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