drivers/staging/greybus/camera.c

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