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_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_alias_from_compatible(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", &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");