drivers/staging/greybus/camera.c

   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 /**
  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
  41  * @module: Greybus camera module registered to HOST processor.
  42  */
  43 struct gb_camera {
  44         struct gb_connection *connection;
  45         bool data_connected;
  46
  47         struct {
  48                 struct dentry *root;
  49                 struct gb_camera_debugfs_buffer *buffers;
  50         } debugfs;
  51
  52         struct gb_camera_module module;
  53 };
  54
  55 struct gb_camera_stream_config {
  56         unsigned int width;
  57         unsigned int height;
  58         unsigned int format;
  59         unsigned int vc;
  60         unsigned int dt[2];
  61         unsigned int max_size;
  62 };
  63
  64 struct gb_camera_fmt_map {
  65         enum v4l2_mbus_pixelcode mbus_code;
  66         unsigned int gb_format;
  67 };
  68
  69 /* GB format to media code map */
  70 static const struct gb_camera_fmt_map mbus_to_gbus_format[] = {
  71         {
  72                 .mbus_code = V4L2_MBUS_FMT_UYVY8_1X16,
  73                 .gb_format = 0x01,
  74         },
  75         {
  76                 .mbus_code = V4L2_MBUS_FMT_NV12_1x8,
  77                 .gb_format = 0x12,
  78         },
  79         {
  80                 .mbus_code = V4L2_MBUS_FMT_NV21_1x8,
  81                 .gb_format = 0x13,
  82         },
  83         {
  84                 .mbus_code = V4L2_MBUS_FMT_YU12_1x8,
  85                 .gb_format = 0x16,
  86         },
  87         {
  88                 .mbus_code = V4L2_MBUS_FMT_YV12_1x8,
  89                 .gb_format = 0x17,
  90         },
  91         {
  92                 .mbus_code = V4L2_MBUS_FMT_JPEG_1X8,
  93                 .gb_format = 0x40,
  94         },
  95         {
  96                 .mbus_code = V4L2_MBUS_FMT_ARA_METADATA_1X8,
  97                 .gb_format = 0x41,
  98         }
  99 };
 100
 101 #define ES2_APB_CDSI0_CPORT             16
 102 #define ES2_APB_CDSI1_CPORT             17
 103
 104 #define GB_CAMERA_MAX_SETTINGS_SIZE     8192
 105
 106 #define gcam_dbg(gcam, format...) \
 107         dev_dbg(&gcam->connection->bundle->dev, format)
 108 #define gcam_info(gcam, format...) \
 109         dev_info(&gcam->connection->bundle->dev, format)
 110 #define gcam_err(gcam, format...) \
 111         dev_err(&gcam->connection->bundle->dev, format)
 112
 113 /* -----------------------------------------------------------------------------
 114  * Camera Protocol Operations
 115  */
 116
 117 static int gb_camera_set_intf_power_mode(struct gb_camera *gcam, u8 intf_id,
 118                                          bool hs)
 119 {
 120         struct gb_svc *svc = gcam->connection->hd->svc;
 121         int ret;
 122
 123         if (hs)
 124                 ret = gb_svc_intf_set_power_mode(svc, intf_id,
 125                                                  GB_SVC_UNIPRO_HS_SERIES_A,
 126                                                  GB_SVC_UNIPRO_FAST_MODE, 2, 2,
 127                                                  GB_SVC_UNIPRO_FAST_MODE, 2, 2,
 128                                                  GB_SVC_PWRM_RXTERMINATION |
 129                                                  GB_SVC_PWRM_TXTERMINATION, 0);
 130         else
 131                 ret = gb_svc_intf_set_power_mode(svc, intf_id,
 132                                                  GB_SVC_UNIPRO_HS_SERIES_A,
 133                                                  GB_SVC_UNIPRO_SLOW_AUTO_MODE,
 134                                                  1, 2,
 135                                                  GB_SVC_UNIPRO_SLOW_AUTO_MODE,
 136                                                  1, 2,
 137                                                  0, 0);
 138
 139         return ret;
 140 }
 141
 142 static int gb_camera_set_power_mode(struct gb_camera *gcam, bool hs)
 143 {
 144         struct gb_interface *intf = gcam->connection->intf;
 145         struct gb_svc *svc = gcam->connection->hd->svc;
 146         int ret;
 147
 148         ret = gb_camera_set_intf_power_mode(gcam, intf->interface_id, hs);
 149         if (ret < 0) {
 150                 gcam_err(gcam, "failed to set module interface to %s (%d)\n",
 151                          hs ? "HS" : "PWM", ret);
 152                 return ret;
 153         }
 154
 155         ret = gb_camera_set_intf_power_mode(gcam, svc->ap_intf_id, hs);
 156         if (ret < 0) {
 157                 gb_camera_set_intf_power_mode(gcam, intf->interface_id, !hs);
 158                 gcam_err(gcam, "failed to set AP interface to %s (%d)\n",
 159                          hs ? "HS" : "PWM", ret);
 160                 return ret;
 161         }
 162
 163         return 0;
 164 }
 165
 166 static int gb_camera_capabilities(struct gb_camera *gcam,
 167                                   u8 *capabilities, size_t *size)
 168 {
 169         struct gb_operation *op;
 170         int ret;
 171
 172         op = gb_operation_create_flags(gcam->connection,
 173                                        GB_CAMERA_TYPE_CAPABILITIES, 0, *size,
 174                                        GB_OPERATION_FLAG_SHORT_RESPONSE,
 175                                        GFP_KERNEL);
 176         if (!op)
 177                 return -ENOMEM;
 178
 179         ret = gb_operation_request_send_sync(op);
 180         if (ret) {
 181                 gcam_err(gcam, "failed to retrieve capabilities: %d\n", ret);
 182                 goto done;
 183         }
 184
 185         memcpy(capabilities, op->response->payload, op->response->payload_size);
 186         *size = op->response->payload_size;
 187
 188 done:
 189         gb_operation_put(op);
 190         return ret;
 191 }
 192
 193 struct ap_csi_config_request {
 194         __u8 csi_id;
 195         __u8 flags;
 196 #define GB_CAMERA_CSI_FLAG_CLOCK_CONTINUOUS 0x01
 197         __u8 num_lanes;
 198         __u8 padding;
 199         __le32 bus_freq;
 200         __le32 lines_per_second;
 201 } __packed;
 202
 203 static int gb_camera_configure_streams(struct gb_camera *gcam,
 204                                        unsigned int *num_streams,
 205                                        unsigned int *flags,
 206                                        struct gb_camera_stream_config *streams)
 207 {
 208         struct gb_camera_configure_streams_request *req;
 209         struct gb_camera_configure_streams_response *resp;
 210         struct ap_csi_config_request csi_cfg;
 211
 212         unsigned int nstreams = *num_streams;
 213         unsigned int i;
 214         size_t req_size;
 215         size_t resp_size;
 216         int ret;
 217
 218         if (nstreams > GB_CAMERA_MAX_STREAMS)
 219                 return -EINVAL;
 220
 221         req_size = sizeof(*req) + nstreams * sizeof(req->config[0]);
 222         resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]);
 223
 224         req = kmalloc(req_size, GFP_KERNEL);
 225         resp = kmalloc(resp_size, GFP_KERNEL);
 226         if (!req || !resp) {
 227                 ret = -ENOMEM;
 228                 goto done;
 229         }
 230
 231         req->num_streams = nstreams;
 232         req->flags = *flags;
 233         req->padding = 0;
 234
 235         for (i = 0; i < nstreams; ++i) {
 236                 struct gb_camera_stream_config_request *cfg = &req->config[i];
 237
 238                 cfg->width = cpu_to_le16(streams[i].width);
 239                 cfg->height = cpu_to_le16(streams[i].height);
 240                 cfg->format = cpu_to_le16(streams[i].format);
 241                 cfg->padding = 0;
 242         }
 243
 244         ret = gb_operation_sync(gcam->connection,
 245                                 GB_CAMERA_TYPE_CONFIGURE_STREAMS,
 246                                 req, req_size, resp, resp_size);
 247         if (ret < 0)
 248                 goto done;
 249
 250         if (resp->num_streams > nstreams) {
 251                 gcam_dbg(gcam, "got #streams %u > request %u\n",
 252                          resp->num_streams, nstreams);
 253                 ret = -EIO;
 254                 goto done;
 255         }
 256
 257         if (resp->padding != 0) {
 258                 gcam_dbg(gcam, "response padding != 0");
 259                 ret = -EIO;
 260                 goto done;
 261         }
 262
 263         for (i = 0; i < nstreams; ++i) {
 264                 struct gb_camera_stream_config_response *cfg = &resp->config[i];
 265
 266                 streams[i].width = le16_to_cpu(cfg->width);
 267                 streams[i].height = le16_to_cpu(cfg->height);
 268                 streams[i].format = le16_to_cpu(cfg->format);
 269                 streams[i].vc = cfg->virtual_channel;
 270                 streams[i].dt[0] = cfg->data_type[0];
 271                 streams[i].dt[1] = cfg->data_type[1];
 272                 streams[i].max_size = le32_to_cpu(cfg->max_size);
 273
 274                 if (cfg->padding[0] || cfg->padding[1] || cfg->padding[2]) {
 275                         gcam_dbg(gcam, "stream #%u padding != 0", i);
 276                         ret = -EIO;
 277                         goto done;
 278                 }
 279         }
 280
 281         if ((resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) ||
 282             (*flags & GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY)) {
 283                 *flags = resp->flags;
 284                 *num_streams = resp->num_streams;
 285                 goto done;
 286         }
 287
 288         /* Setup unipro link speed. */
 289         ret = gb_camera_set_power_mode(gcam, nstreams != 0);
 290         if (ret < 0)
 291                 goto done;
 292
 293         /*
 294          * Configure the APB1 CSI transmitter using the lines count reported by
 295          * the  camera module, but with hard-coded bus frequency and lanes number.
 296          *
 297          * TODO: use the clocking and size informations reported by camera module
 298          * to compute the required CSI bandwidth, and configure the CSI receiver
 299          * on AP side, and the CSI transmitter on APB1 side accordingly.
 300          */
 301         memset(&csi_cfg, 0, sizeof(csi_cfg));
 302
 303         if (nstreams) {
 304                 csi_cfg.csi_id = 1;
 305                 csi_cfg.flags = 0;
 306                 csi_cfg.num_lanes = 4;
 307                 csi_cfg.bus_freq = cpu_to_le32(960000000);
 308                 csi_cfg.lines_per_second = resp->lines_per_second;
 309                 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
 310                                    sizeof(csi_cfg),
 311                                    GB_APB_REQUEST_CSI_TX_CONTROL, false);
 312         } else {
 313                 csi_cfg.csi_id = 1;
 314                 ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
 315                                    sizeof(csi_cfg),
 316                                    GB_APB_REQUEST_CSI_TX_CONTROL, false);
 317         }
 318
 319         if (ret < 0)
 320                 gcam_err(gcam, "failed to %s the CSI transmitter\n",
 321                          nstreams ? "start" : "stop");
 322
 323         *flags = resp->flags;
 324         *num_streams = resp->num_streams;
 325         ret = 0;
 326
 327 done:
 328         kfree(req);
 329         kfree(resp);
 330         return ret;
 331 }
 332
 333 static int gb_camera_capture(struct gb_camera *gcam, u32 request_id,
 334                              unsigned int streams, unsigned int num_frames,
 335                              size_t settings_size, const void *settings)
 336 {
 337         struct gb_camera_capture_request *req;
 338         size_t req_size;
 339         int ret;
 340
 341         if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE)
 342                 return -EINVAL;
 343
 344         req_size = sizeof(*req) + settings_size;
 345         req = kmalloc(req_size, GFP_KERNEL);
 346         if (!req)
 347                 return -ENOMEM;
 348
 349         req->request_id = cpu_to_le32(request_id);
 350         req->streams = streams;
 351         req->padding = 0;
 352         req->num_frames = cpu_to_le16(num_frames);
 353         memcpy(req->settings, settings, settings_size);
 354
 355         ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
 356                                  req, req_size, NULL, 0);
 357
 358         kfree(req);
 359
 360         return ret;
 361 }
 362
 363 static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
 364 {
 365         struct gb_camera_flush_response resp;
 366         int ret;
 367
 368         ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
 369                                 &resp, sizeof(resp));
 370         if (ret < 0)
 371                 return ret;
 372
 373         if (request_id)
 374                 *request_id = le32_to_cpu(resp.request_id);
 375
 376         return 0;
 377 }
 378
 379 static int gb_camera_event_recv(u8 type, struct gb_operation *op)
 380 {
 381         struct gb_camera *gcam = gb_connection_get_data(op->connection);
 382         struct gb_camera_metadata_request *payload;
 383         struct gb_message *request;
 384
 385         if (type != GB_CAMERA_TYPE_METADATA) {
 386                 gcam_err(gcam, "Unsupported unsolicited event: %u\n", type);
 387                 return -EINVAL;
 388         }
 389
 390         request = op->request;
 391
 392         if (request->payload_size < sizeof(*payload)) {
 393                 gcam_err(gcam, "Wrong event size received (%zu < %zu)\n",
 394                          request->payload_size, sizeof(*payload));
 395                 return -EINVAL;
 396         }
 397
 398         payload = request->payload;
 399
 400         gcam_dbg(gcam, "received metadata for request %u, frame %u, stream %u\n",
 401                  payload->request_id, payload->frame_number, payload->stream);
 402
 403         return 0;
 404 }
 405
 406 /* -----------------------------------------------------------------------------
 407  * Interface with HOST ara camera.
 408  */
 409 static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code)
 410 {
 411         unsigned int i;
 412
 413         for (i = 0; i < ARRAY_SIZE(mbus_to_gbus_format); i++) {
 414                 if (mbus_to_gbus_format[i].mbus_code == mbus_code)
 415                         return mbus_to_gbus_format[i].gb_format;
 416         }
 417         return mbus_to_gbus_format[0].gb_format;
 418 }
 419
 420 static enum v4l2_mbus_pixelcode gb_camera_gb_to_mbus(u16 gb_fmt)
 421 {
 422         unsigned int i;
 423
 424         for (i = 0; i < ARRAY_SIZE(mbus_to_gbus_format); i++) {
 425                 if (mbus_to_gbus_format[i].gb_format == gb_fmt)
 426                         return mbus_to_gbus_format[i].mbus_code;
 427         }
 428         return mbus_to_gbus_format[0].mbus_code;
 429 }
 430
 431 static ssize_t gb_camera_op_capabilities(void *priv, char *data, size_t len)
 432 {
 433         struct gb_camera *gcam = priv;
 434         size_t capabilities_len = len;
 435         int ret;
 436
 437         ret = gb_camera_capabilities(gcam, data, &capabilities_len);
 438         if (ret)
 439                 return ret;
 440
 441         return capabilities_len;
 442 }
 443
 444 static int gb_camera_op_configure_streams(void *priv, unsigned int *nstreams,
 445                 unsigned int *flags, struct gb_camera_stream *streams)
 446 {
 447         struct gb_camera *gcam = priv;
 448         struct gb_camera_stream_config *gb_streams;
 449         unsigned int gb_flags = 0;
 450         unsigned int gb_nstreams = *nstreams;
 451         unsigned int i;
 452         int ret;
 453
 454         if (gb_nstreams > GB_CAMERA_MAX_STREAMS)
 455                 return -EINVAL;
 456
 457         gb_streams = kzalloc(gb_nstreams * sizeof(*gb_streams), GFP_KERNEL);
 458         if (!gb_streams)
 459                 return -ENOMEM;
 460
 461         for (i = 0; i < gb_nstreams; i++) {
 462                 gb_streams[i].width = streams[i].width;
 463                 gb_streams[i].height = streams[i].height;
 464                 gb_streams[i].format =
 465                         gb_camera_mbus_to_gb(streams[i].pixel_code);
 466         }
 467
 468         if (*flags & GB_CAMERA_IN_FLAG_TEST)
 469                 gb_flags |= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY;
 470
 471         ret = gb_camera_configure_streams(gcam, &gb_nstreams,
 472                                           &gb_flags, gb_streams);
 473         if (ret < 0)
 474                 goto done;
 475         if (gb_nstreams > *nstreams) {
 476                 ret = -EINVAL;
 477                 goto done;
 478         }
 479
 480         *flags = 0;
 481         if (gb_flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED)
 482                 *flags |= GB_CAMERA_OUT_FLAG_ADJUSTED;
 483
 484         for (i = 0; i < gb_nstreams; i++) {
 485                 streams[i].width = gb_streams[i].width;
 486                 streams[i].height = gb_streams[i].height;
 487                 streams[i].vc = gb_streams[i].vc;
 488                 streams[i].dt[0] = gb_streams[i].dt[0];
 489                 streams[i].dt[1] = gb_streams[i].dt[1];
 490                 streams[i].max_size = gb_streams[i].max_size;
 491                 streams[i].pixel_code =
 492                         gb_camera_gb_to_mbus(gb_streams[i].format);
 493         }
 494         *nstreams = gb_nstreams;
 495
 496 done:
 497         kfree(gb_streams);
 498         return ret;
 499 }
 500
 501 static int gb_camera_op_capture(void *priv, u32 request_id,
 502                 unsigned int streams, unsigned int num_frames,
 503                 size_t settings_size, const void *settings)
 504 {
 505         struct gb_camera *gcam = priv;
 506
 507         return gb_camera_capture(gcam, request_id, streams, num_frames,
 508                                  settings_size, settings);
 509 }
 510
 511 static int gb_camera_op_flush(void *priv, u32 *request_id)
 512 {
 513         struct gb_camera *gcam = priv;
 514
 515         return gb_camera_flush(gcam, request_id);
 516 }
 517
 518 static const struct gb_camera_ops gb_cam_ops = {
 519         .capabilities = gb_camera_op_capabilities,
 520         .configure_streams = gb_camera_op_configure_streams,
 521         .capture = gb_camera_op_capture,
 522         .flush = gb_camera_op_flush,
 523 };
 524
 525 static int gb_camera_register_intf_ops(struct gb_camera *gcam)
 526 {
 527         gcam->module.priv = gcam;
 528         gcam->module.ops = &gb_cam_ops;
 529         return gb_camera_register(&gcam->module);
 530 }
 531
 532 static int gb_camera_unregister_intf_ops(struct gb_camera *gcam)
 533 {
 534         return gb_camera_unregister(&gcam->module);
 535 }
 536
 537 /* -----------------------------------------------------------------------------
 538  * DebugFS
 539  */
 540
 541 static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam,
 542                 char *buf, size_t len)
 543 {
 544         struct gb_camera_debugfs_buffer *buffer =
 545                 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES];
 546         size_t size = 1024;
 547         unsigned int i;
 548         u8 *caps;
 549         int ret;
 550
 551         caps = kmalloc(size, GFP_KERNEL);
 552         if (!caps)
 553                 return -ENOMEM;
 554
 555         ret = gb_camera_capabilities(gcam, caps, &size);
 556         if (ret < 0)
 557                 goto done;
 558
 559         /*
 560          * hex_dump_to_buffer() doesn't return the number of bytes dumped prior
 561          * to v4.0, we need our own implementation :-(
 562          */
 563         buffer->length = 0;
 564
 565         for (i = 0; i < size; i += 16) {
 566                 unsigned int nbytes = min_t(unsigned int, size - i, 16);
 567
 568                 buffer->length += sprintf(buffer->data + buffer->length,
 569                                           "%*ph\n", nbytes, caps + i);
 570         }
 571
 572 done:
 573         kfree(caps);
 574         return ret;
 575 }
 576
 577 static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam,
 578                 char *buf, size_t len)
 579 {
 580         struct gb_camera_debugfs_buffer *buffer =
 581                 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_STREAMS];
 582         struct gb_camera_stream_config *streams;
 583         unsigned int nstreams;
 584         unsigned int flags;
 585         unsigned int i;
 586         char *token;
 587         int ret;
 588
 589         /* Retrieve number of streams to configure */
 590         token = strsep(&buf, ";");
 591         if (token == NULL)
 592                 return -EINVAL;
 593
 594         ret = kstrtouint(token, 10, &nstreams);
 595         if (ret < 0)
 596                 return ret;
 597
 598         if (nstreams > GB_CAMERA_MAX_STREAMS)
 599                 return -EINVAL;
 600
 601         token = strsep(&buf, ";");
 602         if (token == NULL)
 603                 return -EINVAL;
 604
 605         ret = kstrtouint(token, 10, &flags);
 606         if (ret < 0)
 607                 return ret;
 608
 609         /* For each stream to configure parse width, height and format */
 610         streams = kzalloc(nstreams * sizeof(*streams), GFP_KERNEL);
 611         if (!streams)
 612                 return -ENOMEM;
 613
 614         for (i = 0; i < nstreams; ++i) {
 615                 struct gb_camera_stream_config *stream = &streams[i];
 616
 617                 /* width */
 618                 token = strsep(&buf, ";");
 619                 if (token == NULL) {
 620                         ret = -EINVAL;
 621                         goto done;
 622                 }
 623                 ret = kstrtouint(token, 10, &stream->width);
 624                 if (ret < 0)
 625                         goto done;
 626
 627                 /* height */
 628                 token = strsep(&buf, ";");
 629                 if (token == NULL)
 630                         goto done;
 631
 632                 ret = kstrtouint(token, 10, &stream->height);
 633                 if (ret < 0)
 634                         goto done;
 635
 636                 /* Image format code */
 637                 token = strsep(&buf, ";");
 638                 if (token == NULL)
 639                         goto done;
 640
 641                 ret = kstrtouint(token, 16, &stream->format);
 642                 if (ret < 0)
 643                         goto done;
 644         }
 645
 646         ret = gb_camera_configure_streams(gcam, &nstreams, &flags, streams);
 647         if (ret < 0)
 648                 goto done;
 649
 650         buffer->length = sprintf(buffer->data, "%u;%u;", nstreams, flags);
 651
 652         for (i = 0; i < nstreams; ++i) {
 653                 struct gb_camera_stream_config *stream = &streams[i];
 654
 655                 buffer->length += sprintf(buffer->data + buffer->length,
 656                                           "%u;%u;%u;%u;%u;%u;%u;",
 657                                           stream->width, stream->height,
 658                                           stream->format, stream->vc,
 659                                           stream->dt[0], stream->dt[1],
 660                                           stream->max_size);
 661         }
 662
 663         ret = len;
 664
 665 done:
 666         kfree(streams);
 667         return ret;
 668 };
 669
 670 static ssize_t gb_camera_debugfs_capture(struct gb_camera *gcam,
 671                 char *buf, size_t len)
 672 {
 673         unsigned int request_id;
 674         unsigned int streams_mask;
 675         unsigned int num_frames;
 676         char *token;
 677         int ret;
 678
 679         /* Request id */
 680         token = strsep(&buf, ";");
 681         if (token == NULL)
 682                 return -EINVAL;
 683         ret = kstrtouint(token, 10, &request_id);
 684         if (ret < 0)
 685                 return ret;
 686
 687         /* Stream mask */
 688         token = strsep(&buf, ";");
 689         if (token == NULL)
 690                 return -EINVAL;
 691         ret = kstrtouint(token, 16, &streams_mask);
 692         if (ret < 0)
 693                 return ret;
 694
 695         /* number of frames */
 696         token = strsep(&buf, ";");
 697         if (token == NULL)
 698                 return -EINVAL;
 699         ret = kstrtouint(token, 10, &num_frames);
 700         if (ret < 0)
 701                 return ret;
 702
 703         ret = gb_camera_capture(gcam, request_id, streams_mask, num_frames, 0,
 704                                 NULL);
 705         if (ret < 0)
 706                 return ret;
 707
 708         return len;
 709 }
 710
 711 static ssize_t gb_camera_debugfs_flush(struct gb_camera *gcam,
 712                 char *buf, size_t len)
 713 {
 714         struct gb_camera_debugfs_buffer *buffer =
 715                 &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_FLUSH];
 716         unsigned int req_id;
 717         int ret;
 718
 719         ret = gb_camera_flush(gcam, &req_id);
 720         if (ret < 0)
 721                 return ret;
 722
 723         buffer->length = sprintf(buffer->data, "%u", req_id);
 724
 725         return len;
 726 }
 727
 728 struct gb_camera_debugfs_entry {
 729         const char *name;
 730         unsigned int mask;
 731         unsigned int buffer;
 732         ssize_t (*execute)(struct gb_camera *gcam, char *buf, size_t len);
 733 };
 734
 735 static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries[] = {
 736         {
 737                 .name = "capabilities",
 738                 .mask = S_IFREG | S_IRUGO,
 739                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
 740                 .execute = gb_camera_debugfs_capabilities,
 741         }, {
 742                 .name = "configure_streams",
 743                 .mask = S_IFREG | S_IRUGO | S_IWUGO,
 744                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
 745                 .execute = gb_camera_debugfs_configure_streams,
 746         }, {
 747                 .name = "capture",
 748                 .mask = S_IFREG | S_IRUGO | S_IWUGO,
 749                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
 750                 .execute = gb_camera_debugfs_capture,
 751         }, {
 752                 .name = "flush",
 753                 .mask = S_IFREG | S_IRUGO | S_IWUGO,
 754                 .buffer = GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
 755                 .execute = gb_camera_debugfs_flush,
 756         },
 757 };
 758
 759 static ssize_t gb_camera_debugfs_read(struct file *file, char __user *buf,
 760                                       size_t len, loff_t *offset)
 761 {
 762         const struct gb_camera_debugfs_entry *op = file->private_data;
 763         struct gb_camera *gcam = file->f_inode->i_private;
 764         struct gb_camera_debugfs_buffer *buffer;
 765         ssize_t ret;
 766
 767         /* For read-only entries the operation is triggered by a read. */
 768         if (!(op->mask & S_IWUGO)) {
 769                 ret = op->execute(gcam, NULL, 0);
 770                 if (ret < 0)
 771                         return ret;
 772         }
 773
 774         buffer = &gcam->debugfs.buffers[op->buffer];
 775
 776         return simple_read_from_buffer(buf, len, offset, buffer->data,
 777                                        buffer->length);
 778 }
 779
 780 static ssize_t gb_camera_debugfs_write(struct file *file,
 781                                        const char __user *buf, size_t len,
 782                                        loff_t *offset)
 783 {
 784         const struct gb_camera_debugfs_entry *op = file->private_data;
 785         struct gb_camera *gcam = file->f_inode->i_private;
 786         ssize_t ret;
 787         char *kbuf;
 788
 789         if (len > 1024)
 790                return -EINVAL;
 791
 792         kbuf = kmalloc(len + 1, GFP_KERNEL);
 793         if (kbuf == NULL)
 794                 return -ENOMEM;
 795
 796         if (copy_from_user(kbuf, buf, len)) {
 797                 ret = -EFAULT;
 798                 goto done;
 799         }
 800
 801         kbuf[len] = '\0';
 802
 803         ret = op->execute(gcam, kbuf, len);
 804
 805 done:
 806         kfree(kbuf);
 807         return ret;
 808 }
 809
 810 static int gb_camera_debugfs_open(struct inode *inode, struct file *file)
 811 {
 812         unsigned int i;
 813
 814         for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
 815                 const struct gb_camera_debugfs_entry *entry =
 816                         &gb_camera_debugfs_entries[i];
 817
 818                 if (!strcmp(file->f_path.dentry->d_iname, entry->name)) {
 819                         file->private_data = (void *)entry;
 820                         break;
 821                 }
 822         }
 823
 824         return 0;
 825 }
 826
 827 static const struct file_operations gb_camera_debugfs_ops = {
 828         .open = gb_camera_debugfs_open,
 829         .read = gb_camera_debugfs_read,
 830         .write = gb_camera_debugfs_write,
 831 };
 832
 833 static int gb_camera_debugfs_init(struct gb_camera *gcam)
 834 {
 835         struct gb_connection *connection = gcam->connection;
 836         char dirname[27];
 837         unsigned int i;
 838
 839         /*
 840          * Create root debugfs entry and a file entry for each camera operation.
 841          */
 842         snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id,
 843                  connection->bundle->id);
 844
 845         gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get());
 846         if (IS_ERR(gcam->debugfs.root)) {
 847                 gcam_err(gcam, "debugfs root create failed (%ld)\n",
 848                          PTR_ERR(gcam->debugfs.root));
 849                 return PTR_ERR(gcam->debugfs.root);
 850         }
 851
 852         gcam->debugfs.buffers = vmalloc(sizeof(*gcam->debugfs.buffers) *
 853                                         GB_CAMERA_DEBUGFS_BUFFER_MAX);
 854         if (!gcam->debugfs.buffers)
 855                 return -ENOMEM;
 856
 857         for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
 858                 const struct gb_camera_debugfs_entry *entry =
 859                         &gb_camera_debugfs_entries[i];
 860                 struct dentry *dentry;
 861
 862                 gcam->debugfs.buffers[i].length = 0;
 863
 864                 dentry = debugfs_create_file(entry->name, entry->mask,
 865                                              gcam->debugfs.root, gcam,
 866                                              &gb_camera_debugfs_ops);
 867                 if (IS_ERR(dentry)) {
 868                         gcam_err(gcam,
 869                                  "debugfs operation %s create failed (%ld)\n",
 870                                  entry->name, PTR_ERR(gcam->debugfs.root));
 871                         return PTR_ERR(dentry);
 872                 }
 873         }
 874
 875         return 0;
 876 }
 877
 878 static void gb_camera_debugfs_cleanup(struct gb_camera *gcam)
 879 {
 880         if (gcam->debugfs.root)
 881                 debugfs_remove_recursive(gcam->debugfs.root);
 882
 883         vfree(gcam->debugfs.buffers);
 884 }
 885
 886 /* -----------------------------------------------------------------------------
 887  * Init & Cleanup
 888  */
 889
 890 static void gb_camera_cleanup(struct gb_camera *gcam)
 891 {
 892         gb_camera_debugfs_cleanup(gcam);
 893
 894         if (gcam->data_connected) {
 895                 struct gb_interface *intf = gcam->connection->intf;
 896                 struct gb_svc *svc = gcam->connection->hd->svc;
 897
 898                 gb_svc_connection_destroy(svc, intf->interface_id,
 899                                           ES2_APB_CDSI0_CPORT, svc->ap_intf_id,
 900                                           ES2_APB_CDSI1_CPORT);
 901         }
 902
 903         kfree(gcam);
 904 }
 905
 906 static int gb_camera_connection_init(struct gb_connection *connection)
 907 {
 908         struct gb_svc *svc = connection->hd->svc;
 909         struct gb_camera *gcam;
 910         u8 cport_flags;
 911         int ret;
 912
 913         gcam = kzalloc(sizeof(*gcam), GFP_KERNEL);
 914         if (!gcam)
 915                 return -ENOMEM;
 916
 917         gcam->connection = connection;
 918         gb_connection_set_data(connection, gcam);
 919
 920         /*
 921          * Create the data connection between camera module CDSI0 and APB CDS1.
 922          * The CPort IDs are hardcoded by the ES2 bridges.
 923          */
 924         cport_flags = GB_SVC_CPORT_FLAG_CSD_N | GB_SVC_CPORT_FLAG_CSV_N;
 925         ret = gb_svc_connection_create(svc, connection->intf->interface_id,
 926                                        ES2_APB_CDSI0_CPORT, svc->ap_intf_id,
 927                                        ES2_APB_CDSI1_CPORT, cport_flags);
 928         if (ret < 0)
 929                 goto error;
 930
 931         gcam->data_connected = true;
 932
 933         ret = gb_camera_debugfs_init(gcam);
 934         if (ret < 0)
 935                 goto error;
 936
 937         ret = gb_camera_register_intf_ops(gcam);
 938         if (ret < 0)
 939                 goto error;
 940
 941         return 0;
 942
 943 error:
 944         gb_camera_cleanup(gcam);
 945         return ret;
 946 }
 947
 948 static void gb_camera_connection_exit(struct gb_connection *connection)
 949 {
 950         struct gb_camera *gcam = gb_connection_get_data(connection);
 951
 952         gb_camera_unregister_intf_ops(gcam);
 953
 954         gb_camera_cleanup(gcam);
 955 }
 956
 957 static struct gb_protocol camera_protocol = {
 958         .name                   = "camera",
 959         .id                     = GREYBUS_PROTOCOL_CAMERA_MGMT,
 960         .major                  = GB_CAMERA_VERSION_MAJOR,
 961         .minor                  = GB_CAMERA_VERSION_MINOR,
 962         .connection_init        = gb_camera_connection_init,
 963         .connection_exit        = gb_camera_connection_exit,
 964         .request_recv           = gb_camera_event_recv,
 965 };
 966
 967 gb_protocol_driver(&camera_protocol);
 968
 969 MODULE_LICENSE("GPL v2");