int mhi_esoc_register(struct mhi_device_ctxt *mhi_dev_ctxt) { int ret_val = 0; struct device_node *np; struct pci_driver *mhi_driver; struct device *dev = &mhi_dev_ctxt->dev_info->pcie_device->dev; mhi_driver = mhi_dev_ctxt->dev_info->mhi_pcie_driver; np = dev->of_node; mhi_dev_ctxt->esoc_handle = devm_register_esoc_client(dev, "mdm"); mhi_log(MHI_MSG_VERBOSE, "Of table of pcie struct device property is dev->of_node %p\n", np); if (IS_ERR_OR_NULL(mhi_dev_ctxt->esoc_handle)) { mhi_log(MHI_MSG_CRITICAL, "Failed to register for SSR, ret %lx\n", (uintptr_t)mhi_dev_ctxt->esoc_handle); return -EIO; } esoc_parse_link_type(mhi_dev_ctxt); mhi_dev_ctxt->esoc_ssr_handle = subsys_notif_register_notifier( mhi_dev_ctxt->esoc_handle->name, &mhi_ssr_nb); if (IS_ERR_OR_NULL(mhi_dev_ctxt->esoc_ssr_handle)) { ret_val = PTR_RET(mhi_dev_ctxt->esoc_ssr_handle); mhi_log(MHI_MSG_CRITICAL, "Can't find esoc desc ret 0x%lx\n", (uintptr_t)mhi_dev_ctxt->esoc_ssr_handle); } return ret_val; }
static int __devinit pil_subsys_init(struct modem_data *drv, struct platform_device *pdev) { int ret; #ifdef CONFIG_MACH_LGE pr_info("pil_subsys_init : exter init\n"); #endif #ifdef CONFIG_MACH_LGE pr_info("pil_subsys_init : exter init\n"); #endif drv->subsys_desc.name = "modem"; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.shutdown = modem_shutdown; drv->subsys_desc.powerup = modem_powerup; drv->subsys_desc.ramdump = modem_ramdump; drv->subsys_desc.crash_shutdown = modem_crash_shutdown; drv->subsys_desc.start = mss_start; drv->subsys_desc.stop = mss_stop; drv->subsys_desc.err_fatal_handler = modem_err_fatal_intr_handler; drv->subsys_desc.stop_ack_handler = modem_stop_ack_intr_handler; drv->subsys_desc.wdog_bite_handler = modem_wdog_bite_intr_handler; drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { ret = PTR_ERR(drv->subsys); goto err_subsys; } drv->ramdump_dev = create_ramdump_device("modem", &pdev->dev); if (!drv->ramdump_dev) { pr_err("%s: Unable to create a modem ramdump device.\n", __func__); ret = -ENOMEM; goto err_ramdump; } drv->adsp_state_notifier = subsys_notif_register_notifier("adsp", &adsp_state_notifier_block); if (IS_ERR(drv->adsp_state_notifier)) { ret = PTR_ERR(drv->adsp_state_notifier); dev_err(&pdev->dev, "%s: Registration with the SSR notification driver failed (%d)", __func__, ret); goto err_irq; } #ifdef CONFIG_MACH_LGE pr_info("pil_subsys_init : exit init\n"); #endif return 0; err_irq: destroy_ramdump_device(drv->ramdump_dev); err_ramdump: subsys_unregister(drv->subsys); err_subsys: return ret; }
static int mitigate_inrush_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; int i, retval; struct subsystem *subsys; struct inrush_driver_data *drv_data; retval = of_property_count_strings(np, "qcom,dependent-subsystems"); if (IS_ERR_VALUE(retval)) { dev_err(dev, "Failed to get dependent subsystems\n"); return -EINVAL; } drv_data = kzalloc((retval * sizeof(struct subsystem) + sizeof(struct inrush_driver_data)), GFP_KERNEL); if (!drv_data) return -ENOMEM; drv_data->subsystems = (void *)drv_data + sizeof(struct inrush_driver_data); drv_data->subsys_count = retval; for (i = 0; i < drv_data->subsys_count; i++) { subsys = &drv_data->subsystems[i]; subsys->drv_data = drv_data; of_property_read_string_index(np, "qcom,dependent-subsystems", i, &subsys->name); subsys->nb.notifier_call = mitigate_inrush_notifier_cb; subsys->notif_handle = subsys_notif_register_notifier(subsys->name, &subsys->nb); if (IS_ERR(subsys->notif_handle)) { dev_err(dev, "Notifier registration failed for %s\n", subsys->name); retval = PTR_ERR(subsys->notif_handle); goto err_subsys_notif; } } drv_data->vreg = devm_regulator_get(dev, "vdd"); if (IS_ERR(drv_data->vreg)) { dev_err(dev, "Failed to get regulator\n"); return PTR_ERR(drv_data->vreg); } return 0; err_subsys_notif: for (i = 0; i < drv_data->subsys_count; i++) { subsys = &drv_data->subsystems[i]; subsys_notif_unregister_notifier(subsys->notif_handle, &subsys->nb); } kfree(drv_data); return retval; }
static int last_amsslog_driver_probe(struct platform_device *pdev) { struct resource *amsslog_res; struct proc_dir_entry *entry; void *subsys; int ret = 0; dev = &pdev->dev; amsslog_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "amsslog"); if (!amsslog_res || !amsslog_res->start) { dev_err(dev, "last_amsslog resource invalid/absent\n"); return -ENODEV; } amsslog_size = amsslog_res->end - amsslog_res->start + 1; amsslog_base = (char *)ioremap(amsslog_res->start, amsslog_size); if (amsslog_base == NULL) { dev_err(dev, "failed to map last_amsslog memory\n"); return -ENOMEM; } amsslog_buf = (char *)__get_free_pages(GFP_KERNEL, get_order(amsslog_size)); if (!amsslog_buf) { dev_err(dev, "Failed to allocate pages of order %d\n", get_order(amsslog_size)); iounmap(amsslog_base); return -ENOMEM; } subsys = subsys_notif_register_notifier("modem", &modem_status_notifier); if (IS_ERR(subsys)) { dev_err(dev, "Failed to register modem state notifier\n"); ret = -EINVAL; goto out; } entry = proc_create_data("last_amsslog", S_IRUSR, NULL, &last_amsslog_fops, NULL); if (!entry) { dev_err(dev, "failed to create last_amsslog proc entry\n"); ret = -ENOMEM; goto out; } out: if (!ret) dev_info(dev, "Last modem error log driver probe done !!\n"); else { free_pages((unsigned long)amsslog_buf, get_order(amsslog_size)); iounmap(amsslog_base); amsslog_base = NULL; } return ret; }
static void subsys_notif_register_v2(struct notifier_block *mod_notif, struct notifier_block *lp_notif) { subsys_notif_register_notifier("modem", mod_notif); subsys_notif_register_notifier(apr_get_lpass_subsys_name(), lp_notif); }
static void subsys_notif_register_v3(struct notifier_block *mod_notif, struct notifier_block *lp_notif) { subsys_notif_register_notifier("modem", mod_notif); }
static __devinit int msm8x10_asoc_machine_probe(struct platform_device *pdev) { struct snd_soc_card *card = &snd_soc_card_msm8x10; int ret; dev_dbg(&pdev->dev, "%s\n", __func__); if (!pdev->dev.of_node) { dev_err(&pdev->dev, "No platform supplied from device tree\n"); return -EINVAL; } card->dev = &pdev->dev; platform_set_drvdata(pdev, card); ret = snd_soc_of_parse_card_name(card, "qcom,model"); if (ret) goto err; ret = snd_soc_of_parse_audio_routing(card, "qcom,audio-routing"); if (ret) goto err; mutex_init(&cdc_mclk_mutex); pcbcr = ioremap(MSM8X10_DINO_LPASS_DIGCODEC_CBCR, 4); if (!pcbcr) { ret = -ENOMEM; goto err1; } prcgr = ioremap(MSM8X10_DINO_LPASS_DIGCODEC_CMD_RCGR, 4); if (!prcgr) { ret = -ENOMEM; goto err1; } atomic_set(&mclk_rsc_ref, 0); mbhc_cfg.gpio_level_insert = of_property_read_bool(pdev->dev.of_node, "qcom,headset-jack-type-NC"); mbhc_cfg.use_int_rbias = of_property_read_bool(pdev->dev.of_node, "qcom,mbhc-bias-internal"); spdev = pdev; ret = snd_soc_register_card(card); if (ret == -EPROBE_DEFER) goto err1; else if (ret) { dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret); goto err1; } adsp_state_notifier = subsys_notif_register_notifier("adsp", &adsp_state_notifier_block); if (!adsp_state_notifier) { pr_err("%s: Failed to register adsp state notifier\n", __func__); } if (msm_sec_mi2s_rx2_group) msm_mi2s_rx2_init(); return 0; err1: mutex_destroy(&cdc_mclk_mutex); if (pcbcr) iounmap(pcbcr); if (prcgr) iounmap(prcgr); err: return ret; }