1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * STMicroelectronics sensors core library driver 4 * 5 * Copyright 2012-2013 STMicroelectronics Inc. 6 * 7 * Denis Ciocca <denis.ciocca@st.com> 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include <linux/delay.h> 14 #include <linux/iio/iio.h> 15 #include <linux/mutex.h> 16 #include <linux/property.h> 17 #include <linux/regulator/consumer.h> 18 #include <linux/regmap.h> 19 #include <asm/unaligned.h> 20 #include <linux/iio/common/st_sensors.h> 21 22 #include "st_sensors_core.h" 23 24 int st_sensors_write_data_with_mask(struct iio_dev *indio_dev, 25 u8 reg_addr, u8 mask, u8 data) 26 { 27 struct st_sensor_data *sdata = iio_priv(indio_dev); 28 29 return regmap_update_bits(sdata->regmap, 30 reg_addr, mask, data << __ffs(mask)); 31 } 32 33 int st_sensors_debugfs_reg_access(struct iio_dev *indio_dev, 34 unsigned reg, unsigned writeval, 35 unsigned *readval) 36 { 37 struct st_sensor_data *sdata = iio_priv(indio_dev); 38 int err; 39 40 if (!readval) 41 return regmap_write(sdata->regmap, reg, writeval); 42 43 err = regmap_read(sdata->regmap, reg, readval); 44 if (err < 0) 45 return err; 46 47 return 0; 48 } 49 EXPORT_SYMBOL(st_sensors_debugfs_reg_access); 50 51 static int st_sensors_match_odr(struct st_sensor_settings *sensor_settings, 52 unsigned int odr, struct st_sensor_odr_avl *odr_out) 53 { 54 int i, ret = -EINVAL; 55 56 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) { 57 if (sensor_settings->odr.odr_avl[i].hz == 0) 58 goto st_sensors_match_odr_error; 59 60 if (sensor_settings->odr.odr_avl[i].hz == odr) { 61 odr_out->hz = sensor_settings->odr.odr_avl[i].hz; 62 odr_out->value = sensor_settings->odr.odr_avl[i].value; 63 ret = 0; 64 break; 65 } 66 } 67 68 st_sensors_match_odr_error: 69 return ret; 70 } 71 72 int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr) 73 { 74 int err; 75 struct st_sensor_odr_avl odr_out = {0, 0}; 76 struct st_sensor_data *sdata = iio_priv(indio_dev); 77 78 if (!sdata->sensor_settings->odr.mask) 79 return 0; 80 81 err = st_sensors_match_odr(sdata->sensor_settings, odr, &odr_out); 82 if (err < 0) 83 goto st_sensors_match_odr_error; 84 85 if ((sdata->sensor_settings->odr.addr == 86 sdata->sensor_settings->pw.addr) && 87 (sdata->sensor_settings->odr.mask == 88 sdata->sensor_settings->pw.mask)) { 89 if (sdata->enabled == true) { 90 err = st_sensors_write_data_with_mask(indio_dev, 91 sdata->sensor_settings->odr.addr, 92 sdata->sensor_settings->odr.mask, 93 odr_out.value); 94 } else { 95 err = 0; 96 } 97 } else { 98 err = st_sensors_write_data_with_mask(indio_dev, 99 sdata->sensor_settings->odr.addr, 100 sdata->sensor_settings->odr.mask, 101 odr_out.value); 102 } 103 if (err >= 0) 104 sdata->odr = odr_out.hz; 105 106 st_sensors_match_odr_error: 107 return err; 108 } 109 EXPORT_SYMBOL(st_sensors_set_odr); 110 111 static int st_sensors_match_fs(struct st_sensor_settings *sensor_settings, 112 unsigned int fs, int *index_fs_avl) 113 { 114 int i, ret = -EINVAL; 115 116 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) { 117 if (sensor_settings->fs.fs_avl[i].num == 0) 118 return ret; 119 120 if (sensor_settings->fs.fs_avl[i].num == fs) { 121 *index_fs_avl = i; 122 ret = 0; 123 break; 124 } 125 } 126 127 return ret; 128 } 129 130 static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs) 131 { 132 int err, i = 0; 133 struct st_sensor_data *sdata = iio_priv(indio_dev); 134 135 if (sdata->sensor_settings->fs.addr == 0) 136 return 0; 137 138 err = st_sensors_match_fs(sdata->sensor_settings, fs, &i); 139 if (err < 0) 140 goto st_accel_set_fullscale_error; 141 142 err = st_sensors_write_data_with_mask(indio_dev, 143 sdata->sensor_settings->fs.addr, 144 sdata->sensor_settings->fs.mask, 145 sdata->sensor_settings->fs.fs_avl[i].value); 146 if (err < 0) 147 goto st_accel_set_fullscale_error; 148 149 sdata->current_fullscale = &sdata->sensor_settings->fs.fs_avl[i]; 150 return err; 151 152 st_accel_set_fullscale_error: 153 dev_err(&indio_dev->dev, "failed to set new fullscale.\n"); 154 return err; 155 } 156 157 int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable) 158 { 159 u8 tmp_value; 160 int err = -EINVAL; 161 bool found = false; 162 struct st_sensor_odr_avl odr_out = {0, 0}; 163 struct st_sensor_data *sdata = iio_priv(indio_dev); 164 165 if (enable) { 166 tmp_value = sdata->sensor_settings->pw.value_on; 167 if ((sdata->sensor_settings->odr.addr == 168 sdata->sensor_settings->pw.addr) && 169 (sdata->sensor_settings->odr.mask == 170 sdata->sensor_settings->pw.mask)) { 171 err = st_sensors_match_odr(sdata->sensor_settings, 172 sdata->odr, &odr_out); 173 if (err < 0) 174 goto set_enable_error; 175 tmp_value = odr_out.value; 176 found = true; 177 } 178 err = st_sensors_write_data_with_mask(indio_dev, 179 sdata->sensor_settings->pw.addr, 180 sdata->sensor_settings->pw.mask, tmp_value); 181 if (err < 0) 182 goto set_enable_error; 183 184 sdata->enabled = true; 185 186 if (found) 187 sdata->odr = odr_out.hz; 188 } else { 189 err = st_sensors_write_data_with_mask(indio_dev, 190 sdata->sensor_settings->pw.addr, 191 sdata->sensor_settings->pw.mask, 192 sdata->sensor_settings->pw.value_off); 193 if (err < 0) 194 goto set_enable_error; 195 196 sdata->enabled = false; 197 } 198 199 set_enable_error: 200 return err; 201 } 202 EXPORT_SYMBOL(st_sensors_set_enable); 203 204 int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable) 205 { 206 struct st_sensor_data *sdata = iio_priv(indio_dev); 207 int err = 0; 208 209 if (sdata->sensor_settings->enable_axis.addr) 210 err = st_sensors_write_data_with_mask(indio_dev, 211 sdata->sensor_settings->enable_axis.addr, 212 sdata->sensor_settings->enable_axis.mask, 213 axis_enable); 214 return err; 215 } 216 EXPORT_SYMBOL(st_sensors_set_axis_enable); 217 218 static void st_reg_disable(void *reg) 219 { 220 regulator_disable(reg); 221 } 222 223 int st_sensors_power_enable(struct iio_dev *indio_dev) 224 { 225 struct st_sensor_data *pdata = iio_priv(indio_dev); 226 struct device *parent = indio_dev->dev.parent; 227 int err; 228 229 /* Regulators not mandatory, but if requested we should enable them. */ 230 pdata->vdd = devm_regulator_get(parent, "vdd"); 231 if (IS_ERR(pdata->vdd)) 232 return dev_err_probe(&indio_dev->dev, PTR_ERR(pdata->vdd), 233 "unable to get Vdd supply\n"); 234 235 err = regulator_enable(pdata->vdd); 236 if (err != 0) { 237 dev_warn(&indio_dev->dev, 238 "Failed to enable specified Vdd supply\n"); 239 return err; 240 } 241 242 err = devm_add_action_or_reset(parent, st_reg_disable, pdata->vdd); 243 if (err) 244 return err; 245 246 pdata->vdd_io = devm_regulator_get(parent, "vddio"); 247 if (IS_ERR(pdata->vdd_io)) 248 return dev_err_probe(&indio_dev->dev, PTR_ERR(pdata->vdd_io), 249 "unable to get Vdd_IO supply\n"); 250 251 err = regulator_enable(pdata->vdd_io); 252 if (err != 0) { 253 dev_warn(&indio_dev->dev, 254 "Failed to enable specified Vdd_IO supply\n"); 255 return err; 256 } 257 258 return devm_add_action_or_reset(parent, st_reg_disable, pdata->vdd_io); 259 } 260 EXPORT_SYMBOL(st_sensors_power_enable); 261 262 static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev, 263 struct st_sensors_platform_data *pdata) 264 { 265 struct st_sensor_data *sdata = iio_priv(indio_dev); 266 267 /* Sensor does not support interrupts */ 268 if (!sdata->sensor_settings->drdy_irq.int1.addr && 269 !sdata->sensor_settings->drdy_irq.int2.addr) { 270 if (pdata->drdy_int_pin) 271 dev_info(&indio_dev->dev, 272 "DRDY on pin INT%d specified, but sensor does not support interrupts\n", 273 pdata->drdy_int_pin); 274 return 0; 275 } 276 277 switch (pdata->drdy_int_pin) { 278 case 1: 279 if (!sdata->sensor_settings->drdy_irq.int1.mask) { 280 dev_err(&indio_dev->dev, 281 "DRDY on INT1 not available.\n"); 282 return -EINVAL; 283 } 284 sdata->drdy_int_pin = 1; 285 break; 286 case 2: 287 if (!sdata->sensor_settings->drdy_irq.int2.mask) { 288 dev_err(&indio_dev->dev, 289 "DRDY on INT2 not available.\n"); 290 return -EINVAL; 291 } 292 sdata->drdy_int_pin = 2; 293 break; 294 default: 295 dev_err(&indio_dev->dev, "DRDY on pdata not valid.\n"); 296 return -EINVAL; 297 } 298 299 if (pdata->open_drain) { 300 if (!sdata->sensor_settings->drdy_irq.int1.addr_od && 301 !sdata->sensor_settings->drdy_irq.int2.addr_od) 302 dev_err(&indio_dev->dev, 303 "open drain requested but unsupported.\n"); 304 else 305 sdata->int_pin_open_drain = true; 306 } 307 308 return 0; 309 } 310 311 static struct st_sensors_platform_data *st_sensors_dev_probe(struct device *dev, 312 struct st_sensors_platform_data *defdata) 313 { 314 struct st_sensors_platform_data *pdata; 315 u32 val; 316 317 if (!dev_fwnode(dev)) 318 return NULL; 319 320 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 321 if (!pdata) 322 return ERR_PTR(-ENOMEM); 323 if (!device_property_read_u32(dev, "st,drdy-int-pin", &val) && (val <= 2)) 324 pdata->drdy_int_pin = (u8) val; 325 else 326 pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 0; 327 328 pdata->open_drain = device_property_read_bool(dev, "drive-open-drain"); 329 330 return pdata; 331 } 332 333 /** 334 * st_sensors_dev_name_probe() - device probe for ST sensor name 335 * @dev: driver model representation of the device. 336 * @name: device name buffer reference. 337 * @len: device name buffer length. 338 * 339 * In effect this function matches an ID to an internal kernel 340 * name for a certain sensor device, so that the rest of the autodetection can 341 * rely on that name from this point on. I2C/SPI devices will be renamed 342 * to match the internal kernel convention. 343 */ 344 void st_sensors_dev_name_probe(struct device *dev, char *name, int len) 345 { 346 const void *match; 347 348 match = device_get_match_data(dev); 349 if (!match) 350 return; 351 352 /* The name from the match takes precedence if present */ 353 strlcpy(name, match, len); 354 } 355 EXPORT_SYMBOL(st_sensors_dev_name_probe); 356 357 int st_sensors_init_sensor(struct iio_dev *indio_dev, 358 struct st_sensors_platform_data *pdata) 359 { 360 struct st_sensor_data *sdata = iio_priv(indio_dev); 361 struct st_sensors_platform_data *of_pdata; 362 int err = 0; 363 364 /* If OF/DT pdata exists, it will take precedence of anything else */ 365 of_pdata = st_sensors_dev_probe(indio_dev->dev.parent, pdata); 366 if (IS_ERR(of_pdata)) 367 return PTR_ERR(of_pdata); 368 if (of_pdata) 369 pdata = of_pdata; 370 371 if (pdata) { 372 err = st_sensors_set_drdy_int_pin(indio_dev, pdata); 373 if (err < 0) 374 return err; 375 } 376 377 err = st_sensors_set_enable(indio_dev, false); 378 if (err < 0) 379 return err; 380 381 /* Disable DRDY, this might be still be enabled after reboot. */ 382 err = st_sensors_set_dataready_irq(indio_dev, false); 383 if (err < 0) 384 return err; 385 386 if (sdata->current_fullscale) { 387 err = st_sensors_set_fullscale(indio_dev, 388 sdata->current_fullscale->num); 389 if (err < 0) 390 return err; 391 } else 392 dev_info(&indio_dev->dev, "Full-scale not possible\n"); 393 394 err = st_sensors_set_odr(indio_dev, sdata->odr); 395 if (err < 0) 396 return err; 397 398 /* set BDU */ 399 if (sdata->sensor_settings->bdu.addr) { 400 err = st_sensors_write_data_with_mask(indio_dev, 401 sdata->sensor_settings->bdu.addr, 402 sdata->sensor_settings->bdu.mask, true); 403 if (err < 0) 404 return err; 405 } 406 407 /* set DAS */ 408 if (sdata->sensor_settings->das.addr) { 409 err = st_sensors_write_data_with_mask(indio_dev, 410 sdata->sensor_settings->das.addr, 411 sdata->sensor_settings->das.mask, 1); 412 if (err < 0) 413 return err; 414 } 415 416 if (sdata->int_pin_open_drain) { 417 u8 addr, mask; 418 419 if (sdata->drdy_int_pin == 1) { 420 addr = sdata->sensor_settings->drdy_irq.int1.addr_od; 421 mask = sdata->sensor_settings->drdy_irq.int1.mask_od; 422 } else { 423 addr = sdata->sensor_settings->drdy_irq.int2.addr_od; 424 mask = sdata->sensor_settings->drdy_irq.int2.mask_od; 425 } 426 427 dev_info(&indio_dev->dev, 428 "set interrupt line to open drain mode on pin %d\n", 429 sdata->drdy_int_pin); 430 err = st_sensors_write_data_with_mask(indio_dev, addr, 431 mask, 1); 432 if (err < 0) 433 return err; 434 } 435 436 err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS); 437 438 return err; 439 } 440 EXPORT_SYMBOL(st_sensors_init_sensor); 441 442 int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable) 443 { 444 int err; 445 u8 drdy_addr, drdy_mask; 446 struct st_sensor_data *sdata = iio_priv(indio_dev); 447 448 if (!sdata->sensor_settings->drdy_irq.int1.addr && 449 !sdata->sensor_settings->drdy_irq.int2.addr) { 450 /* 451 * there are some devices (e.g. LIS3MDL) where drdy line is 452 * routed to a given pin and it is not possible to select a 453 * different one. Take into account irq status register 454 * to understand if irq trigger can be properly supported 455 */ 456 if (sdata->sensor_settings->drdy_irq.stat_drdy.addr) 457 sdata->hw_irq_trigger = enable; 458 return 0; 459 } 460 461 /* Enable/Disable the interrupt generator 1. */ 462 if (sdata->sensor_settings->drdy_irq.ig1.en_addr > 0) { 463 err = st_sensors_write_data_with_mask(indio_dev, 464 sdata->sensor_settings->drdy_irq.ig1.en_addr, 465 sdata->sensor_settings->drdy_irq.ig1.en_mask, 466 (int)enable); 467 if (err < 0) 468 goto st_accel_set_dataready_irq_error; 469 } 470 471 if (sdata->drdy_int_pin == 1) { 472 drdy_addr = sdata->sensor_settings->drdy_irq.int1.addr; 473 drdy_mask = sdata->sensor_settings->drdy_irq.int1.mask; 474 } else { 475 drdy_addr = sdata->sensor_settings->drdy_irq.int2.addr; 476 drdy_mask = sdata->sensor_settings->drdy_irq.int2.mask; 477 } 478 479 /* Flag to the poll function that the hardware trigger is in use */ 480 sdata->hw_irq_trigger = enable; 481 482 /* Enable/Disable the interrupt generator for data ready. */ 483 err = st_sensors_write_data_with_mask(indio_dev, drdy_addr, 484 drdy_mask, (int)enable); 485 486 st_accel_set_dataready_irq_error: 487 return err; 488 } 489 EXPORT_SYMBOL(st_sensors_set_dataready_irq); 490 491 int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale) 492 { 493 int err = -EINVAL, i; 494 struct st_sensor_data *sdata = iio_priv(indio_dev); 495 496 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) { 497 if ((sdata->sensor_settings->fs.fs_avl[i].gain == scale) && 498 (sdata->sensor_settings->fs.fs_avl[i].gain != 0)) { 499 err = 0; 500 break; 501 } 502 } 503 if (err < 0) 504 goto st_sensors_match_scale_error; 505 506 err = st_sensors_set_fullscale(indio_dev, 507 sdata->sensor_settings->fs.fs_avl[i].num); 508 509 st_sensors_match_scale_error: 510 return err; 511 } 512 EXPORT_SYMBOL(st_sensors_set_fullscale_by_gain); 513 514 static int st_sensors_read_axis_data(struct iio_dev *indio_dev, 515 struct iio_chan_spec const *ch, int *data) 516 { 517 int err; 518 u8 *outdata; 519 struct st_sensor_data *sdata = iio_priv(indio_dev); 520 unsigned int byte_for_channel; 521 522 byte_for_channel = DIV_ROUND_UP(ch->scan_type.realbits + 523 ch->scan_type.shift, 8); 524 outdata = kmalloc(byte_for_channel, GFP_DMA | GFP_KERNEL); 525 if (!outdata) 526 return -ENOMEM; 527 528 err = regmap_bulk_read(sdata->regmap, ch->address, 529 outdata, byte_for_channel); 530 if (err < 0) 531 goto st_sensors_free_memory; 532 533 if (byte_for_channel == 1) 534 *data = (s8)*outdata; 535 else if (byte_for_channel == 2) 536 *data = (s16)get_unaligned_le16(outdata); 537 else if (byte_for_channel == 3) 538 *data = (s32)sign_extend32(get_unaligned_le24(outdata), 23); 539 540 st_sensors_free_memory: 541 kfree(outdata); 542 543 return err; 544 } 545 546 int st_sensors_read_info_raw(struct iio_dev *indio_dev, 547 struct iio_chan_spec const *ch, int *val) 548 { 549 int err; 550 struct st_sensor_data *sdata = iio_priv(indio_dev); 551 552 mutex_lock(&indio_dev->mlock); 553 if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) { 554 err = -EBUSY; 555 goto out; 556 } else { 557 err = st_sensors_set_enable(indio_dev, true); 558 if (err < 0) 559 goto out; 560 561 msleep((sdata->sensor_settings->bootime * 1000) / sdata->odr); 562 err = st_sensors_read_axis_data(indio_dev, ch, val); 563 if (err < 0) 564 goto out; 565 566 *val = *val >> ch->scan_type.shift; 567 568 err = st_sensors_set_enable(indio_dev, false); 569 } 570 out: 571 mutex_unlock(&indio_dev->mlock); 572 573 return err; 574 } 575 EXPORT_SYMBOL(st_sensors_read_info_raw); 576 577 /* 578 * st_sensors_get_settings_index() - get index of the sensor settings for a 579 * specific device from list of settings 580 * @name: device name buffer reference. 581 * @list: sensor settings list. 582 * @list_length: length of sensor settings list. 583 * 584 * Return: non negative number on success (valid index), 585 * negative error code otherwise. 586 */ 587 int st_sensors_get_settings_index(const char *name, 588 const struct st_sensor_settings *list, 589 const int list_length) 590 { 591 int i, n; 592 593 for (i = 0; i < list_length; i++) { 594 for (n = 0; n < ST_SENSORS_MAX_4WAI; n++) { 595 if (strcmp(name, list[i].sensors_supported[n]) == 0) 596 return i; 597 } 598 } 599 600 return -ENODEV; 601 } 602 EXPORT_SYMBOL(st_sensors_get_settings_index); 603 604 /* 605 * st_sensors_verify_id() - verify sensor ID (WhoAmI) is matching with the 606 * expected value 607 * @indio_dev: IIO device reference. 608 * 609 * Return: 0 on success (valid sensor ID), else a negative error code. 610 */ 611 int st_sensors_verify_id(struct iio_dev *indio_dev) 612 { 613 struct st_sensor_data *sdata = iio_priv(indio_dev); 614 int wai, err; 615 616 if (sdata->sensor_settings->wai_addr) { 617 err = regmap_read(sdata->regmap, 618 sdata->sensor_settings->wai_addr, &wai); 619 if (err < 0) { 620 dev_err(&indio_dev->dev, 621 "failed to read Who-Am-I register.\n"); 622 return err; 623 } 624 625 if (sdata->sensor_settings->wai != wai) { 626 dev_err(&indio_dev->dev, 627 "%s: WhoAmI mismatch (0x%x).\n", 628 indio_dev->name, wai); 629 return -EINVAL; 630 } 631 } 632 633 return 0; 634 } 635 EXPORT_SYMBOL(st_sensors_verify_id); 636 637 ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev, 638 struct device_attribute *attr, char *buf) 639 { 640 int i, len = 0; 641 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 642 struct st_sensor_data *sdata = iio_priv(indio_dev); 643 644 mutex_lock(&indio_dev->mlock); 645 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) { 646 if (sdata->sensor_settings->odr.odr_avl[i].hz == 0) 647 break; 648 649 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", 650 sdata->sensor_settings->odr.odr_avl[i].hz); 651 } 652 mutex_unlock(&indio_dev->mlock); 653 buf[len - 1] = '\n'; 654 655 return len; 656 } 657 EXPORT_SYMBOL(st_sensors_sysfs_sampling_frequency_avail); 658 659 ssize_t st_sensors_sysfs_scale_avail(struct device *dev, 660 struct device_attribute *attr, char *buf) 661 { 662 int i, len = 0, q, r; 663 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 664 struct st_sensor_data *sdata = iio_priv(indio_dev); 665 666 mutex_lock(&indio_dev->mlock); 667 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) { 668 if (sdata->sensor_settings->fs.fs_avl[i].num == 0) 669 break; 670 671 q = sdata->sensor_settings->fs.fs_avl[i].gain / 1000000; 672 r = sdata->sensor_settings->fs.fs_avl[i].gain % 1000000; 673 674 len += scnprintf(buf + len, PAGE_SIZE - len, "%u.%06u ", q, r); 675 } 676 mutex_unlock(&indio_dev->mlock); 677 buf[len - 1] = '\n'; 678 679 return len; 680 } 681 EXPORT_SYMBOL(st_sensors_sysfs_scale_avail); 682 683 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 684 MODULE_DESCRIPTION("STMicroelectronics ST-sensors core"); 685 MODULE_LICENSE("GPL v2"); 686