/**
* 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;
}
