EDP: remove old system EDP framework (camera flash drivers)
Timo Alho [Sat, 28 Dec 2013 11:17:58 +0000 (13:17 +0200)]
Revised system edp software framework has been put in place. This
patch removes old system edp client code from as364x, lm3565,
max77387, and max77665 flash drivers.

Bug 1431977

Change-Id: I7bbe058ce5ffd1e6e44a0cef9f5d09879c46d379
Signed-off-by: Timo Alho <talho@nvidia.com>
Reviewed-on: http://git-master/r/350406
Reviewed-by: Charlie Huang <chahuang@nvidia.com>
Reviewed-by: Juha Tukkinen <jtukkinen@nvidia.com>

drivers/media/platform/tegra/as364x.c
drivers/media/platform/tegra/lm3565.c
drivers/media/platform/tegra/max77387.c
drivers/media/platform/tegra/max77665-flash.c
include/media/as364x.h
include/media/lm3565.h
include/media/max77387.h
include/media/max77665-flash.h

index 4ffb270..90b5a1a 100644 (file)
@@ -29,7 +29,6 @@
 #include <linux/module.h>
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
-#include <linux/edp.h>
 #include <linux/sysedp.h>
 #include <linux/regmap.h>
 #include <media/nvc.h>
@@ -148,9 +147,7 @@ struct as364x_info {
        struct nvc_torch_timer_capabilities_v1 *torch_timeouts[2];
        struct as364x_config config;
        struct as364x_reg_cache regs;
-       struct edp_client *edpc;
        struct sysedp_consumer *sysedpc;
-       unsigned edp_state;
        atomic_t in_use;
        int flash_cap_size;
        int torch_cap_size;
@@ -314,113 +311,6 @@ static int as364x_reg_wr(struct as364x_info *info, u8 reg, u8 val)
        return err;
 }
 
