Exemplo n.º 1
0
Arquivo: nmi_32.c Projeto: 274914765/C
static int __init init_lapic_nmi_sysfs(void)
{
    int error;

    /* should really be a BUG_ON but b/c this is an
     * init call, it just doesn't work.  -dcz
     */
    if (nmi_watchdog != NMI_LOCAL_APIC)
        return 0;

    if (atomic_read(&nmi_active) < 0)
        return 0;

    error = sysdev_class_register(&nmi_sysclass);
    if (!error)
        error = sysdev_register(&device_lapic_nmi);
    return error;
}
Exemplo n.º 2
0
static int __init smemc_init(void)
{
    int ret = 0;

    if (cpu_is_pxa3xx()) {
        smemc_mmio_base = ioremap(SMEMC_PHYS_BASE, SMEMC_PHYS_SIZE);
        if (smemc_mmio_base == NULL)
            return -ENODEV;

        ret = sysdev_class_register(&smemc_sysclass);
        if (ret)
            return ret;

        ret = sysdev_register(&smemc_sysdev);
    }

    return ret;
}
Exemplo n.º 3
0
static void __init bast_init(void)
{
	sysdev_class_register(&bast_pm_sysclass);
	sysdev_register(&bast_pm_sysdev);

	s3c_i2c0_set_platdata(&bast_i2c_info);
	s3c_nand_set_platdata(&bast_nand_info);
	s3c24xx_fb_set_platdata(&bast_fb_info);
	platform_add_devices(bast_devices, ARRAY_SIZE(bast_devices));

	i2c_register_board_info(0, bast_i2c_devs,
				ARRAY_SIZE(bast_i2c_devs));

	usb_simtec_init();
	nor_simtec_init();
	simtec_audio_add(NULL, true, &bast_audio);

	s3c_cpufreq_setboard(&bast_cpufreq);
}
Exemplo n.º 4
0
int __init exynos4_init(void)
{
    unsigned int value;
    unsigned int tmp;
    unsigned int i;

    printk(KERN_INFO "EXYNOS4: Initializing architecture\n");

    /* set idle function */
    pm_idle = exynos4_idle;

    /*
     * on exynos4x12, CMU reset system power register should to be set 0x0
     */
    if (!soc_is_exynos4210()) {
        for (i = 0; i < ARRAY_SIZE(exynos4_pmu_init_zero); i++)
            __raw_writel(0x0, exynos4_pmu_init_zero[i]);
    }

    /* set sw_reset function */
    s5p_reset_hook = exynos4_sw_reset;

    /* Disable auto wakeup from power off mode */
    for (i = 0; i < num_possible_cpus(); i++) {
        tmp = __raw_readl(S5P_ARM_CORE_OPTION(i));
        tmp &= ~S5P_CORE_OPTION_DIS;
        __raw_writel(tmp, S5P_ARM_CORE_OPTION(i));
    }

    if (soc_is_exynos4212() || soc_is_exynos4412()) {
        value = __raw_readl(S5P_AUTOMATIC_WDT_RESET_DISABLE);
        value &= ~S5P_SYS_WDTRESET;
        __raw_writel(value, S5P_AUTOMATIC_WDT_RESET_DISABLE);
        value = __raw_readl(S5P_MASK_WDT_RESET_REQUEST);
        value &= ~S5P_SYS_WDTRESET;
        //__raw_writel(value, S5P_MASK_WDT_RESET_REQUEST);
        //Temperory ignore ISP reset, for ISP test. Jiangshanbin120405
        __raw_writel((value | (1<< 26)), S5P_MASK_WDT_RESET_REQUEST);

    }

    return sysdev_register(&exynos4_sysdev);
}
Exemplo n.º 5
0
int __init s3c2416_init(void)
{
	printk(KERN_INFO "S3C2416: Initializing architecture\n");

	s3c24xx_reset_hook = s3c2416_hard_reset;
	/* s3c24xx_idle = s3c2416_idle;	*/

	/* change WDT IRQ number */
	s3c_device_wdt.resource[1].start = IRQ_S3C2443_WDT;
	s3c_device_wdt.resource[1].end   = IRQ_S3C2443_WDT;

	/* the i2c devices are directly compatible with s3c2440 */
	s3c_i2c0_setname("s3c2440-i2c");
	s3c_i2c1_setname("s3c2440-i2c");

	s3c_fb_setname("s3c2443-fb");

	return sysdev_register(&s3c2416_sysdev);
}
Exemplo n.º 6
0
/*
 * register_cpu - Setup a driverfs device for a CPU.
 * @cpu - Callers can set the cpu->no_control field to 1, to indicate not to
 *		  generate a control file in sysfs for this CPU.
 * @num - CPU number to use when creating the device.
 *
 * Initialize and register the CPU device.
 */
