static int esc6270_on(struct modem_ctl *mc)
{
int ret;
struct link_device *ld = get_current_link(mc->iod);
pr_info("[MODEM_IF:ESC] <%s> start!!!\n", __func__);
if (!mc->gpio_cp_reset) {
pr_err("[MODEM_IF:ESC] no gpio data\n");
return -ENXIO;
}
if (mc->gpio_reset_req_n)
gpio_set_value(mc->gpio_reset_req_n, 1);
gpio_set_value(mc->gpio_cp_reset, 1);
msleep(30);
gpio_set_value(mc->gpio_cp_on, 1);
msleep(500);
gpio_set_value(mc->gpio_cp_on, 0);
msleep(500);
gpio_set_value(mc->gpio_pda_active, 1);
mc->iod->modem_state_changed(mc->iod, STATE_BOOTING);
ld->mode = LINK_MODE_BOOT;
return 0;
}
static int ss333_force_crash_exit(struct modem_ctl *mc)
{
struct io_device *iod = mc->iod;
struct link_device *ld = get_current_link(iod);
mif_err("+++\n");
mif_add_timer(&mc->crash_ack_timer, FORCE_CRASH_ACK_TIMEOUT,
handle_no_response_cp_crash, (unsigned long)mc);
if (mc->wake_lock && !wake_lock_active(mc->wake_lock)) {
wake_lock(mc->wake_lock);
mif_err("%s->wake_lock locked\n", mc->name);
}
if (ld->off)
ld->off(ld);
gpio_set_value(mc->gpio_ap_dump_int, 1);
mif_info("set ap_dump_int(%d) to high=%d\n",
mc->gpio_ap_dump_int, gpio_get_value(mc->gpio_ap_dump_int));
mif_err("---\n");
return 0;
}
static int cbp72_boot_off(struct modem_ctl *mc)
{
int ret;
struct link_device *ld = get_current_link(mc->bootd);
struct dpram_link_device *dpld = to_dpram_link_device(ld);
mif_debug("\n");
/* Wait here until the PHONE is up.
* Waiting as the this called from IOCTL->UM thread */
mif_info("Waiting for INT_CMD_PHONE_START\n");
ret = wait_for_completion_interruptible_timeout(
&dpld->dpram_init_cmd, DPRAM_INIT_TIMEOUT);
if (!ret) {
/* ret == 0 on timeout, ret < 0 if interrupted */
mif_err("Timeout!!! (PHONE_START was not arrived.)\n");
return -ENXIO;
}
mif_info("Waiting for INT_CMD_PIF_INIT_DONE\n");
ret = wait_for_completion_interruptible_timeout(
&dpld->modem_pif_init_done, PIF_TIMEOUT);
if (!ret) {
mif_err("Timeout!!! (PIF_INIT_DONE was not arrived.)\n");
return -ENXIO;
}
mc->bootd->modem_state_changed(mc->bootd, STATE_ONLINE);
wake_unlock(&mc->mc_wake_lock);
return 0;
}
/* TODO: not verified */
static struct sk_buff *sipc5_hdr_create_multifmt(struct io_device *iod,
struct sipc_hdr *hdr, struct sk_buff *skb)
{
struct sipc5_link_hdr *sipc5h;
struct link_device *ld = get_current_link(iod);
if (hdr->multifmt) {
sipc5h = (struct sipc5_link_hdr *)
skb_push(skb, SIPC5_HDR_LEN_CTRL);
sipc5h->cfg = SIPC5_HDR_CFG_START | SIPC5_HDR_CONTROL;
sipc5h->len = skb->len;
sipc5h->ext.ctl = hdr->multifmt;
sipc5h->ch = iod->id;
/* Should check the alignment for dynamic switch link dev*/
if (ld->aligned) {
sipc5h->cfg |= SIPC5_HDR_PAD;
skb_set_tail_pointer(skb, SIPC_ALIGN(skb->len));
skb->len = SIPC_ALIGN(skb->len);
}
skbpriv(skb)->sipch = (void *)sipc5h;
return skb;
}
return sipc5_hdr_create(iod, hdr, skb);
}
static void hsic_tx_complete(struct urb *urb)
{
struct sk_buff *skb = urb->context;
struct io_device *iod = skbpriv(skb)->iod;
struct link_device *linkdev = get_current_link(iod);
struct usb_link_device *usb_ld = to_usb_link_device(linkdev);
switch (urb->status) {
case 0:
if (urb->actual_length != urb->transfer_buffer_length)
MIF_ERR("TX len=%d, Complete len=%d\n",
urb->transfer_buffer_length, urb->actual_length);
break;
case -ECONNRESET:
if (urb->actual_length)
MIF_ERR("ECONNRESET: TX len=%d, Complete len=%d\n",
urb->transfer_buffer_length, urb->actual_length);
case -ENOENT:
case -ESHUTDOWN:
default:
MIF_ERR("iod %d TX error (%d)\n", iod->id, urb->status);
}
if (iod->atdebug && iod->atdebugfunc)
iod->atdebugfunc(iod, skb->data, skb->len);
dev_kfree_skb_any(skb);
usb_free_urb(urb);
if (urb->dev && usb_ld->if_usb_connected)
usb_mark_last_busy(urb->dev);
}
static void mc_state_fsm(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
int cp_on = gpio_get_value(mc->gpio_cp_on);
int cp_reset = gpio_get_value(mc->gpio_cp_reset);
int cp_active = gpio_get_value(mc->gpio_phone_active);
enum modem_state old_state = mc->phone_state;
enum modem_state new_state = mc->phone_state;
mif_err("old_state:%s cp_on:%d cp_reset:%d cp_active:%d\n",
cp_state_str(old_state), cp_on, cp_reset, cp_active);
if (cp_active) {
if (!cp_on)
new_state = STATE_OFFLINE;
else if (old_state == STATE_ONLINE)
new_state = STATE_CRASH_EXIT;
else
mif_err("don't care!!!\n");
}
if (new_state != old_state) {
/* Change the modem state for RIL */
mc->iod->modem_state_changed(mc->iod, new_state);
if (new_state == STATE_CRASH_EXIT) {
if (ld->close_tx)
ld->close_tx(ld);
}
/* Change the modem state for CBD */
mc->bootd->modem_state_changed(mc->bootd, new_state);
}
}
static void mc_state_fsm(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
int cp_on = gpio_get_value(mc->gpio_cp_on);
int cp_reset = gpio_get_value(mc->gpio_cp_reset);
int cp_active = gpio_get_value(mc->gpio_phone_active);
int old_state = mc->phone_state;
int new_state = mc->phone_state;
mif_err("%s: old_state:%d cp_on:%d cp_reset:%d cp_active:%d\n",
mc->name, old_state, cp_on, cp_reset, cp_active);
if (!cp_active) {
if (!cp_on) {
gpio_set_value(mc->gpio_cp_reset, 0);
new_state = STATE_OFFLINE;
ld->mode = LINK_MODE_OFFLINE;
mif_err("%s: new_state = PHONE_PWR_OFF\n", mc->name);
} else if (old_state == STATE_ONLINE) {
new_state = STATE_CRASH_EXIT;
mif_err("%s: new_state = CRASH_EXIT\n", mc->name);
} else {
mif_err("%s: Don't care!!!\n", mc->name);
}
}
if (old_state != new_state) {
mc->bootd->modem_state_changed(mc->bootd, new_state);
mc->iod->modem_state_changed(mc->iod, new_state);
}
}
static int mdm6600_on(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
pr_info("[MSM] <%s>\n", __func__);
if (!mc->gpio_reset_req_n || !mc->gpio_cp_reset
|| !mc->gpio_cp_on || !mc->gpio_pda_active) {
pr_err("[MSM] no gpio data\n");
return -ENXIO;
}
gpio_set_value(mc->gpio_pda_active, 0);
gpio_set_value(mc->gpio_cp_on, 1);
msleep(500);
gpio_set_value(mc->gpio_reset_req_n, 1);
msleep(50);
gpio_set_value(mc->gpio_cp_reset, 1);
msleep(50);
gpio_set_value(mc->gpio_cp_on, 0);
msleep(500);
gpio_set_value(mc->gpio_pda_active, 1);
mc->iod->modem_state_changed(mc->iod, STATE_BOOTING);
ld->mode = LINK_MODE_BOOT;
return 0;
}
static int mdm6600_reset(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
/* int ret; */
pr_info("[MODEM_IF] mdm6600_reset()\n");
if (!mc->gpio_cp_reset || !mc->gpio_cp_reset_msm || !mc->gpio_cp_on) {
pr_err("[MODEM_IF] no gpio data\n");
return -ENXIO;
}
if (system_rev >= 0x05) {
dev_err(mc->dev, "[%s] system_rev: %d\n", __func__, system_rev);
gpio_set_value(mc->gpio_cp_reset_msm, 0);
msleep(100); /* no spec, confirm later exactly how much time
needed to initialize CP with RESET_PMU_N */
gpio_set_value(mc->gpio_cp_reset_msm, 1);
msleep(40); /* > 37.2 + 2 msec */
} else {
dev_err(mc->dev, "[%s] system_rev: %d\n", __func__, system_rev);
gpio_set_value(mc->gpio_cp_reset, 0);
msleep(500); /* no spec, confirm later exactly how much time
needed to initialize CP with RESET_PMU_N */
gpio_set_value(mc->gpio_cp_reset, 1);
msleep(40); /* > 37.2 + 2 msec */
}
mc->iod->modem_state_changed(mc->iod, STATE_BOOTING);
ld->mode = LINK_MODE_BOOT;
return 0;
}
int mif_dump_dpram(struct io_device *iod)
{
struct link_device *ld = get_current_link(iod);
struct dpram_link_device *dpld = to_dpram_link_device(ld);
u32 size = dpld->size;
unsigned long read_len = 0;
struct sk_buff *skb;
char *buff;
buff = kzalloc(size, GFP_ATOMIC);
if (!buff) {
mif_err("ERR! kzalloc fail\n");
return -ENOMEM;
} else {
dpld->dpram_dump(ld, buff);
}
while (read_len < size) {
skb = alloc_skb(MAX_IPC_SKB_SIZE, GFP_ATOMIC);
if (!skb) {
mif_err("ERR! alloc_skb fail\n");
kfree(buff);
return -ENOMEM;
}
memcpy(skb_put(skb, MAX_IPC_SKB_SIZE),
buff + read_len, MAX_IPC_SKB_SIZE);
skb_queue_tail(&iod->sk_rx_q, skb);
read_len += MAX_IPC_SKB_SIZE;
wake_up(&iod->wq);
}
kfree(buff);
return 0;
}
static int sprd6500_on(struct modem_ctl *mc)
{
int ret;
struct dpram_link_device *dpram_ld =
to_dpram_link_device(get_current_link(mc->iod));
pr_info("[MODEM_IF:ESC] <%s> start!!!\n", __func__);
if (!mc->gpio_cp_reset) {
pr_err("[MODEM_IF:ESC] no gpio data\n");
return -ENXIO;
}
if (mc->gpio_reset_req_n)
gpio_set_value(mc->gpio_reset_req_n, 1);
gpio_set_value(mc->gpio_cp_reset, 1);
msleep(30);
gpio_set_value(mc->gpio_cp_on, 1);
msleep(500);
gpio_set_value(GPIO_FPGA_SPI_MOSI, 1);
gpio_set_value(mc->gpio_fpga1_cs_n, 1);
gpio_set_value(mc->gpio_pda_active, 1);
dpram_ld->dpram_init_status = DPRAM_INIT_STATE_READY;
dpram_ld->cmd_phone_start_handler(dpram_ld);
complete_all(&dpram_ld->dpram_init_cmd);
mc->iod->modem_state_changed(mc->iod, STATE_BOOTING);
return 0;
}
/* menu_func_T */
void
menu_textarea_edit(struct terminal *term, void *xxx, void *ses_)
{
struct session *ses = ses_;
struct document_view *doc_view;
struct link *link;
struct form_state *fs;
struct form_control *fc;
assert(term && ses);
if_assert_failed return;
doc_view = current_frame(ses);
assert(doc_view && doc_view->vs && doc_view->document);
if_assert_failed return;
link = get_current_link(doc_view);
if (!link) return;
fc = get_link_form_control(link);
if (form_field_is_readonly(fc))
return;
fs = find_form_state(doc_view, fc);
if (!fs) return;
textarea_edit(0, term, fs, doc_view, link);
}
static void ss222_mc_state_fsm(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
int cp_on = gpio_get_value(mc->gpio_cp_on);
int cp_reset = gpio_get_value(mc->gpio_cp_reset);
int cp_active = gpio_get_value(mc->gpio_phone_active);
int old_state = mc->phone_state;
int new_state = mc->phone_state;
mif_err("old_state:%s cp_on:%d cp_reset:%d cp_active:%d\n",
get_cp_state_str(old_state), cp_on, cp_reset, cp_active);
if (cp_active) {
if (!cp_on) {
new_state = STATE_OFFLINE;
ld->mode = LINK_MODE_OFFLINE;
} else if (old_state == STATE_ONLINE) {
new_state = STATE_CRASH_EXIT;
ld->mode = LINK_MODE_ULOAD;
} else {
mif_err("don't care!!!\n");
}
}
if (old_state != new_state) {
mif_err("new_state = %s\n", get_cp_state_str(new_state));
mc->bootd->modem_state_changed(mc->bootd, new_state);
mc->iod->modem_state_changed(mc->iod, new_state);
}
}
static int cmc221_on(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
if (!wake_lock_active(&mc->mc_wake_lock))
wake_lock(&mc->mc_wake_lock);
set_sromc_access(true);
mc->phone_state = STATE_OFFLINE;
ld->mode = LINK_MODE_OFFLINE;
mif_err("%s\n", mc->name);
disable_irq_nosync(mc->irq_phone_active);
gpio_set_value(mc->gpio_cp_on, 0);
msleep(100);
gpio_set_value(mc->gpio_cp_reset, 0);
msleep(500);
gpio_set_value(mc->gpio_cp_on, 1);
msleep(100);
gpio_set_value(mc->gpio_cp_reset, 1);
return 0;
}
/**
* SIPC header_create() family functions
*
* Create SIPC5 header
*
* sipc5_hdr_create_skb()
* Create common SIPC5 header
*
* sipc5_hdr_create_legacy_rfs()
* Create SIPC5 header with IPC4.1 RFS header
* Because IMC modem used the 256KB rfs packet and RILD check the full
* packet with RFS header len, kernel remove the SIPC5 header and add the
* lagacy RFS header.
*
* sipc5_hdr_create_multifmt()
* TBD
*
* sipc5_hdr_create_skb_handover()
* Remove the ethernet frame When use `handover' with Network Bridge,
* user -> bridge device(rmnet0) -> real rmnet(xxxx_rmnet0) -> here.
* bridge device is ethernet device unlike xxxx_rmnet(net device).
* We remove the an ethernet header of skb before using skb->len,
* because bridge device added an ethernet header to skb.
*
* RETURN
* Returns the socket buffer that added SIPC5 header.
*
**/
static struct sk_buff *sipc5_hdr_create(struct io_device *iod,
struct sipc_hdr *hdr, struct sk_buff *skb)
{
struct sipc5_link_hdr *sipc5h;
struct link_device *ld = get_current_link(iod);
if (skb->len > 0xFFFF - SIPC5_HDR_LEN_MAX) {
sipc5h = (struct sipc5_link_hdr *)
skb_push(skb, SIPC5_HDR_LEN_EXT);
sipc5h->cfg = SIPC5_HDR_CFG_START | SIPC5_HDR_EXT;
*((u32 *)&sipc5h->len) = (u32)(skb->len);
} else {
sipc5h = (struct sipc5_link_hdr *)
skb_push(skb, SIPC5_HDR_LEN);
sipc5h->cfg = SIPC5_HDR_CFG_START;
sipc5h->len = (u16)(skb->len);
}
sipc5h->ch = iod->id;
/* Should check the alignment for dynamic switch link dev*/
if (ld->aligned) {
sipc5h->cfg |= SIPC5_HDR_PAD;
skb_set_tail_pointer(skb, SIPC_ALIGN(skb->len));
skb->len = SIPC_ALIGN(skb->len);
}
skbpriv(skb)->sipch = (void *)sipc5h;
return skb;
}
static irqreturn_t phone_active_irq_handler(int irq, void *arg)
{
struct modem_ctl *mc = (struct modem_ctl *)arg;
int phone_reset = 0;
int phone_active = 0;
int phone_state = 0;
int cp_dump_int = 0;
if (!mc->gpio_cp_reset ||
!mc->gpio_phone_active) { /* || !mc->gpio_cp_dump_int) { */
pr_err("[MODEM_IF:ESC] no gpio data\n");
return IRQ_HANDLED;
}
phone_reset = gpio_get_value(mc->gpio_cp_reset);
phone_active = gpio_get_value(mc->gpio_phone_active);
cp_dump_int = gpio_get_value(mc->gpio_cp_dump_int);
phone_reset = 1; // actually, we don't use "reset pin"
pr_info("[MODEM_IF:ESC] <%s> phone_reset=%d, phone_active=%d, cp_dump_int=%d\n",
__func__, phone_reset, phone_active, cp_dump_int);
if (phone_reset && phone_active) {
phone_state = STATE_ONLINE;
if (mc->iod && mc->iod->modem_state_changed) {
struct dpram_link_device *dpram_ld =
to_dpram_link_device(get_current_link(mc->iod));
mc->iod->modem_state_changed(mc->iod, phone_state);
/* Do after PHONE_ACTIVE High */
dpram_ld->dpram_init_status = DPRAM_INIT_STATE_READY;
dpram_ld->cmd_phone_start_handler(dpram_ld);
complete_all(&dpram_ld->dpram_init_cmd);
}
} else if (phone_reset && !phone_active) {
if (mc->phone_state == STATE_ONLINE) {
phone_state = STATE_CRASH_EXIT;
if (mc->iod && mc->iod->modem_state_changed)
mc->iod->modem_state_changed(mc->iod,
phone_state);
}
} else {
phone_state = STATE_OFFLINE;
if (mc->iod && mc->iod->modem_state_changed)
mc->iod->modem_state_changed(mc->iod, phone_state);
}
if (phone_active)
irq_set_irq_type(mc->irq_phone_active, IRQ_TYPE_LEVEL_LOW);
else
irq_set_irq_type(mc->irq_phone_active, IRQ_TYPE_LEVEL_HIGH);
pr_info("[MODEM_IF:ESC] <%s> phone_state = %d\n",
__func__, phone_state);
return IRQ_HANDLED;
}
static int ss300_off(struct modem_ctl *mc)
{
struct io_device *iod = mc->iod;
struct link_device *ld = get_current_link(iod);
unsigned long flags;
int i;
mif_disable_irq(&mc->irq_cp_active);
mif_info("%s: %s: +++\n", mc->name, FUNC);
print_mc_state(mc);
spin_lock_irqsave(&mc->lock, flags);
if (cp_offline(mc)) {
spin_unlock_irqrestore(&mc->lock, flags);
mif_err("%s: %s: OFFLINE already!!!\n", mc->name, FUNC);
goto exit;
}
iod->modem_state_changed(iod, STATE_OFFLINE);
spin_unlock_irqrestore(&mc->lock, flags);
if (ld->close_tx)
ld->close_tx(ld);
#if 0
wait_for_link_unmount(mc, ld);
#endif
if (gpio_get_value(mc->gpio_cp_on) == 0) {
mif_err("%s: cp_on == 0\n", mc->name);
goto exit;
}
/* wait for cp_active for 3 seconds */
for (i = 0; i < 150; i++) {
if (gpio_get_value(mc->gpio_phone_active))
break;
msleep(20);
}
print_mc_state(mc);
if (ld->off)
ld->off(ld);
if (gpio_get_value(mc->gpio_cp_reset)) {
mif_err("%s: %s: cp_reset -> 0\n", mc->name, FUNC);
gpio_set_value(mc->gpio_cp_reset, 0);
print_mc_state(mc);
}
exit:
mif_info("%s: %s: ---\n", mc->name, FUNC);
return 0;
}
static void iodev_showtxlink(struct io_device *iod, void *args)
{
char **p = (char **)args;
struct link_device *ld = get_current_link(iod);
if (iod->io_typ == IODEV_NET && IS_CONNECTED(iod, ld))
*p += sprintf(*p, "%s: %s\n", iod->name, ld->name);
}
static int cbp71_on(struct modem_ctl *mc)
{
int RetVal = 0;
int dpram_init_RetVal = 0;
struct link_device *ld = get_current_link(mc->iod);
struct dpram_link_device *dpram_ld = to_dpram_link_device(ld);
mif_info("cbp71_on()\n");
if (!mc->gpio_cp_off || !mc->gpio_cp_reset) {
mif_err("no gpio data\n");
return -ENXIO;
}
gpio_set_value(mc->gpio_cp_reset, 0);
gpio_set_value(mc->gpio_cp_on, 1);
mdelay(300);
gpio_set_value(mc->gpio_cp_off, 1);
mdelay(300);
gpio_set_value(mc->gpio_cp_on, 0);
gpio_set_value(mc->gpio_cp_reset, 1);
gpio_set_value(mc->gpio_pda_active, 1);
mc->iod->modem_state_changed(mc->iod, STATE_BOOTING);
/* Wait here until the PHONE is up.
* Waiting as the this called from IOCTL->UM thread */
mif_debug("power control waiting for INT_MASK_CMD_PIF_INIT_DONE\n");
/* 1HZ = 1 clock tick, 100 default */
dpram_ld->dpctl->clear_intr();
dpram_init_RetVal =
wait_for_completion_interruptible_timeout(
&dpram_ld->dpram_init_cmd, DPRAM_INIT_TIMEOUT);
if (!dpram_init_RetVal) {
/*RetVal will be 0 on timeout, non zero if interrupted */
mif_err("INIT_START cmd was not arrived.\n");
mif_err("init_cmd_wait_condition is 0 and wait timeout happend\n");
return -ENXIO;
}
RetVal = wait_for_completion_interruptible_timeout(
&dpram_ld->modem_pif_init_done, PIF_TIMEOUT);
if (!RetVal) {
/*RetVal will be 0 on timeout, non zero if interrupted */
mif_err("PIF init failed\n");
mif_err("pif_init_wait_condition is 0 and wait timeout happend\n");
return -ENXIO;
}
mif_debug("complete cbp71_on\n");
mc->iod->modem_state_changed(mc->iod, STATE_ONLINE);
return 0;
}
static int cbp82_boot_on(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->bootd);
mif_info("+++\n");
ld->mode = LINK_MODE_BOOT;
mif_info("---\n");
return 0;
}
static int ss300_on(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
int cp_on;
int cp_reset;
int cp_active;
int cp_status;
unsigned long flags;
mif_err("+++\n");
spin_lock_irqsave(&ld->lock, flags);
cp_on = gpio_get_value(mc->gpio_cp_on);
cp_reset = gpio_get_value(mc->gpio_cp_reset);
cp_active = gpio_get_value(mc->gpio_phone_active);
cp_status = gpio_get_value(mc->gpio_cp_status);
mif_err("state:%s cp_on:%d cp_reset:%d cp_active:%d cp_status:%d\n",
mc_state(mc), cp_on, cp_reset, cp_active, cp_status);
mc->phone_state = STATE_OFFLINE;
gpio_set_value(mc->gpio_pda_active, 1);
if (mc->wake_lock && !wake_lock_active(mc->wake_lock)) {
wake_lock(mc->wake_lock);
mif_err("%s->wake_lock locked\n", mc->name);
}
if (ld->ready)
ld->ready(ld);
spin_unlock_irqrestore(&ld->lock, flags);
mif_disable_irq(&mc->irq_cp_active);
gpio_set_value(mc->gpio_cp_on, 0);
msleep(100);
gpio_set_value(mc->gpio_cp_reset, 0);
msleep(500);
gpio_set_value(mc->gpio_cp_on, 1);
msleep(100);
if (ld->reset)
ld->reset(ld);
gpio_set_value(mc->gpio_cp_reset, 1);
msleep(300);
mif_err("---\n");
return 0;
}
static int ss222_force_crash_exit(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->bootd);
mif_err("+++\n");
/* Make DUMP start */
ld->force_dump(ld, mc->bootd);
mif_err("---\n");
return 0;
}
static int cmc221_force_crash_exit(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->bootd);
mif_err("%s\n", mc->name);
/* Make DUMP start */
ld->force_dump(ld, mc->bootd);
return 0;
}
static irqreturn_t cp_active_handler(int irq, void *arg)
{
struct modem_ctl *mc = (struct modem_ctl *)arg;
struct link_device *ld;
enum modem_state old_state;
enum modem_state new_state;
unsigned long flags;
if (!cp_online(mc))
goto exit;
print_mc_state(mc);
if (gpio_get_value(mc->gpio_cp_reset) == 0)
goto exit;
ld = get_current_link(mc->iod);
spin_lock_irqsave(&mc->lock, flags);
old_state = mc->phone_state;
new_state = mc->phone_state;
if (gpio_get_value(mc->gpio_phone_active) != 0) {
if (gpio_get_value(mc->gpio_cp_on) == 0) {
new_state = STATE_OFFLINE;
} else if (old_state == STATE_ONLINE) {
new_state = STATE_CRASH_EXIT;
} else {
mif_err("%s: %s: don't care!!!\n", mc->name, FUNC);
}
}
if (new_state != old_state) {
/* Change the modem state for RIL */
mc->iod->modem_state_changed(mc->iod, new_state);
/* Change the modem state for CBD */
mc->bootd->modem_state_changed(mc->bootd, new_state);
}
spin_unlock_irqrestore(&mc->lock, flags);
if ((old_state == STATE_ONLINE) && (new_state == STATE_CRASH_EXIT)) {
if (timer_pending(&mc->crash_ack_timer))
del_timer(&mc->crash_ack_timer);
if (ld->close_tx)
ld->close_tx(ld);
}
exit:
return IRQ_HANDLED;
}
int esc6270_boot_on(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
#if defined(CONFIG_LINK_DEVICE_DPRAM)
/* clear intr */
struct dpram_link_device *dpld = to_dpram_link_device(ld);
u16 recv_msg = dpld->recv_intr(dpld);
pr_info("[MODEM_IF:ESC] dpram intr: %x\n", recv_msg);
#endif
pr_info("[MODEM_IF:ESC] <%s>\n", __func__);
/* Need to init uart byt gpio_flm_uart_sel GPIO */
if (!mc->gpio_cp_reset || !mc->gpio_flm_uart_sel) {
pr_err("[MODEM_IF:ESC] no gpio data\n");
return -ENXIO;
}
gpio_set_value(mc->gpio_flm_uart_sel, 1);
pr_info(" - ESC_PHONE_ON : %d, ESC_RESET_N : %d\n",
gpio_get_value(mc->gpio_cp_on),
gpio_get_value(mc->gpio_cp_reset));
gpio_set_value(mc->gpio_cp_on, 0);
gpio_direction_output(mc->gpio_cp_reset, 0);
msleep(100);
gpio_direction_output(mc->gpio_cp_on, 1);
msleep(44);
pr_info(" - ESC_PHONE_ON : %d, ESC_RESET_N : %d\n",
gpio_get_value(mc->gpio_cp_on),
gpio_get_value(mc->gpio_cp_reset));
gpio_direction_input(mc->gpio_cp_reset);
msleep(600);
gpio_direction_output(mc->gpio_cp_on, 0);
msleep(20);
pr_info(" - ESC_PHONE_ON : %d, ESC_RESET_N : %d\n",
gpio_get_value(mc->gpio_cp_on),
gpio_get_value(mc->gpio_cp_reset));
#if defined(CONFIG_LINK_DEVICE_PLD)
gpio_direction_output(mc->gpio_fpga_cs_n, 1);
#endif
mc->iod->modem_state_changed(mc->iod, STATE_BOOTING);
ld->mode = LINK_MODE_BOOT;
return 0;
}
static int cbp71_force_crash_exit(struct modem_ctl *mc)
{
struct link_device *ld = get_current_link(mc->iod);
struct dpram_link_device *dpld = to_dpram_link_device(ld);
mif_err("force_crash_exit\n");
mif_err("<%s>\n", mc->bootd->name);
dpld->dpctl->send_intr(INT_CMD(INT_CMD_ERR_DISPLAY));
mc->iod->modem_state_changed(mc->iod, STATE_CRASH_EXIT);
return 0;
}
static ssize_t show_dm_state(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct miscdevice *miscdev = dev_get_drvdata(dev);
struct io_device *iod = to_io_device(miscdev);
struct link_device *ld = get_current_link(iod);
char *p = buf;
p += sprintf(buf, "%d\n", ld->dm_log_enable);
mif_info("dm logging enable:%d\n", ld->dm_log_enable);
return p - buf;
}
static ssize_t store_dm_state(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct miscdevice *miscdev = dev_get_drvdata(dev);
struct io_device *iod = to_io_device(miscdev);
struct link_device *ld = get_current_link(iod);
ld->dm_log_enable = !!buf[0];
ld->enable_dm(ld, ld->dm_log_enable);
mif_info("dm logging enable:%d\n", ld->dm_log_enable);
return count;
}
static int ss300_on(struct modem_ctl *mc)
{
struct io_device *iod = mc->iod;
struct link_device *ld = get_current_link(iod);
unsigned long flags;
mif_disable_irq(&mc->irq_cp_active);
mif_info("%s: %s: +++\n", mc->name, FUNC);
print_mc_state(mc);
spin_lock_irqsave(&mc->lock, flags);
iod->modem_state_changed(iod, STATE_OFFLINE);
gpio_set_value(mc->gpio_pda_active, 1);
if (mc->wake_lock && !wake_lock_active(mc->wake_lock)) {
wake_lock(mc->wake_lock);
mif_err("%s->wake_lock locked\n", mc->name);
}
if (ld->ready)
ld->ready(ld);
spin_unlock_irqrestore(&mc->lock, flags);
gpio_set_value(mc->gpio_cp_on, 0);
msleep(100);
gpio_set_value(mc->gpio_cp_reset, 0);
print_mc_state(mc);
msleep(500);
gpio_set_value(mc->gpio_cp_on, 1);
msleep(100);
if (ld->reset)
ld->reset(ld);
if (mc->gpio_ap_dump_int)
gpio_set_value(mc->gpio_ap_dump_int, 0);
gpio_set_value(mc->gpio_cp_reset, 1);
print_mc_state(mc);
msleep(300);
mif_info("%s: %s: ---\n", mc->name, FUNC);
return 0;
}
static irqreturn_t phone_active_irq_handler(int irq, void *_mc)
{
int phone_reset = 0;
int phone_active_value = 0;
int cp_dump_value = 0;
int phone_state = 0;
struct modem_ctl *mc = (struct modem_ctl *)_mc;
if (!mc->gpio_cp_reset || !mc->gpio_phone_active
/*|| !mc->gpio_cp_dump_int */) {
pr_err("[MODEM_IF] no gpio data\n");
return IRQ_HANDLED;
}
phone_reset = gpio_get_value(mc->gpio_cp_reset);
phone_active_value = gpio_get_value(mc->gpio_phone_active);
pr_info("[MODEM_IF] PA EVENT : reset =%d, pa=%d, cp_dump=%d\n",
phone_reset, phone_active_value, cp_dump_value);
if (phone_reset && phone_active_value) {
phone_state = STATE_ONLINE;
if (mc->iod && mc->iod->modem_state_changed)
mc->iod->modem_state_changed(mc->iod, phone_state);
} else if (phone_reset && !phone_active_value) {
if (count == 1) {
phone_state = STATE_CRASH_EXIT;
if (mc->iod) {
ld = get_current_link(mc->iod);
if (ld->terminate_comm)
ld->terminate_comm(ld, mc->iod);
}
if (mc->iod && mc->iod->modem_state_changed)
mc->iod->modem_state_changed
(mc->iod, phone_state);
count = 0;
} else {
count++;
}
} else {
phone_state = STATE_OFFLINE;
if (mc->iod && mc->iod->modem_state_changed)
mc->iod->modem_state_changed(mc->iod, phone_state);
}
pr_info("phone_active_irq_handler : phone_state=%d\n", phone_state);
return IRQ_HANDLED;
}
