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