int __devinit register_cpu(struct cpu *cpu, int num, struct node *root)
{
	int error;

	cpu->node_id = cpu_to_node(num);
	cpu->sysdev.id = num;
	cpu->sysdev.cls = &cpu_sysdev_class;

	error = sysdev_register(&cpu->sysdev);
	if (!error && root)
		error = sysfs_create_link(&root->sysdev.kobj,
					  &cpu->sysdev.kobj,
					  kobject_name(&cpu->sysdev.kobj));
	if (!error && !cpu->no_control)
		register_cpu_control(cpu);
	if (!error)
		cpu_sys_devices[num] = &cpu->sysdev;
	return error;
}
Exemplo n.º 7
0
static int __init s3c24xx_dma_sysdev_register(void)
{
    struct s3c2410_dma_chan *cp = s3c2410_chans;
    int channel, ret;

    for (channel = 0; channel < dma_channels; cp++, channel++) {
        cp->dev.cls = &dma_sysclass;
        cp->dev.id  = channel;
        ret = sysdev_register(&cp->dev);

        if (ret) {
            printk(KERN_ERR "error registering dev for dma %d\n",
                   channel);
            return ret;
        }
    }

    return 0;
}
Exemplo n.º 8
0
Arquivo: node.c Projeto: E-LLP/n900
/*
 * register_node - Setup a sysfs device for a node.
 * @num - Node number to use when creating the device.
 *
 * Initialize and register the node device.
 */
int register_node(struct node *node, int num, struct node *parent)
{
	int error;

	node->sysdev.id = num;
	node->sysdev.cls = &node_class;
	error = sysdev_register(&node->sysdev);

	if (!error){
		sysdev_create_file(&node->sysdev, &attr_cpumap);
		sysdev_create_file(&node->sysdev, &attr_cpulist);
		sysdev_create_file(&node->sysdev, &attr_meminfo);
		sysdev_create_file(&node->sysdev, &attr_numastat);
		sysdev_create_file(&node->sysdev, &attr_distance);

		scan_unevictable_register_node(node);
	}
	return error;
}
Exemplo n.º 9
0
int __init dma_create_sysfs_files(struct dma_channel *chan)
{
	struct sys_device *dev = &chan->dev;
	int ret;

	dev->id  = chan->chan;
	dev->cls = &dma_sysclass;

	ret = sysdev_register(dev);
	if (ret)
		return ret;

	sysdev_create_file(dev, &attr_dev_id);
	sysdev_create_file(dev, &attr_count);
	sysdev_create_file(dev, &attr_mode);
	sysdev_create_file(dev, &attr_flags);
	sysdev_create_file(dev, &attr_config);

	return 0;
}
Exemplo n.º 10
0
int __init s3c2443_init(void)
{
	printk("S3C2443: Initialising architecture\n");

	s3c24xx_reset_hook = s3c2443_hard_reset;

#if !defined (CONFIG_MTD_NAND_S3C)
	s3c_device_nand.name = "s3c2412-nand";
#else
	s3c_device_nand.name = "s3c-nand";
#endif
	/* Rename devices that are specific to s3c2443 */
        s3c_device_lcd.name  = "s3c-lcd";

	/* change WDT IRQ number */
	s3c_device_wdt.resource[1].start = IRQ_S3C2443_WDT;
	s3c_device_wdt.resource[1].end   = IRQ_S3C2443_WDT;

	return sysdev_register(&s3c2443_sysdev);
}
Exemplo n.º 11
0
static int acpi_poweroff_init(void)
{
	if (!acpi_disabled) {
		u8 type_a, type_b;
		acpi_status status;

		status =
		    acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
		if (ACPI_SUCCESS(status)) {
			int error;
			error = sysdev_class_register(&acpi_sysclass);
			if (!error)
				error = sysdev_register(&device_acpi);
			if (!error)
				pm_power_off = acpi_power_off;
			return error;
		}
	}
	return 0;
}
Exemplo n.º 12
0
static int __devinit mxs_lradc_probe(struct platform_device *pdev)
{
	struct resource *res;
	struct mxs_lradc_plat_data *plat_data;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL)
		return -ENODEV;

	plat_data = (struct mxs_lradc_plat_data *)(pdev->dev.platform_data);
	if (plat_data == NULL)
		return -EFAULT;

	mxs_lradc.base = (unsigned int)IO_ADDRESS(res->start);
	mxs_lradc.sys.id = -1;
	mxs_lradc.sys.cls = &mxs_lradc_sysclass;
	mxs_lradc.vddio_voltage = plat_data->vddio_voltage;
	mxs_lradc.battery_voltage = plat_data->battery_voltage;
	hw_lradc_reinit(0, lradc_freq);
	return sysdev_register(&mxs_lradc.sys);
}
Exemplo n.º 13
0
static int __init qfprom_init_sysdev(void)
{
	int err;

	err = sysdev_class_register(&qfprom_sysdev_class);
	if (err) {
		pr_err("%s: sysdev_class_register fail (%d)\n",
			__func__, err);
		return err;
	}

	err = sysdev_register(&qfprom_sys_device);
	if (err) {
		pr_err("%s: sysdev_register fail (%d)\n",
			__func__, err);
		return err;
	}

	return qfprom_create_files(&qfprom_sys_device, qfprom_files,
				ARRAY_SIZE(qfprom_files));
}
Exemplo n.º 14
0
/*
 * register_cpu - Setup a driverfs device for a CPU.
 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
 *	  sysfs for this CPU.
 * @num - CPU number to use when creating the device.
 *
 * Initialize and register the CPU device.
 */
