/** * 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; }
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; }
/** * 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; }
void pil_force_shutdown(const char *name) { struct pil_device *pil; pil = find_peripheral(name); if (!pil) { pr_err("%s: Couldn't find %s\n", __func__, name); return; } mutex_lock(&pil->lock); if (!WARN(!pil->count, "%s: Reference count mismatch\n", __func__)) pil_shutdown(pil); mutex_unlock(&pil->lock); put_device(&pil->dev); }
/** * 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; }
int pil_force_boot(const char *name) { int ret = -EINVAL; struct pil_device *pil; pil = find_peripheral(name); if (!pil) { pr_err("%s: Couldn't find %s\n", __func__, name); return -EINVAL; } mutex_lock(&pil->lock); if (!WARN(!pil->count, "%s: Reference count mismatch\n", __func__)) ret = load_image(pil); if (!ret) pil_set_state(pil, PIL_ONLINE); mutex_unlock(&pil->lock); put_device(&pil->dev); return ret; }
/** * 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; }
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; }
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; }