1 files changed, 138 insertions, 139 deletions

diff --git a/drivers/misc/modem_if/modem_link_device_pld_ext_op.c b/drivers/misc/modem_if/modem_link_device_pld_ext_op.c
index ae6578c..26b0e28 100644
--- a/drivers/misc/modem_if/modem_link_device_pld_ext_op.c
+++ b/drivers/misc/modem_if/modem_link_device_pld_ext_op.c
@@ -25,8 +25,8 @@
 #include <linux/if_arp.h>
 #include <linux/platform_device.h>
 #include <linux/kallsyms.h>
-#include <linux/platform_data/modem.h>
 
+#include "modem.h"
 #include "modem_prj.h"
 #include "modem_link_device_pld.h"
 #include "modem_utils.h"
@@ -41,56 +41,55 @@ enum qc_dload_tag {
 
 static void qc_dload_task(unsigned long data);
 
-static void qc_init_boot_map(struct dpram_link_device *dpld)
+static void qc_init_boot_map(struct pld_link_device *pld)
 {
-	struct qc_dpram_boot_map *bt_map = &dpld->qc_bt_map;
-	struct modemlink_dpram_control *dpctl = dpld->dpctl;
+	struct qc_dpram_boot_map *qbt_map = &pld->qc_bt_map;
+	struct modemlink_dpram_data *dpram = pld->dpram;
 
-	bt_map->buff = dpld->dev[0]->txq.buff;
-	bt_map->frame_size = (u16 *)(dpld->dp_base + dpctl->boot_size_offset);
-	bt_map->tag = (u16 *)(dpld->dp_base + dpctl->boot_tag_offset);
-	bt_map->count = (u16 *)(dpld->dp_base + dpctl->boot_count_offset);
+	qbt_map->buff = pld->dev[0]->txq.buff;
+	qbt_map->frame_size = (u16 *)(pld->base + dpram->boot_size_offset);
+	qbt_map->tag = (u16 *)(pld->base + dpram->boot_tag_offset);
+	qbt_map->count = (u16 *)(pld->base + dpram->boot_count_offset);
 
-	tasklet_init(&dpld->dl_tsk, qc_dload_task, (unsigned long)dpld);
+	tasklet_init(&pld->dl_tsk, qc_dload_task, (unsigned long)pld);
 }
 
-static void qc_dload_map(struct dpram_link_device *dpld, u8 is_upload)
+static void qc_dload_map(struct pld_link_device *pld, u8 is_upload)
 {
-	struct qc_dpram_boot_map *bt_map = &dpld->qc_bt_map;
-	struct modemlink_dpram_control *dpctl = dpld->dpctl;
+	struct qc_dpram_boot_map *qbt_map = &pld->qc_bt_map;
+	struct modemlink_dpram_data *dpram = pld->dpram;
 	unsigned int upload_offset = 0;
 
 	if (is_upload == 1)	{
 		upload_offset = 0x1000;
-		bt_map->buff = dpld->dev[0]->rxq.buff;
+		qbt_map->buff = pld->dev[0]->rxq.buff;
 	}	else {
 		upload_offset = 0;
-		bt_map->buff = dpld->dev[0]->txq.buff;
+		qbt_map->buff = pld->dev[0]->txq.buff;
 	}
 
-	bt_map->frame_size = (u16 *)(dpld->dp_base +
-			dpctl->boot_size_offset + upload_offset);
-	bt_map->tag = (u16 *)(dpld->dp_base +
-			dpctl->boot_tag_offset + upload_offset);
-	bt_map->count = (u16 *)(dpld->dp_base +
-			dpctl->boot_count_offset + upload_offset);
-
+	qbt_map->frame_size = (u16 *)(pld->base +
+			dpram->boot_size_offset + upload_offset);
+	qbt_map->tag = (u16 *)(pld->base +
+			dpram->boot_tag_offset + upload_offset);
+	qbt_map->count = (u16 *)(pld->base +
+			dpram->boot_count_offset + upload_offset);
 }
 
-static int qc_prepare_download(struct dpram_link_device *dpld)
+static int qc_prepare_download(struct pld_link_device *pld)
 {
 	int retval = 0;
 	int count = 0;
 
-	qc_dload_map(dpld, 0);
+	qc_dload_map(pld, 0);
 
 	while (1) {
-		if (dpld->udl_check.copy_start) {
-			dpld->udl_check.copy_start = 0;
+		if (pld->qc_udl_check.copy_start) {
+			pld->qc_udl_check.copy_start = 0;
 			break;
 		}
 
-		msleep(20);
+		usleep_range(10000, 11000);
 
 		count++;
 		if (count > 1000) {
@@ -102,42 +101,42 @@ static int qc_prepare_download(struct dpram_link_device *dpld)
 	return retval;
 }
 
-static void _qc_do_download(struct dpram_link_device *dpld,
-			struct dpram_udl_param *param)
+static void _qc_do_download(struct pld_link_device *pld,
+			struct qc_dpram_udl_param *param)
 {
-	struct qc_dpram_boot_map *bt_map = &dpld->qc_bt_map;
+	struct qc_dpram_boot_map *qbt_map = &pld->qc_bt_map;
 
-	if (param->size <= dpld->dpctl->max_boot_frame_size) {
-		iowrite16(PLD_ADDR_MASK(&bt_map->buff[0]),
-					dpld->address_buffer);
-		memcpy(dpld->dp_base, param->addr, param->size);
+	if (param->size <= pld->dpram->max_boot_frame_size) {
+		iowrite16(PLD_ADDR_MASK(&qbt_map->buff[0]),
+					pld->address_buffer);
+		memcpy(pld->base, param->addr, param->size);
 
-		iowrite16(PLD_ADDR_MASK(&bt_map->frame_size[0]),
-					dpld->address_buffer);
-		iowrite16(param->size, dpld->dp_base);
+		iowrite16(PLD_ADDR_MASK(&qbt_map->frame_size[0]),
+					pld->address_buffer);
+		iowrite16(param->size, pld->base);
 
-		iowrite16(PLD_ADDR_MASK(&bt_map->tag[0]),
-					dpld->address_buffer);
-		iowrite16(param->tag, dpld->dp_base);
+		iowrite16(PLD_ADDR_MASK(&qbt_map->tag[0]),
+					pld->address_buffer);
+		iowrite16(param->tag, pld->base);
 
-		iowrite16(PLD_ADDR_MASK(&bt_map->count[0]),
-					dpld->address_buffer);
-		iowrite16(param->count, dpld->dp_base);
+		iowrite16(PLD_ADDR_MASK(&qbt_map->count[0]),
+					pld->address_buffer);
+		iowrite16(param->count, pld->base);
 
-		dpld->send_intr(dpld, 0xDB12);
+		pld->send_intr(pld, 0xDB12);
 	} else {
 		mif_info("param->size %d\n", param->size);
 	}
 }
 
-static int _qc_download(struct dpram_link_device *dpld, void *arg,
+static int _qc_download(struct pld_link_device *pld, void *arg,
 			enum qc_dload_tag tag)
 {
 	int retval = 0;
 	int count = 0;
 	int cnt_limit;
 	unsigned char *img;
-	struct dpram_udl_param param;
+	struct qc_dpram_udl_param param;
 
 	retval = copy_from_user((void *)&param, (void *)arg, sizeof(param));
 	if (retval < 0) {
@@ -153,24 +152,24 @@ static int _qc_download(struct dpram_link_device *dpld, void *arg,
 	memset(img, 0, param.size);
 	memcpy(img, param.addr, param.size);
 
-	dpld->udl_check.total_size = param.size;
-	dpld->udl_check.rest_size = param.size;
-	dpld->udl_check.send_size = 0;
-	dpld->udl_check.copy_complete = 0;
+	pld->qc_udl_check.total_size = param.size;
+	pld->qc_udl_check.rest_size = param.size;
+	pld->qc_udl_check.send_size = 0;
+	pld->qc_udl_check.copy_complete = 0;
 
-	dpld->udl_param.addr = img;
-	dpld->udl_param.size = dpld->dpctl->max_boot_frame_size;
+	pld->qc_udl_param.addr = img;
+	pld->qc_udl_param.size = pld->dpram->max_boot_frame_size;
 	if (tag == QC_DLOAD_TAG_NV)
-		dpld->udl_param.count = 1;
+		pld->qc_udl_param.count = 1;
 	else
-		dpld->udl_param.count = param.count;
-	dpld->udl_param.tag = tag;
+		pld->qc_udl_param.count = param.count;
+	pld->qc_udl_param.tag = tag;
 
-	if (dpld->udl_check.rest_size < dpld->dpctl->max_boot_frame_size)
-		dpld->udl_param.size = dpld->udl_check.rest_size;
+	if (pld->qc_udl_check.rest_size < pld->dpram->max_boot_frame_size)
+		pld->qc_udl_param.size = pld->qc_udl_check.rest_size;
 
 	/* Download image (binary or NV) */
-	_qc_do_download(dpld, &dpld->udl_param);
+	_qc_do_download(pld, &pld->qc_udl_param);
 
 	/* Wait for completion
 	*/
@@ -180,13 +179,13 @@ static int _qc_download(struct dpram_link_device *dpld, void *arg,
 		cnt_limit = 1000;
 
 	while (1) {
-		if (dpld->udl_check.copy_complete) {
-			dpld->udl_check.copy_complete = 0;
+		if (pld->qc_udl_check.copy_complete) {
+			pld->qc_udl_check.copy_complete = 0;
 			retval = 0;
 			break;
 		}
 
-		msleep(20);
+		usleep_range(10000, 11000);
 
 		count++;
 		if (count > cnt_limit) {
@@ -201,53 +200,53 @@ static int _qc_download(struct dpram_link_device *dpld, void *arg,
 	return retval;
 }
 
-static int qc_download_bin(struct dpram_link_device *dpld, void *arg)
+static int qc_download_bin(struct pld_link_device *pld, void *arg)
 {
-	return _qc_download(dpld, arg, QC_DLOAD_TAG_BIN);
+	return _qc_download(pld, arg, QC_DLOAD_TAG_BIN);
 }
 
-static int qc_download_nv(struct dpram_link_device *dpld, void *arg)
+static int qc_download_nv(struct pld_link_device *pld, void *arg)
 {
-	return _qc_download(dpld, arg, QC_DLOAD_TAG_NV);
+	return _qc_download(pld, arg, QC_DLOAD_TAG_NV);
 }
 
 static void qc_dload_task(unsigned long data)
 {
-	struct dpram_link_device *dpld = (struct dpram_link_device *)data;
+	struct pld_link_device *pld = (struct pld_link_device *)data;
 
-	dpld->udl_check.send_size += dpld->udl_param.size;
-	dpld->udl_check.rest_size -= dpld->udl_param.size;
+	pld->qc_udl_check.send_size += pld->qc_udl_param.size;
+	pld->qc_udl_check.rest_size -= pld->qc_udl_param.size;
 
-	dpld->udl_param.addr += dpld->udl_param.size;
+	pld->qc_udl_param.addr += pld->qc_udl_param.size;
 
-	if (dpld->udl_check.send_size >= dpld->udl_check.total_size) {
-		dpld->udl_check.copy_complete = 1;
-		dpld->udl_param.tag = 0;
+	if (pld->qc_udl_check.send_size >= pld->qc_udl_check.total_size) {
+		pld->qc_udl_check.copy_complete = 1;
+		pld->qc_udl_param.tag = 0;
 		return;
 	}
 
-	if (dpld->udl_check.rest_size < dpld->dpctl->max_boot_frame_size)
-		dpld->udl_param.size = dpld->udl_check.rest_size;
+	if (pld->qc_udl_check.rest_size < pld->dpram->max_boot_frame_size)
+		pld->qc_udl_param.size = pld->qc_udl_check.rest_size;
 
-	dpld->udl_param.count += 1;
+	pld->qc_udl_param.count += 1;
 
-	_qc_do_download(dpld, &dpld->udl_param);
+	_qc_do_download(pld, &pld->qc_udl_param);
 }
 
-static void qc_dload_cmd_handler(struct dpram_link_device *dpld, u16 cmd)
+static void qc_dload_cmd_handler(struct pld_link_device *pld, u16 cmd)
 {
 	switch (cmd) {
 	case 0x1234:
-		dpld->udl_check.copy_start = 1;
+		pld->qc_udl_check.copy_start = 1;
 		break;
 
 	case 0xDBAB:
-		tasklet_schedule(&dpld->dl_tsk);
+		tasklet_schedule(&pld->dl_tsk);
 		break;
 
 	case 0xABCD:
-		mif_info("[%s] booting Start\n", dpld->ld.name);
-		dpld->udl_check.boot_complete = 1;
+		mif_info("[%s] booting Start\n", pld->ld.name);
+		pld->qc_udl_check.boot_complete = 1;
 		break;
 
 	default:
@@ -255,22 +254,22 @@ static void qc_dload_cmd_handler(struct dpram_link_device *dpld, u16 cmd)
 	}
 }
 
-static int qc_boot_start(struct dpram_link_device *dpld)
+static int qc_boot_start(struct pld_link_device *pld)
 {
 	u16 mask = 0;
 	int count = 0;
 
 	/* Send interrupt -> '0x4567' */
 	mask = 0x4567;
-	dpld->send_intr(dpld, mask);
+	pld->send_intr(pld, mask);
 
 	while (1) {
-		if (dpld->udl_check.boot_complete) {
-			dpld->udl_check.boot_complete = 0;
+		if (pld->qc_udl_check.boot_complete) {
+			pld->qc_udl_check.boot_complete = 0;
 			break;
 		}
 
-		msleep(20);
+		usleep_range(10000, 11000);
 
 		count++;
 		if (count > 200) {
@@ -282,17 +281,17 @@ static int qc_boot_start(struct dpram_link_device *dpld)
 	return 0;
 }
 
-static int qc_boot_post_process(struct dpram_link_device *dpld)
+static int qc_boot_post_process(struct pld_link_device *pld)
 {
 	int count = 0;
 
 	while (1) {
-		if (dpld->boot_start_complete) {
-			dpld->boot_start_complete = 0;
+		if (pld->boot_start_complete) {
+			pld->boot_start_complete = 0;
 			break;
 		}
 
-		msleep(20);
+		usleep_range(10000, 11000);
 
 		count++;
 		if (count > 200) {
@@ -304,7 +303,7 @@ static int qc_boot_post_process(struct dpram_link_device *dpld)
 	return 0;
 }
 
-static void qc_start_handler(struct dpram_link_device *dpld)
+static void qc_start_handler(struct pld_link_device *pld)
 {
 	/*
 	 * INT_MASK_VALID | INT_MASK_CMD | INT_MASK_CP_AIRPLANE_BOOT |
@@ -312,38 +311,38 @@ static void qc_start_handler(struct dpram_link_device *dpld)
 	 */
 	u16 mask = (0x0080 | 0x0040 | 0x1000 | 0x0100 | 0x0002);
 
-	dpld->boot_start_complete = 1;
+	pld->boot_start_complete = 1;
 
 	/* Send INIT_END code to CP */
 	mif_info("send 0x%04X (INIT_END)\n", mask);
 
-	dpld->send_intr(dpld, mask);
+	pld->send_intr(pld, mask);
 }
 
-static void qc_crash_log(struct dpram_link_device *dpld)
+static void qc_crash_log(struct pld_link_device *pld)
 {
-	struct link_device *ld = &dpld->ld;
+	struct link_device *ld = &pld->ld;
 	static unsigned char buf[151];
 	u8 __iomem *data = NULL;
 
-	data = dpld->get_rx_buff(dpld, IPC_FMT);
+	data = pld->get_rx_buff(pld, IPC_FMT);
 	memcpy(buf, data, (sizeof(buf) - 1));
 
 	mif_info("PHONE ERR MSG\t| %s Crash\n", ld->mdm_data->name);
 	mif_info("PHONE ERR MSG\t| %s\n", buf);
 }
 
-static int _qc_data_upload(struct dpram_link_device *dpld,
-			struct dpram_udl_param *param)
+static int _qc_data_upload(struct pld_link_device *pld,
+			struct qc_dpram_udl_param *param)
 {
-	struct qc_dpram_boot_map *bt_map = &dpld->qc_bt_map;
+	struct qc_dpram_boot_map *qbt_map = &pld->qc_bt_map;
 	int retval = 0;
 	u16 intval = 0;
 	int count = 0;
 
 	while (1) {
-		if (!gpio_get_value(dpld->gpio_dpram_int)) {
-			intval = dpld->recv_intr(dpld);
+		if (!gpio_get_value(pld->gpio_ipc_int2ap)) {
+			intval = pld->recv_intr(pld);
 			if (intval == 0xDBAB) {
 				break;
 			} else {
@@ -352,7 +351,7 @@ static int _qc_data_upload(struct dpram_link_device *dpld,
 			}
 		}
 
-		msleep(20);
+		usleep_range(1000, 2000);
 
 		count++;
 		if (count > 200) {
@@ -361,43 +360,43 @@ static int _qc_data_upload(struct dpram_link_device *dpld,
 		}
 	}
 
-	iowrite16(PLD_ADDR_MASK(&bt_map->frame_size[0]),
-				dpld->address_buffer);
-	param->size = ioread16(dpld->dp_base);
+	iowrite16(PLD_ADDR_MASK(&qbt_map->frame_size[0]),
+				pld->address_buffer);
+	param->size = ioread16(pld->base);
 
-	iowrite16(PLD_ADDR_MASK(&bt_map->tag[0]),
-				dpld->address_buffer);
-	param->tag = ioread16(dpld->dp_base);
+	iowrite16(PLD_ADDR_MASK(&qbt_map->tag[0]),
+				pld->address_buffer);
+	param->tag = ioread16(pld->base);
 
-	iowrite16(PLD_ADDR_MASK(&bt_map->count[0]),
-				dpld->address_buffer);
-	param->count = ioread16(dpld->dp_base);
+	iowrite16(PLD_ADDR_MASK(&qbt_map->count[0]),
+				pld->address_buffer);
+	param->count = ioread16(pld->base);
 
-	iowrite16(PLD_ADDR_MASK(&bt_map->buff[0]),
-				dpld->address_buffer);
-	memcpy(param->addr, dpld->dp_base, param->size);
+	iowrite16(PLD_ADDR_MASK(&qbt_map->buff[0]),
+				pld->address_buffer);
+	memcpy(param->addr, pld->base, param->size);
 
-	dpld->send_intr(dpld, 0xDB12);
+	pld->send_intr(pld, 0xDB12);
 
 	return retval;
 }
 
-static int qc_uload_step1(struct dpram_link_device *dpld)
+static int qc_uload_step1(struct pld_link_device *pld)
 {
 	int retval = 0;
 	int count = 0;
 	u16 intval = 0;
 	u16 mask = 0;
 
-	qc_dload_map(dpld, 1);
+	qc_dload_map(pld, 1);
 
 	mif_info("+---------------------------------------------+\n");
 	mif_info("|            UPLOAD PHONE SDRAM               |\n");
 	mif_info("+---------------------------------------------+\n");
 
 	while (1) {
-		if (!gpio_get_value(dpld->gpio_dpram_int)) {
-			intval = dpld->recv_intr(dpld);
+		if (!gpio_get_value(pld->gpio_ipc_int2ap)) {
+			intval = pld->recv_intr(pld);
 			mif_info("intr 0x%04x\n", intval);
 			if (intval == 0x1234) {
 				break;
@@ -407,11 +406,11 @@ static int qc_uload_step1(struct dpram_link_device *dpld)
 			}
 		}
 
-		msleep(20);
+		usleep_range(1000, 2000);
 
 		count++;
 		if (count > 200) {
-			intval = dpld->recv_intr(dpld);
+			intval = pld->recv_intr(pld);
 			mif_info("count %d, intr 0x%04x\n", count, intval);
 			if (intval == 0x1234)
 				break;
@@ -420,15 +419,15 @@ static int qc_uload_step1(struct dpram_link_device *dpld)
 	}
 
 	mask = 0xDEAD;
-	dpld->send_intr(dpld, mask);
+	pld->send_intr(pld, mask);
 
 	return retval;
 }
 
-static int qc_uload_step2(struct dpram_link_device *dpld, void *arg)
+static int qc_uload_step2(struct pld_link_device *pld, void *arg)
 {
 	int retval = 0;
-	struct dpram_udl_param param;
+	struct qc_dpram_udl_param param;
 
 	retval = copy_from_user((void *)&param, (void *)arg, sizeof(param));
 	if (retval < 0) {
@@ -436,7 +435,7 @@ static int qc_uload_step2(struct dpram_link_device *dpld, void *arg)
 		return -1;
 	}
 
-	retval = _qc_data_upload(dpld, &param);
+	retval = _qc_data_upload(pld, &param);
 	if (retval < 0) {
 		mif_err("ERR! _qc_data_upload fail (err %d)\n", retval);
 		return -1;
@@ -446,7 +445,7 @@ static int qc_uload_step2(struct dpram_link_device *dpld, void *arg)
 		mif_info("param->count = %d\n", param.count);
 
 	if (param.tag == 4) {
-		enable_irq(dpld->irq);
+		enable_irq(pld->irq);
 		mif_info("param->tag = %d\n", param.tag);
 	}
 
@@ -459,57 +458,57 @@ static int qc_uload_step2(struct dpram_link_device *dpld, void *arg)
 	return retval;
 }
 
-static int qc_ioctl(struct dpram_link_device *dpld, struct io_device *iod,
+static int qc_ioctl(struct pld_link_device *pld, struct io_device *iod,
 		unsigned int cmd, unsigned long arg)
 {
-	struct link_device *ld = &dpld->ld;
+	struct link_device *ld = &pld->ld;
 	int err = 0;
 
 	switch (cmd) {
 	case IOCTL_DPRAM_PHONE_POWON:
-		err = qc_prepare_download(dpld);
+		err = qc_prepare_download(pld);
 		if (err < 0)
 			mif_info("%s: ERR! prepare_download fail\n", ld->name);
 		break;
 
 	case IOCTL_DPRAM_PHONEIMG_LOAD:
-		err = qc_download_bin(dpld, (void *)arg);
+		err = qc_download_bin(pld, (void *)arg);
 		if (err < 0)
 			mif_info("%s: ERR! download_bin fail\n", ld->name);
 		break;
 
 	case IOCTL_DPRAM_NVDATA_LOAD:
-		err = qc_download_nv(dpld, (void *)arg);
+		err = qc_download_nv(pld, (void *)arg);
 		if (err < 0)
 			mif_info("%s: ERR! download_nv fail\n", ld->name);
 		break;
 
 	case IOCTL_DPRAM_PHONE_BOOTSTART:
-		err = qc_boot_start(dpld);
+		err = qc_boot_start(pld);
 		if (err < 0) {
 			mif_info("%s: ERR! boot_start fail\n", ld->name);
 			break;
 		}
 
-		err = qc_boot_post_process(dpld);
+		err = qc_boot_post_process(pld);
 		if (err < 0)
 			mif_info("%s: ERR! boot_post_process fail\n", ld->name);
 
 		break;
 
 	case IOCTL_DPRAM_PHONE_UPLOAD_STEP1:
-		disable_irq_nosync(dpld->irq);
-		err = qc_uload_step1(dpld);
+		disable_irq_nosync(pld->irq);
+		err = qc_uload_step1(pld);
 		if (err < 0) {
-			enable_irq(dpld->irq);
+			enable_irq(pld->irq);
 			mif_info("%s: ERR! upload_step1 fail\n", ld->name);
 		}
 		break;
 
 	case IOCTL_DPRAM_PHONE_UPLOAD_STEP2:
-		err = qc_uload_step2(dpld, (void *)arg);
+		err = qc_uload_step2(pld, (void *)arg);
 		if (err < 0) {
-			enable_irq(dpld->irq);
+			enable_irq(pld->irq);
 			mif_info("%s: ERR! upload_step2 fail\n", ld->name);
 		}
 		break;
@@ -524,7 +523,7 @@ static int qc_ioctl(struct dpram_link_device *dpld, struct io_device *iod,
 }
 #endif
 
-static struct dpram_ext_op ext_op_set[] = {
+static struct pld_ext_op ext_op_set[] = {
 #if defined(CONFIG_CDMA_MODEM_MDM6600)
 	[QC_MDM6600] = {
 		.exist = 1,
@@ -547,7 +546,7 @@ static struct dpram_ext_op ext_op_set[] = {
 #endif
 };
 
-struct dpram_ext_op *dpram_get_ext_op(enum modem_t modem)
+struct pld_ext_op *pld_get_ext_op(enum modem_t modem)
 {
 	if (ext_op_set[modem].exist)
 		return &ext_op_set[modem];