int __devinit register_cpu(struct cpu *cpu, int num)
{
	int error;
	cpu->node_id = cpu_to_node(num);
	cpu->sysdev.id = num;
	cpu->sysdev.cls = &cpu_sysdev_class;

	error = sysdev_register(&cpu->sysdev);

	if (!error && cpu->hotpluggable)
		register_cpu_control(cpu);
	if (!error)
		cpu_sys_devices[num] = &cpu->sysdev;
	if (!error)
		register_cpu_under_node(num, cpu_to_node(num));

#ifdef CONFIG_KEXEC
	if (!error)
		error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes);
#endif
	return error;
}
Exemplo n.º 15
0
int dma_create_sysfs_files(struct dma_channel *chan, struct dma_info *info)
{
	struct sys_device *dev = &chan->dev;
	char name[16];
	int ret;

	dev->id  = chan->vchan;
	dev->cls = &dma_sysclass;

	ret = sysdev_register(dev);
	if (ret)
		return ret;

	sysdev_create_file(dev, &attr_dev_id);
	sysdev_create_file(dev, &attr_count);
	sysdev_create_file(dev, &attr_mode);
	sysdev_create_file(dev, &attr_flags);
	sysdev_create_file(dev, &attr_config);

	snprintf(name, sizeof(name), "dma%d", chan->chan);
	return sysfs_create_link(&info->pdev->dev.kobj, &dev->kobj, name);
}
Exemplo n.º 16
0
/*
 * Attention:
 *
 * Path of camera's sysdev: /sys/devices/system/camera/camera0
 */
static int __init sensorinfo_init(void)
{
    int err;

    err = sysdev_class_register(&camera_sysdev_class);
    if (err) {
        pr_err("%s: sysdev_class_register fail (%d)\n",
               __func__, err);
        return -EFAULT;
    }

    err = sysdev_register(&camera_sys_device);
    if (err) {
        pr_err("%s: sysdev_register fail (%d)\n",
               __func__, err);
        return -EFAULT;
    }

    sensorinfo_create_files(&camera_sys_device, sensorinfo_files,
    ARRAY_SIZE(sensorinfo_files));

    return 0;
}
/*
 * MSM LED Trigger Sys Device Register
 *
 * 1. Torch Mode
 *     enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/torch
 *    disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/torch
 *
 * 2. Flash Mode
 *     enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/flash
 *    disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/flash
 */
static int32_t msm_led_trigger_register_sysdev(struct msm_led_flash_ctrl_t *fctrl)
{
	int32_t i, rc;

	rc = sysdev_class_register(&msm_led_trigger_sysdev_class);
	if (rc) {
			return rc;
	}

	msm_led_trigger_sysdev.id = 0;
	msm_led_trigger_sysdev.cls = &msm_led_trigger_sysdev_class;
	rc = sysdev_register(&msm_led_trigger_sysdev);
	if (rc) {
		sysdev_class_unregister(&msm_led_trigger_sysdev_class);
		return rc;
	}

	for (i = 0; i < ARRAY_SIZE(msm_led_trigger_sysdev_attrs); ++i) {
		rc = sysdev_create_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]);
		if (rc) {
			goto msm_led_trigger_register_sysdev_failed;
		}
	}

	msm_led_trigger_sysdev_fctrl = fctrl;

	return 0;

