void __init msm7627a_add_io_devices(void) { /* touchscreen */ #ifdef CONFIG_TOUCHSCREEN_ATMEL_MAXTOUCH if (machine_is_msm7625a_surf() || machine_is_msm7625a_ffa()) { atmel_ts_pdata.min_x = 0; atmel_ts_pdata.max_x = 480; atmel_ts_pdata.min_y = 0; atmel_ts_pdata.max_y = 320; } i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, atmel_ts_i2c_info, ARRAY_SIZE(atmel_ts_i2c_info)); #endif //>>MelChang,[Harry] Add ELAN eKTF2040 and ILITEK ILI2013t touch panel IC #if defined(CONFIG_TOUCHSCREEN_ELAN_EKTF2040) || defined(CONFIG_TOUCHSCREEN_ILITEK_2103T) || defined(CONFIG_TOUCHSCREEN_CYPRESS_CY8CTMA340) gpio_tlmm_config(GPIO_CFG(CAP_TOUCH_DETECT, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); mdelay(10); if(gpio_get_value(CAP_TOUCH_DETECT)) { #if defined(CONFIG_TOUCHSCREEN_CYPRESS_CY8CTMA340) pr_info("-- CAP_TOUCH_DETECT is Cypress IC + Jtouch Panel --\n"); i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, i2c_touch_devices_cypress_tma340, ARRAY_SIZE(i2c_touch_devices_cypress_tma340)); #else pr_info("-- CAP_TOUCH_DETECT High - Fail --\n"); #endif } else { #if defined(CONFIG_TOUCHSCREEN_ELAN_EKTF2040) pr_info("-- CAP_TOUCH_DETECT is ELAN IC --\n"); elan_ktf2k_ts_power(1); i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, i2c_touch_devices_harry_elan, ARRAY_SIZE(i2c_touch_devices_harry_elan)); #elif defined(CONFIG_TOUCHSCREEN_CYPRESS_CY8CTMA340) pr_info("-- CAP_TOUCH_DETECT is Cypress IC + Second Source Panel --\n"); i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, i2c_touch_devices_cypress_tma340, ARRAY_SIZE(i2c_touch_devices_cypress_tma340)); #else pr_info("-- CAP_TOUCH_DETECT Low - Fail --\n"); #endif } #endif //>>MelChang,[Harry] Add ELAN eKTF2040 and ILITEK ILI2013t touch panel IC /*++ Huize - 20110914 Register sensor device ++*/ i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, Sensor_devices_info, ARRAY_SIZE(Sensor_devices_info)); /*-- Huize - 20110914 Register sensor device --*/ /* keypad */ //Mel, 2012/4/18, Enable Key GPIO. ++ #if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE) platform_device_register(&NanHu_button_device); #endif //Mel, 2012/4/18, Enable Key GPIO. -- //Mel, 2012/4/18, Disable Key Matrix. ++ #if 0 platform_device_register(&kp_pdev); #endif //Mel, 2012/4/18, Disable Key Matrix. -- /* headset */ platform_device_register(&hs_pdev); /* LED: configure it as a pdm function */ if (gpio_tlmm_config(GPIO_CFG(LED_GPIO_PDM, 3, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), GPIO_CFG_ENABLE)) pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, LED_GPIO_PDM); else platform_device_register(&led_pdev); /* ++ Edison add led device ++ */ #ifdef CONFIG_LEDS_CHIP_LM3533 led_lm3533_hw_init(); i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, i2c_led_devices_LM3533, ARRAY_SIZE(i2c_led_devices_LM3533)); #endif /* -- Edison add led device -- */ /* Vibrator */ //<<Skies, 2011/10/12 enable vibrator function //if (machine_is_msm7x27a_ffa() || machine_is_msm7625a_ffa() // || machine_is_msm8625_ffa()) //>>Skies, 2011/10/12 msm_init_pmic_vibrator(); }
/*! * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_ipu_data.di_clk[0] = clk_get(NULL, "ipu_di0_clk"); mxc_ipu_data.di_clk[1] = clk_get(NULL, "ipu_di1_clk"); mxc_ipu_data.csi_clk[0] = clk_get(NULL, "ssi_ext1_clk"); mxc_spdif_data.spdif_core_clk = clk_get(NULL, "spdif_xtal_clk"); clk_put(mxc_spdif_data.spdif_core_clk); mxcsdhc1_device.resource[2].start = gpio_to_irq(MX53_SMD_SD1_CD); mxcsdhc1_device.resource[2].end = gpio_to_irq(MX53_SMD_SD1_CD); mxc_cpu_common_init(); mx53_smd_io_init(); /* power off by sending shutdown command to da9053*/ pm_power_off = wm831x_poweroff_system; mxc_register_device(&mxc_dma_device, NULL); mxc_register_device(&mxc_wdt_device, NULL); mxc_register_device(&mxcspi1_device, &mxcspi1_data); mxc_register_device(&mxci2c_devices[0], &mxci2c_data); mxc_register_device(&mxci2c_devices[1], &mxci2c_data); mxc_register_device(&mxci2c_devices[2], &mxci2c_data); mx53_smd_init_wm8325(); mxc_register_device(&mxc_rtc_device, NULL); mxc_register_device(&mxc_ipu_device, &mxc_ipu_data); mxc_register_device(&mxc_ldb_device, &ldb_data); mxc_register_device(&mxc_tve_device, &tve_data); mxc_register_device(&mxcvpu_device, &mxc_vpu_data); mxc_register_device(&gpu_device, &gpu_data); mxc_register_device(&mxcscc_device, NULL); mxc_register_device(&mxc_dvfs_core_device, &dvfs_core_data); mxc_register_device(&busfreq_device, &bus_freq_data); mxc_register_device(&mxc_iim_device, &iim_data); mxc_register_device(&mxc_pwm1_device, &mxc_pwm1_platform_data); mxc_register_device(&mxc_pwm2_device, NULL); mxc_register_device(&mxc_pwm1_backlight_device, &mxc_pwm_backlight_data); /* Register mmc3(eMMC) first, make it's device number be 0 to * avoid device number change by hotplug in SD(mmc1) card */ mxc_register_device(&mxcsdhc3_device, &mmc3_data); mxc_register_device(&mxcsdhc1_device, &mmc1_data); mxc_register_device(&mxcsdhc2_device, &mmc2_data); mxc_register_device(&mxc_ssi1_device, NULL); mxc_register_device(&mxc_ssi2_device, NULL); mxc_register_device(&mxc_alsa_spdif_device, &mxc_spdif_data); mxc_register_device(&mxc_android_pmem_device, &android_pmem_data); mxc_register_device(&mxc_android_pmem_gpu_device, &android_pmem_gpu_data); mxc_register_device(&usb_mass_storage_device, &mass_storage_data); mxc_register_device(&usb_rndis_device, &rndis_data); mxc_register_device(&android_usb_device, &android_usb_data); mxc_register_device(&ahci_fsl_device, &sata_data); /* AHCI SATA PWR EN(DCDC_5V, DCDC_3V3_BB) on SATA bus */ gpio_request(MX53_SMD_SATA_PWR_EN, "sata-pwr-en"); gpio_direction_output(MX53_SMD_SATA_PWR_EN, 1); mxc_register_device(&mxc_fec_device, &fec_data); mxc_register_device(&mxc_ptp_device, NULL); /* ASRC is only available for MX53 TO2.0 */ if (mx53_revision() >= IMX_CHIP_REVISION_2_0) { mxc_asrc_data.asrc_core_clk = clk_get(NULL, "asrc_clk"); clk_put(mxc_asrc_data.asrc_core_clk); mxc_asrc_data.asrc_audio_clk = clk_get(NULL, "asrc_serial_clk"); clk_put(mxc_asrc_data.asrc_audio_clk); mxc_register_device(&mxc_asrc_device, &mxc_asrc_data); } spi_device_init(); i2c_register_board_info(1, mxc_i2c1_board_info, ARRAY_SIZE(mxc_i2c1_board_info)); i2c_register_board_info(2, mxc_i2c2_board_info, ARRAY_SIZE(mxc_i2c2_board_info)); mxc_register_device(&mxc_rt5621_device, &rt5621_data); mxc_register_device(&mxc_spdif_audio_device, &spdif_audio_data); mx5_set_otghost_vbus_func(mx53_gpio_usbotg_driver_vbus); mx5_usb_dr_init(); mx5_usbh1_init(); mxc_register_device(&mxc_v4l2_device, NULL); mxc_register_device(&mxc_v4l2out_device, NULL); mxc_register_device(&mxc_bt_rfkill, &mxc_bt_rfkill_data); smd_add_device_buttons(); smd_add_device_battery(); }
static void __init incrediblec_init(void) { int ret; struct kobject *properties_kobj; printk("incrediblec_init() revision=%d, engineerid=%d\n", system_rev, engineerid); msm_hw_reset_hook = incrediblec_reset; if (0 == engineerid || 0xF == engineerid) { mdp_pmem_pdata.start = MSM_PMEM_MDP_XA_BASE; android_pmem_adsp_pdata.start = MSM_PMEM_ADSP_XA_BASE; msm_kgsl_resources[1].start = MSM_GPU_MEM_XA_BASE; msm_kgsl_resources[1].end = MSM_GPU_MEM_XA_BASE + MSM_GPU_MEM_SIZE - 1; } else if (engineerid >= 3) { mdp_pmem_pdata.start = MSM_PMEM_MDP_BASE + MSM_MEM_128MB_OFFSET; android_pmem_adsp_pdata.start = MSM_PMEM_ADSP_BASE + MSM_MEM_128MB_OFFSET; msm_kgsl_resources[1].start = MSM_GPU_MEM_BASE; msm_kgsl_resources[1].end = msm_kgsl_resources[1].start + MSM_GPU_MEM_SIZE - 1; } incrediblec_board_serialno_setup(board_serialno()); OJ_BMA_power(); msm_acpu_clock_init(&incrediblec_clock_data); perflock_init(&incrediblec_perflock_data); #if defined(CONFIG_MSM_SERIAL_DEBUGGER) msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1, &msm_device_uart1.dev, 1, INT_UART1_RX); #endif bcm_bt_lpm_pdata.gpio_wake = INCREDIBLEC_GPIO_BT_CHIP_WAKE; config_gpio_table(bt_gpio_table_rev_CX, ARRAY_SIZE(bt_gpio_table_rev_CX)); /* set the gpu power rail to manual mode so clk en/dis will not * turn off gpu power, and hang it on resume */ incrediblec_kgsl_power_rail_mode(0); incrediblec_kgsl_power(true); #ifdef CONFIG_SPI_QSD msm_device_spi.dev.platform_data = &incrediblec_spi_pdata; #endif #ifdef CONFIG_SERIAL_MSM_HS msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata; msm_device_uart_dm1.name = "msm_serial_hs"; /* for bcm */ #endif incrediblec_config_uart_gpios(); config_gpio_table(usb_phy_3v3_table, ARRAY_SIZE(usb_phy_3v3_table)); config_gpio_table(camera_off_gpio_table, ARRAY_SIZE(camera_off_gpio_table)); /*gpio_direction_output(INCREDIBLEC_GPIO_TP_LS_EN, 0);*/ gpio_direction_output(INCREDIBLEC_GPIO_TP_EN, 0); incrediblec_audio_init(); #ifdef CONFIG_MICROP_COMMON incrediblec_microp_init(); #endif if (system_rev >= 2) { microp_data.num_functions = ARRAY_SIZE(microp_functions_1); microp_data.microp_function = microp_functions_1; } platform_add_devices(devices, ARRAY_SIZE(devices)); if (!opt_usb_h2w_sw) { msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata; } if (system_rev > 2) { incrediblec_atmel_ts_data[0].config_T9[7] = 33; incrediblec_atmel_ts_data[0].object_crc[0] = 0x2E; incrediblec_atmel_ts_data[0].object_crc[1] = 0x80; incrediblec_atmel_ts_data[0].object_crc[2] = 0xE0; } i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices)); ret = incrediblec_init_mmc(system_rev); if (ret != 0) pr_crit("%s: Unable to initialize MMC\n", __func__); properties_kobj = kobject_create_and_add("board_properties", NULL); if (properties_kobj) ret = sysfs_create_group(properties_kobj, &incrediblec_properties_attr_group); if (!properties_kobj || ret) pr_err("failed to create board_properties\n"); msm_init_pmic_vibrator(); }
void __init qrd7627a_add_io_devices(void) { int rc; /* touchscreen */ if (machine_is_msm7627a_qrd1()) { i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, synaptic_i2c_clearpad3k, ARRAY_SIZE(synaptic_i2c_clearpad3k)); } else if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt()) { /* Use configuration data for EVT */ if (machine_is_msm8625_evt()) { mxt_config_array[0].config = mxt_config_data_evt; mxt_config_array[0].config_length = ARRAY_SIZE(mxt_config_data_evt); mxt_platform_data.panel_maxy = 875; mxt_platform_data.need_calibration = true; mxt_vkey_setup(); } rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_IRQ_GPIO, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, MXT_TS_IRQ_GPIO); } rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_RESET_GPIO, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, MXT_TS_RESET_GPIO); } i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, mxt_device_info, ARRAY_SIZE(mxt_device_info)); } else if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7() || machine_is_qrd_skud_prime() || machine_is_msm8625q_skud() || machine_is_msm8625q_evbd()) { ft5x06_touchpad_setup(); /* evbd+ can support synaptic as well */ if (machine_is_msm8625q_evbd() && (socinfo_get_platform_type() == 0x13)) { /* for QPR EVBD+ with synaptic touch panel */ /* TODO: Add gpio request to the driver to support proper dynamic touch detection */ gpio_tlmm_config( GPIO_CFG(CLEARPAD3000_ATTEN_GPIO_EVBD_PLUS, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), GPIO_CFG_ENABLE); gpio_tlmm_config( GPIO_CFG(CLEARPAD3000_RESET_GPIO, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), GPIO_CFG_ENABLE); gpio_set_value(CLEARPAD3000_RESET_GPIO, 0); usleep(10000); gpio_set_value(CLEARPAD3000_RESET_GPIO, 1); usleep(50000); i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, rmi4_i2c_devices, ARRAY_SIZE(rmi4_i2c_devices)); } else { if (machine_is_msm8625q_evbd()) { mxt_config_array[0].config = mxt_config_data; mxt_config_array[0].config_length = ARRAY_SIZE(mxt_config_data); mxt_platform_data.panel_maxy = 875; mxt_platform_data.need_calibration = true; mxt_platform_data.irq_gpio = MXT_TS_EVBD_IRQ_GPIO; mxt_vkey_setup(); rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_EVBD_IRQ_GPIO, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, MXT_TS_EVBD_IRQ_GPIO); } rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_RESET_GPIO, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, MXT_TS_RESET_GPIO); } i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, mxt_device_info, ARRAY_SIZE(mxt_device_info)); } } } /* handset and power key*/ /* ignore end key as this target doesn't need it */ hs_platform_data.ignore_end_key = true; platform_device_register(&hs_pdev); /* vibrator */ #ifdef CONFIG_MSM_RPC_VIBRATOR msm_init_pmic_vibrator(); #endif /* keypad */ if (machine_is_qrd_skud_prime() || machine_is_msm8625q_evbd() || machine_is_msm8625q_skud()) { kp_matrix_info_sku3.keymap = keymap_skud; kp_matrix_info_sku3.output_gpios = kp_row_gpios_skud; kp_matrix_info_sku3.input_gpios = kp_col_gpios_skud; kp_matrix_info_sku3.noutputs = ARRAY_SIZE(kp_row_gpios_skud); kp_matrix_info_sku3.ninputs = ARRAY_SIZE(kp_col_gpios_skud); /* keypad info for EVBD+ */ if (machine_is_msm8625q_evbd() && (socinfo_get_platform_type() == 0x13)) { gpio_tlmm_config(GPIO_CFG(37, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), GPIO_CFG_ENABLE); gpio_tlmm_config(GPIO_CFG(42, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), GPIO_CFG_ENABLE); gpio_tlmm_config(GPIO_CFG(31, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA), GPIO_CFG_ENABLE); kp_matrix_info_sku3.output_gpios = kp_row_gpios_evbdp; kp_matrix_info_sku3.input_gpios = kp_col_gpios_evbdp; kp_matrix_info_sku3.noutputs = ARRAY_SIZE(kp_row_gpios_evbdp); kp_matrix_info_sku3.ninputs = ARRAY_SIZE(kp_col_gpios_evbdp); } } if (machine_is_msm8625_evt()) kp_matrix_info_8625.keymap = keymap_8625_evt; if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt()) platform_device_register(&kp_pdev_8625); else if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7() || machine_is_qrd_skud_prime() || machine_is_msm8625q_evbd() || machine_is_msm8625q_skud()) platform_device_register(&kp_pdev_sku3); /* leds */ if (machine_is_qrd_skud_prime() || machine_is_msm8625q_evbd() || machine_is_msm8625q_skud()) { ctp_backlight_info.flags = PM_MPP__I_SINK__LEVEL_40mA << 16 | PM_MPP_8; } if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt() || machine_is_qrd_skud_prime() || machine_is_msm8625q_evbd() || machine_is_msm8625q_skud()) platform_device_register(&pmic_mpp_leds_pdev); if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt() || machine_is_msm8625q_evbd()) platform_device_register(&tricolor_leds_pdev); }
static void __init sffsdr_init_i2c(void) { davinci_init_i2c(&i2c_pdata); i2c_register_board_info(1, i2c_info, ARRAY_SIZE(i2c_info)); }
static void __init msm7x2x_init(void) { msm7x2x_misc_init(); /* Initialize regulators first so that other devices can use them */ msm7x27a_init_regulators(); /* Common functions for SURF/FFA/RUMI3 */ msm_device_i2c_init(); msm7x27a_init_ebi2(); msm7x27a_cfg_uart2dm_serial(); #ifdef CONFIG_SERIAL_MSM_HS msm_uart_dm1_pdata.wakeup_irq = gpio_to_irq(UART1DM_RX_GPIO); msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata; #endif #ifdef CONFIG_USB_MSM_OTG_72K msm_otg_pdata.swfi_latency = msm7x27a_pm_data [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency; msm_device_otg.dev.platform_data = &msm_otg_pdata; #endif msm_device_gadget_peripheral.dev.platform_data = &msm_gadget_pdata; msm7x27a_cfg_smsc911x(); platform_add_devices(msm_footswitch_devices, msm_num_footswitch_devices); platform_add_devices(surf_ffa_devices, ARRAY_SIZE(surf_ffa_devices)); /* Ensure ar6000pm device is registered before MMC/SDC */ msm7x27a_init_ar6000pm(); #ifdef CONFIG_MMC_MSM msm7627a_init_mmc(); #endif msm_fb_add_devices(); #ifdef CONFIG_USB_EHCI_MSM_72K msm7x2x_init_host(); #endif msm_pm_set_platform_data(msm7x27a_pm_data, ARRAY_SIZE(msm7x27a_pm_data)); BUG_ON(msm_pm_boot_init(&msm_pm_boot_pdata)); #if defined(CONFIG_I2C) && defined(CONFIG_GPIO_SX150X) register_i2c_devices(); #endif #if defined(CONFIG_BT) && defined(CONFIG_MARIMBA_CORE) msm7627a_bt_power_init(); #endif if (machine_is_msm7625a_surf() || machine_is_msm7625a_ffa()) { atmel_ts_pdata.min_x = 0; atmel_ts_pdata.max_x = 480; atmel_ts_pdata.min_y = 0; atmel_ts_pdata.max_y = 320; } i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, atmel_ts_i2c_info, ARRAY_SIZE(atmel_ts_i2c_info)); #if defined(CONFIG_MSM_CAMERA) msm7627a_camera_init(); #endif platform_device_register(&kp_pdev); platform_device_register(&hs_pdev); /* configure it as a pdm function*/ if (gpio_tlmm_config(GPIO_CFG(LED_GPIO_PDM, 3, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), GPIO_CFG_ENABLE)) pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, LED_GPIO_PDM); else platform_device_register(&led_pdev); #ifdef CONFIG_MSM_RPC_VIBRATOR if (machine_is_msm7x27a_ffa() || machine_is_msm7625a_ffa()) msm_init_pmic_vibrator(); #endif /*7x25a kgsl initializations*/ msm7x25a_kgsl_3d0_init(); }
int __init ventana_sensors_init(void) { struct board_info BoardInfo; #ifdef CONFIG_SENSORS_AK8975 ventana_akm8975_init(); #endif #ifdef CONFIG_MPU_SENSORS_MPU3050 ventana_mpuirq_init(); #endif ventana_camera_init(); ventana_nct1008_init(); i2c_register_board_info(0, ventana_i2c0_board_info, ARRAY_SIZE(ventana_i2c0_board_info)); i2c_register_board_info(2, ventana_i2c2_board_info, ARRAY_SIZE(ventana_i2c2_board_info)); i2c_register_board_info(2, cap_i2c1_board_info, ARRAY_SIZE(cap_i2c1_board_info)); i2c_register_board_info(2, light_i2c1_board_info, ARRAY_SIZE(light_i2c1_board_info)); i2c_register_board_info(2, proximity_i2c1_board_info, ARRAY_SIZE(proximity_i2c1_board_info)); //+ ov5640 rear camera i2c_register_board_info(3, ventana_i2c3_board_info, ARRAY_SIZE(ventana_i2c3_board_info)); //- //+ Front camera i2c_register_board_info(3, front_sensor_i2c3_board_info, ARRAY_SIZE(front_sensor_i2c3_board_info)); //- //+ mi5140 rear camera i2c_register_board_info(3, rear_sensor2_i2c3_board_info, ARRAY_SIZE(rear_sensor2_i2c3_board_info)); //- i2c_register_board_info(4, ventana_i2c4_board_info, ARRAY_SIZE(ventana_i2c4_board_info)); //ddebug i2c_register_board_info(7, ventana_i2c7_board_info, //ddebug ARRAY_SIZE(ventana_i2c7_board_info)); i2c_register_board_info(8, ventana_i2c8_board_info, ARRAY_SIZE(ventana_i2c8_board_info)); #ifdef CONFIG_MPU_SENSORS_MPU3050 i2c_register_board_info(0, mpu3050_i2c0_boardinfo, ARRAY_SIZE(mpu3050_i2c0_boardinfo)); #endif return 0; }
static void __init vpac270_pmic_init(void) { i2c_register_board_info(1, ARRAY_AND_SIZE(vpac270_pi2c_board_info)); }
static void __init income_i2c_init(void) { pxa_set_i2c_info(NULL); pxa27x_set_i2c_power_info(NULL); i2c_register_board_info(0, ARRAY_AND_SIZE(income_i2c_devs)); }
static void __init ap4evb_init(void) { u32 srcr4; struct clk *clk; sh7372_pinmux_init(); /* enable SCIFA0 */ gpio_request(GPIO_FN_SCIFA0_TXD, NULL); gpio_request(GPIO_FN_SCIFA0_RXD, NULL); /* enable SMSC911X */ gpio_request(GPIO_FN_CS5A, NULL); gpio_request(GPIO_FN_IRQ6_39, NULL); /* enable Debug switch (S6) */ gpio_request(GPIO_PORT32, NULL); gpio_request(GPIO_PORT33, NULL); gpio_request(GPIO_PORT34, NULL); gpio_request(GPIO_PORT35, NULL); gpio_direction_input(GPIO_PORT32); gpio_direction_input(GPIO_PORT33); gpio_direction_input(GPIO_PORT34); gpio_direction_input(GPIO_PORT35); gpio_export(GPIO_PORT32, 0); gpio_export(GPIO_PORT33, 0); gpio_export(GPIO_PORT34, 0); gpio_export(GPIO_PORT35, 0); /* SDHI0 */ gpio_request(GPIO_FN_SDHICD0, NULL); gpio_request(GPIO_FN_SDHIWP0, NULL); gpio_request(GPIO_FN_SDHICMD0, NULL); gpio_request(GPIO_FN_SDHICLK0, NULL); gpio_request(GPIO_FN_SDHID0_3, NULL); gpio_request(GPIO_FN_SDHID0_2, NULL); gpio_request(GPIO_FN_SDHID0_1, NULL); gpio_request(GPIO_FN_SDHID0_0, NULL); /* SDHI1 */ gpio_request(GPIO_FN_SDHICMD1, NULL); gpio_request(GPIO_FN_SDHICLK1, NULL); gpio_request(GPIO_FN_SDHID1_3, NULL); gpio_request(GPIO_FN_SDHID1_2, NULL); gpio_request(GPIO_FN_SDHID1_1, NULL); gpio_request(GPIO_FN_SDHID1_0, NULL); /* MMCIF */ gpio_request(GPIO_FN_MMCD0_0, NULL); gpio_request(GPIO_FN_MMCD0_1, NULL); gpio_request(GPIO_FN_MMCD0_2, NULL); gpio_request(GPIO_FN_MMCD0_3, NULL); gpio_request(GPIO_FN_MMCD0_4, NULL); gpio_request(GPIO_FN_MMCD0_5, NULL); gpio_request(GPIO_FN_MMCD0_6, NULL); gpio_request(GPIO_FN_MMCD0_7, NULL); gpio_request(GPIO_FN_MMCCMD0, NULL); gpio_request(GPIO_FN_MMCCLK0, NULL); /* USB enable */ gpio_request(GPIO_FN_VBUS0_1, NULL); gpio_request(GPIO_FN_IDIN_1_18, NULL); gpio_request(GPIO_FN_PWEN_1_115, NULL); gpio_request(GPIO_FN_OVCN_1_114, NULL); gpio_request(GPIO_FN_EXTLP_1, NULL); gpio_request(GPIO_FN_OVCN2_1, NULL); /* setup USB phy */ __raw_writew(0x8a0a, 0xE6058130); /* USBCR2 */ /* enable FSI2 port A (ak4643) */ gpio_request(GPIO_FN_FSIAIBT, NULL); gpio_request(GPIO_FN_FSIAILR, NULL); gpio_request(GPIO_FN_FSIAISLD, NULL); gpio_request(GPIO_FN_FSIAOSLD, NULL); gpio_request(GPIO_PORT161, NULL); gpio_direction_output(GPIO_PORT161, 0); /* slave */ gpio_request(GPIO_PORT9, NULL); gpio_request(GPIO_PORT10, NULL); gpio_no_direction(GPIO_PORT9CR); /* FSIAOBT needs no direction */ gpio_no_direction(GPIO_PORT10CR); /* FSIAOLR needs no direction */ /* card detect pin for MMC slot (CN7) */ gpio_request(GPIO_PORT41, NULL); gpio_direction_input(GPIO_PORT41); /* setup FSI2 port B (HDMI) */ gpio_request(GPIO_FN_FSIBCK, NULL); __raw_writew(__raw_readw(USCCR1) & ~(1 << 6), USCCR1); /* use SPDIF */ /* set SPU2 clock to 119.6 MHz */ clk = clk_get(NULL, "spu_clk"); if (!IS_ERR(clk)) { clk_set_rate(clk, clk_round_rate(clk, 119600000)); clk_put(clk); } /* * set irq priority, to avoid sound chopping * when NFS rootfs is used * FSI(3) > SMSC911X(2) */ intc_set_priority(IRQ_FSI, 3); i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices)); i2c_register_board_info(1, i2c1_devices, ARRAY_SIZE(i2c1_devices)); #ifdef CONFIG_AP4EVB_QHD /* * For QHD Panel (MIPI-DSI, CONFIG_AP4EVB_QHD=y) and * IRQ28 for Touch Panel, set dip switches S3, S43 as OFF, ON. */ /* enable KEYSC */ gpio_request(GPIO_FN_KEYOUT0, NULL); gpio_request(GPIO_FN_KEYOUT1, NULL); gpio_request(GPIO_FN_KEYOUT2, NULL); gpio_request(GPIO_FN_KEYOUT3, NULL); gpio_request(GPIO_FN_KEYOUT4, NULL); gpio_request(GPIO_FN_KEYIN0_136, NULL); gpio_request(GPIO_FN_KEYIN1_135, NULL); gpio_request(GPIO_FN_KEYIN2_134, NULL); gpio_request(GPIO_FN_KEYIN3_133, NULL); gpio_request(GPIO_FN_KEYIN4, NULL); /* enable TouchScreen */ set_irq_type(IRQ28, IRQ_TYPE_LEVEL_LOW); tsc_device.irq = IRQ28; i2c_register_board_info(1, &tsc_device, 1); /* LCDC0 */ lcdc_info.clock_source = LCDC_CLK_PERIPHERAL; lcdc_info.ch[0].interface_type = RGB24; lcdc_info.ch[0].clock_divider = 1; lcdc_info.ch[0].flags = LCDC_FLAGS_DWPOL; lcdc_info.ch[0].lcd_size_cfg.width = 44; lcdc_info.ch[0].lcd_size_cfg.height = 79; platform_add_devices(qhd_devices, ARRAY_SIZE(qhd_devices)); #else /* * For WVGA Panel (18-bit RGB, CONFIG_AP4EVB_WVGA=y) and * IRQ7 for Touch Panel, set dip switches S3, S43 to ON, OFF. */ gpio_request(GPIO_FN_LCDD17, NULL); gpio_request(GPIO_FN_LCDD16, NULL); gpio_request(GPIO_FN_LCDD15, NULL); gpio_request(GPIO_FN_LCDD14, NULL); gpio_request(GPIO_FN_LCDD13, NULL); gpio_request(GPIO_FN_LCDD12, NULL); gpio_request(GPIO_FN_LCDD11, NULL); gpio_request(GPIO_FN_LCDD10, NULL); gpio_request(GPIO_FN_LCDD9, NULL); gpio_request(GPIO_FN_LCDD8, NULL); gpio_request(GPIO_FN_LCDD7, NULL); gpio_request(GPIO_FN_LCDD6, NULL); gpio_request(GPIO_FN_LCDD5, NULL); gpio_request(GPIO_FN_LCDD4, NULL); gpio_request(GPIO_FN_LCDD3, NULL); gpio_request(GPIO_FN_LCDD2, NULL); gpio_request(GPIO_FN_LCDD1, NULL); gpio_request(GPIO_FN_LCDD0, NULL); gpio_request(GPIO_FN_LCDDISP, NULL); gpio_request(GPIO_FN_LCDDCK, NULL); gpio_request(GPIO_PORT189, NULL); /* backlight */ gpio_direction_output(GPIO_PORT189, 1); gpio_request(GPIO_PORT151, NULL); /* LCDDON */ gpio_direction_output(GPIO_PORT151, 1); lcdc_info.clock_source = LCDC_CLK_BUS; lcdc_info.ch[0].interface_type = RGB18; lcdc_info.ch[0].clock_divider = 2; lcdc_info.ch[0].flags = 0; lcdc_info.ch[0].lcd_size_cfg.width = 152; lcdc_info.ch[0].lcd_size_cfg.height = 91; /* enable TouchScreen */ set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW); tsc_device.irq = IRQ7; i2c_register_board_info(0, &tsc_device, 1); #endif /* CONFIG_AP4EVB_QHD */ /* CEU */ /* * TODO: reserve memory for V4L2 DMA buffers, when a suitable API * becomes available */ /* MIPI-CSI stuff */ gpio_request(GPIO_FN_VIO_CKO, NULL); clk = clk_get(NULL, "vck1_clk"); if (!IS_ERR(clk)) { clk_set_rate(clk, clk_round_rate(clk, 13000000)); clk_enable(clk); clk_put(clk); } sh7372_add_standard_devices(); /* HDMI */ gpio_request(GPIO_FN_HDMI_HPD, NULL); gpio_request(GPIO_FN_HDMI_CEC, NULL); /* Reset HDMI, must be held at least one EXTALR (32768Hz) period */ #define SRCR4 0xe61580bc srcr4 = __raw_readl(SRCR4); __raw_writel(srcr4 | (1 << 13), SRCR4); udelay(50); __raw_writel(srcr4 & ~(1 << 13), SRCR4); platform_add_devices(ap4evb_devices, ARRAY_SIZE(ap4evb_devices)); }
static void __init vpac270_rtc_init(void) { i2c_register_board_info(0, ARRAY_AND_SIZE(vpac270_i2c_devs)); }
/*! * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_ipu_data.di_clk[0] = clk_get(NULL, "ipu_di0_clk"); mxc_ipu_data.di_clk[1] = clk_get(NULL, "ipu_di1_clk"); mxc_ipu_data.csi_clk[0] = clk_get(NULL, "csi_mclk1"); mxc_ipu_data.csi_clk[1] = clk_get(NULL, "csi_mclk2"); mxc_spdif_data.spdif_core_clk = clk_get(NULL, "spdif_xtal_clk"); clk_put(mxc_spdif_data.spdif_core_clk); spdif_audio_data.ext_ram_clk = clk_get(NULL, "emi_fast_clk"); clk_put(spdif_audio_data.ext_ram_clk); sgtl5000_data.ext_ram_clk = clk_get(NULL, "emi_fast_clk"); clk_put(sgtl5000_data.ext_ram_clk); /* SD card detect irqs */ mxcsdhc2_device.resource[2].start = gpio_to_irq(BABBAGE_SD2_CD_2_5); mxcsdhc2_device.resource[2].end = gpio_to_irq(BABBAGE_SD2_CD_2_5); mxcsdhc1_device.resource[2].start = gpio_to_irq(BABBAGE_SD1_CD); mxcsdhc1_device.resource[2].end = gpio_to_irq(BABBAGE_SD1_CD); mxc_cpu_common_init(); mx51_babbage_io_init(); mxc_register_device(&mxc_dma_device, NULL); mxc_register_device(&mxc_wdt_device, NULL); mxc_register_device(&mxcspi1_device, &mxcspi1_data); mxc_register_device(&mxci2c_devices[0], &mxci2c_data); mxc_register_device(&mxci2c_devices[1], &mxci2c_data); mxc_register_device(&mxci2c_hs_device, &mxci2c_hs_data); mxc_register_device(&mxc_rtc_device, NULL); mxc_register_device(&mxc_w1_master_device, &mxc_w1_data); mxc_register_device(&mxc_ipu_device, &mxc_ipu_data); mxc_register_device(&mxc_tve_device, &tve_data); if (!mxc_fuse_get_vpu_status()) mxc_register_device(&mxcvpu_device, &mxc_vpu_data); if (!mxc_fuse_get_gpu_status()) mxc_register_device(&gpu_device, &gpu_data); mxc_register_device(&mxcscc_device, NULL); mxc_register_device(&mx51_lpmode_device, NULL); mxc_register_device(&busfreq_device, &bus_freq_data); mxc_register_device(&sdram_autogating_device, NULL); mxc_register_device(&mxc_dvfs_core_device, &dvfs_core_data); mxc_register_device(&mxc_dvfs_per_device, &dvfs_per_data); mxc_register_device(&mxc_iim_device, &iim_data); mxc_register_device(&mxc_pwm1_device, NULL); mxc_register_device(&mxc_pwm1_backlight_device, &mxc_pwm_backlight_data); mxc_register_device(&mxc_keypad_device, &keypad_plat_data); mxc_register_device(&mxcsdhc1_device, &mmc1_data); mxc_register_device(&mxcsdhc2_device, &mmc2_data); mxc_register_device(&mxc_ssi1_device, NULL); mxc_register_device(&mxc_ssi2_device, NULL); mxc_register_device(&mxc_ssi3_device, NULL); mxc_register_device(&mxc_alsa_spdif_device, &mxc_spdif_data); mxc_register_device(&mxc_android_pmem_device, &android_pmem_data); mxc_register_device(&mxc_android_pmem_gpu_device, &android_pmem_gpu_data); mxc_register_device(&usb_mass_storage_device, &mass_storage_data); mxc_register_device(&usb_rndis_device, &rndis_data); mxc_register_device(&android_usb_device, &android_usb_data); mxc_register_device(&mxc_fec_device, NULL); mxc_register_device(&mxc_v4l2_device, NULL); mxc_register_device(&mxc_v4l2out_device, NULL); mxc_register_device(&mxc_powerkey_device, &pwrkey_data); mxc_register_device(&mxc_spdif_audio_device, &spdif_audio_data); mx51_babbage_init_mc13892(); if (board_is_rev(BOARD_REV_2)) /* BB2.5 */ spi_register_board_info(mxc_dataflash_device, ARRAY_SIZE(mxc_dataflash_device)); else /* BB2.0 */ spi_register_board_info(mxc_spi_nor_device, ARRAY_SIZE(mxc_spi_nor_device)); i2c_register_board_info(0, mxc_i2c0_board_info, ARRAY_SIZE(mxc_i2c0_board_info)); i2c_register_board_info(1, mxc_i2c1_board_info, ARRAY_SIZE(mxc_i2c1_board_info)); vga_data.core_reg = NULL; vga_data.io_reg = NULL; vga_data.analog_reg = NULL; i2c_register_board_info(3, mxc_i2c_hs_board_info, ARRAY_SIZE(mxc_i2c_hs_board_info)); pm_power_off = mxc_power_off; sgtl5000_data.sysclk = 26000000; gpio_request(BABBAGE_AUDAMP_STBY, "audioamp-stdby"); gpio_direction_output(BABBAGE_AUDAMP_STBY, 0); mxc_register_device(&mxc_sgtl5000_device, &sgtl5000_data); mx5_usb_dr_init(); mx5_usbh1_init(); }
static void __init pcm037_init(void) { int ret; imx31_soc_init(); regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies)); mxc_iomux_set_gpr(MUX_PGP_UH2, 1); mxc_iomux_setup_multiple_pins(pcm037_pins, ARRAY_SIZE(pcm037_pins), "pcm037"); #define H2_PAD_CFG (PAD_CTL_DRV_MAX | PAD_CTL_SRE_FAST | PAD_CTL_HYS_CMOS \ | PAD_CTL_ODE_CMOS | PAD_CTL_100K_PU) mxc_iomux_set_pad(MX31_PIN_USBH2_CLK, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_USBH2_DIR, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_USBH2_NXT, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_USBH2_STP, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_USBH2_DATA0, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_USBH2_DATA1, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_SRXD6, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_STXD6, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_SFS3, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_SCK3, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_SRXD3, H2_PAD_CFG); mxc_iomux_set_pad(MX31_PIN_STXD3, H2_PAD_CFG); if (pcm037_variant() == PCM037_EET) mxc_iomux_setup_multiple_pins(pcm037_uart1_pins, ARRAY_SIZE(pcm037_uart1_pins), "pcm037_uart1"); else mxc_iomux_setup_multiple_pins(pcm037_uart1_handshake_pins, ARRAY_SIZE(pcm037_uart1_handshake_pins), "pcm037_uart1"); platform_add_devices(devices, ARRAY_SIZE(devices)); imx31_add_imx2_wdt(NULL); imx31_add_imx_uart0(&uart_pdata); imx31_add_imx_uart1(&uart_pdata); imx31_add_imx_uart2(&uart_pdata); imx31_add_mxc_w1(NULL); ret = gpio_request(IOMUX_TO_GPIO(MX31_PIN_GPIO3_1), "lan9217-irq"); if (ret) pr_warning("could not get LAN irq gpio\n"); else { gpio_direction_input(IOMUX_TO_GPIO(MX31_PIN_GPIO3_1)); platform_device_register(&pcm037_eth); } i2c_register_board_info(1, pcm037_i2c_devices, ARRAY_SIZE(pcm037_i2c_devices)); imx31_add_imx_i2c1(&pcm037_i2c1_data); imx31_add_imx_i2c2(&pcm037_i2c2_data); imx31_add_mxc_nand(&pcm037_nand_board_info); imx31_add_mxc_mmc(0, &sdhc_pdata); imx31_add_ipu_core(&mx3_ipu_data); imx31_add_mx3_sdc_fb(&mx3fb_pdata); ret = gpio_request(IOMUX_TO_GPIO(MX31_PIN_CSI_D5), "mt9t031-power"); if (!ret) gpio_direction_output(IOMUX_TO_GPIO(MX31_PIN_CSI_D5), 1); else iclink_mt9t031.power = NULL; pcm037_init_camera(); platform_device_register(&pcm970_sja1000); if (otg_mode_host) { otg_pdata.otg = imx_otg_ulpi_create(ULPI_OTG_DRVVBUS | ULPI_OTG_DRVVBUS_EXT); if (otg_pdata.otg) imx31_add_mxc_ehci_otg(&otg_pdata); } usbh2_pdata.otg = imx_otg_ulpi_create(ULPI_OTG_DRVVBUS | ULPI_OTG_DRVVBUS_EXT); if (usbh2_pdata.otg) imx31_add_mxc_ehci_hs(2, &usbh2_pdata); if (!otg_mode_host) imx31_add_fsl_usb2_udc(&otg_device_pdata); }
void __init qrd7627a_add_io_devices(void) { int rc; /* touchscreen */ if (machine_is_msm7627a_qrd1()) { //20120507-Added by Jordan , it is no used for msm7627a #if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_RMI4_I2C) || \ defined(CONFIG_TOUCHSCREEN_SYNAPTICS_RMI4_I2C_MODULE) i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, synaptic_i2c_clearpad3k, ARRAY_SIZE(synaptic_i2c_clearpad3k)); #endif } else if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt()) { /* Use configuration data for EVT */ if (machine_is_msm8625_evt()) { mxt_config_array[0].config = mxt_config_data_evt; mxt_config_array[0].config_length = ARRAY_SIZE(mxt_config_data_evt); mxt_platform_data.panel_maxy = 875; mxt_platform_data.need_calibration = true; mxt_vkey_setup(); } rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_IRQ_GPIO, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, MXT_TS_IRQ_GPIO); } rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_RESET_GPIO, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, MXT_TS_RESET_GPIO); } i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, mxt_device_info, ARRAY_SIZE(mxt_device_info)); } else if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()) { #ifdef CONFIG_TOUCHSCREEN_FT5X06 //20120507-Jordan ft5x06_touchpad_setup(); #endif } /* headset */ platform_device_register(&hs_pdev); /* vibrator */ #ifdef CONFIG_MSM_RPC_VIBRATOR msm_init_pmic_vibrator(); #endif /* keypad */ if (machine_is_msm8625_evt()) kp_matrix_info_8625.keymap = keymap_8625_evt; if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt()) platform_device_register(&kp_pdev_8625); else if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()) platform_device_register(&kp_pdev_sku3); /* leds */ if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt()) { platform_device_register(&pmic_mpp_leds_pdev); platform_device_register(&tricolor_leds_pdev); } }
static int __init migor_devices_setup(void) { /* register board specific self-refresh code */ sh_mobile_register_self_refresh(SUSP_SH_STANDBY | SUSP_SH_SF, &migor_sdram_enter_start, &migor_sdram_enter_end, &migor_sdram_leave_start, &migor_sdram_leave_end); #ifdef CONFIG_PM /* Let D11 LED show STATUS0 */ gpio_request(GPIO_FN_STATUS0, NULL); /* Lit D12 LED show PDSTATUS */ gpio_request(GPIO_FN_PDSTATUS, NULL); #else /* Lit D11 LED */ gpio_request(GPIO_PTJ7, NULL); gpio_direction_output(GPIO_PTJ7, 1); gpio_export(GPIO_PTJ7, 0); /* Lit D12 LED */ gpio_request(GPIO_PTJ5, NULL); gpio_direction_output(GPIO_PTJ5, 1); gpio_export(GPIO_PTJ5, 0); #endif /* SMC91C111 - Enable IRQ0, Setup CS4 for 16-bit fast access */ gpio_request(GPIO_FN_IRQ0, NULL); __raw_writel(0x00003400, BSC_CS4BCR); __raw_writel(0x00110080, BSC_CS4WCR); /* KEYSC */ gpio_request(GPIO_FN_KEYOUT0, NULL); gpio_request(GPIO_FN_KEYOUT1, NULL); gpio_request(GPIO_FN_KEYOUT2, NULL); gpio_request(GPIO_FN_KEYOUT3, NULL); gpio_request(GPIO_FN_KEYOUT4_IN6, NULL); gpio_request(GPIO_FN_KEYIN1, NULL); gpio_request(GPIO_FN_KEYIN2, NULL); gpio_request(GPIO_FN_KEYIN3, NULL); gpio_request(GPIO_FN_KEYIN4, NULL); gpio_request(GPIO_FN_KEYOUT5_IN5, NULL); /* NAND Flash */ gpio_request(GPIO_FN_CS6A_CE2B, NULL); __raw_writel((__raw_readl(BSC_CS6ABCR) & ~0x0600) | 0x0200, BSC_CS6ABCR); gpio_request(GPIO_PTA1, NULL); gpio_direction_input(GPIO_PTA1); /* SDHI */ gpio_request(GPIO_FN_SDHICD, NULL); gpio_request(GPIO_FN_SDHIWP, NULL); gpio_request(GPIO_FN_SDHID3, NULL); gpio_request(GPIO_FN_SDHID2, NULL); gpio_request(GPIO_FN_SDHID1, NULL); gpio_request(GPIO_FN_SDHID0, NULL); gpio_request(GPIO_FN_SDHICMD, NULL); gpio_request(GPIO_FN_SDHICLK, NULL); /* Touch Panel */ gpio_request(GPIO_FN_IRQ6, NULL); /* LCD Panel */ #ifdef CONFIG_SH_MIGOR_QVGA /* LCDC - QVGA - Enable SYS Interface signals */ gpio_request(GPIO_FN_LCDD17, NULL); gpio_request(GPIO_FN_LCDD16, NULL); gpio_request(GPIO_FN_LCDD15, NULL); gpio_request(GPIO_FN_LCDD14, NULL); gpio_request(GPIO_FN_LCDD13, NULL); gpio_request(GPIO_FN_LCDD12, NULL); gpio_request(GPIO_FN_LCDD11, NULL); gpio_request(GPIO_FN_LCDD10, NULL); gpio_request(GPIO_FN_LCDD8, NULL); gpio_request(GPIO_FN_LCDD7, NULL); gpio_request(GPIO_FN_LCDD6, NULL); gpio_request(GPIO_FN_LCDD5, NULL); gpio_request(GPIO_FN_LCDD4, NULL); gpio_request(GPIO_FN_LCDD3, NULL); gpio_request(GPIO_FN_LCDD2, NULL); gpio_request(GPIO_FN_LCDD1, NULL); gpio_request(GPIO_FN_LCDRS, NULL); gpio_request(GPIO_FN_LCDCS, NULL); gpio_request(GPIO_FN_LCDRD, NULL); gpio_request(GPIO_FN_LCDWR, NULL); gpio_request(GPIO_PTH2, NULL); /* LCD_DON */ gpio_direction_output(GPIO_PTH2, 1); #endif #ifdef CONFIG_SH_MIGOR_RTA_WVGA /* LCDC - WVGA - Enable RGB Interface signals */ gpio_request(GPIO_FN_LCDD15, NULL); gpio_request(GPIO_FN_LCDD14, NULL); gpio_request(GPIO_FN_LCDD13, NULL); gpio_request(GPIO_FN_LCDD12, NULL); gpio_request(GPIO_FN_LCDD11, NULL); gpio_request(GPIO_FN_LCDD10, NULL); gpio_request(GPIO_FN_LCDD9, NULL); gpio_request(GPIO_FN_LCDD8, NULL); gpio_request(GPIO_FN_LCDD7, NULL); gpio_request(GPIO_FN_LCDD6, NULL); gpio_request(GPIO_FN_LCDD5, NULL); gpio_request(GPIO_FN_LCDD4, NULL); gpio_request(GPIO_FN_LCDD3, NULL); gpio_request(GPIO_FN_LCDD2, NULL); gpio_request(GPIO_FN_LCDD1, NULL); gpio_request(GPIO_FN_LCDD0, NULL); gpio_request(GPIO_FN_LCDLCLK, NULL); gpio_request(GPIO_FN_LCDDCK, NULL); gpio_request(GPIO_FN_LCDVEPWC, NULL); gpio_request(GPIO_FN_LCDVCPWC, NULL); gpio_request(GPIO_FN_LCDVSYN, NULL); gpio_request(GPIO_FN_LCDHSYN, NULL); gpio_request(GPIO_FN_LCDDISP, NULL); gpio_request(GPIO_FN_LCDDON, NULL); #endif /* CEU */ gpio_request(GPIO_FN_VIO_CLK2, NULL); gpio_request(GPIO_FN_VIO_VD2, NULL); gpio_request(GPIO_FN_VIO_HD2, NULL); gpio_request(GPIO_FN_VIO_FLD, NULL); gpio_request(GPIO_FN_VIO_CKO, NULL); gpio_request(GPIO_FN_VIO_D15, NULL); gpio_request(GPIO_FN_VIO_D14, NULL); gpio_request(GPIO_FN_VIO_D13, NULL); gpio_request(GPIO_FN_VIO_D12, NULL); gpio_request(GPIO_FN_VIO_D11, NULL); gpio_request(GPIO_FN_VIO_D10, NULL); gpio_request(GPIO_FN_VIO_D9, NULL); gpio_request(GPIO_FN_VIO_D8, NULL); gpio_request(GPIO_PTT3, NULL); /* VIO_RST */ gpio_direction_output(GPIO_PTT3, 0); gpio_request(GPIO_PTT2, NULL); /* TV_IN_EN */ gpio_direction_output(GPIO_PTT2, 1); gpio_request(GPIO_PTT0, NULL); /* CAM_EN */ #ifdef CONFIG_SH_MIGOR_RTA_WVGA gpio_direction_output(GPIO_PTT0, 0); #else gpio_direction_output(GPIO_PTT0, 1); #endif __raw_writew(__raw_readw(PORT_MSELCRB) | 0x2000, PORT_MSELCRB); /* D15->D8 */ platform_resource_setup_memory(&migor_ceu_device, "ceu", 4 << 20); i2c_register_board_info(0, migor_i2c_devices, ARRAY_SIZE(migor_i2c_devices)); return platform_add_devices(migor_devices, ARRAY_SIZE(migor_devices)); }
static int __init axp_board_init(void) { int ret; ret = script_parser_fetch("pmu_para", "pmu_used", &pmu_used, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); return -1; } if (pmu_used) { ret = script_parser_fetch("pmu_para", "pmu_twi_id", &pmu_twi_id, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_twi_id = AXP20_I2CBUS; } ret = script_parser_fetch("pmu_para", "pmu_irq_id", &pmu_irq_id, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_irq_id = AXP20_IRQNO; } ret = script_parser_fetch("pmu_para", "pmu_twi_addr", &pmu_twi_addr, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_twi_addr = AXP20_ADDR; } ret = script_parser_fetch("pmu_para", "pmu_battery_rdc", &pmu_battery_rdc, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_battery_rdc = BATRDC; } ret = script_parser_fetch("pmu_para", "pmu_battery_cap", &pmu_battery_cap, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_battery_cap = BATTERYCAP; } ret = script_parser_fetch("pmu_para", "pmu_init_chgcur", &pmu_init_chgcur, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_chgcur = INTCHGCUR / 1000; } pmu_init_chgcur = pmu_init_chgcur * 1000; ret = script_parser_fetch("pmu_para", "pmu_suspend_chgcur", &pmu_suspend_chgcur, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_suspend_chgcur = SUSCHGCUR / 1000; } pmu_suspend_chgcur = pmu_suspend_chgcur * 1000; ret = script_parser_fetch("pmu_para", "pmu_resume_chgcur", &pmu_resume_chgcur, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_resume_chgcur = RESCHGCUR / 1000; } pmu_resume_chgcur = pmu_resume_chgcur * 1000; ret = script_parser_fetch("pmu_para", "pmu_shutdown_chgcur", &pmu_shutdown_chgcur, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_shutdown_chgcur = CLSCHGCUR / 1000; } pmu_shutdown_chgcur = pmu_shutdown_chgcur * 1000; ret = script_parser_fetch("pmu_para", "pmu_init_chgvol", &pmu_init_chgvol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_chgvol = INTCHGVOL / 1000; } pmu_init_chgvol = pmu_init_chgvol * 1000; ret = script_parser_fetch("pmu_para", "pmu_init_chgend_rate", &pmu_init_chgend_rate, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_chgend_rate = INTCHGENDRATE; } ret = script_parser_fetch("pmu_para", "pmu_init_chg_enabled", &pmu_init_chg_enabled, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_chg_enabled = INTCHGENABLED; } ret = script_parser_fetch("pmu_para", "pmu_init_adc_freq", &pmu_init_adc_freq, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_adc_freq = INTADCFREQ; } ret = script_parser_fetch("pmu_para", "pmu_init_adc_freqc", &pmu_init_adc_freqc, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_adc_freq = INTADCFREQC; } ret = script_parser_fetch("pmu_para", "pmu_init_chg_pretime", &pmu_init_chg_pretime, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_chg_pretime = INTCHGPRETIME; } ret = script_parser_fetch("pmu_para", "pmu_init_chg_csttime", &pmu_init_chg_csttime, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_init_chg_csttime = INTCHGCSTTIME; } ret = script_parser_fetch("pmu_para", "pmu_bat_para1", &pmu_bat_para1, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para1 = OCVREG0; } ret = script_parser_fetch("pmu_para", "pmu_bat_para2", &pmu_bat_para2, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para2 = OCVREG1; } ret = script_parser_fetch("pmu_para", "pmu_bat_para3", &pmu_bat_para3, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para3 = OCVREG2; } ret = script_parser_fetch("pmu_para", "pmu_bat_para4", &pmu_bat_para4, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para4 = OCVREG3; } ret = script_parser_fetch("pmu_para", "pmu_bat_para5", &pmu_bat_para5, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para5 = OCVREG4; } ret = script_parser_fetch("pmu_para", "pmu_bat_para6", &pmu_bat_para6, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para6 = OCVREG5; } ret = script_parser_fetch("pmu_para", "pmu_bat_para7", &pmu_bat_para7, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para7 = OCVREG6; } ret = script_parser_fetch("pmu_para", "pmu_bat_para8", &pmu_bat_para8, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para8 = OCVREG7; } ret = script_parser_fetch("pmu_para", "pmu_bat_para9", &pmu_bat_para9, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para9 = OCVREG8; } ret = script_parser_fetch("pmu_para", "pmu_bat_para10", &pmu_bat_para10, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para10 = OCVREG9; } ret = script_parser_fetch("pmu_para", "pmu_bat_para11", &pmu_bat_para11, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para11 = OCVREGA; } ret = script_parser_fetch("pmu_para", "pmu_bat_para12", &pmu_bat_para12, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para12 = OCVREGB; } ret = script_parser_fetch("pmu_para", "pmu_bat_para13", &pmu_bat_para13, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para13 = OCVREGC; } ret = script_parser_fetch("pmu_para", "pmu_bat_para14", &pmu_bat_para14, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para14 = OCVREGD; } ret = script_parser_fetch("pmu_para", "pmu_bat_para15", &pmu_bat_para15, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para15 = OCVREGE; } ret = script_parser_fetch("pmu_para", "pmu_bat_para16", &pmu_bat_para16, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_bat_para16 = OCVREGF; } ret = script_parser_fetch("pmu_para", "pmu_usbvol_limit", &pmu_usbvol_limit, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_usbvol_limit = 1; } ret = script_parser_fetch("pmu_para", "pmu_usbvol", &pmu_usbvol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_usbvol = 4400; } ret = script_parser_fetch("pmu_para", "pmu_usbcur_limit", &pmu_usbcur_limit, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_usbcur_limit = 0; } ret = script_parser_fetch("pmu_para", "pmu_usbcur", &pmu_usbcur, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_usbcur = 900; } ret = script_parser_fetch("pmu_para", "pmu_pwroff_vol", &pmu_pwroff_vol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_pwroff_vol = 3300; } ret = script_parser_fetch("pmu_para", "pmu_pwron_vol", &pmu_pwron_vol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_pwron_vol = 2900; } ret = script_parser_fetch("target", "dcdc2_vol", &dcdc2_vol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); dcdc2_vol = 1400; } ret = script_parser_fetch("target", "dcdc3_vol", &dcdc3_vol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); dcdc3_vol = 1250; } ret = script_parser_fetch("target", "ldo2_vol", &ldo2_vol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); ldo2_vol = 3000; } ret = script_parser_fetch("target", "ldo3_vol", &ldo3_vol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); ldo3_vol = 2800; } ret = script_parser_fetch("target", "ldo4_vol", &ldo4_vol, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); ldo4_vol = 2800; } ret = script_parser_fetch("pmu_para", "pmu_pekoff_time", &pmu_pekoff_time, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_pekoff_time = 6000; } ret = script_parser_fetch("pmu_para", "pmu_pekoff_en", &pmu_pekoff_en, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_pekoff_en = 1; } ret = script_parser_fetch("pmu_para", "pmu_peklong_time", &pmu_peklong_time, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_peklong_time = 1500; } ret = script_parser_fetch("pmu_para", "pmu_pwrok_time", &pmu_pwrok_time, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_pwrok_time = 64; } ret = script_parser_fetch("pmu_para", "pmu_pwrnoe_time", &pmu_pwrnoe_time, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_pwrnoe_time = 2000; } ret = script_parser_fetch("pmu_para", "pmu_intotp_en", &pmu_intotp_en, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_intotp_en = 1; } ret = script_parser_fetch("pmu_para", "pmu_pekon_time", &pmu_pekon_time, sizeof(int)); if (ret) { printk("axp driver uning configuration failed(%d)\n", __LINE__); pmu_pekon_time = 1000; } axp_regl_init_data[1].constraints.state_standby.uV = ldo2_vol * 1000; axp_regl_init_data[2].constraints.state_standby.uV = ldo3_vol * 1000; axp_regl_init_data[3].constraints.state_standby.uV = ldo4_vol * 1000; axp_regl_init_data[5].constraints.state_standby.uV = dcdc2_vol * 1000; axp_regl_init_data[6].constraints.state_standby.uV = dcdc3_vol * 1000; battery_data.voltage_max_design = pmu_init_chgvol; battery_data.voltage_min_design = pmu_pwroff_vol; battery_data.energy_full_design = pmu_battery_cap; axp_sply_init_data.chgcur = pmu_init_chgcur; axp_sply_init_data.chgvol = pmu_init_chgvol; axp_sply_init_data.chgend = pmu_init_chgend_rate; axp_sply_init_data.chgen = pmu_init_chg_enabled; axp_sply_init_data.sample_time = pmu_init_adc_freq; axp_sply_init_data.chgpretime = pmu_init_chg_pretime; axp_sply_init_data.chgcsttime = pmu_init_chg_csttime; axp_mfd_i2c_board_info[0].addr = pmu_twi_addr; axp_mfd_i2c_board_info[0].irq = pmu_irq_id; return i2c_register_board_info(pmu_twi_id, axp_mfd_i2c_board_info, ARRAY_SIZE(axp_mfd_i2c_board_info)); } else return -1; }
static int __init ap325rxa_devices_setup(void) { /* LD3 and LD4 LEDs */ gpio_request(GPIO_PTX5, NULL); /* RUN */ gpio_direction_output(GPIO_PTX5, 1); gpio_export(GPIO_PTX5, 0); gpio_request(GPIO_PTX4, NULL); /* INDICATOR */ gpio_direction_output(GPIO_PTX4, 0); gpio_export(GPIO_PTX4, 0); /* SW1 input */ gpio_request(GPIO_PTF7, NULL); /* MODE */ gpio_direction_input(GPIO_PTF7); gpio_export(GPIO_PTF7, 0); /* LCDC */ clk_always_enable("mstp200"); gpio_request(GPIO_FN_LCDD15, NULL); gpio_request(GPIO_FN_LCDD14, NULL); gpio_request(GPIO_FN_LCDD13, NULL); gpio_request(GPIO_FN_LCDD12, NULL); gpio_request(GPIO_FN_LCDD11, NULL); gpio_request(GPIO_FN_LCDD10, NULL); gpio_request(GPIO_FN_LCDD9, NULL); gpio_request(GPIO_FN_LCDD8, NULL); gpio_request(GPIO_FN_LCDD7, NULL); gpio_request(GPIO_FN_LCDD6, NULL); gpio_request(GPIO_FN_LCDD5, NULL); gpio_request(GPIO_FN_LCDD4, NULL); gpio_request(GPIO_FN_LCDD3, NULL); gpio_request(GPIO_FN_LCDD2, NULL); gpio_request(GPIO_FN_LCDD1, NULL); gpio_request(GPIO_FN_LCDD0, NULL); gpio_request(GPIO_FN_LCDLCLK_PTR, NULL); gpio_request(GPIO_FN_LCDDCK, NULL); gpio_request(GPIO_FN_LCDVEPWC, NULL); gpio_request(GPIO_FN_LCDVCPWC, NULL); gpio_request(GPIO_FN_LCDVSYN, NULL); gpio_request(GPIO_FN_LCDHSYN, NULL); gpio_request(GPIO_FN_LCDDISP, NULL); gpio_request(GPIO_FN_LCDDON, NULL); /* LCD backlight */ gpio_request(GPIO_PTS3, NULL); gpio_direction_output(GPIO_PTS3, 1); /* CEU */ clk_always_enable("mstp203"); gpio_request(GPIO_FN_VIO_CLK2, NULL); gpio_request(GPIO_FN_VIO_VD2, NULL); gpio_request(GPIO_FN_VIO_HD2, NULL); gpio_request(GPIO_FN_VIO_FLD, NULL); gpio_request(GPIO_FN_VIO_CKO, NULL); gpio_request(GPIO_FN_VIO_D15, NULL); gpio_request(GPIO_FN_VIO_D14, NULL); gpio_request(GPIO_FN_VIO_D13, NULL); gpio_request(GPIO_FN_VIO_D12, NULL); gpio_request(GPIO_FN_VIO_D11, NULL); gpio_request(GPIO_FN_VIO_D10, NULL); gpio_request(GPIO_FN_VIO_D9, NULL); gpio_request(GPIO_FN_VIO_D8, NULL); gpio_request(GPIO_PTZ7, NULL); gpio_direction_output(GPIO_PTZ7, 0); /* OE_CAM */ gpio_request(GPIO_PTZ6, NULL); gpio_direction_output(GPIO_PTZ6, 0); /* STBY_CAM */ gpio_request(GPIO_PTZ5, NULL); gpio_direction_output(GPIO_PTZ5, 1); /* RST_CAM */ gpio_request(GPIO_PTZ4, NULL); gpio_direction_output(GPIO_PTZ4, 0); /* SADDR */ ctrl_outw(ctrl_inw(PORT_MSELCRB) & ~0x0001, PORT_MSELCRB); /* FLCTL */ gpio_request(GPIO_FN_FCE, NULL); gpio_request(GPIO_FN_NAF7, NULL); gpio_request(GPIO_FN_NAF6, NULL); gpio_request(GPIO_FN_NAF5, NULL); gpio_request(GPIO_FN_NAF4, NULL); gpio_request(GPIO_FN_NAF3, NULL); gpio_request(GPIO_FN_NAF2, NULL); gpio_request(GPIO_FN_NAF1, NULL); gpio_request(GPIO_FN_NAF0, NULL); gpio_request(GPIO_FN_FCDE, NULL); gpio_request(GPIO_FN_FOE, NULL); gpio_request(GPIO_FN_FSC, NULL); gpio_request(GPIO_FN_FWE, NULL); gpio_request(GPIO_FN_FRB, NULL); ctrl_outw(0, PORT_HIZCRC); ctrl_outw(0xFFFF, PORT_DRVCRA); ctrl_outw(0xFFFF, PORT_DRVCRB); platform_resource_setup_memory(&ceu_device, "ceu", 4 << 20); i2c_register_board_info(0, ap325rxa_i2c_devices, ARRAY_SIZE(ap325rxa_i2c_devices)); return platform_add_devices(ap325rxa_devices, ARRAY_SIZE(ap325rxa_devices)); }
/* * ip7500av_init * Called to add the devices which we have on this board */ static int __init ip7500av_init(void) { struct platform_device *audio_dev; struct platform_device *audio_dev2; struct ubi32_cs4384_platform_data *cs4384_pd; if (ubicom32_flash_single_init()) { printk(KERN_ERR "%s: could not initialize flash controller\n", __FUNCTION__); } board_init(); ubi_gpio_init(); /* * Start the flash driver */ ubicom32_flash_single_init(); vdc_tio_init(NULL); printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__); platform_add_devices(ip7500av_devices, ARRAY_SIZE(ip7500av_devices)); /* * CS4384 DAC */ audio_dev = audio_device_alloc("snd-ubi32-cs4384", "audio", "audio-i2sout", sizeof(struct ubi32_cs4384_platform_data)); if (audio_dev) { /* * Attempt to figure out a good divisor. This will only work * assuming the core frequency is compatible. */ int i; unsigned int freq = processor_frequency(); for (i = 0; i < ARRAY_SIZE(ip7500av_cs4384_mclk_entries); i++) { unsigned int div; unsigned int rate = ip7500av_cs4384_mclk_entries[i].rate / 1000; div = ((freq / rate) + 500) / 1000; ip7500av_cs4384_mclk_entries[i].div = div; printk("CS4384 mclk %d rate %u000Hz div %u act %u\n", i, rate, div, freq / div); } cs4384_pd = audio_device_priv(audio_dev); cs4384_pd->mclk_src = UBI32_CS4384_MCLK_PWM_0; cs4384_pd->n_mclk = ARRAY_SIZE(ip7500av_cs4384_mclk_entries); cs4384_pd->mclk_entries = ip7500av_cs4384_mclk_entries; ip7500av_i2c_board_info[0].platform_data = audio_dev; /* * Reset the DAC */ if (gpio_request(GPIO_RF_4, "DAC Reset") == 0) { gpio_direction_output(GPIO_RF_4, 0); udelay(1); gpio_direction_output(GPIO_RF_4, 1); } else { printk("Unable to request DAC reset GPIO\n"); } } /* * SPDIF port */ audio_dev2 = audio_device_alloc("snd-ubi32-generic", "audio", "audio-spdifout", 0); if (audio_dev2) { platform_device_register(audio_dev2); } /* * Register all of the devices which sit on the I2C bus */ printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__); i2c_register_board_info(0, ip7500av_i2c_board_info, ARRAY_SIZE(ip7500av_i2c_board_info)); printk(KERN_INFO "IP7500 Audio/Video Board\n"); return 0; }
static void __init nslu2_init(void) { DECLARE_MAC_BUF(mac_buf); uint8_t __iomem *f; int i; ixp4xx_sys_init(); nslu2_flash_resource.start = IXP4XX_EXP_BUS_BASE(0); nslu2_flash_resource.end = IXP4XX_EXP_BUS_BASE(0) + ixp4xx_exp_bus_size - 1; i2c_register_board_info(0, nslu2_i2c_board_info, ARRAY_SIZE(nslu2_i2c_board_info)); /* * This is only useful on a modified machine, but it is valuable * to have it first in order to see debug messages, and so that * it does *not* get removed if platform_add_devices fails! */ (void)platform_device_register(&nslu2_uart); platform_add_devices(nslu2_devices, ARRAY_SIZE(nslu2_devices)); pm_power_off = nslu2_power_off; if (request_irq(gpio_to_irq(NSLU2_RB_GPIO), &nslu2_reset_handler, IRQF_DISABLED | IRQF_TRIGGER_LOW, "NSLU2 reset button", NULL) < 0) { printk(KERN_DEBUG "Reset Button IRQ %d not available\n", gpio_to_irq(NSLU2_RB_GPIO)); } if (request_irq(gpio_to_irq(NSLU2_PB_GPIO), &nslu2_power_handler, IRQF_DISABLED | IRQF_TRIGGER_HIGH, "NSLU2 power button", NULL) < 0) { printk(KERN_DEBUG "Power Button IRQ %d not available\n", gpio_to_irq(NSLU2_PB_GPIO)); } /* * Map in a portion of the flash and read the MAC address. * Since it is stored in BE in the flash itself, we need to * byteswap it if we're in LE mode. */ f = ioremap(IXP4XX_EXP_BUS_BASE(0), 0x40000); if (f) { for (i = 0; i < 6; i++) #ifdef __ARMEB__ nslu2_plat_eth[0].hwaddr[i] = readb(f + 0x3FFB0 + i); #else nslu2_plat_eth[0].hwaddr[i] = readb(f + 0x3FFB0 + (i^3)); #endif iounmap(f); } printk(KERN_INFO "NSLU2: Using MAC address %s for port 0\n", print_mac(mac_buf, nslu2_plat_eth[0].hwaddr)); }
halReturn_t HalOpenI2cDevice(char const *DeviceName, char const *DriverName) { //halReturn_t retStatus; //int32_t retVal; gMhlDevice.pI2cClient=(struct i2c_client *)1; return HAL_RET_SUCCESS; #if 0 retStatus = HalInitCheck(); if (retStatus != HAL_RET_SUCCESS) { return retStatus; } retVal = strnlen(DeviceName, I2C_NAME_SIZE); if (retVal >= I2C_NAME_SIZE) { printk("I2c device name too long!\n"); return HAL_RET_PARAMETER_ERROR; } i2c_register_board_info(0, &i2c_mhl, 1); #if 0 memcpy(gMhlI2cIdTable[0].name, DeviceName, retVal); gMhlI2cIdTable[0].name[retVal] = 0; gMhlI2cIdTable[0].driver_data = 0; gMhlDevice.driver.driver.name = "Sil_MHL"; gMhlDevice.driver.id_table = gMhlI2cIdTable; gMhlDevice.driver.probe = MhlI2cProbe; gMhlDevice.driver.remove = MhlI2cRemove; #endif //printk("gMhlDevice.driver.driver.name=%s\n", gMhlDevice.driver.driver.name); //printk("gMhlI2cIdTable.name=%s\n", gMhlI2cIdTable[0].name); retVal = i2c_add_driver(&mhl_i2c_driver); printk("gMhlDevice.pI2cClient =0x%08x\n", gMhlDevice.pI2cClient); if (retVal != 0) { printk("I2C driver add failed, retVal=%d\n", retVal); retStatus = HAL_RET_FAILURE; } else { gMhlDevice.pI2cClient=1; #if 0 if (gMhlDevice.pI2cClient == NULL) { i2c_del_driver(&gMhlDevice.driver); printk("I2C driver add failed, retVal=%d\n", retVal); retStatus = HAL_RET_NO_DEVICE; } else #endif { retStatus = HAL_RET_SUCCESS; } } printk("GPIO_SCL=%d, GPIO_SDA=%d\n", GPIO_SCL, GPIO_SDA); return retStatus; #endif }
static void __init ft5x06_touchpad_setup(void) { int rc; int irq_gpio; if (machine_is_qrd_skud_prime()) { irq_gpio = FT5X16_IRQ_GPIO; ft5x06_platformdata.x_max = 540; ft5x06_platformdata.y_max = 960; ft5x06_platformdata.irq_gpio = FT5X16_IRQ_GPIO; ft5x06_device_info[0].irq = MSM_GPIO_TO_INT(FT5X16_IRQ_GPIO); ft5x06_virtual_keys_attr.show = &ft5x16_virtual_keys_register; } else if(machine_is_msm8625q_evbd()) { irq_gpio = FT5X16_IRQ_GPIO_EVBD; ft5x06_platformdata.x_max = 540; ft5x06_platformdata.y_max = 960; ft5x06_platformdata.irq_gpio = FT5X16_IRQ_GPIO_EVBD; ft5x06_device_info[0].irq = MSM_GPIO_TO_INT(FT5X16_IRQ_GPIO_EVBD); ft5x06_virtual_keys_attr.show = &ft5x16_virtual_keys_register; } else if(machine_is_msm8625q_skud()) { irq_gpio = FT5X16_IRQ_GPIO_SKUD; ft5x06_platformdata.x_max = 540; ft5x06_platformdata.y_max = 960; ft5x06_platformdata.irq_gpio = FT5X16_IRQ_GPIO_SKUD; ft5x06_device_info[0].irq = MSM_GPIO_TO_INT(FT5X16_IRQ_GPIO_SKUD); ft5x06_virtual_keys_attr.show = &ft5x16_virtual_keys_register; } else irq_gpio = FT5X06_IRQ_GPIO; rc = gpio_tlmm_config(GPIO_CFG(irq_gpio, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, irq_gpio); rc = gpio_tlmm_config(GPIO_CFG(FT5X06_RESET_GPIO, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) pr_err("%s: gpio_tlmm_config for %d failed\n", __func__, FT5X06_RESET_GPIO); ft5x06_virtual_key_properties_kobj = kobject_create_and_add("board_properties", NULL); if (ft5x06_virtual_key_properties_kobj) rc = sysfs_create_group(ft5x06_virtual_key_properties_kobj, &ft5x06_virtual_key_properties_attr_group); if (!ft5x06_virtual_key_properties_kobj || rc) pr_err("%s: failed to create board_properties\n", __func__); i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, ft5x06_device_info, ARRAY_SIZE(ft5x06_device_info)); }
static void __init jive_machine_init(void) { /* register system devices for managing low level suspend */ sysdev_class_register(&jive_pm_sysclass); sysdev_register(&jive_pm_sysdev); /* write our sleep configurations for the IO. Pull down all unused * IO, ensure that we have turned off all peripherals we do not * need, and configure the ones we do need. */ /* Port B sleep */ __raw_writel(S3C2412_SLPCON_IN(0) | S3C2412_SLPCON_PULL(1) | S3C2412_SLPCON_HIGH(2) | S3C2412_SLPCON_PULL(3) | S3C2412_SLPCON_PULL(4) | S3C2412_SLPCON_PULL(5) | S3C2412_SLPCON_PULL(6) | S3C2412_SLPCON_HIGH(7) | S3C2412_SLPCON_PULL(8) | S3C2412_SLPCON_PULL(9) | S3C2412_SLPCON_PULL(10), S3C2412_GPBSLPCON); /* Port C sleep */ __raw_writel(S3C2412_SLPCON_PULL(0) | S3C2412_SLPCON_PULL(1) | S3C2412_SLPCON_PULL(2) | S3C2412_SLPCON_PULL(3) | S3C2412_SLPCON_PULL(4) | S3C2412_SLPCON_PULL(5) | S3C2412_SLPCON_LOW(6) | S3C2412_SLPCON_PULL(6) | S3C2412_SLPCON_PULL(7) | S3C2412_SLPCON_PULL(8) | S3C2412_SLPCON_PULL(9) | S3C2412_SLPCON_PULL(10) | S3C2412_SLPCON_PULL(11) | S3C2412_SLPCON_PULL(12) | S3C2412_SLPCON_PULL(13) | S3C2412_SLPCON_PULL(14) | S3C2412_SLPCON_PULL(15), S3C2412_GPCSLPCON); /* Port D sleep */ __raw_writel(S3C2412_SLPCON_ALL_PULL, S3C2412_GPDSLPCON); /* Port F sleep */ __raw_writel(S3C2412_SLPCON_LOW(0) | S3C2412_SLPCON_LOW(1) | S3C2412_SLPCON_LOW(2) | S3C2412_SLPCON_EINT(3) | S3C2412_SLPCON_EINT(4) | S3C2412_SLPCON_EINT(5) | S3C2412_SLPCON_EINT(6) | S3C2412_SLPCON_EINT(7), S3C2412_GPFSLPCON); /* Port G sleep */ __raw_writel(S3C2412_SLPCON_IN(0) | S3C2412_SLPCON_IN(1) | S3C2412_SLPCON_IN(2) | S3C2412_SLPCON_IN(3) | S3C2412_SLPCON_IN(4) | S3C2412_SLPCON_IN(5) | S3C2412_SLPCON_IN(6) | S3C2412_SLPCON_IN(7) | S3C2412_SLPCON_PULL(8) | S3C2412_SLPCON_PULL(9) | S3C2412_SLPCON_IN(10) | S3C2412_SLPCON_PULL(11) | S3C2412_SLPCON_PULL(12) | S3C2412_SLPCON_PULL(13) | S3C2412_SLPCON_IN(14) | S3C2412_SLPCON_PULL(15), S3C2412_GPGSLPCON); /* Port H sleep */ __raw_writel(S3C2412_SLPCON_PULL(0) | S3C2412_SLPCON_PULL(1) | S3C2412_SLPCON_PULL(2) | S3C2412_SLPCON_PULL(3) | S3C2412_SLPCON_PULL(4) | S3C2412_SLPCON_PULL(5) | S3C2412_SLPCON_PULL(6) | S3C2412_SLPCON_IN(7) | S3C2412_SLPCON_IN(8) | S3C2412_SLPCON_PULL(9) | S3C2412_SLPCON_IN(10), S3C2412_GPHSLPCON); /* initialise the power management now we've setup everything. */ s3c2410_pm_init(); s3c_device_nand.dev.platform_data = &jive_nand_info; /* initialise the spi */ s3c2410_gpio_setpin(S3C2410_GPG13, 0); s3c2410_gpio_cfgpin(S3C2410_GPG13, S3C2410_GPIO_OUTPUT); s3c2410_gpio_setpin(S3C2410_GPB7, 1); s3c2410_gpio_cfgpin(S3C2410_GPB7, S3C2410_GPIO_OUTPUT); s3c2410_gpio_setpin(S3C2410_GPB6, 0); s3c2410_gpio_cfgpin(S3C2410_GPB6, S3C2410_GPIO_OUTPUT); s3c2410_gpio_setpin(S3C2410_GPG8, 1); s3c2410_gpio_cfgpin(S3C2410_GPG8, S3C2410_GPIO_OUTPUT); /* initialise the WM8750 spi */ s3c2410_gpio_setpin(S3C2410_GPH10, 1); s3c2410_gpio_cfgpin(S3C2410_GPH10, S3C2410_GPIO_OUTPUT); /* Turn off suspend on both USB ports, and switch the * selectable USB port to USB device mode. */ s3c2410_modify_misccr(S3C2410_MISCCR_USBHOST | S3C2410_MISCCR_USBSUSPND0 | S3C2410_MISCCR_USBSUSPND1, 0x0); s3c24xx_udc_set_platdata(&jive_udc_cfg); s3c24xx_fb_set_platdata(&jive_lcd_config); spi_register_board_info(jive_spi_devs, ARRAY_SIZE(jive_spi_devs)); s3c_i2c0_set_platdata(&jive_i2c_cfg); i2c_register_board_info(0, jive_i2c_devs, ARRAY_SIZE(jive_i2c_devs)); pm_power_off = jive_power_off; platform_add_devices(jive_devices, ARRAY_SIZE(jive_devices)); }
static void __init omap5panda_display_init(void) { struct sgx_omaplfb_config data = { .tiler2d_buffers = 0, .swap_chain_length = 2, .vram_buffers = 2, }; omapfb_set_platform_data(&panda_fb_pdata); omap_vram_set_sdram_vram(OMAP5_SEVM_FB_RAM_SIZE, 0); sgx_omaplfb_set(0, &data); i2c_register_board_info(0, hdmi_i2c_eeprom, ARRAY_SIZE(hdmi_i2c_eeprom)); platform_device_register(&hdmi_edid_device); omap5panda_hdmi_init(); omap_display_init(&panda5_dss_data); } static const struct usbhs_omap_board_data usbhs_bdata __initconst = { .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED, .port_mode[1] = OMAP_EHCI_PORT_MODE_HSIC, .port_mode[2] = OMAP_EHCI_PORT_MODE_HSIC, .phy_reset = true, .reset_gpio_port[0] = -EINVAL, .reset_gpio_port[1] = GPIO_HUB_NRESET, .reset_gpio_port[2] = GPIO_ETH_NRESET }; static void __init omap_ehci_ohci_init(void) { struct clk *phy_ref_clk; /* FREF_CLK1 provides the 19.2 MHz reference clock to the PHY */ phy_ref_clk = clk_get(NULL, "auxclk1_ck"); if (IS_ERR(phy_ref_clk)) { pr_err("Cannot request auxclk1\n"); } else { clk_set_rate(phy_ref_clk, 19200000); clk_enable(phy_ref_clk); } omap_mux_init_gpio(GPIO_HUB_NRESET, OMAP_PIN_OUTPUT | OMAP_PIN_OFF_NONE | OMAP_MUX_MODE6); omap_mux_init_gpio(GPIO_ETH_NRESET, OMAP_PIN_OUTPUT | OMAP_PIN_OFF_NONE | OMAP_MUX_MODE6); usbhs_init(&usbhs_bdata); return; } static void __init omap_5_panda_init(void) { omap5_mux_init(board_mux, NULL, OMAP_PACKAGE_CBL); omap_sdrc_init(NULL, NULL); omap_init_board_version(BOARD_MAKE_VERSION(BOARD_OMAP5_UEVM, 0)); omap_create_board_props(); omap5pandai2c_init(); omap_msecure_init(); omap5_pmic_init(1, PALMAS_NAME, OMAP44XX_IRQ_SYS_1N, PALMAS_DATA, "twl6040", OMAP44XX_IRQ_SYS_2N, &twl6040_data); omap5_board_serial_init(); platform_device_register(&dummy_sd_regulator_device); omap_ehci_ohci_init(); /* TODO: Once the board identification is passed in from the * bootloader pass in the HACK board ID to the conn board file */ omap4plus_connectivity_init(); omap_hsmmc_init(mmc); usb_dwc3_init(); platform_add_devices(panda5_devices, ARRAY_SIZE(panda5_devices)); omap_init_dmm_tiler(); omap5_register_ion(); omap5panda_display_init(); } static void __init omap_panda5_reserve(void) { omap_rproc_reserve_cma(RPROC_CMA_OMAP5); omap5_ion_init(); omap_reserve(); }
static __init void da850_evm_init(void) { int ret; ret = pmic_tps65070_init(); if (ret) pr_warning("da850_evm_init: TPS65070 PMIC init failed: %d\n", ret); ret = da850_register_edma(da850_edma_rsv); if (ret) pr_warning("da850_evm_init: edma registration failed: %d\n", ret); ret = davinci_cfg_reg_list(da850_i2c0_pins); if (ret) pr_warning("da850_evm_init: i2c0 mux setup failed: %d\n", ret); ret = da8xx_register_i2c(0, &da850_evm_i2c_0_pdata); if (ret) pr_warning("da850_evm_init: i2c0 registration failed: %d\n", ret); ret = da8xx_register_watchdog(); if (ret) pr_warning("da830_evm_init: watchdog registration failed: %d\n", ret); if (HAS_MMC) { ret = davinci_cfg_reg_list(da850_evm_mmcsd0_pins); if (ret) pr_warning("da850_evm_init: mmcsd0 mux setup failed:" " %d\n", ret); ret = gpio_request(DA850_MMCSD_CD_PIN, "MMC CD\n"); if (ret) pr_warning("da850_evm_init: can not open GPIO %d\n", DA850_MMCSD_CD_PIN); gpio_direction_input(DA850_MMCSD_CD_PIN); ret = gpio_request(DA850_MMCSD_WP_PIN, "MMC WP\n"); if (ret) pr_warning("da850_evm_init: can not open GPIO %d\n", DA850_MMCSD_WP_PIN); gpio_direction_input(DA850_MMCSD_WP_PIN); ret = da8xx_register_mmcsd0(&da850_mmc_config); if (ret) pr_warning("da850_evm_init: mmcsd0 registration failed:" " %d\n", ret); } davinci_serial_init(&da850_evm_uart_config); i2c_register_board_info(1, da850_evm_i2c_devices, ARRAY_SIZE(da850_evm_i2c_devices)); /* * shut down uart 0 and 1; they are not used on the board and * accessing them causes endless "too much work in irq53" messages * with arago fs */ __raw_writel(0, IO_ADDRESS(DA8XX_UART1_BASE) + 0x30); __raw_writel(0, IO_ADDRESS(DA8XX_UART0_BASE) + 0x30); ret = davinci_cfg_reg_list(da850_evm_mcasp_pins); if (ret) pr_warning("da850_evm_init: mcasp mux setup failed: %d\n", ret); da8xx_register_mcasp(0, &da850_evm_snd_data); ret = davinci_cfg_reg_list(da850_lcdcntl_pins); if (ret) pr_warning("da850_evm_init: lcdcntl mux setup failed: %d\n", ret); /* Handle board specific muxing for LCD here */ ret = davinci_cfg_reg_list(da850_evm_lcdc_pins); if (ret) pr_warning("da850_evm_init: evm specific lcd mux setup " "failed: %d\n", ret); ret = da850_lcd_hw_init(); if (ret) pr_warning("da850_evm_init: lcd initialization failed: %d\n", ret); sharp_lk043t1dg01_pdata.panel_power_ctrl = da850_panel_power_ctrl, ret = da8xx_register_lcdc(&sharp_lk043t1dg01_pdata); if (ret) pr_warning("da850_evm_init: lcdc registration failed: %d\n", ret); ret = da8xx_register_rtc(); if (ret) pr_warning("da850_evm_init: rtc setup failed: %d\n", ret); ret = da850_evm_init_cpufreq(); if (ret) pr_warning("da850_evm_init: cpufreq registration failed: %d\n", ret); ret = da8xx_register_cpuidle(); if (ret) pr_warning("da850_evm_init: cpuidle registration failed: %d\n", ret); ret = da850_register_pm(&da850_pm_device); if (ret) pr_warning("da850_evm_init: suspend registration failed: %d\n", ret); ret = da8xx_register_spi(1, da850evm_spi_info, ARRAY_SIZE(da850evm_spi_info)); if (ret) pr_warning("da850_evm_init: spi 1 registration failed: %d\n", ret); }
/*! * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_ipu_data.di_clk[0] = clk_get(NULL, "ipu_di0_clk"); mxc_ipu_data.di_clk[1] = clk_get(NULL, "ipu_di1_clk"); mxc_ipu_data.csi_clk[0] = clk_get(NULL, "ssi_ext1_clk"); mxc_spdif_data.spdif_core_clk = clk_get(NULL, "spdif_xtal_clk"); clk_put(mxc_spdif_data.spdif_core_clk); mxcsdhc1_device.resource[2].start = gpio_to_irq(MX53_SMD_SD1_CD); mxcsdhc1_device.resource[2].end = gpio_to_irq(MX53_SMD_SD1_CD); mxc_cpu_common_init(); mx53_smd_io_init(); pm_power_off = mx53_smd_power_off; mxc_register_device(&mxc_dma_device, NULL); mxc_register_device(&mxc_wdt_device, NULL); mxc_register_device(&mxcspi1_device, &mxcspi1_data); mxc_register_device(&mxci2c_devices[0], &mxci2c_data); mxc_register_device(&mxci2c_devices[1], &mxci2c_data); mxc_register_device(&mxci2c_devices[2], &mxci2c_data); mx53_smd_init_da9052(); mxc_register_device(&mxc_rtc_device, NULL); mxc_register_device(&mxc_ipu_device, &mxc_ipu_data); mxc_register_device(&mxc_ldb_device, &ldb_data); mxc_register_device(&mxc_tve_device, &tve_data); mxc_register_device(&mxcvpu_device, &mxc_vpu_data); mxc_register_device(&gpu_device, &z160_revision); mxc_register_device(&mxcscc_device, NULL); mxc_register_device(&mxc_dvfs_core_device, &dvfs_core_data); mxc_register_device(&busfreq_device, &bus_freq_data); mxc_register_device(&mxc_iim_device, &iim_data); mxc_register_device(&mxc_pwm2_device, NULL); mxc_register_device(&mxc_pwm1_backlight_device, &mxc_pwm_backlight_data); mxc_register_device(&mxcsdhc1_device, &mmc1_data); mxc_register_device(&mxcsdhc2_device, &mmc2_data); mxc_register_device(&mxcsdhc3_device, &mmc3_data); mxc_register_device(&mxc_ssi1_device, NULL); mxc_register_device(&mxc_ssi2_device, NULL); mxc_register_device(&mxc_alsa_spdif_device, &mxc_spdif_data); mxc_register_device(&ahci_fsl_device, &sata_data); /* AHCI SATA PWR EN(DCDC_5V, DCDC_3V3_BB) on SATA bus */ gpio_request(MX53_SMD_SATA_PWR_EN, "sata-pwr-en"); gpio_direction_output(MX53_SMD_SATA_PWR_EN, 1); mxc_register_device(&mxc_fec_device, &fec_data); mxc_register_device(&mxc_ptp_device, NULL); /* ASRC is only available for MX53 TO2.0 */ if (mx53_revision() >= IMX_CHIP_REVISION_2_0) { mxc_asrc_data.asrc_core_clk = clk_get(NULL, "asrc_clk"); clk_put(mxc_asrc_data.asrc_core_clk); mxc_asrc_data.asrc_audio_clk = clk_get(NULL, "asrc_serial_clk"); clk_put(mxc_asrc_data.asrc_audio_clk); mxc_register_device(&mxc_asrc_device, &mxc_asrc_data); } spi_device_init(); i2c_register_board_info(0, mxc_i2c0_board_info, ARRAY_SIZE(mxc_i2c0_board_info)); i2c_register_board_info(1, mxc_i2c1_board_info, ARRAY_SIZE(mxc_i2c1_board_info)); i2c_register_board_info(2, mxc_i2c2_board_info, ARRAY_SIZE(mxc_i2c2_board_info)); mxc_register_device(&mxc_sgtl5000_device, &sgtl5000_data); mx5_set_otghost_vbus_func(mx53_gpio_usbotg_driver_vbus); mx5_usb_dr_init(); mx5_usbh1_init(); mxc_register_device(&mxc_v4l2_device, NULL); mxc_register_device(&mxc_v4l2out_device, NULL); mxc_register_device(&mxc_bt_rfkill, &mxc_bt_rfkill_data); smd_add_device_buttons(); smd_add_device_battery(); }
static int __init pmic_tps65070_init(void) { return i2c_register_board_info(1, da850_evm_tps65070_info, ARRAY_SIZE(da850_evm_tps65070_info)); }
static int __init realview_i2c_init(void) { return i2c_register_board_info(0, realview_i2c_board_info, ARRAY_SIZE(realview_i2c_board_info)); }
static void __init bravo_init(void) { int ret; printk("bravo_init() revision=%d\n", system_rev); if (is_cdma_version(system_rev)) smd_set_channel_list(smd_cdma_default_channels, ARRAY_SIZE(smd_cdma_default_channels)); msm_hw_reset_hook = bravo_reset; if (is_cdma_version(system_rev)) msm_acpu_clock_init(&bravo_cdma_clock_data); else msm_acpu_clock_init(&bravo_clock_data); #ifdef CONFIG_PERFLOCK perflock_init(&bravo_perflock_data); #endif msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1, &msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(139)); config_gpio_table(misc_gpio_table, ARRAY_SIZE(misc_gpio_table)); if (is_cdma_version(system_rev)) { bcm_bt_lpm_pdata.gpio_wake = BRAVO_CDMA_GPIO_BT_WAKE; bravo_flashlight_data.torch = BRAVO_CDMA_GPIO_FLASHLIGHT_TORCH; config_gpio_table(bt_gpio_table_rev_CX, ARRAY_SIZE(bt_gpio_table_rev_CX)); } else { config_gpio_table(bt_gpio_table, ARRAY_SIZE(bt_gpio_table)); } gpio_request(BRAVO_GPIO_TP_LS_EN, "tp_ls_en"); gpio_direction_output(BRAVO_GPIO_TP_LS_EN, 0); gpio_request(BRAVO_GPIO_TP_EN, "tp_en"); gpio_direction_output(BRAVO_GPIO_TP_EN, 0); // gpio_request(BRAVO_GPIO_PROXIMITY_EN, "proximity_en"); // gpio_direction_output(BRAVO_GPIO_PROXIMITY_EN, 1); gpio_request(BRAVO_GPIO_LS_EN_N, "ls_en"); gpio_request(BRAVO_GPIO_COMPASS_RST_N, "compass_rst"); gpio_direction_output(BRAVO_GPIO_COMPASS_RST_N, 1); gpio_request(BRAVO_GPIO_COMPASS_INT_N, "compass_int"); gpio_direction_input(BRAVO_GPIO_COMPASS_INT_N); gpio_request(BRAVO_GPIO_DS2482_SLP_N, "ds2482_slp_n"); /* set the gpu power rail to manual mode so clk en/dis will not * turn off gpu power, and hang it on resume */ bravo_kgsl_power_rail_mode(0); bravo_kgsl_power(true); msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata; msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata; platform_add_devices(devices, ARRAY_SIZE(devices)); i2c_register_board_info(0, base_i2c_devices, ARRAY_SIZE(base_i2c_devices)); if (is_cdma_version(system_rev)) { i2c_register_board_info(0, rev_CX_i2c_devices, ARRAY_SIZE(rev_CX_i2c_devices)); } ret = bravo_init_mmc(system_rev, debug_uart); if (ret != 0) pr_crit("%s: Unable to initialize MMC\n", __func__); bravo_audio_init(); bravo_headset_init(); platform_device_register(&bravo_timed_gpios); ds2784_battery_init(); }
static void __init mackerel_init(void) { u32 srcr4; struct clk *clk; /* External clock source */ clk_set_rate(&sh7372_dv_clki_clk, 27000000); sh7372_pinmux_init(); /* enable SCIFA0 */ gpio_request(GPIO_FN_SCIFA0_TXD, NULL); gpio_request(GPIO_FN_SCIFA0_RXD, NULL); /* enable SMSC911X */ gpio_request(GPIO_FN_CS5A, NULL); gpio_request(GPIO_FN_IRQ6_39, NULL); /* LCDC */ gpio_request(GPIO_FN_LCDD23, NULL); gpio_request(GPIO_FN_LCDD22, NULL); gpio_request(GPIO_FN_LCDD21, NULL); gpio_request(GPIO_FN_LCDD20, NULL); gpio_request(GPIO_FN_LCDD19, NULL); gpio_request(GPIO_FN_LCDD18, NULL); gpio_request(GPIO_FN_LCDD17, NULL); gpio_request(GPIO_FN_LCDD16, NULL); gpio_request(GPIO_FN_LCDD15, NULL); gpio_request(GPIO_FN_LCDD14, NULL); gpio_request(GPIO_FN_LCDD13, NULL); gpio_request(GPIO_FN_LCDD12, NULL); gpio_request(GPIO_FN_LCDD11, NULL); gpio_request(GPIO_FN_LCDD10, NULL); gpio_request(GPIO_FN_LCDD9, NULL); gpio_request(GPIO_FN_LCDD8, NULL); gpio_request(GPIO_FN_LCDD7, NULL); gpio_request(GPIO_FN_LCDD6, NULL); gpio_request(GPIO_FN_LCDD5, NULL); gpio_request(GPIO_FN_LCDD4, NULL); gpio_request(GPIO_FN_LCDD3, NULL); gpio_request(GPIO_FN_LCDD2, NULL); gpio_request(GPIO_FN_LCDD1, NULL); gpio_request(GPIO_FN_LCDD0, NULL); gpio_request(GPIO_FN_LCDDISP, NULL); gpio_request(GPIO_FN_LCDDCK, NULL); gpio_request(GPIO_PORT31, NULL); /* backlight */ gpio_direction_output(GPIO_PORT31, 0); /* off by default */ gpio_request(GPIO_PORT151, NULL); /* LCDDON */ gpio_direction_output(GPIO_PORT151, 1); /* USBHS0 */ gpio_request(GPIO_FN_VBUS0_0, NULL); gpio_pull_down(GPIO_PORT168CR); /* VBUS0_0 pull down */ /* USBHS1 */ gpio_request(GPIO_FN_VBUS0_1, NULL); gpio_pull_down(GPIO_PORT167CR); /* VBUS0_1 pull down */ gpio_request(GPIO_FN_IDIN_1_113, NULL); /* enable FSI2 port A (ak4643) */ gpio_request(GPIO_FN_FSIAIBT, NULL); gpio_request(GPIO_FN_FSIAILR, NULL); gpio_request(GPIO_FN_FSIAISLD, NULL); gpio_request(GPIO_FN_FSIAOSLD, NULL); gpio_request(GPIO_PORT161, NULL); gpio_direction_output(GPIO_PORT161, 0); /* slave */ gpio_request(GPIO_PORT9, NULL); gpio_request(GPIO_PORT10, NULL); gpio_no_direction(GPIO_PORT9CR); /* FSIAOBT needs no direction */ gpio_no_direction(GPIO_PORT10CR); /* FSIAOLR needs no direction */ intc_set_priority(IRQ_FSI, 3); /* irq priority FSI(3) > SMSC911X(2) */ /* setup FSI2 port B (HDMI) */ gpio_request(GPIO_FN_FSIBCK, NULL); __raw_writew(__raw_readw(USCCR1) & ~(1 << 6), USCCR1); /* use SPDIF */ /* set SPU2 clock to 119.6 MHz */ clk = clk_get(NULL, "spu_clk"); if (!IS_ERR(clk)) { clk_set_rate(clk, clk_round_rate(clk, 119600000)); clk_put(clk); } /* enable Keypad */ gpio_request(GPIO_FN_IRQ9_42, NULL); irq_set_irq_type(IRQ9, IRQ_TYPE_LEVEL_HIGH); /* enable Touchscreen */ gpio_request(GPIO_FN_IRQ7_40, NULL); irq_set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW); /* enable Accelerometer */ gpio_request(GPIO_FN_IRQ21, NULL); irq_set_irq_type(IRQ21, IRQ_TYPE_LEVEL_HIGH); /* enable SDHI0 */ gpio_request(GPIO_FN_SDHIWP0, NULL); gpio_request(GPIO_FN_SDHICMD0, NULL); gpio_request(GPIO_FN_SDHICLK0, NULL); gpio_request(GPIO_FN_SDHID0_3, NULL); gpio_request(GPIO_FN_SDHID0_2, NULL); gpio_request(GPIO_FN_SDHID0_1, NULL); gpio_request(GPIO_FN_SDHID0_0, NULL); #if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE) /* enable SDHI1 */ gpio_request(GPIO_FN_SDHICMD1, NULL); gpio_request(GPIO_FN_SDHICLK1, NULL); gpio_request(GPIO_FN_SDHID1_3, NULL); gpio_request(GPIO_FN_SDHID1_2, NULL); gpio_request(GPIO_FN_SDHID1_1, NULL); gpio_request(GPIO_FN_SDHID1_0, NULL); #endif /* card detect pin for MMC slot (CN7) */ gpio_request(GPIO_PORT41, NULL); gpio_direction_input(GPIO_PORT41); /* enable SDHI2 */ gpio_request(GPIO_FN_SDHICMD2, NULL); gpio_request(GPIO_FN_SDHICLK2, NULL); gpio_request(GPIO_FN_SDHID2_3, NULL); gpio_request(GPIO_FN_SDHID2_2, NULL); gpio_request(GPIO_FN_SDHID2_1, NULL); gpio_request(GPIO_FN_SDHID2_0, NULL); /* card detect pin for microSD slot (CN23) */ gpio_request(GPIO_PORT162, NULL); gpio_direction_input(GPIO_PORT162); /* MMCIF */ gpio_request(GPIO_FN_MMCD0_0, NULL); gpio_request(GPIO_FN_MMCD0_1, NULL); gpio_request(GPIO_FN_MMCD0_2, NULL); gpio_request(GPIO_FN_MMCD0_3, NULL); gpio_request(GPIO_FN_MMCD0_4, NULL); gpio_request(GPIO_FN_MMCD0_5, NULL); gpio_request(GPIO_FN_MMCD0_6, NULL); gpio_request(GPIO_FN_MMCD0_7, NULL); gpio_request(GPIO_FN_MMCCMD0, NULL); gpio_request(GPIO_FN_MMCCLK0, NULL); /* FLCTL */ gpio_request(GPIO_FN_D0_NAF0, NULL); gpio_request(GPIO_FN_D1_NAF1, NULL); gpio_request(GPIO_FN_D2_NAF2, NULL); gpio_request(GPIO_FN_D3_NAF3, NULL); gpio_request(GPIO_FN_D4_NAF4, NULL); gpio_request(GPIO_FN_D5_NAF5, NULL); gpio_request(GPIO_FN_D6_NAF6, NULL); gpio_request(GPIO_FN_D7_NAF7, NULL); gpio_request(GPIO_FN_D8_NAF8, NULL); gpio_request(GPIO_FN_D9_NAF9, NULL); gpio_request(GPIO_FN_D10_NAF10, NULL); gpio_request(GPIO_FN_D11_NAF11, NULL); gpio_request(GPIO_FN_D12_NAF12, NULL); gpio_request(GPIO_FN_D13_NAF13, NULL); gpio_request(GPIO_FN_D14_NAF14, NULL); gpio_request(GPIO_FN_D15_NAF15, NULL); gpio_request(GPIO_FN_FCE0, NULL); gpio_request(GPIO_FN_WE0_FWE, NULL); gpio_request(GPIO_FN_FRB, NULL); gpio_request(GPIO_FN_A4_FOE, NULL); gpio_request(GPIO_FN_A5_FCDE, NULL); gpio_request(GPIO_FN_RD_FSC, NULL); /* enable GPS module (GT-720F) */ gpio_request(GPIO_FN_SCIFA2_TXD1, NULL); gpio_request(GPIO_FN_SCIFA2_RXD1, NULL); /* CEU */ gpio_request(GPIO_FN_VIO_CLK, NULL); gpio_request(GPIO_FN_VIO_VD, NULL); gpio_request(GPIO_FN_VIO_HD, NULL); gpio_request(GPIO_FN_VIO_FIELD, NULL); gpio_request(GPIO_FN_VIO_CKO, NULL); gpio_request(GPIO_FN_VIO_D7, NULL); gpio_request(GPIO_FN_VIO_D6, NULL); gpio_request(GPIO_FN_VIO_D5, NULL); gpio_request(GPIO_FN_VIO_D4, NULL); gpio_request(GPIO_FN_VIO_D3, NULL); gpio_request(GPIO_FN_VIO_D2, NULL); gpio_request(GPIO_FN_VIO_D1, NULL); gpio_request(GPIO_FN_VIO_D0, NULL); /* HDMI */ gpio_request(GPIO_FN_HDMI_HPD, NULL); gpio_request(GPIO_FN_HDMI_CEC, NULL); /* Reset HDMI, must be held at least one EXTALR (32768Hz) period */ srcr4 = __raw_readl(SRCR4); __raw_writel(srcr4 | (1 << 13), SRCR4); udelay(50); __raw_writel(srcr4 & ~(1 << 13), SRCR4); i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices)); i2c_register_board_info(1, i2c1_devices, ARRAY_SIZE(i2c1_devices)); sh7372_add_standard_devices(); platform_add_devices(mackerel_devices, ARRAY_SIZE(mackerel_devices)); sh7372_add_device_to_domain(&sh7372_a4lc, &lcdc_device); sh7372_add_device_to_domain(&sh7372_a4lc, &hdmi_lcdc_device); sh7372_add_device_to_domain(&sh7372_a4lc, &meram_device); sh7372_add_device_to_domain(&sh7372_a4mp, &fsi_device); sh7372_add_device_to_domain(&sh7372_a3sp, &usbhs0_device); sh7372_add_device_to_domain(&sh7372_a3sp, &usbhs1_device); sh7372_add_device_to_domain(&sh7372_a3sp, &nand_flash_device); sh7372_add_device_to_domain(&sh7372_a3sp, &sh_mmcif_device); sh7372_add_device_to_domain(&sh7372_a3sp, &sdhi0_device); #if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE) sh7372_add_device_to_domain(&sh7372_a3sp, &sdhi1_device); #endif sh7372_add_device_to_domain(&sh7372_a3sp, &sdhi2_device); sh7372_add_device_to_domain(&sh7372_a4r, &ceu_device); hdmi_init_pm_clock(); sh7372_pm_init(); pm_clk_add(&fsi_device.dev, "spu2"); pm_clk_add(&hdmi_lcdc_device.dev, "hdmi"); }
static void __init dns323_init(void) { /* Setup basic Orion functions. Need to be called early. */ orion5x_init(); /* Identify revision */ system_rev = dns323_identify_rev(); pr_info("DNS-323: Identified HW revision %c1\n", 'A' + system_rev); /* Just to be tricky, the 5182 has a completely different * set of MPP modes to the 5181. */ switch(system_rev) { case DNS323_REV_A1: orion5x_mpp_conf(dns323a_mpp_modes); writel(0, MPP_DEV_CTRL); /* DEV_D[31:16] */ break; case DNS323_REV_B1: orion5x_mpp_conf(dns323b_mpp_modes); break; case DNS323_REV_C1: orion5x_mpp_conf(dns323c_mpp_modes); break; } /* setup flash mapping * CS3 holds a 8 MB Spansion S29GL064M90TFIR4 */ orion5x_setup_dev_boot_win(DNS323_NOR_BOOT_BASE, DNS323_NOR_BOOT_SIZE); platform_device_register(&dns323_nor_flash); /* Sort out LEDs, Buttons and i2c devices */ switch(system_rev) { case DNS323_REV_A1: /* The 5181 power LED is active low and requires * DNS323_GPIO_LED_POWER1 to also be low. */ dns323ab_leds[0].active_low = 1; gpio_request(DNS323_GPIO_LED_POWER1, "Power Led Enable"); gpio_direction_output(DNS323_GPIO_LED_POWER1, 0); /* Fall through */ case DNS323_REV_B1: i2c_register_board_info(0, dns323ab_i2c_devices, ARRAY_SIZE(dns323ab_i2c_devices)); break; case DNS323_REV_C1: /* Hookup LEDs & Buttons */ dns323_gpio_leds.dev.platform_data = &dns323c_led_data; dns323_button_device.dev.platform_data = &dns323c_button_data; /* Hookup i2c devices and fan driver */ i2c_register_board_info(0, dns323c_i2c_devices, ARRAY_SIZE(dns323c_i2c_devices)); platform_device_register_simple("dns323c-fan", 0, NULL, 0); /* Register fixup for the PHY LEDs */ phy_register_fixup_for_uid(MARVELL_PHY_ID_88E1118, MARVELL_PHY_ID_MASK, dns323c_phy_fixup); } platform_device_register(&dns323_gpio_leds); platform_device_register(&dns323_button_device); /* * Configure peripherals. */ if (dns323_read_mac_addr() < 0) printk("DNS-323: Failed to read MAC address\n"); orion5x_ehci0_init(); orion5x_eth_init(&dns323_eth_data); orion5x_i2c_init(); orion5x_uart0_init(); /* Remaining GPIOs */ switch(system_rev) { case DNS323_REV_A1: /* Poweroff GPIO */ if (gpio_request(DNS323_GPIO_POWER_OFF, "POWEROFF") != 0 || gpio_direction_output(DNS323_GPIO_POWER_OFF, 0) != 0) pr_err("DNS-323: failed to setup power-off GPIO\n"); pm_power_off = dns323a_power_off; break; case DNS323_REV_B1: /* 5182 built-in SATA init */ orion5x_sata_init(&dns323_sata_data); /* The DNS323 rev B1 has flag to indicate the system is up. * Without this flag set, power LED will flash and cannot be * controlled via leds-gpio. */ if (gpio_request(DNS323_GPIO_SYSTEM_UP, "SYS_READY") == 0) gpio_direction_output(DNS323_GPIO_SYSTEM_UP, 1); /* Poweroff GPIO */ if (gpio_request(DNS323_GPIO_POWER_OFF, "POWEROFF") != 0 || gpio_direction_output(DNS323_GPIO_POWER_OFF, 0) != 0) pr_err("DNS-323: failed to setup power-off GPIO\n"); pm_power_off = dns323b_power_off; break; case DNS323_REV_C1: /* 5182 built-in SATA init */ orion5x_sata_init(&dns323_sata_data); /* Poweroff GPIO */ if (gpio_request(DNS323C_GPIO_POWER_OFF, "POWEROFF") != 0 || gpio_direction_output(DNS323C_GPIO_POWER_OFF, 0) != 0) pr_err("DNS-323: failed to setup power-off GPIO\n"); pm_power_off = dns323c_power_off; /* Now, -this- should theorically be done by the sata_mv driver * once I figure out what's going on there. Maybe the behaviour * of the LEDs should be somewhat passed via the platform_data. * for now, just whack the register and make the LEDs happy * * Note: AFAIK, rev B1 needs the same treatement but I'll let * somebody else test it. */ writel(0x5, ORION5X_SATA_VIRT_BASE | 0x2c); break; } }