static struct lp872x_platform_data *lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which) { struct device_node *np = dev->of_node; struct lp872x_platform_data *pdata; struct of_regulator_match *match; int num_matches; int count; int i; u8 dvs_state; pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return ERR_PTR(-ENOMEM); of_property_read_u8(np, "ti,general-config", &pdata->general_config); if (of_find_property(np, "ti,update-config", NULL)) pdata->update_config = true; pdata->dvs = devm_kzalloc(dev, sizeof(struct lp872x_dvs), GFP_KERNEL); if (!pdata->dvs) return ERR_PTR(-ENOMEM); pdata->dvs->gpio = of_get_named_gpio(np, "ti,dvs-gpio", 0); of_property_read_u8(np, "ti,dvs-vsel", (u8 *)&pdata->dvs->vsel); of_property_read_u8(np, "ti,dvs-state", &dvs_state); pdata->dvs->init_state = dvs_state ? DVS_HIGH : DVS_LOW; pdata->enable_gpio = of_get_named_gpio(np, "enable-gpios", 0); if (of_get_child_count(np) == 0) goto out; switch (which) { case LP8720: match = lp8720_matches; num_matches = ARRAY_SIZE(lp8720_matches); break; case LP8725: match = lp8725_matches; num_matches = ARRAY_SIZE(lp8725_matches); break; default: goto out; } count = of_regulator_match(dev, np, match, num_matches); if (count <= 0) goto out; for (i = 0; i < num_matches; i++) { pdata->regulator_data[i].id = (enum lp872x_regulator_id)match[i].driver_data; pdata->regulator_data[i].init_data = match[i].init_data; } out: return pdata; }
static int sta32x_probe_dt(struct device *dev, struct sta32x_priv *sta32x) { struct device_node *np = dev->of_node; struct sta32x_platform_data *pdata; u16 tmp; pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; of_property_read_u8(np, "st,output-conf", &pdata->output_conf); of_property_read_u8(np, "st,ch1-output-mapping", &pdata->ch1_output_mapping); of_property_read_u8(np, "st,ch2-output-mapping", &pdata->ch2_output_mapping); of_property_read_u8(np, "st,ch3-output-mapping", &pdata->ch3_output_mapping); if (of_get_property(np, "st,thermal-warning-recovery", NULL)) pdata->thermal_warning_recovery = 1; if (of_get_property(np, "st,thermal-warning-adjustment", NULL)) pdata->thermal_warning_adjustment = 1; if (of_get_property(np, "st,needs_esd_watchdog", NULL)) pdata->needs_esd_watchdog = 1; tmp = 140; of_property_read_u16(np, "st,drop-compensation-ns", &tmp); pdata->drop_compensation_ns = clamp_t(u16, tmp, 0, 300) / 20; /* CONFE */ if (of_get_property(np, "st,max-power-use-mpcc", NULL)) pdata->max_power_use_mpcc = 1; if (of_get_property(np, "st,max-power-correction", NULL)) pdata->max_power_correction = 1; if (of_get_property(np, "st,am-reduction-mode", NULL)) pdata->am_reduction_mode = 1; if (of_get_property(np, "st,odd-pwm-speed-mode", NULL)) pdata->odd_pwm_speed_mode = 1; /* CONFF */ if (of_get_property(np, "st,invalid-input-detect-mute", NULL)) pdata->invalid_input_detect_mute = 1; sta32x->pdata = pdata; return 0; }
static struct lp8727_chg_param *lp8727_parse_charge_pdata(struct device *dev, struct device_node *np) { struct lp8727_chg_param *param; param = devm_kzalloc(dev, sizeof(*param), GFP_KERNEL); if (!param) goto out; of_property_read_u8(np, "eoc-level", (u8 *)¶m->eoc_level); of_property_read_u8(np, "charging-current", (u8 *)¶m->ichg); out: return param; }
static int lp855x_parse_dt(struct lp855x *lp) { struct device *dev = lp->dev; struct device_node *node = dev->of_node; struct lp855x_platform_data *pdata; int rom_length; if (!node) { dev_err(dev, "no platform data\n"); return -EINVAL; } pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; of_property_read_string(node, "bl-name", &pdata->name); of_property_read_u8(node, "dev-ctrl", &pdata->device_control); of_property_read_u8(node, "init-brt", &pdata->initial_brightness); of_property_read_u32(node, "pwm-period", &pdata->period_ns); /* Fill ROM platform data if defined */ rom_length = of_get_child_count(node); if (rom_length > 0) { struct lp855x_rom_data *rom; struct device_node *child; int i = 0; rom = devm_kzalloc(dev, sizeof(*rom) * rom_length, GFP_KERNEL); if (!rom) return -ENOMEM; for_each_child_of_node(node, child) { of_property_read_u8(child, "rom-addr", &rom[i].addr); of_property_read_u8(child, "rom-val", &rom[i].val); i++; } pdata->size_program = rom_length; pdata->rom_data = &rom[0]; }
struct lp55xx_platform_data *lp55xx_of_populate_pdata(struct device *dev, struct device_node *np) { struct device_node *child; struct lp55xx_platform_data *pdata; struct lp55xx_led_config *cfg; int num_channels; int i = 0; pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return ERR_PTR(-ENOMEM); num_channels = of_get_child_count(np); if (num_channels == 0) { dev_err(dev, "no LED channels\n"); return ERR_PTR(-EINVAL); } cfg = devm_kzalloc(dev, sizeof(*cfg) * num_channels, GFP_KERNEL); if (!cfg) return ERR_PTR(-ENOMEM); pdata->led_config = &cfg[0]; pdata->num_channels = num_channels; for_each_child_of_node(np, child) { cfg[i].chan_nr = i; of_property_read_string(child, "chan-name", &cfg[i].name); of_property_read_u8(child, "led-cur", &cfg[i].led_current); of_property_read_u8(child, "max-cur", &cfg[i].max_current); cfg[i].default_trigger = of_get_property(child, "linux,default-trigger", NULL); i++; }
static int ir_spi_probe(struct spi_device *spi) { int ret; u8 dc; struct ir_spi_data *idata; idata = devm_kzalloc(&spi->dev, sizeof(*idata), GFP_KERNEL); if (!idata) return -ENOMEM; idata->regulator = devm_regulator_get(&spi->dev, "irda_regulator"); if (IS_ERR(idata->regulator)) return PTR_ERR(idata->regulator); idata->rc = devm_rc_allocate_device(&spi->dev, RC_DRIVER_IR_RAW_TX); if (!idata->rc) return -ENOMEM; idata->rc->tx_ir = ir_spi_tx; idata->rc->s_tx_carrier = ir_spi_set_tx_carrier; idata->rc->s_tx_duty_cycle = ir_spi_set_duty_cycle; idata->rc->driver_name = IR_SPI_DRIVER_NAME; idata->rc->priv = idata; idata->spi = spi; idata->negated = of_property_read_bool(spi->dev.of_node, "led-active-low"); ret = of_property_read_u8(spi->dev.of_node, "duty-cycle", &dc); if (ret) dc = 50; /* ir_spi_set_duty_cycle cannot fail, * it returns int to be compatible with the * rc->s_tx_duty_cycle function */ ir_spi_set_duty_cycle(idata->rc, dc); idata->freq = IR_SPI_DEFAULT_FREQUENCY; return devm_rc_register_device(&spi->dev, idata->rc); }
int get_hw_config_u8(const char *node_name, const char *prop_name, u8 *pvalue) { struct device_node *np; int ret; if(node_name == NULL || prop_name == NULL || pvalue == NULL) { hwlog_err("Invalid Argument, NULL passed\n"); return -EINVAL; } np = of_find_node_by_name(NULL, node_name); if (!np) { hwlog_err("can not get device node with node_name: %s\n", node_name); return -ENODEV; } if(0 == is_property_public(np, prop_name)) { hwlog_err("property to read is not public, permission denied\n"); ret = -EACCES; goto OUT; } ret = of_property_read_u8(np, prop_name, pvalue); if (ret != 0) { hwlog_err("can not get prop values with prop_name: %s\n", prop_name); goto OUT; } OUT: of_node_put(np); return ret; }
int dw_pcie_ep_init(struct dw_pcie_ep *ep) { int ret; void *addr; struct pci_epc *epc; struct dw_pcie *pci = to_dw_pcie_from_ep(ep); struct device *dev = pci->dev; struct device_node *np = dev->of_node; if (!pci->dbi_base || !pci->dbi_base2) { dev_err(dev, "dbi_base/deb_base2 is not populated\n"); return -EINVAL; } ret = of_property_read_u32(np, "num-ib-windows", &ep->num_ib_windows); if (ret < 0) { dev_err(dev, "unable to read *num-ib-windows* property\n"); return ret; } if (ep->num_ib_windows > MAX_IATU_IN) { dev_err(dev, "invalid *num-ib-windows*\n"); return -EINVAL; } ret = of_property_read_u32(np, "num-ob-windows", &ep->num_ob_windows); if (ret < 0) { dev_err(dev, "unable to read *num-ob-windows* property\n"); return ret; } if (ep->num_ob_windows > MAX_IATU_OUT) { dev_err(dev, "invalid *num-ob-windows*\n"); return -EINVAL; } ep->ib_window_map = devm_kzalloc(dev, sizeof(long) * BITS_TO_LONGS(ep->num_ib_windows), GFP_KERNEL); if (!ep->ib_window_map) return -ENOMEM; ep->ob_window_map = devm_kzalloc(dev, sizeof(long) * BITS_TO_LONGS(ep->num_ob_windows), GFP_KERNEL); if (!ep->ob_window_map) return -ENOMEM; addr = devm_kzalloc(dev, sizeof(phys_addr_t) * ep->num_ob_windows, GFP_KERNEL); if (!addr) return -ENOMEM; ep->outbound_addr = addr; if (ep->ops->ep_init) ep->ops->ep_init(ep); epc = devm_pci_epc_create(dev, &epc_ops); if (IS_ERR(epc)) { dev_err(dev, "failed to create epc device\n"); return PTR_ERR(epc); } ret = of_property_read_u8(np, "max-functions", &epc->max_functions); if (ret < 0) epc->max_functions = 1; ret = __pci_epc_mem_init(epc, ep->phys_base, ep->addr_size, ep->page_size); if (ret < 0) { dev_err(dev, "Failed to initialize address space\n"); return ret; } ep->msi_mem = pci_epc_mem_alloc_addr(epc, &ep->msi_mem_phys, epc->mem->page_size); if (!ep->msi_mem) { dev_err(dev, "Failed to reserve memory for MSI\n"); return -ENOMEM; } ep->epc = epc; epc_set_drvdata(epc, ep); dw_pcie_setup(pci); return 0; }
static int sta350_probe_dt(struct device *dev, struct sta350_priv *sta350) { struct device_node *np = dev->of_node; struct sta350_platform_data *pdata; const char *ffx_power_mode; u16 tmp; u8 tmp8; pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; of_property_read_u8(np, "st,output-conf", &pdata->output_conf); of_property_read_u8(np, "st,ch1-output-mapping", &pdata->ch1_output_mapping); of_property_read_u8(np, "st,ch2-output-mapping", &pdata->ch2_output_mapping); of_property_read_u8(np, "st,ch3-output-mapping", &pdata->ch3_output_mapping); if (of_get_property(np, "st,thermal-warning-recovery", NULL)) pdata->thermal_warning_recovery = 1; if (of_get_property(np, "st,thermal-warning-adjustment", NULL)) pdata->thermal_warning_adjustment = 1; if (of_get_property(np, "st,fault-detect-recovery", NULL)) pdata->fault_detect_recovery = 1; pdata->ffx_power_output_mode = STA350_FFX_PM_VARIABLE_DROP_COMP; if (!of_property_read_string(np, "st,ffx-power-output-mode", &ffx_power_mode)) { int i, mode = -EINVAL; for (i = 0; i < ARRAY_SIZE(sta350_ffx_modes); i++) if (!strcasecmp(ffx_power_mode, sta350_ffx_modes[i])) mode = i; if (mode < 0) dev_warn(dev, "Unsupported ffx output mode: %s\n", ffx_power_mode); else pdata->ffx_power_output_mode = mode; } tmp = 140; of_property_read_u16(np, "st,drop-compensation-ns", &tmp); pdata->drop_compensation_ns = clamp_t(u16, tmp, 0, 300) / 20; if (of_get_property(np, "st,overcurrent-warning-adjustment", NULL)) pdata->oc_warning_adjustment = 1; /* CONFE */ if (of_get_property(np, "st,max-power-use-mpcc", NULL)) pdata->max_power_use_mpcc = 1; if (of_get_property(np, "st,max-power-correction", NULL)) pdata->max_power_correction = 1; if (of_get_property(np, "st,am-reduction-mode", NULL)) pdata->am_reduction_mode = 1; if (of_get_property(np, "st,odd-pwm-speed-mode", NULL)) pdata->odd_pwm_speed_mode = 1; if (of_get_property(np, "st,distortion-compensation", NULL)) pdata->distortion_compensation = 1; /* CONFF */ if (of_get_property(np, "st,invalid-input-detect-mute", NULL)) pdata->invalid_input_detect_mute = 1; /* MISC */ if (of_get_property(np, "st,activate-mute-output", NULL)) pdata->activate_mute_output = 1; if (of_get_property(np, "st,bridge-immediate-off", NULL)) pdata->bridge_immediate_off = 1; if (of_get_property(np, "st,noise-shape-dc-cut", NULL)) pdata->noise_shape_dc_cut = 1; if (of_get_property(np, "st,powerdown-master-volume", NULL)) pdata->powerdown_master_vol = 1; if (!of_property_read_u8(np, "st,powerdown-delay-divider", &tmp8)) { if (is_power_of_2(tmp8) && tmp8 >= 1 && tmp8 <= 128) pdata->powerdown_delay_divider = ilog2(tmp8); else dev_warn(dev, "Unsupported powerdown delay divider %d\n", tmp8); } sta350->pdata = pdata; return 0; }
static int cdns_pcie_ep_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct cdns_pcie_ep *ep; struct cdns_pcie *pcie; struct pci_epc *epc; struct resource *res; int ret; ep = devm_kzalloc(dev, sizeof(*ep), GFP_KERNEL); if (!ep) return -ENOMEM; pcie = &ep->pcie; pcie->is_rc = false; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "reg"); pcie->reg_base = devm_ioremap_resource(dev, res); if (IS_ERR(pcie->reg_base)) { dev_err(dev, "missing \"reg\"\n"); return PTR_ERR(pcie->reg_base); } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mem"); if (!res) { dev_err(dev, "missing \"mem\"\n"); return -EINVAL; } pcie->mem_res = res; ret = of_property_read_u32(np, "cdns,max-outbound-regions", &ep->max_regions); if (ret < 0) { dev_err(dev, "missing \"cdns,max-outbound-regions\"\n"); return ret; } ep->ob_addr = devm_kzalloc(dev, ep->max_regions * sizeof(*ep->ob_addr), GFP_KERNEL); if (!ep->ob_addr) return -ENOMEM; pm_runtime_enable(dev); ret = pm_runtime_get_sync(dev); if (ret < 0) { dev_err(dev, "pm_runtime_get_sync() failed\n"); goto err_get_sync; } /* Disable all but function 0 (anyway BIT(0) is hardwired to 1). */ cdns_pcie_writel(pcie, CDNS_PCIE_LM_EP_FUNC_CFG, BIT(0)); epc = devm_pci_epc_create(dev, &cdns_pcie_epc_ops); if (IS_ERR(epc)) { dev_err(dev, "failed to create epc device\n"); ret = PTR_ERR(epc); goto err_init; } epc_set_drvdata(epc, ep); if (of_property_read_u8(np, "max-functions", &epc->max_functions) < 0) epc->max_functions = 1; ret = pci_epc_mem_init(epc, pcie->mem_res->start, resource_size(pcie->mem_res)); if (ret < 0) { dev_err(dev, "failed to initialize the memory space\n"); goto err_init; } ep->irq_cpu_addr = pci_epc_mem_alloc_addr(epc, &ep->irq_phys_addr, SZ_128K); if (!ep->irq_cpu_addr) { dev_err(dev, "failed to reserve memory space for MSI\n"); ret = -ENOMEM; goto free_epc_mem; } ep->irq_pci_addr = CDNS_PCIE_EP_IRQ_PCI_ADDR_NONE; return 0; free_epc_mem: pci_epc_mem_exit(epc); err_init: pm_runtime_put_sync(dev); err_get_sync: pm_runtime_disable(dev); return ret; }
static int dwc3_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct dwc3_platform_data *pdata = dev_get_platdata(dev); struct device_node *node = dev->of_node; struct resource *res; struct dwc3 *dwc; u8 lpm_nyet_threshold; u8 tx_de_emphasis; u8 hird_threshold; int ret; void __iomem *regs; void *mem; mem = devm_kzalloc(dev, sizeof(*dwc) + DWC3_ALIGN_MASK, GFP_KERNEL); if (!mem) return -ENOMEM; dwc = PTR_ALIGN(mem, DWC3_ALIGN_MASK + 1); dwc->mem = mem; dwc->dev = dev; res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res) { dev_err(dev, "missing IRQ\n"); return -ENODEV; } dwc->xhci_resources[1].start = res->start; dwc->xhci_resources[1].end = res->end; dwc->xhci_resources[1].flags = res->flags; dwc->xhci_resources[1].name = res->name; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(dev, "missing memory resource\n"); return -ENODEV; } dwc->xhci_resources[0].start = res->start; dwc->xhci_resources[0].end = dwc->xhci_resources[0].start + DWC3_XHCI_REGS_END; dwc->xhci_resources[0].flags = res->flags; dwc->xhci_resources[0].name = res->name; res->start += DWC3_GLOBALS_REGS_START; /* * Request memory region but exclude xHCI regs, * since it will be requested by the xhci-plat driver. */ regs = devm_ioremap_resource(dev, res); if (IS_ERR(regs)) { ret = PTR_ERR(regs); goto err0; } dwc->regs = regs; dwc->regs_size = resource_size(res); /* default to highest possible threshold */ lpm_nyet_threshold = 0xff; /* default to -3.5dB de-emphasis */ tx_de_emphasis = 1; /* * default to assert utmi_sleep_n and use maximum allowed HIRD * threshold value of 0b1100 */ hird_threshold = 12; if (node) { dwc->maximum_speed = of_usb_get_maximum_speed(node); dwc->has_lpm_erratum = of_property_read_bool(node, "snps,has-lpm-erratum"); of_property_read_u8(node, "snps,lpm-nyet-threshold", &lpm_nyet_threshold); dwc->is_utmi_l1_suspend = of_property_read_bool(node, "snps,is-utmi-l1-suspend"); of_property_read_u8(node, "snps,hird-threshold", &hird_threshold); dwc->usb3_lpm_capable = of_property_read_bool(node, "snps,usb3_lpm_capable"); dwc->needs_fifo_resize = of_property_read_bool(node, "tx-fifo-resize"); dwc->dr_mode = of_usb_get_dr_mode(node); dwc->disable_scramble_quirk = of_property_read_bool(node, "snps,disable_scramble_quirk"); dwc->u2exit_lfps_quirk = of_property_read_bool(node, "snps,u2exit_lfps_quirk"); dwc->u2ss_inp3_quirk = of_property_read_bool(node, "snps,u2ss_inp3_quirk"); dwc->req_p1p2p3_quirk = of_property_read_bool(node, "snps,req_p1p2p3_quirk"); dwc->del_p1p2p3_quirk = of_property_read_bool(node, "snps,del_p1p2p3_quirk"); dwc->del_phy_power_chg_quirk = of_property_read_bool(node, "snps,del_phy_power_chg_quirk"); dwc->lfps_filter_quirk = of_property_read_bool(node, "snps,lfps_filter_quirk"); dwc->rx_detect_poll_quirk = of_property_read_bool(node, "snps,rx_detect_poll_quirk"); dwc->dis_u3_susphy_quirk = of_property_read_bool(node, "snps,dis_u3_susphy_quirk"); dwc->dis_u2_susphy_quirk = of_property_read_bool(node, "snps,dis_u2_susphy_quirk"); dwc->dis_enblslpm_quirk = device_property_read_bool(dev, "snps,dis_enblslpm_quirk"); dwc->tx_de_emphasis_quirk = of_property_read_bool(node, "snps,tx_de_emphasis_quirk"); of_property_read_u8(node, "snps,tx_de_emphasis", &tx_de_emphasis); of_property_read_string(node, "snps,hsphy_interface", &dwc->hsphy_interface); } else if (pdata) { dwc->maximum_speed = pdata->maximum_speed; dwc->has_lpm_erratum = pdata->has_lpm_erratum; if (pdata->lpm_nyet_threshold) lpm_nyet_threshold = pdata->lpm_nyet_threshold; dwc->is_utmi_l1_suspend = pdata->is_utmi_l1_suspend; if (pdata->hird_threshold) hird_threshold = pdata->hird_threshold; dwc->needs_fifo_resize = pdata->tx_fifo_resize; dwc->usb3_lpm_capable = pdata->usb3_lpm_capable; dwc->dr_mode = pdata->dr_mode; dwc->disable_scramble_quirk = pdata->disable_scramble_quirk; dwc->u2exit_lfps_quirk = pdata->u2exit_lfps_quirk; dwc->u2ss_inp3_quirk = pdata->u2ss_inp3_quirk; dwc->req_p1p2p3_quirk = pdata->req_p1p2p3_quirk; dwc->del_p1p2p3_quirk = pdata->del_p1p2p3_quirk; dwc->del_phy_power_chg_quirk = pdata->del_phy_power_chg_quirk; dwc->lfps_filter_quirk = pdata->lfps_filter_quirk; dwc->rx_detect_poll_quirk = pdata->rx_detect_poll_quirk; dwc->dis_u3_susphy_quirk = pdata->dis_u3_susphy_quirk; dwc->dis_u2_susphy_quirk = pdata->dis_u2_susphy_quirk; dwc->dis_enblslpm_quirk = pdata->dis_enblslpm_quirk; dwc->tx_de_emphasis_quirk = pdata->tx_de_emphasis_quirk; if (pdata->tx_de_emphasis) tx_de_emphasis = pdata->tx_de_emphasis; dwc->hsphy_interface = pdata->hsphy_interface; } /* default to superspeed if no maximum_speed passed */ if (dwc->maximum_speed == USB_SPEED_UNKNOWN) dwc->maximum_speed = USB_SPEED_SUPER; dwc->lpm_nyet_threshold = lpm_nyet_threshold; dwc->tx_de_emphasis = tx_de_emphasis; dwc->hird_threshold = hird_threshold | (dwc->is_utmi_l1_suspend << 4); platform_set_drvdata(pdev, dwc); dwc3_cache_hwparams(dwc); ret = dwc3_phy_setup(dwc); if (ret) goto err0; ret = dwc3_core_get_phy(dwc); if (ret) goto err0; spin_lock_init(&dwc->lock); if (!dev->dma_mask) { dev->dma_mask = dev->parent->dma_mask; dev->dma_parms = dev->parent->dma_parms; dma_set_coherent_mask(dev, dev->parent->coherent_dma_mask); } pm_runtime_enable(dev); pm_runtime_get_sync(dev); pm_runtime_forbid(dev); ret = dwc3_alloc_event_buffers(dwc, DWC3_EVENT_BUFFERS_SIZE); if (ret) { dev_err(dwc->dev, "failed to allocate event buffers\n"); ret = -ENOMEM; goto err1; } if (IS_ENABLED(CONFIG_USB_DWC3_HOST)) dwc->dr_mode = USB_DR_MODE_HOST; else if (IS_ENABLED(CONFIG_USB_DWC3_GADGET)) dwc->dr_mode = USB_DR_MODE_PERIPHERAL; if (dwc->dr_mode == USB_DR_MODE_UNKNOWN) dwc->dr_mode = USB_DR_MODE_OTG; ret = dwc3_core_init(dwc); if (ret) { dev_err(dev, "failed to initialize core\n"); goto err1; } usb_phy_set_suspend(dwc->usb2_phy, 0); usb_phy_set_suspend(dwc->usb3_phy, 0); ret = phy_power_on(dwc->usb2_generic_phy); if (ret < 0) goto err2; ret = phy_power_on(dwc->usb3_generic_phy); if (ret < 0) goto err3; ret = dwc3_event_buffers_setup(dwc); if (ret) { dev_err(dwc->dev, "failed to setup event buffers\n"); goto err4; } ret = dwc3_core_init_mode(dwc); if (ret) goto err5; ret = dwc3_debugfs_init(dwc); if (ret) { dev_err(dev, "failed to initialize debugfs\n"); goto err6; } pm_runtime_allow(dev); return 0; err6: dwc3_core_exit_mode(dwc); err5: dwc3_event_buffers_cleanup(dwc); err4: phy_power_off(dwc->usb3_generic_phy); err3: phy_power_off(dwc->usb2_generic_phy); err2: usb_phy_set_suspend(dwc->usb2_phy, 1); usb_phy_set_suspend(dwc->usb3_phy, 1); dwc3_core_exit(dwc); err1: dwc3_free_event_buffers(dwc); dwc3_ulpi_exit(dwc); err0: /* * restore res->start back to its original value so that, in case the * probe is deferred, we don't end up getting error in request the * memory region the next time probe is called. */ res->start -= DWC3_GLOBALS_REGS_START; return ret; }
static int cs53l30_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct device_node *np = client->dev.of_node; struct device *dev = &client->dev; struct cs53l30_private *cs53l30; unsigned int devid = 0; unsigned int reg; int ret = 0, i; u8 val; cs53l30 = devm_kzalloc(dev, sizeof(*cs53l30), GFP_KERNEL); if (!cs53l30) return -ENOMEM; for (i = 0; i < ARRAY_SIZE(cs53l30->supplies); i++) cs53l30->supplies[i].supply = cs53l30_supply_names[i]; ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(cs53l30->supplies), cs53l30->supplies); if (ret) { dev_err(dev, "failed to get supplies: %d\n", ret); return ret; } ret = regulator_bulk_enable(ARRAY_SIZE(cs53l30->supplies), cs53l30->supplies); if (ret) { dev_err(dev, "failed to enable supplies: %d\n", ret); return ret; } /* Reset the Device */ cs53l30->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(cs53l30->reset_gpio)) { ret = PTR_ERR(cs53l30->reset_gpio); goto error; } gpiod_set_value_cansleep(cs53l30->reset_gpio, 1); i2c_set_clientdata(client, cs53l30); cs53l30->mclk_rate = 0; cs53l30->regmap = devm_regmap_init_i2c(client, &cs53l30_regmap); if (IS_ERR(cs53l30->regmap)) { ret = PTR_ERR(cs53l30->regmap); dev_err(dev, "regmap_init() failed: %d\n", ret); goto error; } /* Initialize codec */ ret = regmap_read(cs53l30->regmap, CS53L30_DEVID_AB, ®); devid = reg << 12; ret = regmap_read(cs53l30->regmap, CS53L30_DEVID_CD, ®); devid |= reg << 4; ret = regmap_read(cs53l30->regmap, CS53L30_DEVID_E, ®); devid |= (reg & 0xF0) >> 4; if (devid != CS53L30_DEVID) { ret = -ENODEV; dev_err(dev, "Device ID (%X). Expected %X\n", devid, CS53L30_DEVID); goto error; } ret = regmap_read(cs53l30->regmap, CS53L30_REVID, ®); if (ret < 0) { dev_err(dev, "failed to get Revision ID: %d\n", ret); goto error; } /* Check if MCLK provided */ cs53l30->mclk = devm_clk_get(dev, "mclk"); if (IS_ERR(cs53l30->mclk)) { if (PTR_ERR(cs53l30->mclk) != -ENOENT) { ret = PTR_ERR(cs53l30->mclk); goto error; } /* Otherwise mark the mclk pointer to NULL */ cs53l30->mclk = NULL; } /* Fetch the MUTE control */ cs53l30->mute_gpio = devm_gpiod_get_optional(dev, "mute", GPIOD_OUT_HIGH); if (IS_ERR(cs53l30->mute_gpio)) { ret = PTR_ERR(cs53l30->mute_gpio); goto error; } if (cs53l30->mute_gpio) { /* Enable MUTE controls via MUTE pin */ regmap_write(cs53l30->regmap, CS53L30_MUTEP_CTL1, CS53L30_MUTEP_CTL1_MUTEALL); /* Flip the polarity of MUTE pin */ if (gpiod_is_active_low(cs53l30->mute_gpio)) regmap_update_bits(cs53l30->regmap, CS53L30_MUTEP_CTL2, CS53L30_MUTE_PIN_POLARITY, 0); } if (!of_property_read_u8(np, "cirrus,micbias-lvl", &val)) regmap_update_bits(cs53l30->regmap, CS53L30_MICBIAS_CTL, CS53L30_MIC_BIAS_CTRL_MASK, val); if (of_property_read_bool(np, "cirrus,use-sdout2")) cs53l30->use_sdout2 = true; dev_info(dev, "Cirrus Logic CS53L30, Revision: %02X\n", reg & 0xFF); ret = snd_soc_register_codec(dev, &cs53l30_driver, &cs53l30_dai, 1); if (ret) { dev_err(dev, "failed to register codec: %d\n", ret); goto error; } return 0; error: regulator_bulk_disable(ARRAY_SIZE(cs53l30->supplies), cs53l30->supplies); return ret; }
int dw_pcie_ep_init(struct dw_pcie_ep *ep) { int ret; void *addr; enum pci_barno bar; struct pci_epc *epc; struct dw_pcie *pci = to_dw_pcie_from_ep(ep); struct device *dev = pci->dev; struct device_node *np = dev->of_node; if (!pci->dbi_base || !pci->dbi_base2) { dev_err(dev, "dbi_base/deb_base2 is not populated\n"); return -EINVAL; } ret = of_property_read_u32(np, "num-ib-windows", &ep->num_ib_windows); if (ret < 0) { dev_err(dev, "unable to read *num-ib-windows* property\n"); return ret; } ret = of_property_read_u32(np, "num-ob-windows", &ep->num_ob_windows); if (ret < 0) { dev_err(dev, "unable to read *num-ob-windows* property\n"); return ret; } addr = devm_kzalloc(dev, sizeof(phys_addr_t) * ep->num_ob_windows, GFP_KERNEL); if (!addr) return -ENOMEM; ep->outbound_addr = addr; for (bar = BAR_0; bar <= BAR_5; bar++) dw_pcie_ep_reset_bar(pci, bar); if (ep->ops->ep_init) ep->ops->ep_init(ep); epc = devm_pci_epc_create(dev, &epc_ops); if (IS_ERR(epc)) { dev_err(dev, "failed to create epc device\n"); return PTR_ERR(epc); } ret = of_property_read_u8(np, "max-functions", &epc->max_functions); if (ret < 0) epc->max_functions = 1; ret = pci_epc_mem_init(epc, ep->phys_base, ep->addr_size); if (ret < 0) { dev_err(dev, "Failed to initialize address space\n"); return ret; } ep->epc = epc; epc_set_drvdata(epc, ep); dw_pcie_setup(pci); return 0; }