msm_led_trigger_register_sysdev_failed:

	while (--i >= 0) sysdev_remove_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]);

	sysdev_unregister(&msm_led_trigger_sysdev);
	sysdev_class_unregister(&msm_led_trigger_sysdev_class);

	return rc;
}
Exemplo n.º 18
0
/*
 * Sys device register
 *
 * sysdev file:
 *
 * /sys/devices/system/zte_ftm/zte_ftm0/fusion
 * /sys/devices/system/zte_ftm/zte_ftm0/simlocking
 */
static int32_t ftm_register_sysdev(struct sys_device *sysdev)
{
	int32_t ret;
	int32_t i;

	ret = sysdev_class_register(&ftm_sysdev_class);
	if (ret) {
		return ret;
	}

	sysdev->id = 0;
	sysdev->cls = &ftm_sysdev_class;

	ret = sysdev_register(sysdev);
	if (ret) {
		sysdev_class_unregister(&ftm_sysdev_class);
		return ret;
	}

	for (i = 0; i < ARRAY_SIZE(ftm_attrs); i++) {
		ret = sysdev_create_file(sysdev, ftm_attrs[i]);
		if (ret) {
			goto ftm_fail;
		}
	}

	return 0;

ftm_fail:

	while (--i >= 0) sysdev_remove_file(sysdev, ftm_attrs[i]);

	sysdev_unregister(sysdev);
	sysdev_class_unregister(&ftm_sysdev_class);

	  return ret;
}
Exemplo n.º 19
0
static int __init register_balloon(struct sys_device *sysdev)
{
	int i, error;

	error = sysdev_class_register(&balloon_sysdev_class);
	if (error)
		return error;

	sysdev->id = 0;
	sysdev->cls = &balloon_sysdev_class;

	error = sysdev_register(sysdev);
	if (error) {
		sysdev_class_unregister(&balloon_sysdev_class);
		return error;
	}

	for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) {
		error = sysdev_create_file(sysdev, balloon_attrs[i]);
		if (error)
			goto fail;
	}

	error = sysfs_create_group(&sysdev->kobj, &balloon_info_group);
	if (error)
		goto fail;
	
	return 0;

 fail:
	while (--i >= 0)
		sysdev_remove_file(sysdev, balloon_attrs[i]);
	sysdev_unregister(sysdev);
	sysdev_class_unregister(&balloon_sysdev_class);
	return error;
}
Exemplo n.º 20
0
static int __init init_tsi108_pic_sysfs(void)
{
int rc;

	if (!tsi108_csr_base)
		return -ENODEV;
	printk(KERN_DEBUG "Registering tsi108_pic with sysfs...\n");
	rc = sysdev_class_register(&tsi108_pic_sysclass);
	if (rc) {
		printk(KERN_ERR "Failed registering tsi108_pic sys class\n");
		return -ENODEV;
	}
	rc = sysdev_register(&device_tsi108_pic);
	if (rc) {
		printk(KERN_ERR "Failed registering tsi108_pic sys device\n");
		return -ENODEV;
	}
	rc = sysdev_driver_register(&tsi108_pic_sysclass, &driver_tsi108_pic);
	if (rc) {
		printk(KERN_ERR "Failed registering tsi108_pic sys driver\n");
		return -ENODEV;
	}
	return 0;
}
Exemplo n.º 21
0
static int __init s3c6400_init_pwm(void)
{
	s3c6400_pwm_chan_t *cp;
	int channel;
	int ret;

	printk("S3C PWM Driver, (c) 2006-2007 Samsung Electronics\n");

	ret = sysdev_class_register(&pwm_sysclass);
	if (ret != 0) {
		printk(KERN_ERR "pwm sysclass registration failed\n");
		return -ENODEV;
	}

	for (channel = 0; channel < S3C_PWM_CHANNELS; channel++) {
		cp = &s3c_chans[channel];

		memset(cp, 0, sizeof(s3c6400_pwm_chan_t));

		cp->number = channel;
		/* pwm channel irqs are in order.. */
		cp->irq    = channel + IRQ_TIMER0;

		/* register system device */

		ret = sysdev_register(&cp->sysdev);

		pr_debug("PWM channel %d , irq %d\n",
		       cp->number,  cp->irq);
	}
#ifdef PWM_using_sample
	s3c6400_timer_setup(1,10,1000,10);
#endif

	return ret;
}
Exemplo n.º 22
0
int __init s3c2410_init(void)
{
    printk("S3C2410: Initialising architecture\n");

    return sysdev_register(&s3c2410_sysdev);
}
Exemplo n.º 23
0
static void vfp_pm_init(void)
{
	sysdev_class_register(&vfp_pm_sysclass);
	sysdev_register(&vfp_pm_sysdev);
}
Exemplo n.º 24
0
static __init int s3c64xx_sysdev_init(void)
{
	sysdev_class_register(&s3c64xx_sysclass);
	return sysdev_register(&s3c64xx_sysdev);
}
Exemplo n.º 25
0
static int __init s3c2410_init_dma(void)
{
	s3c2410_dma_chan_t *cp;
	int channel;
	int ret;

	printk("S3C2410 DMA Driver, (c) 2003-2004 Simtec Electronics\n");

	dma_base = ioremap(S3C2410_PA_DMA, 0x200);
	if (dma_base == NULL) {
		printk(KERN_ERR "dma failed to remap register block\n");
		return -ENOMEM;
	}

	ret = sysdev_class_register(&dma_sysclass);
	if (ret != 0) {
		printk(KERN_ERR "dma sysclass registration failed\n");
		goto err;
	}

	dma_kmem = kmem_cache_create("dma_desc", sizeof(s3c2410_dma_buf_t), 0,
				     SLAB_HWCACHE_ALIGN,
				     s3c2410_dma_cache_ctor, NULL);

	if (dma_kmem == NULL) {
		printk(KERN_ERR "dma failed to make kmem cache\n");
		ret = -ENOMEM;
		goto err;
	}

	for (channel = 0; channel < S3C2410_DMA_CHANNELS; channel++) {
		cp = &s3c2410_chans[channel];

		memset(cp, 0, sizeof(s3c2410_dma_chan_t));

		/* dma channel irqs are in order.. */
		cp->number = channel;
		cp->irq    = channel + IRQ_DMA0;
		cp->regs   = dma_base + (channel*0x40);

		/* point current stats somewhere */
		cp->stats  = &cp->stats_store;
		cp->stats_store.timeout_shortest = LONG_MAX;

		/* basic channel configuration */

		cp->load_timeout = 1<<18;

		/* register system device */

		cp->dev.cls = &dma_sysclass;
		cp->dev.id  = channel;
		ret = sysdev_register(&cp->dev);

		printk("DMA channel %d at %p, irq %d\n",
		       cp->number, cp->regs, cp->irq);
	}

	return 0;

 err:
	kmem_cache_destroy(dma_kmem);
	iounmap(dma_base);
	dma_base = NULL;
	return ret;
}
Exemplo n.º 26
0
static int summit_smb347_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct summit_smb347_info *info;
	int ret = 0;
