Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 56607a81 authored by Linux Build Service Account's avatar Linux Build Service Account Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: mdss: abstract the dsi command utility API"

parents b172e2dd 0c90fa42

drivers/video/msm/mdss/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ endif 
dsi-v2-objs = dsi_v2.o dsi_host_v2.o dsi_io_v2.o

obj-$(CONFIG_FB_MSM_MDSS) += dsi-v2.o



mdss-dsi-objs := mdss_dsi.o mdss_dsi_host.o

mdss-dsi-objs := mdss_dsi.o mdss_dsi_host.o mdss_dsi_cmd.o

mdss-dsi-objs += mdss_dsi_panel.o

mdss-dsi-objs += msm_mdss_io_8974.o

obj-$(CONFIG_FB_MSM_MDSS) += mdss-dsi.o

drivers/video/msm/mdss/mdss_dsi.h

+2 −108
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 


#include "mdss_panel.h"

#include "mdss_io_util.h"

#include "mdss_dsi_cmd.h"



#define MMSS_SERDES_BASE_PHY 0x04f01000 /* mmss (De)Serializer CFG */
@@ -189,81 +190,6 @@ struct dsi_clk_desc { 
	u32 pre_div_func;

};



#define DSI_HOST_HDR_SIZE	4

#define DSI_HDR_LAST		BIT(31)

#define DSI_HDR_LONG_PKT	BIT(30)

#define DSI_HDR_BTA		BIT(29)

#define DSI_HDR_VC(vc)		(((vc) & 0x03) << 22)

#define DSI_HDR_DTYPE(dtype)	(((dtype) & 0x03f) << 16)

#define DSI_HDR_DATA2(data)	(((data) & 0x0ff) << 8)

#define DSI_HDR_DATA1(data)	((data) & 0x0ff)

#define DSI_HDR_WC(wc)		((wc) & 0x0ffff)



#define MDSS_DSI_MRPS	0x04  /* Maximum Return Packet Size */



#define MDSS_DSI_LEN 8 /* 4 x 4 - 6 - 2, bytes dcs header+crc-align  */



struct dsi_buf {

	u32 *hdr;	/* dsi host header */

	char *start;	/* buffer start addr */

	char *end;	/* buffer end addr */

	int size;	/* size of buffer */

	char *data;	/* buffer */

	int len;	/* data length */

	dma_addr_t dmap; /* mapped dma addr */

};



/* dcs read/write */

#define DTYPE_DCS_WRITE		0x05	/* short write, 0 parameter */

#define DTYPE_DCS_WRITE1	0x15	/* short write, 1 parameter */

#define DTYPE_DCS_READ		0x06	/* read */

#define DTYPE_DCS_LWRITE	0x39	/* long write */



/* generic read/write */

#define DTYPE_GEN_WRITE		0x03	/* short write, 0 parameter */

#define DTYPE_GEN_WRITE1	0x13	/* short write, 1 parameter */

#define DTYPE_GEN_WRITE2	0x23	/* short write, 2 parameter */

#define DTYPE_GEN_LWRITE	0x29	/* long write */

#define DTYPE_GEN_READ		0x04	/* long read, 0 parameter */

#define DTYPE_GEN_READ1		0x14	/* long read, 1 parameter */

#define DTYPE_GEN_READ2		0x24	/* long read, 2 parameter */



#define DTYPE_TEAR_ON		0x35	/* set tear on */

#define DTYPE_MAX_PKTSIZE	0x37	/* set max packet size */

#define DTYPE_NULL_PKT		0x09	/* null packet, no data */

#define DTYPE_BLANK_PKT		0x19	/* blankiing packet, no data */



#define DTYPE_CM_ON		0x02	/* color mode off */

#define DTYPE_CM_OFF		0x12	/* color mode on */

#define DTYPE_PERIPHERAL_OFF	0x22

#define DTYPE_PERIPHERAL_ON	0x32



/*

 * dcs response

 */

#define DTYPE_ACK_ERR_RESP      0x02

#define DTYPE_EOT_RESP          0x08    /* end of tx */

#define DTYPE_GEN_READ1_RESP    0x11    /* 1 parameter, short */

#define DTYPE_GEN_READ2_RESP    0x12    /* 2 parameter, short */

