drivers/gpu/drm/drm_mipi_dsi.c

   1 /*
   2  * MIPI DSI Bus
   3  *
   4  * Copyright (C) 2012-2013, Samsung Electronics, Co., Ltd.
   5  * Andrzej Hajda <[email protected]>
   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 <drm/drm_mipi_dsi.h>
  29
  30 #include <linux/device.h>
  31 #include <linux/module.h>
  32 #include <linux/of_device.h>
  33 #include <linux/pm_runtime.h>
  34 #include <linux/slab.h>
  35
  36 #include <video/mipi_display.h>
  37
  38 /**
  39  * DOC: dsi helpers
  40  *
  41  * These functions contain some common logic and helpers to deal with MIPI DSI
  42  * peripherals.
  43  *
  44  * Helpers are provided for a number of standard MIPI DSI command as well as a
  45  * subset of the MIPI DCS command set.
  46  */
  47
  48 static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv)
  49 {
  50         return of_driver_match_device(dev, drv);
  51 }
  52
  53 static const struct dev_pm_ops mipi_dsi_device_pm_ops = {
  54         .runtime_suspend = pm_generic_runtime_suspend,
  55         .runtime_resume = pm_generic_runtime_resume,
  56         .suspend = pm_generic_suspend,
  57         .resume = pm_generic_resume,
  58         .freeze = pm_generic_freeze,
  59         .thaw = pm_generic_thaw,
  60         .poweroff = pm_generic_poweroff,
  61         .restore = pm_generic_restore,
  62 };
  63
  64 static struct bus_type mipi_dsi_bus_type = {
  65         .name = "mipi-dsi",
  66         .match = mipi_dsi_device_match,
  67         .pm = &mipi_dsi_device_pm_ops,
  68 };
  69
  70 static int of_device_match(struct device *dev, void *data)
  71 {
  72         return dev->of_node == data;
  73 }
  74
  75 /**
  76  * of_find_mipi_dsi_device_by_node() - find the MIPI DSI device matching a
  77  *    device tree node
  78  * @np: device tree node
  79  *
  80  * Return: A pointer to the MIPI DSI device corresponding to @np or NULL if no
  81  *    such device exists (or has not been registered yet).
  82  */
  83 struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np)
  84 {
  85         struct device *dev;
  86
  87         dev = bus_find_device(&mipi_dsi_bus_type, NULL, np, of_device_match);
  88
  89         return dev ? to_mipi_dsi_device(dev) : NULL;
  90 }
  91 EXPORT_SYMBOL(of_find_mipi_dsi_device_by_node);
  92
  93 static void mipi_dsi_dev_release(struct device *dev)
  94 {
  95         struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
  96
  97         of_node_put(dev->of_node);
  98         kfree(dsi);
  99 }
 100
 101 static const struct device_type mipi_dsi_device_type = {
 102         .release = mipi_dsi_dev_release,
 103 };
 104
 105 static struct mipi_dsi_device *mipi_dsi_device_alloc(struct mipi_dsi_host *host)
 106 {
 107         struct mipi_dsi_device *dsi;
 108
 109         dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
 110         if (!dsi)
 111                 return ERR_PTR(-ENOMEM);
 112
 113         dsi->host = host;
 114         dsi->dev.bus = &mipi_dsi_bus_type;
 115         dsi->dev.parent = host->dev;
 116         dsi->dev.type = &mipi_dsi_device_type;
 117
 118         device_initialize(&dsi->dev);
 119
 120         return dsi;
 121 }
 122
 123 static int mipi_dsi_device_add(struct mipi_dsi_device *dsi)
 124 {
 125         struct mipi_dsi_host *host = dsi->host;
 126
 127         dev_set_name(&dsi->dev, "%s.%d", dev_name(host->dev),  dsi->channel);
 128
 129         return device_add(&dsi->dev);
 130 }
 131
 132 static struct mipi_dsi_device *
 133 of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
 134 {
 135         struct mipi_dsi_device *dsi;
 136         struct device *dev = host->dev;
 137         int ret;
 138         u32 reg;
 139
 140         ret = of_property_read_u32(node, "reg", &reg);
 141         if (ret) {
 142                 dev_err(dev, "device node %s has no valid reg property: %d\n",
 143                         node->full_name, ret);
 144                 return ERR_PTR(-EINVAL);
 145         }
 146
 147         if (reg > 3) {
 148                 dev_err(dev, "device node %s has invalid reg property: %u\n",
 149                         node->full_name, reg);
 150                 return ERR_PTR(-EINVAL);
 151         }
 152
 153         dsi = mipi_dsi_device_alloc(host);
 154         if (IS_ERR(dsi)) {
 155                 dev_err(dev, "failed to allocate DSI device %s: %ld\n",
 156                         node->full_name, PTR_ERR(dsi));
 157                 return dsi;
 158         }
 159
 160         dsi->dev.of_node = of_node_get(node);
 161         dsi->channel = reg;
 162
 163         ret = mipi_dsi_device_add(dsi);
 164         if (ret) {
 165                 dev_err(dev, "failed to add DSI device %s: %d\n",
 166                         node->full_name, ret);
 167                 kfree(dsi);
 168                 return ERR_PTR(ret);
 169         }
 170
 171         return dsi;
 172 }
 173
 174 int mipi_dsi_host_register(struct mipi_dsi_host *host)
 175 {
 176         struct device_node *node;
 177
 178         for_each_available_child_of_node(host->dev->of_node, node) {
 179                 /* skip nodes without reg property */
 180                 if (!of_find_property(node, "reg", NULL))
 181                         continue;
 182                 of_mipi_dsi_device_add(host, node);
 183         }
 184
 185         return 0;
 186 }
 187 EXPORT_SYMBOL(mipi_dsi_host_register);
 188
 189 static int mipi_dsi_remove_device_fn(struct device *dev, void *priv)
 190 {
 191         struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
 192
 193         device_unregister(&dsi->dev);
 194
 195         return 0;
 196 }
 197
 198 void mipi_dsi_host_unregister(struct mipi_dsi_host *host)
 199 {
 200         device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn);
 201 }
 202 EXPORT_SYMBOL(mipi_dsi_host_unregister);
 203
 204 /**
 205  * mipi_dsi_attach - attach a DSI device to its DSI host
 206  * @dsi: DSI peripheral
 207  */
 208 int mipi_dsi_attach(struct mipi_dsi_device *dsi)
 209 {
 210         const struct mipi_dsi_host_ops *ops = dsi->host->ops;
 211
 212         if (!ops || !ops->attach)
 213                 return -ENOSYS;
 214
 215         return ops->attach(dsi->host, dsi);
 216 }
 217 EXPORT_SYMBOL(mipi_dsi_attach);
 218
 219 /**
 220  * mipi_dsi_detach - detach a DSI device from its DSI host
 221  * @dsi: DSI peripheral
 222  */
 223 int mipi_dsi_detach(struct mipi_dsi_device *dsi)
 224 {
 225         const struct mipi_dsi_host_ops *ops = dsi->host->ops;
 226
 227         if (!ops || !ops->detach)
 228                 return -ENOSYS;
 229
 230         return ops->detach(dsi->host, dsi);
 231 }
 232 EXPORT_SYMBOL(mipi_dsi_detach);
 233
 234 static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi,
 235                                         struct mipi_dsi_msg *msg)
 236 {
 237         const struct mipi_dsi_host_ops *ops = dsi->host->ops;
 238
 239         if (!ops || !ops->transfer)
 240                 return -ENOSYS;
 241
 242         if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
 243                 msg->flags |= MIPI_DSI_MSG_USE_LPM;
 244
 245         return ops->transfer(dsi->host, msg);
 246 }
 247
 248 /**
 249  * mipi_dsi_packet_format_is_short - check if a packet is of the short format
 250  * @type: MIPI DSI data type of the packet
 251  *
 252  * Return: true if the packet for the given data type is a short packet, false
 253  * otherwise.
 254  */
 255 bool mipi_dsi_packet_format_is_short(u8 type)
 256 {
 257         switch (type) {
 258         case MIPI_DSI_V_SYNC_START:
 259         case MIPI_DSI_V_SYNC_END:
 260         case MIPI_DSI_H_SYNC_START:
 261         case MIPI_DSI_H_SYNC_END:
 262         case MIPI_DSI_END_OF_TRANSMISSION:
 263         case MIPI_DSI_COLOR_MODE_OFF:
 264         case MIPI_DSI_COLOR_MODE_ON:
 265         case MIPI_DSI_SHUTDOWN_PERIPHERAL:
 266         case MIPI_DSI_TURN_ON_PERIPHERAL:
 267         case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM:
 268         case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM:
 269         case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM:
 270         case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
 271         case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
 272         case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
 273         case MIPI_DSI_DCS_SHORT_WRITE:
 274         case MIPI_DSI_DCS_SHORT_WRITE_PARAM:
 275         case MIPI_DSI_DCS_READ:
 276         case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
 277                 return true;
 278         }
 279
 280         return false;
 281 }
 282 EXPORT_SYMBOL(mipi_dsi_packet_format_is_short);
 283
 284 /**
 285  * mipi_dsi_packet_format_is_long - check if a packet is of the long format
 286  * @type: MIPI DSI data type of the packet
 287  *
 288  * Return: true if the packet for the given data type is a long packet, false
 289  * otherwise.
 290  */
 291 bool mipi_dsi_packet_format_is_long(u8 type)
 292 {
 293         switch (type) {
 294         case MIPI_DSI_NULL_PACKET:
 295         case MIPI_DSI_BLANKING_PACKET:
 296         case MIPI_DSI_GENERIC_LONG_WRITE:
 297         case MIPI_DSI_DCS_LONG_WRITE:
 298         case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20:
 299         case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24:
 300         case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16:
 301         case MIPI_DSI_PACKED_PIXEL_STREAM_30:
 302         case MIPI_DSI_PACKED_PIXEL_STREAM_36:
 303         case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12:
 304         case MIPI_DSI_PACKED_PIXEL_STREAM_16:
 305         case MIPI_DSI_PACKED_PIXEL_STREAM_18:
 306         case MIPI_DSI_PIXEL_STREAM_3BYTE_18:
 307         case MIPI_DSI_PACKED_PIXEL_STREAM_24:
 308                 return true;
 309         }
 310
 311         return false;
 312 }
 313 EXPORT_SYMBOL(mipi_dsi_packet_format_is_long);
 314
 315 /**
 316  * mipi_dsi_create_packet - create a packet from a message according to the
 317  *     DSI protocol
 318  * @packet: pointer to a DSI packet structure
 319  * @msg: message to translate into a packet
 320  *
 321  * Return: 0 on success or a negative error code on failure.
 322  */
 323 int mipi_dsi_create_packet(struct mipi_dsi_packet *packet,
 324                            const struct mipi_dsi_msg *msg)
 325 {
 326         if (!packet || !msg)
 327                 return -EINVAL;
 328
 329         /* do some minimum sanity checking */
 330         if (!mipi_dsi_packet_format_is_short(msg->type) &&
 331             !mipi_dsi_packet_format_is_long(msg->type))
 332                 return -EINVAL;
 333
 334         if (msg->channel > 3)
 335                 return -EINVAL;
 336
 337         memset(packet, 0, sizeof(*packet));
 338         packet->header[0] = ((msg->channel & 0x3) << 6) | (msg->type & 0x3f);
 339
 340         /* TODO: compute ECC if hardware support is not available */
 341
 342         /*
 343          * Long write packets contain the word count in header bytes 1 and 2.
 344          * The payload follows the header and is word count bytes long.
 345          *
 346          * Short write packets encode up to two parameters in header bytes 1
 347          * and 2.
 348          */
 349         if (mipi_dsi_packet_format_is_long(msg->type)) {
 350                 packet->header[1] = (msg->tx_len >> 0) & 0xff;
 351                 packet->header[2] = (msg->tx_len >> 8) & 0xff;
 352
 353                 packet->payload_length = msg->tx_len;
 354                 packet->payload = msg->tx_buf;
 355         } else {
 356                 const u8 *tx = msg->tx_buf;
 357
 358                 packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0;
 359                 packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0;
 360         }
 361
 362         packet->size = sizeof(packet->header) + packet->payload_length;
 363
 364         return 0;
 365 }
 366 EXPORT_SYMBOL(mipi_dsi_create_packet);
 367
 368 /*
 369  * mipi_dsi_set_maximum_return_packet_size() - specify the maximum size of the
 370  *    the payload in a long packet transmitted from the peripheral back to the
 371  *    host processor
 372  * @dsi: DSI peripheral device
 373  * @value: the maximum size of the payload
 374  *
 375  * Return: 0 on success or a negative error code on failure.
 376  */
 377 int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi,
 378                                             u16 value)
 379 {
 380         u8 tx[2] = { value & 0xff, value >> 8 };
 381         struct mipi_dsi_msg msg = {
 382                 .channel = dsi->channel,
 383                 .type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
 384                 .tx_len = sizeof(tx),
 385                 .tx_buf = tx,
 386         };
 387
 388         return mipi_dsi_device_transfer(dsi, &msg);
 389 }
 390 EXPORT_SYMBOL(mipi_dsi_set_maximum_return_packet_size);
 391
 392 /**
 393  * mipi_dsi_generic_write() - transmit data using a generic write packet
 394  * @dsi: DSI peripheral device
 395  * @payload: buffer containing the payload
 396  * @size: size of payload buffer
 397  *
 398  * This function will automatically choose the right data type depending on
 399  * the payload length.
 400  *
 401  * Return: The number of bytes transmitted on success or a negative error code
 402  * on failure.
 403  */
 404 ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload,
 405                                size_t size)
 406 {
 407         struct mipi_dsi_msg msg = {
 408                 .channel = dsi->channel,
 409                 .tx_buf = payload,
 410                 .tx_len = size
 411         };
 412
 413         switch (size) {
 414         case 0:
 415                 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM;
 416                 break;
 417
 418         case 1:
 419                 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM;
 420                 break;
 421
 422         case 2:
 423                 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM;
 424                 break;
 425
 426         default:
 427                 msg.type = MIPI_DSI_GENERIC_LONG_WRITE;
 428                 break;
 429         }
 430
 431         return mipi_dsi_device_transfer(dsi, &msg);
 432 }
 433 EXPORT_SYMBOL(mipi_dsi_generic_write);
 434
 435 /**
 436  * mipi_dsi_generic_read() - receive data using a generic read packet
 437  * @dsi: DSI peripheral device
 438  * @params: buffer containing the request parameters
 439  * @num_params: number of request parameters
 440  * @data: buffer in which to return the received data
 441  * @size: size of receive buffer
 442  *
 443  * This function will automatically choose the right data type depending on
 444  * the number of parameters passed in.
 445  *
 446  * Return: The number of bytes successfully read or a negative error code on
 447  * failure.
 448  */
 449 ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params,
 450                               size_t num_params, void *data, size_t size)
 451 {
 452         struct mipi_dsi_msg msg = {
 453                 .channel = dsi->channel,
 454                 .tx_len = num_params,
 455                 .tx_buf = params,
 456                 .rx_len = size,
 457                 .rx_buf = data
 458         };
 459
 460         switch (num_params) {
 461         case 0:
 462                 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM;
 463                 break;
 464
 465         case 1:
 466                 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM;
 467                 break;
 468
 469         case 2:
 470                 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM;
 471                 break;
 472
 473         default:
 474                 return -EINVAL;
 475         }
 476
 477         return mipi_dsi_device_transfer(dsi, &msg);
 478 }
 479 EXPORT_SYMBOL(mipi_dsi_generic_read);
 480
 481 /**
 482  * mipi_dsi_dcs_write_buffer() - transmit a DCS command with payload
 483  * @dsi: DSI peripheral device
 484  * @data: buffer containing data to be transmitted
 485  * @len: size of transmission buffer
 486  *
 487  * This function will automatically choose the right data type depending on
 488  * the command payload length.
 489  *
 490  * Return: The number of bytes successfully transmitted or a negative error
 491  * code on failure.
 492  */
 493 ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi,
 494                                   const void *data, size_t len)
 495 {
 496         struct mipi_dsi_msg msg = {
 497                 .channel = dsi->channel,
 498                 .tx_buf = data,
 499                 .tx_len = len
 500         };
 501
 502         switch (len) {
 503         case 0:
 504                 return -EINVAL;
 505
 506         case 1:
 507                 msg.type = MIPI_DSI_DCS_SHORT_WRITE;
 508                 break;
 509
 510         case 2:
 511                 msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
 512                 break;
 513
 514         default:
 515                 msg.type = MIPI_DSI_DCS_LONG_WRITE;
 516                 break;
 517         }
 518
 519         return mipi_dsi_device_transfer(dsi, &msg);
 520 }
 521 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer);
 522
 523 /**
 524  * mipi_dsi_dcs_write() - send DCS write command
 525  * @dsi: DSI peripheral device
 526  * @cmd: DCS command
 527  * @data: buffer containing the command payload
 528  * @len: command payload length
 529  *
 530  * This function will automatically choose the right data type depending on
 531  * the command payload length.
 532  *
 533  * Return: The number of bytes successfully transmitted or a negative error
 534  * code on failure.
 535  */
 536 ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd,
 537                            const void *data, size_t len)
 538 {
 539         ssize_t err;
 540         size_t size;
 541         u8 *tx;
 542
 543         if (len > 0) {
 544                 size = 1 + len;
 545
 546                 tx = kmalloc(size, GFP_KERNEL);
 547                 if (!tx)
 548                         return -ENOMEM;
 549
 550                 /* concatenate the DCS command byte and the payload */
 551                 tx[0] = cmd;
 552                 memcpy(&tx[1], data, len);
 553         } else {
 554                 tx = &cmd;
 555                 size = 1;
 556         }
 557
 558         err = mipi_dsi_dcs_write_buffer(dsi, tx, size);
 559
 560         if (len > 0)
 561                 kfree(tx);
 562
 563         return err;
 564 }
 565 EXPORT_SYMBOL(mipi_dsi_dcs_write);
 566
 567 /**
 568  * mipi_dsi_dcs_read() - send DCS read request command
 569  * @dsi: DSI peripheral device
 570  * @cmd: DCS command
 571  * @data: buffer in which to receive data
 572  * @len: size of receive buffer
 573  *
 574  * Return: The number of bytes read or a negative error code on failure.
 575  */
 576 ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
 577                           size_t len)
 578 {
 579         struct mipi_dsi_msg msg = {
 580                 .channel = dsi->channel,
 581                 .type = MIPI_DSI_DCS_READ,
 582                 .tx_buf = &cmd,
 583                 .tx_len = 1,
 584                 .rx_buf = data,
 585                 .rx_len = len
 586         };
 587
 588         return mipi_dsi_device_transfer(dsi, &msg);
 589 }
 590 EXPORT_SYMBOL(mipi_dsi_dcs_read);
 591
 592 /**
 593  * mipi_dsi_dcs_nop() - send DCS nop packet
 594  * @dsi: DSI peripheral device
 595  *
 596  * Return: 0 on success or a negative error code on failure.
 597  */
 598 int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi)
 599 {
 600         ssize_t err;
 601
 602         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_NOP, NULL, 0);
 603         if (err < 0)
 604                 return err;
 605
 606         return 0;
 607 }
 608 EXPORT_SYMBOL(mipi_dsi_dcs_nop);
 609
 610 /**
 611  * mipi_dsi_dcs_soft_reset() - perform a software reset of the display module
 612  * @dsi: DSI peripheral device
 613  *
 614  * Return: 0 on success or a negative error code on failure.
 615  */
 616 int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi)
 617 {
 618         ssize_t err;
 619
 620         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SOFT_RESET, NULL, 0);
 621         if (err < 0)
 622                 return err;
 623
 624         return 0;
 625 }
 626 EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset);
 627
 628 /**
 629  * mipi_dsi_dcs_get_power_mode() - query the display module's current power
 630  *    mode
 631  * @dsi: DSI peripheral device
 632  * @mode: return location for the current power mode
 633  *
 634  * Return: 0 on success or a negative error code on failure.
 635  */
 636 int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode)
 637 {
 638         ssize_t err;
 639
 640         err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_POWER_MODE, mode,
 641                                 sizeof(*mode));
 642         if (err <= 0) {
 643                 if (err == 0)
 644                         err = -ENODATA;
 645
 646                 return err;
 647         }
 648
 649         return 0;
 650 }
 651 EXPORT_SYMBOL(mipi_dsi_dcs_get_power_mode);
 652
 653 /**
 654  * mipi_dsi_dcs_get_pixel_format() - gets the pixel format for the RGB image
 655  *    data used by the interface
 656  * @dsi: DSI peripheral device
 657  * @format: return location for the pixel format
 658  *
 659  * Return: 0 on success or a negative error code on failure.
 660  */
 661 int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format)
 662 {
 663         ssize_t err;
 664
 665         err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_PIXEL_FORMAT, format,
 666                                 sizeof(*format));
 667         if (err <= 0) {
 668                 if (err == 0)
 669                         err = -ENODATA;
 670
 671                 return err;
 672         }
 673
 674         return 0;
 675 }
 676 EXPORT_SYMBOL(mipi_dsi_dcs_get_pixel_format);
 677
 678 /**
 679  * mipi_dsi_dcs_enter_sleep_mode() - disable all unnecessary blocks inside the
 680  *    display module except interface communication
 681  * @dsi: DSI peripheral device
 682  *
 683  * Return: 0 on success or a negative error code on failure.
 684  */
 685 int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi)
 686 {
 687         ssize_t err;
 688
 689         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0);
 690         if (err < 0)
 691                 return err;
 692
 693         return 0;
 694 }
 695 EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode);
 696
 697 /**
 698  * mipi_dsi_dcs_exit_sleep_mode() - enable all blocks inside the display
 699  *    module
 700  * @dsi: DSI peripheral device
 701  *
 702  * Return: 0 on success or a negative error code on failure.
 703  */
 704 int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi)
 705 {
 706         ssize_t err;
 707
 708         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0);
 709         if (err < 0)
 710                 return err;
 711
 712         return 0;
 713 }
 714 EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode);
 715
 716 /**
 717  * mipi_dsi_dcs_set_display_off() - stop displaying the image data on the
 718  *    display device
 719  * @dsi: DSI peripheral device
 720  *
 721  * Return: 0 on success or a negative error code on failure.
 722  */
 723 int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi)
 724 {
 725         ssize_t err;
 726
 727         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0);
 728         if (err < 0)
 729                 return err;
 730
 731         return 0;
 732 }
 733 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off);
 734
 735 /**
 736  * mipi_dsi_dcs_set_display_on() - start displaying the image data on the
 737  *    display device
 738  * @dsi: DSI peripheral device
 739  *
 740  * Return: 0 on success or a negative error code on failure
 741  */
 742 int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi)
 743 {
 744         ssize_t err;
 745
 746         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0);
 747         if (err < 0)
 748                 return err;
 749
 750         return 0;
 751 }
 752 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on);
 753
 754 /**
 755  * mipi_dsi_dcs_set_column_address() - define the column extent of the frame
 756  *    memory accessed by the host processor
 757  * @dsi: DSI peripheral device
 758  * @start: first column of frame memory
 759  * @end: last column of frame memory
 760  *
 761  * Return: 0 on success or a negative error code on failure.
 762  */
 763 int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start,
 764                                     u16 end)
 765 {
 766         u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
 767         ssize_t err;
 768
 769         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_COLUMN_ADDRESS, payload,
 770                                  sizeof(payload));
 771         if (err < 0)
 772                 return err;
 773
 774         return 0;
 775 }
 776 EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address);
 777
 778 /**
 779  * mipi_dsi_dcs_set_page_address() - define the page extent of the frame
 780  *    memory accessed by the host processor
 781  * @dsi: DSI peripheral device
 782  * @start: first page of frame memory
 783  * @end: last page of frame memory
 784  *
 785  * Return: 0 on success or a negative error code on failure.
 786  */
 787 int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start,
 788                                   u16 end)
 789 {
 790         u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
 791         ssize_t err;
 792
 793         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PAGE_ADDRESS, payload,
 794                                  sizeof(payload));
 795         if (err < 0)
 796                 return err;
 797
 798         return 0;
 799 }
 800 EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address);
 801
 802 /**
 803  * mipi_dsi_dcs_set_tear_off() - turn off the display module's Tearing Effect
 804  *    output signal on the TE signal line
 805  * @dsi: DSI peripheral device
 806  *
 807  * Return: 0 on success or a negative error code on failure
 808  */
 809 int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi)
 810 {
 811         ssize_t err;
 812
 813         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_OFF, NULL, 0);
 814         if (err < 0)
 815                 return err;
 816
 817         return 0;
 818 }
 819 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_off);
 820
 821 /**
 822  * mipi_dsi_dcs_set_tear_on() - turn on the display module's Tearing Effect
 823  *    output signal on the TE signal line.
 824  * @dsi: DSI peripheral device
 825  * @mode: the Tearing Effect Output Line mode
 826  *
 827  * Return: 0 on success or a negative error code on failure
 828  */
 829 int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi,
 830                              enum mipi_dsi_dcs_tear_mode mode)
 831 {
 832         u8 value = mode;
 833         ssize_t err;
 834
 835         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_ON, &value,
 836                                  sizeof(value));
 837         if (err < 0)
 838                 return err;
 839
 840         return 0;
 841 }
 842 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on);
 843
 844 /**
 845  * mipi_dsi_dcs_set_pixel_format() - sets the pixel format for the RGB image
 846  *    data used by the interface
 847  * @dsi: DSI peripheral device
 848  * @format: pixel format
 849  *
 850  * Return: 0 on success or a negative error code on failure.
 851  */
 852 int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format)
 853 {
 854         ssize_t err;
 855
 856         err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PIXEL_FORMAT, &format,
 857                                  sizeof(format));
 858         if (err < 0)
 859                 return err;
 860
 861         return 0;
 862 }
 863 EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format);
 864
 865 static int mipi_dsi_drv_probe(struct device *dev)
 866 {
 867         struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
 868         struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
 869
 870         return drv->probe(dsi);
 871 }
 872
 873 static int mipi_dsi_drv_remove(struct device *dev)
 874 {
 875         struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
 876         struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
 877
 878         return drv->remove(dsi);
 879 }
 880
 881 static void mipi_dsi_drv_shutdown(struct device *dev)
 882 {
 883         struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
 884         struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
 885
 886         drv->shutdown(dsi);
 887 }
 888
 889 /**
 890  * mipi_dsi_driver_register_full() - register a driver for DSI devices
 891  * @drv: DSI driver structure
 892  * @owner: owner module
 893  *
 894  * Return: 0 on success or a negative error code on failure.
 895  */
 896 int mipi_dsi_driver_register_full(struct mipi_dsi_driver *drv,
 897                                   struct module *owner)
 898 {
 899         drv->driver.bus = &mipi_dsi_bus_type;
 900         drv->driver.owner = owner;
 901
 902         if (drv->probe)
 903                 drv->driver.probe = mipi_dsi_drv_probe;
 904         if (drv->remove)
 905                 drv->driver.remove = mipi_dsi_drv_remove;
 906         if (drv->shutdown)
 907                 drv->driver.shutdown = mipi_dsi_drv_shutdown;
 908
 909         return driver_register(&drv->driver);
 910 }
 911 EXPORT_SYMBOL(mipi_dsi_driver_register_full);
 912
 913 /**
 914  * mipi_dsi_driver_unregister() - unregister a driver for DSI devices
 915  * @drv: DSI driver structure
 916  *
 917  * Return: 0 on success or a negative error code on failure.
 918  */
 919 void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
 920 {
 921         driver_unregister(&drv->driver);
 922 }
 923 EXPORT_SYMBOL(mipi_dsi_driver_unregister);
 924
 925 static int __init mipi_dsi_bus_init(void)
 926 {
 927         return bus_register(&mipi_dsi_bus_type);
 928 }
 929 postcore_initcall(mipi_dsi_bus_init);
 930
 931 MODULE_AUTHOR("Andrzej Hajda <[email protected]>");
 932 MODULE_DESCRIPTION("MIPI DSI Bus");
 933 MODULE_LICENSE("GPL and additional rights");