void pil_put(void *peripheral_handle) { struct pil_device *pil_d, *pil = peripheral_handle; if (IS_ERR_OR_NULL(pil)) return; printk("%s: %s(%d) for %s\n", __func__, current->comm, current->pid, pil->desc->name); mutex_lock(&pil->lock); if (WARN(!pil->count, "%s: %s: Reference count mismatch\n", pil->desc->name, __func__)) goto err_out; #ifdef CONFIG_MACH_VILLEC2 if (pil->count == 1) goto unlock; #endif if (!--pil->count) pil_shutdown(pil); #ifdef CONFIG_MACH_VILLEC2 unlock: #endif mutex_unlock(&pil->lock); pil_d = find_peripheral(pil->desc->depends_on); module_put(pil->owner); if (pil_d) { pil_put(pil_d); put_device(&pil_d->dev); } put_device(&pil->dev); return; err_out: mutex_unlock(&pil->lock); return; }
static void smd_tty_close(struct tty_struct *tty, struct file *f) { struct smd_tty_info *info = tty->driver_data; unsigned long flags; if (info == 0) return; mutex_lock(&smd_tty_lock); if (--info->open_count == 0) { spin_lock_irqsave(&info->reset_lock, flags); info->is_open = 0; spin_unlock_irqrestore(&info->reset_lock, flags); if (info->tty) { tasklet_kill(&info->tty_tsklt); wake_lock_destroy(&info->wake_lock); info->tty = 0; } tty->driver_data = 0; del_timer(&info->buf_req_timer); if (info->ch) { smd_close(info->ch); info->ch = 0; pil_put(info->pil); } } mutex_unlock(&smd_tty_lock); }
void ddl_fw_release(struct ddl_buf_addr *dram_base) { void *cookie = dram_base->pil_cookie; if (res_trk_is_cp_enabled() && res_trk_check_for_sec_session()) { res_trk_close_secure_session(); if (IS_ERR_OR_NULL(cookie)) { pr_err("Invalid params"); return; } if (res_trk_enable_footswitch()) { pr_err("Failed to enable footswitch"); return; } if (res_trk_enable_iommu_clocks()) { res_trk_disable_footswitch(); pr_err("Failed to enable iommu clocks\n"); return; } pil_put(cookie); if (res_trk_disable_iommu_clocks()) pr_err("Failed to disable iommu clocks\n"); if (res_trk_disable_footswitch()) pr_err("Failed to disable footswitch\n"); } else { if (res_trk_check_for_sec_session()) res_trk_close_secure_session(); res_trk_release_fw_addr(); } }
/** * pil_put() - Inform PIL the peripheral no longer needs to be active * @peripheral_handle: pointer from a previous call to pil_get() * * This doesn't imply that a peripheral is shutdown or in reset since another * driver could be using the peripheral. */ void pil_put(void *peripheral_handle) { struct pil_device *pil_d, *pil = peripheral_handle; if (IS_ERR_OR_NULL(pil)) return; mutex_lock(&pil->lock); if (WARN(!pil->count, "%s: Reference count mismatch\n", __func__)) goto err_out; if (!--pil->count) pil_shutdown(pil); mutex_unlock(&pil->lock); pil_d = find_peripheral(pil->desc->depends_on); module_put(pil->owner); if (pil_d) { pil_put(pil_d); put_device(&pil_d->dev); } put_device(&pil->dev); return; err_out: mutex_unlock(&pil->lock); return; }
static void msm_rmnet_unload_modem(void *pil) { /* printk("%s() ++\n", __func__); */ printk("pil: %s", ( pil? "true" : "false" )); if (pil) pil_put(pil); /* printk("%s() --\n", __func__); */ }
static int adsp_loader_remove(struct platform_device *pdev) { struct adsp_loader_private *priv; priv = platform_get_drvdata(pdev); pil_put(priv->pil_h); pr_info("%s: Q6/ADSP image is unloaded\n", __func__); return 0; }
/** * pil_get() - Load a peripheral into memory and take it out of reset * @name: pointer to a string containing the name of the peripheral to load * * This function returns a pointer if it succeeds. If an error occurs an * ERR_PTR is returned. * * If PIL is not enabled in the kernel, the value %NULL will be returned. */ void *pil_get(const char *name) { int ret; struct pil_device *pil; struct pil_device *pil_d; void *retval; if (!name) return NULL; pil = retval = find_peripheral(name); if (!pil) return ERR_PTR(-ENODEV); if (!try_module_get(pil->owner)) { put_device(&pil->dev); return ERR_PTR(-ENODEV); } pil_d = pil_get(pil->desc->depends_on); if (IS_ERR(pil_d)) { retval = pil_d; goto err_depends; } mutex_lock(&pil->lock); if (!pil->count) { ret = load_image(pil); if (ret) { retval = ERR_PTR(ret); goto err_load; } } pil->count++; pil_set_state(pil, PIL_ONLINE); /* LGE_CHANGE */ #ifdef CONFIG_MACH_LGE //LGE_CNAHGES : Add log for debugging watchdog reset. //ALRAN //pr_err("ALRAN: %s, count %d, pid %d, %s\n", __func__, pil->count, current->pid, current->comm); #endif mutex_unlock(&pil->lock); out: return retval; err_load: mutex_unlock(&pil->lock); pil_put(pil_d); err_depends: put_device(&pil->dev); module_put(pil->owner); goto out; }
/** * pil_get() - Load a peripheral into memory and take it out of reset * @name: pointer to a string containing the name of the peripheral to load * * This function returns a pointer if it succeeds. If an error occurs an * ERR_PTR is returned. * * If PIL is not enabled in the kernel, the value %NULL will be returned. */ void *pil_get(const char *name) { int ret; struct pil_device *pil; struct pil_device *pil_d; void *retval; if (!name) return NULL; pil = retval = find_peripheral(name); if (!pil) return ERR_PTR(-ENODEV); if (!try_module_get(pil->owner)) { put_device(&pil->dev); return ERR_PTR(-ENODEV); } pil_d = pil_get(pil->desc->depends_on); if (IS_ERR(pil_d)) { retval = pil_d; goto err_depends; } if (pil->count <= 1) { printk(KERN_DEBUG "%s:%s, count:%d, pid:%d, %s\n", __func__, name, pil->count, current->pid, current->comm); } mutex_lock(&pil->lock); if (!pil->count) { ret = load_image(pil); if (ret) { retval = ERR_PTR(ret); goto err_load; } } pil->count++; pil_set_state(pil, PIL_ONLINE); mutex_unlock(&pil->lock); out: return retval; err_load: mutex_unlock(&pil->lock); pil_put(pil_d); err_depends: put_device(&pil->dev); module_put(pil->owner); goto out; }
static void __exit wcnss_wlan_exit(void) { if (penv) { if (penv->pil) pil_put(penv->pil); kfree(penv); penv = NULL; } platform_driver_unregister(&wcnss_wlan_ctrl_driver); platform_driver_unregister(&wcnss_wlan_driver); }
static void __exit wcnss_wlan_exit(void) { if (penv) { if (penv->pil) pil_put(penv->pil); kfree(penv); penv = NULL; } platform_driver_unregister(&wcnss_wlan_ctrl_driver); platform_driver_unregister(&wcnss_wlan_driver); #ifdef CONFIG_WCNSS_MEM_PRE_ALLOC wcnss_prealloc_deinit(); #endif }
static void __exit wcnss_wlan_exit(void) { if (penv) { if (penv->pil) pil_put(penv->pil); kfree(penv); penv = NULL; } platform_driver_unregister(&wcnss_wlan_ctrl_driver); platform_driver_unregister(&wcnss_wlan_driver); #ifdef FEATURE_PANTECH_WLAN_QCOM_PATCH //20120726 thkim_wifi the patch to prevent memory fragmentation when the wlan host driver loads.(Case Number: 00924847) wcnss_prealloc_deinit(); #endif }
/** * pil_put() - Inform PIL the peripheral no longer needs to be active * @peripheral_handle: pointer from a previous call to pil_get() * * This doesn't imply that a peripheral is shutdown or in reset since another * driver could be using the peripheral. */ void pil_put(void *peripheral_handle) { struct pil_device *pil_d, *pil = peripheral_handle; if (IS_ERR_OR_NULL(pil)) return; mutex_lock(&pil->lock); if (WARN(!pil->count, "%s: %s: Reference count mismatch\n", pil->desc->name, __func__)) goto err_out; /* LGE_CHANGE */ #if CONFIG_MACH_LGE //LGE_CHANES : Workaround code for pereventing watchdog reset.(QCT Patch) if (!--pil->count){ if (!!strncmp("modem", pil->desc->name, 5)) //ALRAN : LG FX3 - allow pil_put only for not modem* pil_shutdown(pil); else{ pr_err("ALRAN: pil %s shutdown, but block it\n", pil->desc->name); pil->count++; } } #else if (!--pil->count) pil_shutdown(pil); #endif mutex_unlock(&pil->lock); pil_d = find_peripheral(pil->desc->depends_on); module_put(pil->owner); if (pil_d) { pil_put(pil_d); put_device(&pil_d->dev); } put_device(&pil->dev); return; err_out: mutex_unlock(&pil->lock); return; }
/** * pil_put() - Inform PIL the peripheral no longer needs to be active * @peripheral_handle: pointer from a previous call to pil_get() * * This doesn't imply that a peripheral is shutdown or in reset since another * driver could be using the peripheral. */ void pil_put(void *peripheral_handle) { struct pil_device *pil_d, *pil = peripheral_handle; if (IS_ERR_OR_NULL(pil)) return; if (pil->count <= 1) { printk(KERN_DEBUG "%s:%s, count:%d, pid:%d, %s\n", __func__, pil->desc->name, pil->count, current->pid, current->comm); } mutex_lock(&pil->lock); if (WARN(!pil->count, "%s: %s: Reference count mismatch\n", pil->desc->name, __func__)) goto err_out; if (!strncmp(pil->desc->name, "modem", 5)) { if (pil->count == 1) goto unlock; } if (!--pil->count) { pil_shutdown(pil); WARN_ON(1); } unlock: mutex_unlock(&pil->lock); pil_d = find_peripheral(pil->desc->depends_on); module_put(pil->owner); if (pil_d) { pil_put(pil_d); put_device(&pil_d->dev); } put_device(&pil->dev); return; err_out: mutex_unlock(&pil->lock); return; }
static ssize_t msm_pil_debugfs_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos) { struct pil_device *pil = filp->private_data; char buf[4]; if (cnt > sizeof(buf)) return -EINVAL; if (copy_from_user(&buf, ubuf, cnt)) return -EFAULT; if (!strncmp(buf, "get", 3)) { if (IS_ERR(pil_get(pil->desc->name))) return -EIO; } else if (!strncmp(buf, "put", 3)) pil_put(pil); else return -EINVAL; return cnt; }
static int wcnss_trigger_config(struct platform_device *pdev) { int ret; struct qcom_wcnss_opts *pdata; /* make sure we are only triggered once */ if (penv->triggered) return 0; penv->triggered = 1; /* initialize the WCNSS device configuration */ pdata = pdev->dev.platform_data; if (WCNSS_CONFIG_UNSPECIFIED == has_48mhz_xo) has_48mhz_xo = pdata->has_48mhz_xo; penv->wlan_config.use_48mhz_xo = has_48mhz_xo; penv->thermal_mitigation = 0; penv->gpios_5wire = platform_get_resource_byname(pdev, IORESOURCE_IO, "wcnss_gpios_5wire"); /* allocate 5-wire GPIO resources */ if (!penv->gpios_5wire) { dev_err(&pdev->dev, "insufficient IO resources\n"); ret = -ENOENT; goto fail_gpio_res; } /* Configure 5 wire GPIOs */ ret = wcnss_gpios_config(penv->gpios_5wire, true); if (ret) { dev_err(&pdev->dev, "WCNSS gpios config failed.\n"); goto fail_gpio_res; } /* power up the WCNSS */ ret = wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_ON); if (ret) { dev_err(&pdev->dev, "WCNSS Power-up failed.\n"); goto fail_power; } /* trigger initialization of the WCNSS */ penv->pil = pil_get(WCNSS_PIL_DEVICE); if (IS_ERR(penv->pil)) { dev_err(&pdev->dev, "Peripheral Loader failed on WCNSS.\n"); ret = PTR_ERR(penv->pil); penv->pil = NULL; goto fail_pil; } /* allocate resources */ penv->mmio_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "wcnss_mmio"); penv->tx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlantx_irq"); penv->rx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlanrx_irq"); if (!(penv->mmio_res && penv->tx_irq_res && penv->rx_irq_res)) { dev_err(&pdev->dev, "insufficient resources\n"); ret = -ENOENT; goto fail_res; } /* register sysfs entries */ ret = wcnss_create_sysfs(&pdev->dev); if (ret) goto fail_sysfs; return 0; fail_sysfs: fail_res: if (penv->pil) pil_put(penv->pil); fail_pil: wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_OFF); fail_power: wcnss_gpios_config(penv->gpios_5wire, false); fail_gpio_res: kfree(penv); penv = NULL; return ret; }
static int gss_release(struct inode *inode, struct file *filep) { pil_put(gss_data.pil_handle); pr_debug("%s pil_put called on GSS\n", __func__); return 0; }
static int wcnss_trigger_config(struct platform_device *pdev) { int ret; struct qcom_wcnss_opts *pdata; if (penv->triggered) return 0; penv->triggered = 1; pdata = pdev->dev.platform_data; if (WCNSS_CONFIG_UNSPECIFIED == has_48mhz_xo) has_48mhz_xo = pdata->has_48mhz_xo; penv->wlan_config.use_48mhz_xo = has_48mhz_xo; penv->thermal_mitigation = 0; penv->gpios_5wire = platform_get_resource_byname(pdev, IORESOURCE_IO, "wcnss_gpios_5wire"); if (!penv->gpios_5wire) { dev_err(&pdev->dev, "insufficient IO resources\n"); ret = -ENOENT; goto fail_gpio_res; } ret = wcnss_gpios_config(penv->gpios_5wire, true); if (ret) { dev_err(&pdev->dev, "WCNSS gpios config failed.\n"); goto fail_gpio_res; } ret = wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_ON); if (ret) { dev_err(&pdev->dev, "WCNSS Power-up failed.\n"); goto fail_power; } penv->pil = pil_get(WCNSS_PIL_DEVICE); if (IS_ERR(penv->pil)) { dev_err(&pdev->dev, "Peripheral Loader failed on WCNSS.\n"); ret = PTR_ERR(penv->pil); penv->pil = NULL; goto fail_pil; } penv->mmio_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "wcnss_mmio"); penv->tx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlantx_irq"); penv->rx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlanrx_irq"); if (!(penv->mmio_res && penv->tx_irq_res && penv->rx_irq_res)) { dev_err(&pdev->dev, "insufficient resources\n"); ret = -ENOENT; goto fail_res; } ret = wcnss_create_sysfs(&pdev->dev); if (ret) goto fail_sysfs; wake_lock_init(&penv->wcnss_wake_lock, WAKE_LOCK_SUSPEND, "wcnss"); penv->msm_wcnss_base = ioremap(MSM_RIVA_PHYS, SZ_256); if (!penv->msm_wcnss_base) { pr_err("%s: ioremap wcnss physical failed\n", __func__); goto fail_wake; } return 0; fail_wake: wake_lock_destroy(&penv->wcnss_wake_lock); fail_sysfs: fail_res: if (penv->pil) pil_put(penv->pil); fail_pil: wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_OFF); fail_power: wcnss_gpios_config(penv->gpios_5wire, false); fail_gpio_res: kfree(penv); penv = NULL; return ret; }
static int smd_tty_open(struct tty_struct *tty, struct file *f) { int res = 0; unsigned int n = tty->index; struct smd_tty_info *info; const char *peripheral = NULL; if (n >= MAX_SMD_TTYS || !smd_tty[n].smd) return -ENODEV; info = smd_tty + n; mutex_lock(&smd_tty_lock); tty->driver_data = info; if (info->open_count++ == 0) { peripheral = smd_edge_to_subsystem(smd_tty[n].smd->edge); if (peripheral) { info->pil = pil_get(peripheral); if (IS_ERR(info->pil)) { res = PTR_ERR(info->pil); goto out; } /* Wait for the modem SMSM to be inited for the SMD * Loopback channel to be allocated at the modem. Since * the wait need to be done atmost once, using msleep * doesn't degrade the performance. */ if (n == LOOPBACK_IDX) { if (!is_modem_smsm_inited()) msleep(5000); smsm_change_state(SMSM_APPS_STATE, 0, SMSM_SMD_LOOPBACK); msleep(100); } /* * Wait for a channel to be allocated so we know * the modem is ready enough. */ if (smd_tty_modem_wait) { res = wait_for_completion_interruptible_timeout( &info->ch_allocated, msecs_to_jiffies(smd_tty_modem_wait * 1000)); if (res == 0) { pr_err("Timed out waiting for SMD" " channel\n"); res = -ETIMEDOUT; goto release_pil; } else if (res < 0) { pr_err("Error waiting for SMD channel:" " %d\n", res); goto release_pil; } res = 0; } } info->tty = tty; tasklet_init(&info->tty_tsklt, smd_tty_read, (unsigned long)info); wake_lock_init(&info->wake_lock, WAKE_LOCK_SUSPEND, smd_tty[n].smd->port_name); if (!info->ch) { res = smd_named_open_on_edge(smd_tty[n].smd->port_name, smd_tty[n].smd->edge, &info->ch, info, smd_tty_notify); if (res < 0) { pr_err("%s: %s open failed %d\n", __func__, smd_tty[n].smd->port_name, res); goto release_pil; } res = wait_event_interruptible_timeout( info->ch_opened_wait_queue, info->is_open, (2 * HZ)); if (res == 0) res = -ETIMEDOUT; if (res < 0) { pr_err("%s: wait for %s smd_open failed %d\n", __func__, smd_tty[n].smd->port_name, res); goto release_pil; } res = 0; } } release_pil: if (res < 0) pil_put(info->pil); else smd_disable_read_intr(info->ch); out: mutex_unlock(&smd_tty_lock); return res; }
static int wcnss_trigger_config(struct platform_device *pdev) { int ret; struct qcom_wcnss_opts *pdata; unsigned long wcnss_phys_addr; int size = 0; int has_pronto_hw = of_property_read_bool(pdev->dev.of_node, "qcom,has_pronto_hw"); /* make sure we are only triggered once */ if (penv->triggered) return 0; penv->triggered = 1; /* initialize the WCNSS device configuration */ pdata = pdev->dev.platform_data; if (WCNSS_CONFIG_UNSPECIFIED == has_48mhz_xo) { if (has_pronto_hw) { has_48mhz_xo = of_property_read_bool(pdev->dev.of_node, "qcom,has_48mhz_xo"); penv->wcnss_hw_type = WCNSS_PRONTO_HW; } else { penv->wcnss_hw_type = WCNSS_RIVA_HW; has_48mhz_xo = pdata->has_48mhz_xo; } } penv->wlan_config.use_48mhz_xo = has_48mhz_xo; penv->thermal_mitigation = 0; strlcpy(penv->wcnss_version, "INVALID", WCNSS_VERSION_LEN); /* Configure 5 wire GPIOs */ if (!has_pronto_hw) { penv->gpios_5wire = platform_get_resource_byname(pdev, IORESOURCE_IO, "wcnss_gpios_5wire"); /* allocate 5-wire GPIO resources */ if (!penv->gpios_5wire) { dev_err(&pdev->dev, "insufficient IO resources\n"); ret = -ENOENT; goto fail_gpio_res; } ret = wcnss_gpios_config(penv->gpios_5wire, true); } else ret = wcnss_pronto_gpios_config(&pdev->dev, true); if (ret) { dev_err(&pdev->dev, "WCNSS gpios config failed.\n"); goto fail_gpio_res; } /* power up the WCNSS */ ret = wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_ON); if (ret) { dev_err(&pdev->dev, "WCNSS Power-up failed.\n"); goto fail_power; } /* trigger initialization of the WCNSS */ penv->pil = pil_get(WCNSS_PIL_DEVICE); if (IS_ERR(penv->pil)) { dev_err(&pdev->dev, "Peripheral Loader failed on WCNSS.\n"); ret = PTR_ERR(penv->pil); penv->pil = NULL; goto fail_pil; } /* allocate resources */ penv->mmio_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "wcnss_mmio"); penv->tx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlantx_irq"); penv->rx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlanrx_irq"); if (!(penv->mmio_res && penv->tx_irq_res && penv->rx_irq_res)) { dev_err(&pdev->dev, "insufficient resources\n"); ret = -ENOENT; goto fail_res; } INIT_WORK(&penv->wcnssctrl_rx_work, wcnssctrl_rx_handler); INIT_WORK(&penv->wcnssctrl_version_work, wcnss_send_version_req); wake_lock_init(&penv->wcnss_wake_lock, WAKE_LOCK_SUSPEND, "wcnss"); if (wcnss_hardware_type() == WCNSS_PRONTO_HW) { size = 0x3000; wcnss_phys_addr = MSM_PRONTO_PHYS; } else { wcnss_phys_addr = MSM_RIVA_PHYS; size = SZ_256; } penv->msm_wcnss_base = ioremap(wcnss_phys_addr, size); if (!penv->msm_wcnss_base) { ret = -ENOMEM; pr_err("%s: ioremap wcnss physical failed\n", __func__); goto fail_wake; } return 0; fail_wake: wake_lock_destroy(&penv->wcnss_wake_lock); fail_res: if (penv->pil) pil_put(penv->pil); fail_pil: wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_OFF); fail_power: if (has_pronto_hw) wcnss_pronto_gpios_config(&pdev->dev, false); else wcnss_gpios_config(penv->gpios_5wire, false); fail_gpio_res: kfree(penv); penv = NULL; return ret; }
/** * Unload DSPS Firmware. */ static void dsps_unload(void) { pr_debug("%s.\n", __func__); pil_put(drv->pil); }
static int wcnss_trigger_config(struct platform_device *pdev) { int ret; struct qcom_wcnss_opts *pdata; /* make sure we are only triggered once */ if (penv->triggered) return 0; penv->triggered = 1; /* initialize the WCNSS device configuration */ pdata = pdev->dev.platform_data; if (WCNSS_CONFIG_UNSPECIFIED == has_48mhz_xo) has_48mhz_xo = pdata->has_48mhz_xo; penv->wlan_config.use_48mhz_xo = has_48mhz_xo; penv->thermal_mitigation = 0; strlcpy(penv->wcnss_version, "INVALID", WCNSS_VERSION_LEN); penv->gpios_5wire = platform_get_resource_byname(pdev, IORESOURCE_IO, "wcnss_gpios_5wire"); /* allocate 5-wire GPIO resources */ if (!penv->gpios_5wire) { dev_err(&pdev->dev, "insufficient IO resources\n"); ret = -ENOENT; goto fail_gpio_res; } /* Configure 5 wire GPIOs */ ret = wcnss_gpios_config(penv->gpios_5wire, true); if (ret) { dev_err(&pdev->dev, "WCNSS gpios config failed.\n"); goto fail_gpio_res; } /* power up the WCNSS */ ret = wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_ON); if (ret) { dev_err(&pdev->dev, "WCNSS Power-up failed.\n"); goto fail_power; } /* trigger initialization of the WCNSS */ penv->pil = pil_get(WCNSS_PIL_DEVICE); if (IS_ERR(penv->pil)) { dev_err(&pdev->dev, "Peripheral Loader failed on WCNSS.\n"); ret = PTR_ERR(penv->pil); penv->pil = NULL; goto fail_pil; } /* allocate resources */ penv->mmio_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "wcnss_mmio"); penv->tx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlantx_irq"); penv->rx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "wcnss_wlanrx_irq"); if (!(penv->mmio_res && penv->tx_irq_res && penv->rx_irq_res)) { dev_err(&pdev->dev, "insufficient resources\n"); ret = -ENOENT; goto fail_res; } INIT_WORK(&penv->wcnssctrl_rx_work, wcnssctrl_rx_handler); INIT_WORK(&penv->wcnssctrl_version_work, wcnss_send_version_req); INIT_WORK(&penv->wcnssctrl_nvbin_dnld_work, wcnss_nvbin_dnld_main); wake_lock_init(&penv->wcnss_wake_lock, WAKE_LOCK_SUSPEND, "wcnss"); penv->msm_wcnss_base = ioremap(MSM_RIVA_PHYS, SZ_256); if (!penv->msm_wcnss_base) { pr_err("%s: ioremap wcnss physical failed\n", __func__); goto fail_wake; } return 0; fail_wake: wake_lock_destroy(&penv->wcnss_wake_lock); fail_res: if (penv->pil) pil_put(penv->pil); fail_pil: wcnss_wlan_power(&pdev->dev, &penv->wlan_config, WCNSS_WLAN_SWITCH_OFF); fail_power: wcnss_gpios_config(penv->gpios_5wire, false); fail_gpio_res: kfree(penv); penv = NULL; return ret; }
/* Called in soft-irq context */ static void smd_net_data_handler(unsigned long arg) { struct net_device *dev = (struct net_device *) arg; struct rmnet_private *p = netdev_priv(dev); struct sk_buff *skb; void *ptr = 0; int sz; u32 opmode = p->operation_mode; // unsigned long flags; // int max_package_size; for (;;) { sz = smd_cur_packet_size(p->ch); if (sz == 0) break; if (smd_read_avail(p->ch) < sz) break; //ZTE_RIL_WANGCHENG_20110425 start #ifdef CONFIG_ZTE_PLATFORM if (RMNET_IS_MODE_IP(opmode) ? (sz > ((dev->mtu > RMNET_DEFAULT_MTU_LEN)? dev->mtu:RMNET_DEFAULT_MTU_LEN)) : (sz > (((dev->mtu > RMNET_DEFAULT_MTU_LEN)? dev->mtu:RMNET_DEFAULT_MTU_LEN) + ETH_HLEN))) { #else if (RMNET_IS_MODE_IP(opmode) ? (sz > dev->mtu) : (sz > (dev->mtu + ETH_HLEN))) { #endif pr_err("rmnet_recv() discarding %d len (%d mtu)\n", sz, RMNET_IS_MODE_IP(opmode) ? dev->mtu : (dev->mtu + ETH_HLEN)); ptr = 0; } else { skb = dev_alloc_skb(sz + NET_IP_ALIGN); if (skb == NULL) { pr_err("rmnet_recv() cannot allocate skb\n"); } else { skb->dev = dev; skb_reserve(skb, NET_IP_ALIGN); ptr = skb_put(skb, sz); wake_lock_timeout(&p->wake_lock, HZ / 2); if (smd_read(p->ch, ptr, sz) != sz) { pr_err("rmnet_recv() smd lied about avail?!"); ptr = 0; dev_kfree_skb_irq(skb); } else { /* Handle Rx frame format */ //spin_lock_irqsave(&p->lock, flags); //opmode = p->operation_mode; //spin_unlock_irqrestore(&p->lock, flags); if (RMNET_IS_MODE_IP(opmode)) { /* Driver in IP mode */ skb->protocol = rmnet_ip_type_trans(skb, dev); } else { /* Driver in Ethernet mode */ skb->protocol = eth_type_trans(skb, dev); } if (RMNET_IS_MODE_IP(opmode) || count_this_packet(ptr, skb->len)) { #ifdef CONFIG_MSM_RMNET_DEBUG p->wakeups_rcv += rmnet_cause_wakeup(p); #endif p->stats.rx_packets++; p->stats.rx_bytes += skb->len; } netif_rx(skb); } continue; } } if (smd_read(p->ch, ptr, sz) != sz) pr_err("rmnet_recv() smd lied about avail?!"); } } //ZTE_RIL_RJG_20101103 end static DECLARE_TASKLET(smd_net_data_tasklet, smd_net_data_handler, 0); static int _rmnet_xmit(struct sk_buff *skb, struct net_device *dev) { struct rmnet_private *p = netdev_priv(dev); smd_channel_t *ch = p->ch; int smd_ret; struct QMI_QOS_HDR_S *qmih; u32 opmode; unsigned long flags; /* For QoS mode, prepend QMI header and assign flow ID from skb->mark */ spin_lock_irqsave(&p->lock, flags); opmode = p->operation_mode; spin_unlock_irqrestore(&p->lock, flags); if (RMNET_IS_MODE_QOS(opmode)) { qmih = (struct QMI_QOS_HDR_S *) skb_push(skb, sizeof(struct QMI_QOS_HDR_S)); qmih->version = 1; qmih->flags = 0; qmih->flow_id = skb->mark; } dev->trans_start = jiffies; smd_ret = smd_write(ch, skb->data, skb->len); if (smd_ret != skb->len) { pr_err("%s: smd_write returned error %d", __func__, smd_ret); goto xmit_out; } if (RMNET_IS_MODE_IP(opmode) || count_this_packet(skb->data, skb->len)) { p->stats.tx_packets++; p->stats.tx_bytes += skb->len; #ifdef CONFIG_MSM_RMNET_DEBUG p->wakeups_xmit += rmnet_cause_wakeup(p); #endif } xmit_out: /* data xmited, safe to release skb */ dev_kfree_skb_irq(skb); return 0; } static void _rmnet_resume_flow(unsigned long param) { struct net_device *dev = (struct net_device *)param; struct rmnet_private *p = netdev_priv(dev); struct sk_buff *skb = NULL; unsigned long flags; /* xmit and enable the flow only once even if multiple tasklets were scheduled by smd_net_notify */ spin_lock_irqsave(&p->lock, flags); if (p->skb && (smd_write_avail(p->ch) >= p->skb->len)) { skb = p->skb; p->skb = NULL; spin_unlock_irqrestore(&p->lock, flags); _rmnet_xmit(skb, dev); netif_wake_queue(dev); } else spin_unlock_irqrestore(&p->lock, flags); } static void msm_rmnet_unload_modem(void *pil) { if (pil) pil_put(pil); } static void *msm_rmnet_load_modem(struct net_device *dev) { void *pil; int rc; struct rmnet_private *p = netdev_priv(dev); pil = pil_get("modem"); if (IS_ERR(pil)) pr_err("%s: modem load failed\n", __func__); else if (msm_rmnet_modem_wait) { rc = wait_for_completion_interruptible_timeout( &p->complete, msecs_to_jiffies(msm_rmnet_modem_wait * 1000)); if (!rc) rc = -ETIMEDOUT; if (rc < 0) { pr_err("%s: wait for rmnet port failed %d\n", __func__, rc); msm_rmnet_unload_modem(pil); pil = ERR_PTR(rc); } } return pil; }
static void msm_rpcrouter_unload_modem(void *pil) { if (pil) pil_put(pil); }
void *pil_get(const char *name) { int ret; struct pil_device *pil; struct pil_device *pil_d; void *retval; static int modem_initialized = 0; int loop_count = 0; if (!name) return NULL; printk("%s: %s(%d) for %s\n", __func__, current->comm, current->pid, name); pil = retval = find_peripheral(name); if (!pil) return ERR_PTR(-ENODEV); if (!try_module_get(pil->owner)) { put_device(&pil->dev); return ERR_PTR(-ENODEV); } pil_d = pil_get(pil->desc->depends_on); if (IS_ERR(pil_d)) { retval = pil_d; goto err_depends; } printk("%s: pil_get %s sucessfully, pil->count:%d\n", __func__, name, pil->count); if (!strcmp("modem", name)) { while (unlikely(!modem_initialized && strcmp("rmt_storage", current->comm) && loop_count++ < 10)) { printk("%s: %s(%d) waiting for rmt_storage %d\n", __func__, current->comm, current->pid, loop_count); msleep(500); } } mutex_lock(&pil->lock); if (!pil->count) { if (!strcmp("modem", name)) { printk("%s: %s(%d) for %s\n", __func__, current->comm, current->pid, name); modem_initialized = 1; } ret = load_image(pil); if (ret) { retval = ERR_PTR(ret); goto err_load; } } pil->count++; pil_set_state(pil, PIL_ONLINE); mutex_unlock(&pil->lock); out: return retval; err_load: mutex_unlock(&pil->lock); pil_put(pil_d); err_depends: put_device(&pil->dev); module_put(pil->owner); goto out; }
static void msm_rmnet_unload_modem(void *pil) { if (pil) pil_put(pil); }
void *pil_get(const char *name) { int ret; struct pil_device *pil; struct pil_device *pil_d; void *retval; #ifdef CONFIG_MSM8960_ONLY static int modem_initialized = 0; int loop_count = 0; #endif if (!name) return NULL; pil = retval = find_peripheral(name); if (!pil) return ERR_PTR(-ENODEV); if (!try_module_get(pil->owner)) { put_device(&pil->dev); return ERR_PTR(-ENODEV); } pil_d = pil_get(pil->desc->depends_on); if (IS_ERR(pil_d)) { retval = pil_d; goto err_depends; } #ifdef CONFIG_MSM8960_ONLY if (!strcmp("modem", name)) { while (unlikely(!modem_initialized && strcmp("rmt_storage", current->comm) && loop_count++ < 10)) { printk("%s: %s(%d) waiting for rmt_storage %d\n", __func__, current->comm, current->pid, loop_count); msleep(500); } } #endif mutex_lock(&pil->lock); if (!pil->count) { if (!strcmp("modem", name)) { printk("%s: %s(%d) for %s\n", __func__, current->comm, current->pid, name); #ifdef CONFIG_MSM8960_ONLY modem_initialized = 1; #endif } ret = load_image(pil); if (ret) { retval = ERR_PTR(ret); goto err_load; } } pil->count++; pil_set_state(pil, PIL_ONLINE); mutex_unlock(&pil->lock); #if defined(CONFIG_MSM8930_ONLY) if (!strcmp("modem", name)) { complete_all(&pil_work_finished); } #elif defined(CONFIG_ARCH_APQ8064) complete_all(&pil_work_finished); #endif out: return retval; err_load: mutex_unlock(&pil->lock); pil_put(pil_d); err_depends: put_device(&pil->dev); module_put(pil->owner); goto out; }