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; }
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; }
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); }
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); }
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); }
/* * 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; }
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; }
/* * 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; }
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; }
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); }
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; }
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); }
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)); }
/* * 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; }
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); }
/* * 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; }
/* * 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; }
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; }
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; }
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; }
int __init s3c2410_init(void) { printk("S3C2410: Initialising architecture\n"); return sysdev_register(&s3c2410_sysdev); }
static void vfp_pm_init(void) { sysdev_class_register(&vfp_pm_sysclass); sysdev_register(&vfp_pm_sysdev); }
static __init int s3c64xx_sysdev_init(void) { sysdev_class_register(&s3c64xx_sysclass); return sysdev_register(&s3c64xx_sysdev); }
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; }
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; }
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; }
static int __init sa1100irq_init_devicefs(void) { sysdev_class_register(&sa1100irq_sysclass); return sysdev_register(&sa1100irq_device); }
/* * 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; }
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); }