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 int isp1301_detach_client(struct i2c_client *i2c)
{
struct isp1301 *isp;
isp = container_of(i2c, struct isp1301, client);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
free_irq(isp->irq, isp);
#ifdef CONFIG_USB_OTG
otg_unbind(isp);
#endif
if (machine_is_omap_h2())
omap_free_gpio(2);
isp->timer.data = 0;
set_bit(WORK_STOP, &isp->todo);
del_timer_sync(&isp->timer);
flush_scheduled_work();
put_device(&i2c->dev);
the_transceiver = 0;
return i2c_detach_client(i2c);
}
int board_init (void)
{
if (machine_is_omap_h2())
gd->bd->bi_arch_number = MACH_TYPE_OMAP_H2;
else if (machine_is_omap_innovator())
gd->bd->bi_arch_number = MACH_TYPE_OMAP_INNOVATOR;
else
gd->bd->bi_arch_number = MACH_TYPE_OMAP_GENERIC;
/* adress of boot parameters */
gd->bd->bi_boot_params = 0x10000100;
/* Configure MUX settings */
set_muxconf_regs ();
peripheral_power_enable ();
/* this speeds up your boot a quite a bit. However to make it
* work, you need make sure your kernel startup flush bug is fixed.
* ... rkw ...
*/
icache_enable ();
flash__init ();
ether__init ();
return 0;
}
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)
{
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 int __exit isp1301_remove(struct i2c_client *i2c)
{
struct isp1301 *isp;
isp = i2c_get_clientdata(i2c);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
free_irq(i2c->irq, isp);
#ifdef CONFIG_USB_OTG
otg_unbind(isp);
#endif
if (machine_is_omap_h2())
gpio_free(2);
isp->timer.data = 0;
set_bit(WORK_STOP, &isp->todo);
del_timer_sync(&isp->timer);
flush_scheduled_work();
put_device(&i2c->dev);
the_transceiver = NULL;
return 0;
}
static int
isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
{
struct isp1301 *isp = container_of(otg, struct isp1301, otg);
if (!otg || isp != the_transceiver)
return -ENODEV;
if (!gadget) {
OTG_IRQ_EN_REG = 0;
if (!isp->otg.default_a)
enable_vbus_draw(isp, 0);
usb_gadget_vbus_disconnect(isp->otg.gadget);
isp->otg.gadget = 0;
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
OTG_CTRL_REG = (OTG_CTRL_REG & OTG_CTRL_MASK
& ~(OTG_XCEIV_OUTPUTS|OTG_CTRL_BITS))
| OTG_ID;
power_up(isp);
isp->otg.state = OTG_STATE_B_IDLE;
if (machine_is_omap_h2())
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
}
/* add or disable the host device+driver */
static int
isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host)
{
struct isp1301 *isp = container_of(otg, struct isp1301, otg);
if (!otg || isp != the_transceiver)
return -ENODEV;
if (!host) {
omap_writew(0, OTG_IRQ_EN);
power_down(isp);
isp->otg.host = NULL;
return 0;
}
#ifdef CONFIG_USB_OTG
isp->otg.host = host;
dev_dbg(&isp->client->dev, "registered host\n");
host_suspend(isp);
if (isp->otg.gadget)
return isp1301_otg_enable(isp);
return 0;
#elif !defined(CONFIG_USB_GADGET_OMAP)
// FIXME update its refcount
isp->otg.host = host;
power_up(isp);
if (machine_is_omap_h2())
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
dev_info(&isp->client->dev, "A-Host sessions ok\n");
isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
INTR_ID_GND);
isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
INTR_ID_GND);
/* If this has a Mini-AB connector, this mode is highly
* nonstandard ... but can be handy for testing, especially with
* the Mini-A end of an OTG cable. (Or something nonstandard
* like MiniB-to-StandardB, maybe built with a gender mender.)
*/
isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_VBUS_DRV);
dump_regs(isp, __func__);
return 0;
#else
dev_dbg(&isp->client->dev, "host sessions not allowed\n");
return -EINVAL;
#endif
}
static int __init omap_uwire_init(void)
{
spin_lock_init(&uwire_lock);
uwire_write_reg(UWIRE_SR3, 1);
if (machine_is_omap_h2() || machine_is_omap_osk()) {
/* defaults: W21 SDO, U18 SDI, V19 SCL */
omap_cfg_reg(N14_1610_UWIRE_CS0);
omap_cfg_reg(N15_1610_UWIRE_CS1);
}
return 0;
}
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);
}
static int __init
omap_leds_init(void)
{
if (machine_is_omap_innovator())
leds_event = innovator_leds_event;
else if (machine_is_omap_h2() || machine_is_omap_perseus2()) {
leds_event = h2p2_dbg_leds_event;
}
leds_event(led_start);
return 0;
}
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) {
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);
}
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;
}
/* 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 __init
isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
{
int status;
struct isp1301 *isp;
if (the_transceiver)
return 0;
isp = kzalloc(sizeof *isp, GFP_KERNEL);
if (!isp)
return 0;
INIT_WORK(&isp->work, isp1301_work);
init_timer(&isp->timer);
isp->timer.function = isp1301_timer;
isp->timer.data = (unsigned long) isp;
i2c_set_clientdata(i2c, isp);
isp->client = i2c;
/* verify the chip (shouldn't be necesary) */
status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
if (status != I2C_VENDOR_ID_PHILIPS) {
dev_dbg(&i2c->dev, "not philips id: %d\n", status);
goto fail;
}
status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
if (status != I2C_PRODUCT_ID_PHILIPS_1301) {
dev_dbg(&i2c->dev, "not isp1301, %d\n", status);
goto fail;
}
isp->i2c_release = i2c->dev.release;
i2c->dev.release = isp1301_release;
/* initial development used chiprev 2.00 */
status = i2c_smbus_read_word_data(i2c, ISP1301_BCD_DEVICE);
dev_info(&i2c->dev, "chiprev %x.%02x, driver " DRIVER_VERSION "\n",
status >> 8, status & 0xff);
/* make like power-on reset */
isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_MASK);
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_BI_DI);
isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, ~MC2_BI_DI);
isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN);
isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
~(OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN));
isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
#ifdef CONFIG_USB_OTG
status = otg_bind(isp);
if (status < 0) {
dev_dbg(&i2c->dev, "can't bind OTG\n");
goto fail;
}
#endif
if (machine_is_omap_h2()) {
/* full speed signaling by default */
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
MC1_SPEED);
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2,
MC2_SPD_SUSP_CTRL);
/* IRQ wired at M14 */
omap_cfg_reg(M14_1510_GPIO2);
if (gpio_request(2, "isp1301") == 0)
gpio_direction_input(2);
isp->irq_type = IRQF_TRIGGER_FALLING;
}
isp->irq_type |= IRQF_SAMPLE_RANDOM;
status = request_irq(i2c->irq, isp1301_irq,
isp->irq_type, DRIVER_NAME, isp);
if (status < 0) {
dev_dbg(&i2c->dev, "can't get IRQ %d, err %d\n",
i2c->irq, status);
goto fail;
}
isp->otg.dev = &i2c->dev;
isp->otg.label = DRIVER_NAME;
isp->otg.set_host = isp1301_set_host,
isp->otg.set_peripheral = isp1301_set_peripheral,
isp->otg.set_power = isp1301_set_power,
isp->otg.start_srp = isp1301_start_srp,
isp->otg.start_hnp = isp1301_start_hnp,
enable_vbus_draw(isp, 0);
power_down(isp);
the_transceiver = isp;
#ifdef CONFIG_USB_OTG
update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
#endif
dump_regs(isp, __func__);
#ifdef VERBOSE
mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
dev_dbg(&i2c->dev, "scheduled timer, %d min\n", TIMER_MINUTES);
#endif
status = otg_set_transceiver(&isp->otg);
if (status < 0)
dev_err(&i2c->dev, "can't register transceiver, %d\n",
status);
return 0;
fail:
kfree(isp);
return -ENODEV;
}
static int omap1610_irda_startup(struct net_device *dev)
{
__ECHO_IN;
/* Enable UART3 clock and set UART3 to IrDA mode */
omap_writel(omap_readl(MOD_CONF_CTRL_0) | (1 << 31) | (1 << 15),
MOD_CONF_CTRL_0);
if (machine_is_omap_h2()) {
// omap_cfg_reg(Y15_1610_GPIO17);
omap_writel(omap_readl(FUNC_MUX_CTRL_A) | 7, FUNC_MUX_CTRL_A);
omap_set_gpio_direction(OMAP1610_H2_FIRSEL_GPIO, 0);
omap_set_gpio_dataout(OMAP1610_H2_FIRSEL_GPIO, 0);
}
omap_writeb(0x07, UART3_MDR1); /* Put UART3 in reset mode */
/* Clear DLH and DLL */
omap_writeb(1 << 7, UART3_LCR);
omap_writeb(0, UART3_DLL);
omap_writeb(0, UART3_DLH);
omap_writeb(0xbf, UART3_LCR);
omap_writeb(1 << 4, UART3_EFR);
omap_writeb(1 << 7, UART3_LCR);
/* Enable access to UART3_TLR and UART3_TCR registers */
omap_writeb(1 << 6, UART3_MCR);
omap_writeb(0, UART3_SCR);
/* Set Rx trigger to 1 and Tx trigger to 1 */
omap_writeb(0, UART3_TLR);
/* Set LCR to 8 bits and 1 stop bit */
omap_writeb(0x03, UART3_LCR);
/* Clear RX and TX FIFO and enable FIFO */
/* Use DMA Req for transfers */
omap_writeb((1 << 2) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 6) | 1,
UART3_FCR);
omap_writeb(0, UART3_MCR);
omap_writeb((1 << 7) | (1 << 6), UART3_SCR);
/* Enable UART3 SIR Mode,(Frame-length method to end frames) */
omap_writeb(1, UART3_MDR1);
/* Set Status FIFO trig to 1 */
omap_writeb(0, UART3_MDR2);
/* Enables RXIR input */
/* and disable TX underrun */
/* SEND_SIP pulse */
// omap_writeb((1 << 7) | (1 << 6) | (1 << 4), UART3_ACREG);
omap_writeb((1 << 6) | (1 << 4), UART3_ACREG);
/* Enable EOF Interrupt only */
omap_writeb((1 << 7) | (1 << 5), UART3_IER);
/* Set Maximum Received Frame size to 2048 bytes */
omap_writeb(0x00, UART3_RXFLL);
omap_writeb(0x08, UART3_RXFLH);
omap_readb(UART3_RESUME);
__ECHO_OUT;
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;
/* 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;
}
/* no error returns, they'd just make bus scanning stop */
static int isp1301_probe(struct i2c_adapter *bus, int address, int kind)
{
int status;
struct isp1301 *isp;
struct i2c_client *i2c;
if (the_transceiver)
return 0;
isp = kzalloc(sizeof *isp, GFP_KERNEL);
if (!isp)
return 0;
INIT_WORK(&isp->work, isp1301_work, isp);
init_timer(&isp->timer);
isp->timer.function = isp1301_timer;
isp->timer.data = (unsigned long) isp;
isp->irq = -1;
isp->client.addr = address;
i2c_set_clientdata(&isp->client, isp);
isp->client.adapter = bus;
isp->client.driver = &isp1301_driver;
strlcpy(isp->client.name, DRIVER_NAME, I2C_NAME_SIZE);
i2c = &isp->client;
/* if this is a true probe, verify the chip ... */
if (kind < 0) {
status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
if (status != I2C_VENDOR_ID_PHILIPS) {
dev_dbg(&bus->dev, "addr %d not philips id: %d\n",
address, status);
goto fail1;
}
status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
if (status != I2C_PRODUCT_ID_PHILIPS_1301) {
dev_dbg(&bus->dev, "%d not isp1301, %d\n",
address, status);
goto fail1;
}
}
status = i2c_attach_client(i2c);
if (status < 0) {
dev_dbg(&bus->dev, "can't attach %s to device %d, err %d\n",
DRIVER_NAME, address, status);
fail1:
kfree(isp);
return 0;
}
isp->i2c_release = i2c->dev.release;
i2c->dev.release = isp1301_release;
/* initial development used chiprev 2.00 */
status = i2c_smbus_read_word_data(i2c, ISP1301_BCD_DEVICE);
dev_info(&i2c->dev, "chiprev %x.%02x, driver " DRIVER_VERSION "\n",
status >> 8, status & 0xff);
/* make like power-on reset */
isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_MASK);
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_BI_DI);
isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, ~MC2_BI_DI);
isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN);
isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
~(OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN));
isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
#ifdef CONFIG_USB_OTG
status = otg_bind(isp);
if (status < 0) {
dev_dbg(&i2c->dev, "can't bind OTG\n");
goto fail2;
}
#endif
if (machine_is_omap_h2()) {
/* full speed signaling by default */
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
MC1_SPEED_REG);
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2,
MC2_SPD_SUSP_CTRL);
/* IRQ wired at M14 */
omap_cfg_reg(M14_1510_GPIO2);
isp->irq = OMAP_GPIO_IRQ(2);
omap_request_gpio(2);
omap_set_gpio_direction(2, 1);
omap_set_gpio_edge_ctrl(2, OMAP_GPIO_FALLING_EDGE);
}
status = request_irq(isp->irq, isp1301_irq,
IRQF_SAMPLE_RANDOM, DRIVER_NAME, isp);
if (status < 0) {
dev_dbg(&i2c->dev, "can't get IRQ %d, err %d\n",
isp->irq, status);
#ifdef CONFIG_USB_OTG
fail2:
#endif
i2c_detach_client(i2c);
goto fail1;
}
isp->otg.dev = &isp->client.dev;
isp->otg.label = DRIVER_NAME;
isp->otg.set_host = isp1301_set_host,
isp->otg.set_peripheral = isp1301_set_peripheral,
isp->otg.set_power = isp1301_set_power,
isp->otg.start_srp = isp1301_start_srp,
isp->otg.start_hnp = isp1301_start_hnp,
enable_vbus_draw(isp, 0);
power_down(isp);
the_transceiver = isp;
#ifdef CONFIG_USB_OTG
update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
#endif
dump_regs(isp, __FUNCTION__);
#ifdef VERBOSE
mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
dev_dbg(&i2c->dev, "scheduled timer, %d min\n", TIMER_MINUTES);
#endif
status = otg_set_transceiver(&isp->otg);
if (status < 0)
dev_err(&i2c->dev, "can't register transceiver, %d\n",
status);
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;
}
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;
}
/*
* 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;
}
