static void __init pcm038_init(void) { mxc_gpio_setup_multiple_pins(pcm038_pins, ARRAY_SIZE(pcm038_pins), "PCM038"); pcm038_init_sram(); mxc_register_device(&mxc_uart_device0, &uart_pdata[0]); mxc_register_device(&mxc_uart_device1, &uart_pdata[1]); mxc_register_device(&mxc_uart_device2, &uart_pdata[2]); mxc_gpio_mode(PE16_AF_OWIRE); mxc_register_device(&mxc_nand_device, &pcm038_nand_board_info); /* only the i2c master 1 is used on this CPU card */ i2c_register_board_info(1, pcm038_i2c_devices, ARRAY_SIZE(pcm038_i2c_devices)); mxc_register_device(&mxc_i2c_device1, &pcm038_i2c_1_data); /* PE18 for user-LED D40 */ mxc_gpio_mode(GPIO_PORTE | 18 | GPIO_GPIO | GPIO_OUT); platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices)); #ifdef CONFIG_MACH_PCM970_BASEBOARD pcm970_baseboard_init(); #endif }
/* * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_iomux_v3_setup_multiple_pads(eukrea_cpuimx35_pads, ARRAY_SIZE(eukrea_cpuimx35_pads)); imx35_add_fec(NULL); platform_add_devices(devices, ARRAY_SIZE(devices)); imx35_add_imx_uart0(&uart_pdata); imx35_add_mxc_nand(&eukrea_cpuimx35_nand_board_info); i2c_register_board_info(0, eukrea_cpuimx35_i2c_devices, ARRAY_SIZE(eukrea_cpuimx35_i2c_devices)); imx35_add_imx_i2c0(&eukrea_cpuimx35_i2c0_data); if (otg_mode_host) mxc_register_device(&mxc_otg_host, &otg_pdata); else mxc_register_device(&mxc_otg_udc_device, &otg_device_pdata); mxc_register_device(&mxc_usbh1, &usbh1_pdata); #ifdef CONFIG_MACH_EUKREA_MBIMXSD35_BASEBOARD eukrea_mbimxsd35_baseboard_init(); #endif }
/* * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_iomux_v3_setup_multiple_pads(mx35pdk_pads, ARRAY_SIZE(mx35pdk_pads)); platform_add_devices(devices, ARRAY_SIZE(devices)); imx35_add_imx_uart0(&uart_pdata); imx35_add_imx_uart1(&uart_pdata); imx35_add_imx_uart2(&uart_pdata); imx35_add_spi_imx0(&spi_pdata); imx35_add_spi_imx1(&spi_pdata); mxc_register_device(&mxc_otg_udc_device, &usb_pdata); mxc_register_device(&mxc_nor_mtd_device, &mxc_nor_flash_pdata); mxc_register_nandv2_devices(); i2c_register_board_info(0, mxc_i2c_board_info, ARRAY_SIZE(mxc_i2c_board_info)); imx35_add_imx_i2c0(&i2c_data); mx35_3stack_init_mc13892(); mx35_3stack_init_mc9s08dz60(); imx35_add_imx_mmc0(&mmc1_data); if (mxc_expio_init(CS5_BASE_ADDR, EXPIO_PARENT_INT)) printk(KERN_WARNING "Init of the debugboard failed, all " "devices on the board are unusable.\n"); }
static int __init mxc_init_fb(void) { if (!machine_is_mx53_evk()) return 0; if (primary_di) { printk(KERN_INFO "DI1 is primary\n"); /* DI1 -> DP-BG channel: */ mxc_fb_devices[1].num_resources = ARRAY_SIZE(mxcfb_resources); mxc_fb_devices[1].resource = mxcfb_resources; mxc_register_device(&mxc_fb_devices[1], &fb_data[1]); /* DI0 -> DC channel: */ mxc_register_device(&mxc_fb_devices[0], &fb_data[0]); } else { printk(KERN_INFO "DI0 is primary\n"); /* DI0 -> DP-BG channel: */ mxc_fb_devices[0].num_resources = ARRAY_SIZE(mxcfb_resources); mxc_fb_devices[0].resource = mxcfb_resources; mxc_register_device(&mxc_fb_devices[0], &fb_data[0]); /* DI1 -> DC channel: */ mxc_register_device(&mxc_fb_devices[1], &fb_data[1]); } /* * DI0/1 DP-FG channel: */ mxc_register_device(&mxc_fb_devices[2], NULL); return 0; }
static void __init eukrea_cpuimx25_init(void) { if (mxc_iomux_v3_setup_multiple_pads(eukrea_cpuimx25_pads, ARRAY_SIZE(eukrea_cpuimx25_pads))) printk(KERN_ERR "error setting cpuimx25 pads !\n"); imx25_add_imx_uart0(&uart_pdata); imx25_add_mxc_nand(&eukrea_cpuimx25_nand_board_info); mxc_register_device(&mx25_rtc_device, NULL); mxc_register_device(&mx25_fec_device, &mx25_fec_pdata); i2c_register_board_info(0, eukrea_cpuimx25_i2c_devices, ARRAY_SIZE(eukrea_cpuimx25_i2c_devices)); imx25_add_imx_i2c0(&eukrea_cpuimx25_i2c0_data); #if defined(CONFIG_USB_ULPI) if (otg_mode_host) { otg_pdata.otg = otg_ulpi_create(&mxc_ulpi_access_ops, ULPI_OTG_DRVVBUS | ULPI_OTG_DRVVBUS_EXT); mxc_register_device(&mxc_otg, &otg_pdata); } mxc_register_device(&mxc_usbh2, &usbh2_pdata); #endif if (!otg_mode_host) mxc_register_device(&otg_udc_device, &otg_device_pdata); #ifdef CONFIG_MACH_EUKREA_MBIMXSD25_BASEBOARD eukrea_mbimxsd25_baseboard_init(); #endif }
static void __init mx53_loco_board_init(void) { mx53_loco_io_init(); imx53_add_imx_uart(0, NULL); mx53_loco_fec_reset(); imx53_add_fec(&mx53_loco_fec_data); mxc_register_device(&mxc_pm_device, &loco_pm_data); imx53_add_ipuv3(&ipu_data); imx53_add_vpu(); imx53_add_ldb(&ldb_data); imx53_add_tve(&tve_data); imx53_add_v4l2_output(0); imx53_add_mxc_pwm(1); imx53_add_mxc_pwm_backlight(0, &loco_pwm_backlight_data); imx53_add_imx2_wdt(0, NULL); imx53_add_srtc(); imx53_add_dvfs_core(&loco_dvfs_core_data); imx53_add_busfreq(&loco_bus_freq_data); imx53_add_imx_i2c(0, &mx53_loco_i2c_data); imx53_add_imx_i2c(1, &mx53_loco_i2c_data); mx53_loco_init_da9052(); 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)); imx53_add_sdhci_esdhc_imx(0, &mx53_loco_sd1_data); imx53_add_sdhci_esdhc_imx(2, &mx53_loco_sd3_data); imx53_add_ahci_imx(0, &sata_data); imx53_add_iim(&iim_data); /* USB */ mx5_usb_dr_init(); mx5_set_host1_vbus_func(mx53_loco_usbh1_vbus); mx5_usbh1_init(); mxc_register_device(&loco_audio_device, &loco_audio_data); imx53_add_imx_ssi(1, &loco_ssi_pdata); /*GPU*/ if (mx53_revision() >= IMX_CHIP_REVISION_2_0) gpu_data.z160_revision = 1; else gpu_data.z160_revision = 0; imx53_add_mxc_gpu(&gpu_data); imx_add_gpio_keys(&loco_button_data); /* this call required to release SCC RAM partition held by ROM * during boot, even if SCC2 driver is not part of the image */ imx53_add_mxc_scc2(); pm_power_off = da9053_power_off; }
/* * system init for baseboard usage. Will be called by mx31moboard init. */ void __init mx31moboard_marxbot_init(void) { printk(KERN_INFO "Initializing mx31marxbot peripherals\n"); mxc_iomux_setup_multiple_pins(marxbot_pins, ARRAY_SIZE(marxbot_pins), "marxbot"); marxbot_init_sel_gpios(); dspics_resets_init(); mxc_register_device(&mxcsdhc_device1, &sdhc2_pdata); spi_register_board_info(marxbot_spi_board_info, ARRAY_SIZE(marxbot_spi_board_info)); marxbot_cam_init(); platform_add_devices(marxbot_cameras, ARRAY_SIZE(marxbot_cameras)); /* battery present pin */ gpio_request(IOMUX_TO_GPIO(MX31_PIN_LCS0), "bat-present"); gpio_direction_input(IOMUX_TO_GPIO(MX31_PIN_LCS0)); gpio_export(IOMUX_TO_GPIO(MX31_PIN_LCS0), false); mxc_register_device(&mxc_otg_udc_device, &usb_pdata); marxbot_usbh1_init(); }
static void __init eukrea_cpuimx25_init(void) { if (mxc_iomux_v3_setup_multiple_pads(eukrea_cpuimx25_pads, ARRAY_SIZE(eukrea_cpuimx25_pads))) printk(KERN_ERR "error setting cpuimx25 pads !\n"); imx25_add_imx_uart0(&uart_pdata); imx25_add_mxc_nand(&eukrea_cpuimx25_nand_board_info); mxc_register_device(&mx25_rtc_device, NULL); imx25_add_fec(&mx25_fec_pdata); i2c_register_board_info(0, eukrea_cpuimx25_i2c_devices, ARRAY_SIZE(eukrea_cpuimx25_i2c_devices)); imx25_add_imx_i2c0(&eukrea_cpuimx25_i2c0_data); if (otg_mode_host) mxc_register_device(&mxc_otg, &otg_pdata); else mxc_register_device(&otg_udc_device, &otg_device_pdata); mxc_register_device(&mxc_usbh2, &usbh2_pdata); #ifdef CONFIG_MACH_EUKREA_MBIMXSD25_BASEBOARD eukrea_mbimxsd25_baseboard_init(); #endif }
static void __init eukrea_cpuimx27_init(void) { mxc_gpio_setup_multiple_pins(eukrea_cpuimx27_pins, ARRAY_SIZE(eukrea_cpuimx27_pins), "CPUIMX27"); mxc_register_device(&mxc_uart_device0, &uart_pdata[0]); mxc_register_device(&imx27_nand_device, &eukrea_cpuimx27_nand_board_info); i2c_register_board_info(0, eukrea_cpuimx27_i2c_devices, ARRAY_SIZE(eukrea_cpuimx27_i2c_devices)); mxc_register_device(&mxc_i2c_device0, &eukrea_cpuimx27_i2c_1_data); platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices)); #if defined(CONFIG_MACH_EUKREA_CPUIMX27_USESDHC2) /* SDHC2 can be used for Wifi */ mxc_register_device(&mxc_sdhc_device1, NULL); /* in which case UART4 is also used for Bluetooth */ mxc_register_device(&mxc_uart_device3, &uart_pdata[1]); #endif #if defined(CONFIG_SERIAL_8250) || defined(CONFIG_SERIAL_8250_MODULE) platform_device_register(&serial_device); #endif #ifdef CONFIG_MACH_EUKREA_MBIMX27_BASEBOARD eukrea_mbimx27_baseboard_init(); #endif }
/* * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_iomux_setup_multiple_pins(moboard_pins, ARRAY_SIZE(moboard_pins), "moboard"); platform_add_devices(devices, ARRAY_SIZE(devices)); mxc_register_device(&mxc_uart_device0, &uart_pdata); mxc_register_device(&mxc_uart_device4, &uart_pdata); mxc_register_device(&mxc_i2c_device0, &moboard_i2c0_pdata); mxc_register_device(&mxc_i2c_device1, &moboard_i2c1_pdata); mxc_register_device(&mxcsdhc_device0, &sdhc1_pdata); switch (mx31moboard_baseboard) { case MX31NOBOARD: break; case MX31DEVBOARD: mx31moboard_devboard_init(); break; case MX31MARXBOT: mx31moboard_marxbot_init(); break; default: printk(KERN_ERR "Illegal mx31moboard_baseboard type %d\n", mx31moboard_baseboard); } }
static int __init mxc_init_fb(void) { if (!machine_is_mx51_babbage()) return 0; /* DI0-LVDS */ gpio_set_value(BABBAGE_LVDS_POWER_DOWN, 0); msleep(1); gpio_set_value(BABBAGE_LVDS_POWER_DOWN, 1); gpio_set_value(BABBAGE_LCD_3V3_ON, 1); gpio_set_value(BABBAGE_LCD_5V_ON, 1); /* DVI Detect */ gpio_request(BABBAGE_DVI_DET, "dvi-detect"); gpio_direction_input(BABBAGE_DVI_DET); /* DVI Reset - Assert for i2c disabled mode */ gpio_request(BABBAGE_DVI_RESET, "dvi-reset"); gpio_direction_output(BABBAGE_DVI_RESET, 0); /* DVI Power-down */ gpio_request(BABBAGE_DVI_POWER, "dvi-power"); gpio_direction_output(BABBAGE_DVI_POWER, 1); /* WVGA Reset */ gpio_set_value(BABBAGE_DISP_BRIGHTNESS_CTL, 1); /*for bbg board, set default display as DVI*/ if (primary_di < 0) primary_di = 0; if (primary_di) { printk(KERN_INFO "DI1 is primary\n"); /* DI1 -> DP-BG channel: */ mxc_fb_devices[1].num_resources = ARRAY_SIZE(mxcfb_resources); mxc_fb_devices[1].resource = mxcfb_resources; mxc_register_device(&mxc_fb_devices[1], &fb_data[1]); /* DI0 -> DC channel: */ mxc_register_device(&mxc_fb_devices[0], &fb_data[0]); } else { printk(KERN_INFO "DI0 is primary\n"); /* DI0 -> DP-BG channel: */ mxc_fb_devices[0].num_resources = ARRAY_SIZE(mxcfb_resources); mxc_fb_devices[0].resource = mxcfb_resources; mxc_register_device(&mxc_fb_devices[0], &fb_data[0]); /* DI1 -> DC channel: */ mxc_register_device(&mxc_fb_devices[1], &fb_data[1]); } /* * DI0/1 DP-FG channel: */ mxc_register_device(&mxc_fb_devices[2], NULL); return 0; }
static void __init mx31_3ds_init(void) { int ret; mxc_iomux_setup_multiple_pins(mx31_3ds_pins, ARRAY_SIZE(mx31_3ds_pins), "mx31_3ds"); imx31_add_imx_uart0(&uart_pdata); imx31_add_mxc_nand(&mx31_3ds_nand_board_info); imx31_add_spi_imx1(&spi1_pdata); spi_register_board_info(mx31_3ds_spi_devs, ARRAY_SIZE(mx31_3ds_spi_devs)); platform_add_devices(devices, ARRAY_SIZE(devices)); imx31_add_imx_keypad(&mx31_3ds_keymap_data); mx31_3ds_usbotg_init(); 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(&usbotg_pdata); if (mxc_expio_init(MX31_CS5_BASE_ADDR, EXPIO_PARENT_INT)) printk(KERN_WARNING "Init of the debug board failed, all " "devices on the debug board are unusable.\n"); imx31_add_imx2_wdt(NULL); imx31_add_imx_i2c0(&mx31_3ds_i2c0_data); imx31_add_mxc_mmc(0, &sdhc1_pdata); imx31_add_spi_imx0(&spi0_pdata); mxc_register_device(&mx3_ipu, &mx3_ipu_data); mxc_register_device(&mx3_fb, &mx3fb_pdata); /* CSI */ /* Camera power: default - off */ ret = gpio_request_array(mx31_3ds_camera_gpios, ARRAY_SIZE(mx31_3ds_camera_gpios)); if (ret) { pr_err("Failed to request camera gpios"); iclink_ov2640.power = NULL; } if (!mx31_3ds_camera_alloc_dma()) mxc_register_device(&mx3_camera, &mx31_3ds_camera_pdata); else pr_err("Failed to allocate dma memory for camera"); }
/* * Board init */ static void __init mx1ads_init(void) { /* UART */ mxc_register_device(&imx_uart1_device, &uart_pdata[0]); mxc_register_device(&imx_uart2_device, &uart_pdata[1]); /* Physmap flash */ mxc_register_device(&flash_device, &mx1ads_flash_data); }
static void __init eukrea_cpuimx51sd_init(void) { imx51_soc_init(); mxc_iomux_v3_setup_multiple_pads(eukrea_cpuimx51sd_pads, ARRAY_SIZE(eukrea_cpuimx51sd_pads)); #if defined(CONFIG_CPU_FREQ_IMX) get_cpu_op = mx51_get_cpu_op; #endif imx51_add_imx_uart(0, &uart_pdata); imx51_add_mxc_nand(&eukrea_cpuimx51sd_nand_board_info); gpio_request(ETH_RST, "eth_rst"); gpio_set_value(ETH_RST, 1); imx51_add_fec(NULL); gpio_request(CAN_IRQGPIO, "can_irq"); gpio_direction_input(CAN_IRQGPIO); gpio_free(CAN_IRQGPIO); gpio_request(CAN_NCS, "can_ncs"); gpio_direction_output(CAN_NCS, 1); gpio_free(CAN_NCS); gpio_request(CAN_RST, "can_rst"); gpio_direction_output(CAN_RST, 0); msleep(20); gpio_set_value(CAN_RST, 1); imx51_add_ecspi(0, &cpuimx51sd_ecspi1_pdata); spi_register_board_info(cpuimx51sd_spi_device, ARRAY_SIZE(cpuimx51sd_spi_device)); gpio_request(TSC2007_IRQGPIO, "tsc2007_irq"); gpio_direction_input(TSC2007_IRQGPIO); gpio_free(TSC2007_IRQGPIO); i2c_register_board_info(0, eukrea_cpuimx51sd_i2c_devices, ARRAY_SIZE(eukrea_cpuimx51sd_i2c_devices)); platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices)); if (otg_mode_host) mxc_register_device(&mxc_usbdr_host_device, &dr_utmi_config); else { initialize_otg_port(NULL); mxc_register_device(&mxc_usbdr_udc_device, &usb_pdata); } gpio_request(USBH1_RST, "usb_rst"); gpio_direction_output(USBH1_RST, 0); msleep(20); gpio_set_value(USBH1_RST, 1); mxc_register_device(&mxc_usbh1_device, &usbh1_config); #ifdef CONFIG_MACH_EUKREA_MBIMXSD51_BASEBOARD eukrea_mbimxsd51_baseboard_init(); #endif }
void __init mx51_efikamx_init_leds(void) { if (machine_is_mx51_efikamx()) { CONFIG_IOMUX(mx51_efikamx_led_iomux_pins); /* Request each color and set a default output. Since Green is our power light by default, turn it on. Since Red & Blue are disk activity, turn them off (the trigger will activate it) */ gpio_request(IOMUX_TO_GPIO(EFIKAMX_BLUE_LED), "blue_led"); gpio_direction_output(IOMUX_TO_GPIO(EFIKAMX_BLUE_LED), 0); gpio_free(IOMUX_TO_GPIO(EFIKAMX_BLUE_LED)); gpio_request(IOMUX_TO_GPIO(EFIKAMX_GREEN_LED), "green_led"); gpio_direction_output(IOMUX_TO_GPIO(EFIKAMX_GREEN_LED), 1); gpio_free(IOMUX_TO_GPIO(EFIKAMX_GREEN_LED)); gpio_request(IOMUX_TO_GPIO(EFIKAMX_RED_LED), "red_led"); gpio_direction_output(IOMUX_TO_GPIO(EFIKAMX_RED_LED), 0); gpio_free(IOMUX_TO_GPIO(EFIKAMX_RED_LED)); if (mx51_efikamx_revision() >= 2) { /* on 1.2 and above there is no second SD controller, * so the previous external "mmc1" is not valid anymore. * change the trigger to mmc0 to activate the LED for * the external slot for the newer boards */ mx51_efikamx_leds[2].default_trigger = "mmc0"; } (void)platform_device_register(&mx51_efikamx_leds_device); } else { CONFIG_IOMUX(mx51_efikasb_led_iomux_pins); gpio_request(IOMUX_TO_GPIO(EFIKASB_CAPSLOCK_LED), "led:capslock"); gpio_direction_output(IOMUX_TO_GPIO(EFIKASB_CAPSLOCK_LED), 0); gpio_free(IOMUX_TO_GPIO(EFIKASB_CAPSLOCK_LED)); gpio_request(IOMUX_TO_GPIO(EFIKASB_ALARM_LED), "led:alarm"); gpio_direction_output(IOMUX_TO_GPIO(EFIKASB_ALARM_LED), 1); gpio_free(IOMUX_TO_GPIO(EFIKASB_ALARM_LED)); gpio_request(IOMUX_TO_GPIO(EFIKASB_PWM_BACKLIGHT_EN), "backlight:en#"); gpio_direction_output(IOMUX_TO_GPIO(EFIKASB_PWM_BACKLIGHT_EN), 0); mxc_register_device(&mxc_pwm1_device, NULL); #if defined(CONFIG_BACKLIGHT_PWM) mxc_register_device(&mxc_pwm_backlight_device, &mx51_efikasb_backlight_data); #elif defined(CONFIG_LEDS_PWM) (void)platform_device_register(&mx51_efikasb_backlight_device); #endif (void)platform_device_register(&mx51_efikasb_leds_device); } }
/* * system init for baseboard usage. Will be called by pcm038 init. * * Add platform devices present on this baseboard and init * them from CPU side as far as required to use them later on */ void __init pcm970_baseboard_init(void) { mxc_gpio_setup_multiple_pins(pcm970_pins, ARRAY_SIZE(pcm970_pins), "PCM970"); mxc_register_device(&mxc_fb_device, &pcm038_fb_data); mxc_register_device(&mxc_sdhc_device1, &sdhc_pdata); platform_device_register(&pcm970_sja1000); }
static int __init mxc_init_fb(void) { if (!machine_is_mx51_babbage()) return 0; /* DI0-LVDS */ gpio_set_value(IOMUX_TO_GPIO(MX51_PIN_DI1_D0_CS), 0); msleep(1); gpio_set_value(IOMUX_TO_GPIO(MX51_PIN_DI1_D0_CS), 1); gpio_set_value(IOMUX_TO_GPIO(MX51_PIN_CSI2_D12), 1); gpio_set_value(IOMUX_TO_GPIO(MX51_PIN_CSI2_D13), 1); /* DVI Detect */ gpio_request(IOMUX_TO_GPIO(MX51_PIN_NANDF_D12), "nandf_d12"); gpio_direction_input(IOMUX_TO_GPIO(MX51_PIN_NANDF_D12)); /* DVI Reset - Assert for i2c disabled mode */ gpio_request(IOMUX_TO_GPIO(MX51_PIN_DISPB2_SER_DIN), "dispb2_ser_din"); gpio_set_value(IOMUX_TO_GPIO(MX51_PIN_DISPB2_SER_DIN), 0); gpio_direction_output(IOMUX_TO_GPIO(MX51_PIN_DISPB2_SER_DIN), 0); /* DVI Power-down */ gpio_request(IOMUX_TO_GPIO(MX51_PIN_DISPB2_SER_DIO), "dispb2_ser_di0"); gpio_set_value(IOMUX_TO_GPIO(MX51_PIN_DISPB2_SER_DIO), 1); gpio_direction_output(IOMUX_TO_GPIO(MX51_PIN_DISPB2_SER_DIO), 0); /* WVGA Reset */ gpio_set_value(IOMUX_TO_GPIO(MX51_PIN_DI1_D1_CS), 1); if (primary_di) { printk(KERN_INFO "DI1 is primary\n"); /* DI1 -> DP-BG channel: */ mxc_fb_devices[1].num_resources = ARRAY_SIZE(mxcfb_resources); mxc_fb_devices[1].resource = mxcfb_resources; mxc_register_device(&mxc_fb_devices[1], &fb_data[1]); /* DI0 -> DC channel: */ mxc_register_device(&mxc_fb_devices[0], &fb_data[0]); } else { printk(KERN_INFO "DI0 is primary\n"); /* DI0 -> DP-BG channel: */ mxc_fb_devices[0].num_resources = ARRAY_SIZE(mxcfb_resources); mxc_fb_devices[0].resource = mxcfb_resources; mxc_register_device(&mxc_fb_devices[0], &fb_data[0]); /* DI1 -> DC channel: */ mxc_register_device(&mxc_fb_devices[1], &fb_data[1]); } /* * DI0/1 DP-FG channel: */ mxc_register_device(&mxc_fb_devices[2], NULL); return 0; }
static void __init vp6500_board_init(void) { mxc_gpio_setup_multiple_pins(vp6500_pins, ARRAY_SIZE(vp6500_pins), "vp6500"); mxc_register_device(&mxc_uart_device0, NULL); mxc_register_device(&mxc_pwm_device, NULL); platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices)); }
static void lilly1131_usb_init(void) { usbotg_pdata.otg = otg_ulpi_create(&mxc_ulpi_access_ops, USB_OTG_DRV_VBUS | USB_OTG_DRV_VBUS_EXT); usbh2_pdata.otg = otg_ulpi_create(&mxc_ulpi_access_ops, USB_OTG_DRV_VBUS | USB_OTG_DRV_VBUS_EXT); mxc_register_device(&mxc_usbh1, &usbh1_pdata); mxc_register_device(&mxc_usbh2, &usbh2_pdata); }
void __init mx5_usbh2_init(void) { if (cpu_is_mx53() || cpu_is_mx50()) { mxc_usbh2_device.resource[0].start -= MX53_OFFSET; mxc_usbh2_device.resource[0].end -= MX53_OFFSET; } usbh2_config.wakeup_pdata = &usbh2_wakeup_config; mxc_register_device(&mxc_usbh2_device, &usbh2_config); mxc_register_device(&mxc_usbh2_wakeup_device, &usbh2_wakeup_config); }
void __init mx31lite_db_init(void) { mxc_iomux_setup_multiple_pins(litekit_db_board_pins, ARRAY_SIZE(litekit_db_board_pins), "development board pins"); mxc_register_device(&mxc_uart_device0, &uart_pdata); mxc_register_device(&mxcsdhc_device0, &mmc_pdata); mxc_register_device(&mxc_spi_device0, &spi0_pdata); platform_device_register(&litekit_led_device); }
void __init mx31lilly_db_init(void) { mxc_iomux_setup_multiple_pins(lilly_db_board_pins, ARRAY_SIZE(lilly_db_board_pins), "development board pins"); mxc_register_device(&mxc_uart_device0, &uart_pdata); mxc_register_device(&mxc_uart_device1, &uart_pdata); mxc_register_device(&mxc_uart_device2, &uart_pdata); mxc_register_device(&mxcsdhc_device0, &mmc_pdata); mx31lilly_init_fb(); }
static void __init mx31lilly_init_fb(void) { if (gpio_request(LCD_VCC_EN_GPIO, "LCD enable") != 0) { printk(KERN_WARNING "unable to request LCD_VCC_EN pin.\n"); return; } mxc_register_device(&mx3_ipu, &ipu_data); mxc_register_device(&mx3_fb, &fb_pdata); gpio_direction_output(LCD_VCC_EN_GPIO, 1); }
void __init mx5_usbh1_init(void) { if (cpu_is_mx51()) { usbh1_config.phy_mode = FSL_USB2_PHY_ULPI; usbh1_config.transceiver = "isp1504"; usbh1_config.gpio_usb_active = gpio_usbh1_active; usbh1_config.gpio_usb_inactive = gpio_usbh1_inactive; } mxc_register_device(&mxc_usbh1_device, &usbh1_config); usbh1_config.wakeup_pdata = &usbh1_wakeup_config; mxc_register_device(&mxc_usbh1_wakeup_device, &usbh1_wakeup_config); }
/* * system init for baseboard usage. Will be called by mx31moboard init. */ void __init mx31moboard_devboard_init(void) { printk(KERN_INFO "Initializing mx31devboard peripherals\n"); mxc_iomux_setup_multiple_pins(devboard_pins, ARRAY_SIZE(devboard_pins), "devboard"); mxc_register_device(&mxc_uart_device1, &uart_pdata); mxc_register_device(&mxcsdhc_device1, &sdhc2_pdata); devboard_usbh1_init(); }
/* * Board specific initialization. */ static void __init mx51_babbage_init(void) { iomux_v3_cfg_t usbh1stp = MX51_PAD_USBH1_STP__USBH1_STP; iomux_v3_cfg_t power_key = _MX51_PAD_EIM_A27__GPIO2_21 | MUX_PAD_CTRL(PAD_CTL_SRE_FAST | PAD_CTL_DSE_HIGH | PAD_CTL_PUS_100K_UP); imx51_soc_init(); #if defined(CONFIG_CPU_FREQ_IMX) get_cpu_op = mx51_get_cpu_op; #endif mxc_iomux_v3_setup_multiple_pads(mx51babbage_pads, ARRAY_SIZE(mx51babbage_pads)); imx51_add_imx_uart(0, &uart_pdata); imx51_add_imx_uart(1, NULL); imx51_add_imx_uart(2, &uart_pdata); babbage_fec_reset(); imx51_add_fec(NULL); /* Set the PAD settings for the pwr key. */ mxc_iomux_v3_setup_pad(power_key); imx_add_gpio_keys(&imx_button_data); imx51_add_imx_i2c(0, &babbage_i2c_data); imx51_add_imx_i2c(1, &babbage_i2c_data); mxc_register_device(&mxc_hsi2c_device, &babbage_hsi2c_data); if (otg_mode_host) mxc_register_device(&mxc_usbdr_host_device, &dr_utmi_config); else { initialize_otg_port(NULL); mxc_register_device(&mxc_usbdr_udc_device, &usb_pdata); } gpio_usbh1_active(); mxc_register_device(&mxc_usbh1_device, &usbh1_config); /* setback USBH1_STP to be function */ mxc_iomux_v3_setup_pad(usbh1stp); babbage_usbhub_reset(); imx51_add_sdhci_esdhc_imx(0, &mx51_babbage_sd1_data); imx51_add_sdhci_esdhc_imx(1, &mx51_babbage_sd2_data); spi_register_board_info(mx51_babbage_spi_board_info, ARRAY_SIZE(mx51_babbage_spi_board_info)); imx51_add_ecspi(0, &mx51_babbage_spi_pdata); imx51_add_imx2_wdt(0, NULL); }
/* * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_iomux_setup_multiple_pins(moboard_pins, ARRAY_SIZE(moboard_pins), "moboard"); platform_add_devices(devices, ARRAY_SIZE(devices)); mxc_register_device(&mxc_uart_device0, &uart0_pdata); mxc_register_device(&mxc_uart_device4, &uart4_pdata); mx31moboard_init_sel_gpios(); mxc_register_device(&mxc_i2c_device0, &moboard_i2c0_pdata); mxc_register_device(&mxc_i2c_device1, &moboard_i2c1_pdata); mxc_register_device(&mxc_spi_device1, &moboard_spi1_master); mxc_register_device(&mxc_spi_device2, &moboard_spi2_master); gpio_request(IOMUX_TO_GPIO(MX31_PIN_GPIO1_3), "pmic-irq"); gpio_direction_input(IOMUX_TO_GPIO(MX31_PIN_GPIO1_3)); spi_register_board_info(moboard_spi_board_info, ARRAY_SIZE(moboard_spi_board_info)); mxc_register_device(&mxcsdhc_device0, &sdhc1_pdata); mxc_register_device(&mx3_ipu, &mx3_ipu_data); if (!mx31moboard_cam_alloc_dma(CAMERA_BUF_SIZE)) mxc_register_device(&mx3_camera, &camera_pdata); usb_xcvr_reset(); moboard_usbotg_init(); mxc_register_device(&mxc_otg_udc_device, &usb_pdata); moboard_usbh2_init(); switch (mx31moboard_baseboard) { case MX31NOBOARD: break; case MX31DEVBOARD: mx31moboard_devboard_init(); break; case MX31MARXBOT: mx31moboard_marxbot_init(); break; default: printk(KERN_ERR "Illegal mx31moboard_baseboard type %d\n", mx31moboard_baseboard); } }
static void __init mx21ads_board_init(void) { mxc_gpio_setup_multiple_pins(mx21ads_pins, ARRAY_SIZE(mx21ads_pins), "mx21ads"); imx21_add_imx_uart0(&uart_pdata_rts); imx21_add_imx_uart2(&uart_pdata_norts); imx21_add_imx_uart3(&uart_pdata_rts); mxc_register_device(&mxc_fb_device, &mx21ads_fb_data); mxc_register_device(&mxc_sdhc_device0, &mx21ads_sdhc_pdata); imx21_add_mxc_nand(&mx21ads_nand_board_info); platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices)); }
/* * Board specific initialization. */ static void __init mxc_board_init(void) { mxc_iomux_v3_setup_multiple_pads(mx35pdk_pads, ARRAY_SIZE(mx35pdk_pads)); imx35_add_fec(NULL); platform_add_devices(devices, ARRAY_SIZE(devices)); imx35_add_imx_uart0(&uart_pdata); mxc_register_device(&mxc_otg_udc_device, &usb_otg_pdata); mxc_register_device(&mxc_usbh1, &usb_host_pdata); imx35_add_mxc_nand(&mx35pdk_nand_board_info); }
/* * system init for baseboard usage. Will be called by cpuimx35 init. * * Add platform devices present on this baseboard and init * them from CPU side as far as required to use them later on */ void __init eukrea_mbimxsd35_baseboard_init(void) { if (mxc_iomux_v3_setup_multiple_pads(eukrea_mbimxsd_pads, ARRAY_SIZE(eukrea_mbimxsd_pads))) printk(KERN_ERR "error setting mbimxsd pads !\n"); #if defined(CONFIG_SND_SOC_EUKREA_TLV320) /* SSI unit master I2S codec connected to SSI_AUD4 */ mxc_audmux_v2_configure_port(0, MXC_AUDMUX_V2_PTCR_SYN | MXC_AUDMUX_V2_PTCR_TFSDIR | MXC_AUDMUX_V2_PTCR_TFSEL(3) | MXC_AUDMUX_V2_PTCR_TCLKDIR | MXC_AUDMUX_V2_PTCR_TCSEL(3), MXC_AUDMUX_V2_PDCR_RXDSEL(3) ); mxc_audmux_v2_configure_port(3, MXC_AUDMUX_V2_PTCR_SYN, MXC_AUDMUX_V2_PDCR_RXDSEL(0) ); #endif imx35_add_imx_uart1(&uart_pdata); mxc_register_device(&mx3_ipu, &mx3_ipu_data); mxc_register_device(&mx3_fb, &mx3fb_pdata); imx35_add_imx_ssi(0, &eukrea_mbimxsd_ssi_pdata); imx35_add_flexcan1(NULL); imx35_add_sdhci_esdhc_imx(0, NULL); gpio_request(GPIO_LED1, "LED1"); gpio_direction_output(GPIO_LED1, 1); gpio_free(GPIO_LED1); gpio_request(GPIO_SWITCH1, "SWITCH1"); gpio_direction_input(GPIO_SWITCH1); gpio_free(GPIO_SWITCH1); gpio_request(GPIO_LCDPWR, "LCDPWR"); gpio_direction_output(GPIO_LCDPWR, 1); gpio_free(GPIO_LCDPWR); i2c_register_board_info(0, eukrea_mbimxsd_i2c_devices, ARRAY_SIZE(eukrea_mbimxsd_i2c_devices)); platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices)); }