-static void as364x_edp_lowest(struct as364x_info *info)
-{
-       if (!info->edpc)
-               return;
-
-       info->edp_state = info->edpc->num_states - 1;
-       dev_dbg(&info->i2c_client->dev, "%s %d\n", __func__, info->edp_state);
-       if (edp_update_client_request(info->edpc, info->edp_state, NULL)) {
-               dev_err(&info->i2c_client->dev, "THIS IS NOT LIKELY HAPPEN!\n");
-               dev_err(&info->i2c_client->dev,
-                       "UNABLE TO SET LOWEST EDP STATE!\n");
-       }
-}
-
-static void as364x_throttle(unsigned int new_state, void *priv_data);
-static void as364x_edp_register(struct as364x_info *info)
-{
-       struct edp_manager *edp_manager;
-       struct edp_client *edpc = &info->pdata->edpc_config;
-       int ret;
-
-       info->edpc = NULL;
-       if (!edpc->num_states) {
-               dev_notice(&info->i2c_client->dev,
-                       "%s: NO edp states defined.\n", __func__);
-               return;
-       }
-
-       strncpy(edpc->name, "as364x", EDP_NAME_LEN - 1);
-       edpc->name[EDP_NAME_LEN - 1] = 0;
-       edpc->throttle = as364x_throttle;
-       edpc->private_data = info;
-
-       dev_dbg(&info->i2c_client->dev, "%s: %s, e0 = %d, p %d\n",
-               __func__, edpc->name, edpc->e0_index, edpc->priority);
-       for (ret = 0; ret < edpc->num_states; ret++)
-               dev_dbg(&info->i2c_client->dev, "e%d = %d mA\n",
-                       ret - edpc->e0_index, edpc->states[ret]);
-
-       edp_manager = edp_get_manager("battery");
-       if (!edp_manager) {
-               dev_err(&info->i2c_client->dev,
-                       "unable to get edp manager: battery\n");
-               return;
-       }
-
-       ret = edp_register_client(edp_manager, edpc);
-       if (ret) {
-               dev_err(&info->i2c_client->dev,
-                       "unable to register edp client\n");
-               return;
-       }
-
-       info->edpc = edpc;
-       /* set to lowest state at init */
-       as364x_edp_lowest(info);
-}
-
-static int as364x_edp_req(struct as364x_info *info,
-               u8 mask, u8 *curr1, u8 *curr2)
-{
-       unsigned *estates;
-       unsigned total_curr = 0;
-       unsigned curr_mA;
-       unsigned approved;
-       unsigned new_state;
-       int ret = 0;
-
-       if (!info->edpc)
-               return 0;
-
-       dev_dbg(&info->i2c_client->dev, "%s: %d curr1 = %02x curr2 = %02x\n",
-               __func__, mask, *curr1, *curr2);
-       estates = info->edpc->states;
-       if (mask & 1)
-               total_curr += *curr1;
-       if (mask & 2)
-               total_curr += *curr2;
-       curr_mA = GET_CURRENT_BY_INDEX(info, total_curr);
-
-       for (new_state = info->edpc->num_states - 1; new_state > 0; new_state--)
-               if (estates[new_state] >= curr_mA)
-                       break;
-
-       dev_dbg(&info->i2c_client->dev,
-               "edp req: %d curr = %d mA\n", new_state, curr_mA);
-       ret = edp_update_client_request(info->edpc, new_state, &approved);
-       if (ret) {
-               dev_err(&info->i2c_client->dev, "E state transition failed\n");
-               return ret;
-       }
-
-       if (approved > new_state) { /* edp manager returned less current */
-               curr_mA = GET_INDEX_BY_CURRENT(info, estates[approved]);
-               if (mask & 1)
-                       *curr1 = curr_mA * (*curr1) / total_curr;
-               *curr2 = curr_mA - (*curr1);
-               dev_dbg(&info->i2c_client->dev,
-                       "new state: %d curr = %d mA (%d %d)\n",
-                       approved, curr_mA, *curr1, *curr2);
-       }
-
-       info->edp_state = approved;
-
-       return 0;
-}
-
 static unsigned int as364x_sysedp_count_state(struct as364x_info *info,
                                              u8 mask, u8 curr1, u8 curr2)
 {
@@ -469,10 +359,6 @@ static int as364x_set_leds(struct as364x_info *info,
        } else
                curr2 = 0;
 
-       err = as364x_edp_req(info, mask, &curr1, &curr2);
-       if (err)
-               return err;
-
        regs[0] = curr1;
        regs[1] = curr2;
        regs[2] = info->regs.txmask;
@@ -495,8 +381,6 @@ static int as364x_set_leds(struct as364x_info *info,
        if (!err) {
                info->regs.led1_curr = curr1;
                info->regs.led2_curr = curr2;
-               if ((curr1 | curr2) == 0)
-                       as364x_edp_lowest(info);
        }
 
        dev_dbg(info->dev, "%s %x %x %x %x control = %x\n",
@@ -960,7 +844,6 @@ static int as364x_power_on(struct as364x_info *info)
 
        if (!err)
                info->power_on = 1;
-       as364x_edp_lowest(info);
        sysedp_set_state(info->sysedpc, 0);
 power_on_end:
        mutex_unlock(&info->mutex);
@@ -1002,7 +885,6 @@ static int as364x_power_off(struct as364x_info *info)
 
        if (!err)
                info->power_on = 0;
-       as364x_edp_lowest(info);
        sysedp_set_state(info->sysedpc, 0);
 power_off_end:
        mutex_unlock(&info->mutex);
@@ -1058,16 +940,6 @@ static int as364x_power(struct as364x_info *info, int pwr)
        return err;
 }
 
-static void as364x_throttle(unsigned int new_state, void *priv_data)
-{
-       struct as364x_info *info = priv_data;
-
-       if (!info)
-               return;
-
-       as364x_power(info, NVC_PWR_OFF);
-}
-
 static int as364x_get_dev_id(struct as364x_info *info)
 {
        int err;
@@ -1556,7 +1428,6 @@ static int as364x_probe(
        spin_unlock(&as364x_spinlock);
 
        as364x_power_get(info);
-       as364x_edp_register(info);
        info->sysedpc = sysedp_create_consumer("as364x", "as364x");
 
        err = as364x_get_dev_id(info);
index 5fe30b7..2f09079 100644 (file)
@@ -30,7 +30,6 @@
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
 #include <linux/regmap.h>
-#include <linux/edp.h>
 #include <media/nvc.h>
 #include <media/lm3565.h>
 
@@ -120,7 +119,6 @@ struct lm3565_info {
        struct mutex mutex;
        struct lm3565_power_rail power;
        struct regmap *regmap;
-       struct edp_client *edpc;
        struct lm3565_platform_data *pdata;
        struct nvc_torch_capability_query query;
        struct nvc_torch_flash_capabilities_v1 flash_cap;
@@ -135,7 +133,6 @@ struct lm3565_info {
        struct lm3565_config config;
        struct lm3565_reg_cache regs;
        atomic_t in_use;
-       unsigned int edp_state;
        int pwr_state;
        u8 max_flash;
        u8 max_torch;
@@ -294,116 +291,6 @@ static int lm3565_get_current_mA(u8 curr)
        return lm3565_def_flash_levels[curr].luminance / 1000;
 }
 
-static void lm3565_throttle(unsigned int new_state, void *priv_data)
-{
-       struct lm3565_info *info = priv_data;
-
-       if (!info)
-               return;
-
-       /* power off chip to turn off led */
-       lm3565_power(info, NVC_PWR_OFF);
-}
-
-static void lm3565_edp_lowest(struct lm3565_info *info)
-{
-       if (!info->edpc)
-               return;
-
-       info->edp_state = info->edpc->num_states - 1;
-       dev_dbg(info->dev, "%s %d\n", __func__, info->edp_state);
-       if (edp_update_client_request(info->edpc, info->edp_state, NULL)) {
-               dev_err(info->dev, "THIS IS NOT LIKELY HAPPEN!\n");
-               dev_err(info->dev, "UNABLE TO SET LOWEST EDP STATE!\n");
-       }
-}
-
-static void lm3565_edp_register(struct lm3565_info *info)
-{
-       struct edp_manager *edp_manager;
-       struct edp_client *edpc = &info->pdata->edpc_config;
-       int ret;
-
-       info->edpc = NULL;
-       if (!edpc->num_states) {
-               dev_notice(info->dev, "%s: NO edp states defined.\n", __func__);
-               return;
-       }
-
-       strncpy(edpc->name, "lm3565", EDP_NAME_LEN - 1);
-       edpc->name[EDP_NAME_LEN - 1] = 0;
-       edpc->throttle = lm3565_throttle;
-       edpc->private_data = info;
-
-       dev_dbg(info->dev, "%s: %s, e0 = %d, p %d\n",
-               __func__, edpc->name, edpc->e0_index, edpc->priority);
-       for (ret = 0; ret < edpc->num_states; ret++)
-               dev_dbg(info->dev, "e%d = %d mA\n",
-                       ret - edpc->e0_index, edpc->states[ret]);
-
-       edp_manager = edp_get_manager("battery");
-       if (!edp_manager) {
-               dev_err(info->dev, "unable to get edp manager: battery\n");
-               return;
-       }
-
-       ret = edp_register_client(edp_manager, edpc);
-       if (ret) {
-               dev_err(info->dev, "unable to register edp client\n");
-               return;
-       }
-
-       info->edpc = edpc;
-       /* set to lowest state at init */
-       lm3565_edp_lowest(info);
-}
-
-static int lm3565_edp_req(struct lm3565_info *info, u8 *curr)
-{
-       unsigned int *estates;
-       int curr_mA;
-       unsigned int curr_mW;
-       unsigned int approved;
-       unsigned int new_state;
-       int ret = 0;
-
-       if (!info->edpc)
-               return 0;
-
-       dev_dbg(info->dev, "%s: curr = %02x\n", __func__, *curr);
-       estates = info->edpc->states;
-       curr_mA = lm3565_get_current_mA(*curr);
-       if (curr_mA < 0) {
-               dev_err(info->dev, "%s: invalid current %d\n", __func__, *curr);
-               return curr_mA;
-       }
-       curr_mW = curr_mA * 38 / 10;
-
-       for (new_state = info->edpc->num_states - 1; new_state > 0; new_state--)
-               if (estates[new_state] >= curr_mW)
-                       break;
-
-       dev_dbg(info->dev, "edp req: %d curr = %d mW\n", new_state, curr_mW);
-       ret = edp_update_client_request(info->edpc, new_state, &approved);
-       if (ret) {
-               dev_err(info->dev, "E state transition failed\n");
-               return ret;
-       }
-
-       if (approved > new_state) { /* edp manager returned less current */
-               curr_mA = estates[approved] * 10 / 38;
-               curr_mA = lm3565_get_current_mA(curr_mA);
-               if (curr_mA < 0)
-                       return curr_mA;
-               dev_dbg(info->dev, "new state: %d curr = %d mA (%d)\n",
-                       approved, curr_mA, *curr);
-       }
-
-       info->edp_state = approved;
-
-       return 0;
-}
-
 static int lm3565_get_lut_index(u16 val, const u16 *lut, int num)
 {
        int idx;
@@ -426,16 +313,11 @@ static int lm3565_set_leds(struct lm3565_info *info, u8 curr)
                err = lm3565_reg_wr(info, LM3565_REG_MODE, 0);
                if (!err) {
                        info->regs.outmode = 0;
-                       lm3565_edp_lowest(info);
                }
                dev_dbg(info->dev, "%s led disabled\n", __func__);
                goto set_leds_end;
        }
 
-       err = lm3565_edp_req(info, &curr);
-       if (err)
-               goto set_leds_end;
-
        if (info->op_mode == LM3565_MODE_FLASH) {
                if (curr >= info->max_flash)
                        curr = info->max_flash;
@@ -792,7 +674,6 @@ static int lm3565_power_on(struct lm3565_info *info)
 
 power_on_end:
        mutex_unlock(&info->mutex);
-       lm3565_edp_lowest(info);
 
        return err;
 }
@@ -840,7 +721,6 @@ static int lm3565_power_off(struct lm3565_info *info)
 
 power_off_end:
        mutex_unlock(&info->mutex);
-       lm3565_edp_lowest(info);
 
        return err;
 }
@@ -1390,8 +1270,6 @@ static int lm3565_probe(
 
        lm3565_configure(info, false);
 
-       lm3565_edp_register(info);
-
        i2c_set_clientdata(client, info);
        mutex_init(&info->mutex);
        INIT_LIST_HEAD(&info->list);
index a6174b4..354050a 100644 (file)
@@ -67,7 +67,6 @@
 #include <linux/gpio.h>
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
-#include <linux/edp.h>
 #include <linux/regmap.h>
 #include <media/nvc.h>
 #include <media/max77387.h>
@@ -265,8 +264,6 @@ struct max77387_info {
        struct max77387_reg_cache regs;
        struct max77387_settings settings;
        struct regmap *regmap;
-       struct edp_client *edpc;
-       unsigned edp_state;
        atomic_t in_use;
        int flash_cap_size;
        int torch_cap_size;
@@ -344,8 +341,6 @@ static u32 max77387_torch_timer[MAX77387_TORCH_TIMER_NUM + 1] = {
        122880,
 };
 
-static void max77387_throttle(unsigned int new_state, void *priv_data);
-
 static bool rd_wr_reg_chk(struct device *dev, unsigned int reg)
 {
        if (reg > MAX77387_RO_DCDC_MAX) {
@@ -417,107 +412,6 @@ static int max77387_reg_wr(
        return ret;
 }
 
-static void max77387_edp_lowest(struct max77387_info *info)
-{
-       if (!info->edpc)
-               return;
-
-       info->edp_state = info->edpc->num_states - 1;
-       dev_dbg(info->dev, "%s %d\n", __func__, info->edp_state);
-       if (edp_update_client_request(info->edpc, info->edp_state, NULL)) {
-               dev_err(info->dev, "THIS IS NOT LIKELY HAPPEN!\n");
-               dev_err(info->dev, "UNABLE TO SET LOWEST EDP STATE!\n");
-       }
-}
-
-static void max77387_edp_register(struct max77387_info *info)
-{
-       struct edp_manager *edp_manager;
-       struct edp_client *edpc = &info->pdata->edpc_config;
-       int ret;
-
-       info->edpc = NULL;
-       if (!edpc->num_states) {
-               dev_notice(info->dev, "%s: NO edp states defined.\n", __func__);
-               return;
-       }
-
-       strncpy(edpc->name, "max77387f", EDP_NAME_LEN - 1);
-       edpc->name[EDP_NAME_LEN - 1] = 0;
-       edpc->throttle = max77387_throttle;
-       edpc->private_data = info;
-
-       dev_dbg(info->dev, "%s: %s, e0 = %d, p %d\n",
-               __func__, edpc->name, edpc->e0_index, edpc->priority);
-       for (ret = 0; ret < edpc->num_states; ret++)
-               dev_dbg(info->dev, "e%d = %d mA\n",
-                       ret - edpc->e0_index, edpc->states[ret]);
-
-       edp_manager = edp_get_manager("battery");
-       if (!edp_manager) {
-               dev_err(info->dev, "unable to get edp manager: battery\n");
-               return;
-       }
-
-       ret = edp_register_client(edp_manager, edpc);
-       if (ret) {
-               dev_err(info->dev, "unable to register edp client\n");
-               return;
-       }
-
-       info->edpc = edpc;
-       /* set to lowest state at init */
-       max77387_edp_lowest(info);
-}
-
-static int max77387_edp_req(struct max77387_info *info,
-               u8 mask, u8 *curr1, u8 *curr2)
-{
-       unsigned *estates;
-       unsigned total_curr = 0;
-       unsigned curr_mA;
-       unsigned approved;
-       unsigned new_state;
-       int ret = 0;
-
-       if (!info->edpc)
-               return 0;
-
-       dev_dbg(info->dev, "%s: %d curr1 = %02x curr2 = %02x\n",
-               __func__, mask, *curr1, *curr2);
-       estates = info->edpc->states;
-       if (mask & 1)
-               total_curr += *curr1;
-       if (mask & 2)
-               total_curr += *curr2;
-       curr_mA = GET_CURRENT_BY_INDEX(total_curr);
-
-       for (new_state = info->edpc->num_states - 1; new_state > 0; new_state--)
-               if (estates[new_state] >= curr_mA)
-                       break;
-
-       dev_dbg(info->dev, "edp req: %d curr = %d mA\n", new_state, curr_mA);
-       ret = edp_update_client_request(info->edpc, new_state, &approved);
-       if (ret) {
-               dev_err(info->dev, "E state transition failed\n");
-               return ret;
-       }
-
-       if (approved > new_state) { /* edp manager returned less current */
-               curr_mA = GET_INDEX_BY_CURRENT(estates[approved]);
-               if (mask & 1)
-                       *curr1 = curr_mA * (*curr1) / total_curr;
-               *curr2 = curr_mA - (*curr1);
-               dev_dbg(info->dev, "new state: %d curr = %d mA (%d %d)\n",
-                       approved, curr_mA, *curr1, *curr2);
-       }
-
-       info->edp_state = approved;
-
-       return 0;
-}
-
-
 static int max77387_set_leds(struct max77387_info *info,
                u8 mask, u8 curr1, u8 curr2)
 {
@@ -620,25 +514,6 @@ set_leds_end:
        return err;
 }
 
-static int max77387_edp_set_leds(struct max77387_info *info,
-               u8 mask, u8 curr1, u8 curr2)
-{
-       int err;
-
-       err = max77387_edp_req(info, mask, &curr1, &curr2);
-       if (err)
-               goto edp_set_leds_end;
-
-       err = max77387_set_leds(info, mask, curr1, curr2);
-       if (!err && info->op_mode == MAXFLASH_MODE_NONE)
-               max77387_edp_lowest(info);
-
-edp_set_leds_end:
-       if (err)
-               dev_err(info->dev, "%s ERROR: %d\n", __func__, err);
-       return err;
-}
-
 static void max77387_update_config(struct max77387_info *info)
 {
        struct max77387_settings *pst = &info->settings;
@@ -907,10 +782,10 @@ static int max77387_update_settings(struct max77387_info *info)
        err = max77387_reg_raw_wr(info, MAX77387_RW_NTC, regs, 5);
 
        if (info->op_mode == MAXFLASH_MODE_FLASH)
-               err |= max77387_edp_set_leds(info, info->config.led_mask,
+               err |= max77387_set_leds(info, info->config.led_mask,
                                info->regs.led1_fcurr, info->regs.led2_fcurr);
        else
-               err |= max77387_edp_set_leds(info, info->config.led_mask,
+               err |= max77387_set_leds(info, info->config.led_mask,
                                info->regs.led1_tcurr, info->regs.led2_tcurr);
 
        info->regs.regs_stale = false;
@@ -1124,16 +999,6 @@ static int max77387_enter_offmode(struct max77387_info *info, bool op_off)
        return err;
 }
 
-static void max77387_throttle(unsigned int new_state, void *priv_data)
-{
-       struct max77387_info *info = priv_data;
-
-       if (!info)
-               return;
-
-       max77387_enter_offmode(info, true);
-}
-
 #ifdef CONFIG_PM
 static int max77387_suspend(struct i2c_client *client, pm_message_t msg)
 {
@@ -1162,7 +1027,6 @@ static void max77387_shutdown(struct i2c_client *client)
        dev_info(info->dev, "Shutting down\n");
 
        max77387_enter_offmode(info, true);
-       max77387_edp_lowest(info);
        info->regs.regs_stale = true;
 }
 #endif
@@ -1198,7 +1062,6 @@ static int max77387_power_off(struct max77387_info *info)
        }
 
        mutex_unlock(&info->mutex);
-       max77387_edp_lowest(info);
        return err;
 }
 
@@ -1247,7 +1110,6 @@ static int max77387_power_on(struct max77387_info *info)
                max77387_power_off(info);
                return err;
        }
-       max77387_edp_lowest(info);
 
        return 0;
 
@@ -1272,7 +1134,6 @@ static int max77387_power_set(struct max77387_info *info, int pwr)
        switch (pwr) {
        case NVC_PWR_OFF:
                max77387_enter_offmode(info, true);
-               max77387_edp_lowest(info);
                if ((info->pdata->cfg & NVC_CFG_OFF2STDBY) ||
                        (info->pdata->cfg & NVC_CFG_BOOT_INIT))
                        pwr = NVC_PWR_STDBY;
@@ -1545,7 +1406,7 @@ static int max77387_set_param(struct max77387_info *info, long arg)
                        info->new_timer = led_levels.timeout;
                curr1 = led_levels.levels[0];
                curr2 = led_levels.levels[1];
-               err = max77387_edp_set_leds(info,
+               err = max77387_set_leds(info,
                        led_levels.ledmask, curr1, curr2);
                break;
        case NVC_PARAM_TORCH_LEVEL:
@@ -1553,7 +1414,7 @@ static int max77387_set_param(struct max77387_info *info, long arg)
                info->new_timer = led_levels.timeout;
                curr1 = led_levels.levels[0];
                curr2 = led_levels.levels[1];
-               err = max77387_edp_set_leds(info,
+               err = max77387_set_leds(info,
                        led_levels.ledmask, curr1, curr2);
                break;
        case NVC_PARAM_FLASH_PIN_STATE:
@@ -1794,8 +1655,6 @@ static int max77387_probe(
 
        max77387_configure(info, false);
 
-       max77387_edp_register(info);
-
        i2c_set_clientdata(client, info);
        mutex_init(&info->mutex);
 
@@ -1911,7 +1770,7 @@ set_attr:
                break;
        /* change led 1/2 current settings */
        case 'c':
-               max77387_edp_set_leds(info, info->config.led_mask,
+               max77387_set_leds(info, info->config.led_mask,
                        val & 0xff, (val >> 8) & 0xff);
                break;
        /* modify flash timeout reg */
index 8ac4186..d714316 100644 (file)
@@ -69,7 +69,6 @@
 #include <linux/gpio.h>
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
-#include <linux/edp.h>
 #include <linux/mfd/max77665.h>
 #include <media/nvc.h>
 #include <media/max77665-flash.h>
@@ -261,8 +260,6 @@ struct max77665_f_info {
        struct max77665_f_reg_cache regs;
        struct max77665_f_state_regs states;
        struct regmap *regmap;
-       struct edp_client *edpc;
-       unsigned edp_state;
        atomic_t in_use;
        int flash_cap_size;
        int torch_cap_size;
@@ -366,8 +363,6 @@ static u32 max77665_f_torch_timer[] = {
        MAX77665_F_TORCH_TIMER_FOREVER
 };
 
-static void max77665_f_throttle(unsigned int new_state, void *priv_data);
-
 static inline int max77665_f_reg_wr(struct max77665_f_info *info,
                u8 reg, u8 val, bool refresh)
 {
@@ -387,109 +382,6 @@ static inline int max77665_f_reg_raw_wr(struct max77665_f_info *info,
        return regmap_raw_write(info->regmap, reg, val, num);
 }
 
-static void max77665_f_edp_lowest(struct max77665_f_info *info)
-{
-       if (!info->edpc)
-               return;
-
-       info->edp_state = info->edpc->num_states - 1;
-       dev_dbg(info->dev, "%s %d\n", __func__, info->edp_state);
-       if (edp_update_client_request(info->edpc, info->edp_state, NULL)) {
-               dev_err(info->dev, "THIS IS NOT LIKELY HAPPEN!\n");
-               dev_err(info->dev, "UNABLE TO SET LOWEST EDP STATE!\n");
-       }
-}
-
-static void max77665_f_edp_register(struct max77665_f_info *info)
-{
-       struct edp_manager *edp_manager;
-       struct edp_client *edpc = &info->pdata->edpc_config;
-       int ret;
-
-       info->edpc = NULL;
-       if (!edpc->num_states) {
-               dev_notice(info->dev, "%s: NO edp states defined.\n", __func__);
-               return;
-       }
-
-       strncpy(edpc->name, "max77665f", EDP_NAME_LEN - 1);
-       edpc->name[EDP_NAME_LEN - 1] = 0;
-       edpc->throttle = max77665_f_throttle;
-       edpc->private_data = info;
-
-       dev_dbg(info->dev, "%s: %s, e0 = %d, p %d\n",
-               __func__, edpc->name, edpc->e0_index, edpc->priority);
-       for (ret = 0; ret < edpc->num_states; ret++)
-               dev_dbg(info->dev, "e%d = %d mA\n",
-                       ret - edpc->e0_index, edpc->states[ret]);
-
-       edp_manager = edp_get_manager("battery");
-       if (!edp_manager) {
-               dev_err(info->dev, "unable to get edp manager: battery\n");
-               return;
-       }
-
-       ret = edp_register_client(edp_manager, edpc);
-       if (ret) {
-               dev_err(info->dev, "unable to register edp client\n");
-               return;
-       }
-
-       info->edpc = edpc;
-       /* set to lowest state at init */
-       max77665_f_edp_lowest(info);
-}
-
-static int max77665_f_edp_req(struct max77665_f_info *info,
-               u8 mask, u8 *curr1, u8 *curr2)
-{
-       unsigned *estates;
-       unsigned total_curr = 0;
-       unsigned curr_mA;
-       unsigned int curr_mW;
-       unsigned approved;
-       unsigned new_state;
-       int ret = 0;
-
-       if (!info->edpc)
-               return 0;
-
-       dev_dbg(info->dev, "%s: %d curr1 = %02x curr2 = %02x\n",
-               __func__, mask, *curr1, *curr2);
-       estates = info->edpc->states;
-       if (mask & 1)
-               total_curr += *curr1;
-       if (mask & 2)
-               total_curr += *curr2;
-       curr_mA = GET_CURRENT_BY_INDEX(total_curr);
-       curr_mW = curr_mA * 38 / 10;
-
-       for (new_state = info->edpc->num_states - 1; new_state > 0; new_state--)
-               if (estates[new_state] >= curr_mW)
-                       break;
-
-       dev_dbg(info->dev, "edp req: %d curr = %d mW\n", new_state, curr_mW);
-       ret = edp_update_client_request(info->edpc, new_state, &approved);
-       if (ret) {
-               dev_err(info->dev, "E state transition failed\n");
-               return ret;
-       }
-
-       if (approved > new_state) { /* edp manager returned less current */
-               curr_mA = estates[approved] * 10 / 38;
-               curr_mA = GET_INDEX_BY_CURRENT(curr_mA);
-               if (mask & 1)
-                       *curr1 = curr_mA * (*curr1) / total_curr;
-               *curr2 = curr_mA - (*curr1);
-               dev_dbg(info->dev, "new state: %d curr = %d mA (%d %d)\n",
-                       approved, curr_mA, *curr1, *curr2);
-       }
-
-       info->edp_state = approved;
-
-       return 0;
-}
-
 static int max77665_f_set_leds(struct max77665_f_info *info,
                u8 mask, u8 curr1, u8 curr2)
 {
@@ -583,26 +475,6 @@ set_leds_end:
        return err;
 }
 
-static int max77665_f_edp_set_leds(struct max77665_f_info *info,
-               u8 mask, u8 curr1, u8 curr2)
-{
-       int err;
-
-       err = max77665_f_edp_req(info, mask, &curr1, &curr2);
-       if (err)
-               goto edp_set_leds_end;
-
-       err = max77665_f_set_leds(info, mask, curr1, curr2);
-       if (!err && info->op_mode == MAXFLASH_MODE_NONE)
-               max77665_f_edp_lowest(info);
-
-
-edp_set_leds_end:
-       if (err)
-               dev_err(info->dev, "%s ERROR: %d\n", __func__, err);
-       return err;
-}
-
 static inline int max77665_f_get_boost_volt(u16 mV)
 {
        if (mV <= BOOST_VOLT_FLOOR)
@@ -808,7 +680,7 @@ static int max77665_f_update_settings(struct max77665_f_info *info)
        err |= max77665_f_reg_wr(info, MAX77665_F_RW_MAXFLASH_TIMER,
                                info->regs.m_timing, false);
 
-       err |= max77665_f_edp_set_leds(info, info->config.led_mask,
+       err |= max77665_f_set_leds(info, info->config.led_mask,
                                info->regs.led1_curr, info->regs.led2_curr);
 
        info->regs.regs_stale = false;
@@ -973,16 +845,6 @@ static int max77665_f_enter_offmode(struct max77665_f_info *info, bool op_off)
        return err;
 }
 
-static void max77665_f_throttle(unsigned int new_state, void *priv_data)
-{
-       struct max77665_f_info *info = priv_data;
-
-       if (!info)
-               return;
-
-       max77665_f_enter_offmode(info, true);
-}
-
 #ifdef CONFIG_PM
 static int max77665_f_suspend(struct platform_device *pdev, pm_message_t msg)
 {
@@ -1011,7 +873,6 @@ static void max77665_f_shutdown(struct platform_device *pdev)
        dev_info(&pdev->dev, "Shutting down\n");
 
        max77665_f_enter_offmode(info, true);
-       max77665_f_edp_lowest(info);
        info->regs.regs_stale = true;
 }
 #endif
@@ -1046,7 +907,6 @@ static int max77665_f_power_off(struct max77665_f_info *info)
                regulator_disable(pw->vio);
 
 max77665_f_poweroff_done:
-       max77665_f_edp_lowest(info);
        info->power_is_on = 0;
        return err;
 }
@@ -1103,8 +963,6 @@ max77665_f_poweron_sync:
                return err;
        }
 
-       max77665_f_edp_lowest(info);
-
        return 0;
 
 max77665_f_poweron_i2c_fail:
@@ -1129,7 +987,6 @@ static int max77665_f_power_set(struct max77665_f_info *info, int pwr)
        switch (pwr) {
        case NVC_PWR_OFF:
                max77665_f_enter_offmode(info, true);
-               max77665_f_edp_lowest(info);
                if ((info->pdata->cfg & NVC_CFG_OFF2STDBY) ||
                        (info->pdata->cfg & NVC_CFG_BOOT_INIT))
                        pwr = NVC_PWR_STDBY;
@@ -1372,7 +1229,7 @@ static int max77665_f_set_param(struct max77665_f_info *info, long arg)
                info->new_ftimer = led_levels.timeout & 0X0F;
                curr1 = led_levels.levels[0];
                curr2 = led_levels.levels[1];
-               err = max77665_f_edp_set_leds(info,
+               err = max77665_f_set_leds(info,
                        led_levels.ledmask, curr1, curr2);
                return err;
        case NVC_PARAM_TORCH_LEVEL:
@@ -1380,7 +1237,7 @@ static int max77665_f_set_param(struct max77665_f_info *info, long arg)
                info->new_ftimer = led_levels.timeout & 0X0F;
                curr1 = led_levels.levels[0];
                curr2 = led_levels.levels[1];
-               err = max77665_f_edp_set_leds(info,
+               err = max77665_f_set_leds(info,
                        led_levels.ledmask, curr1, curr2);
                return err;
        case NVC_PARAM_FLASH_PIN_STATE:
@@ -1612,8 +1469,6 @@ static int max77665_f_probe(struct platform_device *pdev)
 
        max77665_f_configure(info, false);
 
-       max77665_f_edp_register(info);
-
        dev_set_drvdata(info->dev, info);
        mutex_init(&info->mutex);
 
@@ -1710,7 +1565,7 @@ set_attr:
        dev_info(info->dev, "new data = %x\n", val);
        switch (buf[0]) {
        case 'c': /* change led 1/2 current settings */
-               max77665_f_edp_set_leds(info, info->config.led_mask,
+               max77665_f_set_leds(info, info->config.led_mask,
                        val & 0xff, (val >> 8) & 0xff);
                break;
        case 'l': /* enable/disable led 1/2 */
@@ -1723,7 +1578,7 @@ set_attr:
                break;
        case 'f': /* modify flash timeout reg */
                info->new_ftimer = val & 0X0F;
-               max77665_f_edp_set_leds(info, info->config.led_mask,
+               max77665_f_set_leds(info, info->config.led_mask,
                        info->regs.led1_curr, info->regs.led2_curr);
                break;
        case 'p':
index 9ab0301..be887ad 100644 (file)
@@ -17,7 +17,6 @@
 #ifndef __AS364X_H__
 #define __AS364X_H__
 
-#include <linux/edp.h>
 #include <media/nvc_torch.h>
 
 enum {
@@ -85,7 +84,6 @@ struct as364x_platform_data {
        struct nvc_torch_pin_state pinstate; /* see notes in driver */
        unsigned gpio_strobe; /* GPIO connected to the ACT signal */
        bool strobe_low_act; /* strobe state active low */
-       struct edp_client edpc_config;
 
        int (*power_on_callback)(struct as364x_power_rail *pw);
        int (*power_off_callback)(struct as364x_power_rail *pw);
index d69d025..7a35044 100644 (file)
@@ -65,7 +65,6 @@ struct lm3565_platform_data {
        struct nvc_gpio_pdata strobe_gpio;
        /* GPIO configuration connected to the enable pin */
        struct nvc_gpio_pdata enable_gpio;
-       struct edp_client edpc_config;
 
        int (*power_on_callback)(struct lm3565_power_rail *pw);
        int (*power_off_callback)(struct lm3565_power_rail *pw);
index 95a01a8..47edf2c 100644 (file)
@@ -114,7 +114,6 @@ struct max77387_platform_data {
        const char *dev_name; /* see implementation notes in driver */
        struct nvc_torch_pin_state pinstate; /* see notes in driver */
        unsigned gpio_strobe; /* GPIO connected to the ACT signal */
-       struct edp_client edpc_config;
 
        int (*poweron_callback)(struct max77387_power_rail *pw);
        int (*poweroff_callback)(struct max77387_power_rail *pw);
index fc1edc6..42a177b 100644 (file)
@@ -101,7 +101,6 @@ struct max77665_f_platform_data {
        const char *dev_name; /* see implementation notes in driver */
        struct nvc_torch_pin_state pinstate; /* see notes in driver */
        unsigned gpio_strobe; /* GPIO connected to the ACT signal */
-       struct edp_client edpc_config;
 
        int (*poweron_callback)(struct max77665_f_power_rail *pw);
        int (*poweroff_callback)(struct max77665_f_power_rail *pw);