1 /* 2 * ADXRS450/ADXRS453 Digital Output Gyroscope Driver 3 * 4 * Copyright 2011 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2. 7 */ 8 9 #include <linux/interrupt.h> 10 #include <linux/irq.h> 11 #include <linux/delay.h> 12 #include <linux/mutex.h> 13 #include <linux/device.h> 14 #include <linux/kernel.h> 15 #include <linux/spi/spi.h> 16 #include <linux/slab.h> 17 #include <linux/sysfs.h> 18 #include <linux/list.h> 19 #include <linux/module.h> 20 21 #include <linux/iio/iio.h> 22 #include <linux/iio/sysfs.h> 23 24 #define ADXRS450_STARTUP_DELAY 50 /* ms */ 25 26 /* The MSB for the spi commands */ 27 #define ADXRS450_SENSOR_DATA (0x20 << 24) 28 #define ADXRS450_WRITE_DATA (0x40 << 24) 29 #define ADXRS450_READ_DATA (0x80 << 24) 30 31 #define ADXRS450_RATE1 0x00 /* Rate Registers */ 32 #define ADXRS450_TEMP1 0x02 /* Temperature Registers */ 33 #define ADXRS450_LOCST1 0x04 /* Low CST Memory Registers */ 34 #define ADXRS450_HICST1 0x06 /* High CST Memory Registers */ 35 #define ADXRS450_QUAD1 0x08 /* Quad Memory Registers */ 36 #define ADXRS450_FAULT1 0x0A /* Fault Registers */ 37 #define ADXRS450_PID1 0x0C /* Part ID Register 1 */ 38 #define ADXRS450_SNH 0x0E /* Serial Number Registers, 4 bytes */ 39 #define ADXRS450_SNL 0x10 40 #define ADXRS450_DNC1 0x12 /* Dynamic Null Correction Registers */ 41 /* Check bits */ 42 #define ADXRS450_P 0x01 43 #define ADXRS450_CHK 0x02 44 #define ADXRS450_CST 0x04 45 #define ADXRS450_PWR 0x08 46 #define ADXRS450_POR 0x10 47 #define ADXRS450_NVM 0x20 48 #define ADXRS450_Q 0x40 49 #define ADXRS450_PLL 0x80 50 #define ADXRS450_UV 0x100 51 #define ADXRS450_OV 0x200 52 #define ADXRS450_AMP 0x400 53 #define ADXRS450_FAIL 0x800 54 55 #define ADXRS450_WRERR_MASK (0x7 << 29) 56 57 #define ADXRS450_MAX_RX 4 58 #define ADXRS450_MAX_TX 4 59 60 #define ADXRS450_GET_ST(a) ((a >> 26) & 0x3) 61 62 enum { 63 ID_ADXRS450, 64 ID_ADXRS453, 65 }; 66 67 /** 68 * struct adxrs450_state - device instance specific data 69 * @us: actual spi_device 70 * @buf_lock: mutex to protect tx and rx 71 * @tx: transmit buffer 72 * @rx: receive buffer 73 **/ 74 struct adxrs450_state { 75 struct spi_device *us; 76 struct mutex buf_lock; 77 __be32 tx ____cacheline_aligned; 78 __be32 rx; 79 80 }; 81 82 /** 83 * adxrs450_spi_read_reg_16() - read 2 bytes from a register pair 84 * @indio_dev: device associated with child of actual iio_dev 85 * @reg_address: the address of the lower of the two registers, which should be 86 * an even address, the second register's address is reg_address + 1. 87 * @val: somewhere to pass back the value read 88 **/ 89 static int adxrs450_spi_read_reg_16(struct iio_dev *indio_dev, 90 u8 reg_address, 91 u16 *val) 92 { 93 struct spi_message msg; 94 struct adxrs450_state *st = iio_priv(indio_dev); 95 u32 tx; 96 int ret; 97 struct spi_transfer xfers[] = { 98 { 99 .tx_buf = &st->tx, 100 .bits_per_word = 8, 101 .len = sizeof(st->tx), 102 .cs_change = 1, 103 }, { 104 .rx_buf = &st->rx, 105 .bits_per_word = 8, 106 .len = sizeof(st->rx), 107 }, 108 }; 109 110 mutex_lock(&st->buf_lock); 111 tx = ADXRS450_READ_DATA | (reg_address << 17); 112 113 if (!(hweight32(tx) & 1)) 114 tx |= ADXRS450_P; 115 116 st->tx = cpu_to_be32(tx); 117 spi_message_init(&msg); 118 spi_message_add_tail(&xfers[0], &msg); 119 spi_message_add_tail(&xfers[1], &msg); 120 ret = spi_sync(st->us, &msg); 121 if (ret) { 122 dev_err(&st->us->dev, "problem while reading 16 bit register 0x%02x\n", 123 reg_address); 124 goto error_ret; 125 } 126 127 *val = (be32_to_cpu(st->rx) >> 5) & 0xFFFF; 128 129 error_ret: 130 mutex_unlock(&st->buf_lock); 131 return ret; 132 } 133 134 /** 135 * adxrs450_spi_write_reg_16() - write 2 bytes data to a register pair 136 * @indio_dev: device associated with child of actual actual iio_dev 137 * @reg_address: the address of the lower of the two registers,which should be 138 * an even address, the second register's address is reg_address + 1. 139 * @val: value to be written. 140 **/ 141 static int adxrs450_spi_write_reg_16(struct iio_dev *indio_dev, 142 u8 reg_address, 143 u16 val) 144 { 145 struct adxrs450_state *st = iio_priv(indio_dev); 146 u32 tx; 147 int ret; 148 149 mutex_lock(&st->buf_lock); 150 tx = ADXRS450_WRITE_DATA | (reg_address << 17) | (val << 1); 151 152 if (!(hweight32(tx) & 1)) 153 tx |= ADXRS450_P; 154 155 st->tx = cpu_to_be32(tx); 156 ret = spi_write(st->us, &st->tx, sizeof(st->tx)); 157 if (ret) 158 dev_err(&st->us->dev, "problem while writing 16 bit register 0x%02x\n", 159 reg_address); 160 usleep_range(100, 1000); /* enforce sequential transfer delay 0.1ms */ 161 mutex_unlock(&st->buf_lock); 162 return ret; 163 } 164 165 /** 166 * adxrs450_spi_sensor_data() - read 2 bytes sensor data 167 * @indio_dev: device associated with child of actual iio_dev 168 * @val: somewhere to pass back the value read 169 **/ 170 static int adxrs450_spi_sensor_data(struct iio_dev *indio_dev, s16 *val) 171 { 172 struct spi_message msg; 173 struct adxrs450_state *st = iio_priv(indio_dev); 174 int ret; 175 struct spi_transfer xfers[] = { 176 { 177 .tx_buf = &st->tx, 178 .bits_per_word = 8, 179 .len = sizeof(st->tx), 180 .cs_change = 1, 181 }, { 182 .rx_buf = &st->rx, 183 .bits_per_word = 8, 184 .len = sizeof(st->rx), 185 }, 186 }; 187 188 mutex_lock(&st->buf_lock); 189 st->tx = cpu_to_be32(ADXRS450_SENSOR_DATA); 190 191 spi_message_init(&msg); 192 spi_message_add_tail(&xfers[0], &msg); 193 spi_message_add_tail(&xfers[1], &msg); 194 ret = spi_sync(st->us, &msg); 195 if (ret) { 196 dev_err(&st->us->dev, "Problem while reading sensor data\n"); 197 goto error_ret; 198 } 199 200 *val = (be32_to_cpu(st->rx) >> 10) & 0xFFFF; 201 202 error_ret: 203 mutex_unlock(&st->buf_lock); 204 return ret; 205 } 206 207 /** 208 * adxrs450_spi_initial() - use for initializing procedure. 209 * @st: device instance specific data 210 * @val: somewhere to pass back the value read 211 * @chk: Whether to perform fault check 212 **/ 213 static int adxrs450_spi_initial(struct adxrs450_state *st, 214 u32 *val, char chk) 215 { 216 int ret; 217 u32 tx; 218 struct spi_transfer xfers = { 219 .tx_buf = &st->tx, 220 .rx_buf = &st->rx, 221 .bits_per_word = 8, 222 .len = sizeof(st->tx), 223 }; 224 225 mutex_lock(&st->buf_lock); 226 tx = ADXRS450_SENSOR_DATA; 227 if (chk) 228 tx |= (ADXRS450_CHK | ADXRS450_P); 229 st->tx = cpu_to_be32(tx); 230 ret = spi_sync_transfer(st->us, &xfers, 1); 231 if (ret) { 232 dev_err(&st->us->dev, "Problem while reading initializing data\n"); 233 goto error_ret; 234 } 235 236 *val = be32_to_cpu(st->rx); 237 238 error_ret: 239 mutex_unlock(&st->buf_lock); 240 return ret; 241 } 242 243 /* Recommended Startup Sequence by spec */ 244 static int adxrs450_initial_setup(struct iio_dev *indio_dev) 245 { 246 u32 t; 247 u16 data; 248 int ret; 249 struct adxrs450_state *st = iio_priv(indio_dev); 250 251 msleep(ADXRS450_STARTUP_DELAY*2); 252 ret = adxrs450_spi_initial(st, &t, 1); 253 if (ret) 254 return ret; 255 if (t != 0x01) 256 dev_warn(&st->us->dev, "The initial power on response is not correct! Restart without reset?\n"); 257 258 msleep(ADXRS450_STARTUP_DELAY); 259 ret = adxrs450_spi_initial(st, &t, 0); 260 if (ret) 261 return ret; 262 263 msleep(ADXRS450_STARTUP_DELAY); 264 ret = adxrs450_spi_initial(st, &t, 0); 265 if (ret) 266 return ret; 267 if (((t & 0xff) | 0x01) != 0xff || ADXRS450_GET_ST(t) != 2) { 268 dev_err(&st->us->dev, "The second response is not correct!\n"); 269 return -EIO; 270 271 } 272 ret = adxrs450_spi_initial(st, &t, 0); 273 if (ret) 274 return ret; 275 if (((t & 0xff) | 0x01) != 0xff || ADXRS450_GET_ST(t) != 2) { 276 dev_err(&st->us->dev, "The third response is not correct!\n"); 277 return -EIO; 278 279 } 280 ret = adxrs450_spi_read_reg_16(indio_dev, ADXRS450_FAULT1, &data); 281 if (ret) 282 return ret; 283 if (data & 0x0fff) { 284 dev_err(&st->us->dev, "The device is not in normal status!\n"); 285 return -EINVAL; 286 } 287 288 return 0; 289 } 290 291 static int adxrs450_write_raw(struct iio_dev *indio_dev, 292 struct iio_chan_spec const *chan, 293 int val, 294 int val2, 295 long mask) 296 { 297 int ret; 298 switch (mask) { 299 case IIO_CHAN_INFO_CALIBBIAS: 300 if (val < -0x400 || val >= 0x400) 301 return -EINVAL; 302 ret = adxrs450_spi_write_reg_16(indio_dev, 303 ADXRS450_DNC1, val); 304 break; 305 default: 306 ret = -EINVAL; 307 break; 308 } 309 return ret; 310 } 311 312 static int adxrs450_read_raw(struct iio_dev *indio_dev, 313 struct iio_chan_spec const *chan, 314 int *val, 315 int *val2, 316 long mask) 317 { 318 int ret; 319 s16 t; 320 321 switch (mask) { 322 case IIO_CHAN_INFO_RAW: 323 switch (chan->type) { 324 case IIO_ANGL_VEL: 325 ret = adxrs450_spi_sensor_data(indio_dev, &t); 326 if (ret) 327 break; 328 *val = t; 329 ret = IIO_VAL_INT; 330 break; 331 case IIO_TEMP: 332 ret = adxrs450_spi_read_reg_16(indio_dev, 333 ADXRS450_TEMP1, &t); 334 if (ret) 335 break; 336 *val = (t >> 6) + 225; 337 ret = IIO_VAL_INT; 338 break; 339 default: 340 ret = -EINVAL; 341 break; 342 } 343 break; 344 case IIO_CHAN_INFO_SCALE: 345 switch (chan->type) { 346 case IIO_ANGL_VEL: 347 *val = 0; 348 *val2 = 218166; 349 return IIO_VAL_INT_PLUS_NANO; 350 case IIO_TEMP: 351 *val = 200; 352 *val2 = 0; 353 return IIO_VAL_INT; 354 default: 355 return -EINVAL; 356 } 357 break; 358 case IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW: 359 ret = adxrs450_spi_read_reg_16(indio_dev, ADXRS450_QUAD1, &t); 360 if (ret) 361 break; 362 *val = t; 363 ret = IIO_VAL_INT; 364 break; 365 case IIO_CHAN_INFO_CALIBBIAS: 366 ret = adxrs450_spi_read_reg_16(indio_dev, ADXRS450_DNC1, &t); 367 if (ret) 368 break; 369 *val = sign_extend32(t, 9); 370 ret = IIO_VAL_INT; 371 break; 372 default: 373 ret = -EINVAL; 374 break; 375 } 376 377 return ret; 378 } 379 380 static const struct iio_chan_spec adxrs450_channels[2][2] = { 381 [ID_ADXRS450] = { 382 { 383 .type = IIO_ANGL_VEL, 384 .modified = 1, 385 .channel2 = IIO_MOD_Z, 386 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 387 BIT(IIO_CHAN_INFO_CALIBBIAS) | 388 BIT(IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW) | 389 BIT(IIO_CHAN_INFO_SCALE), 390 }, { 391 .type = IIO_TEMP, 392 .indexed = 1, 393 .channel = 0, 394 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 395 BIT(IIO_CHAN_INFO_SCALE), 396 } 397 }, 398 [ID_ADXRS453] = { 399 { 400 .type = IIO_ANGL_VEL, 401 .modified = 1, 402 .channel2 = IIO_MOD_Z, 403 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 404 BIT(IIO_CHAN_INFO_SCALE) | 405 BIT(IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW), 406 }, { 407 .type = IIO_TEMP, 408 .indexed = 1, 409 .channel = 0, 410 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 411 BIT(IIO_CHAN_INFO_SCALE), 412 } 413 }, 414 }; 415 416 static const struct iio_info adxrs450_info = { 417 .driver_module = THIS_MODULE, 418 .read_raw = &adxrs450_read_raw, 419 .write_raw = &adxrs450_write_raw, 420 }; 421 422 static int adxrs450_probe(struct spi_device *spi) 423 { 424 int ret; 425 struct adxrs450_state *st; 426 struct iio_dev *indio_dev; 427 428 /* setup the industrialio driver allocated elements */ 429 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); 430 if (!indio_dev) 431 return -ENOMEM; 432 st = iio_priv(indio_dev); 433 st->us = spi; 434 mutex_init(&st->buf_lock); 435 /* This is only used for removal purposes */ 436 spi_set_drvdata(spi, indio_dev); 437 438 indio_dev->dev.parent = &spi->dev; 439 indio_dev->info = &adxrs450_info; 440 indio_dev->modes = INDIO_DIRECT_MODE; 441 indio_dev->channels = 442 adxrs450_channels[spi_get_device_id(spi)->driver_data]; 443 indio_dev->num_channels = ARRAY_SIZE(adxrs450_channels); 444 indio_dev->name = spi->dev.driver->name; 445 446 ret = iio_device_register(indio_dev); 447 if (ret) 448 return ret; 449 450 /* Get the device into a sane initial state */ 451 ret = adxrs450_initial_setup(indio_dev); 452 if (ret) 453 goto error_initial; 454 return 0; 455 error_initial: 456 iio_device_unregister(indio_dev); 457 return ret; 458 } 459 460 static int adxrs450_remove(struct spi_device *spi) 461 { 462 iio_device_unregister(spi_get_drvdata(spi)); 463 464 return 0; 465 } 466 467 static const struct spi_device_id adxrs450_id[] = { 468 {"adxrs450", ID_ADXRS450}, 469 {"adxrs453", ID_ADXRS453}, 470 {} 471 }; 472 MODULE_DEVICE_TABLE(spi, adxrs450_id); 473 474 static struct spi_driver adxrs450_driver = { 475 .driver = { 476 .name = "adxrs450", 477 .owner = THIS_MODULE, 478 }, 479 .probe = adxrs450_probe, 480 .remove = adxrs450_remove, 481 .id_table = adxrs450_id, 482 }; 483 module_spi_driver(adxrs450_driver); 484 485 MODULE_AUTHOR("Cliff Cai <cliff.cai@xxxxxxxxxx>"); 486 MODULE_DESCRIPTION("Analog Devices ADXRS450/ADXRS453 Gyroscope SPI driver"); 487 MODULE_LICENSE("GPL v2"); 488