mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![vkorjani](/assets/img/avatar_default.png)
After enabling DSC we need to send compression mode command packet and pps data packet, for which 2 new data types are added 07h Compression Mode Data Type Write , short write, 2 parameters 0Ah PPS Long Write (word count determines number of bytes) This patch adds support to send these packets. Cc: David Airlie <airlied@linux.ie> Cc: Jean-Christophe Plagniol-Villard <plagnioj@jcrosoft.com> Cc: Tomi Valkeinen <tomi.valkeinen@ti.com> Cc: dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org Cc: linux-fbdev@vger.kernel.org Changes in v3: - None Signed-off-by: vkorjani <vikas.korjani@intel.com> [seanpaul removed pps_write_buffer fn, added types to packet_format helpers] Signed-off-by: Sean Paul <seanpaul@chromium.org> Signed-off-by: Rob Clark <robdclark@gmail.com>
1166 lines
28 KiB
C
1166 lines
28 KiB
C
/*
|
|
* MIPI DSI Bus
|
|
*
|
|
* Copyright (C) 2012-2013, Samsung Electronics, Co., Ltd.
|
|
* Andrzej Hajda <a.hajda@samsung.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <drm/drm_mipi_dsi.h>
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <video/mipi_display.h>
|
|
|
|
/**
|
|
* DOC: dsi helpers
|
|
*
|
|
* These functions contain some common logic and helpers to deal with MIPI DSI
|
|
* peripherals.
|
|
*
|
|
* Helpers are provided for a number of standard MIPI DSI command as well as a
|
|
* subset of the MIPI DCS command set.
|
|
*/
|
|
|
|
static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv)
|
|
{
|
|
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
|
|
|
/* attempt OF style match */
|
|
if (of_driver_match_device(dev, drv))
|
|
return 1;
|
|
|
|
/* compare DSI device and driver names */
|
|
if (!strcmp(dsi->name, drv->name))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mipi_dsi_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
{
|
|
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
|
int err;
|
|
|
|
err = of_device_uevent_modalias(dev, env);
|
|
if (err != -ENODEV)
|
|
return err;
|
|
|
|
add_uevent_var(env, "MODALIAS=%s%s", MIPI_DSI_MODULE_PREFIX,
|
|
dsi->name);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct dev_pm_ops mipi_dsi_device_pm_ops = {
|
|
.runtime_suspend = pm_generic_runtime_suspend,
|
|
.runtime_resume = pm_generic_runtime_resume,
|
|
.suspend = pm_generic_suspend,
|
|
.resume = pm_generic_resume,
|
|
.freeze = pm_generic_freeze,
|
|
.thaw = pm_generic_thaw,
|
|
.poweroff = pm_generic_poweroff,
|
|
.restore = pm_generic_restore,
|
|
};
|
|
|
|
static struct bus_type mipi_dsi_bus_type = {
|
|
.name = "mipi-dsi",
|
|
.match = mipi_dsi_device_match,
|
|
.uevent = mipi_dsi_uevent,
|
|
.pm = &mipi_dsi_device_pm_ops,
|
|
};
|
|
|
|
static int of_device_match(struct device *dev, void *data)
|
|
{
|
|
return dev->of_node == data;
|
|
}
|
|
|
|
/**
|
|
* of_find_mipi_dsi_device_by_node() - find the MIPI DSI device matching a
|
|
* device tree node
|
|
* @np: device tree node
|
|
*
|
|
* Return: A pointer to the MIPI DSI device corresponding to @np or NULL if no
|
|
* such device exists (or has not been registered yet).
|
|
*/
|
|
struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np)
|
|
{
|
|
struct device *dev;
|
|
|
|
dev = bus_find_device(&mipi_dsi_bus_type, NULL, np, of_device_match);
|
|
|
|
return dev ? to_mipi_dsi_device(dev) : NULL;
|
|
}
|
|
EXPORT_SYMBOL(of_find_mipi_dsi_device_by_node);
|
|
|
|
static void mipi_dsi_dev_release(struct device *dev)
|
|
{
|
|
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
|
|
|
of_node_put(dev->of_node);
|
|
kfree(dsi);
|
|
}
|
|
|
|
static const struct device_type mipi_dsi_device_type = {
|
|
.release = mipi_dsi_dev_release,
|
|
};
|
|
|
|
static struct mipi_dsi_device *mipi_dsi_device_alloc(struct mipi_dsi_host *host)
|
|
{
|
|
struct mipi_dsi_device *dsi;
|
|
|
|
dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
|
|
if (!dsi)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
dsi->host = host;
|
|
dsi->dev.bus = &mipi_dsi_bus_type;
|
|
dsi->dev.parent = host->dev;
|
|
dsi->dev.type = &mipi_dsi_device_type;
|
|
|
|
device_initialize(&dsi->dev);
|
|
|
|
return dsi;
|
|
}
|
|
|
|
static int mipi_dsi_device_add(struct mipi_dsi_device *dsi)
|
|
{
|
|
struct mipi_dsi_host *host = dsi->host;
|
|
|
|
dev_set_name(&dsi->dev, "%s.%d", dev_name(host->dev), dsi->channel);
|
|
|
|
return device_add(&dsi->dev);
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_OF)
|
|
static struct mipi_dsi_device *
|
|
of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
|
|
{
|
|
struct device *dev = host->dev;
|
|
struct mipi_dsi_device_info info = { };
|
|
int ret;
|
|
u32 reg;
|
|
|
|
if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
|
|
dev_err(dev, "modalias failure on %pOF\n", node);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
ret = of_property_read_u32(node, "reg", ®);
|
|
if (ret) {
|
|
dev_err(dev, "device node %pOF has no valid reg property: %d\n",
|
|
node, ret);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
info.channel = reg;
|
|
info.node = of_node_get(node);
|
|
|
|
return mipi_dsi_device_register_full(host, &info);
|
|
}
|
|
#else
|
|
static struct mipi_dsi_device *
|
|
of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
|
|
{
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* mipi_dsi_device_register_full - create a MIPI DSI device
|
|
* @host: DSI host to which this device is connected
|
|
* @info: pointer to template containing DSI device information
|
|
*
|
|
* Create a MIPI DSI device by using the device information provided by
|
|
* mipi_dsi_device_info template
|
|
*
|
|
* Returns:
|
|
* A pointer to the newly created MIPI DSI device, or, a pointer encoded
|
|
* with an error
|
|
*/
|
|
struct mipi_dsi_device *
|
|
mipi_dsi_device_register_full(struct mipi_dsi_host *host,
|
|
const struct mipi_dsi_device_info *info)
|
|
{
|
|
struct mipi_dsi_device *dsi;
|
|
struct device *dev = host->dev;
|
|
int ret;
|
|
|
|
if (!info) {
|
|
dev_err(dev, "invalid mipi_dsi_device_info pointer\n");
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
if (info->channel > 3) {
|
|
dev_err(dev, "invalid virtual channel: %u\n", info->channel);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
dsi = mipi_dsi_device_alloc(host);
|
|
if (IS_ERR(dsi)) {
|
|
dev_err(dev, "failed to allocate DSI device %ld\n",
|
|
PTR_ERR(dsi));
|
|
return dsi;
|
|
}
|
|
|
|
dsi->dev.of_node = info->node;
|
|
dsi->channel = info->channel;
|
|
strlcpy(dsi->name, info->type, sizeof(dsi->name));
|
|
|
|
ret = mipi_dsi_device_add(dsi);
|
|
if (ret) {
|
|
dev_err(dev, "failed to add DSI device %d\n", ret);
|
|
kfree(dsi);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
return dsi;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_device_register_full);
|
|
|
|
/**
|
|
* mipi_dsi_device_unregister - unregister MIPI DSI device
|
|
* @dsi: DSI peripheral device
|
|
*/
|
|
void mipi_dsi_device_unregister(struct mipi_dsi_device *dsi)
|
|
{
|
|
device_unregister(&dsi->dev);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_device_unregister);
|
|
|
|
static DEFINE_MUTEX(host_lock);
|
|
static LIST_HEAD(host_list);
|
|
|
|
/**
|
|
* of_find_mipi_dsi_host_by_node() - find the MIPI DSI host matching a
|
|
* device tree node
|
|
* @node: device tree node
|
|
*
|
|
* Returns:
|
|
* A pointer to the MIPI DSI host corresponding to @node or NULL if no
|
|
* such device exists (or has not been registered yet).
|
|
*/
|
|
struct mipi_dsi_host *of_find_mipi_dsi_host_by_node(struct device_node *node)
|
|
{
|
|
struct mipi_dsi_host *host;
|
|
|
|
mutex_lock(&host_lock);
|
|
|
|
list_for_each_entry(host, &host_list, list) {
|
|
if (host->dev->of_node == node) {
|
|
mutex_unlock(&host_lock);
|
|
return host;
|
|
}
|
|
}
|
|
|
|
mutex_unlock(&host_lock);
|
|
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL(of_find_mipi_dsi_host_by_node);
|
|
|
|
int mipi_dsi_host_register(struct mipi_dsi_host *host)
|
|
{
|
|
struct device_node *node;
|
|
|
|
for_each_available_child_of_node(host->dev->of_node, node) {
|
|
/* skip nodes without reg property */
|
|
if (!of_find_property(node, "reg", NULL))
|
|
continue;
|
|
of_mipi_dsi_device_add(host, node);
|
|
}
|
|
|
|
mutex_lock(&host_lock);
|
|
list_add_tail(&host->list, &host_list);
|
|
mutex_unlock(&host_lock);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_host_register);
|
|
|
|
static int mipi_dsi_remove_device_fn(struct device *dev, void *priv)
|
|
{
|
|
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
|
|
|
mipi_dsi_device_unregister(dsi);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void mipi_dsi_host_unregister(struct mipi_dsi_host *host)
|
|
{
|
|
device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn);
|
|
|
|
mutex_lock(&host_lock);
|
|
list_del_init(&host->list);
|
|
mutex_unlock(&host_lock);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_host_unregister);
|
|
|
|
/**
|
|
* mipi_dsi_attach - attach a DSI device to its DSI host
|
|
* @dsi: DSI peripheral
|
|
*/
|
|
int mipi_dsi_attach(struct mipi_dsi_device *dsi)
|
|
{
|
|
const struct mipi_dsi_host_ops *ops = dsi->host->ops;
|
|
|
|
if (!ops || !ops->attach)
|
|
return -ENOSYS;
|
|
|
|
return ops->attach(dsi->host, dsi);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_attach);
|
|
|
|
/**
|
|
* mipi_dsi_detach - detach a DSI device from its DSI host
|
|
* @dsi: DSI peripheral
|
|
*/
|
|
int mipi_dsi_detach(struct mipi_dsi_device *dsi)
|
|
{
|
|
const struct mipi_dsi_host_ops *ops = dsi->host->ops;
|
|
|
|
if (!ops || !ops->detach)
|
|
return -ENOSYS;
|
|
|
|
return ops->detach(dsi->host, dsi);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_detach);
|
|
|
|
static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi,
|
|
struct mipi_dsi_msg *msg)
|
|
{
|
|
const struct mipi_dsi_host_ops *ops = dsi->host->ops;
|
|
|
|
if (!ops || !ops->transfer)
|
|
return -ENOSYS;
|
|
|
|
if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
|
|
msg->flags |= MIPI_DSI_MSG_USE_LPM;
|
|
|
|
return ops->transfer(dsi->host, msg);
|
|
}
|
|
|
|
/**
|
|
* mipi_dsi_packet_format_is_short - check if a packet is of the short format
|
|
* @type: MIPI DSI data type of the packet
|
|
*
|
|
* Return: true if the packet for the given data type is a short packet, false
|
|
* otherwise.
|
|
*/
|
|
bool mipi_dsi_packet_format_is_short(u8 type)
|
|
{
|
|
switch (type) {
|
|
case MIPI_DSI_V_SYNC_START:
|
|
case MIPI_DSI_V_SYNC_END:
|
|
case MIPI_DSI_H_SYNC_START:
|
|
case MIPI_DSI_H_SYNC_END:
|
|
case MIPI_DSI_END_OF_TRANSMISSION:
|
|
case MIPI_DSI_COLOR_MODE_OFF:
|
|
case MIPI_DSI_COLOR_MODE_ON:
|
|
case MIPI_DSI_SHUTDOWN_PERIPHERAL:
|
|
case MIPI_DSI_TURN_ON_PERIPHERAL:
|
|
case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM:
|
|
case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM:
|
|
case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM:
|
|
case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
|
|
case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
|
|
case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
|
|
case MIPI_DSI_DCS_SHORT_WRITE:
|
|
case MIPI_DSI_DCS_SHORT_WRITE_PARAM:
|
|
case MIPI_DSI_DCS_READ:
|
|
case MIPI_DSI_DCS_COMPRESSION_MODE:
|
|
case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_packet_format_is_short);
|
|
|
|
/**
|
|
* mipi_dsi_packet_format_is_long - check if a packet is of the long format
|
|
* @type: MIPI DSI data type of the packet
|
|
*
|
|
* Return: true if the packet for the given data type is a long packet, false
|
|
* otherwise.
|
|
*/
|
|
bool mipi_dsi_packet_format_is_long(u8 type)
|
|
{
|
|
switch (type) {
|
|
case MIPI_DSI_PPS_LONG_WRITE:
|
|
case MIPI_DSI_NULL_PACKET:
|
|
case MIPI_DSI_BLANKING_PACKET:
|
|
case MIPI_DSI_GENERIC_LONG_WRITE:
|
|
case MIPI_DSI_DCS_LONG_WRITE:
|
|
case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_30:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_36:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_16:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_18:
|
|
case MIPI_DSI_PIXEL_STREAM_3BYTE_18:
|
|
case MIPI_DSI_PACKED_PIXEL_STREAM_24:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_packet_format_is_long);
|
|
|
|
/**
|
|
* mipi_dsi_create_packet - create a packet from a message according to the
|
|
* DSI protocol
|
|
* @packet: pointer to a DSI packet structure
|
|
* @msg: message to translate into a packet
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_create_packet(struct mipi_dsi_packet *packet,
|
|
const struct mipi_dsi_msg *msg)
|
|
{
|
|
if (!packet || !msg)
|
|
return -EINVAL;
|
|
|
|
/* do some minimum sanity checking */
|
|
if (!mipi_dsi_packet_format_is_short(msg->type) &&
|
|
!mipi_dsi_packet_format_is_long(msg->type))
|
|
return -EINVAL;
|
|
|
|
if (msg->channel > 3)
|
|
return -EINVAL;
|
|
|
|
memset(packet, 0, sizeof(*packet));
|
|
packet->header[0] = ((msg->channel & 0x3) << 6) | (msg->type & 0x3f);
|
|
|
|
/* TODO: compute ECC if hardware support is not available */
|
|
|
|
/*
|
|
* Long write packets contain the word count in header bytes 1 and 2.
|
|
* The payload follows the header and is word count bytes long.
|
|
*
|
|
* Short write packets encode up to two parameters in header bytes 1
|
|
* and 2.
|
|
*/
|
|
if (mipi_dsi_packet_format_is_long(msg->type)) {
|
|
packet->header[1] = (msg->tx_len >> 0) & 0xff;
|
|
packet->header[2] = (msg->tx_len >> 8) & 0xff;
|
|
|
|
packet->payload_length = msg->tx_len;
|
|
packet->payload = msg->tx_buf;
|
|
} else {
|
|
const u8 *tx = msg->tx_buf;
|
|
|
|
packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0;
|
|
packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0;
|
|
}
|
|
|
|
packet->size = sizeof(packet->header) + packet->payload_length;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_create_packet);
|
|
|
|
/**
|
|
* mipi_dsi_shutdown_peripheral() - sends a Shutdown Peripheral command
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_shutdown_peripheral(struct mipi_dsi_device *dsi)
|
|
{
|
|
struct mipi_dsi_msg msg = {
|
|
.channel = dsi->channel,
|
|
.type = MIPI_DSI_SHUTDOWN_PERIPHERAL,
|
|
.tx_buf = (u8 [2]) { 0, 0 },
|
|
.tx_len = 2,
|
|
};
|
|
int ret = mipi_dsi_device_transfer(dsi, &msg);
|
|
|
|
return (ret < 0) ? ret : 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_shutdown_peripheral);
|
|
|
|
/**
|
|
* mipi_dsi_turn_on_peripheral() - sends a Turn On Peripheral command
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi)
|
|
{
|
|
struct mipi_dsi_msg msg = {
|
|
.channel = dsi->channel,
|
|
.type = MIPI_DSI_TURN_ON_PERIPHERAL,
|
|
.tx_buf = (u8 [2]) { 0, 0 },
|
|
.tx_len = 2,
|
|
};
|
|
int ret = mipi_dsi_device_transfer(dsi, &msg);
|
|
|
|
return (ret < 0) ? ret : 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_turn_on_peripheral);
|
|
|
|
/*
|
|
* mipi_dsi_set_maximum_return_packet_size() - specify the maximum size of the
|
|
* the payload in a long packet transmitted from the peripheral back to the
|
|
* host processor
|
|
* @dsi: DSI peripheral device
|
|
* @value: the maximum size of the payload
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi,
|
|
u16 value)
|
|
{
|
|
u8 tx[2] = { value & 0xff, value >> 8 };
|
|
struct mipi_dsi_msg msg = {
|
|
.channel = dsi->channel,
|
|
.type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
|
|
.tx_len = sizeof(tx),
|
|
.tx_buf = tx,
|
|
};
|
|
int ret = mipi_dsi_device_transfer(dsi, &msg);
|
|
|
|
return (ret < 0) ? ret : 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_set_maximum_return_packet_size);
|
|
|
|
/**
|
|
* mipi_dsi_generic_write() - transmit data using a generic write packet
|
|
* @dsi: DSI peripheral device
|
|
* @payload: buffer containing the payload
|
|
* @size: size of payload buffer
|
|
*
|
|
* This function will automatically choose the right data type depending on
|
|
* the payload length.
|
|
*
|
|
* Return: The number of bytes transmitted on success or a negative error code
|
|
* on failure.
|
|
*/
|
|
ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload,
|
|
size_t size)
|
|
{
|
|
struct mipi_dsi_msg msg = {
|
|
.channel = dsi->channel,
|
|
.tx_buf = payload,
|
|
.tx_len = size
|
|
};
|
|
|
|
switch (size) {
|
|
case 0:
|
|
msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM;
|
|
break;
|
|
|
|
case 1:
|
|
msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM;
|
|
break;
|
|
|
|
case 2:
|
|
msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM;
|
|
break;
|
|
|
|
default:
|
|
msg.type = MIPI_DSI_GENERIC_LONG_WRITE;
|
|
break;
|
|
}
|
|
|
|
return mipi_dsi_device_transfer(dsi, &msg);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_generic_write);
|
|
|
|
/**
|
|
* mipi_dsi_generic_read() - receive data using a generic read packet
|
|
* @dsi: DSI peripheral device
|
|
* @params: buffer containing the request parameters
|
|
* @num_params: number of request parameters
|
|
* @data: buffer in which to return the received data
|
|
* @size: size of receive buffer
|
|
*
|
|
* This function will automatically choose the right data type depending on
|
|
* the number of parameters passed in.
|
|
*
|
|
* Return: The number of bytes successfully read or a negative error code on
|
|
* failure.
|
|
*/
|
|
ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params,
|
|
size_t num_params, void *data, size_t size)
|
|
{
|
|
struct mipi_dsi_msg msg = {
|
|
.channel = dsi->channel,
|
|
.tx_len = num_params,
|
|
.tx_buf = params,
|
|
.rx_len = size,
|
|
.rx_buf = data
|
|
};
|
|
|
|
switch (num_params) {
|
|
case 0:
|
|
msg.type = MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM;
|
|
break;
|
|
|
|
case 1:
|
|
msg.type = MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM;
|
|
break;
|
|
|
|
case 2:
|
|
msg.type = MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM;
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return mipi_dsi_device_transfer(dsi, &msg);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_generic_read);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_write_buffer() - transmit a DCS command with payload
|
|
* @dsi: DSI peripheral device
|
|
* @data: buffer containing data to be transmitted
|
|
* @len: size of transmission buffer
|
|
*
|
|
* This function will automatically choose the right data type depending on
|
|
* the command payload length.
|
|
*
|
|
* Return: The number of bytes successfully transmitted or a negative error
|
|
* code on failure.
|
|
*/
|
|
ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi,
|
|
const void *data, size_t len)
|
|
{
|
|
struct mipi_dsi_msg msg = {
|
|
.channel = dsi->channel,
|
|
.tx_buf = data,
|
|
.tx_len = len
|
|
};
|
|
|
|
switch (len) {
|
|
case 0:
|
|
return -EINVAL;
|
|
|
|
case 1:
|
|
msg.type = MIPI_DSI_DCS_SHORT_WRITE;
|
|
break;
|
|
|
|
case 2:
|
|
msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
|
|
break;
|
|
|
|
default:
|
|
msg.type = MIPI_DSI_DCS_LONG_WRITE;
|
|
break;
|
|
}
|
|
|
|
return mipi_dsi_device_transfer(dsi, &msg);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_write() - send DCS write command
|
|
* @dsi: DSI peripheral device
|
|
* @cmd: DCS command
|
|
* @data: buffer containing the command payload
|
|
* @len: command payload length
|
|
*
|
|
* This function will automatically choose the right data type depending on
|
|
* the command payload length.
|
|
*
|
|
* Return: The number of bytes successfully transmitted or a negative error
|
|
* code on failure.
|
|
*/
|
|
ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd,
|
|
const void *data, size_t len)
|
|
{
|
|
ssize_t err;
|
|
size_t size;
|
|
u8 *tx;
|
|
|
|
if (len > 0) {
|
|
size = 1 + len;
|
|
|
|
tx = kmalloc(size, GFP_KERNEL);
|
|
if (!tx)
|
|
return -ENOMEM;
|
|
|
|
/* concatenate the DCS command byte and the payload */
|
|
tx[0] = cmd;
|
|
memcpy(&tx[1], data, len);
|
|
} else {
|
|
tx = &cmd;
|
|
size = 1;
|
|
}
|
|
|
|
err = mipi_dsi_dcs_write_buffer(dsi, tx, size);
|
|
|
|
if (len > 0)
|
|
kfree(tx);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_write);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_read() - send DCS read request command
|
|
* @dsi: DSI peripheral device
|
|
* @cmd: DCS command
|
|
* @data: buffer in which to receive data
|
|
* @len: size of receive buffer
|
|
*
|
|
* Return: The number of bytes read or a negative error code on failure.
|
|
*/
|
|
ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
|
|
size_t len)
|
|
{
|
|
struct mipi_dsi_msg msg = {
|
|
.channel = dsi->channel,
|
|
.type = MIPI_DSI_DCS_READ,
|
|
.tx_buf = &cmd,
|
|
.tx_len = 1,
|
|
.rx_buf = data,
|
|
.rx_len = len
|
|
};
|
|
|
|
return mipi_dsi_device_transfer(dsi, &msg);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_read);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_nop() - send DCS nop packet
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_NOP, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_nop);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_soft_reset() - perform a software reset of the display module
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SOFT_RESET, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_get_power_mode() - query the display module's current power
|
|
* mode
|
|
* @dsi: DSI peripheral device
|
|
* @mode: return location for the current power mode
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_POWER_MODE, mode,
|
|
sizeof(*mode));
|
|
if (err <= 0) {
|
|
if (err == 0)
|
|
err = -ENODATA;
|
|
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_get_power_mode);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_get_pixel_format() - gets the pixel format for the RGB image
|
|
* data used by the interface
|
|
* @dsi: DSI peripheral device
|
|
* @format: return location for the pixel format
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_PIXEL_FORMAT, format,
|
|
sizeof(*format));
|
|
if (err <= 0) {
|
|
if (err == 0)
|
|
err = -ENODATA;
|
|
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_get_pixel_format);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_enter_sleep_mode() - disable all unnecessary blocks inside the
|
|
* display module except interface communication
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_exit_sleep_mode() - enable all blocks inside the display
|
|
* module
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_display_off() - stop displaying the image data on the
|
|
* display device
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_display_on() - start displaying the image data on the
|
|
* display device
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure
|
|
*/
|
|
int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_column_address() - define the column extent of the frame
|
|
* memory accessed by the host processor
|
|
* @dsi: DSI peripheral device
|
|
* @start: first column of frame memory
|
|
* @end: last column of frame memory
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start,
|
|
u16 end)
|
|
{
|
|
u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_COLUMN_ADDRESS, payload,
|
|
sizeof(payload));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_page_address() - define the page extent of the frame
|
|
* memory accessed by the host processor
|
|
* @dsi: DSI peripheral device
|
|
* @start: first page of frame memory
|
|
* @end: last page of frame memory
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start,
|
|
u16 end)
|
|
{
|
|
u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PAGE_ADDRESS, payload,
|
|
sizeof(payload));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_tear_off() - turn off the display module's Tearing Effect
|
|
* output signal on the TE signal line
|
|
* @dsi: DSI peripheral device
|
|
*
|
|
* Return: 0 on success or a negative error code on failure
|
|
*/
|
|
int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_OFF, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_off);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_tear_on() - turn on the display module's Tearing Effect
|
|
* output signal on the TE signal line.
|
|
* @dsi: DSI peripheral device
|
|
* @mode: the Tearing Effect Output Line mode
|
|
*
|
|
* Return: 0 on success or a negative error code on failure
|
|
*/
|
|
int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi,
|
|
enum mipi_dsi_dcs_tear_mode mode)
|
|
{
|
|
u8 value = mode;
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_ON, &value,
|
|
sizeof(value));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_pixel_format() - sets the pixel format for the RGB image
|
|
* data used by the interface
|
|
* @dsi: DSI peripheral device
|
|
* @format: pixel format
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PIXEL_FORMAT, &format,
|
|
sizeof(format));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_tear_scanline() - set the scanline to use as trigger for
|
|
* the Tearing Effect output signal of the display module
|
|
* @dsi: DSI peripheral device
|
|
* @scanline: scanline to use as trigger
|
|
*
|
|
* Return: 0 on success or a negative error code on failure
|
|
*/
|
|
int mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device *dsi, u16 scanline)
|
|
{
|
|
u8 payload[3] = { MIPI_DCS_SET_TEAR_SCANLINE, scanline >> 8,
|
|
scanline & 0xff };
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_generic_write(dsi, payload, sizeof(payload));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_scanline);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_set_display_brightness() - sets the brightness value of the
|
|
* display
|
|
* @dsi: DSI peripheral device
|
|
* @brightness: brightness value
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device *dsi,
|
|
u16 brightness)
|
|
{
|
|
u8 payload[2] = { brightness & 0xff, brightness >> 8 };
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
|
|
payload, sizeof(payload));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness);
|
|
|
|
/**
|
|
* mipi_dsi_dcs_get_display_brightness() - gets the current brightness value
|
|
* of the display
|
|
* @dsi: DSI peripheral device
|
|
* @brightness: brightness value
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device *dsi,
|
|
u16 *brightness)
|
|
{
|
|
ssize_t err;
|
|
|
|
err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
|
|
brightness, sizeof(*brightness));
|
|
if (err <= 0) {
|
|
if (err == 0)
|
|
err = -ENODATA;
|
|
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness);
|
|
|
|
static int mipi_dsi_drv_probe(struct device *dev)
|
|
{
|
|
struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
|
|
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
|
|
|
return drv->probe(dsi);
|
|
}
|
|
|
|
static int mipi_dsi_drv_remove(struct device *dev)
|
|
{
|
|
struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
|
|
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
|
|
|
return drv->remove(dsi);
|
|
}
|
|
|
|
static void mipi_dsi_drv_shutdown(struct device *dev)
|
|
{
|
|
struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
|
|
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
|
|
|
drv->shutdown(dsi);
|
|
}
|
|
|
|
/**
|
|
* mipi_dsi_driver_register_full() - register a driver for DSI devices
|
|
* @drv: DSI driver structure
|
|
* @owner: owner module
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
int mipi_dsi_driver_register_full(struct mipi_dsi_driver *drv,
|
|
struct module *owner)
|
|
{
|
|
drv->driver.bus = &mipi_dsi_bus_type;
|
|
drv->driver.owner = owner;
|
|
|
|
if (drv->probe)
|
|
drv->driver.probe = mipi_dsi_drv_probe;
|
|
if (drv->remove)
|
|
drv->driver.remove = mipi_dsi_drv_remove;
|
|
if (drv->shutdown)
|
|
drv->driver.shutdown = mipi_dsi_drv_shutdown;
|
|
|
|
return driver_register(&drv->driver);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_driver_register_full);
|
|
|
|
/**
|
|
* mipi_dsi_driver_unregister() - unregister a driver for DSI devices
|
|
* @drv: DSI driver structure
|
|
*
|
|
* Return: 0 on success or a negative error code on failure.
|
|
*/
|
|
void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
|
|
{
|
|
driver_unregister(&drv->driver);
|
|
}
|
|
EXPORT_SYMBOL(mipi_dsi_driver_unregister);
|
|
|
|
static int __init mipi_dsi_bus_init(void)
|
|
{
|
|
return bus_register(&mipi_dsi_bus_type);
|
|
}
|
|
postcore_initcall(mipi_dsi_bus_init);
|
|
|
|
MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
|
|
MODULE_DESCRIPTION("MIPI DSI Bus");
|
|
MODULE_LICENSE("GPL and additional rights");
|