drivers/mfd/tps6586x.c

   1 /*
   2  * Core driver for TI TPS6586x PMIC family
   3  *
   4  * Copyright (c) 2010 CompuLab Ltd.
   5  * Mike Rapoport <mike@compulab.co.il>
   6  *
   7  * Based on da903x.c.
   8  * Copyright (C) 2008 Compulab, Ltd.
   9  * Mike Rapoport <mike@compulab.co.il>
  10  * Copyright (C) 2006-2008 Marvell International Ltd.
  11  * Eric Miao <eric.miao@marvell.com>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License version 2 as
  15  * published by the Free Software Foundation.
  16  */
  17
  18 #include <linux/interrupt.h>
  19 #include <linux/irq.h>
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/mutex.h>
  23 #include <linux/slab.h>
  24 #include <linux/gpio.h>
  25 #include <linux/i2c.h>
  26
  27 #include <linux/mfd/core.h>
  28 #include <linux/mfd/tps6586x.h>
  29
  30 /* GPIO control registers */
  31 #define TPS6586X_GPIOSET1       0x5d
  32 #define TPS6586X_GPIOSET2       0x5e
  33
  34 /* interrupt control registers */
  35 #define TPS6586X_INT_ACK1       0xb5
  36 #define TPS6586X_INT_ACK2       0xb6
  37 #define TPS6586X_INT_ACK3       0xb7
  38 #define TPS6586X_INT_ACK4       0xb8
  39
  40 /* interrupt mask registers */
  41 #define TPS6586X_INT_MASK1      0xb0
  42 #define TPS6586X_INT_MASK2      0xb1
  43 #define TPS6586X_INT_MASK3      0xb2
  44 #define TPS6586X_INT_MASK4      0xb3
  45 #define TPS6586X_INT_MASK5      0xb4
  46
  47 /* device id */
  48 #define TPS6586X_VERSIONCRC     0xcd
  49 #define TPS658621A_VERSIONCRC   0x15
  50 #define TPS658621C_VERSIONCRC   0x2c
  51
  52 struct tps6586x_irq_data {
  53         u8      mask_reg;
  54         u8      mask_mask;
  55 };
  56
  57 #define TPS6586X_IRQ(_reg, _mask)                               \
  58         {                                                       \
  59                 .mask_reg = (_reg) - TPS6586X_INT_MASK1,        \
  60                 .mask_mask = (_mask),                           \
  61         }
  62
  63 static const struct tps6586x_irq_data tps6586x_irqs[] = {
  64         [TPS6586X_INT_PLDO_0]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 0),
  65         [TPS6586X_INT_PLDO_1]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 1),
  66         [TPS6586X_INT_PLDO_2]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 2),
  67         [TPS6586X_INT_PLDO_3]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 3),
  68         [TPS6586X_INT_PLDO_4]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 4),
  69         [TPS6586X_INT_PLDO_5]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 5),
  70         [TPS6586X_INT_PLDO_6]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 6),
  71         [TPS6586X_INT_PLDO_7]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 7),
  72         [TPS6586X_INT_COMP_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 0),
  73         [TPS6586X_INT_ADC]      = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 1),
  74         [TPS6586X_INT_PLDO_8]   = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 2),
  75         [TPS6586X_INT_PLDO_9]   = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 3),
  76         [TPS6586X_INT_PSM_0]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 4),
  77         [TPS6586X_INT_PSM_1]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 5),
  78         [TPS6586X_INT_PSM_2]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 6),
  79         [TPS6586X_INT_PSM_3]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 7),
  80         [TPS6586X_INT_RTC_ALM1] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 4),
  81         [TPS6586X_INT_ACUSB_OVP] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 0x03),
  82         [TPS6586X_INT_USB_DET]  = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 2),
  83         [TPS6586X_INT_AC_DET]   = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 3),
  84         [TPS6586X_INT_BAT_DET]  = TPS6586X_IRQ(TPS6586X_INT_MASK3, 1 << 0),
  85         [TPS6586X_INT_CHG_STAT] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 0xfc),
  86         [TPS6586X_INT_CHG_TEMP] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0x06),
  87         [TPS6586X_INT_PP]       = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0xf0),
  88         [TPS6586X_INT_RESUME]   = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 5),
  89         [TPS6586X_INT_LOW_SYS]  = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 6),
  90         [TPS6586X_INT_RTC_ALM2] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 1),
  91 };
  92
  93 struct tps6586x {
  94         struct mutex            lock;
  95         struct device           *dev;
  96         struct i2c_client       *client;
  97
  98         struct gpio_chip        gpio;
  99         struct irq_chip         irq_chip;
 100         struct mutex            irq_lock;
 101         int                     irq_base;
 102         u32                     irq_en;
 103         u8                      mask_cache[5];
 104         u8                      mask_reg[5];
 105 };
 106
 107 static inline int __tps6586x_read(struct i2c_client *client,
 108                                   int reg, uint8_t *val)
 109 {
 110         int ret;
 111
 112         ret = i2c_smbus_read_byte_data(client, reg);
 113         if (ret < 0) {
 114                 dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
 115                 return ret;
 116         }
 117
 118         *val = (uint8_t)ret;
 119
 120         return 0;
 121 }
 122
 123 static inline int __tps6586x_reads(struct i2c_client *client, int reg,
 124                                    int len, uint8_t *val)
 125 {
 126         int ret;
 127
 128         ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
 129         if (ret < 0) {
 130                 dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
 131                 return ret;
 132         }
 133
 134         return 0;
 135 }
 136
 137 static inline int __tps6586x_write(struct i2c_client *client,
 138                                  int reg, uint8_t val)
 139 {
 140         int ret;
 141
 142         ret = i2c_smbus_write_byte_data(client, reg, val);
 143         if (ret < 0) {
 144                 dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
 145                                 val, reg);
 146                 return ret;
 147         }
 148
 149         return 0;
 150 }
 151
 152 static inline int __tps6586x_writes(struct i2c_client *client, int reg,
 153                                   int len, uint8_t *val)
 154 {
 155         int ret;
 156
 157         ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
 158         if (ret < 0) {
 159                 dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
 160                 return ret;
 161         }
 162
 163         return 0;
 164 }
 165
 166 int tps6586x_write(struct device *dev, int reg, uint8_t val)
 167 {
 168         return __tps6586x_write(to_i2c_client(dev), reg, val);
 169 }
 170 EXPORT_SYMBOL_GPL(tps6586x_write);
 171
 172 int tps6586x_writes(struct device *dev, int reg, int len, uint8_t *val)
 173 {
 174         return __tps6586x_writes(to_i2c_client(dev), reg, len, val);
 175 }
 176 EXPORT_SYMBOL_GPL(tps6586x_writes);
 177
 178 int tps6586x_read(struct device *dev, int reg, uint8_t *val)
 179 {
 180         return __tps6586x_read(to_i2c_client(dev), reg, val);
 181 }
 182 EXPORT_SYMBOL_GPL(tps6586x_read);
 183
 184 int tps6586x_reads(struct device *dev, int reg, int len, uint8_t *val)
 185 {
 186         return __tps6586x_reads(to_i2c_client(dev), reg, len, val);
 187 }
 188 EXPORT_SYMBOL_GPL(tps6586x_reads);
 189
 190 int tps6586x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
 191 {
 192         struct tps6586x *tps6586x = dev_get_drvdata(dev);
 193         uint8_t reg_val;
 194         int ret = 0;
 195
 196         mutex_lock(&tps6586x->lock);
 197
 198         ret = __tps6586x_read(to_i2c_client(dev), reg, &reg_val);
 199         if (ret)
 200                 goto out;
 201
 202         if ((reg_val & bit_mask) == 0) {
 203                 reg_val |= bit_mask;
 204                 ret = __tps6586x_write(to_i2c_client(dev), reg, reg_val);
 205         }
 206 out:
 207         mutex_unlock(&tps6586x->lock);
 208         return ret;
 209 }
 210 EXPORT_SYMBOL_GPL(tps6586x_set_bits);
 211
 212 int tps6586x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
 213 {
 214         struct tps6586x *tps6586x = dev_get_drvdata(dev);
 215         uint8_t reg_val;
 216         int ret = 0;
 217
 218         mutex_lock(&tps6586x->lock);
 219
 220         ret = __tps6586x_read(to_i2c_client(dev), reg, &reg_val);
 221         if (ret)
 222                 goto out;
 223
 224         if (reg_val & bit_mask) {
 225                 reg_val &= ~bit_mask;
 226                 ret = __tps6586x_write(to_i2c_client(dev), reg, reg_val);
 227         }
 228 out:
 229         mutex_unlock(&tps6586x->lock);
 230         return ret;
 231 }
 232 EXPORT_SYMBOL_GPL(tps6586x_clr_bits);
 233
 234 int tps6586x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
 235 {
 236         struct tps6586x *tps6586x = dev_get_drvdata(dev);
 237         uint8_t reg_val;
 238         int ret = 0;
 239
 240         mutex_lock(&tps6586x->lock);
 241
 242         ret = __tps6586x_read(tps6586x->client, reg, &reg_val);
 243         if (ret)
 244                 goto out;
 245
 246         if ((reg_val & mask) != val) {
 247                 reg_val = (reg_val & ~mask) | val;
 248                 ret = __tps6586x_write(tps6586x->client, reg, reg_val);
 249         }
 250 out:
 251         mutex_unlock(&tps6586x->lock);
 252         return ret;
 253 }
 254 EXPORT_SYMBOL_GPL(tps6586x_update);
 255
 256 static int tps6586x_gpio_get(struct gpio_chip *gc, unsigned offset)
 257 {
 258         struct tps6586x *tps6586x = container_of(gc, struct tps6586x, gpio);
 259         uint8_t val;
 260         int ret;
 261
 262         ret = __tps6586x_read(tps6586x->client, TPS6586X_GPIOSET2, &val);
 263         if (ret)
 264                 return ret;
 265
 266         return !!(val & (1 << offset));
 267 }
 268
 269
 270 static void tps6586x_gpio_set(struct gpio_chip *chip, unsigned offset,
 271                               int value)
 272 {
 273         struct tps6586x *tps6586x = container_of(chip, struct tps6586x, gpio);
 274
 275         __tps6586x_write(tps6586x->client, TPS6586X_GPIOSET2,
 276                          value << offset);
 277 }
 278
 279 static int tps6586x_gpio_output(struct gpio_chip *gc, unsigned offset,
 280                                 int value)
 281 {
 282         struct tps6586x *tps6586x = container_of(gc, struct tps6586x, gpio);
 283         uint8_t val, mask;
 284
 285         tps6586x_gpio_set(gc, offset, value);
 286
 287         val = 0x1 << (offset * 2);
 288         mask = 0x3 << (offset * 2);
 289
 290         return tps6586x_update(tps6586x->dev, TPS6586X_GPIOSET1, val, mask);
 291 }
 292
 293 static void tps6586x_gpio_init(struct tps6586x *tps6586x, int gpio_base)
 294 {
 295         int ret;
 296
 297         if (!gpio_base)
 298                 return;
 299
 300         tps6586x->gpio.owner            = THIS_MODULE;
 301         tps6586x->gpio.label            = tps6586x->client->name;
 302         tps6586x->gpio.dev              = tps6586x->dev;
 303         tps6586x->gpio.base             = gpio_base;
 304         tps6586x->gpio.ngpio            = 4;
 305         tps6586x->gpio.can_sleep        = 1;
 306
 307         /* FIXME: add handling of GPIOs as dedicated inputs */
 308         tps6586x->gpio.direction_output = tps6586x_gpio_output;
 309         tps6586x->gpio.set              = tps6586x_gpio_set;
 310         tps6586x->gpio.get              = tps6586x_gpio_get;
 311
 312         ret = gpiochip_add(&tps6586x->gpio);
 313         if (ret)
 314                 dev_warn(tps6586x->dev, "GPIO registration failed: %d\n", ret);
 315 }
 316
 317 static int __remove_subdev(struct device *dev, void *unused)
 318 {
 319         platform_device_unregister(to_platform_device(dev));
 320         return 0;
 321 }
 322
 323 static int tps6586x_remove_subdevs(struct tps6586x *tps6586x)
 324 {
 325         return device_for_each_child(tps6586x->dev, NULL, __remove_subdev);
 326 }
 327
 328 static void tps6586x_irq_lock(unsigned int irq)
 329 {
 330         struct tps6586x *tps6586x = get_irq_chip_data(irq);
 331
 332         mutex_lock(&tps6586x->irq_lock);
 333 }
 334
 335 static void tps6586x_irq_enable(unsigned int irq)
 336 {
 337         struct tps6586x *tps6586x = get_irq_chip_data(irq);
 338         unsigned int __irq = irq - tps6586x->irq_base;
 339         const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
 340
 341         tps6586x->mask_reg[data->mask_reg] &= ~data->mask_mask;
 342         tps6586x->irq_en |= (1 << __irq);
 343 }
 344
 345 static void tps6586x_irq_disable(unsigned int irq)
 346 {
 347         struct tps6586x *tps6586x = get_irq_chip_data(irq);
 348
 349         unsigned int __irq = irq - tps6586x->irq_base;
 350         const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
 351
 352         tps6586x->mask_reg[data->mask_reg] |= data->mask_mask;
 353         tps6586x->irq_en &= ~(1 << __irq);
 354 }
 355
 356 static void tps6586x_irq_sync_unlock(unsigned int irq)
 357 {
 358         struct tps6586x *tps6586x = get_irq_chip_data(irq);
 359         int i;
 360
 361         for (i = 0; i < ARRAY_SIZE(tps6586x->mask_reg); i++) {
 362                 if (tps6586x->mask_reg[i] != tps6586x->mask_cache[i]) {
 363                         if (!WARN_ON(tps6586x_write(tps6586x->dev,
 364                                                     TPS6586X_INT_MASK1 + i,
 365                                                     tps6586x->mask_reg[i])))
 366                                 tps6586x->mask_cache[i] = tps6586x->mask_reg[i];
 367                 }
 368         }
 369
 370         mutex_unlock(&tps6586x->irq_lock);
 371 }
 372
 373 static irqreturn_t tps6586x_irq(int irq, void *data)
 374 {
 375         struct tps6586x *tps6586x = data;
 376         u32 acks;
 377         int ret = 0;
 378
 379         ret = tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1,
 380                              sizeof(acks), (uint8_t *)&acks);
 381
 382         if (ret < 0) {
 383                 dev_err(tps6586x->dev, "failed to read interrupt status\n");
 384                 return IRQ_NONE;
 385         }
 386
 387         acks = le32_to_cpu(acks);
 388
 389         while (acks) {
 390                 int i = __ffs(acks);
 391
 392                 if (tps6586x->irq_en & (1 << i))
 393                         handle_nested_irq(tps6586x->irq_base + i);
 394
 395                 acks &= ~(1 << i);
 396         }
 397
 398         return IRQ_HANDLED;
 399 }
 400
 401 static int __devinit tps6586x_irq_init(struct tps6586x *tps6586x, int irq,
 402                                        int irq_base)
 403 {
 404         int i, ret;
 405         u8 tmp[4];
 406
 407         if (!irq_base) {
 408                 dev_warn(tps6586x->dev, "No interrupt support on IRQ base\n");
 409                 return -EINVAL;
 410         }
 411
 412         mutex_init(&tps6586x->irq_lock);
 413         for (i = 0; i < 5; i++) {
 414                 tps6586x->mask_cache[i] = 0xff;
 415                 tps6586x->mask_reg[i] = 0xff;
 416                 tps6586x_write(tps6586x->dev, TPS6586X_INT_MASK1 + i, 0xff);
 417         }
 418
 419         tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1, sizeof(tmp), tmp);
 420
 421         tps6586x->irq_base = irq_base;
 422
 423         tps6586x->irq_chip.name = "tps6586x";
 424         tps6586x->irq_chip.enable = tps6586x_irq_enable;
 425         tps6586x->irq_chip.disable = tps6586x_irq_disable;
 426         tps6586x->irq_chip.bus_lock = tps6586x_irq_lock;
 427         tps6586x->irq_chip.bus_sync_unlock = tps6586x_irq_sync_unlock;
 428
 429         for (i = 0; i < ARRAY_SIZE(tps6586x_irqs); i++) {
 430                 int __irq = i + tps6586x->irq_base;
 431                 set_irq_chip_data(__irq, tps6586x);
 432                 set_irq_chip_and_handler(__irq, &tps6586x->irq_chip,
 433                                          handle_simple_irq);
 434                 set_irq_nested_thread(__irq, 1);
 435 #ifdef CONFIG_ARM
 436                 set_irq_flags(__irq, IRQF_VALID);
 437 #endif
 438         }
 439
 440         ret = request_threaded_irq(irq, NULL, tps6586x_irq, IRQF_ONESHOT,
 441                                    "tps6586x", tps6586x);
 442
 443         if (!ret) {
 444                 device_init_wakeup(tps6586x->dev, 1);
 445                 enable_irq_wake(irq);
 446         }
 447
 448         return ret;
 449 }
 450
 451 static int __devinit tps6586x_add_subdevs(struct tps6586x *tps6586x,
 452                                           struct tps6586x_platform_data *pdata)
 453 {
 454         struct tps6586x_subdev_info *subdev;
 455         struct platform_device *pdev;
 456         int i, ret = 0;
 457
 458         for (i = 0; i < pdata->num_subdevs; i++) {
 459                 subdev = &pdata->subdevs[i];
 460
 461                 pdev = platform_device_alloc(subdev->name, subdev->id);
 462                 if (!pdev) {
 463                         ret = -ENOMEM;
 464                         goto failed;
 465                 }
 466
 467                 pdev->dev.parent = tps6586x->dev;
 468                 pdev->dev.platform_data = subdev->platform_data;
 469
 470                 ret = platform_device_add(pdev);
 471                 if (ret) {
 472                         platform_device_put(pdev);
 473                         goto failed;
 474                 }
 475         }
 476         return 0;
 477
 478 failed:
 479         tps6586x_remove_subdevs(tps6586x);
 480         return ret;
 481 }
 482
 483 static int __devinit tps6586x_i2c_probe(struct i2c_client *client,
 484                                         const struct i2c_device_id *id)
 485 {
 486         struct tps6586x_platform_data *pdata = client->dev.platform_data;
 487         struct tps6586x *tps6586x;
 488         int ret;
 489
 490         if (!pdata) {
 491                 dev_err(&client->dev, "tps6586x requires platform data\n");
 492                 return -ENOTSUPP;
 493         }
 494
 495         ret = i2c_smbus_read_byte_data(client, TPS6586X_VERSIONCRC);
 496         if (ret < 0) {
 497                 dev_err(&client->dev, "Chip ID read failed: %d\n", ret);
 498                 return -EIO;
 499         }
 500
 501         if ((ret != TPS658621A_VERSIONCRC) &&
 502             (ret != TPS658621C_VERSIONCRC)) {
 503                 dev_err(&client->dev, "Unsupported chip ID: %x\n", ret);
 504                 return -ENODEV;
 505         }
 506
 507         tps6586x = kzalloc(sizeof(struct tps6586x), GFP_KERNEL);
 508         if (tps6586x == NULL)
 509                 return -ENOMEM;
 510
 511         tps6586x->client = client;
 512         tps6586x->dev = &client->dev;
 513         i2c_set_clientdata(client, tps6586x);
 514
 515         mutex_init(&tps6586x->lock);
 516
 517         if (client->irq) {
 518                 ret = tps6586x_irq_init(tps6586x, client->irq,
 519                                         pdata->irq_base);
 520                 if (ret) {
 521                         dev_err(&client->dev, "IRQ init failed: %d\n", ret);
 522                         goto err_irq_init;
 523                 }
 524         }
 525
 526         ret = tps6586x_add_subdevs(tps6586x, pdata);
 527         if (ret) {
 528                 dev_err(&client->dev, "add devices failed: %d\n", ret);
 529                 goto err_add_devs;
 530         }
 531
 532         tps6586x_gpio_init(tps6586x, pdata->gpio_base);
 533
 534         return 0;
 535
 536 err_add_devs:
 537         if (client->irq)
 538                 free_irq(client->irq, tps6586x);
 539 err_irq_init:
 540         kfree(tps6586x);
 541         return ret;
 542 }
 543
 544 static int __devexit tps6586x_i2c_remove(struct i2c_client *client)
 545 {
 546         struct tps6586x *tps6586x = i2c_get_clientdata(client);
 547         struct tps6586x_platform_data *pdata = client->dev.platform_data;
 548         int ret;
 549
 550         if (client->irq)
 551                 free_irq(client->irq, tps6586x);
 552
 553         if (pdata->gpio_base) {
 554                 ret = gpiochip_remove(&tps6586x->gpio);
 555                 if (ret)
 556                         dev_err(&client->dev, "Can't remove gpio chip: %d\n",
 557                                 ret);
 558         }
 559
 560         tps6586x_remove_subdevs(tps6586x);
 561         kfree(tps6586x);
 562         return 0;
 563 }
 564
 565 static const struct i2c_device_id tps6586x_id_table[] = {
 566         { "tps6586x", 0 },
 567         { },
 568 };
 569 MODULE_DEVICE_TABLE(i2c, tps6586x_id_table);
 570
 571 static struct i2c_driver tps6586x_driver = {
 572         .driver = {
 573                 .name   = "tps6586x",
 574                 .owner  = THIS_MODULE,
 575         },
 576         .probe          = tps6586x_i2c_probe,
 577         .remove         = __devexit_p(tps6586x_i2c_remove),
 578         .id_table       = tps6586x_id_table,
 579 };
 580
 581 static int __init tps6586x_init(void)
 582 {
 583         return i2c_add_driver(&tps6586x_driver);
 584 }
 585 subsys_initcall(tps6586x_init);
 586
 587 static void __exit tps6586x_exit(void)
 588 {
 589         i2c_del_driver(&tps6586x_driver);
 590 }
 591 module_exit(tps6586x_exit);
 592
 593 MODULE_DESCRIPTION("TPS6586X core driver");
 594 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 595 MODULE_LICENSE("GPL");
 596