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
{
37 * struct gb_camera - A Greybus Camera Device
38 * @connection: the greybus connection for camera control
39 * @data_connected: whether the data connection has been established
40 * @debugfs: debugfs entries for camera protocol operations testing
43 struct gb_connection
*connection
;
48 struct gb_camera_debugfs_buffer
*buffers
;
52 struct gb_camera_stream_config
{
58 unsigned int max_size
;
61 struct gb_camera_fmt_map
{
62 enum v4l2_mbus_pixelcode mbus_code
;
63 unsigned int gb_format
;
66 /* GB format to media code map */
67 static const struct gb_camera_fmt_map mbus_to_gbus_format
[] = {
69 .mbus_code
= V4L2_MBUS_FMT_UYVY8_1X16
,
73 .mbus_code
= V4L2_MBUS_FMT_NV12_1x8
,
77 .mbus_code
= V4L2_MBUS_FMT_NV21_1x8
,
81 .mbus_code
= V4L2_MBUS_FMT_YU12_1x8
,
85 .mbus_code
= V4L2_MBUS_FMT_YV12_1x8
,
89 .mbus_code
= V4L2_MBUS_FMT_JPEG_1X8
,
94 #define ES2_APB_CDSI0_CPORT 16
95 #define ES2_APB_CDSI1_CPORT 17
97 #define GB_CAMERA_MAX_SETTINGS_SIZE 8192
99 #define gcam_dbg(gcam, format...) \
100 dev_dbg(&gcam->connection->bundle->dev, format)
101 #define gcam_info(gcam, format...) \
102 dev_info(&gcam->connection->bundle->dev, format)
103 #define gcam_err(gcam, format...) \
104 dev_err(&gcam->connection->bundle->dev, format)
106 /* -----------------------------------------------------------------------------
107 * Camera Protocol Operations
110 struct ap_csi_config_request
{
118 static int gb_camera_configure_streams(struct gb_camera
*gcam
,
119 unsigned int *num_streams
,
121 struct gb_camera_stream_config
*streams
)
123 struct gb_interface
*intf
= gcam
->connection
->intf
;
124 struct gb_svc
*svc
= gcam
->connection
->hd
->svc
;
125 struct gb_camera_configure_streams_request
*req
;
126 struct gb_camera_configure_streams_response
*resp
;
127 struct ap_csi_config_request csi_cfg
;
129 unsigned int nstreams
= *num_streams
;
135 if (nstreams
> GB_CAMERA_MAX_STREAMS
)
138 req_size
= sizeof(*req
) + nstreams
* sizeof(req
->config
[0]);
139 resp_size
= sizeof(*resp
) + nstreams
* sizeof(resp
->config
[0]);
141 req
= kmalloc(req_size
, GFP_KERNEL
);
142 resp
= kmalloc(resp_size
, GFP_KERNEL
);
149 * Setup unipro link speed before actually issuing configuration
150 * to the camera module, to assure unipro network speed is set
151 * before CSI interfaces gets configured
153 if (nstreams
&& !(*flags
& GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY
)) {
154 ret
= gb_svc_intf_set_power_mode(svc
, intf
->interface_id
,
155 GB_SVC_UNIPRO_HS_SERIES_A
,
156 GB_SVC_UNIPRO_FAST_MODE
, 2, 2,
157 GB_SVC_UNIPRO_FAST_MODE
, 2, 2,
158 GB_SVC_PWRM_RXTERMINATION
|
159 GB_SVC_PWRM_TXTERMINATION
, 0);
163 ret
= gb_svc_intf_set_power_mode(svc
, svc
->ap_intf_id
,
164 GB_SVC_UNIPRO_HS_SERIES_A
,
165 GB_SVC_UNIPRO_FAST_MODE
, 2, 2,
166 GB_SVC_UNIPRO_FAST_MODE
, 2, 2,
167 GB_SVC_PWRM_RXTERMINATION
|
168 GB_SVC_PWRM_TXTERMINATION
, 0);
171 } else if (nstreams
== 0) {
172 ret
= gb_svc_intf_set_power_mode(svc
, intf
->interface_id
,
173 GB_SVC_UNIPRO_HS_SERIES_A
,
174 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
176 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
180 gcam_err(gcam
, "can't take camera link to PWM-G1 auto: %d\n",
185 ret
= gb_svc_intf_set_power_mode(svc
, svc
->ap_intf_id
,
186 GB_SVC_UNIPRO_HS_SERIES_A
,
187 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
189 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
193 gcam_err(gcam
, "can't take AP link to PWM-G1 auto: %d\n",
199 req
->num_streams
= nstreams
;
203 for (i
= 0; i
< nstreams
; ++i
) {
204 struct gb_camera_stream_config_request
*cfg
= &req
->config
[i
];
206 cfg
->width
= cpu_to_le16(streams
[i
].width
);
207 cfg
->height
= cpu_to_le16(streams
[i
].height
);
208 cfg
->format
= cpu_to_le16(streams
[i
].format
);
212 ret
= gb_operation_sync(gcam
->connection
,
213 GB_CAMERA_TYPE_CONFIGURE_STREAMS
,
214 req
, req_size
, resp
, resp_size
);
216 goto set_unipro_slow_mode
;
218 if (resp
->num_streams
> nstreams
) {
219 gcam_dbg(gcam
, "got #streams %u > request %u\n",
220 resp
->num_streams
, nstreams
);
222 goto set_unipro_slow_mode
;
225 if (resp
->padding
!= 0) {
226 gcam_dbg(gcam
, "response padding != 0");
228 goto set_unipro_slow_mode
;
231 for (i
= 0; i
< nstreams
; ++i
) {
232 struct gb_camera_stream_config_response
*cfg
= &resp
->config
[i
];
234 streams
[i
].width
= le16_to_cpu(cfg
->width
);
235 streams
[i
].height
= le16_to_cpu(cfg
->height
);
236 streams
[i
].format
= le16_to_cpu(cfg
->format
);
237 streams
[i
].vc
= cfg
->virtual_channel
;
238 streams
[i
].dt
[0] = cfg
->data_type
[0];
239 streams
[i
].dt
[1] = cfg
->data_type
[1];
240 streams
[i
].max_size
= le32_to_cpu(cfg
->max_size
);
242 if (cfg
->padding
[0] || cfg
->padding
[1] || cfg
->padding
[2]) {
243 gcam_dbg(gcam
, "stream #%u padding != 0", i
);
245 goto set_unipro_slow_mode
;
249 if (nstreams
&& resp
->flags
& GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED
) {
250 *flags
= resp
->flags
;
251 *num_streams
= resp
->num_streams
;
252 goto set_unipro_slow_mode
;
255 memset(&csi_cfg
, 0, sizeof(csi_cfg
));
257 /* Configure the CSI transmitter. Hardcode the parameters for now. */
260 csi_cfg
.clock_mode
= 0;
261 csi_cfg
.num_lanes
= 4;
262 csi_cfg
.bus_freq
= cpu_to_le32(960000000);
263 ret
= gb_hd_output(gcam
->connection
->hd
, &csi_cfg
,
265 GB_APB_REQUEST_CSI_TX_CONTROL
, false);
268 ret
= gb_hd_output(gcam
->connection
->hd
, &csi_cfg
,
270 GB_APB_REQUEST_CSI_TX_CONTROL
, false);
274 gcam_err(gcam
, "failed to %s the CSI transmitter\n",
275 nstreams
? "start" : "stop");
277 *flags
= resp
->flags
;
278 *num_streams
= resp
->num_streams
;
285 set_unipro_slow_mode
:
286 ret
= gb_svc_intf_set_power_mode(svc
, intf
->interface_id
,
287 GB_SVC_UNIPRO_HS_SERIES_A
,
288 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
290 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
294 gcam_err(gcam
, "can't take camera link to PWM-G1 auto: %d\n",
299 ret
= gb_svc_intf_set_power_mode(svc
, svc
->ap_intf_id
,
300 GB_SVC_UNIPRO_HS_SERIES_A
,
301 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
303 GB_SVC_UNIPRO_SLOW_AUTO_MODE
,
307 gcam_err(gcam
, "can't take AP link to PWM-G1 auto: %d\n",
316 static int gb_camera_capture(struct gb_camera
*gcam
, u32 request_id
,
317 unsigned int streams
, unsigned int num_frames
,
318 size_t settings_size
, const void *settings
)
320 struct gb_camera_capture_request
*req
;
324 if (settings_size
> GB_CAMERA_MAX_SETTINGS_SIZE
)
327 req_size
= sizeof(*req
) + settings_size
;
328 req
= kmalloc(req_size
, GFP_KERNEL
);
332 req
->request_id
= cpu_to_le32(request_id
);
333 req
->streams
= streams
;
335 req
->num_frames
= cpu_to_le16(num_frames
);
336 memcpy(req
->settings
, settings
, settings_size
);
338 ret
= gb_operation_sync(gcam
->connection
, GB_CAMERA_TYPE_CAPTURE
,
339 req
, req_size
, NULL
, 0);
346 static int gb_camera_flush(struct gb_camera
*gcam
, u32
*request_id
)
348 struct gb_camera_flush_response resp
;
351 ret
= gb_operation_sync(gcam
->connection
, GB_CAMERA_TYPE_FLUSH
, NULL
, 0,
352 &resp
, sizeof(resp
));
357 *request_id
= le32_to_cpu(resp
.request_id
);
362 static int gb_camera_event_recv(u8 type
, struct gb_operation
*op
)
364 struct gb_camera
*gcam
= op
->connection
->private;
365 struct gb_camera_metadata_request
*payload
;
366 struct gb_message
*request
;
368 if (type
!= GB_CAMERA_TYPE_METADATA
) {
369 gcam_err(gcam
, "Unsupported unsolicited event: %u\n", type
);
373 request
= op
->request
;
375 if (request
->payload_size
< sizeof(*payload
)) {
376 gcam_err(gcam
, "Wrong event size received (%zu < %zu)\n",
377 request
->payload_size
, sizeof(*payload
));
381 payload
= request
->payload
;
383 gcam_dbg(gcam
, "received metadata for request %u, frame %u, stream %u\n",
384 payload
->request_id
, payload
->frame_number
, payload
->stream
);
389 /* -----------------------------------------------------------------------------
390 * Interface with HOST ara camera.
392 static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code
)
396 for (i
= 0; i
< ARRAY_SIZE(mbus_to_gbus_format
); i
++) {
397 if (mbus_to_gbus_format
[i
].mbus_code
== mbus_code
)
398 return mbus_to_gbus_format
[i
].gb_format
;
400 return mbus_to_gbus_format
[0].gb_format
;
403 static enum v4l2_mbus_pixelcode
gb_camera_gb_to_mbus(u16 gb_fmt
)
407 for (i
= 0; i
< ARRAY_SIZE(mbus_to_gbus_format
); i
++) {
408 if (mbus_to_gbus_format
[i
].gb_format
== gb_fmt
)
409 return mbus_to_gbus_format
[i
].mbus_code
;
411 return mbus_to_gbus_format
[0].mbus_code
;
414 static int gb_camera_op_configure_streams(void *priv
, unsigned int *nstreams
,
415 unsigned int *flags
, struct gb_camera_stream
*streams
)
417 struct gb_camera
*gcam
= priv
;
418 struct gb_camera_stream_config
*gb_streams
;
419 unsigned int gb_flags
= 0;
420 unsigned int gb_nstreams
= *nstreams
;
424 if (gb_nstreams
> GB_CAMERA_MAX_STREAMS
)
427 gb_streams
= kzalloc(gb_nstreams
* sizeof(*gb_streams
), GFP_KERNEL
);
431 for (i
= 0; i
< gb_nstreams
; i
++) {
432 gb_streams
[i
].width
= streams
[i
].width
;
433 gb_streams
[i
].height
= streams
[i
].height
;
434 gb_streams
[i
].format
=
435 gb_camera_mbus_to_gb(streams
[i
].pixel_code
);
438 if (*flags
& GB_CAMERA_IN_FLAG_TEST
)
439 gb_flags
|= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY
;
441 ret
= gb_camera_configure_streams(gcam
, &gb_nstreams
,
442 &gb_flags
, gb_streams
);
445 if (gb_nstreams
> *nstreams
) {
451 if (gb_flags
& GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED
)
452 *flags
|= GB_CAMERA_OUT_FLAG_ADJUSTED
;
454 for (i
= 0; i
< gb_nstreams
; i
++) {
455 streams
[i
].width
= gb_streams
[i
].width
;
456 streams
[i
].height
= gb_streams
[i
].height
;
457 streams
[i
].vc
= gb_streams
[i
].vc
;
458 streams
[i
].dt
[0] = gb_streams
[i
].dt
[0];
459 streams
[i
].dt
[1] = gb_streams
[i
].dt
[1];
460 streams
[i
].max_size
= gb_streams
[i
].max_size
;
461 streams
[i
].pixel_code
=
462 gb_camera_gb_to_mbus(gb_streams
[i
].format
);
464 *nstreams
= gb_nstreams
;
471 static int gb_camera_op_capture(void *priv
, u32 request_id
,
472 unsigned int streams
, unsigned int num_frames
,
473 size_t settings_size
, const void *settings
)
475 return gb_camera_capture(priv
, request_id
, streams
, num_frames
,
476 settings_size
, settings
);
479 static int gb_camera_op_flush(void *priv
, u32
*request_id
)
481 return gb_camera_flush(priv
, request_id
);
484 struct gb_camera_ops gb_cam_ops
= {
485 .configure_streams
= gb_camera_op_configure_streams
,
486 .capture
= gb_camera_op_capture
,
487 .flush
= gb_camera_op_flush
,
490 static int gb_camera_register_intf_ops(struct gb_camera
*gcam
)
492 return gb_camera_register(&gb_cam_ops
, gcam
);
495 /* -----------------------------------------------------------------------------
498 static ssize_t
gb_camera_debugfs_capabilities(struct gb_camera
*gcam
,
499 char *buf
, size_t len
)
504 static ssize_t
gb_camera_debugfs_configure_streams(struct gb_camera
*gcam
,
505 char *buf
, size_t len
)
507 struct gb_camera_debugfs_buffer
*buffer
=
508 &gcam
->debugfs
.buffers
[GB_CAMERA_DEBUGFS_BUFFER_STREAMS
];
509 struct gb_camera_stream_config
*streams
;
510 unsigned int nstreams
;
516 /* Retrieve number of streams to configure */
517 token
= strsep(&buf
, ";");
521 ret
= kstrtouint(token
, 10, &nstreams
);
525 if (nstreams
> GB_CAMERA_MAX_STREAMS
)
528 token
= strsep(&buf
, ";");
532 ret
= kstrtouint(token
, 10, &flags
);
536 /* For each stream to configure parse width, height and format */
537 streams
= kzalloc(nstreams
* sizeof(*streams
), GFP_KERNEL
);
541 for (i
= 0; i
< nstreams
; ++i
) {
542 struct gb_camera_stream_config
*stream
= &streams
[i
];
545 token
= strsep(&buf
, ";");
550 ret
= kstrtouint(token
, 10, &stream
->width
);
555 token
= strsep(&buf
, ";");
559 ret
= kstrtouint(token
, 10, &stream
->height
);
563 /* Image format code */
564 token
= strsep(&buf
, ";");
568 ret
= kstrtouint(token
, 16, &stream
->format
);
573 ret
= gb_camera_configure_streams(gcam
, &nstreams
, &flags
, streams
);
577 buffer
->length
= sprintf(buffer
->data
, "%u;%u;", nstreams
, flags
);
579 for (i
= 0; i
< nstreams
; ++i
) {
580 struct gb_camera_stream_config
*stream
= &streams
[i
];
582 buffer
->length
+= sprintf(buffer
->data
+ buffer
->length
,
583 "%u;%u;%u;%u;%u;%u;%u;",
584 stream
->width
, stream
->height
,
585 stream
->format
, stream
->vc
,
586 stream
->dt
[0], stream
->dt
[1],
597 static ssize_t
gb_camera_debugfs_capture(struct gb_camera
*gcam
,
598 char *buf
, size_t len
)
600 unsigned int request_id
;
601 unsigned int streams_mask
;
602 unsigned int num_frames
;
607 token
= strsep(&buf
, ";");
610 ret
= kstrtouint(token
, 10, &request_id
);
615 token
= strsep(&buf
, ";");
618 ret
= kstrtouint(token
, 16, &streams_mask
);
622 /* number of frames */
623 token
= strsep(&buf
, ";");
626 ret
= kstrtouint(token
, 10, &num_frames
);
630 ret
= gb_camera_capture(gcam
, request_id
, streams_mask
, num_frames
, 0,
638 static ssize_t
gb_camera_debugfs_flush(struct gb_camera
*gcam
,
639 char *buf
, size_t len
)
641 struct gb_camera_debugfs_buffer
*buffer
=
642 &gcam
->debugfs
.buffers
[GB_CAMERA_DEBUGFS_BUFFER_FLUSH
];
646 ret
= gb_camera_flush(gcam
, &req_id
);
650 buffer
->length
= sprintf(buffer
->data
, "%u", req_id
);
655 struct gb_camera_debugfs_entry
{
659 ssize_t (*execute
)(struct gb_camera
*gcam
, char *buf
, size_t len
);
662 static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries
[] = {
664 .name
= "capabilities",
665 .mask
= S_IFREG
| S_IRUGO
,
666 .buffer
= GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES
,
667 .execute
= gb_camera_debugfs_capabilities
,
669 .name
= "configure_streams",
670 .mask
= S_IFREG
| S_IRUGO
| S_IWUGO
,
671 .buffer
= GB_CAMERA_DEBUGFS_BUFFER_STREAMS
,
672 .execute
= gb_camera_debugfs_configure_streams
,
675 .mask
= S_IFREG
| S_IRUGO
| S_IWUGO
,
676 .buffer
= GB_CAMERA_DEBUGFS_BUFFER_CAPTURE
,
677 .execute
= gb_camera_debugfs_capture
,
680 .mask
= S_IFREG
| S_IRUGO
| S_IWUGO
,
681 .buffer
= GB_CAMERA_DEBUGFS_BUFFER_FLUSH
,
682 .execute
= gb_camera_debugfs_flush
,
686 static ssize_t
gb_camera_debugfs_read(struct file
*file
, char __user
*buf
,
687 size_t len
, loff_t
*offset
)
689 const struct gb_camera_debugfs_entry
*op
= file
->private_data
;
690 struct gb_camera
*gcam
= file
->f_inode
->i_private
;
691 struct gb_camera_debugfs_buffer
*buffer
;
694 /* For read-only entries the operation is triggered by a read. */
695 if (!(op
->mask
& S_IWUGO
)) {
696 ret
= op
->execute(gcam
, NULL
, 0);
701 buffer
= &gcam
->debugfs
.buffers
[op
->buffer
];
703 return simple_read_from_buffer(buf
, len
, offset
, buffer
->data
,
707 static ssize_t
gb_camera_debugfs_write(struct file
*file
,
708 const char __user
*buf
, size_t len
,
711 const struct gb_camera_debugfs_entry
*op
= file
->private_data
;
712 struct gb_camera
*gcam
= file
->f_inode
->i_private
;
719 kbuf
= kmalloc(len
+ 1, GFP_KERNEL
);
723 if (copy_from_user(kbuf
, buf
, len
)) {
730 ret
= op
->execute(gcam
, kbuf
, len
);
737 static int gb_camera_debugfs_open(struct inode
*inode
, struct file
*file
)
741 for (i
= 0; i
< ARRAY_SIZE(gb_camera_debugfs_entries
); ++i
) {
742 const struct gb_camera_debugfs_entry
*entry
=
743 &gb_camera_debugfs_entries
[i
];
745 if (!strcmp(file
->f_path
.dentry
->d_iname
, entry
->name
)) {
746 file
->private_data
= (void *)entry
;
754 static const struct file_operations gb_camera_debugfs_ops
= {
755 .open
= gb_camera_debugfs_open
,
756 .read
= gb_camera_debugfs_read
,
757 .write
= gb_camera_debugfs_write
,
760 static int gb_camera_debugfs_init(struct gb_camera
*gcam
)
762 struct gb_connection
*connection
= gcam
->connection
;
767 * Create root debugfs entry and a file entry for each camera operation.
769 snprintf(dirname
, 27, "camera-%u.%u", connection
->intf
->interface_id
,
770 connection
->bundle
->id
);
772 gcam
->debugfs
.root
= debugfs_create_dir(dirname
, gb_debugfs_get());
773 if (IS_ERR(gcam
->debugfs
.root
)) {
774 gcam_err(gcam
, "debugfs root create failed (%ld)\n",
775 PTR_ERR(gcam
->debugfs
.root
));
776 return PTR_ERR(gcam
->debugfs
.root
);
779 gcam
->debugfs
.buffers
= vmalloc(sizeof(*gcam
->debugfs
.buffers
) *
780 GB_CAMERA_DEBUGFS_BUFFER_MAX
);
781 if (!gcam
->debugfs
.buffers
)
784 for (i
= 0; i
< ARRAY_SIZE(gb_camera_debugfs_entries
); ++i
) {
785 const struct gb_camera_debugfs_entry
*entry
=
786 &gb_camera_debugfs_entries
[i
];
787 struct dentry
*dentry
;
789 gcam
->debugfs
.buffers
[i
].length
= 0;
791 dentry
= debugfs_create_file(entry
->name
, entry
->mask
,
792 gcam
->debugfs
.root
, gcam
,
793 &gb_camera_debugfs_ops
);
794 if (IS_ERR(dentry
)) {
796 "debugfs operation %s create failed (%ld)\n",
797 entry
->name
, PTR_ERR(gcam
->debugfs
.root
));
798 return PTR_ERR(dentry
);
805 static void gb_camera_debugfs_cleanup(struct gb_camera
*gcam
)
807 if (gcam
->debugfs
.root
)
808 debugfs_remove_recursive(gcam
->debugfs
.root
);
810 vfree(gcam
->debugfs
.buffers
);
813 /* -----------------------------------------------------------------------------
817 static void gb_camera_cleanup(struct gb_camera
*gcam
)
819 gb_camera_debugfs_cleanup(gcam
);
821 if (gcam
->data_connected
) {
822 struct gb_interface
*intf
= gcam
->connection
->intf
;
823 struct gb_svc
*svc
= gcam
->connection
->hd
->svc
;
825 gb_svc_connection_destroy(svc
, intf
->interface_id
,
826 ES2_APB_CDSI0_CPORT
, svc
->ap_intf_id
,
827 ES2_APB_CDSI1_CPORT
);
833 static int gb_camera_connection_init(struct gb_connection
*connection
)
835 struct gb_svc
*svc
= connection
->hd
->svc
;
836 struct gb_camera
*gcam
;
839 gcam
= kzalloc(sizeof(*gcam
), GFP_KERNEL
);
843 gcam
->connection
= connection
;
844 connection
->private = gcam
;
847 * Create the data connection between camera module CDSI0 and APB CDS1.
848 * The CPort IDs are hardcoded by the ES2 bridges.
850 ret
= gb_svc_connection_create(svc
, connection
->intf
->interface_id
,
851 ES2_APB_CDSI0_CPORT
, svc
->ap_intf_id
,
852 ES2_APB_CDSI1_CPORT
, false);
856 gcam
->data_connected
= true;
858 ret
= gb_camera_debugfs_init(gcam
);
862 ret
= gb_camera_register_intf_ops(gcam
);
869 gb_camera_cleanup(gcam
);
873 static void gb_camera_connection_exit(struct gb_connection
*connection
)
875 struct gb_camera
*gcam
= connection
->private;
877 gb_camera_cleanup(gcam
);
880 static struct gb_protocol camera_protocol
= {
882 .id
= GREYBUS_PROTOCOL_CAMERA_MGMT
,
883 .major
= GB_CAMERA_VERSION_MAJOR
,
884 .minor
= GB_CAMERA_VERSION_MINOR
,
885 .connection_init
= gb_camera_connection_init
,
886 .connection_exit
= gb_camera_connection_exit
,
887 .request_recv
= gb_camera_event_recv
,
890 gb_protocol_driver(&camera_protocol
);
892 MODULE_LICENSE("GPL v2");