Changeset 121


Ignore:
Timestamp:
Apr 14, 2011, 2:01:50 PM (6 years ago)
Author:
bs
Message:

1st android bootable version
Sound, usb, adb, battery added.
basic I2C chips configured.

Location:
kern_2.6.32
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • kern_2.6.32/.config

    r120 r121  
    22# Automatically generated make config: don't edit 
    33# Linux kernel version: 2.6.32.9 
    4 # Tue Apr 12 13:00:01 2011 
     4# Wed Apr 13 22:05:51 2011 
    55# 
    66CONFIG_ARM=y 
     
    240240CONFIG_MACH_VINSQ=y 
    241241# CONFIG_MACH_VITAL is not set 
    242 # CONFIG_SEC_HEADSET is not set 
     242CONFIG_SEC_HEADSET=y 
    243243# CONFIG_SEC_LOG_BUF is not set 
    244244 
     
    850850# 
    851851# CONFIG_W1 is not set 
    852 # CONFIG_POWER_SUPPLY is not set 
     852CONFIG_POWER_SUPPLY=y 
     853# CONFIG_POWER_SUPPLY_DEBUG is not set 
     854# CONFIG_PDA_POWER is not set 
     855CONFIG_BATTERY_S3C6410=y 
     856# CONFIG_BATTERY_DS2760 is not set 
     857# CONFIG_BATTERY_DS2782 is not set 
     858# CONFIG_BATTERY_BQ27x00 is not set 
     859CONFIG_FUEL_GAUGE_MAX17040=y 
    853860CONFIG_HWMON=y 
    854861# CONFIG_HWMON_VID is not set 
     
    10181025# CONFIG_SOUND_OSS_CORE is not set 
    10191026CONFIG_SND=y 
     1027CONFIG_SND_TIMER=y 
     1028CONFIG_SND_PCM=y 
     1029CONFIG_SND_JACK=y 
    10201030# CONFIG_SND_SEQUENCER is not set 
    10211031# CONFIG_SND_MIXER_OSS is not set 
     
    10351045# CONFIG_SND_ARM is not set 
    10361046# CONFIG_SND_SPI is not set 
    1037 # CONFIG_SND_SOC is not set 
     1047CONFIG_SND_SOC=y 
     1048CONFIG_SND_S3C64XX_SOC_SOL=y 
     1049CONFIG_SND_S3C_I2S_V32=y 
     1050CONFIG_SND_S3C64XX_SOC_AK4671=y 
     1051CONFIG_SND_S3C64XX_SOC_I2S_REC_DOWNSAMPLING=y 
     1052CONFIG_ANDROID_BUF_NUM=16 
     1053# CONFIG_SND_SMDK6410_WM8580 is not set 
     1054# CONFIG_SND_SMDK6410_S5M8751 is not set 
     1055# CONFIG_SND_SMDK6410_WM9713 is not set 
     1056# CONFIG_SND_SMDK6440_WM8580 is not set 
     1057# CONFIG_SND_SMDK6440_S5M8751 is not set 
     1058# CONFIG_SND_SMDKC100_WM8580 is not set 
     1059# CONFIG_SND_SMDKC100_S5M8751 is not set 
     1060# CONFIG_SND_SMDKC100_WM9713 is not set 
     1061CONFIG_SND_SOC_I2C_AND_SPI=y 
     1062# CONFIG_SND_SOC_ALL_CODECS is not set 
     1063CONFIG_SND_SOC_AK4671=y 
    10381064# CONFIG_SOUND_PRIME is not set 
    10391065# CONFIG_HID_SUPPORT is not set 
     
    10941120# CONFIG_NOP_USB_XCEIV is not set 
    10951121CONFIG_MMC=y 
    1096 CONFIG_MMC_DEBUG=y 
     1122# CONFIG_MMC_DEBUG is not set 
    10971123CONFIG_MMC_UNSAFE_RESUME=y 
    10981124# CONFIG_MMC_EMBEDDED_SDIO is not set 
  • kern_2.6.32/arch/arm/mach-s3c6410/omnia_II.c

    r120 r121  
    1 /* linux/arch/arm/mach-s3c6410/mach-smdk6410.c 
     1/* linux/arch/arm/mach-s3c6410/mach-omnia_II.c 
    22 * 
    33 * Copyright 2008 Openmoko, Inc. 
     
    157157static struct platform_device sec_device_i2c_common = { 
    158158        .name   = "i2c-gpio", 
    159         .id             = 5, 
     159        .id             = 3, 
    160160        .dev.platform_data      = &i2c_common_platdata, 
    161161}; 
     
    170170        { 
    171171                I2C_BOARD_INFO("max8698", (0xcc >> 1)), 
     172        }, 
     173}; 
     174 
     175#define MAX9877_ADDRESS 0x9A 
     176static struct i2c_board_info i2c_devs3[] __initdata = { 
     177        { 
     178                I2C_BOARD_INFO("MAX9877 I2C (AMP)", (MAX9877_ADDRESS >> 1)), 
     179        }, 
     180        { 
     181                I2C_BOARD_INFO("AK4671 I2C Codec", (0x24 >> 1)), 
    172182        }, 
    173183}; 
     
    629639{ 
    630640 
     641//      system_rev = 0x20; 
    631642        s3c_config_gpio_table(ARRAY_SIZE(omnia_II_init_gpio_table), 
    632643                omnia_II_init_gpio_table); 
     
    645656        i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1)); 
    646657        i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2)); 
     658        i2c_register_board_info(3, i2c_devs3, ARRAY_SIZE(i2c_devs3)); 
     659 
    647660        s3c6410_add_mem_devices (&pmem_setting); 
    648661 
     
    651664        s3c6410_wdt_io_map(); 
    652665        saturn_switch_init(); 
    653  
    654666} 
    655667 
  • kern_2.6.32/arch/arm/plat-s3c64xx/s3c64xx-clock.c

    r120 r121  
    768768#define PCLK_DIV_MASK                     (0xf<<PCLK_DIV_RATIO_BIT) 
    769769    clkdiv0 = __raw_readl(S3C_CLK_DIV0); //bss 
    770     a=(clkdiv0 & ~(PCLK_DIV_MASK)) | (7 << PCLK_DIV_RATIO_BIT); //bss pclk to (3: 66MHz, 7: 33MHz ) 
     770    a=(clkdiv0 & ~(PCLK_DIV_MASK)) | (3 << PCLK_DIV_RATIO_BIT); //bss pclk to (3: 66MHz, 7: 33MHz ) 
    771771    writel(a, S3C_CLK_DIV0);         //bss 
    772772#endif  
  • kern_2.6.32/drivers/power/ds2760_battery.c

    r118 r121  
    5757        struct workqueue_struct *monitor_wqueue; 
    5858        struct delayed_work monitor_work; 
    59         struct delayed_work set_charged_work; 
    6059}; 
    6160 
     
    6766module_param(pmod_enabled, bool, 0644); 
    6867MODULE_PARM_DESC(pmod_enabled, "PMOD enable bit"); 
    69  
    70 static unsigned int rated_capacity; 
    71 module_param(rated_capacity, uint, 0644); 
    72 MODULE_PARM_DESC(rated_capacity, "rated battery capacity, 10*mAh or index"); 
    73  
    74 static unsigned int current_accum; 
    75 module_param(current_accum, uint, 0644); 
    76 MODULE_PARM_DESC(current_accum, "current accumulator value"); 
    7768 
    7869/* Some batteries have their rated capacity stored a N * 10 mAh, while 
     
    178169                              di->raw[DS2760_ACTIVE_FULL + 1]; 
    179170 
    180         /* If the full_active_uAh value is not given, fall back to the rated 
    181          * capacity. This is likely to happen when chips are not part of the 
    182          * battery pack and is therefore not bootstrapped. */ 
    183         if (di->full_active_uAh == 0) 
    184                 di->full_active_uAh = di->rated_capacity / 1000L; 
    185  
    186         scale[0] = di->full_active_uAh; 
     171        scale[0] = di->raw[DS2760_ACTIVE_FULL] << 8 | 
     172                   di->raw[DS2760_ACTIVE_FULL + 1]; 
    187173        for (i = 1; i < 5; i++) 
    188174                scale[i] = scale[i - 1] + di->raw[DS2760_ACTIVE_FULL + 2 + i]; 
     
    212198                di->rem_capacity = 100; 
    213199 
    214         if (di->current_uA >= 100L) 
    215                 di->life_sec = -((di->accum_current_uAh - di->empty_uAh) * 36L) 
    216                                         / (di->current_uA / 100L); 
     200        if (di->current_uA) 
     201                di->life_sec = -((di->accum_current_uAh - di->empty_uAh) * 
     202                                 3600L) / di->current_uA; 
    217203        else 
    218204                di->life_sec = 0; 
    219205 
    220206        return 0; 
    221 } 
    222  
    223 static void ds2760_battery_set_current_accum(struct ds2760_device_info *di, 
    224                                              unsigned int acr_val) 
    225 { 
    226         unsigned char acr[2]; 
    227  
    228         /* acr is in units of 0.25 mAh */ 
    229         acr_val *= 4L; 
    230         acr_val /= 1000; 
    231  
    232         acr[0] = acr_val >> 8; 
    233         acr[1] = acr_val & 0xff; 
    234  
    235         if (w1_ds2760_write(di->w1_dev, acr, DS2760_CURRENT_ACCUM_MSB, 2) < 2) 
    236                 dev_warn(di->dev, "ACR write failed\n"); 
    237207} 
    238208 
     
    268238                                di->charge_status = POWER_SUPPLY_STATUS_CHARGING; 
    269239                        } else { 
     240                                unsigned char acr[2]; 
     241                                int acr_val; 
     242 
     243                                /* acr is in units of 0.25 mAh */ 
     244                                acr_val = di->full_active_uAh * 4L / 1000; 
     245 
     246                                acr[0] = acr_val >> 8; 
     247                                acr[1] = acr_val & 0xff; 
     248 
     249                                if (w1_ds2760_write(di->w1_dev, acr, 
     250                                    DS2760_CURRENT_ACCUM_MSB, 2) < 2) 
     251                                        dev_warn(di->dev, 
     252                                                 "ACR reset failed\n"); 
     253 
    270254                                di->charge_status = POWER_SUPPLY_STATUS_FULL; 
    271                                 ds2760_battery_set_current_accum(di, 
    272                                                 di->full_active_uAh); 
    273255                        } 
    274256                } 
     
    293275} 
    294276 
    295 static void ds2760_battery_write_rated_capacity(struct ds2760_device_info *di, 
    296                                                 unsigned char rated_capacity) 
    297 { 
    298         if (rated_capacity == di->raw[DS2760_RATED_CAPACITY]) 
    299                 return; 
    300  
    301         w1_ds2760_write(di->w1_dev, &rated_capacity, DS2760_RATED_CAPACITY, 1); 
    302         w1_ds2760_store_eeprom(di->w1_dev, DS2760_EEPROM_BLOCK1); 
    303         w1_ds2760_recall_eeprom(di->w1_dev, DS2760_EEPROM_BLOCK1); 
    304 } 
    305  
    306277static void ds2760_battery_work(struct work_struct *work) 
    307278{ 
     
    327298        cancel_delayed_work(&di->monitor_work); 
    328299        queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ/10); 
    329 } 
    330  
    331  
    332 static void ds2760_battery_set_charged_work(struct work_struct *work) 
    333 { 
    334         char bias; 
    335         struct ds2760_device_info *di = container_of(work, 
    336                 struct ds2760_device_info, set_charged_work.work); 
    337  
    338         dev_dbg(di->dev, "%s\n", __func__); 
    339  
    340         ds2760_battery_read_status(di); 
    341  
    342         /* When we get notified by external circuitry that the battery is 
    343          * considered fully charged now, we know that there is no current 
    344          * flow any more. However, the ds2760's internal current meter is 
    345          * too inaccurate to rely on - spec say something ~15% failure. 
    346          * Hence, we use the current offset bias register to compensate 
    347          * that error. 
    348          */ 
    349  
    350         if (!power_supply_am_i_supplied(&di->bat)) 
    351                 return; 
    352  
    353         bias = (signed char) di->current_raw + 
    354                 (signed char) di->raw[DS2760_CURRENT_OFFSET_BIAS]; 
    355  
    356         dev_dbg(di->dev, "%s: bias = %d\n", __func__, bias); 
    357  
    358         w1_ds2760_write(di->w1_dev, &bias, DS2760_CURRENT_OFFSET_BIAS, 1); 
    359         w1_ds2760_store_eeprom(di->w1_dev, DS2760_EEPROM_BLOCK1); 
    360         w1_ds2760_recall_eeprom(di->w1_dev, DS2760_EEPROM_BLOCK1); 
    361  
    362         /* Write to the di->raw[] buffer directly - the CURRENT_OFFSET_BIAS 
    363          * value won't be read back by ds2760_battery_read_status() */ 
    364         di->raw[DS2760_CURRENT_OFFSET_BIAS] = bias; 
    365 } 
    366  
    367 static void ds2760_battery_set_charged(struct power_supply *psy) 
    368 { 
    369         struct ds2760_device_info *di = to_ds2760_device_info(psy); 
    370  
    371         /* postpone the actual work by 20 secs. This is for debouncing GPIO 
    372          * signals and to let the current value settle. See AN4188. */ 
    373         cancel_delayed_work(&di->set_charged_work); 
    374         queue_delayed_work(di->monitor_wqueue, &di->set_charged_work, HZ * 20); 
    375300} 
    376301 
     
    412337        case POWER_SUPPLY_PROP_TEMP: 
    413338                val->intval = di->temp_C; 
    414                 break; 
    415         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: 
    416                 val->intval = di->life_sec; 
    417                 break; 
    418         case POWER_SUPPLY_PROP_CAPACITY: 
    419                 val->intval = di->rem_capacity; 
    420339                break; 
    421340        default: 
     
    435354        POWER_SUPPLY_PROP_CHARGE_NOW, 
    436355        POWER_SUPPLY_PROP_TEMP, 
    437         POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 
    438         POWER_SUPPLY_PROP_CAPACITY, 
    439356}; 
    440357 
     
    460377        di->bat.num_properties  = ARRAY_SIZE(ds2760_battery_props); 
    461378        di->bat.get_property    = ds2760_battery_get_property; 
    462         di->bat.set_charged     = ds2760_battery_set_charged; 
    463379        di->bat.external_power_changed = 
    464380                                  ds2760_battery_external_power_changed; 
    465381 
    466382        di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN; 
     383 
     384        retval = power_supply_register(&pdev->dev, &di->bat); 
     385        if (retval) { 
     386                dev_err(di->dev, "failed to register battery\n"); 
     387                goto batt_failed; 
     388        } 
    467389 
    468390        /* enable sleep mode feature */ 
     
    476398        ds2760_battery_write_status(di, status); 
    477399 
    478         /* set rated capacity from module param */ 
    479         if (rated_capacity) 
    480                 ds2760_battery_write_rated_capacity(di, rated_capacity); 
    481  
    482         /* set current accumulator if given as parameter. 
    483          * this should only be done for bootstrapping the value */ 
    484         if (current_accum) 
    485                 ds2760_battery_set_current_accum(di, current_accum); 
    486  
    487         retval = power_supply_register(&pdev->dev, &di->bat); 
    488         if (retval) { 
    489                 dev_err(di->dev, "failed to register battery\n"); 
    490                 goto batt_failed; 
    491         } 
    492  
    493400        INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work); 
    494         INIT_DELAYED_WORK(&di->set_charged_work, 
    495                           ds2760_battery_set_charged_work); 
    496401        di->monitor_wqueue = create_singlethread_workqueue(dev_name(&pdev->dev)); 
    497402        if (!di->monitor_wqueue) { 
     
    518423        cancel_rearming_delayed_workqueue(di->monitor_wqueue, 
    519424                                          &di->monitor_work); 
    520         cancel_rearming_delayed_workqueue(di->monitor_wqueue, 
    521                                           &di->set_charged_work); 
    522425        destroy_workqueue(di->monitor_wqueue); 
    523426        power_supply_unregister(&di->bat); 
  • kern_2.6.32/drivers/power/fuel_gauge.c

    r120 r121  
    2929        .ignore         = fg_ignore, 
    3030        .probe          = fg_probe, 
     31}; 
     32 
     33static struct i2c_device_id fuelgauge_id[] = { 
     34        { "Fuel Gauge I2C", 0 }, 
     35        {} 
    3136}; 
    3237 
     
    192197} 
    193198 
    194 static int fg_attach(struct i2c_adapter *adap, int addr, int kind) 
     199static int fg_i2c_detect(struct i2c_client *client, int kind, struct i2c_board_info *info) 
    195200{ 
    196201        struct i2c_client *c; 
    197         int ret; 
    198  
    199         pr_info("%s\n", __func__); 
    200  
     202 
     203    printk(KERN_DEBUG "[%s] detected\n", __func__); 
     204     
    201205        c = kmalloc(sizeof(*c), GFP_KERNEL); 
    202206        if (!c) 
     
    205209        memset(c, 0, sizeof(struct i2c_client)); 
    206210 
    207         strncpy(c->name, fg_i2c_driver.driver.name, I2C_NAME_SIZE); 
    208         c->addr = addr; 
    209         c->adapter = adap; 
     211        c->addr = client->addr; 
     212        c->adapter = client->adapter; 
    210213        c->driver = &fg_i2c_driver; 
    211214 
    212         if ((ret = i2c_attach_client(c))) 
    213                 goto error; 
    214  
    215215        fg_i2c_client = c; 
    216  
    217 error: 
    218         return ret; 
    219 } 
    220  
    221 static int fg_attach_adapter(struct i2c_adapter *adap) 
    222 { 
    223         pr_info("%s\n", __func__); 
    224         return i2c_probe(adap, &fg_addr_data, fg_attach); 
    225 } 
    226  
    227 static int fg_detach_client(struct i2c_client *client) 
    228 { 
    229         pr_info("%s\n", __func__); 
    230         i2c_detach_client(client); 
     216        strlcpy(info->type, "Fuel Gauge I2C", I2C_NAME_SIZE); 
     217 
     218//      pr_info("%s, fg_i2c_client->addr:%x\n", __func__, fg_i2c_client->addr); 
     219        return 0; 
     220} 
     221 
     222static int __devexit fg_i2c_remove(struct i2c_client *client) 
     223{ 
     224//      pr_info("%s\n", __func__); 
    231225        return 0; 
    232226} 
     
    234228static struct i2c_driver fg_i2c_driver = { 
    235229        .driver = { 
    236                 .name = "Fuel Gauge I2C", 
    237                 .owner = THIS_MODULE, 
     230                .name           = "Fuel Gauge I2C", 
     231                .owner          = THIS_MODULE, 
    238232        }, 
    239         .id             = 0, 
    240         .attach_adapter = fg_attach_adapter, 
    241         .detach_client  = fg_detach_client, 
    242         .command        = NULL, 
     233        .class                  = I2C_CLASS_HWMON, 
     234        .remove                 = __devexit_p(fg_i2c_remove), 
     235        .detect                 = fg_i2c_detect, 
     236        .id_table               = fuelgauge_id, 
     237        .address_data   = &fg_addr_data, 
    243238}; 
  • kern_2.6.32/drivers/power/olpc_battery.c

    r118 r121  
    1111#include <linux/kernel.h> 
    1212#include <linux/module.h> 
    13 #include <linux/types.h> 
    1413#include <linux/err.h> 
    15 #include <linux/device.h> 
    1614#include <linux/platform_device.h> 
    1715#include <linux/power_supply.h> 
     
    234232                        return ret; 
    235233                break; 
    236         case POWER_SUPPLY_PROP_CHARGE_TYPE: 
    237                 if (ec_byte & BAT_STAT_TRICKLE) 
    238                         val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 
    239                 else if (ec_byte & BAT_STAT_CHARGING) 
    240                         val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; 
    241                 else 
    242                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; 
    243                 break; 
    244234        case POWER_SUPPLY_PROP_PRESENT: 
    245235                val->intval = !!(ec_byte & (BAT_STAT_PRESENT | 
     
    287277                val->intval = ec_byte; 
    288278                break; 
    289         case POWER_SUPPLY_PROP_CAPACITY_LEVEL: 
    290                 if (ec_byte & BAT_STAT_FULL) 
    291                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL; 
    292                 else if (ec_byte & BAT_STAT_LOW) 
    293                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW; 
    294                 else 
    295                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 
    296                 break; 
    297279        case POWER_SUPPLY_PROP_TEMP: 
    298280                ret = olpc_ec_cmd(EC_BAT_TEMP, NULL, 0, (void *)&ec_word, 2); 
     
    334316static enum power_supply_property olpc_bat_props[] = { 
    335317        POWER_SUPPLY_PROP_STATUS, 
    336         POWER_SUPPLY_PROP_CHARGE_TYPE, 
    337318        POWER_SUPPLY_PROP_PRESENT, 
    338319        POWER_SUPPLY_PROP_HEALTH, 
     
    341322        POWER_SUPPLY_PROP_CURRENT_AVG, 
    342323        POWER_SUPPLY_PROP_CAPACITY, 
    343         POWER_SUPPLY_PROP_CAPACITY_LEVEL, 
    344324        POWER_SUPPLY_PROP_TEMP, 
    345325        POWER_SUPPLY_PROP_TEMP_AMBIENT, 
     
    391371}; 
    392372 
    393 /* Allow userspace to see the specific error value pulled from the EC */ 
    394  
    395 static ssize_t olpc_bat_error_read(struct device *dev, 
    396                 struct device_attribute *attr, char *buf) 
    397 { 
    398         uint8_t ec_byte; 
    399         ssize_t ret; 
    400  
    401         ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1); 
    402         if (ret < 0) 
    403                 return ret; 
    404  
    405         return sprintf(buf, "%d\n", ec_byte); 
    406 } 
    407  
    408 static struct device_attribute olpc_bat_error = { 
    409         .attr = { 
    410                 .name = "error", 
    411                 .mode = S_IRUGO, 
    412         }, 
    413         .show = olpc_bat_error_read, 
    414 }; 
    415  
    416373/********************************************************************* 
    417374 *              Initialisation 
     
    477434                goto eeprom_failed; 
    478435 
    479         ret = device_create_file(olpc_bat.dev, &olpc_bat_error); 
    480         if (ret) 
    481                 goto error_failed; 
    482  
    483436        goto success; 
    484437 
    485 error_failed: 
    486         device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom); 
    487438eeprom_failed: 
    488439        power_supply_unregister(&olpc_bat); 
     
    497448static void __exit olpc_bat_exit(void) 
    498449{ 
    499         device_remove_file(olpc_bat.dev, &olpc_bat_error); 
    500450        device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom); 
    501451        power_supply_unregister(&olpc_bat); 
  • kern_2.6.32/drivers/power/power_supply_core.c

    r118 r121  
    1919#include "power_supply.h" 
    2020 
    21 /* exported for the APM Power driver, APM emulation */ 
    2221struct class *power_supply_class; 
    23 EXPORT_SYMBOL_GPL(power_supply_class); 
    2422 
    2523static int __power_supply_changed_work(struct device *dev, void *data) 
     
    3937static void power_supply_changed_work(struct work_struct *work) 
    4038{ 
    41         unsigned long flags; 
    4239        struct power_supply *psy = container_of(work, struct power_supply, 
    4340                                                changed_work); 
     
    4542        dev_dbg(psy->dev, "%s\n", __func__); 
    4643 
    47         spin_lock_irqsave(&psy->changed_lock, flags); 
    48         if (psy->changed) { 
    49                 psy->changed = false; 
    50                 spin_unlock_irqrestore(&psy->changed_lock, flags); 
     44        class_for_each_device(power_supply_class, NULL, psy, 
     45                              __power_supply_changed_work); 
    5146 
    52                 class_for_each_device(power_supply_class, NULL, psy, 
    53                                       __power_supply_changed_work); 
     47        power_supply_update_leds(psy); 
    5448 
    55                 power_supply_update_leds(psy); 
    56  
    57                 kobject_uevent(&psy->dev->kobj, KOBJ_CHANGE); 
    58                 spin_lock_irqsave(&psy->changed_lock, flags); 
    59         } 
    60         if (!psy->changed) 
    61                 wake_unlock(&psy->work_wake_lock); 
    62         spin_unlock_irqrestore(&psy->changed_lock, flags); 
     49        kobject_uevent(&psy->dev->kobj, KOBJ_CHANGE); 
    6350} 
    6451 
    6552void power_supply_changed(struct power_supply *psy) 
    6653{ 
    67         unsigned long flags; 
    68  
    6954        dev_dbg(psy->dev, "%s\n", __func__); 
    7055 
    71         spin_lock_irqsave(&psy->changed_lock, flags); 
    72         psy->changed = true; 
    73         wake_lock(&psy->work_wake_lock); 
    74         spin_unlock_irqrestore(&psy->changed_lock, flags); 
    7556        schedule_work(&psy->changed_work); 
    7657} 
    77 EXPORT_SYMBOL_GPL(power_supply_changed); 
    7858 
    7959static int __power_supply_am_i_supplied(struct device *dev, void *data) 
     
    10787        return error; 
    10888} 
    109 EXPORT_SYMBOL_GPL(power_supply_am_i_supplied); 
    11089 
    11190static int __power_supply_is_system_supplied(struct device *dev, void *data) 
     
    132111        return error; 
    133112} 
    134 EXPORT_SYMBOL_GPL(power_supply_is_system_supplied); 
    135  
    136 int power_supply_set_battery_charged(struct power_supply *psy) 
    137 { 
    138         if (psy->type == POWER_SUPPLY_TYPE_BATTERY && psy->set_charged) { 
    139                 psy->set_charged(psy); 
    140                 return 0; 
    141         } 
    142  
    143         return -EINVAL; 
    144 } 
    145 EXPORT_SYMBOL_GPL(power_supply_set_battery_charged); 
    146  
    147 static int power_supply_match_device_by_name(struct device *dev, void *data) 
    148 { 
    149         const char *name = data; 
    150         struct power_supply *psy = dev_get_drvdata(dev); 
    151  
    152         return strcmp(psy->name, name) == 0; 
    153 } 
    154  
    155 struct power_supply *power_supply_get_by_name(char *name) 
    156 { 
    157         struct device *dev = class_find_device(power_supply_class, NULL, name, 
    158                                         power_supply_match_device_by_name); 
    159  
    160         return dev ? dev_get_drvdata(dev) : NULL; 
    161 } 
    162 EXPORT_SYMBOL_GPL(power_supply_get_by_name); 
    163113 
    164114int power_supply_register(struct device *parent, struct power_supply *psy) 
     
    174124 
    175125        INIT_WORK(&psy->changed_work, power_supply_changed_work); 
    176         spin_lock_init(&psy->changed_lock); 
    177         wake_lock_init(&psy->work_wake_lock, WAKE_LOCK_SUSPEND, "power-supply"); 
    178126 
    179127        rc = power_supply_create_attrs(psy); 
     
    192140        power_supply_remove_attrs(psy); 
    193141create_attrs_failed: 
    194         wake_lock_destroy(&psy->work_wake_lock); 
    195142        device_unregister(psy->dev); 
    196143dev_create_failed: 
     
    198145        return rc; 
    199146} 
    200 EXPORT_SYMBOL_GPL(power_supply_register); 
    201147 
    202148void power_supply_unregister(struct power_supply *psy) 
     
    205151        power_supply_remove_triggers(psy); 
    206152        power_supply_remove_attrs(psy); 
    207         wake_lock_destroy(&psy->work_wake_lock); 
    208153        device_unregister(psy->dev); 
    209154} 
    210 EXPORT_SYMBOL_GPL(power_supply_unregister); 
    211155 
    212156static int __init power_supply_class_init(void) 
     
    227171} 
    228172 
     173EXPORT_SYMBOL_GPL(power_supply_changed); 
     174EXPORT_SYMBOL_GPL(power_supply_am_i_supplied); 
     175EXPORT_SYMBOL_GPL(power_supply_is_system_supplied); 
     176EXPORT_SYMBOL_GPL(power_supply_register); 
     177EXPORT_SYMBOL_GPL(power_supply_unregister); 
     178 
     179/* exported for the APM Power driver, APM emulation */ 
     180EXPORT_SYMBOL_GPL(power_supply_class); 
     181 
    229182subsys_initcall(power_supply_class_init); 
    230183module_exit(power_supply_class_exit); 
  • kern_2.6.32/drivers/power/power_supply_sysfs.c

    r118 r121  
    4343        static char *status_text[] = { 
    4444                "Unknown", "Charging", "Discharging", "Not charging", "Full" 
    45         }; 
    46         static char *charge_type[] = { 
    47                 "Unknown", "N/A", "Trickle", "Fast" 
    4845        }; 
    4946        static char *health_text[] = { 
     
    5552                "LiMn" 
    5653        }; 
    57         static char *capacity_level_text[] = { 
    58                 "Unknown", "Critical", "Low", "Normal", "High", "Full" 
    59         }; 
    6054        ssize_t ret; 
    6155        struct power_supply *psy = dev_get_drvdata(dev); 
     
    7468        if (off == POWER_SUPPLY_PROP_STATUS) 
    7569                return sprintf(buf, "%s\n", status_text[value.intval]); 
    76         else if (off == POWER_SUPPLY_PROP_CHARGE_TYPE) 
    77                 return sprintf(buf, "%s\n", charge_type[value.intval]); 
    7870        else if (off == POWER_SUPPLY_PROP_HEALTH) 
    7971                return sprintf(buf, "%s\n", health_text[value.intval]); 
    8072        else if (off == POWER_SUPPLY_PROP_TECHNOLOGY) 
    8173                return sprintf(buf, "%s\n", technology_text[value.intval]); 
    82         else if (off == POWER_SUPPLY_PROP_CAPACITY_LEVEL) 
    83                 return sprintf(buf, "%s\n", capacity_level_text[value.intval]); 
    8474        else if (off >= POWER_SUPPLY_PROP_MODEL_NAME) 
    8575                return sprintf(buf, "%s\n", value.strval); 
     
    9282        /* Properties of type `int' */ 
    9383        POWER_SUPPLY_ATTR(status), 
    94         POWER_SUPPLY_ATTR(charge_type), 
    9584        POWER_SUPPLY_ATTR(health), 
    9685        POWER_SUPPLY_ATTR(present), 
     
    121110        POWER_SUPPLY_ATTR(energy_avg), 
    122111        POWER_SUPPLY_ATTR(capacity), 
    123         POWER_SUPPLY_ATTR(capacity_level), 
    124112        POWER_SUPPLY_ATTR(temp), 
    125113        POWER_SUPPLY_ATTR(temp_ambient), 
     
    128116        POWER_SUPPLY_ATTR(time_to_full_now), 
    129117        POWER_SUPPLY_ATTR(time_to_full_avg), 
     118        /* for android <riversky> */ 
     119        POWER_SUPPLY_ATTR(batt_vol),     
     120        POWER_SUPPLY_ATTR(batt_temp), 
    130121        /* Properties of type `const char *' */ 
    131122        POWER_SUPPLY_ATTR(model_name), 
  • kern_2.6.32/drivers/power/s3c6410_battery_vinsq.c

    r118 r121  
    3838#include "s3c6410_battery_vinsq.h" 
    3939 
     40#define CONFIG_INSTINCTQ_REV04 0x0 
    4041#define DEBUG 
    41  
     42system_rev_bs = 0x0; 
    4243static struct wake_lock vbus_wake_lock; 
    4344 
     
    16871688#else 
    16881689#if defined(CONFIG_MACH_VINSQ) || defined(CONFIG_MACH_VITAL) 
    1689                                 if(system_rev >= CONFIG_INSTINCTQ_REV04) 
     1690                                if(system_rev_bs >= CONFIG_INSTINCTQ_REV04) 
    16901691                                        s3c_bat_info.bat_info.batt_vol_adc = 0; 
    16911692                                else 
     
    25402541#else 
    25412542#if defined(CONFIG_MACH_VINSQ) || defined(CONFIG_MACH_VITAL)     
    2542         if(system_rev >= CONFIG_INSTINCTQ_REV04) 
     2543        if(system_rev_bs >= CONFIG_INSTINCTQ_REV04) 
    25432544                s3c_bat_info.bat_info.level = s3c_get_bat_level_fuel(bat_ps);            
    25442545        else 
     
    25782579#else 
    25792580#if defined(CONFIG_MACH_VINSQ) || defined(CONFIG_MACH_VITAL) 
    2580         if(system_rev >= CONFIG_INSTINCTQ_REV04) 
     2581        if(system_rev_bs >= CONFIG_INSTINCTQ_REV04) 
    25812582                s3c_bat_info.bat_info.batt_vol = s3c_get_bat_vol_fuel(bat_ps); 
    25822583        else 
     
    30773078#ifdef __CHECK_BATTERY_V_F__ 
    30783079#ifdef __CHECK_BOARD_REV__ 
    3079         if (system_rev >= rev_to_check) 
     3080        if (system_rev_bs >= rev_to_check) 
    30803081#endif /* __CHECK_BOARD_REV__ */ 
    30813082                s3c_bat_check_v_f(); 
    30823083#endif /* __CHECK_BATTERY_V_F__ */ 
    30833084        s3c_cable_check_status(); 
    3084         printk("func : %s, rev%02x\n",__FUNCTION__, system_rev); 
     3085        printk("func : %s, rev%02x\n",__FUNCTION__, system_rev_bs); 
    30853086__end__: 
    30863087        return ret; 
     
    31523153 
    31533154#if defined(CONFIG_MACH_VINSQ) || defined(CONFIG_MACH_VITAL) 
    3154         if(system_rev >= CONFIG_INSTINCTQ_REV04) 
     3155        if(system_rev_bs >= CONFIG_INSTINCTQ_REV04) 
    31553156        { 
    31563157#endif 
  • kern_2.6.32/drivers/power/s3c6410_battery_vinsq.h

    r118 r121  
    120120const unsigned int gpio_ta_connected    = GPIO_TA_CONNECTED_N; 
    121121const unsigned int gpio_ta_connected_af = GPIO_TA_CONNECTED_N_AF; 
    122 const unsigned int gpio_chg_ing         = GPIO_CHG_ING_N; 
    123 const unsigned int gpio_chg_ing_af      = GPIO_CHG_ING_N_AF; 
     122const unsigned int gpio_chg_ing         = GPIO_TA_nCHG; 
     123const unsigned int gpio_chg_ing_af      = GPIO_TA_nCHG_AF; 
    124124const unsigned int gpio_chg_en          = GPIO_CHG_EN; 
    125125const unsigned int gpio_chg_en_af       = GPIO_CHG_EN_AF; 
  • kern_2.6.32/drivers/power/wm8350_power.c

    r118 r121  
    322322} 
    323323 
    324 static int wm8350_bat_get_charge_type(struct wm8350 *wm8350) 
    325 { 
    326         int state; 
    327  
    328         state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) & 
    329             WM8350_CHG_STS_MASK; 
    330         switch (state) { 
    331         case WM8350_CHG_STS_OFF: 
    332                 return POWER_SUPPLY_CHARGE_TYPE_NONE; 
    333         case WM8350_CHG_STS_TRICKLE: 
    334                 return POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 
    335         case WM8350_CHG_STS_FAST: 
    336                 return POWER_SUPPLY_CHARGE_TYPE_FAST; 
    337         default: 
    338                 return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 
    339         } 
    340 } 
    341  
    342324static int wm8350_bat_get_property(struct power_supply *psy, 
    343325                                   enum power_supply_property psp, 
     
    360342        case POWER_SUPPLY_PROP_HEALTH: 
    361343                val->intval = wm8350_bat_check_health(wm8350); 
    362                 break; 
    363         case POWER_SUPPLY_PROP_CHARGE_TYPE: 
    364                 val->intval = wm8350_bat_get_charge_type(wm8350); 
    365344                break; 
    366345        default: 
     
    377356        POWER_SUPPLY_PROP_VOLTAGE_NOW, 
    378357        POWER_SUPPLY_PROP_HEALTH, 
    379         POWER_SUPPLY_PROP_CHARGE_TYPE, 
    380358}; 
    381359 
  • kern_2.6.32/drivers/power/wm97xx_battery.c

    r118 r121  
    2323#include <linux/interrupt.h> 
    2424#include <linux/gpio.h> 
    25 #include <linux/irq.h> 
     25#include <linux/wm97xx_batt.h> 
    2626 
    2727static DEFINE_MUTEX(bat_lock); 
     
    2929struct mutex work_lock; 
    3030static int bat_status = POWER_SUPPLY_STATUS_UNKNOWN; 
    31 static struct wm97xx_batt_info *gpdata; 
     31static struct wm97xx_batt_info *pdata; 
    3232static enum power_supply_property *prop; 
    3333 
    3434static unsigned long wm97xx_read_bat(struct power_supply *bat_ps) 
    3535{ 
    36         struct wm97xx_pdata *wmdata = bat_ps->dev->parent->platform_data; 
    37         struct wm97xx_batt_pdata *pdata = wmdata->batt_pdata; 
    38  
    3936        return wm97xx_read_aux_adc(dev_get_drvdata(bat_ps->dev->parent), 
    4037                                        pdata->batt_aux) * pdata->batt_mult / 
     
    4441static unsigned long wm97xx_read_temp(struct power_supply *bat_ps) 
    4542{ 
    46         struct wm97xx_pdata *wmdata = bat_ps->dev->parent->platform_data; 
    47         struct wm97xx_batt_pdata *pdata = wmdata->batt_pdata; 
    48  
    4943        return wm97xx_read_aux_adc(dev_get_drvdata(bat_ps->dev->parent), 
    5044                                        pdata->temp_aux) * pdata->temp_mult / 
     
    5650                            union power_supply_propval *val) 
    5751{ 
    58         struct wm97xx_pdata *wmdata = bat_ps->dev->parent->platform_data; 
    59         struct wm97xx_batt_pdata *pdata = wmdata->batt_pdata; 
    60  
    6152        switch (psp) { 
    6253        case POWER_SUPPLY_PROP_STATUS: 
     
    10798{ 
    10899        int old_status = bat_status; 
    109         struct wm97xx_pdata *wmdata = bat_ps->dev->parent->platform_data; 
    110         struct wm97xx_batt_pdata *pdata = wmdata->batt_pdata; 
    111100 
    112101        mutex_lock(&work_lock); 
     
    139128} 
    140129 
    141 static irqreturn_t wm97xx_chrg_irq(int irq, void *data) 
     130#ifdef CONFIG_PM 
     131static int wm97xx_bat_suspend(struct platform_device *dev, pm_message_t state) 
     132{ 
     133        flush_scheduled_work(); 
     134        return 0; 
     135} 
     136 
     137static int wm97xx_bat_resume(struct platform_device *dev) 
    142138{ 
    143139        schedule_work(&bat_work); 
    144         return IRQ_HANDLED; 
    145 } 
    146  
    147 #ifdef CONFIG_PM 
    148 static int wm97xx_bat_suspend(struct device *dev) 
    149 { 
    150         flush_scheduled_work(); 
    151         return 0; 
    152 } 
    153  
    154 static int wm97xx_bat_resume(struct device *dev) 
    155 { 
    156         schedule_work(&bat_work); 
    157         return 0; 
    158 } 
    159  
    160 static struct dev_pm_ops wm97xx_bat_pm_ops = { 
    161         .suspend        = wm97xx_bat_suspend, 
    162         .resume         = wm97xx_bat_resume, 
    163 }; 
     140        return 0; 
     141} 
     142#else 
     143#define wm97xx_bat_suspend NULL 
     144#define wm97xx_bat_resume NULL 
    164145#endif 
    165146 
     
    169150        int props = 1;  /* POWER_SUPPLY_PROP_PRESENT */ 
    170151        int i = 0; 
    171         struct wm97xx_pdata *wmdata = dev->dev.platform_data; 
    172         struct wm97xx_batt_pdata *pdata; 
    173  
    174         if (gpdata) { 
    175                 dev_err(&dev->dev, "Do not pass platform_data through " 
    176                         "wm97xx_bat_set_pdata!\n"); 
    177                 return -EINVAL; 
    178         } else 
    179                 pdata = wmdata->batt_pdata; 
    180152 
    181153        if (dev->id != -1) 
     
    185157 
    186158        if (!pdata) { 
    187                 dev_err(&dev->dev, "No platform_data supplied\n"); 
     159                dev_err(&dev->dev, "Please use wm97xx_bat_set_pdata\n"); 
    188160                return -EINVAL; 
    189161        } 
    190162 
    191         if (gpio_is_valid(pdata->charge_gpio)) { 
     163        if (pdata->charge_gpio >= 0 && gpio_is_valid(pdata->charge_gpio)) { 
    192164                ret = gpio_request(pdata->charge_gpio, "BATT CHRG"); 
    193165                if (ret) 
    194166                        goto err; 
    195167                ret = gpio_direction_input(pdata->charge_gpio); 
    196                 if (ret) 
    197                         goto err2; 
    198                 ret = request_irq(gpio_to_irq(pdata->charge_gpio), 
    199                                 wm97xx_chrg_irq, IRQF_DISABLED, 
    200                                 "AC Detect", 0); 
    201168                if (ret) 
    202169                        goto err2; 
     
    217184        prop = kzalloc(props * sizeof(*prop), GFP_KERNEL); 
    218185        if (!prop) 
    219                 goto err3; 
     186                goto err2; 
    220187 
    221188        prop[i++] = POWER_SUPPLY_PROP_PRESENT; 
     
    250217                schedule_work(&bat_work); 
    251218        else 
    252                 goto err4; 
    253  
    254         return 0; 
    255 err4: 
     219                goto err3; 
     220 
     221        return 0; 
     222err3: 
    256223        kfree(prop); 
    257 err3: 
    258         if (gpio_is_valid(pdata->charge_gpio)) 
    259                 free_irq(gpio_to_irq(pdata->charge_gpio), dev); 
    260224err2: 
    261         if (gpio_is_valid(pdata->charge_gpio)) 
    262                 gpio_free(pdata->charge_gpio); 
     225        gpio_free(pdata->charge_gpio); 
    263226err: 
    264227        return ret; 
     
    267230static int __devexit wm97xx_bat_remove(struct platform_device *dev) 
    268231{ 
    269         struct wm97xx_pdata *wmdata = dev->dev.platform_data; 
    270         struct wm97xx_batt_pdata *pdata = wmdata->batt_pdata; 
    271  
    272         if (pdata && gpio_is_valid(pdata->charge_gpio)) { 
    273                 free_irq(gpio_to_irq(pdata->charge_gpio), dev); 
     232        if (pdata && pdata->charge_gpio && pdata->charge_gpio >= 0) 
    274233                gpio_free(pdata->charge_gpio); 
    275         } 
    276234        flush_scheduled_work(); 
    277235        power_supply_unregister(&bat_ps); 
     
    284242                .name   = "wm97xx-battery", 
    285243                .owner  = THIS_MODULE, 
    286 #ifdef CONFIG_PM 
    287                 .pm     = &wm97xx_bat_pm_ops, 
    288 #endif 
    289244        }, 
    290245        .probe          = wm97xx_bat_probe, 
    291246        .remove         = __devexit_p(wm97xx_bat_remove), 
     247        .suspend        = wm97xx_bat_suspend, 
     248        .resume         = wm97xx_bat_resume, 
    292249}; 
    293250 
     
    302259} 
    303260 
    304 void wm97xx_bat_set_pdata(struct wm97xx_batt_info *data) 
    305 { 
    306         gpdata = data; 
     261void __init wm97xx_bat_set_pdata(struct wm97xx_batt_info *data) 
     262{ 
     263        pdata = data; 
    307264} 
    308265EXPORT_SYMBOL_GPL(wm97xx_bat_set_pdata); 
  • kern_2.6.32/drivers/usb/gadget/fsa9480_i2c.c

    r120 r121  
    5151static unsigned short fsa9480_normal_i2c[] = {I2C_CLIENT_END }; 
    5252static unsigned short fsa9480_ignore[] = { I2C_CLIENT_END }; 
    53 static unsigned short fsa9480_i2c_probe[] = { 5, FSA9480UCX >> 1, I2C_CLIENT_END }; 
     53static unsigned short fsa9480_i2c_probe[] = { 0, FSA9480UCX >> 1, I2C_CLIENT_END }; 
    5454 
    5555static struct i2c_client_address_data fsa9480_addr_data = { 
  • kern_2.6.32/sound/soc/codecs/ak4671_instinctq.c

    r118 r121  
    2727#include <plat/regs-gpio.h> 
    2828#include <mach/hardware.h> 
     29#include <linux/gpio.h> 
    2930 
    3031#include <sound/soc.h> 
    3132 
    3233#include "ak4671.h" 
     34 
     35#define CONFIG_MACH_MAX 1 
     36#define GPIO_MIC_SEL_EN_REV04 GPIO_MIC_SEL 
     37#define GPIO_MONOHEAD_DET_ISR GPIO_DET_35 
    3338 
    3439#define AUDIO_SPECIFIC_DEBUG    0 
  • kern_2.6.32/sound/soc/s3c64xx/s3c6410-i2s.c

    r118 r121  
    1515#include <linux/io.h> 
    1616#include <linux/interrupt.h> 
     17#include <linux/gpio.h> 
    1718#include <sound/core.h> 
    1819#include <sound/pcm.h> 
    1920#include <sound/pcm_params.h> 
    2021#include <sound/soc.h> 
    21  
    2222#include <asm/dma.h> 
    2323#include <mach/map.h> 
     
    653653 
    654654        /* Configure the I2S pins in correct mode */ 
    655         s3c_gpio_cfgpin(GPIO_I2S_LRCLK, S3C_GPIO_SFN(GPIO_I2S_LRCLK_AF));  
    656         s3c_gpio_cfgpin(GPIO_I2S_CLK, S3C_GPIO_SFN(GPIO_I2S_CLK_AF));  
    657         s3c_gpio_cfgpin(GPIO_I2S_DI, S3C_GPIO_SFN(GPIO_I2S_DI_AF));    
    658         s3c_gpio_cfgpin(GPIO_I2S_DO, S3C_GPIO_SFN(GPIO_I2S_DO_AF)); 
     655        s3c_gpio_cfgpin(GPIO_I2S_SYNC, S3C_GPIO_SFN(GPIO_I2S_SYNC_AF));  
     656        s3c_gpio_cfgpin(GPIO_I2S_SCLK, S3C_GPIO_SFN(GPIO_I2S_SCLK_AF));  
     657        s3c_gpio_cfgpin(GPIO_I2S_SDI, S3C_GPIO_SFN(GPIO_I2S_SDI_AF));    
     658        s3c_gpio_cfgpin(GPIO_I2S_SDO, S3C_GPIO_SFN(GPIO_I2S_SDO_AF)); 
    659659 
    660660    /* pull-up-enable, pull-down-disable*/ 
    661         s3c_gpio_setpull(GPIO_I2S_CLK, S3C_GPIO_PULL_UP);  
    662         s3c_gpio_setpull(GPIO_I2S_LRCLK, S3C_GPIO_PULL_UP);  
    663         s3c_gpio_setpull(GPIO_I2S_DI, S3C_GPIO_PULL_UP);  
    664         s3c_gpio_setpull(GPIO_I2S_DO, S3C_GPIO_PULL_UP);  
     661        s3c_gpio_setpull(GPIO_I2S_SCLK, S3C_GPIO_PULL_UP);  
     662        s3c_gpio_setpull(GPIO_I2S_SYNC, S3C_GPIO_PULL_UP);  
     663        s3c_gpio_setpull(GPIO_I2S_SDI, S3C_GPIO_PULL_UP);  
     664        s3c_gpio_setpull(GPIO_I2S_SDO, S3C_GPIO_PULL_UP);  
    665665 
    666666        if (s3c_i2s.regs == NULL) 
Note: See TracChangeset for help on using the changeset viewer.