static int diag_sdio_probe(struct platform_device *pdev)
{
int err;
if (diag9k_debug_mask)
DIAG_INFO("%s\n", __func__);
err = sdio_open("SDIO_DIAG", &driver->sdio_ch, driver,
diag_sdio_notify);
if (err)
DIAG_ERR("DIAG could not open SDIO channel");
else {
DIAG_INFO("DIAG opened SDIO channel");
if (!strcmp(DIAG_LEGACY, usb_ch_name)) {
driver->legacy_ch = usb_diag_open(DIAG_LEGACY, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->legacy_ch)) {
DIAG_ERR("Unable to open USB diag legacy channel\n");
goto err;
}
DIAG_INFO("open USB diag legacy channel\n");
} else if (!strcmp(DIAG_MDM, usb_ch_name)) {
driver->legacy_ch = usb_diag_open(DIAG_LEGACY, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->legacy_ch)) {
DIAG_ERR("Unable to open USB diag legacy channel\n");
goto err;
}
DIAG_INFO("open USB diag legacy channel\n");
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->mdm_ch)) {
DIAG_ERR("Unable to open USB diag MDM channel\n");
goto err;
}
DIAG_INFO("open USB diag MDM channel\n");
}
/* queue_work(driver->diag_sdio_wq, &(driver->diag_read_mdm_work));*/
}
if (diag_configured)
diagfwd_connect();
driver->in_busy_sdio_1 = 0;
driver->in_busy_sdio_2 = 0;
driver->qxdm2sd_drop = 0;
sdio_diag_initialized = 1;
err:
return err;
}
void __init diagfwd_hsic_init(void)
{
int ret;
pr_debug("DIAG in %s\n", __func__);
driver->diag_hsic_wq = create_singlethread_workqueue("diag_hsic_wq");
INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn);
INIT_WORK(&(driver->diag_usb_read_complete_work),
diag_usb_read_complete_fn);
#ifdef CONFIG_DIAG_OVER_USB
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver, diagfwd_hsic_notifier);
if (IS_ERR(driver->mdm_ch)) {
pr_err("DIAG Unable to open USB diag MDM channel\n");
goto err;
}
#endif
ret = platform_driver_register(&msm_hsic_ch_driver);
if (ret)
pr_err("DIAG could not register HSIC device, ret: %d\n", ret);
else
driver->hsic_initialized = 1;
return;
err:
pr_err("DIAG could not initialize for HSIC execution\n");
}
void diagfwd_sdio_init(void)
{
int ret;
driver->read_len_mdm = 0;
if (driver->buf_in_sdio == NULL)
driver->buf_in_sdio = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_sdio == 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 == NULL)
driver->write_ptr_mdm = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm == 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
#ifdef CONFIG_SH_USB_CUST
driver->mdm_ch = 0;
#else /* CONFIG_SH_USB_CUST */
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;
}
#endif /* CONFIG_SH_USB_CUST */
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);
ret = platform_driver_register(&msm_sdio_ch_driver);
if (ret)
printk(KERN_INFO "DIAG could not register SDIO device");
else
printk(KERN_INFO "DIAG registered SDIO device");
return;
err:
printk(KERN_INFO "\n Could not initialize diag buf for SDIO");
kfree(driver->buf_in_sdio);
kfree(driver->usb_buf_mdm_out);
kfree(driver->write_ptr_mdm);
kfree(driver->usb_read_mdm_ptr);
if (driver->diag_sdio_wq)
destroy_workqueue(driver->diag_sdio_wq);
}
int diag_usb_register(int id, int ctxt, struct diag_mux_ops *ops)
{
struct diag_usb_info *ch = NULL;
unsigned char wq_name[DIAG_USB_NAME_SZ + DIAG_USB_STRING_SZ];
if (id < 0 || id >= NUM_DIAG_USB_DEV) {
pr_err("diag: Unable to register with USB, id: %d\n", id);
return -EIO;
}
if (!ops) {
pr_err("diag: Invalid operations for USB\n");
return -EIO;
}
ch = &diag_usb[id];
ch->ops = ops;
ch->ctxt = ctxt;
spin_lock_init(&ch->lock);
ch->read_buf = kzalloc(USB_MAX_OUT_BUF, GFP_KERNEL);
if (!ch->read_buf)
goto err;
ch->read_ptr = kzalloc(sizeof(struct diag_request), GFP_KERNEL);
if (!ch->read_ptr)
goto err;
diagmem_init(driver, ch->mempool);
INIT_WORK(&(ch->read_work), usb_read_work_fn);
INIT_WORK(&(ch->read_done_work), usb_read_done_work_fn);
INIT_WORK(&(ch->connect_work), usb_connect_work_fn);
INIT_WORK(&(ch->disconnect_work), usb_disconnect_work_fn);
strlcpy(wq_name, "DIAG_USB_", DIAG_USB_STRING_SZ);
strlcat(wq_name, ch->name, sizeof(ch->name));
ch->usb_wq = create_singlethread_workqueue(wq_name);
if (!ch->usb_wq)
goto err;
ch->hdl = usb_diag_open(ch->name, (void *)(uintptr_t)id,
diag_usb_notifier);
if (IS_ERR(ch->hdl)) {
pr_err("diag: Unable to open USB channel %s\n", ch->name);
goto err;
}
ch->enabled = 1;
pr_debug("diag: Successfully registered USB %s\n", ch->name);
return 0;
err:
if (ch->usb_wq)
destroy_workqueue(ch->usb_wq);
kfree(ch->read_ptr);
kfree(ch->read_buf);
return -ENOMEM;
}
void diagfwd_hsic_init(void)
{
int ret;
pr_debug("DIAG in %s\n", __func__);
driver->diag_hsic_wq = create_singlethread_workqueue("diag_hsic_wq");
driver->write_len_mdm = 0;
driver->num_hsic_buf_tbl_entries = 0;
spin_lock_init(&driver->hsic_spinlock);
if (driver->hsic_buf_tbl == NULL)
driver->hsic_buf_tbl = kzalloc(NUM_HSIC_BUF_TBL_ENTRIES *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->hsic_buf_tbl == NULL)
goto err;
driver->count_hsic_pool = 0;
driver->count_hsic_write_pool = 0;
driver->itemsize_hsic = READ_HSIC_BUF_SIZE;
driver->poolsize_hsic = N_MDM_WRITE;
driver->itemsize_hsic_write = sizeof(struct diag_request);
driver->poolsize_hsic_write = N_MDM_WRITE;
INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn);
INIT_WORK(&(driver->diag_usb_read_complete_work),
diag_usb_read_complete_fn);
#ifdef CONFIG_DIAG_OVER_USB
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver, diagfwd_hsic_notifier);
if (IS_ERR(driver->mdm_ch)) {
pr_err("DIAG Unable to open USB diag MDM channel\n");
goto err;
}
#endif
ret = platform_driver_register(&msm_hsic_ch_driver);
if (ret)
pr_err("DIAG could not register HSIC device, ret: %d\n", ret);
else
driver->hsic_initialized = 1;
return;
err:
pr_err("diag: Could not initialize for HSIC execution\n");
kfree(driver->hsic_buf_tbl);
return;
}
void __init diagfwd_hsic_init(void)
{
int ret;
pr_debug("DIAG in %s\n", __func__);
#ifdef CONFIG_DIAG_OVER_USB
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver, diagfwd_hsic_notifier);
if (IS_ERR(driver->mdm_ch)) {
pr_err("DIAG Unable to open USB diag MDM channel\n");
goto err;
}
#endif
ret = platform_driver_register(&msm_hsic_ch_driver);
if (ret)
pr_err("DIAG could not register HSIC device, ret: %d\n", ret);
else
driver->hsic_initialized = 1;
return;
err:
pr_err("DIAG could not initialize for HSIC execution\n");
}
void diagfwd_bridge_init(int index)
{
int ret;
unsigned char name[20];
if (index == HSIC) {
strlcpy(name, "hsic", sizeof(name));
} else if (index == HSIC_2) {
strlcpy(name, "hsic_2", sizeof(name));
} else if (index == SMUX) {
strlcpy(name, "smux", sizeof(name));
} else {
pr_err("diag: incorrect bridge init, instance: %d\n", index);
return;
}
strlcpy(diag_bridge[index].name, name,
sizeof(diag_bridge[index].name));
strlcat(name, "_diag_wq", sizeof(diag_bridge[index].name));
diag_bridge[index].id = index;
diag_bridge[index].wq = create_singlethread_workqueue(name);
diag_bridge[index].read_len = 0;
diag_bridge[index].write_len = 0;
if (diag_bridge[index].usb_buf_out == NULL)
diag_bridge[index].usb_buf_out =
kzalloc(USB_MAX_OUT_BUF, GFP_KERNEL);
if (diag_bridge[index].usb_buf_out == NULL)
goto err;
if (diag_bridge[index].usb_read_ptr == NULL)
diag_bridge[index].usb_read_ptr =
kzalloc(sizeof(struct diag_request), GFP_KERNEL);
if (diag_bridge[index].usb_read_ptr == NULL)
goto err;
if (diag_bridge[index].usb_read_ptr->context == NULL)
diag_bridge[index].usb_read_ptr->context =
kzalloc(sizeof(int), GFP_KERNEL);
if (diag_bridge[index].usb_read_ptr->context == NULL)
goto err;
mutex_init(&diag_bridge[index].bridge_mutex);
if (index == HSIC || index == HSIC_2) {
INIT_WORK(&(diag_bridge[index].usb_read_complete_work),
diag_usb_read_complete_hsic_fn);
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(diag_bridge[index].diag_read_work),
diag_read_usb_hsic_work_fn);
if (index == HSIC)
diag_bridge[index].ch = usb_diag_open(DIAG_MDM,
(void *)index, diagfwd_bridge_notifier);
else if (index == HSIC_2)
diag_bridge[index].ch = usb_diag_open(DIAG_MDM2,
(void *)index, diagfwd_bridge_notifier);
if (IS_ERR(diag_bridge[index].ch)) {
pr_err("diag: Unable to open USB MDM ch = %d\n", index);
goto err;
} else
diag_bridge[index].enabled = 1;
#endif
} else if (index == SMUX) {
INIT_WORK(&(diag_bridge[index].usb_read_complete_work),
diag_usb_read_complete_smux_fn);
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(diag_bridge[index].diag_read_work),
diag_read_usb_smux_work_fn);
diag_bridge[index].ch = usb_diag_open(DIAG_QSC, (void *)index,
diagfwd_bridge_notifier);
if (IS_ERR(diag_bridge[index].ch)) {
pr_err("diag: Unable to open USB diag QSC channel\n");
goto err;
} else
diag_bridge[index].enabled = 1;
#endif
ret = platform_driver_register(&msm_diagfwd_smux_driver);
if (ret)
pr_err("diag: could not register SMUX device, ret: %d\n",
ret);
}
return;
err:
pr_err("diag: Could not initialize for bridge forwarding\n");
kfree(diag_bridge[index].usb_buf_out);
kfree(diag_hsic[index].hsic_buf_tbl);
kfree(driver->write_ptr_mdm);
kfree(diag_bridge[index].usb_read_ptr);
if (diag_bridge[index].wq)
destroy_workqueue(diag_bridge[index].wq);
return;
}
int diagfwd_init(void)
{
diag_debug_buf_idx = 0;
driver->read_len_legacy = 0;
if (driver->buf_in_1 == NULL)
driver->buf_in_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_1 == NULL)
goto err;
if (driver->buf_in_2 == NULL)
driver->buf_in_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_2 == NULL)
goto err;
if (driver->buf_in_qdsp_1 == NULL)
driver->buf_in_qdsp_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_1 == NULL)
goto err;
if (driver->buf_in_qdsp_2 == NULL)
driver->buf_in_qdsp_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_2 == NULL)
goto err;
if (driver->usb_buf_out == NULL &&
(driver->usb_buf_out = kzalloc(USB_MAX_OUT_BUF,
GFP_KERNEL)) == NULL)
goto err;
if (driver->hdlc_buf == NULL
&& (driver->hdlc_buf = kzalloc(HDLC_MAX, GFP_KERNEL)) == NULL)
goto err;
if (driver->msg_masks == NULL
&& (driver->msg_masks = kzalloc(MSG_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->log_masks == NULL &&
(driver->log_masks = kzalloc(LOG_MASK_SIZE, GFP_KERNEL)) == NULL)
goto err;
driver->log_masks_length = 8*MAX_EQUIP_ID;
if (driver->event_masks == NULL &&
(driver->event_masks = kzalloc(EVENT_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->client_map == NULL &&
(driver->client_map = kzalloc
((driver->num_clients) * sizeof(struct diag_client_map),
GFP_KERNEL)) == NULL)
goto err;
#if defined(CONFIG_MACH_MECHA) //|| defined(CONFIG_ARCH_MSM8X60_LTE)
if (driver->buf_in_mdm_1 == NULL)
driver->buf_in_mdm_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_mdm_1 == NULL)
goto err;
if (driver->buf_in_mdm_2 == NULL)
driver->buf_in_mdm_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_mdm_2 == NULL)
goto err;
#endif
#if defined(CONFIG_MACH_MECHA) || defined(CONFIG_ARCH_MSM8X60_LTE)
if (driver->mdmclient_map == NULL &&
(driver->mdmclient_map = kzalloc
((driver->num_mdmclients) * sizeof(struct diag_client_map),
GFP_KERNEL)) == NULL)
goto err;
#endif
if (driver->buf_tbl == NULL)
driver->buf_tbl = kzalloc(buf_tbl_size *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->buf_tbl == NULL)
goto err;
#if 0//defined(CONFIG_MACH_MECHA) || defined(CONFIG_ARCH_MSM8X60_LTE)
if (driver->mdmbuf_tbl == NULL)
driver->mdmbuf_tbl = kzalloc(buf_tbl_size *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->mdmbuf_tbl == NULL)
goto err;
#endif
if (driver->data_ready == NULL &&
(driver->data_ready = kzalloc(driver->num_clients * sizeof(int)
, GFP_KERNEL)) == NULL)
goto err;
#if defined(CONFIG_MACH_MECHA) || defined(CONFIG_ARCH_MSM8X60_LTE)
if (driver->mdmdata_ready == NULL &&
(driver->mdmdata_ready = kzalloc(driver->num_mdmclients * sizeof(struct
diag_client_map), GFP_KERNEL)) == NULL)
goto err;
#endif
if (driver->table == NULL &&
(driver->table = kzalloc(diag_max_registration*
sizeof(struct diag_master_table),
GFP_KERNEL)) == NULL)
goto err;
if (driver->write_ptr_1 == NULL)
driver->write_ptr_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_1 == NULL)
goto err;
if (driver->write_ptr_2 == NULL)
driver->write_ptr_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_2 == NULL)
goto err;
if (driver->write_ptr_qdsp_1 == NULL)
driver->write_ptr_qdsp_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_1 == NULL)
goto err;
if (driver->write_ptr_qdsp_2 == NULL)
driver->write_ptr_qdsp_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_2 == NULL)
goto err;
#if defined(CONFIG_MACH_MECHA) //|| defined(CONFIG_ARCH_MSM8X60_LTE)
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;
#endif
if (driver->usb_read_ptr == NULL)
driver->usb_read_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_ptr == NULL)
goto err;
if (driver->pkt_buf == NULL &&
(driver->pkt_buf = kzalloc(PKT_SIZE,
GFP_KERNEL)) == NULL)
goto err;
#ifdef CONFIG_DIAG_NO_MODEM
if (driver->apps_rsp_buf == NULL)
driver->apps_rsp_buf = kzalloc(150, GFP_KERNEL);
if (driver->apps_rsp_buf == NULL)
goto err;
#endif
driver->diag_wq = create_singlethread_workqueue("diag_wq");
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_proc_hdlc_work), diag_process_hdlc_fn);
INIT_WORK(&(driver->diag_read_work), diag_read_work_fn);
diag_setup();
#ifndef CONFIG_ARCH_MSM8X60_LTE
driver->legacy_ch = usb_diag_open(DIAG_LEGACY, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->legacy_ch)) {
DIAGFWD_ERR("Unable to open USB diag legacy channel\n");
goto err;
}
#endif
#endif
mutex_init(&driver->smd_lock);
#ifdef CONFIG_ARCH_MSM8X60_LTE
#if defined(CONFIG_USB_ANDROID_LTE_DIAG)
diag_ch_sdio = 0;
diagfwd_sdio_init(DIAG_MDM);
#else
diag_ch_sdio = 1;
diagfwd_sdio_init(DIAG_LEGACY);
#endif
#endif
platform_driver_register(&msm_smd_ch1_driver);
DIAGFWD_INFO("\n diag_debug_buf %p %p\n", diag_debug_buf, &diag_debug_buf);
DIAGFWD_INFO("\n diag_debug_buf_idx %p\n", &diag_debug_buf_idx);
#if defined(CONFIG_MACH_MECHA)
if (sdio_diag_init_enable)
sdio_diag_init();
#endif
return diag_ch_sdio;
err:
DIAGFWD_INFO("\n Could not initialize diag buffers\n");
kfree(driver->buf_in_1);
kfree(driver->buf_in_2);
kfree(driver->buf_in_qdsp_1);
kfree(driver->buf_in_qdsp_2);
kfree(driver->usb_buf_out);
kfree(driver->hdlc_buf);
kfree(driver->msg_masks);
kfree(driver->log_masks);
kfree(driver->event_masks);
kfree(driver->client_map);
kfree(driver->buf_tbl);
kfree(driver->data_ready);
#if defined(CONFIG_MACH_MECHA) //|| defined(CONFIG_ARCH_MSM8X60_LTE)
kfree(driver->mdmclient_map);
//kfree(driver->mdmbuf_tbl);
kfree(driver->mdmdata_ready);
#endif
kfree(driver->table);
kfree(driver->pkt_buf);
kfree(driver->write_ptr_1);
kfree(driver->write_ptr_2);
kfree(driver->write_ptr_qdsp_1);
kfree(driver->write_ptr_qdsp_2);
#if defined(CONFIG_MACH_MECHA) //|| defined(CONFIG_ARCH_MSM8X60_LTE)
kfree(driver->write_ptr_mdm_1);
kfree(driver->write_ptr_mdm_2);
#endif
kfree(driver->usb_read_ptr);
#ifdef CONFIG_DIAG_NO_MODEM
kfree(driver->apps_rsp_buf);
#endif
if (driver->diag_wq)
destroy_workqueue(driver->diag_wq);
return 0;
}
void diagfwd_bridge_init(void)
{
int ret;
DIAGFWD_INFO("diag: in %s\n", __func__);
driver->diag_bridge_wq = create_singlethread_workqueue(
"diag_bridge_wq");
driver->read_len_mdm = 0;
driver->write_len_mdm = 0;
driver->num_hsic_buf_tbl_entries = 0;
spin_lock_init(&driver->hsic_spinlock);
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 == NULL)
driver->write_ptr_mdm = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm == 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;
if (driver->hsic_buf_tbl == NULL)
driver->hsic_buf_tbl = kzalloc(NUM_HSIC_BUF_TBL_ENTRIES *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->hsic_buf_tbl == NULL)
goto err;
driver->count_hsic_pool = 0;
driver->count_hsic_write_pool = 0;
driver->qxdmusb_drop = 1;
driver->itemsize_hsic = READ_HSIC_BUF_SIZE;
driver->poolsize_hsic = N_MDM_WRITE;
driver->itemsize_hsic_write = sizeof(struct diag_request);
driver->poolsize_hsic_write = N_MDM_WRITE;
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_read_mdm_work), diag_read_mdm_work_fn);
#endif
INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn);
INIT_WORK(&(driver->diag_usb_read_complete_work),
diag_usb_read_complete_fn);
#ifdef CONFIG_DIAG_OVER_USB
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver,
diagfwd_bridge_notifier);
if (IS_ERR(driver->mdm_ch)) {
pr_err("diag: Unable to open USB diag MDM channel\n");
goto err;
}
#endif
ret = platform_driver_register(&msm_hsic_ch_driver);
if (ret)
pr_err("diag: could not register HSIC device, ret: %d\n", ret);
ret = platform_driver_register(&msm_diagfwd_smux_driver);
if (ret)
pr_err("diag: could not register SMUX device, ret: %d\n", ret);
return;
err:
pr_err("diag: Could not initialize for bridge forwarding\n");
kfree(driver->usb_buf_mdm_out);
kfree(driver->hsic_buf_tbl);
kfree(driver->write_ptr_mdm);
kfree(driver->usb_read_mdm_ptr);
if (driver->diag_bridge_wq)
destroy_workqueue(driver->diag_bridge_wq);
return;
}
void diagfwd_init(void)
{
diag_debug_buf_idx = 0;
driver->read_len_legacy = 0;
/* FIXME: there should be a better way to know if wcnss enabled */
if (chk_config_get_id() == AO8960_TOOLS_ID) {
is_wcnss_used = 1;
DIAGFWD_INFO("wcnss channel was enabled in the platform\n");
} else {
is_wcnss_used = 0;
DIAGFWD_INFO("wcnss channel was not enabled in the platform\n");
}
if (driver->buf_in_1 == NULL) {
driver->buf_in_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_1 == NULL)
goto err;
}
if (driver->buf_in_2 == NULL) {
driver->buf_in_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_2 == NULL)
goto err;
}
if (driver->buf_in_qdsp_1 == NULL) {
driver->buf_in_qdsp_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_1 == NULL)
goto err;
}
if (driver->buf_in_qdsp_2 == NULL) {
driver->buf_in_qdsp_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_2 == NULL)
goto err;
}
if (is_wcnss_used && driver->buf_in_wcnss == NULL) {
driver->buf_in_wcnss = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_wcnss == NULL)
goto err;
}
if (driver->usb_buf_out == NULL &&
(driver->usb_buf_out = kzalloc(USB_MAX_OUT_BUF,
GFP_KERNEL)) == NULL)
goto err;
if (driver->hdlc_buf == NULL
&& (driver->hdlc_buf = kzalloc(HDLC_MAX, GFP_KERNEL)) == NULL)
goto err;
if (driver->user_space_data == NULL)
driver->user_space_data = kzalloc(USER_SPACE_DATA, GFP_KERNEL);
if (driver->user_space_data == NULL)
goto err;
if (driver->msg_masks == NULL
&& (driver->msg_masks = kzalloc(MSG_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->log_masks == NULL &&
(driver->log_masks = kzalloc(LOG_MASK_SIZE, GFP_KERNEL)) == NULL)
goto err;
driver->log_masks_length = 8*MAX_EQUIP_ID;
if (driver->event_masks == NULL &&
(driver->event_masks = kzalloc(EVENT_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->client_map == NULL &&
(driver->client_map = kzalloc
((driver->num_clients) * sizeof(struct diag_client_map),
GFP_KERNEL)) == NULL)
goto err;
#ifdef CONFIG_DIAG_SDIO_PIPE
if (driver->mdmclient_map == NULL &&
(driver->mdmclient_map = kzalloc
((driver->num_mdmclients) * sizeof(struct diag_client_map),
GFP_KERNEL)) == NULL)
goto err;
#endif
if (driver->buf_tbl == NULL)
driver->buf_tbl = kzalloc(buf_tbl_size *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->buf_tbl == NULL)
goto err;
if (driver->data_ready == NULL &&
(driver->data_ready = kzalloc(driver->num_clients * sizeof(int)
, GFP_KERNEL)) == NULL)
goto err;
#ifdef CONFIG_DIAG_SDIO_PIPE
if (driver->mdmdata_ready == NULL &&
(driver->mdmdata_ready = kzalloc(driver->num_mdmclients * sizeof(struct
diag_client_map), GFP_KERNEL)) == NULL)
goto err;
#endif
if (driver->table == NULL &&
(driver->table = kzalloc(diag_max_registration*
sizeof(struct diag_master_table),
GFP_KERNEL)) == NULL)
goto err;
if (driver->write_ptr_1 == NULL) {
driver->write_ptr_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_1 == NULL)
goto err;
}
if (driver->write_ptr_2 == NULL) {
driver->write_ptr_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_2 == NULL)
goto err;
}
if (driver->write_ptr_qdsp_1 == NULL) {
driver->write_ptr_qdsp_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_1 == NULL)
goto err;
}
if (driver->write_ptr_qdsp_2 == NULL) {
driver->write_ptr_qdsp_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_2 == NULL)
goto err;
}
if (driver->write_ptr_wcnss == NULL) {
driver->write_ptr_wcnss = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_wcnss == NULL)
goto err;
}
if (driver->usb_read_ptr == NULL) {
driver->usb_read_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_ptr == NULL)
goto err;
}
if (driver->pkt_buf == NULL &&
(driver->pkt_buf = kzalloc(PKT_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->apps_rsp_buf == NULL) {
driver->apps_rsp_buf = kzalloc(500, GFP_KERNEL);
if (driver->apps_rsp_buf == NULL)
goto err;
}
driver->diag_wq = create_singlethread_workqueue("diag_wq");
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_proc_hdlc_work), diag_process_hdlc_fn);
INIT_WORK(&(driver->diag_read_work), diag_read_work_fn);
driver->legacy_ch = usb_diag_open(DIAG_LEGACY, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->legacy_ch)) {
printk(KERN_ERR "Unable to open USB diag legacy channel\n");
goto err;
}
#endif
#if DIAG_XPST
mutex_init(&driver->smd_lock);
#endif
platform_driver_register(&msm_smd_ch1_driver);
platform_driver_register(&diag_smd_lite_driver);
return;
err:
pr_err("diag: Could not initialize diag buffers");
kfree(driver->buf_in_1);
kfree(driver->buf_in_2);
kfree(driver->buf_in_qdsp_1);
kfree(driver->buf_in_qdsp_2);
kfree(driver->buf_in_wcnss);
kfree(driver->usb_buf_out);
kfree(driver->hdlc_buf);
kfree(driver->msg_masks);
kfree(driver->log_masks);
kfree(driver->event_masks);
kfree(driver->client_map);
kfree(driver->buf_tbl);
kfree(driver->data_ready);
kfree(driver->table);
kfree(driver->pkt_buf);
kfree(driver->write_ptr_1);
kfree(driver->write_ptr_2);
kfree(driver->write_ptr_qdsp_1);
kfree(driver->write_ptr_qdsp_2);
kfree(driver->write_ptr_wcnss);
kfree(driver->usb_read_ptr);
kfree(driver->apps_rsp_buf);
kfree(driver->user_space_data);
if (driver->diag_wq)
destroy_workqueue(driver->diag_wq);
}
void diagfwd_init(void)
{
diag_debug_buf_idx = 0;
driver->read_len_legacy = 0;
if (driver->buf_in_1 == NULL)
driver->buf_in_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_1 == NULL)
goto err;
if (driver->buf_in_2 == NULL)
driver->buf_in_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_2 == NULL)
goto err;
if (driver->buf_in_qdsp_1 == NULL)
driver->buf_in_qdsp_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_1 == NULL)
goto err;
if (driver->buf_in_qdsp_2 == NULL)
driver->buf_in_qdsp_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_2 == NULL)
goto err;
if (driver->usb_buf_out == NULL &&
(driver->usb_buf_out = kzalloc(USB_MAX_OUT_BUF,
GFP_KERNEL)) == NULL)
goto err;
if (driver->hdlc_buf == NULL
&& (driver->hdlc_buf = kzalloc(HDLC_MAX, GFP_KERNEL)) == NULL)
goto err;
if (driver->msg_masks == NULL
&& (driver->msg_masks = kzalloc(MSG_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->log_masks == NULL &&
(driver->log_masks = kzalloc(LOG_MASK_SIZE, GFP_KERNEL)) == NULL)
goto err;
driver->log_masks_length = 8*MAX_EQUIP_ID;
if (driver->event_masks == NULL &&
(driver->event_masks = kzalloc(EVENT_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->client_map == NULL &&
(driver->client_map = kzalloc
((driver->num_clients) * sizeof(struct diag_client_map),
GFP_KERNEL)) == NULL)
goto err;
if (driver->buf_tbl == NULL)
driver->buf_tbl = kzalloc(buf_tbl_size *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->buf_tbl == NULL)
goto err;
if (driver->data_ready == NULL &&
(driver->data_ready = kzalloc(driver->num_clients * sizeof(struct
diag_client_map), GFP_KERNEL)) == NULL)
goto err;
if (driver->table == NULL &&
(driver->table = kzalloc(diag_max_registration*
sizeof(struct diag_master_table),
GFP_KERNEL)) == NULL)
goto err;
if (driver->write_ptr_1 == NULL)
driver->write_ptr_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_1 == NULL)
goto err;
if (driver->write_ptr_2 == NULL)
driver->write_ptr_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_2 == NULL)
goto err;
if (driver->write_ptr_qdsp_1 == NULL)
driver->write_ptr_qdsp_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_1 == NULL)
goto err;
if (driver->write_ptr_qdsp_2 == NULL)
driver->write_ptr_qdsp_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_2 == NULL)
goto err;
if (driver->usb_read_ptr == NULL)
driver->usb_read_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_ptr == NULL)
goto err;
if (driver->pkt_buf == NULL &&
(driver->pkt_buf = kzalloc(PKT_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->apps_rsp_buf == NULL)
driver->apps_rsp_buf = kzalloc(150, GFP_KERNEL);
if (driver->apps_rsp_buf == NULL)
goto err;
driver->diag_wq = create_singlethread_workqueue("diag_wq");
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_proc_hdlc_work), diag_process_hdlc_fn);
INIT_WORK(&(driver->diag_read_work), diag_read_work_fn);
driver->legacy_ch = usb_diag_open(DIAG_LEGACY, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->legacy_ch)) {
printk(KERN_ERR "Unable to open USB diag legacy channel\n");
goto err;
}
#ifdef CONFIG_DIAG_SDIO_PIPE
if (machine_is_msm8x60_charm_surf() || machine_is_msm8x60_charm_ffa())
diagfwd_sdio_init();
#endif
#endif
platform_driver_register(&msm_smd_ch1_driver);
return;
err:
printk(KERN_INFO "\n Could not initialize diag buffers\n");
kfree(driver->buf_in_1);
kfree(driver->buf_in_2);
kfree(driver->buf_in_qdsp_1);
kfree(driver->buf_in_qdsp_2);
kfree(driver->usb_buf_out);
kfree(driver->hdlc_buf);
kfree(driver->msg_masks);
kfree(driver->log_masks);
kfree(driver->event_masks);
kfree(driver->client_map);
kfree(driver->buf_tbl);
kfree(driver->data_ready);
kfree(driver->table);
kfree(driver->pkt_buf);
kfree(driver->write_ptr_1);
kfree(driver->write_ptr_2);
kfree(driver->write_ptr_qdsp_1);
kfree(driver->write_ptr_qdsp_2);
kfree(driver->usb_read_ptr);
kfree(driver->apps_rsp_buf);
if (driver->diag_wq)
destroy_workqueue(driver->diag_wq);
}
void diagfwd_bridge_init(void)
{
int ret;
pr_debug("diag: in %s\n", __func__);
driver->diag_bridge_wq = create_singlethread_workqueue(
"diag_bridge_wq");
driver->read_len_mdm = 0;
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 == NULL)
driver->write_ptr_mdm = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm == 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;
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_read_mdm_work), diag_read_mdm_work_fn);
#endif
INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn);
INIT_WORK(&(driver->diag_usb_read_complete_work),
diag_usb_read_complete_fn);
#ifdef CONFIG_DIAG_OVER_USB
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver,
diagfwd_bridge_notifier);
if (IS_ERR(driver->mdm_ch)) {
pr_err("diag: Unable to open USB diag MDM channel\n");
goto err;
}
#endif
#ifdef CONFIG_DIAG_BRIDGE_CODE
INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn);
INIT_WORK(&(driver->diag_usb_read_complete_work),
diag_usb_read_complete_fn);
/* register HSIC device */
ret = platform_driver_register(&msm_hsic_ch_driver);
if (ret)
pr_err("diag: could not register HSIC device, ret: %d\n", ret);
/* register SMUX device */
ret = platform_driver_register(&msm_diagfwd_smux_driver);
if (ret)
pr_err("diag: could not register SMUX device, ret: %d\n", ret);
#endif
return;
err:
pr_err("diag: Could not initialize for bridge forwarding\n");
kfree(driver->usb_buf_mdm_out);
kfree(driver->write_ptr_mdm);
kfree(driver->usb_read_mdm_ptr);
if (driver->diag_bridge_wq)
destroy_workqueue(driver->diag_bridge_wq);
return;
}
void diagfwd_init(void)
{
diag_debug_buf_idx = 0;
driver->read_len_legacy = 0;
if (driver->buf_in_1 == NULL) {
driver->buf_in_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_1 == NULL)
goto err;
}
if (driver->buf_in_2 == NULL) {
driver->buf_in_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_2 == NULL)
goto err;
}
if (driver->buf_in_qdsp_1 == NULL) {
driver->buf_in_qdsp_1 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_1 == NULL)
goto err;
}
if (driver->buf_in_qdsp_2 == NULL) {
driver->buf_in_qdsp_2 = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_qdsp_2 == NULL)
goto err;
}
if (driver->buf_in_wcnss == NULL) {
driver->buf_in_wcnss = kzalloc(IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_wcnss == NULL)
goto err;
}
if (driver->usb_buf_out == NULL &&
(driver->usb_buf_out = kzalloc(USB_MAX_OUT_BUF,
GFP_KERNEL)) == NULL)
goto err;
if (driver->hdlc_buf == NULL
&& (driver->hdlc_buf = kzalloc(HDLC_MAX, GFP_KERNEL)) == NULL)
goto err;
if (driver->user_space_data == NULL)
driver->user_space_data = kzalloc(USER_SPACE_DATA, GFP_KERNEL);
if (driver->user_space_data == NULL)
goto err;
if (driver->msg_masks == NULL
&& (driver->msg_masks = kzalloc(MSG_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->log_masks == NULL &&
(driver->log_masks = kzalloc(LOG_MASK_SIZE, GFP_KERNEL)) == NULL)
goto err;
driver->log_masks_length = 8*MAX_EQUIP_ID;
if (driver->event_masks == NULL &&
(driver->event_masks = kzalloc(EVENT_MASK_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->client_map == NULL &&
(driver->client_map = kzalloc
((driver->num_clients) * sizeof(struct diag_client_map),
GFP_KERNEL)) == NULL)
goto err;
if (driver->buf_tbl == NULL)
driver->buf_tbl = kzalloc(buf_tbl_size *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->buf_tbl == NULL)
goto err;
if (driver->data_ready == NULL &&
(driver->data_ready = kzalloc(driver->num_clients * sizeof(int)
, GFP_KERNEL)) == NULL)
goto err;
if (driver->table == NULL &&
(driver->table = kzalloc(diag_max_registration*
sizeof(struct diag_master_table),
GFP_KERNEL)) == NULL)
goto err;
if (driver->write_ptr_1 == NULL) {
driver->write_ptr_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_1 == NULL)
goto err;
}
if (driver->write_ptr_2 == NULL) {
driver->write_ptr_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_2 == NULL)
goto err;
}
if (driver->write_ptr_qdsp_1 == NULL) {
driver->write_ptr_qdsp_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_1 == NULL)
goto err;
}
if (driver->write_ptr_qdsp_2 == NULL) {
driver->write_ptr_qdsp_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_qdsp_2 == NULL)
goto err;
}
if (driver->write_ptr_wcnss == NULL) {
driver->write_ptr_wcnss = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_wcnss == NULL)
goto err;
}
if (driver->usb_read_ptr == NULL) {
driver->usb_read_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_ptr == NULL)
goto err;
}
if (driver->pkt_buf == NULL &&
(driver->pkt_buf = kzalloc(PKT_SIZE,
GFP_KERNEL)) == NULL)
goto err;
if (driver->apps_rsp_buf == NULL) {
driver->apps_rsp_buf = kzalloc(500, GFP_KERNEL);
if (driver->apps_rsp_buf == NULL)
goto err;
}
driver->diag_wq = create_singlethread_workqueue("diag_wq");
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_proc_hdlc_work), diag_process_hdlc_fn);
INIT_WORK(&(driver->diag_read_work), diag_read_work_fn);
driver->legacy_ch = usb_diag_open(DIAG_LEGACY, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->legacy_ch)) {
printk(KERN_ERR "Unable to open USB diag legacy channel\n");
goto err;
}
#endif
#ifdef CONFIG_HUAWEI_FEATURE_PHUDIAG
phudriver->diag_wq = driver->diag_wq;
phudriver->diag_read_smd_work = &(driver->diag_read_smd_work);
#endif
platform_driver_register(&msm_smd_ch1_driver);
platform_driver_register(&diag_smd_lite_driver);
return;
err:
pr_err("diag: Could not initialize diag buffers");
kfree(driver->buf_in_1);
kfree(driver->buf_in_2);
kfree(driver->buf_in_qdsp_1);
kfree(driver->buf_in_qdsp_2);
kfree(driver->buf_in_wcnss);
kfree(driver->usb_buf_out);
kfree(driver->hdlc_buf);
kfree(driver->msg_masks);
kfree(driver->log_masks);
kfree(driver->event_masks);
kfree(driver->client_map);
kfree(driver->buf_tbl);
kfree(driver->data_ready);
kfree(driver->table);
kfree(driver->pkt_buf);
kfree(driver->write_ptr_1);
kfree(driver->write_ptr_2);
kfree(driver->write_ptr_qdsp_1);
kfree(driver->write_ptr_qdsp_2);
kfree(driver->write_ptr_wcnss);
kfree(driver->usb_read_ptr);
kfree(driver->apps_rsp_buf);
kfree(driver->user_space_data);
if (driver->diag_wq)
destroy_workqueue(driver->diag_wq);
}
void diagfwd_init(void)
{
int success;
int i;
wrap_enabled = 0;
wrap_count = 0;
diag_debug_buf_idx = 0;
driver->read_len_legacy = 0;
driver->use_device_tree = has_device_tree();
mutex_init(&driver->diag_cntl_mutex);
success = diag_smd_constructor(&driver->smd_data[MODEM_DATA],
MODEM_DATA, SMD_DATA_TYPE);
if (!success)
goto err;
success = diag_smd_constructor(&driver->smd_data[LPASS_DATA],
LPASS_DATA, SMD_DATA_TYPE);
if (!success)
goto err;
success = diag_smd_constructor(&driver->smd_data[WCNSS_DATA],
WCNSS_DATA, SMD_DATA_TYPE);
if (!success)
goto err;
if (driver->usb_buf_out == NULL &&
(driver->usb_buf_out = kzalloc(USB_MAX_OUT_BUF,
GFP_KERNEL)) == NULL)
goto err;
kmemleak_not_leak(driver->usb_buf_out);
if (driver->hdlc_buf == NULL
&& (driver->hdlc_buf = kzalloc(HDLC_MAX, GFP_KERNEL)) == NULL)
goto err;
kmemleak_not_leak(driver->hdlc_buf);
if (driver->user_space_data == NULL)
driver->user_space_data = kzalloc(USER_SPACE_DATA, GFP_KERNEL);
if (driver->user_space_data == NULL)
goto err;
kmemleak_not_leak(driver->user_space_data);
if (driver->client_map == NULL &&
(driver->client_map = kzalloc
((driver->num_clients) * sizeof(struct diag_client_map),
GFP_KERNEL)) == NULL)
goto err;
kmemleak_not_leak(driver->client_map);
if (driver->buf_tbl == NULL)
driver->buf_tbl = kzalloc(buf_tbl_size *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->buf_tbl == NULL)
goto err;
kmemleak_not_leak(driver->buf_tbl);
if (driver->data_ready == NULL &&
(driver->data_ready = kzalloc(driver->num_clients * sizeof(int)
, GFP_KERNEL)) == NULL)
goto err;
kmemleak_not_leak(driver->data_ready);
if (driver->table == NULL &&
(driver->table = kzalloc(diag_max_reg*
sizeof(struct diag_master_table),
GFP_KERNEL)) == NULL)
goto err;
kmemleak_not_leak(driver->table);
if (driver->usb_read_ptr == NULL) {
driver->usb_read_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_ptr == NULL)
goto err;
kmemleak_not_leak(driver->usb_read_ptr);
}
if (driver->pkt_buf == NULL &&
(driver->pkt_buf = kzalloc(PKT_SIZE,
GFP_KERNEL)) == NULL)
goto err;
kmemleak_not_leak(driver->pkt_buf);
if (driver->apps_rsp_buf == NULL) {
driver->apps_rsp_buf = kzalloc(APPS_BUF_SIZE, GFP_KERNEL);
if (driver->apps_rsp_buf == NULL)
goto err;
kmemleak_not_leak(driver->apps_rsp_buf);
}
driver->diag_wq = create_singlethread_workqueue("diag_wq");
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_proc_hdlc_work), diag_process_hdlc_fn);
INIT_WORK(&(driver->diag_read_work), diag_read_work_fn);
driver->legacy_ch = usb_diag_open(DIAG_LEGACY, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->legacy_ch)) {
printk(KERN_ERR "Unable to open USB diag legacy channel\n");
goto err;
}
#endif
platform_driver_register(&msm_smd_ch1_driver);
platform_driver_register(&diag_smd_lite_driver);
return;
err:
pr_err("diag: Could not initialize diag buffers");
for (i = 0; i < NUM_SMD_DATA_CHANNELS; i++)
diag_smd_destructor(&driver->smd_data[i]);
kfree(driver->buf_msg_mask_update);
kfree(driver->buf_log_mask_update);
kfree(driver->buf_event_mask_update);
kfree(driver->usb_buf_out);
kfree(driver->hdlc_buf);
kfree(driver->client_map);
kfree(driver->buf_tbl);
kfree(driver->data_ready);
kfree(driver->table);
kfree(driver->pkt_buf);
kfree(driver->usb_read_ptr);
kfree(driver->apps_rsp_buf);
kfree(driver->user_space_data);
if (driver->diag_wq)
destroy_workqueue(driver->diag_wq);
}