#ifdef SUMMIT_SMB347_DEBUG
	int i = 0;
#endif
	int error = 0;
	unsigned char value = 0xff;

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		return -ENOMEM;
	}

	client->addr = SUMMIT_SMB347_I2C_ADDRESS;

	i2c_set_clientdata(client, info);
	info->client = client;
	info->charger.name = "summit_smb347";
	info->charger.type = POWER_SUPPLY_TYPE_MAINS;
	info->charger.get_property = smb347_get_property;
	info->charger.properties = smb347_charger_props;
	info->charger.num_properties = ARRAY_SIZE(smb347_charger_props);

	ret = power_supply_register(&client->dev, &info->charger);
	if (ret) {
		dev_err(&client->dev, "failed: power supply register\n");
		i2c_set_clientdata(client, NULL);
		kfree(info);
		return ret;
	}

	summit_smb347_i2c_client = info->client;
	summit_smb347_i2c_client->addr = SUMMIT_SMB347_I2C_ADDRESS;

	if (summit_smb347_read_id(&summit_smb347_id_reg) < 0)
		return -ENODEV;

	printk(KERN_INFO "Summit SMB347 detected, chip_id=0x%x\n", summit_smb347_id_reg);

	ret = request_irq(summit_smb347_i2c_client->irq, summit_smb347_irq,
			IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING, "summit_smb347", NULL);

	if (ret != 0) {
		printk(KERN_ERR "Failed to request IRQ %d: %d\n",
				summit_smb347_i2c_client->irq, ret);
	}

	summit_smb347_init_registers();

#ifdef SUMMIT_SMB347_DEBUG
	for (i = 0; i <= 0xE; i++) {
		ret = summit_smb347_i2c_read(i, &value);
		printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value);
	}

	for (i = 0x30; i <= 0x3F; i++) {
		ret = summit_smb347_i2c_read(i, &value);
		printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value);
	}
