static int ov9640_sensor_power_set(int power)
{
unsigned char expa;
int err;
/* read current state of GPIO EXPA outputs */
if ((err = read_gpio_expa(&expa, 0x20))) {
printk(KERN_ERR "Error reading GPIO EXPA 0x20\n");
return err;
}
expa = power ? expa | 0x80 : expa & ~0x08;
/* Set GPIO EXPA P3 (CAMERA_MODULE_EN) to power-up sensor */
if ((err = write_gpio_expa(expa, 0x20))) {
printk(KERN_ERR "Error writing to GPIO EXPA 0x20\n");
return err;
}
if (power) {
/* read current state of GPIO EXPA outputs */
if ((err = read_gpio_expa(&expa, 0x22))) {
printk(KERN_ERR "Error reading GPIO EXPA\n");
return err;
}
/* Clear GPIO EXPA P7 (CAM_RST) */
if ((err = write_gpio_expa(expa & ~0x80, 0x22))) {
printk(KERN_ERR "Error writing to GPIO EXPA\n");
return err;
}
}
return err;
}
/* Select between the IrDA and aGPS module
*/
static int h3_select_irda(struct device *dev, int state)
{
unsigned char expa;
int err = 0;
if ((err = read_gpio_expa(&expa, 0x26))) {
printk(KERN_ERR "Error reading from I/O EXPANDER \n");
return err;
}
/* 'P6' enable/disable IRDA_TX and IRDA_RX */
if (state & IR_SEL) { /* IrDA */
if ((err = write_gpio_expa(expa | 0x40, 0x26))) {
printk(KERN_ERR "Error writing to I/O EXPANDER \n");
return err;
}
} else {
if ((err = write_gpio_expa(expa & ~0x40, 0x26))) {
printk(KERN_ERR "Error writing to I/O EXPANDER \n");
return err;
}
}
return err;
}
int
h3_sensor_powerdown(void)
{
unsigned char expa;
int err;
/* read the current state of GPIO EXPA output */
if (( err = read_gpio_expa(&expa, 0x27))) {
printk(KERN_ERR "Error reading GPIO EXPA \n");
return err;
}
/* clear GPIO EXPA P7 CAMERA_MOD_EN to power-up sensor */
if ((err = write_gpio_expa(expa & ~0x80, 0x27))) {
printk(KERN_ERR "Error writing to GPIO EXPA \n");
return err;
}
return 0;
}
static void set_h3_gpio_expa(u8 FIR_SEL, u8 IrDA_INVSEL)
{
u8 ioExpanderVal = 0;
if (read_gpio_expa(&ioExpanderVal, 0x27) != 0) {
printk(KERN_ERR "Error reading from I/O EXPANDER \n");
return;
}
ioExpanderVal &= ~0x03;
ioExpanderVal |= FIR_SEL << 1;
ioExpanderVal |= IrDA_INVSEL << 0;
if (write_gpio_expa(ioExpanderVal, 0x27) != 0) {
printk(KERN_ERR "Error writing to I/O EXPANDER \n");
return;
}
if (read_gpio_expa(&ioExpanderVal, 0x27) != 0) {
printk(KERN_ERR "Error reading from I/O EXPANDER \n");
return;
}
}
static void set_trans_mode(struct work_struct *work)
{
struct omap_irda_config *irda_config =
container_of(work, struct omap_irda_config, gpio_expa.work);
int mode = irda_config->mode;
unsigned char expa;
int err = 0;
if ((err = read_gpio_expa(&expa, 0x20)) != 0) {
printk(KERN_ERR "Error reading from I/O expander\n");
}
expa &= ~0x01;
if (!(mode & IR_SIRMODE)) { /* MIR/FIR */
expa |= 0x01;
}
if ((err = write_gpio_expa(expa, 0x20)) != 0) {
printk(KERN_ERR "Error writing to I/O expander\n");
}
}
/* 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 omap1610_irda_start(struct net_device *dev)
{
struct omap1610_irda *si = dev->priv;
int err;
unsigned long flags = 0;
#ifdef CONFIG_MACH_OMAP_H3
u8 ioExpanderVal = 0;
#endif
__ECHO_IN;
si->speed = 9600;
err = request_irq(dev->irq, omap1610_irda_irq, 0, dev->name, dev);
if (err)
goto err_irq;
/*
* The interrupt must remain disabled for now.
*/
disable_irq(dev->irq);
/* Request DMA channels for IrDA hardware */
if (omap_request_dma(OMAP_DMA_UART3_RX, "IrDA Rx DMA",
(void *)omap1610_irda_rx_dma_callback,
dev, &(si->rx_dma_channel))) {
printk(KERN_ERR "Failed to request IrDA Rx DMA \n");
goto err_irq;
}
if (omap_request_dma(OMAP_DMA_UART3_TX, "IrDA Tx DMA",
(void *)omap1610_irda_tx_dma_callback,
dev, &(si->tx_dma_channel))) {
printk(KERN_ERR "Failed to request IrDA Tx DMA \n");
goto err_irq;
}
/* Allocate TX and RX buffers for DMA channels */
si->rx_buf_dma_virt =
dma_alloc_coherent(NULL, 4096, &(si->rx_buf_dma_phys), flags);
si->tx_buf_dma_virt =
dma_alloc_coherent(NULL, 4096, &(si->tx_buf_dma_phys), flags);
/*
* Setup the serial port for the specified config.
*/
#if CONFIG_MACH_OMAP_H3
if ((err = read_gpio_expa(&ioExpanderVal, 0x26))) {
printk(KERN_ERR "Error reading from I/O EXPANDER \n");
return err;
}
ioExpanderVal |= 0x40; /* 'P6' Enable IRDA_TX and IRDA_RX */
if ((err = write_gpio_expa(ioExpanderVal, 0x26))) {
printk(KERN_ERR "Error writing to I/O EXPANDER \n");
return err;
}
#endif
err = omap1610_irda_startup(dev);
if (err)
goto err_startup;
omap1610_irda_set_speed(dev, si->speed = 9600);
/*
* Open a new IrLAP layer instance.
*/
si->irlap = irlap_open(dev, &si->qos, "omap_sir");
err = -ENOMEM;
if (!si->irlap)
goto err_irlap;
/* Now enable the interrupt and start the queue */
si->open = 1;
/* Start RX DMA */
omap1610_irda_start_rx_dma(si);
enable_irq(dev->irq);
netif_start_queue(dev);
__ECHO_OUT;
return 0;
err_irlap:
si->open = 0;
omap1610_irda_shutdown(si);
err_startup:
err_irq:
free_irq(dev->irq, dev);
return err;
}
