?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sch_tbf: fix two null pointer dereferences on init failure
[linux-2.6/btrfs-unstable.git] / drivers / staging / greybus / camera.c
bloba64517eabff4cd146cb89d139aa3988e3a7409ef
1 /*
2 * Greybus Camera protocol driver.
3 *
4 * Copyright 2015 Google Inc.
5 * Copyright 2015 Linaro Ltd.
6 *
7 * Released under the GPLv2 only.
8 */
9
10 #include <linux/debugfs.h>
11 #include <linux/fs.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16 #include <linux/uaccess.h>
17 #include <linux/vmalloc.h>
18
19 #include "gb-camera.h"
20 #include "greybus.h"
21 #include "greybus_protocols.h"
22
23 enum gb_camera_debugs_buffer_id {
24 GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
25 GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
26 GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
27 GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
28 GB_CAMERA_DEBUGFS_BUFFER_MAX,
29 };
30
31 struct gb_camera_debugfs_buffer {
32 char data[PAGE_SIZE];
33 size_t length;
34 };
35
36 enum gb_camera_state {
37 GB_CAMERA_STATE_UNCONFIGURED,
38 GB_CAMERA_STATE_CONFIGURED,
39 };
40
41 /**
42 * struct gb_camera - A Greybus Camera Device
43 * @connection: the greybus connection for camera management
44 * @data_connection: the greybus connection for camera data
45 * @data_cport_id: the data CPort ID on the module side
46 * @mutex: protects the connection and state fields
47 * @state: the current module state
48 * @debugfs: debugfs entries for camera protocol operations testing
49 * @module: Greybus camera module registered to HOST processor.
50 */
51 struct gb_camera {
52 struct gb_bundle *bundle;
53 struct gb_connection *connection;
54 struct gb_connection *data_connection;
55 u16 data_cport_id;
56
57 struct mutex mutex;
58 enum gb_camera_state state;
59
60 struct {
61 struct dentry *root;
62 struct gb_camera_debugfs_buffer *buffers;
63 } debugfs;
64
65 struct gb_camera_module module;
66 };
67
68 struct gb_camera_stream_config {
69 unsigned int width;
70 unsigned int height;
71 unsigned int format;
72 unsigned int vc;
73 unsigned int dt[2];
74 unsigned int max_size;
75 };
76
77 struct gb_camera_fmt_info {
78 enum v4l2_mbus_pixelcode mbus_code;
79 unsigned int gb_format;
80 unsigned int bpp;
81 };
82
83 /* GB format to media code map */
84 static const struct gb_camera_fmt_info gb_fmt_info[] = {
85 {
86 .mbus_code = V4L2_MBUS_FMT_UYVY8_1X16,
87 .gb_format = 0x01,
88 .bpp = 16,
89 },
90 {
91 .mbus_code = V4L2_MBUS_FMT_NV12_1x8,
92 .gb_format = 0x12,
93 .bpp = 12,
94 },
95 {
96 .mbus_code = V4L2_MBUS_FMT_NV21_1x8,
97 .gb_format = 0x13,
98 .bpp = 12,
99 },
100 {
101 .mbus_code = V4L2_MBUS_FMT_YU12_1x8,
102 .gb_format = 0x16,
103 .bpp = 12,
104 },
105 {
106 .mbus_code = V4L2_MBUS_FMT_YV12_1x8,
107 .gb_format = 0x17,
108 .bpp = 12,
109 },
110 {
111 .mbus_code = V4L2_MBUS_FMT_JPEG_1X8,
112 .gb_format = 0x40,
113 .bpp = 0,
114 },
115 {
116 .mbus_code = V4L2_MBUS_FMT_GB_CAM_METADATA_1X8,
117 .gb_format = 0x41,
118 .bpp = 0,
119 },
120 {
121 .mbus_code = V4L2_MBUS_FMT_GB_CAM_DEBUG_DATA_1X8,
122 .gb_format = 0x42,
123 .bpp = 0,
124 },
125 {
126 .mbus_code = V4L2_MBUS_FMT_SBGGR10_1X10,
127 .gb_format = 0x80,
128 .bpp = 10,
129 },
130 {
131 .mbus_code = V4L2_MBUS_FMT_SGBRG10_1X10,
132 .gb_format = 0x81,
133 .bpp = 10,
134 },
135 {
136 .mbus_code = V4L2_MBUS_FMT_SGRBG10_1X10,
137 .gb_format = 0x82,
138 .bpp = 10,
139 },
140 {
141 .mbus_code = V4L2_MBUS_FMT_SRGGB10_1X10,
142 .gb_format = 0x83,
143 .bpp = 10,
144 },
145 {
146 .mbus_code = V4L2_MBUS_FMT_SBGGR12_1X12,
147 .gb_format = 0x84,
148 .bpp = 12,
149 },
150 {
151 .mbus_code = V4L2_MBUS_FMT_SGBRG12_1X12,
152 .gb_format = 0x85,
153 .bpp = 12,
154 },
155 {
156 .mbus_code = V4L2_MBUS_FMT_SGRBG12_1X12,
157 .gb_format = 0x86,
158 .bpp = 12,
159 },
160 {
161 .mbus_code = V4L2_MBUS_FMT_SRGGB12_1X12,
162 .gb_format = 0x87,
163 .bpp = 12,
164 },
165 };
166
167 static const struct gb_camera_fmt_info *gb_camera_get_format_info(u16 gb_fmt)
168 {
169 unsigned int i;
170
171 for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
172 if (gb_fmt_info[i].gb_format == gb_fmt)
173 return &gb_fmt_info[i];
174 }
175
176 return NULL;
177 }
178
179 #define ES2_APB_CDSI0_CPORT 16
180 #define ES2_APB_CDSI1_CPORT 17
181
182 #define GB_CAMERA_MAX_SETTINGS_SIZE 8192
183
184 #define gcam_dbg(gcam, format...) dev_dbg(&gcam->bundle->dev, format)
185 #define gcam_info(gcam, format...) dev_info(&gcam->bundle->dev, format)
186 #define gcam_err(gcam, format...) dev_err(&gcam->bundle->dev, format)
187
188 static int gb_camera_operation_sync_flags(struct gb_connection *connection,
189 int type, unsigned int flags,
190 void *request, size_t request_size,
191 void *response, size_t *response_size)
192 {
193 struct gb_operation *operation;
194 int ret;
195
196 operation = gb_operation_create_flags(connection, type, request_size,
197 *response_size, flags,
198 GFP_KERNEL);
199 if (!operation)
200 return -ENOMEM;
201
202 if (request_size)
203 memcpy(operation->request->payload, request, request_size);
204
205 ret = gb_operation_request_send_sync(operation);
206 if (ret) {
207 dev_err(&connection->hd->dev,
208 "%s: synchronous operation of type 0x%02x failed: %d\n",
209 connection->name, type, ret);
210 } else {
211 *response_size = operation->response->payload_size;
212
213 if (operation->response->payload_size)
214 memcpy(response, operation->response->payload,
215 operation->response->payload_size);
216 }
217
218 gb_operation_put(operation);
219
220 return ret;
221 }
222
223 static int gb_camera_get_max_pkt_size(struct gb_camera *gcam,
224 struct gb_camera_configure_streams_response *resp)
225 {
226 unsigned int max_pkt_size = 0;
227 unsigned int i;
228
229 for (i = 0; i < resp->num_streams; i++) {
230 struct gb_camera_stream_config_response *cfg = &resp->config[i];
231 const struct gb_camera_fmt_info *fmt_info;
232 unsigned int pkt_size;
233
234 fmt_info = gb_camera_get_format_info(cfg->format);
235 if (!fmt_info) {
236 gcam_err(gcam, "unsupported greybus image format: %d\n",
237 cfg->format);
238 return -EIO;
239 }
240
241 if (fmt_info->bpp == 0) {
242 pkt_size = le32_to_cpu(cfg->max_pkt_size);
243
244 if (pkt_size == 0) {
245 gcam_err(gcam,
246 "Stream %u: invalid zero maximum packet size\n",
247 i);
248 return -EIO;
249 }
250 } else {
251 pkt_size = le16_to_cpu(cfg->width) * fmt_info->bpp / 8;
252
253 if (pkt_size != le32_to_cpu(cfg->max_pkt_size)) {
254 gcam_err(gcam,
255 "Stream %u: maximum packet size mismatch (%u/%u)\n",
256 i, pkt_size, cfg->max_pkt_size);
257 return -EIO;
258 }
259 }
260
261 max_pkt_size = max(pkt_size, max_pkt_size);
262 }
263
264 return max_pkt_size;
265 }
266
267 /*
268 * Validate the stream configuration response verifying padding is correctly
269 * set and the returned number of streams is supported
270 */
271 static const int gb_camera_configure_streams_validate_response(
272 struct gb_camera *gcam,
273 struct gb_camera_configure_streams_response *resp,
274 unsigned int nstreams)
275 {
276 unsigned int i;
277
278 /* Validate the returned response structure */
279 if (resp->padding[0] || resp->padding[1]) {
280 gcam_err(gcam, "response padding != 0\n");
281 return -EIO;
282 }
283
284 if (resp->num_streams > nstreams) {
285 gcam_err(gcam, "got #streams %u > request %u\n",
286 resp->num_streams, nstreams);
287 return -EIO;
288 }
289
290 for (i = 0; i < resp->num_streams; i++) {
291 struct gb_camera_stream_config_response *cfg = &resp->config[i];
292
293 if (cfg->padding) {
294 gcam_err(gcam, "stream #%u padding != 0\n", i);
295 return -EIO;
296 }
297 }
298
299 return 0;
300 }
301
302 /* -----------------------------------------------------------------------------
303 * Hardware Configuration
304 */
305
306 static int gb_camera_set_intf_power_mode(struct gb_camera *gcam, u8 intf_id,
307 bool hs)
308 {
309 struct gb_svc *svc = gcam->connection->hd->svc;
310 int ret;
311
312 if (hs)
313 ret = gb_svc_intf_set_power_mode(svc, intf_id,
314 GB_SVC_UNIPRO_HS_SERIES_A,
315 GB_SVC_UNIPRO_FAST_MODE, 2, 2,
316 GB_SVC_SMALL_AMPLITUDE,
317 GB_SVC_NO_DE_EMPHASIS,
318 GB_SVC_UNIPRO_FAST_MODE, 2, 2,
319 GB_SVC_PWRM_RXTERMINATION |
320 GB_SVC_PWRM_TXTERMINATION, 0,
321 NULL, NULL);
322 else
323 ret = gb_svc_intf_set_power_mode(svc, intf_id,
324 GB_SVC_UNIPRO_HS_SERIES_A,
325 GB_SVC_UNIPRO_SLOW_AUTO_MODE,
326 2, 1,
327 GB_SVC_SMALL_AMPLITUDE,
328 GB_SVC_NO_DE_EMPHASIS,
329 GB_SVC_UNIPRO_SLOW_AUTO_MODE,
330 2, 1,
331 0, 0,
332 NULL, NULL);
333
334 return ret;
335 }
336
337 static int gb_camera_set_power_mode(struct gb_camera *gcam, bool hs)
338 {
339 struct gb_interface *intf = gcam->connection->intf;
340 struct gb_svc *svc = gcam->connection->hd->svc;
341 int ret;
342
343 ret = gb_camera_set_intf_power_mode(gcam, intf->interface_id, hs);
344 if (ret < 0) {
345 gcam_err(gcam, "failed to set module interface to %s (%d)\n",
346 hs ? "HS" : "PWM", ret);
347 return ret;
348 }
349
350 ret = gb_camera_set_intf_power_mode(gcam, svc->ap_intf_id, hs);
351 if (ret < 0) {
352 gb_camera_set_intf_power_mode(gcam, intf->interface_id, !hs);
353 gcam_err(gcam, "failed to set AP interface to %s (%d)\n",
354 hs ? "HS" : "PWM", ret);
355 return ret;
356 }
357
358 return 0;
359 }
360
361 struct ap_csi_config_request {
362 __u8 csi_id;
363 __u8 flags;
364 #define GB_CAMERA_CSI_FLAG_CLOCK_CONTINUOUS 0x01
365 __u8 num_lanes;
366 __u8 padding;
367 __le32 csi_clk_freq;
368 __le32 max_pkt_size;
369 } __packed;
370
371 /*
372 * TODO: Compute the number of lanes dynamically based on bandwidth
373 * requirements.
374 */
375 #define GB_CAMERA_CSI_NUM_DATA_LANES 4
376
377 #define GB_CAMERA_CSI_CLK_FREQ_MAX 999000000U
378 #define GB_CAMERA_CSI_CLK_FREQ_MIN 100000000U
379 #define GB_CAMERA_CSI_CLK_FREQ_MARGIN 150000000U
380
381 static int gb_camera_setup_data_connection(struct gb_camera *gcam,
382 struct gb_camera_configure_streams_response *resp,
383 struct gb_camera_csi_params *csi_params)
384 {
385 struct ap_csi_config_request csi_cfg;
386 struct gb_connection *conn;
387 unsigned int clk_freq;
388 int ret;
389
390 /*
391 * Create the data connection between the camera module data CPort and
392 * APB CDSI1. The CDSI1 CPort ID is hardcoded by the ES2 bridge.
393 */
394 conn = gb_connection_create_offloaded(gcam->bundle, gcam->data_cport_id,
395 GB_CONNECTION_FLAG_NO_FLOWCTRL |
396 GB_CONNECTION_FLAG_CDSI1);
397 if (IS_ERR(conn))
398 return PTR_ERR(conn);
399
400 gcam->data_connection = conn;
401 gb_connection_set_data(conn, gcam);
402
403 ret = gb_connection_enable(conn);
404 if (ret)
405 goto error_conn_destroy;
406
407 /* Set the UniPro link to high speed mode. */
408 ret = gb_camera_set_power_mode(gcam, true);
409 if (ret < 0)
410 goto error_conn_disable;
411
412 /*
413 * Configure the APB-A CSI-2 transmitter.
414 *
415 * Hardcode the number of lanes to 4 and compute the bus clock frequency
416 * based on the module bandwidth requirements with a safety margin.
417 */
418 memset(&csi_cfg, 0, sizeof(csi_cfg));
419 csi_cfg.csi_id = 1;
420 csi_cfg.flags = 0;
421 csi_cfg.num_lanes = GB_CAMERA_CSI_NUM_DATA_LANES;
422
423 clk_freq = resp->data_rate / 2 / GB_CAMERA_CSI_NUM_DATA_LANES;
424 clk_freq = clamp(clk_freq + GB_CAMERA_CSI_CLK_FREQ_MARGIN,
425 GB_CAMERA_CSI_CLK_FREQ_MIN,
426 GB_CAMERA_CSI_CLK_FREQ_MAX);
427 csi_cfg.csi_clk_freq = clk_freq;
428
429 ret = gb_camera_get_max_pkt_size(gcam, resp);
430 if (ret < 0) {
431 ret = -EIO;
432 goto error_power;
433 }
434 csi_cfg.max_pkt_size = ret;
435
436 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
437 sizeof(csi_cfg),
438 GB_APB_REQUEST_CSI_TX_CONTROL, false);
439 if (ret < 0) {
440 gcam_err(gcam, "failed to start the CSI transmitter\n");
441 goto error_power;
442 }
443
444 if (csi_params) {
445 csi_params->clk_freq = csi_cfg.csi_clk_freq;
446 csi_params->num_lanes = csi_cfg.num_lanes;
447 }
448
449 return 0;
450
451 error_power:
452 gb_camera_set_power_mode(gcam, false);
453 error_conn_disable:
454 gb_connection_disable(gcam->data_connection);
455 error_conn_destroy:
456 gb_connection_destroy(gcam->data_connection);
457 gcam->data_connection = NULL;
458 return ret;
459 }
460
461 static void gb_camera_teardown_data_connection(struct gb_camera *gcam)
462 {
463 struct ap_csi_config_request csi_cfg;
464 int ret;
465
466 /* Stop the APB1 CSI transmitter. */
467 memset(&csi_cfg, 0, sizeof(csi_cfg));
468 csi_cfg.csi_id = 1;
469
470 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
471 sizeof(csi_cfg),
472 GB_APB_REQUEST_CSI_TX_CONTROL, false);
473
474 if (ret < 0)
475 gcam_err(gcam, "failed to stop the CSI transmitter\n");
476
477 /* Set the UniPro link to low speed mode. */
478 gb_camera_set_power_mode(gcam, false);
479
480 /* Destroy the data connection. */
481 gb_connection_disable(gcam->data_connection);
482 gb_connection_destroy(gcam->data_connection);
483 gcam->data_connection = NULL;
484 }
485
486 /* -----------------------------------------------------------------------------
487 * Camera Protocol Operations
488 */
489
490 static int gb_camera_capabilities(struct gb_camera *gcam,
491 u8 *capabilities, size_t *size)
492 {
493 int ret;
494
495 ret = gb_pm_runtime_get_sync(gcam->bundle);
496 if (ret)
497 return ret;
498
499 mutex_lock(&gcam->mutex);
500
501 if (!gcam->connection) {
502 ret = -EINVAL;
503 goto done;
504 }
505
506 ret = gb_camera_operation_sync_flags(gcam->connection,
507 GB_CAMERA_TYPE_CAPABILITIES,
508 GB_OPERATION_FLAG_SHORT_RESPONSE,
509 NULL, 0,
510 (void *)capabilities, size);
511 if (ret)
512 gcam_err(gcam, "failed to retrieve capabilities: %d\n", ret);
513
514 done:
515 mutex_unlock(&gcam->mutex);
516
517 gb_pm_runtime_put_autosuspend(gcam->bundle);
518
519 return ret;
520 }
521
522 static int gb_camera_configure_streams(struct gb_camera *gcam,
523 unsigned int *num_streams,
524 unsigned int *flags,
525 struct gb_camera_stream_config *streams,
526 struct gb_camera_csi_params *csi_params)
527 {
528 struct gb_camera_configure_streams_request *req;
529 struct gb_camera_configure_streams_response *resp;
530 unsigned int nstreams = *num_streams;
531 unsigned int i;
532 size_t req_size;
533 size_t resp_size;
534 int ret;
535
536 if (nstreams > GB_CAMERA_MAX_STREAMS)
537 return -EINVAL;
538
539 req_size = sizeof(*req) + nstreams * sizeof(req->config[0]);
540 resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]);
541
542 req = kmalloc(req_size, GFP_KERNEL);
543 resp = kmalloc(resp_size, GFP_KERNEL);
544 if (!req || !resp) {
545 kfree(req);
546 kfree(resp);
547 return -ENOMEM;
548 }
549
550 req->num_streams = nstreams;
551 req->flags = *flags;
552 req->padding = 0;
553
554 for (i = 0; i < nstreams; ++i) {
555 struct gb_camera_stream_config_request *cfg = &req->config[i];
556
557 cfg->width = cpu_to_le16(streams[i].width);
558 cfg->height = cpu_to_le16(streams[i].height);
559 cfg->format = cpu_to_le16(streams[i].format);
560 cfg->padding = 0;
561 }
562
563 mutex_lock(&gcam->mutex);
564
565 ret = gb_pm_runtime_get_sync(gcam->bundle);
566 if (ret)
567 goto done_skip_pm_put;
568
569 if (!gcam->connection) {
570 ret = -EINVAL;
571 goto done;
572 }
573
574 ret = gb_camera_operation_sync_flags(gcam->connection,
575 GB_CAMERA_TYPE_CONFIGURE_STREAMS,
576 GB_OPERATION_FLAG_SHORT_RESPONSE,
577 req, req_size,
578 resp, &resp_size);
579 if (ret < 0)
580 goto done;
581
582 ret = gb_camera_configure_streams_validate_response(gcam, resp,
583 nstreams);
584 if (ret < 0)
585 goto done;
586
587 *flags = resp->flags;
588 *num_streams = resp->num_streams;
589
590 for (i = 0; i < resp->num_streams; ++i) {
591 struct gb_camera_stream_config_response *cfg = &resp->config[i];
592
593 streams[i].width = le16_to_cpu(cfg->width);
594 streams[i].height = le16_to_cpu(cfg->height);
595 streams[i].format = le16_to_cpu(cfg->format);
596 streams[i].vc = cfg->virtual_channel;
597 streams[i].dt[0] = cfg->data_type[0];
598 streams[i].dt[1] = cfg->data_type[1];
599 streams[i].max_size = le32_to_cpu(cfg->max_size);
600 }
601
602 if ((resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) ||
603 (req->flags & GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY))
604 goto done;
605
606 if (gcam->state == GB_CAMERA_STATE_CONFIGURED) {
607 gb_camera_teardown_data_connection(gcam);
608 gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
609
610 /*
611 * When unconfiguring streams release the PM runtime reference
612 * that was acquired when streams were configured. The bundle
613 * won't be suspended until the PM runtime reference acquired at
614 * the beginning of this function gets released right before
615 * returning.
616 */
617 gb_pm_runtime_put_noidle(gcam->bundle);
618 }
619
620 if (resp->num_streams == 0)
621 goto done;
622
623 /*
624 * Make sure the bundle won't be suspended until streams get
625 * unconfigured after the stream is configured successfully
626 */
627 gb_pm_runtime_get_noresume(gcam->bundle);
628
629 /* Setup CSI-2 connection from APB-A to AP */
630 ret = gb_camera_setup_data_connection(gcam, resp, csi_params);
631 if (ret < 0) {
632 memset(req, 0, sizeof(*req));
633 gb_operation_sync(gcam->connection,
634 GB_CAMERA_TYPE_CONFIGURE_STREAMS,
635 req, sizeof(*req),
636 resp, sizeof(*resp));
637 *flags = 0;
638 *num_streams = 0;
639 gb_pm_runtime_put_noidle(gcam->bundle);
640 goto done;
641 }
642
643 gcam->state = GB_CAMERA_STATE_CONFIGURED;
644
645 done:
646 gb_pm_runtime_put_autosuspend(gcam->bundle);
647
648 done_skip_pm_put:
649 mutex_unlock(&gcam->mutex);
650 kfree(req);
651 kfree(resp);
652 return ret;
653 }
654
655 static int gb_camera_capture(struct gb_camera *gcam, u32 request_id,
656 unsigned int streams, unsigned int num_frames,
657 size_t settings_size, const void *settings)
658 {
659 struct gb_camera_capture_request *req;
660 size_t req_size;
661 int ret;
662
663 if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE)
664 return -EINVAL;
665
666 req_size = sizeof(*req) + settings_size;
667 req = kmalloc(req_size, GFP_KERNEL);
668 if (!req)
669 return -ENOMEM;
670
671 req->request_id = cpu_to_le32(request_id);
672 req->streams = streams;
673 req->padding = 0;
674 req->num_frames = cpu_to_le16(num_frames);
675 memcpy(req->settings, settings, settings_size);
676
677 mutex_lock(&gcam->mutex);
678
679 if (!gcam->connection) {
680 ret = -EINVAL;
681 goto done;
682 }
683
684 ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
685 req, req_size, NULL, 0);
686 done:
687 mutex_unlock(&gcam->mutex);
688
689 kfree(req);
690
691 return ret;
692 }
693
694 static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
695 {
696 struct gb_camera_flush_response resp;
697 int ret;
698
699 mutex_lock(&gcam->mutex);
700
701 if (!gcam->connection) {
702 ret = -EINVAL;
703 goto done;
704 }
705
706 ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
707 &resp, sizeof(resp));
708
709 if (ret < 0)
710 goto done;
711
712 if (request_id)
713 *request_id = le32_to_cpu(resp.request_id);
714
715 done:
716 mutex_unlock(&gcam->mutex);
717
718 return ret;
719 }
720
721 static int gb_camera_request_handler(struct gb_operation *op)
722 {
723 struct gb_camera *gcam = gb_connection_get_data(op->connection);
724 struct gb_camera_metadata_request *payload;
725 struct gb_message *request;
726
727 if (op->type != GB_CAMERA_TYPE_METADATA) {
728 gcam_err(gcam, "Unsupported unsolicited event: %u\n", op->type);
729 return -EINVAL;
730 }
731
732 request = op->request;
733
734 if (request->payload_size < sizeof(*payload)) {
735 gcam_err(gcam, "Wrong event size received (%zu < %zu)\n",
736 request->payload_size, sizeof(*payload));
737 return -EINVAL;
738 }
739
740 payload = request->payload;
741
742 gcam_dbg(gcam, "received metadata for request %u, frame %u, stream %u\n",
743 payload->request_id, payload->frame_number, payload->stream);
744
745 return 0;
746 }
747
748 /* -----------------------------------------------------------------------------
749 * Interface with HOST gmp camera.
750 */
751 static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code)
752 {
753 unsigned int i;
754
755 for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
756 if (gb_fmt_info[i].mbus_code == mbus_code)
757 return gb_fmt_info[i].gb_format;
758 }
759 return gb_fmt_info[0].gb_format;
760 }
761
762 static enum v4l2_mbus_pixelcode gb_camera_gb_to_mbus(u16 gb_fmt)
763 {
764 unsigned int i;
765
766 for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
767 if (gb_fmt_info[i].gb_format == gb_fmt)
768 return gb_fmt_info[i].mbus_code;
769 }
770 return gb_fmt_info[0].mbus_code;
771 }
772
773 static ssize_t gb_camera_op_capabilities(void *priv, char *data, size_t len)
774 {
775 struct gb_camera *gcam = priv;
776 size_t capabilities_len = len;
777 int ret;
778
779 ret = gb_camera_capabilities(gcam, data, &capabilities_len);
780 if (ret)
781 return ret;
782
783 return capabilities_len;
784 }
785
786 static int gb_camera_op_configure_streams(void *priv, unsigned int *nstreams,
787 unsigned int *flags, struct gb_camera_stream *streams,
788 struct gb_camera_csi_params *csi_params)
789 {
790 struct gb_camera *gcam = priv;
791 struct gb_camera_stream_config *gb_streams;
792 unsigned int gb_flags = 0;
793 unsigned int gb_nstreams = *nstreams;
794 unsigned int i;
795 int ret;
796
797 if (gb_nstreams > GB_CAMERA_MAX_STREAMS)
798 return -EINVAL;
799
800 gb_streams = kcalloc(gb_nstreams, sizeof(*gb_streams), GFP_KERNEL);
801 if (!gb_streams)
802 return -ENOMEM;
803
804 for (i = 0; i < gb_nstreams; i++) {
805 gb_streams[i].width = streams[i].width;
806 gb_streams[i].height = streams[i].height;
807 gb_streams[i].format =
808 gb_camera_mbus_to_gb(streams[i].pixel_code);
809 }
810
811 if (*flags & GB_CAMERA_IN_FLAG_TEST)
812 gb_flags |= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY;
813
814 ret = gb_camera_configure_streams(gcam, &gb_nstreams,
815 &gb_flags, gb_streams, csi_params);
816 if (ret < 0)
817 goto done;
818 if (gb_nstreams > *nstreams) {
819 ret = -EINVAL;
820 goto done;
821 }
822
823 *flags = 0;
824 if (gb_flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED)
825 *flags |= GB_CAMERA_OUT_FLAG_ADJUSTED;
826
827 for (i = 0; i < gb_nstreams; i++) {
828 streams[i].width = gb_streams[i].width;
829 streams[i].height = gb_streams[i].height;
830 streams[i].vc = gb_streams[i].vc;
831 streams[i].dt[0] = gb_streams[i].dt[0];
832 streams[i].dt[1] = gb_streams[i].dt[1];
833 streams[i].max_size = gb_streams[i].max_size;
834 streams[i].pixel_code =
835 gb_camera_gb_to_mbus(gb_streams[i].format);
836 }
837 *nstreams = gb_nstreams;
838
839 done:
840 kfree(gb_streams);
841 return ret;
842 }
843
844 static int gb_camera_op_capture(void *priv, u32 request_id,
845 unsigned int streams, unsigned int num_frames,
846 size_t settings_size, const void *settings)
847 {
848 struct gb_camera *gcam = priv;
849
850 return gb_camera_capture(gcam, request_id, streams, num_frames,
851 settings_size, settings);
852 }
853
854 static int gb_camera_op_flush(void *priv, u32 *request_id)
855 {
856 struct gb_camera *gcam = priv;
857
858 return gb_camera_flush(gcam, request_id);
859 }
860
861 static const struct gb_camera_ops gb_cam_ops = {
862 .capabilities = gb_camera_op_capabilities,
863 .configure_streams = gb_camera_op_configure_streams,
864 .capture = gb_camera_op_capture,
865 .flush = gb_camera_op_flush,
866 };
867
868 /* -----------------------------------------------------------------------------
869 * DebugFS
870 */
871
872 static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam,
873 char *buf, size_t len)
874 {
875 struct gb_camera_debugfs_buffer *buffer =
876 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES];
877 size_t size = 1024;
878 unsigned int i;
879 u8 *caps;
880 int ret;
881
882 caps = kmalloc(size, GFP_KERNEL);
883 if (!caps)
884 return -ENOMEM;
885
886 ret = gb_camera_capabilities(gcam, caps, &size);
887 if (ret < 0)
888 goto done;
889
890 /*
891 * hex_dump_to_buffer() doesn't return the number of bytes dumped prior
892 * to v4.0, we need our own implementation :-(
893 */
894 buffer->length = 0;
895
896 for (i = 0; i < size; i += 16) {
897 unsigned int nbytes = min_t(unsigned int, size - i, 16);
898
899 buffer->length += sprintf(buffer->data + buffer->length,
900 "%*ph\n", nbytes, caps + i);
901 }
902
903 done:
904 kfree(caps);
905 return ret;
906 }
907
908 static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam,
909 char *buf, size_t len)
910 {
911 struct gb_camera_debugfs_buffer *buffer =
912 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_STREAMS];
913 struct gb_camera_stream_config *streams;
914 unsigned int nstreams;
915 unsigned int flags;
916 unsigned int i;
917 char *token;
918 int ret;
919
920 /* Retrieve number of streams to configure */
921 token = strsep(&buf, ";");
922 if (token == NULL)
923 return -EINVAL;
924
925 ret = kstrtouint(token, 10, &nstreams);
926 if (ret < 0)
927 return ret;
928
929 if (nstreams > GB_CAMERA_MAX_STREAMS)
930 return -EINVAL;
931
932 token = strsep(&buf, ";");
933 if (token == NULL)
934 return -EINVAL;
935
936 ret = kstrtouint(token, 10, &flags);
937 if (ret < 0)
938 return ret;
939
940 /* For each stream to configure parse width, height and format */
941 streams = kcalloc(nstreams, sizeof(*streams), GFP_KERNEL);
942 if (!streams)
943 return -ENOMEM;
944
945 for (i = 0; i < nstreams; ++i) {
946 struct gb_camera_stream_config *stream = &streams[i];
947
948 /* width */
949 token = strsep(&buf, ";");
950 if (token == NULL) {
951 ret = -EINVAL;
952 goto done;
953 }
954 ret = kstrtouint(token, 10, &stream->width);
955 if (ret < 0)
956 goto done;
957
958 /* height */
959 token = strsep(&buf, ";");
960 if (token == NULL)
961 goto done;
962
963 ret = kstrtouint(token, 10, &stream->height);
964 if (ret < 0)
965 goto done;
966
967 /* Image format code */
968 token = strsep(&buf, ";");
969 if (token == NULL)
970 goto done;
971
972 ret = kstrtouint(token, 16, &stream->format);
973 if (ret < 0)
974 goto done;
975 }
976
977 ret = gb_camera_configure_streams(gcam, &nstreams, &flags, streams,
978 NULL);
979 if (ret < 0)
980 goto done;
981
982 buffer->length = sprintf(buffer->data, "%u;%u;", nstreams, flags);
983
984 for (i = 0; i < nstreams; ++i) {
985 struct gb_camera_stream_config *stream = &streams[i];
986
987 buffer->length += sprintf(buffer->data + buffer->length,
988 "%u;%u;%u;%u;%u;%u;%u;",
989 stream->width, stream->height,
990 stream->format, stream->vc,
991 stream->dt[0], stream->dt[1],
992 stream->max_size);
993 }
994
995 ret = len;
996
997 done:
998 kfree(streams);
999 return ret;
1000 };
1001
1002 static ssize_t gb_camera_debugfs_capture(struct gb_camera *gcam,
1003 char *buf, size_t len)
1004 {
1005 unsigned int request_id;
1006 unsigned int streams_mask;
1007 unsigned int num_frames;
1008 char *token;
1009 int ret;
1010
1011 /* Request id */
1012 token = strsep(&buf, ";");
1013 if (token == NULL)
1014 return -EINVAL;
1015 ret = kstrtouint(token, 10, &request_id);
1016 if (ret < 0)
1017 return ret;
1018
1019 /* Stream mask */
1020 token = strsep(&buf, ";");
1021 if (token == NULL)
1022 return -EINVAL;
1023 ret = kstrtouint(token, 16, &streams_mask);
1024 if (ret < 0)
1025 return ret;
1026
1027 /* number of frames */
1028 token = strsep(&buf, ";");
1029 if (token == NULL)
1030 return -EINVAL;
1031 ret = kstrtouint(token, 10, &num_frames);
1032 if (ret < 0)
1033 return ret;
1034
1035 ret = gb_camera_capture(gcam, request_id, streams_mask, num_frames, 0,
1036 NULL);
1037 if (ret < 0)
1038 return ret;
1039
1040 return len;
1041 }
1042
1043 static ssize_t gb_camera_debugfs_flush(struct gb_camera *gcam,
1044 char *buf, size_t len)
1045 {
1046 struct gb_camera_debugfs_buffer *buffer =
1047 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_FLUSH];
1048 unsigned int req_id;
1049 int ret;
1050
1051 ret = gb_camera_flush(gcam, &req_id);
1052 if (ret < 0)
1053 return ret;
1054
1055 buffer->length = sprintf(buffer->data, "%u", req_id);
1056
1057 return len;
1058 }
1059
1060 struct gb_camera_debugfs_entry {
1061 const char *name;
1062 unsigned int mask;
1063 unsigned int buffer;
1064 ssize_t (*execute)(struct gb_camera *gcam, char *buf, size_t len);
1065 };
1066
1067 static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries[] = {
1068 {
1069 .name = "capabilities",
1070 .mask = S_IFREG | 0444,
1071 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
1072 .execute = gb_camera_debugfs_capabilities,
1073 }, {
1074 .name = "configure_streams",
1075 .mask = S_IFREG | 0666,
1076 .buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
1077 .execute = gb_camera_debugfs_configure_streams,
1078 }, {
1079 .name = "capture",
1080 .mask = S_IFREG | 0666,
1081 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
1082 .execute = gb_camera_debugfs_capture,
1083 }, {
1084 .name = "flush",
1085 .mask = S_IFREG | 0666,
1086 .buffer = GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
1087 .execute = gb_camera_debugfs_flush,
1088 },
1089 };
1090
1091 static ssize_t gb_camera_debugfs_read(struct file *file, char __user *buf,
1092 size_t len, loff_t *offset)
1093 {
1094 const struct gb_camera_debugfs_entry *op = file->private_data;
1095 struct gb_camera *gcam = file_inode(file)->i_private;
1096 struct gb_camera_debugfs_buffer *buffer;
1097 ssize_t ret;
1098
1099 /* For read-only entries the operation is triggered by a read. */
1100 if (!(op->mask & 0222)) {
1101 ret = op->execute(gcam, NULL, 0);
1102 if (ret < 0)
1103 return ret;
1104 }
1105
1106 buffer = &gcam->debugfs.buffers[op->buffer];
1107
1108 return simple_read_from_buffer(buf, len, offset, buffer->data,
1109 buffer->length);
1110 }
1111
1112 static ssize_t gb_camera_debugfs_write(struct file *file,
1113 const char __user *buf, size_t len,
1114 loff_t *offset)
1115 {
1116 const struct gb_camera_debugfs_entry *op = file->private_data;
1117 struct gb_camera *gcam = file_inode(file)->i_private;
1118 ssize_t ret;
1119 char *kbuf;
1120
1121 if (len > 1024)
1122 return -EINVAL;
1123
1124 kbuf = kmalloc(len + 1, GFP_KERNEL);
1125 if (!kbuf)
1126 return -ENOMEM;
1127
1128 if (copy_from_user(kbuf, buf, len)) {
1129 ret = -EFAULT;
1130 goto done;
1131 }
1132
1133 kbuf[len] = '\0';
1134
1135 ret = op->execute(gcam, kbuf, len);
1136
1137 done:
1138 kfree(kbuf);
1139 return ret;
1140 }
1141
1142 static int gb_camera_debugfs_open(struct inode *inode, struct file *file)
1143 {
1144 unsigned int i;
1145
1146 for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
1147 const struct gb_camera_debugfs_entry *entry =
1148 &gb_camera_debugfs_entries[i];
1149
1150 if (!strcmp(file->f_path.dentry->d_iname, entry->name)) {
1151 file->private_data = (void *)entry;
1152 break;
1153 }
1154 }
1155
1156 return 0;
1157 }
1158
1159 static const struct file_operations gb_camera_debugfs_ops = {
1160 .open = gb_camera_debugfs_open,
1161 .read = gb_camera_debugfs_read,
1162 .write = gb_camera_debugfs_write,
1163 };
1164
1165 static int gb_camera_debugfs_init(struct gb_camera *gcam)
1166 {
1167 struct gb_connection *connection = gcam->connection;
1168 char dirname[27];
1169 unsigned int i;
1170
1171 /*
1172 * Create root debugfs entry and a file entry for each camera operation.
1173 */
1174 snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id,
1175 gcam->bundle->id);
1176
1177 gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get());
1178 if (IS_ERR(gcam->debugfs.root)) {
1179 gcam_err(gcam, "debugfs root create failed (%ld)\n",
1180 PTR_ERR(gcam->debugfs.root));
1181 return PTR_ERR(gcam->debugfs.root);
1182 }
1183
1184 gcam->debugfs.buffers = vmalloc(sizeof(*gcam->debugfs.buffers) *
1185 GB_CAMERA_DEBUGFS_BUFFER_MAX);
1186 if (!gcam->debugfs.buffers)
1187 return -ENOMEM;
1188
1189 for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
1190 const struct gb_camera_debugfs_entry *entry =
1191 &gb_camera_debugfs_entries[i];
1192 struct dentry *dentry;
1193
1194 gcam->debugfs.buffers[i].length = 0;
1195
1196 dentry = debugfs_create_file(entry->name, entry->mask,
1197 gcam->debugfs.root, gcam,
1198 &gb_camera_debugfs_ops);
1199 if (IS_ERR(dentry)) {
1200 gcam_err(gcam,
1201 "debugfs operation %s create failed (%ld)\n",
1202 entry->name, PTR_ERR(dentry));
1203 return PTR_ERR(dentry);
1204 }
1205 }
1206
1207 return 0;
1208 }
1209
1210 static void gb_camera_debugfs_cleanup(struct gb_camera *gcam)
1211 {
1212 debugfs_remove_recursive(gcam->debugfs.root);
1213
1214 vfree(gcam->debugfs.buffers);
1215 }
1216
1217 /* -----------------------------------------------------------------------------
1218 * Init & Cleanup
1219 */
1220
1221 static void gb_camera_cleanup(struct gb_camera *gcam)
1222 {
1223 gb_camera_debugfs_cleanup(gcam);
1224
1225 mutex_lock(&gcam->mutex);
1226 if (gcam->data_connection) {
1227 gb_connection_disable(gcam->data_connection);
1228 gb_connection_destroy(gcam->data_connection);
1229 gcam->data_connection = NULL;
1230 }
1231
1232 if (gcam->connection) {
1233 gb_connection_disable(gcam->connection);
1234 gb_connection_destroy(gcam->connection);
1235 gcam->connection = NULL;
1236 }
1237 mutex_unlock(&gcam->mutex);
1238 }
1239
1240 static void gb_camera_release_module(struct kref *ref)
1241 {
1242 struct gb_camera_module *cam_mod =
1243 container_of(ref, struct gb_camera_module, refcount);
1244 kfree(cam_mod->priv);
1245 }
1246
1247 static int gb_camera_probe(struct gb_bundle *bundle,
1248 const struct greybus_bundle_id *id)
1249 {
1250 struct gb_connection *conn;
1251 struct gb_camera *gcam;
1252 u16 mgmt_cport_id = 0;
1253 u16 data_cport_id = 0;
1254 unsigned int i;
1255 int ret;
1256
1257 /*
1258 * The camera bundle must contain exactly two CPorts, one for the
1259 * camera management protocol and one for the camera data protocol.
1260 */
1261 if (bundle->num_cports != 2)
1262 return -ENODEV;
1263
1264 for (i = 0; i < bundle->num_cports; ++i) {
1265 struct greybus_descriptor_cport *desc = &bundle->cport_desc[i];
1266
1267 switch (desc->protocol_id) {
1268 case GREYBUS_PROTOCOL_CAMERA_MGMT:
1269 mgmt_cport_id = le16_to_cpu(desc->id);
1270 break;
1271 case GREYBUS_PROTOCOL_CAMERA_DATA:
1272 data_cport_id = le16_to_cpu(desc->id);
1273 break;
1274 default:
1275 return -ENODEV;
1276 }
1277 }
1278
1279 if (!mgmt_cport_id || !data_cport_id)
1280 return -ENODEV;
1281
1282 gcam = kzalloc(sizeof(*gcam), GFP_KERNEL);
1283 if (!gcam)
1284 return -ENOMEM;
1285
1286 mutex_init(&gcam->mutex);
1287
1288 gcam->bundle = bundle;
1289 gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
1290 gcam->data_cport_id = data_cport_id;
1291
1292 conn = gb_connection_create(bundle, mgmt_cport_id,
1293 gb_camera_request_handler);
1294 if (IS_ERR(conn)) {
1295 ret = PTR_ERR(conn);
1296 goto error;
1297 }
1298
1299 gcam->connection = conn;
1300 gb_connection_set_data(conn, gcam);
1301
1302 ret = gb_connection_enable(conn);
1303 if (ret)
1304 goto error;
1305
1306 ret = gb_camera_debugfs_init(gcam);
1307 if (ret < 0)
1308 goto error;
1309
1310 gcam->module.priv = gcam;
1311 gcam->module.ops = &gb_cam_ops;
1312 gcam->module.interface_id = gcam->connection->intf->interface_id;
1313 gcam->module.release = gb_camera_release_module;
1314 ret = gb_camera_register(&gcam->module);
1315 if (ret < 0)
1316 goto error;
1317
1318 greybus_set_drvdata(bundle, gcam);
1319
1320 gb_pm_runtime_put_autosuspend(gcam->bundle);
1321
1322 return 0;
1323
1324 error:
1325 gb_camera_cleanup(gcam);
1326 kfree(gcam);
1327 return ret;
1328 }
1329
1330 static void gb_camera_disconnect(struct gb_bundle *bundle)
1331 {
1332 struct gb_camera *gcam = greybus_get_drvdata(bundle);
1333 int ret;
1334
1335 ret = gb_pm_runtime_get_sync(bundle);
1336 if (ret)
1337 gb_pm_runtime_get_noresume(bundle);
1338
1339 gb_camera_cleanup(gcam);
1340 gb_camera_unregister(&gcam->module);
1341 }
1342
1343 static const struct greybus_bundle_id gb_camera_id_table[] = {
1344 { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_CAMERA) },
1345 { },
1346 };
1347
1348 #ifdef CONFIG_PM
1349 static int gb_camera_suspend(struct device *dev)
1350 {
1351 struct gb_bundle *bundle = to_gb_bundle(dev);
1352 struct gb_camera *gcam = greybus_get_drvdata(bundle);
1353
1354 if (gcam->data_connection)
1355 gb_connection_disable(gcam->data_connection);
1356
1357 gb_connection_disable(gcam->connection);
1358
1359 return 0;
1360 }
1361
1362 static int gb_camera_resume(struct device *dev)
1363 {
1364 struct gb_bundle *bundle = to_gb_bundle(dev);
1365 struct gb_camera *gcam = greybus_get_drvdata(bundle);
1366 int ret;
1367
1368 ret = gb_connection_enable(gcam->connection);
1369 if (ret) {
1370 gcam_err(gcam, "failed to enable connection: %d\n", ret);
1371 return ret;
1372 }
1373
1374 if (gcam->data_connection) {
1375 ret = gb_connection_enable(gcam->data_connection);
1376 if (ret) {
1377 gcam_err(gcam,
1378 "failed to enable data connection: %d\n", ret);
1379 return ret;
1380 }
1381 }
1382
1383 return 0;
1384 }
1385 #endif
1386
1387 static const struct dev_pm_ops gb_camera_pm_ops = {
1388 SET_RUNTIME_PM_OPS(gb_camera_suspend, gb_camera_resume, NULL)
1389 };
1390
1391 static struct greybus_driver gb_camera_driver = {
1392 .name = "camera",
1393 .probe = gb_camera_probe,
1394 .disconnect = gb_camera_disconnect,
1395 .id_table = gb_camera_id_table,
1396 .driver.pm = &gb_camera_pm_ops,
1397 };
1398
1399 module_greybus_driver(gb_camera_driver);
1400
1401 MODULE_LICENSE("GPL v2");
(deprecated) Btrfs devel tree