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