#endif

	error = sysdev_class_register(&smb347_reg_sysclass);

	if (!error)
		error = sysdev_register(&device_smb347_reg);

	if (!error)
		error = sysdev_create_file(&device_smb347_reg, &attr_smb347_reg);

	error = sysdev_class_register(&smb347_register_sysclass);
	if (!error)
		error = sysdev_register(&device_smb347_register);
	if (!error)
		error = sysdev_create_file(&device_smb347_register, &attr_smb347_register);

	return 0;
}
Exemplo n.º 27
0
static int s3c64xx_dma_init1(int chno, enum dma_ch chbase,
			     int irq, unsigned int base)
{
	struct s3c2410_dma_chan *chptr = &s3c2410_chans[chno];
	struct s3c64xx_dmac *dmac;
	char clkname[16];
	void __iomem *regs;
	void __iomem *regptr;
	int err, ch;

	dmac = kzalloc(sizeof(struct s3c64xx_dmac), GFP_KERNEL);
	if (!dmac) {
		printk(KERN_ERR "%s: failed to alloc mem\n", __func__);
		return -ENOMEM;
	}

	dmac->sysdev.id = chno / 8;
	dmac->sysdev.cls = &dma_sysclass;

	err = sysdev_register(&dmac->sysdev);
	if (err) {
		printk(KERN_ERR "%s: failed to register sysdevice\n", __func__);
		goto err_alloc;
	}

	regs = ioremap(base, 0x200);
	if (!regs) {
		printk(KERN_ERR "%s: failed to ioremap()\n", __func__);
		err = -ENXIO;
		goto err_dev;
	}

	snprintf(clkname, sizeof(clkname), "dma%d", dmac->sysdev.id);

	dmac->clk = clk_get(NULL, clkname);
	if (IS_ERR(dmac->clk)) {
		printk(KERN_ERR "%s: failed to get clock %s\n", __func__, clkname);
		err = PTR_ERR(dmac->clk);
		goto err_map;
	}

	clk_enable(dmac->clk);

	dmac->regs = regs;
	dmac->chanbase = chbase;
	dmac->channels = chptr;

	err = request_irq(irq, s3c64xx_dma_irq, 0, "DMA", dmac);
	if (err < 0) {
		printk(KERN_ERR "%s: failed to get irq\n", __func__);
		goto err_clk;
	}

	regptr = regs + PL080_Cx_BASE(0);

	for (ch = 0; ch < 8; ch++, chno++, chptr++) {
		printk(KERN_INFO "%s: registering DMA %d (%p)\n",
		       __func__, chno, regptr);

		chptr->bit = 1 << ch;
		chptr->number = chno;
		chptr->dmac = dmac;
		chptr->regs = regptr;
		regptr += PL008_Cx_STRIDE;
	}

	/* for the moment, permanently enable the controller */
	writel(PL080_CONFIG_ENABLE, regs + PL080_CONFIG);

	printk(KERN_INFO "PL080: IRQ %d, at %p\n", irq, regs);

	return 0;

err_clk:
	clk_disable(dmac->clk);
	clk_put(dmac->clk);
err_map:
	iounmap(regs);
err_dev:
	sysdev_unregister(&dmac->sysdev);
err_alloc:
	kfree(dmac);
	return err;
}
Exemplo n.º 28
0
static int __init sa1100irq_init_devicefs(void)
{
	sysdev_class_register(&sa1100irq_sysclass);
	return sysdev_register(&sa1100irq_device);
}
Exemplo n.º 29
0
/*
 * First routine called when the kernel module is loaded
 */
