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