2 * Greybus Camera protocol driver.
4 * Copyright 2015 Google Inc.
5 * Copyright 2015 Linaro Ltd.
7 * Released under the GPLv2 only.
10 #include <linux/debugfs.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>
19 #include "gb-camera.h"
21 #include "greybus_protocols.h"
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,
31 struct gb_camera_debugfs_buffer {
36 enum gb_camera_state {
37 GB_CAMERA_STATE_UNCONFIGURED,
38 GB_CAMERA_STATE_CONFIGURED,
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.
52 struct gb_bundle *bundle;
53 struct gb_connection *connection;
54 struct gb_connection *data_connection;
58 enum gb_camera_state state;
62 struct gb_camera_debugfs_buffer *buffers;
65 struct gb_camera_module module;
68 struct gb_camera_stream_config {
74 unsigned int max_size;
77 struct gb_camera_fmt_info {
78 enum v4l2_mbus_pixelcode mbus_code;
79 unsigned int gb_format;
83 /* GB format to media code map */
84 static const struct gb_camera_fmt_info gb_fmt_info[] = {
86 .mbus_code = V4L2_MBUS_FMT_UYVY8_1X16,
91 .mbus_code = V4L2_MBUS_FMT_NV12_1x8,
96 .mbus_code = V4L2_MBUS_FMT_NV21_1x8,
101 .mbus_code = V4L2_MBUS_FMT_YU12_1x8,
106 .mbus_code = V4L2_MBUS_FMT_YV12_1x8,
111 .mbus_code = V4L2_MBUS_FMT_JPEG_1X8,
116 .mbus_code = V4L2_MBUS_FMT_GB_CAM_METADATA_1X8,
121 .mbus_code = V4L2_MBUS_FMT_GB_CAM_DEBUG_DATA_1X8,
126 .mbus_code = V4L2_MBUS_FMT_SBGGR10_1X10,
131 .mbus_code = V4L2_MBUS_FMT_SGBRG10_1X10,
136 .mbus_code = V4L2_MBUS_FMT_SGRBG10_1X10,
141 .mbus_code = V4L2_MBUS_FMT_SRGGB10_1X10,
146 .mbus_code = V4L2_MBUS_FMT_SBGGR12_1X12,
151 .mbus_code = V4L2_MBUS_FMT_SGBRG12_1X12,
156 .mbus_code = V4L2_MBUS_FMT_SGRBG12_1X12,
161 .mbus_code = V4L2_MBUS_FMT_SRGGB12_1X12,
167 static const struct gb_camera_fmt_info *gb_camera_get_format_info(u16 gb_fmt)
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];
179 #define ES2_APB_CDSI0_CPORT 16
180 #define ES2_APB_CDSI1_CPORT 17
182 #define GB_CAMERA_MAX_SETTINGS_SIZE 8192
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)
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)
193 struct gb_operation *operation;
196 operation = gb_operation_create_flags(connection, type, request_size,
197 *response_size, flags,
203 memcpy(operation->request->payload, request, request_size);
205 ret = gb_operation_request_send_sync(operation);
207 dev_err(&connection->hd->dev,
208 "%s: synchronous operation of type 0x%02x failed: %d\n",
209 connection->name, type, ret);
211 *response_size = operation->response->payload_size;
213 if (operation->response->payload_size)
214 memcpy(response, operation->response->payload,
215 operation->response->payload_size);
218 gb_operation_put(operation);
223 static int gb_camera_get_max_pkt_size(struct gb_camera *gcam,
224 struct gb_camera_configure_streams_response *resp)
226 unsigned int max_pkt_size = 0;
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;
234 fmt_info = gb_camera_get_format_info(cfg->format);
236 gcam_err(gcam, "unsupported greybus image format: %d\n",
241 if (fmt_info->bpp == 0) {
242 pkt_size = le32_to_cpu(cfg->max_pkt_size);
246 "Stream %u: invalid zero maximum packet size\n",
251 pkt_size = le16_to_cpu(cfg->width) * fmt_info->bpp / 8;
253 if (pkt_size != le32_to_cpu(cfg->max_pkt_size)) {
255 "Stream %u: maximum packet size mismatch (%u/%u)\n",
256 i, pkt_size, cfg->max_pkt_size);
261 max_pkt_size = max(pkt_size, max_pkt_size);
268 * Validate the stream configuration response verifying padding is correctly
269 * set and the returned number of streams is supported
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)
278 /* Validate the returned response structure */
279 if (resp->padding[0] || resp->padding[1]) {
280 gcam_err(gcam, "response padding != 0\n");
284 if (resp->num_streams > nstreams) {
285 gcam_err(gcam, "got #streams %u > request %u\n",
286 resp->num_streams, nstreams);
290 for (i = 0; i < resp->num_streams; i++) {
291 struct gb_camera_stream_config_response *cfg = &resp->config[i];
294 gcam_err(gcam, "stream #%u padding != 0\n", i);
302 /* -----------------------------------------------------------------------------
303 * Hardware Configuration
306 static int gb_camera_set_intf_power_mode(struct gb_camera *gcam, u8 intf_id,
309 struct gb_svc *svc = gcam->connection->hd->svc;
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,
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,
327 GB_SVC_SMALL_AMPLITUDE,
328 GB_SVC_NO_DE_EMPHASIS,
329 GB_SVC_UNIPRO_SLOW_AUTO_MODE,
337 static int gb_camera_set_power_mode(struct gb_camera *gcam, bool hs)
339 struct gb_interface *intf = gcam->connection->intf;
340 struct gb_svc *svc = gcam->connection->hd->svc;
343 ret = gb_camera_set_intf_power_mode(gcam, intf->interface_id, hs);
345 gcam_err(gcam, "failed to set module interface to %s (%d)\n",
346 hs ? "HS" : "PWM", ret);
350 ret = gb_camera_set_intf_power_mode(gcam, svc->ap_intf_id, hs);
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);
361 struct ap_csi_config_request {
364 #define GB_CAMERA_CSI_FLAG_CLOCK_CONTINUOUS 0x01
372 * TODO: Compute the number of lanes dynamically based on bandwidth
375 #define GB_CAMERA_CSI_NUM_DATA_LANES 4
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
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)
385 struct ap_csi_config_request csi_cfg;
386 struct gb_connection *conn;
387 unsigned int clk_freq;
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.
394 conn = gb_connection_create_offloaded(gcam->bundle, gcam->data_cport_id,
395 GB_CONNECTION_FLAG_NO_FLOWCTRL |
396 GB_CONNECTION_FLAG_CDSI1);
398 return PTR_ERR(conn);
400 gcam->data_connection = conn;
401 gb_connection_set_data(conn, gcam);
403 ret = gb_connection_enable(conn);
405 goto error_conn_destroy;
407 /* Set the UniPro link to high speed mode. */
408 ret = gb_camera_set_power_mode(gcam, true);
410 goto error_conn_disable;
413 * Configure the APB-A CSI-2 transmitter.
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.
418 memset(&csi_cfg, 0, sizeof(csi_cfg));
421 csi_cfg.num_lanes = GB_CAMERA_CSI_NUM_DATA_LANES;
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;
429 ret = gb_camera_get_max_pkt_size(gcam, resp);
434 csi_cfg.max_pkt_size = ret;
436 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
438 GB_APB_REQUEST_CSI_TX_CONTROL, false);
440 gcam_err(gcam, "failed to start the CSI transmitter\n");
445 csi_params->clk_freq = csi_cfg.csi_clk_freq;
446 csi_params->num_lanes = csi_cfg.num_lanes;
452 gb_camera_set_power_mode(gcam, false);
454 gb_connection_disable(gcam->data_connection);
456 gb_connection_destroy(gcam->data_connection);
457 gcam->data_connection = NULL;
461 static void gb_camera_teardown_data_connection(struct gb_camera *gcam)
463 struct ap_csi_config_request csi_cfg;
466 /* Stop the APB1 CSI transmitter. */
467 memset(&csi_cfg, 0, sizeof(csi_cfg));
470 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
472 GB_APB_REQUEST_CSI_TX_CONTROL, false);
475 gcam_err(gcam, "failed to stop the CSI transmitter\n");
477 /* Set the UniPro link to low speed mode. */
478 gb_camera_set_power_mode(gcam, false);
480 /* Destroy the data connection. */
481 gb_connection_disable(gcam->data_connection);
482 gb_connection_destroy(gcam->data_connection);
483 gcam->data_connection = NULL;
486 /* -----------------------------------------------------------------------------
487 * Camera Protocol Operations
490 static int gb_camera_capabilities(struct gb_camera *gcam,
491 u8 *capabilities, size_t *size)
495 ret = gb_pm_runtime_get_sync(gcam->bundle);
499 mutex_lock(&gcam->mutex);
501 if (!gcam->connection) {
506 ret = gb_camera_operation_sync_flags(gcam->connection,
507 GB_CAMERA_TYPE_CAPABILITIES,
508 GB_OPERATION_FLAG_SHORT_RESPONSE,
510 (void *)capabilities, size);
512 gcam_err(gcam, "failed to retrieve capabilities: %d\n", ret);
515 mutex_unlock(&gcam->mutex);
517 gb_pm_runtime_put_autosuspend(gcam->bundle);
522 static int gb_camera_configure_streams(struct gb_camera *gcam,
523 unsigned int *num_streams,
525 struct gb_camera_stream_config *streams,
526 struct gb_camera_csi_params *csi_params)
528 struct gb_camera_configure_streams_request *req;
529 struct gb_camera_configure_streams_response *resp;
530 unsigned int nstreams = *num_streams;
536 if (nstreams > GB_CAMERA_MAX_STREAMS)
539 req_size = sizeof(*req) + nstreams * sizeof(req->config[0]);
540 resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]);
542 req = kmalloc(req_size, GFP_KERNEL);
543 resp = kmalloc(resp_size, GFP_KERNEL);
550 req->num_streams = nstreams;
554 for (i = 0; i < nstreams; ++i) {
555 struct gb_camera_stream_config_request *cfg = &req->config[i];
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);
563 mutex_lock(&gcam->mutex);
565 ret = gb_pm_runtime_get_sync(gcam->bundle);
567 goto done_skip_pm_put;
569 if (!gcam->connection) {
574 ret = gb_camera_operation_sync_flags(gcam->connection,
575 GB_CAMERA_TYPE_CONFIGURE_STREAMS,
576 GB_OPERATION_FLAG_SHORT_RESPONSE,
582 ret = gb_camera_configure_streams_validate_response(gcam, resp,
587 *flags = resp->flags;
588 *num_streams = resp->num_streams;
590 for (i = 0; i < resp->num_streams; ++i) {
591 struct gb_camera_stream_config_response *cfg = &resp->config[i];
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);
602 if ((resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) ||
603 (req->flags & GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY))
606 if (gcam->state == GB_CAMERA_STATE_CONFIGURED) {
607 gb_camera_teardown_data_connection(gcam);
608 gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
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
617 gb_pm_runtime_put_noidle(gcam->bundle);
620 if (resp->num_streams == 0)
624 * Make sure the bundle won't be suspended until streams get
625 * unconfigured after the stream is configured successfully
627 gb_pm_runtime_get_noresume(gcam->bundle);
629 /* Setup CSI-2 connection from APB-A to AP */
630 ret = gb_camera_setup_data_connection(gcam, resp, csi_params);
632 memset(req, 0, sizeof(*req));
633 gb_operation_sync(gcam->connection,
634 GB_CAMERA_TYPE_CONFIGURE_STREAMS,
636 resp, sizeof(*resp));
639 gb_pm_runtime_put_noidle(gcam->bundle);
643 gcam->state = GB_CAMERA_STATE_CONFIGURED;
646 gb_pm_runtime_put_autosuspend(gcam->bundle);
649 mutex_unlock(&gcam->mutex);
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)
659 struct gb_camera_capture_request *req;
663 if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE)
666 req_size = sizeof(*req) + settings_size;
667 req = kmalloc(req_size, GFP_KERNEL);
671 req->request_id = cpu_to_le32(request_id);
672 req->streams = streams;
674 req->num_frames = cpu_to_le16(num_frames);
675 memcpy(req->settings, settings, settings_size);
677 mutex_lock(&gcam->mutex);
679 if (!gcam->connection) {
684 ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
685 req, req_size, NULL, 0);
687 mutex_unlock(&gcam->mutex);
694 static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
696 struct gb_camera_flush_response resp;
699 mutex_lock(&gcam->mutex);
701 if (!gcam->connection) {
706 ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
707 &resp, sizeof(resp));
713 *request_id = le32_to_cpu(resp.request_id);
716 mutex_unlock(&gcam->mutex);
721 static int gb_camera_request_handler(struct gb_operation *op)
723 struct gb_camera *gcam = gb_connection_get_data(op->connection);
724 struct gb_camera_metadata_request *payload;
725 struct gb_message *request;
727 if (op->type != GB_CAMERA_TYPE_METADATA) {
728 gcam_err(gcam, "Unsupported unsolicited event: %u\n", op->type);
732 request = op->request;
734 if (request->payload_size < sizeof(*payload)) {
735 gcam_err(gcam, "Wrong event size received (%zu < %zu)\n",
736 request->payload_size, sizeof(*payload));
740 payload = request->payload;
742 gcam_dbg(gcam, "received metadata for request %u, frame %u, stream %u\n",
743 payload->request_id, payload->frame_number, payload->stream);
748 /* -----------------------------------------------------------------------------
749 * Interface with HOST gmp camera.
751 static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code)
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;
759 return gb_fmt_info[0].gb_format;
762 static enum v4l2_mbus_pixelcode gb_camera_gb_to_mbus(u16 gb_fmt)
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;
770 return gb_fmt_info[0].mbus_code;
773 static ssize_t gb_camera_op_capabilities(void *priv, char *data, size_t len)
775 struct gb_camera *gcam = priv;
776 size_t capabilities_len = len;
779 ret = gb_camera_capabilities(gcam, data, &capabilities_len);
783 return capabilities_len;
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)
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;
797 if (gb_nstreams > GB_CAMERA_MAX_STREAMS)
800 gb_streams = kcalloc(gb_nstreams, sizeof(*gb_streams), GFP_KERNEL);
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);
811 if (*flags & GB_CAMERA_IN_FLAG_TEST)
812 gb_flags |= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY;
814 ret = gb_camera_configure_streams(gcam, &gb_nstreams,
815 &gb_flags, gb_streams, csi_params);
818 if (gb_nstreams > *nstreams) {
824 if (gb_flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED)
825 *flags |= GB_CAMERA_OUT_FLAG_ADJUSTED;
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);
837 *nstreams = gb_nstreams;
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)
848 struct gb_camera *gcam = priv;
850 return gb_camera_capture(gcam, request_id, streams, num_frames,
851 settings_size, settings);
854 static int gb_camera_op_flush(void *priv, u32 *request_id)
856 struct gb_camera *gcam = priv;
858 return gb_camera_flush(gcam, request_id);
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,
868 /* -----------------------------------------------------------------------------
872 static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam,
873 char *buf, size_t len)
875 struct gb_camera_debugfs_buffer *buffer =
876 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES];
882 caps = kmalloc(size, GFP_KERNEL);
886 ret = gb_camera_capabilities(gcam, caps, &size);
891 * hex_dump_to_buffer() doesn't return the number of bytes dumped prior
892 * to v4.0, we need our own implementation :-(
896 for (i = 0; i < size; i += 16) {
897 unsigned int nbytes = min_t(unsigned int, size - i, 16);
899 buffer->length += sprintf(buffer->data + buffer->length,
900 "%*ph\n", nbytes, caps + i);
908 static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam,
909 char *buf, size_t len)
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;
920 /* Retrieve number of streams to configure */
921 token = strsep(&buf, ";");
925 ret = kstrtouint(token, 10, &nstreams);
929 if (nstreams > GB_CAMERA_MAX_STREAMS)
932 token = strsep(&buf, ";");
936 ret = kstrtouint(token, 10, &flags);
940 /* For each stream to configure parse width, height and format */
941 streams = kcalloc(nstreams, sizeof(*streams), GFP_KERNEL);
945 for (i = 0; i < nstreams; ++i) {
946 struct gb_camera_stream_config *stream = &streams[i];
949 token = strsep(&buf, ";");
954 ret = kstrtouint(token, 10, &stream->width);
959 token = strsep(&buf, ";");
963 ret = kstrtouint(token, 10, &stream->height);
967 /* Image format code */
968 token = strsep(&buf, ";");
972 ret = kstrtouint(token, 16, &stream->format);
977 ret = gb_camera_configure_streams(gcam, &nstreams, &flags, streams,
982 buffer->length = sprintf(buffer->data, "%u;%u;", nstreams, flags);
984 for (i = 0; i < nstreams; ++i) {
985 struct gb_camera_stream_config *stream = &streams[i];
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],
1002 static ssize_t gb_camera_debugfs_capture(struct gb_camera *gcam,
1003 char *buf, size_t len)
1005 unsigned int request_id;
1006 unsigned int streams_mask;
1007 unsigned int num_frames;
1012 token = strsep(&buf, ";");
1015 ret = kstrtouint(token, 10, &request_id);
1020 token = strsep(&buf, ";");
1023 ret = kstrtouint(token, 16, &streams_mask);
1027 /* number of frames */
1028 token = strsep(&buf, ";");
1031 ret = kstrtouint(token, 10, &num_frames);
1035 ret = gb_camera_capture(gcam, request_id, streams_mask, num_frames, 0,
1043 static ssize_t gb_camera_debugfs_flush(struct gb_camera *gcam,
1044 char *buf, size_t len)
1046 struct gb_camera_debugfs_buffer *buffer =
1047 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_FLUSH];
1048 unsigned int req_id;
1051 ret = gb_camera_flush(gcam, &req_id);
1055 buffer->length = sprintf(buffer->data, "%u", req_id);
1060 struct gb_camera_debugfs_entry {
1063 unsigned int buffer;
1064 ssize_t (*execute)(struct gb_camera *gcam, char *buf, size_t len);
1067 static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries[] = {
1069 .name = "capabilities",
1070 .mask = S_IFREG | 0444,
1071 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
1072 .execute = gb_camera_debugfs_capabilities,
1074 .name = "configure_streams",
1075 .mask = S_IFREG | 0666,
1076 .buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
1077 .execute = gb_camera_debugfs_configure_streams,
1080 .mask = S_IFREG | 0666,
1081 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
1082 .execute = gb_camera_debugfs_capture,
1085 .mask = S_IFREG | 0666,
1086 .buffer = GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
1087 .execute = gb_camera_debugfs_flush,
1091 static ssize_t gb_camera_debugfs_read(struct file *file, char __user *buf,
1092 size_t len, loff_t *offset)
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;
1099 /* For read-only entries the operation is triggered by a read. */
1100 if (!(op->mask & 0222)) {
1101 ret = op->execute(gcam, NULL, 0);
1106 buffer = &gcam->debugfs.buffers[op->buffer];
1108 return simple_read_from_buffer(buf, len, offset, buffer->data,
1112 static ssize_t gb_camera_debugfs_write(struct file *file,
1113 const char __user *buf, size_t len,
1116 const struct gb_camera_debugfs_entry *op = file->private_data;
1117 struct gb_camera *gcam = file_inode(file)->i_private;
1124 kbuf = kmalloc(len + 1, GFP_KERNEL);
1128 if (copy_from_user(kbuf, buf, len)) {
1135 ret = op->execute(gcam, kbuf, len);
1142 static int gb_camera_debugfs_open(struct inode *inode, struct file *file)
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];
1150 if (!strcmp(file->f_path.dentry->d_iname, entry->name)) {
1151 file->private_data = (void *)entry;
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,
1165 static int gb_camera_debugfs_init(struct gb_camera *gcam)
1167 struct gb_connection *connection = gcam->connection;
1172 * Create root debugfs entry and a file entry for each camera operation.
1174 snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id,
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);
1184 gcam->debugfs.buffers = vmalloc(sizeof(*gcam->debugfs.buffers) *
1185 GB_CAMERA_DEBUGFS_BUFFER_MAX);
1186 if (!gcam->debugfs.buffers)
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;
1194 gcam->debugfs.buffers[i].length = 0;
1196 dentry = debugfs_create_file(entry->name, entry->mask,
1197 gcam->debugfs.root, gcam,
1198 &gb_camera_debugfs_ops);
1199 if (IS_ERR(dentry)) {
1201 "debugfs operation %s create failed (%ld)\n",
1202 entry->name, PTR_ERR(dentry));
1203 return PTR_ERR(dentry);
1210 static void gb_camera_debugfs_cleanup(struct gb_camera *gcam)
1212 debugfs_remove_recursive(gcam->debugfs.root);
1214 vfree(gcam->debugfs.buffers);
1217 /* -----------------------------------------------------------------------------
1221 static void gb_camera_cleanup(struct gb_camera *gcam)
1223 gb_camera_debugfs_cleanup(gcam);
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;
1232 if (gcam->connection) {
1233 gb_connection_disable(gcam->connection);
1234 gb_connection_destroy(gcam->connection);
1235 gcam->connection = NULL;
1237 mutex_unlock(&gcam->mutex);
1240 static void gb_camera_release_module(struct kref *ref)
1242 struct gb_camera_module *cam_mod =
1243 container_of(ref, struct gb_camera_module, refcount);
1244 kfree(cam_mod->priv);
1247 static int gb_camera_probe(struct gb_bundle *bundle,
1248 const struct greybus_bundle_id *id)
1250 struct gb_connection *conn;
1251 struct gb_camera *gcam;
1252 u16 mgmt_cport_id = 0;
1253 u16 data_cport_id = 0;
1258 * The camera bundle must contain exactly two CPorts, one for the
1259 * camera management protocol and one for the camera data protocol.
1261 if (bundle->num_cports != 2)
1264 for (i = 0; i < bundle->num_cports; ++i) {
1265 struct greybus_descriptor_cport *desc = &bundle->cport_desc[i];
1267 switch (desc->protocol_id) {
1268 case GREYBUS_PROTOCOL_CAMERA_MGMT:
1269 mgmt_cport_id = le16_to_cpu(desc->id);
1271 case GREYBUS_PROTOCOL_CAMERA_DATA:
1272 data_cport_id = le16_to_cpu(desc->id);
1279 if (!mgmt_cport_id || !data_cport_id)
1282 gcam = kzalloc(sizeof(*gcam), GFP_KERNEL);
1286 mutex_init(&gcam->mutex);
1288 gcam->bundle = bundle;
1289 gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
1290 gcam->data_cport_id = data_cport_id;
1292 conn = gb_connection_create(bundle, mgmt_cport_id,
1293 gb_camera_request_handler);
1295 ret = PTR_ERR(conn);
1299 gcam->connection = conn;
1300 gb_connection_set_data(conn, gcam);
1302 ret = gb_connection_enable(conn);
1306 ret = gb_camera_debugfs_init(gcam);
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);
1318 greybus_set_drvdata(bundle, gcam);
1320 gb_pm_runtime_put_autosuspend(gcam->bundle);
1325 gb_camera_cleanup(gcam);
1330 static void gb_camera_disconnect(struct gb_bundle *bundle)
1332 struct gb_camera *gcam = greybus_get_drvdata(bundle);
1335 ret = gb_pm_runtime_get_sync(bundle);
1337 gb_pm_runtime_get_noresume(bundle);
1339 gb_camera_cleanup(gcam);
1340 gb_camera_unregister(&gcam->module);
1343 static const struct greybus_bundle_id gb_camera_id_table[] = {
1344 { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_CAMERA) },
1349 static int gb_camera_suspend(struct device *dev)
1351 struct gb_bundle *bundle = to_gb_bundle(dev);
1352 struct gb_camera *gcam = greybus_get_drvdata(bundle);
1354 if (gcam->data_connection)
1355 gb_connection_disable(gcam->data_connection);
1357 gb_connection_disable(gcam->connection);
1362 static int gb_camera_resume(struct device *dev)
1364 struct gb_bundle *bundle = to_gb_bundle(dev);
1365 struct gb_camera *gcam = greybus_get_drvdata(bundle);
1368 ret = gb_connection_enable(gcam->connection);
1370 gcam_err(gcam, "failed to enable connection: %d\n", ret);
1374 if (gcam->data_connection) {
1375 ret = gb_connection_enable(gcam->data_connection);
1378 "failed to enable data connection: %d\n", ret);
1387 static const struct dev_pm_ops gb_camera_pm_ops = {
1388 SET_RUNTIME_PM_OPS(gb_camera_suspend, gb_camera_resume, NULL)
1391 static struct greybus_driver gb_camera_driver = {
1393 .probe = gb_camera_probe,
1394 .disconnect = gb_camera_disconnect,
1395 .id_table = gb_camera_id_table,
1396 .driver.pm = &gb_camera_pm_ops,
1399 module_greybus_driver(gb_camera_driver);
1401 MODULE_LICENSE("GPL v2");