1 /* 2 * iio/adc/max1363.c 3 * Copyright (C) 2008-2010 Jonathan Cameron 4 * 5 * based on linux/drivers/i2c/chips/max123x 6 * Copyright (C) 2002-2004 Stefan Eletzhofer 7 * 8 * based on linux/drivers/acron/char/pcf8583.c 9 * Copyright (C) 2000 Russell King 10 * 11 * Driver for max1363 and similar chips. 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License version 2 as 15 * published by the Free Software Foundation. 16 */ 17 18 #include <linux/interrupt.h> 19 #include <linux/device.h> 20 #include <linux/kernel.h> 21 #include <linux/sysfs.h> 22 #include <linux/list.h> 23 #include <linux/i2c.h> 24 #include <linux/regulator/consumer.h> 25 #include <linux/slab.h> 26 #include <linux/err.h> 27 #include <linux/module.h> 28 29 #include <linux/iio/iio.h> 30 #include <linux/iio/sysfs.h> 31 #include <linux/iio/events.h> 32 #include <linux/iio/buffer.h> 33 #include <linux/iio/driver.h> 34 #include <linux/iio/kfifo_buf.h> 35 #include <linux/iio/trigger_consumer.h> 36 #include <linux/iio/triggered_buffer.h> 37 38 #define MAX1363_SETUP_BYTE(a) ((a) | 0x80) 39 40 /* There is a fair bit more defined here than currently 41 * used, but the intention is to support everything these 42 * chips do in the long run */ 43 44 /* see data sheets */ 45 /* max1363 and max1236, max1237, max1238, max1239 */ 46 #define MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD 0x00 47 #define MAX1363_SETUP_AIN3_IS_REF_EXT_TO_REF 0x20 48 #define MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_INT 0x40 49 #define MAX1363_SETUP_AIN3_IS_REF_REF_IS_INT 0x60 50 #define MAX1363_SETUP_POWER_UP_INT_REF 0x10 51 #define MAX1363_SETUP_POWER_DOWN_INT_REF 0x00 52 53 /* think about including max11600 etc - more settings */ 54 #define MAX1363_SETUP_EXT_CLOCK 0x08 55 #define MAX1363_SETUP_INT_CLOCK 0x00 56 #define MAX1363_SETUP_UNIPOLAR 0x00 57 #define MAX1363_SETUP_BIPOLAR 0x04 58 #define MAX1363_SETUP_RESET 0x00 59 #define MAX1363_SETUP_NORESET 0x02 60 /* max1363 only - though don't care on others. 61 * For now monitor modes are not implemented as the relevant 62 * line is not connected on my test board. 63 * The definitions are here as I intend to add this soon. 64 */ 65 #define MAX1363_SETUP_MONITOR_SETUP 0x01 66 67 /* Specific to the max1363 */ 68 #define MAX1363_MON_RESET_CHAN(a) (1 << ((a) + 4)) 69 #define MAX1363_MON_INT_ENABLE 0x01 70 71 /* defined for readability reasons */ 72 /* All chips */ 73 #define MAX1363_CONFIG_BYTE(a) ((a)) 74 75 #define MAX1363_CONFIG_SE 0x01 76 #define MAX1363_CONFIG_DE 0x00 77 #define MAX1363_CONFIG_SCAN_TO_CS 0x00 78 #define MAX1363_CONFIG_SCAN_SINGLE_8 0x20 79 #define MAX1363_CONFIG_SCAN_MONITOR_MODE 0x40 80 #define MAX1363_CONFIG_SCAN_SINGLE_1 0x60 81 /* max123{6-9} only */ 82 #define MAX1236_SCAN_MID_TO_CHANNEL 0x40 83 84 /* max1363 only - merely part of channel selects or don't care for others */ 85 #define MAX1363_CONFIG_EN_MON_MODE_READ 0x18 86 87 #define MAX1363_CHANNEL_SEL(a) ((a) << 1) 88 89 /* max1363 strictly 0x06 - but doesn't matter */ 90 #define MAX1363_CHANNEL_SEL_MASK 0x1E 91 #define MAX1363_SCAN_MASK 0x60 92 #define MAX1363_SE_DE_MASK 0x01 93 94 #define MAX1363_MAX_CHANNELS 25 95 /** 96 * struct max1363_mode - scan mode information 97 * @conf: The corresponding value of the configuration register 98 * @modemask: Bit mask corresponding to channels enabled in this mode 99 */ 100 struct max1363_mode { 101 int8_t conf; 102 DECLARE_BITMAP(modemask, MAX1363_MAX_CHANNELS); 103 }; 104 105 /* This must be maintained along side the max1363_mode_table in max1363_core */ 106 enum max1363_modes { 107 /* Single read of a single channel */ 108 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11, 109 /* Differential single read */ 110 d0m1, d2m3, d4m5, d6m7, d8m9, d10m11, 111 d1m0, d3m2, d5m4, d7m6, d9m8, d11m10, 112 /* Scan to channel and mid to channel where overlapping */ 113 s0to1, s0to2, s2to3, s0to3, s0to4, s0to5, s0to6, 114 s6to7, s0to7, s6to8, s0to8, s6to9, 115 s0to9, s6to10, s0to10, s6to11, s0to11, 116 /* Differential scan to channel and mid to channel where overlapping */ 117 d0m1to2m3, d0m1to4m5, d0m1to6m7, d6m7to8m9, 118 d0m1to8m9, d6m7to10m11, d0m1to10m11, d1m0to3m2, 119 d1m0to5m4, d1m0to7m6, d7m6to9m8, d1m0to9m8, 120 d7m6to11m10, d1m0to11m10, 121 }; 122 123 /** 124 * struct max1363_chip_info - chip specifc information 125 * @info: iio core function callbacks structure 126 * @channels: channel specification 127 * @num_channels: number of channels 128 * @mode_list: array of available scan modes 129 * @default_mode: the scan mode in which the chip starts up 130 * @int_vref_mv: the internal reference voltage 131 * @num_modes: number of modes 132 * @bits: accuracy of the adc in bits 133 */ 134 struct max1363_chip_info { 135 const struct iio_info *info; 136 const struct iio_chan_spec *channels; 137 int num_channels; 138 const enum max1363_modes *mode_list; 139 enum max1363_modes default_mode; 140 u16 int_vref_mv; 141 u8 num_modes; 142 u8 bits; 143 }; 144 145 /** 146 * struct max1363_state - driver instance specific data 147 * @client: i2c_client 148 * @setupbyte: cache of current device setup byte 149 * @configbyte: cache of current device config byte 150 * @chip_info: chip model specific constants, available modes, etc. 151 * @current_mode: the scan mode of this chip 152 * @requestedmask: a valid requested set of channels 153 * @reg: supply regulator 154 * @monitor_on: whether monitor mode is enabled 155 * @monitor_speed: parameter corresponding to device monitor speed setting 156 * @mask_high: bitmask for enabled high thresholds 157 * @mask_low: bitmask for enabled low thresholds 158 * @thresh_high: high threshold values 159 * @thresh_low: low threshold values 160 * @vref: Reference voltage regulator 161 * @vref_uv: Actual (external or internal) reference voltage 162 * @send: function used to send data to the chip 163 * @recv: function used to receive data from the chip 164 */ 165 struct max1363_state { 166 struct i2c_client *client; 167 u8 setupbyte; 168 u8 configbyte; 169 const struct max1363_chip_info *chip_info; 170 const struct max1363_mode *current_mode; 171 u32 requestedmask; 172 struct regulator *reg; 173 174 /* Using monitor modes and buffer at the same time is 175 currently not supported */ 176 bool monitor_on; 177 unsigned int monitor_speed:3; 178 u8 mask_high; 179 u8 mask_low; 180 /* 4x unipolar first then the fours bipolar ones */ 181 s16 thresh_high[8]; 182 s16 thresh_low[8]; 183 struct regulator *vref; 184 u32 vref_uv; 185 int (*send)(const struct i2c_client *client, 186 const char *buf, int count); 187 int (*recv)(const struct i2c_client *client, 188 char *buf, int count); 189 }; 190 191 #define MAX1363_MODE_SINGLE(_num, _mask) { \ 192 .conf = MAX1363_CHANNEL_SEL(_num) \ 193 | MAX1363_CONFIG_SCAN_SINGLE_1 \ 194 | MAX1363_CONFIG_SE, \ 195 .modemask[0] = _mask, \ 196 } 197 198 #define MAX1363_MODE_SCAN_TO_CHANNEL(_num, _mask) { \ 199 .conf = MAX1363_CHANNEL_SEL(_num) \ 200 | MAX1363_CONFIG_SCAN_TO_CS \ 201 | MAX1363_CONFIG_SE, \ 202 .modemask[0] = _mask, \ 203 } 204 205 /* note not available for max1363 hence naming */ 206 #define MAX1236_MODE_SCAN_MID_TO_CHANNEL(_mid, _num, _mask) { \ 207 .conf = MAX1363_CHANNEL_SEL(_num) \ 208 | MAX1236_SCAN_MID_TO_CHANNEL \ 209 | MAX1363_CONFIG_SE, \ 210 .modemask[0] = _mask \ 211 } 212 213 #define MAX1363_MODE_DIFF_SINGLE(_nump, _numm, _mask) { \ 214 .conf = MAX1363_CHANNEL_SEL(_nump) \ 215 | MAX1363_CONFIG_SCAN_SINGLE_1 \ 216 | MAX1363_CONFIG_DE, \ 217 .modemask[0] = _mask \ 218 } 219 220 /* Can't think how to automate naming so specify for now */ 221 #define MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(_num, _numvals, _mask) { \ 222 .conf = MAX1363_CHANNEL_SEL(_num) \ 223 | MAX1363_CONFIG_SCAN_TO_CS \ 224 | MAX1363_CONFIG_DE, \ 225 .modemask[0] = _mask \ 226 } 227 228 /* note only available for max1363 hence naming */ 229 #define MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(_num, _numvals, _mask) { \ 230 .conf = MAX1363_CHANNEL_SEL(_num) \ 231 | MAX1236_SCAN_MID_TO_CHANNEL \ 232 | MAX1363_CONFIG_SE, \ 233 .modemask[0] = _mask \ 234 } 235 236 static const struct max1363_mode max1363_mode_table[] = { 237 /* All of the single channel options first */ 238 MAX1363_MODE_SINGLE(0, 1 << 0), 239 MAX1363_MODE_SINGLE(1, 1 << 1), 240 MAX1363_MODE_SINGLE(2, 1 << 2), 241 MAX1363_MODE_SINGLE(3, 1 << 3), 242 MAX1363_MODE_SINGLE(4, 1 << 4), 243 MAX1363_MODE_SINGLE(5, 1 << 5), 244 MAX1363_MODE_SINGLE(6, 1 << 6), 245 MAX1363_MODE_SINGLE(7, 1 << 7), 246 MAX1363_MODE_SINGLE(8, 1 << 8), 247 MAX1363_MODE_SINGLE(9, 1 << 9), 248 MAX1363_MODE_SINGLE(10, 1 << 10), 249 MAX1363_MODE_SINGLE(11, 1 << 11), 250 251 MAX1363_MODE_DIFF_SINGLE(0, 1, 1 << 12), 252 MAX1363_MODE_DIFF_SINGLE(2, 3, 1 << 13), 253 MAX1363_MODE_DIFF_SINGLE(4, 5, 1 << 14), 254 MAX1363_MODE_DIFF_SINGLE(6, 7, 1 << 15), 255 MAX1363_MODE_DIFF_SINGLE(8, 9, 1 << 16), 256 MAX1363_MODE_DIFF_SINGLE(10, 11, 1 << 17), 257 MAX1363_MODE_DIFF_SINGLE(1, 0, 1 << 18), 258 MAX1363_MODE_DIFF_SINGLE(3, 2, 1 << 19), 259 MAX1363_MODE_DIFF_SINGLE(5, 4, 1 << 20), 260 MAX1363_MODE_DIFF_SINGLE(7, 6, 1 << 21), 261 MAX1363_MODE_DIFF_SINGLE(9, 8, 1 << 22), 262 MAX1363_MODE_DIFF_SINGLE(11, 10, 1 << 23), 263 264 /* The multichannel scans next */ 265 MAX1363_MODE_SCAN_TO_CHANNEL(1, 0x003), 266 MAX1363_MODE_SCAN_TO_CHANNEL(2, 0x007), 267 MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3, 0x00C), 268 MAX1363_MODE_SCAN_TO_CHANNEL(3, 0x00F), 269 MAX1363_MODE_SCAN_TO_CHANNEL(4, 0x01F), 270 MAX1363_MODE_SCAN_TO_CHANNEL(5, 0x03F), 271 MAX1363_MODE_SCAN_TO_CHANNEL(6, 0x07F), 272 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7, 0x0C0), 273 MAX1363_MODE_SCAN_TO_CHANNEL(7, 0x0FF), 274 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8, 0x1C0), 275 MAX1363_MODE_SCAN_TO_CHANNEL(8, 0x1FF), 276 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9, 0x3C0), 277 MAX1363_MODE_SCAN_TO_CHANNEL(9, 0x3FF), 278 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10, 0x7C0), 279 MAX1363_MODE_SCAN_TO_CHANNEL(10, 0x7FF), 280 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11, 0xFC0), 281 MAX1363_MODE_SCAN_TO_CHANNEL(11, 0xFFF), 282 283 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(2, 2, 0x003000), 284 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(4, 3, 0x007000), 285 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(6, 4, 0x00F000), 286 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(8, 2, 0x018000), 287 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(8, 5, 0x01F000), 288 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(10, 3, 0x038000), 289 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(10, 6, 0x3F000), 290 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(3, 2, 0x0C0000), 291 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(5, 3, 0x1C0000), 292 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(7, 4, 0x3C0000), 293 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(9, 2, 0x600000), 294 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(9, 5, 0x7C0000), 295 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(11, 3, 0xE00000), 296 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(11, 6, 0xFC0000), 297 }; 298 299 static const struct max1363_mode 300 *max1363_match_mode(const unsigned long *mask, 301 const struct max1363_chip_info *ci) 302 { 303 int i; 304 if (mask) 305 for (i = 0; i < ci->num_modes; i++) 306 if (bitmap_subset(mask, 307 max1363_mode_table[ci->mode_list[i]]. 308 modemask, 309 MAX1363_MAX_CHANNELS)) 310 return &max1363_mode_table[ci->mode_list[i]]; 311 return NULL; 312 } 313 314 static int max1363_smbus_send(const struct i2c_client *client, const char *buf, 315 int count) 316 { 317 int i, err; 318 319 for (i = err = 0; err == 0 && i < count; ++i) 320 err = i2c_smbus_write_byte(client, buf[i]); 321 322 return err ? err : count; 323 } 324 325 static int max1363_smbus_recv(const struct i2c_client *client, char *buf, 326 int count) 327 { 328 int i, ret; 329 330 for (i = 0; i < count; ++i) { 331 ret = i2c_smbus_read_byte(client); 332 if (ret < 0) 333 return ret; 334 buf[i] = ret; 335 } 336 337 return count; 338 } 339 340 static int max1363_write_basic_config(struct max1363_state *st) 341 { 342 u8 tx_buf[2] = { st->setupbyte, st->configbyte }; 343 344 return st->send(st->client, tx_buf, 2); 345 } 346 347 static int max1363_set_scan_mode(struct max1363_state *st) 348 { 349 st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK 350 | MAX1363_SCAN_MASK 351 | MAX1363_SE_DE_MASK); 352 st->configbyte |= st->current_mode->conf; 353 354 return max1363_write_basic_config(st); 355 } 356 357 static int max1363_read_single_chan(struct iio_dev *indio_dev, 358 struct iio_chan_spec const *chan, 359 int *val, 360 long m) 361 { 362 int ret = 0; 363 s32 data; 364 u8 rxbuf[2]; 365 struct max1363_state *st = iio_priv(indio_dev); 366 struct i2c_client *client = st->client; 367 368 mutex_lock(&indio_dev->mlock); 369 /* 370 * If monitor mode is enabled, the method for reading a single 371 * channel will have to be rather different and has not yet 372 * been implemented. 373 * 374 * Also, cannot read directly if buffered capture enabled. 375 */ 376 if (st->monitor_on || iio_buffer_enabled(indio_dev)) { 377 ret = -EBUSY; 378 goto error_ret; 379 } 380 381 /* Check to see if current scan mode is correct */ 382 if (st->current_mode != &max1363_mode_table[chan->address]) { 383 /* Update scan mode if needed */ 384 st->current_mode = &max1363_mode_table[chan->address]; 385 ret = max1363_set_scan_mode(st); 386 if (ret < 0) 387 goto error_ret; 388 } 389 if (st->chip_info->bits != 8) { 390 /* Get reading */ 391 data = st->recv(client, rxbuf, 2); 392 if (data < 0) { 393 ret = data; 394 goto error_ret; 395 } 396 data = (rxbuf[1] | rxbuf[0] << 8) & 397 ((1 << st->chip_info->bits) - 1); 398 } else { 399 /* Get reading */ 400 data = st->recv(client, rxbuf, 1); 401 if (data < 0) { 402 ret = data; 403 goto error_ret; 404 } 405 data = rxbuf[0]; 406 } 407 *val = data; 408 error_ret: 409 mutex_unlock(&indio_dev->mlock); 410 return ret; 411 412 } 413 414 static int max1363_read_raw(struct iio_dev *indio_dev, 415 struct iio_chan_spec const *chan, 416 int *val, 417 int *val2, 418 long m) 419 { 420 struct max1363_state *st = iio_priv(indio_dev); 421 int ret; 422 423 switch (m) { 424 case IIO_CHAN_INFO_RAW: 425 ret = max1363_read_single_chan(indio_dev, chan, val, m); 426 if (ret < 0) 427 return ret; 428 return IIO_VAL_INT; 429 case IIO_CHAN_INFO_SCALE: 430 *val = st->vref_uv / 1000; 431 *val2 = st->chip_info->bits; 432 return IIO_VAL_FRACTIONAL_LOG2; 433 default: 434 return -EINVAL; 435 } 436 return 0; 437 } 438 439 /* Applies to max1363 */ 440 static const enum max1363_modes max1363_mode_list[] = { 441 _s0, _s1, _s2, _s3, 442 s0to1, s0to2, s0to3, 443 d0m1, d2m3, d1m0, d3m2, 444 d0m1to2m3, d1m0to3m2, 445 }; 446 447 static const struct iio_event_spec max1363_events[] = { 448 { 449 .type = IIO_EV_TYPE_THRESH, 450 .dir = IIO_EV_DIR_RISING, 451 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 452 BIT(IIO_EV_INFO_ENABLE), 453 }, { 454 .type = IIO_EV_TYPE_THRESH, 455 .dir = IIO_EV_DIR_FALLING, 456 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 457 BIT(IIO_EV_INFO_ENABLE), 458 }, 459 }; 460 461 #define MAX1363_CHAN_U(num, addr, si, bits, ev_spec, num_ev_spec) \ 462 { \ 463 .type = IIO_VOLTAGE, \ 464 .indexed = 1, \ 465 .channel = num, \ 466 .address = addr, \ 467 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 468 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 469 .datasheet_name = "AIN"#num, \ 470 .scan_type = { \ 471 .sign = 'u', \ 472 .realbits = bits, \ 473 .storagebits = (bits > 8) ? 16 : 8, \ 474 .endianness = IIO_BE, \ 475 }, \ 476 .scan_index = si, \ 477 .event_spec = ev_spec, \ 478 .num_event_specs = num_ev_spec, \ 479 } 480 481 /* bipolar channel */ 482 #define MAX1363_CHAN_B(num, num2, addr, si, bits, ev_spec, num_ev_spec) \ 483 { \ 484 .type = IIO_VOLTAGE, \ 485 .differential = 1, \ 486 .indexed = 1, \ 487 .channel = num, \ 488 .channel2 = num2, \ 489 .address = addr, \ 490 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 491 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 492 .datasheet_name = "AIN"#num"-AIN"#num2, \ 493 .scan_type = { \ 494 .sign = 's', \ 495 .realbits = bits, \ 496 .storagebits = (bits > 8) ? 16 : 8, \ 497 .endianness = IIO_BE, \ 498 }, \ 499 .scan_index = si, \ 500 .event_spec = ev_spec, \ 501 .num_event_specs = num_ev_spec, \ 502 } 503 504 #define MAX1363_4X_CHANS(bits, ev_spec, num_ev_spec) { \ 505 MAX1363_CHAN_U(0, _s0, 0, bits, ev_spec, num_ev_spec), \ 506 MAX1363_CHAN_U(1, _s1, 1, bits, ev_spec, num_ev_spec), \ 507 MAX1363_CHAN_U(2, _s2, 2, bits, ev_spec, num_ev_spec), \ 508 MAX1363_CHAN_U(3, _s3, 3, bits, ev_spec, num_ev_spec), \ 509 MAX1363_CHAN_B(0, 1, d0m1, 4, bits, ev_spec, num_ev_spec), \ 510 MAX1363_CHAN_B(2, 3, d2m3, 5, bits, ev_spec, num_ev_spec), \ 511 MAX1363_CHAN_B(1, 0, d1m0, 6, bits, ev_spec, num_ev_spec), \ 512 MAX1363_CHAN_B(3, 2, d3m2, 7, bits, ev_spec, num_ev_spec), \ 513 IIO_CHAN_SOFT_TIMESTAMP(8) \ 514 } 515 516 static const struct iio_chan_spec max1036_channels[] = 517 MAX1363_4X_CHANS(8, NULL, 0); 518 static const struct iio_chan_spec max1136_channels[] = 519 MAX1363_4X_CHANS(10, NULL, 0); 520 static const struct iio_chan_spec max1236_channels[] = 521 MAX1363_4X_CHANS(12, NULL, 0); 522 static const struct iio_chan_spec max1361_channels[] = 523 MAX1363_4X_CHANS(10, max1363_events, ARRAY_SIZE(max1363_events)); 524 static const struct iio_chan_spec max1363_channels[] = 525 MAX1363_4X_CHANS(12, max1363_events, ARRAY_SIZE(max1363_events)); 526 527 /* Applies to max1236, max1237 */ 528 static const enum max1363_modes max1236_mode_list[] = { 529 _s0, _s1, _s2, _s3, 530 s0to1, s0to2, s0to3, 531 d0m1, d2m3, d1m0, d3m2, 532 d0m1to2m3, d1m0to3m2, 533 s2to3, 534 }; 535 536 /* Applies to max1238, max1239 */ 537 static const enum max1363_modes max1238_mode_list[] = { 538 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11, 539 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, 540 s0to7, s0to8, s0to9, s0to10, s0to11, 541 d0m1, d2m3, d4m5, d6m7, d8m9, d10m11, 542 d1m0, d3m2, d5m4, d7m6, d9m8, d11m10, 543 d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11, 544 d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10, 545 s6to7, s6to8, s6to9, s6to10, s6to11, 546 d6m7to8m9, d6m7to10m11, d7m6to9m8, d7m6to11m10, 547 }; 548 549 #define MAX1363_12X_CHANS(bits) { \ 550 MAX1363_CHAN_U(0, _s0, 0, bits, NULL, 0), \ 551 MAX1363_CHAN_U(1, _s1, 1, bits, NULL, 0), \ 552 MAX1363_CHAN_U(2, _s2, 2, bits, NULL, 0), \ 553 MAX1363_CHAN_U(3, _s3, 3, bits, NULL, 0), \ 554 MAX1363_CHAN_U(4, _s4, 4, bits, NULL, 0), \ 555 MAX1363_CHAN_U(5, _s5, 5, bits, NULL, 0), \ 556 MAX1363_CHAN_U(6, _s6, 6, bits, NULL, 0), \ 557 MAX1363_CHAN_U(7, _s7, 7, bits, NULL, 0), \ 558 MAX1363_CHAN_U(8, _s8, 8, bits, NULL, 0), \ 559 MAX1363_CHAN_U(9, _s9, 9, bits, NULL, 0), \ 560 MAX1363_CHAN_U(10, _s10, 10, bits, NULL, 0), \ 561 MAX1363_CHAN_U(11, _s11, 11, bits, NULL, 0), \ 562 MAX1363_CHAN_B(0, 1, d0m1, 12, bits, NULL, 0), \ 563 MAX1363_CHAN_B(2, 3, d2m3, 13, bits, NULL, 0), \ 564 MAX1363_CHAN_B(4, 5, d4m5, 14, bits, NULL, 0), \ 565 MAX1363_CHAN_B(6, 7, d6m7, 15, bits, NULL, 0), \ 566 MAX1363_CHAN_B(8, 9, d8m9, 16, bits, NULL, 0), \ 567 MAX1363_CHAN_B(10, 11, d10m11, 17, bits, NULL, 0), \ 568 MAX1363_CHAN_B(1, 0, d1m0, 18, bits, NULL, 0), \ 569 MAX1363_CHAN_B(3, 2, d3m2, 19, bits, NULL, 0), \ 570 MAX1363_CHAN_B(5, 4, d5m4, 20, bits, NULL, 0), \ 571 MAX1363_CHAN_B(7, 6, d7m6, 21, bits, NULL, 0), \ 572 MAX1363_CHAN_B(9, 8, d9m8, 22, bits, NULL, 0), \ 573 MAX1363_CHAN_B(11, 10, d11m10, 23, bits, NULL, 0), \ 574 IIO_CHAN_SOFT_TIMESTAMP(24) \ 575 } 576 static const struct iio_chan_spec max1038_channels[] = MAX1363_12X_CHANS(8); 577 static const struct iio_chan_spec max1138_channels[] = MAX1363_12X_CHANS(10); 578 static const struct iio_chan_spec max1238_channels[] = MAX1363_12X_CHANS(12); 579 580 static const enum max1363_modes max11607_mode_list[] = { 581 _s0, _s1, _s2, _s3, 582 s0to1, s0to2, s0to3, 583 s2to3, 584 d0m1, d2m3, d1m0, d3m2, 585 d0m1to2m3, d1m0to3m2, 586 }; 587 588 static const enum max1363_modes max11608_mode_list[] = { 589 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, 590 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s0to7, 591 s6to7, 592 d0m1, d2m3, d4m5, d6m7, 593 d1m0, d3m2, d5m4, d7m6, 594 d0m1to2m3, d0m1to4m5, d0m1to6m7, 595 d1m0to3m2, d1m0to5m4, d1m0to7m6, 596 }; 597 598 #define MAX1363_8X_CHANS(bits) { \ 599 MAX1363_CHAN_U(0, _s0, 0, bits, NULL, 0), \ 600 MAX1363_CHAN_U(1, _s1, 1, bits, NULL, 0), \ 601 MAX1363_CHAN_U(2, _s2, 2, bits, NULL, 0), \ 602 MAX1363_CHAN_U(3, _s3, 3, bits, NULL, 0), \ 603 MAX1363_CHAN_U(4, _s4, 4, bits, NULL, 0), \ 604 MAX1363_CHAN_U(5, _s5, 5, bits, NULL, 0), \ 605 MAX1363_CHAN_U(6, _s6, 6, bits, NULL, 0), \ 606 MAX1363_CHAN_U(7, _s7, 7, bits, NULL, 0), \ 607 MAX1363_CHAN_B(0, 1, d0m1, 8, bits, NULL, 0), \ 608 MAX1363_CHAN_B(2, 3, d2m3, 9, bits, NULL, 0), \ 609 MAX1363_CHAN_B(4, 5, d4m5, 10, bits, NULL, 0), \ 610 MAX1363_CHAN_B(6, 7, d6m7, 11, bits, NULL, 0), \ 611 MAX1363_CHAN_B(1, 0, d1m0, 12, bits, NULL, 0), \ 612 MAX1363_CHAN_B(3, 2, d3m2, 13, bits, NULL, 0), \ 613 MAX1363_CHAN_B(5, 4, d5m4, 14, bits, NULL, 0), \ 614 MAX1363_CHAN_B(7, 6, d7m6, 15, bits, NULL, 0), \ 615 IIO_CHAN_SOFT_TIMESTAMP(16) \ 616 } 617 static const struct iio_chan_spec max11602_channels[] = MAX1363_8X_CHANS(8); 618 static const struct iio_chan_spec max11608_channels[] = MAX1363_8X_CHANS(10); 619 static const struct iio_chan_spec max11614_channels[] = MAX1363_8X_CHANS(12); 620 621 static const enum max1363_modes max11644_mode_list[] = { 622 _s0, _s1, s0to1, d0m1, d1m0, 623 }; 624 625 #define MAX1363_2X_CHANS(bits) { \ 626 MAX1363_CHAN_U(0, _s0, 0, bits, NULL, 0), \ 627 MAX1363_CHAN_U(1, _s1, 1, bits, NULL, 0), \ 628 MAX1363_CHAN_B(0, 1, d0m1, 2, bits, NULL, 0), \ 629 MAX1363_CHAN_B(1, 0, d1m0, 3, bits, NULL, 0), \ 630 IIO_CHAN_SOFT_TIMESTAMP(4) \ 631 } 632 633 static const struct iio_chan_spec max11646_channels[] = MAX1363_2X_CHANS(10); 634 static const struct iio_chan_spec max11644_channels[] = MAX1363_2X_CHANS(12); 635 636 enum { max1361, 637 max1362, 638 max1363, 639 max1364, 640 max1036, 641 max1037, 642 max1038, 643 max1039, 644 max1136, 645 max1137, 646 max1138, 647 max1139, 648 max1236, 649 max1237, 650 max1238, 651 max1239, 652 max11600, 653 max11601, 654 max11602, 655 max11603, 656 max11604, 657 max11605, 658 max11606, 659 max11607, 660 max11608, 661 max11609, 662 max11610, 663 max11611, 664 max11612, 665 max11613, 666 max11614, 667 max11615, 668 max11616, 669 max11617, 670 max11644, 671 max11645, 672 max11646, 673 max11647 674 }; 675 676 static const int max1363_monitor_speeds[] = { 133000, 665000, 33300, 16600, 677 8300, 4200, 2000, 1000 }; 678 679 static ssize_t max1363_monitor_show_freq(struct device *dev, 680 struct device_attribute *attr, 681 char *buf) 682 { 683 struct max1363_state *st = iio_priv(dev_to_iio_dev(dev)); 684 return sprintf(buf, "%d\n", max1363_monitor_speeds[st->monitor_speed]); 685 } 686 687 static ssize_t max1363_monitor_store_freq(struct device *dev, 688 struct device_attribute *attr, 689 const char *buf, 690 size_t len) 691 { 692 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 693 struct max1363_state *st = iio_priv(indio_dev); 694 int i, ret; 695 unsigned long val; 696 bool found = false; 697 698 ret = kstrtoul(buf, 10, &val); 699 if (ret) 700 return -EINVAL; 701 for (i = 0; i < ARRAY_SIZE(max1363_monitor_speeds); i++) 702 if (val == max1363_monitor_speeds[i]) { 703 found = true; 704 break; 705 } 706 if (!found) 707 return -EINVAL; 708 709 mutex_lock(&indio_dev->mlock); 710 st->monitor_speed = i; 711 mutex_unlock(&indio_dev->mlock); 712 713 return 0; 714 } 715 716 static IIO_DEV_ATTR_SAMP_FREQ(S_IRUGO | S_IWUSR, 717 max1363_monitor_show_freq, 718 max1363_monitor_store_freq); 719 720 static IIO_CONST_ATTR(sampling_frequency_available, 721 "133000 665000 33300 16600 8300 4200 2000 1000"); 722 723 static int max1363_read_thresh(struct iio_dev *indio_dev, 724 const struct iio_chan_spec *chan, enum iio_event_type type, 725 enum iio_event_direction dir, enum iio_event_info info, int *val, 726 int *val2) 727 { 728 struct max1363_state *st = iio_priv(indio_dev); 729 if (dir == IIO_EV_DIR_FALLING) 730 *val = st->thresh_low[chan->channel]; 731 else 732 *val = st->thresh_high[chan->channel]; 733 return IIO_VAL_INT; 734 } 735 736 static int max1363_write_thresh(struct iio_dev *indio_dev, 737 const struct iio_chan_spec *chan, enum iio_event_type type, 738 enum iio_event_direction dir, enum iio_event_info info, int val, 739 int val2) 740 { 741 struct max1363_state *st = iio_priv(indio_dev); 742 /* make it handle signed correctly as well */ 743 switch (st->chip_info->bits) { 744 case 10: 745 if (val > 0x3FF) 746 return -EINVAL; 747 break; 748 case 12: 749 if (val > 0xFFF) 750 return -EINVAL; 751 break; 752 } 753 754 switch (dir) { 755 case IIO_EV_DIR_FALLING: 756 st->thresh_low[chan->channel] = val; 757 break; 758 case IIO_EV_DIR_RISING: 759 st->thresh_high[chan->channel] = val; 760 break; 761 default: 762 return -EINVAL; 763 } 764 765 return 0; 766 } 767 768 static const u64 max1363_event_codes[] = { 769 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 0, 770 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING), 771 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1, 772 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING), 773 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2, 774 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING), 775 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3, 776 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING), 777 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 0, 778 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 779 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1, 780 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 781 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2, 782 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 783 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3, 784 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 785 }; 786 787 static irqreturn_t max1363_event_handler(int irq, void *private) 788 { 789 struct iio_dev *indio_dev = private; 790 struct max1363_state *st = iio_priv(indio_dev); 791 s64 timestamp = iio_get_time_ns(); 792 unsigned long mask, loc; 793 u8 rx; 794 u8 tx[2] = { st->setupbyte, 795 MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0 }; 796 797 st->recv(st->client, &rx, 1); 798 mask = rx; 799 for_each_set_bit(loc, &mask, 8) 800 iio_push_event(indio_dev, max1363_event_codes[loc], timestamp); 801 st->send(st->client, tx, 2); 802 803 return IRQ_HANDLED; 804 } 805 806 static int max1363_read_event_config(struct iio_dev *indio_dev, 807 const struct iio_chan_spec *chan, enum iio_event_type type, 808 enum iio_event_direction dir) 809 { 810 struct max1363_state *st = iio_priv(indio_dev); 811 int val; 812 int number = chan->channel; 813 814 mutex_lock(&indio_dev->mlock); 815 if (dir == IIO_EV_DIR_FALLING) 816 val = (1 << number) & st->mask_low; 817 else 818 val = (1 << number) & st->mask_high; 819 mutex_unlock(&indio_dev->mlock); 820 821 return val; 822 } 823 824 static int max1363_monitor_mode_update(struct max1363_state *st, int enabled) 825 { 826 u8 *tx_buf; 827 int ret, i = 3, j; 828 unsigned long numelements; 829 int len; 830 const long *modemask; 831 832 if (!enabled) { 833 /* transition to buffered capture is not currently supported */ 834 st->setupbyte &= ~MAX1363_SETUP_MONITOR_SETUP; 835 st->configbyte &= ~MAX1363_SCAN_MASK; 836 st->monitor_on = false; 837 return max1363_write_basic_config(st); 838 } 839 840 /* Ensure we are in the relevant mode */ 841 st->setupbyte |= MAX1363_SETUP_MONITOR_SETUP; 842 st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK 843 | MAX1363_SCAN_MASK 844 | MAX1363_SE_DE_MASK); 845 st->configbyte |= MAX1363_CONFIG_SCAN_MONITOR_MODE; 846 if ((st->mask_low | st->mask_high) & 0x0F) { 847 st->configbyte |= max1363_mode_table[s0to3].conf; 848 modemask = max1363_mode_table[s0to3].modemask; 849 } else if ((st->mask_low | st->mask_high) & 0x30) { 850 st->configbyte |= max1363_mode_table[d0m1to2m3].conf; 851 modemask = max1363_mode_table[d0m1to2m3].modemask; 852 } else { 853 st->configbyte |= max1363_mode_table[d1m0to3m2].conf; 854 modemask = max1363_mode_table[d1m0to3m2].modemask; 855 } 856 numelements = bitmap_weight(modemask, MAX1363_MAX_CHANNELS); 857 len = 3 * numelements + 3; 858 tx_buf = kmalloc(len, GFP_KERNEL); 859 if (!tx_buf) { 860 ret = -ENOMEM; 861 goto error_ret; 862 } 863 tx_buf[0] = st->configbyte; 864 tx_buf[1] = st->setupbyte; 865 tx_buf[2] = (st->monitor_speed << 1); 866 867 /* 868 * So we need to do yet another bit of nefarious scan mode 869 * setup to match what we need. 870 */ 871 for (j = 0; j < 8; j++) 872 if (test_bit(j, modemask)) { 873 /* Establish the mode is in the scan */ 874 if (st->mask_low & (1 << j)) { 875 tx_buf[i] = (st->thresh_low[j] >> 4) & 0xFF; 876 tx_buf[i + 1] = (st->thresh_low[j] << 4) & 0xF0; 877 } else if (j < 4) { 878 tx_buf[i] = 0; 879 tx_buf[i + 1] = 0; 880 } else { 881 tx_buf[i] = 0x80; 882 tx_buf[i + 1] = 0; 883 } 884 if (st->mask_high & (1 << j)) { 885 tx_buf[i + 1] |= 886 (st->thresh_high[j] >> 8) & 0x0F; 887 tx_buf[i + 2] = st->thresh_high[j] & 0xFF; 888 } else if (j < 4) { 889 tx_buf[i + 1] |= 0x0F; 890 tx_buf[i + 2] = 0xFF; 891 } else { 892 tx_buf[i + 1] |= 0x07; 893 tx_buf[i + 2] = 0xFF; 894 } 895 i += 3; 896 } 897 898 899 ret = st->send(st->client, tx_buf, len); 900 if (ret < 0) 901 goto error_ret; 902 if (ret != len) { 903 ret = -EIO; 904 goto error_ret; 905 } 906 907 /* 908 * Now that we hopefully have sensible thresholds in place it is 909 * time to turn the interrupts on. 910 * It is unclear from the data sheet if this should be necessary 911 * (i.e. whether monitor mode setup is atomic) but it appears to 912 * be in practice. 913 */ 914 tx_buf[0] = st->setupbyte; 915 tx_buf[1] = MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0; 916 ret = st->send(st->client, tx_buf, 2); 917 if (ret < 0) 918 goto error_ret; 919 if (ret != 2) { 920 ret = -EIO; 921 goto error_ret; 922 } 923 ret = 0; 924 st->monitor_on = true; 925 error_ret: 926 927 kfree(tx_buf); 928 929 return ret; 930 } 931 932 /* 933 * To keep this manageable we always use one of 3 scan modes. 934 * Scan 0...3, 0-1,2-3 and 1-0,3-2 935 */ 936 937 static inline int __max1363_check_event_mask(int thismask, int checkmask) 938 { 939 int ret = 0; 940 /* Is it unipolar */ 941 if (thismask < 4) { 942 if (checkmask & ~0x0F) { 943 ret = -EBUSY; 944 goto error_ret; 945 } 946 } else if (thismask < 6) { 947 if (checkmask & ~0x30) { 948 ret = -EBUSY; 949 goto error_ret; 950 } 951 } else if (checkmask & ~0xC0) 952 ret = -EBUSY; 953 error_ret: 954 return ret; 955 } 956 957 static int max1363_write_event_config(struct iio_dev *indio_dev, 958 const struct iio_chan_spec *chan, enum iio_event_type type, 959 enum iio_event_direction dir, int state) 960 { 961 int ret = 0; 962 struct max1363_state *st = iio_priv(indio_dev); 963 u16 unifiedmask; 964 int number = chan->channel; 965 966 mutex_lock(&indio_dev->mlock); 967 unifiedmask = st->mask_low | st->mask_high; 968 if (dir == IIO_EV_DIR_FALLING) { 969 970 if (state == 0) 971 st->mask_low &= ~(1 << number); 972 else { 973 ret = __max1363_check_event_mask((1 << number), 974 unifiedmask); 975 if (ret) 976 goto error_ret; 977 st->mask_low |= (1 << number); 978 } 979 } else { 980 if (state == 0) 981 st->mask_high &= ~(1 << number); 982 else { 983 ret = __max1363_check_event_mask((1 << number), 984 unifiedmask); 985 if (ret) 986 goto error_ret; 987 st->mask_high |= (1 << number); 988 } 989 } 990 991 max1363_monitor_mode_update(st, !!(st->mask_high | st->mask_low)); 992 error_ret: 993 mutex_unlock(&indio_dev->mlock); 994 995 return ret; 996 } 997 998 /* 999 * As with scan_elements, only certain sets of these can 1000 * be combined. 1001 */ 1002 static struct attribute *max1363_event_attributes[] = { 1003 &iio_dev_attr_sampling_frequency.dev_attr.attr, 1004 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 1005 NULL, 1006 }; 1007 1008 static struct attribute_group max1363_event_attribute_group = { 1009 .attrs = max1363_event_attributes, 1010 .name = "events", 1011 }; 1012 1013 static int max1363_update_scan_mode(struct iio_dev *indio_dev, 1014 const unsigned long *scan_mask) 1015 { 1016 struct max1363_state *st = iio_priv(indio_dev); 1017 1018 /* 1019 * Need to figure out the current mode based upon the requested 1020 * scan mask in iio_dev 1021 */ 1022 st->current_mode = max1363_match_mode(scan_mask, st->chip_info); 1023 if (!st->current_mode) 1024 return -EINVAL; 1025 max1363_set_scan_mode(st); 1026 return 0; 1027 } 1028 1029 static const struct iio_info max1238_info = { 1030 .read_raw = &max1363_read_raw, 1031 .driver_module = THIS_MODULE, 1032 .update_scan_mode = &max1363_update_scan_mode, 1033 }; 1034 1035 static const struct iio_info max1363_info = { 1036 .read_event_value = &max1363_read_thresh, 1037 .write_event_value = &max1363_write_thresh, 1038 .read_event_config = &max1363_read_event_config, 1039 .write_event_config = &max1363_write_event_config, 1040 .read_raw = &max1363_read_raw, 1041 .update_scan_mode = &max1363_update_scan_mode, 1042 .driver_module = THIS_MODULE, 1043 .event_attrs = &max1363_event_attribute_group, 1044 }; 1045 1046 /* max1363 and max1368 tested - rest from data sheet */ 1047 static const struct max1363_chip_info max1363_chip_info_tbl[] = { 1048 [max1361] = { 1049 .bits = 10, 1050 .int_vref_mv = 2048, 1051 .mode_list = max1363_mode_list, 1052 .num_modes = ARRAY_SIZE(max1363_mode_list), 1053 .default_mode = s0to3, 1054 .channels = max1361_channels, 1055 .num_channels = ARRAY_SIZE(max1361_channels), 1056 .info = &max1363_info, 1057 }, 1058 [max1362] = { 1059 .bits = 10, 1060 .int_vref_mv = 4096, 1061 .mode_list = max1363_mode_list, 1062 .num_modes = ARRAY_SIZE(max1363_mode_list), 1063 .default_mode = s0to3, 1064 .channels = max1361_channels, 1065 .num_channels = ARRAY_SIZE(max1361_channels), 1066 .info = &max1363_info, 1067 }, 1068 [max1363] = { 1069 .bits = 12, 1070 .int_vref_mv = 2048, 1071 .mode_list = max1363_mode_list, 1072 .num_modes = ARRAY_SIZE(max1363_mode_list), 1073 .default_mode = s0to3, 1074 .channels = max1363_channels, 1075 .num_channels = ARRAY_SIZE(max1363_channels), 1076 .info = &max1363_info, 1077 }, 1078 [max1364] = { 1079 .bits = 12, 1080 .int_vref_mv = 4096, 1081 .mode_list = max1363_mode_list, 1082 .num_modes = ARRAY_SIZE(max1363_mode_list), 1083 .default_mode = s0to3, 1084 .channels = max1363_channels, 1085 .num_channels = ARRAY_SIZE(max1363_channels), 1086 .info = &max1363_info, 1087 }, 1088 [max1036] = { 1089 .bits = 8, 1090 .int_vref_mv = 4096, 1091 .mode_list = max1236_mode_list, 1092 .num_modes = ARRAY_SIZE(max1236_mode_list), 1093 .default_mode = s0to3, 1094 .info = &max1238_info, 1095 .channels = max1036_channels, 1096 .num_channels = ARRAY_SIZE(max1036_channels), 1097 }, 1098 [max1037] = { 1099 .bits = 8, 1100 .int_vref_mv = 2048, 1101 .mode_list = max1236_mode_list, 1102 .num_modes = ARRAY_SIZE(max1236_mode_list), 1103 .default_mode = s0to3, 1104 .info = &max1238_info, 1105 .channels = max1036_channels, 1106 .num_channels = ARRAY_SIZE(max1036_channels), 1107 }, 1108 [max1038] = { 1109 .bits = 8, 1110 .int_vref_mv = 4096, 1111 .mode_list = max1238_mode_list, 1112 .num_modes = ARRAY_SIZE(max1238_mode_list), 1113 .default_mode = s0to11, 1114 .info = &max1238_info, 1115 .channels = max1038_channels, 1116 .num_channels = ARRAY_SIZE(max1038_channels), 1117 }, 1118 [max1039] = { 1119 .bits = 8, 1120 .int_vref_mv = 2048, 1121 .mode_list = max1238_mode_list, 1122 .num_modes = ARRAY_SIZE(max1238_mode_list), 1123 .default_mode = s0to11, 1124 .info = &max1238_info, 1125 .channels = max1038_channels, 1126 .num_channels = ARRAY_SIZE(max1038_channels), 1127 }, 1128 [max1136] = { 1129 .bits = 10, 1130 .int_vref_mv = 4096, 1131 .mode_list = max1236_mode_list, 1132 .num_modes = ARRAY_SIZE(max1236_mode_list), 1133 .default_mode = s0to3, 1134 .info = &max1238_info, 1135 .channels = max1136_channels, 1136 .num_channels = ARRAY_SIZE(max1136_channels), 1137 }, 1138 [max1137] = { 1139 .bits = 10, 1140 .int_vref_mv = 2048, 1141 .mode_list = max1236_mode_list, 1142 .num_modes = ARRAY_SIZE(max1236_mode_list), 1143 .default_mode = s0to3, 1144 .info = &max1238_info, 1145 .channels = max1136_channels, 1146 .num_channels = ARRAY_SIZE(max1136_channels), 1147 }, 1148 [max1138] = { 1149 .bits = 10, 1150 .int_vref_mv = 4096, 1151 .mode_list = max1238_mode_list, 1152 .num_modes = ARRAY_SIZE(max1238_mode_list), 1153 .default_mode = s0to11, 1154 .info = &max1238_info, 1155 .channels = max1138_channels, 1156 .num_channels = ARRAY_SIZE(max1138_channels), 1157 }, 1158 [max1139] = { 1159 .bits = 10, 1160 .int_vref_mv = 2048, 1161 .mode_list = max1238_mode_list, 1162 .num_modes = ARRAY_SIZE(max1238_mode_list), 1163 .default_mode = s0to11, 1164 .info = &max1238_info, 1165 .channels = max1138_channels, 1166 .num_channels = ARRAY_SIZE(max1138_channels), 1167 }, 1168 [max1236] = { 1169 .bits = 12, 1170 .int_vref_mv = 4096, 1171 .mode_list = max1236_mode_list, 1172 .num_modes = ARRAY_SIZE(max1236_mode_list), 1173 .default_mode = s0to3, 1174 .info = &max1238_info, 1175 .channels = max1236_channels, 1176 .num_channels = ARRAY_SIZE(max1236_channels), 1177 }, 1178 [max1237] = { 1179 .bits = 12, 1180 .int_vref_mv = 2048, 1181 .mode_list = max1236_mode_list, 1182 .num_modes = ARRAY_SIZE(max1236_mode_list), 1183 .default_mode = s0to3, 1184 .info = &max1238_info, 1185 .channels = max1236_channels, 1186 .num_channels = ARRAY_SIZE(max1236_channels), 1187 }, 1188 [max1238] = { 1189 .bits = 12, 1190 .int_vref_mv = 4096, 1191 .mode_list = max1238_mode_list, 1192 .num_modes = ARRAY_SIZE(max1238_mode_list), 1193 .default_mode = s0to11, 1194 .info = &max1238_info, 1195 .channels = max1238_channels, 1196 .num_channels = ARRAY_SIZE(max1238_channels), 1197 }, 1198 [max1239] = { 1199 .bits = 12, 1200 .int_vref_mv = 2048, 1201 .mode_list = max1238_mode_list, 1202 .num_modes = ARRAY_SIZE(max1238_mode_list), 1203 .default_mode = s0to11, 1204 .info = &max1238_info, 1205 .channels = max1238_channels, 1206 .num_channels = ARRAY_SIZE(max1238_channels), 1207 }, 1208 [max11600] = { 1209 .bits = 8, 1210 .int_vref_mv = 4096, 1211 .mode_list = max11607_mode_list, 1212 .num_modes = ARRAY_SIZE(max11607_mode_list), 1213 .default_mode = s0to3, 1214 .info = &max1238_info, 1215 .channels = max1036_channels, 1216 .num_channels = ARRAY_SIZE(max1036_channels), 1217 }, 1218 [max11601] = { 1219 .bits = 8, 1220 .int_vref_mv = 2048, 1221 .mode_list = max11607_mode_list, 1222 .num_modes = ARRAY_SIZE(max11607_mode_list), 1223 .default_mode = s0to3, 1224 .info = &max1238_info, 1225 .channels = max1036_channels, 1226 .num_channels = ARRAY_SIZE(max1036_channels), 1227 }, 1228 [max11602] = { 1229 .bits = 8, 1230 .int_vref_mv = 4096, 1231 .mode_list = max11608_mode_list, 1232 .num_modes = ARRAY_SIZE(max11608_mode_list), 1233 .default_mode = s0to7, 1234 .info = &max1238_info, 1235 .channels = max11602_channels, 1236 .num_channels = ARRAY_SIZE(max11602_channels), 1237 }, 1238 [max11603] = { 1239 .bits = 8, 1240 .int_vref_mv = 2048, 1241 .mode_list = max11608_mode_list, 1242 .num_modes = ARRAY_SIZE(max11608_mode_list), 1243 .default_mode = s0to7, 1244 .info = &max1238_info, 1245 .channels = max11602_channels, 1246 .num_channels = ARRAY_SIZE(max11602_channels), 1247 }, 1248 [max11604] = { 1249 .bits = 8, 1250 .int_vref_mv = 4096, 1251 .mode_list = max1238_mode_list, 1252 .num_modes = ARRAY_SIZE(max1238_mode_list), 1253 .default_mode = s0to11, 1254 .info = &max1238_info, 1255 .channels = max1038_channels, 1256 .num_channels = ARRAY_SIZE(max1038_channels), 1257 }, 1258 [max11605] = { 1259 .bits = 8, 1260 .int_vref_mv = 2048, 1261 .mode_list = max1238_mode_list, 1262 .num_modes = ARRAY_SIZE(max1238_mode_list), 1263 .default_mode = s0to11, 1264 .info = &max1238_info, 1265 .channels = max1038_channels, 1266 .num_channels = ARRAY_SIZE(max1038_channels), 1267 }, 1268 [max11606] = { 1269 .bits = 10, 1270 .int_vref_mv = 4096, 1271 .mode_list = max11607_mode_list, 1272 .num_modes = ARRAY_SIZE(max11607_mode_list), 1273 .default_mode = s0to3, 1274 .info = &max1238_info, 1275 .channels = max1136_channels, 1276 .num_channels = ARRAY_SIZE(max1136_channels), 1277 }, 1278 [max11607] = { 1279 .bits = 10, 1280 .int_vref_mv = 2048, 1281 .mode_list = max11607_mode_list, 1282 .num_modes = ARRAY_SIZE(max11607_mode_list), 1283 .default_mode = s0to3, 1284 .info = &max1238_info, 1285 .channels = max1136_channels, 1286 .num_channels = ARRAY_SIZE(max1136_channels), 1287 }, 1288 [max11608] = { 1289 .bits = 10, 1290 .int_vref_mv = 4096, 1291 .mode_list = max11608_mode_list, 1292 .num_modes = ARRAY_SIZE(max11608_mode_list), 1293 .default_mode = s0to7, 1294 .info = &max1238_info, 1295 .channels = max11608_channels, 1296 .num_channels = ARRAY_SIZE(max11608_channels), 1297 }, 1298 [max11609] = { 1299 .bits = 10, 1300 .int_vref_mv = 2048, 1301 .mode_list = max11608_mode_list, 1302 .num_modes = ARRAY_SIZE(max11608_mode_list), 1303 .default_mode = s0to7, 1304 .info = &max1238_info, 1305 .channels = max11608_channels, 1306 .num_channels = ARRAY_SIZE(max11608_channels), 1307 }, 1308 [max11610] = { 1309 .bits = 10, 1310 .int_vref_mv = 4096, 1311 .mode_list = max1238_mode_list, 1312 .num_modes = ARRAY_SIZE(max1238_mode_list), 1313 .default_mode = s0to11, 1314 .info = &max1238_info, 1315 .channels = max1138_channels, 1316 .num_channels = ARRAY_SIZE(max1138_channels), 1317 }, 1318 [max11611] = { 1319 .bits = 10, 1320 .int_vref_mv = 2048, 1321 .mode_list = max1238_mode_list, 1322 .num_modes = ARRAY_SIZE(max1238_mode_list), 1323 .default_mode = s0to11, 1324 .info = &max1238_info, 1325 .channels = max1138_channels, 1326 .num_channels = ARRAY_SIZE(max1138_channels), 1327 }, 1328 [max11612] = { 1329 .bits = 12, 1330 .int_vref_mv = 4096, 1331 .mode_list = max11607_mode_list, 1332 .num_modes = ARRAY_SIZE(max11607_mode_list), 1333 .default_mode = s0to3, 1334 .info = &max1238_info, 1335 .channels = max1363_channels, 1336 .num_channels = ARRAY_SIZE(max1363_channels), 1337 }, 1338 [max11613] = { 1339 .bits = 12, 1340 .int_vref_mv = 2048, 1341 .mode_list = max11607_mode_list, 1342 .num_modes = ARRAY_SIZE(max11607_mode_list), 1343 .default_mode = s0to3, 1344 .info = &max1238_info, 1345 .channels = max1363_channels, 1346 .num_channels = ARRAY_SIZE(max1363_channels), 1347 }, 1348 [max11614] = { 1349 .bits = 12, 1350 .int_vref_mv = 4096, 1351 .mode_list = max11608_mode_list, 1352 .num_modes = ARRAY_SIZE(max11608_mode_list), 1353 .default_mode = s0to7, 1354 .info = &max1238_info, 1355 .channels = max11614_channels, 1356 .num_channels = ARRAY_SIZE(max11614_channels), 1357 }, 1358 [max11615] = { 1359 .bits = 12, 1360 .int_vref_mv = 2048, 1361 .mode_list = max11608_mode_list, 1362 .num_modes = ARRAY_SIZE(max11608_mode_list), 1363 .default_mode = s0to7, 1364 .info = &max1238_info, 1365 .channels = max11614_channels, 1366 .num_channels = ARRAY_SIZE(max11614_channels), 1367 }, 1368 [max11616] = { 1369 .bits = 12, 1370 .int_vref_mv = 4096, 1371 .mode_list = max1238_mode_list, 1372 .num_modes = ARRAY_SIZE(max1238_mode_list), 1373 .default_mode = s0to11, 1374 .info = &max1238_info, 1375 .channels = max1238_channels, 1376 .num_channels = ARRAY_SIZE(max1238_channels), 1377 }, 1378 [max11617] = { 1379 .bits = 12, 1380 .int_vref_mv = 2048, 1381 .mode_list = max1238_mode_list, 1382 .num_modes = ARRAY_SIZE(max1238_mode_list), 1383 .default_mode = s0to11, 1384 .info = &max1238_info, 1385 .channels = max1238_channels, 1386 .num_channels = ARRAY_SIZE(max1238_channels), 1387 }, 1388 [max11644] = { 1389 .bits = 12, 1390 .int_vref_mv = 2048, 1391 .mode_list = max11644_mode_list, 1392 .num_modes = ARRAY_SIZE(max11644_mode_list), 1393 .default_mode = s0to1, 1394 .info = &max1238_info, 1395 .channels = max11644_channels, 1396 .num_channels = ARRAY_SIZE(max11644_channels), 1397 }, 1398 [max11645] = { 1399 .bits = 12, 1400 .int_vref_mv = 4096, 1401 .mode_list = max11644_mode_list, 1402 .num_modes = ARRAY_SIZE(max11644_mode_list), 1403 .default_mode = s0to1, 1404 .info = &max1238_info, 1405 .channels = max11644_channels, 1406 .num_channels = ARRAY_SIZE(max11644_channels), 1407 }, 1408 [max11646] = { 1409 .bits = 10, 1410 .int_vref_mv = 2048, 1411 .mode_list = max11644_mode_list, 1412 .num_modes = ARRAY_SIZE(max11644_mode_list), 1413 .default_mode = s0to1, 1414 .info = &max1238_info, 1415 .channels = max11646_channels, 1416 .num_channels = ARRAY_SIZE(max11646_channels), 1417 }, 1418 [max11647] = { 1419 .bits = 10, 1420 .int_vref_mv = 4096, 1421 .mode_list = max11644_mode_list, 1422 .num_modes = ARRAY_SIZE(max11644_mode_list), 1423 .default_mode = s0to1, 1424 .info = &max1238_info, 1425 .channels = max11646_channels, 1426 .num_channels = ARRAY_SIZE(max11646_channels), 1427 }, 1428 }; 1429 1430 static int max1363_initial_setup(struct max1363_state *st) 1431 { 1432 st->setupbyte = MAX1363_SETUP_INT_CLOCK 1433 | MAX1363_SETUP_UNIPOLAR 1434 | MAX1363_SETUP_NORESET; 1435 1436 if (st->vref) 1437 st->setupbyte |= MAX1363_SETUP_AIN3_IS_REF_EXT_TO_REF; 1438 else 1439 st->setupbyte |= MAX1363_SETUP_POWER_UP_INT_REF 1440 | MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_INT; 1441 1442 /* Set scan mode writes the config anyway so wait until then */ 1443 st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte); 1444 st->current_mode = &max1363_mode_table[st->chip_info->default_mode]; 1445 st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte); 1446 1447 return max1363_set_scan_mode(st); 1448 } 1449 1450 static int max1363_alloc_scan_masks(struct iio_dev *indio_dev) 1451 { 1452 struct max1363_state *st = iio_priv(indio_dev); 1453 unsigned long *masks; 1454 int i; 1455 1456 masks = devm_kzalloc(&indio_dev->dev, 1457 BITS_TO_LONGS(MAX1363_MAX_CHANNELS) * sizeof(long) * 1458 (st->chip_info->num_modes + 1), GFP_KERNEL); 1459 if (!masks) 1460 return -ENOMEM; 1461 1462 for (i = 0; i < st->chip_info->num_modes; i++) 1463 bitmap_copy(masks + BITS_TO_LONGS(MAX1363_MAX_CHANNELS)*i, 1464 max1363_mode_table[st->chip_info->mode_list[i]] 1465 .modemask, MAX1363_MAX_CHANNELS); 1466 1467 indio_dev->available_scan_masks = masks; 1468 1469 return 0; 1470 } 1471 1472 static irqreturn_t max1363_trigger_handler(int irq, void *p) 1473 { 1474 struct iio_poll_func *pf = p; 1475 struct iio_dev *indio_dev = pf->indio_dev; 1476 struct max1363_state *st = iio_priv(indio_dev); 1477 __u8 *rxbuf; 1478 int b_sent; 1479 size_t d_size; 1480 unsigned long numvals = bitmap_weight(st->current_mode->modemask, 1481 MAX1363_MAX_CHANNELS); 1482 1483 /* Ensure the timestamp is 8 byte aligned */ 1484 if (st->chip_info->bits != 8) 1485 d_size = numvals*2; 1486 else 1487 d_size = numvals; 1488 if (indio_dev->scan_timestamp) { 1489 d_size += sizeof(s64); 1490 if (d_size % sizeof(s64)) 1491 d_size += sizeof(s64) - (d_size % sizeof(s64)); 1492 } 1493 /* Monitor mode prevents reading. Whilst not currently implemented 1494 * might as well have this test in here in the meantime as it does 1495 * no harm. 1496 */ 1497 if (numvals == 0) 1498 goto done; 1499 1500 rxbuf = kmalloc(d_size, GFP_KERNEL); 1501 if (rxbuf == NULL) 1502 goto done; 1503 if (st->chip_info->bits != 8) 1504 b_sent = st->recv(st->client, rxbuf, numvals * 2); 1505 else 1506 b_sent = st->recv(st->client, rxbuf, numvals); 1507 if (b_sent < 0) 1508 goto done_free; 1509 1510 iio_push_to_buffers_with_timestamp(indio_dev, rxbuf, iio_get_time_ns()); 1511 1512 done_free: 1513 kfree(rxbuf); 1514 done: 1515 iio_trigger_notify_done(indio_dev->trig); 1516 1517 return IRQ_HANDLED; 1518 } 1519 1520 static int max1363_probe(struct i2c_client *client, 1521 const struct i2c_device_id *id) 1522 { 1523 int ret; 1524 struct max1363_state *st; 1525 struct iio_dev *indio_dev; 1526 struct regulator *vref; 1527 1528 indio_dev = devm_iio_device_alloc(&client->dev, 1529 sizeof(struct max1363_state)); 1530 if (!indio_dev) 1531 return -ENOMEM; 1532 1533 indio_dev->dev.of_node = client->dev.of_node; 1534 ret = iio_map_array_register(indio_dev, client->dev.platform_data); 1535 if (ret < 0) 1536 return ret; 1537 1538 st = iio_priv(indio_dev); 1539 1540 st->reg = devm_regulator_get(&client->dev, "vcc"); 1541 if (IS_ERR(st->reg)) { 1542 ret = PTR_ERR(st->reg); 1543 goto error_unregister_map; 1544 } 1545 1546 ret = regulator_enable(st->reg); 1547 if (ret) 1548 goto error_unregister_map; 1549 1550 /* this is only used for device removal purposes */ 1551 i2c_set_clientdata(client, indio_dev); 1552 1553 st->chip_info = &max1363_chip_info_tbl[id->driver_data]; 1554 st->client = client; 1555 1556 st->vref_uv = st->chip_info->int_vref_mv * 1000; 1557 vref = devm_regulator_get_optional(&client->dev, "vref"); 1558 if (!IS_ERR(vref)) { 1559 int vref_uv; 1560 1561 ret = regulator_enable(vref); 1562 if (ret) 1563 goto error_disable_reg; 1564 st->vref = vref; 1565 vref_uv = regulator_get_voltage(vref); 1566 if (vref_uv <= 0) { 1567 ret = -EINVAL; 1568 goto error_disable_reg; 1569 } 1570 st->vref_uv = vref_uv; 1571 } 1572 1573 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 1574 st->send = i2c_master_send; 1575 st->recv = i2c_master_recv; 1576 } else if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE) 1577 && st->chip_info->bits == 8) { 1578 st->send = max1363_smbus_send; 1579 st->recv = max1363_smbus_recv; 1580 } else { 1581 ret = -EOPNOTSUPP; 1582 goto error_disable_reg; 1583 } 1584 1585 ret = max1363_alloc_scan_masks(indio_dev); 1586 if (ret) 1587 goto error_disable_reg; 1588 1589 /* Establish that the iio_dev is a child of the i2c device */ 1590 indio_dev->dev.parent = &client->dev; 1591 indio_dev->name = id->name; 1592 indio_dev->channels = st->chip_info->channels; 1593 indio_dev->num_channels = st->chip_info->num_channels; 1594 indio_dev->info = st->chip_info->info; 1595 indio_dev->modes = INDIO_DIRECT_MODE; 1596 ret = max1363_initial_setup(st); 1597 if (ret < 0) 1598 goto error_disable_reg; 1599 1600 ret = iio_triggered_buffer_setup(indio_dev, NULL, 1601 &max1363_trigger_handler, NULL); 1602 if (ret) 1603 goto error_disable_reg; 1604 1605 if (client->irq) { 1606 ret = devm_request_threaded_irq(&client->dev, st->client->irq, 1607 NULL, 1608 &max1363_event_handler, 1609 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 1610 "max1363_event", 1611 indio_dev); 1612 1613 if (ret) 1614 goto error_uninit_buffer; 1615 } 1616 1617 ret = iio_device_register(indio_dev); 1618 if (ret < 0) 1619 goto error_uninit_buffer; 1620 1621 return 0; 1622 1623 error_uninit_buffer: 1624 iio_triggered_buffer_cleanup(indio_dev); 1625 error_disable_reg: 1626 if (st->vref) 1627 regulator_disable(st->vref); 1628 regulator_disable(st->reg); 1629 error_unregister_map: 1630 iio_map_array_unregister(indio_dev); 1631 return ret; 1632 } 1633 1634 static int max1363_remove(struct i2c_client *client) 1635 { 1636 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1637 struct max1363_state *st = iio_priv(indio_dev); 1638 1639 iio_device_unregister(indio_dev); 1640 iio_triggered_buffer_cleanup(indio_dev); 1641 if (st->vref) 1642 regulator_disable(st->vref); 1643 regulator_disable(st->reg); 1644 iio_map_array_unregister(indio_dev); 1645 1646 return 0; 1647 } 1648 1649 static const struct i2c_device_id max1363_id[] = { 1650 { "max1361", max1361 }, 1651 { "max1362", max1362 }, 1652 { "max1363", max1363 }, 1653 { "max1364", max1364 }, 1654 { "max1036", max1036 }, 1655 { "max1037", max1037 }, 1656 { "max1038", max1038 }, 1657 { "max1039", max1039 }, 1658 { "max1136", max1136 }, 1659 { "max1137", max1137 }, 1660 { "max1138", max1138 }, 1661 { "max1139", max1139 }, 1662 { "max1236", max1236 }, 1663 { "max1237", max1237 }, 1664 { "max1238", max1238 }, 1665 { "max1239", max1239 }, 1666 { "max11600", max11600 }, 1667 { "max11601", max11601 }, 1668 { "max11602", max11602 }, 1669 { "max11603", max11603 }, 1670 { "max11604", max11604 }, 1671 { "max11605", max11605 }, 1672 { "max11606", max11606 }, 1673 { "max11607", max11607 }, 1674 { "max11608", max11608 }, 1675 { "max11609", max11609 }, 1676 { "max11610", max11610 }, 1677 { "max11611", max11611 }, 1678 { "max11612", max11612 }, 1679 { "max11613", max11613 }, 1680 { "max11614", max11614 }, 1681 { "max11615", max11615 }, 1682 { "max11616", max11616 }, 1683 { "max11617", max11617 }, 1684 {} 1685 }; 1686 1687 MODULE_DEVICE_TABLE(i2c, max1363_id); 1688 1689 static struct i2c_driver max1363_driver = { 1690 .driver = { 1691 .name = "max1363", 1692 }, 1693 .probe = max1363_probe, 1694 .remove = max1363_remove, 1695 .id_table = max1363_id, 1696 }; 1697 module_i2c_driver(max1363_driver); 1698 1699 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 1700 MODULE_DESCRIPTION("Maxim 1363 ADC"); 1701 MODULE_LICENSE("GPL v2"); 1702