#define DTYPE_GEN_LREAD_RESP    0x1a

#define DTYPE_DCS_LREAD_RESP    0x1c

#define DTYPE_DCS_READ1_RESP    0x21    /* 1 parameter, short */

#define DTYPE_DCS_READ2_RESP    0x22    /* 2 parameter, short */





struct dsi_ctrl_hdr {

	char dtype;	/* data type */

	char last;	/* last in chain */

	char vc;	/* virtual chan */

	char ack;	/* ask ACK from peripheral */

	char wait;	/* ms */

	short dlen;	/* 16 bits */

} __packed;



struct dsi_cmd_desc {

	struct dsi_ctrl_hdr dchdr;

	char *payload;

};



struct dsi_panel_cmds {

	char *buf;
@@ -273,29 +199,6 @@ struct dsi_panel_cmds { 
	int link_state;

};



#define CMD_REQ_MAX     4



#define CMD_REQ_RX      0x0001

#define CMD_REQ_COMMIT  0x0002

#define CMD_CLK_CTRL    0x0004

#define CMD_REQ_NO_MAX_PKT_SIZE 0x0008



struct dcs_cmd_req {

	struct dsi_cmd_desc *cmds;

	int cmds_cnt;

	u32 flags;

	int rlen;       /* rx length */

	char *rbuf;	/* rx buf */

	void (*cb)(int data);

};



struct dcs_cmd_list {

	int put;

	int get;

	int tot;

	struct dcs_cmd_req list[CMD_REQ_MAX];

};



struct dsi_kickoff_action {

	struct list_head act_entry;

