1
2
3
4
5
6
7
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
23enum 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
31struct gb_camera_debugfs_buffer {
32 char data[PAGE_SIZE];
33 size_t length;
34};
35
36enum gb_camera_state {
37 GB_CAMERA_STATE_UNCONFIGURED,
38 GB_CAMERA_STATE_CONFIGURED,
39};
40
41
42
43
44
45
46
47
48
49
50
51struct 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
68struct 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
77struct gb_camera_fmt_info {
78 enum v4l2_mbus_pixelcode mbus_code;
79 unsigned int gb_format;
80 unsigned int bpp;
81};
82
83
84static 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
167static 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
188static 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
223static 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
269
270
271static 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
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
304
305
306static 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
337static 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
361struct 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
373
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
381static 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
392
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
408 ret = gb_camera_set_power_mode(gcam, true);
409 if (ret < 0)
410 goto error_conn_disable;
411
412
413
414
415
416
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
451error_power:
452 gb_camera_set_power_mode(gcam, false);
453error_conn_disable:
454 gb_connection_disable(gcam->data_connection);
455error_conn_destroy:
456 gb_connection_destroy(gcam->data_connection);
457 gcam->data_connection = NULL;
458 return ret;
459}
460
461static void gb_camera_teardown_data_connection(struct gb_camera *gcam)
462{
463 struct ap_csi_config_request csi_cfg;
464 int ret;
465
466
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
478 gb_camera_set_power_mode(gcam, false);
479
480
481 gb_connection_disable(gcam->data_connection);
482 gb_connection_destroy(gcam->data_connection);
483 gcam->data_connection = NULL;
484}
485
486
487
488
489
490static 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
514done:
515 mutex_unlock(&gcam->mutex);
516
517 gb_pm_runtime_put_autosuspend(gcam->bundle);
518
519 return ret;
520}
521
522static 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
612
613
614
615
616
617 gb_pm_runtime_put_noidle(gcam->bundle);
618 }
619
620 if (resp->num_streams == 0)
621 goto done;
622
623
624
625
626
627 gb_pm_runtime_get_noresume(gcam->bundle);
628
629
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
645done:
646 gb_pm_runtime_put_autosuspend(gcam->bundle);
647
648done_skip_pm_put:
649 mutex_unlock(&gcam->mutex);
650 kfree(req);
651 kfree(resp);
652 return ret;
653}
654
655static 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);
686done:
687 mutex_unlock(&gcam->mutex);
688
689 kfree(req);
690
691 return ret;
692}
693
694static 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
715done:
716 mutex_unlock(&gcam->mutex);
717
718 return ret;
719}
720
721static 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
750
751static 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
762static 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
773static 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
786static 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
839done:
840 kfree(gb_streams);
841 return ret;
842}
843
844static 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
854static 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
861static 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
870
871
872static 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
892
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
903done:
904 kfree(caps);
905 return ret;
906}
907
908static 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
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
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
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
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
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
997done:
998 kfree(streams);
999 return ret;
1000};
1001
1002static 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
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
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
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
1043static 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
1060struct 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
1067static 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
1091static 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
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
1112static 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
1137done:
1138 kfree(kbuf);
1139 return ret;
1140}
1141
1142static 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
1159static 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
1165static 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
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
1210static 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
1219
1220
1221static 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
1240static 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
1247static 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
1259
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
1324error:
1325 gb_camera_cleanup(gcam);
1326 kfree(gcam);
1327 return ret;
1328}
1329
1330static 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
1343static const struct greybus_bundle_id gb_camera_id_table[] = {
1344 { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_CAMERA) },
1345 { },
1346};
1347
1348#ifdef CONFIG_PM
1349static 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
1362static 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
1387static const struct dev_pm_ops gb_camera_pm_ops = {
1388 SET_RUNTIME_PM_OPS(gb_camera_suspend, gb_camera_resume, NULL)
1389};
1390
1391static 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
1399module_greybus_driver(gb_camera_driver);
1400
1401MODULE_LICENSE("GPL v2");
1402
