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;
}
