static int __init msm_serial_hsl_init_irda(void)
{
int ret;
/* Switch Uart Debug by Kernel Flag */
if (get_kernel_flag() & KERNEL_FLAG_SERIAL_HSL_ENABLE)
msm_serial_hsl_enable = 1;
if (!msm_serial_hsl_enable)
msm_hsl_uart_driver.cons = NULL;
ret = uart_register_driver(&msm_hsl_uart_driver);
if (unlikely(ret))
return ret;
debug_base = debugfs_create_dir("msm_serial_irda", NULL);
if (IS_ERR_OR_NULL(debug_base))
E("%s():Cannot create debugfs dir\n", __func__);
ret = platform_driver_register(&msm_hsl_platform_driver);
if (unlikely(ret))
uart_unregister_driver(&msm_hsl_uart_driver);
D("%s(): driver initialized, msm_serial_hsl_enable %d\n", __func__, msm_serial_hsl_enable);
return ret;
}
static void smsm_state_cb_hdlr(void *data, uint32_t old_state,
uint32_t new_state)
{
char *smem_reset_reason;
char buffer[MAX_BUF_SIZE];
unsigned smem_reset_size;
unsigned size;
riva_crash = true;
pr_err("%s: smsm state changed\n", MODULE_NAME);
if (get_kernel_flag() & KERNEL_FLAG_ENABLE_SSR_WCNSS) {
smsm_change_state_ssr(SMSM_APPS_STATE, SMSM_RESET, 0, KERNEL_FLAG_ENABLE_SSR_WCNSS);
}
if (!(new_state & SMSM_RESET))
return;
if (ss_restart_inprogress) {
pr_err("%s: Ignoring smsm reset req, restart in progress\n",
MODULE_NAME);
return;
}
if (!enable_riva_ssr) {
ssr_set_restart_reason(
"riva fatal: SMSM reset request received from Riva");
panic(MODULE_NAME ": SMSM reset request received from Riva");
}
smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_WCNSS0,
&smem_reset_size);
if (!smem_reset_reason || !smem_reset_size) {
pr_err("%s: wcnss subsystem failure reason: %s\n",
__func__, "(unknown, smem_get_entry failed)");
} else if (!smem_reset_reason[0]) {
pr_err("%s: wcnss subsystem failure reason: %s\n",
__func__, "(unknown, init string found)");
} else {
size = smem_reset_size < MAX_BUF_SIZE ? smem_reset_size :
(MAX_BUF_SIZE - 1);
memcpy(buffer, smem_reset_reason, size);
buffer[size] = '\0';
pr_err("%s: wcnss subsystem failure reason: %s\n",
__func__, buffer);
memset(smem_reset_reason, 0, smem_reset_size);
wmb();
}
ss_restart_inprogress = true;
subsystem_restart("riva");
}
static int __init riva_ssr_module_init(void)
{
int ret;
ret = smsm_state_cb_register(SMSM_WCNSS_STATE, SMSM_RESET,
smsm_state_cb_hdlr, 0);
if (ret < 0) {
pr_err("%s: Unable to register smsm callback for Riva Reset! %d\n",
MODULE_NAME, ret);
goto out;
}
ret = request_irq(RIVA_APSS_WDOG_BITE_RESET_RDY_IRQ,
riva_wdog_bite_irq_hdlr, IRQF_TRIGGER_HIGH,
"riva_wdog", NULL);
if (ret < 0) {
pr_err("%s: Unable to register for Riva bite interrupt (%d)\n",
MODULE_NAME, ret);
goto out;
}
if (get_kernel_flag() & KERNEL_FLAG_ENABLE_SSR_WCNSS)
enable_riva_ssr = 1;
pr_info("%s: enable_riva_ssr set to %d\n", __func__, enable_riva_ssr);
ret = riva_restart_init();
if (ret < 0) {
pr_err("%s: Unable to register with ssr. (%d)\n",
MODULE_NAME, ret);
goto out;
}
riva_ramdump_dev = create_ramdump_device("riva");
if (!riva_ramdump_dev) {
pr_err("%s: Unable to create ramdump device.\n",
MODULE_NAME);
ret = -ENOMEM;
goto out;
}
INIT_DELAYED_WORK(&cancel_vote_work, riva_post_bootup);
pr_info("%s: module initialized\n", MODULE_NAME);
out:
return ret;
}
static void smsm_state_cb_hdlr(void *data, uint32_t old_state,
uint32_t new_state)
{
if (get_kernel_flag() & KERNEL_FLAG_ENABLE_SSR_WCNSS)
smsm_change_state_ssr(SMSM_APPS_STATE, SMSM_RESET, 0, KERNEL_FLAG_ENABLE_SSR_WCNSS);
riva_crash = true;
pr_info("%s: smsm state changed to smsm reset\n", MODULE_NAME);
if (ss_restart_inprogress) {
pr_info("%s: Ignoring smsm reset req, restart in progress\n",
MODULE_NAME);
return;
}
if (new_state & SMSM_RESET) {
ss_restart_inprogress = true;
schedule_work(&riva_smsm_cb_work);
}
}
static int __init msm_serial_hsl_init(void)
{
int ret;
/* Switch uartdebug by kernelflag */
if (get_kernel_flag() & BIT1)
msm_serial_hsl_enable = 1;
if (!msm_serial_hsl_enable)
msm_hsl_uart_driver.cons = NULL;
ret = uart_register_driver(&msm_hsl_uart_driver);
if (unlikely(ret))
return ret;
ret = platform_driver_probe(&msm_hsl_platform_driver,
msm_serial_hsl_probe);
if (unlikely(ret))
uart_unregister_driver(&msm_hsl_uart_driver);
printk(KERN_INFO "msm_serial_hsl: driver initialized\n");
return ret;
}
static int __init rmnet_init(void)
{
int ret;
struct device *d;
struct net_device *dev;
struct rmnet_private *p;
unsigned n;
char *tempname;
if (get_kernel_flag() & KERNEL_FLAG_RIL_DBG_RMNET)
ril_debug_flag = 1;
pr_info(MODULE_NAME "%s: BAM devices[%d]\n", __func__, RMNET_DEVICE_COUNT);
#ifdef CONFIG_MSM_RMNET_DEBUG
timeout_us = 0;
#ifdef CONFIG_HAS_EARLYSUSPEND
timeout_suspend_us = 0;
#endif
#endif
for (n = 0; n < RMNET_DEVICE_COUNT; n++) {
dev = alloc_netdev(sizeof(struct rmnet_private),
"rmnet%d", rmnet_setup);
if (!dev) {
pr_err(MODULE_NAME "%s: no memory for netdev %d\n", __func__, n);
return -ENOMEM;
}
netdevs[n] = dev;
d = &(dev->dev);
p = netdev_priv(dev);
/* Initial config uses Ethernet */
p->operation_mode = RMNET_MODE_LLP_ETH;
p->ch_id = n;
p->waiting_for_ul_skb = NULL;
p->in_reset = 0;
spin_lock_init(&p->lock);
spin_lock_init(&p->tx_queue_lock);
#ifdef CONFIG_MSM_RMNET_DEBUG
p->timeout_us = timeout_us;
p->wakeups_xmit = p->wakeups_rcv = 0;
#endif
ret = register_netdev(dev);
if (ret) {
pr_err(MODULE_NAME "%s: unable to register netdev"
" %d rc=%d\n", __func__, n, ret);
free_netdev(dev);
return ret;
}
#ifdef CONFIG_MSM_RMNET_DEBUG
if (device_create_file(d, &dev_attr_timeout))
continue;
if (device_create_file(d, &dev_attr_wakeups_xmit))
continue;
if (device_create_file(d, &dev_attr_wakeups_rcv))
continue;
#ifdef CONFIG_HAS_EARLYSUSPEND
if (device_create_file(d, &dev_attr_timeout_suspend))
continue;
/* Only care about rmnet0 for suspend/resume tiemout hooks. */
if (n == 0)
rmnet0 = d;
#endif
#endif
bam_rmnet_drivers[n].probe = bam_rmnet_probe;
bam_rmnet_drivers[n].remove = bam_rmnet_remove;
tempname = kmalloc(BAM_DMUX_CH_NAME_MAX_LEN, GFP_KERNEL);
if (tempname == NULL)
return -ENOMEM;
scnprintf(tempname, BAM_DMUX_CH_NAME_MAX_LEN, "bam_dmux_ch_%d",
n);
bam_rmnet_drivers[n].driver.name = tempname;
bam_rmnet_drivers[n].driver.owner = THIS_MODULE;
ret = platform_driver_register(&bam_rmnet_drivers[n]);
if (ret) {
pr_err(MODULE_NAME "%s: registration failed n=%d rc=%d\n",
__func__, n, ret);
unregister_netdev(dev);
free_netdev(dev);
kfree(tempname);
return ret;
}
}
return 0;
}
static int htc_headset_gpio_probe(struct platform_device *pdev)
{
int ret = 0;
struct htc_headset_gpio_platform_data *pdata = pdev->dev.platform_data;
HS_LOG("++++++++++++++++++++");
hi = kzalloc(sizeof(struct htc_headset_gpio_info), GFP_KERNEL);
if (!hi) {
HS_ERR("Failed to allocate memory for headset info");
return -ENOMEM;
}
if (pdata->config_headset_gpio)
pdata->config_headset_gpio();
hi->pdata.uart_gpio = pdata->uart_gpio;
hi->pdata.hpin_gpio = pdata->hpin_gpio;
hi->pdata.key_gpio = pdata->key_gpio;
hi->pdata.key_enable_gpio = pdata->key_enable_gpio;
hi->pdata.mic_select_gpio = pdata->mic_select_gpio;
hi->hpin_debounce = HS_JIFFIES_ZERO;
hi->key_irq_type = IRQF_TRIGGER_NONE;
hi->headset_state = 0;
detect_wq = create_workqueue("HS_GPIO_DETECT");
if (detect_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create detect workqueue");
goto err_create_detect_work_queue;
}
button_wq = create_workqueue("HS_GPIO_BUTTON");
if (button_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create button workqueue");
goto err_create_button_work_queue;
}
wake_lock_init(&hi->hs_wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
if (hi->pdata.uart_gpio) {
if (!(get_kernel_flag() & KERNEL_FLAG_SERIAL_HSL_ENABLE))
ret = hs_gpio_request_output(hi->pdata.uart_gpio, "HS_GPIO_UART", 0);
if (ret < 0) {
HS_ERR("Fail to request GPIO UART(0x%x)", ret);
}
}
if (hi->pdata.hpin_gpio) {
ret = hs_gpio_request_irq(hi->pdata.hpin_gpio,
&hi->hpin_irq, detect_irq_handler,
IRQF_TRIGGER_NONE, "HS_GPIO_DETECT", 1);
if (ret < 0) {
HS_ERR("Failed to request GPIO HPIN IRQ (0x%X)", ret);
goto err_request_detect_irq;
}
disable_irq(hi->hpin_irq);
}
if (hi->pdata.key_gpio) {
ret = hs_gpio_request_irq(hi->pdata.key_gpio,
&hi->key_irq, button_irq_handler,
hi->key_irq_type, "HS_GPIO_BUTTON", 1);
if (ret < 0) {
HS_ERR("Failed to request GPIO button IRQ (0x%X)", ret);
goto err_request_button_irq;
}
disable_irq(hi->key_irq);
}
queue_delayed_work(detect_wq, &irq_init_work, HS_JIFFIES_IRQ_INIT);
hs_gpio_register();
hs_notify_driver_ready(DRIVER_NAME);
HS_LOG("--------------------");
return 0;
err_request_button_irq:
if (hi->pdata.hpin_gpio) {
free_irq(hi->hpin_irq, 0);
gpio_free(hi->pdata.hpin_gpio);
}
err_request_detect_irq:
wake_lock_destroy(&hi->hs_wake_lock);
destroy_workqueue(button_wq);
err_create_button_work_queue:
destroy_workqueue(detect_wq);
err_create_detect_work_queue:
kfree(hi);
HS_ERR("Failed to register %s driver", DRIVER_NAME);
return ret;
}
int uart_register_driver(struct uart_driver *drv)
{
struct tty_driver *normal;
int i, retval;
BUG_ON(drv->state);
drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
if (!drv->state)
goto out;
normal = alloc_tty_driver(drv->nr);
if (!normal)
goto out_kfree;
drv->tty_driver = normal;
normal->driver_name = drv->driver_name;
normal->name = drv->dev_name;
normal->major = drv->major;
normal->minor_start = drv->minor;
normal->type = TTY_DRIVER_TYPE_SERIAL;
normal->subtype = SERIAL_TYPE_NORMAL;
normal->init_termios = tty_std_termios;
normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
normal->driver_state = drv;
tty_set_operations(normal, &uart_ops);
for (i = 0; i < drv->nr; i++) {
struct uart_state *state = drv->state + i;
struct tty_port *port = &state->port;
tty_port_init(port);
port->ops = &uart_port_ops;
port->close_delay = HZ / 2;
port->closing_wait = 30 * HZ;
}
retval = tty_register_driver(normal);
#ifdef CONFIG_IMC_UART2DM_HANDSHAKE
if (!strcmp(drv->driver_name, "msm_serial_hs_imc"))
{
if (get_kernel_flag() & BIT(20)){
uart2_handshaking_mask = 1;
printk(KERN_DEBUG MODULE_NAME " %s enable uart2 handshaking debug msg\n", __func__);
}
}
#endif
if (retval >= 0)
return retval;
put_tty_driver(normal);
out_kfree:
kfree(drv->state);
out:
return -ENOMEM;
}
static int __init modem_8960_init(void)
{
int ret;
if (!cpu_is_msm8960() && !cpu_is_msm8930() && !cpu_is_msm8930aa() &&
!cpu_is_msm9615() && !cpu_is_msm8627())
return -ENODEV;
ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET,
smsm_state_cb, 0);
if (ret < 0)
pr_err("%s: Unable to register SMSM callback! (%d)\n",
__func__, ret);
ret = request_irq(Q6FW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq,
IRQF_TRIGGER_RISING, "modem_wdog_fw", NULL);
if (ret < 0) {
pr_err("%s: Unable to request q6fw watchdog IRQ. (%d)\n",
__func__, ret);
goto out;
}
ret = request_irq(Q6SW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq,
IRQF_TRIGGER_RISING, "modem_wdog_sw", NULL);
if (ret < 0) {
pr_err("%s: Unable to request q6sw watchdog IRQ. (%d)\n",
__func__, ret);
disable_irq_nosync(Q6FW_WDOG_EXPIRED_IRQ);
goto out;
}
if (get_kernel_flag() & KERNEL_FLAG_ENABLE_SSR_MODEM)
enable_modem_ssr = 1;
pr_info("%s: enable_modem_ssr set to %d\n", __func__, enable_modem_ssr);
ret = modem_subsystem_restart_init();
if (ret < 0) {
pr_err("%s: Unable to reg with subsystem restart. (%d)\n",
__func__, ret);
goto out;
}
modemfw_ramdump_dev = create_ramdump_device("modem_fw");
if (!modemfw_ramdump_dev) {
pr_err("%s: Unable to create modem fw ramdump device. (%d)\n",
__func__, -ENOMEM);
ret = -ENOMEM;
goto out;
}
modemsw_ramdump_dev = create_ramdump_device("modem_sw");
if (!modemsw_ramdump_dev) {
pr_err("%s: Unable to create modem sw ramdump device. (%d)\n",
__func__, -ENOMEM);
ret = -ENOMEM;
goto out;
}
smem_ramdump_dev = create_ramdump_device("smem-modem");
if (!smem_ramdump_dev) {
pr_err("%s: Unable to create smem ramdump device. (%d)\n",
__func__, -ENOMEM);
ret = -ENOMEM;
goto out;
}
ret = modem_debugfs_init();
pr_info("%s: modem fatal driver init'ed.\n", __func__);
out:
return ret;
}
void diagfwd_sdio_init(const char *name)
{
int ret;
if (diag9k_debug_mask)
DIAG_INFO("%s\n", __func__);
driver->read_len_mdm = 0;
if (driver->buf_in_sdio_1 == NULL)
driver->buf_in_sdio_1 = kzalloc(MAX_IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_sdio_1 == NULL)
goto err;
if (driver->buf_in_sdio_2 == NULL)
driver->buf_in_sdio_2 = kzalloc(MAX_IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_sdio_2 == NULL)
goto err;
if (driver->usb_buf_mdm_out == NULL)
driver->usb_buf_mdm_out = kzalloc(USB_MAX_OUT_BUF, GFP_KERNEL);
if (driver->usb_buf_mdm_out == NULL)
goto err;
if (driver->write_ptr_mdm_1 == NULL)
driver->write_ptr_mdm_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm_1 == NULL)
goto err;
if (driver->write_ptr_mdm_2 == NULL)
driver->write_ptr_mdm_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm_2 == NULL)
goto err;
if (driver->usb_read_mdm_ptr == NULL)
driver->usb_read_mdm_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_mdm_ptr == NULL)
goto err;
driver->diag_sdio_wq = create_singlethread_workqueue("diag_sdio_wq");
#ifdef CONFIG_DIAG_OVER_USB
strncpy(usb_ch_name, name, 16);
DIAG_INFO("%s using %s\n", __func__, usb_ch_name);
/*
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->mdm_ch)) {
printk(KERN_ERR "Unable to open USB diag MDM channel\n");
goto err;
}
*/
INIT_WORK(&(driver->diag_read_mdm_work), diag_read_mdm_work_fn);
#endif
INIT_WORK(&(driver->diag_read_sdio_work), diag_read_sdio_work_fn);
INIT_WORK(&(driver->diag_remove_sdio_work), diag_remove_sdio_work_fn);
ret = platform_driver_register(&msm_sdio_ch_driver);
if (ret)
DIAG_INFO("DIAG could not register SDIO device");
else
DIAG_INFO("DIAG registered SDIO device\n");
ril_sdio_dbg_flag = (get_kernel_flag() & BIT19)?1 :0;
return;
err:
DIAG_INFO("\n Could not initialize diag buf for SDIO");
kfree(driver->buf_in_sdio_1);
kfree(driver->buf_in_sdio_2);
kfree(driver->usb_buf_mdm_out);
kfree(driver->write_ptr_mdm_1);
kfree(driver->write_ptr_mdm_2);
kfree(driver->usb_read_mdm_ptr);
if (driver->diag_sdio_wq)
destroy_workqueue(driver->diag_sdio_wq);
}
int __init msm_rpm_init(struct msm_rpm_platform_data *data)
{
int rc;
memcpy(&msm_rpm_data, data, sizeof(struct msm_rpm_platform_data));
msm_rpm_stat_data = (stats_blob *)msm_rpm_data.reg_base_addrs[MSM_RPM_PAGE_STAT];
msm_rpm_sel_mask_size = msm_rpm_data.sel_last / 32 + 1;
BUG_ON(SEL_MASK_SIZE < msm_rpm_sel_mask_size);
#ifndef CONFIG_ARCH_MSM8X60
if ((get_radio_flag() & KERNEL_FLAG_APPSBARK) && msm_rpm_stat_data)
msm_rpm_stat_data->rpm_debug_mode |= RPM_DEBUG_RAM_DUMP;
if ((get_kernel_flag() & KERNEL_FLAG_PM_MONITOR) && msm_rpm_stat_data)
msm_rpm_stat_data->rpm_debug_mode |= RPM_DEBUG_POWER_MEASUREMENT;
if ((get_kernel_flag() & KERNEL_FLAG_RPM_DISABLE_WATCHDOG) && msm_rpm_stat_data)
msm_rpm_stat_data->rpm_debug_mode |= RPM_DEBUG_DISABLE_WATCHDOG;
#endif
fw_major = msm_rpm_read(MSM_RPM_PAGE_STATUS,
target_status(MSM_RPM_STATUS_ID_VERSION_MAJOR));
fw_minor = msm_rpm_read(MSM_RPM_PAGE_STATUS,
target_status(MSM_RPM_STATUS_ID_VERSION_MINOR));
fw_build = msm_rpm_read(MSM_RPM_PAGE_STATUS,
target_status(MSM_RPM_STATUS_ID_VERSION_BUILD));
/*pr_info("%s: RPM firmware %u.%u.%u\n", __func__,
fw_major, fw_minor, fw_build);*/
if (fw_major != msm_rpm_data.ver[0]) {
/*pr_err("%s: RPM version %u.%u.%u incompatible with "
"this driver version %u.%u.%u\n", __func__,
fw_major, fw_minor, fw_build,
msm_rpm_data.ver[0],
msm_rpm_data.ver[1],
msm_rpm_data.ver[2]);*/
return -EFAULT;
}
msm_rpm_write(MSM_RPM_PAGE_CTRL,
target_ctrl(MSM_RPM_CTRL_VERSION_MAJOR), msm_rpm_data.ver[0]);
msm_rpm_write(MSM_RPM_PAGE_CTRL,
target_ctrl(MSM_RPM_CTRL_VERSION_MINOR), msm_rpm_data.ver[1]);
msm_rpm_write(MSM_RPM_PAGE_CTRL,
target_ctrl(MSM_RPM_CTRL_VERSION_BUILD), msm_rpm_data.ver[2]);
rc = request_irq(data->irq_ack, msm_rpm_ack_interrupt,
IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND,
"rpm_drv", msm_rpm_ack_interrupt);
if (rc) {
/*pr_err("%s: failed to request irq %d: %d\n",
__func__, data->irq_ack, rc);*/
return rc;
}
rc = irq_set_irq_wake(data->irq_ack, 1);
if (rc) {
/*pr_err("%s: failed to set wakeup irq %u: %d\n",
__func__, data->irq_ack, rc);*/
return rc;
}
rc = request_irq(data->irq_err, msm_rpm_err_interrupt,
IRQF_TRIGGER_RISING, "rpm_err", NULL);
if (rc) {
/*pr_err("%s: failed to request error interrupt: %d\n",
__func__, rc);*/
return rc;
}
rc = request_irq(data->irq_wakeup,
msm_pm_rpm_wakeup_interrupt, IRQF_TRIGGER_RISING,
"pm_drv", msm_pm_rpm_wakeup_interrupt);
if (rc) {
/*pr_err("%s: failed to request irq %u: %d\n",
__func__, data->irq_wakeup, rc);*/
return rc;
}
rc = irq_set_irq_wake(data->irq_wakeup, 1);
if (rc) {
/*pr_err("%s: failed to set wakeup irq %u: %d\n",
__func__, data->irq_wakeup, rc);*/
return rc;
}
msm_rpm_populate_map(data);
msm_rpm_print_sleep_tick();
return platform_driver_register(&msm_rpm_platform_driver);
}
static int hs_1wire_init(void)
{
char all_zero = 0;
char send_data = 0xF5;
if ((get_kernel_flag() & BIT(1)) || (board_mfg_mode() != 0)) {
HS_LOG("the debug port is enabled, one wire chip detection would be disabled\n");
return -1;
}
HS_LOG("[1-wire]hs_1wire_init");
fp = openFile(hi->pdata.onewire_tty_dev,O_CREAT|O_RDWR|O_SYNC|O_NONBLOCK,0666);
HS_LOG("Open %s", hi->pdata.onewire_tty_dev);
if (fp != NULL) {
if (!fp->private_data) {
HS_LOG("No private data");
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 0);
hi->aid = 0;
closeFile(fp);
return -1;
}
} else {
HS_LOG("%s, openFile is NULL pointer\n", __func__);
return -1;
}
setup_hs_tty(fp);
HS_LOG("Setup HS tty");
if (hi->pdata.tx_level_shift_en) {
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 0);
HS_LOG("[HS]set tx_level_shift_en to 0");
}
if (hi->pdata.uart_sw) {
gpio_set_value_cansleep(hi->pdata.uart_sw, 1);
HS_LOG("[HS]Set uart sw = 1");
}
hi->aid = 0;
hr_msleep(20);
writeFile(fp,&all_zero,1);
hr_msleep(5);
writeFile(fp,&send_data,1);
HS_LOG("Send 0x00 0xF5");
usleep(300);
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
HS_LOG("[HS]Disable level shift");
hr_msleep(22);
if (hs_read_aid() == 0) {
HS_LOG("[1-wire]Valid AID received, enter 1-wire mode");
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
closeFile(fp);
return 0;
} else {
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 0);
hi->aid = 0;
closeFile(fp);
return -1;
}
}
