static void __init lager_add_standard_devices(void) { r8a7790_clock_init(); pinctrl_register_mappings(lager_pinctrl_map, ARRAY_SIZE(lager_pinctrl_map)); r8a7790_pinmux_init(); r8a7790_add_standard_devices(); platform_device_register_data(&platform_bus, "leds-gpio", -1, &lager_leds_pdata, sizeof(lager_leds_pdata)); platform_device_register_data(&platform_bus, "gpio-keys", -1, &lager_keys_pdata, sizeof(lager_keys_pdata)); regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers, ARRAY_SIZE(fixed3v3_power_consumers), 3300000); platform_device_register_resndata(&platform_bus, "sh_mmcif", 1, mmcif1_resources, ARRAY_SIZE(mmcif1_resources), &mmcif1_pdata, sizeof(mmcif1_pdata)); platform_device_register_resndata(&platform_bus, "r8a7790-ether", -1, ether_resources, ARRAY_SIZE(ether_resources), ðer_pdata, sizeof(ether_pdata)); lager_add_du_device(); }
static void __init armadillo_box_ws1_init(void) { const struct physmap_flash_data *data; imx25_soc_init(); imx25_add_imx_pinctrl("imx25-pinctrl"); pinctrl_register_mappings(armadillo_box_ws1_pinctrl_map, ARRAY_SIZE(armadillo_box_ws1_pinctrl_map)); imx25_add_imx_uart1(&uart1_pdata); imx25_add_imx_uart2(&uart2_pdata); imx25_add_usbmisc_imx(); imx25_add_usb_phy_gen_xceiv_otg(); imx25_add_usb_phy_gen_xceiv_hs(); imx25_add_imx_usb_otg(&otg_pdata); imx25_add_imx_usb_hs(&usbh2_pdata); imx25_add_imx2_wdt(); if (machine_is_armadillo420()) data = &armadillo_box_ws1_nor_flash_pdata_16m; else data = &armadillo_box_ws1_nor_flash_pdata_32m; platform_device_register_resndata(NULL, "physmap-flash", -1, &armadillo_box_ws1_nor_flash_resource, 1, data, sizeof(*data)); imx25_named_gpio_init(); armadillo_box_ws1_fec_reset(); imx25_add_fec(&mx25_fec_pdata); armadillo_box_ws1_bp35a1_init(); imx25_add_imx_i2c0(&mx25_i2c0_data); imx25_add_imx_i2c1(&mx25_i2c1_data); i2c_register_board_info(1, armadillo_box_ws1_i2c1, ARRAY_SIZE(armadillo_box_ws1_i2c1)); platform_device_register_data(NULL, "reg-fixed-voltage", 1, &armadillo_box_ws1_esdhc1_regulator_config, sizeof(armadillo_box_ws1_esdhc1_regulator_config)); platform_device_register_data(NULL, "reg-fixed-voltage", 2, &armadillo_box_ws1_usb_regulator_config, sizeof(armadillo_box_ws1_usb_regulator_config)); imx25_add_sdhci_esdhc_imx(0, &armadillo_box_ws1_esdhc1_pdata); imx_add_gpio_keys(&armadillo_box_ws1_gpio_key_data); gpio_led_register_device(-1, &armadillo_box_ws1_led_data); }
static void __init ape6evm_add_standard_devices(void) { struct clk *parent; struct clk *mp; r8a73a4_clock_init(); /* MP clock parent = extal2 */ parent = clk_get(NULL, "extal2"); mp = clk_get(NULL, "mp"); BUG_ON(IS_ERR(parent) || IS_ERR(mp)); clk_set_parent(mp, parent); clk_put(parent); clk_put(mp); pinctrl_register_mappings(ape6evm_pinctrl_map, ARRAY_SIZE(ape6evm_pinctrl_map)); r8a73a4_pinmux_init(); r8a73a4_add_standard_devices(); /* LAN9220 ethernet */ gpio_request_one(270, GPIOF_OUT_INIT_HIGH, NULL); /* smsc9220 RESET */ regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies)); platform_device_register_resndata(NULL, "smsc911x", -1, lan9220_res, ARRAY_SIZE(lan9220_res), &lan9220_data, sizeof(lan9220_data)); regulator_register_always_on(1, "MMC0 Vcc", vcc_mmc0_consumers, ARRAY_SIZE(vcc_mmc0_consumers), 2800000); platform_device_register_resndata(NULL, "sh_mmcif", 0, mmcif0_resources, ARRAY_SIZE(mmcif0_resources), &mmcif0_pdata, sizeof(mmcif0_pdata)); platform_device_register_data(NULL, "reg-fixed-voltage", 2, &vcc_sdhi0_info, sizeof(vcc_sdhi0_info)); platform_device_register_resndata(NULL, "sh_mobile_sdhi", 0, sdhi0_resources, ARRAY_SIZE(sdhi0_resources), &sdhi0_pdata, sizeof(sdhi0_pdata)); regulator_register_always_on(3, "SDHI1 Vcc", vcc_sdhi1_consumers, ARRAY_SIZE(vcc_sdhi1_consumers), 3300000); platform_device_register_resndata(NULL, "sh_mobile_sdhi", 1, sdhi1_resources, ARRAY_SIZE(sdhi1_resources), &sdhi1_pdata, sizeof(sdhi1_pdata)); platform_device_register_data(NULL, "gpio-keys", -1, &ape6evm_keys_pdata, sizeof(ape6evm_keys_pdata)); platform_device_register_data(NULL, "leds-gpio", -1, &ape6evm_leds_pdata, sizeof(ape6evm_leds_pdata)); }
static void __init edb7211_init(void) { gpio_request_array(edb7211_gpios, ARRAY_SIZE(edb7211_gpios)); platform_device_register(&edb7211_flash_pdev); platform_device_register_data(&platform_bus, "platform-lcd", 0, &edb7211_lcd_power_pdata, sizeof(edb7211_lcd_power_pdata)); platform_device_register_data(&platform_bus, "generic-bl", 0, &edb7211_lcd_backlight_pdata, sizeof(edb7211_lcd_backlight_pdata)); platform_device_register_simple("video-clps711x", 0, NULL, 0); platform_device_register_simple("cs89x0", 0, edb7211_cs8900_resource, ARRAY_SIZE(edb7211_cs8900_resource)); }
static void sst_acpi_fw_cb(const struct firmware *fw, void *context) { struct platform_device *pdev = context; struct device *dev = &pdev->dev; struct sst_acpi_priv *sst_acpi = platform_get_drvdata(pdev); struct sst_pdata *sst_pdata = &sst_acpi->sst_pdata; struct sst_acpi_desc *desc = sst_acpi->desc; struct sst_acpi_mach *mach = sst_acpi->mach; sst_pdata->fw = fw; if (!fw) { dev_err(dev, "Cannot load firmware %s\n", mach->fw_filename); return; } /* register PCM and DAI driver */ sst_acpi->pdev_pcm = platform_device_register_data(dev, desc->drv_name, -1, sst_pdata, sizeof(*sst_pdata)); if (IS_ERR(sst_acpi->pdev_pcm)) { dev_err(dev, "Cannot register device %s. Error %d\n", desc->drv_name, (int)PTR_ERR(sst_acpi->pdev_pcm)); } return; }
static void ramoops_register_dummy(void) { if (!mem_size) return; pr_info("using module parameters\n"); dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL); if (!dummy_data) { pr_info("could not allocate pdata\n"); return; } dummy_data->mem_size = mem_size; dummy_data->mem_address = mem_address; dummy_data->mem_type = mem_type; dummy_data->record_size = record_size; dummy_data->console_size = ramoops_console_size; dummy_data->ftrace_size = ramoops_ftrace_size; dummy_data->pmsg_size = ramoops_pmsg_size; dummy_data->dump_oops = dump_oops; /* * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC * (using 1 byte for ECC isn't much of use anyway). */ dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc; dummy = platform_device_register_data(NULL, "ramoops", -1, dummy_data, sizeof(struct ramoops_platform_data)); if (IS_ERR(dummy)) { pr_info("could not create platform device: %ld\n", PTR_ERR(dummy)); } }
static void msm_hdmi_register_audio_driver(struct hdmi *hdmi, struct device *dev) { struct hdmi_codec_pdata codec_data = { .ops = &msm_hdmi_audio_codec_ops, .max_i2s_channels = 2, .i2s = 1, }; //struct platform_device *pdev; hdmi->audio_pdev = platform_device_register_data(dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, &codec_data, sizeof(codec_data)); if (IS_ERR(hdmi->audio_pdev)) return; DRM_INFO("%s driver bound to HDMI\n", HDMI_CODEC_DRV_NAME); } static int hdmi_dev_probe(struct platform_device *pdev) { return component_add(&pdev->dev, &hdmi_ops); } static int hdmi_dev_remove(struct platform_device *pdev) { component_del(&pdev->dev, &hdmi_ops); return 0; }
static void ramoops_register_dummy(void) { if (!mem_size) return; pr_info("using module parameters\n"); dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL); if (!dummy_data) { pr_info("could not allocate pdata\n"); return; } dummy_data->mem_size = mem_size; dummy_data->mem_address = mem_address; dummy_data->record_size = record_size; dummy_data->console_size = ramoops_console_size; dummy_data->ftrace_size = ramoops_ftrace_size; dummy_data->dump_oops = dump_oops; dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc; dummy = platform_device_register_data(NULL, "ramoops", -1, dummy_data, sizeof(struct ramoops_platform_data)); if (IS_ERR(dummy)) { pr_info("could not create platform device: %ld\n", PTR_ERR(dummy)); } }
/* TODO: Once all pieces are DT:ed, remove completely. */ struct device * __init u8500_of_init_devices(void) { struct device *parent; int i; parent = db8500_soc_device_init(); db8500_add_usb(parent, usb_db8500_rx_dma_cfg, usb_db8500_tx_dma_cfg); platform_device_register_data(parent, "cpufreq-u8500", -1, NULL, 0); for (i = 0; i < ARRAY_SIZE(of_platform_devs); i++) of_platform_devs[i]->dev.parent = parent; /* * Devices to be DT:ed: * u8500_dma40_device = todo * db8500_pmu_device = done * db8500_prcmu_device = done */ platform_add_devices(of_platform_devs, ARRAY_SIZE(of_platform_devs)); return parent; }
int bcma_chipco_watchdog_register(struct bcma_drv_cc *cc) { struct bcma_bus *bus = cc->core->bus; struct bcm47xx_wdt wdt = {}; struct platform_device *pdev; if (bus->chipinfo.id == BCMA_CHIP_ID_BCM53573 && bus->chipinfo.rev <= 1) { pr_debug("No watchdog on 53573A0 / 53573A1\n"); return 0; } wdt.driver_data = cc; wdt.timer_set = bcma_chipco_watchdog_timer_set_wdt; wdt.timer_set_ms = bcma_chipco_watchdog_timer_set_ms_wdt; wdt.max_timer_ms = bcma_chipco_watchdog_get_max_timer(cc) / cc->ticks_per_ms; pdev = platform_device_register_data(NULL, "bcm47xx-wdt", bus->num, &wdt, sizeof(wdt)); if (IS_ERR(pdev)) return PTR_ERR(pdev); cc->watchdog = pdev; return 0; }
static int msm_hdmi_register_audio_driver(struct hdmi *hdmi, struct device *dev) { hdmi->audio_pdev = platform_device_register_data(dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, &codec_data, sizeof(codec_data)); return PTR_ERR_OR_ZERO(hdmi->audio_pdev); }
static int __init rtc_init(void) { struct platform_device *pdev; pdev = platform_device_register_data(NULL, "rtc-generic", -1, &rtc_generic_ops, sizeof(rtc_generic_ops)); return PTR_ERR_OR_ZERO(pdev); }
static int __init rtc_init(void) { struct platform_device *pdev; if (!mach_hwclk) return -ENODEV; pdev = platform_device_register_data(NULL, "rtc-generic", -1, &generic_rtc_ops, sizeof(generic_rtc_ops)); return PTR_ERR_OR_ZERO(pdev); }
int __init mach_nb0916_init(void) { i2c_register_board_info(0, puv3_i2c_devices, ARRAY_SIZE(puv3_i2c_devices)); platform_device_register_simple("PKUnity-v3-I2C", -1, puv3_i2c_resources, ARRAY_SIZE(puv3_i2c_resources)); platform_device_register_data(&platform_bus, "pwm-backlight", -1, &nb0916_backlight_data, sizeof(nb0916_backlight_data)); platform_device_register_data(&platform_bus, "gpio-keys", -1, &nb0916_gpio_button_data, sizeof(nb0916_gpio_button_data)); platform_device_register_resndata(&platform_bus, "physmap-flash", -1, &physmap_flash_resource, 1, &physmap_flash_data, sizeof(physmap_flash_data)); if (request_irq(gpio_to_irq(GPI_LCD_CASE_OFF), &nb0916_lcdcaseoff_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "NB0916 lcd case off", NULL) < 0) { printk(KERN_DEBUG "LCD-Case-OFF IRQ %d not available\n", gpio_to_irq(GPI_LCD_CASE_OFF)); } if (request_irq(gpio_to_irq(GPI_OTP_INT), &nb0916_overheat_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "NB0916 overheating protection", NULL) < 0) { printk(KERN_DEBUG "Overheating Protection IRQ %d not available\n", gpio_to_irq(GPI_OTP_INT)); } return 0; }
static void __init lager_add_vin_device(unsigned idx, struct rcar_vin_platform_data *pdata) { struct platform_device_info vin_info = { .parent = &platform_bus, .name = "r8a7790-vin", .id = idx, .res = &vin_resources[idx * 2], .num_res = 2, .dma_mask = DMA_BIT_MASK(32), .data = pdata, .size_data = sizeof(*pdata), }; BUG_ON(idx > 1); platform_device_register_full(&vin_info); } #define LAGER_CAMERA(idx, name, addr, pdata, flag) \ static struct i2c_board_info i2c_cam##idx##_device = { \ I2C_BOARD_INFO(name, addr), \ }; \ \ static struct rcar_vin_platform_data vin##idx##_pdata = { \ .flags = flag, \ }; \ \ static struct soc_camera_link cam##idx##_link = { \ .bus_id = idx, \ .board_info = &i2c_cam##idx##_device, \ .i2c_adapter_id = 2, \ .module_name = name, \ .priv = pdata, \ } /* Camera 0 is not currently supported due to adv7612 support missing */ LAGER_CAMERA(1, "adv7180", 0x20, NULL, RCAR_VIN_BT656); static void __init lager_add_camera1_device(void) { platform_device_register_data(&platform_bus, "soc-camera-pdrv", 1, &cam1_link, sizeof(cam1_link)); lager_add_vin_device(1, &vin1_pdata); }
static void __init mx27ads_regulator_init(void) { struct gpio_chip *vchip; vchip = kzalloc(sizeof(*vchip), GFP_KERNEL); vchip->owner = THIS_MODULE; vchip->label = "LCD"; vchip->base = MX27ADS_LCD_GPIO; vchip->ngpio = 1; vchip->direction_output = vgpio_dir_out; vchip->set = vgpio_set; gpiochip_add(vchip); platform_device_register_data(&platform_bus, "reg-fixed-voltage", PLATFORM_DEVID_AUTO, &mx27ads_lcd_regulator_pdata, sizeof(mx27ads_lcd_regulator_pdata)); }
int bcma_chipco_watchdog_register(struct bcma_drv_cc *cc) { struct bcm47xx_wdt wdt = {}; struct platform_device *pdev; wdt.driver_data = cc; wdt.timer_set = bcma_chipco_watchdog_timer_set_wdt; wdt.timer_set_ms = bcma_chipco_watchdog_timer_set_ms_wdt; wdt.max_timer_ms = bcma_chipco_watchdog_get_max_timer(cc) / cc->ticks_per_ms; pdev = platform_device_register_data(NULL, "bcm47xx-wdt", cc->core->bus->num, &wdt, sizeof(wdt)); if (IS_ERR(pdev)) return PTR_ERR(pdev); cc->watchdog = pdev; return 0; }
static void __init lager_add_standard_devices(void) { int fixed_regulator_idx = 0; int gpio_regulator_idx = 0; r8a7790_clock_init(); pinctrl_register_mappings(lager_pinctrl_map, ARRAY_SIZE(lager_pinctrl_map)); r8a7790_pinmux_init(); r8a7790_add_standard_devices(); platform_device_register_data(&platform_bus, "leds-gpio", -1, &lager_leds_pdata, sizeof(lager_leds_pdata)); platform_device_register_data(&platform_bus, "gpio-keys", -1, &lager_keys_pdata, sizeof(lager_keys_pdata)); regulator_register_always_on(fixed_regulator_idx++, "fixed-3.3V", fixed3v3_power_consumers, ARRAY_SIZE(fixed3v3_power_consumers), 3300000); platform_device_register_resndata(&platform_bus, "sh_mmcif", 1, mmcif1_resources, ARRAY_SIZE(mmcif1_resources), &mmcif1_pdata, sizeof(mmcif1_pdata)); platform_device_register_resndata(&platform_bus, "r8a7790-ether", -1, ether_resources, ARRAY_SIZE(ether_resources), ðer_pdata, sizeof(ether_pdata)); lager_add_du_device(); platform_device_register_resndata(&platform_bus, "qspi", 0, qspi_resources, ARRAY_SIZE(qspi_resources), &qspi_pdata, sizeof(qspi_pdata)); spi_register_board_info(spi_info, ARRAY_SIZE(spi_info)); platform_device_register_data(&platform_bus, "reg-fixed-voltage", fixed_regulator_idx++, &vcc_sdhi0_info, sizeof(struct fixed_voltage_config)); platform_device_register_data(&platform_bus, "reg-fixed-voltage", fixed_regulator_idx++, &vcc_sdhi2_info, sizeof(struct fixed_voltage_config)); platform_device_register_data(&platform_bus, "gpio-regulator", gpio_regulator_idx++, &vccq_sdhi0_info, sizeof(struct gpio_regulator_config)); platform_device_register_data(&platform_bus, "gpio-regulator", gpio_regulator_idx++, &vccq_sdhi2_info, sizeof(struct gpio_regulator_config)); }
/* * This function is called from the board init */ struct device * __init u8500_init_devices(void) { struct device *parent; int i; parent = db8500_soc_device_init(); db8500_add_rtc(parent); db8500_add_gpios(parent); db8500_add_usb(parent, usb_db8500_rx_dma_cfg, usb_db8500_tx_dma_cfg); platform_device_register_data(parent, "cpufreq-u8500", -1, NULL, 0); for (i = 0; i < ARRAY_SIZE(platform_devs); i++) platform_devs[i]->dev.parent = parent; platform_add_devices(platform_devs, ARRAY_SIZE(platform_devs)); return parent; }
static int hdmi_audio_register(struct device *dev) { struct omap_hdmi_audio_pdata pdata = { .dev = dev, .dss_version = omapdss_get_version(), .audio_dma_addr = hdmi_wp_get_audio_dma_addr(&hdmi.wp), .ops = &hdmi_audio_ops, }; hdmi.audio_pdev = platform_device_register_data( dev, "omap-hdmi-audio", PLATFORM_DEVID_AUTO, &pdata, sizeof(pdata)); if (IS_ERR(hdmi.audio_pdev)) return PTR_ERR(hdmi.audio_pdev); return 0; } /* HDMI HW IP initialisation */ static int omapdss_hdmihw_probe(struct platform_device *pdev) { int r; int irq; hdmi.pdev = pdev; dev_set_drvdata(&pdev->dev, &hdmi); mutex_init(&hdmi.lock); if (pdev->dev.of_node) { r = hdmi_probe_of(pdev); if (r) return r; } r = hdmi_wp_init(pdev, &hdmi.wp); if (r) return r; r = hdmi_pll_init(pdev, &hdmi.pll, &hdmi.wp); if (r) return r; r = hdmi_phy_init(pdev, &hdmi.phy); if (r) goto err; r = hdmi5_core_init(pdev, &hdmi.core); if (r) goto err; irq = platform_get_irq(pdev, 0); if (irq < 0) { DSSERR("platform_get_irq failed\n"); r = -ENODEV; goto err; } r = devm_request_threaded_irq(&pdev->dev, irq, NULL, hdmi_irq_handler, IRQF_ONESHOT, "OMAP HDMI", &hdmi.wp); if (r) { DSSERR("HDMI IRQ request failed\n"); goto err; } pm_runtime_enable(&pdev->dev); hdmi_init_output(pdev); r = hdmi_audio_register(&pdev->dev); if (r) { DSSERR("Registering HDMI audio failed %d\n", r); hdmi_uninit_output(pdev); pm_runtime_disable(&pdev->dev); return r; } dss_debugfs_create_file("hdmi", hdmi_dump_regs); return 0; err: hdmi_pll_uninit(&hdmi.pll); return r; }
/* * Probe routine for each detected JobR subsystem. It assumes that * property detection was picked up externally. */ int caam_jr_probe(struct platform_device *pdev, struct device_node *np, int ring) { struct device *ctrldev, *jrdev; struct platform_device *jr_pdev; struct caam_drv_private *ctrlpriv; struct caam_drv_private_jr *jrpriv; int error; /* FIXME: perhaps "struct resource *" for OF and non? */ u32 *jroffset, *irqres; #ifndef CONFIG_OF char *rname, rinst; #endif ctrldev = &pdev->dev; ctrlpriv = dev_get_drvdata(ctrldev); jrpriv = kmalloc(sizeof(struct caam_drv_private_jr), GFP_KERNEL); if (jrpriv == NULL) { dev_err(ctrldev, "can't alloc private mem for job ring %d\n", ring); return -ENOMEM; } jrpriv->parentdev = ctrldev; /* point back to parent */ jrpriv->ridx = ring; /* save ring identity relative to detection */ /* * Derive a pointer to the detected JobRs regs * Driver has already iomapped the entire space, we just * need to add in the offset to this JobR. Don't know if I * like this long-term, but it'll run */ #ifdef CONFIG_OF jroffset = (u32 *)of_get_property(np, "reg", NULL); #else rname = kmalloc(strlen(JR_MEMRES_NAME_ROOT) + 1, 0); if (rname == NULL) { dev_err(ctrldev, "can't alloc resource detection buffer %d\n", ring); kfree(jrpriv); return -ENOMEM; } rname[0] = 0; rinst = '0' + ring; strcat(rname, JR_MEMRES_NAME_ROOT); strncat(rname, &rinst, 1); jroffset = (u32 *)platform_get_resource_byname(pdev, IORESOURCE_MEM, rname); kfree(rname); #endif jrpriv->rregs = (struct caam_job_ring __iomem *)((void *)ctrlpriv->ctrl + *jroffset); /* Build a local dev for each detected queue */ #ifdef CONFIG_OF jr_pdev = of_platform_device_create(np, NULL, ctrldev); #else jr_pdev = platform_device_register_data(ctrldev, "caam_jr", ring, jrpriv, sizeof(struct caam_drv_private_jr)); #endif if (jr_pdev == NULL) { kfree(jrpriv); return -EINVAL; } jrdev = &jr_pdev->dev; dev_set_drvdata(jrdev, jrpriv); ctrlpriv->jrdev[ring] = jrdev; /* Identify the interrupt */ #ifdef CONFIG_OF jrpriv->irq = of_irq_to_resource(np, 0, NULL); #else rname = kmalloc(strlen(JR_IRQRES_NAME_ROOT) + 1, 0); if (rname == NULL) { dev_err(ctrldev, "can't alloc resource detection buffer %d\n", ring); kfree(jrpriv); return -ENOMEM; } rname[0] = 0; strcat(rname, JR_IRQRES_NAME_ROOT); strncat(rname, &rinst, 1); irqres = (u32 *)platform_get_resource_byname(pdev, IORESOURCE_IRQ, rname); jrpriv->irq = *irqres; kfree(rname); #endif /* Now do the platform independent part */ error = caam_jr_init(jrdev); /* now turn on hardware */ if (error) { kfree(jrpriv); return error; } return error; }
static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap) { int ret; struct dvb_usb_device *d = adap_to_d(adap); struct rtl28xxu_dev *dev = d_to_priv(d); struct dvb_frontend *fe = NULL; struct i2c_board_info info; struct i2c_client *client; struct v4l2_subdev *subdev = NULL; struct platform_device *pdev; struct rtl2832_sdr_platform_data pdata; dev_dbg(&d->intf->dev, "\n"); memset(&info, 0, sizeof(struct i2c_board_info)); memset(&pdata, 0, sizeof(pdata)); switch (dev->tuner) { case TUNER_RTL2832_FC0012: fe = dvb_attach(fc0012_attach, adap->fe[0], dev->demod_i2c_adapter, &rtl2832u_fc0012_config); /* since fc0012 includs reading the signal strength delegate * that to the tuner driver */ adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; break; case TUNER_RTL2832_FC0013: fe = dvb_attach(fc0013_attach, adap->fe[0], dev->demod_i2c_adapter, 0xc6>>1, 0, FC_XTAL_28_8_MHZ); /* fc0013 also supports signal strength reading */ adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; break; case TUNER_RTL2832_E4000: { struct e4000_config e4000_config = { .fe = adap->fe[0], .clock = 28800000, }; strlcpy(info.type, "e4000", I2C_NAME_SIZE); info.addr = 0x64; info.platform_data = &e4000_config; request_module(info.type); client = i2c_new_device(dev->demod_i2c_adapter, &info); if (client == NULL || client->dev.driver == NULL) break; if (!try_module_get(client->dev.driver->owner)) { i2c_unregister_device(client); break; } dev->i2c_client_tuner = client; subdev = i2c_get_clientdata(client); } break; case TUNER_RTL2832_FC2580: fe = dvb_attach(fc2580_attach, adap->fe[0], dev->demod_i2c_adapter, &rtl2832u_fc2580_config); break; case TUNER_RTL2832_TUA9001: /* enable GPIO1 and GPIO4 as output */ ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x12); if (ret) goto err; ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x12, 0x12); if (ret) goto err; fe = dvb_attach(tua9001_attach, adap->fe[0], dev->demod_i2c_adapter, &rtl2832u_tua9001_config); break; case TUNER_RTL2832_R820T: fe = dvb_attach(r820t_attach, adap->fe[0], dev->demod_i2c_adapter, &rtl2832u_r820t_config); /* Use tuner to get the signal strength */ adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; break; case TUNER_RTL2832_R828D: fe = dvb_attach(r820t_attach, adap->fe[0], dev->demod_i2c_adapter, &rtl2832u_r828d_config); adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; if (adap->fe[1]) { fe = dvb_attach(r820t_attach, adap->fe[1], dev->demod_i2c_adapter, &rtl2832u_r828d_config); adap->fe[1]->ops.read_signal_strength = adap->fe[1]->ops.tuner_ops.get_rf_strength; } break; default: dev_err(&d->intf->dev, "unknown tuner %d\n", dev->tuner); } if (fe == NULL && dev->i2c_client_tuner == NULL) { ret = -ENODEV; goto err; } /* register SDR */ switch (dev->tuner) { case TUNER_RTL2832_FC0012: case TUNER_RTL2832_FC0013: case TUNER_RTL2832_E4000: case TUNER_RTL2832_R820T: case TUNER_RTL2832_R828D: pdata.clk = dev->rtl2832_platform_data.clk; pdata.tuner = dev->tuner; pdata.i2c_client = dev->i2c_client_demod; pdata.bulk_read = dev->rtl2832_platform_data.bulk_read; pdata.bulk_write = dev->rtl2832_platform_data.bulk_write; pdata.update_bits = dev->rtl2832_platform_data.update_bits; pdata.dvb_frontend = adap->fe[0]; pdata.dvb_usb_device = d; pdata.v4l2_subdev = subdev; request_module("%s", "rtl2832_sdr"); pdev = platform_device_register_data(&d->intf->dev, "rtl2832_sdr", PLATFORM_DEVID_AUTO, &pdata, sizeof(pdata)); if (pdev == NULL || pdev->dev.driver == NULL) break; dev->platform_device_sdr = pdev; break; default: dev_dbg(&d->intf->dev, "no SDR for tuner=%d\n", dev->tuner); } return 0; err: dev_dbg(&d->intf->dev, "failed=%d\n", ret); return ret; } static int rtl28xxu_tuner_attach(struct dvb_usb_adapter *adap) { struct rtl28xxu_dev *dev = adap_to_priv(adap); if (dev->chip_id == CHIP_ID_RTL2831U) return rtl2831u_tuner_attach(adap); else return rtl2832u_tuner_attach(adap); } static int rtl28xxu_tuner_detach(struct dvb_usb_adapter *adap) { struct dvb_usb_device *d = adap_to_d(adap); struct rtl28xxu_dev *dev = d_to_priv(d); struct i2c_client *client; struct platform_device *pdev; dev_dbg(&d->intf->dev, "\n"); /* remove platform SDR */ pdev = dev->platform_device_sdr; if (pdev) platform_device_unregister(pdev); /* remove I2C tuner */ client = dev->i2c_client_tuner; if (client) { module_put(client->dev.driver->owner); i2c_unregister_device(client); } return 0; } static int rtl28xxu_init(struct dvb_usb_device *d) { int ret; u8 val; dev_dbg(&d->intf->dev, "\n"); /* init USB endpoints */ ret = rtl28xxu_rd_reg(d, USB_SYSCTL_0, &val); if (ret) goto err; /* enable DMA and Full Packet Mode*/ val |= 0x09; ret = rtl28xxu_wr_reg(d, USB_SYSCTL_0, val); if (ret) goto err; /* set EPA maximum packet size to 0x0200 */ ret = rtl28xxu_wr_regs(d, USB_EPA_MAXPKT, "\x00\x02\x00\x00", 4); if (ret) goto err; /* change EPA FIFO length */ ret = rtl28xxu_wr_regs(d, USB_EPA_FIFO_CFG, "\x14\x00\x00\x00", 4); if (ret) goto err; return ret; err: dev_dbg(&d->intf->dev, "failed=%d\n", ret); return ret; }
static int __devinit adp5520_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adp5520_platform_data *pdata = client->dev.platform_data; struct platform_device *pdev; struct adp5520_chip *chip; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { dev_err(&client->dev, "SMBUS Word Data not Supported\n"); return -EIO; } if (pdata == NULL) { dev_err(&client->dev, "missing platform data\n"); return -ENODEV; } chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; i2c_set_clientdata(client, chip); chip->client = client; chip->dev = &client->dev; chip->irq = client->irq; chip->id = id->driver_data; mutex_init(&chip->lock); if (chip->irq) { BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list); ret = request_threaded_irq(chip->irq, NULL, adp5520_irq_thread, IRQF_TRIGGER_LOW | IRQF_ONESHOT, "adp5520", chip); if (ret) { dev_err(&client->dev, "failed to request irq %d\n", chip->irq); goto out_free_chip; } } ret = adp5520_write(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY); if (ret) { dev_err(&client->dev, "failed to write\n"); goto out_free_irq; } if (pdata->keys) { pdev = platform_device_register_data(chip->dev, "adp5520-keys", chip->id, pdata->keys, sizeof(*pdata->keys)); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); goto out_remove_subdevs; } } if (pdata->gpio) { pdev = platform_device_register_data(chip->dev, "adp5520-gpio", chip->id, pdata->gpio, sizeof(*pdata->gpio)); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); goto out_remove_subdevs; } } if (pdata->leds) { pdev = platform_device_register_data(chip->dev, "adp5520-led", chip->id, pdata->leds, sizeof(*pdata->leds)); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); goto out_remove_subdevs; } } if (pdata->backlight) { pdev = platform_device_register_data(chip->dev, "adp5520-backlight", chip->id, pdata->backlight, sizeof(*pdata->backlight)); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); goto out_remove_subdevs; } } return 0; out_remove_subdevs: adp5520_remove_subdevs(chip); out_free_irq: if (chip->irq) free_irq(chip->irq, chip); out_free_chip: kfree(chip); return ret; }
static int sst_acpi_probe(struct platform_device *pdev) { const struct acpi_device_id *id; struct device *dev = &pdev->dev; struct sst_acpi_priv *sst_acpi; struct sst_pdata *sst_pdata; struct sst_acpi_mach *mach; struct sst_acpi_desc *desc; struct resource *mmio; int ret = 0; sst_acpi = devm_kzalloc(dev, sizeof(*sst_acpi), GFP_KERNEL); if (sst_acpi == NULL) return -ENOMEM; id = acpi_match_device(dev->driver->acpi_match_table, dev); if (!id) return -ENODEV; desc = (struct sst_acpi_desc *)id->driver_data; mach = sst_acpi_find_machine(desc->machines); if (mach == NULL) { dev_err(dev, "No matching ASoC machine driver found\n"); return -ENODEV; } sst_pdata = &sst_acpi->sst_pdata; sst_pdata->id = desc->sst_id; sst_acpi->desc = desc; sst_acpi->mach = mach; if (desc->resindex_dma_base >= 0) { sst_pdata->dma_engine = desc->dma_engine; sst_pdata->dma_base = desc->resindex_dma_base; sst_pdata->dma_size = desc->dma_size; } if (desc->irqindex_host_ipc >= 0) sst_pdata->irq = platform_get_irq(pdev, desc->irqindex_host_ipc); if (desc->resindex_lpe_base >= 0) { mmio = platform_get_resource(pdev, IORESOURCE_MEM, desc->resindex_lpe_base); if (mmio) { sst_pdata->lpe_base = mmio->start; sst_pdata->lpe_size = resource_size(mmio); } } if (desc->resindex_pcicfg_base >= 0) { mmio = platform_get_resource(pdev, IORESOURCE_MEM, desc->resindex_pcicfg_base); if (mmio) { sst_pdata->pcicfg_base = mmio->start; sst_pdata->pcicfg_size = resource_size(mmio); } } if (desc->resindex_fw_base >= 0) { mmio = platform_get_resource(pdev, IORESOURCE_MEM, desc->resindex_fw_base); if (mmio) { sst_pdata->fw_base = mmio->start; sst_pdata->fw_size = resource_size(mmio); } } platform_set_drvdata(pdev, sst_acpi); /* register machine driver */ sst_acpi->pdev_mach = platform_device_register_data(dev, mach->drv_name, -1, sst_pdata, sizeof(*sst_pdata)); if (IS_ERR(sst_acpi->pdev_mach)) return PTR_ERR(sst_acpi->pdev_mach); /* continue SST probing after firmware is loaded */ ret = request_firmware_nowait(THIS_MODULE, true, mach->fw_filename, dev, GFP_KERNEL, pdev, sst_acpi_fw_cb); if (ret) platform_device_unregister(sst_acpi->pdev_mach); return ret; }
static void __init lager_add_rsnd_device(void) { struct platform_device_info cardinfo = { .name = "asoc-simple-card", .id = -1, .data = &rsnd_card_info, .size_data = sizeof(struct asoc_simple_card_info), .dma_mask = DMA_BIT_MASK(32), }; i2c_register_board_info(2, i2c2_devices, ARRAY_SIZE(i2c2_devices)); platform_device_register_resndata( NULL, "rcar_sound", -1, rsnd_resources, ARRAY_SIZE(rsnd_resources), &rsnd_info, sizeof(rsnd_info)); platform_device_register_full(&cardinfo); } /* SDHI0 */ static struct sh_mobile_sdhi_info sdhi0_info __initdata = { .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ | MMC_CAP_POWER_OFF_CARD, .tmio_caps2 = MMC_CAP2_NO_MULTI_READ, .tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_WRPROTECT_DISABLE, }; static struct resource sdhi0_resources[] __initdata = { DEFINE_RES_MEM(0xee100000, 0x200), DEFINE_RES_IRQ(gic_spi(165)), }; /* SDHI2 */ static struct sh_mobile_sdhi_info sdhi2_info __initdata = { .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ | MMC_CAP_POWER_OFF_CARD, .tmio_caps2 = MMC_CAP2_NO_MULTI_READ, .tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_WRPROTECT_DISABLE, }; static struct resource sdhi2_resources[] __initdata = { DEFINE_RES_MEM(0xee140000, 0x100), DEFINE_RES_IRQ(gic_spi(167)), }; /* Internal PCI1 */ static const struct resource pci1_resources[] __initconst = { DEFINE_RES_MEM(0xee0b0000, 0x10000), /* CFG */ DEFINE_RES_MEM(0xee0a0000, 0x10000), /* MEM */ DEFINE_RES_IRQ(gic_spi(112)), }; static const struct platform_device_info pci1_info __initconst = { .name = "pci-rcar-gen2", .id = 1, .res = pci1_resources, .num_res = ARRAY_SIZE(pci1_resources), .dma_mask = DMA_BIT_MASK(32), }; static void __init lager_add_usb1_device(void) { platform_device_register_full(&pci1_info); } /* Internal PCI2 */ static const struct resource pci2_resources[] __initconst = { DEFINE_RES_MEM(0xee0d0000, 0x10000), /* CFG */ DEFINE_RES_MEM(0xee0c0000, 0x10000), /* MEM */ DEFINE_RES_IRQ(gic_spi(113)), }; static const struct platform_device_info pci2_info __initconst = { .name = "pci-rcar-gen2", .id = 2, .res = pci2_resources, .num_res = ARRAY_SIZE(pci2_resources), .dma_mask = DMA_BIT_MASK(32), }; static void __init lager_add_usb2_device(void) { platform_device_register_full(&pci2_info); } static const struct pinctrl_map lager_pinctrl_map[] = { /* DU (CN10: ARGB0, CN13: LVDS) */ PIN_MAP_MUX_GROUP_DEFAULT("rcar-du-r8a7790", "pfc-r8a7790", "du_rgb666", "du"), PIN_MAP_MUX_GROUP_DEFAULT("rcar-du-r8a7790", "pfc-r8a7790", "du_sync_1", "du"), PIN_MAP_MUX_GROUP_DEFAULT("rcar-du-r8a7790", "pfc-r8a7790", "du_clk_out_0", "du"), /* I2C2 */ PIN_MAP_MUX_GROUP_DEFAULT("i2c-rcar.2", "pfc-r8a7790", "i2c2", "i2c2"), /* QSPI */ PIN_MAP_MUX_GROUP_DEFAULT("qspi.0", "pfc-r8a7790", "qspi_ctrl", "qspi"), PIN_MAP_MUX_GROUP_DEFAULT("qspi.0", "pfc-r8a7790", "qspi_data4", "qspi"), /* SCIF0 (CN19: DEBUG SERIAL0) */ PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.6", "pfc-r8a7790", "scif0_data", "scif0"), /* SCIF1 (CN20: DEBUG SERIAL1) */ PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.7", "pfc-r8a7790", "scif1_data", "scif1"), /* SDHI0 */ PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7790", "sdhi0_data4", "sdhi0"), PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7790", "sdhi0_ctrl", "sdhi0"), PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7790", "sdhi0_cd", "sdhi0"), /* SDHI2 */ PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.2", "pfc-r8a7790", "sdhi2_data4", "sdhi2"), PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.2", "pfc-r8a7790", "sdhi2_ctrl", "sdhi2"), PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.2", "pfc-r8a7790", "sdhi2_cd", "sdhi2"), /* SSI (CN17: sound) */ PIN_MAP_MUX_GROUP_DEFAULT("rcar_sound", "pfc-r8a7790", "ssi0129_ctrl", "ssi"), PIN_MAP_MUX_GROUP_DEFAULT("rcar_sound", "pfc-r8a7790", "ssi0_data", "ssi"), PIN_MAP_MUX_GROUP_DEFAULT("rcar_sound", "pfc-r8a7790", "ssi1_data", "ssi"), PIN_MAP_MUX_GROUP_DEFAULT("rcar_sound", "pfc-r8a7790", "audio_clk_a", "audio_clk"), /* MMCIF1 */ PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.1", "pfc-r8a7790", "mmc1_data8", "mmc1"), PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.1", "pfc-r8a7790", "mmc1_ctrl", "mmc1"), /* Ether */ PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-ether", "pfc-r8a7790", "eth_link", "eth"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-ether", "pfc-r8a7790", "eth_mdio", "eth"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-ether", "pfc-r8a7790", "eth_rmii", "eth"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-ether", "pfc-r8a7790", "intc_irq0", "intc"), /* VIN0 */ PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-vin.0", "pfc-r8a7790", "vin0_data24", "vin0"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-vin.0", "pfc-r8a7790", "vin0_sync", "vin0"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-vin.0", "pfc-r8a7790", "vin0_field", "vin0"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-vin.0", "pfc-r8a7790", "vin0_clkenb", "vin0"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-vin.0", "pfc-r8a7790", "vin0_clk", "vin0"), /* VIN1 */ PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-vin.1", "pfc-r8a7790", "vin1_data8", "vin1"), PIN_MAP_MUX_GROUP_DEFAULT("r8a7790-vin.1", "pfc-r8a7790", "vin1_clk", "vin1"), /* USB0 */ PIN_MAP_MUX_GROUP_DEFAULT("renesas_usbhs", "pfc-r8a7790", "usb0_ovc_vbus", "usb0"), /* USB1 */ PIN_MAP_MUX_GROUP_DEFAULT("pci-rcar-gen2.1", "pfc-r8a7790", "usb1", "usb1"), /* USB2 */ PIN_MAP_MUX_GROUP_DEFAULT("pci-rcar-gen2.2", "pfc-r8a7790", "usb2", "usb2"), }; static void __init lager_add_standard_devices(void) { int fixed_regulator_idx = 0; int gpio_regulator_idx = 0; r8a7790_clock_init(); pinctrl_register_mappings(lager_pinctrl_map, ARRAY_SIZE(lager_pinctrl_map)); r8a7790_pinmux_init(); r8a7790_add_standard_devices(); platform_device_register_data(NULL, "leds-gpio", -1, &lager_leds_pdata, sizeof(lager_leds_pdata)); platform_device_register_data(NULL, "gpio-keys", -1, &lager_keys_pdata, sizeof(lager_keys_pdata)); regulator_register_always_on(fixed_regulator_idx++, "fixed-3.3V", fixed3v3_power_consumers, ARRAY_SIZE(fixed3v3_power_consumers), 3300000); platform_device_register_resndata(NULL, "sh_mmcif", 1, mmcif1_resources, ARRAY_SIZE(mmcif1_resources), &mmcif1_pdata, sizeof(mmcif1_pdata)); platform_device_register_full(ðer_info); lager_add_du_device(); platform_device_register_resndata(NULL, "qspi", 0, qspi_resources, ARRAY_SIZE(qspi_resources), &qspi_pdata, sizeof(qspi_pdata)); spi_register_board_info(spi_info, ARRAY_SIZE(spi_info)); platform_device_register_data(NULL, "reg-fixed-voltage", fixed_regulator_idx++, &vcc_sdhi0_info, sizeof(struct fixed_voltage_config)); platform_device_register_data(NULL, "reg-fixed-voltage", fixed_regulator_idx++, &vcc_sdhi2_info, sizeof(struct fixed_voltage_config)); platform_device_register_data(NULL, "gpio-regulator", gpio_regulator_idx++, &vccq_sdhi0_info, sizeof(struct gpio_regulator_config)); platform_device_register_data(NULL, "gpio-regulator", gpio_regulator_idx++, &vccq_sdhi2_info, sizeof(struct gpio_regulator_config)); lager_add_camera1_device(); platform_device_register_full(&sata1_info); platform_device_register_resndata(NULL, "usb_phy_rcar_gen2", -1, usbhs_phy_resources, ARRAY_SIZE(usbhs_phy_resources), &usbhs_phy_pdata, sizeof(usbhs_phy_pdata)); lager_register_usbhs(); lager_add_usb1_device(); lager_add_usb2_device(); lager_add_rsnd_device(); platform_device_register_resndata(NULL, "sh_mobile_sdhi", 0, sdhi0_resources, ARRAY_SIZE(sdhi0_resources), &sdhi0_info, sizeof(struct sh_mobile_sdhi_info)); platform_device_register_resndata(NULL, "sh_mobile_sdhi", 2, sdhi2_resources, ARRAY_SIZE(sdhi2_resources), &sdhi2_info, sizeof(struct sh_mobile_sdhi_info)); } /* * Ether LEDs on the Lager board are named LINK and ACTIVE which corresponds * to non-default 01 setting of the Micrel KSZ8041 PHY control register 1 bits * 14-15. We have to set them back to 01 from the default 00 value each time * the PHY is reset. It's also important because the PHY's LED0 signal is * connected to SoC's ETH_LINK signal and in the PHY's default mode it will * bounce on and off after each packet, which we apparently want to avoid. */ static int lager_ksz8041_fixup(struct phy_device *phydev) { u16 phyctrl1 = phy_read(phydev, 0x1e); phyctrl1 &= ~0xc000; phyctrl1 |= 0x4000; return phy_write(phydev, 0x1e, phyctrl1); } static void __init lager_init(void) { lager_add_standard_devices(); irq_set_irq_type(irq_pin(0), IRQ_TYPE_LEVEL_LOW); if (IS_ENABLED(CONFIG_PHYLIB)) phy_register_fixup_for_id("r8a7790-ether-ff:01", lager_ksz8041_fixup); }
int caam_secvio_startup(struct platform_device *pdev) { struct device *ctrldev, *svdev; struct caam_drv_private *ctrlpriv; struct caam_drv_private_secvio *svpriv; struct platform_device *svpdev; struct device_node *np; const void *prop; int i, error, secvio_inten_src; ctrldev = &pdev->dev; ctrlpriv = dev_get_drvdata(ctrldev); /* * Set up the private block for secure memory * Only one instance is possible */ svpriv = kzalloc(sizeof(struct caam_drv_private_secvio), GFP_KERNEL); if (svpriv == NULL) { dev_err(ctrldev, "can't alloc private mem for secvio\n"); return -ENOMEM; } svpriv->parentdev = ctrldev; /* Create the security violation dev */ #ifdef CONFIG_OF np = of_find_compatible_node(NULL, NULL, "fsl,imx6q-caam-secvio"); if (!np) return -ENODEV; ctrlpriv->secvio_irq = of_irq_to_resource(np, 0, NULL); prop = of_get_property(np, "secvio_src", NULL); if (prop) secvio_inten_src = of_read_ulong(prop, 1); else secvio_inten_src = HP_SECVIO_INTEN_ALL; printk(KERN_ERR "secvio_inten_src = %x\n", secvio_inten_src); svpdev = of_platform_device_create(np, NULL, ctrldev); if (!svpdev) return -ENODEV; #else svpdev = platform_device_register_data(ctrldev, "caam_secvio", 0, svpriv, sizeof(struct caam_drv_private_secvio)); secvio_inten_src = HP_SECVIO_INTEN_ALL; #endif if (svpdev == NULL) { kfree(svpriv); return -EINVAL; } svdev = &svpdev->dev; dev_set_drvdata(svdev, svpriv); ctrlpriv->secviodev = svdev; svpriv->svregs = ctrlpriv->snvs; /* * Now we have all the dev data set up. Init interrupt * source descriptions */ for (i = 0; i < MAX_SECVIO_SOURCES; i++) { svpriv->intsrc[i].intname = violation_src_name[i]; svpriv->intsrc[i].handler = caam_secvio_default; } /* Connect main handler */ for_each_possible_cpu(i) tasklet_init(&svpriv->irqtask[i], caam_secvio_dispatch, (unsigned long)svdev); error = request_irq(ctrlpriv->secvio_irq, caam_secvio_interrupt, IRQF_SHARED, "caam_secvio", svdev); if (error) { dev_err(svdev, "can't connect secvio interrupt\n"); irq_dispose_mapping(ctrlpriv->secvio_irq); ctrlpriv->secvio_irq = 0; return -EINVAL; } /* Enable all sources */ wr_reg32(&svpriv->svregs->hp.secvio_int_ctl, secvio_inten_src); dev_info(svdev, "security violation service handlers armed\n"); return 0; }
static int __devinit fsl_ssi_probe(struct platform_device *pdev, const struct of_device_id *match) { struct fsl_ssi_private *ssi_private; int ret = 0; struct device_attribute *dev_attr = NULL; struct device_node *np = pdev->dev.of_node; const char *p, *sprop; const uint32_t *iprop; struct resource res; char name[64]; /* SSIs that are not connected on the board should have a * status = "disabled" * property in their device tree nodes. */ if (!of_device_is_available(np)) return -ENODEV; /* Check for a codec-handle property. */ if (!of_get_property(np, "codec-handle", NULL)) { dev_err(&pdev->dev, "missing codec-handle property\n"); return -ENODEV; } /* We only support the SSI in "I2S Slave" mode */ sprop = of_get_property(np, "fsl,mode", NULL); if (!sprop || strcmp(sprop, "i2s-slave")) { dev_notice(&pdev->dev, "mode %s is unsupported\n", sprop); return -ENODEV; } /* The DAI name is the last part of the full name of the node. */ p = strrchr(np->full_name, '/') + 1; ssi_private = kzalloc(sizeof(struct fsl_ssi_private) + strlen(p), GFP_KERNEL); if (!ssi_private) { dev_err(&pdev->dev, "could not allocate DAI object\n"); return -ENOMEM; } strcpy(ssi_private->name, p); /* Initialize this copy of the CPU DAI driver structure */ memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_dai_template, sizeof(fsl_ssi_dai_template)); ssi_private->cpu_dai_drv.name = ssi_private->name; /* Get the addresses and IRQ */ ret = of_address_to_resource(np, 0, &res); if (ret) { dev_err(&pdev->dev, "could not determine device resources\n"); kfree(ssi_private); return ret; } ssi_private->ssi = ioremap(res.start, 1 + res.end - res.start); ssi_private->ssi_phys = res.start; ssi_private->irq = irq_of_parse_and_map(np, 0); /* Are the RX and the TX clocks locked? */ if (of_find_property(np, "fsl,ssi-asynchronous", NULL)) ssi_private->asynchronous = 1; else ssi_private->cpu_dai_drv.symmetric_rates = 1; /* Determine the FIFO depth. */ iprop = of_get_property(np, "fsl,fifo-depth", NULL); if (iprop) ssi_private->fifo_depth = *iprop; else /* Older 8610 DTs didn't have the fifo-depth property */ ssi_private->fifo_depth = 8; /* Initialize the the device_attribute structure */ dev_attr = &ssi_private->dev_attr; dev_attr->attr.name = "statistics"; dev_attr->attr.mode = S_IRUGO; dev_attr->show = fsl_sysfs_ssi_show; ret = device_create_file(&pdev->dev, dev_attr); if (ret) { dev_err(&pdev->dev, "could not create sysfs %s file\n", ssi_private->dev_attr.attr.name); goto error; } /* Register with ASoC */ dev_set_drvdata(&pdev->dev, ssi_private); ret = snd_soc_register_dai(&pdev->dev, &ssi_private->cpu_dai_drv); if (ret) { dev_err(&pdev->dev, "failed to register DAI: %d\n", ret); goto error; } /* Trigger the machine driver's probe function. The platform driver * name of the machine driver is taken from the /model property of the * device tree. We also pass the address of the CPU DAI driver * structure. */ sprop = of_get_property(of_find_node_by_path("/"), "model", NULL); /* Sometimes the model name has a "fsl," prefix, so we strip that. */ p = strrchr(sprop, ','); if (p) sprop = p + 1; snprintf(name, sizeof(name), "snd-soc-%s", sprop); make_lowercase(name); ssi_private->pdev = platform_device_register_data(&pdev->dev, name, 0, NULL, 0); if (IS_ERR(ssi_private->pdev)) { ret = PTR_ERR(ssi_private->pdev); dev_err(&pdev->dev, "failed to register platform: %d\n", ret); goto error; } return 0; error: snd_soc_unregister_dai(&pdev->dev); dev_set_drvdata(&pdev->dev, NULL); if (dev_attr) device_remove_file(&pdev->dev, dev_attr); irq_dispose_mapping(ssi_private->irq); iounmap(ssi_private->ssi); kfree(ssi_private); return ret; }
static void __init bockw_init(void) { void __iomem *base; struct clk *clk; int i; r8a7778_clock_init(); r8a7778_init_irq_extpin(1); r8a7778_add_standard_devices(); platform_device_register_resndata(&platform_bus, "r8a777x-ether", -1, ether_resources, ARRAY_SIZE(ether_resources), ðer_platform_data, sizeof(ether_platform_data)); platform_device_register_full(&vin0_info); /* VIN1 has a pin conflict with Ether */ if (!IS_ENABLED(CONFIG_SH_ETH)) platform_device_register_full(&vin1_info); platform_device_register_data(&platform_bus, "soc-camera-pdrv", 0, &iclink0_ml86v7667, sizeof(iclink0_ml86v7667)); platform_device_register_data(&platform_bus, "soc-camera-pdrv", 1, &iclink1_ml86v7667, sizeof(iclink1_ml86v7667)); i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices)); spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); pinctrl_register_mappings(bockw_pinctrl_map, ARRAY_SIZE(bockw_pinctrl_map)); r8a7778_pinmux_init(); platform_device_register_resndata( &platform_bus, "sh_mmcif", -1, mmc_resources, ARRAY_SIZE(mmc_resources), &sh_mmcif_plat, sizeof(struct sh_mmcif_plat_data)); platform_device_register_resndata( &platform_bus, "rcar_usb_phy", -1, usb_phy_resources, ARRAY_SIZE(usb_phy_resources), &usb_phy_platform_data, sizeof(struct rcar_phy_platform_data)); /* for SMSC */ fpga = ioremap_nocache(FPGA, SZ_1M); if (fpga) { /* * CAUTION * * IRQ0/1 is cascaded interrupt from FPGA. * it should be cared in the future * Now, it is assuming IRQ0 was used only from SMSC. */ u16 val = ioread16(fpga + IRQ0MR); val &= ~(1 << 4); /* enable SMSC911x */ iowrite16(val, fpga + IRQ0MR); regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies)); platform_device_register_resndata( &platform_bus, "smsc911x", -1, smsc911x_resources, ARRAY_SIZE(smsc911x_resources), &smsc911x_data, sizeof(smsc911x_data)); } /* for SDHI */ base = ioremap_nocache(PFC, 0x200); if (base) { /* * FIXME * * SDHI CD/WP pin needs pull-up */ iowrite32(ioread32(base + PUPR4) | (3 << 26), base + PUPR4); iounmap(base); platform_device_register_resndata( &platform_bus, "sh_mobile_sdhi", 0, sdhi0_resources, ARRAY_SIZE(sdhi0_resources), &sdhi0_info, sizeof(struct sh_mobile_sdhi_info)); } /* for Audio */ clk = clk_get(NULL, "audio_clk_b"); clk_set_rate(clk, 24576000); clk_put(clk); rsnd_codec_power(5, 1); /* enable ak4642 */ platform_device_register_simple( "ak4554-adc-dac", 0, NULL, 0); platform_device_register_simple( "ak4554-adc-dac", 1, NULL, 0); platform_device_register_resndata( &platform_bus, "rcar_sound", -1, rsnd_resources, ARRAY_SIZE(rsnd_resources), &rsnd_info, sizeof(rsnd_info)); for (i = 0; i < ARRAY_SIZE(rsnd_card_info); i++) { struct platform_device_info cardinfo = { .parent = &platform_bus, .name = "asoc-simple-card", .id = i, .data = &rsnd_card_info[i], .size_data = sizeof(struct asoc_simple_card_info), .dma_mask = ~0, }; platform_device_register_full(&cardinfo); } } static void __init bockw_init_late(void) { r8a7778_init_late(); ADD_USB_FUNC_DEVICE_IF_POSSIBLE(); }
static int hdmi_audio_register(struct device *dev) { struct omap_hdmi_audio_pdata pdata = { .dev = dev, .dss_version = omapdss_get_version(), .audio_dma_addr = hdmi_wp_get_audio_dma_addr(&hdmi.wp), .ops = &hdmi_audio_ops, }; hdmi.audio_pdev = platform_device_register_data( dev, "omap-hdmi-audio", PLATFORM_DEVID_AUTO, &pdata, sizeof(pdata)); if (IS_ERR(hdmi.audio_pdev)) return PTR_ERR(hdmi.audio_pdev); hdmi_runtime_get(); hdmi.wp_idlemode = REG_GET(hdmi.wp.base, HDMI_WP_SYSCONFIG, 3, 2); hdmi_runtime_put(); return 0; } /* HDMI HW IP initialisation */ static int hdmi5_bind(struct device *dev, struct device *master, void *data) { struct platform_device *pdev = to_platform_device(dev); int r; int irq; hdmi.pdev = pdev; dev_set_drvdata(&pdev->dev, &hdmi); mutex_init(&hdmi.lock); spin_lock_init(&hdmi.audio_playing_lock); if (pdev->dev.of_node) { r = hdmi_probe_of(pdev); if (r) return r; } r = hdmi_wp_init(pdev, &hdmi.wp); if (r) return r; r = hdmi_pll_init(pdev, &hdmi.pll, &hdmi.wp); if (r) return r; r = hdmi_phy_init(pdev, &hdmi.phy); if (r) goto err; r = hdmi5_core_init(pdev, &hdmi.core); if (r) goto err; irq = platform_get_irq(pdev, 0); if (irq < 0) { DSSERR("platform_get_irq failed\n"); r = -ENODEV; goto err; } r = devm_request_threaded_irq(&pdev->dev, irq, NULL, hdmi_irq_handler, IRQF_ONESHOT, "OMAP HDMI", &hdmi.wp); if (r) { DSSERR("HDMI IRQ request failed\n"); goto err; } pm_runtime_enable(&pdev->dev); hdmi_init_output(pdev); r = hdmi_audio_register(&pdev->dev); if (r) { DSSERR("Registering HDMI audio failed %d\n", r); hdmi_uninit_output(pdev); pm_runtime_disable(&pdev->dev); return r; } dss_debugfs_create_file("hdmi", hdmi_dump_regs); return 0; err: hdmi_pll_uninit(&hdmi.pll); return r; } static void hdmi5_unbind(struct device *dev, struct device *master, void *data) { struct platform_device *pdev = to_platform_device(dev); if (hdmi.audio_pdev) platform_device_unregister(hdmi.audio_pdev); hdmi_uninit_output(pdev); hdmi_pll_uninit(&hdmi.pll); pm_runtime_disable(&pdev->dev); } static const struct component_ops hdmi5_component_ops = { .bind = hdmi5_bind, .unbind = hdmi5_unbind, }; static int hdmi5_probe(struct platform_device *pdev) { return component_add(&pdev->dev, &hdmi5_component_ops); } static int hdmi5_remove(struct platform_device *pdev) { component_del(&pdev->dev, &hdmi5_component_ops); return 0; }
static int sst_acpi_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; int ret = 0; struct intel_sst_drv *ctx; const struct acpi_device_id *id; struct sst_acpi_mach *mach; struct platform_device *mdev; struct platform_device *plat_dev; struct sst_platform_info *pdata; unsigned int dev_id; id = acpi_match_device(dev->driver->acpi_match_table, dev); if (!id) return -ENODEV; dev_dbg(dev, "for %s", id->id); mach = (struct sst_acpi_mach *)id->driver_data; mach = sst_acpi_find_machine(mach); if (mach == NULL) { dev_err(dev, "No matching machine driver found\n"); return -ENODEV; } pdata = mach->pdata; ret = kstrtouint(id->id, 16, &dev_id); if (ret < 0) { dev_err(dev, "Unique device id conversion error: %d\n", ret); return ret; } dev_dbg(dev, "ACPI device id: %x\n", dev_id); plat_dev = platform_device_register_data(dev, pdata->platform, -1, NULL, 0); if (IS_ERR(plat_dev)) { dev_err(dev, "Failed to create machine device: %s\n", pdata->platform); return PTR_ERR(plat_dev); } /* * Create platform device for sst machine driver, * pass machine info as pdata */ mdev = platform_device_register_data(dev, mach->drv_name, -1, (const void *)mach, sizeof(*mach)); if (IS_ERR(mdev)) { dev_err(dev, "Failed to create machine device: %s\n", mach->drv_name); return PTR_ERR(mdev); } ret = sst_alloc_drv_context(&ctx, dev, dev_id); if (ret < 0) return ret; /* Fill sst platform data */ ctx->pdata = pdata; strcpy(ctx->firmware_name, mach->fw_filename); ret = sst_platform_get_resources(ctx); if (ret) return ret; ret = sst_context_init(ctx); if (ret < 0) return ret; /* need to save shim registers in BYT */ ctx->shim_regs64 = devm_kzalloc(ctx->dev, sizeof(*ctx->shim_regs64), GFP_KERNEL); if (!ctx->shim_regs64) { ret = -ENOMEM; goto do_sst_cleanup; } sst_configure_runtime_pm(ctx); platform_set_drvdata(pdev, ctx); return ret; do_sst_cleanup: sst_context_cleanup(ctx); platform_set_drvdata(pdev, NULL); dev_err(ctx->dev, "failed with %d\n", ret); return ret; }