__init struct platform_device *host_pdev_register(struct resource *res, int n_res, struct fsl_usb2_platform_data *config) { struct platform_device *pdev; int rc; pr_debug("register host res=0x%p, size=%d\n", res, n_res); pdev = platform_device_register_simple("fsl-ehci", usb_mxc_instance_id, res, n_res); if (IS_ERR(pdev)) { pr_debug("can't register %s Host, %ld\n", config->name, PTR_ERR(pdev)); return NULL; } pdev->dev.coherent_dma_mask = 0xffffffff; pdev->dev.dma_mask = &ehci_dmamask; /* * platform_device_add_data() makes a copy of * the platform_data passed in. That makes it * impossible to share the same config struct for * all OTG devices (host,gadget,otg). So, just * set the platorm_data pointer ourselves. */ rc = platform_device_add_data(pdev, config, sizeof(struct fsl_usb2_platform_data)); if (rc) { platform_device_unregister(pdev); return NULL; } printk(KERN_INFO "usb: %s host (%s) registered\n", config->name, config->transceiver); pr_debug("pdev=0x%p dev=0x%p resources=0x%p pdata=0x%p\n", pdev, &pdev->dev, pdev->resource, pdev->dev.platform_data); usb_mxc_instance_id++; return pdev; }
static int __init acq_init(void) { int err; pr_info("WDT driver for Acquire single board computer initialising\n"); acq_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0); if (IS_ERR(acq_platform_device)) return PTR_ERR(acq_platform_device); err = platform_driver_probe(&acquirewdt_driver, acq_probe); if (err) goto unreg_platform_device; return 0; unreg_platform_device: platform_device_unregister(acq_platform_device); return err; }
static void __init clps711x_add_gpio(void) { unsigned i; struct resource gpio_res[2]; memset(gpio_res, 0, sizeof(gpio_res)); gpio_res[0].flags = IORESOURCE_MEM; gpio_res[1].flags = IORESOURCE_MEM; for (i = 0; i < ARRAY_SIZE(clps711x_gpios); i++) { gpio_res[0].start = CLPS711X_PHYS_BASE + clps711x_gpios[i][0]; gpio_res[0].end = gpio_res[0].start; gpio_res[1].start = CLPS711X_PHYS_BASE + clps711x_gpios[i][1]; gpio_res[1].end = gpio_res[1].start; platform_device_register_simple("clps711x-gpio", i, gpio_res, ARRAY_SIZE(gpio_res)); } }
static int __init geodewdt_init(void) { int ret; ret = platform_driver_register(&geodewdt_driver); if (ret) return ret; geodewdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0); if (IS_ERR(geodewdt_platform_device)) { ret = PTR_ERR(geodewdt_platform_device); goto err; } return 0; err: platform_driver_unregister(&geodewdt_driver); return ret; }
static int __init bma020_acc_init(void) { int result; result = platform_driver_register( &bma020_accelerometer_driver ); if( result ) { return result; } bma020_accelerometer_device = platform_device_register_simple( "bma020-accelerometer", -1, NULL, 0 ); if( IS_ERR( bma020_accelerometer_device ) ) { return PTR_ERR( bma020_accelerometer_device ); } return 0; }
static int __init mmi_key_init(void) { int rc = 0; /* register a platform device */ mmi_key_dev = platform_device_register_simple("mmi_key_dev",-1,NULL,0); if(IS_ERR(mmi_key_dev)) { printk(KERN_ALERT "mmi_key_dev: platform_device_register_simple error\n"); return -1; } rc = device_create_file(&mmi_key_dev->dev,&dev_attr_keytest); if(rc) { platform_device_unregister(mmi_key_dev); printk(KERN_ALERT "mmi_key_dev: sysfs_create_file error\n"); } return rc; }
static int __init olpc_bat_init(void) { int ret = 0; uint8_t status; if (!olpc_platform_info.ecver) return -ENXIO; if (olpc_platform_info.ecver < 0x43) { printk(KERN_NOTICE "OLPC EC version 0x%02x too old for battery driver.\n", olpc_platform_info.ecver); return -ENXIO; } ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1); if (ret) return ret; /* Ignore the status. It doesn't actually matter */ bat_pdev = platform_device_register_simple("olpc-battery", 0, NULL, 0); if (IS_ERR(bat_pdev)) return PTR_ERR(bat_pdev); ret = power_supply_register(&bat_pdev->dev, &olpc_ac); if (ret) goto ac_failed; olpc_bat.name = bat_pdev->name; ret = power_supply_register(&bat_pdev->dev, &olpc_bat); if (ret) goto battery_failed; goto success; battery_failed: power_supply_unregister(&olpc_ac); ac_failed: platform_device_unregister(bat_pdev); success: return ret; }
static int __init ct82c710_init(void) { if (ct82c710_probe()) return -ENODEV; ct82c710_device = platform_device_register_simple("ct82c710", -1, &ct82c710_iores, 1); if (IS_ERR(ct82c710_device)) return PTR_ERR(ct82c710_device); if (!(ct82c710_port = ct82c710_allocate_port())) { platform_device_unregister(ct82c710_device); return -ENOMEM; } serio_register_port(ct82c710_port); printk(KERN_INFO "serio: C&T 82c710 mouse port at %#lx irq %d\n", CT82C710_DATA, CT82C710_IRQ); return 0; }
static void __init mini2440_machine_init(void) { s3c24xx_fb_set_platdata(&s3c24xx_fb_info); s3c_i2c0_set_platdata(NULL); s3c2410_gpio_cfgpin(S3C2410_GPC(0), S3C2410_GPC0_LEND); printk("S3C2410_GPA=%d\n",S3C2410_GPA(0)); printk("S3C2410_GPB=%d\n",S3C2410_GPB(0)); printk("S3C2410_GPC=%d\n",S3C2410_GPC(0)); printk("S3C2410_GPD=%d\n",S3C2410_GPD(0)); printk("S3C2410_GPE=%d\n",S3C2410_GPE(0)); printk("S3C2410_GPF=%d\n",S3C2410_GPF(0)); printk("S3C2410_GPG=%d\n",S3C2410_GPG(0)); printk("S3C2410_GPH=%d\n",S3C2410_GPH(0)); s3c_device_nand.dev.platform_data = &friendly_arm_nand_info; s3c_device_sdi.dev.platform_data = &mini2440_mmc_cfg; platform_add_devices(mini2440_devices, ARRAY_SIZE(mini2440_devices)); platform_device_register_simple("GPIODEV", 0, &gpiodev_resource, 1); //GPIO resource MAP s3c_pm_init(); }
static int __devinit simone_probe(struct platform_device *pdev) { struct snd_soc_card *card = &snd_soc_simone; int ret; simone_snd_ac97_device = platform_device_register_simple("ac97-codec", -1, NULL, 0); if (IS_ERR(simone_snd_ac97_device)) return PTR_ERR(simone_snd_ac97_device); card->dev = &pdev->dev; ret = snd_soc_register_card(card); if (ret) { dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n", ret); platform_device_unregister(simone_snd_ac97_device); } return ret; }
void __init imx51_soc_init(void) { /* i.mx51 has the i.mx31 type gpio */ mxc_register_gpio("imx31-gpio", 0, MX51_GPIO1_BASE_ADDR, SZ_16K, MX51_INT_GPIO1_LOW, MX51_INT_GPIO1_HIGH); mxc_register_gpio("imx31-gpio", 1, MX51_GPIO2_BASE_ADDR, SZ_16K, MX51_INT_GPIO2_LOW, MX51_INT_GPIO2_HIGH); mxc_register_gpio("imx31-gpio", 2, MX51_GPIO3_BASE_ADDR, SZ_16K, MX51_INT_GPIO3_LOW, MX51_INT_GPIO3_HIGH); mxc_register_gpio("imx31-gpio", 3, MX51_GPIO4_BASE_ADDR, SZ_16K, MX51_INT_GPIO4_LOW, MX51_INT_GPIO4_HIGH); pinctrl_provide_dummies(); /* i.mx51 has the i.mx35 type sdma */ imx_add_imx_sdma("imx35-sdma", MX51_SDMA_BASE_ADDR, MX51_INT_SDMA, &imx51_sdma_pdata); /* Setup AIPS registers */ imx_set_aips(MX51_IO_ADDRESS(MX51_AIPS1_BASE_ADDR)); imx_set_aips(MX51_IO_ADDRESS(MX51_AIPS2_BASE_ADDR)); /* i.mx51 has the i.mx31 type audmux */ platform_device_register_simple("imx31-audmux", 0, imx51_audmux_res, ARRAY_SIZE(imx51_audmux_res)); }
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); r8a73a4_add_dt_devices(); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); platform_device_register_simple("cpufreq-cpu0", -1, NULL, 0); }
static int __init mmc328x_init(void) { int result; result = platform_driver_register( &mmc328x_magnetic_driver ); pr_info("mmc328x driver: init : %d\n",result); atomic_set(&suspend_flag, 0); pr_info("mmc328x suspend mode : %d\n",suspend_flag.counter); if( result ) { return result; } mmc328x_magnetic_device = platform_device_register_simple( "mmc328x-magnetic", -1, NULL, 0 ); if( IS_ERR( mmc328x_magnetic_device ) ) { return PTR_ERR( mmc328x_magnetic_device ); } return 0; }
static int __init cvm_oct_init_module(void) { int err; struct platform_device *dev; err = platform_driver_register(&cvm_oct_driver); if (err) { pr_err("Failed to register cavium-ethernet driver\n"); return err; } dev = platform_device_register_simple(cvm_oct_driver.driver.name, -1, NULL, 0); if (IS_ERR(dev)) { platform_driver_unregister(&cvm_oct_driver); return PTR_ERR(dev); } cvm_oct_plat_device = dev; return 0; }
static int __init warpfpga_init_module(void) { int ret = 0; // Create PDX global veriable - this is for legacy uses if ((pdx = kzalloc(sizeof(DEVICE_EXTENSION), GFP_KERNEL)) == NULL) { printk(KERN_ERR "%s:%s() error allocating memory\n", __FILE__, __FUNCTION__); return -ENOMEM; } // You need a device for DMA or nothing works with 2.6.31 pdx->dev = platform_device_register_simple("warp-dev", 0, NULL, 0); pdx->dev->dev.coherent_dma_mask = ~0ULL; // Create spin-lock spin_lock_init(&fpgalock); // Register device printk(KERN_INFO "Registering WARP FPGA driver\n"); #ifdef WARP_V2 ret = platform_driver_register(&warp_fpga_platform_driver); #else ret = pci_register_driver(&warp_fpga_pci_driver); #endif printk(KERN_INFO "WARP FPGA driver registration successful\n"); // Check probing was done if (ret != 0) { printk(KERN_ERR "%s:%s() error registering driver\n", __FILE__, __FUNCTION__); goto error_cleanup; } return 0; error_cleanup: kfree(pdx); platform_device_unregister(pdx->dev); return -ENOENT; }
static int __init alsa_card_dummy_init(void) { int i, cards, err; err = platform_driver_register(&snd_dummy_driver); if (err < 0) return err; err = alloc_fake_buffer(); if (err < 0) { platform_driver_unregister(&snd_dummy_driver); return err; } cards = 0; for (i = 0; i < SNDRV_CARDS; i++) { struct platform_device *device; if (! enable[i]) continue; device = platform_device_register_simple(SND_DUMMY_DRIVER, i, NULL, 0); if (IS_ERR(device)) continue; if (!platform_get_drvdata(device)) { platform_device_unregister(device); continue; } devices[i] = device; cards++; } if (!cards) { #ifdef MODULE printk(KERN_ERR "Dummy soundcard not found or device busy\n"); #endif snd_dummy_unregister_all(); return -ENODEV; } return 0; }
static void __init toshiba_rbtx4927_rtc_init(void) { struct resource res = { .start = RBTX4927_BRAMRTC_BASE - IO_BASE, .end = RBTX4927_BRAMRTC_BASE - IO_BASE + 0x800 - 1, .flags = IORESOURCE_MEM, }; platform_device_register_simple("rtc-ds1742", -1, &res, 1); } static void __init rbtx4927_ne_init(void) { struct resource res[] = { { .start = RBTX4927_RTL_8019_BASE, .end = RBTX4927_RTL_8019_BASE + 0x20 - 1, .flags = IORESOURCE_IO, }, { .start = RBTX4927_RTL_8019_IRQ, .flags = IORESOURCE_IRQ, } };
void __init imx27_soc_init(void) { mxc_arch_reset_init(MX27_IO_ADDRESS(MX27_WDOG_BASE_ADDR)); mxc_device_init(); /* i.mx27 has the i.mx21 type gpio */ mxc_register_gpio("imx21-gpio", 0, MX27_GPIO1_BASE_ADDR, SZ_256, MX27_INT_GPIO, 0); mxc_register_gpio("imx21-gpio", 1, MX27_GPIO2_BASE_ADDR, SZ_256, MX27_INT_GPIO, 0); mxc_register_gpio("imx21-gpio", 2, MX27_GPIO3_BASE_ADDR, SZ_256, MX27_INT_GPIO, 0); mxc_register_gpio("imx21-gpio", 3, MX27_GPIO4_BASE_ADDR, SZ_256, MX27_INT_GPIO, 0); mxc_register_gpio("imx21-gpio", 4, MX27_GPIO5_BASE_ADDR, SZ_256, MX27_INT_GPIO, 0); mxc_register_gpio("imx21-gpio", 5, MX27_GPIO6_BASE_ADDR, SZ_256, MX27_INT_GPIO, 0); pinctrl_provide_dummies(); imx_add_imx_dma("imx27-dma", MX27_DMA_BASE_ADDR, MX27_INT_DMACH0, 0); /* No ERR irq */ /* imx27 has the imx21 type audmux */ platform_device_register_simple("imx21-audmux", 0, imx27_audmux_res, ARRAY_SIZE(imx27_audmux_res)); imx27_pm_init(); }
static int __init alsa_card_mpu401_init(void) { int i, err; if ((err = platform_driver_register(&snd_mpu401_driver)) < 0) return err; for (i = 0; i < SNDRV_CARDS; i++) { struct platform_device *device; if (! enable[i]) continue; #ifdef CONFIG_PNP if (pnp[i]) continue; #endif device = platform_device_register_simple(SND_MPU401_DRIVER, i, NULL, 0); if (IS_ERR(device)) continue; if (!platform_get_drvdata(device)) { platform_device_unregister(device); continue; } platform_devices[i] = device; snd_mpu401_devices++; } err = pnp_register_driver(&snd_mpu401_pnp_driver); if (!err) pnp_registered = 1; if (!snd_mpu401_devices) { #ifdef MODULE printk(KERN_ERR "MPU-401 device not found or device busy\n"); #endif snd_mpu401_unregister_all(); return -ENODEV; } return 0; }
static int __init android_bat_init(void) { int ret = 0; bat_pdev = platform_device_register_simple("battery", 0, NULL, 0); ret = power_supply_register(&bat_pdev->dev, &android_ac); if (ret) goto ac_failed; android_bat.name = bat_pdev->name; ret = power_supply_register(&bat_pdev->dev, &android_bat); if (ret) goto battery_failed; goto success; power_supply_unregister(&android_bat); battery_failed: power_supply_unregister(&android_ac); ac_failed: platform_device_unregister(bat_pdev); success: return ret; }
static int __init add_rtc(void) { struct device_node *np; struct platform_device *pd; struct resource res[2]; int ret; memset(&res, 0, sizeof(res)); np = of_find_compatible_node(NULL, NULL, "pnpPNP,b00"); if (!np) return -ENODEV; ret = of_address_to_resource(np, 0, &res[0]); of_node_put(np); if (ret) return ret; /* * RTC_PORT(x) is hardcoded in asm/mc146818rtc.h. Verify that the * address provided by the device node matches. */ if (res[0].start != RTC_PORT(0)) return -EINVAL; /* Use a fixed interrupt value of 8 since on PPC if we are using this * its off an i8259 which we ensure has interrupt numbers 0..15. */ res[1].start = 8; res[1].end = 8; res[1].flags = IORESOURCE_IRQ; pd = platform_device_register_simple("rtc_cmos", -1, &res[0], 2); if (IS_ERR(pd)) return PTR_ERR(pd); return 0; }
static int __init ohci_hcd_pci_init (void) { int ret; //cfyeh+ 2005/10/05 printk (KERN_DEBUG "%s: " DRIVER_INFO " (PCI)\n", hcd_name); if (usb_disabled()) return -ENODEV; pr_debug ("%s: block sizes: ed %Zd td %Zd\n", hcd_name, sizeof (struct ed), sizeof (struct td)); //cfyeh+ 2005/10/05 ohci_hcd_devs = platform_device_register_simple((char *)hcd_name, -1, NULL, 0); if (IS_ERR(ohci_hcd_devs)) { ret = PTR_ERR(ohci_hcd_devs); return ret; } return driver_register (&ohci_hcd_driver); }
static int aml_m3_audio_probe(struct platform_device *pdev) { int ret; //pdev->dev.platform_data; // TODO printk("***Entered %s:%s\n", __FILE__,__func__); aml_m3_snd_device = platform_device_alloc("soc-audio", -1); if (!aml_m3_snd_device) { printk(KERN_ERR "ASoC: Platform device allocation failed\n"); ret = -ENOMEM; } platform_set_drvdata(aml_m3_snd_device,&aml_m3_snd_devdata); aml_m3_snd_devdata.dev = &aml_m3_snd_device->dev; ret = platform_device_add(aml_m3_snd_device); if (ret) { printk(KERN_ERR "ASoC: Platform device allocation failed\n"); goto error2; } aml_m3_platform_device = platform_device_register_simple("aml_m3_codec", -1, NULL, 0); aml_m3_platform_device->dev.platform_data = pdev->dev.platform_data; #if HP_DET sdev.name = "h2w";//for report headphone to android ret = switch_dev_register(&sdev); if (ret < 0){ printk(KERN_ERR "ASoC: register switch dev failed\n"); goto error1; } #endif return 0; error1: platform_device_unregister(aml_m3_snd_device); error2: platform_device_put(aml_m3_snd_device); return ret; }
void __init imx53_soc_init(void) { /* */ mxc_register_gpio("imx31-gpio", 0, MX53_GPIO1_BASE_ADDR, SZ_16K, MX53_INT_GPIO1_LOW, MX53_INT_GPIO1_HIGH); mxc_register_gpio("imx31-gpio", 1, MX53_GPIO2_BASE_ADDR, SZ_16K, MX53_INT_GPIO2_LOW, MX53_INT_GPIO2_HIGH); mxc_register_gpio("imx31-gpio", 2, MX53_GPIO3_BASE_ADDR, SZ_16K, MX53_INT_GPIO3_LOW, MX53_INT_GPIO3_HIGH); mxc_register_gpio("imx31-gpio", 3, MX53_GPIO4_BASE_ADDR, SZ_16K, MX53_INT_GPIO4_LOW, MX53_INT_GPIO4_HIGH); mxc_register_gpio("imx31-gpio", 4, MX53_GPIO5_BASE_ADDR, SZ_16K, MX53_INT_GPIO5_LOW, MX53_INT_GPIO5_HIGH); mxc_register_gpio("imx31-gpio", 5, MX53_GPIO6_BASE_ADDR, SZ_16K, MX53_INT_GPIO6_LOW, MX53_INT_GPIO6_HIGH); mxc_register_gpio("imx31-gpio", 6, MX53_GPIO7_BASE_ADDR, SZ_16K, MX53_INT_GPIO7_LOW, MX53_INT_GPIO7_HIGH); /* */ imx_add_imx_sdma("imx35-sdma", MX53_SDMA_BASE_ADDR, MX53_INT_SDMA, &imx53_sdma_pdata); /* */ imx_set_aips(MX53_IO_ADDRESS(MX53_AIPS1_BASE_ADDR)); imx_set_aips(MX53_IO_ADDRESS(MX53_AIPS2_BASE_ADDR)); /* */ platform_device_register_simple("imx31-audmux", 0, imx53_audmux_res, ARRAY_SIZE(imx53_audmux_res)); }
static int __init kr3dm_acc_init(void) { int result; result = platform_driver_register( &kr3dm_accelerometer_driver); #if DEBUG printk("[KR3DM] ********** kr3dm_acc_init =====================\n"); #endif if( result ) { return result; } kr3dm_accelerometer_device = platform_device_register_simple( "kr3dm-accelerometer", -1, NULL, 0 ); if( IS_ERR( kr3dm_accelerometer_device ) ) { return PTR_ERR( kr3dm_accelerometer_device ); } return 0; }
static int errhandler_add_device(void) { int err; err = misc_register(&errhandler_device); if (err) goto err1; errhandler_platform_dev = platform_device_register_simple("errhandler", -1, NULL, 0); if (IS_ERR(errhandler_platform_dev)) { err = PTR_ERR(errhandler_platform_dev); goto err2; } return 0; err2: misc_deregister(&errhandler_device); err1: return err; }
/* * Create mv64x60_eth platform devices */ static int __init eth_register_shared_pdev(struct device_node *np) { struct platform_device *pdev; struct resource r[1]; int err; np = of_get_parent(np); if (!np) return -ENODEV; err = of_address_to_resource(np, 0, &r[0]); of_node_put(np); if (err) return err; pdev = platform_device_register_simple(MV643XX_ETH_SHARED_NAME, 0, r, 1); if (IS_ERR(pdev)) return PTR_ERR(pdev); return 0; }
static int __init apu_led_init(void) { int ret; ret = platform_driver_register(&apu_led_driver); if (ret < 0) goto out; pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); platform_driver_unregister(&apu_led_driver); goto out; } p1 = ioremap(BASEADDR, 1); p2 = ioremap(BASEADDR+1, 1); p3 = ioremap(BASEADDR+2, 1); out: return ret; }
static int mali_driver_load(struct drm_device *dev, unsigned long chipset) { int ret; unsigned long base, size; drm_mali_private_t *dev_priv; printk(KERN_ERR "DRM: mali_driver_load start\n"); dev_priv = drm_calloc(1, sizeof(drm_mali_private_t), DRM_MEM_DRIVER); if (dev_priv == NULL) { return -ENOMEM; } dev->dev_private = (void *)dev_priv; if (NULL == dev->platformdev) { dev->platformdev = platform_device_register_simple(mali_drm_device_name, 0, NULL, 0); pdev = dev->platformdev; } #if 0 base = drm_get_resource_start(dev, 1); size = drm_get_resource_len(dev, 1); #endif ret = drm_sman_init(&dev_priv->sman, 2, 12, 8); if (ret) { drm_free(dev_priv, sizeof(dev_priv), DRM_MEM_DRIVER); } //if ( ret ) kfree( dev_priv ); printk(KERN_ERR "DRM: mali_driver_load done\n"); return ret; }
static int __init ibwdt_init(void) { int err; printk(KERN_INFO PFX "WDT driver for IB700 single board computer initialising.\n"); err = platform_driver_register(&ibwdt_driver); if (err) return err; ibwdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0); if (IS_ERR(ibwdt_platform_device)) { err = PTR_ERR(ibwdt_platform_device); goto unreg_platform_driver; } return 0; unreg_platform_driver: platform_driver_unregister(&ibwdt_driver); return err; }