drivers/staging/greybus/camera.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Greybus Camera protocol driver.
   4  *
   5  * Copyright 2015 Google Inc.
   6  * Copyright 2015 Linaro Ltd.
   7  */
   8
   9 #include <linux/debugfs.h>
  10 #include <linux/fs.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/string.h>
  15 #include <linux/uaccess.h>
  16 #include <linux/vmalloc.h>
  17 #include <linux/greybus.h>
  18
  19 #include "gb-camera.h"
  20 #include "greybus_protocols.h"
  21
  22 enum gb_camera_debugs_buffer_id {
  23         GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
  24         GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
  25         GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
  26         GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
  27         GB_CAMERA_DEBUGFS_BUFFER_MAX,
  28 };
  29
  30 struct gb_camera_debugfs_buffer {
  31         char data[PAGE_SIZE];
  32         size_t length;
  33 };
  34
  35 enum gb_camera_state {
  36         GB_CAMERA_STATE_UNCONFIGURED,
  37         GB_CAMERA_STATE_CONFIGURED,
  38 };
  39
  40 /**
  41  * struct gb_camera - A Greybus Camera Device
  42  * @connection: the greybus connection for camera management
  43  * @data_connection: the greybus connection for camera data
  44  * @data_cport_id: the data CPort ID on the module side
  45  * @mutex: protects the connection and state fields
  46  * @state: the current module state
  47  * @debugfs: debugfs entries for camera protocol operations testing
  48  * @module: Greybus camera module registered to HOST processor.
  49  */
  50 struct gb_camera {
  51         struct gb_bundle *bundle;
  52         struct gb_connection *connection;
  53         struct gb_connection *data_connection;
  54         u16 data_cport_id;
  55
  56         struct mutex mutex;
  57         enum gb_camera_state state;
  58
  59         struct {
  60                 struct dentry *root;
  61                 struct gb_camera_debugfs_buffer *buffers;
  62         } debugfs;
  63
  64         struct gb_camera_module module;
  65 };
  66
  67 struct gb_camera_stream_config {
  68         unsigned int width;
  69         unsigned int height;
  70         unsigned int format;
  71         unsigned int vc;
  72         unsigned int dt[2];
  73         unsigned int max_size;
  74 };
  75
  76 struct gb_camera_fmt_info {
  77         enum v4l2_mbus_pixelcode mbus_code;
  78         unsigned int gb_format;
  79         unsigned int bpp;
  80 };
  81
  82 /* GB format to media code map */
  83 static const struct gb_camera_fmt_info gb_fmt_info[] = {
  84         {
  85                 .mbus_code = V4L2_MBUS_FMT_UYVY8_1X16,
  86                 .gb_format = 0x01,
  87                 .bpp       = 16,
  88         },
  89         {
  90                 .mbus_code = V4L2_MBUS_FMT_NV12_1x8,
  91                 .gb_format = 0x12,
  92                 .bpp       = 12,
  93         },
  94         {
  95                 .mbus_code = V4L2_MBUS_FMT_NV21_1x8,
  96                 .gb_format = 0x13,
  97                 .bpp       = 12,
  98         },
  99         {
 100                 .mbus_code = V4L2_MBUS_FMT_YU12_1x8,
 101                 .gb_format = 0x16,
 102                 .bpp       = 12,
 103         },
 104         {
 105                 .mbus_code = V4L2_MBUS_FMT_YV12_1x8,
 106                 .gb_format = 0x17,
 107                 .bpp       = 12,
 108         },
 109         {
 110                 .mbus_code = V4L2_MBUS_FMT_JPEG_1X8,
 111                 .gb_format = 0x40,
 112                 .bpp       = 0,
 113         },
 114         {
 115                 .mbus_code = V4L2_MBUS_FMT_GB_CAM_METADATA_1X8,
 116                 .gb_format = 0x41,
 117                 .bpp       = 0,
 118         },
 119         {
 120                 .mbus_code = V4L2_MBUS_FMT_GB_CAM_DEBUG_DATA_1X8,
 121                 .gb_format = 0x42,
 122                 .bpp       = 0,
 123         },
 124         {
 125                 .mbus_code = V4L2_MBUS_FMT_SBGGR10_1X10,
 126                 .gb_format = 0x80,
 127                 .bpp       = 10,
 128         },
 129         {
 130                 .mbus_code = V4L2_MBUS_FMT_SGBRG10_1X10,
 131                 .gb_format = 0x81,
 132                 .bpp       = 10,
 133         },
 134         {
 135                 .mbus_code = V4L2_MBUS_FMT_SGRBG10_1X10,
 136                 .gb_format = 0x82,
 137                 .bpp       = 10,
 138         },
 139         {
 140                 .mbus_code = V4L2_MBUS_FMT_SRGGB10_1X10,
 141                 .gb_format = 0x83,
 142                 .bpp       = 10,
 143         },
 144         {
 145                 .mbus_code = V4L2_MBUS_FMT_SBGGR12_1X12,
 146                 .gb_format = 0x84,
 147                 .bpp       = 12,
 148         },
 149         {
 150                 .mbus_code = V4L2_MBUS_FMT_SGBRG12_1X12,
 151                 .gb_format = 0x85,
 152                 .bpp       = 12,
 153         },
 154         {
 155                 .mbus_code = V4L2_MBUS_FMT_SGRBG12_1X12,
 156                 .gb_format = 0x86,
 157                 .bpp       = 12,
 158         },
 159         {
 160                 .mbus_code = V4L2_MBUS_FMT_SRGGB12_1X12,
 161                 .gb_format = 0x87,
 162                 .bpp       = 12,
 163         },
 164 };
 165
 166 static const struct gb_camera_fmt_info *gb_camera_get_format_info(u16 gb_fmt)
 167 {
 168         unsigned int i;
 169
 170         for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
 171                 if (gb_fmt_info[i].gb_format == gb_fmt)
 172                         return &gb_fmt_info[i];
 173         }
 174
 175         return NULL;
 176 }
 177
 178 #define ES2_APB_CDSI0_CPORT             16
 179 #define ES2_APB_CDSI1_CPORT             17
 180
 181 #define GB_CAMERA_MAX_SETTINGS_SIZE     8192
 182
 183 static int gb_camera_operation_sync_flags(struct gb_connection *connection,
 184                                           int type, unsigned int flags,
 185                                           void *request, size_t request_size,
 186                                           void *response, size_t *response_size)
 187 {
 188         struct gb_operation *operation;
 189         int ret;
 190
 191         operation = gb_operation_create_flags(connection, type, request_size,
 192                                               *response_size, flags,
 193                                               GFP_KERNEL);
 194         if (!operation)
 195                 return  -ENOMEM;
 196
 197         if (request_size)
 198                 memcpy(operation->request->payload, request, request_size);
 199
 200         ret = gb_operation_request_send_sync(operation);
 201         if (ret) {
 202                 dev_err(&connection->hd->dev,
 203                         "%s: synchronous operation of type 0x%02x failed: %d\n",
 204                         connection->name, type, ret);
 205         } else {
 206                 *response_size = operation->response->payload_size;
 207
 208                 if (operation->response->payload_size)
 209                         memcpy(response, operation->response->payload,
 210                                operation->response->payload_size);
 211         }
 212
 213         gb_operation_put(operation);
 214
 215         return ret;
 216 }
 217
 218 static int gb_camera_get_max_pkt_size(struct gb_camera *gcam,
 219                                       struct gb_camera_configure_streams_response *resp)
 220 {
 221         unsigned int max_pkt_size = 0;
 222         unsigned int i;
 223
 224         for (i = 0; i < resp->num_streams; i++) {
 225                 struct gb_camera_stream_config_response *cfg = &resp->config[i];
 226                 const struct gb_camera_fmt_info *fmt_info;
 227                 unsigned int pkt_size;
 228
 229                 fmt_info = gb_camera_get_format_info(cfg->format);
 230                 if (!fmt_info) {
 231                         dev_err(&gcam->bundle->dev, "unsupported greybus image format: %d\n",
 232                                 cfg->format);
 233                         return -EIO;
 234                 }
 235
 236                 if (fmt_info->bpp == 0) {
 237                         pkt_size = le32_to_cpu(cfg->max_pkt_size);
 238
 239                         if (pkt_size == 0) {
 240                                 dev_err(&gcam->bundle->dev,
 241                                         "Stream %u: invalid zero maximum packet size\n",
 242                                         i);
 243                                 return -EIO;
 244                         }
 245                 } else {
 246                         pkt_size = le16_to_cpu(cfg->width) * fmt_info->bpp / 8;
 247
 248                         if (pkt_size != le32_to_cpu(cfg->max_pkt_size)) {
 249                                 dev_err(&gcam->bundle->dev,
 250                                         "Stream %u: maximum packet size mismatch (%u/%u)\n",
 251                                         i, pkt_size, cfg->max_pkt_size);
 252                                 return -EIO;
 253                         }
 254                 }
 255
 256                 max_pkt_size = max(pkt_size, max_pkt_size);
 257         }
 258
 259         return max_pkt_size;
 260 }
 261
 262 /*
 263  * Validate the stream configuration response verifying padding is correctly
 264  * set and the returned number of streams is supported
 265  */
 266 static const int gb_camera_configure_streams_validate_response(struct gb_camera *gcam,
 267                 struct gb_camera_configure_streams_response *resp,
 268                 unsigned int nstreams)
 269 {
 270         unsigned int i;
 271
 272         /* Validate the returned response structure */
 273         if (resp->padding[0] || resp->padding[1]) {
 274                 dev_err(&gcam->bundle->dev, "response padding != 0\n");
 275                 return -EIO;
 276         }
 277
 278         if (resp->num_streams > nstreams) {
 279                 dev_err(&gcam->bundle->dev, "got #streams %u > request %u\n",
 280                         resp->num_streams, nstreams);
 281                 return -EIO;
 282         }
 283
 284         for (i = 0; i < resp->num_streams; i++) {
 285                 struct gb_camera_stream_config_response *cfg = &resp->config[i];
 286
 287                 if (cfg->padding) {
 288                         dev_err(&gcam->bundle->dev, "stream #%u padding != 0\n", i);
 289                         return -EIO;
 290                 }
 291         }
 292
 293         return 0;
 294 }
 295
 296 /* -----------------------------------------------------------------------------
 297  * Hardware Configuration
 298  */
 299
 300 static int gb_camera_set_intf_power_mode(struct gb_camera *gcam, u8 intf_id,
 301                                          bool hs)
 302 {
 303         struct gb_svc *svc = gcam->connection->hd->svc;
 304         int ret;
 305
 306         if (hs)
 307                 ret = gb_svc_intf_set_power_mode(svc, intf_id,
 308                                                  GB_SVC_UNIPRO_HS_SERIES_A,
 309                                                  GB_SVC_UNIPRO_FAST_MODE, 2, 2,
 310                                                  GB_SVC_SMALL_AMPLITUDE,
 311                                                  GB_SVC_NO_DE_EMPHASIS,
 312                                                  GB_SVC_UNIPRO_FAST_MODE, 2, 2,
 313                                                  GB_SVC_PWRM_RXTERMINATION |
 314                                                  GB_SVC_PWRM_TXTERMINATION, 0,
 315                                                  NULL, NULL);
 316         else
 317                 ret = gb_svc_intf_set_power_mode(svc, intf_id,
 318                                                  GB_SVC_UNIPRO_HS_SERIES_A,
 319                                                  GB_SVC_UNIPRO_SLOW_AUTO_MODE,
 320                                                  2, 1,
 321                                                  GB_SVC_SMALL_AMPLITUDE,
 322                                                  GB_SVC_NO_DE_EMPHASIS,
 323                                                  GB_SVC_UNIPRO_SLOW_AUTO_MODE,
 324                                                  2, 1,
 325                                                  0, 0,
 326                                                  NULL, NULL);
 327
 328         return ret;
 329 }
 330
 331 static int gb_camera_set_power_mode(struct gb_camera *gcam, bool hs)
 332 {
 333         struct gb_interface *intf = gcam->connection->intf;
 334         struct gb_svc *svc = gcam->connection->hd->svc;
 335         int ret;
 336
 337         ret = gb_camera_set_intf_power_mode(gcam, intf->interface_id, hs);
 338         if (ret < 0) {
 339                 dev_err(&gcam->bundle->dev, "failed to set module interface to %s (%d)\n",
 340                         hs ? "HS" : "PWM", ret);
 341                 return ret;
 342         }
 343
 344         ret = gb_camera_set_intf_power_mode(gcam, svc->ap_intf_id, hs);
 345         if (ret < 0) {
 346                 gb_camera_set_intf_power_mode(gcam, intf->interface_id, !hs);
 347                 dev_err(&gcam->bundle->dev, "failed to set AP interface to %s (%d)\n",
 348                         hs ? "HS" : "PWM", ret);
 349                 return ret;
 350         }
 351
 352         return 0;
 353 }
 354
 355 struct ap_csi_config_request {
 356         __u8 csi_id;
 357         __u8 flags;
 358 #define GB_CAMERA_CSI_FLAG_CLOCK_CONTINUOUS 0x01
 359         __u8 num_lanes;
 360         __u8 padding;
 361         __le32 csi_clk_freq;
 362         __le32 max_pkt_size;
 363 } __packed;
 364
 365 /*
 366  * TODO: Compute the number of lanes dynamically based on bandwidth
 367  * requirements.
 368  */
 369 #define GB_CAMERA_CSI_NUM_DATA_LANES            4
 370
 371 #define GB_CAMERA_CSI_CLK_FREQ_MAX              999000000U
 372 #define GB_CAMERA_CSI_CLK_FREQ_MIN              100000000U
 373 #define GB_CAMERA_CSI_CLK_FREQ_MARGIN           150000000U
 374
 375 static int gb_camera_setup_data_connection(struct gb_camera *gcam,
 376                                            struct gb_camera_configure_streams_response *resp,
 377                                            struct gb_camera_csi_params *csi_params)
 378 {
 379         struct ap_csi_config_request csi_cfg;
 380         struct gb_connection *conn;
 381         unsigned int clk_freq;
 382         int ret;
 383
 384         /*
 385          * Create the data connection between the camera module data CPort and
 386          * APB CDSI1. The CDSI1 CPort ID is hardcoded by the ES2 bridge.
 387          */
 388         conn = gb_connection_create_offloaded(gcam->bundle, gcam->data_cport_id,
 389                                               GB_CONNECTION_FLAG_NO_FLOWCTRL |
 390                                               GB_CONNECTION_FLAG_CDSI1);
 391         if (IS_ERR(conn))
 392                 return PTR_ERR(conn);
 393
 394         gcam->data_connection = conn;
 395         gb_connection_set_data(conn, gcam);
 396
 397         ret = gb_connection_enable(conn);
 398         if (ret)
 399                 goto error_conn_destroy;
 400
 401         /* Set the UniPro link to high speed mode. */
 402         ret = gb_camera_set_power_mode(gcam, true);
 403         if (ret < 0)
 404                 goto error_conn_disable;
 405
 406         /*
 407          * Configure the APB-A CSI-2 transmitter.
 408          *
 409          * Hardcode the number of lanes to 4 and compute the bus clock frequency
 410          * based on the module bandwidth requirements with a safety margin.
 411          */
 412         memset(&csi_cfg, 0, sizeof(csi_cfg));
 413         csi_cfg.csi_id = 1;
 414         csi_cfg.flags = 0;
 415         csi_cfg.num_lanes = GB_CAMERA_CSI_NUM_DATA_LANES;
 416
 417         clk_freq = resp->data_rate / 2 / GB_CAMERA_CSI_NUM_DATA_LANES;
 418         clk_freq = clamp(clk_freq + GB_CAMERA_CSI_CLK_FREQ_MARGIN,
 419                          GB_CAMERA_CSI_CLK_FREQ_MIN,
 420                          GB_CAMERA_CSI_CLK_FREQ_MAX);
 421         csi_cfg.csi_clk_freq = clk_freq;
 422
 423         ret = gb_camera_get_max_pkt_size(gcam, resp);
 424         if (ret < 0) {
 425                 ret = -EIO;
 426                 goto error_power;
 427         }
 428         csi_cfg.max_pkt_size = ret;
 429
 430         ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
 431                            sizeof(csi_cfg),
 432                            GB_APB_REQUEST_CSI_TX_CONTROL, false);
 433         if (ret < 0) {
 434                 dev_err(&gcam->bundle->dev, "failed to start the CSI transmitter\n");
 435                 goto error_power;
 436         }
 437
 438         if (csi_params) {
 439                 csi_params->clk_freq = csi_cfg.csi_clk_freq;
 440                 csi_params->num_lanes = csi_cfg.num_lanes;
 441         }
 442
 443         return 0;
 444
 445 error_power:
 446         gb_camera_set_power_mode(gcam, false);
 447 error_conn_disable:
 448         gb_connection_disable(gcam->data_connection);
 449 error_conn_destroy:
 450         gb_connection_destroy(gcam->data_connection);
 451         gcam->data_connection = NULL;
 452         return ret;
 453 }
 454
 455 static void gb_camera_teardown_data_connection(struct gb_camera *gcam)
 456 {
 457         struct ap_csi_config_request csi_cfg;
 458         int ret;
 459
 460         /* Stop the APB1 CSI transmitter. */
 461         memset(&csi_cfg, 0, sizeof(csi_cfg));
 462         csi_cfg.csi_id = 1;
 463
 464         ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
 465                            sizeof(csi_cfg),
 466                            GB_APB_REQUEST_CSI_TX_CONTROL, false);
 467
 468         if (ret < 0)
 469                 dev_err(&gcam->bundle->dev, "failed to stop the CSI transmitter\n");
 470
 471         /* Set the UniPro link to low speed mode. */
 472         gb_camera_set_power_mode(gcam, false);
 473
 474         /* Destroy the data connection. */
 475         gb_connection_disable(gcam->data_connection);
 476         gb_connection_destroy(gcam->data_connection);
 477         gcam->data_connection = NULL;
 478 }
 479
 480 /* -----------------------------------------------------------------------------
 481  * Camera Protocol Operations
 482  */
 483
 484 static int gb_camera_capabilities(struct gb_camera *gcam,
 485                                   u8 *capabilities, size_t *size)
 486 {
 487         int ret;
 488
 489         ret = gb_pm_runtime_get_sync(gcam->bundle);
 490         if (ret)
 491                 return ret;
 492
 493         mutex_lock(&gcam->mutex);
 494
 495         if (!gcam->connection) {
 496                 ret = -EINVAL;
 497                 goto done;
 498         }
 499
 500         ret = gb_camera_operation_sync_flags(gcam->connection,
 501                                              GB_CAMERA_TYPE_CAPABILITIES,
 502                                              GB_OPERATION_FLAG_SHORT_RESPONSE,
 503                                              NULL, 0,
 504                                              (void *)capabilities, size);
 505         if (ret)
 506                 dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret);
 507
 508 done:
 509         mutex_unlock(&gcam->mutex);
 510
 511         gb_pm_runtime_put_autosuspend(gcam->bundle);
 512
 513         return ret;
 514 }
 515
 516 static int gb_camera_configure_streams(struct gb_camera *gcam,
 517                                        unsigned int *num_streams,
 518                                        unsigned int *flags,
 519                                        struct gb_camera_stream_config *streams,
 520                                        struct gb_camera_csi_params *csi_params)
 521 {
 522         struct gb_camera_configure_streams_request *req;
 523         struct gb_camera_configure_streams_response *resp;
 524         unsigned int nstreams = *num_streams;
 525         unsigned int i;
 526         size_t req_size;
 527         size_t resp_size;
 528         int ret;
 529
 530         if (nstreams > GB_CAMERA_MAX_STREAMS)
 531                 return -EINVAL;
 532
 533         req_size = sizeof(*req) + nstreams * sizeof(req->config[0]);
 534         resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]);
 535
 536         req = kmalloc(req_size, GFP_KERNEL);
 537         resp = kmalloc(resp_size, GFP_KERNEL);
 538         if (!req || !resp) {
 539                 kfree(req);
 540                 kfree(resp);
 541                 return -ENOMEM;
 542         }
 543
 544         req->num_streams = nstreams;
 545         req->flags = *flags;
 546         req->padding = 0;
 547
 548         for (i = 0; i < nstreams; ++i) {
 549                 struct gb_camera_stream_config_request *cfg = &req->config[i];
 550
 551                 cfg->width = cpu_to_le16(streams[i].width);
 552                 cfg->height = cpu_to_le16(streams[i].height);
 553                 cfg->format = cpu_to_le16(streams[i].format);
 554                 cfg->padding = 0;
 555         }
 556
 557         mutex_lock(&gcam->mutex);
 558
 559         ret = gb_pm_runtime_get_sync(gcam->bundle);
 560         if (ret)
 561                 goto done_skip_pm_put;
 562
 563         if (!gcam->connection) {
 564                 ret = -EINVAL;
 565                 goto done;
 566         }
 567
 568         ret = gb_camera_operation_sync_flags(gcam->connection,
 569                                              GB_CAMERA_TYPE_CONFIGURE_STREAMS,
 570                                              GB_OPERATION_FLAG_SHORT_RESPONSE,
 571                                              req, req_size,
 572                                              resp, &resp_size);
 573         if (ret < 0)
 574                 goto done;
 575
 576         ret = gb_camera_configure_streams_validate_response(gcam, resp,
 577                                                             nstreams);
 578         if (ret < 0)
 579                 goto done;
 580
 581         *flags = resp->flags;
 582         *num_streams = resp->num_streams;
 583
 584         for (i = 0; i < resp->num_streams; ++i) {
 585                 struct gb_camera_stream_config_response *cfg = &resp->config[i];
 586
 587                 streams[i].width = le16_to_cpu(cfg->width);
 588                 streams[i].height = le16_to_cpu(cfg->height);
 589                 streams[i].format = le16_to_cpu(cfg->format);
 590                 streams[i].vc = cfg->virtual_channel;
 591                 streams[i].dt[0] = cfg->data_type[0];
 592                 streams[i].dt[1] = cfg->data_type[1];
 593                 streams[i].max_size = le32_to_cpu(cfg->max_size);
 594         }
 595
 596         if ((resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) ||
 597             (req->flags & GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY))
 598                 goto done;
 599
 600         if (gcam->state == GB_CAMERA_STATE_CONFIGURED) {
 601                 gb_camera_teardown_data_connection(gcam);
 602                 gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
 603
 604                 /*
 605                  * When unconfiguring streams release the PM runtime reference
 606                  * that was acquired when streams were configured. The bundle
 607                  * won't be suspended until the PM runtime reference acquired at
 608                  * the beginning of this function gets released right before
 609                  * returning.
 610                  */
 611                 gb_pm_runtime_put_noidle(gcam->bundle);
 612         }
 613
 614         if (resp->num_streams == 0)
 615                 goto done;
 616
 617         /*
 618          * Make sure the bundle won't be suspended until streams get
 619          * unconfigured after the stream is configured successfully
 620          */
 621         gb_pm_runtime_get_noresume(gcam->bundle);
 622
 623         /* Setup CSI-2 connection from APB-A to AP */
 624         ret = gb_camera_setup_data_connection(gcam, resp, csi_params);
 625         if (ret < 0) {
 626                 memset(req, 0, sizeof(*req));
 627                 gb_operation_sync(gcam->connection,
 628                                   GB_CAMERA_TYPE_CONFIGURE_STREAMS,
 629                                   req, sizeof(*req),
 630                                   resp, sizeof(*resp));
 631                 *flags = 0;
 632                 *num_streams = 0;
 633                 gb_pm_runtime_put_noidle(gcam->bundle);
 634                 goto done;
 635         }
 636
 637         gcam->state = GB_CAMERA_STATE_CONFIGURED;
 638
 639 done:
 640         gb_pm_runtime_put_autosuspend(gcam->bundle);
 641
 642 done_skip_pm_put:
 643         mutex_unlock(&gcam->mutex);
 644         kfree(req);
 645         kfree(resp);
 646         return ret;
 647 }
 648
 649 static int gb_camera_capture(struct gb_camera *gcam, u32 request_id,
 650                              unsigned int streams, unsigned int num_frames,
 651                              size_t settings_size, const void *settings)
 652 {
 653         struct gb_camera_capture_request *req;
 654         size_t req_size;
 655         int ret;
 656
 657         if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE)
 658                 return -EINVAL;
 659
 660         req_size = sizeof(*req) + settings_size;
 661         req = kmalloc(req_size, GFP_KERNEL);
 662         if (!req)
 663                 return -ENOMEM;
 664
 665         req->request_id = cpu_to_le32(request_id);
 666         req->streams = streams;
 667         req->padding = 0;
 668         req->num_frames = cpu_to_le16(num_frames);
 669         memcpy(req->settings, settings, settings_size);
 670
 671         mutex_lock(&gcam->mutex);
 672
 673         if (!gcam->connection) {
 674                 ret = -EINVAL;
 675                 goto done;
 676         }
 677
 678         ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
 679                                 req, req_size, NULL, 0);
 680 done:
 681         mutex_unlock(&gcam->mutex);
 682
 683         kfree(req);
 684
 685         return ret;
 686 }
 687
 688 static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
 689 {
 690         struct gb_camera_flush_response resp;
 691         int ret;
 692
 693         mutex_lock(&gcam->mutex);
 694
 695         if (!gcam->connection) {
 696                 ret = -EINVAL;
 697                 goto done;
 698         }
 699
 700         ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
 701                                 &resp, sizeof(resp));
 702
 703         if (ret < 0)
 704                 goto done;
 705
 706         if (request_id)
 707                 *request_id = le32_to_cpu(resp.request_id);
 708
 709 done:
 710         mutex_unlock(&gcam->mutex);
 711
 712         return ret;
 713 }
 714
 715 static int gb_camera_request_handler(struct gb_operation *op)
 716 {
 717         struct gb_camera *gcam = gb_connection_get_data(op->connection);
 718         struct gb_camera_metadata_request *payload;
 719         struct gb_message *request;
 720
 721         if (op->type != GB_CAMERA_TYPE_METADATA) {
 722                 dev_err(&gcam->bundle->dev, "Unsupported unsolicited event: %u\n", op->type);
 723                 return -EINVAL;
 724         }
 725
 726         request = op->request;
 727
 728         if (request->payload_size < sizeof(*payload)) {
 729                 dev_err(&gcam->bundle->dev, "Wrong event size received (%zu < %zu)\n",
 730                         request->payload_size, sizeof(*payload));
 731                 return -EINVAL;
 732         }
 733
 734         payload = request->payload;
 735
 736         dev_dbg(&gcam->bundle->dev, "received metadata for request %u, frame %u, stream %u\n",
 737                 payload->request_id, payload->frame_number, payload->stream);
 738
 739         return 0;
 740 }
 741
 742 /* -----------------------------------------------------------------------------
 743  * Interface with HOST gmp camera.
 744  */
 745 static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code)
 746 {
 747         unsigned int i;
 748
 749         for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
 750                 if (gb_fmt_info[i].mbus_code == mbus_code)
 751                         return gb_fmt_info[i].gb_format;
 752         }
 753         return gb_fmt_info[0].gb_format;
 754 }
 755
 756 static enum v4l2_mbus_pixelcode gb_camera_gb_to_mbus(u16 gb_fmt)
 757 {
 758         unsigned int i;
 759
 760         for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
 761                 if (gb_fmt_info[i].gb_format == gb_fmt)
 762                         return gb_fmt_info[i].mbus_code;
 763         }
 764         return gb_fmt_info[0].mbus_code;
 765 }
 766
 767 static ssize_t gb_camera_op_capabilities(void *priv, char *data, size_t len)
 768 {
 769         struct gb_camera *gcam = priv;
 770         size_t capabilities_len = len;
 771         int ret;
 772
 773         ret = gb_camera_capabilities(gcam, data, &capabilities_len);
 774         if (ret)
 775                 return ret;
 776
 777         return capabilities_len;
 778 }
 779
 780 static int gb_camera_op_configure_streams(void *priv, unsigned int *nstreams,
 781                                           unsigned int *flags, struct gb_camera_stream *streams,
 782                                           struct gb_camera_csi_params *csi_params)
 783 {
 784         struct gb_camera *gcam = priv;
 785         struct gb_camera_stream_config *gb_streams;
 786         unsigned int gb_flags = 0;
 787         unsigned int gb_nstreams = *nstreams;
 788         unsigned int i;
 789         int ret;
 790
 791         if (gb_nstreams > GB_CAMERA_MAX_STREAMS)
 792                 return -EINVAL;
 793
 794         gb_streams = kcalloc(gb_nstreams, sizeof(*gb_streams), GFP_KERNEL);
 795         if (!gb_streams)
 796                 return -ENOMEM;
 797
 798         for (i = 0; i < gb_nstreams; i++) {
 799                 gb_streams[i].width = streams[i].width;
 800                 gb_streams[i].height = streams[i].height;
 801                 gb_streams[i].format =
 802                         gb_camera_mbus_to_gb(streams[i].pixel_code);
 803         }
 804
 805         if (*flags & GB_CAMERA_IN_FLAG_TEST)
 806                 gb_flags |= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY;
 807
 808         ret = gb_camera_configure_streams(gcam, &gb_nstreams,
 809                                           &gb_flags, gb_streams, csi_params);
 810         if (ret < 0)
 811                 goto done;
 812         if (gb_nstreams > *nstreams) {
 813                 ret = -EINVAL;
 814                 goto done;
 815         }
 816
 817         *flags = 0;
 818         if (gb_flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED)
 819                 *flags |= GB_CAMERA_OUT_FLAG_ADJUSTED;
 820
 821         for (i = 0; i < gb_nstreams; i++) {
 822                 streams[i].width = gb_streams[i].width;
 823                 streams[i].height = gb_streams[i].height;
 824                 streams[i].vc = gb_streams[i].vc;
 825                 streams[i].dt[0] = gb_streams[i].dt[0];
 826                 streams[i].dt[1] = gb_streams[i].dt[1];
 827                 streams[i].max_size = gb_streams[i].max_size;
 828                 streams[i].pixel_code =
 829                         gb_camera_gb_to_mbus(gb_streams[i].format);
 830         }
 831         *nstreams = gb_nstreams;
 832
 833 done:
 834         kfree(gb_streams);
 835         return ret;
 836 }
 837
 838 static int gb_camera_op_capture(void *priv, u32 request_id,
 839                                 unsigned int streams, unsigned int num_frames,
 840                                 size_t settings_size, const void *settings)
 841 {
 842         struct gb_camera *gcam = priv;
 843
 844         return gb_camera_capture(gcam, request_id, streams, num_frames,
 845                                  settings_size, settings);
 846 }
 847
 848 static int gb_camera_op_flush(void *priv, u32 *request_id)
 849 {
 850         struct gb_camera *gcam = priv;
 851
 852         return gb_camera_flush(gcam, request_id);
 853 }
 854
 855 static const struct gb_camera_ops gb_cam_ops = {
 856         .capabilities = gb_camera_op_capabilities,
 857         .configure_streams = gb_camera_op_configure_streams,
 858         .capture = gb_camera_op_capture,
 859         .flush = gb_camera_op_flush,
 860 };
 861
 862 /* -----------------------------------------------------------------------------
 863  * DebugFS
 864  */
 865
 866 static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam,
 867                                               char *buf, size_t len)
 868 {
 869         struct gb_camera_debugfs_buffer *buffer =
 870                 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES];
 871         size_t size = 1024;
 872         unsigned int i;
 873         u8 *caps;
 874         int ret;
 875
 876         caps = kmalloc(size, GFP_KERNEL);
 877         if (!caps)
 878                 return -ENOMEM;
 879
 880         ret = gb_camera_capabilities(gcam, caps, &size);
 881         if (ret < 0)
 882                 goto done;
 883
 884         /*
 885          * hex_dump_to_buffer() doesn't return the number of bytes dumped prior
 886          * to v4.0, we need our own implementation :-(
 887          */
 888         buffer->length = 0;
 889
 890         for (i = 0; i < size; i += 16) {
 891                 unsigned int nbytes = min_t(unsigned int, size - i, 16);
 892
 893                 buffer->length += sprintf(buffer->data + buffer->length,
 894                                           "%*ph\n", nbytes, caps + i);
 895         }
 896
 897 done:
 898         kfree(caps);
 899         return ret;
 900 }
 901
 902 static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam,
 903                                                    char *buf, size_t len)
 904 {
 905         struct gb_camera_debugfs_buffer *buffer =
 906                 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_STREAMS];
 907         struct gb_camera_stream_config *streams;
 908         unsigned int nstreams;
 909         unsigned int flags;
 910         unsigned int i;
 911         char *token;
 912         int ret;
 913
 914         /* Retrieve number of streams to configure */
 915         token = strsep(&buf, ";");
 916         if (!token)
 917                 return -EINVAL;
 918
 919         ret = kstrtouint(token, 10, &nstreams);
 920         if (ret < 0)
 921                 return ret;
 922
 923         if (nstreams > GB_CAMERA_MAX_STREAMS)
 924                 return -EINVAL;
 925
 926         token = strsep(&buf, ";");
 927         if (!token)
 928                 return -EINVAL;
 929
 930         ret = kstrtouint(token, 10, &flags);
 931         if (ret < 0)
 932                 return ret;
 933
 934         /* For each stream to configure parse width, height and format */
 935         streams = kcalloc(nstreams, sizeof(*streams), GFP_KERNEL);
 936         if (!streams)
 937                 return -ENOMEM;
 938
 939         for (i = 0; i < nstreams; ++i) {
 940                 struct gb_camera_stream_config *stream = &streams[i];
 941
 942                 /* width */
 943                 token = strsep(&buf, ";");
 944                 if (!token) {
 945                         ret = -EINVAL;
 946                         goto done;
 947                 }
 948                 ret = kstrtouint(token, 10, &stream->width);
 949                 if (ret < 0)
 950                         goto done;
 951
 952                 /* height */
 953                 token = strsep(&buf, ";");
 954                 if (!token)
 955                         goto done;
 956
 957                 ret = kstrtouint(token, 10, &stream->height);
 958                 if (ret < 0)
 959                         goto done;
 960
 961                 /* Image format code */
 962                 token = strsep(&buf, ";");
 963                 if (!token)
 964                         goto done;
 965
 966                 ret = kstrtouint(token, 16, &stream->format);
 967                 if (ret < 0)
 968                         goto done;
 969         }
 970
 971         ret = gb_camera_configure_streams(gcam, &nstreams, &flags, streams,
 972                                           NULL);
 973         if (ret < 0)
 974                 goto done;
 975
 976         buffer->length = sprintf(buffer->data, "%u;%u;", nstreams, flags);
 977
 978         for (i = 0; i < nstreams; ++i) {
 979                 struct gb_camera_stream_config *stream = &streams[i];
 980
 981                 buffer->length += sprintf(buffer->data + buffer->length,
 982                                           "%u;%u;%u;%u;%u;%u;%u;",
 983                                           stream->width, stream->height,
 984                                           stream->format, stream->vc,
 985                                           stream->dt[0], stream->dt[1],
 986                                           stream->max_size);
 987         }
 988
 989         ret = len;
 990
 991 done:
 992         kfree(streams);
 993         return ret;
 994 };
 995
 996 static ssize_t gb_camera_debugfs_capture(struct gb_camera *gcam,
 997                                          char *buf, size_t len)
 998 {
 999         unsigned int request_id;
1000         unsigned int streams_mask;
1001         unsigned int num_frames;
1002         char *token;
1003         int ret;
1004
1005         /* Request id */
1006         token = strsep(&buf, ";");
1007         if (!token)
1008                 return -EINVAL;
1009         ret = kstrtouint(token, 10, &request_id);
1010         if (ret < 0)
1011                 return ret;
1012
1013         /* Stream mask */
1014         token = strsep(&buf, ";");
1015         if (!token)
1016                 return -EINVAL;
1017         ret = kstrtouint(token, 16, &streams_mask);
1018         if (ret < 0)
1019                 return ret;
1020
1021         /* number of frames */
1022         token = strsep(&buf, ";");
1023         if (!token)
1024                 return -EINVAL;
1025         ret = kstrtouint(token, 10, &num_frames);
1026         if (ret < 0)
1027                 return ret;
1028
1029         ret = gb_camera_capture(gcam, request_id, streams_mask, num_frames, 0,
1030                                 NULL);
1031         if (ret < 0)
1032                 return ret;
1033
1034         return len;
1035 }
1036
1037 static ssize_t gb_camera_debugfs_flush(struct gb_camera *gcam,
1038                                        char *buf, size_t len)
1039 {
1040         struct gb_camera_debugfs_buffer *buffer =
1041                 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_FLUSH];
1042         unsigned int req_id;
1043         int ret;
1044
1045         ret = gb_camera_flush(gcam, &req_id);
1046         if (ret < 0)
1047                 return ret;
1048
1049         buffer->length = sprintf(buffer->data, "%u", req_id);
1050
1051         return len;
1052 }
1053
1054 struct gb_camera_debugfs_entry {
1055         const char *name;
1056         unsigned int mask;
1057         unsigned int buffer;
1058         ssize_t (*execute)(struct gb_camera *gcam, char *buf, size_t len);
1059 };
1060
1061 static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries[] = {
1062         {
1063                 .name = "capabilities",
1064                 .mask = S_IFREG | 0444,
1065                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
1066                 .execute = gb_camera_debugfs_capabilities,
1067         }, {
1068                 .name = "configure_streams",
1069                 .mask = S_IFREG | 0666,
1070                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
1071                 .execute = gb_camera_debugfs_configure_streams,
1072         }, {
1073                 .name = "capture",
1074                 .mask = S_IFREG | 0666,
1075                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
1076                 .execute = gb_camera_debugfs_capture,
1077         }, {
1078                 .name = "flush",
1079                 .mask = S_IFREG | 0666,
1080                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
1081                 .execute = gb_camera_debugfs_flush,
1082         },
1083 };
1084
1085 static ssize_t gb_camera_debugfs_read(struct file *file, char __user *buf,
1086                                       size_t len, loff_t *offset)
1087 {
1088         const struct gb_camera_debugfs_entry *op = file->private_data;
1089         struct gb_camera *gcam = file_inode(file)->i_private;
1090         struct gb_camera_debugfs_buffer *buffer;
1091         ssize_t ret;
1092
1093         /* For read-only entries the operation is triggered by a read. */
1094         if (!(op->mask & 0222)) {
1095                 ret = op->execute(gcam, NULL, 0);
1096                 if (ret < 0)
1097                         return ret;
1098         }
1099
1100         buffer = &gcam->debugfs.buffers[op->buffer];
1101
1102         return simple_read_from_buffer(buf, len, offset, buffer->data,
1103                                        buffer->length);
1104 }
1105
1106 static ssize_t gb_camera_debugfs_write(struct file *file,
1107                                        const char __user *buf, size_t len,
1108                                        loff_t *offset)
1109 {
1110         const struct gb_camera_debugfs_entry *op = file->private_data;
1111         struct gb_camera *gcam = file_inode(file)->i_private;
1112         ssize_t ret;
1113         char *kbuf;
1114
1115         if (len > 1024)
1116                 return -EINVAL;
1117
1118         kbuf = memdup_user_nul(buf, len);
1119         if (IS_ERR(kbuf))
1120                 return PTR_ERR(kbuf);
1121
1122         ret = op->execute(gcam, kbuf, len);
1123
1124 done:
1125         kfree(kbuf);
1126         return ret;
1127 }
1128
1129 static int gb_camera_debugfs_open(struct inode *inode, struct file *file)
1130 {
1131         unsigned int i;
1132
1133         for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
1134                 const struct gb_camera_debugfs_entry *entry =
1135                         &gb_camera_debugfs_entries[i];
1136
1137                 if (!strcmp(file->f_path.dentry->d_iname, entry->name)) {
1138                         file->private_data = (void *)entry;
1139                         break;
1140                 }
1141         }
1142
1143         return 0;
1144 }
1145
1146 static const struct file_operations gb_camera_debugfs_ops = {
1147         .open = gb_camera_debugfs_open,
1148         .read = gb_camera_debugfs_read,
1149         .write = gb_camera_debugfs_write,
1150 };
1151
1152 static int gb_camera_debugfs_init(struct gb_camera *gcam)
1153 {
1154         struct gb_connection *connection = gcam->connection;
1155         char dirname[27];
1156         unsigned int i;
1157
1158         /*
1159          * Create root debugfs entry and a file entry for each camera operation.
1160          */
1161         snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id,
1162                  gcam->bundle->id);
1163
1164         gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get());
1165
1166         gcam->debugfs.buffers =
1167                 vmalloc(array_size(GB_CAMERA_DEBUGFS_BUFFER_MAX,
1168                                    sizeof(*gcam->debugfs.buffers)));
1169         if (!gcam->debugfs.buffers)
1170                 return -ENOMEM;
1171
1172         for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
1173                 const struct gb_camera_debugfs_entry *entry =
1174                         &gb_camera_debugfs_entries[i];
1175
1176                 gcam->debugfs.buffers[i].length = 0;
1177
1178                 debugfs_create_file(entry->name, entry->mask,
1179                                     gcam->debugfs.root, gcam,
1180                                     &gb_camera_debugfs_ops);
1181         }
1182
1183         return 0;
1184 }
1185
1186 static void gb_camera_debugfs_cleanup(struct gb_camera *gcam)
1187 {
1188         debugfs_remove_recursive(gcam->debugfs.root);
1189
1190         vfree(gcam->debugfs.buffers);
1191 }
1192
1193 /* -----------------------------------------------------------------------------
1194  * Init & Cleanup
1195  */
1196
1197 static void gb_camera_cleanup(struct gb_camera *gcam)
1198 {
1199         gb_camera_debugfs_cleanup(gcam);
1200
1201         mutex_lock(&gcam->mutex);
1202         if (gcam->data_connection) {
1203                 gb_connection_disable(gcam->data_connection);
1204                 gb_connection_destroy(gcam->data_connection);
1205                 gcam->data_connection = NULL;
1206         }
1207
1208         if (gcam->connection) {
1209                 gb_connection_disable(gcam->connection);
1210                 gb_connection_destroy(gcam->connection);
1211                 gcam->connection = NULL;
1212         }
1213         mutex_unlock(&gcam->mutex);
1214 }
1215
1216 static void gb_camera_release_module(struct kref *ref)
1217 {
1218         struct gb_camera_module *cam_mod =
1219                 container_of(ref, struct gb_camera_module, refcount);
1220         kfree(cam_mod->priv);
1221 }
1222
1223 static int gb_camera_probe(struct gb_bundle *bundle,
1224                            const struct greybus_bundle_id *id)
1225 {
1226         struct gb_connection *conn;
1227         struct gb_camera *gcam;
1228         u16 mgmt_cport_id = 0;
1229         u16 data_cport_id = 0;
1230         unsigned int i;
1231         int ret;
1232
1233         /*
1234          * The camera bundle must contain exactly two CPorts, one for the
1235          * camera management protocol and one for the camera data protocol.
1236          */
1237         if (bundle->num_cports != 2)
1238                 return -ENODEV;
1239
1240         for (i = 0; i < bundle->num_cports; ++i) {
1241                 struct greybus_descriptor_cport *desc = &bundle->cport_desc[i];
1242
1243                 switch (desc->protocol_id) {
1244                 case GREYBUS_PROTOCOL_CAMERA_MGMT:
1245                         mgmt_cport_id = le16_to_cpu(desc->id);
1246                         break;
1247                 case GREYBUS_PROTOCOL_CAMERA_DATA:
1248                         data_cport_id = le16_to_cpu(desc->id);
1249                         break;
1250                 default:
1251                         return -ENODEV;
1252                 }
1253         }
1254
1255         if (!mgmt_cport_id || !data_cport_id)
1256                 return -ENODEV;
1257
1258         gcam = kzalloc(sizeof(*gcam), GFP_KERNEL);
1259         if (!gcam)
1260                 return -ENOMEM;
1261
1262         mutex_init(&gcam->mutex);
1263
1264         gcam->bundle = bundle;
1265         gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
1266         gcam->data_cport_id = data_cport_id;
1267
1268         conn = gb_connection_create(bundle, mgmt_cport_id,
1269                                     gb_camera_request_handler);
1270         if (IS_ERR(conn)) {
1271                 ret = PTR_ERR(conn);
1272                 goto error;
1273         }
1274
1275         gcam->connection = conn;
1276         gb_connection_set_data(conn, gcam);
1277
1278         ret = gb_connection_enable(conn);
1279         if (ret)
1280                 goto error;
1281
1282         ret = gb_camera_debugfs_init(gcam);
1283         if (ret < 0)
1284                 goto error;
1285
1286         gcam->module.priv = gcam;
1287         gcam->module.ops = &gb_cam_ops;
1288         gcam->module.interface_id = gcam->connection->intf->interface_id;
1289         gcam->module.release = gb_camera_release_module;
1290         ret = gb_camera_register(&gcam->module);
1291         if (ret < 0)
1292                 goto error;
1293
1294         greybus_set_drvdata(bundle, gcam);
1295
1296         gb_pm_runtime_put_autosuspend(gcam->bundle);
1297
1298         return 0;
1299
1300 error:
1301         gb_camera_cleanup(gcam);
1302         kfree(gcam);
1303         return ret;
1304 }
1305
1306 static void gb_camera_disconnect(struct gb_bundle *bundle)
1307 {
1308         struct gb_camera *gcam = greybus_get_drvdata(bundle);
1309         int ret;
1310
1311         ret = gb_pm_runtime_get_sync(bundle);
1312         if (ret)
1313                 gb_pm_runtime_get_noresume(bundle);
1314
1315         gb_camera_cleanup(gcam);
1316         gb_camera_unregister(&gcam->module);
1317 }
1318
1319 static const struct greybus_bundle_id gb_camera_id_table[] = {
1320         { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_CAMERA) },
1321         { },
1322 };
1323
1324 #ifdef CONFIG_PM
1325 static int gb_camera_suspend(struct device *dev)
1326 {
1327         struct gb_bundle *bundle = to_gb_bundle(dev);
1328         struct gb_camera *gcam = greybus_get_drvdata(bundle);
1329
1330         if (gcam->data_connection)
1331                 gb_connection_disable(gcam->data_connection);
1332
1333         gb_connection_disable(gcam->connection);
1334
1335         return 0;
1336 }
1337
1338 static int gb_camera_resume(struct device *dev)
1339 {
1340         struct gb_bundle *bundle = to_gb_bundle(dev);
1341         struct gb_camera *gcam = greybus_get_drvdata(bundle);
1342         int ret;
1343
1344         ret = gb_connection_enable(gcam->connection);
1345         if (ret) {
1346                 dev_err(&gcam->bundle->dev, "failed to enable connection: %d\n", ret);
1347                 return ret;
1348         }
1349
1350         if (gcam->data_connection) {
1351                 ret = gb_connection_enable(gcam->data_connection);
1352                 if (ret) {
1353                         dev_err(&gcam->bundle->dev,
1354                                 "failed to enable data connection: %d\n", ret);
1355                         return ret;
1356                 }
1357         }
1358
1359         return 0;
1360 }
1361 #endif
1362
1363 static const struct dev_pm_ops gb_camera_pm_ops = {
1364         SET_RUNTIME_PM_OPS(gb_camera_suspend, gb_camera_resume, NULL)
1365 };
1366
1367 static struct greybus_driver gb_camera_driver = {
1368         .name           = "camera",
1369         .probe          = gb_camera_probe,
1370         .disconnect     = gb_camera_disconnect,
1371         .id_table       = gb_camera_id_table,
1372         .driver.pm      = &gb_camera_pm_ops,
1373 };
1374
1375 module_greybus_driver(gb_camera_driver);
1376
1377 MODULE_DESCRIPTION("Greybus Camera protocol driver.");
1378 MODULE_LICENSE("GPL v2");