1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * srf08.c - Support for Devantech SRFxx ultrasonic ranger 4 * with i2c interface 5 * actually supported are srf02, srf08, srf10 6 * 7 * Copyright (c) 2016, 2017 Andreas Klinger <ak@it-klinger.de> 8 * 9 * For details about the device see: 10 * https://www.robot-electronics.co.uk/htm/srf08tech.html 11 * https://www.robot-electronics.co.uk/htm/srf10tech.htm 12 * https://www.robot-electronics.co.uk/htm/srf02tech.htm 13 */ 14 15 #include <linux/err.h> 16 #include <linux/i2c.h> 17 #include <linux/delay.h> 18 #include <linux/module.h> 19 #include <linux/bitops.h> 20 #include <linux/iio/iio.h> 21 #include <linux/iio/sysfs.h> 22 #include <linux/iio/buffer.h> 23 #include <linux/iio/trigger_consumer.h> 24 #include <linux/iio/triggered_buffer.h> 25 26 /* registers of SRF08 device */ 27 #define SRF08_WRITE_COMMAND 0x00 /* Command Register */ 28 #define SRF08_WRITE_MAX_GAIN 0x01 /* Max Gain Register: 0 .. 31 */ 29 #define SRF08_WRITE_RANGE 0x02 /* Range Register: 0 .. 255 */ 30 #define SRF08_READ_SW_REVISION 0x00 /* Software Revision */ 31 #define SRF08_READ_LIGHT 0x01 /* Light Sensor during last echo */ 32 #define SRF08_READ_ECHO_1_HIGH 0x02 /* Range of first echo received */ 33 #define SRF08_READ_ECHO_1_LOW 0x03 /* Range of first echo received */ 34 35 #define SRF08_CMD_RANGING_CM 0x51 /* Ranging Mode - Result in cm */ 36 37 enum srf08_sensor_type { 38 SRF02, 39 SRF08, 40 SRF10, 41 SRF_MAX_TYPE 42 }; 43 44 struct srf08_chip_info { 45 const int *sensitivity_avail; 46 int num_sensitivity_avail; 47 int sensitivity_default; 48 49 /* default value of Range in mm */ 50 int range_default; 51 }; 52 53 struct srf08_data { 54 struct i2c_client *client; 55 56 /* 57 * Gain in the datasheet is called sensitivity here to distinct it 58 * from the gain used with amplifiers of adc's 59 */ 60 int sensitivity; 61 62 /* max. Range in mm */ 63 int range_mm; 64 struct mutex lock; 65 66 /* 67 * triggered buffer 68 * 1x16-bit channel + 3x16 padding + 4x16 timestamp 69 */ 70 s16 buffer[8]; 71 72 /* Sensor-Type */ 73 enum srf08_sensor_type sensor_type; 74 75 /* Chip-specific information */ 76 const struct srf08_chip_info *chip_info; 77 }; 78 79 /* 80 * in the documentation one can read about the "Gain" of the device 81 * which is used here for amplifying the signal and filtering out unwanted 82 * ones. 83 * But with ADC's this term is already used differently and that's why it 84 * is called "Sensitivity" here. 85 */ 86 static const struct srf08_chip_info srf02_chip_info = { 87 .sensitivity_avail = NULL, 88 .num_sensitivity_avail = 0, 89 .sensitivity_default = 0, 90 91 .range_default = 0, 92 }; 93 94 static const int srf08_sensitivity_avail[] = { 95 94, 97, 100, 103, 107, 110, 114, 118, 96 123, 128, 133, 139, 145, 152, 159, 168, 97 177, 187, 199, 212, 227, 245, 265, 288, 98 317, 352, 395, 450, 524, 626, 777, 1025 99 }; 100 101 static const struct srf08_chip_info srf08_chip_info = { 102 .sensitivity_avail = srf08_sensitivity_avail, 103 .num_sensitivity_avail = ARRAY_SIZE(srf08_sensitivity_avail), 104 .sensitivity_default = 1025, 105 106 .range_default = 6020, 107 }; 108 109 static const int srf10_sensitivity_avail[] = { 110 40, 40, 50, 60, 70, 80, 100, 120, 111 140, 200, 250, 300, 350, 400, 500, 600, 112 700, 113 }; 114 115 static const struct srf08_chip_info srf10_chip_info = { 116 .sensitivity_avail = srf10_sensitivity_avail, 117 .num_sensitivity_avail = ARRAY_SIZE(srf10_sensitivity_avail), 118 .sensitivity_default = 700, 119 120 .range_default = 6020, 121 }; 122 123 static int srf08_read_ranging(struct srf08_data *data) 124 { 125 struct i2c_client *client = data->client; 126 int ret, i; 127 int waittime; 128 129 mutex_lock(&data->lock); 130 131 ret = i2c_smbus_write_byte_data(data->client, 132 SRF08_WRITE_COMMAND, SRF08_CMD_RANGING_CM); 133 if (ret < 0) { 134 dev_err(&client->dev, "write command - err: %d\n", ret); 135 mutex_unlock(&data->lock); 136 return ret; 137 } 138 139 /* 140 * we read here until a correct version number shows up as 141 * suggested by the documentation 142 * 143 * with an ultrasonic speed of 343 m/s and a roundtrip of it 144 * sleep the expected duration and try to read from the device 145 * if nothing useful is read try it in a shorter grid 146 * 147 * polling for not more than 20 ms should be enough 148 */ 149 waittime = 1 + data->range_mm / 172; 150 msleep(waittime); 151 for (i = 0; i < 4; i++) { 152 ret = i2c_smbus_read_byte_data(data->client, 153 SRF08_READ_SW_REVISION); 154 155 /* check if a valid version number is read */ 156 if (ret < 255 && ret > 0) 157 break; 158 msleep(5); 159 } 160 161 if (ret >= 255 || ret <= 0) { 162 dev_err(&client->dev, "device not ready\n"); 163 mutex_unlock(&data->lock); 164 return -EIO; 165 } 166 167 ret = i2c_smbus_read_word_swapped(data->client, 168 SRF08_READ_ECHO_1_HIGH); 169 if (ret < 0) { 170 dev_err(&client->dev, "cannot read distance: ret=%d\n", ret); 171 mutex_unlock(&data->lock); 172 return ret; 173 } 174 175 mutex_unlock(&data->lock); 176 177 return ret; 178 } 179 180 static irqreturn_t srf08_trigger_handler(int irq, void *p) 181 { 182 struct iio_poll_func *pf = p; 183 struct iio_dev *indio_dev = pf->indio_dev; 184 struct srf08_data *data = iio_priv(indio_dev); 185 s16 sensor_data; 186 187 sensor_data = srf08_read_ranging(data); 188 if (sensor_data < 0) 189 goto err; 190 191 mutex_lock(&data->lock); 192 193 data->buffer[0] = sensor_data; 194 iio_push_to_buffers_with_timestamp(indio_dev, 195 data->buffer, pf->timestamp); 196 197 mutex_unlock(&data->lock); 198 err: 199 iio_trigger_notify_done(indio_dev->trig); 200 return IRQ_HANDLED; 201 } 202 203 static int srf08_read_raw(struct iio_dev *indio_dev, 204 struct iio_chan_spec const *channel, int *val, 205 int *val2, long mask) 206 { 207 struct srf08_data *data = iio_priv(indio_dev); 208 int ret; 209 210 if (channel->type != IIO_DISTANCE) 211 return -EINVAL; 212 213 switch (mask) { 214 case IIO_CHAN_INFO_RAW: 215 ret = srf08_read_ranging(data); 216 if (ret < 0) 217 return ret; 218 *val = ret; 219 return IIO_VAL_INT; 220 case IIO_CHAN_INFO_SCALE: 221 /* 1 LSB is 1 cm */ 222 *val = 0; 223 *val2 = 10000; 224 return IIO_VAL_INT_PLUS_MICRO; 225 default: 226 return -EINVAL; 227 } 228 } 229 230 static ssize_t srf08_show_range_mm_available(struct device *dev, 231 struct device_attribute *attr, char *buf) 232 { 233 return sprintf(buf, "[0.043 0.043 11.008]\n"); 234 } 235 236 static IIO_DEVICE_ATTR(sensor_max_range_available, S_IRUGO, 237 srf08_show_range_mm_available, NULL, 0); 238 239 static ssize_t srf08_show_range_mm(struct device *dev, 240 struct device_attribute *attr, char *buf) 241 { 242 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 243 struct srf08_data *data = iio_priv(indio_dev); 244 245 return sprintf(buf, "%d.%03d\n", data->range_mm / 1000, 246 data->range_mm % 1000); 247 } 248 249 /* 250 * set the range of the sensor to an even multiple of 43 mm 251 * which corresponds to 1 LSB in the register 252 * 253 * register value corresponding range 254 * 0x00 43 mm 255 * 0x01 86 mm 256 * 0x02 129 mm 257 * ... 258 * 0xFF 11008 mm 259 */ 260 static ssize_t srf08_write_range_mm(struct srf08_data *data, unsigned int val) 261 { 262 int ret; 263 struct i2c_client *client = data->client; 264 unsigned int mod; 265 u8 regval; 266 267 ret = val / 43 - 1; 268 mod = val % 43; 269 270 if (mod || (ret < 0) || (ret > 255)) 271 return -EINVAL; 272 273 regval = ret; 274 275 mutex_lock(&data->lock); 276 277 ret = i2c_smbus_write_byte_data(client, SRF08_WRITE_RANGE, regval); 278 if (ret < 0) { 279 dev_err(&client->dev, "write_range - err: %d\n", ret); 280 mutex_unlock(&data->lock); 281 return ret; 282 } 283 284 data->range_mm = val; 285 286 mutex_unlock(&data->lock); 287 288 return 0; 289 } 290 291 static ssize_t srf08_store_range_mm(struct device *dev, 292 struct device_attribute *attr, 293 const char *buf, size_t len) 294 { 295 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 296 struct srf08_data *data = iio_priv(indio_dev); 297 int ret; 298 int integer, fract; 299 300 ret = iio_str_to_fixpoint(buf, 100, &integer, &fract); 301 if (ret) 302 return ret; 303 304 ret = srf08_write_range_mm(data, integer * 1000 + fract); 305 if (ret < 0) 306 return ret; 307 308 return len; 309 } 310 311 static IIO_DEVICE_ATTR(sensor_max_range, S_IRUGO | S_IWUSR, 312 srf08_show_range_mm, srf08_store_range_mm, 0); 313 314 static ssize_t srf08_show_sensitivity_available(struct device *dev, 315 struct device_attribute *attr, char *buf) 316 { 317 int i, len = 0; 318 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 319 struct srf08_data *data = iio_priv(indio_dev); 320 321 for (i = 0; i < data->chip_info->num_sensitivity_avail; i++) 322 if (data->chip_info->sensitivity_avail[i]) 323 len += sprintf(buf + len, "%d ", 324 data->chip_info->sensitivity_avail[i]); 325 326 len += sprintf(buf + len, "\n"); 327 328 return len; 329 } 330 331 static IIO_DEVICE_ATTR(sensor_sensitivity_available, S_IRUGO, 332 srf08_show_sensitivity_available, NULL, 0); 333 334 static ssize_t srf08_show_sensitivity(struct device *dev, 335 struct device_attribute *attr, char *buf) 336 { 337 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 338 struct srf08_data *data = iio_priv(indio_dev); 339 int len; 340 341 len = sprintf(buf, "%d\n", data->sensitivity); 342 343 return len; 344 } 345 346 static ssize_t srf08_write_sensitivity(struct srf08_data *data, 347 unsigned int val) 348 { 349 struct i2c_client *client = data->client; 350 int ret, i; 351 u8 regval; 352 353 if (!val) 354 return -EINVAL; 355 356 for (i = 0; i < data->chip_info->num_sensitivity_avail; i++) 357 if (val && (val == data->chip_info->sensitivity_avail[i])) { 358 regval = i; 359 break; 360 } 361 362 if (i >= data->chip_info->num_sensitivity_avail) 363 return -EINVAL; 364 365 mutex_lock(&data->lock); 366 367 ret = i2c_smbus_write_byte_data(client, SRF08_WRITE_MAX_GAIN, regval); 368 if (ret < 0) { 369 dev_err(&client->dev, "write_sensitivity - err: %d\n", ret); 370 mutex_unlock(&data->lock); 371 return ret; 372 } 373 374 data->sensitivity = val; 375 376 mutex_unlock(&data->lock); 377 378 return 0; 379 } 380 381 static ssize_t srf08_store_sensitivity(struct device *dev, 382 struct device_attribute *attr, 383 const char *buf, size_t len) 384 { 385 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 386 struct srf08_data *data = iio_priv(indio_dev); 387 int ret; 388 unsigned int val; 389 390 ret = kstrtouint(buf, 10, &val); 391 if (ret) 392 return ret; 393 394 ret = srf08_write_sensitivity(data, val); 395 if (ret < 0) 396 return ret; 397 398 return len; 399 } 400 401 static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR, 402 srf08_show_sensitivity, srf08_store_sensitivity, 0); 403 404 static struct attribute *srf08_attributes[] = { 405 &iio_dev_attr_sensor_max_range.dev_attr.attr, 406 &iio_dev_attr_sensor_max_range_available.dev_attr.attr, 407 &iio_dev_attr_sensor_sensitivity.dev_attr.attr, 408 &iio_dev_attr_sensor_sensitivity_available.dev_attr.attr, 409 NULL, 410 }; 411 412 static const struct attribute_group srf08_attribute_group = { 413 .attrs = srf08_attributes, 414 }; 415 416 static const struct iio_chan_spec srf08_channels[] = { 417 { 418 .type = IIO_DISTANCE, 419 .info_mask_separate = 420 BIT(IIO_CHAN_INFO_RAW) | 421 BIT(IIO_CHAN_INFO_SCALE), 422 .scan_index = 0, 423 .scan_type = { 424 .sign = 's', 425 .realbits = 16, 426 .storagebits = 16, 427 .endianness = IIO_CPU, 428 }, 429 }, 430 IIO_CHAN_SOFT_TIMESTAMP(1), 431 }; 432 433 static const struct iio_info srf08_info = { 434 .read_raw = srf08_read_raw, 435 .attrs = &srf08_attribute_group, 436 }; 437 438 /* 439 * srf02 don't have an adjustable range or sensitivity, 440 * so we don't need attributes at all 441 */ 442 static const struct iio_info srf02_info = { 443 .read_raw = srf08_read_raw, 444 }; 445 446 static int srf08_probe(struct i2c_client *client, 447 const struct i2c_device_id *id) 448 { 449 struct iio_dev *indio_dev; 450 struct srf08_data *data; 451 int ret; 452 453 if (!i2c_check_functionality(client->adapter, 454 I2C_FUNC_SMBUS_READ_BYTE_DATA | 455 I2C_FUNC_SMBUS_WRITE_BYTE_DATA | 456 I2C_FUNC_SMBUS_READ_WORD_DATA)) 457 return -ENODEV; 458 459 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 460 if (!indio_dev) 461 return -ENOMEM; 462 463 data = iio_priv(indio_dev); 464 i2c_set_clientdata(client, indio_dev); 465 data->client = client; 466 data->sensor_type = (enum srf08_sensor_type)id->driver_data; 467 468 switch (data->sensor_type) { 469 case SRF02: 470 data->chip_info = &srf02_chip_info; 471 indio_dev->info = &srf02_info; 472 break; 473 case SRF08: 474 data->chip_info = &srf08_chip_info; 475 indio_dev->info = &srf08_info; 476 break; 477 case SRF10: 478 data->chip_info = &srf10_chip_info; 479 indio_dev->info = &srf08_info; 480 break; 481 default: 482 return -EINVAL; 483 } 484 485 indio_dev->name = id->name; 486 indio_dev->modes = INDIO_DIRECT_MODE; 487 indio_dev->channels = srf08_channels; 488 indio_dev->num_channels = ARRAY_SIZE(srf08_channels); 489 490 mutex_init(&data->lock); 491 492 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, 493 iio_pollfunc_store_time, srf08_trigger_handler, NULL); 494 if (ret < 0) { 495 dev_err(&client->dev, "setup of iio triggered buffer failed\n"); 496 return ret; 497 } 498 499 if (data->chip_info->range_default) { 500 /* 501 * set default range of device in mm here 502 * these register values cannot be read from the hardware 503 * therefore set driver specific default values 504 * 505 * srf02 don't have a default value so it'll be omitted 506 */ 507 ret = srf08_write_range_mm(data, 508 data->chip_info->range_default); 509 if (ret < 0) 510 return ret; 511 } 512 513 if (data->chip_info->sensitivity_default) { 514 /* 515 * set default sensitivity of device here 516 * these register values cannot be read from the hardware 517 * therefore set driver specific default values 518 * 519 * srf02 don't have a default value so it'll be omitted 520 */ 521 ret = srf08_write_sensitivity(data, 522 data->chip_info->sensitivity_default); 523 if (ret < 0) 524 return ret; 525 } 526 527 return devm_iio_device_register(&client->dev, indio_dev); 528 } 529 530 static const struct of_device_id of_srf08_match[] = { 531 { .compatible = "devantech,srf02", (void *)SRF02}, 532 { .compatible = "devantech,srf08", (void *)SRF08}, 533 { .compatible = "devantech,srf10", (void *)SRF10}, 534 {}, 535 }; 536 537 MODULE_DEVICE_TABLE(of, of_srf08_match); 538 539 static const struct i2c_device_id srf08_id[] = { 540 { "srf02", SRF02 }, 541 { "srf08", SRF08 }, 542 { "srf10", SRF10 }, 543 { } 544 }; 545 MODULE_DEVICE_TABLE(i2c, srf08_id); 546 547 static struct i2c_driver srf08_driver = { 548 .driver = { 549 .name = "srf08", 550 .of_match_table = of_srf08_match, 551 }, 552 .probe = srf08_probe, 553 .id_table = srf08_id, 554 }; 555 module_i2c_driver(srf08_driver); 556 557 MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>"); 558 MODULE_DESCRIPTION("Devantech SRF02/SRF08/SRF10 i2c ultrasonic ranger driver"); 559 MODULE_LICENSE("GPL"); 560