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