int __init ardbeg_panel_init(void) { int err = 0; struct resource __maybe_unused *res; struct platform_device *phost1x = NULL; struct board_info board_info; struct device_node *dc1_node = NULL; struct device_node *dc2_node = NULL; #ifdef CONFIG_NVMAP_USE_CMA_FOR_CARVEOUT struct dma_declare_info vpr_dma_info; struct dma_declare_info generic_dma_info; #endif find_dc_node(&dc1_node, &dc2_node); #ifndef CONFIG_TEGRA_HDMI_PRIMARY ardbeg_panel_select(); #endif #ifdef CONFIG_TEGRA_NVMAP ardbeg_carveouts[1].base = tegra_carveout_start; ardbeg_carveouts[1].size = tegra_carveout_size; ardbeg_carveouts[2].base = tegra_vpr_start; ardbeg_carveouts[2].size = tegra_vpr_size; #ifdef CONFIG_NVMAP_USE_CMA_FOR_CARVEOUT generic_dma_info.name = "generic"; generic_dma_info.base = tegra_carveout_start; generic_dma_info.size = tegra_carveout_size; generic_dma_info.resize = false; generic_dma_info.cma_dev = NULL; vpr_dma_info.name = "vpr"; vpr_dma_info.base = tegra_vpr_start; vpr_dma_info.size = tegra_vpr_size; vpr_dma_info.resize = false; vpr_dma_info.cma_dev = NULL; ardbeg_carveouts[1].cma_dev = &tegra_generic_cma_dev; ardbeg_carveouts[1].resize = false; ardbeg_carveouts[2].cma_dev = &tegra_vpr_cma_dev; ardbeg_carveouts[2].resize = true; vpr_dma_info.size = SZ_32M; vpr_dma_info.resize = true; vpr_dma_info.cma_dev = &tegra_vpr_cma_dev; vpr_dma_info.notifier.ops = &vpr_dev_ops; if (tegra_carveout_size) { err = dma_declare_coherent_resizable_cma_memory( &tegra_generic_dev, &generic_dma_info); if (err) { pr_err("Generic coherent memory declaration failed\n"); return err; } } if (tegra_vpr_size) { err = dma_declare_coherent_resizable_cma_memory( &tegra_vpr_dev, &vpr_dma_info); if (err) { pr_err("VPR coherent memory declaration failed\n"); return err; } } #endif err = platform_device_register(&ardbeg_nvmap_device); if (err) { pr_err("nvmap device registration failed\n"); return err; } #endif phost1x = ardbeg_host1x_init(); if (!phost1x) { pr_err("host1x devices registration failed\n"); return -EINVAL; } if (!of_have_populated_dt() || !dc1_node || !of_device_is_available(dc1_node)) { #ifndef CONFIG_TEGRA_HDMI_PRIMARY res = platform_get_resource_byname(&ardbeg_disp1_device, IORESOURCE_MEM, "fbmem"); #else res = platform_get_resource_byname(&ardbeg_disp2_device, IORESOURCE_MEM, "fbmem"); #endif res->start = tegra_fb_start; res->end = tegra_fb_start + tegra_fb_size - 1; } /* Copy the bootloader fb to the fb. */ if (tegra_bootloader_fb_size) __tegra_move_framebuffer(&ardbeg_nvmap_device, tegra_fb_start, tegra_bootloader_fb_start, min(tegra_fb_size, tegra_bootloader_fb_size)); else __tegra_clear_framebuffer(&ardbeg_nvmap_device, tegra_fb_start, tegra_fb_size); /* Copy the bootloader fb2 to the fb2. */ if (tegra_bootloader_fb2_size) __tegra_move_framebuffer(&ardbeg_nvmap_device, tegra_fb2_start, tegra_bootloader_fb2_start, min(tegra_fb2_size, tegra_bootloader_fb2_size)); else __tegra_clear_framebuffer(&ardbeg_nvmap_device, tegra_fb2_start, tegra_fb2_size); #ifndef CONFIG_TEGRA_HDMI_PRIMARY if (!of_have_populated_dt() || !dc1_node || !of_device_is_available(dc1_node)) { ardbeg_disp1_device.dev.parent = &phost1x->dev; err = platform_device_register(&ardbeg_disp1_device); if (err) { pr_err("disp1 device registration failed\n"); return err; } } #endif tegra_get_board_info(&board_info); switch (board_info.board_id) { case BOARD_E1991: ardbeg_hdmi_out.tmds_config = ardbeg_tn8_tmds_config2; break; case BOARD_P1761: if (board_info.fab == 3) ardbeg_hdmi_out.tmds_config = ardbeg_tn8_tmds_config2; else ardbeg_hdmi_out.tmds_config = ardbeg_tn8_tmds_config; break; case BOARD_PM359: case BOARD_E1971: case BOARD_E1973: default: /* default is ardbeg_tmds_config[] */ break; } if (!of_have_populated_dt() || !dc2_node || !of_device_is_available(dc2_node)) { #ifndef CONFIG_TEGRA_HDMI_PRIMARY res = platform_get_resource_byname(&ardbeg_disp2_device, IORESOURCE_MEM, "fbmem"); res->start = tegra_fb2_start; res->end = tegra_fb2_start + tegra_fb2_size - 1; #endif ardbeg_disp2_device.dev.parent = &phost1x->dev; err = platform_device_register(&ardbeg_disp2_device); if (err) { pr_err("disp2 device registration failed\n"); return err; } } return err; }
static int _rsnd_gen_regmap_init(struct rsnd_priv *priv, int id_size, int reg_id, const char *name, const struct rsnd_regmap_field_conf *conf, int conf_size) { struct platform_device *pdev = rsnd_priv_to_pdev(priv); struct rsnd_gen *gen = rsnd_priv_to_gen(priv); struct device *dev = rsnd_priv_to_dev(priv); struct resource *res; struct regmap_config regc; struct regmap_field *regs; struct regmap *regmap; struct reg_field regf; void __iomem *base; int i; memset(®c, 0, sizeof(regc)); regc.reg_bits = 32; regc.val_bits = 32; regc.reg_stride = 4; regc.name = name; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name); if (!res) res = platform_get_resource(pdev, IORESOURCE_MEM, reg_id); if (!res) return -ENODEV; base = devm_ioremap_resource(dev, res); if (IS_ERR(base)) return PTR_ERR(base); regmap = devm_regmap_init_mmio(dev, base, ®c); if (IS_ERR(regmap)) return PTR_ERR(regmap); /* RSND_BASE_MAX base */ gen->base[reg_id] = base; gen->regmap[reg_id] = regmap; gen->res[reg_id] = res->start; for (i = 0; i < conf_size; i++) { regf.reg = conf[i].reg_offset; regf.id_offset = conf[i].id_offset; regf.lsb = 0; regf.msb = 31; regf.id_size = id_size; regs = devm_regmap_field_alloc(dev, regmap, regf); if (IS_ERR(regs)) return PTR_ERR(regs); /* RSND_REG_MAX base */ gen->regs[conf[i].idx] = regs; gen->reg_name[conf[i].idx] = conf[i].reg_name; } return 0; }
static int __init i2c_ssbi_probe(struct platform_device *pdev) { int ret = 0; struct resource *ssbi_res; struct i2c_ssbi_dev *ssbi; struct msm_i2c_platform_data *pdata; pdata = pdev->dev.platform_data; if (!pdata) { ret = -ENXIO; dev_err(&pdev->dev, "platform data not initialized\n"); goto err_probe_exit; } ssbi = kzalloc(sizeof(struct i2c_ssbi_dev), GFP_KERNEL); if (!ssbi) { ret = -ENOMEM; dev_err(&pdev->dev, "allocation failed\n"); goto err_probe_exit; } ssbi_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ssbi_base"); if (!ssbi_res) { ret = -ENXIO; dev_err(&pdev->dev, "get_resource_byname failed\n"); goto err_probe_res; } ssbi->mem_phys_addr = ssbi_res->start; ssbi->mem_size = resource_size(ssbi_res);; if (!request_mem_region(ssbi->mem_phys_addr, ssbi->mem_size, SSBI_MSM_NAME)) { ret = -ENXIO; dev_err(&pdev->dev, "request_mem_region failed\n"); goto err_probe_reqmem; } ssbi->base = ioremap(ssbi->mem_phys_addr, ssbi->mem_size); if (!ssbi->base) { dev_err(&pdev->dev, "ioremap failed\n"); goto err_probe_ioremap; } ssbi->dev = &pdev->dev; platform_set_drvdata(pdev, ssbi); i2c_set_adapdata(&ssbi->adapter, ssbi); ssbi->adapter.algo = &msm_i2c_algo; strlcpy(ssbi->adapter.name, "MSM SSBI adapter", sizeof(ssbi->adapter.name)); ret = remote_spin_lock_init(&ssbi->rspin_lock, pdata->rsl_id); if (ret) { dev_err(&pdev->dev, "remote spinlock init failed\n"); goto err_remote_spinlock_init_failed; } ssbi->adapter.nr = pdev->id; ret = i2c_add_numbered_adapter(&ssbi->adapter); if (ret) { dev_err(&pdev->dev, "i2c_add_numbered_adapter failed\n"); goto err_add_adapter_failed; } return 0; err_add_adapter_failed: err_remote_spinlock_init_failed: iounmap(ssbi->base); platform_set_drvdata(pdev, NULL); err_probe_ioremap: release_mem_region(ssbi->mem_phys_addr, ssbi->mem_size); err_probe_reqmem: err_probe_res: kfree(ssbi); err_probe_exit: return ret; }
static int ns_pinctrl_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; const struct of_device_id *of_id; struct ns_pinctrl *ns_pinctrl; struct pinctrl_desc *pctldesc; struct pinctrl_pin_desc *pin; struct ns_pinctrl_group *group; struct ns_pinctrl_function *function; struct resource *res; int i; ns_pinctrl = devm_kzalloc(dev, sizeof(*ns_pinctrl), GFP_KERNEL); if (!ns_pinctrl) return -ENOMEM; pctldesc = &ns_pinctrl->pctldesc; platform_set_drvdata(pdev, ns_pinctrl); /* Set basic properties */ ns_pinctrl->dev = dev; of_id = of_match_device(ns_pinctrl_of_match_table, dev); if (!of_id) return -EINVAL; ns_pinctrl->chipset_flag = (uintptr_t)of_id->data; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cru_gpio_control"); ns_pinctrl->base = devm_ioremap_resource(dev, res); if (IS_ERR(ns_pinctrl->base)) { dev_err(dev, "Failed to map pinctrl regs\n"); return PTR_ERR(ns_pinctrl->base); } memcpy(pctldesc, &ns_pinctrl_desc, sizeof(*pctldesc)); /* Set pinctrl properties */ pctldesc->pins = devm_kcalloc(dev, ARRAY_SIZE(ns_pinctrl_pins), sizeof(struct pinctrl_pin_desc), GFP_KERNEL); if (!pctldesc->pins) return -ENOMEM; for (i = 0, pin = (struct pinctrl_pin_desc *)&pctldesc->pins[0]; i < ARRAY_SIZE(ns_pinctrl_pins); i++) { const struct pinctrl_pin_desc *src = &ns_pinctrl_pins[i]; unsigned int chipsets = (uintptr_t)src->drv_data; if (chipsets & ns_pinctrl->chipset_flag) { memcpy(pin++, src, sizeof(*src)); pctldesc->npins++; } } ns_pinctrl->groups = devm_kcalloc(dev, ARRAY_SIZE(ns_pinctrl_groups), sizeof(struct ns_pinctrl_group), GFP_KERNEL); if (!ns_pinctrl->groups) return -ENOMEM; for (i = 0, group = &ns_pinctrl->groups[0]; i < ARRAY_SIZE(ns_pinctrl_groups); i++) { const struct ns_pinctrl_group *src = &ns_pinctrl_groups[i]; if (src->chipsets & ns_pinctrl->chipset_flag) { memcpy(group++, src, sizeof(*src)); ns_pinctrl->num_groups++; } } ns_pinctrl->functions = devm_kcalloc(dev, ARRAY_SIZE(ns_pinctrl_functions), sizeof(struct ns_pinctrl_function), GFP_KERNEL); if (!ns_pinctrl->functions) return -ENOMEM; for (i = 0, function = &ns_pinctrl->functions[0]; i < ARRAY_SIZE(ns_pinctrl_functions); i++) { const struct ns_pinctrl_function *src = &ns_pinctrl_functions[i]; if (src->chipsets & ns_pinctrl->chipset_flag) { memcpy(function++, src, sizeof(*src)); ns_pinctrl->num_functions++; } } /* Register */ ns_pinctrl->pctldev = devm_pinctrl_register(dev, pctldesc, ns_pinctrl); if (IS_ERR(ns_pinctrl->pctldev)) { dev_err(dev, "Failed to register pinctrl\n"); return PTR_ERR(ns_pinctrl->pctldev); } return 0; }
static int pxau2h_ehci_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct resource *res; struct usb_hcd *hcd; int irq, retval, tmp; dev_dbg(&pdev->dev,"Initializing PXA EHCI-SOC USB Controller(U2H)\n"); info = dev->platform_data; pxau2h_ehci_clk_set(1); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "u2h"); info->regbase = (unsigned)ioremap_nocache(res->start, res_size(res)); if (!info->regbase) { printk(KERN_ERR "Cannot get regbase 0x%x\n", info->regbase); return -ENOMEM; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "u2hphy"); info->phybase = (unsigned)ioremap_nocache(res->start, res_size(res)); if (!info->phybase) { printk(KERN_ERR "Cannot get phybase 0x%x\n", info->phybase); retval = -ENODEV; goto err1; } irq = platform_get_irq(pdev, 0); if (!irq) { printk( KERN_ERR "Cannot get irq %x\n", irq); retval = -ENODEV; goto err1; } printk("u2h regbase 0x%x phybase 0x%x irq %d\n", info->regbase, info->phybase, irq); if (!info->phy_init || info->phy_init(info->phybase)) { printk(KERN_ERR "unable to init pxa usb 2.0 host controller" " phy_init 0x%p\n", info->phy_init); retval = -EBUSY; goto err1; } if (info->plat_init) { info->plat_init(dev); } if (!info->vbus_set || info->vbus_set(1)) { printk(KERN_ERR "Unable to power USB Host Controller.\n"); retval = -EBUSY; goto err1; } hcd = usb_create_hcd(&pxau2h_ehci_hc_driver, &pdev->dev, pdev->dev.bus_id); if (!hcd) { retval = -ENOMEM; goto err1; } hcd->rsrc_start = virt_to_phys((void *)info->regbase); hcd->rsrc_len = 0x1ff; hcd->regs = (void __iomem*)info->regbase; hcd->irq = (unsigned int)irq; /* @USBCMD, Reset USB core */ tmp = readl(hcd->regs + U2xUSBCMD); tmp |= U2xUSBCMD_RST; writel(tmp,hcd->regs + U2xUSBCMD); udelay(1000); retval = usb_add_hcd(hcd, hcd->irq, IRQF_DISABLED | IRQF_SHARED); if (retval != 0) { goto err2; } platform_set_drvdata(pdev, hcd); return retval; err2: usb_put_hcd(hcd); err1: dev_err(&pdev->dev, "init %s fail, %d\n", pdev->dev.bus_id, retval); return retval; }
/** * usbhs_omap_probe - initialize TI-based HCDs * * Allocates basic resources for this USB host controller. */ static int __devinit usbhs_omap_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct usbhs_omap_platform_data *pdata = dev->platform_data; struct usbhs_hcd_omap *omap; struct resource *res; int ret = 0; int i; if (!pdata) { dev_err(dev, "Missing platform data\n"); ret = -ENOMEM; goto end_probe; } omap = kzalloc(sizeof(*omap), GFP_KERNEL); if (!omap) { dev_err(dev, "Memory allocation failed\n"); ret = -ENOMEM; goto end_probe; } spin_lock_init(&omap->lock); for (i = 0; i < OMAP3_HS_USB_PORTS; i++) omap->platdata.port_mode[i] = pdata->port_mode[i]; omap->platdata.ehci_data = pdata->ehci_data; omap->platdata.ohci_data = pdata->ohci_data; pm_runtime_enable(&pdev->dev); omap->utmi_p1_fck = clk_get(dev, "utmi_p1_gfclk"); if (IS_ERR(omap->utmi_p1_fck)) { ret = PTR_ERR(omap->utmi_p1_fck); dev_err(dev, "utmi_p1_gfclk failed error:%d\n", ret); goto err_end; } omap->xclk60mhsp1_ck = clk_get(dev, "xclk60mhsp1_ck"); if (IS_ERR(omap->xclk60mhsp1_ck)) { ret = PTR_ERR(omap->xclk60mhsp1_ck); dev_err(dev, "xclk60mhsp1_ck failed error:%d\n", ret); goto err_utmi_p1_fck; } omap->utmi_p2_fck = clk_get(dev, "utmi_p2_gfclk"); if (IS_ERR(omap->utmi_p2_fck)) { ret = PTR_ERR(omap->utmi_p2_fck); dev_err(dev, "utmi_p2_gfclk failed error:%d\n", ret); goto err_xclk60mhsp1_ck; } omap->xclk60mhsp2_ck = clk_get(dev, "xclk60mhsp2_ck"); if (IS_ERR(omap->xclk60mhsp2_ck)) { ret = PTR_ERR(omap->xclk60mhsp2_ck); dev_err(dev, "xclk60mhsp2_ck failed error:%d\n", ret); goto err_utmi_p2_fck; } omap->usbhost_p1_fck = clk_get(dev, "usb_host_hs_utmi_p1_clk"); if (IS_ERR(omap->usbhost_p1_fck)) { ret = PTR_ERR(omap->usbhost_p1_fck); dev_err(dev, "usbhost_p1_fck failed error:%d\n", ret); goto err_xclk60mhsp2_ck; } omap->usbtll_p1_fck = clk_get(dev, "usb_tll_hs_usb_ch0_clk"); if (IS_ERR(omap->usbtll_p1_fck)) { ret = PTR_ERR(omap->usbtll_p1_fck); dev_err(dev, "usbtll_p1_fck failed error:%d\n", ret); goto err_usbhost_p1_fck; } omap->usbhost_p2_fck = clk_get(dev, "usb_host_hs_utmi_p2_clk"); if (IS_ERR(omap->usbhost_p2_fck)) { ret = PTR_ERR(omap->usbhost_p2_fck); dev_err(dev, "usbhost_p2_fck failed error:%d\n", ret); goto err_usbtll_p1_fck; } omap->usbtll_p2_fck = clk_get(dev, "usb_tll_hs_usb_ch1_clk"); if (IS_ERR(omap->usbtll_p2_fck)) { ret = PTR_ERR(omap->usbtll_p2_fck); dev_err(dev, "usbtll_p2_fck failed error:%d\n", ret); goto err_usbhost_p2_fck; } omap->init_60m_fclk = clk_get(dev, "init_60m_fclk"); if (IS_ERR(omap->init_60m_fclk)) { ret = PTR_ERR(omap->init_60m_fclk); dev_err(dev, "init_60m_fclk failed error:%d\n", ret); goto err_usbtll_p2_fck; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "uhh"); if (!res) { dev_err(dev, "UHH EHCI get resource failed\n"); ret = -ENODEV; goto err_init_60m_fclk; } omap->uhh_base = ioremap(res->start, resource_size(res)); if (!omap->uhh_base) { dev_err(dev, "UHH ioremap failed\n"); ret = -ENOMEM; goto err_init_60m_fclk; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tll"); if (!res) { dev_err(dev, "UHH EHCI get resource failed\n"); ret = -ENODEV; goto err_tll; } omap->tll_base = ioremap(res->start, resource_size(res)); if (!omap->tll_base) { dev_err(dev, "TLL ioremap failed\n"); ret = -ENOMEM; goto err_tll; } platform_set_drvdata(pdev, omap); ret = omap_usbhs_alloc_children(pdev); if (ret) { dev_err(dev, "omap_usbhs_alloc_children failed\n"); goto err_alloc; } goto end_probe; err_alloc: iounmap(omap->tll_base); err_tll: iounmap(omap->uhh_base); err_init_60m_fclk: clk_put(omap->init_60m_fclk); err_usbtll_p2_fck: clk_put(omap->usbtll_p2_fck); err_usbhost_p2_fck: clk_put(omap->usbhost_p2_fck); err_usbtll_p1_fck: clk_put(omap->usbtll_p1_fck); err_usbhost_p1_fck: clk_put(omap->usbhost_p1_fck); err_xclk60mhsp2_ck: clk_put(omap->xclk60mhsp2_ck); err_utmi_p2_fck: clk_put(omap->utmi_p2_fck); err_xclk60mhsp1_ck: clk_put(omap->xclk60mhsp1_ck); err_utmi_p1_fck: clk_put(omap->utmi_p1_fck); err_end: pm_runtime_disable(&pdev->dev); kfree(omap); end_probe: return ret; }
static int pda_power_probe(struct platform_device *pdev) { int ret = 0; dev = &pdev->dev; if (pdev->id != -1) { dev_err(dev, "it's meaningless to register several " "pda_powers; use id = -1\n"); ret = -EINVAL; goto wrongid; } pdata = pdev->dev.platform_data; if (pdata->init) { ret = pdata->init(dev); if (ret < 0) goto init_failed; } update_status(); update_charger(); if (!pdata->wait_for_status) pdata->wait_for_status = 500; if (!pdata->wait_for_charger) pdata->wait_for_charger = 500; if (!pdata->polling_interval) pdata->polling_interval = 2000; setup_timer(&charger_timer, charger_timer_func, 0); setup_timer(&supply_timer, supply_timer_func, 0); ac_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "ac"); usb_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "usb"); if (pdata->supplied_to) { pda_psy_ac.supplied_to = pdata->supplied_to; pda_psy_ac.num_supplicants = pdata->num_supplicants; pda_psy_usb.supplied_to = pdata->supplied_to; pda_psy_usb.num_supplicants = pdata->num_supplicants; } if (pdata->is_ac_online) { ret = power_supply_register(&pdev->dev, &pda_psy_ac); if (ret) { dev_err(dev, "failed to register %s power supply\n", pda_psy_ac.name); goto ac_supply_failed; } if (ac_irq) { ret = request_irq(ac_irq->start, power_changed_isr, get_irq_flags(ac_irq), ac_irq->name, &pda_psy_ac); if (ret) { dev_err(dev, "request ac irq failed\n"); goto ac_irq_failed; } } else { polling = 1; } } if (pdata->is_usb_online) { ret = power_supply_register(&pdev->dev, &pda_psy_usb); if (ret) { dev_err(dev, "failed to register %s power supply\n", pda_psy_usb.name); goto usb_supply_failed; } if (usb_irq) { ret = request_irq(usb_irq->start, power_changed_isr, get_irq_flags(usb_irq), usb_irq->name, &pda_psy_usb); if (ret) { dev_err(dev, "request usb irq failed\n"); goto usb_irq_failed; } } else { polling = 1; } } if (polling) { dev_dbg(dev, "will poll for status\n"); setup_timer(&polling_timer, polling_timer_func, 0); mod_timer(&polling_timer, jiffies + msecs_to_jiffies(pdata->polling_interval)); } if (ac_irq || usb_irq) device_init_wakeup(&pdev->dev, 1); return 0; usb_irq_failed: if (pdata->is_usb_online) power_supply_unregister(&pda_psy_usb); usb_supply_failed: if (pdata->is_ac_online && ac_irq) free_irq(ac_irq->start, &pda_psy_ac); ac_irq_failed: if (pdata->is_ac_online) power_supply_unregister(&pda_psy_ac); ac_supply_failed: if (pdata->exit) pdata->exit(dev); init_failed: wrongid: return ret; }
static int stih407_usb2_picophy_probe(struct platform_device *pdev) { struct stih407_usb2_picophy *phy_dev; struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct phy_provider *phy_provider; struct phy *phy; struct resource *res; phy_dev = devm_kzalloc(dev, sizeof(*phy_dev), GFP_KERNEL); if (!phy_dev) return -ENOMEM; phy_dev->dev = dev; dev_set_drvdata(dev, phy_dev); phy_dev->rstc = devm_reset_control_get(dev, "global"); if (IS_ERR(phy_dev->rstc)) { dev_err(dev, "failed to ctrl picoPHY reset\n"); return PTR_ERR(phy_dev->rstc); } phy_dev->rstport = devm_reset_control_get(dev, "port"); if (IS_ERR(phy_dev->rstport)) { dev_err(dev, "failed to ctrl picoPHY reset\n"); return PTR_ERR(phy_dev->rstport); } /* Reset port by default: only deassert it in phy init */ reset_control_assert(phy_dev->rstport); phy_dev->regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg"); if (IS_ERR(phy_dev->regmap)) { dev_err(dev, "No syscfg phandle specified\n"); return PTR_ERR(phy_dev->regmap); } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ctrl"); if (!res) { dev_err(dev, "No ctrl reg found\n"); return -ENXIO; } phy_dev->ctrl = res->start; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "param"); if (!res) { dev_err(dev, "No param reg found\n"); return -ENXIO; } phy_dev->param = res->start; phy = devm_phy_create(dev, NULL, &stih407_usb2_picophy_data, NULL); if (IS_ERR(phy)) { dev_err(dev, "failed to create Display Port PHY\n"); return PTR_ERR(phy); } phy_dev->phy = phy; phy_set_drvdata(phy, phy_dev); phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); if (IS_ERR(phy_provider)) return PTR_ERR(phy_provider); dev_info(dev, "STiH407 USB Generic picoPHY driver probed!"); return 0; }
static int ispif_probe(struct platform_device *pdev) { int rc; struct ispif_device *ispif; ispif = kzalloc(sizeof(struct ispif_device), GFP_KERNEL); if (!ispif) { pr_err("%s: no enough memory\n", __func__); return -ENOMEM; } v4l2_subdev_init(&ispif->msm_sd.sd, &msm_ispif_subdev_ops); ispif->msm_sd.sd.internal_ops = &msm_ispif_internal_ops; ispif->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; snprintf(ispif->msm_sd.sd.name, ARRAY_SIZE(ispif->msm_sd.sd.name), MSM_ISPIF_DRV_NAME); v4l2_set_subdevdata(&ispif->msm_sd.sd, ispif); platform_set_drvdata(pdev, &ispif->msm_sd.sd); mutex_init(&ispif->mutex); media_entity_init(&ispif->msm_sd.sd.entity, 0, NULL, 0); ispif->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV; ispif->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_ISPIF; ispif->msm_sd.sd.entity.name = pdev->name; ispif->msm_sd.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x1; rc = msm_sd_register(&ispif->msm_sd); if (rc) { pr_err("%s: msm_sd_register error = %d\n", __func__, rc); goto error_sd_register; } if (pdev->dev.of_node) { of_property_read_u32((&pdev->dev)->of_node, "cell-index", &pdev->id); rc = of_property_read_u32((&pdev->dev)->of_node, "qcom,num-isps", &ispif->hw_num_isps); if (rc) /* backward compatibility */ ispif->hw_num_isps = 1; /* not an error condition */ rc = 0; } ispif->mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ispif"); if (!ispif->mem) { pr_err("%s: no mem resource?\n", __func__); rc = -ENODEV; goto error; } ispif->irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "ispif"); if (!ispif->irq) { pr_err("%s: no irq resource?\n", __func__); rc = -ENODEV; goto error; } ispif->io = request_mem_region(ispif->mem->start, resource_size(ispif->mem), pdev->name); if (!ispif->io) { pr_err("%s: no valid mem region\n", __func__); rc = -EBUSY; goto error; } ispif->clk_mux_mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "csi_clk_mux"); if (ispif->clk_mux_mem) { ispif->clk_mux_io = request_mem_region( ispif->clk_mux_mem->start, resource_size(ispif->clk_mux_mem), ispif->clk_mux_mem->name); if (!ispif->clk_mux_io) pr_err("%s: no valid csi_mux region\n", __func__); } ispif->pdev = pdev; ispif->ispif_state = ISPIF_POWER_DOWN; ispif->open_cnt = 0; return 0; error: msm_sd_unregister(&ispif->msm_sd); error_sd_register: mutex_destroy(&ispif->mutex); kfree(ispif); return rc; }
static int serial_omap_probe(struct platform_device *pdev) { struct uart_omap_port *up = NULL; struct resource *mem, *irq, *dma_tx, *dma_rx; struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data; struct omap_device *od; int ret = -ENOSPC; mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } if (!request_mem_region(mem->start, (mem->end - mem->start) + 1, pdev->dev.driver->name)) { dev_err(&pdev->dev, "memory region already claimed\n"); return -EBUSY; } dma_rx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx"); if (!dma_rx) { ret = -EINVAL; goto do_release_region; } dma_tx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx"); if (!dma_tx) { ret = -EINVAL; goto do_release_region; } up = kzalloc(sizeof(*up), GFP_KERNEL); if (up == NULL) { ret = -ENOMEM; goto do_release_region; } sprintf(up->name, "OMAP UART%d", pdev->id); up->pdev = pdev; up->port.dev = &pdev->dev; up->port.type = PORT_OMAP; up->port.iotype = UPIO_MEM; up->port.irq = irq->start; up->port.regshift = 2; up->port.fifosize = 64; up->port.ops = &serial_omap_pops; up->port.line = pdev->id; up->port.mapbase = mem->start; up->port.membase = ioremap(mem->start, mem->end - mem->start); if (!up->port.membase) { dev_err(&pdev->dev, "can't ioremap UART\n"); ret = -ENOMEM; goto do_free; } up->port.flags = omap_up_info->flags; up->port.uartclk = omap_up_info->uartclk; up->uart_dma.uart_base = mem->start; up->errata = omap_up_info->errata; up->enable_wakeup = omap_up_info->enable_wakeup; up->wer = omap_up_info->wer; up->chk_wakeup = omap_up_info->chk_wakeup; up->wake_peer = omap_up_info->wake_peer; up->rts_mux_driver_control = omap_up_info->rts_mux_driver_control; up->rts_pullup_in_suspend = 0; if (omap_up_info->use_dma) { up->uart_dma.uart_dma_tx = dma_tx->start; up->uart_dma.uart_dma_rx = dma_rx->start; up->use_dma = 1; up->uart_dma.rx_buf_size = omap_up_info->dma_rx_buf_size; up->uart_dma.rx_timeout = omap_up_info->dma_rx_timeout; up->uart_dma.rx_poll_rate = omap_up_info->dma_rx_poll_rate; spin_lock_init(&(up->uart_dma.tx_lock)); spin_lock_init(&(up->uart_dma.rx_lock)); up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE; up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE; } pm_runtime_use_autosuspend(&pdev->dev); pm_runtime_set_autosuspend_delay(&pdev->dev, omap_up_info->auto_sus_timeout); if (device_may_wakeup(&pdev->dev)) pm_runtime_enable(&pdev->dev); pm_runtime_irq_safe(&pdev->dev); if (omap_up_info->console_uart) { od = to_omap_device(up->pdev); omap_hwmod_idle(od->hwmods[0]); serial_omap_port_enable(up); serial_omap_port_disable(up); } ui[pdev->id] = up; serial_omap_add_console_port(up); ret = request_irq(up->port.irq, serial_omap_irq, up->port.irqflags, up->name, up); if (ret) goto do_iounmap; disable_irq(up->port.irq); ret = uart_add_one_port(&serial_omap_reg, &up->port); if (ret != 0) goto do_free_irq; dev_set_drvdata(&pdev->dev, up); platform_set_drvdata(pdev, up); return 0; do_free_irq: free_irq(up->port.irq, up); do_iounmap: iounmap(up->port.membase); do_free: kfree(up); do_release_region: release_mem_region(mem->start, (mem->end - mem->start) + 1); dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", pdev->id, __func__, ret); return ret; }
static int vlynq_probe(struct platform_device *pdev) { struct vlynq_device *dev; struct resource *regs_res, *mem_res, *irq_res; int len, result; regs_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs"); if (!regs_res) return -ENODEV; mem_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mem"); if (!mem_res) return -ENODEV; irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "devirq"); if (!irq_res) return -ENODEV; dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { printk(KERN_ERR "vlynq: failed to allocate device structure\n"); return -ENOMEM; } dev->id = pdev->id; dev->dev.bus = &vlynq_bus_type; dev->dev.parent = &pdev->dev; dev_set_name(&dev->dev, "vlynq%d", dev->id); dev->dev.platform_data = pdev->dev.platform_data; dev->dev.release = vlynq_device_release; dev->regs_start = regs_res->start; dev->regs_end = regs_res->end; dev->mem_start = mem_res->start; dev->mem_end = mem_res->end; len = regs_res->end - regs_res->start; if (!request_mem_region(regs_res->start, len, dev_name(&dev->dev))) { printk(KERN_ERR "%s: Can't request vlynq registers\n", dev_name(&dev->dev)); result = -ENXIO; goto fail_request; } dev->local = ioremap(regs_res->start, len); if (!dev->local) { printk(KERN_ERR "%s: Can't remap vlynq registers\n", dev_name(&dev->dev)); result = -ENXIO; goto fail_remap; } dev->remote = (struct vlynq_regs *)((void *)dev->local + VLYNQ_REMOTE_OFFSET); dev->irq = platform_get_irq_byname(pdev, "irq"); dev->irq_start = irq_res->start; dev->irq_end = irq_res->end; dev->local_irq = dev->irq_end - dev->irq_start; dev->remote_irq = dev->local_irq - 1; if (device_register(&dev->dev)) goto fail_register; platform_set_drvdata(pdev, dev); printk(KERN_INFO "%s: regs 0x%p, irq %d, mem 0x%p\n", dev_name(&dev->dev), (void *)dev->regs_start, dev->irq, (void *)dev->mem_start); dev->dev_id = 0; dev->divisor = vlynq_div_auto; result = __vlynq_enable_device(dev); if (result == 0) { dev->dev_id = readl(&dev->remote->chip); ((struct plat_vlynq_ops *)(dev->dev.platform_data))->off(dev); } if (dev->dev_id) printk(KERN_INFO "Found a VLYNQ device: %08x\n", dev->dev_id); return 0; fail_register: iounmap(dev->local); fail_remap: fail_request: release_mem_region(regs_res->start, len); kfree(dev); return result; }
static int serial_omap_probe(struct platform_device *pdev) { struct uart_omap_port *up; struct resource *mem, *irq, *dma_tx, *dma_rx; struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data; int ret = -ENOSPC; if (pdev->dev.of_node) omap_up_info = of_get_uart_port_info(&pdev->dev); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } if (!devm_request_mem_region(&pdev->dev, mem->start, resource_size(mem), pdev->dev.driver->name)) { dev_err(&pdev->dev, "memory region already claimed\n"); return -EBUSY; } dma_rx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx"); if (!dma_rx) return -ENXIO; dma_tx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx"); if (!dma_tx) return -ENXIO; up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL); if (!up) return -ENOMEM; up->pdev = pdev; up->port.dev = &pdev->dev; up->port.type = PORT_OMAP; up->port.iotype = UPIO_MEM; up->port.irq = irq->start; up->port.regshift = 2; up->port.fifosize = 64; up->port.ops = &serial_omap_pops; if (pdev->dev.of_node) up->port.line = of_alias_get_id(pdev->dev.of_node, "serial"); else up->port.line = pdev->id; if (up->port.line < 0) { dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n", up->port.line); ret = -ENODEV; goto err_port_line; } sprintf(up->name, "OMAP UART%d", up->port.line); up->port.mapbase = mem->start; up->port.membase = devm_ioremap(&pdev->dev, mem->start, resource_size(mem)); if (!up->port.membase) { dev_err(&pdev->dev, "can't ioremap UART\n"); ret = -ENOMEM; goto err_ioremap; } up->port.flags = omap_up_info->flags; up->port.uartclk = omap_up_info->uartclk; if (!up->port.uartclk) { up->port.uartclk = DEFAULT_CLK_SPEED; dev_warn(&pdev->dev, "No clock speed specified: using default:" "%d\n", DEFAULT_CLK_SPEED); } up->uart_dma.uart_base = mem->start; up->errata = omap_up_info->errata; if (omap_up_info->dma_enabled) { up->uart_dma.uart_dma_tx = dma_tx->start; up->uart_dma.uart_dma_rx = dma_rx->start; up->use_dma = 1; up->uart_dma.rx_buf_size = omap_up_info->dma_rx_buf_size; up->uart_dma.rx_timeout = omap_up_info->dma_rx_timeout; up->uart_dma.rx_poll_rate = omap_up_info->dma_rx_poll_rate; spin_lock_init(&(up->uart_dma.tx_lock)); spin_lock_init(&(up->uart_dma.rx_lock)); up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE; up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE; } up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; pm_qos_add_request(&up->pm_qos_request, PM_QOS_CPU_DMA_LATENCY, up->latency); serial_omap_uart_wq = create_singlethread_workqueue(up->name); INIT_WORK(&up->qos_work, serial_omap_uart_qos_work); pm_runtime_use_autosuspend(&pdev->dev); pm_runtime_set_autosuspend_delay(&pdev->dev, omap_up_info->autosuspend_timeout); pm_runtime_irq_safe(&pdev->dev); pm_runtime_enable(&pdev->dev); pm_runtime_get_sync(&pdev->dev); ui[up->port.line] = up; serial_omap_add_console_port(up); ret = uart_add_one_port(&serial_omap_reg, &up->port); if (ret != 0) goto err_add_port; pm_runtime_put(&pdev->dev); platform_set_drvdata(pdev, up); return 0; err_add_port: pm_runtime_put(&pdev->dev); pm_runtime_disable(&pdev->dev); err_ioremap: err_port_line: dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", pdev->id, __func__, ret); return ret; }
static int mv_ehci_probe(struct platform_device *pdev) { struct mv_usb_platform_data *pdata = pdev->dev.platform_data; struct usb_hcd *hcd; struct ehci_hcd *ehci; struct ehci_hcd_mv *ehci_mv; struct resource *r; int clk_i, retval = -ENODEV; u32 offset; size_t size; if (!pdata) { dev_err(&pdev->dev, "missing platform_data\n"); return -ENODEV; } if (usb_disabled()) return -ENODEV; hcd = usb_create_hcd(&mv_ehci_hc_driver, &pdev->dev, "mv ehci"); if (!hcd) return -ENOMEM; size = sizeof(*ehci_mv) + sizeof(struct clk *) * pdata->clknum; ehci_mv = kzalloc(size, GFP_KERNEL); if (ehci_mv == NULL) { dev_err(&pdev->dev, "cannot allocate ehci_hcd_mv\n"); retval = -ENOMEM; goto err_put_hcd; } platform_set_drvdata(pdev, ehci_mv); ehci_mv->pdata = pdata; ehci_mv->hcd = hcd; ehci_mv->clknum = pdata->clknum; for (clk_i = 0; clk_i < ehci_mv->clknum; clk_i++) { ehci_mv->clk[clk_i] = clk_get(&pdev->dev, pdata->clkname[clk_i]); if (IS_ERR(ehci_mv->clk[clk_i])) { dev_err(&pdev->dev, "error get clck \"%s\"\n", pdata->clkname[clk_i]); retval = PTR_ERR(ehci_mv->clk[clk_i]); goto err_put_clk; } } r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phyregs"); if (r == NULL) { dev_err(&pdev->dev, "no phy I/O memory resource defined\n"); retval = -ENODEV; goto err_put_clk; } ehci_mv->phy_regs = ioremap(r->start, resource_size(r)); if (ehci_mv->phy_regs == 0) { dev_err(&pdev->dev, "failed to map phy I/O memory\n"); retval = -EFAULT; goto err_put_clk; } r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "capregs"); if (!r) { dev_err(&pdev->dev, "no I/O memory resource defined\n"); retval = -ENODEV; goto err_iounmap_phyreg; } ehci_mv->cap_regs = ioremap(r->start, resource_size(r)); if (ehci_mv->cap_regs == NULL) { dev_err(&pdev->dev, "failed to map I/O memory\n"); retval = -EFAULT; goto err_iounmap_phyreg; } retval = mv_ehci_enable(ehci_mv); if (retval) { dev_err(&pdev->dev, "init phy error %d\n", retval); goto err_iounmap_capreg; } offset = readl(ehci_mv->cap_regs) & CAPLENGTH_MASK; ehci_mv->op_regs = (void __iomem *) ((unsigned long) ehci_mv->cap_regs + offset); hcd->rsrc_start = r->start; hcd->rsrc_len = r->end - r->start + 1; hcd->regs = ehci_mv->op_regs; hcd->irq = platform_get_irq(pdev, 0); if (!hcd->irq) { dev_err(&pdev->dev, "Cannot get irq."); retval = -ENODEV; goto err_disable_clk; } ehci = hcd_to_ehci(hcd); ehci->caps = (struct ehci_caps *) ehci_mv->cap_regs; ehci->regs = (struct ehci_regs *) ehci_mv->op_regs; ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params); ehci_mv->mode = pdata->mode; if (ehci_mv->mode == MV_USB_MODE_OTG) { #ifdef CONFIG_USB_OTG_UTILS ehci_mv->otg = usb_get_transceiver(); if (!ehci_mv->otg) { dev_err(&pdev->dev, "unable to find transceiver\n"); retval = -ENODEV; goto err_disable_clk; } retval = otg_set_host(ehci_mv->otg->otg, &hcd->self); if (retval < 0) { dev_err(&pdev->dev, "unable to register with transceiver\n"); retval = -ENODEV; goto err_put_transceiver; } /* */ mv_ehci_disable(ehci_mv); #else dev_info(&pdev->dev, "MV_USB_MODE_OTG " "must have CONFIG_USB_OTG_UTILS enabled\n"); goto err_disable_clk; #endif } else { if (pdata->set_vbus) pdata->set_vbus(1); retval = usb_add_hcd(hcd, hcd->irq, IRQF_SHARED); if (retval) { dev_err(&pdev->dev, "failed to add hcd with err %d\n", retval); goto err_set_vbus; } } if (pdata->private_init) pdata->private_init(ehci_mv->op_regs, ehci_mv->phy_regs); dev_info(&pdev->dev, "successful find EHCI device with regs 0x%p irq %d" " working in %s mode\n", hcd->regs, hcd->irq, ehci_mv->mode == MV_USB_MODE_OTG ? "OTG" : "Host"); return 0; err_set_vbus: if (pdata->set_vbus) pdata->set_vbus(0); #ifdef CONFIG_USB_OTG_UTILS err_put_transceiver: if (ehci_mv->otg) usb_put_transceiver(ehci_mv->otg); #endif err_disable_clk: mv_ehci_disable(ehci_mv); err_iounmap_capreg: iounmap(ehci_mv->cap_regs); err_iounmap_phyreg: iounmap(ehci_mv->phy_regs); err_put_clk: for (clk_i--; clk_i >= 0; clk_i--) clk_put(ehci_mv->clk[clk_i]); platform_set_drvdata(pdev, NULL); kfree(ehci_mv); err_put_hcd: usb_put_hcd(hcd); return retval; }
static int __init_or_module headset_probe(struct platform_device *pdev) { int ret; struct resource *res; unsigned int irq; memset(&headset_data, 0, sizeof( headset_data)); headset_data.sdev.name = pdev->name; headset_data.sdev.print_name = switch_hds_print_state; ret = switch_dev_register(&headset_data.sdev); if (ret < 0) { goto err_switch_dev_register; } headset_data.debounceDelay1 = 300; headset_data.debounceDelay2 = 600; headset_data.debounceDelayHookKey = 65; headset_data.jack_status = 0; headset_data.recover_chk_times = RECOVER_CHK_HEADSET_TYPE_TIMES; g_headset_type = HSD_NONE; atomic_set(&headset_data.is_button_press, 0); printk(KERN_INFO "Init headset wake lock\n"); wake_lock_init(&headset_data.headset_det_wakelock, WAKE_LOCK_SUSPEND, "headset_det"); g_detection_work_queue = create_workqueue("headset_detection"); if (g_detection_work_queue == NULL) { ret = -ENOMEM; goto err_create_work_queue; } res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "hook_int"); if (!res) { HEADSET_ERR("couldn't find hook int\n"); ret = -ENODEV; goto err_get_hook_gpio_resource; } headset_data.hook_gpio = res->start; ret = gpio_request(headset_data.hook_gpio, "headset_hook"); if (ret < 0) goto err_request_hook_gpio; ret = gpio_direction_input(headset_data.hook_gpio); if (ret < 0) goto err_set_hook_gpio; irq = MSM_GPIO_TO_INT(headset_data.hook_gpio); if (irq <0) { ret = irq; goto err_get_hook_detect_irq_num_failed; } headset_data.hook_irq = irq; set_irq_flags(headset_data.hook_irq, IRQF_VALID | IRQF_NOAUTOEN); ret = request_irq(headset_data.hook_irq, hook_irqhandler, IRQF_TRIGGER_NONE, "headset_hook", &headset_data); if( ret < 0) { HEADSET_ERR("Fail to request hook irq"); goto err_request_austin_headset_hook_irq; } res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "jack_int"); if (!res) { HEADSET_ERR("couldn't find jack int\n"); ret = -ENODEV; goto err_get_jack_int_resource; } headset_data.jack_gpio = res->start; ret = gpio_request(headset_data.jack_gpio, "headset_jack"); if (ret < 0) goto err_request_jack_gpio; ret = gpio_direction_input(headset_data.jack_gpio); if (ret < 0) goto err_set_jack_gpio; irq = MSM_GPIO_TO_INT(headset_data.jack_gpio); if (irq <0) { ret = irq; goto err_get_jack_detect_irq_num_failed; } headset_data.jack_irq = irq; headset_data.jack_irq_status = HSD_IRQ_ENABLE; ret = request_irq(headset_data.jack_irq, jack_irqhandler, IRQF_TRIGGER_LOW, "headset_jack", &headset_data); if (ret < 0) { HEADSET_ERR("Fail to request jack irq"); goto err_request_austin_headset_jack_irq; } ret = set_irq_wake(headset_data.jack_irq, 1); if (ret < 0) goto err_request_input_dev; headset_data.input = input_allocate_device(); if (!headset_data.input) { ret = -ENOMEM; goto err_request_input_dev; } headset_data.input->name = "Austin headset"; headset_data.input->evbit[0] = BIT_MASK(EV_KEY); set_bit(KEY_MEDIA, headset_data.input->keybit); ret = input_register_device(headset_data.input); if (ret < 0) { HEADSET_ERR("Fail to register input device"); goto err_register_input_dev; } gpio_set_value(AUDIO_HEADSET_MIC_SHTDWN_N, 1); PM_LOG_EVENT(PM_LOG_OFF, PM_LOG_AUTIO_MIC); return 0; err_register_input_dev: input_free_device(headset_data.input); err_request_input_dev: free_irq(headset_data.jack_irq, 0); err_request_austin_headset_jack_irq: err_get_jack_detect_irq_num_failed: err_set_jack_gpio: gpio_free(headset_data.jack_gpio); err_request_jack_gpio: err_get_jack_int_resource: free_irq(headset_data.hook_irq, 0); err_request_austin_headset_hook_irq: err_get_hook_detect_irq_num_failed: err_set_hook_gpio: gpio_free(headset_data.hook_gpio); err_request_hook_gpio: err_get_hook_gpio_resource: destroy_workqueue(g_detection_work_queue); err_create_work_queue: switch_dev_unregister(&headset_data.sdev); err_switch_dev_register: HEADSET_ERR(" Failed to register driver"); return ret; }
int smmu_driver_probe(struct platform_device *pdev) { static void __iomem *regs_base; struct resource *r; struct smmu_device *smmu_dev = pdev->dev.platform_data; struct clk *smmu_clk = NULL; int irq = 0; int ret; int ncb, nm2v; struct smmu_driver *drv = NULL; resource_size_t len; if (pdev->id != -1) { if (!smmu_dev) { pr_err("smmu device lacks platform data\n"); goto fail_nodev; } if (smmu_dev->clk) { smmu_clk = clk_get(NULL, smmu_dev->clk); if (!smmu_clk) { pr_err("clock defined but not present\n"); goto fail_nodev; } if (smmu_dev->clk_rate != 0) clk_set_rate(smmu_clk, smmu_dev->clk_rate); clk_enable(smmu_clk); clk_put(smmu_clk); } drv = kzalloc(sizeof(struct smmu_driver), GFP_KERNEL); if (!drv) { pr_err("could not allocate memory\n"); goto fail_nomem; } r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "physbase"); if (!r) { pr_err("could not get resources\n"); goto fail_nodev; } len = r->end - r->start + 1; r = request_mem_region(r->start, len, r->name); if (!r) { pr_err("could not request memory region: " "start=%p, len=%d\n", (void *) r->start, len); goto fail_busy; } regs_base = ioremap(r->start, len); if (!regs_base) { pr_err("could not ioremap: start=%p, len=%d\n", (void *) r->start, len); goto fail_busy; } irq = platform_get_irq_byname(pdev, "secure_irq"); if (irq < 0) { pr_err("could not retrieve irq\n"); goto fail_nodev; } mb(); if (GET_IDR((unsigned long) regs_base) == 0) { pr_err("IDR reads as 0\n"); goto fail_nodev; } ret = smmu_drvdata_init(drv, (unsigned long) regs_base, irq); if (ret != 0) { pr_err("could not init drvdata: error %d\n", ret); goto fail_nodev; } nm2v = GET_NM2VCBMT((unsigned long) regs_base); ncb = GET_NCB((unsigned long) regs_base); printk(KERN_INFO "Registered driver for %s at %lx, " "irq %d (%d cb, %d m2v) \n", pdev->name, (unsigned long) regs_base, irq, ncb+1, nm2v+1); platform_set_drvdata(pdev, drv); } else { printk(KERN_INFO "Registered SMMU root device.\n"); ret = vcm_setup_tex_classes(); if (ret != 0) { pr_err("vcm_setup_tex_classes: returned %d\n", ret); goto fail_nodev; } all_smmus = pdev; } return 0; fail_busy: kfree(drv); return -EBUSY; fail_nodev: kfree(drv); return -ENODEV; fail_nomem: return -ENOMEM; }
static int __devinit pm8058_othc_probe(struct platform_device *pd) { int rc; struct pm8058_othc *dd; struct pm8058_chip *chip; struct resource *res; struct pmic8058_othc_config_pdata *pdata = pd->dev.platform_data; chip = platform_get_drvdata(pd); if (chip == NULL) { pr_err("%s: Invalid driver information \n", __func__); return -EINVAL; } /* Check PMIC8058 version. A0 version is not supported */ if (pm8058_rev(chip) == PM_8058_REV_1p0) { pr_err("%s: PMIC8058 version not supported \n", __func__); return -ENODEV; } if (pdata == NULL) { pr_err("%s: Platform data not present \n", __func__); return -EINVAL; } dd = kzalloc(sizeof(*dd), GFP_KERNEL); if (dd == NULL) { pr_err("%s: Unable to allocate memory \n", __func__); return -ENOMEM; } /* Enable runtime PM ops, start in ACTIVE mode */ rc = pm_runtime_set_active(&pd->dev); if (rc < 0) dev_dbg(&pd->dev, "unable to set runtime pm state\n"); pm_runtime_enable(&pd->dev); res = platform_get_resource_byname(pd, IORESOURCE_IO, "othc_base"); if (res == NULL) { pr_err("%s: othc resource:Base address absent \n", __func__); rc = -ENXIO; goto fail_get_res; } dd->othc_pdata = pdata; dd->pm_chip = chip; dd->othc_base = res->start; if (pdata->micbias_capability == OTHC_MICBIAS_HSED) { /* HSED to be supported on this MICBIAS line */ if (pdata->hsed_config != NULL) { rc = othc_configure_hsed(dd, pd); if (rc < 0) goto fail_get_res; } else { pr_err("%s: HSED config data not present\n", __func__); rc = -EINVAL; goto fail_get_res; } } /* Store the local driver data structure */ if (dd->othc_pdata->micbias_select < OTHC_MICBIAS_MAX) config[dd->othc_pdata->micbias_select] = dd; platform_set_drvdata(pd, dd); pr_debug("%s: Device %s:%d successfully registered\n", __func__, pd->name, pd->id); return 0; fail_get_res: pm_runtime_set_suspended(&pd->dev); pm_runtime_disable(&pd->dev); kfree(dd); return rc; }
static int omap_usbhs_alloc_children(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct usbhs_hcd_omap *omap; struct ehci_hcd_omap_platform_data *ehci_data; struct ohci_hcd_omap_platform_data *ohci_data; struct platform_device *ehci; struct platform_device *ohci; struct resource *res; struct resource resources[2]; int ret; omap = platform_get_drvdata(pdev); ehci_data = omap->platdata.ehci_data; ohci_data = omap->platdata.ohci_data; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ehci"); if (!res) { dev_err(dev, "EHCI get resource IORESOURCE_MEM failed\n"); ret = -ENODEV; goto err_end; } resources[0] = *res; res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "ehci-irq"); if (!res) { dev_err(dev, " EHCI get resource IORESOURCE_IRQ failed\n"); ret = -ENODEV; goto err_end; } resources[1] = *res; ehci = omap_usbhs_alloc_child(OMAP_EHCI_DEVICE, resources, 2, ehci_data, sizeof(*ehci_data), dev); if (!ehci) { dev_err(dev, "omap_usbhs_alloc_child failed\n"); ret = -ENOMEM; goto err_end; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ohci"); if (!res) { dev_err(dev, "OHCI get resource IORESOURCE_MEM failed\n"); ret = -ENODEV; goto err_ehci; } resources[0] = *res; res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "ohci-irq"); if (!res) { dev_err(dev, "OHCI get resource IORESOURCE_IRQ failed\n"); ret = -ENODEV; goto err_ehci; } resources[1] = *res; ohci = omap_usbhs_alloc_child(OMAP_OHCI_DEVICE, resources, 2, ohci_data, sizeof(*ohci_data), dev); if (!ohci) { dev_err(dev, "omap_usbhs_alloc_child failed\n"); ret = -ENOMEM; goto err_ehci; } return 0; err_ehci: platform_device_unregister(ehci); err_end: return ret; }
static int __devinit msm_ts_probe(struct platform_device *pdev) { struct msm_ts_platform_data *pdata = pdev->dev.platform_data; struct msm_ts *ts; struct resource *tssc_res; struct resource *irq1_res; struct resource *irq2_res; int err = 0; /*int i;*/ /*struct marimba_tsadc_client *ts_client;*/ tssc_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tssc"); irq1_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "tssc1"); irq2_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "tssc2"); if (!tssc_res || !irq1_res || !irq2_res) { pr_err("%s: required resources not defined\n", __func__); return -ENODEV; } if (pdata == NULL) { pr_err("%s: missing platform_data\n", __func__); return -ENODEV; } ts = kzalloc(sizeof(struct msm_ts), GFP_KERNEL); if (ts == NULL) { pr_err("%s: No memory for struct msm_ts\n", __func__); return -ENOMEM; } ts->pdata = pdata; ts->dev = &pdev->dev; ts->sample_irq = irq1_res->start; ts->pen_up_irq = irq2_res->start; ts->tssc_base = ioremap(tssc_res->start, resource_size(tssc_res)); if (ts->tssc_base == NULL) { pr_err("%s: Can't ioremap region (0x%08x - 0x%08x)\n", __func__, (uint32_t)tssc_res->start, (uint32_t)tssc_res->end); err = -ENOMEM; goto err_ioremap_tssc; } #if 0 ts_client = marimba_tsadc_register(pdev, 1); if (IS_ERR(ts_client)) { pr_err("%s: Unable to register with TSADC\n", __func__); err = -ENOMEM; goto err_tsadc_register; } ts->ts_client = ts_client; err = marimba_tsadc_start(ts_client); if (err) { pr_err("%s: Unable to start TSADC\n", __func__); err = -EINVAL; goto err_start_tsadc; } #endif ts->input_dev = input_allocate_device(); if (ts->input_dev == NULL) { pr_err("failed to allocate touchscreen input device\n"); err = -ENOMEM; goto err_alloc_input_dev; } ts->input_dev->name = "msm-touchscreen"; ts->input_dev->dev.parent = &pdev->dev; input_set_drvdata(ts->input_dev, ts); input_set_capability(ts->input_dev, EV_KEY, BTN_TOUCH); set_bit(EV_ABS, ts->input_dev->evbit); input_set_abs_params(ts->input_dev, ABS_X, pdata->min_x, pdata->max_x, 0, 0); input_set_abs_params(ts->input_dev, ABS_Y, pdata->min_y, pdata->max_y, 0, 0); input_set_abs_params(ts->input_dev, ABS_PRESSURE, pdata->min_press, pdata->max_press, 0, 0); /* for (i = 0; pdata->vkeys_x && (i < pdata->vkeys_x->num_keys); ++i) input_set_capability(ts->input_dev, EV_KEY, pdata->vkeys_x->keys[i].key); for (i = 0; pdata->vkeys_y && (i < pdata->vkeys_y->num_keys); ++i) input_set_capability(ts->input_dev, EV_KEY, pdata->vkeys_y->keys[i].key); */ err = input_register_device(ts->input_dev); if (err != 0) { pr_err("%s: failed to register input device\n", __func__); goto err_input_dev_reg; } setup_timer(&ts->timer, ts_timer, (unsigned long)ts); msm_ts_hw_init(ts); err = request_irq(ts->sample_irq, msm_ts_irq, (irq1_res->flags & ~IORESOURCE_IRQ) | IRQF_DISABLED, "msm_touchscreen", ts); if (err != 0) { pr_err("%s: Cannot register irq1 (%d)\n", __func__, err); goto err_request_irq1; } err = request_irq(ts->pen_up_irq, msm_ts_irq, (irq2_res->flags & ~IORESOURCE_IRQ) | IRQF_DISABLED, "msm_touchscreen", ts); if (err != 0) { pr_err("%s: Cannot register irq2 (%d)\n", __func__, err); goto err_request_irq2; } platform_set_drvdata(pdev, ts); #ifdef CONFIG_HAS_EARLYSUSPEND ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + TSSC_SUSPEND_LEVEL; ts->early_suspend.suspend = msm_ts_early_suspend; ts->early_suspend.resume = msm_ts_late_resume; register_early_suspend(&ts->early_suspend); #endif pr_info("%s: tssc_base=%p irq1=%d irq2=%d\n", __func__, ts->tssc_base, (int)ts->sample_irq, (int)ts->pen_up_irq); //xiayc #if defined(CONFIG_TOUCHSCREEN_VIRTUAL_KEYS) ts_key_report_init(); #endif // dump_tssc_regs(ts); return 0; err_request_irq2: free_irq(ts->sample_irq, ts); err_request_irq1: /* disable the tssc */ tssc_writel(ts, TSSC_CTL_ENABLE, TSSC_CTL); err_input_dev_reg: input_set_drvdata(ts->input_dev, NULL); input_free_device(ts->input_dev); err_alloc_input_dev: #if 0 err_start_tsadc: marimba_tsadc_unregister(ts->ts_client); err_tsadc_register: #endif iounmap(ts->tssc_base); err_ioremap_tssc: kfree(ts); return err; }
/* construct hdmi at bind/probe time, grab all the resources. If * we are to EPROBE_DEFER we want to do it here, rather than later * at modeset_init() time */ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) { struct hdmi_platform_config *config = pdev->dev.platform_data; struct hdmi *hdmi = NULL; struct resource *res; int i, ret; hdmi = devm_kzalloc(&pdev->dev, sizeof(*hdmi), GFP_KERNEL); if (!hdmi) { ret = -ENOMEM; goto fail; } hdmi->pdev = pdev; hdmi->config = config; spin_lock_init(&hdmi->reg_lock); hdmi->mmio = msm_ioremap(pdev, config->mmio_name, "HDMI"); if (IS_ERR(hdmi->mmio)) { ret = PTR_ERR(hdmi->mmio); goto fail; } /* HDCP needs physical address of hdmi register */ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, config->mmio_name); hdmi->mmio_phy_addr = res->start; hdmi->qfprom_mmio = msm_ioremap(pdev, config->qfprom_mmio_name, "HDMI_QFPROM"); if (IS_ERR(hdmi->qfprom_mmio)) { dev_info(&pdev->dev, "can't find qfprom resource\n"); hdmi->qfprom_mmio = NULL; } hdmi->hpd_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_regs[0]) * config->hpd_reg_cnt, GFP_KERNEL); if (!hdmi->hpd_regs) { ret = -ENOMEM; goto fail; } for (i = 0; i < config->hpd_reg_cnt; i++) { struct regulator *reg; reg = devm_regulator_get(&pdev->dev, config->hpd_reg_names[i]); if (IS_ERR(reg)) { ret = PTR_ERR(reg); dev_err(&pdev->dev, "failed to get hpd regulator: %s (%d)\n", config->hpd_reg_names[i], ret); goto fail; } hdmi->hpd_regs[i] = reg; } hdmi->pwr_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_regs[0]) * config->pwr_reg_cnt, GFP_KERNEL); if (!hdmi->pwr_regs) { ret = -ENOMEM; goto fail; } for (i = 0; i < config->pwr_reg_cnt; i++) { struct regulator *reg; reg = devm_regulator_get(&pdev->dev, config->pwr_reg_names[i]); if (IS_ERR(reg)) { ret = PTR_ERR(reg); dev_err(&pdev->dev, "failed to get pwr regulator: %s (%d)\n", config->pwr_reg_names[i], ret); goto fail; } hdmi->pwr_regs[i] = reg; } hdmi->hpd_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_clks[0]) * config->hpd_clk_cnt, GFP_KERNEL); if (!hdmi->hpd_clks) { ret = -ENOMEM; goto fail; } for (i = 0; i < config->hpd_clk_cnt; i++) { struct clk *clk; clk = msm_clk_get(pdev, config->hpd_clk_names[i]); if (IS_ERR(clk)) { ret = PTR_ERR(clk); dev_err(&pdev->dev, "failed to get hpd clk: %s (%d)\n", config->hpd_clk_names[i], ret); goto fail; } hdmi->hpd_clks[i] = clk; } hdmi->pwr_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_clks[0]) * config->pwr_clk_cnt, GFP_KERNEL); if (!hdmi->pwr_clks) { ret = -ENOMEM; goto fail; } for (i = 0; i < config->pwr_clk_cnt; i++) { struct clk *clk; clk = msm_clk_get(pdev, config->pwr_clk_names[i]); if (IS_ERR(clk)) { ret = PTR_ERR(clk); dev_err(&pdev->dev, "failed to get pwr clk: %s (%d)\n", config->pwr_clk_names[i], ret); goto fail; } hdmi->pwr_clks[i] = clk; } pm_runtime_enable(&pdev->dev); hdmi->workq = alloc_ordered_workqueue("msm_hdmi", 0); hdmi->i2c = msm_hdmi_i2c_init(hdmi); if (IS_ERR(hdmi->i2c)) { ret = PTR_ERR(hdmi->i2c); dev_err(&pdev->dev, "failed to get i2c: %d\n", ret); hdmi->i2c = NULL; goto fail; } ret = msm_hdmi_get_phy(hdmi); if (ret) { dev_err(&pdev->dev, "failed to get phy\n"); goto fail; } hdmi->hdcp_ctrl = msm_hdmi_hdcp_init(hdmi); if (IS_ERR(hdmi->hdcp_ctrl)) { dev_warn(&pdev->dev, "failed to init hdcp: disabled\n"); hdmi->hdcp_ctrl = NULL; } return hdmi; fail: if (hdmi) msm_hdmi_destroy(hdmi); return ERR_PTR(ret); }
static int __devinit mxr_acquire_plat_resources(struct mxr_device *mdev, struct platform_device *pdev) { struct resource *res; int ret; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mxr"); if (res == NULL) { mxr_err(mdev, "get memory resource failed.\n"); ret = -ENXIO; goto fail; } mdev->res.mxr_regs = ioremap(res->start, resource_size(res)); if (mdev->res.mxr_regs == NULL) { mxr_err(mdev, "register mapping failed.\n"); ret = -ENXIO; goto fail; } #if defined(CONFIG_ARCH_EXYNOS4) res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vp"); if (res == NULL) { mxr_err(mdev, "get memory resource failed.\n"); ret = -ENXIO; goto fail_mxr_regs; } mdev->res.vp_regs = ioremap(res->start, resource_size(res)); if (mdev->res.vp_regs == NULL) { mxr_err(mdev, "register mapping failed.\n"); ret = -ENXIO; goto fail_mxr_regs; } #endif res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "irq"); if (res == NULL) { mxr_err(mdev, "get interrupt resource failed.\n"); ret = -ENXIO; goto fail_vp_regs; } ret = request_irq(res->start, mxr_irq_handler, 0, "s5p-mixer", mdev); if (ret) { mxr_err(mdev, "request interrupt failed.\n"); goto fail_vp_regs; } mdev->res.irq = res->start; return 0; fail_vp_regs: #if defined(CONFIG_ARCH_EXYNOS4) iounmap(mdev->res.vp_regs); fail_mxr_regs: #endif iounmap(mdev->res.mxr_regs); fail: return ret; }
static int exynos5433_decon_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct decon_context *ctx; struct resource *res; int ret; int i; ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; ctx->default_win = 0; ctx->suspended = true; ctx->dev = dev; if (of_get_child_by_name(dev->of_node, "i80-if-timings")) ctx->i80_if = true; for (i = 0; i < ARRAY_SIZE(decon_clks_name); i++) { struct clk *clk; clk = devm_clk_get(ctx->dev, decon_clks_name[i]); if (IS_ERR(clk)) return PTR_ERR(clk); ctx->clks[i] = clk; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(dev, "cannot find IO resource\n"); return -ENXIO; } ctx->addr = devm_ioremap_resource(dev, res); if (IS_ERR(ctx->addr)) { dev_err(dev, "ioremap failed\n"); return PTR_ERR(ctx->addr); } res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, ctx->i80_if ? "lcd_sys" : "vsync"); if (!res) { dev_err(dev, "cannot find IRQ resource\n"); return -ENXIO; } ret = devm_request_irq(dev, res->start, ctx->i80_if ? decon_lcd_sys_irq_handler : decon_vsync_irq_handler, 0, "drm_decon", ctx); if (ret < 0) { dev_err(dev, "lcd_sys irq request failed\n"); return ret; } platform_set_drvdata(pdev, ctx); pm_runtime_enable(dev); ret = component_add(dev, &decon_component_ops); if (ret) goto err_disable_pm_runtime; return 0; err_disable_pm_runtime: pm_runtime_disable(dev); return ret; }
static int smc_dev_init(smc_dev_t *smc, int id) { struct resource *res; char buf[32]; struct devio_aml_platform_data *pd_smc; smc->id = id; smc->reset_pin = smc0_reset; if(smc->reset_pin==-1) { snprintf(buf, sizeof(buf), "smc%d_reset", id); res = platform_get_resource_byname(smc->pdev, IORESOURCE_MEM, buf); if (!res) { pr_error("cannot get resource \"%s\"\n", buf); } else { smc->reset_pin = res->start; } } smc->irq_num = smc0_irq; if(smc->irq_num==-1) { snprintf(buf, sizeof(buf), "smc%d_irq", id); res = platform_get_resource_byname(smc->pdev, IORESOURCE_IRQ, buf); if (!res) { pr_error("cannot get resource \"%s\"\n", buf); return -1; } smc->irq_num = res->start; } init_waitqueue_head(&smc->rd_wq); init_waitqueue_head(&smc->wr_wq); spin_lock_init(&smc->slock); mutex_init(&smc->lock); pd_smc = (struct devio_aml_platform_data*)smc->pdev->dev.platform_data; if(pd_smc) { if(pd_smc->io_setup) pd_smc->io_setup(NULL); smc->reset = pd_smc->io_reset; } smc->irq_num=request_irq(smc->irq_num,(irq_handler_t)smc_irq_handler,IRQF_SHARED,"smc",smc); if(smc->irq_num<0) { pr_error("request irq error!\n"); smc_dev_deinit(smc); return -1; } snprintf(buf, sizeof(buf), "smc%d", smc->id); smc->dev=device_create(&smc_class, NULL, MKDEV(smc_major, smc->id), smc, buf); if(!smc->dev) { pr_error("create device error!\n"); smc_dev_deinit(smc); return -1; } smc->param.f = F_DEFAULT; smc->param.d = D_DEFAULT; smc->param.n = N_DEFAULT; smc->param.bwi = BWI_DEFAULT; smc->param.cwi = CWI_DEFAULT; smc->param.bgt = BGT_DEFAULT; smc->param.freq = FREQ_DEFAULT; smc->param.recv_invert = 0; smc->param.recv_lsb_msb = 0; smc->param.recv_no_parity = 1; smc->param.xmit_invert = 0; smc->param.xmit_lsb_msb = 0; smc->param.xmit_retries = 1; smc->param.xmit_repeat_dis = 1; smc->init = 1; smc_hw_setup(smc); return 0; }
static int __devinit pm8xxx_tm_probe(struct platform_device *pdev) { const struct pm8xxx_tm_core_data *cdata = pdev->dev.platform_data; struct thermal_zone_device_ops *tz_ops; struct pm8xxx_tm_chip *chip; struct resource *res; int rc = 0; if (!cdata) { pr_err("missing core data\n"); return -EINVAL; } chip = kzalloc(sizeof(struct pm8xxx_tm_chip), GFP_KERNEL); if (chip == NULL) { pr_err("kzalloc() failed.\n"); return -ENOMEM; } chip->dev = &pdev->dev; memcpy(&(chip->cdata), cdata, sizeof(struct pm8xxx_tm_core_data)); res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, chip->cdata.irq_name_temp_stat); if (res) { chip->tempstat_irq = res->start; } else { pr_err("temp stat IRQ not specified\n"); goto err_free_chip; } res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, chip->cdata.irq_name_over_temp); if (res) { chip->overtemp_irq = res->start; } else { pr_err("over temp IRQ not specified\n"); goto err_free_chip; } /* Select proper thermal zone ops functions based on ADC type. */ if (chip->cdata.adc_type == PM8XXX_TM_ADC_PM8XXX_ADC) tz_ops = &pm8xxx_thermal_zone_ops_pm8xxx_adc; else tz_ops = &pm8xxx_thermal_zone_ops_no_adc; chip->tz_dev = thermal_zone_device_register(chip->cdata.tm_name, TRIP_NUM, chip, tz_ops, 0, 0, 0, 0); if (chip->tz_dev == NULL) { pr_err("thermal_zone_device_register() failed.\n"); rc = -ENODEV; goto err_free_chip; } rc = pm8xxx_tm_init_reg(chip); if (rc < 0) goto err_free_tz; rc = pm8xxx_tm_shutdown_override(chip, SOFTWARE_OVERRIDE_DISABLED); if (rc < 0) goto err_free_tz; if (chip->cdata.adc_type == PM8XXX_TM_ADC_NONE) { rc = pm8xxx_tm_init_temp_no_adc(chip); if (rc < 0) goto err_free_tz; } /* Start in HW control; switch to SW control when user changes mode. */ chip->mode = THERMAL_DEVICE_DISABLED; thermal_zone_device_update(chip->tz_dev); INIT_WORK(&chip->irq_work, pm8xxx_tm_work); rc = request_irq(chip->tempstat_irq, pm8xxx_tm_isr, IRQF_TRIGGER_RISING, chip->cdata.irq_name_temp_stat, chip); if (rc < 0) { pr_err("request_irq(%d) failed: %d\n", chip->tempstat_irq, rc); goto err_cancel_work; } rc = request_irq(chip->overtemp_irq, pm8xxx_tm_isr, IRQF_TRIGGER_RISING, chip->cdata.irq_name_over_temp, chip); if (rc < 0) { pr_err("request_irq(%d) failed: %d\n", chip->overtemp_irq, rc); goto err_free_irq_tempstat; } platform_set_drvdata(pdev, chip); pr_info("OK\n"); return 0; err_free_irq_tempstat: free_irq(chip->tempstat_irq, chip); err_cancel_work: cancel_work_sync(&chip->irq_work); err_free_tz: thermal_zone_device_unregister(chip->tz_dev); err_free_chip: kfree(chip); return rc; }
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; }
static int msm_iommu_probe(struct platform_device *pdev) { struct iommu_pmon *pmon_info; struct msm_iommu_drvdata *drvdata; struct resource *r; int ret, needs_alt_core_clk, needs_alt_iface_clk; int global_cfg_irq, global_client_irq; u32 temp; drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); if (!drvdata) return -ENOMEM; r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "iommu_base"); if (!r) return -EINVAL; drvdata->base = devm_ioremap(&pdev->dev, r->start, resource_size(r)); if (!drvdata->base) return -ENOMEM; drvdata->phys_base = r->start; r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smmu_local_base"); if (r) { drvdata->smmu_local_base = devm_ioremap(&pdev->dev, r->start, resource_size(r)); if (!drvdata->smmu_local_base) return -ENOMEM; } drvdata->glb_base = drvdata->base; if (of_device_is_compatible(pdev->dev.of_node, "qcom,msm-mmu-500")) drvdata->model = MMU_500; if (of_get_property(pdev->dev.of_node, "vdd-supply", NULL)) { drvdata->gdsc = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(drvdata->gdsc)) return PTR_ERR(drvdata->gdsc); drvdata->alt_gdsc = devm_regulator_get(&pdev->dev, "qcom,alt-vdd"); if (IS_ERR(drvdata->alt_gdsc)) drvdata->alt_gdsc = NULL; } else { pr_debug("Warning: No regulator specified for IOMMU\n"); } drvdata->pclk = devm_clk_get(&pdev->dev, "iface_clk"); if (IS_ERR(drvdata->pclk)) return PTR_ERR(drvdata->pclk); drvdata->clk = devm_clk_get(&pdev->dev, "core_clk"); if (IS_ERR(drvdata->clk)) return PTR_ERR(drvdata->clk); needs_alt_core_clk = of_property_read_bool(pdev->dev.of_node, "qcom,needs-alt-core-clk"); if (needs_alt_core_clk) { drvdata->aclk = devm_clk_get(&pdev->dev, "alt_core_clk"); if (IS_ERR(drvdata->aclk)) return PTR_ERR(drvdata->aclk); } needs_alt_iface_clk = of_property_read_bool(pdev->dev.of_node, "qcom,needs-alt-iface-clk"); if (needs_alt_iface_clk) { drvdata->aiclk = devm_clk_get(&pdev->dev, "alt_iface_clk"); if (IS_ERR(drvdata->aiclk)) return PTR_ERR(drvdata->aiclk); } if (!of_property_read_u32(pdev->dev.of_node, "qcom,cb-base-offset", &temp)) drvdata->cb_base = drvdata->base + temp; else drvdata->cb_base = drvdata->base + 0x8000; if (clk_get_rate(drvdata->clk) == 0) { ret = clk_round_rate(drvdata->clk, 1000); clk_set_rate(drvdata->clk, ret); } if (drvdata->aclk && clk_get_rate(drvdata->aclk) == 0) { ret = clk_round_rate(drvdata->aclk, 1000); clk_set_rate(drvdata->aclk, ret); } if (drvdata->aiclk && clk_get_rate(drvdata->aiclk) == 0) { ret = clk_round_rate(drvdata->aiclk, 1000); clk_set_rate(drvdata->aiclk, ret); } ret = msm_iommu_parse_dt(pdev, drvdata); if (ret) return ret; dev_info(&pdev->dev, "device %s (model: %d) mapped at %p, with %d ctx banks\n", drvdata->name, drvdata->model, drvdata->base, drvdata->ncb); platform_set_drvdata(pdev, drvdata); pmon_info = msm_iommu_pm_alloc(&pdev->dev); if (pmon_info != NULL) { ret = msm_iommu_pmon_parse_dt(pdev, pmon_info); if (ret) { msm_iommu_pm_free(&pdev->dev); pr_info("%s: pmon not available.\n", drvdata->name); } else { pmon_info->iommu.base = drvdata->base; pmon_info->iommu.ops = msm_get_iommu_access_ops(); pmon_info->iommu.hw_ops = iommu_pm_get_hw_ops_v1(); pmon_info->iommu.iommu_name = drvdata->name; ret = msm_iommu_pm_iommu_register(pmon_info); if (ret) { pr_err("%s iommu register fail\n", drvdata->name); msm_iommu_pm_free(&pdev->dev); } else { pr_debug("%s iommu registered for pmon\n", pmon_info->iommu.iommu_name); } } } global_cfg_irq = platform_get_irq_byname(pdev, "global_cfg_NS_irq"); if (global_cfg_irq > 0) { ret = devm_request_threaded_irq(&pdev->dev, global_cfg_irq, NULL, msm_iommu_global_fault_handler, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_RISING, "msm_iommu_global_cfg_irq", pdev); if (ret < 0) pr_err("Request Global CFG IRQ %d failed with ret=%d\n", global_cfg_irq, ret); } global_client_irq = platform_get_irq_byname(pdev, "global_client_NS_irq"); if (global_client_irq > 0) { ret = devm_request_threaded_irq(&pdev->dev, global_client_irq, NULL, msm_iommu_global_fault_handler, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_RISING, "msm_iommu_global_client_irq", pdev); if (ret < 0) pr_err("Request Global Client IRQ %d failed with ret=%d\n", global_client_irq, ret); } ret = of_platform_populate(pdev->dev.of_node, msm_iommu_ctx_match_table, NULL, &pdev->dev); if (ret) pr_err("Failed to create iommu context device\n"); return ret; }
static int pda_power_probe(struct platform_device *pdev) { int ret = 0; dev = &pdev->dev; if (pdev->id != -1) { dev_err(dev, "it's meaningless to register several " "pda_powers; use id = -1\n"); ret = -EINVAL; goto wrongid; } pdata = pdev->dev.platform_data; if (pdata->init) { ret = pdata->init(dev); if (ret < 0) goto init_failed; } update_status(); update_charger(); if (!pdata->wait_for_status) pdata->wait_for_status = 500; if (!pdata->wait_for_charger) pdata->wait_for_charger = 500; if (!pdata->polling_interval) pdata->polling_interval = 2000; if (!pdata->ac_max_uA) pdata->ac_max_uA = 500000; setup_timer(&charger_timer, charger_timer_func, 0); setup_timer(&supply_timer, supply_timer_func, 0); ac_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "ac"); usb_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "usb"); if (pdata->supplied_to) { pda_psy_ac.supplied_to = pdata->supplied_to; pda_psy_ac.num_supplicants = pdata->num_supplicants; pda_psy_usb.supplied_to = pdata->supplied_to; pda_psy_usb.num_supplicants = pdata->num_supplicants; } ac_draw = regulator_get(dev, "ac_draw"); if (IS_ERR(ac_draw)) { dev_dbg(dev, "couldn't get ac_draw regulator\n"); ac_draw = NULL; ret = PTR_ERR(ac_draw); } #ifdef CONFIG_USB_OTG_UTILS transceiver = otg_get_transceiver(); if (transceiver && !pdata->is_usb_online) { pdata->is_usb_online = otg_is_usb_online; } if (transceiver && !pdata->is_ac_online) { pdata->is_ac_online = otg_is_ac_online; } #endif if (pdata->is_ac_online) { ret = power_supply_register(&pdev->dev, &pda_psy_ac); if (ret) { dev_err(dev, "failed to register %s power supply\n", pda_psy_ac.name); goto ac_supply_failed; } if (ac_irq) { ret = request_irq(ac_irq->start, power_changed_isr, get_irq_flags(ac_irq), ac_irq->name, &pda_psy_ac); if (ret) { dev_err(dev, "request ac irq failed\n"); goto ac_irq_failed; } } else { polling = 1; } } if (pdata->is_usb_online) { ret = power_supply_register(&pdev->dev, &pda_psy_usb); if (ret) { dev_err(dev, "failed to register %s power supply\n", pda_psy_usb.name); goto usb_supply_failed; } if (usb_irq) { ret = request_irq(usb_irq->start, power_changed_isr, get_irq_flags(usb_irq), usb_irq->name, &pda_psy_usb); if (ret) { dev_err(dev, "request usb irq failed\n"); goto usb_irq_failed; } } else { polling = 1; } } #ifdef CONFIG_USB_OTG_UTILS if (transceiver && pdata->use_otg_notifier) { otg_nb.notifier_call = otg_handle_notification; ret = otg_register_notifier(transceiver, &otg_nb); if (ret) { dev_err(dev, "failure to register otg notifier\n"); goto otg_reg_notifier_failed; } polling = 0; } #endif if (polling) { dev_dbg(dev, "will poll for status\n"); setup_timer(&polling_timer, polling_timer_func, 0); mod_timer(&polling_timer, jiffies + msecs_to_jiffies(pdata->polling_interval)); } if (ac_irq || usb_irq) device_init_wakeup(&pdev->dev, 1); return 0; #ifdef CONFIG_USB_OTG_UTILS otg_reg_notifier_failed: if (pdata->is_usb_online && usb_irq) free_irq(usb_irq->start, &pda_psy_usb); #endif usb_irq_failed: if (pdata->is_usb_online) power_supply_unregister(&pda_psy_usb); usb_supply_failed: if (pdata->is_ac_online && ac_irq) free_irq(ac_irq->start, &pda_psy_ac); #ifdef CONFIG_USB_OTG_UTILS if (transceiver) otg_put_transceiver(transceiver); #endif ac_irq_failed: if (pdata->is_ac_online) power_supply_unregister(&pda_psy_ac); ac_supply_failed: if (ac_draw) { regulator_put(ac_draw); ac_draw = NULL; } if (pdata->exit) pdata->exit(dev); init_failed: wrongid: return ret; }
int __init kai_panel_init(void) { int err; struct resource __maybe_unused *res; struct board_info board_info; struct platform_device *phost1x; tegra_get_board_info(&board_info); #if defined(CONFIG_TEGRA_NVMAP) kai_carveouts[1].base = tegra_carveout_start; kai_carveouts[1].size = tegra_carveout_size; #endif err = gpio_request(kai_lvds_avdd_en, "lvds_avdd_en"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_output(kai_lvds_avdd_en, 1); if (err < 0) { pr_err("%s: gpio_direction_output failed %d\n", __func__, err); gpio_free(kai_lvds_avdd_en); return err; } err = gpio_request(kai_lvds_stdby, "lvds_stdby"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_output(kai_lvds_stdby, 1); if (err < 0) { pr_err("%s: gpio_direction_output failed %d\n", __func__, err); gpio_free(kai_lvds_stdby); return err; } err = gpio_request(kai_lvds_rst, "lvds_rst"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_output(kai_lvds_rst, 1); if (err < 0) { pr_err("%s: gpio_direction_output failed %d\n", __func__, err); gpio_free(kai_lvds_rst); return err; } if (board_info.fab == BOARD_FAB_A00) { err = gpio_request(kai_lvds_rs_a00, "lvds_rs"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_output(kai_lvds_rs_a00, 0); if (err < 0) { pr_err("%s: gpio_direction_output failed %d\n", __func__, err); gpio_free(kai_lvds_rs_a00); return err; } } else { err = gpio_request(kai_lvds_rs, "lvds_rs"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_output(kai_lvds_rs, 0); if (err < 0) { pr_err("%s: gpio_direction_output failed %d\n", __func__, err); gpio_free(kai_lvds_rs); return err; } } err = gpio_request(kai_lvds_lr, "lvds_lr"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_output(kai_lvds_lr, 1); if (err < 0) { pr_err("%s: gpio_direction_output failed %d\n", __func__, err); gpio_free(kai_lvds_lr); return err; } err = gpio_request(kai_lvds_shutdown, "lvds_shutdown"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_output(kai_lvds_shutdown, 1); if (err < 0) { pr_err("%s: gpio_direction_output failed %d\n", __func__, err); gpio_free(kai_lvds_shutdown); return err; } err = gpio_request(kai_hdmi_hpd, "hdmi_hpd"); if (err < 0) { pr_err("%s: gpio_request failed %d\n", __func__, err); return err; } err = gpio_direction_input(kai_hdmi_hpd); if (err < 0) { pr_err("%s: gpio_direction_input failed %d\n", __func__, err); gpio_free(kai_hdmi_hpd); return err; } err = platform_add_devices(kai_gfx_devices, ARRAY_SIZE(kai_gfx_devices)); #ifdef CONFIG_TEGRA_GRHOST phost1x = tegra3_register_host1x_devices(); if (!phost1x) return -EINVAL; #endif #if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC) res = platform_get_resource_byname(&kai_disp1_device, IORESOURCE_MEM, "fbmem"); res->start = tegra_fb_start; res->end = tegra_fb_start + tegra_fb_size - 1; #endif /* Copy the bootloader fb to the fb. */ __tegra_move_framebuffer(&kai_nvmap_device, tegra_fb_start, tegra_bootloader_fb_start, min(tegra_fb_size, tegra_bootloader_fb_size)); #if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC) if (!err) { kai_disp1_device.dev.parent = &phost1x->dev; err = platform_device_register(&kai_disp1_device); } res = platform_get_resource_byname(&kai_disp2_device, IORESOURCE_MEM, "fbmem"); res->start = tegra_fb2_start; res->end = tegra_fb2_start + tegra_fb2_size - 1; if (!err) { kai_disp2_device.dev.parent = &phost1x->dev; err = platform_device_register(&kai_disp2_device); } #endif #if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP) if (!err) { nvavp_device.dev.parent = &phost1x->dev; err = platform_device_register(&nvavp_device); } #endif return err; }
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; }
static int bluedroid_pm_probe(struct platform_device *pdev) { static struct bluedroid_pm_data *bluedroid_pm; struct rfkill *rfkill; struct resource *res; int ret; bool enable = false; /* off */ bluedroid_pm = kzalloc(sizeof(*bluedroid_pm), GFP_KERNEL); if (!bluedroid_pm) return -ENOMEM; bluedroid_pm->vdd_3v3 = regulator_get(&pdev->dev, "vdd_bt_3v3"); if (IS_ERR_OR_NULL(bluedroid_pm->vdd_3v3)) { pr_warn("%s: regulator vdd_bt_3v3 not available\n", __func__); bluedroid_pm->vdd_3v3 = NULL; } bluedroid_pm->vdd_1v8 = regulator_get(&pdev->dev, "vddio_bt_1v8"); if (IS_ERR_OR_NULL(bluedroid_pm->vdd_1v8)) { pr_warn("%s: regulator vddio_bt_1v8 not available\n", __func__); bluedroid_pm->vdd_1v8 = NULL; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "reset_gpio"); if (res) { bluedroid_pm->gpio_reset = res->start; ret = gpio_request(bluedroid_pm->gpio_reset, "reset_gpio"); if (ret) { pr_err("%s: Failed to get reset gpio\n", __func__); goto free_res; } gpio_direction_output(bluedroid_pm->gpio_reset, enable); } else { pr_debug("%s: Reset gpio not registered.\n", __func__); bluedroid_pm->gpio_reset = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "shutdown_gpio"); if (res) { bluedroid_pm->gpio_shutdown = res->start; ret = gpio_request(bluedroid_pm->gpio_shutdown, "shutdown_gpio"); if (ret) { pr_err("%s: Failed to get shutdown gpio\n", __func__); goto free_res; } gpio_direction_output(bluedroid_pm->gpio_shutdown, enable); } else { pr_debug("%s: shutdown gpio not registered\n", __func__); bluedroid_pm->gpio_shutdown = 0; } /* * make sure at-least one of the GPIO or regulators avaiable to * register with rfkill is defined */ if (bluedroid_pm->gpio_reset || bluedroid_pm->gpio_shutdown || bluedroid_pm->vdd_1v8 || bluedroid_pm->vdd_3v3) { rfkill = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bluedroid_pm_rfkill_ops, bluedroid_pm); if (unlikely(!rfkill)) goto free_res; bluedroid_pm->is_blocked = !enable; rfkill_set_states(rfkill, bluedroid_pm->is_blocked, false); ret = rfkill_register(rfkill); if (unlikely(ret)) { rfkill_destroy(rfkill); kfree(rfkill); goto free_res; } bluedroid_pm->rfkill = rfkill; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "gpio_host_wake"); if (res) { bluedroid_pm->host_wake = res->start; ret = gpio_request(bluedroid_pm->host_wake, "bt_host_wake"); if (ret) { pr_err("%s: Failed to get host_wake gpio\n", __func__); goto free_res; } /* configure host_wake as input */ gpio_direction_input(bluedroid_pm->host_wake); } else { pr_debug("%s: gpio_host_wake not registered\n", __func__); bluedroid_pm->host_wake = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "host_wake"); if (res) { pr_err("%s : found host_wake irq\n", __func__); bluedroid_pm->host_wake_irq = res->start; ret = request_irq(bluedroid_pm->host_wake_irq, bluedroid_pm_hostwake_isr, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "bluetooth hostwake", bluedroid_pm); if (ret) { pr_err("%s: Failed to get host_wake irq\n", __func__); goto free_res; } } else { pr_debug("%s: host_wake not registered\n", __func__); bluedroid_pm->host_wake_irq = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "gpio_ext_wake"); if (res) { bluedroid_pm->ext_wake = res->start; ret = gpio_request(bluedroid_pm->ext_wake, "bt_ext_wake"); if (ret) { pr_err("%s: Failed to get ext_wake gpio\n", __func__); goto free_res; } /* configure ext_wake as output mode*/ gpio_direction_output(bluedroid_pm->ext_wake, 1); if (create_bt_proc_interface(bluedroid_pm)) { pr_err("%s: Failed to create proc interface", __func__); goto free_res; } /* initialize wake lock */ wake_lock_init(&bluedroid_pm->wake_lock, WAKE_LOCK_SUSPEND, "bluedroid_pm"); } else { pr_debug("%s: gpio_ext_wake not registered\n", __func__); bluedroid_pm->ext_wake = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "min_cpu_freq"); if (res) bluedroid_pm->resume_min_frequency = res->start; platform_set_drvdata(pdev, bluedroid_pm); pr_debug("RFKILL BT driver successfully registered"); return 0; free_res: if (bluedroid_pm->vdd_3v3) regulator_put(bluedroid_pm->vdd_3v3); if (bluedroid_pm->vdd_1v8) regulator_put(bluedroid_pm->vdd_1v8); if (bluedroid_pm->gpio_shutdown) gpio_free(bluedroid_pm->gpio_shutdown); if (bluedroid_pm->gpio_reset) gpio_free(bluedroid_pm->gpio_reset); if (bluedroid_pm->ext_wake) gpio_free(bluedroid_pm->ext_wake); if (bluedroid_pm->host_wake) gpio_free(bluedroid_pm->host_wake); if (bluedroid_pm->rfkill) { rfkill_unregister(bluedroid_pm->rfkill); rfkill_destroy(bluedroid_pm->rfkill); kfree(bluedroid_pm->rfkill); } kfree(bluedroid_pm); return -ENODEV; }
static int mv_ehci_probe(struct platform_device *pdev) { struct mv_usb_platform_data *pdata = dev_get_platdata(&pdev->dev); struct usb_hcd *hcd; struct ehci_hcd *ehci; struct ehci_hcd_mv *ehci_mv; struct resource *r; int retval = -ENODEV; u32 offset; if (!pdata) { dev_err(&pdev->dev, "missing platform_data\n"); return -ENODEV; } if (usb_disabled()) return -ENODEV; hcd = usb_create_hcd(&mv_ehci_hc_driver, &pdev->dev, "mv ehci"); if (!hcd) return -ENOMEM; ehci_mv = devm_kzalloc(&pdev->dev, sizeof(*ehci_mv), GFP_KERNEL); if (ehci_mv == NULL) { retval = -ENOMEM; goto err_put_hcd; } platform_set_drvdata(pdev, ehci_mv); ehci_mv->pdata = pdata; ehci_mv->hcd = hcd; ehci_mv->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(ehci_mv->clk)) { dev_err(&pdev->dev, "error getting clock\n"); retval = PTR_ERR(ehci_mv->clk); goto err_put_hcd; } r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phyregs"); ehci_mv->phy_regs = devm_ioremap_resource(&pdev->dev, r); if (IS_ERR(ehci_mv->phy_regs)) { retval = PTR_ERR(ehci_mv->phy_regs); goto err_put_hcd; } r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "capregs"); ehci_mv->cap_regs = devm_ioremap_resource(&pdev->dev, r); if (IS_ERR(ehci_mv->cap_regs)) { retval = PTR_ERR(ehci_mv->cap_regs); goto err_put_hcd; } retval = mv_ehci_enable(ehci_mv); if (retval) { dev_err(&pdev->dev, "init phy error %d\n", retval); goto err_put_hcd; } offset = readl(ehci_mv->cap_regs) & CAPLENGTH_MASK; ehci_mv->op_regs = (void __iomem *) ((unsigned long) ehci_mv->cap_regs + offset); hcd->rsrc_start = r->start; hcd->rsrc_len = resource_size(r); hcd->regs = ehci_mv->op_regs; hcd->irq = platform_get_irq(pdev, 0); if (!hcd->irq) { dev_err(&pdev->dev, "Cannot get irq."); retval = -ENODEV; goto err_disable_clk; } ehci = hcd_to_ehci(hcd); ehci->caps = (struct ehci_caps *) ehci_mv->cap_regs; ehci_mv->mode = pdata->mode; if (ehci_mv->mode == MV_USB_MODE_OTG) { ehci_mv->otg = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2); if (IS_ERR(ehci_mv->otg)) { retval = PTR_ERR(ehci_mv->otg); if (retval == -ENXIO) dev_info(&pdev->dev, "MV_USB_MODE_OTG " "must have CONFIG_USB_PHY enabled\n"); else dev_err(&pdev->dev, "unable to find transceiver\n"); goto err_disable_clk; } retval = otg_set_host(ehci_mv->otg->otg, &hcd->self); if (retval < 0) { dev_err(&pdev->dev, "unable to register with transceiver\n"); retval = -ENODEV; goto err_disable_clk; } /* otg will enable clock before use as host */ mv_ehci_disable(ehci_mv); } else { if (pdata->set_vbus) pdata->set_vbus(1); retval = usb_add_hcd(hcd, hcd->irq, IRQF_SHARED); if (retval) { dev_err(&pdev->dev, "failed to add hcd with err %d\n", retval); goto err_set_vbus; } device_wakeup_enable(hcd->self.controller); } if (pdata->private_init) pdata->private_init(ehci_mv->op_regs, ehci_mv->phy_regs); dev_info(&pdev->dev, "successful find EHCI device with regs 0x%p irq %d" " working in %s mode\n", hcd->regs, hcd->irq, ehci_mv->mode == MV_USB_MODE_OTG ? "OTG" : "Host"); return 0; err_set_vbus: if (pdata->set_vbus) pdata->set_vbus(0); err_disable_clk: mv_ehci_disable(ehci_mv); err_put_hcd: usb_put_hcd(hcd); return retval; }