static void ams_delta_write_byte(struct mtd_info *mtd, u_char byte) { struct nand_chip *this = mtd->priv; void __iomem *io_base = this->priv; writew(0, io_base + OMAP_MPUIO_IO_CNTL); writew(byte, this->IO_ADDR_W); ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NWE, 0); ndelay(40); ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NWE, AMS_DELTA_LATCH2_NAND_NWE); }
static int ams_delta_panel_enable(struct lcd_panel *panel) { ams_delta_latch2_write(AMS_DELTA_LATCH2_LCD_NDISP, AMS_DELTA_LATCH2_LCD_NDISP); ams_delta_latch2_write(AMS_DELTA_LATCH2_LCD_VBLEN, AMS_DELTA_LATCH2_LCD_VBLEN); omap_writeb(1, OMAP_PWL_CLK_ENABLE); omap_writeb(AMS_DELTA_DEFAULT_CONTRAST, OMAP_PWL_ENABLE); return 0; }
static u_char ams_delta_read_byte(struct mtd_info *mtd) { u_char res; struct nand_chip *this = mtd->priv; ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE, 0); ndelay(40); omap_writew(~0, (OMAP_MPUIO_BASE + OMAP_MPUIO_IO_CNTL)); res = omap_readw(this->IO_ADDR_R); ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE, AMS_DELTA_LATCH2_NAND_NRE); return res; }
static u_char ams_delta_read_byte(struct mtd_info *mtd) { u_char res; struct nand_chip *this = mtd->priv; void __iomem *io_base = this->priv; ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE, 0); ndelay(40); writew(~0, io_base + OMAP_MPUIO_IO_CNTL); res = readw(this->IO_ADDR_R); ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE, AMS_DELTA_LATCH2_NAND_NRE); return res; }
static int __init late_init(void) { int err; if (!machine_is_ams_delta()) return -ENODEV; err = gpio_request_array(latch_gpios, ARRAY_SIZE(latch_gpios)); if (err) { pr_err("Couldn't take over latch1/latch2 GPIO pins\n"); return err; } platform_add_devices(late_devices, ARRAY_SIZE(late_devices)); err = platform_device_register(&modem_nreset_device); if (err) { pr_err("Couldn't register the modem regulator device\n"); return err; } omap_cfg_reg(M14_1510_GPIO2); ams_delta_modem_ports[0].irq = gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ); err = gpio_request(AMS_DELTA_GPIO_PIN_MODEM_IRQ, "modem"); if (err) { pr_err("Couldn't request gpio pin for modem\n"); return err; } gpio_direction_input(AMS_DELTA_GPIO_PIN_MODEM_IRQ); /* Initialize the modem_nreset regulator consumer before use */ modem_priv.regulator = ERR_PTR(-ENODEV); ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC, AMS_DELTA_LATCH2_MODEM_CODEC); err = platform_device_register(&ams_delta_modem_device); if (err) goto gpio_free; /* * Once the modem device is registered, the modem_nreset * regulator can be requested on behalf of that device. */ modem_priv.regulator = regulator_get(&ams_delta_modem_device.dev, "RESET#"); if (IS_ERR(modem_priv.regulator)) { err = PTR_ERR(modem_priv.regulator); goto unregister; } return 0; unregister: platform_device_unregister(&ams_delta_modem_device); gpio_free: gpio_free(AMS_DELTA_GPIO_PIN_MODEM_IRQ); return err; }
static int __init ams_delta_modem_init(void) { omap_cfg_reg(M14_1510_GPIO2); ams_delta_modem_ports[0].irq = gpio_to_irq(2); ams_delta_latch2_write( AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC, AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC); return platform_device_register(&ams_delta_modem_device); }
/* Board specific codec bias level control */ static int ams_delta_set_bias_level(struct snd_soc_card *card, struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level) { switch (level) { case SND_SOC_BIAS_ON: case SND_SOC_BIAS_PREPARE: case SND_SOC_BIAS_STANDBY: if (card->dapm.bias_level == SND_SOC_BIAS_OFF) ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_NRESET, AMS_DELTA_LATCH2_MODEM_NRESET); break; case SND_SOC_BIAS_OFF: if (card->dapm.bias_level != SND_SOC_BIAS_OFF) ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_NRESET, 0); } card->dapm.bias_level = level; return 0; }
static void __init ams_delta_init(void) { iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc)); omap_board_config = ams_delta_config; omap_board_config_size = ARRAY_SIZE(ams_delta_config); omap_serial_init(); /* Clear latch2 (NAND, LCD, modem enable) */ ams_delta_latch2_write(~0, 0); platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices)); }
/* Line discipline .receive_buf() */ static void cx81801_receive(struct tty_struct *tty, const unsigned char *cp, char *fp, int count) { struct snd_soc_codec *codec = tty->disc_data; const unsigned char *c; int apply, ret; if (!codec) return; if (!codec->hw_write) { /* First modem response, complete setup procedure */ /* Initialize timer used for config pulse generation */ setup_timer(&cx81801_timer, cx81801_timeout, 0); v253_ops.receive_buf(tty, cp, fp, count); /* Link hook switch to DAPM pins */ ret = snd_soc_jack_add_pins(&ams_delta_hook_switch, ARRAY_SIZE(ams_delta_hook_switch_pins), ams_delta_hook_switch_pins); if (ret) dev_warn(codec->dev, "Failed to link hook switch to DAPM pins, " "will continue with hook switch unlinked.\n"); return; } v253_ops.receive_buf(tty, cp, fp, count); for (c = &cp[count - 1]; c >= cp; c--) { if (*c != '\r') continue; /* Complete modem response received, apply config to codec */ spin_lock_bh(&ams_delta_lock); mod_timer(&cx81801_timer, jiffies + msecs_to_jiffies(150)); apply = !ams_delta_muted && !cx81801_cmd_pending; cx81801_cmd_pending = 1; spin_unlock_bh(&ams_delta_lock); /* Apply config pulse by connecting the codec to the modem * if not already done */ if (apply) ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC, AMS_DELTA_LATCH2_MODEM_CODEC); break; } }
static void cx81801_timeout(unsigned long data) { int muted; spin_lock(&ams_delta_lock); cx81801_cmd_pending = 0; muted = ams_delta_muted; spin_unlock(&ams_delta_lock); /* Reconnect the codec DAI back from the modem to the CPU DAI * only if digital mute still off */ if (!muted) ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC, 0); }
static int ams_delta_digital_mute(struct snd_soc_dai *dai, int mute) { int apply; if (ams_delta_muted == mute) return 0; spin_lock_bh(&ams_delta_lock); ams_delta_muted = mute; apply = !cx81801_cmd_pending; spin_unlock_bh(&ams_delta_lock); if (apply) ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC, mute ? AMS_DELTA_LATCH2_MODEM_CODEC : 0); return 0; }
static void __init ams_delta_init(void) { /* mux pins for uarts */ omap_cfg_reg(UART1_TX); omap_cfg_reg(UART1_RTS); /* parallel camera interface */ omap_cfg_reg(H19_1610_CAM_EXCLK); omap_cfg_reg(J15_1610_CAM_LCLK); omap_cfg_reg(L18_1610_CAM_VS); omap_cfg_reg(L15_1610_CAM_HS); omap_cfg_reg(L19_1610_CAM_D0); omap_cfg_reg(K14_1610_CAM_D1); omap_cfg_reg(K15_1610_CAM_D2); omap_cfg_reg(K19_1610_CAM_D3); omap_cfg_reg(K18_1610_CAM_D4); omap_cfg_reg(J14_1610_CAM_D5); omap_cfg_reg(J19_1610_CAM_D6); omap_cfg_reg(J18_1610_CAM_D7); iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc)); omap_board_config = ams_delta_config; omap_board_config_size = ARRAY_SIZE(ams_delta_config); omap_serial_init(); omap_register_i2c_bus(1, 100, NULL, 0); /* Clear latch2 (NAND, LCD, modem enable) */ ams_delta_latch2_write(~0, 0); omap1_usb_init(&ams_delta_usb_config); omap1_set_camera_info(&ams_delta_camera_platform_data); #ifdef CONFIG_LEDS_TRIGGERS led_trigger_register_simple("ams_delta_camera", &ams_delta_camera_led_trigger); #endif platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices)); #ifdef CONFIG_AMS_DELTA_FIQ ams_delta_init_fiq(); #endif omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1); }
/* * Command control function * * ctrl: * NAND_NCE: bit 0 -> bit 2 * NAND_CLE: bit 1 -> bit 7 * NAND_ALE: bit 2 -> bit 6 */ static void ams_delta_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl) { if (ctrl & NAND_CTRL_CHANGE) { unsigned long bits; bits = (~ctrl & NAND_NCE) ? AMS_DELTA_LATCH2_NAND_NCE : 0; bits |= (ctrl & NAND_CLE) ? AMS_DELTA_LATCH2_NAND_CLE : 0; bits |= (ctrl & NAND_ALE) ? AMS_DELTA_LATCH2_NAND_ALE : 0; ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_CLE | AMS_DELTA_LATCH2_NAND_ALE | AMS_DELTA_LATCH2_NAND_NCE, bits); } if (cmd != NAND_CMD_NONE) ams_delta_write_byte(mtd, cmd); }
static int __init ams_delta_modem_init(void) { int err; omap_cfg_reg(M14_1510_GPIO2); ams_delta_modem_ports[0].irq = gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ); err = gpio_request(AMS_DELTA_GPIO_PIN_MODEM_IRQ, "modem"); if (err) { pr_err("Couldn't request gpio pin for modem\n"); return err; } gpio_direction_input(AMS_DELTA_GPIO_PIN_MODEM_IRQ); ams_delta_latch2_write( AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC, AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC); return platform_device_register(&ams_delta_modem_device); }
static void __init ams_delta_init(void) { /* mux pins for uarts */ omap_cfg_reg(UART1_TX); omap_cfg_reg(UART1_RTS); iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc)); omap_board_config = ams_delta_config; omap_board_config_size = ARRAY_SIZE(ams_delta_config); omap_serial_init(); omap_register_i2c_bus(1, 100, NULL, 0); /* Clear latch2 (NAND, LCD, modem enable) */ ams_delta_latch2_write(~0, 0); omap_usb_init(&ams_delta_usb_config); platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices)); omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1); }
static int __init late_init(void) { int err; if (!machine_is_ams_delta()) return -ENODEV; err = gpio_request_array(latch_gpios, ARRAY_SIZE(latch_gpios)); if (err) { pr_err("Couldn't take over latch1/latch2 GPIO pins\n"); return err; } platform_add_devices(late_devices, ARRAY_SIZE(late_devices)); omap_cfg_reg(M14_1510_GPIO2); ams_delta_modem_ports[0].irq = gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ); err = gpio_request(AMS_DELTA_GPIO_PIN_MODEM_IRQ, "modem"); if (err) { pr_err("Couldn't request gpio pin for modem\n"); return err; } gpio_direction_input(AMS_DELTA_GPIO_PIN_MODEM_IRQ); ams_delta_latch2_write( AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC, AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC); err = platform_device_register(&ams_delta_modem_device); if (err) goto gpio_free; return 0; gpio_free: gpio_free(AMS_DELTA_GPIO_PIN_MODEM_IRQ); return err; }
static void ams_delta_panel_disable(struct lcd_panel *panel) { ams_delta_latch2_write(AMS_DELTA_LATCH2_LCD_VBLEN, 0); ams_delta_latch2_write(AMS_DELTA_LATCH2_LCD_NDISP, 0); }
/* * Main initialization routine */ static int __init ams_delta_init(void) { struct nand_chip *this; int err = 0; /* Allocate memory for MTD device structure and private data */ ams_delta_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL); if (!ams_delta_mtd) { printk (KERN_WARNING "Unable to allocate E3 NAND MTD device structure.\n"); err = -ENOMEM; goto out; } ams_delta_mtd->owner = THIS_MODULE; /* Get pointer to private data */ this = (struct nand_chip *) (&ams_delta_mtd[1]); /* Initialize structures */ memset(ams_delta_mtd, 0, sizeof(struct mtd_info)); memset(this, 0, sizeof(struct nand_chip)); /* Link the private data with the MTD structure */ ams_delta_mtd->priv = this; /* Set address of NAND IO lines */ this->IO_ADDR_R = (OMAP_MPUIO_BASE + OMAP_MPUIO_INPUT_LATCH); this->IO_ADDR_W = (OMAP_MPUIO_BASE + OMAP_MPUIO_OUTPUT); this->read_byte = ams_delta_read_byte; this->write_buf = ams_delta_write_buf; this->read_buf = ams_delta_read_buf; this->verify_buf = ams_delta_verify_buf; this->cmd_ctrl = ams_delta_hwcontrol; if (gpio_request(AMS_DELTA_GPIO_PIN_NAND_RB, "nand_rdy") == 0) { this->dev_ready = ams_delta_nand_ready; } else { this->dev_ready = NULL; printk(KERN_NOTICE "Couldn't request gpio for Delta NAND ready.\n"); } /* 25 us command delay time */ this->chip_delay = 30; this->ecc.mode = NAND_ECC_SOFT; /* Set chip enabled, but */ ams_delta_latch2_write(NAND_MASK, AMS_DELTA_LATCH2_NAND_NRE | AMS_DELTA_LATCH2_NAND_NWE | AMS_DELTA_LATCH2_NAND_NCE | AMS_DELTA_LATCH2_NAND_NWP); /* Scan to find existance of the device */ if (nand_scan(ams_delta_mtd, 1)) { err = -ENXIO; goto out_mtd; } /* Register the partitions */ add_mtd_partitions(ams_delta_mtd, partition_info, ARRAY_SIZE(partition_info)); goto out; out_mtd: kfree(ams_delta_mtd); out: return err; }
/* * Main initialization routine */ static int __devinit ams_delta_init(struct platform_device *pdev) { struct nand_chip *this; struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0); void __iomem *io_base; int err = 0; if (!res) return -ENXIO; /* Allocate memory for MTD device structure and private data */ ams_delta_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL); if (!ams_delta_mtd) { printk (KERN_WARNING "Unable to allocate E3 NAND MTD device structure.\n"); err = -ENOMEM; goto out; } ams_delta_mtd->owner = THIS_MODULE; /* Get pointer to private data */ this = (struct nand_chip *) (&ams_delta_mtd[1]); /* Initialize structures */ memset(ams_delta_mtd, 0, sizeof(struct mtd_info)); memset(this, 0, sizeof(struct nand_chip)); /* Link the private data with the MTD structure */ ams_delta_mtd->priv = this; if (!request_mem_region(res->start, resource_size(res), dev_name(&pdev->dev))) { dev_err(&pdev->dev, "request_mem_region failed\n"); err = -EBUSY; goto out_free; } io_base = ioremap(res->start, resource_size(res)); if (io_base == NULL) { dev_err(&pdev->dev, "ioremap failed\n"); err = -EIO; goto out_release_io; } this->priv = io_base; /* Set address of NAND IO lines */ this->IO_ADDR_R = io_base + OMAP_MPUIO_INPUT_LATCH; this->IO_ADDR_W = io_base + OMAP_MPUIO_OUTPUT; this->read_byte = ams_delta_read_byte; this->write_buf = ams_delta_write_buf; this->read_buf = ams_delta_read_buf; this->verify_buf = ams_delta_verify_buf; this->cmd_ctrl = ams_delta_hwcontrol; if (gpio_request(AMS_DELTA_GPIO_PIN_NAND_RB, "nand_rdy") == 0) { this->dev_ready = ams_delta_nand_ready; } else { this->dev_ready = NULL; printk(KERN_NOTICE "Couldn't request gpio for Delta NAND ready.\n"); } /* 25 us command delay time */ this->chip_delay = 30; this->ecc.mode = NAND_ECC_SOFT; platform_set_drvdata(pdev, io_base); /* Set chip enabled, but */ ams_delta_latch2_write(NAND_MASK, AMS_DELTA_LATCH2_NAND_NRE | AMS_DELTA_LATCH2_NAND_NWE | AMS_DELTA_LATCH2_NAND_NCE | AMS_DELTA_LATCH2_NAND_NWP); /* Scan to find existence of the device */ if (nand_scan(ams_delta_mtd, 1)) { err = -ENXIO; goto out_mtd; } /* Register the partitions */ mtd_device_register(ams_delta_mtd, partition_info, ARRAY_SIZE(partition_info)); goto out; out_mtd: platform_set_drvdata(pdev, NULL); iounmap(io_base); out_release_io: release_mem_region(res->start, resource_size(res)); out_free: kfree(ams_delta_mtd); out: return err; }