static int __init omap_kp_probe(struct device *dev) { int i; /* Disable the interrupt for the MPUIO keyboard */ omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); if (machine_is_omap_h2() || machine_is_omap_h3()) { keymap = h2_keymap; set_bit(EV_REP, omap_kp_dev.evbit); } else if (machine_is_omap_innovator()) { keymap = innovator_keymap; } else if (machine_is_omap_osk()) { keymap = osk_keymap; } else { keymap = test_keymap; } init_timer(&kp_timer); kp_timer.function = omap_kp_timer; /* get the irq and init timer*/ tasklet_enable(&kp_tasklet); if (request_irq(INT_KEYBOARD, omap_kp_interrupt, 0, "omap-keypad", 0) < 0) return -EINVAL; /* setup input device */ set_bit(EV_KEY, omap_kp_dev.evbit); for (i = 0; keymap[i] != 0; i++) set_bit(keymap[i] & 0x00ffffff, omap_kp_dev.keybit); omap_kp_dev.name = "omap-keypad"; input_register_device(&omap_kp_dev); if (machine_is_omap_h2() || machine_is_omap_h3()) { omap_cfg_reg(F18_1610_KBC0); omap_cfg_reg(D20_1610_KBC1); omap_cfg_reg(D19_1610_KBC2); omap_cfg_reg(E18_1610_KBC3); omap_cfg_reg(C21_1610_KBC4); omap_cfg_reg(G18_1610_KBR0); omap_cfg_reg(F19_1610_KBR1); omap_cfg_reg(H14_1610_KBR2); omap_cfg_reg(E20_1610_KBR3); omap_cfg_reg(E19_1610_KBR4); omap_cfg_reg(N19_1610_KBR5); omap_writew(0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING); } /* scan current status and enable interrupt */ omap_kp_scan_keypad(keypad_state); omap_writew(0, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); return 0; }
static int __init omap_leds_init(void) { if (!cpu_class_is_omap1()) return -ENODEV; if (machine_is_omap_innovator()) leds_event = innovator_leds_event; else if (machine_is_omap_h2() || machine_is_omap_h3() || machine_is_omap_perseus2()) leds_event = h2p2_dbg_leds_event; else if (machine_is_omap_osk()) leds_event = osk_leds_event; else return -1; if (machine_is_omap_h2() || machine_is_omap_h3() #ifdef CONFIG_OMAP_OSK_MISTRAL || machine_is_omap_osk() #endif ) { /* LED1/LED2 pins can be used as GPIO (as done here), or by * the LPG (works even in deep sleep!), to drive a bicolor * LED on the H2 sample board, and another on the H2/P2 * "surfer" expansion board. * * The same pins drive a LED on the OSK Mistral board, but * that's a different kind of LED (just one color at a time). */ omap_cfg_reg(P18_1610_GPIO3); if (gpio_request(3, "LED red") == 0) gpio_direction_output(3, 1); else printk(KERN_WARNING "LED: can't get GPIO3/red?\n"); omap_cfg_reg(MPUIO4); if (gpio_request(OMAP_MPUIO(4), "LED green") == 0) gpio_direction_output(OMAP_MPUIO(4), 1); else printk(KERN_WARNING "LED: can't get MPUIO4/green?\n"); } leds_event(led_start); return 0; }
static void omap_init_kp(void) { if (machine_is_omap_h2() || machine_is_omap_h3()) { omap_cfg_reg(F18_1610_KBC0); omap_cfg_reg(D20_1610_KBC1); omap_cfg_reg(D19_1610_KBC2); omap_cfg_reg(E18_1610_KBC3); omap_cfg_reg(C21_1610_KBC4); omap_cfg_reg(G18_1610_KBR0); omap_cfg_reg(F19_1610_KBR1); omap_cfg_reg(H14_1610_KBR2); omap_cfg_reg(E20_1610_KBR3); omap_cfg_reg(E19_1610_KBR4); omap_cfg_reg(N19_1610_KBR5); } else if (machine_is_omap_perseus2()) { omap_cfg_reg(E2_730_KBR0); omap_cfg_reg(J7_730_KBR1); omap_cfg_reg(E1_730_KBR2); omap_cfg_reg(F3_730_KBR3); omap_cfg_reg(D2_730_KBR4); omap_cfg_reg(C2_730_KBC0); omap_cfg_reg(D3_730_KBC1); omap_cfg_reg(E4_730_KBC2); omap_cfg_reg(F4_730_KBC3); omap_cfg_reg(E3_730_KBC4); } (void) platform_device_register(&omap_kp_device); }
static void __exit hx_ts_remove(void) { if (machine_is_omap_h2()) omap_free_gpio(H2_GPIO_NUM); else if (machine_is_omap_h3()) omap_free_gpio(H3_GPIO_NUM); }
static void omap_init_kp(void) { /* 2430 and 34xx keypad is on TWL4030 */ if (cpu_is_omap2430() || cpu_is_omap34xx()) return; if (machine_is_omap_h2() || machine_is_omap_h3()) { omap_cfg_reg(F18_1610_KBC0); omap_cfg_reg(D20_1610_KBC1); omap_cfg_reg(D19_1610_KBC2); omap_cfg_reg(E18_1610_KBC3); omap_cfg_reg(C21_1610_KBC4); omap_cfg_reg(G18_1610_KBR0); omap_cfg_reg(F19_1610_KBR1); omap_cfg_reg(H14_1610_KBR2); omap_cfg_reg(E20_1610_KBR3); omap_cfg_reg(E19_1610_KBR4); omap_cfg_reg(N19_1610_KBR5); } else if (machine_is_omap_perseus2() || machine_is_omap_fsample()) { omap_cfg_reg(E2_7XX_KBR0); omap_cfg_reg(J7_7XX_KBR1); omap_cfg_reg(E1_7XX_KBR2); omap_cfg_reg(F3_7XX_KBR3); omap_cfg_reg(D2_7XX_KBR4); omap_cfg_reg(C2_7XX_KBC0); omap_cfg_reg(D3_7XX_KBC1); omap_cfg_reg(E4_7XX_KBC2); omap_cfg_reg(F4_7XX_KBC3); omap_cfg_reg(E3_7XX_KBC4); } else if (machine_is_omap_h4()) { omap_cfg_reg(T19_24XX_KBR0); omap_cfg_reg(R19_24XX_KBR1); omap_cfg_reg(V18_24XX_KBR2); omap_cfg_reg(M21_24XX_KBR3); omap_cfg_reg(E5__24XX_KBR4); if (omap_has_menelaus()) { omap_cfg_reg(B3__24XX_KBR5); omap_cfg_reg(AA4_24XX_KBC2); omap_cfg_reg(B13_24XX_KBC6); } else { omap_cfg_reg(M18_24XX_KBR5); omap_cfg_reg(H19_24XX_KBC2); omap_cfg_reg(N19_24XX_KBC6); } omap_cfg_reg(R20_24XX_KBC0); omap_cfg_reg(M14_24XX_KBC1); omap_cfg_reg(V17_24XX_KBC3); omap_cfg_reg(P21_24XX_KBC4); omap_cfg_reg(L14_24XX_KBC5); } }
static void omap_init_irda(void) { /* FIXME define and use a boot tag, members something like: * u8 uart; // uart1, or uart3 * ... but driver only handles uart3 for now * s16 fir_sel; // gpio for SIR vs FIR * ... may prefer a callback for SIR/MIR/FIR mode select; * while h2 uses a GPIO, H3 uses a gpio expander */ if (machine_is_omap_h2() || machine_is_omap_h3()) (void) platform_device_register(&omap1610ir_device); }
void omap_tsc2101_reads(int page, u8 startaddress, u16 * data, int numregs) { int cs = 0, i; if (machine_is_omap_h2()) { cs = 1; } if (machine_is_omap_h3()) { cs = 0; } (void)omap_uwire_data_transfer(cs, (0x8000 | (page << 11) | (startaddress << 5)), 16, 0, NULL, 1); for (i = 0; i < (numregs - 1); i++, data++) { omap_uwire_data_transfer(cs, 0, 0, 16, data, 1); } omap_uwire_data_transfer(cs, 0, 0, 16, data, 0); }
void omap_tsc2101_write(int page, u8 address, u16 data) { int ret = 0; if (machine_is_omap_h2()) { ret = omap_uwire_data_transfer(1, (((page) << 11) | (address << 5)), 16, 0, NULL, 1); if (ret) { printk(KERN_ERR "uwire-write returned error for address %x\n", address); return; } ret = omap_uwire_data_transfer(1, data, 16, 0, NULL, 0); if (ret) { printk(KERN_ERR "uwire-write returned error for address %x\n", address); return; } } if (machine_is_omap_h3()) { ret = omap_uwire_data_transfer(0, ((page << 11) | (address << 5)), 16, 0, NULL, 1); if (ret) { printk(KERN_ERR "uwire-write returned error for address %x\n", address); return; } ret = omap_uwire_data_transfer(0, data, 16, 0, NULL, 0); if (ret) { printk(KERN_ERR "uwire-write returned error for address %x\n", address); return; } } }
int omap_tsc2101_enable(void) { int ret = 0; spin_lock(&tsc2101_lock); if (count++ == 0) { int ret = 0; /* set the Mux to provide MCLK to TSC2101 */ if (machine_is_omap_h3()) { ret = omap_cfg_reg(V5_1710_MCLK_ON); } else { if (machine_is_omap_h2()) { ret = omap_cfg_reg(R10_1610_MCLK_ON); } } /* Get the MCLK */ tsc2101_mclk_ck = clk_get(NULL, "mclk"); if (NULL == tsc2101_mclk_ck) { printk(KERN_ERR "Unable to get the clock MCLK!!!\n");; ret = -EPERM; goto done; } if (clk_set_rate(tsc2101_mclk_ck, 12000000)) { printk(KERN_ERR "Unable to set rate to the MCLK!!!\n");; ret = -EPERM; goto done; } clk_enable(tsc2101_mclk_ck); ret = omap_tsc2101_configure(); /* Lock the module */ if (!ret && !try_module_get(THIS_MODULE)) { printk(KERN_CRIT "Failed to get TSC module\n"); ret = -ESTALE; } } done: spin_unlock(&tsc2101_lock); return ret; }
static void omap_kp_scan_keypad(unsigned char *state) { int col = 0; /* read the keypad status */ omap_writew(0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC); for (col = 0; col < 8; col++) { omap_writew(~(1 << col) & 0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC); if (machine_is_omap_osk() || machine_is_omap_h2() || machine_is_omap_h3()) { udelay(9); } else { udelay(2); } state[col] = ~omap_readw(OMAP_MPUIO_BASE + OMAP_MPUIO_KBR_LATCH) & 0xff; } omap_writew(0x00, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC); udelay(2); }
static int omap1610_irda_set_speed(struct net_device *dev, int speed) { struct omap1610_irda *si = dev->priv; int divisor; __ECHO_IN; /* Set IrDA speed */ if (speed <= 115200) { /* SIR mode */ if (machine_is_omap_h2()) { omap_set_gpio_dataout(OMAP1610_H2_FIRSEL_GPIO, 0); } if (machine_is_omap_h3()) set_h3_irda_mode(SIR_MODE); printk("Set SIR Mode! Speed: %d\n", speed); omap_writeb(1, UART3_MDR1); /* Set SIR mode */ omap_writeb(1, UART3_EBLR); divisor = 48000000 / (16 * speed); /* Base clock 48 MHz */ HDBG2(1); omap_writeb(1 << 7, UART3_LCR); omap_writeb((divisor & 0xFF), UART3_DLL); omap_writeb((divisor >> 8), UART3_DLH); omap_writeb(0x03, UART3_LCR); omap_writeb(0, UART3_MCR); HDBG2(1); } else if (speed <= 1152000) {
static int __init hx_ts_probe(struct omap_ts_t *ts) { unsigned gpio; if (machine_is_omap_h2()) { gpio = H2_GPIO_NUM; omap_cfg_reg(P20_1610_GPIO4); } else if (machine_is_omap_h3()) { gpio = H3_GPIO_NUM; omap_cfg_reg(W19_1610_GPIO48); } else return -ENODEV; ts->irq = OMAP_GPIO_IRQ(gpio); if (omap_request_gpio(gpio) != 0) { printk(KERN_ERR "hX_ts_init.c: Could not reserve GPIO!\n"); return -EINVAL; }; omap_set_gpio_direction(gpio, 1); ts->irq_type = IRQF_TRIGGER_FALLING; return 0; }
void omap_tsc2101_disable(void) { spin_lock(&tsc2101_lock); if (--count == 0) { int ret = 0; /* Remove the Mux to Stop MCLK to TSC2101 */ if (machine_is_omap_h3()) { ret = omap_cfg_reg(V5_1710_MCLK_OFF); } else { if (machine_is_omap_h2()) { ret = omap_cfg_reg(R10_1610_MCLK_OFF); } } /* Release the MCLK */ clk_disable(tsc2101_mclk_ck); clk_put(tsc2101_mclk_ck); tsc2101_mclk_ck = NULL; module_put(THIS_MODULE); } spin_unlock(&tsc2101_lock); }
/* FIXME: adapt clock divisors for uwire to current ARM xor clock rate */ static int omap_tsc2101_configure(void) { unsigned long uwire_flags = 0; #ifdef CONFIG_MACH_OMAP_H3 int err = 0; u8 ioExpanderVal = 0; if ((err = read_gpio_expa(&ioExpanderVal, 0x24))) { printk(" Error reading from I/O EXPANDER \n"); return err; } ioExpanderVal |= 0x8; if ((err = write_gpio_expa(ioExpanderVal, 0x24))) { printk(KERN_ERR ": Error writing to I/O EXPANDER \n"); return err; } #endif if (machine_is_omap_h2()) { uwire_flags = UWIRE_READ_RISING_EDGE | UWIRE_WRITE_RISING_EDGE; omap_cfg_reg(N15_1610_UWIRE_CS1); omap_uwire_configure_mode(1, uwire_flags); } if (machine_is_omap_h3()) { uwire_flags = UWIRE_READ_RISING_EDGE | UWIRE_WRITE_RISING_EDGE; omap_cfg_reg(N14_1610_UWIRE_CS0); omap_uwire_configure_mode(0, uwire_flags); } /* Configure MCLK enable */ omap_writel(omap_readl(PU_PD_SEL_2) | (1 << 22), PU_PD_SEL_2); return 0; }
static int ohci_omap_init(struct usb_hcd *hcd) { struct ohci_hcd *ohci = hcd_to_ohci(hcd); struct omap_usb_config *config = hcd->self.controller->platform_data; int need_transceiver = (config->otg != 0); int ret; dev_dbg(hcd->self.controller, "starting USB Controller\n"); if (config->otg) { ohci_to_hcd(ohci)->self.otg_port = config->otg; /* */ ohci_to_hcd(ohci)->power_budget = 8; } /* */ need_transceiver = need_transceiver || machine_is_omap_h2() || machine_is_omap_h3(); if (cpu_is_omap16xx()) ocpi_enable(); #ifdef CONFIG_USB_OTG if (need_transceiver) { ohci->transceiver = usb_get_transceiver(); if (ohci->transceiver) { int status = otg_set_host(ohci->transceiver->otg, &ohci_to_hcd(ohci)->self); dev_dbg(hcd->self.controller, "init %s transceiver, status %d\n", ohci->transceiver->label, status); if (status) { if (ohci->transceiver) put_device(ohci->transceiver->dev); return status; } } else { dev_err(hcd->self.controller, "can't find transceiver\n"); return -ENODEV; } ohci->start_hnp = start_hnp; } #endif omap_ohci_clock_power(1); if (cpu_is_omap15xx()) { omap_1510_local_bus_power(1); omap_1510_local_bus_init(); } if ((ret = ohci_init(ohci)) < 0) return ret; /* */ if (machine_is_omap_osk() || machine_is_omap_innovator()) { u32 rh = roothub_a (ohci); /* */ rh &= ~RH_A_NPS; /* */ if (machine_is_omap_osk()) { ohci_to_hcd(ohci)->power_budget = 250; rh &= ~RH_A_NOCP; /* */ omap_cfg_reg(W8_1610_GPIO9); gpio_request(9, "OHCI overcurrent"); gpio_direction_input(9); /* */ omap_cfg_reg(W4_USB_HIGHZ); } ohci_writel(ohci, rh, &ohci->regs->roothub.a); ohci->flags &= ~OHCI_QUIRK_HUB_POWER; } else if (machine_is_nokia770()) { /* */ ohci_to_hcd(ohci)->power_budget = 0; } /* */ omap_ohci_transceiver_power(1); /* */ return 0; }
static int isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget) { struct isp1301 *isp = container_of(otg, struct isp1301, otg); #ifndef CONFIG_USB_OTG u32 l; #endif if (!otg || isp != the_transceiver) return -ENODEV; if (!gadget) { omap_writew(0, OTG_IRQ_EN); if (!isp->otg.default_a) enable_vbus_draw(isp, 0); usb_gadget_vbus_disconnect(isp->otg.gadget); isp->otg.gadget = NULL; power_down(isp); return 0; } #ifdef CONFIG_USB_OTG isp->otg.gadget = gadget; dev_dbg(&isp->client->dev, "registered gadget\n"); /* gadget driver may be suspended until vbus_connect () */ if (isp->otg.host) return isp1301_otg_enable(isp); return 0; #elif !defined(CONFIG_USB_OHCI_HCD) && !defined(CONFIG_USB_OHCI_HCD_MODULE) isp->otg.gadget = gadget; // FIXME update its refcount l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK; l &= ~(OTG_XCEIV_OUTPUTS|OTG_CTRL_BITS); l |= OTG_ID; omap_writel(l, OTG_CTRL); power_up(isp); isp->otg.state = OTG_STATE_B_IDLE; if (machine_is_omap_h2() || machine_is_omap_h3()) isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0); isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING, INTR_SESS_VLD); isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING, INTR_VBUS_VLD); dev_info(&isp->client->dev, "B-Peripheral sessions ok\n"); dump_regs(isp, __func__); /* If this has a Mini-AB connector, this mode is highly * nonstandard ... but can be handy for testing, so long * as you don't plug a Mini-A cable into the jack. */ if (isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE) & INTR_VBUS_VLD) b_peripheral(isp); return 0; #else dev_dbg(&isp->client->dev, "peripheral sessions not allowed\n"); return -EINVAL; #endif }
static int ohci_omap_init(struct usb_hcd *hcd) { struct ohci_hcd *ohci = hcd_to_ohci(hcd); struct omap_usb_config *config = hcd->self.controller->platform_data; int need_transceiver = (config->otg != 0); int ret; dev_dbg(hcd->self.controller, "starting USB Controller\n"); if (config->otg) { ohci_to_hcd(ohci)->self.otg_port = config->otg; /* default/minimum OTG power budget: 8 mA */ ohci_to_hcd(ohci)->power_budget = 8; } /* boards can use OTG transceivers in non-OTG modes */ need_transceiver = need_transceiver || machine_is_omap_h2() || machine_is_omap_h3(); if (cpu_is_omap16xx()) ocpi_enable(); #ifdef CONFIG_ARCH_OMAP_OTG if (need_transceiver) { ohci->transceiver = otg_get_transceiver(); if (ohci->transceiver) { int status = otg_set_host(ohci->transceiver, &ohci_to_hcd(ohci)->self); dev_dbg(hcd->self.controller, "init %s transceiver, status %d\n", ohci->transceiver->label, status); if (status) { if (ohci->transceiver) put_device(ohci->transceiver->dev); return status; } } else { dev_err(hcd->self.controller, "can't find transceiver\n"); return -ENODEV; } } #endif omap_ohci_clock_power(1); if (cpu_is_omap1510()) { omap_1510_local_bus_power(1); omap_1510_local_bus_init(); } if ((ret = ohci_init(ohci)) < 0) return ret; /* board-specific power switching and overcurrent support */ if (machine_is_omap_osk() || machine_is_omap_innovator()) { u32 rh = roothub_a (ohci); /* power switching (ganged by default) */ rh &= ~RH_A_NPS; /* TPS2045 switch for internal transceiver (port 1) */ if (machine_is_omap_osk()) { ohci_to_hcd(ohci)->power_budget = 250; rh &= ~RH_A_NOCP; /* gpio9 for overcurrent detction */ omap_cfg_reg(W8_1610_GPIO9); omap_request_gpio(9); omap_set_gpio_direction(9, 1 /* IN */); /* for paranoia's sake: disable USB.PUEN */ omap_cfg_reg(W4_USB_HIGHZ); } ohci_writel(ohci, rh, &ohci->regs->roothub.a); distrust_firmware = 0; } else if (machine_is_nokia770()) { /* We require a self-powered hub, which should have * plenty of power. */ ohci_to_hcd(ohci)->power_budget = 0; } /* FIXME khubd hub requests should manage power switching */ omap_ohci_transceiver_power(1); /* board init will have already handled HMC and mux setup. * any external transceiver should already be initialized * too, so all configured ports use the right signaling now. */ return 0; }
static int ohci_omap_reset(struct usb_hcd *hcd) { struct ohci_hcd *ohci = hcd_to_ohci(hcd); struct omap_usb_config *config = dev_get_platdata(hcd->self.controller); int need_transceiver = (config->otg != 0); int ret; dev_dbg(hcd->self.controller, "starting USB Controller\n"); if (config->otg) { hcd->self.otg_port = config->otg; /* default/minimum OTG power budget: 8 mA */ hcd->power_budget = 8; } /* boards can use OTG transceivers in non-OTG modes */ need_transceiver = need_transceiver || machine_is_omap_h2() || machine_is_omap_h3(); /* XXX OMAP16xx only */ if (config->ocpi_enable) config->ocpi_enable(); #ifdef CONFIG_USB_OTG if (need_transceiver) { hcd->phy = usb_get_phy(USB_PHY_TYPE_USB2); if (!IS_ERR_OR_NULL(hcd->phy)) { int status = otg_set_host(hcd->phy->otg, &ohci_to_hcd(ohci)->self); dev_dbg(hcd->self.controller, "init %s phy, status %d\n", hcd->phy->label, status); if (status) { usb_put_phy(hcd->phy); return status; } } else { dev_err(hcd->self.controller, "can't find phy\n"); return -ENODEV; } ohci->start_hnp = start_hnp; } #endif omap_ohci_clock_power(1); if (cpu_is_omap15xx()) { omap_1510_local_bus_power(1); omap_1510_local_bus_init(); } ret = ohci_setup(hcd); if (ret < 0) return ret; if (config->otg || config->rwc) { ohci->hc_control = OHCI_CTRL_RWC; writel(OHCI_CTRL_RWC, &ohci->regs->control); } /* board-specific power switching and overcurrent support */ if (machine_is_omap_osk() || machine_is_omap_innovator()) { u32 rh = roothub_a (ohci); /* power switching (ganged by default) */ rh &= ~RH_A_NPS; /* TPS2045 switch for internal transceiver (port 1) */ if (machine_is_omap_osk()) { ohci_to_hcd(ohci)->power_budget = 250; rh &= ~RH_A_NOCP; /* gpio9 for overcurrent detction */ omap_cfg_reg(W8_1610_GPIO9); gpio_request(9, "OHCI overcurrent"); gpio_direction_input(9); /* for paranoia's sake: disable USB.PUEN */ omap_cfg_reg(W4_USB_HIGHZ); } ohci_writel(ohci, rh, &ohci->regs->roothub.a); ohci->flags &= ~OHCI_QUIRK_HUB_POWER; } else if (machine_is_nokia770()) { /* We require a self-powered hub, which should have * plenty of power. */ ohci_to_hcd(ohci)->power_budget = 0; } /* FIXME khubd hub requests should manage power switching */ omap_ohci_transceiver_power(1); /* board init will have already handled HMC and mux setup. * any external transceiver should already be initialized * too, so all configured ports use the right signaling now. */ return 0; }
/* * Set the IrDA communications speed. * Interrupt have to be disabled here. */ static int omap_irda_startup(struct net_device *dev) { struct omap_irda *omap_ir = netdev_priv(dev); /* FIXME: use clk_* apis for UART3 clock*/ /* Enable UART3 clock and set UART3 to IrDA mode */ if (machine_is_omap_h2() || machine_is_omap_h3()) omap_writel(omap_readl(MOD_CONF_CTRL_0) | (1 << 31) | (1 << 15), MOD_CONF_CTRL_0); /* Only for H2? */ if (omap_ir->pdata->transceiver_mode && machine_is_omap_h2()) { /* Is it select_irda on H2 ? */ omap_writel(omap_readl(FUNC_MUX_CTRL_A) | 7, FUNC_MUX_CTRL_A); omap_ir->pdata->transceiver_mode(omap_ir->dev, IR_SIRMODE); } uart_reg_out(UART3_MDR1, UART3_MDR1_RESET); /* Reset mode */ /* Clear DLH and DLL */ uart_reg_out(UART3_LCR, UART3_LCR_DIVEN); uart_reg_out(UART3_DLL, 0); uart_reg_out(UART3_DLH, 0); uart_reg_out(UART3_LCR, 0xbf); /* FIXME: Add #define */ uart_reg_out(UART3_EFR, UART3_EFR_EN); uart_reg_out(UART3_LCR, UART3_LCR_DIVEN); /* Enable access to UART3_TLR and UART3_TCR registers */ uart_reg_out(UART3_MCR, UART3_MCR_EN_TCR_TLR); uart_reg_out(UART3_SCR, 0); /* Set Rx trigger to 1 and Tx trigger to 1 */ uart_reg_out(UART3_TLR, 0); /* Set LCR to 8 bits and 1 stop bit */ uart_reg_out(UART3_LCR, 0x03); /* Clear RX and TX FIFO and enable FIFO */ /* Use DMA Req for transfers */ uart_reg_out(UART3_FCR, UART3_FCR_CONFIG); uart_reg_out(UART3_MCR, 0); uart_reg_out(UART3_SCR, UART3_SCR_TX_TRIG1 | UART3_SCR_RX_TRIG1); /* Enable UART3 SIR Mode,(Frame-length method to end frames) */ uart_reg_out(UART3_MDR1, UART3_MDR1_SIR); /* Set Status FIFO trig to 1 */ uart_reg_out(UART3_MDR2, 0); /* Enables RXIR input */ /* and disable TX underrun */ /* SEND_SIP pulse */ uart_reg_out(UART3_ACREG, UART3_ACERG_SD_MODE_LOW | UART3_ACERG_TX_UNDERRUN_DIS); /* Enable EOF Interrupt only */ uart_reg_out(UART3_IER, UART3_IER_CTS | UART3_IER_EOF); /* Set Maximum Received Frame size to 2048 bytes */ uart_reg_out(UART3_RXFLL, 0x00); uart_reg_out(UART3_RXFLH, 0x08); uart_reg_in(UART3_RESUME); return 0; }
static int omap_start_hc(struct ohci_hcd *ohci, struct platform_device *pdev) { struct omap_usb_config *config = pdev->dev.platform_data; int need_transceiver = (config->otg != 0); dev_dbg(&pdev->dev, "starting USB Controller\n"); if (config->otg) { ohci->hcd.self.otg_port = config->otg; /* default/minimum OTG power budget: 8 mA */ ohci->power_budget = 8; } /* boards can use OTG transceivers in non-OTG modes */ need_transceiver = need_transceiver || machine_is_omap_h2() || machine_is_omap_h3(); if (cpu_is_omap16xx()) ocpi_enable(); #ifdef CONFIG_ARCH_OMAP_OTG if (need_transceiver) { ohci->transceiver = otg_get_transceiver(); if (ohci->transceiver) { int status = otg_set_host(ohci->transceiver, &ohci->hcd.self); dev_dbg(&pdev->dev, "init %s transceiver, status %d\n", ohci->transceiver->label, status); if (status) { if (ohci->transceiver) put_device(ohci->transceiver->dev); return status; } } else { dev_err(&pdev->dev, "can't find transceiver\n"); return -ENODEV; } } #endif if (machine_is_omap_osk()) { omap_request_gpio(9); omap_set_gpio_direction(9, 1); omap_set_gpio_dataout(9, 1); } omap_ohci_clock_power(1); omap_ohci_transceiver_power(1); if (cpu_is_omap1510()) { omap_1510_local_bus_power(1); omap_1510_local_bus_init(); } /* board init will have already handled HMC and mux setup. * any external transceiver should already be initialized * too, so all configured ports use the right signaling now. */ return 0; }