1 /* 2 * AD7879/AD7889 based touchscreen and GPIO driver 3 * 4 * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc. 5 * 6 * Licensed under the GPL-2 or later. 7 * 8 * History: 9 * Copyright (c) 2005 David Brownell 10 * Copyright (c) 2006 Nokia Corporation 11 * Various changes: Imre Deak <imre.deak@nokia.com> 12 * 13 * Using code from: 14 * - corgi_ts.c 15 * Copyright (C) 2004-2005 Richard Purdie 16 * - omap_ts.[hc], ads7846.h, ts_osk.c 17 * Copyright (C) 2002 MontaVista Software 18 * Copyright (C) 2004 Texas Instruments 19 * Copyright (C) 2005 Dirk Behme 20 * - ad7877.c 21 * Copyright (C) 2006-2008 Analog Devices Inc. 22 */ 23 24 #include <linux/device.h> 25 #include <linux/delay.h> 26 #include <linux/input.h> 27 #include <linux/interrupt.h> 28 #include <linux/irq.h> 29 #include <linux/property.h> 30 #include <linux/regmap.h> 31 #include <linux/slab.h> 32 #include <linux/gpio.h> 33 34 #include <linux/input/touchscreen.h> 35 #include <linux/platform_data/ad7879.h> 36 #include <linux/module.h> 37 #include "ad7879.h" 38 39 #define AD7879_REG_ZEROS 0 40 #define AD7879_REG_CTRL1 1 41 #define AD7879_REG_CTRL2 2 42 #define AD7879_REG_CTRL3 3 43 #define AD7879_REG_AUX1HIGH 4 44 #define AD7879_REG_AUX1LOW 5 45 #define AD7879_REG_TEMP1HIGH 6 46 #define AD7879_REG_TEMP1LOW 7 47 #define AD7879_REG_XPLUS 8 48 #define AD7879_REG_YPLUS 9 49 #define AD7879_REG_Z1 10 50 #define AD7879_REG_Z2 11 51 #define AD7879_REG_AUXVBAT 12 52 #define AD7879_REG_TEMP 13 53 #define AD7879_REG_REVID 14 54 55 /* Control REG 1 */ 56 #define AD7879_TMR(x) ((x & 0xFF) << 0) 57 #define AD7879_ACQ(x) ((x & 0x3) << 8) 58 #define AD7879_MODE_NOC (0 << 10) /* Do not convert */ 59 #define AD7879_MODE_SCC (1 << 10) /* Single channel conversion */ 60 #define AD7879_MODE_SEQ0 (2 << 10) /* Sequence 0 in Slave Mode */ 61 #define AD7879_MODE_SEQ1 (3 << 10) /* Sequence 1 in Master Mode */ 62 #define AD7879_MODE_INT (1 << 15) /* PENIRQ disabled INT enabled */ 63 64 /* Control REG 2 */ 65 #define AD7879_FCD(x) ((x & 0x3) << 0) 66 #define AD7879_RESET (1 << 4) 67 #define AD7879_MFS(x) ((x & 0x3) << 5) 68 #define AD7879_AVG(x) ((x & 0x3) << 7) 69 #define AD7879_SER (1 << 9) /* non-differential */ 70 #define AD7879_DFR (0 << 9) /* differential */ 71 #define AD7879_GPIOPOL (1 << 10) 72 #define AD7879_GPIODIR (1 << 11) 73 #define AD7879_GPIO_DATA (1 << 12) 74 #define AD7879_GPIO_EN (1 << 13) 75 #define AD7879_PM(x) ((x & 0x3) << 14) 76 #define AD7879_PM_SHUTDOWN (0) 77 #define AD7879_PM_DYN (1) 78 #define AD7879_PM_FULLON (2) 79 80 /* Control REG 3 */ 81 #define AD7879_TEMPMASK_BIT (1<<15) 82 #define AD7879_AUXVBATMASK_BIT (1<<14) 83 #define AD7879_INTMODE_BIT (1<<13) 84 #define AD7879_GPIOALERTMASK_BIT (1<<12) 85 #define AD7879_AUXLOW_BIT (1<<11) 86 #define AD7879_AUXHIGH_BIT (1<<10) 87 #define AD7879_TEMPLOW_BIT (1<<9) 88 #define AD7879_TEMPHIGH_BIT (1<<8) 89 #define AD7879_YPLUS_BIT (1<<7) 90 #define AD7879_XPLUS_BIT (1<<6) 91 #define AD7879_Z1_BIT (1<<5) 92 #define AD7879_Z2_BIT (1<<4) 93 #define AD7879_AUX_BIT (1<<3) 94 #define AD7879_VBAT_BIT (1<<2) 95 #define AD7879_TEMP_BIT (1<<1) 96 97 enum { 98 AD7879_SEQ_YPOS = 0, 99 AD7879_SEQ_XPOS = 1, 100 AD7879_SEQ_Z1 = 2, 101 AD7879_SEQ_Z2 = 3, 102 AD7879_NR_SENSE = 4, 103 }; 104 105 #define MAX_12BIT ((1<<12)-1) 106 #define TS_PEN_UP_TIMEOUT msecs_to_jiffies(50) 107 108 struct ad7879 { 109 struct regmap *regmap; 110 struct device *dev; 111 struct input_dev *input; 112 struct timer_list timer; 113 #ifdef CONFIG_GPIOLIB 114 struct gpio_chip gc; 115 struct mutex mutex; 116 #endif 117 unsigned int irq; 118 bool disabled; /* P: input->mutex */ 119 bool suspended; /* P: input->mutex */ 120 bool swap_xy; 121 u16 conversion_data[AD7879_NR_SENSE]; 122 char phys[32]; 123 u8 first_conversion_delay; 124 u8 acquisition_time; 125 u8 averaging; 126 u8 pen_down_acc_interval; 127 u8 median; 128 u16 x_plate_ohms; 129 u16 cmd_crtl1; 130 u16 cmd_crtl2; 131 u16 cmd_crtl3; 132 int x; 133 int y; 134 int Rt; 135 }; 136 137 static int ad7879_read(struct ad7879 *ts, u8 reg) 138 { 139 unsigned int val; 140 int error; 141 142 error = regmap_read(ts->regmap, reg, &val); 143 if (error) { 144 dev_err(ts->dev, "failed to read register %#02x: %d\n", 145 reg, error); 146 return error; 147 } 148 149 return val; 150 } 151 152 static int ad7879_write(struct ad7879 *ts, u8 reg, u16 val) 153 { 154 int error; 155 156 error = regmap_write(ts->regmap, reg, val); 157 if (error) { 158 dev_err(ts->dev, 159 "failed to write %#04x to register %#02x: %d\n", 160 val, reg, error); 161 return error; 162 } 163 164 return 0; 165 } 166 167 static int ad7879_report(struct ad7879 *ts) 168 { 169 struct input_dev *input_dev = ts->input; 170 unsigned Rt; 171 u16 x, y, z1, z2; 172 173 x = ts->conversion_data[AD7879_SEQ_XPOS] & MAX_12BIT; 174 y = ts->conversion_data[AD7879_SEQ_YPOS] & MAX_12BIT; 175 z1 = ts->conversion_data[AD7879_SEQ_Z1] & MAX_12BIT; 176 z2 = ts->conversion_data[AD7879_SEQ_Z2] & MAX_12BIT; 177 178 if (ts->swap_xy) 179 swap(x, y); 180 181 /* 182 * The samples processed here are already preprocessed by the AD7879. 183 * The preprocessing function consists of a median and an averaging 184 * filter. The combination of these two techniques provides a robust 185 * solution, discarding the spurious noise in the signal and keeping 186 * only the data of interest. The size of both filters is 187 * programmable. (dev.platform_data, see linux/platform_data/ad7879.h) 188 * Other user-programmable conversion controls include variable 189 * acquisition time, and first conversion delay. Up to 16 averages can 190 * be taken per conversion. 191 */ 192 193 if (likely(x && z1)) { 194 /* compute touch pressure resistance using equation #1 */ 195 Rt = (z2 - z1) * x * ts->x_plate_ohms; 196 Rt /= z1; 197 Rt = (Rt + 2047) >> 12; 198 199 /* 200 * Sample found inconsistent, pressure is beyond 201 * the maximum. Don't report it to user space. 202 */ 203 if (Rt > input_abs_get_max(input_dev, ABS_PRESSURE)) 204 return -EINVAL; 205 206 /* 207 * Note that we delay reporting events by one sample. 208 * This is done to avoid reporting last sample of the 209 * touch sequence, which may be incomplete if finger 210 * leaves the surface before last reading is taken. 211 */ 212 if (timer_pending(&ts->timer)) { 213 /* Touch continues */ 214 input_report_key(input_dev, BTN_TOUCH, 1); 215 input_report_abs(input_dev, ABS_X, ts->x); 216 input_report_abs(input_dev, ABS_Y, ts->y); 217 input_report_abs(input_dev, ABS_PRESSURE, ts->Rt); 218 input_sync(input_dev); 219 } 220 221 ts->x = x; 222 ts->y = y; 223 ts->Rt = Rt; 224 225 return 0; 226 } 227 228 return -EINVAL; 229 } 230 231 static void ad7879_ts_event_release(struct ad7879 *ts) 232 { 233 struct input_dev *input_dev = ts->input; 234 235 input_report_abs(input_dev, ABS_PRESSURE, 0); 236 input_report_key(input_dev, BTN_TOUCH, 0); 237 input_sync(input_dev); 238 } 239 240 static void ad7879_timer(unsigned long handle) 241 { 242 struct ad7879 *ts = (void *)handle; 243 244 ad7879_ts_event_release(ts); 245 } 246 247 static irqreturn_t ad7879_irq(int irq, void *handle) 248 { 249 struct ad7879 *ts = handle; 250 251 regmap_bulk_read(ts->regmap, AD7879_REG_XPLUS, 252 ts->conversion_data, AD7879_NR_SENSE); 253 254 if (!ad7879_report(ts)) 255 mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT); 256 257 return IRQ_HANDLED; 258 } 259 260 static void __ad7879_enable(struct ad7879 *ts) 261 { 262 ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2); 263 ad7879_write(ts, AD7879_REG_CTRL3, ts->cmd_crtl3); 264 ad7879_write(ts, AD7879_REG_CTRL1, ts->cmd_crtl1); 265 266 enable_irq(ts->irq); 267 } 268 269 static void __ad7879_disable(struct ad7879 *ts) 270 { 271 u16 reg = (ts->cmd_crtl2 & ~AD7879_PM(-1)) | 272 AD7879_PM(AD7879_PM_SHUTDOWN); 273 disable_irq(ts->irq); 274 275 if (del_timer_sync(&ts->timer)) 276 ad7879_ts_event_release(ts); 277 278 ad7879_write(ts, AD7879_REG_CTRL2, reg); 279 } 280 281 282 static int ad7879_open(struct input_dev *input) 283 { 284 struct ad7879 *ts = input_get_drvdata(input); 285 286 /* protected by input->mutex */ 287 if (!ts->disabled && !ts->suspended) 288 __ad7879_enable(ts); 289 290 return 0; 291 } 292 293 static void ad7879_close(struct input_dev* input) 294 { 295 struct ad7879 *ts = input_get_drvdata(input); 296 297 /* protected by input->mutex */ 298 if (!ts->disabled && !ts->suspended) 299 __ad7879_disable(ts); 300 } 301 302 static int __maybe_unused ad7879_suspend(struct device *dev) 303 { 304 struct ad7879 *ts = dev_get_drvdata(dev); 305 306 mutex_lock(&ts->input->mutex); 307 308 if (!ts->suspended && !ts->disabled && ts->input->users) 309 __ad7879_disable(ts); 310 311 ts->suspended = true; 312 313 mutex_unlock(&ts->input->mutex); 314 315 return 0; 316 } 317 318 static int __maybe_unused ad7879_resume(struct device *dev) 319 { 320 struct ad7879 *ts = dev_get_drvdata(dev); 321 322 mutex_lock(&ts->input->mutex); 323 324 if (ts->suspended && !ts->disabled && ts->input->users) 325 __ad7879_enable(ts); 326 327 ts->suspended = false; 328 329 mutex_unlock(&ts->input->mutex); 330 331 return 0; 332 } 333 334 SIMPLE_DEV_PM_OPS(ad7879_pm_ops, ad7879_suspend, ad7879_resume); 335 EXPORT_SYMBOL(ad7879_pm_ops); 336 337 static void ad7879_toggle(struct ad7879 *ts, bool disable) 338 { 339 mutex_lock(&ts->input->mutex); 340 341 if (!ts->suspended && ts->input->users != 0) { 342 343 if (disable) { 344 if (ts->disabled) 345 __ad7879_enable(ts); 346 } else { 347 if (!ts->disabled) 348 __ad7879_disable(ts); 349 } 350 } 351 352 ts->disabled = disable; 353 354 mutex_unlock(&ts->input->mutex); 355 } 356 357 static ssize_t ad7879_disable_show(struct device *dev, 358 struct device_attribute *attr, char *buf) 359 { 360 struct ad7879 *ts = dev_get_drvdata(dev); 361 362 return sprintf(buf, "%u\n", ts->disabled); 363 } 364 365 static ssize_t ad7879_disable_store(struct device *dev, 366 struct device_attribute *attr, 367 const char *buf, size_t count) 368 { 369 struct ad7879 *ts = dev_get_drvdata(dev); 370 unsigned int val; 371 int error; 372 373 error = kstrtouint(buf, 10, &val); 374 if (error) 375 return error; 376 377 ad7879_toggle(ts, val); 378 379 return count; 380 } 381 382 static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store); 383 384 static struct attribute *ad7879_attributes[] = { 385 &dev_attr_disable.attr, 386 NULL 387 }; 388 389 static const struct attribute_group ad7879_attr_group = { 390 .attrs = ad7879_attributes, 391 }; 392 393 #ifdef CONFIG_GPIOLIB 394 static int ad7879_gpio_direction_input(struct gpio_chip *chip, 395 unsigned gpio) 396 { 397 struct ad7879 *ts = gpiochip_get_data(chip); 398 int err; 399 400 mutex_lock(&ts->mutex); 401 ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL; 402 err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2); 403 mutex_unlock(&ts->mutex); 404 405 return err; 406 } 407 408 static int ad7879_gpio_direction_output(struct gpio_chip *chip, 409 unsigned gpio, int level) 410 { 411 struct ad7879 *ts = gpiochip_get_data(chip); 412 int err; 413 414 mutex_lock(&ts->mutex); 415 ts->cmd_crtl2 &= ~AD7879_GPIODIR; 416 ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL; 417 if (level) 418 ts->cmd_crtl2 |= AD7879_GPIO_DATA; 419 else 420 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA; 421 422 err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2); 423 mutex_unlock(&ts->mutex); 424 425 return err; 426 } 427 428 static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio) 429 { 430 struct ad7879 *ts = gpiochip_get_data(chip); 431 u16 val; 432 433 mutex_lock(&ts->mutex); 434 val = ad7879_read(ts, AD7879_REG_CTRL2); 435 mutex_unlock(&ts->mutex); 436 437 return !!(val & AD7879_GPIO_DATA); 438 } 439 440 static void ad7879_gpio_set_value(struct gpio_chip *chip, 441 unsigned gpio, int value) 442 { 443 struct ad7879 *ts = gpiochip_get_data(chip); 444 445 mutex_lock(&ts->mutex); 446 if (value) 447 ts->cmd_crtl2 |= AD7879_GPIO_DATA; 448 else 449 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA; 450 451 ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2); 452 mutex_unlock(&ts->mutex); 453 } 454 455 static int ad7879_gpio_add(struct ad7879 *ts, 456 const struct ad7879_platform_data *pdata) 457 { 458 bool gpio_export; 459 int gpio_base; 460 int ret = 0; 461 462 if (pdata) { 463 gpio_export = pdata->gpio_export; 464 gpio_base = pdata->gpio_base; 465 } else { 466 gpio_export = device_property_read_bool(ts->dev, 467 "gpio-controller"); 468 gpio_base = -1; 469 } 470 471 mutex_init(&ts->mutex); 472 473 if (gpio_export) { 474 ts->gc.direction_input = ad7879_gpio_direction_input; 475 ts->gc.direction_output = ad7879_gpio_direction_output; 476 ts->gc.get = ad7879_gpio_get_value; 477 ts->gc.set = ad7879_gpio_set_value; 478 ts->gc.can_sleep = 1; 479 ts->gc.base = gpio_base; 480 ts->gc.ngpio = 1; 481 ts->gc.label = "AD7879-GPIO"; 482 ts->gc.owner = THIS_MODULE; 483 ts->gc.parent = ts->dev; 484 485 ret = devm_gpiochip_add_data(ts->dev, &ts->gc, ts); 486 if (ret) 487 dev_err(ts->dev, "failed to register gpio %d\n", 488 ts->gc.base); 489 } 490 491 return ret; 492 } 493 #else 494 static int ad7879_gpio_add(struct ad7879 *ts, 495 const struct ad7879_platform_data *pdata) 496 { 497 return 0; 498 } 499 #endif 500 501 static int ad7879_parse_dt(struct device *dev, struct ad7879 *ts) 502 { 503 int err; 504 u32 tmp; 505 506 err = device_property_read_u32(dev, "adi,resistance-plate-x", &tmp); 507 if (err) { 508 dev_err(dev, "failed to get resistance-plate-x property\n"); 509 return err; 510 } 511 ts->x_plate_ohms = (u16)tmp; 512 513 device_property_read_u8(dev, "adi,first-conversion-delay", 514 &ts->first_conversion_delay); 515 device_property_read_u8(dev, "adi,acquisition-time", 516 &ts->acquisition_time); 517 device_property_read_u8(dev, "adi,median-filter-size", &ts->median); 518 device_property_read_u8(dev, "adi,averaging", &ts->averaging); 519 device_property_read_u8(dev, "adi,conversion-interval", 520 &ts->pen_down_acc_interval); 521 522 ts->swap_xy = device_property_read_bool(dev, "touchscreen-swapped-x-y"); 523 524 return 0; 525 } 526 527 static void ad7879_cleanup_sysfs(void *_ts) 528 { 529 struct ad7879 *ts = _ts; 530 531 sysfs_remove_group(&ts->dev->kobj, &ad7879_attr_group); 532 } 533 534 int ad7879_probe(struct device *dev, struct regmap *regmap, 535 int irq, u16 bustype, u8 devid) 536 { 537 struct ad7879_platform_data *pdata = dev_get_platdata(dev); 538 struct ad7879 *ts; 539 struct input_dev *input_dev; 540 int err; 541 u16 revid; 542 543 if (irq <= 0) { 544 dev_err(dev, "No IRQ specified\n"); 545 return -EINVAL; 546 } 547 548 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); 549 if (!ts) 550 return -ENOMEM; 551 552 if (pdata) { 553 /* Platform data use swapped axis (backward compatibility) */ 554 ts->swap_xy = !pdata->swap_xy; 555 556 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; 557 558 ts->first_conversion_delay = pdata->first_conversion_delay; 559 ts->acquisition_time = pdata->acquisition_time; 560 ts->averaging = pdata->averaging; 561 ts->pen_down_acc_interval = pdata->pen_down_acc_interval; 562 ts->median = pdata->median; 563 } else { 564 err = ad7879_parse_dt(dev, ts); 565 if (err) 566 return err; 567 } 568 569 input_dev = devm_input_allocate_device(dev); 570 if (!input_dev) { 571 dev_err(dev, "Failed to allocate input device\n"); 572 return -ENOMEM; 573 } 574 575 ts->dev = dev; 576 ts->input = input_dev; 577 ts->irq = irq; 578 ts->regmap = regmap; 579 580 setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts); 581 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev)); 582 583 input_dev->name = "AD7879 Touchscreen"; 584 input_dev->phys = ts->phys; 585 input_dev->dev.parent = dev; 586 input_dev->id.bustype = bustype; 587 588 input_dev->open = ad7879_open; 589 input_dev->close = ad7879_close; 590 591 input_set_drvdata(input_dev, ts); 592 593 input_set_capability(input_dev, EV_KEY, BTN_TOUCH); 594 595 if (pdata) { 596 input_set_abs_params(input_dev, ABS_X, 597 pdata->x_min ? : 0, 598 pdata->x_max ? : MAX_12BIT, 599 0, 0); 600 input_set_abs_params(input_dev, ABS_Y, 601 pdata->y_min ? : 0, 602 pdata->y_max ? : MAX_12BIT, 603 0, 0); 604 input_set_abs_params(input_dev, ABS_PRESSURE, 605 pdata->pressure_min, 606 pdata->pressure_max ? : ~0, 607 0, 0); 608 } else { 609 input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0); 610 input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0); 611 input_set_capability(input_dev, EV_ABS, ABS_PRESSURE); 612 touchscreen_parse_properties(input_dev, false, NULL); 613 if (!input_abs_get_max(input_dev, ABS_PRESSURE)) { 614 dev_err(dev, "Touchscreen pressure is not specified\n"); 615 return -EINVAL; 616 } 617 } 618 619 err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET); 620 if (err < 0) { 621 dev_err(dev, "Failed to write %s\n", input_dev->name); 622 return err; 623 } 624 625 revid = ad7879_read(ts, AD7879_REG_REVID); 626 input_dev->id.product = (revid & 0xff); 627 input_dev->id.version = revid >> 8; 628 if (input_dev->id.product != devid) { 629 dev_err(dev, "Failed to probe %s (%x vs %x)\n", 630 input_dev->name, devid, revid); 631 return -ENODEV; 632 } 633 634 ts->cmd_crtl3 = AD7879_YPLUS_BIT | 635 AD7879_XPLUS_BIT | 636 AD7879_Z2_BIT | 637 AD7879_Z1_BIT | 638 AD7879_TEMPMASK_BIT | 639 AD7879_AUXVBATMASK_BIT | 640 AD7879_GPIOALERTMASK_BIT; 641 642 ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR | 643 AD7879_AVG(ts->averaging) | 644 AD7879_MFS(ts->median) | 645 AD7879_FCD(ts->first_conversion_delay); 646 647 ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 | 648 AD7879_ACQ(ts->acquisition_time) | 649 AD7879_TMR(ts->pen_down_acc_interval); 650 651 err = devm_request_threaded_irq(dev, ts->irq, NULL, ad7879_irq, 652 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 653 dev_name(dev), ts); 654 if (err) { 655 dev_err(dev, "Failed to request IRQ: %d\n", err); 656 return err; 657 } 658 659 __ad7879_disable(ts); 660 661 err = sysfs_create_group(&dev->kobj, &ad7879_attr_group); 662 if (err) 663 return err; 664 665 err = devm_add_action_or_reset(dev, ad7879_cleanup_sysfs, ts); 666 if (err) 667 return err; 668 669 err = ad7879_gpio_add(ts, pdata); 670 if (err) 671 return err; 672 673 err = input_register_device(input_dev); 674 if (err) 675 return err; 676 677 dev_set_drvdata(dev, ts); 678 679 return 0; 680 } 681 EXPORT_SYMBOL(ad7879_probe); 682 683 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>"); 684 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver"); 685 MODULE_LICENSE("GPL"); 686