int __init panel_fwvga_43_init(struct omap_dss_device *disp_data)
{
const struct archos_display_config *disp_cfg;
int ret = -ENODEV;
printk("panel_fwvga_43_init\n");
disp_cfg = omap_get_config( ARCHOS_TAG_DISPLAY, struct archos_display_config );
if (disp_cfg == NULL)
return ret;
if ( hardware_rev >= disp_cfg->nrev ) {
printk(KERN_DEBUG "archos_display_init: hardware_rev (%i) >= nrev (%i)\n",
hardware_rev, disp_cfg->nrev);
return ret;
}
*disp_data = lg_fwvga_43_panel;
display_gpio = disp_cfg->rev[hardware_rev];
archos_gpio_init_output(&display_gpio.lcd_pwon, "LCD_PWON");
archos_gpio_init_output(&display_gpio.lcd_rst, "LCD_RST");
#if !defined(CONFIG_FB_OMAP_BOOTLOADER_INIT)
panel_disable(&lg_fwvga_43_panel);
#endif
return 0;
}
void __init archos_usb_ehci_init(void)
{
const struct archos_usb_config *usb_cfg;
usb_cfg = omap_get_config( ARCHOS_TAG_USB, struct archos_usb_config );
if (usb_cfg == NULL) {
printk(KERN_DEBUG "%s: no board configuration found\n", __FUNCTION__);
return;
}
if ( hardware_rev >= usb_cfg->nrev ) {
printk(KERN_DEBUG "%s: hardware_rev (%i) >= nrev (%i)\n",
__FUNCTION__, hardware_rev, usb_cfg->nrev);
return;
}
if ( GPIO_PIN (usb_cfg->rev[hardware_rev].enable_usb_hub) != 0 ) {
gio_hub_enable = usb_cfg->rev[hardware_rev].enable_usb_hub;
archos_gpio_init_output(&gio_hub_enable, "hub enable");
}
if ( GPIO_PIN (usb_cfg->rev[hardware_rev].enable_5v) != 0 ) {
gio_5v_enable = usb_cfg->rev[hardware_rev].enable_5v;
archos_gpio_init_output(&gio_5v_enable, "5v enable");
}
if ( GPIO_PIN (usb_cfg->rev[hardware_rev].enable_usb_ehci) != 0 ) {
gio_ehci_enable = usb_cfg->rev[hardware_rev].enable_usb_ehci;
archos_gpio_init_output(&gio_ehci_enable, "ehci enable");
archos_enable_ehci( 0 );
setup_ehci_io_mux();
}
#if defined(CONFIG_USB_EHCI_HCD) || defined(CONFIG_USB_EHCI_HCD_MODULE)
if (platform_device_register(&ehci_device) < 0) {
printk(KERN_ERR "Unable to register HS-USB (EHCI) device\n");
return;
}
#endif
if (platform_device_register(&archos_ehci_device) < 0)
printk(KERN_ERR "Unable to register Archos EHCI device\n");
device_create_file(&archos_ehci_device.dev, &dev_attr_ehci_enable);
device_create_file(&archos_ehci_device.dev, &dev_attr_hub_enable);
platform_driver_register(&archos_ehci_driver);
}
static int __init panel_init(void)
{
if (!have_panel)
return -ENODEV;
pr_debug("panel_init\n");
archos_gpio_init_output( display_gpio.lcd_pwon, "lcd_pwon" );
archos_gpio_init_output( display_gpio.bridge_en, "bridge_en" );
if (gpio_is_valid(display_gpio.lcd_stdby)){
if (gpio_request(display_gpio.lcd_stdby, "dc_en") < 0) {
pr_debug("gpio_init_output: cannot acquire GPIO%d \n", display_gpio.lcd_stdby);
return -1;
}
}
omap_mux_init_signal("gpmc_ncs4.gpio_101", OMAP_PIN_OUTPUT );
gpio_direction_output(display_gpio.lcd_stdby, 0);
archos_gpio_init_output( display_gpio.lcd_avdd_en, "bkl_en" );
if (display_gpio.use_fixed_bkl) {
if (gpio_is_valid(display_gpio.bkl_en)) {
archos_gpio_init_output(display_gpio.bkl_en, "bkl_en");
gpio_set_value( display_gpio.bkl_en, 1);
}
if (gpio_is_valid(display_gpio.bkl_pwr)) {
archos_gpio_init_output(display_gpio.bkl_pwr, "bkl_power");
gpio_set_value( display_gpio.bkl_pwr, 0);
}
}
if (gpio_is_valid(display_gpio.lcd_pwon))
gpio_set_value( display_gpio.lcd_pwon, 0);
if (gpio_is_valid(display_gpio.bridge_en))
gpio_set_value( display_gpio.bridge_en, 0);
if (gpio_is_valid(display_gpio.lcd_stdby))
gpio_set_value( display_gpio.lcd_stdby, 1);
if (gpio_is_valid(display_gpio.lcd_avdd_en))
gpio_set_value( display_gpio.lcd_avdd_en, 1);
/* regulators */
lcd_1v8 = regulator_get(&lcd_device.dev, "LCD_1V8");
if (IS_ERR(lcd_1v8))
dev_dbg(&lcd_device.dev, "no LCD_1V8 for this display\n");
lcd_vcc = regulator_get(&lcd_device.dev, "LCD_VCC");
if (IS_ERR(lcd_vcc))
dev_dbg(&lcd_device.dev, "no LCD_VCC for this display\n");
return 0;
}
void __init archos_usb_ohci_init(void)
{
#if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
const struct archos_fsusb_config *usb_cfg;
usb_cfg = omap_get_config( ARCHOS_TAG_FSUSB, struct archos_fsusb_config );
if (usb_cfg == NULL) {
printk(KERN_DEBUG "%s: no board configuration found\n", __FUNCTION__);
return;
}
if ( hardware_rev >= usb_cfg->nrev ) {
printk(KERN_DEBUG "%s: hardware_rev (%i) >= nrev (%i)\n",
__FUNCTION__, hardware_rev, usb_cfg->nrev);
return;
}
printk("archos_usb_ohci_init\n");
if ( GPIO_EXISTS(usb_cfg->rev[hardware_rev].enable_usb_ohci)) {
gio_ohci_enable = usb_cfg->rev[hardware_rev].enable_usb_ohci;
archos_gpio_init_output( &gio_ohci_enable, "fsusb_enable" );
archos_enable_ohci( 0 );
gio_ohci_suspend = usb_cfg->rev[hardware_rev].suspend;
archos_gpio_init_output( &gio_ohci_suspend, "fsusb_suspend" );
gpio_set_value( GPIO_PIN(gio_ohci_suspend), 0);
archos_enable_ohci( 1 );
}
omap_cfg_reg(AG8_3430_USB2FS_RCV);
omap_cfg_reg(AH8_3430_USB2FS_VM);
omap_cfg_reg(AB2_3430_USB2FS_VP);
omap_cfg_reg(V3_3430_USB2FS_EN);
if (platform_device_register(&ohci_device) < 0) {
printk(KERN_ERR "Unable to register FS-USB (OHCI) device\n");
return;
}
device_create_file(&ohci_device.dev, &dev_attr_fsusb_enable);
device_create_file(&ohci_device.dev, &dev_attr_fsusb_suspend);
#endif
}
static int panel_init(struct omap_dss_device *ddata)
{
pr_debug("panel_init [%s]\n", ddata->name);
archos_gpio_init_output(&display_gpio.lcd_pwon, "lcd_pwon");
archos_gpio_init_output(&display_gpio.lcd_rst, "lcd_rst");
#if !defined(CONFIG_FB_OMAP_BOOTLOADER_INIT)
if (GPIO_EXISTS(display_gpio.lcd_pwon))
gpio_set_value( GPIO_PIN(display_gpio.lcd_pwon), 0);
if (GPIO_EXISTS(display_gpio.lcd_rst))
gpio_set_value( GPIO_PIN(display_gpio.lcd_rst), 0);
#endif
return 0;
}
int __init ads7846_dev_init(void)
{
const struct archos_tsp_config *tsp_cfg;
tsp_cfg = omap_get_config( ARCHOS_TAG_TSP, struct archos_tsp_config );
/* might be NULL */
if (tsp_cfg == NULL) {
printk(KERN_DEBUG "ads7846_dev_init: no board configuration found\n");
return -ENODEV;
}
if ( hardware_rev >= tsp_cfg->nrev ) {
printk(KERN_DEBUG "ads7846_dev_init: hardware_rev (%i) >= nrev (%i)\n",
hardware_rev, tsp_cfg->nrev);
return -ENODEV;
}
ts_irq = tsp_cfg->rev[hardware_rev].irq_gpio;
ts_pwron = tsp_cfg->rev[hardware_rev].pwr_gpio;
tsc2046_config.x_plate_ohms = tsp_cfg->rev[hardware_rev].x_plate_ohms;
tsc2046_config.pressure_max = tsp_cfg->rev[hardware_rev].pressure_max;
tsc2046_config.inversion_flags = tsp_cfg->rev[hardware_rev].inversion_flags;
if (tsp_cfg->rev[hardware_rev].bus_num != 0)
ts_spi_board_info[0].bus_num = tsp_cfg->rev[hardware_rev].bus_num;
if (tsp_cfg->rev[hardware_rev].filter_factor != 0)
filter_factor = tsp_cfg->rev[hardware_rev].filter_factor;
switch (tsp_cfg->rev[hardware_rev].filter_type) {
case 1: tsc2046_config.filter = simple_filter; break;
default: break;
}
if (tsp_cfg->rev[hardware_rev].bus_num == 2) {
omap_cfg_reg(AA3_3430_MCSPI2_CLK);
omap_cfg_reg(Y2_3430_MCSPI2_SIMO);
omap_cfg_reg(Y3_3430_MCSPI2_SOMI);
omap_cfg_reg(Y4_3430_MCSPI2_CS0);
}
printk(KERN_DEBUG "ads7846_dev_init: irq_gpio %i, pwr_gpio %i\n",
ts_irq.nb, ts_pwron.nb);
archos_gpio_init_output(&ts_pwron, "ts_pwron");
tsc2046_config.gpio_pendown = GPIO_PIN(ts_irq);
ads7846_vaux_control( VAUX_DISABLE );
/* fix spi irq gio nb */
ts_spi_board_info[0].irq = OMAP_GPIO_IRQ(GPIO_PIN(ts_irq));
spi_register_board_info(ts_spi_board_info, 1);
return 0;
}
static void panel_tv_init(void)
{
if (hardware_rev >= display_config.nrev)
return;
pr_info("panel_tv_init\n");
if (GPIO_EXISTS(display_config.rev[hardware_rev].cvbs_on)) {
cvbs_on = display_config.rev[hardware_rev].cvbs_on;
archos_gpio_init_output(&cvbs_on, "cvbs enable");
gpio_set_value( GPIO_PIN(cvbs_on), 0 );
}
}
static void __init archos_hdmi_gpio_init(
const struct archos_disp_conf* disp_conf)
{
/* driver will manage the GPIO, just apply the pin multiplexing
* archos_gpio_init_input(&disp_conf->hdmi_int, "hdmi irq"); */
omap_cfg_reg(GPIO_MUX(disp_conf->hdmi_int));
archos_gpio_init_output(&disp_conf->hdmi_pwr, "hdmi pwr");
/* FIXME: make userspace configurable */
gpio_set_value(GPIO_PIN(disp_conf->hdmi_pwr), 1);
/* patch power gpio into platform data */
board_hdmi_pdata.pwr_gpio = GPIO_PIN(disp_conf->hdmi_pwr);
/* patch IRQ into HDMI I2C bus info */
board_i2c_bus2_info[1].irq = gpio_to_irq(GPIO_PIN(disp_conf->hdmi_int));
board_i2c_bus2_info[2].irq = gpio_to_irq(GPIO_PIN(disp_conf->hdmi_int));
omap_cfg_reg(H26_3630_DSS_DATA0);
omap_cfg_reg(H25_3630_DSS_DATA1);
omap_cfg_reg(E28_3630_DSS_DATA2);
omap_cfg_reg(J26_3630_DSS_DATA3);
omap_cfg_reg(AC27_3630_DSS_DATA4);
omap_cfg_reg(AC28_3630_DSS_DATA5);
omap_cfg_reg(D26_3630_DSS_HSYNC);
omap_cfg_reg(D27_3630_DSS_VSYNC);
omap_cfg_reg(D28_3630_DSS_PCLK);
omap_cfg_reg(E27_3630_DSS_ACBIAS);
omap_cfg_reg(E26_3630_DSS_DATA6);
omap_cfg_reg(F28_3630_DSS_DATA7);
omap_cfg_reg(F27_3630_DSS_DATA8);
omap_cfg_reg(G26_3630_DSS_DATA9);
omap_cfg_reg(AD28_3630_DSS_DATA10);
omap_cfg_reg(AD27_3630_DSS_DATA11);
omap_cfg_reg(AB28_3630_DSS_DATA12);
omap_cfg_reg(AB27_3630_DSS_DATA13);
omap_cfg_reg(AA28_3630_DSS_DATA14);
omap_cfg_reg(AA27_3630_DSS_DATA15);
omap_cfg_reg(G25_3630_DSS_DATA16);
omap_cfg_reg(H27_3630_DSS_DATA17);
omap_cfg_reg(AH26_3630_DSS_DATA18);
omap_cfg_reg(AG26_3630_DSS_DATA19);
omap_cfg_reg(AF18_3630_DSS_DATA20);
omap_cfg_reg(AF19_3630_DSS_DATA21);
omap_cfg_reg(AE21_3630_DSS_DATA22);
omap_cfg_reg(AF21_3630_DSS_DATA23);
}
static int __init archos_battery_probe(struct platform_device *pdev)
{
int ret;
const struct archos_charge_config *chg_cfg;
bat = kzalloc(sizeof(struct archos_battery), GFP_KERNEL);
if (bat == NULL)
return -ENOMEM;
bat->main_battery = main_battery_template;
bat->ac_supply = ac_supply_template;
bat->usb_supply = usb_supply_template;
bat->charge_enable = UNUSED_GPIO;
bat->charge_low = UNUSED_GPIO;
bat->charge_high = UNUSED_GPIO;
/* FIXME: default values for now */
bat->current_mV = 3850;
bat->current_capacity = 50;
bat->voltage_max_design = 4200;
bat->voltage_min_design = 3500;
/* charger configuration */
chg_cfg = omap_get_config( ARCHOS_TAG_CHARGE, struct archos_charge_config);
if (chg_cfg != NULL && hardware_rev < chg_cfg->nrev) {
if (GPIO_EXISTS(chg_cfg->rev[hardware_rev].charge_enable) &&
GPIO_EXISTS(chg_cfg->rev[hardware_rev].charge_low) &&
GPIO_EXISTS(chg_cfg->rev[hardware_rev].charge_high) ) {
bat->charge_enable = chg_cfg->rev[hardware_rev].charge_enable;
bat->charge_low = chg_cfg->rev[hardware_rev].charge_low;
bat->charge_high = chg_cfg->rev[hardware_rev].charge_high;
archos_gpio_init_output(&bat->charge_enable, "charge enable");
archos_gpio_init_output(&bat->charge_low, "charge low");
archos_gpio_init_output(&bat->charge_high, "charge high");
ret = device_create_file(&pdev->dev, &dev_attr_charge_level);
if (ret < 0)
dev_dbg(&pdev->dev, "cannot create charge_level attribute\n");
}
if (chg_cfg->rev[hardware_rev].gpio_dc_detect) {
int ret;
bat->gpio_dc_detect = chg_cfg->rev[hardware_rev].gpio_dc_detect;
gpio_request(bat->gpio_dc_detect, "dc detect");
gpio_direction_input(bat->gpio_dc_detect);
bat->old_dcin = gpio_get_value_cansleep(bat->gpio_dc_detect);
ret = request_irq(gpio_to_irq(bat->gpio_dc_detect), dcin_irq_handler,
IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
"dc detect", pdev);
if (ret < 0)
dev_warn(&pdev->dev, "failed to request irq %i for dc detect\n",
gpio_to_irq(bat->gpio_dc_detect));
}
}
platform_set_drvdata(pdev, bat);
ret = power_supply_register(&pdev->dev, &bat->main_battery);
if (ret < 0) {
printk(KERN_DEBUG "archos_battery_probe: "
"cannot register main battery: %i\n", ret);
}
ret = power_supply_register(&pdev->dev, &bat->ac_supply);
if (ret < 0) {
printk(KERN_DEBUG "archos_battery_probe: "
"cannot register ac supply: %i\n", ret);
}
ret = power_supply_register(&pdev->dev, &bat->usb_supply);
if (ret < 0) {
printk(KERN_DEBUG "archos_battery_probe: "
"cannot register usb supply: %i\n", ret);
}
ret = device_create_file(&pdev->dev, &dev_attr_voltage_avg);
if (ret < 0)
dev_dbg(&pdev->dev, "cannot create voltage_avg attribute\n");
ret = device_create_file(&pdev->dev, &dev_attr_capacity);
if (ret < 0)
dev_dbg(&pdev->dev, "cannot create capacity attribute\n");
ret = device_create_file(&pdev->dev, &dev_attr_ac_online);
if (ret < 0)
dev_dbg(&pdev->dev, "cannot create ac_online attribute\n");
ret = device_create_file(&pdev->dev, &dev_attr_usb_online);
if (ret < 0)
dev_dbg(&pdev->dev, "cannot create usb_online attribute\n");
ret = device_create_file(&pdev->dev, &dev_attr_voltage_max_design);
if (ret < 0)
dev_dbg(&pdev->dev, "cannot create voltage_max_design attribute\n");
ret = device_create_file(&pdev->dev, &dev_attr_voltage_min_design);
if (ret < 0)
dev_dbg(&pdev->dev, "cannot create voltage_min_design attribute\n");
return 0;
}
int __init archos_audio_gpio_init(void)
{
const struct archos_audio_config *audio_cfg;
struct clk *clkout2_src_ck;
struct clk *sys_clkout2;
struct clk *core_ck;
/* audio */
audio_cfg = omap_get_config( ARCHOS_TAG_AUDIO, struct archos_audio_config );
if (audio_cfg == NULL) {
pr_err("archos_audio_gpio_init: no board configuration found\n");
return -ENODEV;
}
if ( hardware_rev >= audio_cfg->nrev ) {
pr_err("archos_audio_gpio_init: hardware_rev (%i) >= nrev (%i)\n",
hardware_rev, audio_cfg->nrev);
return -ENODEV;
}
audio_gpio = audio_cfg->rev[hardware_rev];
// a32 & a43 protos where using clkout1.
if (hardware_rev >= 1 || !(machine_is_archos_a32() || machine_is_archos_a43())) {
core_ck = clk_get(NULL, "cm_96m_fck");
if (IS_ERR(core_ck)) {
printk(KERN_ERR "failed to get core_ck\n");
}
clkout2_src_ck = clk_get(NULL, "clkout2_src_ck");
if (IS_ERR(clkout2_src_ck)) {
printk(KERN_ERR "failed to get clkout2_src_ck\n");
}
sys_clkout2 = clk_get(NULL, "sys_clkout2");
if (IS_ERR(sys_clkout2)) {
printk(KERN_ERR "failed to get sys_clkout2\n");
}
if ( clk_set_parent(clkout2_src_ck, core_ck) != 0) {
printk(KERN_ERR "failed to set sys_clkout2 parent to clkout2\n");
}
/* Set the clock to 12 Mhz */
omap2_clksel_set_rate(sys_clkout2, 12000000);
clk_put(sys_clkout2);
clk_put(clkout2_src_ck);
clk_put(core_ck);
sysclock_name = sys_clkout2_name;
use_mcbsp1_fclk = 1;
} else {
sysclock_name = sys_clkout1_name;
}
if (GPIO_PIN( audio_gpio.spdif ) != -1)
archos_gpio_init_output( &audio_gpio.spdif, "spdif" );
if (GPIO_PIN( audio_gpio.hp_on ) != -1)
archos_gpio_init_output( &audio_gpio.hp_on, "hp_on" );
if (GPIO_PIN( audio_gpio.headphone_plugged ) != -1)
archos_gpio_init_input( &audio_gpio.headphone_plugged, "hp_detect" );
if (GPIO_PIN( audio_gpio.vamp_vbat ) != -1)
archos_gpio_init_output( &audio_gpio.vamp_vbat, "vamp_vbat" );
if (GPIO_PIN( audio_gpio.vamp_dc ) != -1)
archos_gpio_init_output( &audio_gpio.vamp_dc, "vamp_dc" );
// XXX maybe prevents OFF mode?
if (GPIO_PIN( audio_gpio.headphone_plugged ) != -1)
gpio_set_debounce(GPIO_PIN(audio_gpio.headphone_plugged), (1 + 1) * 0x1f);
if (GPIO_PIN(audio_gpio.vamp_dc) != -1) {
int ret = platform_device_register(&archos_audio_vamp_device);
if (ret < 0)
return ret;
ret = platform_driver_register(&archos_audio_vamp_driver);
if (ret < 0)
return ret;
ret = device_create_file(&archos_audio_vamp_device.dev, &dev_attr_vamp_vusb_ctrl);
if (ret < 0)
return ret;
hrtimer_init(&vamp_watchdog_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vamp_watchdog_timer.function = vamp_watchdog_timer_func;
}
pr_debug("%s init done\n", __FUNCTION__);
return 0;
}