	void (*action) (void *);
@@ -325,6 +228,7 @@ struct mdss_dsi_ctrl_pdata { 
	int (*off) (struct mdss_panel_data *pdata);

	int (*partial_update_fnc) (struct mdss_panel_data *pdata);

	int (*check_status) (struct mdss_dsi_ctrl_pdata *pdata);

	void (*cmdlist_commit)(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp);

	struct mdss_panel_data panel_data;

	unsigned char *ctrl_base;

	int reg_size;
@@ -386,11 +290,6 @@ struct mdss_dsi_ctrl_pdata { 
int dsi_panel_device_register(struct device_node *pan_node,

				struct mdss_dsi_ctrl_pdata *ctrl_pdata);



char *mdss_dsi_buf_reserve_hdr(struct dsi_buf *dp, int hlen);

char *mdss_dsi_buf_init(struct dsi_buf *dp);

void mdss_dsi_init(void);

int mdss_dsi_buf_alloc(struct dsi_buf *, int size);

int mdss_dsi_cmd_dma_add(struct dsi_buf *dp, struct dsi_cmd_desc *cm);

int mdss_dsi_cmds_tx(struct mdss_dsi_ctrl_pdata *ctrl,

		struct dsi_cmd_desc *cmds, int cnt);
@@ -399,8 +298,6 @@ int mdss_dsi_cmds_rx(struct mdss_dsi_ctrl_pdata *ctrl, 


void mdss_dsi_host_init(struct mipi_panel_info *pinfo,

				struct mdss_panel_data *pdata);

void mdss_dsi_set_tear_on(struct mdss_dsi_ctrl_pdata *ctrl);

void mdss_dsi_set_tear_off(struct mdss_dsi_ctrl_pdata *ctrl);

void mdss_dsi_op_mode_config(int mode,

				struct mdss_panel_data *pdata);

void mdss_dsi_cmd_mode_ctrl(int enable);
@@ -437,9 +334,6 @@ void mdss_dsi_ctrl_init(struct mdss_dsi_ctrl_pdata *ctrl); 
void mdss_dsi_cmd_mdp_busy(struct mdss_dsi_ctrl_pdata *ctrl);

void mdss_dsi_wait4video_done(struct mdss_dsi_ctrl_pdata *ctrl);

void mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp);

int mdss_dsi_cmdlist_put(struct mdss_dsi_ctrl_pdata *ctrl,

				struct dcs_cmd_req *cmdreq);

struct dcs_cmd_req *mdss_dsi_cmdlist_get(struct mdss_dsi_ctrl_pdata *ctrl);

void mdss_dsi_cmdlist_kickoff(int intf);

int mdss_dsi_bta_status_check(struct mdss_dsi_ctrl_pdata *ctrl);

drivers/video/msm/mdss/mdss_dsi_cmd.c

0 → 100644
+689 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */



#include <linux/module.h>

#include <linux/interrupt.h>

#include <linux/spinlock.h>

#include <linux/delay.h>

#include <linux/io.h>

#include <linux/dma-mapping.h>

#include <linux/slab.h>

#include <linux/iopoll.h>

#include <linux/kthread.h>



#include <mach/iommu_domains.h>



#include "mdss_dsi_cmd.h"

#include "mdss_dsi.h"



/*

 * mipi dsi buf mechanism

 */

char *mdss_dsi_buf_reserve(struct dsi_buf *dp, int len)

{

	dp->data += len;

	return dp->data;

}



char *mdss_dsi_buf_unreserve(struct dsi_buf *dp, int len)

{

	dp->data -= len;

	return dp->data;

}



char *mdss_dsi_buf_push(struct dsi_buf *dp, int len)

{

	dp->data -= len;

	dp->len += len;

	return dp->data;

}



char *mdss_dsi_buf_reserve_hdr(struct dsi_buf *dp, int hlen)

{

	dp->hdr = (u32 *)dp->data;

	return mdss_dsi_buf_reserve(dp, hlen);

}



char *mdss_dsi_buf_init(struct dsi_buf *dp)

{

	int off;



	dp->data = dp->start;

	off = (int)dp->data;

	/* 8 byte align */

	off &= 0x07;

	if (off)

		off = 8 - off;

	dp->data += off;

	dp->len = 0;

	return dp->data;

}



int mdss_dsi_buf_alloc(struct dsi_buf *dp, int size)

{



	dp->start = dma_alloc_writecombine(NULL, size, &dp->dmap, GFP_KERNEL);

	if (dp->start == NULL) {

		pr_err("%s:%u\n", __func__, __LINE__);

		return -ENOMEM;

	}



	dp->end = dp->start + size;

	dp->size = size;



	if ((int)dp->start & 0x07)

		pr_err("%s: buf NOT 8 bytes aligned\n", __func__);



	dp->data = dp->start;

	dp->len = 0;

	return size;

}



/*

 * mipi dsi generic long write

 */

static int mdss_dsi_generic_lwrite(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	char *bp;

	u32 *hp;

	int i, len = 0;



	dchdr = &cm->dchdr;

	bp = mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);



	/* fill up payload */

	if (cm->payload) {

		len = dchdr->dlen;

		len += 3;

		len &= ~0x03;	/* multipled by 4 */

		for (i = 0; i < dchdr->dlen; i++)

			*bp++ = cm->payload[i];



		/* append 0xff to the end */

		for (; i < len; i++)

			*bp++ = 0xff;



		dp->len += len;

	}



	/* fill up header */

	hp = dp->hdr;

	*hp = 0;

	*hp = DSI_HDR_WC(dchdr->dlen);

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_LONG_PKT;

	*hp |= DSI_HDR_DTYPE(DTYPE_GEN_LWRITE);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	len += DSI_HOST_HDR_SIZE;



	return len;

}



/*

 * mipi dsi generic short write with 0, 1 2 parameters

 */

static int mdss_dsi_generic_swrite(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;

	int len;



	dchdr = &cm->dchdr;

	if (dchdr->dlen && cm->payload == 0) {

		pr_err("%s: NO payload error\n", __func__);

		return 0;

	}



	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;





	len = (dchdr->dlen > 2) ? 2 : dchdr->dlen;



	if (len == 1) {

		*hp |= DSI_HDR_DTYPE(DTYPE_GEN_WRITE1);

		*hp |= DSI_HDR_DATA1(cm->payload[0]);

		*hp |= DSI_HDR_DATA2(0);

	} else if (len == 2) {

		*hp |= DSI_HDR_DTYPE(DTYPE_GEN_WRITE2);

		*hp |= DSI_HDR_DATA1(cm->payload[0]);

		*hp |= DSI_HDR_DATA2(cm->payload[1]);

	} else {

		*hp |= DSI_HDR_DTYPE(DTYPE_GEN_WRITE);

		*hp |= DSI_HDR_DATA1(0);

		*hp |= DSI_HDR_DATA2(0);

	}



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



/*

 * mipi dsi gerneric read with 0, 1 2 parameters

 */

static int mdss_dsi_generic_read(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;

	int len;



	dchdr = &cm->dchdr;

	if (dchdr->dlen && cm->payload == 0) {

		pr_err("%s: NO payload error\n", __func__);

		return 0;

	}



	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_BTA;

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	len = (dchdr->dlen > 2) ? 2 : dchdr->dlen;



	if (len == 1) {

		*hp |= DSI_HDR_DTYPE(DTYPE_GEN_READ1);

		*hp |= DSI_HDR_DATA1(cm->payload[0]);

		*hp |= DSI_HDR_DATA2(0);

	} else if (len == 2) {

		*hp |= DSI_HDR_DTYPE(DTYPE_GEN_READ2);

		*hp |= DSI_HDR_DATA1(cm->payload[0]);

		*hp |= DSI_HDR_DATA2(cm->payload[1]);

	} else {

		*hp |= DSI_HDR_DTYPE(DTYPE_GEN_READ);

		*hp |= DSI_HDR_DATA1(0);

		*hp |= DSI_HDR_DATA2(0);

	}



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



/*

 * mipi dsi dcs long write

 */

static int mdss_dsi_dcs_lwrite(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	char *bp;

	u32 *hp;

	int i, len = 0;



	dchdr = &cm->dchdr;

	bp = mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);



	/*

	 * fill up payload

	 * dcs command byte (first byte) followed by payload

	 */

	if (cm->payload) {

		len = dchdr->dlen;

		len += 3;

		len &= ~0x03;	/* multipled by 4 */

		for (i = 0; i < dchdr->dlen; i++)

			*bp++ = cm->payload[i];



		/* append 0xff to the end */

		for (; i < len; i++)

			*bp++ = 0xff;



		dp->len += len;

	}



	/* fill up header */

	hp = dp->hdr;

	*hp = 0;

	*hp = DSI_HDR_WC(dchdr->dlen);

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_LONG_PKT;

	*hp |= DSI_HDR_DTYPE(DTYPE_DCS_LWRITE);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);



	len += DSI_HOST_HDR_SIZE;

	return len;

}



/*

 * mipi dsi dcs short write with 0 parameters

 */

static int mdss_dsi_dcs_swrite(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;

	int len;



	dchdr = &cm->dchdr;

	if (cm->payload == 0) {

		pr_err("%s: NO payload error\n", __func__);

		return -EINVAL;

	}



	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	if (dchdr->ack)		/* ask ACK trigger msg from peripeheral */

		*hp |= DSI_HDR_BTA;

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	len = (dchdr->dlen > 1) ? 1 : dchdr->dlen;



	*hp |= DSI_HDR_DTYPE(DTYPE_DCS_WRITE);

	*hp |= DSI_HDR_DATA1(cm->payload[0]);	/* dcs command byte */

	*hp |= DSI_HDR_DATA2(0);



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



/*

 * mipi dsi dcs short write with 1 parameters

 */

static int mdss_dsi_dcs_swrite1(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	if (dchdr->dlen < 2 || cm->payload == 0) {

		pr_err("%s: NO payload error\n", __func__);

		return -EINVAL;

	}



	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	if (dchdr->ack)		/* ask ACK trigger msg from peripeheral */

		*hp |= DSI_HDR_BTA;

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	*hp |= DSI_HDR_DTYPE(DTYPE_DCS_WRITE1);

	*hp |= DSI_HDR_DATA1(cm->payload[0]);	/* dcs comamnd byte */

	*hp |= DSI_HDR_DATA2(cm->payload[1]);	/* parameter */



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}

/*

 * mipi dsi dcs read with 0 parameters

 */



static int mdss_dsi_dcs_read(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	if (cm->payload == 0) {

		pr_err("%s: NO payload error\n", __func__);

		return -EINVAL;

	}



	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_BTA;

	*hp |= DSI_HDR_DTYPE(DTYPE_DCS_READ);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	*hp |= DSI_HDR_DATA1(cm->payload[0]);	/* dcs command byte */

	*hp |= DSI_HDR_DATA2(0);



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



static int mdss_dsi_cm_on(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_DTYPE(DTYPE_CM_ON);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



static int mdss_dsi_cm_off(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_DTYPE(DTYPE_CM_OFF);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



static int mdss_dsi_peripheral_on(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_DTYPE(DTYPE_PERIPHERAL_ON);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



static int mdss_dsi_peripheral_off(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_DTYPE(DTYPE_PERIPHERAL_OFF);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



static int mdss_dsi_set_max_pktsize(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	if (cm->payload == 0) {

		pr_err("%s: NO payload error\n", __func__);

		return 0;

	}



	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_DTYPE(DTYPE_MAX_PKTSIZE);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	*hp |= DSI_HDR_DATA1(cm->payload[0]);

	*hp |= DSI_HDR_DATA2(cm->payload[1]);



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



static int mdss_dsi_null_pkt(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp = DSI_HDR_WC(dchdr->dlen);

	*hp |= DSI_HDR_LONG_PKT;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_DTYPE(DTYPE_NULL_PKT);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



static int mdss_dsi_blank_pkt(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	u32 *hp;



	dchdr = &cm->dchdr;

	mdss_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);

	hp = dp->hdr;

	*hp = 0;

	*hp = DSI_HDR_WC(dchdr->dlen);

	*hp |= DSI_HDR_LONG_PKT;

	*hp |= DSI_HDR_VC(dchdr->vc);

	*hp |= DSI_HDR_DTYPE(DTYPE_BLANK_PKT);

	if (dchdr->last)

		*hp |= DSI_HDR_LAST;



	mdss_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);

	return DSI_HOST_HDR_SIZE; /* 4 bytes */

}



/*

 * prepare cmd buffer to be txed

 */

int mdss_dsi_cmd_dma_add(struct dsi_buf *dp, struct dsi_cmd_desc *cm)

{

	struct dsi_ctrl_hdr *dchdr;

	int len = 0;



	dchdr = &cm->dchdr;



	switch (dchdr->dtype) {

	case DTYPE_GEN_WRITE:

	case DTYPE_GEN_WRITE1:

	case DTYPE_GEN_WRITE2:

		len = mdss_dsi_generic_swrite(dp, cm);

		break;

	case DTYPE_GEN_LWRITE:

		len = mdss_dsi_generic_lwrite(dp, cm);

		break;

	case DTYPE_GEN_READ:

	case DTYPE_GEN_READ1:

	case DTYPE_GEN_READ2:

		len = mdss_dsi_generic_read(dp, cm);

		break;

	case DTYPE_DCS_LWRITE:

		len = mdss_dsi_dcs_lwrite(dp, cm);

		break;

	case DTYPE_DCS_WRITE:

		len = mdss_dsi_dcs_swrite(dp, cm);

		break;

	case DTYPE_DCS_WRITE1:

		len = mdss_dsi_dcs_swrite1(dp, cm);

		break;

	case DTYPE_DCS_READ:

		len = mdss_dsi_dcs_read(dp, cm);

		break;

	case DTYPE_MAX_PKTSIZE:

		len = mdss_dsi_set_max_pktsize(dp, cm);

		break;

	case DTYPE_NULL_PKT:

		len = mdss_dsi_null_pkt(dp, cm);

		break;

	case DTYPE_BLANK_PKT:

		len = mdss_dsi_blank_pkt(dp, cm);

		break;

	case DTYPE_CM_ON:

		len = mdss_dsi_cm_on(dp, cm);

		break;

	case DTYPE_CM_OFF:

		len = mdss_dsi_cm_off(dp, cm);

		break;

	case DTYPE_PERIPHERAL_ON:

		len = mdss_dsi_peripheral_on(dp, cm);

		break;

	case DTYPE_PERIPHERAL_OFF:

		len = mdss_dsi_peripheral_off(dp, cm);

		break;

	default:

		pr_debug("%s: dtype=%x NOT supported\n",

					__func__, dchdr->dtype);

		break;



	}



	return len;

}



/*

 * mdss_dsi_short_read1_resp: 1 parameter

 */

int mdss_dsi_short_read1_resp(struct dsi_buf *rp)

{

	/* strip out dcs type */

	rp->data++;

	rp->len = 1;

	return rp->len;

}



/*

 * mdss_dsi_short_read2_resp: 2 parameter

 */

int mdss_dsi_short_read2_resp(struct dsi_buf *rp)

{

	/* strip out dcs type */

	rp->data++;

	rp->len = 2;

	return rp->len;

}



int mdss_dsi_long_read_resp(struct dsi_buf *rp)

{

	/* strip out dcs header */

	rp->data += 4;

	rp->len -= 4;

	return rp->len;

}



static char set_tear_on[2] = {0x35, 0x00};

static struct dsi_cmd_desc dsi_tear_on_cmd = {

	{DTYPE_DCS_WRITE1, 1, 0, 0, 0, sizeof(set_tear_on)}, set_tear_on};



static char set_tear_off[2] = {0x34, 0x00};

static struct dsi_cmd_desc dsi_tear_off_cmd = {

	{DTYPE_DCS_WRITE, 1, 0, 0, 0, sizeof(set_tear_off)}, set_tear_off};



void mdss_dsi_set_tear_on(struct mdss_dsi_ctrl_pdata *ctrl)

{

	struct dcs_cmd_req cmdreq;



	cmdreq.cmds = &dsi_tear_on_cmd;

	cmdreq.cmds_cnt = 1;

	cmdreq.flags = CMD_REQ_COMMIT;

	cmdreq.rlen = 0;

	cmdreq.cb = NULL;



	mdss_dsi_cmdlist_put(ctrl, &cmdreq);

}



void mdss_dsi_set_tear_off(struct mdss_dsi_ctrl_pdata *ctrl)

{

	struct dcs_cmd_req cmdreq;



	cmdreq.cmds = &dsi_tear_off_cmd;

	cmdreq.cmds_cnt = 1;

	cmdreq.flags = CMD_REQ_COMMIT;

	cmdreq.rlen = 0;

	cmdreq.cb = NULL;



	mdss_dsi_cmdlist_put(ctrl, &cmdreq);

}



/*

 * mdss_dsi_cmd_get: ctrl->cmd_mutex acquired by caller

 */

struct dcs_cmd_req *mdss_dsi_cmdlist_get(struct mdss_dsi_ctrl_pdata *ctrl)

{

	struct dcs_cmd_list *clist;

	struct dcs_cmd_req *req = NULL;



	clist = &ctrl->cmdlist;

	if (clist->get != clist->put) {

		req = &clist->list[clist->get];

		clist->get++;

		clist->get %= CMD_REQ_MAX;

		clist->tot--;

		pr_debug("%s: tot=%d put=%d get=%d\n", __func__,

		clist->tot, clist->put, clist->get);

	}

	return req;

}



int mdss_dsi_cmdlist_put(struct mdss_dsi_ctrl_pdata *ctrl,

				struct dcs_cmd_req *cmdreq)

{

	struct dcs_cmd_req *req;

	struct dcs_cmd_list *clist;

	int ret = 0;



	mutex_lock(&ctrl->cmd_mutex);

	clist = &ctrl->cmdlist;

	req = &clist->list[clist->put];

	*req = *cmdreq;

	clist->put++;

	clist->put %= CMD_REQ_MAX;

	clist->tot++;

	if (clist->put == clist->get) {

		/* drop the oldest one */

		pr_debug("%s: DROP, tot=%d put=%d get=%d\n", __func__,

			clist->tot, clist->put, clist->get);

		clist->get++;

		clist->get %= CMD_REQ_MAX;

		clist->tot--;

	}

	mutex_unlock(&ctrl->cmd_mutex);



	ret++;

	pr_debug("%s: tot=%d put=%d get=%d\n", __func__,

		clist->tot, clist->put, clist->get);



	if (req->flags & CMD_REQ_COMMIT) {

		if (!ctrl->cmdlist_commit)

			pr_err("cmdlist_commit not implemented!\n");

		else

			ctrl->cmdlist_commit(ctrl, 0);

	}

	return ret;

}

drivers/video/msm/mdss/mdss_dsi_cmd.h

0 → 100644
+133 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/video/msm/mdss/mdss_dsi_host.c

+1 −660

File changed.

Preview size limit exceeded, changes collapsed.