static int __init tf_device_register(void)
{
	int error;
	struct tf_device *dev = &g_tf_dev;

	dprintk(KERN_INFO "tf_device_register()\n");

	/*
	 * Initialize the device
	 */
	dev->dev_number = MKDEV(device_major_number,
		TF_DEVICE_MINOR_NUMBER);
	cdev_init(&dev->cdev, &g_tf_device_file_ops);
	dev->cdev.owner = THIS_MODULE;

	g_tf_sysdev.id = 0;
	g_tf_sysdev.cls = &g_tf_device_sys_class;

	INIT_LIST_HEAD(&dev->connection_list);
	spin_lock_init(&dev->connection_list_lock);

#if defined(MODULE) && defined(CONFIG_TF_ZEBRA)
	error = (*tf_comm_early_init)();
	if (error)
		goto module_early_init_failed;

	error = tf_device_mshield_init(smc_mem);
	if (error)
		goto mshield_init_failed;

#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
	error = tf_crypto_hmac_module_init();
	if (error)
		goto hmac_init_failed;

	error = tf_self_test_register_device();
	if (error)
		goto self_test_register_device_failed;
#endif
#endif

	/* register the sysfs object driver stats */
	error = kobject_init_and_add(&dev->kobj,  &tf_ktype, NULL, "%s",
		 TF_DEVICE_BASE_NAME);
	if (error) {
		printk(KERN_ERR "tf_device_register(): "
			"kobject_init_and_add failed (error %d)!\n", error);
		kobject_put(&dev->kobj);
		goto kobject_init_and_add_failed;
	}

	/*
	 * Register the system device.
	 */

	error = sysdev_class_register(&g_tf_device_sys_class);
	if (error != 0) {
		printk(KERN_ERR "tf_device_register():"
			" sysdev_class_register failed (error %d)!\n",
			error);
		goto sysdev_class_register_failed;
	}

	error = sysdev_register(&g_tf_sysdev);
	if (error != 0) {
		dprintk(KERN_ERR "tf_device_register(): "
			"sysdev_register failed (error %d)!\n",
			error);
		goto sysdev_register_failed;
	}

	/*
	 * Register the char device.
	 */
	printk(KERN_INFO "Registering char device %s (%u:%u)\n",
		TF_DEVICE_BASE_NAME,
		MAJOR(dev->dev_number),
		MINOR(dev->dev_number));
	error = register_chrdev_region(dev->dev_number, 1,
		TF_DEVICE_BASE_NAME);
	if (error != 0) {
		printk(KERN_ERR "tf_device_register():"
			" register_chrdev_region failed (error %d)!\n",
			error);
		goto register_chrdev_region_failed;
	}

	error = cdev_add(&dev->cdev, dev->dev_number, 1);
	if (error != 0) {
		printk(KERN_ERR "tf_device_register(): "
			"cdev_add failed (error %d)!\n",
			error);
		goto cdev_add_failed;
	}

	/*
	 * Initialize the communication with the Secure World.
	 */
#ifdef CONFIG_TF_TRUSTZONE
	dev->sm.soft_int_irq = soft_interrupt;
#endif
	error = tf_init(&g_tf_dev.sm);
	if (error != S_SUCCESS) {
		dprintk(KERN_ERR "tf_device_register(): "
			"tf_init failed (error %d)!\n",
			error);
		goto init_failed;
	}

#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
	error = tf_self_test_post_init(&(dev_stats->kobj));
	/* N.B. error > 0 indicates a POST failure, which will not
	   prevent the module from loading. */
	if (error < 0) {
		dprintk(KERN_ERR "tf_device_register(): "
			"tf_self_test_post_vectors failed (error %d)!\n",
			error);
		goto post_failed;
	}
#endif

#ifdef CONFIG_ANDROID
	tf_class = class_create(THIS_MODULE, TF_DEVICE_BASE_NAME);
	device_create(tf_class, NULL,
		dev->dev_number,
		NULL, TF_DEVICE_BASE_NAME);
#endif

#ifdef CONFIG_TF_ZEBRA
	/*
	 * Initializes the /dev/tf_ctrl device node.
	 */
	error = tf_ctrl_device_register();
	if (error)
		goto ctrl_failed;
#endif

#ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT
	address_cache_property((unsigned long) &tf_device_register);
#endif
	/*
	 * Successful completion.
	 */

	dprintk(KERN_INFO "tf_device_register(): Success\n");
	return 0;

	/*
	 * Error: undo all operations in the reverse order
	 */
#ifdef CONFIG_TF_ZEBRA
ctrl_failed:
#endif
#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
	tf_self_test_post_exit();
post_failed:
#endif
init_failed:
	cdev_del(&dev->cdev);
cdev_add_failed:
	unregister_chrdev_region(dev->dev_number, 1);
register_chrdev_region_failed:
	sysdev_unregister(&g_tf_sysdev);
sysdev_register_failed:
	sysdev_class_unregister(&g_tf_device_sys_class);
sysdev_class_register_failed:
kobject_init_and_add_failed:
	kobject_del(&g_tf_dev.kobj);

#if defined(MODULE) && defined(CONFIG_TF_ZEBRA)
#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
	tf_self_test_unregister_device();
self_test_register_device_failed:
	tf_crypto_hmac_module_exit();
hmac_init_failed:
#endif
	tf_device_mshield_exit();
mshield_init_failed:
module_early_init_failed:
#endif
	dprintk(KERN_INFO "tf_device_register(): Failure (error %d)\n",
		error);
	return error;
}
Exemplo n.º 30
0
static void __init bahamas_init(void)
{
	int rc;
	printk("bahamas_init() revision=%d\n", system_rev);

	/*
	 * Setup common MSM GPIOS
	 */
	sdc1_boot_reset();
//        printk("\n\nboard-mega.c: sdc1 boot reset\n\n");

	config_gpios();
//        printk("\n\nboard-mega.c: config gpios\n\n");

	msm_hw_reset_hook = bahamas_reset;
//        printk("\n\nboard-mega.c: msm hw reset hook\n\n");

	msm_acpu_clock_init(&bahamas_clock_data);
//        printk("\n\nmsm acpu clock init\n\n");
	perflock_init(&bahamas_perflock_data);
//        printk("\n\nperflock init\n\n");
	/* adjust GPIOs based on bootloader request */
	/* XXX: on Memphis,
	 *      GPIO#86 is H2W DAT / UART RX for HTC 11-Pin
	 *      GPIO#87 is H2W CLK / UART TX for HTC 11-Pin
	 *      We would need to use UART3 as debug port
	 *
	 * TODO: switch UART3 and H2W (for headset detect)
	 *       based on bootloader request.
	 */

/*#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
	if (!opt_disable_uart3)
		msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
				      &msm_device_uart3.dev, 1);
#endif*/


	/* touchscreen must be powered before we enable i2c pullup */
#if 0 /* TODO: do some equivalent operations here */
	udelay(50);
	trout_gpio_write(NULL, TROUT_GPIO_I2C_PULL, 1);
#endif

	/* put the AF VCM in powerdown mode to avoid noise */
#if 0
	trout_gpio_write(NULL, TROUT_GPIO_VCM_PWDN, 1);
	mdelay(100);
	trout_i2c_sysdev_resume(NULL);
#endif

#if 0 /* TODO: do some equivalent operations here */
	if(sysdev_class_register(&trout_i2c_sysdev_class) == 0)
		sysdev_register(&trout_i2c_sys_device);
#endif

	#ifdef CONFIG_SERIAL_MSM_HS
	msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
	msm_add_serial_devices(3);
	#else
	msm_add_serial_devices(0);
	#endif

	msm_add_serial_devices(2);

	msm_add_usb_devices(NULL,NULL);

	//msm_change_usb_id(0x0bb4, 0x0c06);
	if (board_mcp_monodie())
		msm_add_mem_devices(&pmem_setting_monodie);
	else
		msm_add_mem_devices(&pmem_setting_dualdie);
	msm_init_pmic_vibrator();
//        printk("\n\nboard-mega.c: msm init pmic vibrator\n\n");

	bahamas_init_h2w_power_gpio();
//        printk("\n\nboard-mega.c: bahamas init h2w power gpio\n\n");
//#if 1
	rc = bahamas_init_mmc(system_rev);
//        printk("\n\nboard-mega.c: init mmc\n\n");
	if (rc)
		printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
//#endif
	if(!system_rev)
		bahamas_reset_keys_device.dev.platform_data = &bahamas_reset_keys_pdata0;
	/*CC090319*/
/*	if  (bahamas_is_3M_camera())   {
		msm_camera_device_data.sinfo = &msm_camera_sensor_mt9t013;
		}
	else  {
		msm_camera_device_data.sinfo = &msm_camera_sensor_s5k4b2fx;
	}*/

	if(system_rev < 3) {
		if (panel_detect() == PANEL_WINTEK) {
			microp_data.num_pins   = ARRAY_SIZE(microp_pins_0_wint);
			microp_data.pin_config = microp_pins_0_wint;
		} else {
			microp_data.num_pins   = ARRAY_SIZE(microp_pins_0);
			microp_data.pin_config = microp_pins_0;
		}
		i2c_microp_devices.irq = 0;
	} else if (panel_detect() == PANEL_WINTEK) {
		microp_data.num_pins   = ARRAY_SIZE(microp_pins_1_wint);
		microp_data.pin_config = microp_pins_1_wint;
	}

/*~CC090319*/
	//platform_add_devices(devices, ARRAY_SIZE(devices));

	/* Read Config 8 200 (Full Speed USB Mode) */
	/*if (readl(MSM_SHARED_RAM_BASE + 0xFC054) & 0x200)
		bahamas_h2w_data.flags |= FULL_SPEED_USB;

	if (system_rev >= 3)
		bahamas_h2w_data.flags |= _35MM_MIC_DET_L2H;

/*	if (system_rev >= 5)
		i2c_register_board_info(0, i2c_sensor, ARRAY_SIZE(i2c_sensor));

	i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
	i2c_register_board_info(0 ,&i2c_microp_devices, 1);

	/* SD card door should wake the device */
	//trout_gpio_irq_set_wake(TROUT_GPIO_TO_INT(TROUT_GPIO_SD_DOOR_N), 1);
	msm_hsusb_set_vbus_state(1);
}