diff options
Diffstat (limited to 'drivers')
67 files changed, 2253 insertions, 1533 deletions
diff --git a/drivers/battery/battery-factory.c b/drivers/battery/battery-factory.c index d617a01..e244c8e 100644 --- a/drivers/battery/battery-factory.c +++ b/drivers/battery/battery-factory.c @@ -50,6 +50,8 @@ static struct device_attribute battery_attrs[] = { BATTERY_ATTR(siop_activated), BATTERY_ATTR(wc_status), BATTERY_ATTR(wpc_pin_state), + BATTERY_ATTR(factory_mode), + BATTERY_ATTR(update), /* not use */ BATTERY_ATTR(batt_vol_adc), @@ -82,6 +84,8 @@ enum { SIOP_ACTIVATED, WC_STATUS, WPC_PIN_STATE, + FACTORY_MODE, + UPDATE, /* not use */ BATT_VOL_ADC, @@ -207,6 +211,10 @@ static ssize_t battery_show_property(struct device *dev, #endif i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", val); break; + case FACTORY_MODE: + i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", + info->factory_mode); + break; case BATT_VOL_ADC: case BATT_VOL_ADC_CAL: case BATT_VOL_ADC_AVER: @@ -291,6 +299,22 @@ static ssize_t battery_store_property(struct device *dev, ret = count; } break; + case FACTORY_MODE: + if (sscanf(buf, "%d\n", &x) == 1) { + if (x) + info->factory_mode = true; + else + info->factory_mode = false; + + pr_info("%s: factory mode %s\n", __func__, + (info->factory_mode ? "set" : "clear")); + ret = count; + } + break; + case UPDATE: + pr_info("%s: battery update\n", __func__); + ret = count; + break; default: ret = -EINVAL; } diff --git a/drivers/battery/max17047_fuelgauge.c b/drivers/battery/max17047_fuelgauge.c index ae462a6..fc01547 100644 --- a/drivers/battery/max17047_fuelgauge.c +++ b/drivers/battery/max17047_fuelgauge.c @@ -37,11 +37,6 @@ #ifdef CONFIG_DEBUG_FS #include <linux/debugfs.h> #endif -/* adjust full soc */ -#define FULL_SOC_DEFAULT 9850 -#define FULL_SOC_LOW 9700 -#define FULL_SOC_HIGH 10000 -#define KEEP_SOC_DEFAULT 50 /* 0.5% */ #endif /* TRIM ERROR DETECTION */ @@ -69,9 +64,11 @@ #undef DEBUG_FUELGAUGE_POLLING #define MAX17047_POLLING_INTERVAL 10000 -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) -static void max17047_adjust_fullsoc(struct i2c_client *client); -#endif +/* adjust full soc */ +#define FULL_SOC_DEFAULT 9850 +#define FULL_SOC_LOW 9700 +#define FULL_SOC_HIGH 10000 +#define KEEP_SOC_DEFAULT 50 /* 0.5% */ struct max17047_fuelgauge_data { struct i2c_client *client; @@ -100,14 +97,12 @@ struct max17047_fuelgauge_data { unsigned int rawsoc; unsigned int temperature; -#if defined(CONFIG_TARGET_LOCALE_KOR) + /* adjust full soc */ int full_soc; + #ifdef CONFIG_DEBUG_FS struct dentry *fg_debugfs_dir; #endif -#elif defined(CONFIG_MACH_M0_CTC) - int full_soc; -#endif #ifdef CONFIG_HIBERNATION u8 *reg_dump; @@ -270,10 +265,6 @@ static int max17047_get_soc(struct i2c_client *client) rawsoc = max17047_get_rawsoc(fg_data->client); -#if defined(CONFIG_BATTERY_SAMSUNG_S2PLUS) - soc = fg_data->soc - = (rawsoc < 300) ? 0 : ((rawsoc - 300) * 100 / 9200) + 1; -#else #if defined(CONFIG_MACH_C1_KOR_SKT) || \ defined(CONFIG_MACH_C1_KOR_KT) || \ defined(CONFIG_MACH_C1_KOR_LGT) @@ -291,19 +282,30 @@ static int max17047_get_soc(struct i2c_client *client) soc = fg_data->soc = ((rawsoc < 29) ? 0 : (min(((rawsoc - 29) * 100 / (fg_data->full_soc - 29)), 100))); +#elif defined(CONFIG_MACH_T0_KOR_SKT) || \ + defined(CONFIG_MACH_T0_KOR_KT) || \ + defined(CONFIG_MACH_T0_KOR_LGT) + if (fg_data->full_soc <= 0) + fg_data->full_soc = FULL_SOC_DEFAULT; + + soc = fg_data->soc = + ((rawsoc < 29) ? 0 : (min(((rawsoc - 29) * 100 / + (fg_data->full_soc - 29)), 100))); #elif defined(CONFIG_MACH_M0_CTC) if (fg_data->full_soc <= 0) fg_data->full_soc = FULL_SOC_DEFAULT; soc = fg_data->soc = ((rawsoc < 29) ? 0 : (min(((rawsoc - 29) * 100 / - (fg_data->full_soc - 29)), 100))); + (fg_data->full_soc - 29)), 100))); #else - /* prevent minus value and add 0.5% up raw soc */ + /* M0 */ + if (fg_data->full_soc <= 0) + fg_data->full_soc = FULL_SOC_DEFAULT; + soc = fg_data->soc = ((rawsoc < 29) ? 0 : (min(((rawsoc - 29) * 100 / - (10000 - 79)), 100))); -#endif + (fg_data->full_soc - 29)), 100))); #endif pr_debug("%s: SOC(%d, %d)\n", __func__, soc, rawsoc); @@ -341,6 +343,38 @@ static void max17047_reset_soc(struct i2c_client *client) return; } +static void max17047_adjust_fullsoc(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + int prev_full_soc = fg_data->full_soc; + int temp_soc = max17047_get_rawsoc(fg_data->client); + int keep_soc = 0; + + if (temp_soc < 0) { + pr_err("%s : fg data error!(%d)\n", __func__, temp_soc); + fg_data->full_soc = FULL_SOC_DEFAULT; + return; + } + + if (temp_soc < FULL_SOC_LOW) + fg_data->full_soc = FULL_SOC_LOW; + else if (temp_soc > FULL_SOC_HIGH) { + keep_soc = FULL_SOC_HIGH / 100; + fg_data->full_soc = (FULL_SOC_HIGH - keep_soc); + } else { + keep_soc = temp_soc / 100; + if (temp_soc > (FULL_SOC_LOW + keep_soc)) + fg_data->full_soc = temp_soc - keep_soc; + else + fg_data->full_soc = FULL_SOC_LOW; + } + + if (prev_full_soc != fg_data->full_soc) + pr_info("%s : full_soc = %d, keep_soc = %d\n", __func__, + fg_data->full_soc, keep_soc); +} + /* SOC% alert, disabled(0xFF00) */ static void max17047_set_salrt(struct max17047_fuelgauge_data *fg_data, u8 min, u8 max) @@ -425,24 +459,6 @@ static void max17047_reg_init(struct max17047_fuelgauge_data *fg_data) u8 i2c_data[2]; pr_debug("%s\n", __func__); - -#if defined(CONFIG_BATTERY_SAMSUNG_S2PLUS) - i2c_data[1] = 0x00; - i2c_data[0] = 0x00; - max17047_i2c_write(client, MAX17047_REG_CGAIN, i2c_data); - - i2c_data[1] = 0x00; - i2c_data[0] = 0x03; - max17047_i2c_write(client, MAX17047_REG_MISCCFG, i2c_data); - - i2c_data[1] = 0x00; - i2c_data[0] = 0x07; - max17047_i2c_write(client, MAX17047_REG_LEARNCFG, i2c_data); - - i2c_data[1] = 0x00; - i2c_data[0] = 0x50; - max17047_i2c_write(client, MAX17047_REG_RCOMP, i2c_data); -#else /* Use MG1 */ i2c_data[1] = 0x00; i2c_data[0] = 0x00; max17047_i2c_write(client, MAX17047_REG_CGAIN, i2c_data); @@ -454,7 +470,6 @@ static void max17047_reg_init(struct max17047_fuelgauge_data *fg_data) i2c_data[1] = 0x07; i2c_data[0] = 0x00; max17047_i2c_write(client, MAX17047_REG_LEARNCFG, i2c_data); -#endif } static void max17047_update_work(struct work_struct *work) @@ -607,18 +622,16 @@ static int max17047_get_property(struct power_supply *psy, switch (val->intval) { case SOC_TYPE_ADJUSTED: val->intval = max17047_get_soc(fg_data->client); - break; + break; case SOC_TYPE_RAW: val->intval = max17047_get_rawsoc(fg_data->client); - break; -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) + break; case SOC_TYPE_FULL: val->intval = fg_data->full_soc; - break; -#endif + break; default: val->intval = max17047_get_soc(fg_data->client); - break; + break; } break; case POWER_SUPPLY_PROP_TEMP: @@ -643,7 +656,6 @@ static int max17047_set_property(struct power_supply *psy, case POWER_SUPPLY_PROP_CAPACITY: max17047_reset_soc(fg_data->client); break; -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) case POWER_SUPPLY_PROP_STATUS: if (val->intval != POWER_SUPPLY_STATUS_FULL) return -EINVAL; @@ -651,7 +663,6 @@ static int max17047_set_property(struct power_supply *psy, /* adjust full soc */ max17047_adjust_fullsoc(fg_data->client); break; -#endif default: return -EINVAL; } @@ -663,7 +674,6 @@ static irqreturn_t max17047_fuelgauge_isr(int irq, void *data) { struct max17047_fuelgauge_data *fg_data = data; struct i2c_client *client = fg_data->client; - struct power_supply *battery_psy = power_supply_get_by_name("battery"); union power_supply_propval value; u8 i2c_data[2]; pr_info("%s: irq(%d)\n", __func__, irq); @@ -680,40 +690,6 @@ static irqreturn_t max17047_fuelgauge_isr(int irq, void *data) return IRQ_HANDLED; } -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) -static void max17047_adjust_fullsoc(struct i2c_client *client) -{ - struct max17047_fuelgauge_data *fg_data = - i2c_get_clientdata(client); - int prev_full_soc = fg_data->full_soc; - int temp_soc = max17047_get_rawsoc(fg_data->client); - int keep_soc = 0; - - if (temp_soc < 0) { - pr_err("%s : fg data error!(%d)\n", __func__, temp_soc); - fg_data->full_soc = FULL_SOC_DEFAULT; - return; - } - - if (temp_soc < FULL_SOC_LOW) - fg_data->full_soc = FULL_SOC_LOW; - else if (temp_soc > FULL_SOC_HIGH) { - keep_soc = FULL_SOC_HIGH / 100; - fg_data->full_soc = (FULL_SOC_HIGH - keep_soc); - } else { - keep_soc = temp_soc / 100; - if (temp_soc > (FULL_SOC_LOW + keep_soc)) - fg_data->full_soc = temp_soc - keep_soc; - else - fg_data->full_soc = FULL_SOC_LOW; - } - - if (prev_full_soc != fg_data->full_soc) - pr_info("%s : full_soc = %d, keep_soc = %d\n", __func__, - fg_data->full_soc, keep_soc); -} -#endif - #if defined(CONFIG_TARGET_LOCALE_KOR) #ifdef CONFIG_DEBUG_FS static int max17047_debugfs_open(struct inode *inode, struct file *filp) @@ -868,10 +844,7 @@ static int __devinit max17047_fuelgauge_i2c_probe(struct i2c_client *client, struct max17047_fuelgauge_data *fg_data; int ret; u8 i2c_data[2]; -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) - int rawsoc; - int firstsoc; -#endif + int rawsoc, firstsoc; pr_info("%s: max17047 Fuel gauge Driver Loading\n", __func__); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) @@ -891,7 +864,6 @@ static int __devinit max17047_fuelgauge_i2c_probe(struct i2c_client *client, wake_lock_init(&fg_data->update_wake_lock, WAKE_LOCK_SUSPEND, "fuel-update"); -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) /* Initialize full_soc, set this before fisrt SOC reading */ fg_data->full_soc = FULL_SOC_DEFAULT; /* first full_soc update */ @@ -900,8 +872,7 @@ static int __devinit max17047_fuelgauge_i2c_probe(struct i2c_client *client, max17047_adjust_fullsoc(client); firstsoc = max17047_get_soc(client); pr_info("%s: rsoc=%d, fsoc=%d, soc=%d\n", __func__, - rawsoc, fg_data->full_soc, firstsoc); -#endif + rawsoc, fg_data->full_soc, firstsoc); if (fg_data->pdata->psy_name) fg_data->fuelgauge.name = diff --git a/drivers/battery/max77693_charger.c b/drivers/battery/max77693_charger.c index 9ed3122..c17bbac 100644 --- a/drivers/battery/max77693_charger.c +++ b/drivers/battery/max77693_charger.c @@ -101,8 +101,10 @@ #define MAX77693_CHG_CC 0x3F /* MAX77693_CHG_REG_CHG_CNFG_04 */ -#define MAX77693_CHG_MINVSYS_MASK 0x1F -#define MAX77693_CHG_MINVSYS_SHIFT 5 +#define MAX77693_CHG_MINVSYS_MASK 0xE0 +#define MAX77693_CHG_MINVSYS_SHIFT 5 +#define MAX77693_CHG_PRM_MASK 0x1F +#define MAX77693_CHG_PRM_SHIFT 0 /* MAX77693_CHG_REG_CHG_CNFG_09 */ #define MAX77693_CHG_CHGIN_LIM 0x7F @@ -114,6 +116,8 @@ /* MAX77693_MUIC_REG_STATUS2 */ #define MAX77693_VBVOLT 0x40 #define MAX77693_VBVOLT_SHIFT 6 +#define MAX77693_DXOVP 0x20 +#define MAX77693_DXOVP_SHIFT 5 #define MAX77693_CHGDETRUN 0x08 #define MAX77693_CHGDETRUN_SHIFT 3 #define MAX77693_CHGTYPE 0x07 @@ -132,12 +136,18 @@ #define SOFT_CHG_CURR_STEP 100 /* mA */ #define SOFT_CHG_STEP_DUR 20 /* ms */ +/* soft regulation */ +#define SW_REG_CURR_STEP_MA 100 +#define SW_REG_START_DELAY 1000 +#define SW_REG_STEP_DELAY 500 + struct max77693_charger_data { struct max77693_dev *max77693; struct power_supply charger; struct delayed_work update_work; + struct delayed_work softreg_work; /* mutex */ struct mutex irq_lock; @@ -145,6 +155,7 @@ struct max77693_charger_data { /* wakelock */ struct wake_lock update_wake_lock; + struct wake_lock softreg_wake_lock; unsigned int charging_state; unsigned int charging_type; @@ -331,11 +342,7 @@ static int max77693_get_charger_state(struct max77693_charger_data *chg_data) max77693_read_reg(i2c, MAX77693_CHG_REG_CHG_DTLS_01, ®_data); reg_data = ((reg_data & MAX77693_CHG_DTLS) >> MAX77693_CHG_DTLS_SHIFT); -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) - pr_info("%s: CHG_DTLS(0x%02x)\n", __func__, reg_data); -#else pr_debug("%s: CHG_DTLS(0x%02x)\n", __func__, reg_data); -#endif switch (reg_data) { case 0x0: @@ -583,10 +590,10 @@ static bool max77693_get_wc_state(struct max77693_charger_data *chg_data) /* check chargable dock */ static int max77693_get_dock_type(struct max77693_charger_data *chg_data) { - int state; + int state = POWER_SUPPLY_TYPE_BATTERY; u8 reg_data; int muic_cb_typ; - u8 mu_st2, vbvolt; + u8 mu_st2, vbvolt = 0; pr_debug("%s\n", __func__); muic_cb_typ = max77693_muic_get_charging_type(); @@ -632,7 +639,7 @@ static int max77693_get_cable_type(struct max77693_charger_data *chg_data) int state; u8 reg_data, mu_adc, mu_adc1k, otg; u8 dtls_00, chgin_dtls; - u8 mu_st2, chgdetrun, vbvolt, chgtyp; + u8 mu_st2, chgdetrun, vbvolt, chgtyp, dxovp; bool wc_state; bool retry_det, chg_det_erred; int retry_cnt = 0; @@ -673,7 +680,7 @@ static int max77693_get_cable_type(struct max77693_charger_data *chg_data) goto chg_det_finish; } - chg_det_erred = true; /* TEMP: set as true for logging */ + chg_det_erred = false; /* TEMP: set as true for logging */ do { retry_det = false; @@ -690,7 +697,7 @@ static int max77693_get_cable_type(struct max77693_charger_data *chg_data) chgtyp = ((mu_st2 & MAX77693_CHGTYPE) >> MAX77693_CHGTYPE_SHIFT); if (chg_det_erred) - pr_info("%s: CHGIN(0x%x). MU_ST2(0x%x), " + pr_err("%s: CHGIN(0x%x). MU_ST2(0x%x), " "CDR(0x%x), VB(0x%x), CHGTYP(0x%x)\n", __func__, chgin_dtls, mu_st2, chgdetrun, vbvolt, chgtyp); @@ -699,13 +706,14 @@ static int max77693_get_cable_type(struct max77693_charger_data *chg_data) if (((chgin_dtls != 0x0) && (vbvolt == 0x1)) || ((chgin_dtls == 0x0) && (vbvolt == 0x0)) || (chg_data->reg_loop_deted == true)) { - pr_info("%s: sync power: CHGIN(0x%x), VB(0x%x), REG(%d)\n", + pr_debug("%s: sync power: CHGIN(0x%x), VB(0x%x), REG(%d)\n", __func__, chgin_dtls, vbvolt, chg_data->reg_loop_deted); } else { pr_err("%s: async power: CHGIN(0x%x), VB(0x%x), REG(%d)\n", __func__, chgin_dtls, vbvolt, chg_data->reg_loop_deted); + chg_det_erred = true; /* check chargable input power */ if ((chgin_dtls == 0x0) && @@ -728,12 +736,24 @@ static int max77693_get_cable_type(struct max77693_charger_data *chg_data) ((vbvolt == 0x0) && (chgtyp != 0x00))) { pr_info("%s: VB(0x%x), CHGTYP(0x%x)\n", __func__, vbvolt, chgtyp); - goto chg_det_err; + + /* check D+/D- ovp */ + dxovp = ((mu_st2 & MAX77693_DXOVP) >> + MAX77693_DXOVP_SHIFT); + if (dxovp) { + pr_err("%s: D+/D- ovp state\n", __func__); + chg_det_erred = true; + state = POWER_SUPPLY_TYPE_USB; + goto chg_det_finish; + } else { + pr_err("%s: async power and chgtyp\n", __func__); + goto chg_det_err; + } } /* charger type ok */ if (chg_det_erred) - pr_info("%s: chgtyp detect ok, " + pr_err("%s: chgtyp detect ok, " "CHGIN(0x%x). MU_ST2(0x%x), " "CDR(0x%x), VB(0x%x), CHGTYP(0x%x)\n", __func__, chgin_dtls, mu_st2, @@ -789,7 +809,13 @@ chg_det_err: } chg_det_finish: - pr_info("%s: cable type(%d)\n", __func__, state); + if (chg_det_erred) + pr_err("%s: cable type(%d)\n", __func__, state); + + /* if cable is nothing, clear soft reg state flag */ + if (state == POWER_SUPPLY_TYPE_BATTERY) + chg_data->soft_reg_state = false; + chg_data->cable_type = state; mutex_unlock(&chg_data->ops_lock); @@ -803,20 +829,20 @@ static int max77693_get_battery_state(struct max77693_charger_data *chg_data) int state; int vbus_state; int chg_state; + bool low_bat = false; u8 reg_data; pr_debug("%s\n", __func__); max77693_read_reg(i2c, MAX77693_CHG_REG_CHG_DTLS_01, ®_data); reg_data = ((reg_data & MAX77693_BAT_DTLS) >> MAX77693_BAT_DTLS_SHIFT); -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) - pr_info("%s: BAT_DTLS(0x%02x)\n", __func__, reg_data); -#else pr_debug("%s: BAT_DTLS(0x%02x)\n", __func__, reg_data); -#endif switch (reg_data) { case 0x01: - state = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; + pr_info("%s: battery is okay " + "but its voltage is low(~VPQLB)\n", __func__); + low_bat = true; + state = POWER_SUPPLY_HEALTH_GOOD; break; case 0x02: pr_info("%s: battery dead\n", __func__); @@ -827,7 +853,8 @@ static int max77693_get_battery_state(struct max77693_charger_data *chg_data) break; case 0x04: pr_info("%s: battery is okay " - "but its voltage is low\n", __func__); + "but its voltage is low(VPQLB~VSYSMIN)\n", __func__); + low_bat = true; state = POWER_SUPPLY_HEALTH_GOOD; break; case 0x05: @@ -850,7 +877,7 @@ static int max77693_get_battery_state(struct max77693_charger_data *chg_data) if (vbus_state == POWER_SUPPLY_VBUS_OVLO) { pr_info("%s: vbus ovp\n", __func__); state = POWER_SUPPLY_HEALTH_OVERVOLTAGE; - } else if ((reg_data == 0x4) && + } else if ((low_bat == true) && (chg_state == POWER_SUPPLY_STATUS_FULL)) { pr_info("%s: battery terminal error\n", __func__); state = POWER_SUPPLY_HEALTH_UNDERVOLTAGE; @@ -896,10 +923,6 @@ static void max77693_charger_reg_init(struct max77693_charger_data *chg_data) reg_data = (1 << 7); max77693_write_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_02, reg_data); -#if defined(CONFIG_MACH_S2PLUS) - /* top off current 200mA */ - reg_data = 0x04; -#else /* * top off current 100mA * top off timer 0min @@ -908,7 +931,7 @@ static void max77693_charger_reg_init(struct max77693_charger_data *chg_data) reg_data = (0x03 << 0); /* 125mA */ else reg_data = (0x00 << 0); /* 100mA */ -#endif + reg_data |= (0x00 << 3); max77693_write_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_03, reg_data); @@ -921,15 +944,24 @@ static void max77693_charger_reg_init(struct max77693_charger_data *chg_data) else reg_data = (0xD6 << 0); - /* For GC1 Model, MINVSYS is 3.4V*/ + /* + * For GC1 Model, MINVSYS is 3.4V. + * For GC1 Model PRMV( Primary Charge Regn. Voltage) = 4.25V. + * Actual expected regulated voltage needs to be 4.2V but due to + * internal resistance and circuit deviation we need to set the + * benchmark a bit higher(4.25V). + */ #if defined(CONFIG_MACH_GC1) - reg_data &= MAX77693_CHG_MINVSYS_MASK; + reg_data &= (~MAX77693_CHG_PRM_MASK); + reg_data |= (0x18 << MAX77693_CHG_PRM_SHIFT); + reg_data &= (~MAX77693_CHG_MINVSYS_MASK); reg_data |= (0x4 << MAX77693_CHG_MINVSYS_SHIFT); #endif pr_info("%s: battery cv voltage %s, (sysrev %d)\n", __func__, - (((reg_data & MAX77693_CHG_MINVSYS_MASK) == \ - (0x1D << 0)) ? "4.35V" : "4.2V"), system_rev); + (((reg_data & MAX77693_CHG_PRM_MASK) == \ + (0x1D << MAX77693_CHG_PRM_SHIFT)) ? "4.35V" : "4.2V"), + system_rev); max77693_write_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_04, reg_data); @@ -937,38 +969,9 @@ static void max77693_charger_reg_init(struct max77693_charger_data *chg_data) reg_data = 0x50; max77693_write_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_11, reg_data); -#if defined(CONFIG_MACH_S2PLUS) - /* charging disable */ - reg_data = 0x00; - max77693_write_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_00, reg_data); -#endif - max77693_dump_reg(chg_data); } -#define SW_REG_CURR_STEP_MA 300 -static void max77693_soft_regulation(struct max77693_charger_data *chg_data) -{ - struct i2c_client *i2c = chg_data->max77693->i2c; - u8 reg_data; - pr_info("%s\n", __func__); - - /* enable soft regulation loop */ - chg_data->soft_reg_state = true; - - max77693_read_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_09, ®_data); - reg_data &= MAX77693_CHG_CHGIN_LIM; - chg_data->soft_reg_current = reg_data * 20; - chg_data->soft_reg_current -= SW_REG_CURR_STEP_MA; - chg_data->soft_reg_current = max(chg_data->soft_reg_current, 0); - pr_info("%s: %dmA to %dmA\n", __func__, - reg_data * 20, chg_data->soft_reg_current); - - reg_data = (chg_data->soft_reg_current / 20); - pr_debug("%s: reg_data(0x%02x)\n", __func__, reg_data); - max77693_write_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_09, reg_data); -} - static void max77693_update_work(struct work_struct *work) { struct max77693_charger_data *chg_data = container_of(work, @@ -1012,7 +1015,9 @@ static void max77693_update_work(struct work_struct *work) vbus_state = max77693_get_vbus_state(chg_data); if (vbus_state == POWER_SUPPLY_VBUS_WEAK) { pr_info("%s: vbus weak\n", __func__); - max77693_soft_regulation(chg_data); + wake_lock(&chg_data->softreg_wake_lock); + schedule_delayed_work(&chg_data->softreg_work, + msecs_to_jiffies(SW_REG_START_DELAY)); } else pr_debug("%s: vbus not weak\n", __func__); break; @@ -1029,6 +1034,60 @@ static void max77693_update_work(struct work_struct *work) wake_unlock(&chg_data->update_wake_lock); } +static void max77693_softreg_work(struct work_struct *work) +{ + struct max77693_charger_data *chg_data = container_of(work, + struct max77693_charger_data, + softreg_work.work); + struct i2c_client *i2c = chg_data->max77693->i2c; + u8 reg_data; + u8 int_ok, dtls_02, byp_dtls; + pr_info("%s\n", __func__); + + mutex_lock(&chg_data->ops_lock); + + max77693_read_reg(chg_data->max77693->i2c, + MAX77693_CHG_REG_CHG_INT_OK, + &int_ok); + + max77693_read_reg(chg_data->max77693->i2c, + MAX77693_CHG_REG_CHG_DTLS_02, + &dtls_02); + + byp_dtls = ((dtls_02 & MAX77693_BYP_DTLS) >> + MAX77693_BYP_DTLS_SHIFT); + pr_info("%s: INT_OK(0x%02x), BYP_DTLS(0x%02x)\n", + __func__, int_ok, byp_dtls); + + if (byp_dtls & MAX77693_BYP_DTLS3) { + pr_info("%s: unstable power state for %dms\n", __func__, + SW_REG_START_DELAY); + /* enable soft regulation loop */ + chg_data->soft_reg_state = true; + + max77693_read_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_09, ®_data); + reg_data &= MAX77693_CHG_CHGIN_LIM; + chg_data->soft_reg_current = reg_data * 20; + chg_data->soft_reg_current -= SW_REG_CURR_STEP_MA; + chg_data->soft_reg_current = max(chg_data->soft_reg_current, 0); + pr_info("%s: %dmA to %dmA\n", __func__, + reg_data * 20, chg_data->soft_reg_current); + + reg_data = (chg_data->soft_reg_current / 20); + pr_debug("%s: reg_data(0x%02x)\n", __func__, reg_data); + max77693_write_reg(i2c, MAX77693_CHG_REG_CHG_CNFG_09, reg_data); + + wake_lock(&chg_data->softreg_wake_lock); + schedule_delayed_work(&chg_data->softreg_work, + msecs_to_jiffies(SW_REG_STEP_DELAY)); + } else { + pr_info("%s: (recover) stable power\n", __func__); + wake_unlock(&chg_data->softreg_wake_lock); + } + + mutex_unlock(&chg_data->ops_lock); +} + /* Support property from charger */ static enum power_supply_property max77693_charger_props[] = { POWER_SUPPLY_PROP_STATUS, @@ -1154,7 +1213,9 @@ static irqreturn_t max77693_bypass_irq(int irq, void *data) pr_err("%s: chgin regulation loop is active\n", __func__); if (chg_data->cable_type != POWER_SUPPLY_TYPE_WIRELESS) { /* software regulation */ - max77693_soft_regulation(chg_data); + wake_lock(&chg_data->softreg_wake_lock); + schedule_delayed_work(&chg_data->softreg_work, + msecs_to_jiffies(SW_REG_START_DELAY)); } else pr_err("%s: now in wireless charging, " " do not sw regulation\n", __func__); @@ -1254,9 +1315,13 @@ static irqreturn_t wpc_charger_irq(int irq, void *data) __func__); s3c_gpio_setpull(chg_data->wc_v_gpio, S3C_GPIO_PULL_NONE); + mutex_unlock(&chg_data->irq_lock); enable_irq(chg_data->wc_v_irq); + mutex_lock(&chg_data->irq_lock); } else if ((chg_data->wc_w_state == 1) && (wc_w_state == 0)) { - disable_irq(chg_data->wc_v_irq); + mutex_unlock(&chg_data->irq_lock); + disable_irq_nosync(chg_data->wc_v_irq); + mutex_lock(&chg_data->irq_lock); pr_info("%s: wpc deactivated, set V_INT as PD\n", __func__); s3c_gpio_setpull(chg_data->wc_v_gpio, @@ -1392,6 +1457,8 @@ static __devinit int max77693_charger_probe(struct platform_device *pdev) wake_lock_init(&chg_data->update_wake_lock, WAKE_LOCK_SUSPEND, "charger-update"); + wake_lock_init(&chg_data->softreg_wake_lock, WAKE_LOCK_SUSPEND, + "charger-softreg"); chg_data->charger_pdata = pdata->charger_data; if (!pdata->charger_data->init_data) @@ -1421,6 +1488,9 @@ static __devinit int max77693_charger_probe(struct platform_device *pdev) INIT_DELAYED_WORK_DEFERRABLE(&chg_data->update_work, max77693_update_work); + INIT_DELAYED_WORK_DEFERRABLE(&chg_data->softreg_work, + max77693_softreg_work); + ret = request_threaded_irq(chg_data->irq_bypass, NULL, max77693_bypass_irq, 0, "bypass-irq", chg_data); if (ret < 0) @@ -1441,7 +1511,8 @@ static __devinit int max77693_charger_probe(struct platform_device *pdev) #ifdef CONFIG_BATTERY_WPC_CHARGER chg_data->wc_pwr_det = chg_data->charger_pdata->wc_pwr_det; -#if defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_C1VZW) +#if defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_C1VZW) || \ + defined(CONFIG_MACH_GRANDE) || defined(CONFIG_MACH_IRON) if (system_rev >= 0xA) chg_data->wc_pwr_det = true; #endif @@ -1449,6 +1520,9 @@ static __devinit int max77693_charger_probe(struct platform_device *pdev) if (system_rev >= 0x6) chg_data->wc_pwr_det = true; #endif +#if defined(CONFIG_MACH_C2) + chg_data->wc_pwr_det = true; +#endif if (chg_data->wc_pwr_det) pr_info("%s: support wc power detection\n", __func__); @@ -1551,6 +1625,7 @@ wpc_init_finish: err_kfree: wake_lock_destroy(&chg_data->update_wake_lock); + wake_lock_destroy(&chg_data->softreg_wake_lock); mutex_destroy(&chg_data->ops_lock); mutex_destroy(&chg_data->irq_lock); @@ -1563,6 +1638,7 @@ static int __devexit max77693_charger_remove(struct platform_device *pdev) struct max77693_charger_data *chg_data = platform_get_drvdata(pdev); wake_lock_destroy(&chg_data->update_wake_lock); + wake_lock_destroy(&chg_data->softreg_wake_lock); mutex_destroy(&chg_data->ops_lock); mutex_destroy(&chg_data->irq_lock); diff --git a/drivers/battery/samsung_battery.c b/drivers/battery/samsung_battery.c index dfd5d4a..d1cee8f 100644 --- a/drivers/battery/samsung_battery.c +++ b/drivers/battery/samsung_battery.c @@ -46,7 +46,6 @@ static char *supply_list[] = { }; #if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) -static void battery_notify_full_state(struct battery_info *info); static bool battery_terminal_check_support(struct battery_info *info); static void battery_error_control(struct battery_info *info); #endif @@ -111,14 +110,6 @@ static int battery_get_temper(struct battery_info *info) temper = value.intval; break; case TEMPER_AP_ADC: -#if defined(CONFIG_MACH_S2PLUS) - if (system_rev < 2) { - pr_info("%s: adc fixed as 30.0\n", __func__); - temper = 300; - mutex_unlock(&info->ops_lock); - return temper; - } -#endif #if defined(CONFIG_S3C_ADC) adc = adc_max = adc_min = adc_total = 0; for (cnt = 0; cnt < CNT_ADC_SAMPLE; cnt++) { @@ -293,7 +284,14 @@ void battery_update_info(struct battery_info *info) value.intval = SOC_TYPE_ADJUSTED; info->psy_fuelgauge->get_property(info->psy_fuelgauge, POWER_SUPPLY_PROP_CAPACITY, &value); - info->battery_soc = value.intval; + + if ((info->cable_type == POWER_SUPPLY_TYPE_BATTERY) && + (info->battery_soc < value.intval) && (info->monitor_count)) + pr_info("%s: new soc(%d) is bigger than prev soc(%d)" + " in discharging state\n", __func__, + value.intval, info->battery_soc); + else + info->battery_soc = value.intval; value.intval = SOC_TYPE_RAW; info->psy_fuelgauge->get_property(info->psy_fuelgauge, @@ -301,12 +299,10 @@ void battery_update_info(struct battery_info *info) info->battery_r_s_delta = value.intval - info->battery_raw_soc; info->battery_raw_soc = value.intval; -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) value.intval = SOC_TYPE_FULL; info->psy_fuelgauge->get_property(info->psy_fuelgauge, POWER_SUPPLY_PROP_CAPACITY, &value); info->battery_full_soc = value.intval; -#endif value.intval = VOLTAGE_TYPE_VCELL; info->psy_fuelgauge->get_property(info->psy_fuelgauge, @@ -355,7 +351,7 @@ update_finish: break; } - pr_debug("%s: state(%d), type(%d), " + pr_info("%s: state(%d), type(%d), " "health(%d), present(%d), " "cable(%d), curr(%d), " "soc(%d), raw(%d), " @@ -382,19 +378,8 @@ void battery_control_info(struct battery_info *info, case POWER_SUPPLY_PROP_CURRENT_MAX: case POWER_SUPPLY_PROP_CURRENT_NOW: #if defined(CONFIG_CHARGER_MAX8922_U1) -#if defined(CONFIG_MACH_S2PLUS) - if (system_rev >= 2) { - info->psy_sub_charger->set_property( - info->psy_sub_charger, - property, &value); - } else { - info->psy_charger->set_property(info->psy_charger, - property, &value); - } -#else info->psy_sub_charger->set_property(info->psy_sub_charger, property, &value); -#endif #else info->psy_charger->set_property(info->psy_charger, property, &value); @@ -421,6 +406,20 @@ static void samsung_battery_alarm_start(struct alarm *alarm) schedule_work(&info->monitor_work); } +static void battery_notify_full_state(struct battery_info *info) +{ + union power_supply_propval value; + + if ((info->recharge_phase && info->full_charged_state) || + ((info->battery_raw_soc > info->battery_full_soc) && + (info->battery_soc == 100))) { + /* notify full state to fuel guage */ + value.intval = POWER_SUPPLY_STATUS_FULL; + info->psy_fuelgauge->set_property(info->psy_fuelgauge, + POWER_SUPPLY_PROP_STATUS, &value); + } +} + static void battery_monitor_interval(struct battery_info *info) { ktime_t interval, next, slack; @@ -518,10 +517,16 @@ static bool battery_abstimer_cond(struct battery_info *info) ktime = alarm_get_elapsed_realtime(); current_time = ktime_to_timespec(ktime); - if (info->recharge_phase) + if (info->recharge_phase) { abstimer_duration = info->pdata->abstimer_recharge_duration; - else - abstimer_duration = info->pdata->abstimer_charge_duration; + } else { + if (info->cable_type == POWER_SUPPLY_TYPE_WIRELESS) + abstimer_duration = + info->pdata->abstimer_charge_duration_wpc; + else + abstimer_duration = + info->pdata->abstimer_charge_duration; + } if ((current_time.tv_sec - info->charge_start_time) > abstimer_duration) { @@ -1294,9 +1299,7 @@ monitor_finish: /* icon indicator */ battery_indicator_icon(info); -#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) battery_notify_full_state(info); -#endif /* dynamic battery polling interval */ battery_interval_calulation(info); @@ -1426,20 +1429,6 @@ static void battery_error_work(struct work_struct *work) } #if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC) -static void battery_notify_full_state(struct battery_info *info) -{ - union power_supply_propval value; - - if ((info->recharge_phase && info->full_charged_state) || - ((info->battery_raw_soc > info->battery_full_soc) && - (info->battery_soc == 100))) { - /* notify full state to fuel guage */ - value.intval = POWER_SUPPLY_STATUS_FULL; - info->psy_fuelgauge->set_property(info->psy_fuelgauge, - POWER_SUPPLY_PROP_STATUS, &value); - } -} - static bool battery_terminal_check_support(struct battery_info *info) { int full_mode; @@ -1724,11 +1713,8 @@ static __devinit int samsung_battery_probe(struct platform_device *pdev) pr_info("%s: Recharge voltage: %d\n", __func__, info->pdata->recharge_voltage); #if defined(CONFIG_S3C_ADC) -#if defined(CONFIG_MACH_S2PLUS) - if (system_rev >= 2) -#endif - /* adc register */ - info->adc_client = s3c_adc_register(pdev, NULL, NULL, 0); + /* adc register */ + info->adc_client = s3c_adc_register(pdev, NULL, NULL, 0); if (IS_ERR(info->adc_client)) { pr_err("%s: fail to register adc\n", __func__); diff --git a/drivers/input/keyboard/cypress/cypress-touchkey.c b/drivers/input/keyboard/cypress/cypress-touchkey.c index dde89e4..72a3422 100644 --- a/drivers/input/keyboard/cypress/cypress-touchkey.c +++ b/drivers/input/keyboard/cypress/cypress-touchkey.c @@ -590,6 +590,13 @@ static int touchkey_firmware_update(struct touchkey_i2c *tkey_i2c) return TK_UPDATE_FAIL; } + ret = i2c_touchkey_read(tkey_i2c->client, KEYCODE_REG, data, 3); + if (ret < 0) { + printk(KERN_DEBUG + "[TouchKey] i2c read fail. do not excute firm update.\n"); + } + tkey_i2c->firmware_ver = data[1]; + tkey_i2c->module_ver = data[2]; printk(KERN_DEBUG "[TouchKey] firm ver = %d, module ver = %d\n", tkey_i2c->firmware_ver, tkey_i2c->module_ver); } else { @@ -640,6 +647,7 @@ static int touchkey_firmware_update(struct touchkey_i2c *tkey_i2c) if (retry <= 0) { tkey_i2c->pdata->power_on(0); tkey_i2c->update_status = TK_UPDATE_FAIL; + ret = TK_UPDATE_FAIL; } } else { if (tkey_i2c->firmware_ver >= 0x0A) { @@ -1739,6 +1747,16 @@ static int i2c_touchkey_probe(struct i2c_client *client, } } + ret = touchkey_i2c_check(tkey_i2c); + if (ret < 0) { + printk(KERN_DEBUG + "[TouchKey] i2c read fail. do not excute firm update.\n"); + + input_unregister_device(input_dev); + touchkey_probe = false; + return -EBUSY; + } + ret = request_threaded_irq(tkey_i2c->irq, NULL, touchkey_interrupt, IRQF_DISABLED | IRQF_TRIGGER_FALLING | @@ -1751,13 +1769,6 @@ static int i2c_touchkey_probe(struct i2c_client *client, return -EBUSY; } -#ifdef CONFIG_HAS_EARLYSUSPEND - tkey_i2c->early_suspend.suspend = - (void *)sec_touchkey_early_suspend; - tkey_i2c->early_suspend.resume = - (void *)sec_touchkey_late_resume; - register_early_suspend(&tkey_i2c->early_suspend); -#endif tkey_i2c->pdata->led_power_on(1); @@ -1772,6 +1783,14 @@ static int i2c_touchkey_probe(struct i2c_client *client, } #endif +#ifdef CONFIG_HAS_EARLYSUSPEND + tkey_i2c->early_suspend.suspend = + (void *)sec_touchkey_early_suspend; + tkey_i2c->early_suspend.resume = + (void *)sec_touchkey_late_resume; + register_early_suspend(&tkey_i2c->early_suspend); +#endif + #if defined(TK_HAS_AUTOCAL) touchkey_autocalibration(tkey_i2c); #endif diff --git a/drivers/input/touchscreen/mms_ts.c b/drivers/input/touchscreen/mms_ts.c index 058cc89..3b86885 100644 --- a/drivers/input/touchscreen/mms_ts.c +++ b/drivers/input/touchscreen/mms_ts.c @@ -3212,6 +3212,19 @@ static int __devinit mms_ts_probe(struct i2c_client *client, #endif touch_is_pressed = 0; +#if defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_C1) + gpio_request(GPIO_OLED_DET, "OLED_DET"); + ret = gpio_get_value(GPIO_OLED_DET); + printk(KERN_DEBUG + "[TSP] OLED_DET = %d\n", ret); + + if (ret == 0) { + printk(KERN_DEBUG + "[TSP] device wasn't connected to board\n"); + return -EIO; + } +#endif + if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) return -EIO; diff --git a/drivers/leds/leds-aat1290a.c b/drivers/leds/leds-aat1290a.c index 8889360..493f422 100644 --- a/drivers/leds/leds-aat1290a.c +++ b/drivers/leds/leds-aat1290a.c @@ -125,7 +125,7 @@ static long aat1290a_ioctl(struct file *file, return 0; } -static ssize_t aat1290a_power(struct device *dev, +ssize_t aat1290a_power(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { diff --git a/drivers/leds/leds-an30259a.c b/drivers/leds/leds-an30259a.c index bae3203..ce05065 100644 --- a/drivers/leds/leds-an30259a.c +++ b/drivers/leds/leds-an30259a.c @@ -77,6 +77,7 @@ #define LED_R_CURRENT 0x28 #define LED_G_CURRENT 0x28 #define LED_B_CURRENT 0x28 +#define LED_MAX_CURRENT 0xFF #define LED_OFF 0x00 #define MAX_NUM_LEDS 3 @@ -85,17 +86,17 @@ static struct an30259_led_conf led_conf[] = { { .name = "led_r", .brightness = LED_OFF, - .max_brightness = 0x3C, + .max_brightness = LED_R_CURRENT, .flags = 0, }, { .name = "led_g", .brightness = LED_OFF, - .max_brightness = 0x3C, + .max_brightness = LED_G_CURRENT, .flags = 0, }, { .name = "led_b", .brightness = LED_OFF, - .max_brightness = 0x3C, + .max_brightness = LED_B_CURRENT, .flags = 0, } }; @@ -394,8 +395,20 @@ static void an30259a_set_led_blink(enum an30259a_led_enum led, struct i2c_client *client; client = b_client; + if (brightness == LED_OFF) { + leds_on(led, false, false, brightness); + return; + } + + if (brightness > LED_MAX_CURRENT) + brightness = LED_MAX_CURRENT; + + /* In user case, LED current is restricted to less than 2mA */ + brightness = (brightness * LED_R_CURRENT) / LED_MAX_CURRENT + 1; + if (delay_on_time > SLPTT_MAX_VALUE) delay_on_time = SLPTT_MAX_VALUE; + if (delay_off_time > SLPTT_MAX_VALUE) delay_off_time = SLPTT_MAX_VALUE; @@ -404,9 +417,6 @@ static void an30259a_set_led_blink(enum an30259a_led_enum led, if (brightness == LED_OFF) leds_on(led, false, false, brightness); return; - } else if (brightness == LED_OFF) { - leds_on(led, false, false, brightness); - return; } else leds_on(led, true, true, brightness); diff --git a/drivers/media/video/s5c73m3.c b/drivers/media/video/s5c73m3.c index ea07a34..5db5f7f 100644 --- a/drivers/media/video/s5c73m3.c +++ b/drivers/media/video/s5c73m3.c @@ -37,6 +37,7 @@ #endif #include <linux/regulator/machine.h> +#include <linux/leds-aat1290a.h> #include <media/s5c73m3_platform.h> #include "s5c73m3.h" @@ -163,6 +164,8 @@ static u8 sysfs_phone_fw[10] = {0,}; static u8 sysfs_sensor_type[15] = {0,}; static u8 sysfs_isp_core[10] = {0,}; static u8 data_memory[500000] = {0,}; +static u32 crc_table[256] = {0,}; +static int copied_fw_binary; static u16 isp_chip_info1; static u16 isp_chip_info2; @@ -312,6 +315,48 @@ static int s5c73m3_read(struct v4l2_subdev *sd, return err; } +static int s5c73m3_i2c_check_status_with_CRC(struct v4l2_subdev *sd) +{ + int err = 0; + int index = 0; + u16 status = 0; + u16 i2c_status = 0; + u16 i2c_seq_status = 0; + + do { + err = s5c73m3_read(sd, 0x0009, S5C73M3_STATUS, &status); + err = s5c73m3_read(sd, 0x0009, + S5C73M3_I2C_ERR_STATUS, &i2c_status); + if (i2c_status & ERROR_STATUS_CHECK_BIN_CRC) { + cam_dbg("failed to check CRC value of ISP Ram\n"); + err = -1; + break; + } + + if (status == 0xffff) + break; + + index++; + udelay(500); + } while (index < 2000); /* 1 sec */ + + if (index >= 2000) { + err = s5c73m3_read(sd, 0x0009, + S5C73M3_I2C_ERR_STATUS, &i2c_status); + err = s5c73m3_read(sd, 0x0009, + S5C73M3_I2C_SEQ_STATUS, &i2c_seq_status); + cam_dbg("TimeOut!! index:%d,status:%#x,i2c_stauts:%#x,i2c_seq_status:%#x\n", + index, + status, + i2c_status, + i2c_seq_status); + + err = -1; + } + + return err; +} + static int s5c73m3_i2c_check_status(struct v4l2_subdev *sd) { int err = 0; @@ -346,6 +391,46 @@ static int s5c73m3_i2c_check_status(struct v4l2_subdev *sd) return err; } +void s5c73m3_make_CRC_table(u32 *table, u32 id) +{ + u32 i, j, k; + + for(i = 0; i < 256; ++i) { + k = i; + for(j = 0; j < 8; ++j) { + if(k & 1) + k = (k >> 1) ^ id; + else + k >>= 1; + } + table[i] = k; + } +} + +static int s5c73m3_reset_module(struct v4l2_subdev *sd, bool powerReset) +{ + struct s5c73m3_state *state = to_state(sd); + int err = 0; + + cam_trace("E\n"); + + if (powerReset) { + err = state->pdata->power_on_off(0); + CHECK_ERR(err); + err = state->pdata->power_on_off(1); + CHECK_ERR(err); + } else { + err = state->pdata->is_isp_reset(); + CHECK_ERR(err); + } + err = s5c73m3_set_timing_register_for_vdd(sd); + CHECK_ERR(err); + + cam_trace("X\n"); + + return err; +} + static int s5c73m3_writeb(struct v4l2_subdev *sd, unsigned short addr, unsigned short data) { @@ -487,6 +572,27 @@ static int s5c73m3_get_sensor_fw_binary(struct v4l2_subdev *sd) mm_segment_t old_fs; long ret = 0; char fw_path[25] = {0,}; + u8 mem0 =0, mem1 = 0; + u32 CRC = 0; + u32 DataCRC = 0; + u32 IntOriginalCRC = 0; + u32 crc_index = 0; + int retryCnt = 2; + + if (state->sensor_fw[0] == 'O') { + sprintf(fw_path, "/data/cfw/SlimISP_G%c.bin", + state->sensor_fw[1]); + } else if (state->sensor_fw[0] == 'S') { + sprintf(fw_path, "/data/cfw/SlimISP_Z%c.bin", + state->sensor_fw[1]); + } else { + sprintf(fw_path, "/data/cfw/SlimISP_%c%c.bin", + state->sensor_fw[0], + state->sensor_fw[1]); + } + + /* Make CRC Table */ + s5c73m3_make_CRC_table((u32 *)&crc_table, 0xEDB88320); /*ARM go*/ err = s5c73m3_write(sd, 0x3000, 0x0004, 0xFFFF); @@ -554,32 +660,18 @@ static int s5c73m3_get_sensor_fw_binary(struct v4l2_subdev *sd) mdelay(200); - old_fs = get_fs(); - set_fs(KERNEL_DS); - - if (state->sensor_fw[0] == 'O') { - sprintf(fw_path, "/data/cfw/SlimISP_G%c.bin", - state->sensor_fw[1]); - } else if (state->sensor_fw[0] == 'S') { - sprintf(fw_path, "/data/cfw/SlimISP_Z%c.bin", - state->sensor_fw[1]); - } else { - sprintf(fw_path, "/data/cfw/SlimISP_%c%c.bin", - state->sensor_fw[0], - state->sensor_fw[1]); - } - - fp = filp_open(fw_path, O_WRONLY|O_CREAT, 0644); - if (IS_ERR(fp) || fp == NULL) { - cam_err("failed to open %s, err %ld\n", - fw_path, PTR_ERR(fp)); - err = -EINVAL; - goto out; - } +retry: + memset(data_memory, 0, sizeof(data_memory)); + mem0 =0, mem1 = 0; + CRC = 0; + DataCRC = 0; + IntOriginalCRC = 0; + crc_index = 0; /* SPI Copy mode ready I2C CMD */ err = s5c73m3_writeb(sd, 0x0924, 0x0000); CHECK_ERR(err); + cam_dbg("sent SPI ready CMD\n"); rxSize = 64*1024; mdelay(10); @@ -589,19 +681,72 @@ static int s5c73m3_get_sensor_fw_binary(struct v4l2_subdev *sd) state->sensor_size, rxSize); CHECK_ERR(err); - ret = vfs_write(fp, (char __user *)data_memory, - state->sensor_size, &fp->f_pos); + CRC = ~CRC; + for(crc_index = 0;crc_index < (state->sensor_size-4)/2;crc_index++) { + /*low byte*/ + mem0 = (unsigned char)(data_memory[crc_index*2] & 0x00ff); + /*high byte*/ + mem1 = (unsigned char)(data_memory[crc_index*2+1] & 0x00ff); + CRC = crc_table[(CRC ^ (mem0)) & 0xFF] ^ (CRC >> 8); + CRC = crc_table[(CRC ^ (mem1)) & 0xFF] ^ (CRC >> 8); + } + CRC = ~CRC; + + DataCRC = (CRC&0x000000ff)<<24; + DataCRC += (CRC&0x0000ff00)<<8; + DataCRC += (CRC&0x00ff0000)>>8; + DataCRC += (CRC&0xff000000)>>24; + cam_err("made CSC value by S/W = 0x%x\n", DataCRC); + + IntOriginalCRC = (data_memory[state->sensor_size-4]&0x00ff)<<24; + IntOriginalCRC += (data_memory[state->sensor_size-3]&0x00ff)<<16; + IntOriginalCRC += (data_memory[state->sensor_size-2]&0x00ff)<<8; + IntOriginalCRC += (data_memory[state->sensor_size-1]&0x00ff); + cam_err("Original CRC Int = 0x%x\n", IntOriginalCRC); + + old_fs = get_fs(); + set_fs(KERNEL_DS); + + if (IntOriginalCRC == DataCRC) { + fp = filp_open(fw_path, O_WRONLY|O_CREAT|O_TRUNC, 0644); + if (IS_ERR(fp) || fp == NULL) { + cam_err("failed to open %s, err %ld\n", + fw_path, PTR_ERR(fp)); + err = -EINVAL; + goto out; + } + + ret = vfs_write(fp, (char __user *)data_memory, + state->sensor_size, &fp->f_pos); + + if (camfw_info[S5C73M3_SD_CARD].opened == 0) { + memcpy(state->phone_fw, + state->sensor_fw, + S5C73M3_FW_VER_LEN); + state->phone_fw[S5C73M3_FW_VER_LEN+1] = ' '; + + memcpy(sysfs_phone_fw, + state->phone_fw, + sizeof(state->phone_fw)); + cam_dbg("Changed to Phone_version = %s\n", + state->phone_fw); + } + } else { + if (retryCnt > 0) { + set_fs(old_fs); + retryCnt--; + goto retry; + } + } if (fp != NULL) filp_close(fp, current->files); out: set_fs(old_fs); - return err; } - static int s5c73m3_get_sensor_fw_version(struct v4l2_subdev *sd) { struct s5c73m3_state *state = to_state(sd); @@ -802,7 +947,6 @@ static int s5c73m3_get_phone_fw_version(struct v4l2_subdev *sd) int err = 0; int retVal = 0; int fw_requested = 1; - int copied_fw_binary = 0; if (state->sensor_fw[0] == 'O') { sprintf(fw_path, "SlimISP_G%c.bin", @@ -885,14 +1029,12 @@ request_fw: state->fw_index = S5C73M3_IN_DATA; } } else { - cam_dbg("get new fw to F-ROM : %s Version\n", + cam_dbg("can't open %s Ver. Firmware. so, download from F-ROM\n", state->sensor_fw); if (fw != NULL) release_firmware(fw); - retVal = state->pdata->is_isp_reset(); - CHECK_ERR(retVal); - retVal = s5c73m3_set_timing_register_for_vdd(sd); + retVal = s5c73m3_reset_module(sd, true); CHECK_ERR(retVal); retVal = s5c73m3_get_sensor_fw_binary(sd); CHECK_ERR(retVal); @@ -901,17 +1043,13 @@ request_fw: } } - if (copied_fw_binary) { + if (!copied_fw_binary) { memcpy(state->phone_fw, - state->sensor_fw, + camfw_info[state->fw_index].ver, S5C73M3_FW_VER_LEN); state->phone_fw[S5C73M3_FW_VER_LEN+1] = ' '; - } else { - memcpy(state->phone_fw, - camfw_info[state->fw_index].ver, - S5C73M3_FW_VER_LEN); - state->phone_fw[S5C73M3_FW_VER_LEN+1] = ' '; } + memcpy(sysfs_phone_fw, state->phone_fw, sizeof(state->phone_fw)); @@ -1049,10 +1187,11 @@ static int s5c73m3_check_fw_date(struct v4l2_subdev *sd) static int s5c73m3_check_fw(struct v4l2_subdev *sd, int download) { - struct s5c73m3_state *state = to_state(sd); int err, i; int retVal; + copied_fw_binary = 0; + if (!download) { for (i = 0; i < S5C73M3_PATH_MAX; i++) camfw_info[i].opened = 0; @@ -1065,16 +1204,22 @@ static int s5c73m3_check_fw(struct v4l2_subdev *sd, int download) } retVal = s5c73m3_check_fw_date(sd); - err = state->pdata->is_isp_reset(); - CHECK_ERR(err); - err = s5c73m3_set_timing_register_for_vdd(sd); - CHECK_ERR(err); /* retVal = 0 : Same Version - retVal < 0 : Phone Version is latest Version than sensorFW. - retVal > 0 : Sensor Version is latest version than phoenFW. */ - if (retVal <= 0 || download) { + retVal < 0 : Phone Version is latest Version than sensorFW. + retVal > 0 : Sensor Version is latest version than phoenFW. */ + if (retVal <= 0||download) { cam_dbg("Loading From PhoneFW......\n"); + + /* In case that there is no FW in phone and FW needs to be + downloaded from F-ROM, ISP power reset is required before + loading FW to ISP for F-ROM to work properly.*/ + if (copied_fw_binary) + err = s5c73m3_reset_module(sd, true); + else + err = s5c73m3_reset_module(sd, false); + CHECK_ERR(err); + err = s5c73m3_SPI_booting(sd); CHECK_ERR(err); @@ -1084,26 +1229,13 @@ static int s5c73m3_check_fw(struct v4l2_subdev *sd, int download) } } else { cam_dbg("Loading From SensorFW......\n"); -#if 0 - err = s5c73m3_SPI_booting_by_ISP(sd); + err = s5c73m3_reset_module(sd, true); CHECK_ERR(err); -#else err = s5c73m3_get_sensor_fw_binary(sd); CHECK_ERR(err); - - memcpy(state->phone_fw, - state->sensor_fw, - S5C73M3_FW_VER_LEN); - state->phone_fw[S5C73M3_FW_VER_LEN+1] = ' '; - - memcpy(sysfs_phone_fw, - state->phone_fw, - sizeof(state->phone_fw)); - cam_dbg("Changed to Phone_version = %s\n", - state->phone_fw); -#endif } + return 0; } @@ -1927,6 +2059,27 @@ static int s5c73m3_aeawb_lock_unlock(struct v4l2_subdev *sd, int val) return 0; } +static void s5c73m3_wait_for_preflash_fire(struct v4l2_subdev *sd) +{ + u16 pre_flash = false; + u16 timeout_cnt = 0; + + do { + s5c73m3_read(sd, 0x0009, + S5C73M3_STILL_PRE_FLASH | 0x5000, &pre_flash); + if (pre_flash || timeout_cnt > 20) { + if (!pre_flash) { + cam_dbg("pre_Flash = %d, timeout_cnt = %d\n", + pre_flash, timeout_cnt); + } + break; + } else + timeout_cnt++; + + mdelay(15); + } while (1); +} + static int s5c73m3_start_capture(struct v4l2_subdev *sd, int val) { struct s5c73m3_state *state = to_state(sd); @@ -1940,7 +2093,7 @@ static int s5c73m3_start_capture(struct v4l2_subdev *sd, int val) if (!pre_flash) { err = s5c73m3_writeb(sd, S5C73M3_STILL_PRE_FLASH , S5C73M3_STILL_PRE_FLASH_FIRE); - msleep(100); + s5c73m3_wait_for_preflash_fire(sd); } err = s5c73m3_writeb(sd, S5C73M3_STILL_MAIN_FLASH , S5C73M3_STILL_MAIN_FLASH_FIRE); @@ -1954,7 +2107,7 @@ static int s5c73m3_start_capture(struct v4l2_subdev *sd, int val) if (isneed_flash) { err = s5c73m3_writeb(sd, S5C73M3_STILL_PRE_FLASH , S5C73M3_STILL_PRE_FLASH_FIRE); - msleep(100); + s5c73m3_wait_for_preflash_fire(sd); err = s5c73m3_writeb(sd, S5C73M3_STILL_MAIN_FLASH, S5C73M3_STILL_MAIN_FLASH_FIRE); @@ -3109,7 +3262,7 @@ static int s5c73m3_read_vdd_core(struct v4l2_subdev *sd) set_fs(KERNEL_DS); fp = filp_open(S5C73M3_CORE_VDD, - O_WRONLY|O_CREAT, 0666); + O_WRONLY|O_CREAT|O_TRUNC, 0644); if (IS_ERR(fp)) goto out; @@ -3197,34 +3350,31 @@ static int s5c73m3_init(struct v4l2_subdev *sd, u32 val) #endif CHECK_ERR(err); - err = s5c73m3_i2c_check_status(sd); + err = s5c73m3_i2c_check_status_with_CRC(sd); if (err < 0) { cam_err("ISP is not ready. retry loading fw!!\n"); /* retry */ retVal = s5c73m3_check_fw_date(sd); - err = state->pdata->is_isp_reset(); - CHECK_ERR(err); - err = s5c73m3_set_timing_register_for_vdd(sd); - CHECK_ERR(err); - /* retVal = 0 : Same Version retVal < 0 : Phone Version is latest Version than sensorFW. retVal > 0 : Sensor Version is latest version than phoenFW. */ if (retVal <= 0) { cam_dbg("Loading From PhoneFW......\n"); + err = s5c73m3_reset_module(sd, false); + CHECK_ERR(err); err = s5c73m3_SPI_booting(sd); CHECK_ERR(err); } else { cam_dbg("Loading From SensorFW......\n"); + err = s5c73m3_reset_module(sd, true); + CHECK_ERR(err); err = s5c73m3_get_sensor_fw_binary(sd); CHECK_ERR(err); } - } state->isp.bad_fw = 0; - s5c73m3_init_param(sd); return 0; @@ -3271,18 +3421,7 @@ static ssize_t s5c73m3_camera_rear_flash(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { - int err; - - if (buf[0] == '0') - err = s5c73m3_writeb(sd_internal, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_OFF); - else - err = s5c73m3_writeb(sd_internal, S5C73M3_FLASH_TORCH, - S5C73M3_FLASH_TORCH_ON); - - CHECK_ERR(err); - - return count; + return aat1290a_power(dev, attr, buf, count); } static ssize_t s5c73m3_camera_isp_core_show(struct device *dev, diff --git a/drivers/media/video/s5c73m3.h b/drivers/media/video/s5c73m3.h index 97a697b..40d7eaf 100644 --- a/drivers/media/video/s5c73m3.h +++ b/drivers/media/video/s5c73m3.h @@ -450,10 +450,10 @@ struct s5c73m3_state { #define ERR_STATUS_FROM_INIT (1<<0x4) #define ERR_STATUS_I2C_CIS_STREAM_OFF (1<<0x5) #define ERR_STATUS_I2C_N_CMD_OVER (1<<0x6) -#define ERR_STATUS_I2C_N_CMD_MISMATCH0 (1<<0x7) -#define ERR_STATUS_I2C_N_CMD_MISMATCH1 (1<<0x8) -#define ERR_STATUS_EXCEPTION (1<<0x9) - +#define ERROR_STATUS_I2C_N_CMD_MISMATCH (1<<0x7) +#define ERROR_STATUS_CHECK_BIN_CRC (1<<0x8) +#define ERROR_STATUS_EXCEPTION (1<<0x9) +#define ERROR_STATUS_INIF_INIT_STATE (0x8) #ifdef CONFIG_VIDEO_S5C73M3_SPI extern int s5c73m3_spi_write(const u8 *addr, const int len, const int txSize); diff --git a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d.h b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d.h index 97fc4cb..2d8f3b7 100644 --- a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d.h +++ b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d.h @@ -40,6 +40,7 @@ #define FIMG2D_BITBLT_BLIT _IOWR(FIMG2D_IOCTL_MAGIC, 0, struct fimg2d_blit) #define FIMG2D_BITBLT_SYNC _IOW(FIMG2D_IOCTL_MAGIC, 1, int) #define FIMG2D_BITBLT_VERSION _IOR(FIMG2D_IOCTL_MAGIC, 2, struct fimg2d_version) +#define FIMG2D_BITBLT_SECURE _IOW(FIMG2D_IOCTL_MAGIC, 3, unsigned int) struct fimg2d_version { unsigned int hw; @@ -483,8 +484,8 @@ struct fimg2d_control { struct resource *mem; void __iomem *regs; - bool err; int irq; + unsigned int secure; atomic_t nctx; atomic_t busy; atomic_t active; diff --git a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x.h b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x.h index 9165d6f..4bf8f74 100644 --- a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x.h +++ b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x.h @@ -172,6 +172,7 @@ struct fimg2d_blend_coeff { enum fimg2d_coeff d_coeff; }; +void fimg2d4x_sw_reset(struct fimg2d_control *info); void fimg2d4x_reset(struct fimg2d_control *info); void fimg2d4x_enable_irq(struct fimg2d_control *info); void fimg2d4x_disable_irq(struct fimg2d_control *info); diff --git a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_blt.c b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_blt.c index 9a4f8ad..fc6016c 100644 --- a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_blt.c +++ b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_blt.c @@ -38,7 +38,9 @@ static inline void fimg2d4x_blit_wait(struct fimg2d_control *info, struct fimg2d fimg2d_dump_command(cmd); if (!fimg2d4x_blit_done_status(info)) - info->err = true; /* device error */ + printk(KERN_ERR "[%s] G2D operation is not finished", __func__); + + fimg2d4x_sw_reset(info); } } @@ -63,19 +65,16 @@ void fimg2d4x_bitblt(struct fimg2d_control *info) fimg2d_clk_on(info); while (1) { + spin_lock(&info->bltlock); cmd = fimg2d_get_first_command(info); if (!cmd) { - spin_lock(&info->bltlock); atomic_set(&info->active, 0); spin_unlock(&info->bltlock); break; } + spin_unlock(&info->bltlock); ctx = cmd->ctx; - if (info->err) { - printk(KERN_ERR "[%s] device error\n", __func__); - goto blitend; - } atomic_set(&info->busy, 1); diff --git a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_hw.c b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_hw.c index 8135ecd..4eb4d04 100644 --- a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_hw.c +++ b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d4x_hw.c @@ -28,6 +28,17 @@ static const int msk_oprmode = (int)MSK_ARGB; static const int premult_round_mode = (int)PREMULT_ROUND_1; /* (A+1)*B) >> 8 */ static const int blend_round_mode = (int)BLEND_ROUND_0; /* (A+1)*B) >> 8 */ +void fimg2d4x_sw_reset(struct fimg2d_control *info) +{ + wr(FIMG2D_SOFT_RESET, FIMG2D_SOFT_RESET_REG); + /* turn off wince option */ + wr(0x0, FIMG2D_BLEND_FUNCTION_REG); + + /* set default repeat mode to reflect(mirror) */ + wr(FIMG2D_SRC_REPEAT_REFLECT, FIMG2D_SRC_REPEAT_MODE_REG); + wr(FIMG2D_MSK_REPEAT_REFLECT, FIMG2D_MSK_REPEAT_MODE_REG); +} + void fimg2d4x_reset(struct fimg2d_control *info) { #ifdef SOFT_RESET_ENABLED diff --git a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_ctx.c b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_ctx.c index 26ea56b..eaa722c 100644 --- a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_ctx.c +++ b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_ctx.c @@ -295,16 +295,20 @@ int fimg2d_add_command(struct fimg2d_control *info, struct fimg2d_context *ctx, if (copy_from_user(&cmd->image[i], buf[i], sizeof(struct fimg2d_image))) { if ((blit->dst) && (type == ADDR_USER)) - if (!down_write_trylock(&page_alloc_slow_rwsem)) - return -EAGAIN; + if (!down_write_trylock(&page_alloc_slow_rwsem)) { + ret = -EAGAIN; + goto err_user; + } ret = -EFAULT; goto err_user; } } if ((blit->dst) && (type == ADDR_USER)) - if (!down_write_trylock(&page_alloc_slow_rwsem)) - return -EAGAIN; + if (!down_write_trylock(&page_alloc_slow_rwsem)) { + ret = -EAGAIN; + goto err_user; + } cmd->ctx = ctx; cmd->op = blit->op; diff --git a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_drv.c b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_drv.c index 6ae4d6e..ed14901 100644 --- a/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_drv.c +++ b/drivers/media/video/samsung/fimg2d4x-exynos4/fimg2d_drv.c @@ -38,8 +38,14 @@ #include "fimg2d_clk.h" #include "fimg2d_ctx.h" #include "fimg2d_helper.h" +#include "fimg2d_cache.h" #define CTX_TIMEOUT msecs_to_jiffies(1000) +#define LV1_SHIFT 20 +#define LV2_BASE_MASK 0x3ff +#define LV2_PT_MASK 0xff000 +#define LV2_SHIFT 12 +#define LV1_DESC_MASK 0x3 static struct fimg2d_control *info; @@ -58,7 +64,13 @@ static DECLARE_WORK(fimg2d_work, fimg2d_worker); static irqreturn_t fimg2d_irq(int irq, void *dev_id) { fimg2d_debug("irq\n"); - info->stop(info); + if (!atomic_read(&info->clkon)) { + fimg2d_clk_on(info); + info->stop(info); + fimg2d_clk_off(info); + } else { + info->stop(info); + } return IRQ_HANDLED; } @@ -67,6 +79,8 @@ static int fimg2d_sysmmu_fault_handler(enum S5P_SYSMMU_INTERRUPT_TYPE itype, unsigned long pgtable_base, unsigned long fault_addr) { struct fimg2d_bltcmd *cmd; + unsigned long *pgd; + unsigned long *lv1d, *lv2d; if (itype == SYSMMU_PAGEFAULT) { printk(KERN_ERR "[%s] sysmmu page fault(0x%lx), pgd(0x%lx)\n", @@ -91,11 +105,20 @@ static int fimg2d_sysmmu_fault_handler(enum S5P_SYSMMU_INTERRUPT_TYPE itype, fimg2d_dump_command(cmd); + pgd = (unsigned long *)cmd->ctx->mm->pgd; + lv1d = pgd + (fault_addr >> LV1_SHIFT); + printk(KERN_ERR " Level 1 descriptor(0x%lx)\n", *lv1d); + if ((*lv1d & LV1_DESC_MASK) != 0x1) { + fimg2d_clean_outer_pagetable(cmd->ctx->mm, fault_addr, 4); + goto next; + } + + lv2d = (unsigned long *)phys_to_virt(*lv1d & ~LV2_BASE_MASK) + + ((fault_addr & LV2_PT_MASK) >> LV2_SHIFT); + printk(KERN_ERR " Level 2 descriptor(0x%lx)\n", *lv2d); + fimg2d_clean_outer_pagetable(cmd->ctx->mm, fault_addr, 4); next: - fimg2d_clk_dump(info); - info->dump(info); - BUG(); return 0; } @@ -106,8 +129,6 @@ static void fimg2d_context_wait(struct fimg2d_context *ctx) atomic_set(&info->active, 1); queue_work(info->work_q, &fimg2d_work); printk(KERN_ERR "[%s] ctx %p cmd wait timeout\n", __func__, ctx); - if (info->err) - break; } } } @@ -188,11 +209,8 @@ static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg) switch (cmd) { case FIMG2D_BITBLT_BLIT: - if (info->err) { - printk(KERN_ERR "[%s] device error, do sw fallback\n", - __func__); + if (info->secure) return -EFAULT; - } if (copy_from_user(&blit, (void *)arg, sizeof(blit))) return -EFAULT; @@ -245,6 +263,24 @@ static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return -EFAULT; break; + case FIMG2D_BITBLT_SECURE: + if (copy_from_user(&info->secure, + (unsigned int *)arg, + sizeof(unsigned int))) { + printk(KERN_ERR + "[%s] failed to FIMG2D_BITBLT_SECURE: copy_from_user error\n\n", + __func__); + return -EFAULT; + } + + while (1) { + if (fimg2d_queue_is_empty(&info->cmd_q)) + break; + mdelay(2); + } + + break; + default: printk(KERN_ERR "[%s] unknown ioctl\n", __func__); ret = -EFAULT; @@ -278,6 +314,7 @@ static int fimg2d_setup_controller(struct fimg2d_control *info) atomic_set(&info->busy, 0); atomic_set(&info->nctx, 0); atomic_set(&info->active, 0); + info->secure = 0; spin_lock_init(&info->bltlock); diff --git a/drivers/media/video/samsung/mali/linux/mali_osk_notification.c b/drivers/media/video/samsung/mali/linux/mali_osk_notification.c index 74a18e8..eef839f 100644 --- a/drivers/media/video/samsung/mali/linux/mali_osk_notification.c +++ b/drivers/media/video/samsung/mali/linux/mali_osk_notification.c @@ -15,6 +15,8 @@ #include "mali_osk.h" #include "mali_kernel_common.h" +#include "mali_pmm.h" +#include "mali_pmm_state.h" /* needed to detect kernel version specific code */ #include <linux/version.h> @@ -65,6 +67,11 @@ _mali_osk_notification_t *_mali_osk_notification_create( u32 type, u32 size ) /* OPT Recycling of notification objects */ _mali_osk_notification_wrapper_t *notification; + if (MALI_PMM_NOTIFICATION_TYPE == type) { + if (size != sizeof(mali_pmm_message_t)) + return NULL; + } + notification = (_mali_osk_notification_wrapper_t *)kmalloc( sizeof(_mali_osk_notification_wrapper_t) + size, GFP_KERNEL ); if (NULL == notification) { diff --git a/drivers/media/video/samsung/mfc5x/mfc_dec.c b/drivers/media/video/samsung/mfc5x/mfc_dec.c index 6e0645d..fd78b7d 100644 --- a/drivers/media/video/samsung/mfc5x/mfc_dec.c +++ b/drivers/media/video/samsung/mfc5x/mfc_dec.c @@ -2388,6 +2388,12 @@ int mfc_exec_decoding(struct mfc_inst_ctx *ctx, union mfc_args *args) offset = CheckMPEG4StartCode(stream_vir+consumed, dec_ctx->streamsize - consumed); + + if (offset == -1) { + mfc_warn("No start code in remained bitstream: %d\n", offset); + return ret; + } + if (offset > 4) consumed += offset; diff --git a/drivers/media/video/samsung/tvout/s5p_tvout_v4l2.c b/drivers/media/video/samsung/tvout/s5p_tvout_v4l2.c index 7af8a15..68508e7 100644 --- a/drivers/media/video/samsung/tvout/s5p_tvout_v4l2.c +++ b/drivers/media/video/samsung/tvout/s5p_tvout_v4l2.c @@ -953,8 +953,11 @@ static int s5p_tvout_tvif_release(struct file *file) tvout_dbg("on_stop_process(%d)\n", on_stop_process); atomic_dec(&s5p_tvout_v4l2_private.tvif_use); - if (atomic_read(&s5p_tvout_v4l2_private.tvif_use) == 0) + if (atomic_read(&s5p_tvout_v4l2_private.tvif_use) == 0) { + s5p_tvout_mutex_lock(); s5p_tvif_ctrl_stop(); + s5p_tvout_mutex_unlock(); + } on_stop_process = false; tvout_dbg("on_stop_process(%d)\n", on_stop_process); diff --git a/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.c b/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.c index 323c13c..07fbd3f 100644 --- a/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.c +++ b/drivers/media/video/samsung/ump/linux/ump_kernel_memory_backend_os.c @@ -142,10 +142,10 @@ static int os_allocate(void* ctx, ump_dd_mem * descriptor) if (is_cached) { - new_page = alloc_page(GFP_KERNEL | __GFP_ZERO | __GFP_NORETRY | __GFP_NOWARN ); + new_page = alloc_page(GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN ); } else { - new_page = alloc_page(GFP_KERNEL | __GFP_ZERO | __GFP_NORETRY | __GFP_NOWARN | __GFP_COLD); + new_page = alloc_page(GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN | __GFP_COLD); } if (NULL == new_page) { diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c index e505132..bb89b20 100644 --- a/drivers/mmc/card/block.c +++ b/drivers/mmc/card/block.c @@ -1008,12 +1008,11 @@ static int mmc_blk_err_check(struct mmc_card *card, brq->data.error) { #if defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_P4NOTE) || \ defined(CONFIG_MACH_C1_USA_ATT) - /* dh0421.hwang */ if (mmc_card_mmc(card)) { - printk(KERN_ERR "[TEST] brq->sbc.opcode=%d," + pr_err("brq->sbc.opcode=%d," "brq->cmd.opcode=%d.\n", brq->sbc.opcode, brq->cmd.opcode); - printk(KERN_ERR "[TEST] brq->sbc.error=%d," + pr_err("brq->sbc.error=%d," "brq->cmd.error=%d, brq->stop.error=%d," "brq->data.error=%d.\n", brq->sbc.error, brq->cmd.error, brq->stop.error, @@ -1934,35 +1933,21 @@ snd_packed_rd: #if defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_P4NOTE) || \ defined(CONFIG_MACH_C1_USA_ATT) /* - * dh0421.hwang * It's for Engineering DEBUGGING only * This has to be removed before PVR(guessing) * Please refer mshci reg dumps */ if (mmc_card_mmc(card) && status != 3) { - printk(KERN_ERR "[TEST] CMD aborting case in" + pr_err("CMD aborting case in " "MMC's block layer ret %d.\n", ret); - printk(KERN_ERR "%s: CMD%d, ARG=0x%x.\n", + pr_err("%s: CMD%d, ARG=0x%x.\n", req->rq_disk->disk_name, brq->cmd.opcode, brq->cmd.arg); - printk(KERN_ERR "[TEST] If PACKED_NONE," - "confirm end_request done\n"); - printk(KERN_ERR "packed CMD type = %d.\n", + pr_err("packed CMD type = %d.\n", mq_rq ? mq_rq->packed_cmd : -1); - printk(KERN_ERR "[TEST] mmc%d, request returns %d.\n", + pr_err("mmc%d, request returns %d.\n", card->host->index, status); - printk(KERN_ERR "[TEST] err means...\n"); - printk(KERN_ERR "\t1: MMC_BLK_PARTIAL.\n"); - printk(KERN_ERR "\t2: MMC_BLK_CMD_ERR.\n"); - printk(KERN_ERR "\t3: MMC_BLK_RETRY.\n"); - printk(KERN_ERR "\t4: MMC_BLK_ABORT.\n"); - printk(KERN_ERR "\t5: MMC_BLK_DATA_ERR.\n"); - printk(KERN_ERR "\t6: MMC_BLK_ECC_ERR.\n"); - if (!rqc) { - panic("[TEST] mmc%d, returns %d.\n", - card->host->index, status); - } } #endif diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c index 8051835..0b2b5b4 100644 --- a/drivers/mmc/core/core.c +++ b/drivers/mmc/core/core.c @@ -2373,12 +2373,9 @@ int mmc_flush_cache(struct mmc_card *card) (card->ext_csd.cache_ctrl & 1)) { err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_FLUSH_CACHE, 1, 0); - if (err) { + if (err) pr_err("%s: cache flush error %d\n", mmc_hostname(card->host), err); - panic("[TEST] mmc%d, %s returns %d.\n", - host->index, __func__, err); - } } return err; diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c index d118f3b..596098b 100644 --- a/drivers/mmc/core/mmc.c +++ b/drivers/mmc/core/mmc.c @@ -28,9 +28,11 @@ #define MMC_RETRY_READ_EXT_CSD #else /* For debugging about ext_csd register value */ +#if 0 #define MMC_CHECK_EXT_CSD #endif #endif +#endif static const unsigned int tran_exp[] = { 10000, 100000, 1000000, 10000000, @@ -208,15 +210,6 @@ static void mmc_error_ext_csd(struct mmc_card *card, u8 *ext_csd, } memcpy(ext_csd_backup, ext_csd, 512); -#if 0 /* Just checking */ -#define EXT_CSD_REV 192 /* RO */ -#define EXT_CSD_STRUCTURE 194 /* RO */ -#define EXT_CSD_CARD_TYPE 196 /* RO */ -#endif - pr_err("[TEST] eMMC check : %d, %d, %d.\n", - ext_csd_backup[EXT_CSD_REV], - ext_csd_backup[EXT_CSD_STRUCTURE], - ext_csd_backup[EXT_CSD_CARD_TYPE]); } else { ext_csd_new = kmalloc(512, GFP_KERNEL); if (!ext_csd_new) { @@ -225,12 +218,12 @@ static void mmc_error_ext_csd(struct mmc_card *card, u8 *ext_csd, } else { err = mmc_send_ext_csd(card, ext_csd_new); if (err) - pr_err("[TEST] Fail to get new EXT_CSD.\n"); + pr_err("Fail to get new EXT_CSD.\n"); else available_new = 1; } - pr_err("[TEST] %s: starting diff ext_csd.\n", __func__); - pr_err("[TEST] %s: error on slice %d: backup=%d, now=%d," + pr_err("%s: starting diff ext_csd.\n", __func__); + pr_err("%s: error on slice %d: backup=%d, now=%d," "new=%d.\n", __func__, slice, ext_csd_backup[slice], ext_csd[slice], @@ -384,62 +377,104 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd) mmc_card_set_blockaddr(card); } card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE]; - switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) { - case EXT_CSD_CARD_TYPE_SDR_ALL: - case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_8V: - case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_2V: - case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_52: - card->ext_csd.hs_max_dtr = 200000000; - card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_200; - break; - case EXT_CSD_CARD_TYPE_SDR_1_2V_ALL: - case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_8V: - case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_2V: - case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_52: - card->ext_csd.hs_max_dtr = 200000000; - card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_2V; - break; - case EXT_CSD_CARD_TYPE_SDR_1_8V_ALL: - case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_8V: - case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_2V: - case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_52: - card->ext_csd.hs_max_dtr = 200000000; - card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_8V; - break; - case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 | - EXT_CSD_CARD_TYPE_26: - card->ext_csd.hs_max_dtr = 52000000; - card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52; - break; - case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 | - EXT_CSD_CARD_TYPE_26: - card->ext_csd.hs_max_dtr = 52000000; - card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V; - break; - case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 | - EXT_CSD_CARD_TYPE_26: - card->ext_csd.hs_max_dtr = 52000000; - card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V; - break; - case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26: - card->ext_csd.hs_max_dtr = 52000000; - break; - case EXT_CSD_CARD_TYPE_26: - card->ext_csd.hs_max_dtr = 26000000; - break; - default: + if (card->host->caps2 & MMC_CAP2_HS200) { + switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) { + case EXT_CSD_CARD_TYPE_SDR_ALL: + case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_8V: + case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_2V: + case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_52: + card->ext_csd.hs_max_dtr = 200000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_200; + break; + case EXT_CSD_CARD_TYPE_SDR_1_2V_ALL: + case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_8V: + case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_2V: + case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_52: + card->ext_csd.hs_max_dtr = 200000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_2V; + break; + case EXT_CSD_CARD_TYPE_SDR_1_8V_ALL: + case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_8V: + case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_2V: + case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_52: + card->ext_csd.hs_max_dtr = 200000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_8V; + break; + case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 | + EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52; + break; + case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 | + EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V; + break; + case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 | + EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V; + break; + case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + break; + case EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 26000000; + break; + default: #if defined(MMC_CHECK_EXT_CSD) - /* For debugging about ext_csd register value */ - mmc_error_ext_csd(card, ext_csd, 0, EXT_CSD_CARD_TYPE); + /* For debugging about ext_csd register value */ + mmc_error_ext_csd(card, ext_csd, 0, EXT_CSD_CARD_TYPE); #endif - /* MMC v4 spec says this cannot happen */ - printk(KERN_WARNING "%s: card is mmc v4 but doesn't " - "support any high-speed modes.\n", - mmc_hostname(card->host)); + /* MMC v4 spec says this cannot happen */ + printk(KERN_WARNING "%s: card is mmc v4 but doesn't " + "support any high-speed modes.\n", + mmc_hostname(card->host)); #if defined(MMC_RETRY_READ_EXT_CSD) - err = -EINVAL; - goto out; + err = -EINVAL; + goto out; #endif + } + } else { + pr_debug("%s: Ignore device type HS200.\n", + mmc_hostname(card->host)); + switch (ext_csd[EXT_CSD_CARD_TYPE] & + EXT_CSD_CARD_TYPE_NO_HS200_MASK) { + case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 | + EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52; + break; + case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 | + EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V; + break; + case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 | + EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V; + break; + case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 52000000; + break; + case EXT_CSD_CARD_TYPE_26: + card->ext_csd.hs_max_dtr = 26000000; + break; + default: +#if defined(MMC_CHECK_EXT_CSD) + /* For debugging about ext_csd register value */ + mmc_error_ext_csd(card, ext_csd, 0, EXT_CSD_CARD_TYPE); +#endif + /* MMC v4 spec says this cannot happen */ + printk(KERN_WARNING "%s: card is mmc v4 but doesn't " + "support any high-speed modes.\n", + mmc_hostname(card->host)); +#if defined(MMC_RETRY_READ_EXT_CSD) + err = -EINVAL; + goto out; +#endif + } } card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT]; diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c index 4586eaa..e4271fa 100644 --- a/drivers/mmc/core/sd.c +++ b/drivers/mmc/core/sd.c @@ -934,7 +934,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr, if (!mmc_host_is_spi(host)) { err = mmc_send_relative_addr(host, &card->rca); if (err) - return err; + goto free_card; mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); } @@ -942,7 +942,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr, if (!oldcard) { err = mmc_sd_get_csd(host, card); if (err) - return err; + goto free_card; mmc_decode_cid(card); } @@ -953,7 +953,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr, if (!mmc_host_is_spi(host)) { err = mmc_select_card(card); if (err) - return err; + goto free_card; } err = mmc_sd_setup_card(host, card, oldcard != NULL); diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c index 26e42d8..979cf0b 100644 --- a/drivers/mmc/core/sdio.c +++ b/drivers/mmc/core/sdio.c @@ -1058,9 +1058,6 @@ static const struct mmc_bus_ops mmc_sdio_ops = { .alive = mmc_sdio_alive, }; -#if defined(CONFIG_MACH_M0) && defined(CONFIG_TARGET_LOCALE_EUR) -extern void print_epll_con0(void); -#endif /* * Starting point for SDIO card init. */ @@ -1077,11 +1074,6 @@ int mmc_attach_sdio(struct mmc_host *host) if (err) return err; -#if defined(CONFIG_MACH_M0) && defined(CONFIG_TARGET_LOCALE_EUR) - /* a sdio module is detected. print EPLL */ - print_epll_con0(); -#endif - mmc_attach_bus(host, &mmc_sdio_ops); if (host->ocr_avail_sdio) host->ocr_avail = host->ocr_avail_sdio; diff --git a/drivers/mmc/host/mshci-s3c.c b/drivers/mmc/host/mshci-s3c.c index 323f115..5023d10 100644 --- a/drivers/mmc/host/mshci-s3c.c +++ b/drivers/mmc/host/mshci-s3c.c @@ -487,6 +487,13 @@ static int __devinit mshci_s3c_probe(struct platform_device *pdev) if (pdata->cd_type == S3C_MSHCI_CD_PERMANENT) { host->quirks |= MSHCI_QUIRK_BROKEN_PRESENT_BIT; host->mmc->caps |= MMC_CAP_NONREMOVABLE; + if (pdata->int_power_gpio) { + gpio_set_value(pdata->int_power_gpio, 1); + s3c_gpio_cfgpin(pdata->int_power_gpio, + S3C_GPIO_OUTPUT); + s3c_gpio_setpull(pdata->int_power_gpio, + S3C_GPIO_PULL_NONE); + } } /* IF SD controller's WP pin donsn't connected with SD card and there diff --git a/drivers/mmc/host/mshci.c b/drivers/mmc/host/mshci.c index 73de297..9431405 100644 --- a/drivers/mmc/host/mshci.c +++ b/drivers/mmc/host/mshci.c @@ -1620,7 +1620,6 @@ static void mshci_cmd_irq(struct mshci_host *host, u32 intmask) host->error_state = 1; #if defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_P4NOTE) || \ defined(CONFIG_MACH_C1_USA_ATT) - /* dh0421.hwang */ if (host->mmc && host->mmc->card) mshci_dumpregs(host); #endif @@ -1662,11 +1661,8 @@ static void mshci_data_irq(struct mshci_host *host, u32 intmask, u8 intr_src) printk(KERN_ERR "%s: Host timeout error\n", mmc_hostname(host->mmc)); host->data->error = -ETIMEDOUT; -#if 1 /* debugging for Host timeout error */ + /* debugging for Host timeout error */ mshci_dumpregs(host); - panic("[TEST] %s: HTO error interrupt occured\n", - mmc_hostname(host->mmc)); -#endif } else if (intmask & INTMSK_DRTO) { printk(KERN_ERR "%s: Data read timeout error\n", mmc_hostname(host->mmc)); @@ -1709,7 +1705,6 @@ static void mshci_data_irq(struct mshci_host *host, u32 intmask, u8 intr_src) host->error_state = 1; #if defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_P4NOTE) || \ defined(CONFIG_MACH_C1_USA_ATT) - /* dh0421.hwang */ if (host->mmc && host->mmc->card) mshci_dumpregs(host); #endif diff --git a/drivers/net/wireless/bcmdhd/Makefile b/drivers/net/wireless/bcmdhd/Makefile index 15d6c7c..1a27ef0 100644 --- a/drivers/net/wireless/bcmdhd/Makefile +++ b/drivers/net/wireless/bcmdhd/Makefile @@ -1,7 +1,7 @@ # bcmdhd DHDCFLAGS = -Wall -Wstrict-prototypes -Dlinux -DBCMDRIVER \ -DBCMDONGLEHOST -DUNRELEASEDCHIP -DBCMDMA32 -DWLBTAMP -DBCMFILEIMAGE \ - -DDHDTHREAD -DDHD_GPL -DDHD_SCHED -DDHD_DEBUG -DBDC -DTOE \ + -DDHDTHREAD -DDHD_GPL -DDHD_SCHED -DDHD_DEBUG -DBDC \ -DDHD_BCMEVENTS -DSHOW_EVENTS -DDONGLEOVERLAYS -DBCMDBG \ -DCUSTOMER_HW_SAMSUNG -DOOB_INTR_ONLY \ -DMMC_SDIO_ABORT -DBCMSDIO -DBCMLXSDMMC -DBCMPLATFORM_BUS -DWLP2P \ @@ -84,7 +84,7 @@ endif # For SLP feature ifeq ($(CONFIG_SLP),y) -DHDCFLAGS += -DSLP_PATH -DWRITE_MACADDR +DHDCFLAGS += -DSLP_PATH -DWRITE_MACADDR -DCUSTOMER_HW_SLP endif # 5GHz channels setting diff --git a/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_linux.c b/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_linux.c index 42433d6..f7676d8 100644 --- a/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_linux.c +++ b/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_linux.c @@ -49,6 +49,10 @@ extern void dhdsdio_isr(void * args); #include <dhd.h> #endif /* defined(OOB_INTR_ONLY) */ +#if defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) +/*SLP_wakelock_alternative_code*/ +struct device *pm_dev; +#endif /* CONFIG_PM_SLEEP && CUSTOMER_HW_SLP */ /** * SDIO Host Controller info */ @@ -162,6 +166,9 @@ int bcmsdh_probe(struct device *dev) int irq = 0; uint32 vendevid; unsigned long irq_flags = 0; +#if defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) + int ret = 0; +#endif /* CONFIG_PM_SLEEP && CUSTOMER_HW_SLP */ #if !defined(BCMLXSDMMC) && defined(BCMPLATFORM_BUS) pdev = to_platform_device(dev); @@ -228,6 +235,12 @@ int bcmsdh_probe(struct device *dev) sdhc->next = sdhcinfo; sdhcinfo = sdhc; +#if defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) + /*SLP_wakelock_alternative_code*/ + pm_dev=sdhc->dev; + ret = device_init_wakeup(pm_dev, 1); + printf("%s : device_init_wakeup(pm_dev) enable, ret = %d\n", __func__, ret); +#endif /* CONFIG_PM_SLEEP && CUSTOMER_HW_SLP */ /* Read the vendor/device ID from the CIS */ vendevid = bcmsdh_query_device(sdh); /* try to attach to the target device */ @@ -261,6 +274,11 @@ int bcmsdh_remove(struct device *dev) osl_t *osh; sdhc = sdhcinfo; +#if defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) + /*SLP_wakelock_alternative_code*/ + device_init_wakeup(pm_dev, 0); + printf("%s : device_init_wakeup(pm_dev) disable\n", __func__); +#endif /* CONFIG_PM_SLEEP && CUSTOMER_HW_SLP */ drvinfo.detach(sdhc->ch); bcmsdh_detach(sdhc->osh, sdhc->sdh); diff --git a/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_sdmmc_linux.c b/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_sdmmc_linux.c index 9687141..83c1192 100644 --- a/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_sdmmc_linux.c +++ b/drivers/net/wireless/bcmdhd/src/bcmsdio/sys/bcmsdh_sdmmc_linux.c @@ -200,6 +200,9 @@ static int bcmsdh_sdmmc_suspend(struct device *pdev) #endif /* defined(OOB_INTR_ONLY) */ #endif /* defined(OOB_INTR_ONLY) */ dhd_mmc_suspend = TRUE; +#if defined (CUSTOMER_HW_SAMSUNG) && defined (CONFIG_ARCH_TEGRA) + irq_set_irq_wake(390, 1); +#endif smp_mb(); return 0; @@ -218,7 +221,11 @@ static int bcmsdh_sdmmc_resume(struct device *pdev) if ((func->num == 2) && dhd_os_check_if_up(bcmsdh_get_drvdata())) bcmsdh_oob_intr_set(1); #endif /* (OOB_INTR_ONLY) */ -#endif /* (OOB_INTR_ONLY) */ +#endif /* !CUSTOMER_HW_SAMSUNG */ +#if defined (CUSTOMER_HW_SAMSUNG) && defined (CONFIG_ARCH_TEGRA) + if (func->num == 2) + irq_set_irq_wake(390, 0); +#endif smp_mb(); return 0; diff --git a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd.h b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd.h index 3b7f026..5095aba 100644 --- a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd.h +++ b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd.h @@ -83,7 +83,11 @@ enum dhd_bus_state { #define CONCURRENT_MASK (STA_MASK | WFD_MASK) /* max sequential rxcntl timeouts to set HANG event */ +#ifdef BCM4334_CHIP +#define MAX_CNTL_TIMEOUT 1 +#else #define MAX_CNTL_TIMEOUT 2 +#endif #define DHD_SCAN_ACTIVE_TIME 40 /* ms : Embedded default Active setting from DHD Driver */ #define DHD_SCAN_PASSIVE_TIME 130 /* ms: Embedded default Passive setting from DHD Driver */ @@ -258,9 +262,6 @@ typedef struct dhd_pub { int hang_was_sent; int rxcnt_timeout; /* counter rxcnt timeout to send HANG */ int txcnt_timeout; /* counter txcnt timeout to send HANG */ -#ifdef BCM4334_CHIP - int tx_seq_badcnt; -#endif #ifdef WLMEDIA_HTSF uint8 htsfdlystat_sz; /* Size of delay stats, max 255B */ #endif @@ -638,7 +639,11 @@ extern uint dhd_radio_up; /* Initial idletime ticks (may be -1 for immediate idle, 0 for no idle) */ extern int dhd_idletime; +#ifdef DHD_USE_IDLECOUNT +#define DHD_IDLETIME_TICKS 5 +#else #define DHD_IDLETIME_TICKS 1 +#endif /* DHD_USE_IDLECOUNT */ /* SDIO Drive Strength */ extern uint dhd_sdiod_drive_strength; diff --git a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_cfg80211.c b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_cfg80211.c index 73760ef..c0ef0bd 100644 --- a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_cfg80211.c +++ b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_cfg80211.c @@ -507,10 +507,6 @@ int wl_cfg80211_set_btcoex_dhcp(struct net_device *dev, char *command) int i; #endif -#ifdef PASS_ALL_MCAST_PKTS - char iovbuf[20]; - uint32 allmultivar = 0; -#endif /* Figure out powermode 1 or o command */ strncpy((char *)&powermode_val, command + strlen("BTCOEXMODE") +1, 1); @@ -530,13 +526,6 @@ int wl_cfg80211_set_btcoex_dhcp(struct net_device *dev, char *command) dhd_pktfilter_offload_enable(dhd, dhd->pktfilter[i], 0, dhd_master_mode); } - -#ifdef PASS_ALL_MCAST_PKTS - allmultivar = 1; - bcm_mkiovar("allmulti", (char *)&allmultivar, 4, iovbuf, sizeof(iovbuf)); - dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0); - WL_ERR(("DHCP is progressing , allmulti value = %d \n", allmultivar)); -#endif /* PASS_ALL_MCAST_PKTS */ } #endif @@ -594,13 +583,6 @@ int wl_cfg80211_set_btcoex_dhcp(struct net_device *dev, char *command) dhd_pktfilter_offload_enable(dhd, dhd->pktfilter[i], 1, dhd_master_mode); } - -#ifdef PASS_ALL_MCAST_PKTS - allmultivar = 0; - bcm_mkiovar("allmulti", (char *)&allmultivar, 4, iovbuf, sizeof(iovbuf)); - dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0); - WL_ERR(("DHCP is complete , allmulti value = %d \n", allmultivar)); -#endif /* PASS_ALL_MCAST_PKTS */ } #endif diff --git a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_common.c b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_common.c index 956c4e1..f9f8c20 100644 --- a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_common.c +++ b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_common.c @@ -267,36 +267,13 @@ int dhd_wl_ioctl_cmd(dhd_pub_t *dhd_pub, int cmd, void *arg, int len, uint8 set, int ifindex) { wl_ioctl_t ioc; -#ifdef CUSTOMER_HW_SAMSUNG - int ret; -#endif /* CUSTOMER_HW_SAMSUNG */ ioc.cmd = cmd; ioc.buf = arg; ioc.len = len; ioc.set = set; -#ifdef CUSTOMER_HW_SAMSUNG - ret = dhd_wl_ioctl(dhd_pub, ifindex, &ioc, arg, len); - if (ret < 0) { - if (ioc.cmd == WLC_GET_VAR) { - DHD_ERROR(("%s: WLC_GET_VAR: %s, error = %d\n", - __FUNCTION__, (char *)ioc.buf, ret)); - } else if (ioc.cmd == WLC_SET_VAR) { - char pkt_filter[] = "pkt_filter_add"; - if (strncmp(pkt_filter, ioc.buf, sizeof(pkt_filter)) != 0) { - DHD_ERROR(("%s: WLC_SET_VAR: %s, error = %d\n", - __FUNCTION__, (char *)ioc.buf, ret)); - } - } else { - DHD_ERROR(("%s: WLC_IOCTL: cmd:%d, error = %d\n", - __FUNCTION__, ioc.cmd, ret)); - } - } - return ret; -#else return dhd_wl_ioctl(dhd_pub, ifindex, &ioc, arg, len); -#endif /* CUSTOMER_HW_SAMSUNG */ } @@ -308,14 +285,26 @@ dhd_wl_ioctl(dhd_pub_t *dhd_pub, int ifindex, wl_ioctl_t *ioc, void *buf, int le dhd_os_proto_block(dhd_pub); ret = dhd_prot_ioctl(dhd_pub, ifindex, ioc, buf, len); -#ifdef BCM4334_CHIP - if (!ret || ret == -ETIMEDOUT || (dhd_pub->tx_seq_badcnt >= 2)) -#else - if (!ret || ret == -ETIMEDOUT) -#endif + if (!ret || ret == -ETIMEDOUT) { + /* Send hang event only if dhd_open() was success */ + if (dhd_pub->up) dhd_os_check_hang(dhd_pub, ifindex, ret); + } dhd_os_proto_unblock(dhd_pub); +#ifdef CUSTOMER_HW_SAMSUNG + if (ret < 0) { + if (ioc->cmd == WLC_GET_VAR) + DHD_ERROR(("%s: WLC_GET_VAR: %s, error = %d\n", + __FUNCTION__, (char *)ioc->buf, ret)); + else if (ioc->cmd == WLC_SET_VAR) + DHD_ERROR(("%s: WLC_SET_VAR: %s, error = %d\n", + __FUNCTION__, (char *)ioc->buf, ret)); + else + DHD_ERROR(("%s: WLC_IOCTL: cmd: %d, error = %d\n", + __FUNCTION__, ioc->cmd, ret)); + } +#endif /* CUSTOMER_HW_SAMSUNG */ return ret; } @@ -586,10 +575,8 @@ dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, void *pkt, int prec) if (pktq_pfull(q, prec)) eprec = prec; else if (pktq_full(q)) { -#if defined(BCMASSERT_LOG) p = pktq_peek_tail(q, &eprec); - ASSERT(p); -#endif +// ASSERT(p); if (eprec > prec || eprec < 0) return FALSE; } @@ -608,11 +595,9 @@ dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, void *pkt, int prec) PKTFREE(dhdp->osh, p, TRUE); } -#if defined(BCMASSERT_LOG) /* Enqueue */ p = pktq_penq(q, prec, pkt); - ASSERT(p); -#endif +// ASSERT(p); return TRUE; } diff --git a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_custom_sec.c b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_custom_sec.c index 2e80890..4ef1dcb 100644 --- a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_custom_sec.c +++ b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_custom_sec.c @@ -1,3 +1,19 @@ +/* Function list + 1. Module Type + a. For CID - Use 'USE_CID_CHECK' Feature + dhd_write_cid_file(), dhd_dump_cis(), dhd_check_module_cid() + b. For MAC - Use 'GET_MAC_FROM_OTP' Feature + dhd_write_mac_file(), dhd_check_module_mac() + 2. COB Type + a. For MAC - Use 'READ_MACADDR' Feature + dhd_read_macaddr() + 3. Etc + a. Power Save Mode - Use 'CONFIG_CONTROL_PM' Feature + sec_control_pm() + b. U1 Module only - Use 'WRITE_MACADDR' Feature + dhd_write_macaddr +*/ + #include <typedefs.h> #include <linuxver.h> #include <osl.h> @@ -21,6 +37,9 @@ extern int _dhd_set_mac_address(struct dhd_info *dhd, #define MACINFO "/opt/etc/.mac.info" #define REVINFO "/data/.rev" #else +#define MACINFO "/data/.mac.info" +#define MACINFO_EFS "/efs/wifi/.mac.info" +#define NVMACINFO "/data/.nvmac.info" #define REVINFO "/data/.rev" #define CIDINFO "/data/.cid.info" #define PSMINFO "/data/.psm.info" @@ -34,21 +53,21 @@ int dhd_read_macaddr(struct dhd_info *dhd, struct ether_addr *mac) mm_segment_t oldfs = {0}; char randommac[3] = {0}; char buf[18] = {0}; - char *filepath = "/efs/wifi/.mac.info"; + char *filepath_efs = MACINFO_EFS; #ifdef CONFIG_TARGET_LOCALE_VZW char *nvfilepath = "/data/misc/wifi/.nvmac.info"; #else - char *nvfilepath = "/data/.nvmac.info"; + char *nvfilepath = NVMACINFO; #endif int ret = 0; - fp = filp_open(filepath, O_RDONLY, 0); + fp = filp_open(filepath_efs, O_RDONLY, 0); if (IS_ERR(fp)) { start_readmac: /* File Doesn't Exist. Create and write mac addr.*/ - fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); + fp = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp)) { - DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); + DHD_ERROR(("[WIFI] %s: File open error\n", filepath_efs)); return -1; } oldfs = get_fs(); @@ -64,9 +83,9 @@ start_readmac: if (fp->f_mode & FMODE_WRITE) { ret = fp->f_op->write(fp, (const char *)macbuffer, sizeof(macbuffer), &fp->f_pos); if (ret < 0) - DHD_ERROR(("[WIFI]MAC address [%s] Failed to write into File: %s\n", macbuffer, filepath)); + DHD_ERROR(("[WIFI]MAC address [%s] Failed to write into File: %s\n", macbuffer, filepath_efs)); else - DHD_ERROR(("[WIFI]MAC address [%s] written into File: %s\n", macbuffer, filepath)); + DHD_ERROR(("[WIFI]MAC address [%s] written into File: %s\n", macbuffer, filepath_efs)); } set_fs(oldfs); /* Reading the MAC Address from .mac.info file( the existed file or just created file)*/ @@ -90,7 +109,7 @@ start_readmac: (unsigned int *)&(mac->octet[2]), (unsigned int *)&(mac->octet[3]), (unsigned int *)&(mac->octet[4]), (unsigned int *)&(mac->octet[5])); else - DHD_ERROR(("dhd_bus_start: Reading from the '%s' returns 0 bytes\n", filepath)); + DHD_ERROR(("dhd_bus_start: Reading from the '%s' returns 0 bytes\n", filepath_efs)); if (fp) filp_close(fp, NULL); @@ -119,8 +138,8 @@ enum { int dhd_write_rdwr_macaddr(struct ether_addr *mac) { - char *filepath_old = "/data/.mac.info"; - char *filepath = "/efs/wifi/.mac.info"; + char *filepath_data = MACINFO; + char *filepath_efs = MACINFO_EFS; struct file *fp_mac = NULL; char buf[18] = {0}; mm_segment_t oldfs = {0}; @@ -134,9 +153,9 @@ int dhd_write_rdwr_macaddr(struct ether_addr *mac) mac->octet[3], mac->octet[4], mac->octet[5]); /* /data/.mac.info will be created */ - fp_mac = filp_open(filepath_old, O_RDWR | O_CREAT, 0666); + fp_mac = filp_open(filepath_data, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp_mac)) { - DHD_ERROR(("[WIFI] %s: File open error\n", filepath_old)); + DHD_ERROR(("[WIFI] %s: File open error\n", filepath_data)); return -1; } else { oldfs = get_fs(); @@ -147,18 +166,18 @@ int dhd_write_rdwr_macaddr(struct ether_addr *mac) sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed" - " to write into File: %s\n", buf, filepath_old)); + " to write into File: %s\n", buf, filepath_data)); else DHD_INFO(("[WIFI] Mac address [%s] written" - " into File: %s\n", buf, filepath_old)); + " into File: %s\n", buf, filepath_data)); } set_fs(oldfs); filp_close(fp_mac, NULL); } /* /efs/wifi/.mac.info will be created */ - fp_mac = filp_open(filepath, O_RDWR | O_CREAT, 0666); + fp_mac = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp_mac)) { - DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); + DHD_ERROR(("[WIFI] %s: File open error\n", filepath_efs)); return -1; } else { oldfs = get_fs(); @@ -169,10 +188,10 @@ int dhd_write_rdwr_macaddr(struct ether_addr *mac) sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed" - " to write into File: %s\n", buf, filepath)); + " to write into File: %s\n", buf, filepath_efs)); else DHD_INFO(("[WIFI] Mac address [%s] written" - " into File: %s\n", buf, filepath)); + " into File: %s\n", buf, filepath_efs)); } set_fs(oldfs); filp_close(fp_mac, NULL); @@ -190,12 +209,12 @@ int dhd_check_rdwr_macaddr(struct dhd_info *dhd, dhd_pub_t *dhdp, char macbuffer[18] = {0}; char randommac[3] = {0}; char buf[18] = {0}; - char *filepath_old = "/data/.mac.info"; - char *filepath = "/efs/wifi/.mac.info"; + char *filepath_data = MACINFO; + char *filepath_efs = MACINFO_EFS; #ifdef CONFIG_TARGET_LOCALE_NA char *nvfilepath = "/data/misc/wifi/.nvmac.info"; #else - char *nvfilepath = "/data/.nvmac.info"; + char *nvfilepath = NVMACINFO; #endif char cur_mac[128] = {0}; char dummy_mac[ETHER_ADDR_LEN] = {0x00, 0x90, 0x4C, 0xC5, 0x12, 0x38}; @@ -231,7 +250,7 @@ int dhd_check_rdwr_macaddr(struct dhd_info *dhd, dhd_pub_t *dhdp, cur_mac[0], cur_mac[1], cur_mac[2], cur_mac[3], cur_mac[4], cur_mac[5]); - fp_mac = filp_open(filepath_old, O_RDONLY, 0); + fp_mac = filp_open(filepath_data, O_RDONLY, 0); if (IS_ERR(fp_mac)) { /* file does not exist */ /* read mac is the dummy mac (00:90:4C:C5:12:38) */ if (memcmp(cur_mac, dummy_mac, ETHER_ADDR_LEN) == 0) @@ -280,7 +299,7 @@ int dhd_check_rdwr_macaddr(struct dhd_info *dhd, dhd_pub_t *dhdp, } } } - fp_mac = filp_open(filepath, O_RDONLY, 0); + fp_mac = filp_open(filepath_efs, O_RDONLY, 0); if (IS_ERR(fp_mac)) { /* file does not exist */ /* read mac is the dummy mac (00:90:4C:C5:12:38) */ if (memcmp(cur_mac, dummy_mac, ETHER_ADDR_LEN) == 0) @@ -402,18 +421,18 @@ int dhd_write_rdwr_korics_macaddr(struct dhd_info *dhd, struct ether_addr *mac) mm_segment_t oldfs = {0}; char randommac[3] = {0}; char buf[18] = {0}; - char *filepath = "/efs/wifi/.mac.info"; + char *filepath_efs = MACINFO_EFS; int is_zeromac = 0; int ret = 0; /* MAC address copied from efs/wifi.mac.info */ - fp = filp_open(filepath, O_RDONLY, 0); + fp = filp_open(filepath_efs, O_RDONLY, 0); if (IS_ERR(fp)) { /* File Doesn't Exist. Create and write mac addr.*/ - fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); + fp = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp)) { DHD_ERROR(("[WIFI] %s: File open error\n", - filepath)); + filepath_efs)); return -1; } @@ -438,11 +457,11 @@ int dhd_write_rdwr_korics_macaddr(struct dhd_info *dhd, struct ether_addr *mac) if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s]" " Failed to write into File:" - " %s\n", macbuffer, filepath)); + " %s\n", macbuffer, filepath_efs)); else DHD_ERROR(("[WIFI] Mac address [%s]" " written into File: %s\n", - macbuffer, filepath)); + macbuffer, filepath_efs)); } set_fs(oldfs); } else { @@ -473,7 +492,7 @@ int dhd_write_rdwr_korics_macaddr(struct dhd_info *dhd, struct ether_addr *mac) (unsigned int *)&(mac->octet[5])); else DHD_INFO(("dhd_bus_start: Reading from the" - " '%s' returns 0 bytes\n", filepath)); + " '%s' returns 0 bytes\n", filepath_efs)); if (fp) filp_close(fp, NULL); @@ -494,16 +513,16 @@ int dhd_write_rdwr_korics_macaddr(struct dhd_info *dhd, struct ether_addr *mac) #endif /* RDWR_KORICS_MACADDR */ #ifdef USE_CID_CHECK -static int dhd_write_cid_file(const char *filepath, const char *buf, int buf_len) +static int dhd_write_cid_file(const char *filepath_efs, const char *buf, int buf_len) { struct file *fp = NULL; mm_segment_t oldfs = {0}; int ret = 0; /* File is always created.*/ - fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); + fp = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp)) { - DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); + DHD_ERROR(("[WIFI] %s: File open error\n", filepath_efs)); return -1; } else { oldfs = get_fs(); @@ -513,10 +532,10 @@ static int dhd_write_cid_file(const char *filepath, const char *buf, int buf_len ret = fp->f_op->write(fp, buf, buf_len, &fp->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Failed to write CIS[%s]" - " into '%s'\n", buf, filepath)); + " into '%s'\n", buf, filepath_efs)); else DHD_ERROR(("[WIFI] CID [%s] written into" - " '%s'\n", buf, filepath)); + " '%s'\n", buf, filepath_efs)); } set_fs(oldfs); } @@ -664,7 +683,7 @@ static int dhd_write_mac_file(const char *filepath, const char *buf, int buf_len fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); /*File is always created.*/ if (IS_ERR(fp)) { - DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); + DHD_ERROR(("[WIFI] File open error\n")); return -1; } else { oldfs = get_fs(); @@ -673,11 +692,9 @@ static int dhd_write_mac_file(const char *filepath, const char *buf, int buf_len if (fp->f_mode & FMODE_WRITE) { ret = fp->f_op->write(fp, buf, buf_len, &fp->f_pos); if (ret < 0) - DHD_ERROR(("[WIFI] Failed to write CIS[%s]\ -into '%s'\n", buf, filepath)); + DHD_ERROR(("[WIFI] Failed to write CIS. \n")); else - DHD_ERROR(("[WIFI] MAC [%s] written\ -into '%s'\n", buf, filepath)); + DHD_ERROR(("[WIFI] MAC written. \n")); } set_fs(oldfs); } @@ -693,19 +710,13 @@ int dhd_check_module_mac(dhd_pub_t *dhd) int ret = -1; unsigned char cis_buf[250] = {0}; unsigned char mac_buf[20] = {0}; - const char *macfilepath = "/efs/wifi/.mac.info"; + unsigned char otp_mac_buf[20] = {0}; + const char *macfilepath = MACINFO_EFS; /* Try reading out from CIS */ cis_rw_t *cish = (cis_rw_t *)&cis_buf[8]; struct file *fp_mac = NULL; - fp_mac = filp_open(macfilepath, O_RDONLY, 0); - if (!IS_ERR(fp_mac)) { - kernel_read(fp_mac, fp_mac->f_pos, mac_buf, sizeof(mac_buf)); - DHD_ERROR(("[WIFI].mac.info file already exist : [%s]\n", - mac_buf)); - return 0; - } cish->source = 0; cish->byteoff = 0; cish->nbytes = sizeof(cis_buf); @@ -716,6 +727,7 @@ int dhd_check_module_mac(dhd_pub_t *dhd) if (ret < 0) { DHD_ERROR(("%s: CIS reading failed, err=%d\n", __func__, ret)); + return ret; } else { unsigned char mac_id[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; #ifdef DUMP_CIS @@ -728,11 +740,21 @@ int dhd_check_module_mac(dhd_pub_t *dhd) mac_id[4] = cis_buf[CIS_MAC_OFFSET + 4]; mac_id[5] = cis_buf[CIS_MAC_OFFSET + 5]; - sprintf(mac_buf, "%02X:%02X:%02X:%02X:%02X:%02X\n", + sprintf(otp_mac_buf, "%02X:%02X:%02X:%02X:%02X:%02X\n", mac_id[0], mac_id[1], mac_id[2], mac_id[3], mac_id[4], mac_id[5]); - DHD_ERROR(("[WIFI]mac_id is setted from OTP: [%s]\n", mac_buf)); - dhd_write_mac_file(macfilepath, mac_buf, sizeof(mac_buf)); + DHD_ERROR(("[WIFI]mac_id is setted from OTP \n")); + } + + fp_mac = filp_open(macfilepath, O_RDONLY, 0); + if (!IS_ERR(fp_mac)) { + DHD_ERROR(("[WIFI]Check Mac address in .mac.info \n")); + kernel_read(fp_mac, fp_mac->f_pos, mac_buf, sizeof(mac_buf)); + + if (strncmp(mac_buf , otp_mac_buf , 17) != 0) { + DHD_ERROR(("[WIFI]file MAC is wrong. Write OTP MAC in .mac.info \n")); + dhd_write_mac_file(macfilepath, otp_mac_buf, sizeof(otp_mac_buf)); + } } return ret; @@ -742,8 +764,8 @@ int dhd_check_module_mac(dhd_pub_t *dhd) #ifdef WRITE_MACADDR int dhd_write_macaddr(struct ether_addr *mac) { - char *filepath_old = "/data/.mac.info"; - char *filepath = "/efs/wifi/.mac.info"; + char *filepath_data = MACINFO; + char *filepath_efs = MACINFO_EFS; struct file *fp_mac = NULL; char buf[18] = {0}; @@ -758,10 +780,10 @@ startwrite: mac->octet[3], mac->octet[4], mac->octet[5]); /* File will be created /data/.mac.info. */ - fp_mac = filp_open(filepath_old, O_RDWR | O_CREAT, 0666); + fp_mac = filp_open(filepath_data, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp_mac)) { - DHD_ERROR(("[WIFI] %s: File open error\n", filepath_old)); + DHD_ERROR(("[WIFI] %s: File open error\n", filepath_data)); return -1; } else { oldfs = get_fs(); @@ -772,16 +794,16 @@ startwrite: sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed to" - " write into File: %s\n", buf, filepath_old)); + " write into File: %s\n", buf, filepath_data)); else DHD_INFO(("[WIFI] Mac address [%s] written" - " into File: %s\n", buf, filepath_old)); + " into File: %s\n", buf, filepath_data)); } set_fs(oldfs); filp_close(fp_mac, NULL); } /* check .mac.info file is 0 byte */ - fp_mac = filp_open(filepath_old, O_RDONLY, 0); + fp_mac = filp_open(filepath_data, O_RDONLY, 0); ret = kernel_read(fp_mac, 0, buf, 18); if ((ret == 0) && (retry_count++ < 3)) { @@ -793,10 +815,10 @@ startwrite: /* end of /data/.mac.info */ /* File will be created /efs/wifi/.mac.info. */ - fp_mac = filp_open(filepath, O_RDWR | O_CREAT, 0666); + fp_mac = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp_mac)) { - DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); + DHD_ERROR(("[WIFI] %s: File open error\n", filepath_efs)); return -1; } else { oldfs = get_fs(); @@ -807,17 +829,17 @@ startwrite: sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed to" - " write into File: %s\n", buf, filepath)); + " write into File: %s\n", buf, filepath_efs)); else DHD_INFO(("[WIFI] Mac address [%s] written" - " into File: %s\n", buf, filepath)); + " into File: %s\n", buf, filepath_efs)); } set_fs(oldfs); filp_close(fp_mac, NULL); } /* check .mac.info file is 0 byte */ - fp_mac = filp_open(filepath, O_RDONLY, 0); + fp_mac = filp_open(filepath_efs, O_RDONLY, 0); ret = kernel_read(fp_mac, 0, buf, 18); if ((ret == 0) && (retry_count++ < 3)) { diff --git a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_linux.c b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_linux.c index d01b9fc..ca43dda 100644 --- a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_linux.c +++ b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_linux.c @@ -244,6 +244,10 @@ static uint32 maxdelay = 0, tspktcnt = 0, maxdelaypktno = 0; #endif /* WLMEDIA_HTSF */ +#if defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) +/*SLP_wakelock_alternative_code*/ +extern struct device *pm_dev; +#endif /* CONFIG_PM_SLEEP && CUSTOMER_HW_SLP */ #if defined(PKT_FILTER_SUPPORT) #if defined(CUSTOMER_HW_SAMSUNG) #define HEX_PREF_STR "0x" @@ -617,13 +621,17 @@ static int dhd_set_suspend(int value, dhd_pub_t *dhd) #ifdef BCM4334_CHIP int bcn_li_bcn; #endif +#ifdef PASS_ALL_MCAST_PKTS + uint32 allmulti; +#endif /* PASS_ALL_MCAST_PKTS */ DHD_ERROR(("%s: enter, value = %d in_suspend=%d\n", __FUNCTION__, value, dhd->in_suspend)); if (dhd && dhd->up) { if (value && dhd->in_suspend) { - + if (wl_cfgp2p_p2p_listen_suspend()) + DHD_ERROR(("failed to set WLC_E_P2P_PROBREQ_MSG\n")); #ifdef PKT_FILTER_SUPPORT dhd->early_suspended = 1; #endif @@ -637,7 +645,17 @@ static int dhd_set_suspend(int value, dhd_pub_t *dhd) #endif /* Enable packet filter, only allow unicast packet to send up */ - dhd_set_packet_filter(1, dhd); + if (dhd_pkt_filter_enable && !dhd->dhcp_in_progress) { + int i; + for (i = 0; i < dhd->pktfilter_count; i++) + dhd_pktfilter_offload_enable(dhd, dhd->pktfilter[i], + 1, dhd_master_mode); + } +#ifdef PASS_ALL_MCAST_PKTS + allmulti = 0; + bcm_mkiovar("allmulti", (char *)&allmulti, 4, iovbuf, sizeof(iovbuf)); + dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0); +#endif /* PASS_ALL_MCAST_PKTS */ #ifndef CUSTOMER_HW_SAMSUNG /* If DTIM skip is set up as default, force it to wake @@ -676,7 +694,17 @@ static int dhd_set_suspend(int value, dhd_pub_t *dhd) #endif /* disable pkt filter */ - dhd_set_packet_filter(0, dhd); + if (dhd_pkt_filter_enable && !dhd->dhcp_in_progress) { + int i; + for (i = 0; i < dhd->pktfilter_count; i++) + dhd_pktfilter_offload_enable(dhd, dhd->pktfilter[i], + 0, dhd_master_mode); + } +#ifdef PASS_ALL_MCAST_PKTS + allmulti = 1; + bcm_mkiovar("allmulti", (char *)&allmulti, 4, iovbuf, sizeof(iovbuf)); + dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0); +#endif /* PASS_ALL_MCAST_PKTS */ #ifndef CUSTOMER_HW_SAMSUNG /* restore pre-suspend setting for dtim_skip */ @@ -1319,7 +1347,10 @@ _dhd_sysioc_thread(void *data) } if (dhd->set_macaddress == i+1) { dhd->set_macaddress = 0; - _dhd_set_mac_address(dhd, i, &dhd->macvalue); + if (0 == _dhd_set_mac_address(dhd, i, &dhd->macvalue)) + DHD_INFO(("dhd_sysioc_thread: MACID is overwritten\n")); + else + DHD_ERROR(("dhd_sysioc_thread: _dhd_set_mac_address() failed\n")); } } } @@ -2334,16 +2365,6 @@ static bool dhd_check_hang(struct net_device *net, dhd_pub_t *dhdp, int error) { if (!dhdp) return FALSE; -#ifdef BCM4334_CHIP - if ((error == -ETIMEDOUT) || (error == -EREMOTEIO) || (dhdp->tx_seq_badcnt >= 2) - || ((dhdp->busstate == DHD_BUS_DOWN)&&(!dhdp->dongle_reset))) { - DHD_ERROR(("%s: Event HANG send up due to re=%d te=%d e=%d s=%d tse=%d\n", - __FUNCTION__, dhdp->rxcnt_timeout, dhdp->txcnt_timeout, error, - dhdp->busstate, dhdp->tx_seq_badcnt)); - net_os_send_hang_message(net); - return TRUE; - } -#else if ((error == -ETIMEDOUT) || (error == -EREMOTEIO) || ((dhdp->busstate == DHD_BUS_DOWN)&&(!dhdp->dongle_reset))) { DHD_ERROR(("%s: Event HANG send up due to re=%d te=%d e=%d s=%d\n", __FUNCTION__, @@ -2351,7 +2372,6 @@ static bool dhd_check_hang(struct net_device *net, dhd_pub_t *dhdp, int error) net_os_send_hang_message(net); return TRUE; } -#endif return FALSE; } @@ -2680,9 +2700,6 @@ dhd_stop(struct net_device *net) dhd->pub.hang_was_sent = 0; dhd->pub.rxcnt_timeout = 0; dhd->pub.txcnt_timeout = 0; -#ifdef BCM4334_CHIP - dhd->pub.tx_seq_badcnt = 0; -#endif OLD_MOD_DEC_USE_COUNT; exit: DHD_OS_WAKE_UNLOCK(&dhd->pub); @@ -3457,6 +3474,9 @@ dhd_preinit_ioctls(dhd_pub_t *dhd) #ifdef AUTOCOUNTRY int autocountry = 1; #endif +#ifdef VSDB + int interference_mode = 3; +#endif #ifdef PROP_TXSTATUS dhd->wlfc_enabled = FALSE; /* enable WLFC only if the firmware is VSDB */ @@ -3736,7 +3756,6 @@ dhd_preinit_ioctls(dhd_pub_t *dhd) setbit(eventmask, WLC_E_ACTION_FRAME_RX); setbit(eventmask, WLC_E_ACTION_FRAME_COMPLETE); setbit(eventmask, WLC_E_ACTION_FRAME_OFF_CHAN_COMPLETE); - setbit(eventmask, WLC_E_P2P_PROBREQ_MSG); setbit(eventmask, WLC_E_P2P_DISC_LISTEN_COMPLETE); } #endif /* WL_CFG80211 */ @@ -3812,6 +3831,12 @@ dhd_preinit_ioctls(dhd_pub_t *dhd) } } #endif /* defined(SOFTAP) */ + if (dhd->pktfilter_count) { + int i; + + for (i = 0; i < dhd->pktfilter_count; i++) + dhd_pktfilter_offload_set(dhd, dhd->pktfilter[i]); + } #endif /* PKT_FILTER_SUPPORT */ #ifdef VLAN_MODE_OFF @@ -3828,6 +3853,9 @@ dhd_preinit_ioctls(dhd_pub_t *dhd) DHD_ERROR(("%s Setting WL UP failed %d\n", __FUNCTION__, ret)); goto done; } +#ifdef VSDB + dhd_wl_ioctl_cmd(dhd, WLC_SET_INTERFERENCE_MODE, (int *)&interference_mode, sizeof(int), TRUE, 0); +#endif #ifdef BCM4334_CHIP bcm_mkiovar("bcn_li_bcn", (char *)&bcn_li_bcn, 4, iovbuf, sizeof(iovbuf)); @@ -4598,6 +4626,9 @@ dhd_os_wd_timer(void *bus, uint wdtick) DHD_TRACE(("%s: Enter\n", __FUNCTION__)); + if (!dhd) + return; + flags = dhd_os_spin_lock(pub); /* don't start the wd until fw is loaded */ @@ -4936,7 +4967,7 @@ void dhd_wait_for_event(dhd_pub_t *dhd, bool *lockvar) #if 1 && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)) struct dhd_info *dhdinfo = dhd->info; dhd_os_sdunlock(dhd); - wait_event_interruptible_timeout(dhdinfo->ctrl_wait, (*lockvar == FALSE), HZ * 2); + wait_event_interruptible_timeout(dhdinfo->ctrl_wait, (*lockvar == FALSE), HZ * 5); dhd_os_sdlock(dhd); #endif return; @@ -5034,6 +5065,7 @@ int net_os_rxfilter_add_remove(struct net_device *dev, int add_remove, int num) } } dhd->pub.pktfilter[num] = filterp; + dhd_pktfilter_offload_set(&dhd->pub, dhd->pub.pktfilter[num]); return ret; #else return 0; @@ -5052,8 +5084,12 @@ int net_os_set_packet_filter(struct net_device *dev, int val) */ if (dhd && dhd->pub.up) { if (dhd->pub.in_suspend) { - if (!val || (val && !dhd->pub.suspend_disable_flag)) - dhd_set_packet_filter(val, &dhd->pub); + if (!val || (val && !dhd->pub.suspend_disable_flag)) { + int i; + for (i = 0; i < dhd->pub.pktfilter_count; i++) + dhd_pktfilter_offload_enable(&dhd->pub, dhd->pub.pktfilter[i], + val, dhd_master_mode); + } } } return ret; @@ -5337,6 +5373,9 @@ int dhd_os_wake_lock(dhd_pub_t *pub) #ifdef CONFIG_HAS_WAKELOCK if (!dhd->wakelock_counter) wake_lock(&dhd->wl_wifi); +#elif defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) + /*SLP_wakelock_alternative_code*/ + pm_stay_awake(pm_dev); #endif dhd->wakelock_counter++; ret = dhd->wakelock_counter; @@ -5369,6 +5408,9 @@ int dhd_os_wake_unlock(dhd_pub_t *pub) #ifdef CONFIG_HAS_WAKELOCK if (!dhd->wakelock_counter) wake_unlock(&dhd->wl_wifi); +#elif defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) + /*SLP_wakelock_alternative_code*/ + pm_relax(pm_dev); #endif ret = dhd->wakelock_counter; } @@ -5389,6 +5431,19 @@ int dhd_os_check_wakelock(void *dhdp) if (dhd && wake_lock_active(&dhd->wl_wifi)) return 1; +#elif defined(CONFIG_PM_SLEEP) && defined(CUSTOMER_HW_SLP) + /*SLP_wakelock_alternative_code*/ + dhd_pub_t *pub = (dhd_pub_t *)dhdp; + dhd_info_t *dhd; + + if (!pub) + return 0; + dhd = (dhd_info_t *)(pub->info); + + DHD_ERROR(("%s : wakelock_count = %d\n", __func__, dhd->wakelock_counter )); + + if (dhd && (dhd->wakelock_counter > 0)) + return 1; #endif return 0; } diff --git a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sdio.c b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sdio.c index 2c411f8..052eaaf 100644 --- a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sdio.c +++ b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sdio.c @@ -265,9 +265,6 @@ typedef struct dhd_bus { bool activity; /* Activity flag for clock down */ int32 idletime; /* Control for activity timeout */ int32 idlecount; /* Activity timeout counter */ -#ifdef DHD_USE_IDLECOUNT - int32 dhd_idlecount; /* DHD idle count */ -#endif /* DHD_USE_IDLECOUNT */ int32 idleclock; /* How to set bus driver when idle */ int32 sd_divisor; /* Speed control to bus driver */ int32 sd_mode; /* Mode control to bus driver */ @@ -1034,7 +1031,7 @@ dhdsdio_htclk(dhd_bus_t *bus, bool on, bool pendok) bus->activity = TRUE; #ifdef DHD_USE_IDLECOUNT - bus->dhd_idlecount = 0; + bus->idlecount = 0; #endif /* DHD_USE_IDLECOUNT */ } else { clkreq = 0; @@ -1162,7 +1159,7 @@ dhdsdio_clkctl(dhd_bus_t *bus, uint target, bool pendok) dhd_os_wd_timer(bus->dhd, dhd_watchdog_ms); bus->activity = TRUE; #ifdef DHD_USE_IDLECOUNT - bus->dhd_idlecount = 0; + bus->idlecount = 0; #endif /* DHD_USE_IDLECOUNT */ } return ret; @@ -1179,7 +1176,7 @@ dhdsdio_clkctl(dhd_bus_t *bus, uint target, bool pendok) dhd_os_wd_timer(bus->dhd, dhd_watchdog_ms); bus->activity = TRUE; #ifdef DHD_USE_IDLECOUNT - bus->dhd_idlecount = 0; + bus->idlecount = 0; #endif /* DHD_USE_IDLECOUNT */ } break; @@ -1828,8 +1825,13 @@ dhd_bus_txctl(struct dhd_bus *bus, uchar *msg, uint msglen) /* Send from dpc */ bus->ctrl_frame_buf = frame; bus->ctrl_frame_len = len; - - dhd_wait_for_event(bus->dhd, &bus->ctrl_frame_stat); + if(!bus->dpc_sched) { + bus->dpc_sched = TRUE; + dhd_sched_dpc(bus->dhd); + } + if (bus->ctrl_frame_stat) { + dhd_wait_for_event(bus->dhd, &bus->ctrl_frame_stat); + } if (bus->ctrl_frame_stat == FALSE) { DHD_INFO(("%s: ctrl_frame_stat == FALSE\n", __FUNCTION__)); @@ -4645,22 +4647,11 @@ dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished) } /* Check window for sanity */ -#ifdef BCM4334_CHIP - if ((uint8)(txmax - bus->tx_seq) > 0x40) { - DHD_ERROR(("%s: got unlikely tx max %d with tx_seq %d\n", - __FUNCTION__, txmax, bus->tx_seq)); - txmax = bus->tx_max; - bus->dhd->tx_seq_badcnt++; - } - else - bus->dhd->tx_seq_badcnt = 0; -#else if ((uint8)(txmax - bus->tx_seq) > 0x40) { DHD_ERROR(("%s: got unlikely tx max %d with tx_seq %d\n", __FUNCTION__, txmax, bus->tx_seq)); txmax = bus->tx_max; } -#endif bus->tx_max = txmax; #ifdef DHD_DEBUG @@ -4813,22 +4804,11 @@ dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished) } /* Check window for sanity */ -#ifdef BCM4334_CHIP - if ((uint8)(txmax - bus->tx_seq) > 0x40) { - DHD_ERROR(("%s: got unlikely tx max %d with tx_seq %d\n", - __FUNCTION__, txmax, bus->tx_seq)); - txmax = bus->tx_max; - bus->dhd->tx_seq_badcnt++; - } - else - bus->dhd->tx_seq_badcnt = 0; -#else if ((uint8)(txmax - bus->tx_seq) > 0x40) { DHD_ERROR(("%s: got unlikely tx max %d with tx_seq %d\n", __FUNCTION__, txmax, bus->tx_seq)); txmax = bus->tx_max; } -#endif bus->tx_max = txmax; /* Call a separate function for control frames */ @@ -5296,6 +5276,13 @@ clkwait: if (TXCTLOK(bus) && bus->ctrl_frame_stat && (bus->clkstate == CLK_AVAIL)) { int ret, i; + uint8* frame_seq = bus->ctrl_frame_buf + SDPCM_FRAMETAG_LEN; + if (*frame_seq != bus->tx_seq) { + DHD_INFO(("%s IOCTL frame seq lag detected!" + " frm_seq:%d != bus->tx_seq:%d, corrected\n", + __FUNCTION__, *frame_seq, bus->tx_seq)); + *frame_seq = bus->tx_seq; + } ret = dhd_bcmsdh_send_buf(bus, bcmsdh_cur_sbwad(sdh), SDIO_FUNC_2, F2SYNC, (uint8 *)bus->ctrl_frame_buf, (uint32)bus->ctrl_frame_len, @@ -5720,9 +5707,6 @@ dhd_disable_intr(dhd_pub_t *dhdp) bcmsdh_intr_disable(bus->sdh); } -#ifdef DHD_USE_IDLECOUNT -#define DHD_IDLE_TIMEOUT_MS (50) -#endif /* DHD_USE_IDLECOUNT */ extern bool dhd_bus_watchdog(dhd_pub_t *dhdp) @@ -5805,31 +5789,27 @@ dhd_bus_watchdog(dhd_pub_t *dhdp) #endif /* On idle timeout clear activity flag and/or turn off clock */ - if ((bus->idletime > 0) && (bus->clkstate == CLK_AVAIL)) { #ifdef DHD_USE_IDLECOUNT - if (++bus->idlecount >= bus->idletime) { - bus->idlecount = 0; if (bus->activity) bus->activity = FALSE; else { - bus->dhd_idlecount++; + bus->idlecount++; - if (bus->dhd_idlecount >= (DHD_IDLE_TIMEOUT_MS/dhd_watchdog_ms)) { + if (bus->idlecount >= bus->idletime) { DHD_TIMER(("%s: DHD Idle state!!\n", __FUNCTION__)); if (SLPAUTO_ENAB(bus)) { if (dhdsdio_bussleep(bus, TRUE) != BCME_BUSY) dhd_os_wd_timer(bus->dhd, 0); - } - else + } else dhdsdio_clkctl(bus, CLK_NONE, FALSE); - bus->dhd_idlecount = 0; + bus->idlecount = 0; } } - } #else + if ((bus->idletime > 0) && (bus->clkstate == CLK_AVAIL)) { if (++bus->idlecount >= bus->idletime) { bus->idlecount = 0; if (bus->activity) { @@ -5840,8 +5820,8 @@ dhd_bus_watchdog(dhd_pub_t *dhdp) dhdsdio_clkctl(bus, CLK_NONE, FALSE); } } -#endif /* DHD_USE_IDLECOUNT */ } +#endif /* DHD_USE_IDLECOUNT */ return bus->ipend; } @@ -6147,6 +6127,12 @@ dhdsdio_probe(uint16 venid, uint16 devid, uint16 bus_no, uint16 slot, goto fail; } +#ifdef BCMHOST_XTAL_PU_TIME_MOD +#ifdef BCM4334_CHIP + bcmsdh_reg_write(bus->sdh, 0x18000620, 2, 11); + bcmsdh_reg_write(bus->sdh, 0x18000628, 4, 0x00A60001); +#endif +#endif #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)) mutex_unlock(&_dhd_sdio_mutex_lock_); DHD_ERROR(("%s : the lock is released.\n", __FUNCTION__)); diff --git a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sec_feature.h b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sec_feature.h index 89fc7ee..2d1d200 100644 --- a/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sec_feature.h +++ b/drivers/net/wireless/bcmdhd/src/dhd/sys/dhd_sec_feature.h @@ -40,7 +40,8 @@ #define HW_OOB #endif -#ifdef CONFIG_MACH_U1 /* Q1 also uses this feature */ +/* Q1 also uses this feature */ +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) #ifdef CONFIG_MACH_Q1_BD #define HW_OOB #endif @@ -48,6 +49,11 @@ #define WRITE_MACADDR #endif +#ifdef CONFIG_MACH_GC1 +#undef USE_CID_CHECK +#define READ_MACADDR +#endif + /* REGION CODE */ #if (WLAN_REGION_CODE >= 100) && (WLAN_REGION_CODE < 200) /*EUR*/ @@ -106,3 +112,6 @@ #define BCMWAPI_WAI #endif +#if !defined(READ_MACADDR) && !defined(WRITE_MACADDR) && !defined(RDWR_KORICS_MACADDR) && !defined(RDWR_MACADDR) +#define GET_MAC_FROM_OTP +#endif diff --git a/drivers/net/wireless/bcmdhd/src/include/epivers.h b/drivers/net/wireless/bcmdhd/src/include/epivers.h index 058f1d4..8be59f6 100644 --- a/drivers/net/wireless/bcmdhd/src/include/epivers.h +++ b/drivers/net/wireless/bcmdhd/src/include/epivers.h @@ -30,19 +30,19 @@ #define EPI_MINOR_VERSION 15 -#define EPI_RC_NUMBER 11 +#define EPI_RC_NUMBER 12 #define EPI_INCREMENTAL_NUMBER 0 #define EPI_BUILD_NUMBER 0 -#define EPI_VERSION 1, 15, 11, 0 +#define EPI_VERSION 1, 15, 12, 0 #define EPI_VERSION_NUM 0x010f0900 -#define EPI_VERSION_DEV 1.15.11 +#define EPI_VERSION_DEV 1.15.12 -#define EPI_VERSION_STR "1.15.11" +#define EPI_VERSION_STR "1.15.12" #endif /* _epivers_h_ */ diff --git a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_android.c b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_android.c index 1704701..49782c5 100644 --- a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_android.c +++ b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_android.c @@ -132,7 +132,10 @@ typedef struct cmd_tlv { #ifdef BCM4334_CHIP //ampdu_mpdu #define CMD_AMPDU_MPDU "AMPDU_MPDU" #endif - +#ifdef VSDB +#define CMD_CHANGE_RL "CHANGE_RL" +#define CMD_RESTORE_RL "RESTORE_RL" +#endif typedef struct android_wifi_priv_cmd { char *buf; int used_len; @@ -778,10 +781,12 @@ wl_android_set_auto_channel(struct net_device *dev, const char* string_num, } done: - snprintf(command, total_len, "%d", channel); +// snprintf(command, total_len, "%d", channel); + snprintf(command, 4, "%d", channel); DHD_INFO(("%s: command result is %s\n", __FUNCTION__, command)); - return 1; +// return 1; + return 4; } static int @@ -895,6 +900,31 @@ wl_android_okc_enable(struct net_device *dev, char *command, int total_len) } #endif /* OKC_ SUPPORT */ +#ifdef VSDB +static int +wl_android_ch_res_rl(struct net_device *dev, bool change) +{ + int error = 0; + s32 srl = 7; + s32 lrl = 4; + printk("%s enter\n", __FUNCTION__); + if (change) { + srl = 4; + lrl = 2; + } + error = wldev_ioctl(dev, WLC_SET_SRL, &srl, + sizeof(s32), true); + if (error) { + DHD_ERROR(("Failed to set SRL, error = %d\n", error)); + } + error = wldev_ioctl(dev, WLC_SET_LRL, &lrl, + sizeof(s32), true); + if (error) { + DHD_ERROR(("Failed to set LRL, error = %d\n", error)); + } + return error; +} +#endif #ifdef BCM4334_CHIP //ampdu_mpdu static int @@ -1012,8 +1042,9 @@ int wl_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd) /* TBD: BTCOEXSCAN-STOP */ } else if (strnicmp(command, CMD_BTCOEXMODE, strlen(CMD_BTCOEXMODE)) == 0) { +#if !defined(CUSTOMER_HW_SAMSUNG) uint mode = *(command + strlen(CMD_BTCOEXMODE) + 1) - '0'; -#if 0 + if (mode == 1) net_os_set_packet_filter(net, 0); /* DHCP starts */ else @@ -1116,7 +1147,9 @@ int wl_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd) else if (strnicmp(command, CMD_SET_HAPD_AUTO_CHANNEL, strlen(CMD_SET_HAPD_AUTO_CHANNEL)) == 0) { int skip = strlen(CMD_SET_HAPD_AUTO_CHANNEL) + 3; - wl_android_set_auto_channel(net, (const char*)command+skip, command, +// wl_android_set_auto_channel(net, (const char*)command+skip, command, +// priv_cmd.total_len); + bytes_written = wl_android_set_auto_channel(net, (const char*)command+skip, command, priv_cmd.total_len); } else if (strnicmp(command, CMD_SET_HAPD_MAX_NUM_STA, @@ -1162,6 +1195,12 @@ int wl_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd) bytes_written = wl_android_set_ampdu_mpdu(net, (const char*)command+skip); } #endif +#ifdef VSDB + else if (strnicmp(command, CMD_CHANGE_RL, strlen(CMD_CHANGE_RL)) == 0) + bytes_written = wl_android_ch_res_rl(net, true); + else if (strnicmp(command, CMD_RESTORE_RL, strlen(CMD_RESTORE_RL)) == 0) + bytes_written = wl_android_ch_res_rl(net, false); +#endif else { if ((strnicmp(command, CMD_START, strlen(CMD_START)) != 0) && (strnicmp(command, CMD_SETFWPATH, strlen(CMD_SETFWPATH)) != 0)) diff --git a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.c b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.c index f805d60..c74adcc 100644 --- a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.c +++ b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.c @@ -402,7 +402,6 @@ static __used bool wl_is_ibssstarter(struct wl_priv *wl); */ static s32 __wl_cfg80211_up(struct wl_priv *wl); static s32 __wl_cfg80211_down(struct wl_priv *wl); -static s32 wl_add_remove_eventmsg(struct net_device *ndev, u16 event, bool add); static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e); static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e, struct net_device *ndev); static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e); @@ -2462,9 +2461,9 @@ wl_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme) val = WL_AUTH_OPEN_SHARED; WL_DBG(("automatic\n")); break; +#ifdef BCMCCX case NL80211_AUTHTYPE_NETWORK_EAP: WL_DBG(("network eap\n")); -#ifdef BCMCCX val = DOT11_LEAP_AUTH; break; #endif @@ -4286,6 +4285,7 @@ wl_cfg80211_mgmt_tx(struct wiphy *wiphy, struct net_device *ndev, #ifdef WL_CFG80211_SYNC_GON_TIME bool is_waiting_more_time = false; #endif /* WL_CFG80211_SYNC_GON_TIME */ + bool is_PROVDIS_REQ_GO = false; WL_DBG(("Enter \n")); @@ -4542,8 +4542,14 @@ wl_cfg80211_mgmt_tx(struct wiphy *wiphy, struct net_device *ndev, memcpy(wl->afx_hdl->tx_dst_addr.octet, af_params->action_frame.da.octet, sizeof(wl->afx_hdl->tx_dst_addr.octet)); + if ((act_frm->subtype == P2P_PAF_PROVDIS_REQ) && + (p2p_ie = wl_cfgp2p_find_p2pie((u8 *)act_frm->elts, action_frame->len)) != NULL) { + if ((ptr = wl_cfgp2p_retreive_p2pattrib(p2p_ie, P2P_SEID_GROUP_ID))) { + is_PROVDIS_REQ_GO = true; + } + } - if (IS_P2P_SOCIAL(af_params->channel) && + if (!is_PROVDIS_REQ_GO && IS_P2P_SOCIAL(af_params->channel) && (IS_P2P_PUB_ACT_REQ(act_frm, action_frame->len) || IS_GAS_REQ(sd_act_frm, action_frame->len)) && wl_to_p2p_bss_saved_ie(wl, P2PAPI_BSSCFG_DEVICE).p2p_probe_req_ie_len) { @@ -5132,6 +5138,14 @@ wl_cfg80211_add_set_beacon(struct wiphy *wiphy, struct net_device *dev, is_bssup = wl_cfgp2p_bss_isup(dev, bssidx); if (!is_bssup && (wpa2_ie != NULL)) { + if (!info->dtim_period) { + info->dtim_period = 1; + } + if ((err = wldev_ioctl(dev, WLC_SET_DTIMPRD, + &info->dtim_period, sizeof(s32), true)) < 0) { + WL_ERR(("DTIM Interval Set Error, %d\n", err)); + return err; + } wldev_iovar_setint(dev, "mpc", 0); if ((err = wl_validate_wpa2ie(dev, wpa2_ie, bssidx)) < 0) { WL_ERR(("WPA2 IE parsing error")); @@ -5248,13 +5262,15 @@ wl_cfg80211_add_set_beacon(struct wiphy *wiphy, struct net_device *dev, return err; } } - if (info->dtim_period) { - if ((err = wldev_ioctl(dev, WLC_SET_DTIMPRD, - &info->dtim_period, sizeof(s32), true)) < 0) { - WL_ERR(("DTIM Interval Set Error, %d\n", err)); - return err; - } + if (!info->dtim_period) { + info->dtim_period = 1; } + if ((err = wldev_ioctl(dev, WLC_SET_DTIMPRD, + &info->dtim_period, sizeof(s32), true)) < 0) { + WL_ERR(("DTIM Interval Set Error, %d\n", err)); + return err; + } + err = wldev_ioctl(dev, WLC_UP, &ap, sizeof(s32), true); if (unlikely(err)) { WL_ERR(("WLC_UP error (%d)\n", err)); @@ -5734,20 +5750,26 @@ wl_notify_connect_status_ap(struct wl_priv *wl, struct net_device *ndev, } #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)) && !CFG80211_STA_EVENT_AVAILABLE - body=kzalloc(len, GFP_KERNEL); WL_DBG(("Enter \n")); + if (!len && (event == WLC_E_DEAUTH)) { + len = 2; /* reason code field */ + data = &reason; + } + if (len) { + body=kzalloc(len, GFP_KERNEL); + if(body==NULL) { WL_ERR(("wl_notify_connect_status: Failed to allocate body\n")); return WL_INVALID; } - + } memset(&bssid, 0, ETHER_ADDR_LEN); WL_DBG(("Enter \n")); if (wl_get_mode_by_netdev(wl, ndev) == WL_INVALID) { kfree(body); return WL_INVALID; } - + if (len) memcpy(body, data, len); wldev_iovar_getbuf_bsscfg(ndev, "cur_etheraddr", NULL, 0, wl->ioctl_buf, WLC_IOCTL_MAXLEN, bsscfgidx, &wl->ioctl_buf_sync); @@ -5858,8 +5880,6 @@ wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev, if (wl_is_linkup(wl, e, ndev)) { wl_link_up(wl); act = true; - wl_update_prof(wl, ndev, e, &act, WL_PROF_ACT); - wl_update_prof(wl, ndev, NULL, (void *)&e->addr, WL_PROF_BSSID); if (wl_is_ibssmode(wl, ndev)) { printk("cfg80211_ibss_joined\n"); cfg80211_ibss_joined(ndev, (s8 *)&e->addr, @@ -5874,6 +5894,8 @@ wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev, wl_read_prof(wl, ndev, WL_PROF_SSID))->SSID)); } } + wl_update_prof(wl, ndev, e, &act, WL_PROF_ACT); + wl_update_prof(wl, ndev, NULL, (void *)&e->addr, WL_PROF_BSSID); } else if (wl_is_linkdown(wl, e)) { if (wl->scan_request) { @@ -6222,18 +6244,17 @@ wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev, WL_DBG((" Enter\n")); #ifdef ESCAN_RESULT_PATCH - if (memcmp(curbssid, broad_bssid, ETHER_ADDR_LEN) == 0 && - memcmp(broad_bssid, connect_req_bssid, ETHER_ADDR_LEN) != 0) { - WL_DBG(("copy bssid\n")); - memcpy(curbssid, connect_req_bssid, ETHER_ADDR_LEN); - } if (wl_get_drv_status(wl, CONNECTED, ndev)) { if (memcmp(curbssid, connect_req_bssid, ETHER_ADDR_LEN) == 0) { WL_ERR((" Connected event of connected device, ignore it\n")); return err; } } - + if (memcmp(curbssid, broad_bssid, ETHER_ADDR_LEN) == 0 && + memcmp(broad_bssid, connect_req_bssid, ETHER_ADDR_LEN) != 0) { + WL_DBG(("copy bssid\n")); + memcpy(curbssid, connect_req_bssid, ETHER_ADDR_LEN); + } WL_SCAN2(("Connect done \n")); #if defined(BCM4334_CHIP) @@ -6403,7 +6424,8 @@ wl_frame_get_mgmt(u16 fc, const struct ether_addr *da, bcopy((const char*)da, (u8*)&hdr->da, ETHER_ADDR_LEN); bcopy((const char*)sa, (u8*)&hdr->sa, ETHER_ADDR_LEN); bcopy((const char*)bssid, (u8*)&hdr->bssid, ETHER_ADDR_LEN); - bcopy((const char*)pbody, offset, prebody_len); + if ((pbody != NULL) && prebody_len) + bcopy((const char*)pbody, offset, prebody_len); *body_len = totlen; return err; } @@ -7103,7 +7125,8 @@ wl_cfg80211_netdev_notifier_call(struct notifier_block * nb, return NOTIFY_DONE; switch (state) { case NETDEV_DOWN: - while(work_pending(&wdev->cleanup_work)) { + while(work_pending(&wdev->cleanup_work) && refcnt < 100) { + if(refcnt%5==0) WL_ERR(("%s : [NETDEV_DOWN] work_pending (%d th)\n", __FUNCTION__, refcnt)); set_current_state(TASK_INTERRUPTIBLE); @@ -7265,10 +7288,6 @@ static s32 wl_escan_handler(struct wl_priv *wl, } else { int cur_len = 0; list = (wl_scan_results_t *)wl->escan_info.escan_buf[wl->escan_info.cur_sync_id%2]; - if (bi_length > ESCAN_BUF_SIZE - list->buflen) { - WL_ERR(("Buffer is too small: ignoring\n")); - goto exit; - } #define WLC_BSS_RSSI_ON_CHANNEL 0x0002 for (i = 0; i < list->count; i++) { bss = bss ? (wl_bss_info_t *)((uintptr)bss + dtoh32(bss->length)) @@ -7276,25 +7295,26 @@ static s32 wl_escan_handler(struct wl_priv *wl, if (!bcmp(&bi->BSSID, &bss->BSSID, ETHER_ADDR_LEN) && CHSPEC_BAND(bi->chanspec) == CHSPEC_BAND(bss->chanspec) && bi->SSID_len == bss->SSID_len && - !bcmp(bi->SSID, bss->SSID, bi->SSID_len) - && (bi->length == bss->length)) { - if (p2p_is_on(wl) && p2p_scan(wl)) { - if (bss->dtoh32(ie_length)< bi_length) { - int prev_len = dtoh32(bss->length); - WL_SCAN2(("bss info replacement is occured(bcast:%d->probresp%d)\n", - bss->ie_length, bi->ie_length)); - /* prev : broadcast, cur : prob_resp */ - if (list->count != 1 && i < list->count -1) { - /* memory copy required by this case only */ - memcpy((u8 *)bss, - (u8 *)bss + prev_len, list->buflen - cur_len - prev_len); - } - list->buflen -= prev_len; - memcpy(&(((u8 *)list)[list->buflen]), bi, bi_length); - list->version = dtoh32(bi->version); - list->buflen += bi_length; + !bcmp(bi->SSID, bss->SSID, bi->SSID_len)) { + if (bss->dtoh32(ie_length) != bi_length) { + int prev_len = dtoh32(bss->length); + WL_SCAN2(("bss info replacement is occured(bcast:%d->probresp%d)\n", + bss->ie_length, bi->ie_length)); + /* prev : broadcast, cur : prob_resp */ + if (list->count != 1 && i < list->count -1) { + /* memory copy required by this case only */ + memcpy((u8 *)bss, + (u8 *)bss + prev_len, list->buflen - cur_len - prev_len); + } + list->buflen -= prev_len; + if (bi_length > ESCAN_BUF_SIZE - list->buflen) { + WL_ERR(("Buffer is too small: ignoring\n")); goto exit; } + memcpy(&(((u8 *)list)[list->buflen]), bi, bi_length); + list->version = dtoh32(bi->version); + list->buflen += bi_length; + goto exit; } if ((bss->flags & WLC_BSS_RSSI_ON_CHANNEL) == (bi->flags & WLC_BSS_RSSI_ON_CHANNEL)) { @@ -7315,6 +7335,10 @@ static s32 wl_escan_handler(struct wl_priv *wl, } cur_len += dtoh32(bss->length); } + if (bi_length > ESCAN_BUF_SIZE - list->buflen) { + WL_ERR(("Buffer is too small: ignoring\n")); + goto exit; + } memcpy(&(wl->escan_info.escan_buf[wl->escan_info.cur_sync_id%2][list->buflen]), bi, bi_length); list->version = dtoh32(bi->version); list->buflen += bi_length; @@ -7373,6 +7397,12 @@ static s32 wl_escan_handler(struct wl_priv *wl, } wl->escan_info.cur_sync_id += 2; } + else if (status == WLC_E_STATUS_NEWSCAN) + { + escan_result = (wl_escan_result_t *) data; + WL_ERR(("WLC_E_STATUS_NEWSCAN : scan_request[%p]\n", wl->scan_request)); + WL_ERR(("sync_id[%d], bss_count[%d]\n", escan_result->sync_id, escan_result->bss_count)); + } else { WL_ERR(("unexpected Escan Event %d : abort\n", status)); wl->escan_info.escan_state = WL_ESCAN_STATE_IDLE; @@ -7405,12 +7435,17 @@ static s32 wl_notifier_change_state(struct wl_priv *wl, struct net_info *_net_in { s32 pm = PM_FAST; s32 err = BCME_OK; + s32 glom = -1; + u32 chan = 0; + u32 chanspec = 0; + u32 prev_chan = 0; + u32 connected_cnt = 0; struct net_info *iter, *next; + struct net_device *primary_dev = wl_to_prmry_ndev(wl); if (set) { /* set */ switch (state) { case WL_STATUS_CONNECTED: { - if (wl_get_drv_status_all(wl, CONNECTED) > 1) { - wl->vsdb_mode = true; + if ((connected_cnt = wl_get_drv_status_all(wl, CONNECTED)) > 1) { pm = PM_OFF; WL_INFO(("Do not enable the power save for VSDB mode\n")); } else if (_net_info->pm_block) { @@ -7419,10 +7454,22 @@ static s32 wl_notifier_change_state(struct wl_priv *wl, struct net_info *_net_in pm = PM_FAST; } for_each_ndev(wl, iter, next) { - if (!wl->vsdb_mode && (iter->ndev != _net_info->ndev)) + if ((connected_cnt == 1) && (iter->ndev != _net_info->ndev)) continue; - if (wl_get_drv_status(wl, CONNECTED, iter->ndev) && - (wl_get_mode_by_netdev(wl, iter->ndev) == WL_MODE_BSS)) { + chanspec = 0; + chan = 0; + if (wl_get_drv_status(wl, CONNECTED, iter->ndev)) { + if (wldev_iovar_getint(iter->ndev, "chanspec", (s32 *)&chanspec) == BCME_OK) { + chan = CHSPEC_CHANNEL(chanspec); + if (CHSPEC_IS40(chanspec)) { + if (CHSPEC_SB_UPPER(chanspec)) + chan += CH_10MHZ_APART; + else + chan -= CH_10MHZ_APART; + } + wl_update_prof(wl, iter->ndev, NULL, &chan, WL_PROF_CHAN); + } + if ((wl_get_mode_by_netdev(wl, iter->ndev) == WL_MODE_BSS)) { pm = htod32(pm); WL_DBG(("power save %s\n", (pm ? "enabled" : "disabled"))); err = wldev_ioctl(iter->ndev, WLC_SET_PM, &pm, sizeof(pm), true); @@ -7434,6 +7481,23 @@ static s32 wl_notifier_change_state(struct wl_priv *wl, struct net_info *_net_in break; } } + if (connected_cnt > 1) { + if (!prev_chan && chan) + prev_chan = chan; + else if (prev_chan && (prev_chan != chan)){ + wl->vsdb_mode = true; + } + } + } + } + if ((wl_get_mode_by_netdev(wl, _net_info->ndev) == WL_MODE_AP) && p2p_is_on(wl)) + if (wl_add_remove_eventmsg(primary_dev, WLC_E_P2P_PROBREQ_MSG, true) != BCME_OK) + CFGP2P_ERR((" failed to set WLC_E_P2P_PROPREQ_MSG\n")); + if (!wl->vsdb_mode && (connected_cnt > 1)) { + if (wldev_iovar_getint(primary_dev, "bus:txglom", (s32 *)&glom) == BCME_OK) { + wl->glom = glom; + wldev_iovar_setint(primary_dev, "bus:txglom", 0); + } } break; } @@ -7443,6 +7507,8 @@ static s32 wl_notifier_change_state(struct wl_priv *wl, struct net_info *_net_in } else { /* clear */ switch (state) { case WL_STATUS_CONNECTED: { + chan = 0; + wl_update_prof(wl, _net_info->ndev, NULL, &chan, WL_PROF_CHAN); if (wl_get_drv_status_all(wl, CONNECTED) == 1) { wl->vsdb_mode = false; for_each_ndev(wl, iter, next) { @@ -7465,7 +7531,13 @@ static s32 wl_notifier_change_state(struct wl_priv *wl, struct net_info *_net_in } } } + if (wl->glom != -1) + wldev_iovar_setint(primary_dev, "bus:txglom", wl->glom); + wl->glom = -1; } + if ((wl_get_mode_by_netdev(wl, _net_info->ndev) == WL_MODE_AP) && p2p_is_on(wl)) + if (wl_add_remove_eventmsg(primary_dev, WLC_E_P2P_PROBREQ_MSG, false) != BCME_OK) + CFGP2P_ERR((" failed to unset WLC_E_P2P_PROPREQ_MSG\n")); break; } default: @@ -7524,6 +7596,7 @@ static s32 wl_init_priv(struct wl_priv *wl) wl->rf_blocked = false; wl->first_remain = true; wl->wlfc_on = false; + wl->glom = -1; set_bit(WL_STATUS_CONNECTED, &wl->interrested_state); spin_lock_init(&wl->cfgdrv_lock); mutex_init(&wl->ioctl_buf_sync); @@ -7997,7 +8070,7 @@ static s32 wl_config_ifmode(struct wl_priv *wl, struct net_device *ndev, s32 ift return 0; } -static s32 wl_add_remove_eventmsg(struct net_device *ndev, u16 event, bool add) +s32 wl_add_remove_eventmsg(struct net_device *ndev, u16 event, bool add) { s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; @@ -8088,6 +8161,9 @@ static int wl_construct_reginfo(struct wl_priv *wl, s32 bw_cap) n_cnt = &n_5g; band = IEEE80211_BAND_5GHZ; ht40_allowed = (bw_cap == WLC_N_BW_20ALL)? false : true; + } else { + WL_ERR(("Invalid channel Sepc. 0x%x.\n", c)); + continue; } for (j = 0; (j < *n_cnt && (*n_cnt < array_size)); j++) { if (band_chan_arr[j].hw_value == channel) { @@ -8377,6 +8453,8 @@ static void *wl_read_prof(struct wl_priv *wl, struct net_device *ndev, s32 item) break; case WL_PROF_SSID: rptr = &profile->ssid; + case WL_PROF_CHAN: + rptr = &profile->channel; break; } spin_unlock_irqrestore(&wl->cfgdrv_lock, flags); @@ -8423,6 +8501,8 @@ wl_update_prof(struct wl_priv *wl, struct net_device *ndev, case WL_PROF_DTIMPERIOD: profile->dtim_period = *(u8 *)data; break; + case WL_PROF_CHAN: + profile->channel = *(u32*)data; default: err = -EOPNOTSUPP; break; @@ -8607,17 +8687,44 @@ s32 wl_cfg80211_set_wps_p2p_ie(struct net_device *net, char *buf, int len, { struct wl_priv *wl; struct net_device *ndev = NULL; + struct ether_addr primary_mac; s32 ret = 0; s32 bssidx = 0; s32 pktflag = 0; wl = wlcfg_drv_priv; - if (wl->p2p && wl->p2p->vif_created) { - ndev = wl_to_p2p_bss_ndev(wl, P2PAPI_BSSCFG_CONNECTION); - bssidx = wl_to_p2p_bss_bssidx(wl, P2PAPI_BSSCFG_CONNECTION); - } else if (wl_get_drv_status(wl, AP_CREATING, net) || + + if (wl_get_drv_status(wl, AP_CREATING, net) || wl_get_drv_status(wl, AP_CREATED, net)) { ndev = net; bssidx = 0; + } else if (wl->p2p) { + if (net == wl->p2p_net) { + net = wl_to_prmry_ndev(wl); + } + if (!wl->p2p->on) { + get_primary_mac(wl, &primary_mac); + wl_cfgp2p_generate_bss_mac(&primary_mac, &wl->p2p->dev_addr, &wl->p2p->int_addr); + + /* In case of p2p_listen command, supplicant send remain_on_channel + * without turning on P2P + */ + + p2p_on(wl) = true; + ret = wl_cfgp2p_enable_discovery(wl, net, NULL, 0); + + if (unlikely(ret)) { + goto exit; + } + } + if (net != wl_to_prmry_ndev(wl)) { + if (wl_get_mode_by_netdev(wl, net) == WL_MODE_AP) { + ndev = wl_to_p2p_bss_ndev(wl, P2PAPI_BSSCFG_CONNECTION); + bssidx = wl_to_p2p_bss_bssidx(wl, P2PAPI_BSSCFG_CONNECTION); + } + } else { + ndev = wl_to_p2p_bss_ndev(wl, P2PAPI_BSSCFG_PRIMARY); + bssidx = wl_to_p2p_bss_bssidx(wl, P2PAPI_BSSCFG_DEVICE); + } } if (ndev != NULL) { switch (type) { @@ -8634,7 +8741,7 @@ s32 wl_cfg80211_set_wps_p2p_ie(struct net_device *net, char *buf, int len, if (pktflag) ret = wl_cfgp2p_set_management_ie(wl, ndev, bssidx, pktflag, buf, len); } - +exit: return ret; } diff --git a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.h b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.h index cc8e7e1..04bd49e 100644 --- a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.h +++ b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfg80211.h @@ -65,7 +65,7 @@ struct wl_ibss; #define WL_ERR(args) \ do { \ if (wl_dbg_level & WL_DBG_ERR) { \ - printk(KERN_ERR "CFG80211-INFO2) %s : ", __func__); \ + printk(KERN_INFO "CFG80211-INFO2) %s : ", __func__); \ printk args; \ } \ } while (0) @@ -75,7 +75,7 @@ do { \ #define WL_INFO(args) \ do { \ if (wl_dbg_level & WL_DBG_INFO) { \ - printk(KERN_ERR "CFG80211-INFO) %s : ", __func__); \ + printk(KERN_INFO "CFG80211-INFO) %s : ", __func__); \ printk args; \ } \ } while (0) @@ -85,7 +85,7 @@ do { \ #define WL_SCAN(args) \ do { \ if (wl_dbg_level & WL_DBG_SCAN) { \ - printk(KERN_ERR "CFG80211-SCAN) %s :", __func__); \ + printk(KERN_INFO "CFG80211-SCAN) %s :", __func__); \ printk args; \ } \ } while (0) @@ -95,7 +95,7 @@ do { \ #define WL_TRACE(args) \ do { \ if (wl_dbg_level & WL_DBG_TRACE) { \ - printk(KERN_ERR "CFG80211-TRACE) %s :", __func__); \ + printk(KERN_INFO "CFG80211-TRACE) %s :", __func__); \ printk args; \ } \ } while (0) @@ -103,7 +103,7 @@ do { \ #define WL_DBG(args) \ do { \ if (wl_dbg_level & WL_DBG_DBG) { \ - printk(KERN_ERR "CFG80211-DEBUG) %s :", __func__); \ + printk(KERN_DEBUG "CFG80211-DEBUG) %s :", __func__); \ printk args; \ } \ } while (0) @@ -116,7 +116,7 @@ do { \ #define WL_SCAN2(args) \ do { \ if (wl_dbg_level & WL_DBG_SCAN2) { \ - printk(KERN_ERR "CFG80211-SCAN) %s :", __func__); \ + printk(KERN_DEBUG "CFG80211-SCAN) %s :", __func__); \ printk args; \ } \ } while (0) @@ -193,6 +193,7 @@ enum wl_prof_list { WL_PROF_SEC, WL_PROF_IBSS, WL_PROF_BAND, + WL_PROF_CHAN, WL_PROF_BSSID, WL_PROF_ACT, WL_PROF_BEACONINT, @@ -292,6 +293,7 @@ struct wl_ibss { struct wl_profile { u32 mode; s32 band; + u32 channel; struct wlc_ssid ssid; struct wl_security sec; struct wl_ibss ibss; @@ -453,6 +455,7 @@ struct wl_priv { void *pub; u32 iface_cnt; u32 channel; /* current channel */ + s32 glom; #ifdef WL_CFG80211_SYNC_GON_TIME u32 af_sent_channel; /* channel action frame is sent */ /* save the next gon af subtype when it needs to wait more time for next gon af @@ -796,4 +799,5 @@ extern s32 wl_update_wiphybands(struct wl_priv *wl); extern s32 wl_cfg80211_scan_abort(struct wl_priv *wl, struct net_device *ndev); extern s32 wl_cfg80211_if_is_group_owner(void); +extern s32 wl_add_remove_eventmsg(struct net_device *ndev, u16 event, bool add); #endif /* _wl_cfg80211_h_ */ diff --git a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.c b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.c index f25cae4..fdc2ed8 100644 --- a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.c +++ b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.c @@ -41,20 +41,25 @@ #include <bcmutils.h> #include <bcmendian.h> #include <proto/ethernet.h> - +#include <dngl_stats.h> +#include <dhd.h> +#include <dhdioctl.h> +#include <wlioctl.h> +#include <dhd_cfg80211.h> #include <wl_cfg80211.h> #include <wl_cfgp2p.h> #include <wldev_common.h> #include <wl_android.h> static s8 scanparambuf[WLC_IOCTL_SMLEN]; - +static s8 g_mgmt_ie_buf[2048]; +extern struct wl_priv *wlcfg_drv_priv; static bool wl_cfgp2p_has_ie(u8 *ie, u8 **tlvs, u32 *tlvs_len, const u8 *oui, u32 oui_len, u8 type); -static s32 -wl_cfgp2p_vndr_ie(struct wl_priv *wl, struct net_device *ndev, s32 bssidx, s32 pktflag, - s8 *oui, s32 ie_id, s8 *data, s32 data_len, s32 delete); +static u32 +wl_cfgp2p_vndr_ie(struct wl_priv *wl, u8 *iebuf, s32 bssidx, s32 pktflag, + s8 *oui, s32 ie_id, s8 *data, s32 datalen, const s8* add_del_cmd); static int wl_cfgp2p_start_xmit(struct sk_buff *skb, struct net_device *ndev); static int wl_cfgp2p_do_ioctl(struct net_device *net, struct ifreq *ifr, int cmd); @@ -924,13 +929,17 @@ wl_cfgp2p_set_management_ie(struct wl_priv *wl, struct net_device *ndev, s32 bss s32 ret = BCME_OK; u32 pos; u8 *ie_buf; + u8 *curr_ie_buf = NULL; u8 *mgmt_ie_buf = NULL; u32 mgmt_ie_buf_len = 0; u32 *mgmt_ie_len = 0; + u32 del_add_ie_buf_len = 0; + u32 total_ie_buf_len = 0; u8 ie_id, ie_len; - u8 delete = 0; #define IE_TYPE(type, bsstype) (wl_to_p2p_bss_saved_ie(wl, bsstype).p2p_ ## type ## _ie) #define IE_TYPE_LEN(type, bsstype) (wl_to_p2p_bss_saved_ie(wl, bsstype).p2p_ ## type ## _ie_len) + memset(g_mgmt_ie_buf, 0, sizeof(g_mgmt_ie_buf)); + curr_ie_buf = g_mgmt_ie_buf; if (p2p_is_on(wl) && bssidx != -1) { if (bssidx == P2PAPI_BSSCFG_PRIMARY) bssidx = wl_to_p2p_bss_bssidx(wl, P2PAPI_BSSCFG_DEVICE); @@ -1020,7 +1029,6 @@ wl_cfgp2p_set_management_ie(struct wl_priv *wl, struct net_device *ndev, s32 bss goto exit; } pos = 0; - delete = 1; ie_buf = (u8 *) mgmt_ie_buf; while (pos < *mgmt_ie_len) { ie_id = ie_buf[pos++]; @@ -1030,12 +1038,14 @@ wl_cfgp2p_set_management_ie(struct wl_priv *wl, struct net_device *ndev, s32 bss wl_cfgp2p_is_p2p_ie(&ie_buf[pos-2], NULL, 0) || wl_cfgp2p_is_wfd_ie(&ie_buf[pos-2], NULL, 0) || wl_cfgp2p_is_customer_ie(&ie_buf[pos-2], NULL, 0))) { - CFGP2P_INFO(("DELELED ID : %d, Len : %d , OUI :" + CFGP2P_INFO(("DELETED ID : %d, Len : %d , OUI :" "%02x:%02x:%02x\n", ie_id, ie_len, ie_buf[pos], ie_buf[pos+1], ie_buf[pos+2])); - ret = wl_cfgp2p_vndr_ie(wl, ndev, bssidx, pktflag, + del_add_ie_buf_len = wl_cfgp2p_vndr_ie(wl, curr_ie_buf, bssidx, pktflag, ie_buf+pos, VNDR_SPEC_ELEMENT_ID, ie_buf+pos+3, - ie_len-3, delete); + ie_len-3, "del"); + curr_ie_buf += del_add_ie_buf_len; + total_ie_buf_len += del_add_ie_buf_len; } pos += ie_len; } @@ -1049,7 +1059,6 @@ wl_cfgp2p_set_management_ie(struct wl_priv *wl, struct net_device *ndev, s32 bss *mgmt_ie_len = vndr_ie_len; pos = 0; ie_buf = (u8 *) vndr_ie; - delete = 0; while (pos < vndr_ie_len) { ie_id = ie_buf[pos++]; ie_len = ie_buf[pos++]; @@ -1061,14 +1070,21 @@ wl_cfgp2p_set_management_ie(struct wl_priv *wl, struct net_device *ndev, s32 bss CFGP2P_INFO(("ADDED ID : %d, Len : %d , OUI :" "%02x:%02x:%02x\n", ie_id, ie_len, ie_buf[pos], ie_buf[pos+1], ie_buf[pos+2])); - ret = wl_cfgp2p_vndr_ie(wl, ndev, bssidx, pktflag, + del_add_ie_buf_len = wl_cfgp2p_vndr_ie(wl, curr_ie_buf, bssidx, pktflag, ie_buf+pos, VNDR_SPEC_ELEMENT_ID, ie_buf+pos+3, - ie_len-3, delete); + ie_len-3, "add"); + curr_ie_buf += del_add_ie_buf_len; + total_ie_buf_len += del_add_ie_buf_len; } pos += ie_len; } } - + if (total_ie_buf_len) { + ret = wldev_iovar_setbuf_bsscfg(ndev, "vndr_ie", g_mgmt_ie_buf, total_ie_buf_len, + wl->ioctl_buf, WLC_IOCTL_MAXLEN, bssidx, &wl->ioctl_buf_sync); + if (ret) + CFGP2P_ERR(("vndr ie set error : %d\n", ret)); + } } #undef IE_TYPE #undef IE_TYPE_LEN @@ -1203,15 +1219,13 @@ wl_cfgp2p_find_wfdie(u8 *parse, u32 len) } return NULL; } -static s32 -wl_cfgp2p_vndr_ie(struct wl_priv *wl, struct net_device *ndev, s32 bssidx, s32 pktflag, - s8 *oui, s32 ie_id, s8 *data, s32 data_len, s32 delete) +static u32 +wl_cfgp2p_vndr_ie(struct wl_priv *wl, u8 *iebuf, s32 bssidx, s32 pktflag, + s8 *oui, s32 ie_id, s8 *data, s32 datalen, const s8* add_del_cmd) { - s32 err = BCME_OK; - s32 buf_len; + vndr_ie_setbuf_t hdr; /* aligned temporary vndr_ie buffer header */ s32 iecount; - - vndr_ie_setbuf_t *ie_setbuf; + u32 data_offset; /* Validate the pktflag parameter */ if ((pktflag & ~(VNDR_IE_BEACON_FLAG | VNDR_IE_PRBRSP_FLAG | @@ -1221,36 +1235,34 @@ wl_cfgp2p_vndr_ie(struct wl_priv *wl, struct net_device *ndev, s32 bssidx, s32 p return -1; } - buf_len = sizeof(vndr_ie_setbuf_t) + data_len - 1; - ie_setbuf = (vndr_ie_setbuf_t *) kzalloc(buf_len, GFP_KERNEL); + /* Copy the vndr_ie SET command ("add"/"del") to the buffer */ + strncpy(hdr.cmd, add_del_cmd, VNDR_IE_CMD_LEN - 1); + hdr.cmd[VNDR_IE_CMD_LEN - 1] = '\0'; - CFGP2P_INFO((" ie_id : %02x, data length : %d\n", ie_id, data_len)); - if (!ie_setbuf) { - - CFGP2P_ERR(("Error allocating buffer for IE\n")); - return -ENOMEM; - } - if (delete) - strcpy(ie_setbuf->cmd, "del"); - else - strcpy(ie_setbuf->cmd, "add"); /* Buffer contains only 1 IE */ iecount = htod32(1); - memcpy((void *)&ie_setbuf->vndr_ie_buffer.iecount, &iecount, sizeof(int)); + memcpy((void *)&hdr.vndr_ie_buffer.iecount, &iecount, sizeof(s32)); pktflag = htod32(pktflag); - memcpy((void *)&ie_setbuf->vndr_ie_buffer.vndr_ie_list[0].pktflag, - &pktflag, sizeof(uint32)); - ie_setbuf->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.id = ie_id; - ie_setbuf->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.len - = (uchar)(data_len + VNDR_IE_MIN_LEN); - memcpy(ie_setbuf->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.oui, oui, 3); - memcpy(ie_setbuf->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.data, data, data_len); - err = wldev_iovar_setbuf_bsscfg(ndev, "vndr_ie", ie_setbuf, buf_len, - wl->ioctl_buf, WLC_IOCTL_MAXLEN, bssidx, &wl->ioctl_buf_sync); + memcpy((void *)&hdr.vndr_ie_buffer.vndr_ie_list[0].pktflag, &pktflag, + sizeof(u32)); + hdr.vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.id = ie_id; + hdr.vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.len = + (uint8) VNDR_IE_MIN_LEN + datalen; + + /* Add the IE OUI to the buffer */ + hdr.vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.oui[0] = oui[0]; + hdr.vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.oui[1] = oui[1]; + hdr.vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.oui[2] = oui[2]; + + /* Copy the aligned temporary vndr_ie buffer header to the IE buffer */ + memcpy(iebuf, &hdr, sizeof(hdr) - 1); + + data_offset = + (u8*)&hdr.vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.data[0] - + (u8*)&hdr; + memcpy(iebuf + data_offset, data, datalen); + return data_offset + datalen; - CFGP2P_INFO(("vndr_ie iovar returns %d\n", err)); - kfree(ie_setbuf); - return err; } /* @@ -1284,6 +1296,33 @@ wl_cfgp2p_find_idx(struct wl_priv *wl, struct net_device *ndev) exit: return index; } +s32 wl_cfgp2p_p2p_listen_suspend(void) +{ + struct wl_priv *wl = wlcfg_drv_priv; + bool enable = true; + s32 ret = BCME_OK; + s32 bssidx = -1; + struct net_device *netdev = wl_to_prmry_ndev(wl); + CFGP2P_ERR(("enter\n")); + if (wl == NULL || wl->p2p == NULL || netdev == NULL) + goto exit; + if (wl_get_p2p_status(wl, DISCOVERY_ON) == 0) + goto exit; + if (!timer_pending(&wl->p2p->listen_timer)) + goto exit; + bssidx = wl_to_p2p_bss_bssidx(wl, P2PAPI_BSSCFG_DEVICE); + if (bssidx) { + if (wl_to_p2p_bss_saved_ie(wl, bssidx).p2p_probe_res_ie_len) + enable = false; + + if ((ret = wl_add_remove_eventmsg(netdev, WLC_E_P2P_PROBREQ_MSG, enable)) != BCME_OK) { + CFGP2P_ERR((" failed to %s WLC_E_P2P_PROPREQ_MSG\n", enable? "set":"unset" )); + } + + } +exit: + return ret; +} /* * Callback function for WLC_E_P2P_DISC_LISTEN_COMPLETE */ @@ -1292,7 +1331,7 @@ wl_cfgp2p_listen_complete(struct wl_priv *wl, struct net_device *ndev, const wl_event_msg_t *e, void *data) { s32 ret = BCME_OK; - + struct net_device *netdev = wl_to_prmry_ndev(wl); CFGP2P_DBG((" Enter\n")); if (wl_get_p2p_status(wl, LISTEN_EXPIRED) == 0) { wl_set_p2p_status(wl, LISTEN_EXPIRED); @@ -1333,6 +1372,9 @@ wl_cfgp2p_listen_complete(struct wl_priv *wl, struct net_device *ndev, cfg80211_remain_on_channel_expired(ndev, wl->last_roc_id, &wl->remain_on_chan, wl->remain_on_chan_type, GFP_KERNEL); } + if (wl_add_remove_eventmsg(netdev, WLC_E_P2P_PROBREQ_MSG, false) != BCME_OK) { + CFGP2P_ERR((" failed to unset WLC_E_P2P_PROPREQ_MSG\n")); + } } else wl_clr_p2p_status(wl, LISTEN_EXPIRED); @@ -1374,6 +1416,10 @@ wl_cfgp2p_discover_listen(struct wl_priv *wl, s32 channel, u32 duration_ms) s32 ret = BCME_OK; struct timer_list *_timer; s32 extra_delay; + struct net_device *netdev = wl_to_prmry_ndev(wl); + dhd_pub_t *dhd = (dhd_pub_t *)(wl->pub); + bool enable = true; + s32 bssidx = wl_to_p2p_bss_bssidx(wl, P2PAPI_BSSCFG_DEVICE); CFGP2P_DBG((" Enter Listen Channel : %d, Duration : %d\n", channel, duration_ms)); if (unlikely(wl_get_p2p_status(wl, DISCOVERY_ON) == 0)) { @@ -1392,9 +1438,15 @@ wl_cfgp2p_discover_listen(struct wl_priv *wl, s32 channel, u32 duration_ms) else wl_clr_p2p_status(wl, LISTEN_EXPIRED); #endif /* not WL_CFG80211_VSDB_PRIORITIZE_SCAN_REQUEST */ - - ret = wl_cfgp2p_set_p2p_mode(wl, WL_P2P_DISC_ST_LISTEN, channel, (u16) duration_ms, - wl_to_p2p_bss_bssidx(wl, P2PAPI_BSSCFG_DEVICE)); + if (wl_to_p2p_bss_saved_ie(wl, bssidx).p2p_probe_res_ie_len && dhd && dhd->in_suspend) { + /* Clear WLC_E_P2P_PROBREQ_MSG in case of early suspend and p2p ie != 0 */ + enable = false; + } + + if (wl_add_remove_eventmsg(netdev, WLC_E_P2P_PROBREQ_MSG, enable) != BCME_OK) { + CFGP2P_ERR((" failed to set WLC_E_P2P_PROPREQ_MSG\n")); + } + ret = wl_cfgp2p_set_p2p_mode(wl, WL_P2P_DISC_ST_LISTEN, channel, (u16) duration_ms, bssidx); _timer = &wl->p2p->listen_timer; /* We will wait to receive WLC_E_P2P_DISC_LISTEN_COMPLETE from dongle , diff --git a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.h b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.h index ebc1030..348aeca 100644 --- a/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.h +++ b/drivers/net/wireless/bcmdhd/src/wl/sys/wl_cfgp2p.h @@ -123,21 +123,21 @@ enum wl_cfgp2p_status { #define CFGP2P_ERR(args) \ do { \ if (wl_dbg_level & WL_DBG_ERR) { \ - printk(KERN_ERR "CFGP2P-INFO2) %s : ", __func__); \ + printk(KERN_INFO "CFGP2P-INFO2) %s : ", __func__); \ printk args; \ } \ } while (0) #define CFGP2P_INFO(args) \ do { \ if (wl_dbg_level & WL_DBG_INFO) { \ - printk(KERN_ERR "CFGP2P-INFO) %s : ", __func__); \ + printk(KERN_INFO "CFGP2P-INFO) %s : ", __func__); \ printk args; \ } \ } while (0) #define CFGP2P_DBG(args) \ do { \ if (wl_dbg_level & WL_DBG_DBG) { \ - printk(KERN_ERR "CFGP2P-DEBUG) %s :", __func__); \ + printk(KERN_DEBUG "CFGP2P-DEBUG) %s :", __func__); \ printk args; \ } \ } while (0) @@ -221,6 +221,8 @@ wl_cfgp2p_find_idx(struct wl_priv *wl, struct net_device *ndev); extern s32 +wl_cfgp2p_p2p_listen_suspend(void); +extern s32 wl_cfgp2p_listen_complete(struct wl_priv *wl, struct net_device *ndev, const wl_event_msg_t *e, void *data); extern s32 diff --git a/drivers/rtc/rtc-max77686.c b/drivers/rtc/rtc-max77686.c index 955cc1a..4bf32eb 100644 --- a/drivers/rtc/rtc-max77686.c +++ b/drivers/rtc/rtc-max77686.c @@ -648,6 +648,8 @@ static void max77686_rtc_enable_wtsr(struct max77686_rtc_info *info, bool enable dev_info(info->dev, "%s: %s WTSR\n", __func__, enable ? "enable" : "disable"); + max77686_rtc_update(info, MAX77686_RTC_READ); + ret = max77686_update_reg(info->rtc, MAX77686_WTSR_SMPL_CNTL, val, mask); if (ret < 0) { dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n", @@ -673,6 +675,8 @@ static void max77686_rtc_enable_smpl(struct max77686_rtc_info *info, bool enable dev_info(info->dev, "%s: %s SMPL\n", __func__, enable ? "enable" : "disable"); + max77686_rtc_update(info, MAX77686_RTC_READ); + ret = max77686_update_reg(info->rtc, MAX77686_WTSR_SMPL_CNTL, val, mask); if (ret < 0) { dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n", @@ -681,10 +685,6 @@ static void max77686_rtc_enable_smpl(struct max77686_rtc_info *info, bool enable } max77686_rtc_update(info, MAX77686_RTC_WRITE); - - val = 0; - max77686_read_reg(info->rtc, MAX77686_WTSR_SMPL_CNTL, &val); - pr_info("%s: WTSR_SMPL(0x%02x)\n", __func__, val); } #endif /* MAX77686_RTC_WTSR_SMPL */ @@ -715,6 +715,8 @@ static int max77686_rtc_init_reg(struct max77686_rtc_info *info) data_alm2[RTC_WEEKDAY]); #endif + max77686_rtc_update(info, MAX77686_RTC_READ); + ret = max77686_read_reg(info->rtc, MAX77686_RTC_CONTROL, &buf); if (ret < 0) { dev_err(info->dev, "%s: fail to read control reg(%d)\n", @@ -722,12 +724,15 @@ static int max77686_rtc_init_reg(struct max77686_rtc_info *info) return ret; } + if (buf & (1 << MODEL24_SHIFT)) { + dev_info(info->dev, "%s: bypass init\n", __func__); + return ret; + } + /* Set RTC control register : Binary mode, 24hour mdoe */ data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); - info->rtc_24hr_mode = 1; - ret = max77686_bulk_write(info->rtc, MAX77686_RTC_CONTROLM, 2, data); if (ret < 0) { dev_err(info->dev, "%s: fail to write controlm reg(%d)\n", @@ -737,6 +742,18 @@ static int max77686_rtc_init_reg(struct max77686_rtc_info *info) max77686_rtc_update(info, MAX77686_RTC_WRITE); + /* Mask control register */ + max77686_rtc_update(info, MAX77686_RTC_READ); + + ret = max77686_update_reg(info->rtc, MAX77686_RTC_CONTROLM, 0x0, 0x3); + if (ret < 0) { + dev_err(info->dev, "%s: fail to mask CONTROLM reg(%d)\n", + __func__, ret); + return ret; + } + + max77686_rtc_update(info, MAX77686_RTC_WRITE); + /* If it's first boot, reset rtc to 1/1/2012 00:00:00(SUN) */ if (buf == 0) { dev_info(info->dev, "rtc init\n"); @@ -775,6 +792,7 @@ static int __devinit max77686_rtc_probe(struct platform_device *pdev) #if defined(CONFIG_RTC_ALARM_BOOT) info->irq2 = max77686->irq_base + MAX77686_RTCIRQ_RTCA2; #endif + info->rtc_24hr_mode = 1; platform_set_drvdata(pdev, info); @@ -861,6 +879,8 @@ static void max77686_rtc_shutdown(struct platform_device *pdev) for (i = 0; i < 3; i++) { max77686_rtc_enable_wtsr(info, false); + + max77686_rtc_update(info, MAX77686_RTC_READ); max77686_read_reg(info->rtc, MAX77686_WTSR_SMPL_CNTL, &val); pr_info("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val); if (val & WTSR_EN_MASK) diff --git a/drivers/sensor/lsm330dlc_gyro.c b/drivers/sensor/lsm330dlc_gyro.c index 1c48308..631730a 100644 --- a/drivers/sensor/lsm330dlc_gyro.c +++ b/drivers/sensor/lsm330dlc_gyro.c @@ -93,8 +93,8 @@ #define MIN_ST 175 #define MAX_ST 875 #define FIFO_TEST_WTM 0x1F -#define MIN_ZERO_RATE -1714 -#define MAX_ZERO_RATE 1714 /* 30*1000/17.5 */ +#define MIN_ZERO_RATE -3142 +#define MAX_ZERO_RATE 3142 /* 55*1000/17.5 */ /* max and min entry */ #define MAX_ENTRY 20 diff --git a/drivers/usb/gadget/f_mtp_samsung.c b/drivers/usb/gadget/f_mtp_samsung.c index aa58024..7f0dec8 100644 --- a/drivers/usb/gadget/f_mtp_samsung.c +++ b/drivers/usb/gadget/f_mtp_samsung.c @@ -94,11 +94,12 @@ /*-------------------------------------------------------------------------*/ #define MTPG_BULK_BUFFER_SIZE 4096 -#define INT_MAX_PACKET_SIZE 10 +#define MTPG_INTR_BUFFER_SIZE 28 /* number of rx and tx requests to allocate */ #define MTPG_RX_REQ_MAX 4 #define MTPG_MTPG_TX_REQ_MAX 4 +#define MTPG_INTR_REQ_MAX 5 /* ID for Microsoft MTP OS String */ #define MTPG_OS_STRING_ID 0xEE @@ -124,8 +125,10 @@ struct mtpg_dev { struct list_head tx_idle; struct list_head rx_idle; struct list_head rx_done; + struct list_head intr_idle; wait_queue_head_t read_wq; wait_queue_head_t write_wq; + wait_queue_head_t intr_wq; struct usb_request *read_req; unsigned char *read_buf; @@ -134,7 +137,6 @@ struct mtpg_dev { struct usb_ep *bulk_in; struct usb_ep *bulk_out; struct usb_ep *int_in; - struct usb_request *notify_req; atomic_t read_excl; atomic_t write_excl; @@ -192,8 +194,8 @@ static struct usb_endpoint_descriptor int_fs_notify_desc = { .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_INT, - .wMaxPacketSize = __constant_cpu_to_le16(64), - .bInterval = 0x04, + .wMaxPacketSize = __constant_cpu_to_le16(MTPG_INTR_BUFFER_SIZE), + .bInterval = 6, }; static struct usb_descriptor_header *fs_mtpg_desc[] = { @@ -228,8 +230,8 @@ static struct usb_endpoint_descriptor int_hs_notify_desc = { .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_INT, - .wMaxPacketSize = __constant_cpu_to_le16(64), - .bInterval = INT_MAX_PACKET_SIZE + 4, + .wMaxPacketSize = __constant_cpu_to_le16(MTPG_INTR_BUFFER_SIZE), + .bInterval = 6, }; static struct usb_descriptor_header *hs_mtpg_desc[] = { @@ -434,6 +436,13 @@ static int mtp_send_signal(int value) info.si_code = SI_QUEUE; info.si_int = value; rcu_read_lock(); + + if (!current->nsproxy) { + printk(KERN_DEBUG "process has gone\n"); + rcu_read_unlock(); + return -ENODEV; + } + t = pid_task(find_vpid(mtp_pid), PIDTYPE_PID); if (t == NULL) { printk(KERN_DEBUG "no such pid\n"); @@ -710,34 +719,37 @@ static ssize_t interrupt_write(struct file *fd, int ret; DEBUG_MTPB("[%s] \tline = [%d]\n", __func__, __LINE__); - req = dev->notify_req; + + if (count > MTPG_INTR_BUFFER_SIZE) + return -EINVAL; + + ret = wait_event_interruptible_timeout(dev->intr_wq, + (req = mtpg_req_get(dev, &dev->intr_idle)), + msecs_to_jiffies(1000)); if (!req) { printk(KERN_ERR "[%s]Alloc has failed\n", __func__); return -ENOMEM; } - if (_lock(&dev->wintfd_excl)) { - printk(KERN_ERR "write failed on interrupt endpoint\n"); - return -EBUSY; - } - if (copy_from_user(req->buf, buf, count)) { + mtpg_req_put(dev, &dev->intr_idle, req); printk(KERN_ERR "[%s]copy from user has failed\n", __func__); return -EIO; } req->length = count; - req->complete = interrupt_complete; + /*req->complete = interrupt_complete;*/ ret = usb_ep_queue(dev->int_in, req, GFP_ATOMIC); - if (ret < 0) { - printk(KERN_ERR "[%s]usb_ep_queue failed\n", __func__); - return -EIO; + if (ret) { + printk(KERN_ERR "[%s:%d]\n", __func__, __LINE__); + mtpg_req_put(dev, &dev->intr_idle, req); } - _unlock(&dev->wintfd_excl); + DEBUG_MTPB("[%s] \tline = [%d] returning ret is %d\\n", + __func__, __LINE__, ret); return ret; } @@ -797,7 +809,7 @@ static long mtpg_ioctl(struct file *fd, unsigned int code, unsigned long arg) status = usb_ep_clear_halt(dev->bulk_out); break; case MTP_WRITE_INT_DATA: - printk(KERN_INFO "[%s]\t%d MTP intrpt_Write\n", + printk(KERN_INFO "[%s]\t%d MTP intrpt_Write no slep\n", __func__, __LINE__); ret_value = interrupt_write(fd, (const char *)arg, MTP_MAX_PACKET_LEN_FROM_APP); @@ -1009,6 +1021,19 @@ static void mtpg_complete_out(struct usb_ep *ep, struct usb_request *req) wake_up(&dev->read_wq); } +static void mtpg_complete_intr(struct usb_ep *ep, struct usb_request *req) +{ + struct mtpg_dev *dev = the_mtpg; + /*printk(KERN_INFO "[%s]\tline = [%d]\n", __func__, __LINE__);*/ + + if (req->status != 0) + dev->error = 1; + + mtpg_req_put(dev, &dev->intr_idle, req); + + wake_up(&dev->intr_wq); +} + static void mtpg_function_unbind(struct usb_configuration *c, struct usb_function *f) { @@ -1022,6 +1047,9 @@ mtpg_function_unbind(struct usb_configuration *c, struct usb_function *f) while ((req = mtpg_req_get(dev, &dev->tx_idle))) mtpg_request_free(req, dev->bulk_in); + + while ((req = mtpg_req_get(dev, &dev->intr_idle))) + mtpg_request_free(req, dev->int_in); } static int @@ -1075,12 +1103,13 @@ mtpg_function_bind(struct usb_configuration *c, struct usb_function *f) mtpg->int_in = ep; the_mtpg->int_in = ep; - mtpg->notify_req = alloc_ep_req(ep, - sizeof(struct usb_mtp_ctrlrequest) + 2, - GFP_ATOMIC); - if (!mtpg->notify_req) - goto out; - + for (i = 0; i < MTPG_INTR_REQ_MAX; i++) { + req = mtpg_request_new(mtpg->int_in, MTPG_INTR_BUFFER_SIZE); + if (!req) + goto out; + req->complete = mtpg_complete_intr; + mtpg_req_put(mtpg, &mtpg->intr_idle, req); + } for (i = 0; i < MTPG_RX_REQ_MAX; i++) { req = mtpg_request_new(mtpg->bulk_out, MTPG_BULK_BUFFER_SIZE); if (!req) @@ -1110,7 +1139,6 @@ mtpg_function_bind(struct usb_configuration *c, struct usb_function *f) int_hs_notify_desc.bEndpointAddress = int_fs_notify_desc.bEndpointAddress; - f->hs_descriptors = hs_mtpg_desc; } mtpg->cdev = cdev; @@ -1402,6 +1430,7 @@ static int mtp_setup(void) } spin_lock_init(&mtpg->lock); + init_waitqueue_head(&mtpg->intr_wq); init_waitqueue_head(&mtpg->read_wq); init_waitqueue_head(&mtpg->write_wq); @@ -1413,6 +1442,7 @@ static int mtp_setup(void) INIT_LIST_HEAD(&mtpg->rx_idle); INIT_LIST_HEAD(&mtpg->rx_done); INIT_LIST_HEAD(&mtpg->tx_idle); + INIT_LIST_HEAD(&mtpg->intr_idle); /* the_mtpg must be set before calling usb_gadget_register_driver */ the_mtpg = mtpg; diff --git a/drivers/video/samsung/Kconfig b/drivers/video/samsung/Kconfig index 10d7474..3cb946f 100644 --- a/drivers/video/samsung/Kconfig +++ b/drivers/video/samsung/Kconfig @@ -154,7 +154,7 @@ config FB_S5P_S6F1202A config FB_S5P_LD9040 bool "LD9040" - depends on MACH_U1 || MACH_MIDAS + depends on MACH_U1 || MACH_MIDAS || MACH_TRATS select LCD_CLASS_DEVICE select SPI select SPI_GPIO @@ -164,7 +164,7 @@ config FB_S5P_LD9040 config FB_S5P_NT35560 bool "Sony NT35560" - depends on MACH_U1 && !FB_S5P_MIPI_DSIM + depends on (MACH_U1 || MACH_TRATS) && !FB_S5P_MIPI_DSIM select LCD_CLASS_DEVICE select SPI select SPI_GPIO @@ -188,13 +188,13 @@ config FB_S5P_DUMMY_MIPI_LCD config FB_S5P_S6E8AA0 bool "S6E8AA0 MIPI LCD" - depends on (MACH_U1 || MACH_MIDAS) && FB_S5P_MIPI_DSIM + depends on FB_S5P_MIPI_DSIM ---help--- This enables support for Samsung S6E8AA0 MIPI LCD config FB_S5P_S6E8AB0 bool "S6E8AB0 MIPI LCD" - depends on MACH_P8 && FB_S5P_MIPI_DSIM + depends on MACH_PX && FB_S5P_MIPI_DSIM ---help--- This enables support for Samsung S6E8AB0 MIPI LCD @@ -203,6 +203,30 @@ config FB_S5P_S6D6AA1 depends on FB_S5P_MIPI_DSIM ---help--- This enables support for Samsung S6D6AA1 MIPI LCD + +config FB_S5P_S6E63M0 + bool "S6E63M0 MIPI LCD" + depends on (MACH_MIDAS) && FB_S5P_MIPI_DSIM + ---help--- + This enables support for Samsung S6E63M0 MIPI LCD + +endchoice + +choice + prompt "Select PANEL Type" + depends on FB_S5P_S6E8AA0 + default S6E8AA0_AMS480GYXX + +config S6E8AA0_AMS529HA01 + bool "AMS529HA01(Q1)" + ---help--- + This enables support for Samsung S6E8AA0 AMS529HA01(Q1) PANEL + +config S6E8AA0_AMS480GYXX + bool "AMS480GYXX(M0)" + ---help--- + This enables support for Samsung S6E8AA0 AMS480GYXX(M0) PANEL + endchoice config AID_DIMMING diff --git a/drivers/video/samsung/lcdfreq.c b/drivers/video/samsung/lcdfreq.c index 6895bf8..8c25c22 100644 --- a/drivers/video/samsung/lcdfreq.c +++ b/drivers/video/samsung/lcdfreq.c @@ -50,12 +50,7 @@ struct lcdfreq_info { struct notifier_block pm_noti; struct notifier_block reboot_noti; - unsigned long time_stamp[LCDFREQ_LEVEL_END]; - unsigned long previous_time; - unsigned long current_time; - struct delayed_work work; - u32 count; struct early_suspend early_suspend; }; @@ -108,7 +103,7 @@ int set_div(struct s3cfb_global *ctrl, u32 div) } while (count); /* } while (time_before(jiffies, timeout)); */ - dev_err(ctrl->dev, "%s fail\n", __func__); + dev_err(ctrl->dev, "%s fail, div=%d\n", __func__, div); return -EINVAL; } @@ -121,11 +116,12 @@ static int set_lcdfreq_div(struct device *dev, enum lcdfreq_level_idx level) struct lcdfreq_info *lcdfreq = fbdev->data; - u32 div = 0, ret = 0; + u32 div, ret; mutex_lock(&lcdfreq->lock); if (unlikely(fbdev->system_state == POWER_OFF || !lcdfreq->enable)) { + dev_err(dev, "%s reject. %d, %d\n", __func__, fbdev->system_state, lcdfreq->enable); ret = -EINVAL; goto exit; } @@ -135,7 +131,7 @@ static int set_lcdfreq_div(struct device *dev, enum lcdfreq_level_idx level) ret = set_div(fbdev, div); if (ret) { - dev_info(dev, "fail to change lcd freq\n"); + dev_err(dev, "fail to change lcd freq\n"); goto exit; } @@ -193,7 +189,6 @@ static int lcdfreq_lock_free(struct device *dev) mutex_lock(&lcdfreq->lock); atomic_dec(&lcdfreq->usage); mutex_unlock(&lcdfreq->lock); - lcdfreq->count = 0; cancel_delayed_work(&lcdfreq->work); } @@ -229,7 +224,7 @@ int get_divider(struct fb_info *fb) for (i = 0; i < LCDFREQ_LEVEL_END; i++) { lcdfreq->table[i].cmu_clkdiv--; - dev_info(fb->dev, "%dHz divider is %d\n", + dev_info(fb->dev, "%dHZ divider is %d\n", lcdfreq->table[i].hz, lcdfreq->table[i].cmu_clkdiv); } @@ -256,6 +251,11 @@ static ssize_t level_show(struct device *dev, struct s3cfb_global *fbdev = get_fimd_global(win->id); struct lcdfreq_info *lcdfreq = fbdev->data; + if (unlikely(fbdev->system_state == POWER_OFF || !lcdfreq->enable)) { + dev_err(dev, "%s reject. %d, %d\n", __func__, fbdev->system_state, lcdfreq->enable); + return -EINVAL; + } + return sprintf(buf, "%dHZ, div=%d\n", lcdfreq->table[lcdfreq->level].hz, get_div(fbdev)); } @@ -298,12 +298,10 @@ static ssize_t usage_show(struct device *dev, static DEVICE_ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store); static DEVICE_ATTR(usage, S_IRUGO, usage_show, NULL); -static DEVICE_ATTR(time_stamp, S_IRUGO, NULL, NULL); static struct attribute *lcdfreq_attributes[] = { &dev_attr_level.attr, &dev_attr_usage.attr, - &dev_attr_time_stamp.attr, NULL, }; @@ -390,17 +388,13 @@ static void lcdfreq_status_work(struct work_struct *work) struct lcdfreq_info *lcdfreq = container_of(work, struct lcdfreq_info, work.work); - u32 hz = lcdfreq->table[lcdfreq->level].hz; cancel_delayed_work(&lcdfreq->work); - if (!(lcdfreq->count % 2)) - dev_info(lcdfreq->dev, "\thz=%d, usage=%d\n", hz, atomic_read(&lcdfreq->usage)); - - schedule_delayed_work(&lcdfreq->work, HZ*60); + dev_info(lcdfreq->dev, "\tHZ=%d, usage=%d\n", hz, atomic_read(&lcdfreq->usage)); - lcdfreq->count++; + schedule_delayed_work(&lcdfreq->work, HZ*120); } int lcdfreq_init(struct fb_info *fb) @@ -425,7 +419,6 @@ int lcdfreq_init(struct fb_info *fb) lcdfreq->dev = fb->dev; lcdfreq->level = LEVEL_NORMAL; - lcdfreq->previous_time = lcdfreq->current_time = jiffies; vclk = (lcd->freq * (var->left_margin + var->right_margin diff --git a/drivers/video/samsung/mdnie.c b/drivers/video/samsung/mdnie.c index bb672bd..d45d3e9 100644 --- a/drivers/video/samsung/mdnie.c +++ b/drivers/video/samsung/mdnie.c @@ -48,6 +48,8 @@ #else /* CONFIG_CPU_EXYNOS4210 */ #if defined(CONFIG_FB_S5P_S6E8AA0) #include "mdnie_table_c1m0.h" +#elif defined(CONFIG_FB_S5P_S6E63M0) +#include "mdnie_table_c1m0.h" #elif defined(CONFIG_FB_S5P_S6C1372) #include "mdnie_table_p4note.h" #elif defined(CONFIG_FB_S5P_S6D6AA1) @@ -72,7 +74,7 @@ #define DIM_BACKLIGHT_VALUE 16 #define CABC_CUTOFF_BACKLIGHT_VALUE 40 /* 2.5% */ #elif defined(CONFIG_FB_S5P_S6C1372) -#define MAX_BACKLIGHT_VALUE 1329 +#define MAX_BACKLIGHT_VALUE 1441 //90% #define MID_BACKLIGHT_VALUE 784 #define LOW_BACKLIGHT_VALUE 16 #define DIM_BACKLIGHT_VALUE 16 @@ -104,15 +106,16 @@ struct class *mdnie_class; struct mdnie_info *g_mdnie; +#ifdef CONFIG_MACH_P4NOTE +static struct mdnie_backlight_value b_value; +#endif + int mdnie_send_sequence(struct mdnie_info *mdnie, const unsigned short *seq) { int ret = 0, i = 0; const unsigned short *wbuf; - if (!mdnie->enable) { - dev_err(mdnie->dev, "do not configure mDNIe after LCD/mDNIe power off\n"); - return -EPERM; - } else if (IS_ERR_OR_NULL(seq)) { + if (IS_ERR_OR_NULL(seq)) { dev_err(mdnie->dev, "mdnie sequence is null\n"); return -EPERM; } @@ -135,12 +138,12 @@ int mdnie_send_sequence(struct mdnie_info *mdnie, const unsigned short *seq) return ret; } -void set_mdnie_value(struct mdnie_info *mdnie) +void set_mdnie_value(struct mdnie_info *mdnie, u8 force) { u8 idx; - if (!mdnie->enable) { - dev_err(mdnie->dev, "do not configure mDNIe after LCD/mDNIe power off\n"); + if ((!mdnie->enable) && (!force)) { + dev_err(mdnie->dev, "mdnie states is off\n"); return; } @@ -152,7 +155,7 @@ void set_mdnie_value(struct mdnie_info *mdnie) mdnie->tone = TONE_NORMAL; if (mdnie->tunning) { - dev_info(mdnie->dev, "mDNIe tunning mode is enabled\n"); + dev_info(mdnie->dev, "mdnie tunning mode is enabled\n"); return; } @@ -200,7 +203,9 @@ void set_mdnie_value(struct mdnie_info *mdnie) tunning_table[mdnie->cabc][mdnie->mode][mdnie->scenario].name); } +#if defined(CONFIG_TDMB) || defined(CONFIG_TARGET_LOCALE_NTT) etc: +#endif if (!IS_ERR_OR_NULL(etc_table[mdnie->cabc][mdnie->outdoor][mdnie->tone].seq)) { mdnie_send_sequence(mdnie, etc_table[mdnie->cabc][mdnie->outdoor][mdnie->tone].seq); dev_info(mdnie->dev, "%s\n", etc_table[mdnie->cabc][mdnie->outdoor][mdnie->tone].name); @@ -213,6 +218,34 @@ exit: } #if defined(CONFIG_FB_MDNIE_PWM) +#ifdef CONFIG_MACH_P4NOTE +static int get_backlight_level_from_brightness(unsigned int brightness) +{ + unsigned int value; + + /* brightness tuning*/ + if (brightness >= MID_BRIGHTNESS_LEVEL) + value = (brightness - MID_BRIGHTNESS_LEVEL) * (b_value.max-b_value.mid) / (MAX_BRIGHTNESS_LEVEL-MID_BRIGHTNESS_LEVEL) + b_value.mid; + else if (brightness >= LOW_BRIGHTNESS_LEVEL) + value = (brightness - LOW_BRIGHTNESS_LEVEL) * (b_value.mid-b_value.low) / (MID_BRIGHTNESS_LEVEL-LOW_BRIGHTNESS_LEVEL) + b_value.low; + else if (brightness >= DIM_BRIGHTNESS_LEVEL) + value = (brightness - DIM_BRIGHTNESS_LEVEL) * (b_value.low-b_value.dim) / (LOW_BRIGHTNESS_LEVEL-DIM_BRIGHTNESS_LEVEL) + b_value.dim; + else if (brightness > 0) + value = b_value.dim; + else + return 0; + + if (value > 1600) + value = 1600; + + if (value < 16) + value = 1; + else + value = value >> 4; + + return value; +} +#else static int get_backlight_level_from_brightness(unsigned int brightness) { unsigned int value; @@ -227,7 +260,7 @@ static int get_backlight_level_from_brightness(unsigned int brightness) else if (brightness > 0) value = DIM_BACKLIGHT_VALUE; else - value = brightness; + return 0; if (value > 1600) value = 1600; @@ -239,6 +272,7 @@ static int get_backlight_level_from_brightness(unsigned int brightness) return value; } +#endif #if defined(CONFIG_CPU_EXYNOS4210) static void mdnie_pwm_control(struct mdnie_info *mdnie, int value) @@ -283,8 +317,7 @@ static void mdnie_pwm_control_cabc(struct mdnie_info *mdnie, int value) mutex_unlock(&mdnie->dev_lock); } -#endif -#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) +#elif defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) static void mdnie_pwm_control(struct mdnie_info *mdnie, int value) { mutex_lock(&mdnie->dev_lock); @@ -329,6 +362,11 @@ static void mdnie_pwm_control_cabc(struct mdnie_info *mdnie, int value) } #endif +void set_mdnie_pwm_value(struct mdnie_info *mdnie, int value) +{ + mdnie_pwm_control(mdnie, value); +} + static int update_brightness(struct mdnie_info *mdnie) { unsigned int value; @@ -413,7 +451,7 @@ static ssize_t mode_store(struct device *dev, mdnie->mode = value; mutex_unlock(&mdnie->lock); - set_mdnie_value(mdnie); + set_mdnie_value(mdnie, 0); #if defined(CONFIG_FB_MDNIE_PWM) if ((mdnie->enable) && (mdnie->bd_enable)) update_brightness(mdnie); @@ -454,7 +492,7 @@ static ssize_t scenario_store(struct device *dev, mdnie->scenario = value; mutex_unlock(&mdnie->lock); - set_mdnie_value(mdnie); + set_mdnie_value(mdnie, 0); #if defined(CONFIG_FB_MDNIE_PWM) if ((mdnie->enable) && (mdnie->bd_enable)) update_brightness(mdnie); @@ -492,7 +530,7 @@ static ssize_t outdoor_store(struct device *dev, mdnie->outdoor = value; mutex_unlock(&mdnie->lock); - set_mdnie_value(mdnie); + set_mdnie_value(mdnie, 0); return count; } @@ -527,7 +565,7 @@ static ssize_t cabc_store(struct device *dev, mdnie->cabc = value; mutex_unlock(&mdnie->lock); - set_mdnie_value(mdnie); + set_mdnie_value(mdnie, 0); if ((mdnie->enable) && (mdnie->bd_enable)) update_brightness(mdnie); @@ -609,7 +647,7 @@ static ssize_t negative_store(struct device *dev, mdnie->negative = value; mutex_unlock(&mdnie->lock); - set_mdnie_value(mdnie); + set_mdnie_value(mdnie, 0); } return count; } @@ -756,6 +794,22 @@ static int mdnie_probe(struct platform_device *pdev) #endif #endif +#if defined(CONFIG_FB_S5P_S6C1372) + check_lcd_type(); + dev_info(mdnie->dev, "lcdtype = %d\n", pdata->display_type); + if (pdata->display_type == 1) { + b_value.max = 1441; + b_value.mid = 784; + b_value.low = 16; + b_value.dim = 16; + } else { + b_value.max = 1137; /* 71% */ + b_value.mid = 482; /* 38% */ + b_value.low = 16; /* 1% */ + b_value.dim = 16; /* 1% */ + } +#endif + #if defined(CONFIG_FB_S5P_S6F1202A) if (pdata->display_type == 0) { memcpy(tunning_table, tunning_table_hy, sizeof(tunning_table)); @@ -777,7 +831,7 @@ static int mdnie_probe(struct platform_device *pdev) g_mdnie = mdnie; - set_mdnie_value(mdnie); + set_mdnie_value(mdnie, 0); dev_info(mdnie->dev, "registered successfully\n"); diff --git a/drivers/video/samsung/mdnie.h b/drivers/video/samsung/mdnie.h index f5098aa..4c37418 100644 --- a/drivers/video/samsung/mdnie.h +++ b/drivers/video/samsung/mdnie.h @@ -111,7 +111,18 @@ struct mdnie_info { extern struct mdnie_info *g_mdnie; int mdnie_send_sequence(struct mdnie_info *mdnie, const unsigned short *seq); -extern void set_mdnie_value(struct mdnie_info *mdnie); +extern void set_mdnie_value(struct mdnie_info *mdnie, u8 force); +#if defined(CONFIG_FB_MDNIE_PWM) +extern void set_mdnie_pwm_value(struct mdnie_info *mdnie, int value); +#endif extern int mdnie_txtbuf_to_parsing(char const *pFilepath); +extern void check_lcd_type(void); +struct mdnie_backlight_value { + unsigned int max; + unsigned int mid; + unsigned char low; + unsigned char dim; +}; + #endif /* __MDNIE_H__ */ diff --git a/drivers/video/samsung/s3cfb.h b/drivers/video/samsung/s3cfb.h index 8f38995..fc4e10d 100644 --- a/drivers/video/samsung/s3cfb.h +++ b/drivers/video/samsung/s3cfb.h @@ -167,6 +167,7 @@ struct s3cfb_global { void __iomem *ielcd_regs; void *data; struct mutex lock; + spinlock_t slock; struct device *dev; #ifdef CONFIG_BUSFREQ_OPP struct device *bus_dev; @@ -327,6 +328,7 @@ extern int s3cfb_set_window_control(struct s3cfb_global *ctrl, int id); extern int s3cfb_set_alpha_mode(struct s3cfb_global *ctrl, int id, unsigned int mode); extern int s3cfb_set_alpha_value_width(struct s3cfb_global *ctrl, int id); extern int s3cfb_set_alpha_blending(struct s3cfb_global *ctrl, int id); +extern int s3cfb_set_oneshot(struct s3cfb_global *ctrl, int value); extern int s3cfb_set_alpha_value(struct s3cfb_global *ctrl, int value); extern int s3cfb_set_window_position(struct s3cfb_global *ctrl, int id); extern int s3cfb_set_window_size(struct s3cfb_global *ctrl, int id); @@ -336,12 +338,11 @@ extern int s3cfb_set_buffer_size(struct s3cfb_global *ctrl, int id); extern int s3cfb_set_chroma_key(struct s3cfb_global *ctrl, int id); extern int s3cfb_channel_localpath_on(struct s3cfb_global *ctrl, int id); extern int s3cfb_channel_localpath_off(struct s3cfb_global *ctrl, int id); -#ifdef CONFIG_FB_S5P_MIPI_DSIM -extern void s3cfb_set_trigger(struct s3cfb_global *ctrl); -extern void s3cfb_trigger(void); -#endif extern int s3cfb_check_vsync_status(struct s3cfb_global *ctrl); +extern int s3cfb_set_dualrgb(struct s3cfb_global *ctrl, int mode); +#ifdef CONFIG_FB_S5P_MIPI_DSIM extern int s3cfb_vsync_status_check(void); +#endif #ifdef CONFIG_HAS_WAKELOCK #ifdef CONFIG_HAS_EARLYSUSPEND @@ -356,11 +357,16 @@ extern void s3cfb_set_lcd_info(struct s3cfb_global *ctrl); #ifdef CONFIG_FB_S5P_MIPI_DSIM extern void s5p_dsim_early_suspend(void); extern void s5p_dsim_late_resume(void); +#ifdef CONFIG_FB_S5P_S6E63M0 +extern void s6e63m0_early_suspend(void); +extern void s6e63m0_late_resume(void); +#else extern void s6e8ax0_early_suspend(void); extern void s6e8ax0_late_resume(void); +#endif extern int s5p_dsim_fifo_clear(void); extern void set_dsim_hs_clk_toggle_count(u8 count); -extern void set_dsim_lcd_enabled(void); +extern void set_dsim_lcd_enabled(u8 enable); extern u32 read_dsim_register(u32 num); #endif @@ -374,7 +380,7 @@ extern void ams369fg06_gpio_cfg(void); extern void lms501kf03_ldi_disable(void); #endif -#if defined(CONFIG_FB_S5P_S6C1372) +#if defined(CONFIG_FB_S5P_S6C1372) || defined(CONFIG_FB_S5P_S6F1202A) extern void s5c1372_ldi_enable(void); extern void s5c1372_ldi_disable(void); #endif diff --git a/drivers/video/samsung/s3cfb_fimd6x.c b/drivers/video/samsung/s3cfb_fimd6x.c index 3813852..71a24ae 100644 --- a/drivers/video/samsung/s3cfb_fimd6x.c +++ b/drivers/video/samsung/s3cfb_fimd6x.c @@ -41,7 +41,14 @@ void s3cfb_check_line_count(struct s3cfb_global *ctrl) int s3cfb_check_vsync_status(struct s3cfb_global *ctrl) { - u32 cfg = (readl(ctrl->regs + S3C_VIDCON1) & S3C_VIDCON1_VSTATUS_MASK); + u32 cfg; + + if (unlikely(!ctrl->regs)) { + dev_err(ctrl->dev, "reg is zero\n"); + return 0; + } + + cfg = (readl(ctrl->regs + S3C_VIDCON1) & S3C_VIDCON1_VSTATUS_MASK); if (cfg != S3C_VIDCON1_VSTATUS_ACTIVE && cfg != S3C_VIDCON1_VSTATUS_BACK) return 1; @@ -794,6 +801,76 @@ int s3cfb_set_alpha_blending(struct s3cfb_global *ctrl, int id) return 0; } +int s3cfb_set_oneshot(struct s3cfb_global *ctrl, int id) +{ + struct s3c_platform_fb *pdata = to_fb_plat(ctrl->dev); + struct fb_var_screeninfo *var = &ctrl->fb[id]->var; + struct fb_fix_screeninfo *fix = &ctrl->fb[id]->fix; + struct s3cfb_window *win = ctrl->fb[id]->par; + u32 cfg, shw; + u32 offset = (var->xres_virtual - var->xres) * var->bits_per_pixel / 8; + dma_addr_t start_addr = 0, end_addr = 0; + + /* Shadow Register Protection */ + if ((pdata->hw_ver == 0x62) || (pdata->hw_ver == 0x70)) { + shw = readl(ctrl->regs + S3C_WINSHMAP); + shw |= S3C_WINSHMAP_PROTECT(id); + writel(shw, ctrl->regs + S3C_WINSHMAP); + } + + /* s3cfb_set_window_position */ + cfg = S3C_VIDOSD_LEFT_X(win->x) | S3C_VIDOSD_TOP_Y(win->y); + writel(cfg, ctrl->regs + S3C_VIDOSD_A(id)); + + cfg = S3C_VIDOSD_RIGHT_X(win->x + var->xres - 1) | + S3C_VIDOSD_BOTTOM_Y(win->y + var->yres - 1); + writel(cfg, ctrl->regs + S3C_VIDOSD_B(id)); + + dev_dbg(ctrl->dev, "[fb%d] offset: (%d, %d, %d, %d)\n", id, + win->x, win->y, win->x + var->xres - 1, win->y + var->yres - 1); + + /* s3cfb_set_buffer_address */ + if (fix->smem_start) { + start_addr = fix->smem_start + ((var->xres_virtual * + var->yoffset + var->xoffset) * + (var->bits_per_pixel / 8)); + + end_addr = start_addr + fix->line_length * var->yres; + } + + writel(start_addr, ctrl->regs + S3C_VIDADDR_START0(id)); + writel(end_addr, ctrl->regs + S3C_VIDADDR_END0(id)); + + dev_dbg(ctrl->dev, "[fb%d] start_addr: 0x%08x, end_addr: 0x%08x\n", + id, start_addr, end_addr); + + /* s3cfb_set_window_size */ + if (id <= 2) { + cfg = S3C_VIDOSD_SIZE(var->xres * var->yres); + if (id == 0) + writel(cfg, ctrl->regs + S3C_VIDOSD_C(id)); + else + writel(cfg, ctrl->regs + S3C_VIDOSD_D(id)); + + dev_dbg(ctrl->dev, "[fb%d] resolution: %d x %d\n", id, + var->xres, var->yres); + } + + /* s3cfb_set_buffer_size */ + cfg = S3C_VIDADDR_PAGEWIDTH(var->xres * var->bits_per_pixel / 8); + cfg |= S3C_VIDADDR_OFFSIZE(offset); + writel(cfg, ctrl->regs + S3C_VIDADDR_SIZE(id)); + + /* Shadow Register Un-Protection */ + if ((pdata->hw_ver == 0x62) || (pdata->hw_ver == 0x70)) { + shw = readl(ctrl->regs + S3C_WINSHMAP); + shw &= ~(S3C_WINSHMAP_PROTECT(id)); + writel(shw, ctrl->regs + S3C_WINSHMAP); + } + + return 0; +} + int s3cfb_set_window_position(struct s3cfb_global *ctrl, int id) { struct fb_var_screeninfo *var = &ctrl->fb[id]->var; @@ -911,3 +988,11 @@ int s3cfb_set_chroma_key(struct s3cfb_global *ctrl, int id) return 0; } + +int s3cfb_set_dualrgb(struct s3cfb_global *ctrl, int mode) +{ + writel(mode, ctrl->regs + S3C_DUALRGB); + + return 0; +} + diff --git a/drivers/video/samsung/s3cfb_ielcd.c b/drivers/video/samsung/s3cfb_ielcd.c index 9550327..b86d6f5 100644 --- a/drivers/video/samsung/s3cfb_ielcd.c +++ b/drivers/video/samsung/s3cfb_ielcd.c @@ -78,7 +78,7 @@ int s3c_ielcd_logic_stop(void) return 0; } -int s3c_ielcd_start(void) +int s3c_ielcd_display_on(void) { unsigned int cfg; @@ -90,7 +90,7 @@ int s3c_ielcd_start(void) } #if 0 -int s3c_ielcd_stop(void) +int s3c_ielcd_display_off(void) { unsigned int cfg; @@ -102,13 +102,13 @@ int s3c_ielcd_stop(void) return 0; } #else -int s3c_ielcd_stop(void) +int s3c_ielcd_display_off(void) { - unsigned int cfg = 0, ielcd_count = 0; + unsigned int cfg, ielcd_count = 0; cfg = s3c_ielcd_readl(S3C_VIDCON0); cfg |= S3C_VIDCON0_ENVID_ENABLE; - cfg &= ~S3C_VIDCON0_ENVID_F_ENABLE; + cfg &= ~(S3C_VIDCON0_ENVID_F_ENABLE); s3c_ielcd_writel(cfg, S3C_VIDCON0); @@ -121,7 +121,6 @@ int s3c_ielcd_stop(void) if (!(s3c_ielcd_readl(S3C_VIDCON1) & 0xffff0000)) return 0; } while (1); - } #endif @@ -136,31 +135,26 @@ int s3c_ielcd_init_global(struct s3cfb_global *ctrl) s3cfb_set_timing(ielcd_fbdev); s3cfb_set_lcd_size(ielcd_fbdev); - s3c_ielcd_writel(0, S3C_DITHMODE); - + /* vclock divider setting , same as FIMD */ cfg = readl(ctrl->regs + S3C_VIDCON0); - cfg &= ~(S3C_VIDCON0_VIDOUT_MASK | S3C_VIDCON0_VCLKEN_MASK | S3C_VIDCON0_ENVID_F_ENABLE); + cfg &= ~(S3C_VIDCON0_VIDOUT_MASK | S3C_VIDCON0_VCLKEN_MASK); cfg |= S3C_VIDCON0_VIDOUT_RGB; -#ifdef CONFIG_FB_S5P_MIPI_DSIM cfg |= S3C_VIDCON0_VCLKEN_NORMAL; -#else - cfg |= S3C_VIDCON0_VCLKEN_FREERUN; -#endif s3c_ielcd_writel(cfg, S3C_VIDCON0); - /* s3c_ielcd_writel(1<<5, S3C_VIDINTCON0); */ /* for what? */ - - s3cfb_set_vsync_interrupt(ielcd_fbdev, 0); - s3cfb_set_global_interrupt(ielcd_fbdev, 0); - + /* window0 position setting , fixed */ s3c_ielcd_writel(0, S3C_VIDOSD0A); + + /* window0 position setting */ cfg = S3C_VIDOSD_RIGHT_X(ctrl->lcd->width - 1); cfg |= S3C_VIDOSD_BOTTOM_Y(ctrl->lcd->height - 1); s3c_ielcd_writel(cfg, S3C_VIDOSD0B); + + /* window0 osd size setting */ s3c_ielcd_writel((ctrl->lcd->width * ctrl->lcd->height), S3C_VIDOSD0C); - cfg = S3C_WINCON_DATAPATH_LOCAL | S3C_WINCON_BPPMODE_32BPP; - cfg |= S3C_WINCON_INRGB_RGB; + /* window0 setting , fixed */ + cfg = S3C_WINCON_DATAPATH_LOCAL | S3C_WINCON_BPPMODE_32BPP | S3C_WINCON_INRGB_RGB; s3c_ielcd_writel(cfg, S3C_WINCON0); s3cfb_window_on(ielcd_fbdev, 0); diff --git a/drivers/video/samsung/s3cfb_ielcd.h b/drivers/video/samsung/s3cfb_ielcd.h index 0684a7f..e5b637b 100644 --- a/drivers/video/samsung/s3cfb_ielcd.h +++ b/drivers/video/samsung/s3cfb_ielcd.h @@ -23,8 +23,8 @@ int s3c_ielcd_hw_init(void); int s3c_ielcd_logic_start(void); int s3c_ielcd_logic_stop(void); -int s3c_ielcd_start(void); -int s3c_ielcd_stop(void); +int s3c_ielcd_display_on(void); +int s3c_ielcd_display_off(void); int s3c_ielcd_init_global(struct s3cfb_global *ctrl); diff --git a/drivers/video/samsung/s3cfb_main.c b/drivers/video/samsung/s3cfb_main.c index 3abbb4c..a6e4564 100644 --- a/drivers/video/samsung/s3cfb_main.c +++ b/drivers/video/samsung/s3cfb_main.c @@ -192,6 +192,7 @@ void read_lcd_register(void) (i*16), reg_val[i*4], reg_val[i*4+1], reg_val[i*4+2], reg_val[i*4+3]); #endif } + static int s3cfb_sysfs_show_win_power(struct device *dev, struct device_attribute *attr, char *buf) { @@ -289,15 +290,15 @@ static ssize_t fimd_dump_show(struct device *dev, } static DEVICE_ATTR(fimd_dump, 0444, fimd_dump_show, NULL); -#ifdef CONFIG_FB_S5P_MIPI_DSIM +#if 0 /* def CONFIG_FB_S5P_MIPI_DSIM */ void s3cfb_display_on_remote(void) { struct s3cfb_global *fbdev = fbfimd->fbdev[0]; struct s3c_platform_fb *pdata = to_fb_plat(fbdev->dev); if (pdata == NULL) { - dev_err(fbdev->dev, "failed to get defualt window number.\n"); - return; + dev_err(fbdev->dev, "failed to get defualt window number.\n"); + return; } s3cfb_display_on(fbdev); } @@ -324,7 +325,6 @@ static int s3cfb_probe(struct platform_device *pdev) struct s3cfb_global *fbdev[2]; int ret = 0; int i = 0; - u32 reg; #ifdef CONFIG_EXYNOS_DEV_PD /* to use the runtime PM helper functions */ @@ -421,6 +421,8 @@ static int s3cfb_probe(struct platform_device *pdev) fbdev[i]->system_state = POWER_ON; + spin_lock_init(&fbdev[i]->slock); + /* alloc fb_info */ if (s3cfb_alloc_framebuffer(fbdev[i], i)) { dev_err(fbdev[i]->dev, "alloc error fimd[%d]\n", i); @@ -440,20 +442,14 @@ static int s3cfb_probe(struct platform_device *pdev) #ifdef CONFIG_FB_S5P_MDNIE /* only FIMD0 is supported */ if (i == 0) { - reg = readl(S3C_VA_SYS + 0x0210); - reg &= ~(1<<13); - reg &= ~(1<<12); - reg &= ~(3<<10); - reg |= (1<<0); - reg &= ~(1<<1); - writel(reg, S3C_VA_SYS + 0x0210); - writel(3, fbdev[i]->regs + 0x27c); + if (pdata->set_display_path) + pdata->set_display_path(); + s3cfb_set_dualrgb(fbdev[i], S3C_DUALRGB_MDNIE); s3c_mdnie_init_global(fbdev[i]); - s3c_mdnie_start(fbdev[i]); + s3c_mdnie_display_on(fbdev[i]); } #endif - s3cfb_enable_window(fbdev[0], pdata->default_win); s3cfb_update_power_state(fbdev[i], pdata->default_win, @@ -462,9 +458,7 @@ static int s3cfb_probe(struct platform_device *pdev) /* Set alpha value width to 8-bit */ s3cfb_set_alpha_value_width(fbdev[i], i); -#ifndef CONFIG_MACH_JENGA s3cfb_display_on(fbdev[i]); -#endif #if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) #ifdef CONFIG_BUSFREQ_OPP @@ -654,7 +648,7 @@ void s3cfb_lcd0_power_domain_stop(void) void s3cfb_lcd0_pmu_off(void) { s3cfb_lcd0_power_domain_stop(); - msleep(5); + usleep_range(5000, 5000); s3cfb_lcd0_power_domain_start(); printk(KERN_WARNING "lcd0 pmu re_start!!!\n"); } @@ -668,13 +662,16 @@ void s3cfb_early_suspend(struct early_suspend *h) struct platform_device *pdev = to_platform_device(info->dev); struct s3cfb_global *fbdev[2]; int i, ret; - u32 reg; printk(KERN_INFO "+%s\n", __func__); -#if defined(CONFIG_FB_S5P_S6E8AA0) || defined(CONFIG_FB_S5P_S6E8AB0) || defined(CONFIG_FB_S5P_S6D6AA1) +#ifdef CONFIG_FB_S5P_MIPI_DSIM +#if defined(CONFIG_FB_S5P_S6E63M0) + s6e63m0_early_suspend(); +#else s6e8ax0_early_suspend(); #endif +#endif for (i = 0; i < FIMD_MAX; i++) { fbdev[i] = fbfimd->fbdev[i]; @@ -694,36 +691,29 @@ void s3cfb_early_suspend(struct early_suspend *h) #elif defined(CONFIG_FB_S5P_LMS501KF03) lms501kf03_ldi_disable(); #endif - ret = s3cfb_display_off(fbdev[i]); #ifdef CONFIG_FB_S5P_MDNIE - ret += s3c_mdnie_stop(); + ret += s3c_mdnie_display_off(); #endif if (ret > 0) s3cfb_lcd0_pmu_off(); -#ifdef CONFIG_FB_S5P_MDNIE - writel(0, fbdev[i]->regs + 0x27c); - msleep(20); - reg = readl(S3C_VA_SYS + 0x0210); - reg |= (1<<1); - writel(reg, S3C_VA_SYS + 0x0210); -#endif - info->system_state = POWER_OFF; if (fbdev[i]->regs) { fbdev[i]->regs_org = fbdev[i]->regs; + spin_lock(&fbdev[i]->slock); fbdev[i]->regs = 0; + spin_unlock(&fbdev[i]->slock); } if (pdata->clk_off) pdata->clk_off(pdev, &fbdev[i]->clock); } -#if defined(CONFIG_FB_S5P_S6C1372) +#if defined(CONFIG_FB_S5P_S6C1372) || defined(CONFIG_FB_S5P_S6F1202A) s5c1372_ldi_disable(); #endif @@ -750,7 +740,6 @@ void s3cfb_late_resume(struct early_suspend *h) struct s3cfb_global *fbdev[2]; int i, j; struct platform_device *pdev = to_platform_device(info->dev); - u32 reg; printk(KERN_INFO "+%s\n", __func__); @@ -767,13 +756,13 @@ void s3cfb_late_resume(struct early_suspend *h) if (s5p_dsim_fifo_clear() == 0) { s5p_dsim_early_suspend(); - msleep(10); + usleep_range(10000, 10000); s5p_dsim_late_resume(); if (s5p_dsim_fifo_clear() == 0) pr_info("dsim resume fail!!!\n"); } - msleep(10); + usleep_range(10000, 10000); #endif #if defined(CONFIG_FB_S5P_DUMMYLCD) @@ -791,18 +780,15 @@ void s3cfb_late_resume(struct early_suspend *h) /* fbdev[i]->regs_org should be non-zero value */ BUG(); - info->system_state = POWER_ON; + if (pdata->set_display_path) + pdata->set_display_path(); #ifdef CONFIG_FB_S5P_MDNIE - reg = readl(S3C_VA_SYS + 0x0210); - reg &= ~(1<<13); - reg &= ~(1<<12); - reg &= ~(3<<10); - reg |= (1<<0); - reg &= ~(1<<1); - writel(reg, S3C_VA_SYS + 0x0210); - writel(3, fbdev[i]->regs + 0x27c); + s3cfb_set_dualrgb(fbdev[i], S3C_DUALRGB_MDNIE); #endif + + info->system_state = POWER_ON; + s3cfb_init_global(fbdev[i]); s3cfb_set_clock(fbdev[i]); /* Set Alpha value width to 8-bit alpha value @@ -810,18 +796,15 @@ void s3cfb_late_resume(struct early_suspend *h) * 2 : 4bit mode */ s3cfb_set_alpha_value(fbdev[i], 1); -#if defined(CONFIG_FB_S5P_S6C1372) +#ifdef CONFIG_FB_S5P_MDNIE +#if defined(CONFIG_FB_S5P_S6C1372) || defined(CONFIG_FB_S5P_S6F1202A) s5c1372_ldi_enable(); #endif - -#ifdef CONFIG_FB_S5P_MDNIE s3c_mdnie_init_global(fbdev[i]); - s3c_mdnie_start(fbdev[i]); + set_mdnie_value(g_mdnie, 1); + s3c_mdnie_display_on(fbdev[i]); #endif s3cfb_display_on(fbdev[i]); -#ifdef CONFIG_FB_S5P_MDNIE - set_mdnie_value(g_mdnie); -#endif /* Set alpha value width to 8-bit */ s3cfb_set_alpha_value_width(fbdev[i], i); @@ -836,11 +819,6 @@ void s3cfb_late_resume(struct early_suspend *h) } } -#ifdef CONFIG_FB_S5P_AMS369FG06 - ams369fg06_gpio_cfg(); - ams369fg06_ldi_init(); - ams369fg06_ldi_enable(); -#endif if (pdata->cfg_gpio) pdata->cfg_gpio(pdev); @@ -854,9 +832,13 @@ void s3cfb_late_resume(struct early_suspend *h) pdata->backlight_on(pdev); } -#if defined(CONFIG_FB_S5P_S6E8AA0) || defined(CONFIG_FB_S5P_S6E8AB0) || defined(CONFIG_FB_S5P_S6D6AA1) +#ifdef CONFIG_FB_S5P_MIPI_DSIM +#if defined(CONFIG_FB_S5P_S6E63M0) + s6e63m0_late_resume(); +#else s6e8ax0_late_resume(); #endif +#endif printk(KERN_INFO "-%s\n", __func__); @@ -880,7 +862,7 @@ int s3cfb_suspend(struct platform_device *pdev, pm_message_t state) reg = readl(S3C_VA_SYS + 0x0210); reg |= (1<<1); writel(reg, S3C_VA_SYS + 0x0210); - s3c_mdnie_stop(); + s3c_mdnie_display_off(); #endif if (atomic_read(&fbdev[i]->enabled_win) > 0) { /* lcd_off and backlight_off isn't needed. */ @@ -956,7 +938,7 @@ int s3cfb_resume(struct platform_device *pdev) s3cfb_set_clock(fbdev[i]); #ifdef CONFIG_FB_S5P_MDNIE s3c_mdnie_init_global(fbdev[i]); - s3c_mdnie_start(fbdev[i]); + s3c_mdnie_display_on(fbdev[i]); #endif for (j = 0; j < pdata->nr_wins; j++) { fb = fbdev[i]->fb[j]; @@ -974,9 +956,7 @@ int s3cfb_resume(struct platform_device *pdev) s3cfb_set_alpha_value_width(fbdev[i], i); -#ifndef CONFIG_MACH_JENGA s3cfb_display_on(fbdev[i]); -#endif if (pdata->backlight_on) pdata->backlight_on(pdev); diff --git a/drivers/video/samsung/s3cfb_mdnie.c b/drivers/video/samsung/s3cfb_mdnie.c index 6860e59..0fa2f60 100644 --- a/drivers/video/samsung/s3cfb_mdnie.c +++ b/drivers/video/samsung/s3cfb_mdnie.c @@ -146,9 +146,9 @@ int s3c_mdnie_init_global(struct s3cfb_global *s3cfb_ctrl) return 0; } -int s3c_mdnie_start(struct s3cfb_global *ctrl) +int s3c_mdnie_display_on(struct s3cfb_global *ctrl) { - s3c_ielcd_start(); + s3c_ielcd_display_on(); if (!IS_ERR_OR_NULL(g_mdnie)) g_mdnie->enable = TRUE; @@ -156,22 +156,22 @@ int s3c_mdnie_start(struct s3cfb_global *ctrl) return 0; } -int s3c_mdnie_off(void) +int s3c_mdnie_display_off(void) { if (!IS_ERR_OR_NULL(g_mdnie)) g_mdnie->enable = FALSE; - s3c_ielcd_logic_stop(); - - return 0; + return s3c_ielcd_display_off(); } -int s3c_mdnie_stop(void) +int s3c_mdnie_off(void) { if (!IS_ERR_OR_NULL(g_mdnie)) g_mdnie->enable = FALSE; - return s3c_ielcd_stop(); + s3c_ielcd_logic_stop(); + + return 0; } int s3c_mdnie_hw_init(void) diff --git a/drivers/video/samsung/s3cfb_mdnie.h b/drivers/video/samsung/s3cfb_mdnie.h index 962b342..329a40a 100644 --- a/drivers/video/samsung/s3cfb_mdnie.h +++ b/drivers/video/samsung/s3cfb_mdnie.h @@ -326,9 +326,9 @@ int s3c_mdnie_setup(void); int s3c_mdnie_init_global(struct s3cfb_global *s3cfb_ctrl); -int s3c_mdnie_start(struct s3cfb_global *ctrl); +int s3c_mdnie_display_on(struct s3cfb_global *ctrl); +int s3c_mdnie_display_off(void); int s3c_mdnie_off(void); -int s3c_mdnie_stop(void); int mdnie_write(unsigned int addr, unsigned int val); int s3c_mdnie_mask(void); diff --git a/drivers/video/samsung/s3cfb_ops.c b/drivers/video/samsung/s3cfb_ops.c index c6cfab3..3ff2f05 100644 --- a/drivers/video/samsung/s3cfb_ops.c +++ b/drivers/video/samsung/s3cfb_ops.c @@ -104,15 +104,12 @@ int s3cfb_draw_logo(struct fb_info *fb) #else /* #ifdef RGB_BOOTSCREEN */ u8 *logo_virt_buf; - if (bootloaderfb) - printk(KERN_INFO "Bootloader sent 'bootloaderfb' to Kernel Successfully : %d", bootloaderfb); - else { - bootloaderfb = BOOT_FB_BASE_ADDR; - printk(KERN_ERR "Fail to get 'bootloaderfb' from Bootloader. so we must set this value as %d", bootloaderfb); + if (bootloaderfb) { + logo_virt_buf = phys_to_virt(bootloaderfb); + memcpy(fb->screen_base, logo_virt_buf, fb->var.yres * fb->fix.line_length); + printk(KERN_INFO "Bootloader sent 'bootloaderfb' : %08X\n", bootloaderfb); } - logo_virt_buf = phys_to_virt(bootloaderfb); - memcpy(fb->screen_base, logo_virt_buf, fb->var.yres * fb->fix.line_length); #endif /* #ifdef RGB_BOOTSCREEN */ #endif #endif @@ -393,7 +390,8 @@ int s3cfb_map_default_video_memory(struct s3cfb_global *fbdev, (unsigned int)fix->smem_start, (unsigned int)fb->screen_base, fix->smem_len); - memset(fb->screen_base, 0, fix->smem_len); + if (bootloaderfb) + memset(fb->screen_base, 0, fix->smem_len); win->owner = DMA_MEM_FIMD; return 0; @@ -552,10 +550,14 @@ int s3cfb_check_var(struct fb_var_screeninfo *var, struct fb_info *fb) void s3cfb_set_win_params(struct s3cfb_global *fbdev, int id) { s3cfb_set_window_control(fbdev, id); +#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) + s3cfb_set_oneshot(fbdev, id); +#else s3cfb_set_window_position(fbdev, id); s3cfb_set_window_size(fbdev, id); s3cfb_set_buffer_address(fbdev, id); s3cfb_set_buffer_size(fbdev, id); +#endif if (id > 0) { s3cfb_set_alpha_blending(fbdev, id); @@ -1031,22 +1033,32 @@ int s3cfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fb) { struct s3cfb_window *win = fb->par; struct s3cfb_global *fbdev = get_fimd_global(win->id); + struct s3c_platform_fb *pdata = to_fb_plat(fbdev->dev); + + if (win->id == pdata->default_win) + spin_lock(&fbdev->slock); #ifdef CONFIG_EXYNOS_DEV_PD if (unlikely(fbdev->system_state == POWER_OFF) || fbdev->regs == 0) { dev_err(fbdev->dev, "%s::system_state is POWER_OFF, fb%d\n", __func__, win->id); - return 0; + if (win->id == pdata->default_win) + spin_unlock(&fbdev->slock); + return -EINVAL; } #endif if (var->yoffset + var->yres > var->yres_virtual) { dev_err(fbdev->dev, "invalid yoffset value\n"); + if (win->id == pdata->default_win) + spin_unlock(&fbdev->slock); return -EINVAL; } #if defined(CONFIG_CPU_EXYNOS4210) if (unlikely(var->xoffset + var->xres > var->xres_virtual)) { dev_err(fbdev->dev, "invalid xoffset value\n"); + if (win->id == pdata->default_win) + spin_unlock(&fbdev->slock); return -EINVAL; } fb->var.xoffset = var->xoffset; @@ -1059,6 +1071,8 @@ int s3cfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fb) s3cfb_set_buffer_address(fbdev, win->id); + if (win->id == pdata->default_win) + spin_unlock(&fbdev->slock); return 0; } @@ -1143,6 +1157,10 @@ int s3cfb_ioctl(struct fb_info *fb, unsigned int cmd, unsigned long arg) sizeof(p.user_window))) ret = -EFAULT; else { +#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) + win->x = p.user_window.x; + win->y = p.user_window.y; +#else if (p.user_window.x < 0) p.user_window.x = 0; @@ -1160,6 +1178,7 @@ int s3cfb_ioctl(struct fb_info *fb, unsigned int cmd, unsigned long arg) win->y = p.user_window.y; s3cfb_set_window_position(fbdev, win->id); +#endif } break; diff --git a/drivers/video/samsung/s3cfb_s6e39a0.c b/drivers/video/samsung/s3cfb_s6e39a0.c index 4e9fa8f..3d0f534 100644 --- a/drivers/video/samsung/s3cfb_s6e39a0.c +++ b/drivers/video/samsung/s3cfb_s6e39a0.c @@ -106,9 +106,9 @@ struct lcd_info { #endif unsigned int irq; unsigned int connected; -}; -static struct mipi_ddi_platform_data *ddi_pd; + struct dsim_global *dsim; +}; static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len) { @@ -124,11 +124,11 @@ static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len wbuf = seq; if (size == 1) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_NO_PARA, wbuf[0], 0); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_NO_PARA, wbuf[0], 0); else if (size == 2) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_1_PARA, wbuf[0], wbuf[1]); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_1_PARA, wbuf[0], wbuf[1]); else - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_LONG_WR, (unsigned int)wbuf, size); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_LONG_WR, (unsigned int)wbuf, size); mutex_unlock(&lcd->lock); @@ -144,44 +144,14 @@ static int s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf) mutex_lock(&lcd->lock); - if (ddi_pd->cmd_read) - ret = ddi_pd->cmd_read(ddi_pd->dsim_base, addr, count, buf); + if (lcd->dsim->ops->cmd_read) + ret = lcd->dsim->ops->cmd_read(lcd->dsim, addr, count, buf); mutex_unlock(&lcd->lock); return ret; } -static int s6e8ax0_set_link(void *pd, unsigned int dsim_base, - unsigned char (*cmd_write) (unsigned int dsim_base, unsigned int data0, - unsigned int data1, unsigned int data2), - int (*cmd_read) (unsigned int reg_base, u8 addr, u16 count, u8 *buf)) -{ - struct mipi_ddi_platform_data *temp_pd = NULL; - - temp_pd = (struct mipi_ddi_platform_data *) pd; - if (temp_pd == NULL) { - printk(KERN_ERR "mipi_ddi_platform_data is null.\n"); - return -EPERM; - } - - ddi_pd = temp_pd; - - ddi_pd->dsim_base = dsim_base; - - if (cmd_write) - ddi_pd->cmd_write = cmd_write; - else - printk(KERN_WARNING "cmd_write function is null.\n"); - - if (cmd_read) - ddi_pd->cmd_read = cmd_read; - else - printk(KERN_WARNING "cmd_read function is null.\n"); - - return 0; -} - static int get_backlight_level_from_brightness(int brightness) { int backlightlevel; @@ -362,8 +332,7 @@ static int update_brightness(struct lcd_info *lcd) { int ret; -#if defined(CONFIG_MACH_MIDAS_01_BD) || defined(CONFIG_MACH_MIDAS_02_BD) || \ - defined(CONFIG_MACH_C1) || defined(CONFIG_MACH_C1VZW) || \ +#if defined(CONFIG_MACH_C1) || defined(CONFIG_MACH_C1VZW) || \ defined(CONFIG_MACH_M0) || defined(CONFIG_MACH_SLP_PQ) || \ defined(CONFIG_MACH_SLP_PQ_LTE) || defined(CONFIG_MACH_M3) #else @@ -956,8 +925,7 @@ static void s6e8aa0_check_id(struct lcd_info *lcd, u8 *idbuf) lcd->elvss.reference = lcd->smart.panelid[2]; printk(KERN_DEBUG "Dynamic ELVSS Information\n"); - printk(KERN_DEBUG "Refrence : %02x , manual_version = %02x,\ - lcd->aid= %02x\n", lcd->elvss.reference, lcd->manual_version, lcd->aid); + printk(KERN_DEBUG "Refrence : %02x , manual_version = %02x, lcd->aid= %02x\n", lcd->elvss.reference, lcd->manual_version, lcd->aid); } else if ((idbuf[0] == PANEL_A1_M3) || (idbuf[0] == PANEL_A2_M3)) { lcd->support_elvss = 0; printk(KERN_DEBUG "ID-3 is 0xff does not support dynamic elvss\n"); @@ -1003,6 +971,7 @@ static int s6e8ax0_probe(struct device *dev) } lcd->dev = dev; + lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = DEFAULT_GAMMA_LEVEL; @@ -1103,7 +1072,6 @@ static void s6e8ax0_shutdown(struct device *dev) static struct mipi_lcd_driver s6e8ax0_mipi_driver = { .name = "s6e8aa0", - .set_link = s6e8ax0_set_link, .probe = s6e8ax0_probe, .remove = __devexit_p(s6e8ax0_remove), .shutdown = s6e8ax0_shutdown, diff --git a/drivers/video/samsung/s3cfb_s6e8aa0.c b/drivers/video/samsung/s3cfb_s6e8aa0.c index e9581e9..987b215 100644 --- a/drivers/video/samsung/s3cfb_s6e8aa0.c +++ b/drivers/video/samsung/s3cfb_s6e8aa0.c @@ -34,7 +34,7 @@ #include "s3cfb.h" #include "s6e8aa0_gamma_l.h" -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) #include "s6e8aa0_gamma_q1.h" #define SMART_DIMMING #else @@ -53,7 +53,7 @@ #define MIN_BRIGHTNESS 0 #define MAX_BRIGHTNESS 255 -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) #define MAX_GAMMA 290 #define DEFAULT_BRIGHTNESS 150 #define DEFAULT_GAMMA_LEVEL GAMMA_150CD @@ -122,13 +122,12 @@ struct lcd_info { unsigned int connected; #if defined(GPIO_OLED_DET) - struct delayed_work hs_clk_toggle; - unsigned int esd_detection_count; + struct delayed_work oled_detection; + unsigned int oled_detection_count; #endif + struct dsim_global *dsim; }; -static struct mipi_ddi_platform_data *ddi_pd; - #ifdef CONFIG_AID_DIMMING static const unsigned int candela_table[GAMMA_MAX] = { 20, 30, 40, 50, 60, 70, 80, 90, 100, @@ -183,19 +182,19 @@ static unsigned int elvss_offset_table[ELVSS_STATUS_MAX] = { #endif #if defined(GPIO_OLED_DET) -static void hs_clk_toggle_work(struct work_struct *work) +static void oled_detection_work(struct work_struct *work) { struct lcd_info *lcd = - container_of(work, struct lcd_info, hs_clk_toggle.work); + container_of(work, struct lcd_info, oled_detection.work); int oled_det_level = gpio_get_value(GPIO_OLED_DET); - printk(KERN_INFO "%s, %d, %d\n", __func__, lcd->esd_detection_count, oled_det_level); + dev_info(&lcd->ld->dev, "%s, %d, %d\n", __func__, lcd->oled_detection_count, oled_det_level); if (!oled_det_level) { - if (lcd->esd_detection_count < 10) { - schedule_delayed_work(&lcd->hs_clk_toggle, HZ/8); - lcd->esd_detection_count++; + if (lcd->oled_detection_count < 10) { + schedule_delayed_work(&lcd->oled_detection, HZ/8); + lcd->oled_detection_count++; set_dsim_hs_clk_toggle_count(15); } else set_dsim_hs_clk_toggle_count(0); @@ -204,14 +203,14 @@ static void hs_clk_toggle_work(struct work_struct *work) } -static irqreturn_t oled_det_int(int irq, void *_lcd) +static irqreturn_t oled_detection_int(int irq, void *_lcd) { struct lcd_info *lcd = _lcd; - printk(KERN_INFO "%s\n", __func__); + dev_info(&lcd->ld->dev, "%s\n", __func__); - lcd->esd_detection_count = 0; - schedule_delayed_work(&lcd->hs_clk_toggle, HZ/16); + lcd->oled_detection_count = 0; + schedule_delayed_work(&lcd->oled_detection, HZ/16); return IRQ_HANDLED; } @@ -231,11 +230,11 @@ static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len wbuf = seq; if (size == 1) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_NO_PARA, wbuf[0], 0); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_NO_PARA, wbuf[0], 0); else if (size == 2) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_1_PARA, wbuf[0], wbuf[1]); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_1_PARA, wbuf[0], wbuf[1]); else - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_LONG_WR, (unsigned int)wbuf, size); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_LONG_WR, (unsigned int)wbuf, size); mutex_unlock(&lcd->lock); @@ -251,44 +250,14 @@ static int _s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf mutex_lock(&lcd->lock); - if (ddi_pd->cmd_read) - ret = ddi_pd->cmd_read(ddi_pd->dsim_base, addr, count, buf); + if (lcd->dsim->ops->cmd_read) + ret = lcd->dsim->ops->cmd_read(lcd->dsim, addr, count, buf); mutex_unlock(&lcd->lock); return ret; } -static int s6e8ax0_set_link(void *pd, unsigned int dsim_base, - unsigned char (*cmd_write) (unsigned int dsim_base, unsigned int data0, - unsigned int data1, unsigned int data2), - int (*cmd_read) (u32 reg_base, u8 addr, u16 count, u8 *buf)) -{ - struct mipi_ddi_platform_data *temp_pd = NULL; - - temp_pd = (struct mipi_ddi_platform_data *) pd; - if (temp_pd == NULL) { - printk(KERN_ERR "mipi_ddi_platform_data is null.\n"); - return -EPERM; - } - - ddi_pd = temp_pd; - - ddi_pd->dsim_base = dsim_base; - - if (cmd_write) - ddi_pd->cmd_write = cmd_write; - else - printk(KERN_WARNING "cmd_write function is null.\n"); - - if (cmd_read) - ddi_pd->cmd_read = cmd_read; - else - printk(KERN_WARNING "cmd_read function is null.\n"); - - return 0; -} - static int s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf, u8 retry_cnt) { int ret = 0; @@ -456,7 +425,7 @@ static int s6e8ax0_gamma_ctl(struct lcd_info *lcd) return 0; } -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) static int s6e8ax0_set_acl(struct lcd_info *lcd) { int ret = 0; @@ -605,7 +574,7 @@ static int s6e8ax0_set_acl(struct lcd_info *lcd) #ifdef SMART_DIMMING #ifdef CONFIG_AID_DIMMING -static int s6e8ax0_set_elvss(struct lcd_info *lcd) +static int s6e8ax0_set_elvss(struct lcd_info *lcd, u8 force) { int ret = 0, elvss_level = 0; u32 candela = candela_table[lcd->bl]; @@ -673,7 +642,7 @@ static int s6e8ax0_set_elvss(struct lcd_info *lcd) break; } - if (lcd->current_elvss != lcd->elvss_table[elvss_level][2]) { + if ((lcd->current_elvss != lcd->elvss_table[elvss_level][2]) || force) { ret = s6e8ax0_write(lcd, lcd->elvss_table[elvss_level], ELVSS_PARAM_SIZE); lcd->current_elvss = lcd->elvss_table[elvss_level][2]; } @@ -689,7 +658,7 @@ elvss_err: return ret; } #else -static int s6e8ax0_set_elvss(struct lcd_info *lcd) +static int s6e8ax0_set_elvss(struct lcd_info *lcd, u8 force) { int ret = 0, elvss_level = 0; u32 candela = candela_table[lcd->bl]; @@ -711,7 +680,7 @@ static int s6e8ax0_set_elvss(struct lcd_info *lcd) break; } - if (lcd->current_elvss != lcd->elvss_table[elvss_level][2]) { + if ((lcd->current_elvss != lcd->elvss_table[elvss_level][2]) || force) { ret = s6e8ax0_write(lcd, lcd->elvss_table[elvss_level], ELVSS_PARAM_SIZE); lcd->current_elvss = lcd->elvss_table[elvss_level][2]; } @@ -947,7 +916,7 @@ static int update_brightness(struct lcd_info *lcd, u8 force) #endif s6e8ax0_set_acl(lcd); - s6e8ax0_set_elvss(lcd); + s6e8ax0_set_elvss(lcd, force); lcd->current_bl = lcd->bl; @@ -963,11 +932,11 @@ static int s6e8ax0_ldi_init(struct lcd_info *lcd) { int ret = 0; -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) s6e8ax0_write(lcd, SEQ_APPLY_LEVEL_2_KEY, ARRAY_SIZE(SEQ_APPLY_LEVEL_2_KEY)); - msleep(20); + s6e8ax0_write(lcd, SEQ_LTPS_DELAY, ARRAY_SIZE(SEQ_LTPS_DELAY)); s6e8ax0_write(lcd, SEQ_SLEEP_OUT, ARRAY_SIZE(SEQ_SLEEP_OUT)); - usleep_range(5000, 5000); + msleep(22); s6e8ax0_write(lcd, SEQ_PANEL_CONDITION_SET, ARRAY_SIZE(SEQ_PANEL_CONDITION_SET)); s6e8ax0_write(lcd, SEQ_DISPLAY_CONDITION_SET, ARRAY_SIZE(SEQ_DISPLAY_CONDITION_SET)); s6e8ax0_gamma_ctl(lcd); @@ -980,7 +949,7 @@ static int s6e8ax0_ldi_init(struct lcd_info *lcd) s6e8ax0_write(lcd, SEQ_APPLY_LEVEL_2, ARRAY_SIZE(SEQ_APPLY_LEVEL_2)); s6e8ax0_write(lcd, SEQ_APPLY_MTP_KEY_ENABLE, ARRAY_SIZE(SEQ_APPLY_MTP_KEY_ENABLE)); s6e8ax0_write(lcd, SEQ_SLEEP_OUT, ARRAY_SIZE(SEQ_SLEEP_OUT)); - usleep_range(22000, 22000); + msleep(22); /* 4.8" HD for M0/C1*/ if (lcd->id[1] == 0x20 || lcd->id[1] == 0x40 || lcd->id[1] == 0x60) { @@ -1209,7 +1178,7 @@ static ssize_t lcd_type_show(struct device *dev, struct device_attribute *attr, char *buf) { char temp[15]; -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) sprintf(temp, "SMD_AMS529HA01\n"); #else sprintf(temp, "SMD_AMS480GYXX\n"); @@ -1286,6 +1255,8 @@ void s6e8ax0_early_suspend(void) { struct lcd_info *lcd = g_lcd; + set_dsim_lcd_enabled(0); + dev_info(&lcd->ld->dev, "+%s\n", __func__); #if defined(GPIO_OLED_DET) disable_irq(lcd->irq); @@ -1314,7 +1285,7 @@ void s6e8ax0_late_resume(void) #endif dev_info(&lcd->ld->dev, "-%s\n", __func__); - set_dsim_lcd_enabled(); + set_dsim_lcd_enabled(1); return ; } @@ -1341,7 +1312,7 @@ static int s6e8ax0_read_mtp(struct lcd_info *lcd, u8 *mtp_data) return ret; } -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) static void s6e8aa0_check_id(struct lcd_info *lcd, u8 *idbuf) { u32 i; @@ -1409,6 +1380,7 @@ static int s6e8ax0_probe(struct device *dev) } lcd->dev = dev; + lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = DEFAULT_GAMMA_LEVEL; @@ -1490,14 +1462,14 @@ static int s6e8ax0_probe(struct device *dev) #if defined(GPIO_OLED_DET) if (lcd->connected) { - INIT_DELAYED_WORK(&lcd->hs_clk_toggle, hs_clk_toggle_work); + INIT_DELAYED_WORK(&lcd->oled_detection, oled_detection_work); lcd->irq = gpio_to_irq(GPIO_OLED_DET); s3c_gpio_cfgpin(GPIO_OLED_DET, S3C_GPIO_SFN(0xf)); s3c_gpio_setpull(GPIO_OLED_DET, S3C_GPIO_PULL_NONE); - if (request_irq(lcd->irq, oled_det_int, - IRQF_TRIGGER_FALLING, "esd_detection", lcd)) + if (request_irq(lcd->irq, oled_detection_int, + IRQF_TRIGGER_FALLING, "oled_detection", lcd)) pr_err("failed to reqeust irq. %d\n", lcd->irq); } #endif @@ -1540,7 +1512,6 @@ static void s6e8ax0_shutdown(struct device *dev) static struct mipi_lcd_driver s6e8ax0_mipi_driver = { .name = "s6e8aa0", - .set_link = s6e8ax0_set_link, .probe = s6e8ax0_probe, .remove = __devexit_p(s6e8ax0_remove), .shutdown = s6e8ax0_shutdown, diff --git a/drivers/video/samsung/s3cfb_s6e8ab0.c b/drivers/video/samsung/s3cfb_s6e8ab0.c index 185bab0..bc47c37 100644 --- a/drivers/video/samsung/s3cfb_s6e8ab0.c +++ b/drivers/video/samsung/s3cfb_s6e8ab0.c @@ -101,9 +101,9 @@ struct lcd_info { struct str_elvss elvss; #endif unsigned int connected; -}; -static struct mipi_ddi_platform_data *ddi_pd; + struct dsim_global *dsim; +}; static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len) { @@ -119,11 +119,11 @@ static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len wbuf = seq; if (size == 1) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_NO_PARA, wbuf[0], 0); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_NO_PARA, wbuf[0], 0); else if (size == 2) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_1_PARA, wbuf[0], wbuf[1]); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_1_PARA, wbuf[0], wbuf[1]); else - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_LONG_WR, (unsigned int)wbuf, size); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_LONG_WR, (unsigned int)wbuf, size); mutex_unlock(&lcd->lock); @@ -139,44 +139,14 @@ static int _s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf mutex_lock(&lcd->lock); - if (ddi_pd->cmd_read) - ret = ddi_pd->cmd_read(ddi_pd->dsim_base, addr, count, buf); + if (lcd->dsim->ops->cmd_read) + ret = lcd->dsim->ops->cmd_read(lcd->dsim, addr, count, buf); mutex_unlock(&lcd->lock); return ret; } -static int s6e8ax0_set_link(void *pd, unsigned int dsim_base, - unsigned char (*cmd_write) (unsigned int dsim_base, unsigned int data0, - unsigned int data1, unsigned int data2), - int (*cmd_read) (u32 reg_base, u8 addr, u16 count, u8 *buf)) -{ - struct mipi_ddi_platform_data *temp_pd = NULL; - - temp_pd = (struct mipi_ddi_platform_data *) pd; - if (temp_pd == NULL) { - printk(KERN_ERR "mipi_ddi_platform_data is null.\n"); - return -EPERM; - } - - ddi_pd = temp_pd; - - ddi_pd->dsim_base = dsim_base; - - if (cmd_write) - ddi_pd->cmd_write = cmd_write; - else - printk(KERN_WARNING "cmd_write function is null.\n"); - - if (cmd_read) - ddi_pd->cmd_read = cmd_read; - else - printk(KERN_WARNING "cmd_read function is null.\n"); - - return 0; -} - static int s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf, u8 retry_cnt) { int ret = 0; @@ -781,6 +751,8 @@ void s6e8ax0_early_suspend(void) { struct lcd_info *lcd = g_lcd; + set_dsim_lcd_enabled(0); + dev_info(&lcd->ld->dev, "+%s\n", __func__); s6e8ax0_power(lcd, FB_BLANK_POWERDOWN); dev_info(&lcd->ld->dev, "-%s\n", __func__); @@ -796,7 +768,7 @@ void s6e8ax0_late_resume(void) s6e8ax0_power(lcd, FB_BLANK_UNBLANK); dev_info(&lcd->ld->dev, "-%s\n", __func__); - set_dsim_lcd_enabled(); + set_dsim_lcd_enabled(1); return ; } @@ -884,6 +856,7 @@ static int s6e8ax0_probe(struct device *dev) } lcd->dev = dev; + lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = DEFAULT_GAMMA_LEVEL; @@ -990,7 +963,6 @@ static void s6e8ax0_shutdown(struct device *dev) static struct mipi_lcd_driver s6e8ax0_mipi_driver = { .name = "s6e8ab0", - .set_link = s6e8ax0_set_link, .probe = s6e8ax0_probe, .remove = __devexit_p(s6e8ax0_remove), .shutdown = s6e8ax0_shutdown, diff --git a/drivers/video/samsung/s5p-dsim.c b/drivers/video/samsung/s5p-dsim.c index 540a75b..4f2cb7f 100644 --- a/drivers/video/samsung/s5p-dsim.c +++ b/drivers/video/samsung/s5p-dsim.c @@ -50,38 +50,6 @@ #include <linux/suspend.h> #endif - -/* Indicates the state of the device */ -struct dsim_global { - struct device *dev; - struct clk *clock; - struct s5p_platform_dsim *pd; - struct dsim_config *dsim_info; - struct dsim_lcd_config *dsim_lcd_info; - /* lcd panel data. */ - struct s3cfb_lcd *lcd_panel_info; - /* platform and machine specific data for lcd panel driver. */ - struct mipi_ddi_platform_data *mipi_ddi_pd; - /* lcd panel driver based on MIPI-DSI. */ - struct mipi_lcd_driver *mipi_drv; - - unsigned int irq; - unsigned int te_irq; - unsigned int reg_base; - unsigned char state; - unsigned int data_lane; - enum dsim_byte_clk_src e_clk_src; - unsigned long hs_clk; - unsigned long byte_clk; - unsigned long escape_clk; - unsigned char freq_band; - char header_fifo_index[DSIM_HEADER_FIFO_SZ]; -#ifdef CONFIG_HAS_WAKELOCK - struct early_suspend early_suspend; - struct wake_lock idle_lock; -#endif -}; - struct mipi_lcd_info { struct list_head list; struct mipi_lcd_driver *mipi_drv; @@ -134,82 +102,83 @@ static DECLARE_COMPLETION(dsim_wr_comp); static LIST_HEAD(lcd_info_list); static DEFINE_MUTEX(mipi_lock); -static struct dsim_global dsim; -struct delayed_work dsim_work; -struct delayed_work check_hs_toggle_work; +static struct dsim_global *g_dsim; -static unsigned int dsim_toggle_per_frame_count; +static struct s5p_platform_dsim *to_dsim_plat(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + + return (struct s5p_platform_dsim *)pdev->dev.platform_data; +} -void s5p_dsim_frame_done_interrupt_enable(u8 enable) +static void s5p_dsim_frame_done_interrupt_enable(struct dsim_global *dsim, u8 enable) { u32 intmsk; u8 state = !enable; - if (!dsim.mipi_ddi_pd->resume_complete) + if (!dsim->mipi_ddi_pd->resume_complete) return; -#if 0 - if (state == 0) /* enable Frame Done interrupts */ - writel(0xF237FFFF, dsim.reg_base + S5P_DSIM_INTMSK); - else /* disable Frame Done interrupts */ - writel(0xF337FFFF, dsim.reg_base + S5P_DSIM_INTMSK); -#else - intmsk = readl(dsim.reg_base + S5P_DSIM_INTMSK); + intmsk = readl(dsim->reg_base + S5P_DSIM_INTMSK); - if (state == 0) + if (state == 0) /* enable Frame Done interrupts */ intmsk &= ~(0x01 << S5P_DSIM_INT_MSK_FRAME_DONE); - else + else /* disable Frame Done interrupts */ intmsk |= (0x01 << S5P_DSIM_INT_MSK_FRAME_DONE); - writel(intmsk, dsim.reg_base + S5P_DSIM_INTMSK); -#endif + writel(intmsk, dsim->reg_base + S5P_DSIM_INTMSK); } -void set_dsim_lcd_enabled(void) +void set_dsim_lcd_enabled(u8 enable) { - dsim.dsim_lcd_info->lcd_enabled = 1; - if (dsim.dsim_info->hs_toggle) - s5p_dsim_frame_done_interrupt_enable(1); + struct dsim_global *dsim = g_dsim; + + dsim->dsim_lcd_info->lcd_enabled = enable; + if (dsim->dsim_info->hs_toggle) + s5p_dsim_frame_done_interrupt_enable(dsim, enable); } void set_dsim_hs_clk_toggle_count(u8 count) { - dsim_toggle_per_frame_count = count; - if (dsim.dsim_lcd_info->lcd_enabled) - s5p_dsim_frame_done_interrupt_enable(count ? 1 : 0); + struct dsim_global *dsim = g_dsim; + + dsim->dsim_toggle_per_frame_count = count; + if (dsim->dsim_lcd_info->lcd_enabled) + s5p_dsim_frame_done_interrupt_enable(dsim, count ? 1 : 0); } static void dsim_work_q_handler(struct work_struct *work) { - s5p_dsim_frame_done_interrupt_enable(1); -} + struct dsim_global *dsim = + container_of(work, struct dsim_global, dsim_work.work); -static void dsim_check_hs_toggle_work_q_handler(struct work_struct *work) -{ - if (dsim.dsim_info->hs_toggle) { - dev_info(dsim.dev, "check_hs_toggle.\n"); - schedule_delayed_work(&check_hs_toggle_work,\ - msecs_to_jiffies(120000)); - } + s5p_dsim_frame_done_interrupt_enable(dsim, 1); } -struct s5p_platform_dsim *to_dsim_plat(struct device *dev) +static void dsim_check_hs_toggle_work_q_handler(struct work_struct *work) { - struct platform_device *pdev = to_platform_device(dev); + struct dsim_global *dsim = + container_of(work, struct dsim_global, check_hs_toggle_work.work); - return (struct s5p_platform_dsim *)pdev->dev.platform_data; + if (dsim->dsim_info->hs_toggle) { + dev_info(dsim->dev, "check_hs_toggle\n"); + schedule_delayed_work(&dsim->check_hs_toggle_work, msecs_to_jiffies(120000)); + } } -unsigned char s5p_dsim_wr_data(unsigned int dsim_base, +unsigned char s5p_dsim_wr_data(void *ptr, unsigned int data_id, unsigned int data0, unsigned int data1) { - if (dsim.state == DSIM_STATE_ULPS) { - dev_err(dsim.dev, "state is ULPS\n"); + struct dsim_global *dsim = ptr; + unsigned int dsim_base = dsim->reg_base; + + if (dsim->state == DSIM_STATE_ULPS) { + dev_err(dsim->dev, "DSIM state: ULPS\n"); return DSIM_FALSE; } - if (dsim.mipi_ddi_pd->resume_complete == 0) { - printk(KERN_INFO "DSIM Status: SUSPEND\n"); + if (dsim->mipi_ddi_pd->resume_complete == 0) { + dev_err(dsim->dev, "DSIM Status: SUSPEND\n"); return DSIM_FALSE; } @@ -278,7 +247,7 @@ unsigned char s5p_dsim_wr_data(unsigned int dsim_base, (unsigned char) ((((unsigned short) data1) & 0xff00) >> 8)); if (!wait_for_completion_interruptible_timeout(&dsim_wr_comp, DSIM_TIMEOUT)) { - printk(KERN_ERR "[DSIM:ERROR] %s Timeout\n", __func__); + dev_err(dsim->dev, "[DSIM:ERROR] %s Timeout\n", __func__); mutex_unlock(&dsim_rd_wr_mutex); return DSIM_FALSE; } @@ -293,13 +262,13 @@ unsigned char s5p_dsim_wr_data(unsigned int dsim_base, mutex_unlock(&dsim_rd_wr_mutex); return DSIM_TRUE; /* response should be implemented. */ default: - dev_warn(dsim.dev, "data id %x is not supported current DSI spec.\n", data_id); + dev_warn(dsim->dev, "data id %x is not supported current DSI spec\n", data_id); mutex_unlock(&dsim_rd_wr_mutex); return DSIM_FALSE; } } -int s5p_dsim_rd_data(unsigned int reg_base, u8 addr, u16 count, u8 *buf) +int s5p_dsim_rd_data(void *ptr, u8 addr, u16 count, u8 *buf) { u32 i, temp; u8 response = 0; @@ -307,11 +276,11 @@ int s5p_dsim_rd_data(unsigned int reg_base, u8 addr, u16 count, u8 *buf) u32 txhd; u32 rxhd; int j; + struct dsim_global *dsim = ptr; + unsigned int reg_base = dsim->reg_base; - printk(KERN_INFO "%s called, count : %d\n", __func__, count); - - if (dsim.mipi_ddi_pd->resume_complete == 0) { - printk(KERN_INFO "DSIM Status: SUSPEND\n"); + if (dsim->mipi_ddi_pd->resume_complete == 0) { + dev_err(dsim->dev, "DSIM Status: SUSPEND\n"); return DSIM_FALSE; } @@ -341,15 +310,15 @@ int s5p_dsim_rd_data(unsigned int reg_base, u8 addr, u16 count, u8 *buf) writel(txhd, reg_base + S5P_DSIM_PKTHDR); if (!wait_for_completion_interruptible_timeout(&dsim_rd_comp, DSIM_TIMEOUT)) { - printk(KERN_ERR "ERROR:%s timout\n", __func__); + dev_err(dsim->dev, "ERROR:%s timout\n", __func__); mutex_unlock(&dsim_rd_wr_mutex); return 0; } rxhd = readl(reg_base + S5P_DSIM_RXFIFO); - printk(KERN_INFO "rxhd : %x\n", rxhd); + dev_info(dsim->dev, "rxhd : %x\n", rxhd); if ((u8)(rxhd & 0xff) != response) { - printk(KERN_ERR "[DSIM:ERROR]:%s wrong response rxhd : %x, response:%x\n" + dev_err(dsim->dev, "[DSIM:ERROR]:%s wrong response rxhd : %x, response:%x\n" , __func__, rxhd, response); goto clear_rx_fifo; } @@ -361,16 +330,16 @@ int s5p_dsim_rd_data(unsigned int reg_base, u8 addr, u16 count, u8 *buf) } else { /* for long packet */ rxsize = (u16)((rxhd & 0x00ffff00) >> 8); - printk(KERN_INFO "rcv size : %d\n", rxsize); + dev_info(dsim->dev, "rcv size : %d\n", rxsize); if (rxsize != count) { - printk(KERN_ERR "[DSIM:ERROR]:%s received data size mismatch received : %d, requested : %d\n", + dev_err(dsim->dev, "[DSIM:ERROR]:%s received data size mismatch received : %d, requested : %d\n", __func__, rxsize, count); goto clear_rx_fifo; } for (i = 0; i < rxsize>>2; i++) { temp = readl(reg_base + S5P_DSIM_RXFIFO); - printk(KERN_INFO "pkt : %08x\n", temp); + dev_info(dsim->dev, "pkt : %08x\n", temp); for (j = 0; j < 4; j++) { buf[(i*4)+j] = (u8)(temp>>(j*8))&0xff; /* printk("Value : %02x\n",(temp>>(j*8))&0xff); */ @@ -378,7 +347,7 @@ int s5p_dsim_rd_data(unsigned int reg_base, u8 addr, u16 count, u8 *buf) } if (rxsize % 4) { temp = readl(reg_base + S5P_DSIM_RXFIFO); - printk(KERN_INFO "pkt-l : %08x\n", temp); + dev_info(dsim->dev, "pkt-l : %08x\n", temp); for (j = 0; j < rxsize%4; j++) { buf[(i*4)+j] = (u8)(temp>>(j*8))&0xff; /* printk("Value : %02x\n",(temp>>(j*8))&0xff); */ @@ -389,7 +358,7 @@ int s5p_dsim_rd_data(unsigned int reg_base, u8 addr, u16 count, u8 *buf) temp = readl(reg_base + S5P_DSIM_RXFIFO); if (temp != DSIM_RX_FIFO_READ_DONE) { - printk(KERN_WARNING "[DSIM:WARN]:%s Can't found RX FIFO READ DONE FLAG : %x\n", __func__, temp); + dev_warn(dsim->dev, "[DSIM:WARN]:%s Can't found RX FIFO READ DONE FLAG : %x\n", __func__, temp); goto clear_rx_fifo; } @@ -402,10 +371,10 @@ clear_rx_fifo: temp = readl(reg_base+S5P_DSIM_RXFIFO); if ((temp == DSIM_RX_FIFO_READ_DONE) || (i > DSIM_MAX_RX_FIFO)) break; - printk(KERN_INFO "[DSIM:INFO] : %s clear rx fifo : %08x\n", __func__, temp); + dev_info(dsim->dev, "[DSIM:INFO] : %s clear rx fifo : %08x\n", __func__, temp); i++; } - printk(KERN_INFO "[DSIM:INFO] : %s done count : %d, temp : %08x\n", __func__, i, temp); + dev_info(dsim->dev, "[DSIM:INFO] : %s done count : %d, temp : %08x\n", __func__, i, temp); mutex_unlock(&dsim_rd_wr_mutex); return 0; @@ -417,16 +386,16 @@ static irqreturn_t s5p_dsim_isr(int irq, void *dev_id) int i; unsigned int intsrc = 0; unsigned int intmsk = 0; - struct dsim_global *pdsim = NULL; + struct dsim_global *dsim = NULL; - pdsim = (struct dsim_global *)dev_id; - if (!pdsim) { + dsim = (struct dsim_global *)dev_id; + if (!dsim) { printk(KERN_ERR "%s:error:wrong parameter\n", __func__); return IRQ_HANDLED; } - intsrc = readl(pdsim->reg_base + S5P_DSIM_INTSRC); - intmsk = readl(pdsim->reg_base + S5P_DSIM_INTMSK); + intsrc = readl(dsim->reg_base + S5P_DSIM_INTSRC); + intmsk = readl(dsim->reg_base + S5P_DSIM_INTMSK); intmsk = ~(intmsk) & intsrc; @@ -464,16 +433,18 @@ static irqreturn_t s5p_dsim_isr(int irq, void *dev_id) break; case S5P_DSIM_INT_MSK_FRAME_DONE: /* printk("S5P_DSIM_INT_MSK_FRAME_DONE\n"); */ - if (s3cfb_vsync_status_check() && dsim.mipi_ddi_pd->resume_complete == 1) { + if (dsim->dsim_lcd_info->lcd_enabled && dsim->mipi_ddi_pd->resume_complete) { if (completion_done(&dsim_wr_comp) && completion_done(&dsim_rd_comp)) { - s5p_dsim_toggle_hs_clock(dsim.reg_base); - if (!dsim_toggle_per_frame_count) { - s5p_dsim_frame_done_interrupt_enable(0); - if (likely(dsim.dsim_info->hs_toggle - 1)) - schedule_delayed_work(&dsim_work, dsim.dsim_info->hs_toggle); + if (s3cfb_vsync_status_check()) { + s5p_dsim_toggle_hs_clock(dsim->reg_base); + if (!dsim->dsim_toggle_per_frame_count) { + s5p_dsim_frame_done_interrupt_enable(dsim, 0); + if (likely(dsim->dsim_info->hs_toggle - 1)) + schedule_delayed_work(&dsim->dsim_work, dsim->dsim_info->hs_toggle); + } + if (dsim->dsim_toggle_per_frame_count) + dsim->dsim_toggle_per_frame_count--; } - if (dsim_toggle_per_frame_count) - dsim_toggle_per_frame_count--; } } break; @@ -481,20 +452,20 @@ static irqreturn_t s5p_dsim_isr(int irq, void *dev_id) } } /* clear irq */ - writel(intsrc, pdsim->reg_base + S5P_DSIM_INTSRC); + writel(intsrc, dsim->reg_base + S5P_DSIM_INTSRC); return IRQ_HANDLED; } -static void s5p_dsim_init_header_fifo(void) +static void s5p_dsim_init_header_fifo(struct dsim_global *dsim) { unsigned int cnt; for (cnt = 0; cnt < DSIM_HEADER_FIFO_SZ; cnt++) - dsim.header_fifo_index[cnt] = -1; + dsim->header_fifo_index[cnt] = -1; return; } -unsigned char s5p_dsim_pll_on(unsigned int dsim_base, unsigned char enable) +static unsigned char s5p_dsim_pll_on(unsigned int dsim_base, unsigned char enable) { if (enable) { int sw_timeout = 1000; @@ -513,19 +484,20 @@ unsigned char s5p_dsim_pll_on(unsigned int dsim_base, unsigned char enable) return DSIM_TRUE; } -static unsigned long s5p_dsim_change_pll(unsigned int dsim_base, unsigned char pre_divider, +static unsigned long s5p_dsim_change_pll(struct dsim_global *dsim, unsigned char pre_divider, unsigned short main_divider, unsigned char scaler) { unsigned long dfin_pll, dfvco, dpll_out; unsigned char freq_band; unsigned char temp0 = 0, temp1 = 0; + unsigned int dsim_base = dsim->reg_base; dfin_pll = (MIPI_FIN / pre_divider); if (dfin_pll < 6 * 1000 * 1000 || dfin_pll > 12 * 1000 * 1000) { - dev_warn(dsim.dev, "warning!!\n"); - dev_warn(dsim.dev, "fin_pll range is 6MHz ~ 12MHz\n"); - dev_warn(dsim.dev, "fin_pll of mipi dphy pll is %luMHz\n", (dfin_pll / 1000000)); + dev_warn(dsim->dev, "warning!!\n"); + dev_warn(dsim->dev, "fin_pll range is 6MHz ~ 12MHz\n"); + dev_warn(dsim->dev, "fin_pll of mipi dphy pll is %luMHz\n", (dfin_pll / 1000000)); s5p_dsim_enable_afc(dsim_base, 0, 0); } else { @@ -544,16 +516,16 @@ static unsigned long s5p_dsim_change_pll(unsigned int dsim_base, unsigned char p } dfvco = dfin_pll * main_divider; - dev_dbg(dsim.dev, "dfvco = %lu, dfin_pll = %lu, main_divider = %d\n", + dev_dbg(dsim->dev, "dfvco = %lu, dfin_pll = %lu, main_divider = %d\n", dfvco, dfin_pll, main_divider); if (dfvco < 500000000 || dfvco > 1000000000) { - dev_warn(dsim.dev, "Caution!!\n"); - dev_warn(dsim.dev, "fvco range is 500MHz ~ 1000MHz\n"); - dev_warn(dsim.dev, "fvco of mipi dphy pll is %luMHz\n", (dfvco / 1000000)); + dev_warn(dsim->dev, "Caution!!\n"); + dev_warn(dsim->dev, "fvco range is 500MHz ~ 1000MHz\n"); + dev_warn(dsim->dev, "fvco of mipi dphy pll is %luMHz\n", (dfvco / 1000000)); } dpll_out = dfvco / (1 << scaler); - dev_dbg(dsim.dev, "dpll_out = %lu, dfvco = %lu, scaler = %d\n", + dev_dbg(dsim->dev, "dpll_out = %lu, dfvco = %lu, scaler = %d\n", dpll_out, dfvco, scaler); if (dpll_out < 100 * 1000000) freq_band = 0x0; @@ -588,7 +560,7 @@ static unsigned long s5p_dsim_change_pll(unsigned int dsim_base, unsigned char p else freq_band = 0xf; - dev_dbg(dsim.dev, "freq_band = %d\n", freq_band); + dev_dbg(dsim->dev, "freq_band = %d\n", freq_band); s5p_dsim_pll_freq(dsim_base, pre_divider, main_divider, scaler); @@ -599,51 +571,52 @@ static unsigned long s5p_dsim_change_pll(unsigned int dsim_base, unsigned char p s5p_dsim_pll_freq_band(dsim_base, freq_band); /* Stable time */ - s5p_dsim_pll_stable_time(dsim_base, dsim.dsim_info->pll_stable_time); + s5p_dsim_pll_stable_time(dsim_base, dsim->dsim_info->pll_stable_time); /* Enable PLL */ - dev_dbg(dsim.dev, "FOUT of mipi dphy pll is %luMHz\n", (dpll_out / 1000000)); + dev_dbg(dsim->dev, "FOUT of mipi dphy pll is %luMHz\n", (dpll_out / 1000000)); return dpll_out; } -static void s5p_dsim_set_clock(unsigned int dsim_base, +static void s5p_dsim_set_clock(struct dsim_global *dsim, unsigned char byte_clk_sel, unsigned char enable) { unsigned int esc_div; unsigned long esc_clk_error_rate; + unsigned int dsim_base = dsim->reg_base; if (enable) { - dsim.e_clk_src = byte_clk_sel; + dsim->e_clk_src = byte_clk_sel; /* Escape mode clock and byte clock source */ s5p_dsim_set_byte_clock_src(dsim_base, byte_clk_sel); /* DPHY, DSIM Link : D-PHY clock out */ if (byte_clk_sel == DSIM_PLL_OUT_DIV8) { - dsim.hs_clk = s5p_dsim_change_pll(dsim_base, dsim.dsim_info->p, - dsim.dsim_info->m, dsim.dsim_info->s); - dsim.byte_clk = dsim.hs_clk / 8; + dsim->hs_clk = s5p_dsim_change_pll(dsim, dsim->dsim_info->p, + dsim->dsim_info->m, dsim->dsim_info->s); + dsim->byte_clk = dsim->hs_clk / 8; s5p_dsim_enable_pll_bypass(dsim_base, 0); s5p_dsim_pll_on(dsim_base, 1); usleep_range(1000, 1000); /* DPHY : D-PHY clock out, DSIM link : external clock out */ } else if (byte_clk_sel == DSIM_EXT_CLK_DIV8) - dev_warn(dsim.dev, "this project is not supported external clock source for MIPI DSIM\n"); + dev_warn(dsim->dev, "this project is not supported external clock source for MIPI DSIM\n"); else if (byte_clk_sel == DSIM_EXT_CLK_BYPASS) - dev_warn(dsim.dev, "this project is not supported external clock source for MIPI DSIM\n"); + dev_warn(dsim->dev, "this project is not supported external clock source for MIPI DSIM\n"); /* escape clock divider */ - esc_div = dsim.byte_clk / (dsim.dsim_info->esc_clk); - dev_dbg(dsim.dev, "esc_div = %d, byte_clk = %lu, esc_clk = %lu\n", - esc_div, dsim.byte_clk, dsim.dsim_info->esc_clk); - if ((dsim.byte_clk / esc_div) >= 20000000 || - (dsim.byte_clk / esc_div) > dsim.dsim_info->esc_clk) + esc_div = dsim->byte_clk / (dsim->dsim_info->esc_clk); + dev_dbg(dsim->dev, "esc_div = %d, byte_clk = %lu, esc_clk = %lu\n", + esc_div, dsim->byte_clk, dsim->dsim_info->esc_clk); + if ((dsim->byte_clk / esc_div) >= 20000000 || + (dsim->byte_clk / esc_div) > dsim->dsim_info->esc_clk) esc_div += 1; - dsim.escape_clk = dsim.byte_clk / esc_div; - dev_dbg(dsim.dev, "escape_clk = %lu, byte_clk = %lu, esc_div = %d\n", - dsim.escape_clk, dsim.byte_clk, esc_div); + dsim->escape_clk = dsim->byte_clk / esc_div; + dev_dbg(dsim->dev, "escape_clk = %lu, byte_clk = %lu, esc_div = %d\n", + dsim->escape_clk, dsim->byte_clk, esc_div); /* * enable escclk on lane @@ -653,22 +626,22 @@ static void s5p_dsim_set_clock(unsigned int dsim_base, /* enable byte clk and escape clock */ s5p_dsim_set_esc_clk_prs(dsim_base, 1, esc_div); /* escape clock on lane */ - s5p_dsim_enable_esc_clk_on_lane(dsim_base, (DSIM_LANE_CLOCK | dsim.data_lane), 1); - - dev_dbg(dsim.dev, "byte clock is %luMHz\n", (dsim.byte_clk / 1000000)); - dev_dbg(dsim.dev, "escape clock that user's need is %lu\n", (dsim.dsim_info->esc_clk / 1000000)); - dev_dbg(dsim.dev, "escape clock divider is %x\n", esc_div); - dev_dbg(dsim.dev, "escape clock is %luMHz\n", ((dsim.byte_clk / esc_div) / 1000000)); - - if ((dsim.byte_clk / esc_div) > dsim.escape_clk) { - esc_clk_error_rate = dsim.escape_clk / (dsim.byte_clk / esc_div); - dev_warn(dsim.dev, "error rate is %lu over.\n", (esc_clk_error_rate / 100)); - } else if ((dsim.byte_clk / esc_div) < (dsim.escape_clk)) { - esc_clk_error_rate = (dsim.byte_clk / esc_div) / dsim.escape_clk; - dev_warn(dsim.dev, "error rate is %lu under.\n", (esc_clk_error_rate / 100)); + s5p_dsim_enable_esc_clk_on_lane(dsim_base, (DSIM_LANE_CLOCK | dsim->data_lane), 1); + + dev_dbg(dsim->dev, "byte clock is %luMHz\n", (dsim->byte_clk / 1000000)); + dev_dbg(dsim->dev, "escape clock that user's need is %lu\n", (dsim->dsim_info->esc_clk / 1000000)); + dev_dbg(dsim->dev, "escape clock divider is %x\n", esc_div); + dev_dbg(dsim->dev, "escape clock is %luMHz\n", ((dsim->byte_clk / esc_div) / 1000000)); + + if ((dsim->byte_clk / esc_div) > dsim->escape_clk) { + esc_clk_error_rate = dsim->escape_clk / (dsim->byte_clk / esc_div); + dev_warn(dsim->dev, "error rate is %lu over\n", (esc_clk_error_rate / 100)); + } else if ((dsim->byte_clk / esc_div) < (dsim->escape_clk)) { + esc_clk_error_rate = (dsim->byte_clk / esc_div) / dsim->escape_clk; + dev_warn(dsim->dev, "error rate is %lu under\n", (esc_clk_error_rate / 100)); } } else { - s5p_dsim_enable_esc_clk_on_lane(dsim_base, (DSIM_LANE_CLOCK | dsim.data_lane), 0); + s5p_dsim_enable_esc_clk_on_lane(dsim_base, (DSIM_LANE_CLOCK | dsim->data_lane), 0); s5p_dsim_set_esc_clk_prs(dsim_base, 0, 0); s5p_dsim_enable_byte_clock(dsim_base, DSIM_FALSE); @@ -678,88 +651,93 @@ static void s5p_dsim_set_clock(unsigned int dsim_base, } } -static int s5p_dsim_late_resume_init_dsim(unsigned int dsim_base) +static int s5p_dsim_late_resume_init_dsim(struct dsim_global *dsim) { - if (dsim.pd->init_d_phy) - dsim.pd->init_d_phy(dsim.reg_base); + unsigned int dsim_base = dsim->reg_base; - dsim.state = DSIM_STATE_RESET; + if (dsim->pd->init_d_phy) + dsim->pd->init_d_phy(dsim->reg_base); - switch (dsim.dsim_info->e_no_data_lane) { + dsim->state = DSIM_STATE_RESET; + + switch (dsim->dsim_info->e_no_data_lane) { case DSIM_DATA_LANE_1: - dsim.data_lane = DSIM_LANE_DATA0; + dsim->data_lane = DSIM_LANE_DATA0; break; case DSIM_DATA_LANE_2: - dsim.data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1; + dsim->data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1; break; case DSIM_DATA_LANE_3: - dsim.data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | + dsim->data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | DSIM_LANE_DATA2; break; case DSIM_DATA_LANE_4: - dsim.data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | + dsim->data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | DSIM_LANE_DATA2 | DSIM_LANE_DATA3; break; default: - dev_info(dsim.dev, "data lane is invalid.\n"); + dev_info(dsim->dev, "data lane is invalid\n"); return -1; }; - s5p_dsim_init_header_fifo(); + s5p_dsim_init_header_fifo(dsim); s5p_dsim_sw_reset(dsim_base); - s5p_dsim_dp_dn_swap(dsim_base, dsim.dsim_info->e_lane_swap); + s5p_dsim_dp_dn_swap(dsim_base, dsim->dsim_info->e_lane_swap); /* enable only frame done interrupt */ /* s5p_dsim_clear_interrupt(dsim_base, AllDsimIntr); */ - /* s5p_dsim_set_interrupt_mask(dsim.reg_base, AllDsimIntr, 1); */ + /* s5p_dsim_set_interrupt_mask(dsim->reg_base, AllDsimIntr, 1); */ return 0; } #if 0 -static int s5p_dsim_init_dsim(unsigned int dsim_base) +static int s5p_dsim_init_dsim(struct dsim_global *dsim) { - if (dsim.pd->init_d_phy) - dsim.pd->init_d_phy(dsim.reg_base); + unsigned int dsim_base = dsim->reg_base; + + if (dsim->pd->init_d_phy) + dsim->pd->init_d_phy(dsim->reg_base); - dsim.state = DSIM_STATE_RESET; + dsim->state = DSIM_STATE_RESET; - switch (dsim.dsim_info->e_no_data_lane) { + switch (dsim->dsim_info->e_no_data_lane) { case DSIM_DATA_LANE_1: - dsim.data_lane = DSIM_LANE_DATA0; + dsim->data_lane = DSIM_LANE_DATA0; break; case DSIM_DATA_LANE_2: - dsim.data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1; + dsim->data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1; break; case DSIM_DATA_LANE_3: - dsim.data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | + dsim->data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | DSIM_LANE_DATA2; break; case DSIM_DATA_LANE_4: - dsim.data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | + dsim->data_lane = DSIM_LANE_DATA0 | DSIM_LANE_DATA1 | DSIM_LANE_DATA2 | DSIM_LANE_DATA3; break; default: - dev_info(dsim.dev, "data lane is invalid.\n"); + dev_info(dsim->dev, "data lane is invalid\n"); return -1; }; - s5p_dsim_init_header_fifo(); - s5p_dsim_dp_dn_swap(dsim_base, dsim.dsim_info->e_lane_swap); + s5p_dsim_init_header_fifo(dsim); + s5p_dsim_dp_dn_swap(dsim_base, dsim->dsim_info->e_lane_swap); /* enable only frame done interrupt */ /* s5p_dsim_clear_interrupt(dsim_base, AllDsimIntr); */ - /* s5p_dsim_set_interrupt_mask(dsim.reg_base, AllDsimIntr, 1); */ + /* s5p_dsim_set_interrupt_mask(dsim->reg_base, AllDsimIntr, 1); */ return 0; } #endif -static void s5p_dsim_set_display_mode(unsigned int dsim_base, +static void s5p_dsim_set_display_mode(struct dsim_global *dsim, struct dsim_lcd_config *main_lcd, struct dsim_lcd_config *sub_lcd) { struct s3cfb_lcd *main_lcd_panel_info = NULL, *sub_lcd_panel_info = NULL; struct s3cfb_lcd_timing *main_timing = NULL; + unsigned int dsim_base = dsim->reg_base; if (main_lcd != NULL) { if (main_lcd->lcd_panel_info != NULL) { @@ -770,18 +748,18 @@ static void s5p_dsim_set_display_mode(unsigned int dsim_base, main_lcd_panel_info->height, main_lcd_panel_info->width); } else - dev_warn(dsim.dev, "lcd panel info of main lcd is NULL.\n"); + dev_warn(dsim->dev, "lcd panel info of main lcd is NULL\n"); } else { - dev_err(dsim.dev, "main lcd is NULL.\n"); + dev_err(dsim->dev, "main lcd is NULL\n"); return; } /* in case of VIDEO MODE (RGB INTERFACE) */ - if (dsim.dsim_lcd_info->e_interface == (u32) DSIM_VIDEO) { + if (dsim->dsim_lcd_info->e_interface == (u32)DSIM_VIDEO) { main_timing = &main_lcd_panel_info->timing; if (main_timing == NULL) { - dev_err(dsim.dev, "main_timing is NULL.\n"); + dev_err(dsim->dev, "main_timing is NULL\n"); return; } @@ -805,130 +783,131 @@ static void s5p_dsim_set_display_mode(unsigned int dsim_base, sub_lcd_panel_info->height, sub_lcd_panel_info->width); } else - dev_warn(dsim.dev, "lcd panel info of sub lcd is NULL.\n"); + dev_warn(dsim->dev, "lcd panel info of sub lcd is NULL\n"); } } - s5p_dsim_display_config(dsim_base, dsim.dsim_lcd_info, NULL); + s5p_dsim_display_config(dsim_base, dsim->dsim_lcd_info, NULL); } -static int s5p_dsim_init_link(unsigned int dsim_base) +static int s5p_dsim_init_link(struct dsim_global *dsim) { unsigned int time_out = 100; + unsigned int dsim_base = dsim->reg_base; - switch (dsim.state) { + switch (dsim->state) { case DSIM_STATE_RESET: case DSIM_STATE_INIT: - printk(KERN_INFO "%s\n", __func__); s5p_dsim_init_fifo_pointer(dsim_base, 0x0); usleep_range(10000, 10000); s5p_dsim_init_fifo_pointer(dsim_base, 0x1f); /* dsi configuration */ - s5p_dsim_init_config(dsim_base, dsim.dsim_lcd_info, NULL, dsim.dsim_info); + s5p_dsim_init_config(dsim_base, dsim->dsim_lcd_info, NULL, dsim->dsim_info); s5p_dsim_enable_lane(dsim_base, DSIM_LANE_CLOCK, 1); - s5p_dsim_enable_lane(dsim_base, dsim.data_lane, 1); + s5p_dsim_enable_lane(dsim_base, dsim->data_lane, 1); /* set clock configuration */ - s5p_dsim_set_clock(dsim_base, dsim.dsim_info->e_byte_clk, 1); + s5p_dsim_set_clock(dsim, dsim->dsim_info->e_byte_clk, 1); usleep_range(5000, 5000); /* check clock and data lane state is stop state */ while (!(s5p_dsim_is_lane_state(dsim_base, DSIM_LANE_CLOCK) == DSIM_LANE_STATE_STOP) && - !(s5p_dsim_is_lane_state(dsim_base, dsim.data_lane) == DSIM_LANE_STATE_STOP)) { + !(s5p_dsim_is_lane_state(dsim_base, dsim->data_lane) == DSIM_LANE_STATE_STOP)) { time_out--; if (time_out == 0) { - dev_info(dsim.dev, "DSI Master state is not stop state!!!\n"); - dev_info(dsim.dev, "Please check initialization process\n"); + dev_info(dsim->dev, "DSI Master state is not stop state!!!\n"); + dev_info(dsim->dev, "Please check initialization process\n"); return DSIM_FALSE; } } if (time_out != 0) { - /* dev_info(dsim.dev, "initialization of DSI Master is successful\n"); */ - /* dev_info(dsim.dev, "DSI Master state is stop state\n"); */ + /* dev_info(dsim->dev, "initialization of DSI Master is successful\n"); */ + /* dev_info(dsim->dev, "DSI Master state is stop state\n"); */ } - dsim.state = DSIM_STATE_STOP; + dsim->state = DSIM_STATE_STOP; /* BTA sequence counters */ - s5p_dsim_set_stop_state_counter(dsim_base, dsim.dsim_info->stop_holding_cnt); - s5p_dsim_set_bta_timeout(dsim_base, dsim.dsim_info->bta_timeout); - s5p_dsim_set_lpdr_timeout(dsim_base, dsim.dsim_info->rx_timeout); + s5p_dsim_set_stop_state_counter(dsim_base, dsim->dsim_info->stop_holding_cnt); + s5p_dsim_set_bta_timeout(dsim_base, dsim->dsim_info->bta_timeout); + s5p_dsim_set_lpdr_timeout(dsim_base, dsim->dsim_info->rx_timeout); /* default LPDT by both cpu and lcd controller */ - s5p_dsim_set_data_mode(dsim_base, DSIM_TRANSFER_BOTH, - DSIM_STATE_STOP); + s5p_dsim_set_data_mode(dsim_base, DSIM_TRANSFER_BOTH, DSIM_STATE_STOP); return DSIM_TRUE; default: - dev_info(dsim.dev, "DSI Master is already init.\n"); + dev_info(dsim->dev, "DSI Master is already init\n"); return DSIM_FALSE; } } -unsigned char s5p_dsim_set_hs_enable(unsigned int dsim_base) +static unsigned char s5p_dsim_set_hs_enable(struct dsim_global *dsim) { u8 ret = DSIM_FALSE; + unsigned int dsim_base = dsim->reg_base; - if (dsim.state == DSIM_STATE_STOP) { - if (dsim.e_clk_src != DSIM_EXT_CLK_BYPASS) { - dsim.state = DSIM_STATE_HSCLKEN; - s5p_dsim_set_data_mode(dsim_base, DSIM_TRANSFER_BOTH, - DSIM_STATE_HSCLKEN); + if (dsim->state == DSIM_STATE_STOP) { + if (dsim->e_clk_src != DSIM_EXT_CLK_BYPASS) { + dsim->state = DSIM_STATE_HSCLKEN; + s5p_dsim_set_data_mode(dsim_base, DSIM_TRANSFER_BOTH, DSIM_STATE_HSCLKEN); s5p_dsim_enable_hs_clock(dsim_base, 1); ret = DSIM_TRUE; } else - dev_warn(dsim.dev, "clock source is external bypass.\n"); + dev_warn(dsim->dev, "clock source is external bypass\n"); } else - dev_warn(dsim.dev, "DSIM is not stop state.\n"); + dev_warn(dsim->dev, "DSIM is not stop state\n"); return ret; } #if 0 -static unsigned char s5p_dsim_set_stopstate(unsigned int dsim_base) +static unsigned char s5p_dsim_set_stopstate(struct dsim_global *dsim) { u8 ret = DSIM_FALSE; + unsigned int dsim_base = dsim->reg_base; - if (dsim.state == DSIM_STATE_HSCLKEN) { - if (dsim.e_clk_src != DSIM_EXT_CLK_BYPASS) { - dsim.state = DSIM_STATE_STOP; + if (dsim->state == DSIM_STATE_HSCLKEN) { + if (dsim->e_clk_src != DSIM_EXT_CLK_BYPASS) { + dsim->state = DSIM_STATE_STOP; s5p_dsim_enable_hs_clock(dsim_base, 0); ret = DSIM_TRUE; } else - dev_warn(dsim.dev, "clock source is external bypass.\n"); - } else if (dsim.state == DSIM_STATE_ULPS) { + dev_warn(dsim->dev, "clock source is external bypass\n"); + } else if (dsim->state == DSIM_STATE_ULPS) { /* will be update for exiting ulps */ ret = DSIM_TRUE; - } else if (dsim.state == DSIM_STATE_STOP) { - dev_warn(dsim.dev, "DSIM is already stop state.\n"); + } else if (dsim->state == DSIM_STATE_STOP) { + dev_warn(dsim->dev, "DSIM is already stop state\n"); ret = DSIM_TRUE; } else - dev_warn(dsim.dev, "DSIM is not stop state.\n"); + dev_warn(dsim->dev, "DSIM is not stop state\n"); return ret; } #endif -static unsigned char s5p_dsim_set_data_transfer_mode(unsigned int dsim_base, +static unsigned char s5p_dsim_set_data_transfer_mode(struct dsim_global *dsim, unsigned char data_path, unsigned char hs_enable) { u8 ret = DSIM_FALSE; + unsigned int dsim_base = dsim->reg_base; if (hs_enable) { - if (dsim.state == DSIM_STATE_HSCLKEN) { + if (dsim->state == DSIM_STATE_HSCLKEN) { s5p_dsim_set_data_mode(dsim_base, data_path, DSIM_STATE_HSCLKEN); ret = DSIM_TRUE; } else { - dev_err(dsim.dev, "HS Clock lane is not enabled.\n"); + dev_err(dsim->dev, "HS Clock lane is not enabled\n"); ret = DSIM_FALSE; } } else { - if (dsim.state == DSIM_STATE_INIT || dsim.state == DSIM_STATE_ULPS) { - dev_err(dsim.dev, "DSI Master is not STOP or HSDT state.\n"); + if (dsim->state == DSIM_STATE_INIT || dsim->state == DSIM_STATE_ULPS) { + dev_err(dsim->dev, "DSI Master is not STOP or HSDT state\n"); ret = DSIM_FALSE; } else { s5p_dsim_set_data_mode(dsim_base, data_path, DSIM_STATE_STOP); @@ -941,7 +920,8 @@ static unsigned char s5p_dsim_set_data_transfer_mode(unsigned int dsim_base, int s5p_dsim_register_lcd_driver(struct mipi_lcd_driver *lcd_drv) { - struct mipi_lcd_info *lcd_info = NULL; + struct mipi_lcd_info *lcd_info = NULL; + struct dsim_global *dsim = g_dsim; lcd_info = kmalloc(sizeof(struct mipi_lcd_info), GFP_KERNEL); if (lcd_info == NULL) @@ -959,45 +939,42 @@ int s5p_dsim_register_lcd_driver(struct mipi_lcd_driver *lcd_drv) list_add_tail(&lcd_info->list, &lcd_info_list); mutex_unlock(&mipi_lock); - dev_dbg(dsim.dev, "registered lcd panel driver(%s) to mipi-dsi driver.\n", - lcd_drv->name); + dev_dbg(dsim->dev, "registered lcd panel driver(%s) to mipi-dsi driver\n", lcd_drv->name); return 0; } -struct mipi_lcd_driver *scan_mipi_driver(const char *name) +static struct mipi_lcd_driver *scan_mipi_driver(struct dsim_global *dsim, const char *name) { struct mipi_lcd_info *lcd_info; struct mipi_lcd_driver *mipi_drv = NULL; mutex_lock(&mipi_lock); - dev_dbg(dsim.dev, "find lcd panel driver(%s).\n", - name); + dev_dbg(dsim->dev, "find lcd panel driver(%s)\n", name); list_for_each_entry(lcd_info, &lcd_info_list, list) { mipi_drv = lcd_info->mipi_drv; if ((strcmp(mipi_drv->name, name)) == 0) { mutex_unlock(&mipi_lock); - dev_dbg(dsim.dev, "found!!!(%s).\n", mipi_drv->name); + dev_dbg(dsim->dev, "found!!!(%s)\n", mipi_drv->name); return mipi_drv; } } - dev_warn(dsim.dev, "failed to find lcd panel driver(%s).\n", - name); + dev_warn(dsim->dev, "failed to find lcd panel driver(%s)\n", name); mutex_unlock(&mipi_lock); return NULL; } -void s5p_dsim_interrupt_mask_set(void) +static void s5p_dsim_interrupt_mask_set(struct dsim_global *dsim) { u32 int_stat; - int_stat = readl(dsim.reg_base + S5P_DSIM_INTMSK); + int_stat = readl(dsim->reg_base + S5P_DSIM_INTMSK); int_stat &= ~((0x01<<S5P_DSIM_INT_BTA) | (0x01<<S5P_DSIM_INT_RX_TIMEOUT) | (0x01<<S5P_DSIM_INT_BTA_TIMEOUT) | (0x01 << S5P_DSIM_INT_RX_DONE) | @@ -1005,26 +982,27 @@ void s5p_dsim_interrupt_mask_set(void) (0x01<<S5P_DSIM_INT_RX_ECC_ERR) | (0x01<<S5P_DSIM_IMT_RX_CRC_ERR) | (0x01<<S5P_DSIM_INT_SFR_FIFO_EMPTY)); - writel(int_stat, dsim.reg_base + S5P_DSIM_INTMSK); + writel(int_stat, dsim->reg_base + S5P_DSIM_INTMSK); } int s5p_dsim_fifo_clear(void) { int dsim_count = 0, ret; + struct dsim_global *dsim = g_dsim; - writel(SwRstRelease, dsim.reg_base + S5P_DSIM_INTSRC); + writel(SwRstRelease, dsim->reg_base + S5P_DSIM_INTSRC); - writel(DSIM_FUNCRST, dsim.reg_base + S5P_DSIM_SWRST); + writel(DSIM_FUNCRST, dsim->reg_base + S5P_DSIM_SWRST); do { if (++dsim_count > 90000) { - printk(KERN_ERR "dsim fifo clear fail re_try dsim resume\n"); + dev_err(dsim->dev, "dsim fifo clear fail re_try dsim resume\n"); ret = 0; break; } - if (readl(dsim.reg_base + S5P_DSIM_INTSRC) & SwRstRelease) { - s5p_dsim_interrupt_mask_set(); + if (readl(dsim->reg_base + S5P_DSIM_INTSRC) & SwRstRelease) { + s5p_dsim_interrupt_mask_set(dsim); ret = 1; break; } @@ -1038,16 +1016,17 @@ void s5p_dsim_early_suspend(void) { u32 int_stat = 0; pm_message_t state; + struct dsim_global *dsim = g_dsim; - printk(KERN_INFO "+%s\n", __func__); + dev_info(dsim->dev, "+%s\n", __func__); - if (dsim.mipi_ddi_pd->resume_complete == 0) + if (dsim->mipi_ddi_pd->resume_complete == 0) return; - dsim.mipi_ddi_pd->resume_complete = 0; - dsim.dsim_lcd_info->lcd_enabled = 0; + dsim->mipi_ddi_pd->resume_complete = 0; + dsim->dsim_lcd_info->lcd_enabled = 0; - /* int_stat = readl(dsim.reg_base + S5P_DSIM_INTMSK); */ + /* int_stat = readl(dsim->reg_base + S5P_DSIM_INTMSK); */ int_stat |= ((0x01<<S5P_DSIM_INT_BTA) | (0x01<<S5P_DSIM_INT_RX_TIMEOUT) | (0x01<<S5P_DSIM_INT_BTA_TIMEOUT) | (0x01 << S5P_DSIM_INT_RX_DONE) | @@ -1055,134 +1034,140 @@ void s5p_dsim_early_suspend(void) (0x01<<S5P_DSIM_INT_RX_ECC_ERR) | (0x01<<S5P_DSIM_IMT_RX_CRC_ERR) | (0x01<<S5P_DSIM_INT_SFR_FIFO_EMPTY) | (0x01 << S5P_DSIM_INT_MSK_FRAME_DONE)); - writel(int_stat, dsim.reg_base + S5P_DSIM_INTMSK); + writel(int_stat, dsim->reg_base + S5P_DSIM_INTMSK); - /* disable_irq(dsim.irq); */ + /* disable_irq(dsim->irq); */ state.event = PM_EVENT_SUSPEND; - if (dsim.mipi_drv->suspend) - dsim.mipi_drv->suspend(dsim.dev, state); + if (dsim->mipi_drv->suspend) + dsim->mipi_drv->suspend(dsim->dev, state); - if (dsim.mipi_ddi_pd->lcd_power_on) - dsim.mipi_ddi_pd->lcd_power_on(dsim.dev, 0); + if (dsim->mipi_ddi_pd->lcd_power_on) + dsim->mipi_ddi_pd->lcd_power_on(dsim->dev, 0); - s5p_dsim_enable_hs_clock(dsim.reg_base, 0); - s5p_dsim_set_clock(dsim.reg_base, dsim.dsim_info->e_byte_clk, 0); + s5p_dsim_enable_hs_clock(dsim->reg_base, 0); + s5p_dsim_set_clock(dsim, dsim->dsim_info->e_byte_clk, 0); #if defined(CONFIG_CPU_EXYNOS4210) - writel(0x1, dsim.reg_base + S5P_DSIM_SWRST); + writel(0x1, dsim->reg_base + S5P_DSIM_SWRST); #endif - if (dsim.pd->exit_d_phy) - dsim.pd->exit_d_phy(dsim.reg_base); + if (dsim->pd->exit_d_phy) + dsim->pd->exit_d_phy(dsim->reg_base); - clk_disable(dsim.clock); + clk_disable(dsim->clock); - if (dsim.pd->mipi_power) - dsim.pd->mipi_power(0); + if (dsim->pd->mipi_power) + dsim->pd->mipi_power(0); - printk(KERN_INFO "-%s\n", __func__); + dev_info(dsim->dev, "-%s\n", __func__); return; } void s5p_dsim_late_resume(void) { - printk(KERN_INFO "+%s\n", __func__); + struct dsim_global *dsim = g_dsim; + + dev_info(dsim->dev, "+%s\n", __func__); /* MIPI SIGNAL ON */ - if (dsim.pd->mipi_power) - dsim.pd->mipi_power(1); + if (dsim->pd->mipi_power) + dsim->pd->mipi_power(1); - clk_enable(dsim.clock); + clk_enable(dsim->clock); usleep_range(10000, 10000); - if (dsim.mipi_ddi_pd->lcd_power_on) - dsim.mipi_ddi_pd->lcd_power_on(dsim.dev, 1); + if (dsim->mipi_ddi_pd->lcd_power_on) + dsim->mipi_ddi_pd->lcd_power_on(dsim->dev, 1); usleep_range(25000, 25000); - if (dsim.mipi_ddi_pd->lcd_reset) - dsim.mipi_ddi_pd->lcd_reset(); + if (dsim->mipi_ddi_pd->lcd_reset) + dsim->mipi_ddi_pd->lcd_reset(); usleep_range(5000, 5000); - s5p_dsim_late_resume_init_dsim(dsim.reg_base); - s5p_dsim_init_link(dsim.reg_base); + s5p_dsim_late_resume_init_dsim(dsim); + s5p_dsim_init_link(dsim); usleep_range(10000, 10000); - s5p_dsim_set_hs_enable(dsim.reg_base); - s5p_dsim_set_data_transfer_mode(dsim.reg_base, DSIM_TRANSFER_BYCPU, 1); - s5p_dsim_set_display_mode(dsim.reg_base, dsim.dsim_lcd_info, NULL); - s5p_dsim_set_data_transfer_mode(dsim.reg_base, DSIM_TRANSFER_BYLCDC, 1); - /* s5p_dsim_set_interrupt_mask(dsim.reg_base, AllDsimIntr, 0); */ + s5p_dsim_set_hs_enable(dsim); + s5p_dsim_set_data_transfer_mode(dsim, DSIM_TRANSFER_BYCPU, 1); + s5p_dsim_set_display_mode(dsim, dsim->dsim_lcd_info, NULL); + s5p_dsim_set_data_transfer_mode(dsim, DSIM_TRANSFER_BYLCDC, 1); + /* s5p_dsim_set_interrupt_mask(dsim->reg_base, AllDsimIntr, 0); */ - dsim.mipi_ddi_pd->resume_complete = 1; + dsim->mipi_ddi_pd->resume_complete = 1; - printk(KERN_INFO "-%s\n", __func__); + dev_info(dsim->dev, "-%s\n", __func__); return; } #else #ifdef CONFIG_PM -int s5p_dsim_suspend(struct platform_device *pdev, pm_message_t state) +static int s5p_dsim_suspend(struct platform_device *pdev, pm_message_t state) { - printk(KERN_INFO "%s\n", __func__); + struct dsim_global *dsim = platform_get_drvdata(pdev); + + dev_info(&pdev->dev, "%s\n", __func__); - dsim.mipi_ddi_pd->resume_complete = 0; + dsim->mipi_ddi_pd->resume_complete = 0; - if (dsim.mipi_drv->suspend) - dsim.mipi_drv->suspend(&pdev->dev, state); + if (dsim->mipi_drv->suspend) + dsim->mipi_drv->suspend(&pdev->dev, state); else - dev_warn(&pdev->dev, "suspend func is null.\n"); + dev_warn(&pdev->dev, "suspend func is null\n"); - clk_disable(dsim.clock); + clk_disable(dsim->clock); - if (dsim.pd->mipi_power) - dsim.pd->mipi_power(0); + if (dsim->pd->mipi_power) + dsim->pd->mipi_power(0); else - dev_warn(&pdev->dev, "mipi_power func is null.\n"); + dev_warn(&pdev->dev, "mipi_power func is null\n"); return 0; } -int s5p_dsim_resume(struct platform_device *pdev) +static int s5p_dsim_resume(struct platform_device *pdev) { u32 int_stat; - printk(KERN_INFO "%s\n", __func__); + struct dsim_global *dsim = platform_get_drvdata(pdev); + + dev_info(&pdev->dev, "%s\n", __func__); - if (dsim.pd->mipi_power) - dsim.pd->mipi_power(1); + if (dsim->pd->mipi_power) + dsim->pd->mipi_power(1); else - dev_warn(&pdev->dev, "mipi_power func is null.\n"); + dev_warn(&pdev->dev, "mipi_power func is null\n"); usleep_range(10000, 10000); - clk_enable(dsim.clock); + clk_enable(dsim->clock); - if (dsim.mipi_drv->resume) - dsim.mipi_drv->resume(&pdev->dev); + if (dsim->mipi_drv->resume) + dsim->mipi_drv->resume(&pdev->dev); else - dev_warn(&pdev->dev, "resume func is null.\n"); + dev_warn(&pdev->dev, "resume func is null\n"); - s5p_dsim_init_dsim(dsim.reg_base); - s5p_dsim_init_link(dsim.reg_base); + s5p_dsim_init_dsim(dsim); + s5p_dsim_init_link(dsim); - s5p_dsim_set_hs_enable(dsim.reg_base); - s5p_dsim_set_data_transfer_mode(dsim.reg_base, DSIM_TRANSFER_BYCPU, 1); + s5p_dsim_set_hs_enable(dsim); + s5p_dsim_set_data_transfer_mode(dsim, DSIM_TRANSFER_BYCPU, 1); msleep(120); /* initialize lcd panel */ - if (dsim.mipi_drv->init) - dsim.mipi_drv->init(&pdev->dev); + if (dsim->mipi_drv->init) + dsim->mipi_drv->init(&pdev->dev); else - dev_warn(&pdev->dev, "init func is null.\n"); + dev_warn(&pdev->dev, "init func is null\n"); - s5p_dsim_set_display_mode(dsim.reg_base, dsim.dsim_lcd_info, NULL); + s5p_dsim_set_display_mode(dsim, dsim->dsim_lcd_info, NULL); - s5p_dsim_set_data_transfer_mode(dsim.reg_base, DSIM_TRANSFER_BYLCDC, 1); + s5p_dsim_set_data_transfer_mode(dsim, DSIM_TRANSFER_BYLCDC, 1); - int_stat = readl(dsim.reg_base + S5P_DSIM_INTMSK); + int_stat = readl(dsim->reg_base + S5P_DSIM_INTMSK); int_stat &= ~((0x01<<S5P_DSIM_INT_BTA) | (0x01<<S5P_DSIM_INT_RX_TIMEOUT) | (0x01<<S5P_DSIM_INT_BTA_TIMEOUT) | (0x01 << S5P_DSIM_INT_RX_DONE) | @@ -1190,9 +1175,9 @@ int s5p_dsim_resume(struct platform_device *pdev) (0x01<<S5P_DSIM_INT_RX_ECC_ERR) | (0x01<<S5P_DSIM_IMT_RX_CRC_ERR) | (0x01<<S5P_DSIM_INT_SFR_FIFO_EMPTY)); - writel(int_stat, dsim.reg_base + S5P_DSIM_INTMSK); + writel(int_stat, dsim->reg_base + S5P_DSIM_INTMSK); - dsim.mipi_ddi_pd->resume_complete = 1; + dsim->mipi_ddi_pd->resume_complete = 1; return 0; } @@ -1201,17 +1186,21 @@ int s5p_dsim_resume(struct platform_device *pdev) #define s5p_dsim_resume NULL #endif #endif + u32 read_dsim_register(u32 num) { - return readl(dsim.reg_base + (num*4)); + struct dsim_global *dsim = g_dsim; + + return readl(dsim->reg_base + (num*4)); } static ssize_t hs_toggle_show(struct device *dev, struct device_attribute *attr, char *buf) { char temp[3]; + struct dsim_global *dsim = container_of(dev, struct dsim_global, panel); - sprintf(temp, "%d\n", jiffies_to_msecs(dsim.dsim_info->hs_toggle)); + sprintf(temp, "%d\n", jiffies_to_msecs(dsim->dsim_info->hs_toggle)); strcpy(buf, temp); return strlen(buf); @@ -1222,22 +1211,22 @@ static int hs_toggle_store(struct device *dev, { int value; int rc; + struct dsim_global *dsim = container_of(dev, struct dsim_global, panel); rc = strict_strtoul(buf, (unsigned int)0, (unsigned long *)&value); if (rc < 0) return rc; else { - dev_info(dev, "%s - %d, %d\n", __func__, jiffies_to_msecs(dsim.dsim_info->hs_toggle), value); + dev_info(dev, "%s - %d, %d\n", __func__, jiffies_to_msecs(dsim->dsim_info->hs_toggle), value); if (value == 1) { - dsim.dsim_info->hs_toggle = msecs_to_jiffies(3000); - s5p_dsim_frame_done_interrupt_enable(1); - schedule_delayed_work(&check_hs_toggle_work,\ - msecs_to_jiffies(120000)); + dsim->dsim_info->hs_toggle = msecs_to_jiffies(3000); + s5p_dsim_frame_done_interrupt_enable(dsim, 1); + schedule_delayed_work(&dsim->check_hs_toggle_work, msecs_to_jiffies(120000)); } else { - dsim.dsim_info->hs_toggle = 0; - s5p_dsim_frame_done_interrupt_enable(0); - cancel_delayed_work(&check_hs_toggle_work); + dsim->dsim_info->hs_toggle = 0; + s5p_dsim_frame_done_interrupt_enable(dsim, 0); + cancel_delayed_work(&dsim->check_hs_toggle_work); } } return size; @@ -1250,10 +1239,11 @@ static ssize_t dsim_dump_show(struct device *dev, { int reg_val, i; char temp[50]; + struct dsim_global *dsim = dev_get_drvdata(dev); for (i = 0; i < 25; i++) { - reg_val = readl(dsim.reg_base + i*4); - sprintf(temp, "[DSIM]0x11c8_00%02X = 0x%08X\n", (i*4), reg_val); + reg_val = readl(dsim->reg_base + i*4); + sprintf(temp, "[DSIM]0x11C8_00%02X = 0x%08X\n", (i*4), reg_val); strcat(buf, temp); } @@ -1261,43 +1251,57 @@ static ssize_t dsim_dump_show(struct device *dev, } static DEVICE_ATTR(dsim_dump, 0444, dsim_dump_show, NULL); +static struct dsim_ops s5p_dsim_ops = { + .cmd_write = s5p_dsim_wr_data, + .cmd_read = s5p_dsim_rd_data, + .suspend = s5p_dsim_early_suspend, + .resume = s5p_dsim_late_resume, +}; + static int s5p_dsim_probe(struct platform_device *pdev) { struct resource *res; int ret = -1; u32 int_stat; - INIT_DELAYED_WORK(&dsim_work, dsim_work_q_handler); - INIT_DELAYED_WORK(&check_hs_toggle_work, \ - dsim_check_hs_toggle_work_q_handler); + struct dsim_global *dsim; + + dsim = kzalloc(sizeof(struct dsim_global), GFP_KERNEL); + if (!dsim) { + pr_err("failed to allocate for dsim_global\n"); + ret = -ENOMEM; + goto err_alloc; + } - dsim.pd = to_dsim_plat(&pdev->dev); - if (!dsim.pd) { + g_dsim = dsim; + + dsim->pd = to_dsim_plat(&pdev->dev); + if (!dsim->pd) { dev_err(&pdev->dev, "platform data is NULL\n"); return -EINVAL; } - dsim.dev = &pdev->dev; + dsim->dev = &pdev->dev; /* set dsim config data, dsim lcd config data and lcd panel data. */ - dsim.dsim_info = dsim.pd->dsim_info; - dsim.dsim_lcd_info = dsim.pd->dsim_lcd_info; - dsim.lcd_panel_info = (struct s3cfb_lcd *) dsim.dsim_lcd_info->lcd_panel_info; - dsim.mipi_ddi_pd = (struct mipi_ddi_platform_data *) dsim.dsim_lcd_info->mipi_ddi_pd; - dsim.mipi_ddi_pd->te_irq = dsim.pd->te_irq; + dsim->dsim_info = dsim->pd->dsim_info; + dsim->dsim_lcd_info = dsim->pd->dsim_lcd_info; + dsim->lcd_panel_info = (struct s3cfb_lcd *) dsim->dsim_lcd_info->lcd_panel_info; + dsim->mipi_ddi_pd = (struct mipi_ddi_platform_data *) dsim->dsim_lcd_info->mipi_ddi_pd; + dsim->mipi_ddi_pd->te_irq = dsim->pd->te_irq; - if (dsim.pd->mipi_power) - dsim.pd->mipi_power(1); + if (dsim->pd->mipi_power) + dsim->pd->mipi_power(1); - strcpy(dsim.pd->lcd_panel_name, dsim.lcd_panel_info->name); + strcpy(dsim->pd->lcd_panel_name, dsim->lcd_panel_info->name); /* clock */ - dsim.clock = clk_get(&pdev->dev, dsim.pd->clk_name); - if (IS_ERR(dsim.clock)) { + dsim->clock = clk_get(&pdev->dev, dsim->pd->clk_name); + if (IS_ERR(dsim->clock)) { dev_err(&pdev->dev, "failed to get dsim clock source\n"); return -EINVAL; } - clk_enable(dsim.clock); + clk_enable(dsim->clock); /* io memory */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); @@ -1317,9 +1321,9 @@ static int s5p_dsim_probe(struct platform_device *pdev) } /* ioremap for register block */ - dsim.reg_base = (unsigned int) ioremap(res->start, + dsim->reg_base = (unsigned int)ioremap(res->start, res->end - res->start + 1); - if (!dsim.reg_base) { + if (!dsim->reg_base) { dev_err(&pdev->dev, "failed to remap io region\n"); ret = -EINVAL; goto err_clk_disable; @@ -1331,15 +1335,15 @@ static int s5p_dsim_probe(struct platform_device *pdev) ret = -EINVAL; goto err_clk_disable; } - /* dsim.irq = res->start; */ + /* dsim->irq = res->start; */ /* clear interrupt */ - /* int_stat = readl(dsim.reg_base + S5P_DSIM_INTSRC); */ + /* int_stat = readl(dsim->reg_base + S5P_DSIM_INTSRC); */ int_stat = 0xffffffff; - writel(int_stat, dsim.reg_base + S5P_DSIM_INTSRC); + writel(int_stat, dsim->reg_base + S5P_DSIM_INTSRC); /* enable interrupts */ - int_stat = readl(dsim.reg_base + S5P_DSIM_INTMSK); + int_stat = readl(dsim->reg_base + S5P_DSIM_INTMSK); int_stat &= ~((0x01<<S5P_DSIM_INT_BTA) | (0x01<<S5P_DSIM_INT_RX_TIMEOUT) | (0x01<<S5P_DSIM_INT_BTA_TIMEOUT) | (0x01 << S5P_DSIM_INT_RX_DONE) | @@ -1347,68 +1351,77 @@ static int s5p_dsim_probe(struct platform_device *pdev) (0x01<<S5P_DSIM_INT_RX_ECC_ERR) | (0x01<<S5P_DSIM_IMT_RX_CRC_ERR) | (0x01<<S5P_DSIM_INT_SFR_FIFO_EMPTY)); - writel(int_stat, dsim.reg_base + S5P_DSIM_INTMSK); + writel(int_stat, dsim->reg_base + S5P_DSIM_INTMSK); init_completion(&dsim_rd_comp); init_completion(&dsim_wr_comp); mutex_init(&dsim_rd_wr_mutex); - dsim.mipi_ddi_pd->resume_complete = 1; - dsim.dsim_lcd_info->lcd_enabled = 1; + dsim->mipi_ddi_pd->resume_complete = 1; + dsim->dsim_lcd_info->lcd_enabled = 1; - ret = request_irq(res->start, (void *)s5p_dsim_isr, IRQF_DISABLED, pdev->name, &dsim); + ret = request_irq(res->start, (void *)s5p_dsim_isr, IRQF_DISABLED, pdev->name, dsim); if (ret != 0) { dev_err(&pdev->dev, "failed to request dsim irq\n"); ret = -EINVAL; goto err_clk_disable; } - /* find lcd panel driver registered to mipi-dsi driver. */ - dsim.mipi_drv = scan_mipi_driver(dsim.pd->lcd_panel_name); - if (dsim.mipi_drv == NULL) { - dev_err(&pdev->dev, "mipi_drv is NULL.\n"); + INIT_DELAYED_WORK(&dsim->dsim_work, dsim_work_q_handler); + INIT_DELAYED_WORK(&dsim->check_hs_toggle_work, dsim_check_hs_toggle_work_q_handler); + + dsim->ops = &s5p_dsim_ops; + + platform_set_drvdata(pdev, dsim); + + dsim->panel.parent = &pdev->dev; + dev_set_name(&dsim->panel, dsim->pd->lcd_panel_name); + ret = device_register(&dsim->panel); + if (ret < 0) { + dev_err(&pdev->dev, "faild device register\n"); ret = -EINVAL; goto mipi_drv_err; } - /* set lcd panel driver link */ - ret = dsim.mipi_drv->set_link((void *) dsim.mipi_ddi_pd, dsim.reg_base, - s5p_dsim_wr_data, s5p_dsim_rd_data); - if (ret < 0) { - dev_err(&pdev->dev, "[DSIM : ERROR] faild set_link()\n"); + /* find lcd panel driver registered to mipi-dsi driver. */ + dsim->mipi_drv = scan_mipi_driver(dsim, dsim->pd->lcd_panel_name); + if (dsim->mipi_drv == NULL) { + dev_err(&pdev->dev, "mipi_drv is NULL\n"); ret = -EINVAL; goto mipi_drv_err; } - ret = dsim.mipi_drv->probe(&pdev->dev); + ret = dsim->mipi_drv->probe(&dsim->panel); if (ret < 0) { - dev_err(&pdev->dev, "[DSIM : ERROR] faild probe()\n"); + dev_err(&pdev->dev, "faild probe\n"); ret = -EINVAL; goto mipi_drv_err; } - dsim.state = DSIM_STATE_HSCLKEN; + dsim->state = DSIM_STATE_HSCLKEN; ret = device_create_file(&(pdev->dev), &dev_attr_dsim_dump); if (ret < 0) dev_err(&pdev->dev, "failed to add sysfs entries, %d\n", __LINE__); - ret = device_create_file(&(pdev->dev), &dev_attr_hs_toggle); - if (ret < 0) - dev_err(&pdev->dev, "failed to add sysfs entries, %d\n", __LINE__); + if (!dsim->dsim_info->hs_toggle) { + ret = device_create_file(&dsim->panel, &dev_attr_hs_toggle); + if (ret < 0) + dev_err(&pdev->dev, "failed to add sysfs entries, %d\n", __LINE__); + } - if (dsim.dsim_info->hs_toggle) - s5p_dsim_frame_done_interrupt_enable(1); + if (dsim->dsim_info->hs_toggle) + s5p_dsim_frame_done_interrupt_enable(dsim, 1); - dev_info(&pdev->dev, "mipi-dsi driver has been probed.\n"); + dev_info(&pdev->dev, "mipi-dsi driver has been probed\n"); #if 0 #ifdef CONFIG_HAS_WAKELOCK #ifdef CONFIG_HAS_EARLYSUSPEND - dsim.early_suspend.suspend = s5p_dsim_early_suspend; - dsim.early_suspend.resume = s5p_dsim_late_resume; - dsim.early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; - register_early_suspend(&dsim.early_suspend); + dsim->early_suspend.suspend = s5p_dsim_early_suspend; + dsim->early_suspend.resume = s5p_dsim_late_resume; + dsim->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; + register_early_suspend(&dsim->early_suspend); #endif #endif #endif @@ -1416,11 +1429,11 @@ static int s5p_dsim_probe(struct platform_device *pdev) mipi_drv_err: free_irq(res->start, &dsim); - dsim.pd->mipi_power(0); + dsim->pd->mipi_power(0); err_clk_disable: - clk_disable(dsim.clock); - + clk_disable(dsim->clock); +err_alloc: return ret; } diff --git a/drivers/video/samsung/s5p-dsim.h b/drivers/video/samsung/s5p-dsim.h index 77870a0..baf8f66 100644 --- a/drivers/video/samsung/s5p-dsim.h +++ b/drivers/video/samsung/s5p-dsim.h @@ -34,9 +34,6 @@ struct mipi_lcd_driver { s32 (*init)(struct device *dev); void (*display_on)(struct device *dev); - s32 (*set_link)(void *pd, u32 dsim_base, - u8 (*cmd_write)(u32 dsim_base, u32 data0, u32 data1, u32 data2), - int (*cmd_read)(u32 reg_base, u8 addr, u16 count, u8 *buf)); s32 (*probe)(struct device *dev); s32 (*remove)(struct device *dev); void (*shutdown)(struct device *dev); @@ -44,6 +41,47 @@ struct mipi_lcd_driver { s32 (*resume)(struct device *dev); }; +struct dsim_ops { + u8 (*cmd_write)(void *ptr, u32 data0, u32 data1, u32 data2); + int (*cmd_read)(void *ptr, u8 addr, u16 count, u8 *buf); + void (*suspend)(void); + void (*resume)(void); +}; + +/* Indicates the state of the device */ +struct dsim_global { + struct device *dev; + struct device panel; + struct clk *clock; + struct s5p_platform_dsim *pd; + struct dsim_config *dsim_info; + struct dsim_lcd_config *dsim_lcd_info; + /* lcd panel data. */ + struct s3cfb_lcd *lcd_panel_info; + /* platform and machine specific data for lcd panel driver. */ + struct mipi_ddi_platform_data *mipi_ddi_pd; + /* lcd panel driver based on MIPI-DSI. */ + struct mipi_lcd_driver *mipi_drv; + + unsigned int irq; + unsigned int te_irq; + unsigned int reg_base; + unsigned char state; + unsigned int data_lane; + enum dsim_byte_clk_src e_clk_src; + unsigned long hs_clk; + unsigned long byte_clk; + unsigned long escape_clk; + unsigned char freq_band; + char header_fifo_index[DSIM_HEADER_FIFO_SZ]; + + struct delayed_work dsim_work; + struct delayed_work check_hs_toggle_work; + unsigned int dsim_toggle_per_frame_count; + + struct dsim_ops *ops; +}; + int s5p_dsim_register_lcd_driver(struct mipi_lcd_driver *lcd_drv); #endif /* _S5P_DSIM_LOWLEVEL_H */ diff --git a/drivers/video/samsung/s6d6aa1.c b/drivers/video/samsung/s6d6aa1.c index 2efb506..2a4c4ad 100644 --- a/drivers/video/samsung/s6d6aa1.c +++ b/drivers/video/samsung/s6d6aa1.c @@ -37,7 +37,7 @@ #define MIN_BRIGHTNESS 0 #define MAX_BRIGHTNESS 255 -#define DEFAULT_BRIGHTNESS 160 +#define DEFAULT_BRIGHTNESS 170 struct lcd_info { unsigned int bl; @@ -57,9 +57,9 @@ struct lcd_info { unsigned int irq; unsigned int connected; -}; -static struct mipi_ddi_platform_data *ddi_pd; + struct dsim_global *dsim; +}; static const unsigned char SEQ_SLPOUT[] = { 0x11, @@ -67,13 +67,13 @@ static const unsigned char SEQ_SLPOUT[] = { 0x00 }; -static unsigned char SEQ_DSCTL[] = { +static const unsigned char SEQ_DSCTL[] = { 0x36, 0x00, 0x00 }; -static unsigned char SEQ_WRDISBV[] = { +static const unsigned char SEQ_WRDISBV[] = { 0x51, 0xFF, 0x00 @@ -109,6 +109,13 @@ static const unsigned char SEQ_SLPIN[] = { 0x00 }; +static unsigned char SEQ_WRDISBV_CTL[] = { + 0x51, + 0xFF, + 0x00 +}; + + static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len) { int size; @@ -123,11 +130,11 @@ static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len wbuf = seq; if (size == 1) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_NO_PARA, wbuf[0], 0); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_NO_PARA, wbuf[0], 0); else if (size == 2) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_1_PARA, wbuf[0], wbuf[1]); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_1_PARA, wbuf[0], wbuf[1]); else - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_LONG_WR, (unsigned int)wbuf, size); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_LONG_WR, (unsigned int)wbuf, size); mutex_unlock(&lcd->lock); @@ -143,44 +150,14 @@ static int _s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf mutex_lock(&lcd->lock); - if (ddi_pd->cmd_read) - ret = ddi_pd->cmd_read(ddi_pd->dsim_base, addr, count, buf); + if (lcd->dsim->ops->cmd_read) + ret = lcd->dsim->ops->cmd_read(lcd->dsim, addr, count, buf); mutex_unlock(&lcd->lock); return ret; } -static int s6e8ax0_set_link(void *pd, unsigned int dsim_base, - unsigned char (*cmd_write) (unsigned int dsim_base, unsigned int data0, - unsigned int data1, unsigned int data2), - int (*cmd_read) (u32 reg_base, u8 addr, u16 count, u8 *buf)) -{ - struct mipi_ddi_platform_data *temp_pd = NULL; - - temp_pd = (struct mipi_ddi_platform_data *) pd; - if (temp_pd == NULL) { - printk(KERN_ERR "mipi_ddi_platform_data is null.\n"); - return -EPERM; - } - - ddi_pd = temp_pd; - - ddi_pd->dsim_base = dsim_base; - - if (cmd_write) - ddi_pd->cmd_write = cmd_write; - else - printk(KERN_WARNING "cmd_write function is null.\n"); - - if (cmd_read) - ddi_pd->cmd_read = cmd_read; - else - printk(KERN_WARNING "cmd_read function is null.\n"); - - return 0; -} - static int s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf, u8 retry_cnt) { int ret = 0; @@ -231,8 +208,9 @@ static int update_brightness(struct lcd_info *lcd, u8 force) if ((force) || ((lcd->ldi_enable) && (lcd->current_bl != lcd->bl))) { lcd->current_bl = lcd->bl; - SEQ_WRDISBV[1] = lcd->bl; - s6e8ax0_write(lcd, SEQ_WRDISBV, ARRAY_SIZE(SEQ_WRDISBV)); + SEQ_WRDISBV_CTL[1] = lcd->bl; + s6e8ax0_write(lcd, SEQ_WRDISBV_CTL, \ + ARRAY_SIZE(SEQ_WRDISBV_CTL)); dev_info(&lcd->ld->dev, "brightness=%d, bl=%d\n", brightness, lcd->bl); } @@ -250,7 +228,7 @@ static int s6e8ax0_ldi_init(struct lcd_info *lcd) msleep(200); - s6e8ax0_write(lcd, SEQ_DSCTL, ARRAY_SIZE(SEQ_WRDISBV)); + s6e8ax0_write(lcd, SEQ_DSCTL, ARRAY_SIZE(SEQ_DSCTL)); s6e8ax0_write(lcd, SEQ_WRDISBV, ARRAY_SIZE(SEQ_WRDISBV)); s6e8ax0_write(lcd, SEQ_WRCTRLD, ARRAY_SIZE(SEQ_WRCTRLD)); s6e8ax0_write(lcd, SEQ_WRCABC, ARRAY_SIZE(SEQ_WRCABC)); @@ -459,6 +437,8 @@ void s6e8ax0_early_suspend(void) { struct lcd_info *lcd = g_lcd; + set_dsim_lcd_enabled(0); + dev_info(&lcd->ld->dev, "+%s\n", __func__); s6e8ax0_power(lcd, FB_BLANK_POWERDOWN); @@ -478,7 +458,7 @@ void s6e8ax0_late_resume(void) dev_info(&lcd->ld->dev, "-%s\n", __func__); - set_dsim_lcd_enabled(); + set_dsim_lcd_enabled(1); return ; } @@ -526,6 +506,7 @@ static int s6e8ax0_probe(struct device *dev) } lcd->dev = dev; + lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = 0; @@ -591,7 +572,6 @@ static void s6e8ax0_shutdown(struct device *dev) static struct mipi_lcd_driver s6e8ax0_mipi_driver = { .name = "s6d6aa1", - .set_link = s6e8ax0_set_link, .probe = s6e8ax0_probe, .remove = __devexit_p(s6e8ax0_remove), .shutdown = s6e8ax0_shutdown, diff --git a/drivers/video/samsung/s6dr171.c b/drivers/video/samsung/s6dr171.c index b48e40a..167f658 100644 --- a/drivers/video/samsung/s6dr171.c +++ b/drivers/video/samsung/s6dr171.c @@ -76,10 +76,9 @@ struct lcd_info { unsigned int irq; unsigned int connected; + struct dsim_global *dsim; }; -static struct mipi_ddi_platform_data *ddi_pd; - static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len) { int size; @@ -94,11 +93,11 @@ static int s6e8ax0_write(struct lcd_info *lcd, const unsigned char *seq, int len wbuf = seq; if (size == 1) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_NO_PARA, wbuf[0], 0); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_NO_PARA, wbuf[0], 0); else if (size == 2) - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_WR_1_PARA, wbuf[0], wbuf[1]); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_WR_1_PARA, wbuf[0], wbuf[1]); else - ddi_pd->cmd_write(ddi_pd->dsim_base, DCS_LONG_WR, (unsigned int)wbuf, size); + lcd->dsim->ops->cmd_write(lcd->dsim, DCS_LONG_WR, (unsigned int)wbuf, size); mutex_unlock(&lcd->lock); @@ -114,44 +113,14 @@ static int _s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf mutex_lock(&lcd->lock); - if (ddi_pd->cmd_read) - ret = ddi_pd->cmd_read(ddi_pd->dsim_base, addr, count, buf); + if (lcd->dsim->ops->cmd_read) + ret = lcd->dsim->ops->cmd_read(lcd->dsim, addr, count, buf); mutex_unlock(&lcd->lock); return ret; } -static int s6e8ax0_set_link(void *pd, unsigned int dsim_base, - unsigned char (*cmd_write) (unsigned int dsim_base, unsigned int data0, - unsigned int data1, unsigned int data2), - int (*cmd_read) (u32 reg_base, u8 addr, u16 count, u8 *buf)) -{ - struct mipi_ddi_platform_data *temp_pd = NULL; - - temp_pd = (struct mipi_ddi_platform_data *) pd; - if (temp_pd == NULL) { - printk(KERN_ERR "mipi_ddi_platform_data is null.\n"); - return -EPERM; - } - - ddi_pd = temp_pd; - - ddi_pd->dsim_base = dsim_base; - - if (cmd_write) - ddi_pd->cmd_write = cmd_write; - else - printk(KERN_WARNING "cmd_write function is null.\n"); - - if (cmd_read) - ddi_pd->cmd_read = cmd_read; - else - printk(KERN_WARNING "cmd_read function is null.\n"); - - return 0; -} - static int s6e8ax0_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf, u8 retry_cnt) { int ret = 0; @@ -424,6 +393,8 @@ void s6e8ax0_early_suspend(void) { struct lcd_info *lcd = g_lcd; + set_dsim_lcd_enabled(0); + dev_info(&lcd->ld->dev, "+%s\n", __func__); s6e8ax0_power(lcd, FB_BLANK_POWERDOWN); dev_info(&lcd->ld->dev, "-%s\n", __func__); @@ -439,7 +410,7 @@ void s6e8ax0_late_resume(void) s6e8ax0_power(lcd, FB_BLANK_UNBLANK); dev_info(&lcd->ld->dev, "-%s\n", __func__); - set_dsim_lcd_enabled(); + set_dsim_lcd_enabled(1); return ; } @@ -496,6 +467,7 @@ static int s6e8ax0_probe(struct device *dev) } lcd->dev = dev; + lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = DEFAULT_GAMMA_LEVEL; @@ -577,7 +549,6 @@ static void s6e8ax0_shutdown(struct device *dev) static struct mipi_lcd_driver s6e8ax0_mipi_driver = { .name = "s6e8aa0", - .set_link = s6e8ax0_set_link, .probe = s6e8ax0_probe, .remove = __devexit_p(s6e8ax0_remove), .shutdown = s6e8ax0_shutdown, diff --git a/drivers/video/samsung/s6e8aa0_param.h b/drivers/video/samsung/s6e8aa0_param.h index b40932d..3ac11ad 100644 --- a/drivers/video/samsung/s6e8aa0_param.h +++ b/drivers/video/samsung/s6e8aa0_param.h @@ -55,13 +55,13 @@ enum { #define ELVSS_OFFSET_300 0x00 #define ELVSS_OFFSET_200 0x08 #define ELVSS_OFFSET_160 0x0D -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) #define ELVSS_OFFSET_100 0x11 #else #define ELVSS_OFFSET_100 0x12 #endif -#if defined(CONFIG_MACH_Q1_BD) +#if defined(CONFIG_S6E8AA0_AMS529HA01) #define ELVSS_OFFSET_MAX ELVSS_OFFSET_300 #define ELVSS_OFFSET_1 ELVSS_OFFSET_200 #define ELVSS_OFFSET_2 ELVSS_OFFSET_160 diff --git a/drivers/video/samsung/smart_dimming.c b/drivers/video/samsung/smart_dimming.c index a1c428d..d356009 100644 --- a/drivers/video/samsung/smart_dimming.c +++ b/drivers/video/samsung/smart_dimming.c @@ -20,7 +20,7 @@ #define V1_255_calc_param (V1_255_div_1000 / VREG_OUT_1000) #endif -#ifdef CONFIG_MACH_Q1_BD +#if defined(CONFIG_S6E8AA0_AMS529HA01) #define VREG_OUT_1000 4600 #else #ifdef CONFIG_AID_DIMMING |