1 /* 2 * MIPI DSI Bus 3 * 4 * Copyright (C) 2012-2013, Samsung Electronics, Co., Ltd. 5 * Andrzej Hajda <a.hajda@samsung.com> 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the 9 * "Software"), to deal in the Software without restriction, including 10 * without limitation the rights to use, copy, modify, merge, publish, 11 * distribute, sub license, and/or sell copies of the Software, and to 12 * permit persons to whom the Software is furnished to do so, subject to 13 * the following conditions: 14 * 15 * The above copyright notice and this permission notice (including the 16 * next paragraph) shall be included in all copies or substantial portions 17 * of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 22 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, 23 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 24 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 25 * USE OR OTHER DEALINGS IN THE SOFTWARE. 26 */ 27 28 #include <linux/device.h> 29 #include <linux/module.h> 30 #include <linux/of_device.h> 31 #include <linux/pm_runtime.h> 32 #include <linux/slab.h> 33 34 #include <drm/display/drm_dsc.h> 35 #include <drm/drm_mipi_dsi.h> 36 #include <drm/drm_print.h> 37 38 #include <video/mipi_display.h> 39 40 /** 41 * DOC: dsi helpers 42 * 43 * These functions contain some common logic and helpers to deal with MIPI DSI 44 * peripherals. 45 * 46 * Helpers are provided for a number of standard MIPI DSI command as well as a 47 * subset of the MIPI DCS command set. 48 */ 49 50 static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv) 51 { 52 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev); 53 54 /* attempt OF style match */ 55 if (of_driver_match_device(dev, drv)) 56 return 1; 57 58 /* compare DSI device and driver names */ 59 if (!strcmp(dsi->name, drv->name)) 60 return 1; 61 62 return 0; 63 } 64 65 static int mipi_dsi_uevent(const struct device *dev, struct kobj_uevent_env *env) 66 { 67 const struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev); 68 int err; 69 70 err = of_device_uevent_modalias(dev, env); 71 if (err != -ENODEV) 72 return err; 73 74 add_uevent_var(env, "MODALIAS=%s%s", MIPI_DSI_MODULE_PREFIX, 75 dsi->name); 76 77 return 0; 78 } 79 80 static const struct dev_pm_ops mipi_dsi_device_pm_ops = { 81 .runtime_suspend = pm_generic_runtime_suspend, 82 .runtime_resume = pm_generic_runtime_resume, 83 .suspend = pm_generic_suspend, 84 .resume = pm_generic_resume, 85 .freeze = pm_generic_freeze, 86 .thaw = pm_generic_thaw, 87 .poweroff = pm_generic_poweroff, 88 .restore = pm_generic_restore, 89 }; 90 91 static struct bus_type mipi_dsi_bus_type = { 92 .name = "mipi-dsi", 93 .match = mipi_dsi_device_match, 94 .uevent = mipi_dsi_uevent, 95 .pm = &mipi_dsi_device_pm_ops, 96 }; 97 98 /** 99 * of_find_mipi_dsi_device_by_node() - find the MIPI DSI device matching a 100 * device tree node 101 * @np: device tree node 102 * 103 * Return: A pointer to the MIPI DSI device corresponding to @np or NULL if no 104 * such device exists (or has not been registered yet). 105 */ 106 struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np) 107 { 108 struct device *dev; 109 110 dev = bus_find_device_by_of_node(&mipi_dsi_bus_type, np); 111 112 return dev ? to_mipi_dsi_device(dev) : NULL; 113 } 114 EXPORT_SYMBOL(of_find_mipi_dsi_device_by_node); 115 116 static void mipi_dsi_dev_release(struct device *dev) 117 { 118 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev); 119 120 of_node_put(dev->of_node); 121 kfree(dsi); 122 } 123 124 static const struct device_type mipi_dsi_device_type = { 125 .release = mipi_dsi_dev_release, 126 }; 127 128 static struct mipi_dsi_device *mipi_dsi_device_alloc(struct mipi_dsi_host *host) 129 { 130 struct mipi_dsi_device *dsi; 131 132 dsi = kzalloc(sizeof(*dsi), GFP_KERNEL); 133 if (!dsi) 134 return ERR_PTR(-ENOMEM); 135 136 dsi->host = host; 137 dsi->dev.bus = &mipi_dsi_bus_type; 138 dsi->dev.parent = host->dev; 139 dsi->dev.type = &mipi_dsi_device_type; 140 141 device_initialize(&dsi->dev); 142 143 return dsi; 144 } 145 146 static int mipi_dsi_device_add(struct mipi_dsi_device *dsi) 147 { 148 struct mipi_dsi_host *host = dsi->host; 149 150 dev_set_name(&dsi->dev, "%s.%d", dev_name(host->dev), dsi->channel); 151 152 return device_add(&dsi->dev); 153 } 154 155 #if IS_ENABLED(CONFIG_OF) 156 static struct mipi_dsi_device * 157 of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node) 158 { 159 struct mipi_dsi_device_info info = { }; 160 int ret; 161 u32 reg; 162 163 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) { 164 drm_err(host, "modalias failure on %pOF\n", node); 165 return ERR_PTR(-EINVAL); 166 } 167 168 ret = of_property_read_u32(node, "reg", ®); 169 if (ret) { 170 drm_err(host, "device node %pOF has no valid reg property: %d\n", 171 node, ret); 172 return ERR_PTR(-EINVAL); 173 } 174 175 info.channel = reg; 176 info.node = of_node_get(node); 177 178 return mipi_dsi_device_register_full(host, &info); 179 } 180 #else 181 static struct mipi_dsi_device * 182 of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node) 183 { 184 return ERR_PTR(-ENODEV); 185 } 186 #endif 187 188 /** 189 * mipi_dsi_device_register_full - create a MIPI DSI device 190 * @host: DSI host to which this device is connected 191 * @info: pointer to template containing DSI device information 192 * 193 * Create a MIPI DSI device by using the device information provided by 194 * mipi_dsi_device_info template 195 * 196 * Returns: 197 * A pointer to the newly created MIPI DSI device, or, a pointer encoded 198 * with an error 199 */ 200 struct mipi_dsi_device * 201 mipi_dsi_device_register_full(struct mipi_dsi_host *host, 202 const struct mipi_dsi_device_info *info) 203 { 204 struct mipi_dsi_device *dsi; 205 int ret; 206 207 if (!info) { 208 drm_err(host, "invalid mipi_dsi_device_info pointer\n"); 209 return ERR_PTR(-EINVAL); 210 } 211 212 if (info->channel > 3) { 213 drm_err(host, "invalid virtual channel: %u\n", info->channel); 214 return ERR_PTR(-EINVAL); 215 } 216 217 dsi = mipi_dsi_device_alloc(host); 218 if (IS_ERR(dsi)) { 219 drm_err(host, "failed to allocate DSI device %ld\n", 220 PTR_ERR(dsi)); 221 return dsi; 222 } 223 224 dsi->dev.of_node = info->node; 225 dsi->channel = info->channel; 226 strlcpy(dsi->name, info->type, sizeof(dsi->name)); 227 228 ret = mipi_dsi_device_add(dsi); 229 if (ret) { 230 drm_err(host, "failed to add DSI device %d\n", ret); 231 kfree(dsi); 232 return ERR_PTR(ret); 233 } 234 235 return dsi; 236 } 237 EXPORT_SYMBOL(mipi_dsi_device_register_full); 238 239 /** 240 * mipi_dsi_device_unregister - unregister MIPI DSI device 241 * @dsi: DSI peripheral device 242 */ 243 void mipi_dsi_device_unregister(struct mipi_dsi_device *dsi) 244 { 245 device_unregister(&dsi->dev); 246 } 247 EXPORT_SYMBOL(mipi_dsi_device_unregister); 248 249 static void devm_mipi_dsi_device_unregister(void *arg) 250 { 251 struct mipi_dsi_device *dsi = arg; 252 253 mipi_dsi_device_unregister(dsi); 254 } 255 256 /** 257 * devm_mipi_dsi_device_register_full - create a managed MIPI DSI device 258 * @dev: device to tie the MIPI-DSI device lifetime to 259 * @host: DSI host to which this device is connected 260 * @info: pointer to template containing DSI device information 261 * 262 * Create a MIPI DSI device by using the device information provided by 263 * mipi_dsi_device_info template 264 * 265 * This is the managed version of mipi_dsi_device_register_full() which 266 * automatically calls mipi_dsi_device_unregister() when @dev is 267 * unbound. 268 * 269 * Returns: 270 * A pointer to the newly created MIPI DSI device, or, a pointer encoded 271 * with an error 272 */ 273 struct mipi_dsi_device * 274 devm_mipi_dsi_device_register_full(struct device *dev, 275 struct mipi_dsi_host *host, 276 const struct mipi_dsi_device_info *info) 277 { 278 struct mipi_dsi_device *dsi; 279 int ret; 280 281 dsi = mipi_dsi_device_register_full(host, info); 282 if (IS_ERR(dsi)) 283 return dsi; 284 285 ret = devm_add_action_or_reset(dev, 286 devm_mipi_dsi_device_unregister, 287 dsi); 288 if (ret) 289 return ERR_PTR(ret); 290 291 return dsi; 292 } 293 EXPORT_SYMBOL_GPL(devm_mipi_dsi_device_register_full); 294 295 static DEFINE_MUTEX(host_lock); 296 static LIST_HEAD(host_list); 297 298 /** 299 * of_find_mipi_dsi_host_by_node() - find the MIPI DSI host matching a 300 * device tree node 301 * @node: device tree node 302 * 303 * Returns: 304 * A pointer to the MIPI DSI host corresponding to @node or NULL if no 305 * such device exists (or has not been registered yet). 306 */ 307 struct mipi_dsi_host *of_find_mipi_dsi_host_by_node(struct device_node *node) 308 { 309 struct mipi_dsi_host *host; 310 311 mutex_lock(&host_lock); 312 313 list_for_each_entry(host, &host_list, list) { 314 if (host->dev->of_node == node) { 315 mutex_unlock(&host_lock); 316 return host; 317 } 318 } 319 320 mutex_unlock(&host_lock); 321 322 return NULL; 323 } 324 EXPORT_SYMBOL(of_find_mipi_dsi_host_by_node); 325 326 int mipi_dsi_host_register(struct mipi_dsi_host *host) 327 { 328 struct device_node *node; 329 330 for_each_available_child_of_node(host->dev->of_node, node) { 331 /* skip nodes without reg property */ 332 if (!of_property_present(node, "reg")) 333 continue; 334 of_mipi_dsi_device_add(host, node); 335 } 336 337 mutex_lock(&host_lock); 338 list_add_tail(&host->list, &host_list); 339 mutex_unlock(&host_lock); 340 341 return 0; 342 } 343 EXPORT_SYMBOL(mipi_dsi_host_register); 344 345 static int mipi_dsi_remove_device_fn(struct device *dev, void *priv) 346 { 347 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev); 348 349 mipi_dsi_detach(dsi); 350 mipi_dsi_device_unregister(dsi); 351 352 return 0; 353 } 354 355 void mipi_dsi_host_unregister(struct mipi_dsi_host *host) 356 { 357 device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn); 358 359 mutex_lock(&host_lock); 360 list_del_init(&host->list); 361 mutex_unlock(&host_lock); 362 } 363 EXPORT_SYMBOL(mipi_dsi_host_unregister); 364 365 /** 366 * mipi_dsi_attach - attach a DSI device to its DSI host 367 * @dsi: DSI peripheral 368 */ 369 int mipi_dsi_attach(struct mipi_dsi_device *dsi) 370 { 371 const struct mipi_dsi_host_ops *ops = dsi->host->ops; 372 373 if (!ops || !ops->attach) 374 return -ENOSYS; 375 376 return ops->attach(dsi->host, dsi); 377 } 378 EXPORT_SYMBOL(mipi_dsi_attach); 379 380 /** 381 * mipi_dsi_detach - detach a DSI device from its DSI host 382 * @dsi: DSI peripheral 383 */ 384 int mipi_dsi_detach(struct mipi_dsi_device *dsi) 385 { 386 const struct mipi_dsi_host_ops *ops = dsi->host->ops; 387 388 if (!ops || !ops->detach) 389 return -ENOSYS; 390 391 return ops->detach(dsi->host, dsi); 392 } 393 EXPORT_SYMBOL(mipi_dsi_detach); 394 395 static void devm_mipi_dsi_detach(void *arg) 396 { 397 struct mipi_dsi_device *dsi = arg; 398 399 mipi_dsi_detach(dsi); 400 } 401 402 /** 403 * devm_mipi_dsi_attach - Attach a MIPI-DSI device to its DSI Host 404 * @dev: device to tie the MIPI-DSI device attachment lifetime to 405 * @dsi: DSI peripheral 406 * 407 * This is the managed version of mipi_dsi_attach() which automatically 408 * calls mipi_dsi_detach() when @dev is unbound. 409 * 410 * Returns: 411 * 0 on success, a negative error code on failure. 412 */ 413 int devm_mipi_dsi_attach(struct device *dev, 414 struct mipi_dsi_device *dsi) 415 { 416 int ret; 417 418 ret = mipi_dsi_attach(dsi); 419 if (ret) 420 return ret; 421 422 ret = devm_add_action_or_reset(dev, devm_mipi_dsi_detach, dsi); 423 if (ret) 424 return ret; 425 426 return 0; 427 } 428 EXPORT_SYMBOL_GPL(devm_mipi_dsi_attach); 429 430 static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi, 431 struct mipi_dsi_msg *msg) 432 { 433 const struct mipi_dsi_host_ops *ops = dsi->host->ops; 434 435 if (!ops || !ops->transfer) 436 return -ENOSYS; 437 438 if (dsi->mode_flags & MIPI_DSI_MODE_LPM) 439 msg->flags |= MIPI_DSI_MSG_USE_LPM; 440 441 return ops->transfer(dsi->host, msg); 442 } 443 444 /** 445 * mipi_dsi_packet_format_is_short - check if a packet is of the short format 446 * @type: MIPI DSI data type of the packet 447 * 448 * Return: true if the packet for the given data type is a short packet, false 449 * otherwise. 450 */ 451 bool mipi_dsi_packet_format_is_short(u8 type) 452 { 453 switch (type) { 454 case MIPI_DSI_V_SYNC_START: 455 case MIPI_DSI_V_SYNC_END: 456 case MIPI_DSI_H_SYNC_START: 457 case MIPI_DSI_H_SYNC_END: 458 case MIPI_DSI_COMPRESSION_MODE: 459 case MIPI_DSI_END_OF_TRANSMISSION: 460 case MIPI_DSI_COLOR_MODE_OFF: 461 case MIPI_DSI_COLOR_MODE_ON: 462 case MIPI_DSI_SHUTDOWN_PERIPHERAL: 463 case MIPI_DSI_TURN_ON_PERIPHERAL: 464 case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM: 465 case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM: 466 case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM: 467 case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM: 468 case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM: 469 case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM: 470 case MIPI_DSI_DCS_SHORT_WRITE: 471 case MIPI_DSI_DCS_SHORT_WRITE_PARAM: 472 case MIPI_DSI_DCS_READ: 473 case MIPI_DSI_EXECUTE_QUEUE: 474 case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE: 475 return true; 476 } 477 478 return false; 479 } 480 EXPORT_SYMBOL(mipi_dsi_packet_format_is_short); 481 482 /** 483 * mipi_dsi_packet_format_is_long - check if a packet is of the long format 484 * @type: MIPI DSI data type of the packet 485 * 486 * Return: true if the packet for the given data type is a long packet, false 487 * otherwise. 488 */ 489 bool mipi_dsi_packet_format_is_long(u8 type) 490 { 491 switch (type) { 492 case MIPI_DSI_NULL_PACKET: 493 case MIPI_DSI_BLANKING_PACKET: 494 case MIPI_DSI_GENERIC_LONG_WRITE: 495 case MIPI_DSI_DCS_LONG_WRITE: 496 case MIPI_DSI_PICTURE_PARAMETER_SET: 497 case MIPI_DSI_COMPRESSED_PIXEL_STREAM: 498 case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20: 499 case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24: 500 case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16: 501 case MIPI_DSI_PACKED_PIXEL_STREAM_30: 502 case MIPI_DSI_PACKED_PIXEL_STREAM_36: 503 case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12: 504 case MIPI_DSI_PACKED_PIXEL_STREAM_16: 505 case MIPI_DSI_PACKED_PIXEL_STREAM_18: 506 case MIPI_DSI_PIXEL_STREAM_3BYTE_18: 507 case MIPI_DSI_PACKED_PIXEL_STREAM_24: 508 return true; 509 } 510 511 return false; 512 } 513 EXPORT_SYMBOL(mipi_dsi_packet_format_is_long); 514 515 /** 516 * mipi_dsi_create_packet - create a packet from a message according to the 517 * DSI protocol 518 * @packet: pointer to a DSI packet structure 519 * @msg: message to translate into a packet 520 * 521 * Return: 0 on success or a negative error code on failure. 522 */ 523 int mipi_dsi_create_packet(struct mipi_dsi_packet *packet, 524 const struct mipi_dsi_msg *msg) 525 { 526 if (!packet || !msg) 527 return -EINVAL; 528 529 /* do some minimum sanity checking */ 530 if (!mipi_dsi_packet_format_is_short(msg->type) && 531 !mipi_dsi_packet_format_is_long(msg->type)) 532 return -EINVAL; 533 534 if (msg->channel > 3) 535 return -EINVAL; 536 537 memset(packet, 0, sizeof(*packet)); 538 packet->header[0] = ((msg->channel & 0x3) << 6) | (msg->type & 0x3f); 539 540 /* TODO: compute ECC if hardware support is not available */ 541 542 /* 543 * Long write packets contain the word count in header bytes 1 and 2. 544 * The payload follows the header and is word count bytes long. 545 * 546 * Short write packets encode up to two parameters in header bytes 1 547 * and 2. 548 */ 549 if (mipi_dsi_packet_format_is_long(msg->type)) { 550 packet->header[1] = (msg->tx_len >> 0) & 0xff; 551 packet->header[2] = (msg->tx_len >> 8) & 0xff; 552 553 packet->payload_length = msg->tx_len; 554 packet->payload = msg->tx_buf; 555 } else { 556 const u8 *tx = msg->tx_buf; 557 558 packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0; 559 packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0; 560 } 561 562 packet->size = sizeof(packet->header) + packet->payload_length; 563 564 return 0; 565 } 566 EXPORT_SYMBOL(mipi_dsi_create_packet); 567 568 /** 569 * mipi_dsi_shutdown_peripheral() - sends a Shutdown Peripheral command 570 * @dsi: DSI peripheral device 571 * 572 * Return: 0 on success or a negative error code on failure. 573 */ 574 int mipi_dsi_shutdown_peripheral(struct mipi_dsi_device *dsi) 575 { 576 struct mipi_dsi_msg msg = { 577 .channel = dsi->channel, 578 .type = MIPI_DSI_SHUTDOWN_PERIPHERAL, 579 .tx_buf = (u8 [2]) { 0, 0 }, 580 .tx_len = 2, 581 }; 582 int ret = mipi_dsi_device_transfer(dsi, &msg); 583 584 return (ret < 0) ? ret : 0; 585 } 586 EXPORT_SYMBOL(mipi_dsi_shutdown_peripheral); 587 588 /** 589 * mipi_dsi_turn_on_peripheral() - sends a Turn On Peripheral command 590 * @dsi: DSI peripheral device 591 * 592 * Return: 0 on success or a negative error code on failure. 593 */ 594 int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi) 595 { 596 struct mipi_dsi_msg msg = { 597 .channel = dsi->channel, 598 .type = MIPI_DSI_TURN_ON_PERIPHERAL, 599 .tx_buf = (u8 [2]) { 0, 0 }, 600 .tx_len = 2, 601 }; 602 int ret = mipi_dsi_device_transfer(dsi, &msg); 603 604 return (ret < 0) ? ret : 0; 605 } 606 EXPORT_SYMBOL(mipi_dsi_turn_on_peripheral); 607 608 /* 609 * mipi_dsi_set_maximum_return_packet_size() - specify the maximum size of 610 * the payload in a long packet transmitted from the peripheral back to the 611 * host processor 612 * @dsi: DSI peripheral device 613 * @value: the maximum size of the payload 614 * 615 * Return: 0 on success or a negative error code on failure. 616 */ 617 int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi, 618 u16 value) 619 { 620 u8 tx[2] = { value & 0xff, value >> 8 }; 621 struct mipi_dsi_msg msg = { 622 .channel = dsi->channel, 623 .type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE, 624 .tx_len = sizeof(tx), 625 .tx_buf = tx, 626 }; 627 int ret = mipi_dsi_device_transfer(dsi, &msg); 628 629 return (ret < 0) ? ret : 0; 630 } 631 EXPORT_SYMBOL(mipi_dsi_set_maximum_return_packet_size); 632 633 /** 634 * mipi_dsi_compression_mode() - enable/disable DSC on the peripheral 635 * @dsi: DSI peripheral device 636 * @enable: Whether to enable or disable the DSC 637 * 638 * Enable or disable Display Stream Compression on the peripheral using the 639 * default Picture Parameter Set and VESA DSC 1.1 algorithm. 640 * 641 * Return: 0 on success or a negative error code on failure. 642 */ 643 ssize_t mipi_dsi_compression_mode(struct mipi_dsi_device *dsi, bool enable) 644 { 645 /* Note: Needs updating for non-default PPS or algorithm */ 646 u8 tx[2] = { enable << 0, 0 }; 647 struct mipi_dsi_msg msg = { 648 .channel = dsi->channel, 649 .type = MIPI_DSI_COMPRESSION_MODE, 650 .tx_len = sizeof(tx), 651 .tx_buf = tx, 652 }; 653 int ret = mipi_dsi_device_transfer(dsi, &msg); 654 655 return (ret < 0) ? ret : 0; 656 } 657 EXPORT_SYMBOL(mipi_dsi_compression_mode); 658 659 /** 660 * mipi_dsi_picture_parameter_set() - transmit the DSC PPS to the peripheral 661 * @dsi: DSI peripheral device 662 * @pps: VESA DSC 1.1 Picture Parameter Set 663 * 664 * Transmit the VESA DSC 1.1 Picture Parameter Set to the peripheral. 665 * 666 * Return: 0 on success or a negative error code on failure. 667 */ 668 ssize_t mipi_dsi_picture_parameter_set(struct mipi_dsi_device *dsi, 669 const struct drm_dsc_picture_parameter_set *pps) 670 { 671 struct mipi_dsi_msg msg = { 672 .channel = dsi->channel, 673 .type = MIPI_DSI_PICTURE_PARAMETER_SET, 674 .tx_len = sizeof(*pps), 675 .tx_buf = pps, 676 }; 677 int ret = mipi_dsi_device_transfer(dsi, &msg); 678 679 return (ret < 0) ? ret : 0; 680 } 681 EXPORT_SYMBOL(mipi_dsi_picture_parameter_set); 682 683 /** 684 * mipi_dsi_generic_write() - transmit data using a generic write packet 685 * @dsi: DSI peripheral device 686 * @payload: buffer containing the payload 687 * @size: size of payload buffer 688 * 689 * This function will automatically choose the right data type depending on 690 * the payload length. 691 * 692 * Return: The number of bytes transmitted on success or a negative error code 693 * on failure. 694 */ 695 ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload, 696 size_t size) 697 { 698 struct mipi_dsi_msg msg = { 699 .channel = dsi->channel, 700 .tx_buf = payload, 701 .tx_len = size 702 }; 703 704 switch (size) { 705 case 0: 706 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM; 707 break; 708 709 case 1: 710 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM; 711 break; 712 713 case 2: 714 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM; 715 break; 716 717 default: 718 msg.type = MIPI_DSI_GENERIC_LONG_WRITE; 719 break; 720 } 721 722 return mipi_dsi_device_transfer(dsi, &msg); 723 } 724 EXPORT_SYMBOL(mipi_dsi_generic_write); 725 726 /** 727 * mipi_dsi_generic_read() - receive data using a generic read packet 728 * @dsi: DSI peripheral device 729 * @params: buffer containing the request parameters 730 * @num_params: number of request parameters 731 * @data: buffer in which to return the received data 732 * @size: size of receive buffer 733 * 734 * This function will automatically choose the right data type depending on 735 * the number of parameters passed in. 736 * 737 * Return: The number of bytes successfully read or a negative error code on 738 * failure. 739 */ 740 ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params, 741 size_t num_params, void *data, size_t size) 742 { 743 struct mipi_dsi_msg msg = { 744 .channel = dsi->channel, 745 .tx_len = num_params, 746 .tx_buf = params, 747 .rx_len = size, 748 .rx_buf = data 749 }; 750 751 switch (num_params) { 752 case 0: 753 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM; 754 break; 755 756 case 1: 757 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM; 758 break; 759 760 case 2: 761 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM; 762 break; 763 764 default: 765 return -EINVAL; 766 } 767 768 return mipi_dsi_device_transfer(dsi, &msg); 769 } 770 EXPORT_SYMBOL(mipi_dsi_generic_read); 771 772 /** 773 * mipi_dsi_dcs_write_buffer() - transmit a DCS command with payload 774 * @dsi: DSI peripheral device 775 * @data: buffer containing data to be transmitted 776 * @len: size of transmission buffer 777 * 778 * This function will automatically choose the right data type depending on 779 * the command payload length. 780 * 781 * Return: The number of bytes successfully transmitted or a negative error 782 * code on failure. 783 */ 784 ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi, 785 const void *data, size_t len) 786 { 787 struct mipi_dsi_msg msg = { 788 .channel = dsi->channel, 789 .tx_buf = data, 790 .tx_len = len 791 }; 792 793 switch (len) { 794 case 0: 795 return -EINVAL; 796 797 case 1: 798 msg.type = MIPI_DSI_DCS_SHORT_WRITE; 799 break; 800 801 case 2: 802 msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM; 803 break; 804 805 default: 806 msg.type = MIPI_DSI_DCS_LONG_WRITE; 807 break; 808 } 809 810 return mipi_dsi_device_transfer(dsi, &msg); 811 } 812 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer); 813 814 /** 815 * mipi_dsi_dcs_write() - send DCS write command 816 * @dsi: DSI peripheral device 817 * @cmd: DCS command 818 * @data: buffer containing the command payload 819 * @len: command payload length 820 * 821 * This function will automatically choose the right data type depending on 822 * the command payload length. 823 * 824 * Return: The number of bytes successfully transmitted or a negative error 825 * code on failure. 826 */ 827 ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd, 828 const void *data, size_t len) 829 { 830 ssize_t err; 831 size_t size; 832 u8 stack_tx[8]; 833 u8 *tx; 834 835 size = 1 + len; 836 if (len > ARRAY_SIZE(stack_tx) - 1) { 837 tx = kmalloc(size, GFP_KERNEL); 838 if (!tx) 839 return -ENOMEM; 840 } else { 841 tx = stack_tx; 842 } 843 844 /* concatenate the DCS command byte and the payload */ 845 tx[0] = cmd; 846 if (data) 847 memcpy(&tx[1], data, len); 848 849 err = mipi_dsi_dcs_write_buffer(dsi, tx, size); 850 851 if (tx != stack_tx) 852 kfree(tx); 853 854 return err; 855 } 856 EXPORT_SYMBOL(mipi_dsi_dcs_write); 857 858 /** 859 * mipi_dsi_dcs_read() - send DCS read request command 860 * @dsi: DSI peripheral device 861 * @cmd: DCS command 862 * @data: buffer in which to receive data 863 * @len: size of receive buffer 864 * 865 * Return: The number of bytes read or a negative error code on failure. 866 */ 867 ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data, 868 size_t len) 869 { 870 struct mipi_dsi_msg msg = { 871 .channel = dsi->channel, 872 .type = MIPI_DSI_DCS_READ, 873 .tx_buf = &cmd, 874 .tx_len = 1, 875 .rx_buf = data, 876 .rx_len = len 877 }; 878 879 return mipi_dsi_device_transfer(dsi, &msg); 880 } 881 EXPORT_SYMBOL(mipi_dsi_dcs_read); 882 883 /** 884 * mipi_dsi_dcs_nop() - send DCS nop packet 885 * @dsi: DSI peripheral device 886 * 887 * Return: 0 on success or a negative error code on failure. 888 */ 889 int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi) 890 { 891 ssize_t err; 892 893 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_NOP, NULL, 0); 894 if (err < 0) 895 return err; 896 897 return 0; 898 } 899 EXPORT_SYMBOL(mipi_dsi_dcs_nop); 900 901 /** 902 * mipi_dsi_dcs_soft_reset() - perform a software reset of the display module 903 * @dsi: DSI peripheral device 904 * 905 * Return: 0 on success or a negative error code on failure. 906 */ 907 int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi) 908 { 909 ssize_t err; 910 911 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SOFT_RESET, NULL, 0); 912 if (err < 0) 913 return err; 914 915 return 0; 916 } 917 EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset); 918 919 /** 920 * mipi_dsi_dcs_get_power_mode() - query the display module's current power 921 * mode 922 * @dsi: DSI peripheral device 923 * @mode: return location for the current power mode 924 * 925 * Return: 0 on success or a negative error code on failure. 926 */ 927 int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode) 928 { 929 ssize_t err; 930 931 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_POWER_MODE, mode, 932 sizeof(*mode)); 933 if (err <= 0) { 934 if (err == 0) 935 err = -ENODATA; 936 937 return err; 938 } 939 940 return 0; 941 } 942 EXPORT_SYMBOL(mipi_dsi_dcs_get_power_mode); 943 944 /** 945 * mipi_dsi_dcs_get_pixel_format() - gets the pixel format for the RGB image 946 * data used by the interface 947 * @dsi: DSI peripheral device 948 * @format: return location for the pixel format 949 * 950 * Return: 0 on success or a negative error code on failure. 951 */ 952 int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format) 953 { 954 ssize_t err; 955 956 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_PIXEL_FORMAT, format, 957 sizeof(*format)); 958 if (err <= 0) { 959 if (err == 0) 960 err = -ENODATA; 961 962 return err; 963 } 964 965 return 0; 966 } 967 EXPORT_SYMBOL(mipi_dsi_dcs_get_pixel_format); 968 969 /** 970 * mipi_dsi_dcs_enter_sleep_mode() - disable all unnecessary blocks inside the 971 * display module except interface communication 972 * @dsi: DSI peripheral device 973 * 974 * Return: 0 on success or a negative error code on failure. 975 */ 976 int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi) 977 { 978 ssize_t err; 979 980 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0); 981 if (err < 0) 982 return err; 983 984 return 0; 985 } 986 EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode); 987 988 /** 989 * mipi_dsi_dcs_exit_sleep_mode() - enable all blocks inside the display 990 * module 991 * @dsi: DSI peripheral device 992 * 993 * Return: 0 on success or a negative error code on failure. 994 */ 995 int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi) 996 { 997 ssize_t err; 998 999 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0); 1000 if (err < 0) 1001 return err; 1002 1003 return 0; 1004 } 1005 EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode); 1006 1007 /** 1008 * mipi_dsi_dcs_set_display_off() - stop displaying the image data on the 1009 * display device 1010 * @dsi: DSI peripheral device 1011 * 1012 * Return: 0 on success or a negative error code on failure. 1013 */ 1014 int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi) 1015 { 1016 ssize_t err; 1017 1018 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0); 1019 if (err < 0) 1020 return err; 1021 1022 return 0; 1023 } 1024 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off); 1025 1026 /** 1027 * mipi_dsi_dcs_set_display_on() - start displaying the image data on the 1028 * display device 1029 * @dsi: DSI peripheral device 1030 * 1031 * Return: 0 on success or a negative error code on failure 1032 */ 1033 int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi) 1034 { 1035 ssize_t err; 1036 1037 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0); 1038 if (err < 0) 1039 return err; 1040 1041 return 0; 1042 } 1043 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on); 1044 1045 /** 1046 * mipi_dsi_dcs_set_column_address() - define the column extent of the frame 1047 * memory accessed by the host processor 1048 * @dsi: DSI peripheral device 1049 * @start: first column of frame memory 1050 * @end: last column of frame memory 1051 * 1052 * Return: 0 on success or a negative error code on failure. 1053 */ 1054 int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start, 1055 u16 end) 1056 { 1057 u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff }; 1058 ssize_t err; 1059 1060 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_COLUMN_ADDRESS, payload, 1061 sizeof(payload)); 1062 if (err < 0) 1063 return err; 1064 1065 return 0; 1066 } 1067 EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address); 1068 1069 /** 1070 * mipi_dsi_dcs_set_page_address() - define the page extent of the frame 1071 * memory accessed by the host processor 1072 * @dsi: DSI peripheral device 1073 * @start: first page of frame memory 1074 * @end: last page of frame memory 1075 * 1076 * Return: 0 on success or a negative error code on failure. 1077 */ 1078 int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start, 1079 u16 end) 1080 { 1081 u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff }; 1082 ssize_t err; 1083 1084 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PAGE_ADDRESS, payload, 1085 sizeof(payload)); 1086 if (err < 0) 1087 return err; 1088 1089 return 0; 1090 } 1091 EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address); 1092 1093 /** 1094 * mipi_dsi_dcs_set_tear_off() - turn off the display module's Tearing Effect 1095 * output signal on the TE signal line 1096 * @dsi: DSI peripheral device 1097 * 1098 * Return: 0 on success or a negative error code on failure 1099 */ 1100 int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi) 1101 { 1102 ssize_t err; 1103 1104 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_OFF, NULL, 0); 1105 if (err < 0) 1106 return err; 1107 1108 return 0; 1109 } 1110 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_off); 1111 1112 /** 1113 * mipi_dsi_dcs_set_tear_on() - turn on the display module's Tearing Effect 1114 * output signal on the TE signal line. 1115 * @dsi: DSI peripheral device 1116 * @mode: the Tearing Effect Output Line mode 1117 * 1118 * Return: 0 on success or a negative error code on failure 1119 */ 1120 int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi, 1121 enum mipi_dsi_dcs_tear_mode mode) 1122 { 1123 u8 value = mode; 1124 ssize_t err; 1125 1126 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_ON, &value, 1127 sizeof(value)); 1128 if (err < 0) 1129 return err; 1130 1131 return 0; 1132 } 1133 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on); 1134 1135 /** 1136 * mipi_dsi_dcs_set_pixel_format() - sets the pixel format for the RGB image 1137 * data used by the interface 1138 * @dsi: DSI peripheral device 1139 * @format: pixel format 1140 * 1141 * Return: 0 on success or a negative error code on failure. 1142 */ 1143 int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format) 1144 { 1145 ssize_t err; 1146 1147 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PIXEL_FORMAT, &format, 1148 sizeof(format)); 1149 if (err < 0) 1150 return err; 1151 1152 return 0; 1153 } 1154 EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format); 1155 1156 /** 1157 * mipi_dsi_dcs_set_tear_scanline() - set the scanline to use as trigger for 1158 * the Tearing Effect output signal of the display module 1159 * @dsi: DSI peripheral device 1160 * @scanline: scanline to use as trigger 1161 * 1162 * Return: 0 on success or a negative error code on failure 1163 */ 1164 int mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device *dsi, u16 scanline) 1165 { 1166 u8 payload[2] = { scanline >> 8, scanline & 0xff }; 1167 ssize_t err; 1168 1169 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_SCANLINE, payload, 1170 sizeof(payload)); 1171 if (err < 0) 1172 return err; 1173 1174 return 0; 1175 } 1176 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_scanline); 1177 1178 /** 1179 * mipi_dsi_dcs_set_display_brightness() - sets the brightness value of the 1180 * display 1181 * @dsi: DSI peripheral device 1182 * @brightness: brightness value 1183 * 1184 * Return: 0 on success or a negative error code on failure. 1185 */ 1186 int mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device *dsi, 1187 u16 brightness) 1188 { 1189 u8 payload[2] = { brightness & 0xff, brightness >> 8 }; 1190 ssize_t err; 1191 1192 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS, 1193 payload, sizeof(payload)); 1194 if (err < 0) 1195 return err; 1196 1197 return 0; 1198 } 1199 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness); 1200 1201 /** 1202 * mipi_dsi_dcs_get_display_brightness() - gets the current brightness value 1203 * of the display 1204 * @dsi: DSI peripheral device 1205 * @brightness: brightness value 1206 * 1207 * Return: 0 on success or a negative error code on failure. 1208 */ 1209 int mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device *dsi, 1210 u16 *brightness) 1211 { 1212 ssize_t err; 1213 1214 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS, 1215 brightness, sizeof(*brightness)); 1216 if (err <= 0) { 1217 if (err == 0) 1218 err = -ENODATA; 1219 1220 return err; 1221 } 1222 1223 return 0; 1224 } 1225 EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness); 1226 1227 /** 1228 * mipi_dsi_dcs_set_display_brightness_large() - sets the 16-bit brightness value 1229 * of the display 1230 * @dsi: DSI peripheral device 1231 * @brightness: brightness value 1232 * 1233 * Return: 0 on success or a negative error code on failure. 1234 */ 1235 int mipi_dsi_dcs_set_display_brightness_large(struct mipi_dsi_device *dsi, 1236 u16 brightness) 1237 { 1238 u8 payload[2] = { brightness >> 8, brightness & 0xff }; 1239 ssize_t err; 1240 1241 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS, 1242 payload, sizeof(payload)); 1243 if (err < 0) 1244 return err; 1245 1246 return 0; 1247 } 1248 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness_large); 1249 1250 /** 1251 * mipi_dsi_dcs_get_display_brightness_large() - gets the current 16-bit 1252 * brightness value of the display 1253 * @dsi: DSI peripheral device 1254 * @brightness: brightness value 1255 * 1256 * Return: 0 on success or a negative error code on failure. 1257 */ 1258 int mipi_dsi_dcs_get_display_brightness_large(struct mipi_dsi_device *dsi, 1259 u16 *brightness) 1260 { 1261 u8 brightness_be[2]; 1262 ssize_t err; 1263 1264 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS, 1265 brightness_be, sizeof(brightness_be)); 1266 if (err <= 0) { 1267 if (err == 0) 1268 err = -ENODATA; 1269 1270 return err; 1271 } 1272 1273 *brightness = (brightness_be[0] << 8) | brightness_be[1]; 1274 1275 return 0; 1276 } 1277 EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness_large); 1278 1279 static int mipi_dsi_drv_probe(struct device *dev) 1280 { 1281 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver); 1282 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev); 1283 1284 return drv->probe(dsi); 1285 } 1286 1287 static int mipi_dsi_drv_remove(struct device *dev) 1288 { 1289 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver); 1290 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev); 1291 1292 drv->remove(dsi); 1293 1294 return 0; 1295 } 1296 1297 static void mipi_dsi_drv_shutdown(struct device *dev) 1298 { 1299 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver); 1300 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev); 1301 1302 drv->shutdown(dsi); 1303 } 1304 1305 /** 1306 * mipi_dsi_driver_register_full() - register a driver for DSI devices 1307 * @drv: DSI driver structure 1308 * @owner: owner module 1309 * 1310 * Return: 0 on success or a negative error code on failure. 1311 */ 1312 int mipi_dsi_driver_register_full(struct mipi_dsi_driver *drv, 1313 struct module *owner) 1314 { 1315 drv->driver.bus = &mipi_dsi_bus_type; 1316 drv->driver.owner = owner; 1317 1318 if (drv->probe) 1319 drv->driver.probe = mipi_dsi_drv_probe; 1320 if (drv->remove) 1321 drv->driver.remove = mipi_dsi_drv_remove; 1322 if (drv->shutdown) 1323 drv->driver.shutdown = mipi_dsi_drv_shutdown; 1324 1325 return driver_register(&drv->driver); 1326 } 1327 EXPORT_SYMBOL(mipi_dsi_driver_register_full); 1328 1329 /** 1330 * mipi_dsi_driver_unregister() - unregister a driver for DSI devices 1331 * @drv: DSI driver structure 1332 * 1333 * Return: 0 on success or a negative error code on failure. 1334 */ 1335 void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv) 1336 { 1337 driver_unregister(&drv->driver); 1338 } 1339 EXPORT_SYMBOL(mipi_dsi_driver_unregister); 1340 1341 static int __init mipi_dsi_bus_init(void) 1342 { 1343 return bus_register(&mipi_dsi_bus_type); 1344 } 1345 postcore_initcall(mipi_dsi_bus_init); 1346 1347 MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>"); 1348 MODULE_DESCRIPTION("MIPI DSI Bus"); 1349 MODULE_LICENSE("GPL and additional rights"); 1350