793 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * leds-tca65074 *5 * The TCA6507 is a programmable LED controller that can drive 76 * separate lines either by holding them low, or by pulsing them7 * with modulated width.8 * The modulation can be varied in a simple pattern to produce a9 * blink or double-blink.10 *11 * This driver can configure each line either as a 'GPIO' which is12 * out-only (pull-up resistor required) or as an LED with variable13 * brightness and hardware-assisted blinking.14 *15 * Apart from OFF and ON there are three programmable brightness16 * levels which can be programmed from 0 to 15 and indicate how many17 * 500usec intervals in each 8msec that the led is 'on'. The levels18 * are named MASTER, BANK0 and BANK1.19 *20 * There are two different blink rates that can be programmed, each21 * with separate time for rise, on, fall, off and second-off. Thus if22 * 3 or more different non-trivial rates are required, software must23 * be used for the extra rates. The two different blink rates must24 * align with the two levels BANK0 and BANK1. This driver does not25 * support double-blink so 'second-off' always matches 'off'.26 *27 * Only 16 different times can be programmed in a roughly logarithmic28 * scale from 64ms to 16320ms. To be precise the possible times are:29 * 0, 64, 128, 192, 256, 384, 512, 768,30 * 1024, 1536, 2048, 3072, 4096, 5760, 8128, 1632031 *32 * Times that cannot be closely matched with these must be handled in33 * software. This driver allows 12.5% error in matching.34 *35 * This driver does not allow rise/fall rates to be set explicitly.36 * When trying to match a given 'on' or 'off' period, an appropriate37 * pair of 'change' and 'hold' times are chosen to get a close match.38 * If the target delay is even, the 'change' number will be the39 * smaller; if odd, the 'hold' number will be the smaller.40 41 * Choosing pairs of delays with 12.5% errors allows us to match42 * delays in the ranges: 56-72, 112-144, 168-216, 224-27504,43 * 28560-36720.44 * 26% of the achievable sums can be matched by multiple pairings.45 * For example 1536 == 1536+0, 1024+512, or 768+768.46 * This driver will always choose the pairing with the least47 * maximum - 768+768 in this case. Other pairings are not available.48 *49 * Access to the 3 levels and 2 blinks are on a first-come,50 * first-served basis. Access can be shared by multiple leds if they51 * have the same level and either same blink rates, or some don't52 * blink. When a led changes, it relinquishes access and tries again,53 * so it might lose access to hardware blink.54 *55 * If a blink engine cannot be allocated, software blink is used. If56 * the desired brightness cannot be allocated, the closest available57 * non-zero brightness is used. As 'full' is always available, the58 * worst case would be to have two different blink rates at '1', with59 * Max at '2', then other leds will have to choose between '2' and60 * '16'. Hopefully this is not likely.61 *62 * Each bank (BANK0 and BANK1) has two usage counts - LEDs using the63 * brightness and LEDs using the blink. It can only be reprogrammed64 * when the appropriate counter is zero. The MASTER level has a65 * single usage count.66 *67 * Each LED has programmable 'on' and 'off' time as milliseconds.68 * With each there is a flag saying if it was explicitly requested or69 * defaulted. Similarly the banks know if each time was explicit or a70 * default. Defaults are permitted to be changed freely - they are71 * not recognised when matching.72 */73 74#include <linux/module.h>75#include <linux/slab.h>76#include <linux/leds.h>77#include <linux/err.h>78#include <linux/i2c.h>79#include <linux/gpio/driver.h>80#include <linux/property.h>81#include <linux/workqueue.h>82 83/* LED select registers determine the source that drives LED outputs */84#define TCA6507_LS_LED_OFF 0x0 /* Output HI-Z (off) */85#define TCA6507_LS_LED_OFF1 0x1 /* Output HI-Z (off) - not used */86#define TCA6507_LS_LED_PWM0 0x2 /* Output LOW with Bank0 rate */87#define TCA6507_LS_LED_PWM1 0x3 /* Output LOW with Bank1 rate */88#define TCA6507_LS_LED_ON 0x4 /* Output LOW (on) */89#define TCA6507_LS_LED_MIR 0x5 /* Output LOW with Master Intensity */90#define TCA6507_LS_BLINK0 0x6 /* Blink at Bank0 rate */91#define TCA6507_LS_BLINK1 0x7 /* Blink at Bank1 rate */92 93struct tca6507_platform_data {94 struct led_platform_data leds;95};96 97#define TCA6507_MAKE_GPIO 198 99enum {100 BANK0,101 BANK1,102 MASTER,103};104static int bank_source[3] = {105 TCA6507_LS_LED_PWM0,106 TCA6507_LS_LED_PWM1,107 TCA6507_LS_LED_MIR,108};109static int blink_source[2] = {110 TCA6507_LS_BLINK0,111 TCA6507_LS_BLINK1,112};113 114/* PWM registers */115#define TCA6507_REG_CNT 11116 117/*118 * 0x00, 0x01, 0x02 encode the TCA6507_LS_* values, each output119 * owns one bit in each register120 */121#define TCA6507_FADE_ON 0x03122#define TCA6507_FULL_ON 0x04123#define TCA6507_FADE_OFF 0x05124#define TCA6507_FIRST_OFF 0x06125#define TCA6507_SECOND_OFF 0x07126#define TCA6507_MAX_INTENSITY 0x08127#define TCA6507_MASTER_INTENSITY 0x09128#define TCA6507_INITIALIZE 0x0A129 130#define INIT_CODE 0x8131 132#define TIMECODES 16133static int time_codes[TIMECODES] = {134 0, 64, 128, 192, 256, 384, 512, 768,135 1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320136};137 138/* Convert an led.brightness level (0..255) to a TCA6507 level (0..15) */139static inline int TO_LEVEL(int brightness)140{141 return brightness >> 4;142}143 144/* ...and convert back */145static inline int TO_BRIGHT(int level)146{147 if (level)148 return (level << 4) | 0xf;149 return 0;150}151 152#define NUM_LEDS 7153struct tca6507_chip {154 int reg_set; /* One bit per register where155 * a '1' means the register156 * should be written */157 u8 reg_file[TCA6507_REG_CNT];158 /* Bank 2 is Master Intensity and doesn't use times */159 struct bank {160 int level;161 int ontime, offtime;162 int on_dflt, off_dflt;163 int time_use, level_use;164 } bank[3];165 struct i2c_client *client;166 struct work_struct work;167 spinlock_t lock;168 169 struct tca6507_led {170 struct tca6507_chip *chip;171 struct led_classdev led_cdev;172 int num;173 int ontime, offtime;174 int on_dflt, off_dflt;175 int bank; /* Bank used, or -1 */176 int blink; /* Set if hardware-blinking */177 } leds[NUM_LEDS];178#ifdef CONFIG_GPIOLIB179 struct gpio_chip gpio;180 int gpio_map[NUM_LEDS];181#endif182};183 184static const struct i2c_device_id tca6507_id[] = {185 { "tca6507" },186 { }187};188MODULE_DEVICE_TABLE(i2c, tca6507_id);189 190static int choose_times(int msec, int *c1p, int *c2p)191{192 /*193 * Choose two timecodes which add to 'msec' as near as194 * possible. The first returned is the 'on' or 'off' time.195 * The second is to be used as a 'fade-on' or 'fade-off' time.196 * If 'msec' is even, the first will not be smaller than the197 * second. If 'msec' is odd, the first will not be larger198 * than the second.199 * If we cannot get a sum within 1/8 of 'msec' fail with200 * -EINVAL, otherwise return the sum that was achieved, plus 1201 * if the first is smaller.202 * If two possibilities are equally good (e.g. 512+0,203 * 256+256), choose the first pair so there is more204 * change-time visible (i.e. it is softer).205 */206 int c1, c2;207 int tmax = msec * 9 / 8;208 int tmin = msec * 7 / 8;209 int diff = 65536;210 211 /* We start at '1' to ensure we never even think of choosing a212 * total time of '0'.213 */214 for (c1 = 1; c1 < TIMECODES; c1++) {215 int t = time_codes[c1];216 if (t*2 < tmin)217 continue;218 if (t > tmax)219 break;220 for (c2 = 0; c2 <= c1; c2++) {221 int tt = t + time_codes[c2];222 int d;223 if (tt < tmin)224 continue;225 if (tt > tmax)226 break;227 /* This works! */228 d = abs(msec - tt);229 if (d >= diff)230 continue;231 /* Best yet */232 *c1p = c1;233 *c2p = c2;234 diff = d;235 if (d == 0)236 return msec;237 }238 }239 if (diff < 65536) {240 int actual;241 if (msec & 1) {242 swap(*c2p, *c1p);243 }244 actual = time_codes[*c1p] + time_codes[*c2p];245 if (*c1p < *c2p)246 return actual + 1;247 else248 return actual;249 }250 /* No close match */251 return -EINVAL;252}253 254/*255 * Update the register file with the appropriate 3-bit state for the256 * given led.257 */258static void set_select(struct tca6507_chip *tca, int led, int val)259{260 int mask = (1 << led);261 int bit;262 263 for (bit = 0; bit < 3; bit++) {264 int n = tca->reg_file[bit] & ~mask;265 if (val & (1 << bit))266 n |= mask;267 if (tca->reg_file[bit] != n) {268 tca->reg_file[bit] = n;269 tca->reg_set |= (1 << bit);270 }271 }272}273 274/* Update the register file with the appropriate 4-bit code for one275 * bank or other. This can be used for timers, for levels, or for276 * initialization.277 */278static void set_code(struct tca6507_chip *tca, int reg, int bank, int new)279{280 int mask = 0xF;281 int n;282 if (bank) {283 mask <<= 4;284 new <<= 4;285 }286 n = tca->reg_file[reg] & ~mask;287 n |= new;288 if (tca->reg_file[reg] != n) {289 tca->reg_file[reg] = n;290 tca->reg_set |= 1 << reg;291 }292}293 294/* Update brightness level. */295static void set_level(struct tca6507_chip *tca, int bank, int level)296{297 switch (bank) {298 case BANK0:299 case BANK1:300 set_code(tca, TCA6507_MAX_INTENSITY, bank, level);301 break;302 case MASTER:303 set_code(tca, TCA6507_MASTER_INTENSITY, 0, level);304 break;305 }306 tca->bank[bank].level = level;307}308 309/* Record all relevant time codes for a given bank */310static void set_times(struct tca6507_chip *tca, int bank)311{312 int c1, c2;313 int result;314 315 result = choose_times(tca->bank[bank].ontime, &c1, &c2);316 if (result < 0)317 return;318 dev_dbg(&tca->client->dev,319 "Chose on times %d(%d) %d(%d) for %dms\n",320 c1, time_codes[c1],321 c2, time_codes[c2], tca->bank[bank].ontime);322 set_code(tca, TCA6507_FADE_ON, bank, c2);323 set_code(tca, TCA6507_FULL_ON, bank, c1);324 tca->bank[bank].ontime = result;325 326 result = choose_times(tca->bank[bank].offtime, &c1, &c2);327 dev_dbg(&tca->client->dev,328 "Chose off times %d(%d) %d(%d) for %dms\n",329 c1, time_codes[c1],330 c2, time_codes[c2], tca->bank[bank].offtime);331 set_code(tca, TCA6507_FADE_OFF, bank, c2);332 set_code(tca, TCA6507_FIRST_OFF, bank, c1);333 set_code(tca, TCA6507_SECOND_OFF, bank, c1);334 tca->bank[bank].offtime = result;335 336 set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE);337}338 339/* Write all needed register of tca6507 */340 341static void tca6507_work(struct work_struct *work)342{343 struct tca6507_chip *tca = container_of(work, struct tca6507_chip,344 work);345 struct i2c_client *cl = tca->client;346 int set;347 u8 file[TCA6507_REG_CNT];348 int r;349 350 spin_lock_irq(&tca->lock);351 set = tca->reg_set;352 memcpy(file, tca->reg_file, TCA6507_REG_CNT);353 tca->reg_set = 0;354 spin_unlock_irq(&tca->lock);355 356 for (r = 0; r < TCA6507_REG_CNT; r++)357 if (set & (1<<r))358 i2c_smbus_write_byte_data(cl, r, file[r]);359}360 361static void led_release(struct tca6507_led *led)362{363 /* If led owns any resource, release it. */364 struct tca6507_chip *tca = led->chip;365 if (led->bank >= 0) {366 struct bank *b = tca->bank + led->bank;367 if (led->blink)368 b->time_use--;369 b->level_use--;370 }371 led->blink = 0;372 led->bank = -1;373}374 375static int led_prepare(struct tca6507_led *led)376{377 /* Assign this led to a bank, configuring that bank if378 * necessary. */379 int level = TO_LEVEL(led->led_cdev.brightness);380 struct tca6507_chip *tca = led->chip;381 int c1, c2;382 int i;383 struct bank *b;384 int need_init = 0;385 386 led->led_cdev.brightness = TO_BRIGHT(level);387 if (level == 0) {388 set_select(tca, led->num, TCA6507_LS_LED_OFF);389 return 0;390 }391 392 if (led->ontime == 0 || led->offtime == 0) {393 /*394 * Just set the brightness, choosing first usable395 * bank. If none perfect, choose best. Count396 * backwards so we check MASTER bank first to avoid397 * wasting a timer.398 */399 int best = -1;/* full-on */400 int diff = 15-level;401 402 if (level == 15) {403 set_select(tca, led->num, TCA6507_LS_LED_ON);404 return 0;405 }406 407 for (i = MASTER; i >= BANK0; i--) {408 int d;409 if (tca->bank[i].level == level ||410 tca->bank[i].level_use == 0) {411 best = i;412 break;413 }414 d = abs(level - tca->bank[i].level);415 if (d < diff) {416 diff = d;417 best = i;418 }419 }420 if (best == -1) {421 /* Best brightness is full-on */422 set_select(tca, led->num, TCA6507_LS_LED_ON);423 led->led_cdev.brightness = LED_FULL;424 return 0;425 }426 427 if (!tca->bank[best].level_use)428 set_level(tca, best, level);429 430 tca->bank[best].level_use++;431 led->bank = best;432 set_select(tca, led->num, bank_source[best]);433 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level);434 return 0;435 }436 437 /*438 * We have on/off time so we need to try to allocate a timing439 * bank. First check if times are compatible with hardware440 * and give up if not.441 */442 if (choose_times(led->ontime, &c1, &c2) < 0)443 return -EINVAL;444 if (choose_times(led->offtime, &c1, &c2) < 0)445 return -EINVAL;446 447 for (i = BANK0; i <= BANK1; i++) {448 if (tca->bank[i].level_use == 0)449 /* not in use - it is ours! */450 break;451 if (tca->bank[i].level != level)452 /* Incompatible level - skip */453 /* FIX: if timer matches we maybe should consider454 * this anyway...455 */456 continue;457 458 if (tca->bank[i].time_use == 0)459 /* Timer not in use, and level matches - use it */460 break;461 462 if (!(tca->bank[i].on_dflt ||463 led->on_dflt ||464 tca->bank[i].ontime == led->ontime))465 /* on time is incompatible */466 continue;467 468 if (!(tca->bank[i].off_dflt ||469 led->off_dflt ||470 tca->bank[i].offtime == led->offtime))471 /* off time is incompatible */472 continue;473 474 /* looks like a suitable match */475 break;476 }477 478 if (i > BANK1)479 /* Nothing matches - how sad */480 return -EINVAL;481 482 b = &tca->bank[i];483 if (b->level_use == 0)484 set_level(tca, i, level);485 b->level_use++;486 led->bank = i;487 488 if (b->on_dflt ||489 !led->on_dflt ||490 b->time_use == 0) {491 b->ontime = led->ontime;492 b->on_dflt = led->on_dflt;493 need_init = 1;494 }495 496 if (b->off_dflt ||497 !led->off_dflt ||498 b->time_use == 0) {499 b->offtime = led->offtime;500 b->off_dflt = led->off_dflt;501 need_init = 1;502 }503 504 if (need_init)505 set_times(tca, i);506 507 led->ontime = b->ontime;508 led->offtime = b->offtime;509 510 b->time_use++;511 led->blink = 1;512 led->led_cdev.brightness = TO_BRIGHT(b->level);513 set_select(tca, led->num, blink_source[i]);514 return 0;515}516 517static int led_assign(struct tca6507_led *led)518{519 struct tca6507_chip *tca = led->chip;520 int err;521 unsigned long flags;522 523 spin_lock_irqsave(&tca->lock, flags);524 led_release(led);525 err = led_prepare(led);526 if (err) {527 /*528 * Can only fail on timer setup. In that case we need529 * to re-establish as steady level.530 */531 led->ontime = 0;532 led->offtime = 0;533 led_prepare(led);534 }535 spin_unlock_irqrestore(&tca->lock, flags);536 537 if (tca->reg_set)538 schedule_work(&tca->work);539 return err;540}541 542static void tca6507_brightness_set(struct led_classdev *led_cdev,543 enum led_brightness brightness)544{545 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,546 led_cdev);547 led->led_cdev.brightness = brightness;548 led->ontime = 0;549 led->offtime = 0;550 led_assign(led);551}552 553static int tca6507_blink_set(struct led_classdev *led_cdev,554 unsigned long *delay_on,555 unsigned long *delay_off)556{557 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,558 led_cdev);559 560 if (*delay_on == 0)561 led->on_dflt = 1;562 else if (delay_on != &led_cdev->blink_delay_on)563 led->on_dflt = 0;564 led->ontime = *delay_on;565 566 if (*delay_off == 0)567 led->off_dflt = 1;568 else if (delay_off != &led_cdev->blink_delay_off)569 led->off_dflt = 0;570 led->offtime = *delay_off;571 572 if (led->ontime == 0)573 led->ontime = 512;574 if (led->offtime == 0)575 led->offtime = 512;576 577 if (led->led_cdev.brightness == LED_OFF)578 led->led_cdev.brightness = LED_FULL;579 if (led_assign(led) < 0) {580 led->ontime = 0;581 led->offtime = 0;582 led->led_cdev.brightness = LED_OFF;583 return -EINVAL;584 }585 *delay_on = led->ontime;586 *delay_off = led->offtime;587 return 0;588}589 590#ifdef CONFIG_GPIOLIB591static void tca6507_gpio_set_value(struct gpio_chip *gc,592 unsigned offset, int val)593{594 struct tca6507_chip *tca = gpiochip_get_data(gc);595 unsigned long flags;596 597 spin_lock_irqsave(&tca->lock, flags);598 /*599 * 'OFF' is floating high, and 'ON' is pulled down, so it has600 * the inverse sense of 'val'.601 */602 set_select(tca, tca->gpio_map[offset],603 val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON);604 spin_unlock_irqrestore(&tca->lock, flags);605 if (tca->reg_set)606 schedule_work(&tca->work);607}608 609static int tca6507_gpio_direction_output(struct gpio_chip *gc,610 unsigned offset, int val)611{612 tca6507_gpio_set_value(gc, offset, val);613 return 0;614}615 616static int tca6507_probe_gpios(struct device *dev,617 struct tca6507_chip *tca,618 struct tca6507_platform_data *pdata)619{620 int err;621 int i = 0;622 int gpios = 0;623 624 for (i = 0; i < NUM_LEDS; i++)625 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) {626 /* Configure as a gpio */627 tca->gpio_map[gpios] = i;628 gpios++;629 }630 631 if (!gpios)632 return 0;633 634 tca->gpio.label = "gpio-tca6507";635 tca->gpio.ngpio = gpios;636 tca->gpio.base = -1;637 tca->gpio.owner = THIS_MODULE;638 tca->gpio.direction_output = tca6507_gpio_direction_output;639 tca->gpio.set = tca6507_gpio_set_value;640 tca->gpio.parent = dev;641 err = devm_gpiochip_add_data(dev, &tca->gpio, tca);642 if (err) {643 tca->gpio.ngpio = 0;644 return err;645 }646 return 0;647}648#else /* CONFIG_GPIOLIB */649static int tca6507_probe_gpios(struct device *dev,650 struct tca6507_chip *tca,651 struct tca6507_platform_data *pdata)652{653 return 0;654}655#endif /* CONFIG_GPIOLIB */656 657static struct tca6507_platform_data *658tca6507_led_dt_init(struct device *dev)659{660 struct tca6507_platform_data *pdata;661 struct fwnode_handle *child;662 struct led_info *tca_leds;663 int count;664 665 count = device_get_child_node_count(dev);666 if (!count || count > NUM_LEDS)667 return ERR_PTR(-ENODEV);668 669 tca_leds = devm_kcalloc(dev, NUM_LEDS, sizeof(struct led_info),670 GFP_KERNEL);671 if (!tca_leds)672 return ERR_PTR(-ENOMEM);673 674 device_for_each_child_node(dev, child) {675 struct led_info led;676 u32 reg;677 int ret;678 679 if (fwnode_property_read_string(child, "label", &led.name))680 led.name = fwnode_get_name(child);681 682 if (fwnode_property_read_string(child, "linux,default-trigger",683 &led.default_trigger))684 led.default_trigger = NULL;685 686 led.flags = 0;687 if (fwnode_device_is_compatible(child, "gpio"))688 led.flags |= TCA6507_MAKE_GPIO;689 690 ret = fwnode_property_read_u32(child, "reg", ®);691 if (ret || reg >= NUM_LEDS) {692 fwnode_handle_put(child);693 return ERR_PTR(ret ? : -EINVAL);694 }695 696 tca_leds[reg] = led;697 }698 699 pdata = devm_kzalloc(dev, sizeof(struct tca6507_platform_data),700 GFP_KERNEL);701 if (!pdata)702 return ERR_PTR(-ENOMEM);703 704 pdata->leds.leds = tca_leds;705 pdata->leds.num_leds = NUM_LEDS;706 707 return pdata;708}709 710static const struct of_device_id __maybe_unused of_tca6507_leds_match[] = {711 { .compatible = "ti,tca6507", },712 {},713};714MODULE_DEVICE_TABLE(of, of_tca6507_leds_match);715 716static int tca6507_probe(struct i2c_client *client)717{718 struct device *dev = &client->dev;719 struct i2c_adapter *adapter;720 struct tca6507_chip *tca;721 struct tca6507_platform_data *pdata;722 int err;723 int i = 0;724 725 adapter = client->adapter;726 727 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))728 return -EIO;729 730 pdata = tca6507_led_dt_init(dev);731 if (IS_ERR(pdata)) {732 dev_err(dev, "Need %d entries in platform-data list\n", NUM_LEDS);733 return PTR_ERR(pdata);734 }735 tca = devm_kzalloc(dev, sizeof(*tca), GFP_KERNEL);736 if (!tca)737 return -ENOMEM;738 739 tca->client = client;740 INIT_WORK(&tca->work, tca6507_work);741 spin_lock_init(&tca->lock);742 i2c_set_clientdata(client, tca);743 744 for (i = 0; i < NUM_LEDS; i++) {745 struct tca6507_led *l = tca->leds + i;746 747 l->chip = tca;748 l->num = i;749 if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) {750 l->led_cdev.name = pdata->leds.leds[i].name;751 l->led_cdev.default_trigger752 = pdata->leds.leds[i].default_trigger;753 l->led_cdev.brightness_set = tca6507_brightness_set;754 l->led_cdev.blink_set = tca6507_blink_set;755 l->bank = -1;756 err = devm_led_classdev_register(dev, &l->led_cdev);757 if (err < 0)758 return err;759 }760 }761 err = tca6507_probe_gpios(dev, tca, pdata);762 if (err)763 return err;764 /* set all registers to known state - zero */765 tca->reg_set = 0x7f;766 schedule_work(&tca->work);767 768 return 0;769}770 771static void tca6507_remove(struct i2c_client *client)772{773 struct tca6507_chip *tca = i2c_get_clientdata(client);774 775 cancel_work_sync(&tca->work);776}777 778static struct i2c_driver tca6507_driver = {779 .driver = {780 .name = "leds-tca6507",781 .of_match_table = of_match_ptr(of_tca6507_leds_match),782 },783 .probe = tca6507_probe,784 .remove = tca6507_remove,785 .id_table = tca6507_id,786};787 788module_i2c_driver(tca6507_driver);789 790MODULE_AUTHOR("NeilBrown <neilb@suse.de>");791MODULE_DESCRIPTION("TCA6507 LED/GPO driver");792MODULE_LICENSE("GPL v2");793