static int panel_init(struct omap_display_data *ddata) { pr_debug("panel_init [%s]\n", ddata->panel_name); GPIO_INIT_OUTPUT(display_gpio.lcd_pwon); GPIO_INIT_OUTPUT(display_gpio.lcd_rst); GPIO_INIT_OUTPUT(display_gpio.lcd_pci); GPIO_INIT_OUTPUT(display_gpio.disp_select); GPIO_INIT_OUTPUT(display_gpio.cpldreset); #if !defined(CONFIG_FB_OMAP_BOOTLOADER_INIT) if (GPIO_EXISTS(display_gpio.lcd_pwon)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_pwon), 0); if (GPIO_EXISTS(display_gpio.lcd_rst)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_rst), 0); if (GPIO_EXISTS(display_gpio.lcd_pci)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_pci), 0); /* reset and enable the CPLD */ if (GPIO_EXISTS(display_gpio.cpldreset)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.cpldreset), 0); mdelay(2); if (GPIO_EXISTS(display_gpio.cpldreset)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.cpldreset), 1); #endif return 0; }
int archos_enable_ehci( int enable ) { if (enable) { if ( GPIO_EXISTS( gio_5v_enable ) ) gpio_set_value( GPIO_PIN( gio_5v_enable ), 1); if ( GPIO_EXISTS( gio_ehci_enable ) ) gpio_set_value( GPIO_PIN( gio_ehci_enable ), 1); } else { if ( GPIO_EXISTS( gio_ehci_enable ) ) gpio_set_value( GPIO_PIN( gio_ehci_enable ), 0); if ( GPIO_EXISTS( gio_5v_enable ) ) gpio_set_value( GPIO_PIN( gio_5v_enable ), 0); } if ( GPIO_EXISTS( gio_hub_enable ) ) { msleep(300); // fix me if ( enable ) gpio_set_value( GPIO_PIN( gio_hub_enable ), 1); else gpio_set_value( GPIO_PIN( gio_hub_enable ), 0); } ehci_phy_enable = enable; return 0; }
static int archos_ehci_suspend(struct platform_device *dev, pm_message_t pm) { printk("%s\n", __FUNCTION__); if ( GPIO_EXISTS( gio_ehci_enable ) ) gpio_set_value( GPIO_PIN(gio_ehci_enable), 0); if ( GPIO_EXISTS( gio_5v_enable ) ) gpio_set_value( GPIO_PIN(gio_5v_enable), 0); return 0; }
static int archos_ehci_resume(struct platform_device *dev) { printk("%s\n", __FUNCTION__); if ( GPIO_EXISTS( gio_5v_enable ) ) gpio_set_value( GPIO_PIN(gio_5v_enable), ehci_phy_enable); if ( GPIO_EXISTS( gio_ehci_enable ) ) gpio_set_value( GPIO_PIN( gio_ehci_enable ), ehci_phy_enable); return 0; }
static void panel_disable(struct omap_dss_device *disp) { pr_debug("panel_disable [%s]\n", disp->name); if (GPIO_EXISTS(display_gpio.lcd_rst)) gpio_set_value( GPIO_PIN(display_gpio.lcd_rst), 0 ); if (GPIO_EXISTS(display_gpio.lcd_pwon)) gpio_set_value( GPIO_PIN(display_gpio.lcd_pwon), 0 ); panel_state = 0; }
static int panel_set_backlight_level( struct omap_display *disp, int level) { int hw_level; pr_debug("panel_set_backlight_level [%s] %d\n", disp != NULL ? disp->panel->name: "cpt_wvga_48", level); /* skip if panel is not on */ if (panel_state == 0) { saved_bkl_level = level; return 0; } /* clamp the level */ if (level < 0) level = 0; if (level > 255) level = 255; /* nothing to do if levels are equal */ if (bkl_level == level) return 0; /* stop backlight? */ if (level == 0) { if (GPIO_EXISTS(display_gpio.bkl_pwon)) omap_set_gpio_dataout(GPIO_PIN(display_gpio.bkl_pwon), 0); omap_dm_timer_stop(bkl_pwm); omap_dm_timer_disable(bkl_pwm); bkl_level = 0; return 0; } /* start backlight? */ if (bkl_level == 0) { omap_dm_timer_enable(bkl_pwm); omap_dm_timer_set_pwm(bkl_pwm, 0, 1, 2); omap_dm_timer_start(bkl_pwm); if (GPIO_EXISTS(display_gpio.bkl_pwon)) omap_set_gpio_dataout(GPIO_PIN(display_gpio.bkl_pwon), 1); } /* set new level, g7 machines have inverted level */ hw_level = level; if (!machine_is_archos_g6h()) hw_level = 255 - level; pwm_set_speed(bkl_pwm, 10000, hw_level); bkl_level = level; return 0; }
static void panel_disable(struct omap_display *disp) { pr_debug("panel_disable [%s]\n", disp->panel->name); if (GPIO_EXISTS(display_gpio.lcd_rst)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_rst), 0 ); if (GPIO_EXISTS(display_gpio.lcd_pci)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_pci), 0 ); if (GPIO_EXISTS(display_gpio.lcd_pwon)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_pwon), 0 ); saved_bkl_level = bkl_level; panel_set_backlight_level(disp, 0); panel_state = 0; }
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; }
static void phy_disable( void ) { if (GPIO_EXISTS(gpio_phy_enable)) omap_set_gpio_dataout(GPIO_PIN(gpio_phy_enable), 0); mdelay(1); clk_disable(phy_clk); }
static void panel_disable_tv(struct omap_dss_device *display) { pr_info("panel_disable_tv\n"); if (GPIO_EXISTS(cvbs_on)) gpio_set_value( GPIO_PIN(cvbs_on), 0 ); }
void __init usb_musb_init(void) { #ifdef CONFIG_USB_MUSB_SOC 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 "archos_usb_init: no board configuration found\n"); return; } if ( hardware_rev >= usb_cfg->nrev ) { printk(KERN_DEBUG "archos_usb_init: hardware_rev (%i) >= nrev (%i)\n", hardware_rev, usb_cfg->nrev); return; } /* ground USB ID pin */ gpio_usb_id = usb_cfg->rev[hardware_rev].usb_id; if (GPIO_EXISTS(gpio_usb_id)) { GPIO_INIT_OUTPUT( gpio_usb_id ); omap_set_gpio_dataout( GPIO_PIN( gpio_usb_id ), 0 ); } /* keep PHY in reset to save power... */ gpio_phy_enable = usb_cfg->rev[hardware_rev].enable_usb_musb; if (GPIO_EXISTS(gpio_phy_enable)) { GPIO_INIT_OUTPUT( gpio_phy_enable ); omap_set_gpio_dataout( GPIO_PIN ( gpio_phy_enable ), 0); } /* sys_clkout1 is needed by the phy */ phy_clk = clk_get(NULL, "sys_clkout1"); if (IS_ERR(phy_clk)) { /* No need to proceed, PHY will not work without clock */ pr_err("usb_musb_init: cannot get PHY external clock\n"); return; } if (platform_device_register(&musb_device) < 0) { printk(KERN_ERR "Unable to register HS-USB (MUSB) device\n"); return; } otg_set_transceiver(&musb_xceiv); #endif }
static int panel_enable(struct omap_dss_device *disp) { pr_debug("panel_enable [%s]\n", disp->name); if ( panel_state == 1 ) return -1; if (GPIO_EXISTS(display_gpio.lcd_pwon)) { gpio_set_value( GPIO_PIN(display_gpio.lcd_pwon), 1 ); msleep(50); } if (GPIO_EXISTS(display_gpio.lcd_rst)) { gpio_set_value( GPIO_PIN(display_gpio.lcd_rst), 1 ); msleep(100); } panel_state = 1; return 0; }
static int panel_enable_tv(struct omap_dss_device *display) { pr_info("panel_enable_tv\n"); if (GPIO_EXISTS(cvbs_on)) { gpio_set_value( GPIO_PIN(cvbs_on), 1 ); msleep(1); } return 0; }
int archos_set_usb_id( int enable ) { if (GPIO_EXISTS(gpio_usb_id)) { if (enable) omap_set_gpio_dataout( GPIO_PIN( gpio_usb_id ), 1); else omap_set_gpio_dataout( GPIO_PIN( gpio_usb_id ), 0); } return 0; }
int archos_enable_ohci( int enable ) { printk(" enable ohci interface %d \n", enable); if ( GPIO_EXISTS( gio_ohci_enable ) ) { if ( enable ) gpio_set_value( GPIO_PIN( gio_ohci_enable ), 1); else gpio_set_value( GPIO_PIN( gio_ohci_enable ), 0); } return 0; }
static int panel_enable(struct omap_display *disp) { pr_info("panel_enable [%s]\n", disp->panel->name); if (GPIO_EXISTS(display_gpio.disp_select)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.disp_select), 1); if (GPIO_EXISTS(display_gpio.lcd_pwon)) { omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_pwon), 1 ); msleep(50); } if (GPIO_EXISTS(display_gpio.lcd_rst)) { omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_rst), 1 ); msleep(100); } if (GPIO_EXISTS(display_gpio.lcd_pci)) omap_set_gpio_dataout( GPIO_PIN(display_gpio.lcd_pci), 1 ); panel_state = 1; panel_set_backlight_level(disp, saved_bkl_level); return 0; }
int archos_enable_ehci( int enable ) { if ( GPIO_EXISTS( gio_ehci_enable ) ) { if ( enable ) omap_set_gpio_dataout( GPIO_PIN( gio_ehci_enable ), 1); else omap_set_gpio_dataout( GPIO_PIN( gio_ehci_enable ), 0); } ehci_phy_enable = enable; 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 ); } }
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 __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; }
static int main_battery_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct archos_battery *bat = container_of(psy, struct archos_battery, main_battery); switch (psp) { case POWER_SUPPLY_PROP_STATUS: if (!get_on_dcin(bat) && !bat->on_usb) { val->intval = POWER_SUPPLY_STATUS_DISCHARGING; break; } if (bat->charge_state) val->intval = POWER_SUPPLY_STATUS_CHARGING; else val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; break; case POWER_SUPPLY_PROP_PRESENT: val->intval = 1; /* always present */ break; case POWER_SUPPLY_PROP_CAPACITY: val->intval = bat->current_capacity; break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: val->intval = bat->current_mV; break; case POWER_SUPPLY_PROP_VOLTAGE_AVG: val->intval = bat->current_mV; break; case POWER_SUPPLY_PROP_HEALTH: val->intval = POWER_SUPPLY_HEALTH_UNKNOWN; break; case POWER_SUPPLY_PROP_TEMP: val->intval = 230; /* we have no sensor for that */ break; case POWER_SUPPLY_PROP_TECHNOLOGY: val->intval = POWER_SUPPLY_TECHNOLOGY_LIPO; break; case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: val->intval = bat->voltage_max_design; break; case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: val->intval = bat->voltage_min_design; break; case POWER_SUPPLY_PROP_CHARGE_NOW: if (!GPIO_EXISTS(bat->charge_enable)) { if (bat->charge_state) val->intval = 1000; else val->intval = 0; break; } switch(bat->charge_level) { case 1: val->intval = 100; break; case 2: val->intval = 500; break; case 3: val->intval = 1000; break; case 0: default: val->intval = 0; break; } break; default: return -EINVAL; } return 0; }
int __init archos_wifi_init(void) { int ret; const struct archos_wifi_bt_config *wifi_bt_cfg; struct archos_gpio wifi_irq; struct archos_gpio bt_nshutdown; wifi_bt_cfg = omap_get_config(ARCHOS_TAG_WIFI_BT, struct archos_wifi_bt_config); /* might be NULL */ if (wifi_bt_cfg == NULL) { printk(KERN_DEBUG "archos_wifi_init: no board configuration found\n"); return -ENODEV; } if ( hardware_rev >= wifi_bt_cfg->nrev ) { printk(KERN_DEBUG "archos_wifi_init: hardware_rev (%i) >= nrev (%i)\n", hardware_rev, wifi_bt_cfg->nrev); return -ENODEV; } wifi_irq = wifi_bt_cfg->rev[hardware_rev].wifi_irq; wifi_pmena = wifi_bt_cfg->rev[hardware_rev].wifi_power; archos_wifi_pa_type = wifi_bt_cfg->rev[hardware_rev].wifi_pa_type; printk("%s: start\n", __func__); ret = gpio_request(GPIO_PIN(wifi_irq), "wifi_irq"); if (ret < 0) { printk(KERN_ERR "%s: can't reserve GPIO: %d\n", __func__, GPIO_PIN(wifi_irq)); goto out; } gpio_direction_input(GPIO_PIN(wifi_irq)); archos_wlan_data.irq = gpio_to_irq(GPIO_PIN(wifi_irq)); if (wl12xx_set_platform_data(&archos_wlan_data)) { pr_err("archos_wifi_bt_init: error setting wl12xx data\n"); return -1; } bt_nshutdown = wifi_bt_cfg->rev[hardware_rev].bt_power; if (GPIO_EXISTS(bt_nshutdown)) { wl1271_chip_plat_data.nshutdown_gpio = GPIO_PIN(bt_nshutdown); ret = platform_device_register(&wl1271_chip_device); if (ret < 0) goto out; } ret = platform_device_register(&bt_device); if (ret < 0) { pr_err("archos_wifi_bt_init: couldn't register bt device\n"); return -1; } ret = platform_device_register(&archos_wifi_device); if (ret < 0) goto out; ret = device_create_file(&archos_wifi_device.dev, &dev_attr_wifi_reset); if (ret < 0) goto out; ret = device_create_file(&archos_wifi_device.dev, &dev_attr_wifi_pa_type); out: return ret; }