コード例 #1
0
__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;
}
コード例 #2
0
ファイル: acquirewdt.c プロジェクト: 3null/linux
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;
}
コード例 #3
0
ファイル: devices.c プロジェクト: 01org/KVMGT-kernel
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));
	}
}
コード例 #4
0
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;
}
コード例 #5
0
ファイル: bma020_acc.c プロジェクト: moikop/Astrum-Kernel
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;
}
コード例 #6
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;
}
コード例 #7
0
ファイル: olpc_battery.c プロジェクト: 274914765/C
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;
}
コード例 #8
0
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;
}
コード例 #9
0
ファイル: mach-mini2440.c プロジェクト: IoveSunny/DreamBox
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();
}
コード例 #10
0
ファイル: simone.c プロジェクト: 33d/linux-2.6.21-hh20
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;
}
コード例 #11
0
ファイル: mm-imx5.c プロジェクト: benedictsibiya/linux
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));
}
コード例 #12
0
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);
}
コード例 #13
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;
}
コード例 #14
0
ファイル: ethernet.c プロジェクト: robacklin/uclinux-linux
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;
}
コード例 #15
0
ファイル: warp-fpga.c プロジェクト: dvangilst/dahdi-linux
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;
}
コード例 #16
0
ファイル: dummy.c プロジェクト: 325116067/semc-qsd8x50
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;
}
コード例 #17
0
ファイル: setup.c プロジェクト: 0-T-0/ps4-linux
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,
		}
	};
コード例 #18
0
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();
}
コード例 #19
0
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;
}
コード例 #20
0
ファイル: battery_driver.c プロジェクト: andycodes/helloworld
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;
}
コード例 #21
0
ファイル: rtc_cmos_setup.c プロジェクト: human3000/linux-2.6
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;
}
コード例 #22
0
ファイル: ohci-rbus.c プロジェクト: OpenHMR/Open-HMR600
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);
}
コード例 #23
0
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;
}
コード例 #24
0
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));
}
コード例 #25
0
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;
}
コード例 #26
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;
}
コード例 #27
0
ファイル: mv64x60_dev.c プロジェクト: 3sOx/asuswrt-merlin
/*
 * 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;
}
コード例 #28
0
ファイル: leds-apu.c プロジェクト: LordVeovis/gentoo
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;
}
コード例 #29
0
ファイル: .mali_drv.c プロジェクト: newsy5/OrangePI-Kernel
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;
}
コード例 #30
0
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;
}