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