struct hisi_clock_data *hisi_clk_alloc(struct platform_device *pdev, int nr_clks) { struct hisi_clock_data *clk_data; struct resource *res; struct clk **clk_table; clk_data = devm_kmalloc(&pdev->dev, sizeof(*clk_data), GFP_KERNEL); if (!clk_data) return NULL; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return NULL; clk_data->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!clk_data->base) return NULL; clk_table = devm_kmalloc_array(&pdev->dev, nr_clks, sizeof(*clk_table), GFP_KERNEL); if (!clk_table) return NULL; clk_data->clk_data.clks = clk_table; clk_data->clk_data.clk_num = nr_clks; return clk_data; }
static int gswip_gphy_fw_list(struct gswip_priv *priv, struct device_node *gphy_fw_list_np, u32 version) { struct device *dev = priv->dev; struct device_node *gphy_fw_np; const struct of_device_id *match; int err; int i = 0; /* The VRX200 rev 1.1 uses the GSWIP 2.0 and needs the older * GPHY firmware. The VRX200 rev 1.2 uses the GSWIP 2.1 and also * needs a different GPHY firmware. */ if (of_device_is_compatible(gphy_fw_list_np, "lantiq,xrx200-gphy-fw")) { switch (version) { case GSWIP_VERSION_2_0: priv->gphy_fw_name_cfg = &xrx200a1x_gphy_data; break; case GSWIP_VERSION_2_1: priv->gphy_fw_name_cfg = &xrx200a2x_gphy_data; break; default: dev_err(dev, "unknown GSWIP version: 0x%x", version); return -ENOENT; } } match = of_match_node(xway_gphy_match, gphy_fw_list_np); if (match && match->data) priv->gphy_fw_name_cfg = match->data; if (!priv->gphy_fw_name_cfg) { dev_err(dev, "GPHY compatible type not supported"); return -ENOENT; } priv->num_gphy_fw = of_get_available_child_count(gphy_fw_list_np); if (!priv->num_gphy_fw) return -ENOENT; priv->rcu_regmap = syscon_regmap_lookup_by_phandle(gphy_fw_list_np, "lantiq,rcu"); if (IS_ERR(priv->rcu_regmap)) return PTR_ERR(priv->rcu_regmap); priv->gphy_fw = devm_kmalloc_array(dev, priv->num_gphy_fw, sizeof(*priv->gphy_fw), GFP_KERNEL | __GFP_ZERO); if (!priv->gphy_fw) return -ENOMEM; for_each_available_child_of_node(gphy_fw_list_np, gphy_fw_np) { err = gswip_gphy_fw_probe(priv, &priv->gphy_fw[i], gphy_fw_np, i); if (err) goto remove_gphy; i++; }
int xgene_extd_stats_init(struct xgene_enet_pdata *pdata) { pdata->extd_stats = devm_kmalloc_array(&pdata->pdev->dev, XGENE_EXTD_STATS_LEN, sizeof(u64), GFP_KERNEL); if (!pdata->extd_stats) return -ENOMEM; xgene_get_extd_stats(pdata); memset(pdata->extd_stats, 0, XGENE_EXTD_STATS_LEN * sizeof(u64)); return 0; }
static int qcom_usb_hs_phy_probe(struct ulpi *ulpi) { struct qcom_usb_hs_phy *uphy; struct phy_provider *p; struct clk *clk; struct regulator *reg; struct reset_control *reset; int size; int ret; uphy = devm_kzalloc(&ulpi->dev, sizeof(*uphy), GFP_KERNEL); if (!uphy) return -ENOMEM; ulpi_set_drvdata(ulpi, uphy); uphy->ulpi = ulpi; size = of_property_count_u8_elems(ulpi->dev.of_node, "qcom,init-seq"); if (size < 0) size = 0; uphy->init_seq = devm_kmalloc_array(&ulpi->dev, (size / 2) + 1, sizeof(*uphy->init_seq), GFP_KERNEL); if (!uphy->init_seq) return -ENOMEM; ret = of_property_read_u8_array(ulpi->dev.of_node, "qcom,init-seq", (u8 *)uphy->init_seq, size); if (ret && size) return ret; /* NUL terminate */ uphy->init_seq[size / 2].addr = uphy->init_seq[size / 2].val = 0; uphy->ref_clk = clk = devm_clk_get(&ulpi->dev, "ref"); if (IS_ERR(clk)) return PTR_ERR(clk); uphy->sleep_clk = clk = devm_clk_get(&ulpi->dev, "sleep"); if (IS_ERR(clk)) return PTR_ERR(clk); uphy->v1p8 = reg = devm_regulator_get(&ulpi->dev, "v1p8"); if (IS_ERR(reg)) return PTR_ERR(reg); uphy->v3p3 = reg = devm_regulator_get(&ulpi->dev, "v3p3"); if (IS_ERR(reg)) return PTR_ERR(reg); uphy->reset = reset = devm_reset_control_get(&ulpi->dev, "por"); if (IS_ERR(reset)) { if (PTR_ERR(reset) == -EPROBE_DEFER) return PTR_ERR(reset); uphy->reset = NULL; } uphy->phy = devm_phy_create(&ulpi->dev, ulpi->dev.of_node, &qcom_usb_hs_phy_ops); if (IS_ERR(uphy->phy)) return PTR_ERR(uphy->phy); uphy->vbus_edev = extcon_get_edev_by_phandle(&ulpi->dev, 0); if (IS_ERR(uphy->vbus_edev)) { if (PTR_ERR(uphy->vbus_edev) != -ENODEV) return PTR_ERR(uphy->vbus_edev); uphy->vbus_edev = NULL; } uphy->vbus_notify.notifier_call = qcom_usb_hs_phy_vbus_notifier; phy_set_drvdata(uphy->phy, uphy); p = devm_of_phy_provider_register(&ulpi->dev, of_phy_simple_xlate); return PTR_ERR_OR_ZERO(p); }
static int __init cpg_mssr_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; const struct cpg_mssr_info *info; struct cpg_mssr_priv *priv; unsigned int nclks, i; struct resource *res; struct clk **clks; int error; info = of_match_node(cpg_mssr_match, np)->data; if (info->init) { error = info->init(dev); if (error) return error; } priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->dev = dev; spin_lock_init(&priv->mstp_lock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->base = devm_ioremap_resource(dev, res); if (IS_ERR(priv->base)) return PTR_ERR(priv->base); nclks = info->num_total_core_clks + info->num_hw_mod_clks; clks = devm_kmalloc_array(dev, nclks, sizeof(*clks), GFP_KERNEL); if (!clks) return -ENOMEM; priv->clks = clks; priv->num_core_clks = info->num_total_core_clks; priv->num_mod_clks = info->num_hw_mod_clks; priv->last_dt_core_clk = info->last_dt_core_clk; for (i = 0; i < nclks; i++) clks[i] = ERR_PTR(-ENOENT); for (i = 0; i < info->num_core_clks; i++) cpg_mssr_register_core_clk(&info->core_clks[i], info, priv); for (i = 0; i < info->num_mod_clks; i++) cpg_mssr_register_mod_clk(&info->mod_clks[i], info, priv); error = of_clk_add_provider(np, cpg_mssr_clk_src_twocell_get, priv); if (error) return error; error = devm_add_action_or_reset(dev, cpg_mssr_del_clk_provider, np); if (error) return error; error = cpg_mssr_add_clk_domain(dev, info->core_pm_clks, info->num_core_pm_clks); if (error) return error; return 0; }
/** * dprc_scan_objects - Discover objects in a DPRC * * @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object * @total_irq_count: total number of IRQs needed by objects in the DPRC. * * Detects objects added and removed from a DPRC and synchronizes the * state of the Linux bus driver, MC by adding and removing * devices accordingly. * Two types of devices can be found in a DPRC: allocatable objects (e.g., * dpbp, dpmcp) and non-allocatable devices (e.g., dprc, dpni). * All allocatable devices needed to be probed before all non-allocatable * devices, to ensure that device drivers for non-allocatable * devices can allocate any type of allocatable devices. * That is, we need to ensure that the corresponding resource pools are * populated before they can get allocation requests from probe callbacks * of the device drivers for the non-allocatable devices. */ int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev, unsigned int *total_irq_count) { int num_child_objects; int dprc_get_obj_failures; int error; unsigned int irq_count = mc_bus_dev->obj_desc.irq_count; struct dprc_obj_desc *child_obj_desc_array = NULL; error = dprc_get_obj_count(mc_bus_dev->mc_io, 0, mc_bus_dev->mc_handle, &num_child_objects); if (error < 0) { dev_err(&mc_bus_dev->dev, "dprc_get_obj_count() failed: %d\n", error); return error; } if (num_child_objects != 0) { int i; child_obj_desc_array = devm_kmalloc_array(&mc_bus_dev->dev, num_child_objects, sizeof(*child_obj_desc_array), GFP_KERNEL); if (!child_obj_desc_array) return -ENOMEM; /* * Discover objects currently present in the physical DPRC: */ dprc_get_obj_failures = 0; for (i = 0; i < num_child_objects; i++) { struct dprc_obj_desc *obj_desc = &child_obj_desc_array[i]; error = dprc_get_obj(mc_bus_dev->mc_io, 0, mc_bus_dev->mc_handle, i, obj_desc); if (error < 0) { dev_err(&mc_bus_dev->dev, "dprc_get_obj(i=%d) failed: %d\n", i, error); /* * Mark the obj entry as "invalid", by using the * empty string as obj type: */ obj_desc->type[0] = '\0'; obj_desc->id = error; dprc_get_obj_failures++; continue; } /* * add a quirk for all versions of dpsec < 4.0...none * are coherent regardless of what the MC reports. */ if ((strcmp(obj_desc->type, "dpseci") == 0) && (obj_desc->ver_major < 4)) obj_desc->flags |= DPRC_OBJ_FLAG_NO_MEM_SHAREABILITY; irq_count += obj_desc->irq_count; dev_dbg(&mc_bus_dev->dev, "Discovered object: type %s, id %d\n", obj_desc->type, obj_desc->id); } if (dprc_get_obj_failures != 0) { dev_err(&mc_bus_dev->dev, "%d out of %d devices could not be retrieved\n", dprc_get_obj_failures, num_child_objects); } } *total_irq_count = irq_count; dprc_remove_devices(mc_bus_dev, child_obj_desc_array, num_child_objects); dprc_add_new_devices(mc_bus_dev, child_obj_desc_array, num_child_objects); if (child_obj_desc_array) devm_kfree(&mc_bus_dev->dev, child_obj_desc_array); return 0; }