/** * devm_regmap_init_iobg(): Initialise managed register map * * @iobg: Device that will be interacted with * @config: Configuration for register map * * The return value will be an ERR_PTR() on error or a valid pointer * to a struct regmap. The regmap will be automatically freed by the * device management code. */ struct regmap *devm_regmap_init_iobg(struct device *dev, const struct regmap_config *config) { const struct regmap_bus *bus = ®map_iobg; return devm_regmap_init(dev, bus, dev, config); }
static int uda134x_codec_probe(struct platform_device *pdev) { struct uda134x_platform_data *pd = pdev->dev.platform_data; struct uda134x_priv *uda134x; if (!pd) { dev_err(&pdev->dev, "Missing L3 bitbang function\n"); return -ENODEV; } uda134x = devm_kzalloc(&pdev->dev, sizeof(*uda134x), GFP_KERNEL); if (!uda134x) return -ENOMEM; uda134x->pd = pd; platform_set_drvdata(pdev, uda134x); uda134x->regmap = devm_regmap_init(&pdev->dev, NULL, pd, &uda134x_regmap_config); if (IS_ERR(uda134x->regmap)) return PTR_ERR(uda134x->regmap); return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_uda134x, &uda134x_dai, 1); }
/** * devm_regmap_init_i2c(): Initialise managed register map * * @i2c: Device that will be interacted with * @config: Configuration for register map * * The return value will be an ERR_PTR() on error or a valid pointer * to a struct regmap. The regmap will be automatically freed by the * device management code. */ struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, const struct regmap_config *config) { const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config); if (IS_ERR(bus)) return ERR_CAST(bus); return devm_regmap_init(&i2c->dev, bus, &i2c->dev, config); }
/** * devm_regmap_init_mcuio(): Initialise mcuio register map, device manage * version * * @dev: Device that will be interacted with * @hc: mcuio system controller * @config: Configuration for register map * * The return value will be an ERR_PTR() on error or a valid pointer to * a struct regmap. */ struct regmap *devm_regmap_init_mcuio(struct mcuio_device *mdev, const struct regmap_config *config) { struct regmap_mcuio_context *ctx; ctx = regmap_mcuio_setup_context(mdev, config); if (IS_ERR(ctx)) return ERR_CAST(ctx); return devm_regmap_init(&mdev->dev, ®map_mcuio, ctx, config); }
/** * devm_regmap_init_mmio(): Initialise managed register map * * @dev: Device that will be interacted with * @regs: Pointer to memory-mapped IO region * @config: Configuration for register map * * The return value will be an ERR_PTR() on error or a valid pointer * to a struct regmap. The regmap will be automatically freed by the * device management code. */ struct regmap *devm_regmap_init_mmio(struct device *dev, void __iomem *regs, const struct regmap_config *config) { struct regmap_mmio_context *ctx; ctx = regmap_mmio_gen_context(regs, config); if (IS_ERR(ctx)) return ERR_CAST(ctx); return devm_regmap_init(dev, ®map_mmio, ctx, config); }
static int sn95031_device_probe(struct platform_device *pdev) { struct regmap *regmap; pr_debug("codec device probe called for %s\n", dev_name(&pdev->dev)); regmap = devm_regmap_init(&pdev->dev, NULL, NULL, &sn95031_regmap); if (IS_ERR(regmap)) return PTR_ERR(regmap); return snd_soc_register_codec(&pdev->dev, &sn95031_codec, sn95031_dais, ARRAY_SIZE(sn95031_dais)); }
static int tas5086_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct tas5086_private *priv; struct device *dev = &i2c->dev; int gpio_nreset = -EINVAL; int i, ret; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->regmap = devm_regmap_init(dev, NULL, i2c, &tas5086_regmap); if (IS_ERR(priv->regmap)) { ret = PTR_ERR(priv->regmap); dev_err(&i2c->dev, "Failed to create regmap: %d\n", ret); return ret; } i2c_set_clientdata(i2c, priv); if (of_match_device(of_match_ptr(tas5086_dt_ids), dev)) { struct device_node *of_node = dev->of_node; gpio_nreset = of_get_named_gpio(of_node, "reset-gpio", 0); } if (gpio_is_valid(gpio_nreset)) if (devm_gpio_request(dev, gpio_nreset, "TAS5086 Reset")) gpio_nreset = -EINVAL; priv->gpio_nreset = gpio_nreset; tas5086_reset(priv); /* The TAS5086 always returns 0x03 in its TAS5086_DEV_ID register */ ret = regmap_read(priv->regmap, TAS5086_DEV_ID, &i); if (ret < 0) return ret; if (i != 0x3) { dev_err(dev, "Failed to identify TAS5086 codec (got %02x)\n", i); return -ENODEV; } return snd_soc_register_codec(&i2c->dev, &soc_codec_dev_tas5086, &tas5086_dai, 1); }
static int rockchip_efuse_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct resource *res; struct nvmem_device *nvmem; struct regmap *regmap; void __iomem *base; struct clk *clk; struct rockchip_efuse_context *context; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); base = devm_ioremap_resource(dev, res); if (IS_ERR(base)) return PTR_ERR(base); context = devm_kzalloc(dev, sizeof(struct rockchip_efuse_context), GFP_KERNEL); if (IS_ERR(context)) return PTR_ERR(context); clk = devm_clk_get(dev, "pclk_efuse"); if (IS_ERR(clk)) return PTR_ERR(clk); context->dev = dev; context->base = base; context->efuse_clk = clk; rockchip_efuse_regmap_config.max_register = resource_size(res) - 1; regmap = devm_regmap_init(dev, &rockchip_efuse_bus, context, &rockchip_efuse_regmap_config); if (IS_ERR(regmap)) { dev_err(dev, "regmap init failed\n"); return PTR_ERR(regmap); } econfig.dev = dev; nvmem = nvmem_register(&econfig); if (IS_ERR(nvmem)) return PTR_ERR(nvmem); platform_set_drvdata(pdev, nvmem); return 0; }
static int tas571x_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct tas571x_private *priv; struct device *dev = &client->dev; const struct of_device_id *of_id; int i, ret; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; i2c_set_clientdata(client, priv); of_id = of_match_device(tas571x_of_match, dev); if (of_id) priv->chip = of_id->data; else priv->chip = (void *) id->driver_data; priv->mclk = devm_clk_get(dev, "mclk"); if (IS_ERR(priv->mclk) && PTR_ERR(priv->mclk) != -ENOENT) { dev_err(dev, "Failed to request mclk: %ld\n", PTR_ERR(priv->mclk)); return PTR_ERR(priv->mclk); } if (WARN_ON(priv->chip->num_supply_names > TAS571X_MAX_SUPPLIES)) return -EINVAL; for (i = 0; i < priv->chip->num_supply_names; i++) priv->supplies[i].supply = priv->chip->supply_names[i]; ret = devm_regulator_bulk_get(dev, priv->chip->num_supply_names, priv->supplies); if (ret) { dev_err(dev, "Failed to get supplies: %d\n", ret); return ret; } ret = regulator_bulk_enable(priv->chip->num_supply_names, priv->supplies); if (ret) { dev_err(dev, "Failed to enable supplies: %d\n", ret); return ret; } priv->regmap = devm_regmap_init(dev, NULL, client, priv->chip->regmap_config); if (IS_ERR(priv->regmap)) return PTR_ERR(priv->regmap); priv->pdn_gpio = devm_gpiod_get_optional(dev, "pdn", GPIOD_OUT_LOW); if (IS_ERR(priv->pdn_gpio)) { dev_err(dev, "error requesting pdn_gpio: %ld\n", PTR_ERR(priv->pdn_gpio)); return PTR_ERR(priv->pdn_gpio); } priv->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(priv->reset_gpio)) { dev_err(dev, "error requesting reset_gpio: %ld\n", PTR_ERR(priv->reset_gpio)); return PTR_ERR(priv->reset_gpio); } else if (priv->reset_gpio) { /* pulse the active low reset line for ~100us */ usleep_range(100, 200); gpiod_set_value(priv->reset_gpio, 0); usleep_range(13500, 20000); } ret = regmap_write(priv->regmap, TAS571X_OSC_TRIM_REG, 0); if (ret) return ret; usleep_range(50000, 60000); memcpy(&priv->component_driver, &tas571x_component, sizeof(priv->component_driver)); priv->component_driver.controls = priv->chip->controls; priv->component_driver.num_controls = priv->chip->num_controls; if (priv->chip->vol_reg_size == 2) { /* * The master volume defaults to 0x3ff (mute), but we ignore * (zero) the LSB because the hardware step size is 0.125 dB * and TLV_DB_SCALE_ITEM has a resolution of 0.01 dB. */ ret = regmap_update_bits(priv->regmap, TAS571X_MVOL_REG, 1, 0); if (ret) return ret; } return devm_snd_soc_register_component(&client->dev, &priv->component_driver, &tas571x_dai, 1); }
/** * devm_regmap_init_ac97(): Initialise AC'97 register map * * @ac97: Device that will be interacted with * @config: Configuration for register map * * The return value will be an ERR_PTR() on error or a valid pointer * to a struct regmap. The regmap will be automatically freed by the * device management code. */ struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97, const struct regmap_config *config) { return devm_regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config); }
/** * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space * @sdev: SPMI device that will be interacted with * @config: Configuration for register map * * The return value will be an ERR_PTR() on error or a valid pointer * to a struct regmap. The regmap will be automatically freed by the * device management code. */ struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *sdev, const struct regmap_config *config) { return devm_regmap_init(&sdev->dev, ®map_spmi_ext, sdev, config); }
/** * devm_regmap_init_i2c(): Initialise managed register map * * @i2c: Device that will be interacted with * @config: Configuration for register map * * The return value will be an ERR_PTR() on error or a valid pointer * to a struct regmap. The regmap will be automatically freed by the * device management code. */ struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, const struct regmap_config *config) { return devm_regmap_init(&i2c->dev, ®map_i2c, &i2c->dev, config); }
static int adau1701_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adau1701 *adau1701; struct device *dev = &client->dev; int gpio_nreset = -EINVAL; int gpio_pll_mode[2] = { -EINVAL, -EINVAL }; int ret, i; adau1701 = devm_kzalloc(dev, sizeof(*adau1701), GFP_KERNEL); if (!adau1701) return -ENOMEM; for (i = 0; i < ARRAY_SIZE(supply_names); i++) adau1701->supplies[i].supply = supply_names[i]; ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(adau1701->supplies), adau1701->supplies); if (ret < 0) { dev_err(dev, "Failed to get regulators: %d\n", ret); return ret; } ret = regulator_bulk_enable(ARRAY_SIZE(adau1701->supplies), adau1701->supplies); if (ret < 0) { dev_err(dev, "Failed to enable regulators: %d\n", ret); return ret; } adau1701->client = client; adau1701->regmap = devm_regmap_init(dev, NULL, client, &adau1701_regmap); if (IS_ERR(adau1701->regmap)) { ret = PTR_ERR(adau1701->regmap); goto exit_regulators_disable; } if (dev->of_node) { gpio_nreset = of_get_named_gpio(dev->of_node, "reset-gpio", 0); if (gpio_nreset < 0 && gpio_nreset != -ENOENT) { ret = gpio_nreset; goto exit_regulators_disable; } gpio_pll_mode[0] = of_get_named_gpio(dev->of_node, "adi,pll-mode-gpios", 0); if (gpio_pll_mode[0] < 0 && gpio_pll_mode[0] != -ENOENT) { ret = gpio_pll_mode[0]; goto exit_regulators_disable; } gpio_pll_mode[1] = of_get_named_gpio(dev->of_node, "adi,pll-mode-gpios", 1); if (gpio_pll_mode[1] < 0 && gpio_pll_mode[1] != -ENOENT) { ret = gpio_pll_mode[1]; goto exit_regulators_disable; } of_property_read_u32(dev->of_node, "adi,pll-clkdiv", &adau1701->pll_clkdiv); of_property_read_u8_array(dev->of_node, "adi,pin-config", adau1701->pin_config, ARRAY_SIZE(adau1701->pin_config)); } if (gpio_is_valid(gpio_nreset)) { ret = devm_gpio_request_one(dev, gpio_nreset, GPIOF_OUT_INIT_LOW, "ADAU1701 Reset"); if (ret < 0) goto exit_regulators_disable; } if (gpio_is_valid(gpio_pll_mode[0]) && gpio_is_valid(gpio_pll_mode[1])) { ret = devm_gpio_request_one(dev, gpio_pll_mode[0], GPIOF_OUT_INIT_LOW, "ADAU1701 PLL mode 0"); if (ret < 0) goto exit_regulators_disable; ret = devm_gpio_request_one(dev, gpio_pll_mode[1], GPIOF_OUT_INIT_LOW, "ADAU1701 PLL mode 1"); if (ret < 0) goto exit_regulators_disable; } adau1701->gpio_nreset = gpio_nreset; adau1701->gpio_pll_mode[0] = gpio_pll_mode[0]; adau1701->gpio_pll_mode[1] = gpio_pll_mode[1]; i2c_set_clientdata(client, adau1701); adau1701->sigmadsp = devm_sigmadsp_init_i2c(client, &adau1701_sigmadsp_ops, ADAU1701_FIRMWARE); if (IS_ERR(adau1701->sigmadsp)) { ret = PTR_ERR(adau1701->sigmadsp); goto exit_regulators_disable; } ret = snd_soc_register_codec(&client->dev, &adau1701_codec_drv, &adau1701_dai, 1); exit_regulators_disable: regulator_bulk_disable(ARRAY_SIZE(adau1701->supplies), adau1701->supplies); return ret; }
static int tas5086_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct tas5086_private *priv; struct device *dev = &i2c->dev; int gpio_nreset = -EINVAL; int i, ret; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; for (i = 0; i < ARRAY_SIZE(supply_names); i++) priv->supplies[i].supply = supply_names[i]; ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(priv->supplies), priv->supplies); if (ret < 0) { dev_err(dev, "Failed to get regulators: %d\n", ret); return ret; } priv->regmap = devm_regmap_init(dev, NULL, i2c, &tas5086_regmap); if (IS_ERR(priv->regmap)) { ret = PTR_ERR(priv->regmap); dev_err(&i2c->dev, "Failed to create regmap: %d\n", ret); return ret; } i2c_set_clientdata(i2c, priv); if (of_match_device(of_match_ptr(tas5086_dt_ids), dev)) { struct device_node *of_node = dev->of_node; gpio_nreset = of_get_named_gpio(of_node, "reset-gpio", 0); } if (gpio_is_valid(gpio_nreset)) if (devm_gpio_request(dev, gpio_nreset, "TAS5086 Reset")) gpio_nreset = -EINVAL; priv->gpio_nreset = gpio_nreset; ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), priv->supplies); if (ret < 0) { dev_err(dev, "Failed to enable regulators: %d\n", ret); return ret; } tas5086_reset(priv); /* The TAS5086 always returns 0x03 in its TAS5086_DEV_ID register */ ret = regmap_read(priv->regmap, TAS5086_DEV_ID, &i); if (ret == 0 && i != 0x3) { dev_err(dev, "Failed to identify TAS5086 codec (got %02x)\n", i); ret = -ENODEV; } /* * The chip has been identified, so we can turn off the power * again until the dai link is set up. */ regulator_bulk_disable(ARRAY_SIZE(priv->supplies), priv->supplies); if (ret == 0) ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_tas5086, &tas5086_dai, 1); return ret; }
static int meson_dw_hdmi_bind(struct device *dev, struct device *master, void *data) { struct platform_device *pdev = to_platform_device(dev); const struct meson_dw_hdmi_data *match; struct meson_dw_hdmi *meson_dw_hdmi; struct drm_device *drm = data; struct meson_drm *priv = drm->dev_private; struct dw_hdmi_plat_data *dw_plat_data; struct drm_encoder *encoder; struct resource *res; int irq; int ret; DRM_DEBUG_DRIVER("\n"); if (!meson_hdmi_connector_is_available(dev)) { dev_info(drm->dev, "HDMI Output connector not available\n"); return -ENODEV; } match = of_device_get_match_data(&pdev->dev); if (!match) { dev_err(&pdev->dev, "failed to get match data\n"); return -ENODEV; } meson_dw_hdmi = devm_kzalloc(dev, sizeof(*meson_dw_hdmi), GFP_KERNEL); if (!meson_dw_hdmi) return -ENOMEM; meson_dw_hdmi->priv = priv; meson_dw_hdmi->dev = dev; meson_dw_hdmi->data = match; dw_plat_data = &meson_dw_hdmi->dw_plat_data; encoder = &meson_dw_hdmi->encoder; meson_dw_hdmi->hdmi_supply = devm_regulator_get_optional(dev, "hdmi"); if (IS_ERR(meson_dw_hdmi->hdmi_supply)) { if (PTR_ERR(meson_dw_hdmi->hdmi_supply) == -EPROBE_DEFER) return -EPROBE_DEFER; meson_dw_hdmi->hdmi_supply = NULL; } else { ret = regulator_enable(meson_dw_hdmi->hdmi_supply); if (ret) return ret; } meson_dw_hdmi->hdmitx_apb = devm_reset_control_get_exclusive(dev, "hdmitx_apb"); if (IS_ERR(meson_dw_hdmi->hdmitx_apb)) { dev_err(dev, "Failed to get hdmitx_apb reset\n"); return PTR_ERR(meson_dw_hdmi->hdmitx_apb); } meson_dw_hdmi->hdmitx_ctrl = devm_reset_control_get_exclusive(dev, "hdmitx"); if (IS_ERR(meson_dw_hdmi->hdmitx_ctrl)) { dev_err(dev, "Failed to get hdmitx reset\n"); return PTR_ERR(meson_dw_hdmi->hdmitx_ctrl); } meson_dw_hdmi->hdmitx_phy = devm_reset_control_get_exclusive(dev, "hdmitx_phy"); if (IS_ERR(meson_dw_hdmi->hdmitx_phy)) { dev_err(dev, "Failed to get hdmitx_phy reset\n"); return PTR_ERR(meson_dw_hdmi->hdmitx_phy); } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); meson_dw_hdmi->hdmitx = devm_ioremap_resource(dev, res); if (IS_ERR(meson_dw_hdmi->hdmitx)) return PTR_ERR(meson_dw_hdmi->hdmitx); meson_dw_hdmi->hdmi_pclk = devm_clk_get(dev, "isfr"); if (IS_ERR(meson_dw_hdmi->hdmi_pclk)) { dev_err(dev, "Unable to get HDMI pclk\n"); return PTR_ERR(meson_dw_hdmi->hdmi_pclk); } clk_prepare_enable(meson_dw_hdmi->hdmi_pclk); meson_dw_hdmi->venci_clk = devm_clk_get(dev, "venci"); if (IS_ERR(meson_dw_hdmi->venci_clk)) { dev_err(dev, "Unable to get venci clk\n"); return PTR_ERR(meson_dw_hdmi->venci_clk); } clk_prepare_enable(meson_dw_hdmi->venci_clk); dw_plat_data->regm = devm_regmap_init(dev, NULL, meson_dw_hdmi, &meson_dw_hdmi_regmap_config); if (IS_ERR(dw_plat_data->regm)) return PTR_ERR(dw_plat_data->regm); irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(dev, "Failed to get hdmi top irq\n"); return irq; } ret = devm_request_threaded_irq(dev, irq, dw_hdmi_top_irq, dw_hdmi_top_thread_irq, IRQF_SHARED, "dw_hdmi_top_irq", meson_dw_hdmi); if (ret) { dev_err(dev, "Failed to request hdmi top irq\n"); return ret; } /* Encoder */ drm_encoder_helper_add(encoder, &meson_venc_hdmi_encoder_helper_funcs); ret = drm_encoder_init(drm, encoder, &meson_venc_hdmi_encoder_funcs, DRM_MODE_ENCODER_TMDS, "meson_hdmi"); if (ret) { dev_err(priv->dev, "Failed to init HDMI encoder\n"); return ret; } encoder->possible_crtcs = BIT(0); DRM_DEBUG_DRIVER("encoder initialized\n"); /* Enable clocks */ regmap_update_bits(priv->hhi, HHI_HDMI_CLK_CNTL, 0xffff, 0x100); /* Bring HDMITX MEM output of power down */ regmap_update_bits(priv->hhi, HHI_MEM_PD_REG0, 0xff << 8, 0); /* Reset HDMITX APB & TX & PHY */ reset_control_reset(meson_dw_hdmi->hdmitx_apb); reset_control_reset(meson_dw_hdmi->hdmitx_ctrl); reset_control_reset(meson_dw_hdmi->hdmitx_phy); /* Enable APB3 fail on error */ if (!meson_vpu_is_compatible(priv, "amlogic,meson-g12a-vpu")) { writel_bits_relaxed(BIT(15), BIT(15), meson_dw_hdmi->hdmitx + HDMITX_TOP_CTRL_REG); writel_bits_relaxed(BIT(15), BIT(15), meson_dw_hdmi->hdmitx + HDMITX_DWC_CTRL_REG); } /* Bring out of reset */ meson_dw_hdmi->data->top_write(meson_dw_hdmi, HDMITX_TOP_SW_RESET, 0); msleep(20); meson_dw_hdmi->data->top_write(meson_dw_hdmi, HDMITX_TOP_CLK_CNTL, 0xff); /* Enable HDMI-TX Interrupt */ meson_dw_hdmi->data->top_write(meson_dw_hdmi, HDMITX_TOP_INTR_STAT_CLR, HDMITX_TOP_INTR_CORE); meson_dw_hdmi->data->top_write(meson_dw_hdmi, HDMITX_TOP_INTR_MASKN, HDMITX_TOP_INTR_CORE); /* Bridge / Connector */ dw_plat_data->mode_valid = dw_hdmi_mode_valid; dw_plat_data->phy_ops = &meson_dw_hdmi_phy_ops; dw_plat_data->phy_name = "meson_dw_hdmi_phy"; dw_plat_data->phy_data = meson_dw_hdmi; dw_plat_data->input_bus_format = MEDIA_BUS_FMT_YUV8_1X24; dw_plat_data->input_bus_encoding = V4L2_YCBCR_ENC_709; platform_set_drvdata(pdev, meson_dw_hdmi); meson_dw_hdmi->hdmi = dw_hdmi_bind(pdev, encoder, &meson_dw_hdmi->dw_plat_data); if (IS_ERR(meson_dw_hdmi->hdmi)) return PTR_ERR(meson_dw_hdmi->hdmi); DRM_DEBUG_DRIVER("HDMI controller initialized\n"); return 0; }
static int mc13xxx_spi_read(void *context, const void *reg, size_t reg_size, void *val, size_t val_size) { unsigned char w[4] = { *((unsigned char *) reg), 0, 0, 0}; unsigned char r[4]; unsigned char *p = val; struct device *dev = context; struct spi_device *spi = to_spi_device(dev); struct spi_transfer t = { .tx_buf = w, .rx_buf = r, .len = 4, }; struct spi_message m; int ret; if (val_size != 3 || reg_size != 1) return -ENOTSUPP; spi_message_init(&m); spi_message_add_tail(&t, &m); ret = spi_sync(spi, &m); memcpy(p, &r[1], 3); return ret; } static int mc13xxx_spi_write(void *context, const void *data, size_t count) { struct device *dev = context; struct spi_device *spi = to_spi_device(dev); if (count != 4) return -ENOTSUPP; return spi_write(spi, data, count); } /* * We cannot use regmap-spi generic bus implementation here. * The MC13783 chip will get corrupted if CS signal is deasserted * and on i.Mx31 SoC (the target SoC for MC13783 PMIC) the SPI controller * has the following errata (DSPhl22960): * "The CSPI negates SS when the FIFO becomes empty with * SSCTL= 0. Software cannot guarantee that the FIFO will not * drain because of higher priority interrupts and the * non-realtime characteristics of the operating system. As a * result, the SS will negate before all of the data has been * transferred to/from the peripheral." * We workaround this by accessing the SPI controller with a * single transfert. */ static struct regmap_bus regmap_mc13xxx_bus = { .write = mc13xxx_spi_write, .read = mc13xxx_spi_read, }; static int mc13xxx_spi_probe(struct spi_device *spi) { struct mc13xxx *mc13xxx; struct mc13xxx_platform_data *pdata = dev_get_platdata(&spi->dev); int ret; mc13xxx = devm_kzalloc(&spi->dev, sizeof(*mc13xxx), GFP_KERNEL); if (!mc13xxx) return -ENOMEM; spi_set_drvdata(spi, mc13xxx); spi->mode = SPI_MODE_0 | SPI_CS_HIGH; mc13xxx->dev = &spi->dev; mutex_init(&mc13xxx->lock); mc13xxx->regmap = devm_regmap_init(&spi->dev, ®map_mc13xxx_bus, &spi->dev, &mc13xxx_regmap_spi_config); if (IS_ERR(mc13xxx->regmap)) { ret = PTR_ERR(mc13xxx->regmap); dev_err(mc13xxx->dev, "Failed to initialize register map: %d\n", ret); spi_set_drvdata(spi, NULL); return ret; } if (spi->dev.of_node) { const struct of_device_id *of_id = of_match_device(mc13xxx_dt_ids, &spi->dev); mc13xxx->variant = of_id->data; } else { const struct spi_device_id *id_entry = spi_get_device_id(spi); mc13xxx->variant = (void *)id_entry->driver_data; } return mc13xxx_common_init(mc13xxx, pdata, spi->irq); } static int mc13xxx_spi_remove(struct spi_device *spi) { struct mc13xxx *mc13xxx = spi_get_drvdata(spi); mc13xxx_common_cleanup(mc13xxx); return 0; } static struct spi_driver mc13xxx_spi_driver = { .id_table = mc13xxx_device_id, .driver = { .name = "mc13xxx", .owner = THIS_MODULE, .of_match_table = mc13xxx_dt_ids, }, .probe = mc13xxx_spi_probe, .remove = mc13xxx_spi_remove, };
struct regmap *sun8i_adda_pr_regmap_init(struct device *dev, void __iomem *base) { return devm_regmap_init(dev, NULL, base, &adda_pr_regmap_cfg); }
static int sti_sas_driver_probe(struct platform_device *pdev) { struct device_node *pnode = pdev->dev.of_node; struct sti_sas_data *drvdata; const struct of_device_id *of_id; /* Allocate device structure */ drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_data), GFP_KERNEL); if (!drvdata) return -ENOMEM; /* Populate data structure depending on compatibility */ of_id = of_match_node(sti_sas_dev_match, pnode); if (!of_id->data) { dev_err(&pdev->dev, "data associated to device is missing"); return -EINVAL; } drvdata->dev_data = (struct sti_sas_dev_data *)of_id->data; /* Initialise device structure */ drvdata->dev = &pdev->dev; /* Request the DAC & SPDIF registers memory region */ drvdata->dac.virt_regmap = devm_regmap_init(&pdev->dev, NULL, drvdata, drvdata->dev_data->regmap); if (IS_ERR(drvdata->dac.virt_regmap)) { dev_err(&pdev->dev, "audio registers not enabled\n"); return PTR_ERR(drvdata->dac.virt_regmap); } /* Request the syscon region */ drvdata->dac.regmap = syscon_regmap_lookup_by_phandle(pnode, "st,syscfg"); if (IS_ERR(drvdata->dac.regmap)) { dev_err(&pdev->dev, "syscon registers not available\n"); return PTR_ERR(drvdata->dac.regmap); } drvdata->spdif.regmap = drvdata->dac.regmap; /* Set DAC dai probe */ if (drvdata->dev_data->chipid == CHIPID_STIH416) sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].probe = stih416_dac_probe; sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].ops = drvdata->dev_data->dac_ops; /* Set dapms*/ sti_sas_driver.component_driver.dapm_widgets = drvdata->dev_data->dapm_widgets; sti_sas_driver.component_driver.num_dapm_widgets = drvdata->dev_data->num_dapm_widgets; sti_sas_driver.component_driver.dapm_routes = drvdata->dev_data->dapm_routes; sti_sas_driver.component_driver.num_dapm_routes = drvdata->dev_data->num_dapm_routes; /* Store context */ dev_set_drvdata(&pdev->dev, drvdata); return snd_soc_register_codec(&pdev->dev, &sti_sas_driver, sti_sas_dai, ARRAY_SIZE(sti_sas_dai)); }
static int adau1701_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adau1701 *adau1701; struct device *dev = &client->dev; int gpio_nreset = -EINVAL; int gpio_pll_mode[2] = { -EINVAL, -EINVAL }; int ret; adau1701 = devm_kzalloc(dev, sizeof(*adau1701), GFP_KERNEL); if (!adau1701) return -ENOMEM; adau1701->regmap = devm_regmap_init(dev, NULL, client, &adau1701_regmap); if (IS_ERR(adau1701->regmap)) return PTR_ERR(adau1701->regmap); if (dev->of_node) { gpio_nreset = of_get_named_gpio(dev->of_node, "reset-gpio", 0); if (gpio_nreset < 0 && gpio_nreset != -ENOENT) return gpio_nreset; gpio_pll_mode[0] = of_get_named_gpio(dev->of_node, "adi,pll-mode-gpios", 0); if (gpio_pll_mode[0] < 0 && gpio_pll_mode[0] != -ENOENT) return gpio_pll_mode[0]; gpio_pll_mode[1] = of_get_named_gpio(dev->of_node, "adi,pll-mode-gpios", 1); if (gpio_pll_mode[1] < 0 && gpio_pll_mode[1] != -ENOENT) return gpio_pll_mode[1]; of_property_read_u32(dev->of_node, "adi,pll-clkdiv", &adau1701->pll_clkdiv); of_property_read_u8_array(dev->of_node, "adi,pin-config", adau1701->pin_config, ARRAY_SIZE(adau1701->pin_config)); } if (gpio_is_valid(gpio_nreset)) { ret = devm_gpio_request_one(dev, gpio_nreset, GPIOF_OUT_INIT_LOW, "ADAU1701 Reset"); if (ret < 0) return ret; } if (gpio_is_valid(gpio_pll_mode[0]) && gpio_is_valid(gpio_pll_mode[1])) { ret = devm_gpio_request_one(dev, gpio_pll_mode[0], GPIOF_OUT_INIT_LOW, "ADAU1701 PLL mode 0"); if (ret < 0) return ret; ret = devm_gpio_request_one(dev, gpio_pll_mode[1], GPIOF_OUT_INIT_LOW, "ADAU1701 PLL mode 1"); if (ret < 0) return ret; } adau1701->gpio_nreset = gpio_nreset; adau1701->gpio_pll_mode[0] = gpio_pll_mode[0]; adau1701->gpio_pll_mode[1] = gpio_pll_mode[1]; i2c_set_clientdata(client, adau1701); ret = snd_soc_register_codec(&client->dev, &adau1701_codec_drv, &adau1701_dai, 1); return ret; }