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