/*! * Invert the IOMUX/GPIO for SDHC1 SD1_DET. * * @param flag Flag represents whether the card is inserted/removed. * Using this sensitive level of GPIO signal is changed. * **/ void sdhc_intr_clear(int flag) { if (flag) { set_irq_type(IOMUX_TO_IRQ(PIN_GPIO37), IRQT_FALLING); } else { set_irq_type(IOMUX_TO_IRQ(PIN_GPIO37), IRQT_RISING); } }
/*! * Invert the IOMUX/GPIO for SDHC1 SD1_DET. * * @param flag Flag represents whether the mmc card is inserted/removed. * Using this sensitive level of GPIO signal is changed. * **/ void sdhc_intr_clear(int flag) { if (flag) { set_irq_type(IOMUX_TO_IRQ(SP_SD2_DAT1), IRQT_FALLING); } else { set_irq_type(IOMUX_TO_IRQ(SP_SD2_DAT1), IRQT_RISING); } }
static int mx31_3ds_sdhc1_init(struct device *dev, irq_handler_t detect_irq, void *data) { int ret; ret = gpio_request_array(mx31_3ds_sdhc1_gpios, ARRAY_SIZE(mx31_3ds_sdhc1_gpios)); if (ret) { pr_warning("Unable to request the SD/MMC GPIOs.\n"); return ret; } ret = request_irq(IOMUX_TO_IRQ(MX31_PIN_GPIO3_1), detect_irq, IRQF_DISABLED | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "sdhc1-detect", data); if (ret) { pr_warning("Unable to request the SD/MMC card-detect IRQ.\n"); goto gpio_free; } return 0; gpio_free: gpio_free_array(mx31_3ds_sdhc1_gpios, ARRAY_SIZE(mx31_3ds_sdhc1_gpios)); return ret; }
static int pcm970_sdhc1_init(struct device *dev, irq_handler_t detect_irq, void *data) { int ret; ret = gpio_request(SDHC1_GPIO_DET, "sdhc-detect"); if (ret) return ret; gpio_direction_input(SDHC1_GPIO_DET); #ifdef PCM970_SDHC_RW_SWITCH ret = gpio_request(SDHC1_GPIO_WP, "sdhc-wp"); if (ret) goto err_gpio_free; gpio_direction_input(SDHC1_GPIO_WP); #endif ret = request_irq(IOMUX_TO_IRQ(MX31_PIN_SCK6), detect_irq, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "sdhc-detect", data); if (ret) goto err_gpio_free_2; return 0; err_gpio_free_2: #ifdef PCM970_SDHC_RW_SWITCH gpio_free(SDHC1_GPIO_WP); err_gpio_free: #endif gpio_free(SDHC1_GPIO_DET); return ret; }
static int mxc_mmc1_init(struct device *dev, irq_handler_t detect_irq, void *data) { int ret; gpio_det = IOMUX_TO_GPIO(MX31_PIN_GPIO1_1); gpio_wp = IOMUX_TO_GPIO(MX31_PIN_LCS0); ret = gpio_request(gpio_det, "MMC detect"); if (ret) return ret; ret = gpio_request(gpio_wp, "MMC w/p"); if (ret) goto exit_free_det; gpio_direction_input(gpio_det); gpio_direction_input(gpio_wp); ret = request_irq(IOMUX_TO_IRQ(MX31_PIN_GPIO1_1), detect_irq, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "MMC detect", data); if (ret) goto exit_free_wp; return 0; exit_free_wp: gpio_free(gpio_wp); exit_free_det: gpio_free(gpio_det); return ret; }
/* * Return the card detect pin. */ int sdhc_init_card_det(int id) { if (id == 0) { /* CD Pin */ mxc_request_iomux(MX31_PIN_STX0, OUTPUTCONFIG_GPIO, INPUTCONFIG_GPIO); mxc_iomux_set_pad(MX31_PIN_STX0, PAD_CTL_PKE_NONE); mxc_set_gpio_direction(MX31_PIN_STX0, 1); return IOMUX_TO_IRQ(MX31_PIN_STX0); } else { mxc_request_iomux(MX31_PIN_DSR_DCE1, OUTPUTCONFIG_GPIO, INPUTCONFIG_GPIO); mxc_iomux_set_pad(MX31_PIN_DSR_DCE1, PAD_CTL_PKE_NONE); mxc_set_gpio_direction(MX31_PIN_DSR_DCE1, 1); return IOMUX_TO_IRQ(MX31_PIN_DSR_DCE1); } }
/*! * zasevb_isp1301_bh()- call isp1301 bottom half handler * @param arg * This is a wrapper to the isp1301 bottom half handler, it * re-enables the gpio interrupt after processing complete. */ void *zasevb_isp1301_bh(void *arg) { TRACE_MSG0(REMOVE_TCD, "ZASEVB GPIO INTERRUPT: ISP1301_BH"); isp1301_bh(arg); TRACE_MSG0(REMOVE_TCD, "ZASEVB GPIO INTERRUPT: REENABLE"); if (zasevb_int_disabled) { zasevb_int_disabled = FALSE; enable_irq(IOMUX_TO_IRQ(PIN_GPIO2)); } return 0; }
int mxc_iomux_gpio_isp1301_set (struct otg_instance *otg, int usb_mode) { int gpio = 1; printk (KERN_INFO"MXC gpio setting for isp1301\n"); isp1301_mod_init(otg, &zasevb_isp1301_bh); TRACE_MSG0(otg->tcd->TAG, "5. IOMUX and GPIO Interrupt Configuration"); iomux_config_mux(PIN_GPIO2, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); //Setting interrupt for ISP1301 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) set_irq_type(IOMUX_TO_IRQ(PIN_GPIO2), IRQF_TRIGGER_FALLING); #else set_irq_type(IOMUX_TO_IRQ(PIN_GPIO2), IRQT_FALLING); #endif gpio = request_irq(IOMUX_TO_IRQ(PIN_GPIO2), zasevb_gpio_int_hndlr, 0, "ISP1301", (void *)&ocd_ops); THROW_IF(gpio, error); iomux_config_mux(PIN_USB_XRXD, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); iomux_config_mux(PIN_USB_VMOUT, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); iomux_config_mux(PIN_USB_VPOUT, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); iomux_config_mux(PIN_USB_VPIN, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); iomux_config_mux(PIN_USB_TXENB, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); iomux_config_mux(PIN_USB_VMIN, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); CATCH(error) { printk(KERN_INFO"%s: failed\n", __FUNCTION__); UNLESS (gpio) gpio_free_irq (ZGPIO_PORT, ZGPIO_PIN, GPIO_HIGH_PRIO); return -EINVAL; } return 0; }
/*! * Power Key initialization. */ static int __init mxc_init_power_key(void) { /* Set power key as wakeup resource */ int irq, ret; irq = IOMUX_TO_IRQ(MX51_PIN_EIM_A27); set_irq_type(irq, IRQF_TRIGGER_RISING); ret = request_irq(irq, power_key_int, 0, "power_key", 0); if (ret) pr_info("register on-off key interrupt failed\n"); else enable_irq_wake(irq); return ret; }
static int __init mxc_expio_init(void) { int i; mx35_3stack_board_io = (u32) ioremap(BOARD_IO_ADDR, SZ_4K); if (mx35_3stack_board_io == 0) return -ENOMEM; if ((__raw_readw(mx35_3stack_board_io + MAGIC_NUMBER1_REG) != 0xAAAA) || (__raw_readw(mx35_3stack_board_io + MAGIC_NUMBER2_REG) != 0x5555)) return -ENODEV; pr_info("3-Stack Debug board detected, rev = 0x%04X\n", readw(mx35_3stack_board_io + CPLD_CODE_VER_REG)); /* * Configure INT line as GPIO input */ mxc_request_iomux(EXPIO_PARENT_INT, MUX_CONFIG_FUNC); gpio_request(IOMUX_TO_GPIO(EXPIO_PARENT_INT), NULL); gpio_direction_input(IOMUX_TO_GPIO(EXPIO_PARENT_INT)); /* disable the interrupt and clear the status */ __raw_writew(0, mx35_3stack_board_io + INTR_MASK_REG); __raw_writew(0xFFFF, mx35_3stack_board_io + INTR_RESET_REG); __raw_writew(0, mx35_3stack_board_io + INTR_RESET_REG); __raw_writew(0x1F, mx35_3stack_board_io + INTR_MASK_REG); for (i = MXC_BOARD_IRQ_START; i < (MXC_BOARD_IRQ_START + MXC_BOARD_IRQS); i++) { set_irq_chip(i, &expio_irq_chip); set_irq_handler(i, handle_level_irq); set_irq_flags(i, IRQF_VALID); } set_irq_type(IOMUX_TO_IRQ(EXPIO_PARENT_INT), IRQF_TRIGGER_LOW); set_irq_chained_handler(IOMUX_TO_IRQ(EXPIO_PARENT_INT), mxc_expio_irq_handler); return 0; }
int volume_get_irq(int line_direction) { iomux_pin_name_t gpio; int err = -1; switch (line_direction) { case 0: gpio = VOLUME_UP_gpio; break; case 1: gpio = VOLUME_DOWN_gpio; break; default: return err; } return IOMUX_TO_IRQ(gpio); }
/*! * Setup the IOMUX/GPIO for SDHC1 SD1_DET. * * @param host Pointer to MMC/SD host structure. * @param handler GPIO ISR function pointer for the GPIO signal. * @return The function returns 0 on success and -1 on failure. * **/ int sdhc_intr_setup(void *host, irqreturn_t(*handler) (int, void *, struct pt_regs *)) { int ret; /* MMC1_SDDET is connected to GPIO37 */ iomux_config_mux(PIN_GPIO37, OUTPUTCONFIG_FUNC, INPUTCONFIG_FUNC); /* check if a card in the slot if so we need to start with * the proper edge definition */ sdhc_intr_clear(sdhc_find_card()); ret = request_irq(IOMUX_TO_IRQ(PIN_GPIO37), handler, 0, "MXCMMC", host); return ret; }
static int mxc_mmc1_init(struct device *dev, irq_handler_t detect_irq, void *data) { int ret; gpio_det = IOMUX_TO_GPIO(MX31_PIN_DCD_DCE1); gpio_wp = IOMUX_TO_GPIO(MX31_PIN_GPIO1_6); mxc_iomux_set_pad(MX31_PIN_SD1_DATA0, MMC_PAD_CFG | PAD_CTL_PUE_PUD | PAD_CTL_100K_PU); mxc_iomux_set_pad(MX31_PIN_SD1_DATA1, MMC_PAD_CFG | PAD_CTL_PUE_PUD | PAD_CTL_100K_PU); mxc_iomux_set_pad(MX31_PIN_SD1_DATA2, MMC_PAD_CFG | PAD_CTL_PUE_PUD | PAD_CTL_100K_PU); mxc_iomux_set_pad(MX31_PIN_SD1_DATA3, MMC_PAD_CFG | PAD_CTL_PUE_PUD | PAD_CTL_100K_PU); mxc_iomux_set_pad(MX31_PIN_SD1_CMD, MMC_PAD_CFG | PAD_CTL_PUE_PUD | PAD_CTL_100K_PU); mxc_iomux_set_pad(MX31_PIN_SD1_CLK, MMC_PAD_CFG); ret = gpio_request(gpio_det, "MMC detect"); if (ret) return ret; ret = gpio_request(gpio_wp, "MMC w/p"); if (ret) goto exit_free_det; gpio_direction_input(gpio_det); gpio_direction_input(gpio_wp); ret = request_irq(IOMUX_TO_IRQ(MX31_PIN_DCD_DCE1), detect_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "MMC detect", data); if (ret) goto exit_free_wp; return 0; exit_free_wp: gpio_free(gpio_wp); exit_free_det: gpio_free(gpio_det); return ret; }
/*! * Setup the IOMUX/GPIO for SDHC1 SD1_DET. * * @param host Pointer to MMC/SD host structure. * @param handler GPIO ISR function pointer for the GPIO signal. * @return The function returns 0 on success and -1 on failure. * **/ int sdhc_intr_setup(void *host, irqreturn_t(*handler) (int, void *, struct pt_regs *)) { int ret; /* use SD2_DAT1 as GPIO for SD1_DET */ iomux_config_mux(SP_SD2_DAT1, OUTPUTCONFIG_DEFAULT, INPUTCONFIG_DEFAULT); /* check if a card in the slot if so we need to start with * the proper edge definition */ sdhc_intr_clear(sdhc_find_card()); ret = request_irq(IOMUX_TO_IRQ(SP_SD2_DAT1), handler, 0, "MXCMMC", host); return ret; }
static int __devexit imx_wm1808_audio_remove(struct platform_device *pdev) { struct snd_soc_machine **machine = platform_get_drvdata(pdev); struct snd_soc_codec *codec; struct snd_soc_pcm_link *pcm_link; pcm_link = list_first_entry(&(*machine)->active_list, struct snd_soc_pcm_link, active_list); codec = pcm_link->codec; codec->ops->io_remove(codec, *machine); free_irq(IOMUX_TO_IRQ(MX37_PIN_CSPI1_SS1), 0); snd_soc_machine_free(*machine); return 0; }
/* * Return the card detect pin. */ int sdhc_init_card_det(int id) { #if defined(GPIO_SDHC_ENABLE) if (id == 0) { int ret = 0; mxc_request_iomux(MX37_PIN_UART1_CTS, IOMUX_CONFIG_ALT4); mxc_iomux_set_pad(MX37_PIN_UART1_CTS, PAD_CTL_DRV_HIGH | PAD_CTL_HYS_NONE | PAD_CTL_PKE_NONE | PAD_CTL_SRE_FAST); mxc_set_gpio_direction(MX37_PIN_UART1_CTS, 1); pr_info("[Henry/0206] SD detect pin initialized!!\n"); ret = IOMUX_TO_IRQ(MX37_PIN_UART1_CTS); mxc_free_iomux(MX37_PIN_UART1_CTS, IOMUX_CONFIG_ALT4); return ret; } else { /* config the det pin for SDHC2 */ return 0; } #endif }
int fiveway_get_irq(int line_direction) { iomux_pin_name_t gpio; int err = -1; switch (line_direction) { case 0: gpio = FIVEWAY_up_gpio; break; case 1: gpio = FIVEWAY_down_gpio; break; case 2: gpio = FIVEWAY_left_gpio; break; case 3: gpio = FIVEWAY_right_gpio; break; case 4: gpio = FIVEWAY_select_gpio; break; default: return err; } return IOMUX_TO_IRQ(gpio); }
/*! * Power Key initialization. */ static int __init mxc_init_power_key(void) { /*Set power key as wakeup resource */ int irq, ret; mxc_request_iomux(MX25_PIN_A25, MUX_CONFIG_ALT5); mxc_iomux_set_pad(MX25_PIN_A25, PAD_CTL_DRV_NORMAL); gpio_request(IOMUX_TO_GPIO(MX25_PIN_A25), NULL); gpio_direction_input(IOMUX_TO_GPIO(MX25_PIN_A25)); irq = IOMUX_TO_IRQ(MX25_PIN_A25); set_irq_type(irq, IRQF_TRIGGER_RISING); ret = request_irq(irq, power_key_int, 0, "power_key", 0); if (ret) pr_info("register on-off key interrupt failed\n"); else enable_irq_wake(irq); return ret; }
static int armadillo5x0_sdhc1_init(struct device *dev, irq_handler_t detect_irq, void *data) { int ret; int gpio_det, gpio_wp; gpio_det = IOMUX_TO_GPIO(MX31_PIN_ATA_DMACK); gpio_wp = IOMUX_TO_GPIO(MX31_PIN_ATA_RESET_B); ret = gpio_request(gpio_det, "sdhc-card-detect"); if (ret) return ret; gpio_direction_input(gpio_det); ret = gpio_request(gpio_wp, "sdhc-write-protect"); if (ret) goto err_gpio_free; gpio_direction_input(gpio_wp); /* When supported the trigger type have to be BOTH */ ret = request_irq(IOMUX_TO_IRQ(MX31_PIN_ATA_DMACK), detect_irq, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "sdhc-detect", data); if (ret) goto err_gpio_free_2; return 0; err_gpio_free_2: gpio_free(gpio_wp); err_gpio_free: gpio_free(gpio_det); return ret; }
/*! * Get irq for gpio pins * @param pin GPIO pin name * @param trigger_flag [out] The initial trigger flag. * @return The irq associated with gpio pin. */ u32 get_gpio_irq(iomux_pin_name_t pin, unsigned long* trigger_flag) { int val; mxc_request_iomux(pin, OUTPUTCONFIG_GPIO, INPUTCONFIG_GPIO); if ((pin != MX31_PIN_DTR_DCE1) && (pin != MX31_PIN_KEY_ROW4)) mxc_iomux_set_pad(pin, PAD_CTL_PKE_NONE); mxc_set_gpio_direction(pin, 1); val = mxc_get_gpio_datain(pin); if (val == 0) { // Now the gpio pin is in low electrical level, should be trigger by high *trigger_flag = IRQF_TRIGGER_RISING; } else { // Now the gpio pin is in high electrical level, should be trigger by low *trigger_flag = IRQF_TRIGGER_FALLING; } return IOMUX_TO_IRQ(pin); }
static void pcm970_sdhc1_exit(struct device *dev, void *data) { free_irq(IOMUX_TO_IRQ(MX31_PIN_SCK6), data); gpio_free(SDHC1_GPIO_DET); gpio_free(SDHC1_GPIO_WP); }
}, .resource = &pcm037_flash_resource, .num_resources = 1, }; static const struct imxuart_platform_data uart_pdata __initconst = { .flags = IMXUART_HAVE_RTSCTS, }; static struct resource smsc911x_resources[] = { { .start = MX31_CS1_BASE_ADDR + 0x300, .end = MX31_CS1_BASE_ADDR + 0x300 + SZ_64K - 1, .flags = IORESOURCE_MEM, }, { .start = IOMUX_TO_IRQ(MX31_PIN_GPIO3_1), .end = IOMUX_TO_IRQ(MX31_PIN_GPIO3_1), .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL, }, }; static struct smsc911x_platform_config smsc911x_info = { .flags = SMSC911X_USE_32BIT | SMSC911X_FORCE_INTERNAL_PHY | SMSC911X_SAVE_MAC_ADDRESS, .irq_polarity = SMSC911X_IRQ_POLARITY_ACTIVE_LOW, .irq_type = SMSC911X_IRQ_TYPE_OPEN_DRAIN, .phy_interface = PHY_INTERFACE_MODE_MII, }; static struct platform_device pcm037_eth = { .name = "smsc911x",
static void mx31_3ds_sdhc1_exit(struct device *dev, void *data) { free_irq(IOMUX_TO_IRQ(MX31_PIN_GPIO3_1), data); gpio_free_array(mx31_3ds_sdhc1_gpios, ARRAY_SIZE(mx31_3ds_sdhc1_gpios)); }
}; #endif #ifdef CONFIG_I2C_MXC_SELECT2 static struct i2c_board_info mxc_i2c1_board_info[] __initdata = { { .type = "wm8903-i2c", .addr = 0x1a, }, { .type = "sgtl5000-i2c", .addr = 0x0a, }, { .type = "tsc2007", .addr = 0x48, .irq = IOMUX_TO_IRQ(MX51_PIN_GPIO1_5), }, { .type = "si4702", .addr = 0x10, .platform_data = (void *)&si4702_data, }, }; #endif #if defined(CONFIG_I2C_MXC_HS) || defined(CONFIG_I2C_MXC_HS_MODULE) static struct mxc_camera_platform_data camera_data = { .io_regulator = "SW4", .analog_regulator = "VIOHI", .mclk = 24000000, .csi = 0, };
MXC_SPI_CS(2), }; static const struct spi_imx_master spi1_pdata __initconst = { .chipselect = spi1_internal_chipselect, .num_chipselect = ARRAY_SIZE(spi1_internal_chipselect), }; static struct spi_board_info mx31_3ds_spi_devs[] __initdata = { { .modalias = "mc13783", .max_speed_hz = 1000000, .bus_num = 1, .chip_select = 1, /* SS2 */ .platform_data = &mc13783_pdata, .irq = IOMUX_TO_IRQ(MX31_PIN_GPIO1_3), .mode = SPI_CS_HIGH, }, { .modalias = "l4f00242t03", .max_speed_hz = 5000000, .bus_num = 0, .chip_select = 0, /* SS2 */ .platform_data = &mx31_3ds_l4f00242t03_pdata, }, }; /* * NAND Flash */ static const struct mxc_nand_platform_data mx31_3ds_nand_board_info __initconst = {
/*! * 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); /* SD card detect irqs */ mxcsdhc2_device.resource[2].start = IOMUX_TO_IRQ(MX51_PIN_GPIO1_6); mxcsdhc2_device.resource[2].end = IOMUX_TO_IRQ(MX51_PIN_GPIO1_6); mxcsdhc1_device.resource[2].start = IOMUX_TO_IRQ(MX51_PIN_GPIO1_0); mxcsdhc1_device.resource[2].end = IOMUX_TO_IRQ(MX51_PIN_GPIO1_0); mxc_cpu_common_init(); mxc_register_gpios(); 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, &srtc_data); 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); mxc_register_device(&mxcvpu_device, &mxc_vpu_data); mxc_register_device(&gpu_device, NULL); mxc_register_device(&mxcscc_device, NULL); mxc_register_device(&mx51_lpmode_device, NULL); mxc_register_device(&busfreq_device, NULL); 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, NULL); mxc_register_device(&mxc_pwm1_device, NULL); mxc_register_device(&mxc_pwm_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_alsa_spdif_device, &mxc_spdif_data); mxc_register_device(&mxc_fec_device, NULL); mxc_register_device(&mxc_v4l2_device, NULL); mxc_register_device(&mxc_v4l2out_device, NULL); 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)); if (cpu_is_mx51_rev(CHIP_REV_2_0) >= 1) { 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; if (cpu_is_mx51_rev(CHIP_REV_1_1) == 2) { sgtl5000_data.sysclk = 26000000; } gpio_request(IOMUX_TO_GPIO(MX51_PIN_EIM_A23), "eim_a23"); gpio_direction_output(IOMUX_TO_GPIO(MX51_PIN_EIM_A23), 0); mxc_register_device(&mxc_sgtl5000_device, &sgtl5000_data); mx5_usb_dr_init(); mx5_usbh1_init(); }
.seekth = 0xa, }; static struct i2c_board_info mxc_i2c1_board_info[] __initdata = { { .type = "wm8903-i2c", .addr = 0x1a, }, { .type = "sgtl5000-i2c", .addr = 0x0a, }, { .type = "tsc2007", .addr = 0x48, .irq = IOMUX_TO_IRQ(MX51_PIN_GPIO1_5), }, { .type = "si4702", .addr = 0x10, .platform_data = (void *)&si4702_data, }, }; static struct mxc_camera_platform_data camera_data = { .io_regulator = "SW4", .analog_regulator = "VIOHI", .mclk = 24000000, .csi = 0, }; static struct mxc_lightsensor_platform_data ls_data = {
return 0; } static int headphone_det_status(void) { if (cpu_is_mx51_rev(CHIP_REV_1_1) == 2) return (gpio_get_value(IOMUX_TO_GPIO(MX51_PIN_NANDF_D14)) == 0); return gpio_get_value(IOMUX_TO_GPIO(MX51_PIN_NANDF_CS0)); } static struct mxc_audio_platform_data sgtl5000_data = { .ssi_num = 1, .src_port = 2, .ext_port = 3, .hp_irq = IOMUX_TO_IRQ(MX51_PIN_NANDF_D14), .hp_status = headphone_det_status, .amp_enable = mxc_sgtl5000_amp_enable, .sysclk = 12288000, }; static struct platform_device mxc_sgtl5000_device = { .name = "imx-3stack-sgtl5000", }; /*! * Board specific fixup function. It is called by \b setup_arch() in * setup.c file very early on during kernel starts. It allows the user to * statically fill in the proper values for the passed-in parameters. None of * the parameters is used currently. *
/*! * Board specific initialization. */ static void __init mxc_board_init(void) { int err; 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); mxc_cpu_common_init(); mx51_3stack_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); mxc_register_device(&mxcvpu_device, &mxc_vpu_data); mxc_register_device(&gpu_device, NULL); 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, NULL); 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); mxcsdhc1_device.resource[2].start = IOMUX_TO_IRQ(MX51_PIN_GPIO1_0); mxcsdhc1_device.resource[2].end = IOMUX_TO_IRQ(MX51_PIN_GPIO1_0); mxc_register_device(&mxcsdhc1_device, &mmc1_data); mxc_register_device(&mxcsdhc2_device, &mmc2_data); mxc_register_device(&mxc_sim_device, &sim_data); mxc_register_device(&pata_fsl_device, &ata_data); mxc_register_device(&mxc_alsa_spdif_device, &mxc_spdif_data); mxc_expio_init(); if (debug_board_present) mxc_register_device(&smsc_lan9217_device, &smsc911x_config); if (cpu_is_mx51_rev(CHIP_REV_2_0) > 0) lcd_data.reset = lcd_reset_to2; mxc_register_device(&mxc_lcd_device, &lcd_data); mxc_register_device(&lcd_wvga_device, &lcd_wvga_data); mxc_register_device(&mxc_fb_devices[0], &fb_data[0]); mxc_register_device(&mxc_fb_devices[1], &fb_data[1]); mxc_register_device(&mxc_fb_devices[2], NULL); mxc_register_device(&mxcbl_device, NULL); #if defined(CONFIG_MTD_NAND_IMX_NFC) || defined(CONFIG_MTD_NAND_IMX_NFC_MODULE) mxc_register_device(&imx_nfc_device, &imx_nfc_platform_data); #else mxc_register_device(&mxc_nandv2_mtd_device, &mxc_nand_data); #endif mx51_3stack_init_mc13892(); i2c_register_board_info(1, mxc_i2c1_board_info, ARRAY_SIZE(mxc_i2c1_board_info)); i2c_register_board_info(3, mxc_i2c_hs_board_info, ARRAY_SIZE(mxc_i2c_hs_board_info)); mxc_init_wm8903(); mxc_register_device(&mxc_sgtl5000_device, &sgtl5000_data); mxc_register_device(&mxc_bt_device, &mxc_bt_data); mxc_register_device(&mxc_gps_device, &gps_data); mxc_register_device(&mxc_v4l2_device, NULL); mxc_register_device(&mxc_v4l2out_device, NULL); mx5_usb_dr_init(); mx5_usbh1_init(); /* Setup Touchscreen interrupt */ gpio_request(IOMUX_TO_GPIO(MX51_PIN_GPIO1_5), "gpio1_5"); gpio_direction_input(IOMUX_TO_GPIO(MX51_PIN_GPIO1_5)); err = mxc_request_iomux(MX51_PIN_EIM_D19, IOMUX_CONFIG_GPIO); if (err) printk(KERN_ERR "Error: bt reset request gpio failed!\n"); else { gpio_request(IOMUX_TO_GPIO(MX51_PIN_EIM_D19), "eim_d19"); gpio_direction_output(IOMUX_TO_GPIO(MX51_PIN_EIM_D19), 0); } }
static void mxc_mmc1_exit(struct device *dev, void *data) { gpio_free(gpio_det); gpio_free(gpio_wp); free_irq(IOMUX_TO_IRQ(MX31_PIN_DCD_DCE1), data); }