Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Greybus Camera protocol driver.
0004  *
0005  * Copyright 2015 Google Inc.
0006  * Copyright 2015 Linaro Ltd.
0007  */
0008 
0009 #include <linux/debugfs.h>
0010 #include <linux/fs.h>
0011 #include <linux/kernel.h>
0012 #include <linux/module.h>
0013 #include <linux/slab.h>
0014 #include <linux/string.h>
0015 #include <linux/uaccess.h>
0016 #include <linux/vmalloc.h>
0017 #include <linux/greybus.h>
0018 
0019 #include "gb-camera.h"
0020 #include "greybus_protocols.h"
0021 
0022 enum gb_camera_debugs_buffer_id {
0023     GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
0024     GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
0025     GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
0026     GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
0027     GB_CAMERA_DEBUGFS_BUFFER_MAX,
0028 };
0029 
0030 struct gb_camera_debugfs_buffer {
0031     char data[PAGE_SIZE];
0032     size_t length;
0033 };
0034 
0035 enum gb_camera_state {
0036     GB_CAMERA_STATE_UNCONFIGURED,
0037     GB_CAMERA_STATE_CONFIGURED,
0038 };
0039 
0040 /**
0041  * struct gb_camera - A Greybus Camera Device
0042  * @connection: the greybus connection for camera management
0043  * @data_connection: the greybus connection for camera data
0044  * @data_cport_id: the data CPort ID on the module side
0045  * @mutex: protects the connection and state fields
0046  * @state: the current module state
0047  * @debugfs: debugfs entries for camera protocol operations testing
0048  * @module: Greybus camera module registered to HOST processor.
0049  */
0050 struct gb_camera {
0051     struct gb_bundle *bundle;
0052     struct gb_connection *connection;
0053     struct gb_connection *data_connection;
0054     u16 data_cport_id;
0055 
0056     struct mutex mutex;
0057     enum gb_camera_state state;
0058 
0059     struct {
0060         struct dentry *root;
0061         struct gb_camera_debugfs_buffer *buffers;
0062     } debugfs;
0063 
0064     struct gb_camera_module module;
0065 };
0066 
0067 struct gb_camera_stream_config {
0068     unsigned int width;
0069     unsigned int height;
0070     unsigned int format;
0071     unsigned int vc;
0072     unsigned int dt[2];
0073     unsigned int max_size;
0074 };
0075 
0076 struct gb_camera_fmt_info {
0077     enum v4l2_mbus_pixelcode mbus_code;
0078     unsigned int gb_format;
0079     unsigned int bpp;
0080 };
0081 
0082 /* GB format to media code map */
0083 static const struct gb_camera_fmt_info gb_fmt_info[] = {
0084     {
0085         .mbus_code = V4L2_MBUS_FMT_UYVY8_1X16,
0086         .gb_format = 0x01,
0087         .bpp       = 16,
0088     },
0089     {
0090         .mbus_code = V4L2_MBUS_FMT_NV12_1x8,
0091         .gb_format = 0x12,
0092         .bpp       = 12,
0093     },
0094     {
0095         .mbus_code = V4L2_MBUS_FMT_NV21_1x8,
0096         .gb_format = 0x13,
0097         .bpp       = 12,
0098     },
0099     {
0100         .mbus_code = V4L2_MBUS_FMT_YU12_1x8,
0101         .gb_format = 0x16,
0102         .bpp       = 12,
0103     },
0104     {
0105         .mbus_code = V4L2_MBUS_FMT_YV12_1x8,
0106         .gb_format = 0x17,
0107         .bpp       = 12,
0108     },
0109     {
0110         .mbus_code = V4L2_MBUS_FMT_JPEG_1X8,
0111         .gb_format = 0x40,
0112         .bpp       = 0,
0113     },
0114     {
0115         .mbus_code = V4L2_MBUS_FMT_GB_CAM_METADATA_1X8,
0116         .gb_format = 0x41,
0117         .bpp       = 0,
0118     },
0119     {
0120         .mbus_code = V4L2_MBUS_FMT_GB_CAM_DEBUG_DATA_1X8,
0121         .gb_format = 0x42,
0122         .bpp       = 0,
0123     },
0124     {
0125         .mbus_code = V4L2_MBUS_FMT_SBGGR10_1X10,
0126         .gb_format = 0x80,
0127         .bpp       = 10,
0128     },
0129     {
0130         .mbus_code = V4L2_MBUS_FMT_SGBRG10_1X10,
0131         .gb_format = 0x81,
0132         .bpp       = 10,
0133     },
0134     {
0135         .mbus_code = V4L2_MBUS_FMT_SGRBG10_1X10,
0136         .gb_format = 0x82,
0137         .bpp       = 10,
0138     },
0139     {
0140         .mbus_code = V4L2_MBUS_FMT_SRGGB10_1X10,
0141         .gb_format = 0x83,
0142         .bpp       = 10,
0143     },
0144     {
0145         .mbus_code = V4L2_MBUS_FMT_SBGGR12_1X12,
0146         .gb_format = 0x84,
0147         .bpp       = 12,
0148     },
0149     {
0150         .mbus_code = V4L2_MBUS_FMT_SGBRG12_1X12,
0151         .gb_format = 0x85,
0152         .bpp       = 12,
0153     },
0154     {
0155         .mbus_code = V4L2_MBUS_FMT_SGRBG12_1X12,
0156         .gb_format = 0x86,
0157         .bpp       = 12,
0158     },
0159     {
0160         .mbus_code = V4L2_MBUS_FMT_SRGGB12_1X12,
0161         .gb_format = 0x87,
0162         .bpp       = 12,
0163     },
0164 };
0165 
0166 static const struct gb_camera_fmt_info *gb_camera_get_format_info(u16 gb_fmt)
0167 {
0168     unsigned int i;
0169 
0170     for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
0171         if (gb_fmt_info[i].gb_format == gb_fmt)
0172             return &gb_fmt_info[i];
0173     }
0174 
0175     return NULL;
0176 }
0177 
0178 #define ES2_APB_CDSI0_CPORT     16
0179 #define ES2_APB_CDSI1_CPORT     17
0180 
0181 #define GB_CAMERA_MAX_SETTINGS_SIZE 8192
0182 
0183 #define gcam_dbg(gcam, format...)   dev_dbg(&gcam->bundle->dev, format)
0184 #define gcam_info(gcam, format...)  dev_info(&gcam->bundle->dev, format)
0185 #define gcam_err(gcam, format...)   dev_err(&gcam->bundle->dev, format)
0186 
0187 static int gb_camera_operation_sync_flags(struct gb_connection *connection,
0188                       int type, unsigned int flags,
0189                       void *request, size_t request_size,
0190                       void *response, size_t *response_size)
0191 {
0192     struct gb_operation *operation;
0193     int ret;
0194 
0195     operation = gb_operation_create_flags(connection, type, request_size,
0196                           *response_size, flags,
0197                           GFP_KERNEL);
0198     if (!operation)
0199         return  -ENOMEM;
0200 
0201     if (request_size)
0202         memcpy(operation->request->payload, request, request_size);
0203 
0204     ret = gb_operation_request_send_sync(operation);
0205     if (ret) {
0206         dev_err(&connection->hd->dev,
0207             "%s: synchronous operation of type 0x%02x failed: %d\n",
0208             connection->name, type, ret);
0209     } else {
0210         *response_size = operation->response->payload_size;
0211 
0212         if (operation->response->payload_size)
0213             memcpy(response, operation->response->payload,
0214                    operation->response->payload_size);
0215     }
0216 
0217     gb_operation_put(operation);
0218 
0219     return ret;
0220 }
0221 
0222 static int gb_camera_get_max_pkt_size(struct gb_camera *gcam,
0223         struct gb_camera_configure_streams_response *resp)
0224 {
0225     unsigned int max_pkt_size = 0;
0226     unsigned int i;
0227 
0228     for (i = 0; i < resp->num_streams; i++) {
0229         struct gb_camera_stream_config_response *cfg = &resp->config[i];
0230         const struct gb_camera_fmt_info *fmt_info;
0231         unsigned int pkt_size;
0232 
0233         fmt_info = gb_camera_get_format_info(cfg->format);
0234         if (!fmt_info) {
0235             gcam_err(gcam, "unsupported greybus image format: %d\n",
0236                  cfg->format);
0237             return -EIO;
0238         }
0239 
0240         if (fmt_info->bpp == 0) {
0241             pkt_size = le32_to_cpu(cfg->max_pkt_size);
0242 
0243             if (pkt_size == 0) {
0244                 gcam_err(gcam,
0245                      "Stream %u: invalid zero maximum packet size\n",
0246                      i);
0247                 return -EIO;
0248             }
0249         } else {
0250             pkt_size = le16_to_cpu(cfg->width) * fmt_info->bpp / 8;
0251 
0252             if (pkt_size != le32_to_cpu(cfg->max_pkt_size)) {
0253                 gcam_err(gcam,
0254                      "Stream %u: maximum packet size mismatch (%u/%u)\n",
0255                      i, pkt_size, cfg->max_pkt_size);
0256                 return -EIO;
0257             }
0258         }
0259 
0260         max_pkt_size = max(pkt_size, max_pkt_size);
0261     }
0262 
0263     return max_pkt_size;
0264 }
0265 
0266 /*
0267  * Validate the stream configuration response verifying padding is correctly
0268  * set and the returned number of streams is supported
0269  */
0270 static const int gb_camera_configure_streams_validate_response(
0271         struct gb_camera *gcam,
0272         struct gb_camera_configure_streams_response *resp,
0273         unsigned int nstreams)
0274 {
0275     unsigned int i;
0276 
0277     /* Validate the returned response structure */
0278     if (resp->padding[0] || resp->padding[1]) {
0279         gcam_err(gcam, "response padding != 0\n");
0280         return -EIO;
0281     }
0282 
0283     if (resp->num_streams > nstreams) {
0284         gcam_err(gcam, "got #streams %u > request %u\n",
0285              resp->num_streams, nstreams);
0286         return -EIO;
0287     }
0288 
0289     for (i = 0; i < resp->num_streams; i++) {
0290         struct gb_camera_stream_config_response *cfg = &resp->config[i];
0291 
0292         if (cfg->padding) {
0293             gcam_err(gcam, "stream #%u padding != 0\n", i);
0294             return -EIO;
0295         }
0296     }
0297 
0298     return 0;
0299 }
0300 
0301 /* -----------------------------------------------------------------------------
0302  * Hardware Configuration
0303  */
0304 
0305 static int gb_camera_set_intf_power_mode(struct gb_camera *gcam, u8 intf_id,
0306                      bool hs)
0307 {
0308     struct gb_svc *svc = gcam->connection->hd->svc;
0309     int ret;
0310 
0311     if (hs)
0312         ret = gb_svc_intf_set_power_mode(svc, intf_id,
0313                          GB_SVC_UNIPRO_HS_SERIES_A,
0314                          GB_SVC_UNIPRO_FAST_MODE, 2, 2,
0315                          GB_SVC_SMALL_AMPLITUDE,
0316                          GB_SVC_NO_DE_EMPHASIS,
0317                          GB_SVC_UNIPRO_FAST_MODE, 2, 2,
0318                          GB_SVC_PWRM_RXTERMINATION |
0319                          GB_SVC_PWRM_TXTERMINATION, 0,
0320                          NULL, NULL);
0321     else
0322         ret = gb_svc_intf_set_power_mode(svc, intf_id,
0323                          GB_SVC_UNIPRO_HS_SERIES_A,
0324                          GB_SVC_UNIPRO_SLOW_AUTO_MODE,
0325                          2, 1,
0326                          GB_SVC_SMALL_AMPLITUDE,
0327                          GB_SVC_NO_DE_EMPHASIS,
0328                          GB_SVC_UNIPRO_SLOW_AUTO_MODE,
0329                          2, 1,
0330                          0, 0,
0331                          NULL, NULL);
0332 
0333     return ret;
0334 }
0335 
0336 static int gb_camera_set_power_mode(struct gb_camera *gcam, bool hs)
0337 {
0338     struct gb_interface *intf = gcam->connection->intf;
0339     struct gb_svc *svc = gcam->connection->hd->svc;
0340     int ret;
0341 
0342     ret = gb_camera_set_intf_power_mode(gcam, intf->interface_id, hs);
0343     if (ret < 0) {
0344         gcam_err(gcam, "failed to set module interface to %s (%d)\n",
0345              hs ? "HS" : "PWM", ret);
0346         return ret;
0347     }
0348 
0349     ret = gb_camera_set_intf_power_mode(gcam, svc->ap_intf_id, hs);
0350     if (ret < 0) {
0351         gb_camera_set_intf_power_mode(gcam, intf->interface_id, !hs);
0352         gcam_err(gcam, "failed to set AP interface to %s (%d)\n",
0353              hs ? "HS" : "PWM", ret);
0354         return ret;
0355     }
0356 
0357     return 0;
0358 }
0359 
0360 struct ap_csi_config_request {
0361     __u8 csi_id;
0362     __u8 flags;
0363 #define GB_CAMERA_CSI_FLAG_CLOCK_CONTINUOUS 0x01
0364     __u8 num_lanes;
0365     __u8 padding;
0366     __le32 csi_clk_freq;
0367     __le32 max_pkt_size;
0368 } __packed;
0369 
0370 /*
0371  * TODO: Compute the number of lanes dynamically based on bandwidth
0372  * requirements.
0373  */
0374 #define GB_CAMERA_CSI_NUM_DATA_LANES        4
0375 
0376 #define GB_CAMERA_CSI_CLK_FREQ_MAX      999000000U
0377 #define GB_CAMERA_CSI_CLK_FREQ_MIN      100000000U
0378 #define GB_CAMERA_CSI_CLK_FREQ_MARGIN       150000000U
0379 
0380 static int gb_camera_setup_data_connection(struct gb_camera *gcam,
0381         struct gb_camera_configure_streams_response *resp,
0382         struct gb_camera_csi_params *csi_params)
0383 {
0384     struct ap_csi_config_request csi_cfg;
0385     struct gb_connection *conn;
0386     unsigned int clk_freq;
0387     int ret;
0388 
0389     /*
0390      * Create the data connection between the camera module data CPort and
0391      * APB CDSI1. The CDSI1 CPort ID is hardcoded by the ES2 bridge.
0392      */
0393     conn = gb_connection_create_offloaded(gcam->bundle, gcam->data_cport_id,
0394                           GB_CONNECTION_FLAG_NO_FLOWCTRL |
0395                           GB_CONNECTION_FLAG_CDSI1);
0396     if (IS_ERR(conn))
0397         return PTR_ERR(conn);
0398 
0399     gcam->data_connection = conn;
0400     gb_connection_set_data(conn, gcam);
0401 
0402     ret = gb_connection_enable(conn);
0403     if (ret)
0404         goto error_conn_destroy;
0405 
0406     /* Set the UniPro link to high speed mode. */
0407     ret = gb_camera_set_power_mode(gcam, true);
0408     if (ret < 0)
0409         goto error_conn_disable;
0410 
0411     /*
0412      * Configure the APB-A CSI-2 transmitter.
0413      *
0414      * Hardcode the number of lanes to 4 and compute the bus clock frequency
0415      * based on the module bandwidth requirements with a safety margin.
0416      */
0417     memset(&csi_cfg, 0, sizeof(csi_cfg));
0418     csi_cfg.csi_id = 1;
0419     csi_cfg.flags = 0;
0420     csi_cfg.num_lanes = GB_CAMERA_CSI_NUM_DATA_LANES;
0421 
0422     clk_freq = resp->data_rate / 2 / GB_CAMERA_CSI_NUM_DATA_LANES;
0423     clk_freq = clamp(clk_freq + GB_CAMERA_CSI_CLK_FREQ_MARGIN,
0424              GB_CAMERA_CSI_CLK_FREQ_MIN,
0425              GB_CAMERA_CSI_CLK_FREQ_MAX);
0426     csi_cfg.csi_clk_freq = clk_freq;
0427 
0428     ret = gb_camera_get_max_pkt_size(gcam, resp);
0429     if (ret < 0) {
0430         ret = -EIO;
0431         goto error_power;
0432     }
0433     csi_cfg.max_pkt_size = ret;
0434 
0435     ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
0436                sizeof(csi_cfg),
0437                GB_APB_REQUEST_CSI_TX_CONTROL, false);
0438     if (ret < 0) {
0439         gcam_err(gcam, "failed to start the CSI transmitter\n");
0440         goto error_power;
0441     }
0442 
0443     if (csi_params) {
0444         csi_params->clk_freq = csi_cfg.csi_clk_freq;
0445         csi_params->num_lanes = csi_cfg.num_lanes;
0446     }
0447 
0448     return 0;
0449 
0450 error_power:
0451     gb_camera_set_power_mode(gcam, false);
0452 error_conn_disable:
0453     gb_connection_disable(gcam->data_connection);
0454 error_conn_destroy:
0455     gb_connection_destroy(gcam->data_connection);
0456     gcam->data_connection = NULL;
0457     return ret;
0458 }
0459 
0460 static void gb_camera_teardown_data_connection(struct gb_camera *gcam)
0461 {
0462     struct ap_csi_config_request csi_cfg;
0463     int ret;
0464 
0465     /* Stop the APB1 CSI transmitter. */
0466     memset(&csi_cfg, 0, sizeof(csi_cfg));
0467     csi_cfg.csi_id = 1;
0468 
0469     ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
0470                sizeof(csi_cfg),
0471                GB_APB_REQUEST_CSI_TX_CONTROL, false);
0472 
0473     if (ret < 0)
0474         gcam_err(gcam, "failed to stop the CSI transmitter\n");
0475 
0476     /* Set the UniPro link to low speed mode. */
0477     gb_camera_set_power_mode(gcam, false);
0478 
0479     /* Destroy the data connection. */
0480     gb_connection_disable(gcam->data_connection);
0481     gb_connection_destroy(gcam->data_connection);
0482     gcam->data_connection = NULL;
0483 }
0484 
0485 /* -----------------------------------------------------------------------------
0486  * Camera Protocol Operations
0487  */
0488 
0489 static int gb_camera_capabilities(struct gb_camera *gcam,
0490                   u8 *capabilities, size_t *size)
0491 {
0492     int ret;
0493 
0494     ret = gb_pm_runtime_get_sync(gcam->bundle);
0495     if (ret)
0496         return ret;
0497 
0498     mutex_lock(&gcam->mutex);
0499 
0500     if (!gcam->connection) {
0501         ret = -EINVAL;
0502         goto done;
0503     }
0504 
0505     ret = gb_camera_operation_sync_flags(gcam->connection,
0506                          GB_CAMERA_TYPE_CAPABILITIES,
0507                          GB_OPERATION_FLAG_SHORT_RESPONSE,
0508                          NULL, 0,
0509                          (void *)capabilities, size);
0510     if (ret)
0511         gcam_err(gcam, "failed to retrieve capabilities: %d\n", ret);
0512 
0513 done:
0514     mutex_unlock(&gcam->mutex);
0515 
0516     gb_pm_runtime_put_autosuspend(gcam->bundle);
0517 
0518     return ret;
0519 }
0520 
0521 static int gb_camera_configure_streams(struct gb_camera *gcam,
0522                        unsigned int *num_streams,
0523                        unsigned int *flags,
0524                        struct gb_camera_stream_config *streams,
0525                        struct gb_camera_csi_params *csi_params)
0526 {
0527     struct gb_camera_configure_streams_request *req;
0528     struct gb_camera_configure_streams_response *resp;
0529     unsigned int nstreams = *num_streams;
0530     unsigned int i;
0531     size_t req_size;
0532     size_t resp_size;
0533     int ret;
0534 
0535     if (nstreams > GB_CAMERA_MAX_STREAMS)
0536         return -EINVAL;
0537 
0538     req_size = sizeof(*req) + nstreams * sizeof(req->config[0]);
0539     resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]);
0540 
0541     req = kmalloc(req_size, GFP_KERNEL);
0542     resp = kmalloc(resp_size, GFP_KERNEL);
0543     if (!req || !resp) {
0544         kfree(req);
0545         kfree(resp);
0546         return -ENOMEM;
0547     }
0548 
0549     req->num_streams = nstreams;
0550     req->flags = *flags;
0551     req->padding = 0;
0552 
0553     for (i = 0; i < nstreams; ++i) {
0554         struct gb_camera_stream_config_request *cfg = &req->config[i];
0555 
0556         cfg->width = cpu_to_le16(streams[i].width);
0557         cfg->height = cpu_to_le16(streams[i].height);
0558         cfg->format = cpu_to_le16(streams[i].format);
0559         cfg->padding = 0;
0560     }
0561 
0562     mutex_lock(&gcam->mutex);
0563 
0564     ret = gb_pm_runtime_get_sync(gcam->bundle);
0565     if (ret)
0566         goto done_skip_pm_put;
0567 
0568     if (!gcam->connection) {
0569         ret = -EINVAL;
0570         goto done;
0571     }
0572 
0573     ret = gb_camera_operation_sync_flags(gcam->connection,
0574                          GB_CAMERA_TYPE_CONFIGURE_STREAMS,
0575                          GB_OPERATION_FLAG_SHORT_RESPONSE,
0576                          req, req_size,
0577                          resp, &resp_size);
0578     if (ret < 0)
0579         goto done;
0580 
0581     ret = gb_camera_configure_streams_validate_response(gcam, resp,
0582                                 nstreams);
0583     if (ret < 0)
0584         goto done;
0585 
0586     *flags = resp->flags;
0587     *num_streams = resp->num_streams;
0588 
0589     for (i = 0; i < resp->num_streams; ++i) {
0590         struct gb_camera_stream_config_response *cfg = &resp->config[i];
0591 
0592         streams[i].width = le16_to_cpu(cfg->width);
0593         streams[i].height = le16_to_cpu(cfg->height);
0594         streams[i].format = le16_to_cpu(cfg->format);
0595         streams[i].vc = cfg->virtual_channel;
0596         streams[i].dt[0] = cfg->data_type[0];
0597         streams[i].dt[1] = cfg->data_type[1];
0598         streams[i].max_size = le32_to_cpu(cfg->max_size);
0599     }
0600 
0601     if ((resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) ||
0602         (req->flags & GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY))
0603         goto done;
0604 
0605     if (gcam->state == GB_CAMERA_STATE_CONFIGURED) {
0606         gb_camera_teardown_data_connection(gcam);
0607         gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
0608 
0609         /*
0610          * When unconfiguring streams release the PM runtime reference
0611          * that was acquired when streams were configured. The bundle
0612          * won't be suspended until the PM runtime reference acquired at
0613          * the beginning of this function gets released right before
0614          * returning.
0615          */
0616         gb_pm_runtime_put_noidle(gcam->bundle);
0617     }
0618 
0619     if (resp->num_streams == 0)
0620         goto done;
0621 
0622     /*
0623      * Make sure the bundle won't be suspended until streams get
0624      * unconfigured after the stream is configured successfully
0625      */
0626     gb_pm_runtime_get_noresume(gcam->bundle);
0627 
0628     /* Setup CSI-2 connection from APB-A to AP */
0629     ret = gb_camera_setup_data_connection(gcam, resp, csi_params);
0630     if (ret < 0) {
0631         memset(req, 0, sizeof(*req));
0632         gb_operation_sync(gcam->connection,
0633                   GB_CAMERA_TYPE_CONFIGURE_STREAMS,
0634                   req, sizeof(*req),
0635                   resp, sizeof(*resp));
0636         *flags = 0;
0637         *num_streams = 0;
0638         gb_pm_runtime_put_noidle(gcam->bundle);
0639         goto done;
0640     }
0641 
0642     gcam->state = GB_CAMERA_STATE_CONFIGURED;
0643 
0644 done:
0645     gb_pm_runtime_put_autosuspend(gcam->bundle);
0646 
0647 done_skip_pm_put:
0648     mutex_unlock(&gcam->mutex);
0649     kfree(req);
0650     kfree(resp);
0651     return ret;
0652 }
0653 
0654 static int gb_camera_capture(struct gb_camera *gcam, u32 request_id,
0655                  unsigned int streams, unsigned int num_frames,
0656                  size_t settings_size, const void *settings)
0657 {
0658     struct gb_camera_capture_request *req;
0659     size_t req_size;
0660     int ret;
0661 
0662     if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE)
0663         return -EINVAL;
0664 
0665     req_size = sizeof(*req) + settings_size;
0666     req = kmalloc(req_size, GFP_KERNEL);
0667     if (!req)
0668         return -ENOMEM;
0669 
0670     req->request_id = cpu_to_le32(request_id);
0671     req->streams = streams;
0672     req->padding = 0;
0673     req->num_frames = cpu_to_le16(num_frames);
0674     memcpy(req->settings, settings, settings_size);
0675 
0676     mutex_lock(&gcam->mutex);
0677 
0678     if (!gcam->connection) {
0679         ret = -EINVAL;
0680         goto done;
0681     }
0682 
0683     ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
0684                 req, req_size, NULL, 0);
0685 done:
0686     mutex_unlock(&gcam->mutex);
0687 
0688     kfree(req);
0689 
0690     return ret;
0691 }
0692 
0693 static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
0694 {
0695     struct gb_camera_flush_response resp;
0696     int ret;
0697 
0698     mutex_lock(&gcam->mutex);
0699 
0700     if (!gcam->connection) {
0701         ret = -EINVAL;
0702         goto done;
0703     }
0704 
0705     ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
0706                 &resp, sizeof(resp));
0707 
0708     if (ret < 0)
0709         goto done;
0710 
0711     if (request_id)
0712         *request_id = le32_to_cpu(resp.request_id);
0713 
0714 done:
0715     mutex_unlock(&gcam->mutex);
0716 
0717     return ret;
0718 }
0719 
0720 static int gb_camera_request_handler(struct gb_operation *op)
0721 {
0722     struct gb_camera *gcam = gb_connection_get_data(op->connection);
0723     struct gb_camera_metadata_request *payload;
0724     struct gb_message *request;
0725 
0726     if (op->type != GB_CAMERA_TYPE_METADATA) {
0727         gcam_err(gcam, "Unsupported unsolicited event: %u\n", op->type);
0728         return -EINVAL;
0729     }
0730 
0731     request = op->request;
0732 
0733     if (request->payload_size < sizeof(*payload)) {
0734         gcam_err(gcam, "Wrong event size received (%zu < %zu)\n",
0735              request->payload_size, sizeof(*payload));
0736         return -EINVAL;
0737     }
0738 
0739     payload = request->payload;
0740 
0741     gcam_dbg(gcam, "received metadata for request %u, frame %u, stream %u\n",
0742          payload->request_id, payload->frame_number, payload->stream);
0743 
0744     return 0;
0745 }
0746 
0747 /* -----------------------------------------------------------------------------
0748  * Interface with HOST gmp camera.
0749  */
0750 static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code)
0751 {
0752     unsigned int i;
0753 
0754     for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
0755         if (gb_fmt_info[i].mbus_code == mbus_code)
0756             return gb_fmt_info[i].gb_format;
0757     }
0758     return gb_fmt_info[0].gb_format;
0759 }
0760 
0761 static enum v4l2_mbus_pixelcode gb_camera_gb_to_mbus(u16 gb_fmt)
0762 {
0763     unsigned int i;
0764 
0765     for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
0766         if (gb_fmt_info[i].gb_format == gb_fmt)
0767             return gb_fmt_info[i].mbus_code;
0768     }
0769     return gb_fmt_info[0].mbus_code;
0770 }
0771 
0772 static ssize_t gb_camera_op_capabilities(void *priv, char *data, size_t len)
0773 {
0774     struct gb_camera *gcam = priv;
0775     size_t capabilities_len = len;
0776     int ret;
0777 
0778     ret = gb_camera_capabilities(gcam, data, &capabilities_len);
0779     if (ret)
0780         return ret;
0781 
0782     return capabilities_len;
0783 }
0784 
0785 static int gb_camera_op_configure_streams(void *priv, unsigned int *nstreams,
0786         unsigned int *flags, struct gb_camera_stream *streams,
0787         struct gb_camera_csi_params *csi_params)
0788 {
0789     struct gb_camera *gcam = priv;
0790     struct gb_camera_stream_config *gb_streams;
0791     unsigned int gb_flags = 0;
0792     unsigned int gb_nstreams = *nstreams;
0793     unsigned int i;
0794     int ret;
0795 
0796     if (gb_nstreams > GB_CAMERA_MAX_STREAMS)
0797         return -EINVAL;
0798 
0799     gb_streams = kcalloc(gb_nstreams, sizeof(*gb_streams), GFP_KERNEL);
0800     if (!gb_streams)
0801         return -ENOMEM;
0802 
0803     for (i = 0; i < gb_nstreams; i++) {
0804         gb_streams[i].width = streams[i].width;
0805         gb_streams[i].height = streams[i].height;
0806         gb_streams[i].format =
0807             gb_camera_mbus_to_gb(streams[i].pixel_code);
0808     }
0809 
0810     if (*flags & GB_CAMERA_IN_FLAG_TEST)
0811         gb_flags |= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY;
0812 
0813     ret = gb_camera_configure_streams(gcam, &gb_nstreams,
0814                       &gb_flags, gb_streams, csi_params);
0815     if (ret < 0)
0816         goto done;
0817     if (gb_nstreams > *nstreams) {
0818         ret = -EINVAL;
0819         goto done;
0820     }
0821 
0822     *flags = 0;
0823     if (gb_flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED)
0824         *flags |= GB_CAMERA_OUT_FLAG_ADJUSTED;
0825 
0826     for (i = 0; i < gb_nstreams; i++) {
0827         streams[i].width = gb_streams[i].width;
0828         streams[i].height = gb_streams[i].height;
0829         streams[i].vc = gb_streams[i].vc;
0830         streams[i].dt[0] = gb_streams[i].dt[0];
0831         streams[i].dt[1] = gb_streams[i].dt[1];
0832         streams[i].max_size = gb_streams[i].max_size;
0833         streams[i].pixel_code =
0834             gb_camera_gb_to_mbus(gb_streams[i].format);
0835     }
0836     *nstreams = gb_nstreams;
0837 
0838 done:
0839     kfree(gb_streams);
0840     return ret;
0841 }
0842 
0843 static int gb_camera_op_capture(void *priv, u32 request_id,
0844                 unsigned int streams, unsigned int num_frames,
0845                 size_t settings_size, const void *settings)
0846 {
0847     struct gb_camera *gcam = priv;
0848 
0849     return gb_camera_capture(gcam, request_id, streams, num_frames,
0850                  settings_size, settings);
0851 }
0852 
0853 static int gb_camera_op_flush(void *priv, u32 *request_id)
0854 {
0855     struct gb_camera *gcam = priv;
0856 
0857     return gb_camera_flush(gcam, request_id);
0858 }
0859 
0860 static const struct gb_camera_ops gb_cam_ops = {
0861     .capabilities = gb_camera_op_capabilities,
0862     .configure_streams = gb_camera_op_configure_streams,
0863     .capture = gb_camera_op_capture,
0864     .flush = gb_camera_op_flush,
0865 };
0866 
0867 /* -----------------------------------------------------------------------------
0868  * DebugFS
0869  */
0870 
0871 static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam,
0872                           char *buf, size_t len)
0873 {
0874     struct gb_camera_debugfs_buffer *buffer =
0875         &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES];
0876     size_t size = 1024;
0877     unsigned int i;
0878     u8 *caps;
0879     int ret;
0880 
0881     caps = kmalloc(size, GFP_KERNEL);
0882     if (!caps)
0883         return -ENOMEM;
0884 
0885     ret = gb_camera_capabilities(gcam, caps, &size);
0886     if (ret < 0)
0887         goto done;
0888 
0889     /*
0890      * hex_dump_to_buffer() doesn't return the number of bytes dumped prior
0891      * to v4.0, we need our own implementation :-(
0892      */
0893     buffer->length = 0;
0894 
0895     for (i = 0; i < size; i += 16) {
0896         unsigned int nbytes = min_t(unsigned int, size - i, 16);
0897 
0898         buffer->length += sprintf(buffer->data + buffer->length,
0899                       "%*ph\n", nbytes, caps + i);
0900     }
0901 
0902 done:
0903     kfree(caps);
0904     return ret;
0905 }
0906 
0907 static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam,
0908                            char *buf, size_t len)
0909 {
0910     struct gb_camera_debugfs_buffer *buffer =
0911         &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_STREAMS];
0912     struct gb_camera_stream_config *streams;
0913     unsigned int nstreams;
0914     unsigned int flags;
0915     unsigned int i;
0916     char *token;
0917     int ret;
0918 
0919     /* Retrieve number of streams to configure */
0920     token = strsep(&buf, ";");
0921     if (!token)
0922         return -EINVAL;
0923 
0924     ret = kstrtouint(token, 10, &nstreams);
0925     if (ret < 0)
0926         return ret;
0927 
0928     if (nstreams > GB_CAMERA_MAX_STREAMS)
0929         return -EINVAL;
0930 
0931     token = strsep(&buf, ";");
0932     if (!token)
0933         return -EINVAL;
0934 
0935     ret = kstrtouint(token, 10, &flags);
0936     if (ret < 0)
0937         return ret;
0938 
0939     /* For each stream to configure parse width, height and format */
0940     streams = kcalloc(nstreams, sizeof(*streams), GFP_KERNEL);
0941     if (!streams)
0942         return -ENOMEM;
0943 
0944     for (i = 0; i < nstreams; ++i) {
0945         struct gb_camera_stream_config *stream = &streams[i];
0946 
0947         /* width */
0948         token = strsep(&buf, ";");
0949         if (!token) {
0950             ret = -EINVAL;
0951             goto done;
0952         }
0953         ret = kstrtouint(token, 10, &stream->width);
0954         if (ret < 0)
0955             goto done;
0956 
0957         /* height */
0958         token = strsep(&buf, ";");
0959         if (!token)
0960             goto done;
0961 
0962         ret = kstrtouint(token, 10, &stream->height);
0963         if (ret < 0)
0964             goto done;
0965 
0966         /* Image format code */
0967         token = strsep(&buf, ";");
0968         if (!token)
0969             goto done;
0970 
0971         ret = kstrtouint(token, 16, &stream->format);
0972         if (ret < 0)
0973             goto done;
0974     }
0975 
0976     ret = gb_camera_configure_streams(gcam, &nstreams, &flags, streams,
0977                       NULL);
0978     if (ret < 0)
0979         goto done;
0980 
0981     buffer->length = sprintf(buffer->data, "%u;%u;", nstreams, flags);
0982 
0983     for (i = 0; i < nstreams; ++i) {
0984         struct gb_camera_stream_config *stream = &streams[i];
0985 
0986         buffer->length += sprintf(buffer->data + buffer->length,
0987                       "%u;%u;%u;%u;%u;%u;%u;",
0988                       stream->width, stream->height,
0989                       stream->format, stream->vc,
0990                       stream->dt[0], stream->dt[1],
0991                       stream->max_size);
0992     }
0993 
0994     ret = len;
0995 
0996 done:
0997     kfree(streams);
0998     return ret;
0999 };
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)
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)
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)
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 | 0444,
1070         .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
1071         .execute = gb_camera_debugfs_capabilities,
1072     }, {
1073         .name = "configure_streams",
1074         .mask = S_IFREG | 0666,
1075         .buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
1076         .execute = gb_camera_debugfs_configure_streams,
1077     }, {
1078         .name = "capture",
1079         .mask = S_IFREG | 0666,
1080         .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
1081         .execute = gb_camera_debugfs_capture,
1082     }, {
1083         .name = "flush",
1084         .mask = S_IFREG | 0666,
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_inode(file)->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 & 0222)) {
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_inode(file)->i_private;
1117     ssize_t ret;
1118     char *kbuf;
1119 
1120     if (len > 1024)
1121         return -EINVAL;
1122 
1123     kbuf = memdup_user_nul(buf, len);
1124     if (IS_ERR(kbuf))
1125         return PTR_ERR(kbuf);
1126 
1127     ret = op->execute(gcam, kbuf, len);
1128 
1129 done:
1130     kfree(kbuf);
1131     return ret;
1132 }
1133 
1134 static int gb_camera_debugfs_open(struct inode *inode, struct file *file)
1135 {
1136     unsigned int i;
1137 
1138     for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
1139         const struct gb_camera_debugfs_entry *entry =
1140             &gb_camera_debugfs_entries[i];
1141 
1142         if (!strcmp(file->f_path.dentry->d_iname, entry->name)) {
1143             file->private_data = (void *)entry;
1144             break;
1145         }
1146     }
1147 
1148     return 0;
1149 }
1150 
1151 static const struct file_operations gb_camera_debugfs_ops = {
1152     .open = gb_camera_debugfs_open,
1153     .read = gb_camera_debugfs_read,
1154     .write = gb_camera_debugfs_write,
1155 };
1156 
1157 static int gb_camera_debugfs_init(struct gb_camera *gcam)
1158 {
1159     struct gb_connection *connection = gcam->connection;
1160     char dirname[27];
1161     unsigned int i;
1162 
1163     /*
1164      * Create root debugfs entry and a file entry for each camera operation.
1165      */
1166     snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id,
1167          gcam->bundle->id);
1168 
1169     gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get());
1170 
1171     gcam->debugfs.buffers =
1172         vmalloc(array_size(GB_CAMERA_DEBUGFS_BUFFER_MAX,
1173                    sizeof(*gcam->debugfs.buffers)));
1174     if (!gcam->debugfs.buffers)
1175         return -ENOMEM;
1176 
1177     for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
1178         const struct gb_camera_debugfs_entry *entry =
1179             &gb_camera_debugfs_entries[i];
1180 
1181         gcam->debugfs.buffers[i].length = 0;
1182 
1183         debugfs_create_file(entry->name, entry->mask,
1184                     gcam->debugfs.root, gcam,
1185                     &gb_camera_debugfs_ops);
1186     }
1187 
1188     return 0;
1189 }
1190 
1191 static void gb_camera_debugfs_cleanup(struct gb_camera *gcam)
1192 {
1193     debugfs_remove_recursive(gcam->debugfs.root);
1194 
1195     vfree(gcam->debugfs.buffers);
1196 }
1197 
1198 /* -----------------------------------------------------------------------------
1199  * Init & Cleanup
1200  */
1201 
1202 static void gb_camera_cleanup(struct gb_camera *gcam)
1203 {
1204     gb_camera_debugfs_cleanup(gcam);
1205 
1206     mutex_lock(&gcam->mutex);
1207     if (gcam->data_connection) {
1208         gb_connection_disable(gcam->data_connection);
1209         gb_connection_destroy(gcam->data_connection);
1210         gcam->data_connection = NULL;
1211     }
1212 
1213     if (gcam->connection) {
1214         gb_connection_disable(gcam->connection);
1215         gb_connection_destroy(gcam->connection);
1216         gcam->connection = NULL;
1217     }
1218     mutex_unlock(&gcam->mutex);
1219 }
1220 
1221 static void gb_camera_release_module(struct kref *ref)
1222 {
1223     struct gb_camera_module *cam_mod =
1224         container_of(ref, struct gb_camera_module, refcount);
1225     kfree(cam_mod->priv);
1226 }
1227 
1228 static int gb_camera_probe(struct gb_bundle *bundle,
1229                const struct greybus_bundle_id *id)
1230 {
1231     struct gb_connection *conn;
1232     struct gb_camera *gcam;
1233     u16 mgmt_cport_id = 0;
1234     u16 data_cport_id = 0;
1235     unsigned int i;
1236     int ret;
1237 
1238     /*
1239      * The camera bundle must contain exactly two CPorts, one for the
1240      * camera management protocol and one for the camera data protocol.
1241      */
1242     if (bundle->num_cports != 2)
1243         return -ENODEV;
1244 
1245     for (i = 0; i < bundle->num_cports; ++i) {
1246         struct greybus_descriptor_cport *desc = &bundle->cport_desc[i];
1247 
1248         switch (desc->protocol_id) {
1249         case GREYBUS_PROTOCOL_CAMERA_MGMT:
1250             mgmt_cport_id = le16_to_cpu(desc->id);
1251             break;
1252         case GREYBUS_PROTOCOL_CAMERA_DATA:
1253             data_cport_id = le16_to_cpu(desc->id);
1254             break;
1255         default:
1256             return -ENODEV;
1257         }
1258     }
1259 
1260     if (!mgmt_cport_id || !data_cport_id)
1261         return -ENODEV;
1262 
1263     gcam = kzalloc(sizeof(*gcam), GFP_KERNEL);
1264     if (!gcam)
1265         return -ENOMEM;
1266 
1267     mutex_init(&gcam->mutex);
1268 
1269     gcam->bundle = bundle;
1270     gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
1271     gcam->data_cport_id = data_cport_id;
1272 
1273     conn = gb_connection_create(bundle, mgmt_cport_id,
1274                     gb_camera_request_handler);
1275     if (IS_ERR(conn)) {
1276         ret = PTR_ERR(conn);
1277         goto error;
1278     }
1279 
1280     gcam->connection = conn;
1281     gb_connection_set_data(conn, gcam);
1282 
1283     ret = gb_connection_enable(conn);
1284     if (ret)
1285         goto error;
1286 
1287     ret = gb_camera_debugfs_init(gcam);
1288     if (ret < 0)
1289         goto error;
1290 
1291     gcam->module.priv = gcam;
1292     gcam->module.ops = &gb_cam_ops;
1293     gcam->module.interface_id = gcam->connection->intf->interface_id;
1294     gcam->module.release = gb_camera_release_module;
1295     ret = gb_camera_register(&gcam->module);
1296     if (ret < 0)
1297         goto error;
1298 
1299     greybus_set_drvdata(bundle, gcam);
1300 
1301     gb_pm_runtime_put_autosuspend(gcam->bundle);
1302 
1303     return 0;
1304 
1305 error:
1306     gb_camera_cleanup(gcam);
1307     kfree(gcam);
1308     return ret;
1309 }
1310 
1311 static void gb_camera_disconnect(struct gb_bundle *bundle)
1312 {
1313     struct gb_camera *gcam = greybus_get_drvdata(bundle);
1314     int ret;
1315 
1316     ret = gb_pm_runtime_get_sync(bundle);
1317     if (ret)
1318         gb_pm_runtime_get_noresume(bundle);
1319 
1320     gb_camera_cleanup(gcam);
1321     gb_camera_unregister(&gcam->module);
1322 }
1323 
1324 static const struct greybus_bundle_id gb_camera_id_table[] = {
1325     { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_CAMERA) },
1326     { },
1327 };
1328 
1329 #ifdef CONFIG_PM
1330 static int gb_camera_suspend(struct device *dev)
1331 {
1332     struct gb_bundle *bundle = to_gb_bundle(dev);
1333     struct gb_camera *gcam = greybus_get_drvdata(bundle);
1334 
1335     if (gcam->data_connection)
1336         gb_connection_disable(gcam->data_connection);
1337 
1338     gb_connection_disable(gcam->connection);
1339 
1340     return 0;
1341 }
1342 
1343 static int gb_camera_resume(struct device *dev)
1344 {
1345     struct gb_bundle *bundle = to_gb_bundle(dev);
1346     struct gb_camera *gcam = greybus_get_drvdata(bundle);
1347     int ret;
1348 
1349     ret = gb_connection_enable(gcam->connection);
1350     if (ret) {
1351         gcam_err(gcam, "failed to enable connection: %d\n", ret);
1352         return ret;
1353     }
1354 
1355     if (gcam->data_connection) {
1356         ret = gb_connection_enable(gcam->data_connection);
1357         if (ret) {
1358             gcam_err(gcam,
1359                  "failed to enable data connection: %d\n", ret);
1360             return ret;
1361         }
1362     }
1363 
1364     return 0;
1365 }
1366 #endif
1367 
1368 static const struct dev_pm_ops gb_camera_pm_ops = {
1369     SET_RUNTIME_PM_OPS(gb_camera_suspend, gb_camera_resume, NULL)
1370 };
1371 
1372 static struct greybus_driver gb_camera_driver = {
1373     .name       = "camera",
1374     .probe      = gb_camera_probe,
1375     .disconnect = gb_camera_disconnect,
1376     .id_table   = gb_camera_id_table,
1377     .driver.pm  = &gb_camera_pm_ops,
1378 };
1379 
1380 module_greybus_driver(gb_camera_driver);
1381 
1382 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!