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