diff options
Diffstat (limited to 'target/linux/s3c24xx/patches-2.6.24/1306--lis302dl-refactor-and-cleanup.patch.patch')
| -rw-r--r-- | target/linux/s3c24xx/patches-2.6.24/1306--lis302dl-refactor-and-cleanup.patch.patch | 478 |
1 files changed, 478 insertions, 0 deletions
diff --git a/target/linux/s3c24xx/patches-2.6.24/1306--lis302dl-refactor-and-cleanup.patch.patch b/target/linux/s3c24xx/patches-2.6.24/1306--lis302dl-refactor-and-cleanup.patch.patch new file mode 100644 index 0000000000..452b2aae24 --- /dev/null +++ b/target/linux/s3c24xx/patches-2.6.24/1306--lis302dl-refactor-and-cleanup.patch.patch @@ -0,0 +1,478 @@ +From 3318a7cb3165a33046e122294e1878e3bd6555d8 Mon Sep 17 00:00:00 2001 +From: Simon Kagstrom <simon.kagstrom@gmail.com> +Date: Thu, 16 Oct 2008 01:19:20 +0100 +Subject: [PATCH] : lis302dl-refactor-and-cleanup.patch + +Some code refactoring. + +From: Simon Kagstrom <simon.kagstrom@gmail.com> + +Re-added __reg_read and __reg_write and re-indent the code according to +these. Move some input-related functions to get a more "logical" order, +e.g., in the future we might want to support clicks again and call these +from read_sample. Removed unused function pointer in the structure + +Signed-off-by: Simon Kagstrom <simon.kagstrom@gmail.com> +--- + drivers/input/misc/lis302dl.c | 260 ++++++++++++++++++++--------------------- + include/linux/lis302dl.h | 1 - + 2 files changed, 125 insertions(+), 136 deletions(-) + +diff --git a/drivers/input/misc/lis302dl.c b/drivers/input/misc/lis302dl.c +index 1013f4a..300918d 100644 +--- a/drivers/input/misc/lis302dl.c ++++ b/drivers/input/misc/lis302dl.c +@@ -43,19 +43,58 @@ + + #include <linux/lis302dl.h> + ++/* Utility functions */ ++static u8 __reg_read(struct lis302dl_info *lis, u8 reg) ++{ ++ return (lis->pdata->lis302dl_bitbang_reg_read)(lis, reg); ++} + ++static void __reg_write(struct lis302dl_info *lis, u8 reg, u8 val) ++{ ++ (lis->pdata->lis302dl_bitbang_reg_write)(lis, reg, val); ++} + + static void __reg_set_bit_mask(struct lis302dl_info *lis, u8 reg, u8 mask, +- u8 val) ++ u8 val) + { + u_int8_t tmp; + + val &= mask; + +- tmp = (lis->pdata->lis302dl_bitbang_reg_read)(lis, reg); ++ tmp = __reg_read(lis, reg); + tmp &= ~mask; + tmp |= val; +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, reg, tmp); ++ __reg_write(lis, reg, tmp); ++} ++ ++static int __ms_to_duration(struct lis302dl_info *lis, int ms) ++{ ++ u8 r = __reg_read(lis, LIS302DL_REG_CTRL1); ++ ++ /* If we have 400 ms sampling rate, the stepping is 2.5 ms, ++ * on 100 ms the stepping is 10ms */ ++ if (r & LIS302DL_CTRL1_DR) { ++ /* Too large */ ++ if (ms > 637) ++ return -1; ++ ++ return (ms * 10) / 25; ++ } ++ ++ /* Too large value */ ++ if (ms > 2550) ++ return -1; ++ return ms / 10; ++} ++ ++static int __duration_to_ms(struct lis302dl_info *lis, int duration) ++{ ++ u8 r = __reg_read(lis, LIS302DL_REG_CTRL1); ++ ++ if (r & LIS302DL_CTRL1_DR) ++ return (duration * 25) / 10; ++ ++ return duration * 10; + } + + /* interrupt handling related */ +@@ -69,30 +108,6 @@ enum lis302dl_intmode { + LIS302DL_INTMODE_CLICK = 0x07, + }; + +-#define MG_PER_SAMPLE 18 +- +-static void lis302dl_bitbang_read_sample(struct lis302dl_info *lis) +-{ +- u8 data = 0xc0 | LIS302DL_REG_OUT_X; /* read, autoincrement */ +- u8 read[5]; +- unsigned long flags; +- +- local_irq_save(flags); +- +- (lis->pdata->lis302dl_bitbang)(lis, &data, 1, &read[0], 5); +- +- local_irq_restore(flags); +- +- input_report_rel(lis->input_dev, REL_X, MG_PER_SAMPLE * (s8)read[0]); +- input_report_rel(lis->input_dev, REL_Y, MG_PER_SAMPLE * (s8)read[2]); +- input_report_rel(lis->input_dev, REL_Z, MG_PER_SAMPLE * (s8)read[4]); +- +- input_sync(lis->input_dev); +- +- /* Reset the HP filter */ +- (lis->pdata->lis302dl_bitbang_reg_read)(lis, +- LIS302DL_REG_HP_FILTER_RESET); +-} + + static void __lis302dl_int_mode(struct device *dev, int int_pin, + enum lis302dl_intmode mode) +@@ -110,6 +125,7 @@ static void __lis302dl_int_mode(struct device *dev, int int_pin, + BUG(); + } + } ++ + #if 0 + static void _report_btn_single(struct input_dev *inp, int btn) + { +@@ -130,6 +146,29 @@ static void _report_btn_double(struct input_dev *inp, int btn) + } + #endif + ++#define MG_PER_SAMPLE 18 ++ ++static void lis302dl_bitbang_read_sample(struct lis302dl_info *lis) ++{ ++ u8 data = 0xc0 | LIS302DL_REG_OUT_X; /* read, autoincrement */ ++ u8 read[5]; ++ unsigned long flags; ++ ++ local_irq_save(flags); ++ ++ (lis->pdata->lis302dl_bitbang)(lis, &data, 1, &read[0], 5); ++ ++ local_irq_restore(flags); ++ ++ input_report_rel(lis->input_dev, REL_X, MG_PER_SAMPLE * (s8)read[0]); ++ input_report_rel(lis->input_dev, REL_Y, MG_PER_SAMPLE * (s8)read[2]); ++ input_report_rel(lis->input_dev, REL_Z, MG_PER_SAMPLE * (s8)read[4]); ++ ++ input_sync(lis->input_dev); ++ ++ /* Reset the HP filter */ ++ __reg_read(lis, LIS302DL_REG_HP_FILTER_RESET); ++} + + static irqreturn_t lis302dl_interrupt(int irq, void *_lis) + { +@@ -149,8 +188,7 @@ static ssize_t show_rate(struct device *dev, struct device_attribute *attr, + unsigned long flags; + + local_irq_save(flags); +- ctrl1 = (lis->pdata->lis302dl_bitbang_reg_read) +- (lis, LIS302DL_REG_CTRL1); ++ ctrl1 = __reg_read(lis, LIS302DL_REG_CTRL1); + local_irq_restore(flags); + + return sprintf(buf, "%d\n", ctrl1 & LIS302DL_CTRL1_DR ? 400 : 100); +@@ -185,8 +223,7 @@ static ssize_t show_scale(struct device *dev, struct device_attribute *attr, + unsigned long flags; + + local_irq_save(flags); +- ctrl1 = (lis->pdata->lis302dl_bitbang_reg_read)(lis, +- LIS302DL_REG_CTRL1); ++ ctrl1 = __reg_read(lis, LIS302DL_REG_CTRL1); + local_irq_restore(flags); + + return sprintf(buf, "%s\n", ctrl1 & LIS302DL_CTRL1_FS ? "9.2" : "2.3"); +@@ -236,8 +273,7 @@ static ssize_t set_threshold(struct device *dev, struct device_attribute *attr, + /* Set the threshold and write it out if the device is used */ + lis->threshold = val; + if (lis->flags & LIS302DL_F_INPUT_OPEN) +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_FF_WU_THS_1, lis->threshold); ++ __reg_write(lis, LIS302DL_REG_FF_WU_THS_1, lis->threshold); + + return count; + } +@@ -256,7 +292,7 @@ static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr, + local_irq_save(flags); + + for (n = 0; n < sizeof(reg); n++) +- reg[n] = (lis->pdata->lis302dl_bitbang_reg_read)(lis, n); ++ reg[n] = __reg_read(lis, n); + + local_irq_restore(flags); + +@@ -271,36 +307,6 @@ static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr, + } + static DEVICE_ATTR(dump, S_IRUGO, lis302dl_dump, NULL); + +-static int __freefall_ms_to_duration(struct lis302dl_info *lis, int ms) +-{ +- u8 r = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL1); +- +- /* If we have 400 ms sampling rate, the stepping is 2.5 ms, +- * on 100 ms the stepping is 10ms */ +- if (r & LIS302DL_CTRL1_DR) { +- /* Too large */ +- if (ms > 637) +- return -1; +- +- return (ms * 10) / 25; +- } +- +- /* Too large value */ +- if (ms > 2550) +- return -1; +- return ms / 10; +-} +- +-static int __freefall_duration_to_ms(struct lis302dl_info *lis, int duration) +-{ +- u8 r = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL1); +- +- if (r & LIS302DL_CTRL1_DR) +- return (duration * 25) / 10; +- +- return duration * 10; +-} +- + /* Configure freefall/wakeup interrupts */ + static ssize_t set_freefall_common(int which, struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +@@ -342,9 +348,9 @@ static ssize_t set_freefall_common(int which, struct device *dev, + LIS302DL_INTMODE_DATA_READY); + lis->flags &= ~(flag_mask | LIS302DL_F_IRQ_WAKE); + +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, r_cfg, 0); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, r_ths, 0); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, r_duration, 0); ++ __reg_write(lis, r_cfg, 0); ++ __reg_write(lis, r_ths, 0); ++ __reg_write(lis, r_duration, 0); + + /* Power off unless the input subsystem is using the device */ + if (!(lis->flags & LIS302DL_F_INPUT_OPEN)) +@@ -361,7 +367,7 @@ static ssize_t set_freefall_common(int which, struct device *dev, + return -EINVAL; + + local_irq_save(flags); +- duration = __freefall_ms_to_duration(lis, ms); ++ duration = __ms_to_duration(lis, ms); + local_irq_save(flags); + + if (duration < 0) +@@ -382,13 +388,12 @@ static ssize_t set_freefall_common(int which, struct device *dev, + /* Setup the configuration registers */ + local_irq_save(flags); + /* First zero to get to a known state */ +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, r_cfg, 0); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, r_cfg, ++ __reg_write(lis, r_cfg, 0); ++ __reg_write(lis, r_cfg, + (and_events ? LIS302DL_FFWUCFG_AOI : 0) | + x_lo | x_hi | y_lo | y_hi | z_lo | z_hi); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, r_ths, +- threshold & ~LIS302DL_FFWUTHS_DCRM); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, r_duration, duration); ++ __reg_write(lis, r_ths, threshold & ~LIS302DL_FFWUTHS_DCRM); ++ __reg_write(lis, r_duration, duration); + + /* Route the interrupt for wakeup */ + __lis302dl_int_mode(lis->dev, which, intmode); +@@ -443,12 +448,12 @@ static ssize_t show_freefall_common(int which, struct device *dev, + } + + local_irq_save(flags); +- config = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_cfg); +- threshold = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_ths); +- duration = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_duration); +- r4 = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_src); +- r5 = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL3); +- ms = __freefall_duration_to_ms(lis, duration); ++ config = __reg_read(lis, r_cfg); ++ threshold = __reg_read(lis, r_ths); ++ duration = __reg_read(lis, r_duration); ++ r4 = __reg_read(lis, r_src); ++ r5 = __reg_read(lis, LIS302DL_REG_CTRL3); ++ ms = __duration_to_ms(lis, duration); + local_irq_restore(flags); + + /* All events off? */ +@@ -519,18 +524,14 @@ static int lis302dl_input_open(struct input_dev *inp) + /* make sure we're powered up and generate data ready */ + __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, ctrl1); + +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL2, ++ __reg_write(lis, LIS302DL_REG_CTRL2, + ctrl2); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_FF_WU_THS_1, lis->threshold); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_FF_WU_DURATION_1, 0); ++ __reg_write(lis, LIS302DL_REG_FF_WU_THS_1, lis->threshold); ++ __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, 0); + + /* Clear the HP filter "starting point" */ +- (lis->pdata->lis302dl_bitbang_reg_read)(lis, +- LIS302DL_REG_HP_FILTER_RESET); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_FF_WU_CFG_1, LIS302DL_FFWUCFG_XHIE | ++ __reg_read(lis, LIS302DL_REG_HP_FILTER_RESET); ++ __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1, LIS302DL_FFWUCFG_XHIE | + LIS302DL_FFWUCFG_YHIE | LIS302DL_FFWUCFG_ZHIE); + + lis->flags |= LIS302DL_F_INPUT_OPEN; +@@ -576,11 +577,11 @@ static int __lis302dl_reset_device(struct lis302dl_info *lis) + { + int timeout = 10; + +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL2, +- LIS302DL_CTRL2_BOOT | LIS302DL_CTRL2_FDS); ++ __reg_write(lis, LIS302DL_REG_CTRL2, ++ LIS302DL_CTRL2_BOOT | LIS302DL_CTRL2_FDS); + +- while (((lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL2) +- & LIS302DL_CTRL2_BOOT) && (timeout--)) ++ while ((__reg_read(lis, LIS302DL_REG_CTRL2) ++ & LIS302DL_CTRL2_BOOT) && (timeout--)) + mdelay(1); + + return !!(timeout < 0); +@@ -609,8 +610,7 @@ static int __devinit lis302dl_probe(struct platform_device *pdev) + /* Configure our IO */ + (lis->pdata->lis302dl_suspend_io)(lis, 1); + +- wai = (lis->pdata->lis302dl_bitbang_reg_read)(lis, +- LIS302DL_REG_WHO_AM_I); ++ wai = __reg_read(lis, LIS302DL_REG_WHO_AM_I); + if (wai != LIS302DL_WHO_AM_I_MAGIC) { + dev_err(lis->dev, "unknown who_am_i signature 0x%02x\n", wai); + dev_set_drvdata(lis->dev, NULL); +@@ -659,46 +659,38 @@ static int __devinit lis302dl_probe(struct platform_device *pdev) + dev_err(lis->dev, "device BOOT reload failed\n"); + + /* force us powered */ +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1, +- LIS302DL_CTRL1_PD | +- LIS302DL_CTRL1_Xen | +- LIS302DL_CTRL1_Yen | +- LIS302DL_CTRL1_Zen); ++ __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD | ++ LIS302DL_CTRL1_Xen | ++ LIS302DL_CTRL1_Yen | ++ LIS302DL_CTRL1_Zen); + mdelay(1); + +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL2, 0); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL3, +- LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_FF_WU_THS_1, 0x0); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_FF_WU_DURATION_1, 0x00); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_FF_WU_CFG_1, 0x0); ++ __reg_write(lis, LIS302DL_REG_CTRL2, 0); ++ __reg_write(lis, LIS302DL_REG_CTRL3, ++ LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL); ++ __reg_write(lis, LIS302DL_REG_FF_WU_THS_1, 0x0); ++ __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, 0x00); ++ __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1, 0x0); + + /* start off in powered down mode; we power up when someone opens us */ +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1, +- LIS302DL_CTRL1_Xen | +- LIS302DL_CTRL1_Yen | +- LIS302DL_CTRL1_Zen); ++ __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_Xen | ++ LIS302DL_CTRL1_Yen | LIS302DL_CTRL1_Zen); + + if (pdata->open_drain) + /* switch interrupt to open collector, active-low */ +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_CTRL3, LIS302DL_CTRL3_PP_OD | +- LIS302DL_CTRL3_IHL); ++ __reg_write(lis, LIS302DL_REG_CTRL3, ++ LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL); + else + /* push-pull, active-low */ +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- LIS302DL_REG_CTRL3, LIS302DL_CTRL3_IHL); ++ __reg_write(lis, LIS302DL_REG_CTRL3, LIS302DL_CTRL3_IHL); + + __lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_FF_WU_12); + __lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_FF_WU_12); + +- (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_STATUS); +- (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_FF_WU_SRC_1); +- (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_FF_WU_SRC_2); +- (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CLICK_SRC); ++ __reg_read(lis, LIS302DL_REG_STATUS); ++ __reg_read(lis, LIS302DL_REG_FF_WU_SRC_1); ++ __reg_read(lis, LIS302DL_REG_FF_WU_SRC_2); ++ __reg_read(lis, LIS302DL_REG_CLICK_SRC); + + dev_info(lis->dev, "Found %s\n", pdata->name); + +@@ -733,9 +725,9 @@ static int __devexit lis302dl_remove(struct platform_device *pdev) + + /* Reset and power down the device */ + local_irq_save(flags); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL3, 0x00); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL2, 0x00); +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1, 0x00); ++ __reg_write(lis, LIS302DL_REG_CTRL3, 0x00); ++ __reg_write(lis, LIS302DL_REG_CTRL2, 0x00); ++ __reg_write(lis, LIS302DL_REG_CTRL1, 0x00); + local_irq_restore(flags); + + /* Cleanup resources */ +@@ -798,13 +790,12 @@ static int lis302dl_suspend(struct platform_device *pdev, pm_message_t state) + /* save registers */ + for (n = 0; n < ARRAY_SIZE(regs_to_save); n++) + lis->regs[regs_to_save[n]] = +- (lis->pdata->lis302dl_bitbang_reg_read)(lis, +- regs_to_save[n]); ++ __reg_read(lis, regs_to_save[n]); + + /* power down */ +- tmp = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL1); ++ tmp = __reg_read(lis, LIS302DL_REG_CTRL1); + tmp &= ~LIS302DL_CTRL1_PD; +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1, tmp); ++ __reg_write(lis, LIS302DL_REG_CTRL1, tmp); + + /* place our IO to the device in sleep-compatible states */ + (lis->pdata->lis302dl_suspend_io)(lis, 0); +@@ -830,11 +821,11 @@ static int lis302dl_resume(struct platform_device *pdev) + (lis->pdata->lis302dl_suspend_io)(lis, 1); + + /* resume from powerdown first! */ +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1, +- LIS302DL_CTRL1_PD | +- LIS302DL_CTRL1_Xen | +- LIS302DL_CTRL1_Yen | +- LIS302DL_CTRL1_Zen); ++ __reg_write(lis, LIS302DL_REG_CTRL1, ++ LIS302DL_CTRL1_PD | ++ LIS302DL_CTRL1_Xen | ++ LIS302DL_CTRL1_Yen | ++ LIS302DL_CTRL1_Zen); + mdelay(1); + + if (__lis302dl_reset_device(lis)) +@@ -847,8 +838,7 @@ static int lis302dl_resume(struct platform_device *pdev) + + /* restore registers after resume */ + for (n = 0; n < ARRAY_SIZE(regs_to_save); n++) +- (lis->pdata->lis302dl_bitbang_reg_write)(lis, +- regs_to_save[n], lis->regs[regs_to_save[n]]); ++ __reg_write(lis, regs_to_save[n], lis->regs[regs_to_save[n]]); + + local_irq_restore(flags); + enable_irq(lis->pdata->interrupt); +diff --git a/include/linux/lis302dl.h b/include/linux/lis302dl.h +index f3f994d..a756f55 100644 +--- a/include/linux/lis302dl.h ++++ b/include/linux/lis302dl.h +@@ -18,7 +18,6 @@ struct lis302dl_platform_data { + int interrupt; + void (*lis302dl_bitbang)(struct lis302dl_info *lis, u8 *tx, + int tx_bytes, u8 *rx, int rx_bytes); +- void (*lis302dl_bitbang_read_sample)(struct lis302dl_info *); + void (*lis302dl_suspend_io)(struct lis302dl_info *, int resuming); + int (*lis302dl_bitbang_reg_read)(struct lis302dl_info *, u8 reg); + void (*lis302dl_bitbang_reg_write)(struct lis302dl_info *, u8 reg, +-- +1.5.6.5 + |