Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * TWL4030 MADC module driver-This driver monitors the real time |
| 4 | * conversion of analog signals like battery temperature, |
| 5 | * battery type, battery level etc. |
| 6 | * |
| 7 | * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ |
| 8 | * J Keerthy <j-keerthy@ti.com> |
| 9 | * |
| 10 | * Based on twl4030-madc.c |
| 11 | * Copyright (C) 2008 Nokia Corporation |
| 12 | * Mikko Ylinen <mikko.k.ylinen@nokia.com> |
| 13 | * |
| 14 | * Amit Kucheria <amit.kucheria@canonical.com> |
| 15 | * |
| 16 | * This program is free software; you can redistribute it and/or |
| 17 | * modify it under the terms of the GNU General Public License |
| 18 | * version 2 as published by the Free Software Foundation. |
| 19 | * |
| 20 | * This program is distributed in the hope that it will be useful, but |
| 21 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 22 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 23 | * General Public License for more details. |
| 24 | * |
| 25 | * You should have received a copy of the GNU General Public License |
| 26 | * along with this program; if not, write to the Free Software |
| 27 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
| 28 | * 02110-1301 USA |
| 29 | * |
| 30 | */ |
| 31 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 32 | #include <linux/device.h> |
| 33 | #include <linux/interrupt.h> |
| 34 | #include <linux/kernel.h> |
| 35 | #include <linux/delay.h> |
| 36 | #include <linux/platform_device.h> |
| 37 | #include <linux/slab.h> |
| 38 | #include <linux/i2c/twl.h> |
| 39 | #include <linux/i2c/twl4030-madc.h> |
| 40 | #include <linux/module.h> |
| 41 | #include <linux/stddef.h> |
| 42 | #include <linux/mutex.h> |
| 43 | #include <linux/bitops.h> |
| 44 | #include <linux/jiffies.h> |
| 45 | #include <linux/types.h> |
| 46 | #include <linux/gfp.h> |
| 47 | #include <linux/err.h> |
| 48 | |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 49 | #include <linux/iio/iio.h> |
| 50 | |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 51 | /** |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 52 | * struct twl4030_madc_data - a container for madc info |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 53 | * @dev: Pointer to device structure for madc |
| 54 | * @lock: Mutex protecting this data structure |
| 55 | * @requests: Array of request struct corresponding to SW1, SW2 and RT |
| 56 | * @use_second_irq: IRQ selection (main or co-processor) |
| 57 | * @imr: Interrupt mask register of MADC |
| 58 | * @isr: Interrupt status register of MADC |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 59 | */ |
| 60 | struct twl4030_madc_data { |
| 61 | struct device *dev; |
| 62 | struct mutex lock; /* mutex protecting this data structure */ |
| 63 | struct twl4030_madc_request requests[TWL4030_MADC_NUM_METHODS]; |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 64 | bool use_second_irq; |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 65 | u8 imr; |
| 66 | u8 isr; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 67 | }; |
| 68 | |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 69 | static int twl4030_madc_read(struct iio_dev *iio_dev, |
| 70 | const struct iio_chan_spec *chan, |
| 71 | int *val, int *val2, long mask) |
| 72 | { |
| 73 | struct twl4030_madc_data *madc = iio_priv(iio_dev); |
| 74 | struct twl4030_madc_request req; |
| 75 | int ret; |
| 76 | |
| 77 | req.method = madc->use_second_irq ? TWL4030_MADC_SW2 : TWL4030_MADC_SW1; |
| 78 | |
| 79 | req.channels = BIT(chan->channel); |
| 80 | req.active = false; |
| 81 | req.func_cb = NULL; |
| 82 | req.type = TWL4030_MADC_WAIT; |
| 83 | req.raw = !(mask == IIO_CHAN_INFO_PROCESSED); |
| 84 | req.do_avg = (mask == IIO_CHAN_INFO_AVERAGE_RAW); |
| 85 | |
| 86 | ret = twl4030_madc_conversion(&req); |
| 87 | if (ret < 0) |
| 88 | return ret; |
| 89 | |
| 90 | *val = req.rbuf[chan->channel]; |
| 91 | |
| 92 | return IIO_VAL_INT; |
| 93 | } |
| 94 | |
| 95 | static const struct iio_info twl4030_madc_iio_info = { |
| 96 | .read_raw = &twl4030_madc_read, |
| 97 | .driver_module = THIS_MODULE, |
| 98 | }; |
| 99 | |
| 100 | #define TWL4030_ADC_CHANNEL(_channel, _type, _name) { \ |
| 101 | .type = _type, \ |
| 102 | .channel = _channel, \ |
| 103 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ |
| 104 | BIT(IIO_CHAN_INFO_AVERAGE_RAW) | \ |
| 105 | BIT(IIO_CHAN_INFO_PROCESSED), \ |
| 106 | .datasheet_name = _name, \ |
| 107 | .indexed = 1, \ |
| 108 | } |
| 109 | |
| 110 | static const struct iio_chan_spec twl4030_madc_iio_channels[] = { |
| 111 | TWL4030_ADC_CHANNEL(0, IIO_VOLTAGE, "ADCIN0"), |
| 112 | TWL4030_ADC_CHANNEL(1, IIO_TEMP, "ADCIN1"), |
| 113 | TWL4030_ADC_CHANNEL(2, IIO_VOLTAGE, "ADCIN2"), |
| 114 | TWL4030_ADC_CHANNEL(3, IIO_VOLTAGE, "ADCIN3"), |
| 115 | TWL4030_ADC_CHANNEL(4, IIO_VOLTAGE, "ADCIN4"), |
| 116 | TWL4030_ADC_CHANNEL(5, IIO_VOLTAGE, "ADCIN5"), |
| 117 | TWL4030_ADC_CHANNEL(6, IIO_VOLTAGE, "ADCIN6"), |
| 118 | TWL4030_ADC_CHANNEL(7, IIO_VOLTAGE, "ADCIN7"), |
| 119 | TWL4030_ADC_CHANNEL(8, IIO_VOLTAGE, "ADCIN8"), |
| 120 | TWL4030_ADC_CHANNEL(9, IIO_VOLTAGE, "ADCIN9"), |
| 121 | TWL4030_ADC_CHANNEL(10, IIO_CURRENT, "ADCIN10"), |
| 122 | TWL4030_ADC_CHANNEL(11, IIO_VOLTAGE, "ADCIN11"), |
| 123 | TWL4030_ADC_CHANNEL(12, IIO_VOLTAGE, "ADCIN12"), |
| 124 | TWL4030_ADC_CHANNEL(13, IIO_VOLTAGE, "ADCIN13"), |
| 125 | TWL4030_ADC_CHANNEL(14, IIO_VOLTAGE, "ADCIN14"), |
| 126 | TWL4030_ADC_CHANNEL(15, IIO_VOLTAGE, "ADCIN15"), |
| 127 | }; |
| 128 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 129 | static struct twl4030_madc_data *twl4030_madc; |
| 130 | |
| 131 | struct twl4030_prescale_divider_ratios { |
| 132 | s16 numerator; |
| 133 | s16 denominator; |
| 134 | }; |
| 135 | |
| 136 | static const struct twl4030_prescale_divider_ratios |
| 137 | twl4030_divider_ratios[16] = { |
| 138 | {1, 1}, /* CHANNEL 0 No Prescaler */ |
| 139 | {1, 1}, /* CHANNEL 1 No Prescaler */ |
| 140 | {6, 10}, /* CHANNEL 2 */ |
| 141 | {6, 10}, /* CHANNEL 3 */ |
| 142 | {6, 10}, /* CHANNEL 4 */ |
| 143 | {6, 10}, /* CHANNEL 5 */ |
| 144 | {6, 10}, /* CHANNEL 6 */ |
| 145 | {6, 10}, /* CHANNEL 7 */ |
| 146 | {3, 14}, /* CHANNEL 8 */ |
| 147 | {1, 3}, /* CHANNEL 9 */ |
| 148 | {1, 1}, /* CHANNEL 10 No Prescaler */ |
| 149 | {15, 100}, /* CHANNEL 11 */ |
| 150 | {1, 4}, /* CHANNEL 12 */ |
| 151 | {1, 1}, /* CHANNEL 13 Reserved channels */ |
| 152 | {1, 1}, /* CHANNEL 14 Reseved channels */ |
| 153 | {5, 11}, /* CHANNEL 15 */ |
| 154 | }; |
| 155 | |
| 156 | |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 157 | /* Conversion table from -3 to 55 degrees Celcius */ |
| 158 | static int twl4030_therm_tbl[] = { |
| 159 | 30800, 29500, 28300, 27100, |
| 160 | 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, |
| 161 | 17900, 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, |
| 162 | 12600, 12100, 11600, 11200, 10800, 10400, 10000, 9630, 9280, |
| 163 | 8950, 8620, 8310, 8020, 7730, 7460, 7200, 6950, 6710, |
| 164 | 6470, 6250, 6040, 5830, 5640, 5450, 5260, 5090, 4920, |
| 165 | 4760, 4600, 4450, 4310, 4170, 4040, 3910, 3790, 3670, |
| 166 | 3550 |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 167 | }; |
| 168 | |
| 169 | /* |
| 170 | * Structure containing the registers |
| 171 | * of different conversion methods supported by MADC. |
| 172 | * Hardware or RT real time conversion request initiated by external host |
| 173 | * processor for RT Signal conversions. |
| 174 | * External host processors can also request for non RT conversions |
| 175 | * SW1 and SW2 software conversions also called asynchronous or GPC request. |
| 176 | */ |
| 177 | static |
| 178 | const struct twl4030_madc_conversion_method twl4030_conversion_methods[] = { |
| 179 | [TWL4030_MADC_RT] = { |
| 180 | .sel = TWL4030_MADC_RTSELECT_LSB, |
| 181 | .avg = TWL4030_MADC_RTAVERAGE_LSB, |
| 182 | .rbase = TWL4030_MADC_RTCH0_LSB, |
| 183 | }, |
| 184 | [TWL4030_MADC_SW1] = { |
| 185 | .sel = TWL4030_MADC_SW1SELECT_LSB, |
| 186 | .avg = TWL4030_MADC_SW1AVERAGE_LSB, |
| 187 | .rbase = TWL4030_MADC_GPCH0_LSB, |
| 188 | .ctrl = TWL4030_MADC_CTRL_SW1, |
| 189 | }, |
| 190 | [TWL4030_MADC_SW2] = { |
| 191 | .sel = TWL4030_MADC_SW2SELECT_LSB, |
| 192 | .avg = TWL4030_MADC_SW2AVERAGE_LSB, |
| 193 | .rbase = TWL4030_MADC_GPCH0_LSB, |
| 194 | .ctrl = TWL4030_MADC_CTRL_SW2, |
| 195 | }, |
| 196 | }; |
| 197 | |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 198 | /** |
| 199 | * twl4030_madc_channel_raw_read() - Function to read a particular channel value |
| 200 | * @madc: pointer to struct twl4030_madc_data |
| 201 | * @reg: lsb of ADC Channel |
| 202 | * |
| 203 | * Return: 0 on success, an error code otherwise. |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 204 | */ |
| 205 | static int twl4030_madc_channel_raw_read(struct twl4030_madc_data *madc, u8 reg) |
| 206 | { |
Sebastian Reichel | 168ae30 | 2014-03-16 02:43:29 +0100 | [diff] [blame] | 207 | u16 val; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 208 | int ret; |
| 209 | /* |
| 210 | * For each ADC channel, we have MSB and LSB register pair. MSB address |
| 211 | * is always LSB address+1. reg parameter is the address of LSB register |
| 212 | */ |
Sebastian Reichel | 168ae30 | 2014-03-16 02:43:29 +0100 | [diff] [blame] | 213 | ret = twl_i2c_read_u16(TWL4030_MODULE_MADC, &val, reg); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 214 | if (ret) { |
Sebastian Reichel | 168ae30 | 2014-03-16 02:43:29 +0100 | [diff] [blame] | 215 | dev_err(madc->dev, "unable to read register 0x%X\n", reg); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 216 | return ret; |
| 217 | } |
| 218 | |
Sebastian Reichel | 168ae30 | 2014-03-16 02:43:29 +0100 | [diff] [blame] | 219 | return (int)(val >> 6); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 220 | } |
| 221 | |
| 222 | /* |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 223 | * Return battery temperature in degrees Celsius |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 224 | * Or < 0 on failure. |
| 225 | */ |
| 226 | static int twl4030battery_temperature(int raw_volt) |
| 227 | { |
| 228 | u8 val; |
| 229 | int temp, curr, volt, res, ret; |
| 230 | |
| 231 | volt = (raw_volt * TEMP_STEP_SIZE) / TEMP_PSR_R; |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 232 | /* Getting and calculating the supply current in micro amperes */ |
Peter Ujfalusi | e45342f | 2012-11-13 09:28:51 +0100 | [diff] [blame] | 233 | ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, &val, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 234 | REG_BCICTL2); |
| 235 | if (ret < 0) |
| 236 | return ret; |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 237 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 238 | curr = ((val & TWL4030_BCI_ITHEN) + 1) * 10; |
| 239 | /* Getting and calculating the thermistor resistance in ohms */ |
| 240 | res = volt * 1000 / curr; |
| 241 | /* calculating temperature */ |
| 242 | for (temp = 58; temp >= 0; temp--) { |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 243 | int actual = twl4030_therm_tbl[temp]; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 244 | if ((actual - res) >= 0) |
| 245 | break; |
| 246 | } |
| 247 | |
| 248 | return temp + 1; |
| 249 | } |
| 250 | |
| 251 | static int twl4030battery_current(int raw_volt) |
| 252 | { |
| 253 | int ret; |
| 254 | u8 val; |
| 255 | |
Peter Ujfalusi | e45342f | 2012-11-13 09:28:51 +0100 | [diff] [blame] | 256 | ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, &val, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 257 | TWL4030_BCI_BCICTL1); |
| 258 | if (ret) |
| 259 | return ret; |
| 260 | if (val & TWL4030_BCI_CGAIN) /* slope of 0.44 mV/mA */ |
| 261 | return (raw_volt * CURR_STEP_SIZE) / CURR_PSR_R1; |
| 262 | else /* slope of 0.88 mV/mA */ |
| 263 | return (raw_volt * CURR_STEP_SIZE) / CURR_PSR_R2; |
| 264 | } |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 265 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 266 | /* |
| 267 | * Function to read channel values |
| 268 | * @madc - pointer to twl4030_madc_data struct |
| 269 | * @reg_base - Base address of the first channel |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 270 | * @Channels - 16 bit bitmap. If the bit is set, channel's value is read |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 271 | * @buf - The channel values are stored here. if read fails error |
Pali Rohár | a5055d5 | 2013-02-15 23:56:49 +0100 | [diff] [blame] | 272 | * @raw - Return raw values without conversion |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 273 | * value is stored |
| 274 | * Returns the number of successfully read channels. |
| 275 | */ |
| 276 | static int twl4030_madc_read_channels(struct twl4030_madc_data *madc, |
| 277 | u8 reg_base, unsigned |
Pali Rohár | a5055d5 | 2013-02-15 23:56:49 +0100 | [diff] [blame] | 278 | long channels, int *buf, |
| 279 | bool raw) |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 280 | { |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 281 | int count = 0; |
| 282 | int i; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 283 | u8 reg; |
| 284 | |
| 285 | for_each_set_bit(i, &channels, TWL4030_MADC_MAX_CHANNELS) { |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 286 | reg = reg_base + (2 * i); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 287 | buf[i] = twl4030_madc_channel_raw_read(madc, reg); |
| 288 | if (buf[i] < 0) { |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 289 | dev_err(madc->dev, "Unable to read register 0x%X\n", |
| 290 | reg); |
| 291 | return buf[i]; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 292 | } |
Pali Rohár | a5055d5 | 2013-02-15 23:56:49 +0100 | [diff] [blame] | 293 | if (raw) { |
| 294 | count++; |
| 295 | continue; |
| 296 | } |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 297 | switch (i) { |
| 298 | case 10: |
| 299 | buf[i] = twl4030battery_current(buf[i]); |
| 300 | if (buf[i] < 0) { |
| 301 | dev_err(madc->dev, "err reading current\n"); |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 302 | return buf[i]; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 303 | } else { |
| 304 | count++; |
| 305 | buf[i] = buf[i] - 750; |
| 306 | } |
| 307 | break; |
| 308 | case 1: |
| 309 | buf[i] = twl4030battery_temperature(buf[i]); |
| 310 | if (buf[i] < 0) { |
| 311 | dev_err(madc->dev, "err reading temperature\n"); |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 312 | return buf[i]; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 313 | } else { |
| 314 | buf[i] -= 3; |
| 315 | count++; |
| 316 | } |
| 317 | break; |
| 318 | default: |
| 319 | count++; |
| 320 | /* Analog Input (V) = conv_result * step_size / R |
| 321 | * conv_result = decimal value of 10-bit conversion |
| 322 | * result |
| 323 | * step size = 1.5 / (2 ^ 10 -1) |
| 324 | * R = Prescaler ratio for input channels. |
| 325 | * Result given in mV hence multiplied by 1000. |
| 326 | */ |
| 327 | buf[i] = (buf[i] * 3 * 1000 * |
| 328 | twl4030_divider_ratios[i].denominator) |
| 329 | / (2 * 1023 * |
| 330 | twl4030_divider_ratios[i].numerator); |
| 331 | } |
| 332 | } |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 333 | |
| 334 | return count; |
| 335 | } |
| 336 | |
| 337 | /* |
| 338 | * Enables irq. |
| 339 | * @madc - pointer to twl4030_madc_data struct |
| 340 | * @id - irq number to be enabled |
| 341 | * can take one of TWL4030_MADC_RT, TWL4030_MADC_SW1, TWL4030_MADC_SW2 |
| 342 | * corresponding to RT, SW1, SW2 conversion requests. |
| 343 | * If the i2c read fails it returns an error else returns 0. |
| 344 | */ |
| 345 | static int twl4030_madc_enable_irq(struct twl4030_madc_data *madc, u8 id) |
| 346 | { |
| 347 | u8 val; |
| 348 | int ret; |
| 349 | |
| 350 | ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &val, madc->imr); |
| 351 | if (ret) { |
| 352 | dev_err(madc->dev, "unable to read imr register 0x%X\n", |
| 353 | madc->imr); |
| 354 | return ret; |
| 355 | } |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 356 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 357 | val &= ~(1 << id); |
| 358 | ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, val, madc->imr); |
| 359 | if (ret) { |
| 360 | dev_err(madc->dev, |
| 361 | "unable to write imr register 0x%X\n", madc->imr); |
| 362 | return ret; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 363 | } |
| 364 | |
| 365 | return 0; |
| 366 | } |
| 367 | |
| 368 | /* |
| 369 | * Disables irq. |
| 370 | * @madc - pointer to twl4030_madc_data struct |
| 371 | * @id - irq number to be disabled |
| 372 | * can take one of TWL4030_MADC_RT, TWL4030_MADC_SW1, TWL4030_MADC_SW2 |
| 373 | * corresponding to RT, SW1, SW2 conversion requests. |
| 374 | * Returns error if i2c read/write fails. |
| 375 | */ |
| 376 | static int twl4030_madc_disable_irq(struct twl4030_madc_data *madc, u8 id) |
| 377 | { |
| 378 | u8 val; |
| 379 | int ret; |
| 380 | |
| 381 | ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &val, madc->imr); |
| 382 | if (ret) { |
| 383 | dev_err(madc->dev, "unable to read imr register 0x%X\n", |
| 384 | madc->imr); |
| 385 | return ret; |
| 386 | } |
| 387 | val |= (1 << id); |
| 388 | ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, val, madc->imr); |
| 389 | if (ret) { |
| 390 | dev_err(madc->dev, |
| 391 | "unable to write imr register 0x%X\n", madc->imr); |
| 392 | return ret; |
| 393 | } |
| 394 | |
| 395 | return 0; |
| 396 | } |
| 397 | |
| 398 | static irqreturn_t twl4030_madc_threaded_irq_handler(int irq, void *_madc) |
| 399 | { |
| 400 | struct twl4030_madc_data *madc = _madc; |
| 401 | const struct twl4030_madc_conversion_method *method; |
| 402 | u8 isr_val, imr_val; |
| 403 | int i, len, ret; |
| 404 | struct twl4030_madc_request *r; |
| 405 | |
| 406 | mutex_lock(&madc->lock); |
| 407 | ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &isr_val, madc->isr); |
| 408 | if (ret) { |
| 409 | dev_err(madc->dev, "unable to read isr register 0x%X\n", |
| 410 | madc->isr); |
| 411 | goto err_i2c; |
| 412 | } |
| 413 | ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &imr_val, madc->imr); |
| 414 | if (ret) { |
| 415 | dev_err(madc->dev, "unable to read imr register 0x%X\n", |
| 416 | madc->imr); |
| 417 | goto err_i2c; |
| 418 | } |
| 419 | isr_val &= ~imr_val; |
| 420 | for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) { |
| 421 | if (!(isr_val & (1 << i))) |
| 422 | continue; |
| 423 | ret = twl4030_madc_disable_irq(madc, i); |
| 424 | if (ret < 0) |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 425 | dev_dbg(madc->dev, "Disable interrupt failed %d\n", i); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 426 | madc->requests[i].result_pending = 1; |
| 427 | } |
| 428 | for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) { |
| 429 | r = &madc->requests[i]; |
| 430 | /* No pending results for this method, move to next one */ |
| 431 | if (!r->result_pending) |
| 432 | continue; |
| 433 | method = &twl4030_conversion_methods[r->method]; |
| 434 | /* Read results */ |
| 435 | len = twl4030_madc_read_channels(madc, method->rbase, |
Pali Rohár | a5055d5 | 2013-02-15 23:56:49 +0100 | [diff] [blame] | 436 | r->channels, r->rbuf, r->raw); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 437 | /* Return results to caller */ |
| 438 | if (r->func_cb != NULL) { |
| 439 | r->func_cb(len, r->channels, r->rbuf); |
| 440 | r->func_cb = NULL; |
| 441 | } |
| 442 | /* Free request */ |
| 443 | r->result_pending = 0; |
| 444 | r->active = 0; |
| 445 | } |
| 446 | mutex_unlock(&madc->lock); |
| 447 | |
| 448 | return IRQ_HANDLED; |
| 449 | |
| 450 | err_i2c: |
| 451 | /* |
| 452 | * In case of error check whichever request is active |
| 453 | * and service the same. |
| 454 | */ |
| 455 | for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) { |
| 456 | r = &madc->requests[i]; |
| 457 | if (r->active == 0) |
| 458 | continue; |
| 459 | method = &twl4030_conversion_methods[r->method]; |
| 460 | /* Read results */ |
| 461 | len = twl4030_madc_read_channels(madc, method->rbase, |
Pali Rohár | a5055d5 | 2013-02-15 23:56:49 +0100 | [diff] [blame] | 462 | r->channels, r->rbuf, r->raw); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 463 | /* Return results to caller */ |
| 464 | if (r->func_cb != NULL) { |
| 465 | r->func_cb(len, r->channels, r->rbuf); |
| 466 | r->func_cb = NULL; |
| 467 | } |
| 468 | /* Free request */ |
| 469 | r->result_pending = 0; |
| 470 | r->active = 0; |
| 471 | } |
| 472 | mutex_unlock(&madc->lock); |
| 473 | |
| 474 | return IRQ_HANDLED; |
| 475 | } |
| 476 | |
| 477 | static int twl4030_madc_set_irq(struct twl4030_madc_data *madc, |
| 478 | struct twl4030_madc_request *req) |
| 479 | { |
| 480 | struct twl4030_madc_request *p; |
| 481 | int ret; |
| 482 | |
| 483 | p = &madc->requests[req->method]; |
| 484 | memcpy(p, req, sizeof(*req)); |
| 485 | ret = twl4030_madc_enable_irq(madc, req->method); |
| 486 | if (ret < 0) { |
| 487 | dev_err(madc->dev, "enable irq failed!!\n"); |
| 488 | return ret; |
| 489 | } |
| 490 | |
| 491 | return 0; |
| 492 | } |
| 493 | |
| 494 | /* |
| 495 | * Function which enables the madc conversion |
| 496 | * by writing to the control register. |
| 497 | * @madc - pointer to twl4030_madc_data struct |
| 498 | * @conv_method - can be TWL4030_MADC_RT, TWL4030_MADC_SW2, TWL4030_MADC_SW1 |
| 499 | * corresponding to RT SW1 or SW2 conversion methods. |
| 500 | * Returns 0 if succeeds else a negative error value |
| 501 | */ |
| 502 | static int twl4030_madc_start_conversion(struct twl4030_madc_data *madc, |
| 503 | int conv_method) |
| 504 | { |
| 505 | const struct twl4030_madc_conversion_method *method; |
| 506 | int ret = 0; |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 507 | |
| 508 | if (conv_method != TWL4030_MADC_SW1 && conv_method != TWL4030_MADC_SW2) |
| 509 | return -ENOTSUPP; |
| 510 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 511 | method = &twl4030_conversion_methods[conv_method]; |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 512 | ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, TWL4030_MADC_SW_START, |
| 513 | method->ctrl); |
| 514 | if (ret) { |
| 515 | dev_err(madc->dev, "unable to write ctrl register 0x%X\n", |
| 516 | method->ctrl); |
| 517 | return ret; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 518 | } |
| 519 | |
| 520 | return 0; |
| 521 | } |
| 522 | |
| 523 | /* |
| 524 | * Function that waits for conversion to be ready |
| 525 | * @madc - pointer to twl4030_madc_data struct |
| 526 | * @timeout_ms - timeout value in milliseconds |
| 527 | * @status_reg - ctrl register |
| 528 | * returns 0 if succeeds else a negative error value |
| 529 | */ |
| 530 | static int twl4030_madc_wait_conversion_ready(struct twl4030_madc_data *madc, |
| 531 | unsigned int timeout_ms, |
| 532 | u8 status_reg) |
| 533 | { |
| 534 | unsigned long timeout; |
| 535 | int ret; |
| 536 | |
| 537 | timeout = jiffies + msecs_to_jiffies(timeout_ms); |
| 538 | do { |
| 539 | u8 reg; |
| 540 | |
| 541 | ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, ®, status_reg); |
| 542 | if (ret) { |
| 543 | dev_err(madc->dev, |
| 544 | "unable to read status register 0x%X\n", |
| 545 | status_reg); |
| 546 | return ret; |
| 547 | } |
| 548 | if (!(reg & TWL4030_MADC_BUSY) && (reg & TWL4030_MADC_EOC_SW)) |
| 549 | return 0; |
| 550 | usleep_range(500, 2000); |
| 551 | } while (!time_after(jiffies, timeout)); |
| 552 | dev_err(madc->dev, "conversion timeout!\n"); |
| 553 | |
| 554 | return -EAGAIN; |
| 555 | } |
| 556 | |
| 557 | /* |
| 558 | * An exported function which can be called from other kernel drivers. |
| 559 | * @req twl4030_madc_request structure |
| 560 | * req->rbuf will be filled with read values of channels based on the |
| 561 | * channel index. If a particular channel reading fails there will |
| 562 | * be a negative error value in the corresponding array element. |
| 563 | * returns 0 if succeeds else error value |
| 564 | */ |
| 565 | int twl4030_madc_conversion(struct twl4030_madc_request *req) |
| 566 | { |
| 567 | const struct twl4030_madc_conversion_method *method; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 568 | int ret; |
| 569 | |
Kyle Manna | d0e84ca | 2011-08-11 22:33:14 -0500 | [diff] [blame] | 570 | if (!req || !twl4030_madc) |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 571 | return -EINVAL; |
Kyle Manna | d0e84ca | 2011-08-11 22:33:14 -0500 | [diff] [blame] | 572 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 573 | mutex_lock(&twl4030_madc->lock); |
| 574 | if (req->method < TWL4030_MADC_RT || req->method > TWL4030_MADC_SW2) { |
| 575 | ret = -EINVAL; |
| 576 | goto out; |
| 577 | } |
| 578 | /* Do we have a conversion request ongoing */ |
| 579 | if (twl4030_madc->requests[req->method].active) { |
| 580 | ret = -EBUSY; |
| 581 | goto out; |
| 582 | } |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 583 | method = &twl4030_conversion_methods[req->method]; |
| 584 | /* Select channels to be converted */ |
Sebastian Reichel | 168ae30 | 2014-03-16 02:43:29 +0100 | [diff] [blame] | 585 | ret = twl_i2c_write_u16(TWL4030_MODULE_MADC, req->channels, method->sel); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 586 | if (ret) { |
| 587 | dev_err(twl4030_madc->dev, |
Sebastian Reichel | 168ae30 | 2014-03-16 02:43:29 +0100 | [diff] [blame] | 588 | "unable to write sel register 0x%X\n", method->sel); |
Sanjeev Premi | e178ccb | 2011-07-11 20:50:31 +0530 | [diff] [blame] | 589 | goto out; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 590 | } |
| 591 | /* Select averaging for all channels if do_avg is set */ |
| 592 | if (req->do_avg) { |
Sebastian Reichel | 168ae30 | 2014-03-16 02:43:29 +0100 | [diff] [blame] | 593 | ret = twl_i2c_write_u16(TWL4030_MODULE_MADC, req->channels, |
| 594 | method->avg); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 595 | if (ret) { |
| 596 | dev_err(twl4030_madc->dev, |
| 597 | "unable to write avg register 0x%X\n", |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 598 | method->avg); |
Sanjeev Premi | e178ccb | 2011-07-11 20:50:31 +0530 | [diff] [blame] | 599 | goto out; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 600 | } |
| 601 | } |
| 602 | if (req->type == TWL4030_MADC_IRQ_ONESHOT && req->func_cb != NULL) { |
| 603 | ret = twl4030_madc_set_irq(twl4030_madc, req); |
| 604 | if (ret < 0) |
| 605 | goto out; |
| 606 | ret = twl4030_madc_start_conversion(twl4030_madc, req->method); |
| 607 | if (ret < 0) |
| 608 | goto out; |
| 609 | twl4030_madc->requests[req->method].active = 1; |
| 610 | ret = 0; |
| 611 | goto out; |
| 612 | } |
| 613 | /* With RT method we should not be here anymore */ |
| 614 | if (req->method == TWL4030_MADC_RT) { |
| 615 | ret = -EINVAL; |
| 616 | goto out; |
| 617 | } |
| 618 | ret = twl4030_madc_start_conversion(twl4030_madc, req->method); |
| 619 | if (ret < 0) |
| 620 | goto out; |
| 621 | twl4030_madc->requests[req->method].active = 1; |
| 622 | /* Wait until conversion is ready (ctrl register returns EOC) */ |
| 623 | ret = twl4030_madc_wait_conversion_ready(twl4030_madc, 5, method->ctrl); |
| 624 | if (ret) { |
| 625 | twl4030_madc->requests[req->method].active = 0; |
| 626 | goto out; |
| 627 | } |
| 628 | ret = twl4030_madc_read_channels(twl4030_madc, method->rbase, |
Pali Rohár | a5055d5 | 2013-02-15 23:56:49 +0100 | [diff] [blame] | 629 | req->channels, req->rbuf, req->raw); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 630 | twl4030_madc->requests[req->method].active = 0; |
| 631 | |
| 632 | out: |
| 633 | mutex_unlock(&twl4030_madc->lock); |
| 634 | |
| 635 | return ret; |
| 636 | } |
| 637 | EXPORT_SYMBOL_GPL(twl4030_madc_conversion); |
| 638 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 639 | int twl4030_get_madc_conversion(int channel_no) |
| 640 | { |
| 641 | struct twl4030_madc_request req; |
| 642 | int temp = 0; |
| 643 | int ret; |
| 644 | |
| 645 | req.channels = (1 << channel_no); |
| 646 | req.method = TWL4030_MADC_SW2; |
| 647 | req.active = 0; |
Paul Kocialkowski | e0326be | 2014-05-24 13:09:00 +0100 | [diff] [blame^] | 648 | req.raw = 0; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 649 | req.func_cb = NULL; |
| 650 | ret = twl4030_madc_conversion(&req); |
| 651 | if (ret < 0) |
| 652 | return ret; |
| 653 | if (req.rbuf[channel_no] > 0) |
| 654 | temp = req.rbuf[channel_no]; |
| 655 | |
| 656 | return temp; |
| 657 | } |
| 658 | EXPORT_SYMBOL_GPL(twl4030_get_madc_conversion); |
| 659 | |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 660 | /** |
| 661 | * twl4030_madc_set_current_generator() - setup bias current |
| 662 | * |
| 663 | * @madc: pointer to twl4030_madc_data struct |
| 664 | * @chan: can be one of the two values: |
| 665 | * TWL4030_BCI_ITHEN |
| 666 | * Enables bias current for main battery type reading |
| 667 | * TWL4030_BCI_TYPEN |
| 668 | * Enables bias current for main battery temperature sensing |
| 669 | * @on: enable or disable chan. |
| 670 | * |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 671 | * Function to enable or disable bias current for |
| 672 | * main battery type reading or temperature sensing |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 673 | */ |
| 674 | static int twl4030_madc_set_current_generator(struct twl4030_madc_data *madc, |
| 675 | int chan, int on) |
| 676 | { |
| 677 | int ret; |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 678 | int regmask; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 679 | u8 regval; |
| 680 | |
Peter Ujfalusi | e45342f | 2012-11-13 09:28:51 +0100 | [diff] [blame] | 681 | ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 682 | ®val, TWL4030_BCI_BCICTL1); |
| 683 | if (ret) { |
| 684 | dev_err(madc->dev, "unable to read BCICTL1 reg 0x%X", |
| 685 | TWL4030_BCI_BCICTL1); |
| 686 | return ret; |
| 687 | } |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 688 | |
| 689 | regmask = chan ? TWL4030_BCI_ITHEN : TWL4030_BCI_TYPEN; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 690 | if (on) |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 691 | regval |= regmask; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 692 | else |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 693 | regval &= ~regmask; |
| 694 | |
Peter Ujfalusi | e45342f | 2012-11-13 09:28:51 +0100 | [diff] [blame] | 695 | ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 696 | regval, TWL4030_BCI_BCICTL1); |
| 697 | if (ret) { |
| 698 | dev_err(madc->dev, "unable to write BCICTL1 reg 0x%X\n", |
| 699 | TWL4030_BCI_BCICTL1); |
| 700 | return ret; |
| 701 | } |
| 702 | |
| 703 | return 0; |
| 704 | } |
| 705 | |
| 706 | /* |
| 707 | * Function that sets MADC software power on bit to enable MADC |
| 708 | * @madc - pointer to twl4030_madc_data struct |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 709 | * @on - Enable or disable MADC software power on bit. |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 710 | * returns error if i2c read/write fails else 0 |
| 711 | */ |
| 712 | static int twl4030_madc_set_power(struct twl4030_madc_data *madc, int on) |
| 713 | { |
| 714 | u8 regval; |
| 715 | int ret; |
| 716 | |
Peter Ujfalusi | e45342f | 2012-11-13 09:28:51 +0100 | [diff] [blame] | 717 | ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 718 | ®val, TWL4030_MADC_CTRL1); |
| 719 | if (ret) { |
| 720 | dev_err(madc->dev, "unable to read madc ctrl1 reg 0x%X\n", |
| 721 | TWL4030_MADC_CTRL1); |
| 722 | return ret; |
| 723 | } |
| 724 | if (on) |
| 725 | regval |= TWL4030_MADC_MADCON; |
| 726 | else |
| 727 | regval &= ~TWL4030_MADC_MADCON; |
| 728 | ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, regval, TWL4030_MADC_CTRL1); |
| 729 | if (ret) { |
| 730 | dev_err(madc->dev, "unable to write madc ctrl1 reg 0x%X\n", |
| 731 | TWL4030_MADC_CTRL1); |
| 732 | return ret; |
| 733 | } |
| 734 | |
| 735 | return 0; |
| 736 | } |
| 737 | |
| 738 | /* |
| 739 | * Initialize MADC and request for threaded irq |
| 740 | */ |
Bill Pemberton | f791be4 | 2012-11-19 13:23:04 -0500 | [diff] [blame] | 741 | static int twl4030_madc_probe(struct platform_device *pdev) |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 742 | { |
| 743 | struct twl4030_madc_data *madc; |
Jingoo Han | 334a41c | 2013-07-30 17:10:05 +0900 | [diff] [blame] | 744 | struct twl4030_madc_platform_data *pdata = dev_get_platdata(&pdev->dev); |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 745 | struct device_node *np = pdev->dev.of_node; |
Sebastian Reichel | e7f22b7 | 2014-03-16 02:43:25 +0100 | [diff] [blame] | 746 | int irq, ret; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 747 | u8 regval; |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 748 | struct iio_dev *iio_dev = NULL; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 749 | |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 750 | if (!pdata && !np) { |
| 751 | dev_err(&pdev->dev, "neither platform data nor Device Tree node available\n"); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 752 | return -EINVAL; |
| 753 | } |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 754 | |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 755 | iio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*madc)); |
| 756 | if (!iio_dev) { |
| 757 | dev_err(&pdev->dev, "failed allocating iio device\n"); |
| 758 | return -ENOMEM; |
| 759 | } |
| 760 | |
| 761 | madc = iio_priv(iio_dev); |
Kyle Manna | 66cc5b8 | 2011-08-11 22:33:12 -0500 | [diff] [blame] | 762 | madc->dev = &pdev->dev; |
| 763 | |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 764 | iio_dev->name = dev_name(&pdev->dev); |
| 765 | iio_dev->dev.parent = &pdev->dev; |
| 766 | iio_dev->dev.of_node = pdev->dev.of_node; |
| 767 | iio_dev->info = &twl4030_madc_iio_info; |
| 768 | iio_dev->modes = INDIO_DIRECT_MODE; |
| 769 | iio_dev->channels = twl4030_madc_iio_channels; |
| 770 | iio_dev->num_channels = ARRAY_SIZE(twl4030_madc_iio_channels); |
| 771 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 772 | /* |
| 773 | * Phoenix provides 2 interrupt lines. The first one is connected to |
| 774 | * the OMAP. The other one can be connected to the other processor such |
| 775 | * as modem. Hence two separate ISR and IMR registers. |
| 776 | */ |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 777 | if (pdata) |
| 778 | madc->use_second_irq = (pdata->irq_line != 1); |
| 779 | else |
| 780 | madc->use_second_irq = of_property_read_bool(np, |
| 781 | "ti,system-uses-second-madc-irq"); |
| 782 | |
| 783 | madc->imr = madc->use_second_irq ? TWL4030_MADC_IMR2 : |
| 784 | TWL4030_MADC_IMR1; |
| 785 | madc->isr = madc->use_second_irq ? TWL4030_MADC_ISR2 : |
| 786 | TWL4030_MADC_ISR1; |
| 787 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 788 | ret = twl4030_madc_set_power(madc, 1); |
| 789 | if (ret < 0) |
Sebastian Reichel | e7f22b7 | 2014-03-16 02:43:25 +0100 | [diff] [blame] | 790 | return ret; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 791 | ret = twl4030_madc_set_current_generator(madc, 0, 1); |
| 792 | if (ret < 0) |
| 793 | goto err_current_generator; |
| 794 | |
Peter Ujfalusi | e45342f | 2012-11-13 09:28:51 +0100 | [diff] [blame] | 795 | ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 796 | ®val, TWL4030_BCI_BCICTL1); |
| 797 | if (ret) { |
| 798 | dev_err(&pdev->dev, "unable to read reg BCI CTL1 0x%X\n", |
| 799 | TWL4030_BCI_BCICTL1); |
| 800 | goto err_i2c; |
| 801 | } |
| 802 | regval |= TWL4030_BCI_MESBAT; |
Peter Ujfalusi | e45342f | 2012-11-13 09:28:51 +0100 | [diff] [blame] | 803 | ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 804 | regval, TWL4030_BCI_BCICTL1); |
| 805 | if (ret) { |
| 806 | dev_err(&pdev->dev, "unable to write reg BCI Ctl1 0x%X\n", |
| 807 | TWL4030_BCI_BCICTL1); |
| 808 | goto err_i2c; |
| 809 | } |
Kyle Manna | 3d6271f | 2011-08-11 22:33:13 -0500 | [diff] [blame] | 810 | |
| 811 | /* Check that MADC clock is on */ |
| 812 | ret = twl_i2c_read_u8(TWL4030_MODULE_INTBR, ®val, TWL4030_REG_GPBR1); |
| 813 | if (ret) { |
| 814 | dev_err(&pdev->dev, "unable to read reg GPBR1 0x%X\n", |
| 815 | TWL4030_REG_GPBR1); |
| 816 | goto err_i2c; |
| 817 | } |
| 818 | |
| 819 | /* If MADC clk is not on, turn it on */ |
| 820 | if (!(regval & TWL4030_GPBR1_MADC_HFCLK_EN)) { |
| 821 | dev_info(&pdev->dev, "clk disabled, enabling\n"); |
| 822 | regval |= TWL4030_GPBR1_MADC_HFCLK_EN; |
| 823 | ret = twl_i2c_write_u8(TWL4030_MODULE_INTBR, regval, |
| 824 | TWL4030_REG_GPBR1); |
| 825 | if (ret) { |
| 826 | dev_err(&pdev->dev, "unable to write reg GPBR1 0x%X\n", |
| 827 | TWL4030_REG_GPBR1); |
| 828 | goto err_i2c; |
| 829 | } |
| 830 | } |
| 831 | |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 832 | platform_set_drvdata(pdev, iio_dev); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 833 | mutex_init(&madc->lock); |
Sebastian Reichel | e7f22b7 | 2014-03-16 02:43:25 +0100 | [diff] [blame] | 834 | |
| 835 | irq = platform_get_irq(pdev, 0); |
| 836 | ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 837 | twl4030_madc_threaded_irq_handler, |
| 838 | IRQF_TRIGGER_RISING, "twl4030_madc", madc); |
| 839 | if (ret) { |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 840 | dev_err(&pdev->dev, "could not request irq\n"); |
Jingoo Han | c3d6a0a | 2013-05-06 13:08:08 +0900 | [diff] [blame] | 841 | goto err_i2c; |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 842 | } |
| 843 | twl4030_madc = madc; |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 844 | |
| 845 | ret = iio_device_register(iio_dev); |
| 846 | if (ret) { |
| 847 | dev_err(&pdev->dev, "could not register iio device\n"); |
| 848 | goto err_i2c; |
| 849 | } |
| 850 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 851 | return 0; |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 852 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 853 | err_i2c: |
| 854 | twl4030_madc_set_current_generator(madc, 0, 0); |
| 855 | err_current_generator: |
| 856 | twl4030_madc_set_power(madc, 0); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 857 | return ret; |
| 858 | } |
| 859 | |
Bill Pemberton | 4740f73 | 2012-11-19 13:26:01 -0500 | [diff] [blame] | 860 | static int twl4030_madc_remove(struct platform_device *pdev) |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 861 | { |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 862 | struct iio_dev *iio_dev = platform_get_drvdata(pdev); |
| 863 | struct twl4030_madc_data *madc = iio_priv(iio_dev); |
| 864 | |
| 865 | iio_device_unregister(iio_dev); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 866 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 867 | twl4030_madc_set_current_generator(madc, 0, 0); |
| 868 | twl4030_madc_set_power(madc, 0); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 869 | |
| 870 | return 0; |
| 871 | } |
| 872 | |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 873 | #ifdef CONFIG_OF |
| 874 | static const struct of_device_id twl_madc_of_match[] = { |
| 875 | { .compatible = "ti,twl4030-madc", }, |
| 876 | { }, |
| 877 | }; |
| 878 | MODULE_DEVICE_TABLE(of, twl_madc_of_match); |
| 879 | #endif |
| 880 | |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 881 | static struct platform_driver twl4030_madc_driver = { |
| 882 | .probe = twl4030_madc_probe, |
Arnd Bergmann | 0371541 | 2013-03-14 22:56:38 +0100 | [diff] [blame] | 883 | .remove = twl4030_madc_remove, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 884 | .driver = { |
| 885 | .name = "twl4030_madc", |
| 886 | .owner = THIS_MODULE, |
Sebastian Reichel | 2f39b70 | 2014-03-16 02:43:26 +0100 | [diff] [blame] | 887 | .of_match_table = of_match_ptr(twl_madc_of_match), |
Sebastian Reichel | 99be024 | 2014-03-16 02:43:27 +0100 | [diff] [blame] | 888 | }, |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 889 | }; |
| 890 | |
Mark Brown | 65349d6 | 2011-11-23 22:58:34 +0000 | [diff] [blame] | 891 | module_platform_driver(twl4030_madc_driver); |
Keerthy | f99c1d4 | 2011-03-01 19:12:26 +0530 | [diff] [blame] | 892 | |
| 893 | MODULE_DESCRIPTION("TWL4030 ADC driver"); |
| 894 | MODULE_LICENSE("GPL"); |
| 895 | MODULE_AUTHOR("J Keerthy"); |
Axel Lin | 0ea3e83 | 2011-03-07 11:02:29 +0800 | [diff] [blame] | 896 | MODULE_ALIAS("platform:twl4030_madc"); |