drivers/gpio/gpio-ts5500.c

   1 /*
   2  * Digital I/O driver for Technologic Systems TS-5500
   3  *
   4  * Copyright (c) 2012 Savoir-faire Linux Inc.
   5  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
   6  *
   7  * Technologic Systems platforms have pin blocks, exposing several Digital
   8  * Input/Output lines (DIO). This driver aims to support single pin blocks.
   9  * In that sense, the support is not limited to the TS-5500 blocks.
  10  * Actually, the following platforms have DIO support:
  11  *
  12  * TS-5500:
  13  *   Documentation: http://wiki.embeddedarm.com/wiki/TS-5500
  14  *   Blocks: DIO1, DIO2 and LCD port.
  15  *
  16  * TS-5600:
  17  *   Documentation: http://wiki.embeddedarm.com/wiki/TS-5600
  18  *   Blocks: LCD port (identical to TS-5500 LCD).
  19  *
  20  * This program is free software; you can redistribute it and/or modify
  21  * it under the terms of the GNU General Public License version 2 as
  22  * published by the Free Software Foundation.
  23  */
  24
  25 #include <linux/bitops.h>
  26 #include <linux/gpio.h>
  27 #include <linux/io.h>
  28 #include <linux/module.h>
  29 #include <linux/platform_data/gpio-ts5500.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/slab.h>
  32
  33 /* List of supported Technologic Systems platforms DIO blocks */
  34 enum ts5500_blocks { TS5500_DIO1, TS5500_DIO2, TS5500_LCD, TS5600_LCD };
  35
  36 struct ts5500_priv {
  37         const struct ts5500_dio *pinout;
  38         struct gpio_chip gpio_chip;
  39         spinlock_t lock;
  40         bool strap;
  41         u8 hwirq;
  42 };
  43
  44 /*
  45  * Hex 7D is used to control several blocks (e.g. DIO2 and LCD port).
  46  * This flag ensures that the region has been requested by this driver.
  47  */
  48 static bool hex7d_reserved;
  49
  50 /*
  51  * This structure is used to describe capabilities of DIO lines,
  52  * such as available directions and connected interrupt (if any).
  53  */
  54 struct ts5500_dio {
  55         const u8 value_addr;
  56         const u8 value_mask;
  57         const u8 control_addr;
  58         const u8 control_mask;
  59         const bool no_input;
  60         const bool no_output;
  61         const u8 irq;
  62 };
  63
  64 #define TS5500_DIO_IN_OUT(vaddr, vbit, caddr, cbit)     \
  65         {                                               \
  66                 .value_addr = vaddr,                    \
  67                 .value_mask = BIT(vbit),                \
  68                 .control_addr = caddr,                  \
  69                 .control_mask = BIT(cbit),              \
  70         }
  71
  72 #define TS5500_DIO_IN(addr, bit)                \
  73         {                                       \
  74                 .value_addr = addr,             \
  75                 .value_mask = BIT(bit),         \
  76                 .no_output = true,              \
  77         }
  78
  79 #define TS5500_DIO_IN_IRQ(addr, bit, _irq)      \
  80         {                                       \
  81                 .value_addr = addr,             \
  82                 .value_mask = BIT(bit),         \
  83                 .no_output = true,              \
  84                 .irq = _irq,                    \
  85         }
  86
  87 #define TS5500_DIO_OUT(addr, bit)               \
  88         {                                       \
  89                 .value_addr = addr,             \
  90                 .value_mask = BIT(bit),         \
  91                 .no_input = true,               \
  92         }
  93
  94 /*
  95  * Input/Output DIO lines are programmed in groups of 4. Their values are
  96  * available through 4 consecutive bits in a value port, whereas the direction
  97  * of these 4 lines is driven by only 1 bit in a control port.
  98  */
  99 #define TS5500_DIO_GROUP(vaddr, vbitfrom, caddr, cbit)          \
 100         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 0, caddr, cbit),    \
 101         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 1, caddr, cbit),    \
 102         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 2, caddr, cbit),    \
 103         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 3, caddr, cbit)
 104
 105 /*
 106  * TS-5500 DIO1 block
 107  *
 108  *  value    control  dir    hw
 109  *  addr bit addr bit in out irq name     pin offset
 110  *
 111  *  0x7b  0  0x7a  0  x   x      DIO1_0   1   0
 112  *  0x7b  1  0x7a  0  x   x      DIO1_1   3   1
 113  *  0x7b  2  0x7a  0  x   x      DIO1_2   5   2
 114  *  0x7b  3  0x7a  0  x   x      DIO1_3   7   3
 115  *  0x7b  4  0x7a  1  x   x      DIO1_4   9   4
 116  *  0x7b  5  0x7a  1  x   x      DIO1_5   11  5
 117  *  0x7b  6  0x7a  1  x   x      DIO1_6   13  6
 118  *  0x7b  7  0x7a  1  x   x      DIO1_7   15  7
 119  *  0x7c  0  0x7a  5  x   x      DIO1_8   4   8
 120  *  0x7c  1  0x7a  5  x   x      DIO1_9   6   9
 121  *  0x7c  2  0x7a  5  x   x      DIO1_10  8   10
 122  *  0x7c  3  0x7a  5  x   x      DIO1_11  10  11
 123  *  0x7c  4           x          DIO1_12  12  12
 124  *  0x7c  5           x      7   DIO1_13  14  13
 125  */
 126 static const struct ts5500_dio ts5500_dio1[] = {
 127         TS5500_DIO_GROUP(0x7b, 0, 0x7a, 0),
 128         TS5500_DIO_GROUP(0x7b, 4, 0x7a, 1),
 129         TS5500_DIO_GROUP(0x7c, 0, 0x7a, 5),
 130         TS5500_DIO_IN(0x7c, 4),
 131         TS5500_DIO_IN_IRQ(0x7c, 5, 7),
 132 };
 133
 134 /*
 135  * TS-5500 DIO2 block
 136  *
 137  *  value    control  dir    hw
 138  *  addr bit addr bit in out irq name     pin offset
 139  *
 140  *  0x7e  0  0x7d  0  x   x      DIO2_0   1   0
 141  *  0x7e  1  0x7d  0  x   x      DIO2_1   3   1
 142  *  0x7e  2  0x7d  0  x   x      DIO2_2   5   2
 143  *  0x7e  3  0x7d  0  x   x      DIO2_3   7   3
 144  *  0x7e  4  0x7d  1  x   x      DIO2_4   9   4
 145  *  0x7e  5  0x7d  1  x   x      DIO2_5   11  5
 146  *  0x7e  6  0x7d  1  x   x      DIO2_6   13  6
 147  *  0x7e  7  0x7d  1  x   x      DIO2_7   15  7
 148  *  0x7f  0  0x7d  5  x   x      DIO2_8   4   8
 149  *  0x7f  1  0x7d  5  x   x      DIO2_9   6   9
 150  *  0x7f  2  0x7d  5  x   x      DIO2_10  8   10
 151  *  0x7f  3  0x7d  5  x   x      DIO2_11  10  11
 152  *  0x7f  4           x      6   DIO2_13  14  12
 153  */
 154 static const struct ts5500_dio ts5500_dio2[] = {
 155         TS5500_DIO_GROUP(0x7e, 0, 0x7d, 0),
 156         TS5500_DIO_GROUP(0x7e, 4, 0x7d, 1),
 157         TS5500_DIO_GROUP(0x7f, 0, 0x7d, 5),
 158         TS5500_DIO_IN_IRQ(0x7f, 4, 6),
 159 };
 160
 161 /*
 162  * TS-5500 LCD port used as DIO block
 163  * TS-5600 LCD port is identical
 164  *
 165  *  value    control  dir    hw
 166  *  addr bit addr bit in out irq name    pin offset
 167  *
 168  *  0x72  0  0x7d  2  x   x      LCD_0   8   0
 169  *  0x72  1  0x7d  2  x   x      LCD_1   7   1
 170  *  0x72  2  0x7d  2  x   x      LCD_2   10  2
 171  *  0x72  3  0x7d  2  x   x      LCD_3   9   3
 172  *  0x72  4  0x7d  3  x   x      LCD_4   12  4
 173  *  0x72  5  0x7d  3  x   x      LCD_5   11  5
 174  *  0x72  6  0x7d  3  x   x      LCD_6   14  6
 175  *  0x72  7  0x7d  3  x   x      LCD_7   13  7
 176  *  0x73  0               x      LCD_EN  5   8
 177  *  0x73  6           x          LCD_WR  6   9
 178  *  0x73  7           x      1   LCD_RS  3   10
 179  */
 180 static const struct ts5500_dio ts5500_lcd[] = {
 181         TS5500_DIO_GROUP(0x72, 0, 0x7d, 2),
 182         TS5500_DIO_GROUP(0x72, 4, 0x7d, 3),
 183         TS5500_DIO_OUT(0x73, 0),
 184         TS5500_DIO_IN(0x73, 6),
 185         TS5500_DIO_IN_IRQ(0x73, 7, 1),
 186 };
 187
 188 static inline void ts5500_set_mask(u8 mask, u8 addr)
 189 {
 190         u8 val = inb(addr);
 191         val |= mask;
 192         outb(val, addr);
 193 }
 194
 195 static inline void ts5500_clear_mask(u8 mask, u8 addr)
 196 {
 197         u8 val = inb(addr);
 198         val &= ~mask;
 199         outb(val, addr);
 200 }
 201
 202 static int ts5500_gpio_input(struct gpio_chip *chip, unsigned offset)
 203 {
 204         struct ts5500_priv *priv = gpiochip_get_data(chip);
 205         const struct ts5500_dio line = priv->pinout[offset];
 206         unsigned long flags;
 207
 208         if (line.no_input)
 209                 return -ENXIO;
 210
 211         if (line.no_output)
 212                 return 0;
 213
 214         spin_lock_irqsave(&priv->lock, flags);
 215         ts5500_clear_mask(line.control_mask, line.control_addr);
 216         spin_unlock_irqrestore(&priv->lock, flags);
 217
 218         return 0;
 219 }
 220
 221 static int ts5500_gpio_get(struct gpio_chip *chip, unsigned offset)
 222 {
 223         struct ts5500_priv *priv = gpiochip_get_data(chip);
 224         const struct ts5500_dio line = priv->pinout[offset];
 225
 226         return !!(inb(line.value_addr) & line.value_mask);
 227 }
 228
 229 static int ts5500_gpio_output(struct gpio_chip *chip, unsigned offset, int val)
 230 {
 231         struct ts5500_priv *priv = gpiochip_get_data(chip);
 232         const struct ts5500_dio line = priv->pinout[offset];
 233         unsigned long flags;
 234
 235         if (line.no_output)
 236                 return -ENXIO;
 237
 238         spin_lock_irqsave(&priv->lock, flags);
 239         if (!line.no_input)
 240                 ts5500_set_mask(line.control_mask, line.control_addr);
 241
 242         if (val)
 243                 ts5500_set_mask(line.value_mask, line.value_addr);
 244         else
 245                 ts5500_clear_mask(line.value_mask, line.value_addr);
 246         spin_unlock_irqrestore(&priv->lock, flags);
 247
 248         return 0;
 249 }
 250
 251 static void ts5500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 252 {
 253         struct ts5500_priv *priv = gpiochip_get_data(chip);
 254         const struct ts5500_dio line = priv->pinout[offset];
 255         unsigned long flags;
 256
 257         spin_lock_irqsave(&priv->lock, flags);
 258         if (val)
 259                 ts5500_set_mask(line.value_mask, line.value_addr);
 260         else
 261                 ts5500_clear_mask(line.value_mask, line.value_addr);
 262         spin_unlock_irqrestore(&priv->lock, flags);
 263 }
 264
 265 static int ts5500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 266 {
 267         struct ts5500_priv *priv = gpiochip_get_data(chip);
 268         const struct ts5500_dio *block = priv->pinout;
 269         const struct ts5500_dio line = block[offset];
 270
 271         /* Only one pin is connected to an interrupt */
 272         if (line.irq)
 273                 return line.irq;
 274
 275         /* As this pin is input-only, we may strap it to another in/out pin */
 276         if (priv->strap)
 277                 return priv->hwirq;
 278
 279         return -ENXIO;
 280 }
 281
 282 static int ts5500_enable_irq(struct ts5500_priv *priv)
 283 {
 284         int ret = 0;
 285         unsigned long flags;
 286
 287         spin_lock_irqsave(&priv->lock, flags);
 288         if (priv->hwirq == 7)
 289                 ts5500_set_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
 290         else if (priv->hwirq == 6)
 291                 ts5500_set_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
 292         else if (priv->hwirq == 1)
 293                 ts5500_set_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
 294         else
 295                 ret = -EINVAL;
 296         spin_unlock_irqrestore(&priv->lock, flags);
 297
 298         return ret;
 299 }
 300
 301 static void ts5500_disable_irq(struct ts5500_priv *priv)
 302 {
 303         unsigned long flags;
 304
 305         spin_lock_irqsave(&priv->lock, flags);
 306         if (priv->hwirq == 7)
 307                 ts5500_clear_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
 308         else if (priv->hwirq == 6)
 309                 ts5500_clear_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
 310         else if (priv->hwirq == 1)
 311                 ts5500_clear_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
 312         else
 313                 dev_err(priv->gpio_chip.parent, "invalid hwirq %d\n",
 314                         priv->hwirq);
 315         spin_unlock_irqrestore(&priv->lock, flags);
 316 }
 317
 318 static int ts5500_dio_probe(struct platform_device *pdev)
 319 {
 320         enum ts5500_blocks block = platform_get_device_id(pdev)->driver_data;
 321         struct ts5500_dio_platform_data *pdata = dev_get_platdata(&pdev->dev);
 322         struct device *dev = &pdev->dev;
 323         const char *name = dev_name(dev);
 324         struct ts5500_priv *priv;
 325         struct resource *res;
 326         unsigned long flags;
 327         int ret;
 328
 329         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 330         if (!res) {
 331                 dev_err(dev, "missing IRQ resource\n");
 332                 return -EINVAL;
 333         }
 334
 335         priv = devm_kzalloc(dev, sizeof(struct ts5500_priv), GFP_KERNEL);
 336         if (!priv)
 337                 return -ENOMEM;
 338
 339         platform_set_drvdata(pdev, priv);
 340         priv->hwirq = res->start;
 341         spin_lock_init(&priv->lock);
 342
 343         priv->gpio_chip.owner = THIS_MODULE;
 344         priv->gpio_chip.label = name;
 345         priv->gpio_chip.parent = dev;
 346         priv->gpio_chip.direction_input = ts5500_gpio_input;
 347         priv->gpio_chip.direction_output = ts5500_gpio_output;
 348         priv->gpio_chip.get = ts5500_gpio_get;
 349         priv->gpio_chip.set = ts5500_gpio_set;
 350         priv->gpio_chip.to_irq = ts5500_gpio_to_irq;
 351         priv->gpio_chip.base = -1;
 352         if (pdata) {
 353                 priv->gpio_chip.base = pdata->base;
 354                 priv->strap = pdata->strap;
 355         }
 356
 357         switch (block) {
 358         case TS5500_DIO1:
 359                 priv->pinout = ts5500_dio1;
 360                 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio1);
 361
 362                 if (!devm_request_region(dev, 0x7a, 3, name)) {
 363                         dev_err(dev, "failed to request %s ports\n", name);
 364                         return -EBUSY;
 365                 }
 366                 break;
 367         case TS5500_DIO2:
 368                 priv->pinout = ts5500_dio2;
 369                 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio2);
 370
 371                 if (!devm_request_region(dev, 0x7e, 2, name)) {
 372                         dev_err(dev, "failed to request %s ports\n", name);
 373                         return -EBUSY;
 374                 }
 375
 376                 if (hex7d_reserved)
 377                         break;
 378
 379                 if (!devm_request_region(dev, 0x7d, 1, name)) {
 380                         dev_err(dev, "failed to request %s 7D\n", name);
 381                         return -EBUSY;
 382                 }
 383
 384                 hex7d_reserved = true;
 385                 break;
 386         case TS5500_LCD:
 387         case TS5600_LCD:
 388                 priv->pinout = ts5500_lcd;
 389                 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_lcd);
 390
 391                 if (!devm_request_region(dev, 0x72, 2, name)) {
 392                         dev_err(dev, "failed to request %s ports\n", name);
 393                         return -EBUSY;
 394                 }
 395
 396                 if (!hex7d_reserved) {
 397                         if (!devm_request_region(dev, 0x7d, 1, name)) {
 398                                 dev_err(dev, "failed to request %s 7D\n", name);
 399                                 return -EBUSY;
 400                         }
 401
 402                         hex7d_reserved = true;
 403                 }
 404
 405                 /* Ensure usage of LCD port as DIO */
 406                 spin_lock_irqsave(&priv->lock, flags);
 407                 ts5500_clear_mask(BIT(4), 0x7d);
 408                 spin_unlock_irqrestore(&priv->lock, flags);
 409                 break;
 410         }
 411
 412         ret = devm_gpiochip_add_data(dev, &priv->gpio_chip, priv);
 413         if (ret) {
 414                 dev_err(dev, "failed to register the gpio chip\n");
 415                 return ret;
 416         }
 417
 418         ret = ts5500_enable_irq(priv);
 419         if (ret) {
 420                 dev_err(dev, "invalid interrupt %d\n", priv->hwirq);
 421                 return ret;
 422         }
 423
 424         return 0;
 425 }
 426
 427 static int ts5500_dio_remove(struct platform_device *pdev)
 428 {
 429         struct ts5500_priv *priv = platform_get_drvdata(pdev);
 430
 431         ts5500_disable_irq(priv);
 432
 433         return 0;
 434 }
 435
 436 static const struct platform_device_id ts5500_dio_ids[] = {
 437         { "ts5500-dio1", TS5500_DIO1 },
 438         { "ts5500-dio2", TS5500_DIO2 },
 439         { "ts5500-dio-lcd", TS5500_LCD },
 440         { "ts5600-dio-lcd", TS5600_LCD },
 441         { }
 442 };
 443 MODULE_DEVICE_TABLE(platform, ts5500_dio_ids);
 444
 445 static struct platform_driver ts5500_dio_driver = {
 446         .driver = {
 447                 .name = "ts5500-dio",
 448         },
 449         .probe = ts5500_dio_probe,
 450         .remove = ts5500_dio_remove,
 451         .id_table = ts5500_dio_ids,
 452 };
 453
 454 module_platform_driver(ts5500_dio_driver);
 455
 456 MODULE_LICENSE("GPL");
 457 MODULE_AUTHOR("Savoir-faire Linux Inc. <kernel@savoirfairelinux.com>");
 458 MODULE_DESCRIPTION("Technologic Systems TS-5500 Digital I/O driver");