void usi6276_power(struct sw_modem *modem, u32 on)
{
modem_dbg("set %s modem power %s\n", modem->name, (on ? "on" : "off"));
if(on){
/* default */
//modem_vbat(modem, 1);
modem_dldo_on_off(modem, 1);
modem_power_on_off(modem, 0);
sw_module_mdelay(5);
modem_reset(modem,1);
sw_module_mdelay(20);
modem_power_on_off(modem, 1);
}else{
modem_power_on_off(modem, 0);
sw_module_mdelay(5);
modem_reset(modem,0);
sw_module_mdelay(20);
modem_power_on_off(modem, 1);
modem_dldo_on_off(modem, 0);
//modem_vbat(modem, 0);
}
return;
}
/*
*******************************************************************************
*
* (1)��wankeup : ���߳���100����, ���׳���100����, �����߳���100����, ������
* (2)��sleep : ���߳���100����, ���׳���100����, �����߳���100����, ������
*
*******************************************************************************
*/
static void usi6276_sleep(struct sw_modem *modem, u32 sleep)
{
modem_dbg("%s modem %s\n", modem->name, (sleep ? "sleep" : "wakeup"));
if(sleep){
modem_reset(modem, 0);
}else{
modem_reset(modem, 1);
}
return;
}
void usi6276_reset(struct sw_modem *modem)
{
modem_dbg("reset %s modem\n", modem->name);
//modem_reset(modem, 0);
modem_reset(modem, 0);
sw_module_mdelay(100);
modem_reset(modem, 1);
sw_module_mdelay(10);
//modem_reset(modem, 1);
return;
}
static ssize_t store_control(struct device *d,
struct device_attribute *attr, const char *buf, size_t count)
{
struct modemctl *mc = dev_get_drvdata(d);
if (!strncmp(buf, "on", 2)) {
modem_on(mc);
return count;
}
if (!strncmp(buf, "off", 3)) {
modem_off(mc);
return count;
}
if (!strncmp(buf, "reset", 5)) {
modem_reset(mc);
return count;
}
if (!strncmp(buf, "boot", 4)) {
modem_boot(mc);
return count;
}
if (!strncmp(buf, "daolpu", 6)) {
kernel_upload(mc);
return count;
}
return count;
}
static ssize_t modem_write (struct file *filp, const char __user *buffer, size_t count, loff_t *offset)
{
if(!global_mc)
return -1;
if(count >= 4 && !strncmp(buffer, "main", 4))
{
modem_main_enumeration(global_mc);
}
if(count >= 5 && !strncmp(buffer, "flash", 5))
{
modem_boot_enumeration(global_mc);
}
if(count >= 3 && !strncmp(buffer, "off", 3))
{
modem_on(global_mc);
}
if(count >= 2 && !strncmp(buffer, "on", 2))
{
modem_off(global_mc);
}
if(count >= 5 && !strncmp(buffer, "reset", 5))
{
modem_reset(global_mc);
}
return count;
}
static void ifx_trap_delayed_work(struct work_struct *work)
{
unsigned long flags;
int nResetStatus = 0;
static int nCount = 0;
spin_lock_irqsave(&ifx_trap_lock, flags);
if (!gpio_get_value(GPIO_IFX_TRAP_INT_N))
{
printk(KERN_ERR ">>>>IFX status pin makes interrupt, but still HIGH.....\n");
nResetStatus = 1;
}
else {
printk(KERN_ERR ">>>>IFX6160 was trapped!\n");
nCount++;
if ( nCount == 1 )
{
printk(KERN_ERR ">>>>IFX6160 do reset!\n");
modem_reset();
goto error;
}
else if ( nCount > 1 ) nCount = 0;
}
#ifdef LGE_FEATURE_CP_RESET_RECOVERY
ts0710_CPState_to_GPS();
cwc_notify_reset(nResetStatus);
#else
ts0710_cp_emergency_state(); // filtering of the false alarm, instead of the cwc_notify_reset()
#endif //LGE_FEATURE_CP_RESET_RECOVERY
error:
spin_unlock_irqrestore(&ifx_trap_lock, flags);
}
static long modemctl_ioctl(struct file *filp,
unsigned int cmd, unsigned long arg)
{
struct modemctl *mc = filp->private_data;
int ret;
mutex_lock(&mc->ctl_lock);
switch (cmd) {
case IOCTL_MODEM_RESET:
ret = modem_reset(mc);
MODEM_COUNT(mc,resets);
break;
case IOCTL_MODEM_START:
ret = modem_start(mc, 0);
break;
case IOCTL_MODEM_RAMDUMP:
ret = modem_start(mc, 1);
break;
case IOCTL_MODEM_OFF:
ret = modem_off(mc);
break;
default:
ret = -EINVAL;
}
mutex_unlock(&mc->ctl_lock);
pr_info("modemctl_ioctl() %d\n", ret);
return ret;
}
static long modemctl_ioctl(struct file *filp,
unsigned int cmd, unsigned long arg)
{
struct modemctl *mc = filp->private_data;
struct dpram_firmware fw;
struct stat_info *pst;
int ret = 0;
mutex_lock(&mc->ctl_lock);
switch (cmd) {
case IOCTL_MODEM_RESET:
ret = modem_reset(mc);
MODEM_COUNT(mc,resets);
break;
case IOCTL_MODEM_START:
ret = modem_start(mc, 0);
break;
case IOCTL_MODEM_RAMDUMP:
ret = modem_start(mc, 1);
break;
case IOCTL_MODEM_OFF:
ret = modem_off(mc);
break;
/* CDMA modem update in recovery mode */
case IOCTL_MODEM_FW_UPDATE:
pr_info("IOCTL_MODEM_FW_UPDATE\n");
if (arg == '\0') {
pr_err("No firmware");
break;
}
ret = copy_from_user((void *)&fw, (void *)arg, sizeof(fw));
if (ret < 0) {
pr_err("copy from user failed!");
ret = -EINVAL;
} else if (dpram_process_modem_update(mc, &fw) < 0) {
pr_err("firmware write failed\n");
ret = -EIO;
}
break;
case IOCTL_MODEM_CHK_STAT:
pst = (struct stat_info *)arg;
if (mc->is_modem_delta_update)
ret = dpram_chk_delta_update(mc, &(pst->pct), pst->msg);
else
ret = dpram_chk_full_update(mc, &(pst->pct), pst->msg);
break;
case IOCTL_MODEM_PWROFF:
pr_info("IOCTL_MODEM_PWROFF\n");
dpram_modem_pwroff(mc);
break;
default:
ret = -EINVAL;
}
mutex_unlock(&mc->ctl_lock);
pr_info("modemctl_ioctl() %d\n", ret);
return ret;
}
static ssize_t store_control(struct device *d,
struct device_attribute *attr, const char *buf, size_t count)
{
struct modemctl *mc = dev_get_drvdata(d);
if (!strncmp(buf, "on", 2)) {
modem_on(mc);
return count;
}
if (!strncmp(buf, "off", 3)) {
modem_off(mc);
return count;
}
if (!strncmp(buf, "reset", 5)) {
modem_reset(mc);
return count;
}
if (!strncmp(buf, "boot", 4)) {
modem_boot(mc);
return count;
}
if (!strncmp(buf, "renum", 6)) {
enumeration(mc);
return count;
}
if (!strncmp(buf, "phon", 4)) {
gpio_set_value(mc->gpio_phone_on, 0);
mdelay(1);
gpio_set_value(mc->gpio_phone_on, 1);
return count;
}
if (!strncmp(buf, "gsw=0", 5)) {
gpio_set_value(mc->gpio_ipc_slave_wakeup, 0);
return count;
}
if (!strncmp(buf, "gsw=1", 5)) {
gpio_set_value(mc->gpio_ipc_slave_wakeup, 1);
return count;
}
if (!strncmp(buf, "gat=0", 5)) {
gpio_set_value(mc->gpio_active_state, 0);
return count;
}
if (!strncmp(buf, "gat=1", 5)) {
gpio_set_value(mc->gpio_active_state, 1);
return count;
}
return count;
}
static int ifx_spi_shutdown(struct spi_device *spi)
{
//printk("%s()\n", __func__);
// if modem is not connected, return
if (!is_modem_connected())
return 0;
// power down modem by gpio
if (modem_powerdown()) // if fail to power down, retry
{
modem_reset();
mdelay(6000); // wait until CP reboot
modem_powerdown();
}
return 0;
}
static ssize_t store_control(struct device *d,
struct device_attribute *attr, const char *buf, size_t count)
{
struct modemctl *mc = dev_get_drvdata(d);
if (!strncmp(buf, "on", 2)) {
modem_on(mc);
return count;
}
if (!strncmp(buf, "off", 3)) {
modem_off(mc);
return count;
}
if (!strncmp(buf, "reset", 5)) {
modem_reset(mc);
return count;
}
if (!strncmp(buf, "boot", 4)) {
//modem_boot(mc);
ignore_irq_count = 1;
enable_irq(mc->irq[0]);
return count;
}
if (!strncmp(buf, "daolpu", 6)) {
kernel_upload(mc);
return count;
}
if (!strncmp(buf, "silent", 6)) {
printk(KERN_ERR "%s -LTE Silent Reset!!!\n", __func__);
crash_event(1);
return count;
}
return count;
}
int modem_ioctl (struct file *filp, unsigned int cmd, unsigned long arg)
{
if(!global_mc)
return -1;
switch(cmd)
{
case MODEM_POWER_MAIN_CMD:
modem_main_enumeration(global_mc);
break;
case MODEM_POWER_FLASH_CMD:
modem_boot_enumeration(global_mc);
break;
case MODEM_POWER_OFF_CMD:
modem_off(global_mc);
break;
case MODEM_POWER_ON_CMD:
modem_on(global_mc);
break;
case MODEM_POWER_RESET_CMD:
modem_reset(global_mc);
break;
}
return 0;
}
// Helper function to keep code base small
void modem_test_demodstats(modulation_scheme _ms)
{
// generate mod/demod
modem mod = modem_create(_ms);
modem demod = modem_create(_ms);
// run the test
unsigned int i, s, M = 1 << modem_get_bps(mod);
float complex x;
float complex x_hat; // rotated symbol
float demodstats;
float phi = 0.01f;
for (i=0; i<M; i++) {
// reset modem objects
modem_reset(mod);
modem_reset(demod);
// modulate symbol
modem_modulate(mod, i, &x);
// ignore rare condition where modulated symbol is (0,0)
// (e.g. APSK-8)
if (cabsf(x) < 1e-3f) continue;
// add phase offsets
x_hat = x * cexpf( phi*_Complex_I);
// demod positive phase signal, and ensure demodulator
// maps to appropriate symbol
modem_demodulate(demod, x_hat, &s);
if (s != i)
AUTOTEST_WARN("modem_test_demodstats(), output symbol does not match");
demodstats = modem_get_demodulator_phase_error(demod);
CONTEND_EXPRESSION(demodstats > 0.0f);
}
// repeat with negative phase error
for (i=0; i<M; i++) {
// reset modem objects
modem_reset(mod);
modem_reset(demod);
// modulate symbol
modem_modulate(mod, i, &x);
// ignore rare condition where modulated symbol is (0,0)
// (e.g. APSK-8)
if (cabsf(x) < 1e-3f) continue;
// add phase offsets
x_hat = x * cexpf(-phi*_Complex_I);
// demod positive phase signal, and ensure demodulator
// maps to appropriate symbol
modem_demodulate(demod, x_hat, &s);
if (s != i)
AUTOTEST_WARN("modem_test_demodstats(), output symbol does not match");
demodstats = modem_get_demodulator_phase_error(demod);
CONTEND_EXPRESSION(demodstats < 0.0f);
}
// clean up allocated objects up
modem_destroy(mod);
modem_destroy(demod);
}
int test_loopback()
{
int ret;
pthread_t rx_thread;
ret = setup_signal_handler();
if (ret < 0)
return 1;
ret = modem_setup();
if(ret) {
perror(": Failed to setup modem");
return ret;
}
ret = modem_reset();
if(ret) {
perror(": Failed to reset modem");
return 1;
}
ret = modem_start();
if(ret) {
perror(": Failed to start modem");
return 1;
}
ret = pthread_create(&rx_thread, NULL, rx_thread_fnc, NULL);
if(ret) {
perror(": Error - pthread_create");
return 1;
}
printf("Setup modem defaults\n");
defaults(INTERNAL_PACKET_GEN, IP_LOOPBACK_MODE);
if (INTERNAL_PACKET_GEN) {
sleep(1);
fill_in_internal_pgen_data();
printf("Sending 1 packet from internal IP\n");
reg_write(0x120, 1);
reg_write(0x120, 0);
sleep(3);
} else {
sleep(1);
printf("Sending data\n");
ret = receive_data();
sleep(3);
}
modem_stop();
pthread_join(rx_thread, NULL);
modem_close();
int i;
bool b = false;
for(i = 0; i < TX_BUF_SIZE-HEADER_DATA_SIZE; i++) {
b |= rx_buffer[i] != tx_buffer[i+HEADER_DATA_SIZE];
}
if (b) {
printf("\n---------RX|TX---------\n");
for(i = 0; i < TX_BUF_SIZE-HEADER_DATA_SIZE; i++) {
printf("%d %d\n", rx_buffer[i]>>0, tx_buffer[i+HEADER_DATA_SIZE]);
}
}
printf("Exiting test\n");
return (int) b;
}
void* mc77x0_thread_reg(modem_t *priv)
{
enum registration_state_e state = RS_INIT;
at_queue_t* at_q = modem_proto_get(priv, MODEM_PROTO_AT);
const modem_info_device_t* mdd = priv->mdd;
int periodical_reset;
int state_delay = 0;
modem_conf_t conf;
int last_error;
int prev_last_error = 0;
int cnt_last_error = 0;
while(!priv->reg.terminate)
{
/* delay for commands */
if(state_delay)
{
/* periodical reset handling */
if(state != RS_RESET && conf.periodical_reset)
{
if(periodical_reset == 0)
{
printf("Periodical reset modem..\n");
periodical_reset = conf.periodical_reset * 3600;
state = RS_RESET;
}
else
{
-- periodical_reset;
#ifdef _DEV_EDITION
printf("Periodical reset modem: %d\n", periodical_reset);
#endif
}
}
sleep(1);
#ifdef _DEV_EDITION
printf("Delay: %d\n", state_delay);
#endif
-- state_delay;
continue;
}
last_error = modem_queues_last_error(priv, MODEM_PROTO_AT);
/* I/O modem error handling */
if(last_error == __ME_WRITE_FAILED || last_error == __ME_READ_FAILED)
{
++ cnt_last_error;
#if _DEV_EDITION
printf("cnt_last_error: %d\n", cnt_last_error);
#endif
if(cnt_last_error > 3)
{
cnt_last_error = 0;
prev_last_error = at_q->last_error;
printf("(EE) Too many errors (%d), reseting modem..\n", prev_last_error);
state = RS_RESET;
}
state_delay = 1;
}
else
{
cnt_last_error = 0;
prev_last_error = at_q->last_error;
}
#ifdef _DEV_EDITION
printf("State: %s\n", RS_STR[state]);
printf("last_error: %d\n", at_q->last_error);
#endif
if(state == RS_INIT)
{
printf("Started registration for modem on port %s\n", priv->port);
/* initialize data */
priv->reg.last_error = __ME_REG_IN_PROGRESS;
priv->reg.state.reg = MODEM_NETWORK_REG_SEARCHING;
state = RS_DISABLE_ECHO;
}
else if(state == RS_DISABLE_ECHO)
{
at_raw_ok(priv, "ATE0\r\n");
state = RS_CMEE_NUMBER;
}
else if(state == RS_CMEE_NUMBER)
{
at_raw_ok(priv, "AT+CMEE=1\r\n");
state = RS_GET_FIRMWARE_VER;
}
else if(state == RS_GET_FIRMWARE_VER)
{
mdd->functions.get_fw_version(priv, &priv->reg.state.fw_info);
state = RS_GET_IMEI;
}
else if(state == RS_GET_IMEI)
{
mdd->functions.get_imei(priv, priv->reg.state.imei, sizeof(priv->reg.state.imei));
state = RS_READ_CONFIG;
}
else if(state == RS_READ_CONFIG)
{
/* waiting for config */
if(modem_conf_read(priv->port, &conf))
{
state_delay = 1;
continue;
}
periodical_reset = conf.periodical_reset * 3600;
state = RS_SET_BAND;
}
else if(state == RS_SET_BAND)
{
/* current modem band */
int band = mdd->functions.get_freq_band(priv);
printf("(II) Modem Band is %x\n", band);
if(conf.frequency_band != band)
{
/* band selection */
if(mdd->functions.set_freq_band(priv, conf.frequency_band))
{
priv->reg.last_error = at_q->last_error;
printf("(EE) Band selection error: %d\n", at_q->last_error);
return(NULL);
}
/* delay for band setup */
state_delay = 5;
/* reset is required */
state = RS_RESET;
continue;
}
state = RS_CHECK_PIN;
}
else if(state == RS_CHECK_PIN)
{
switch(mdd->functions.cpin_state(priv))
{
case MODEM_CPIN_STATE_PIN:
state = RS_SET_PIN;
break;
case MODEM_CPIN_STATE_PUK:
state = RS_SET_PUK;
break;
case MODEM_CPIN_STATE_READY:
state = RS_GET_IMSI;
break;
default:
/* registration error? */;
priv->reg.last_error = at_q->last_error;
if(at_q->last_error == __ME_SIM_BUSY)
state_delay = 5;
else if(at_q->last_error == __ME_SIM_WRONG)
/* buggy MC7750 ... */
state_delay = 10;
else if(at_q->last_error == __ME_NO_SIM)
{
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
return(NULL);
}
}
}
else if(state == RS_SET_PIN)
{
if(*conf.pin && !mdd->functions.cpin_pin(priv, conf.pin))
{
state = RS_GET_IMSI;
}
else
{
printf("(EE) PIN Error\n");
if(*conf.pin)
/* SIM PIN invalid */
priv->reg.last_error = at_q->last_error;
else
priv->reg.last_error = __ME_SIM_PIN;
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
return(NULL);
}
}
else if(state == RS_SET_PUK)
{
if(*conf.pin && *conf.puk && !mdd->functions.cpin_puk(priv, conf.puk, conf.pin))
{
state = RS_GET_IMSI;
}
else
{
if(*conf.pin && *conf.puk)
/* SIM PUK invalid */
priv->reg.last_error = at_q->last_error;
else
priv->reg.last_error = __ME_SIM_PUK;
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
return(NULL);
}
}
else if(state == RS_GET_IMSI)
{
if(conf.frequency_band == 10)
{
state = RS_OPERATOR_SELECT;
printf("(WW) Band is CDMA skip SIM Check's\n");
continue;
}
if(!mdd->functions.get_imsi(priv, priv->reg.state.imsi, sizeof(priv->reg.state.imsi)))
{
/* SIM busy? */
state_delay = 5;
continue;
}
/* mcc */
strncpy(priv->reg.state.mcc, priv->reg.state.imsi, sizeof(priv->reg.state.mcc) - 1);
priv->reg.state.mcc[sizeof(priv->reg.state.mcc) - 1] = 0;
/* mnc */
strncpy(priv->reg.state.mnc, priv->reg.state.imsi + strlen(priv->reg.state.mcc), sizeof(priv->reg.state.mnc) - 1);
priv->reg.state.mnc[mnc_get_length(priv->reg.state.imsi)] = 0;
state = RS_MCC_LOCK;
}
else if(state == RS_MCC_LOCK)
{
printf("MCC = [%s]\n", priv->reg.state.mcc);
if(*conf.mcc_lock)
{
if(strcmp(priv->reg.state.mcc, conf.mcc_lock) != 0)
{
/* Network not allowed, emergency calls only */
priv->reg.last_error = __ME_MCC_LOCKED;
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
printf("(EE) MCC Lock error\n");
return(NULL);
}
}
state = RS_MNC_LOCK;
}
else if(state == RS_MNC_LOCK)
{
printf("MNC = [%s]\n", priv->reg.state.mnc);
if(*conf.mnc_lock)
{
if(strcmp(priv->reg.state.mnc, conf.mnc_lock) != 0)
{
/* Network not allowed, emergency calls only */
priv->reg.last_error = __ME_MNC_LOCKED;
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
printf("(EE) MNC Lock error\n");
return(NULL);
}
}
state = RS_CCID_LOCK;
}
else if(state == RS_CCID_LOCK)
{
if(!mc77x0_at_get_ccid(priv, priv->reg.state.ccid, sizeof(priv->reg.state.ccid)))
{
state_delay = 5;
continue;
}
printf("CCID = [%s]\n", priv->reg.state.ccid);
if
(
*conf.ccid.low && *conf.ccid.high && (
strcasecmp(priv->reg.state.ccid, conf.ccid.low) < 0 ||
strcasecmp(conf.ccid.high, priv->reg.state.ccid) < 0
)
)
{
/* Network not allowed, emergency calls only */
priv->reg.last_error = __ME_CCID_LOCKED;
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
printf("(EE) CCID Lock error\n");
return(NULL);
}
state = RS_MSIN_LOCK;
}
else if(state == RS_MSIN_LOCK)
{
strncpy(priv->reg.state.msin,
priv->reg.state.imsi +
strlen(priv->reg.state.mcc) +
strlen(priv->reg.state.mnc),
sizeof(priv->reg.state.msin));
printf("MSIN = [%s]\n", priv->reg.state.msin);
if
(
*conf.msin.low && *conf.msin.high && (
strcasecmp(priv->reg.state.msin, conf.msin.low) < 0 ||
strcasecmp(conf.msin.high, priv->reg.state.msin) < 0
)
)
{
/* Network not allowed, emergency calls only */
priv->reg.last_error = __ME_MSIN_LOCKED;
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
printf("(EE) MSIN Lock error\n");
return(NULL);
}
state = RS_OPERATOR_SELECT;
}
else if(state == RS_OPERATOR_SELECT)
{
if(mdd->functions.operator_select(priv, conf.operator_number, conf.access_technology))
{
// operator selection is failed, wait 5 seconds and try again
state_delay = 5;
continue;
}
state = RS_CHECK_REGISTRATION;
}
else if(state == RS_CHECK_REGISTRATION)
{
priv->reg.state.reg = mdd->functions.network_registration(priv);
/* if roaming disabled */
if(MODEM_NETWORK_REG_ROAMING == priv->reg.state.reg && !conf.roaming)
/* set registration status as a denied */
priv->reg.state.reg = MODEM_NETWORK_REG_DENIED;
switch(priv->reg.state.reg)
{
case MODEM_NETWORK_REG_HOME:
case MODEM_NETWORK_REG_ROAMING:
priv->reg.ready = 1;
priv->reg.last_error = -1;
state = RS_GET_SIGNAL_QUALITY;
break;
default:
priv->reg.ready = 0;
priv->reg.last_error = __ME_REG_IN_PROGRESS;
state_delay = 5;
break;
}
}
else if(state == RS_GET_SIGNAL_QUALITY)
{
mdd->functions.get_signal_quality(priv, &priv->reg.state.sq);
state = RS_GET_NETWORK_TYPE;
}
else if(state == RS_GET_NETWORK_TYPE)
{
mdd->functions.get_network_type(priv, priv->reg.state.network_type, sizeof(priv->reg.state.network_type));
state = RS_GET_OPERATOR_NUMBER;
}
else if(state == RS_GET_OPERATOR_NUMBER)
{
if(!mdd->functions.get_operator_number(priv, priv->reg.state.oper_number, sizeof(priv->reg.state.oper_number)))
*priv->reg.state.oper_number = 0;
state = RS_GET_OPERATOR_NAME;
}
else if(state == RS_GET_OPERATOR_NAME)
{
if(!mdd->functions.get_operator_name(priv, priv->reg.state.oper, sizeof(priv->reg.state.oper)))
*priv->reg.state.oper = 0;
state = RS_CHECK_REGISTRATION;
state_delay = 10;
}
else if(state == RS_RESET)
{
modem_reset(priv);
state = RS_INIT;
}
}
return(NULL);
}
