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>
20 #include "greybus_protocols.h"
22 enum gb_camera_debugs_buffer_id {
23 GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
24 GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
25 GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
26 GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
27 GB_CAMERA_DEBUGFS_BUFFER_MAX,
30 struct gb_camera_debugfs_buffer {
36 * struct gb_camera - A Greybus Camera Device
37 * @connection: the greybus connection for camera control
38 * @data_connected: whether the data connection has been established
39 * @debugfs: debugfs entries for camera protocol operations testing
42 struct gb_connection *connection;
47 struct gb_camera_debugfs_buffer *buffers;
51 struct gb_camera_stream_config {
57 unsigned int max_size;
60 #define ES2_APB_CDSI0_CPORT 16
61 #define ES2_APB_CDSI1_CPORT 17
63 #define GB_CAMERA_MAX_SETTINGS_SIZE 8192
65 #define gcam_dbg(gcam, format...) \
66 dev_dbg(&gcam->connection->bundle->dev, format)
67 #define gcam_info(gcam, format...) \
68 dev_info(&gcam->connection->bundle->dev, format)
69 #define gcam_err(gcam, format...) \
70 dev_err(&gcam->connection->bundle->dev, format)
72 /* -----------------------------------------------------------------------------
73 * Camera Protocol Operations
76 struct ap_csi_config_request {
84 static int gb_camera_configure_streams(struct gb_camera *gcam,
85 unsigned int nstreams,
87 struct gb_camera_stream_config *streams)
89 struct gb_camera_configure_streams_request *req;
90 struct gb_camera_configure_streams_response *resp;
91 struct ap_csi_config_request csi_cfg;
97 if (nstreams > GB_CAMERA_MAX_STREAMS)
100 req_size = sizeof(*req) + nstreams * sizeof(req->config[0]);
101 resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]);
103 req = kmalloc(req_size, GFP_KERNEL);
104 resp = kmalloc(resp_size, GFP_KERNEL);
110 req->num_streams = nstreams;
114 for (i = 0; i < nstreams; ++i) {
115 struct gb_camera_stream_config_request *cfg = &req->config[i];
117 cfg->width = cpu_to_le16(streams[i].width);
118 cfg->height = cpu_to_le16(streams[i].height);
119 cfg->format = cpu_to_le16(streams[i].format);
123 ret = gb_operation_sync(gcam->connection,
124 GB_CAMERA_TYPE_CONFIGURE_STREAMS,
125 req, req_size, resp, resp_size);
129 if (resp->num_streams > nstreams) {
130 gcam_dbg(gcam, "got #streams %u > request %u\n",
131 resp->num_streams, nstreams);
136 if (resp->padding != 0) {
137 gcam_dbg(gcam, "response padding != 0");
142 for (i = 0; i < nstreams; ++i) {
143 struct gb_camera_stream_config_response *cfg = &resp->config[i];
145 streams[i].width = le16_to_cpu(cfg->width);
146 streams[i].height = le16_to_cpu(cfg->height);
147 streams[i].format = le16_to_cpu(cfg->format);
148 streams[i].vc = cfg->virtual_channel;
149 streams[i].dt[0] = cfg->data_type[0];
150 streams[i].dt[1] = cfg->data_type[1];
151 streams[i].max_size = le32_to_cpu(cfg->max_size);
153 if (cfg->padding[0] || cfg->padding[1] || cfg->padding[2]) {
154 gcam_dbg(gcam, "stream #%u padding != 0", i);
160 memset(&csi_cfg, 0, sizeof(csi_cfg));
162 /* Configure the CSI transmitter. Hardcode the parameters for now. */
163 if (nstreams && !(resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED)) {
165 csi_cfg.clock_mode = 0;
166 csi_cfg.num_lanes = 4;
167 csi_cfg.bus_freq = cpu_to_le32(960000000);
168 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
170 GB_APB_REQUEST_CSI_TX_CONTROL, false);
171 } else if (nstreams == 0) {
173 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
175 GB_APB_REQUEST_CSI_TX_CONTROL, false);
179 gcam_err(gcam, "failed to %s the CSI transmitter\n",
180 nstreams ? "start" : "stop");
182 ret = resp->num_streams;
190 static int gb_camera_capture(struct gb_camera *gcam, u32 request_id,
191 unsigned int streams, unsigned int num_frames,
192 size_t settings_size, const void *settings)
194 struct gb_camera_capture_request *req;
198 if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE)
201 req_size = sizeof(*req) + settings_size;
202 req = kmalloc(req_size, GFP_KERNEL);
206 req->request_id = cpu_to_le32(request_id);
207 req->streams = streams;
209 req->num_frames = cpu_to_le16(num_frames);
210 memcpy(req->settings, settings, settings_size);
212 ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
213 req, req_size, NULL, 0);
220 static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
222 struct gb_camera_flush_response resp;
225 ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
226 &resp, sizeof(resp));
231 *request_id = le32_to_cpu(resp.request_id);
236 static int gb_camera_event_recv(u8 type, struct gb_operation *op)
238 struct gb_camera *gcam = op->connection->private;
239 struct gb_camera_metadata_request *payload;
240 struct gb_message *request;
242 if (type != GB_CAMERA_TYPE_METADATA) {
243 gcam_err(gcam, "Unsupported unsolicited event: %u\n", type);
247 request = op->request;
249 if (request->payload_size < sizeof(*payload)) {
250 gcam_err(gcam, "Wrong event size received (%zu < %zu)\n",
251 request->payload_size, sizeof(*payload));
255 payload = request->payload;
257 gcam_dbg(gcam, "received metadata for request %u, frame %u, stream %u\n",
258 payload->request_id, payload->frame_number, payload->stream);
263 /* -----------------------------------------------------------------------------
266 static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam,
267 char *buf, size_t len)
272 static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam,
273 char *buf, size_t len)
275 struct gb_camera_debugfs_buffer *buffer =
276 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_STREAMS];
277 struct gb_camera_stream_config *streams;
278 unsigned int nstreams;
284 /* Retrieve number of streams to configure */
285 token = strsep(&buf, ";");
289 ret = kstrtouint(token, 10, &nstreams);
293 if (nstreams > GB_CAMERA_MAX_STREAMS)
296 token = strsep(&buf, ";");
300 ret = kstrtouint(token, 10, &flags);
304 /* For each stream to configure parse width, height and format */
305 streams = kzalloc(nstreams * sizeof(*streams), GFP_KERNEL);
309 for (i = 0; i < nstreams; ++i) {
310 struct gb_camera_stream_config *stream = &streams[i];
313 token = strsep(&buf, ";");
318 ret = kstrtouint(token, 10, &stream->width);
323 token = strsep(&buf, ";");
327 ret = kstrtouint(token, 10, &stream->height);
331 /* Image format code */
332 token = strsep(&buf, ";");
336 ret = kstrtouint(token, 16, &stream->format);
341 ret = gb_camera_configure_streams(gcam, nstreams, flags, streams);
346 buffer->length = sprintf(buffer->data, "%u;", nstreams);
348 for (i = 0; i < nstreams; ++i) {
349 struct gb_camera_stream_config *stream = &streams[i];
351 buffer->length += sprintf(buffer->data + buffer->length,
352 "%u;%u;%u;%u;%u;%u;%u;",
353 stream->width, stream->height,
354 stream->format, stream->vc,
355 stream->dt[0], stream->dt[1],
366 static ssize_t gb_camera_debugfs_capture(struct gb_camera *gcam,
367 char *buf, size_t len)
369 unsigned int request_id;
370 unsigned int streams_mask;
371 unsigned int num_frames;
376 token = strsep(&buf, ";");
379 ret = kstrtouint(token, 10, &request_id);
384 token = strsep(&buf, ";");
387 ret = kstrtouint(token, 16, &streams_mask);
391 /* number of frames */
392 token = strsep(&buf, ";");
395 ret = kstrtouint(token, 10, &num_frames);
399 ret = gb_camera_capture(gcam, request_id, streams_mask, num_frames, 0,
407 static ssize_t gb_camera_debugfs_flush(struct gb_camera *gcam,
408 char *buf, size_t len)
410 struct gb_camera_debugfs_buffer *buffer =
411 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_FLUSH];
415 ret = gb_camera_flush(gcam, &req_id);
419 buffer->length = sprintf(buffer->data, "%u", req_id);
424 struct gb_camera_debugfs_entry {
428 ssize_t (*execute)(struct gb_camera *gcam, char *buf, size_t len);
431 static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries[] = {
433 .name = "capabilities",
434 .mask = S_IFREG | S_IRUGO,
435 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
436 .execute = gb_camera_debugfs_capabilities,
438 .name = "configure_streams",
439 .mask = S_IFREG | S_IRUGO | S_IWUGO,
440 .buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
441 .execute = gb_camera_debugfs_configure_streams,
444 .mask = S_IFREG | S_IRUGO | S_IWUGO,
445 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
446 .execute = gb_camera_debugfs_capture,
449 .mask = S_IFREG | S_IRUGO | S_IWUGO,
450 .buffer = GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
451 .execute = gb_camera_debugfs_flush,
455 static ssize_t gb_camera_debugfs_read(struct file *file, char __user *buf,
456 size_t len, loff_t *offset)
458 const struct gb_camera_debugfs_entry *op = file->private_data;
459 struct gb_camera *gcam = file->f_inode->i_private;
460 struct gb_camera_debugfs_buffer *buffer;
463 /* For read-only entries the operation is triggered by a read. */
464 if (!(op->mask & S_IWUGO)) {
465 ret = op->execute(gcam, NULL, 0);
470 buffer = &gcam->debugfs.buffers[op->buffer];
472 return simple_read_from_buffer(buf, len, offset, buffer->data,
476 static ssize_t gb_camera_debugfs_write(struct file *file,
477 const char __user *buf, size_t len,
480 const struct gb_camera_debugfs_entry *op = file->private_data;
481 struct gb_camera *gcam = file->f_inode->i_private;
488 kbuf = kmalloc(len + 1, GFP_KERNEL);
492 if (copy_from_user(kbuf, buf, len)) {
499 ret = op->execute(gcam, kbuf, len);
506 static int gb_camera_debugfs_open(struct inode *inode, struct file *file)
510 for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
511 const struct gb_camera_debugfs_entry *entry =
512 &gb_camera_debugfs_entries[i];
514 if (!strcmp(file->f_path.dentry->d_iname, entry->name)) {
515 file->private_data = (void *)entry;
523 static const struct file_operations gb_camera_debugfs_ops = {
524 .open = gb_camera_debugfs_open,
525 .read = gb_camera_debugfs_read,
526 .write = gb_camera_debugfs_write,
529 static int gb_camera_debugfs_init(struct gb_camera *gcam)
531 struct gb_connection *connection = gcam->connection;
536 * Create root debugfs entry and a file entry for each camera operation.
538 snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id,
539 connection->bundle->id);
541 gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get());
542 if (IS_ERR(gcam->debugfs.root)) {
543 gcam_err(gcam, "debugfs root create failed (%ld)\n",
544 PTR_ERR(gcam->debugfs.root));
545 return PTR_ERR(gcam->debugfs.root);
548 gcam->debugfs.buffers = vmalloc(sizeof(*gcam->debugfs.buffers) *
549 GB_CAMERA_DEBUGFS_BUFFER_MAX);
550 if (!gcam->debugfs.buffers)
553 for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
554 const struct gb_camera_debugfs_entry *entry =
555 &gb_camera_debugfs_entries[i];
556 struct dentry *dentry;
558 gcam->debugfs.buffers[i].length = 0;
560 dentry = debugfs_create_file(entry->name, entry->mask,
561 gcam->debugfs.root, gcam,
562 &gb_camera_debugfs_ops);
563 if (IS_ERR(dentry)) {
565 "debugfs operation %s create failed (%ld)\n",
566 entry->name, PTR_ERR(gcam->debugfs.root));
567 return PTR_ERR(dentry);
574 static void gb_camera_debugfs_cleanup(struct gb_camera *gcam)
576 if (gcam->debugfs.root)
577 debugfs_remove_recursive(gcam->debugfs.root);
579 vfree(gcam->debugfs.buffers);
582 /* -----------------------------------------------------------------------------
586 static void gb_camera_cleanup(struct gb_camera *gcam)
588 gb_camera_debugfs_cleanup(gcam);
590 if (gcam->data_connected) {
591 struct gb_interface *intf = gcam->connection->intf;
592 struct gb_svc *svc = gcam->connection->hd->svc;
594 gb_svc_connection_destroy(svc, intf->interface_id,
595 ES2_APB_CDSI0_CPORT, svc->ap_intf_id,
596 ES2_APB_CDSI1_CPORT);
602 static int gb_camera_connection_init(struct gb_connection *connection)
604 struct gb_svc *svc = connection->hd->svc;
605 struct gb_camera *gcam;
608 gcam = kzalloc(sizeof(*gcam), GFP_KERNEL);
612 gcam->connection = connection;
613 connection->private = gcam;
616 * Create the data connection between camera module CDSI0 and APB CDS1.
617 * The CPort IDs are hardcoded by the ES2 bridges.
619 ret = gb_svc_connection_create(svc, connection->intf->interface_id,
620 ES2_APB_CDSI0_CPORT, svc->ap_intf_id,
621 ES2_APB_CDSI1_CPORT, false);
625 gcam->data_connected = true;
627 ret = gb_svc_intf_set_power_mode(svc, connection->intf->interface_id,
628 GB_SVC_UNIPRO_HS_SERIES_A,
629 GB_SVC_UNIPRO_FAST_MODE, 2, 2,
630 GB_SVC_UNIPRO_FAST_MODE, 2, 2,
631 GB_SVC_PWRM_RXTERMINATION |
632 GB_SVC_PWRM_TXTERMINATION, 0);
636 ret = gb_svc_intf_set_power_mode(svc, svc->ap_intf_id,
637 GB_SVC_UNIPRO_HS_SERIES_A,
638 GB_SVC_UNIPRO_FAST_MODE, 2, 2,
639 GB_SVC_UNIPRO_FAST_MODE, 2, 2,
640 GB_SVC_PWRM_RXTERMINATION |
641 GB_SVC_PWRM_TXTERMINATION, 0);
645 ret = gb_camera_debugfs_init(gcam);
652 gb_camera_cleanup(gcam);
656 static void gb_camera_connection_exit(struct gb_connection *connection)
658 struct gb_camera *gcam = connection->private;
660 gb_camera_cleanup(gcam);
663 static struct gb_protocol camera_protocol = {
665 .id = GREYBUS_PROTOCOL_CAMERA_MGMT,
666 .major = GB_CAMERA_VERSION_MAJOR,
667 .minor = GB_CAMERA_VERSION_MINOR,
668 .connection_init = gb_camera_connection_init,
669 .connection_exit = gb_camera_connection_exit,
670 .request_recv = gb_camera_event_recv,
673 gb_protocol_driver(&camera_protocol);
675 MODULE_LICENSE("GPL v2");