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 struct ts5500_priv *ts5500_gc_to_priv(struct gpio_chip *chip) 189 { 190 return container_of(chip, struct ts5500_priv, gpio_chip); 191 } 192 193 static inline void ts5500_set_mask(u8 mask, u8 addr) 194 { 195 u8 val = inb(addr); 196 val |= mask; 197 outb(val, addr); 198 } 199 200 static inline void ts5500_clear_mask(u8 mask, u8 addr) 201 { 202 u8 val = inb(addr); 203 val &= ~mask; 204 outb(val, addr); 205 } 206 207 static int ts5500_gpio_input(struct gpio_chip *chip, unsigned offset) 208 { 209 struct ts5500_priv *priv = ts5500_gc_to_priv(chip); 210 const struct ts5500_dio line = priv->pinout[offset]; 211 unsigned long flags; 212 213 if (line.no_input) 214 return -ENXIO; 215 216 if (line.no_output) 217 return 0; 218 219 spin_lock_irqsave(&priv->lock, flags); 220 ts5500_clear_mask(line.control_mask, line.control_addr); 221 spin_unlock_irqrestore(&priv->lock, flags); 222 223 return 0; 224 } 225 226 static int ts5500_gpio_get(struct gpio_chip *chip, unsigned offset) 227 { 228 struct ts5500_priv *priv = ts5500_gc_to_priv(chip); 229 const struct ts5500_dio line = priv->pinout[offset]; 230 231 return !!(inb(line.value_addr) & line.value_mask); 232 } 233 234 static int ts5500_gpio_output(struct gpio_chip *chip, unsigned offset, int val) 235 { 236 struct ts5500_priv *priv = ts5500_gc_to_priv(chip); 237 const struct ts5500_dio line = priv->pinout[offset]; 238 unsigned long flags; 239 240 if (line.no_output) 241 return -ENXIO; 242 243 spin_lock_irqsave(&priv->lock, flags); 244 if (!line.no_input) 245 ts5500_set_mask(line.control_mask, line.control_addr); 246 247 if (val) 248 ts5500_set_mask(line.value_mask, line.value_addr); 249 else 250 ts5500_clear_mask(line.value_mask, line.value_addr); 251 spin_unlock_irqrestore(&priv->lock, flags); 252 253 return 0; 254 } 255 256 static void ts5500_gpio_set(struct gpio_chip *chip, unsigned offset, int val) 257 { 258 struct ts5500_priv *priv = ts5500_gc_to_priv(chip); 259 const struct ts5500_dio line = priv->pinout[offset]; 260 unsigned long flags; 261 262 spin_lock_irqsave(&priv->lock, flags); 263 if (val) 264 ts5500_set_mask(line.value_mask, line.value_addr); 265 else 266 ts5500_clear_mask(line.value_mask, line.value_addr); 267 spin_unlock_irqrestore(&priv->lock, flags); 268 } 269 270 static int ts5500_gpio_to_irq(struct gpio_chip *chip, unsigned offset) 271 { 272 struct ts5500_priv *priv = ts5500_gc_to_priv(chip); 273 const struct ts5500_dio *block = priv->pinout; 274 const struct ts5500_dio line = block[offset]; 275 276 /* Only one pin is connected to an interrupt */ 277 if (line.irq) 278 return line.irq; 279 280 /* As this pin is input-only, we may strap it to another in/out pin */ 281 if (priv->strap) 282 return priv->hwirq; 283 284 return -ENXIO; 285 } 286 287 static int ts5500_enable_irq(struct ts5500_priv *priv) 288 { 289 int ret = 0; 290 unsigned long flags; 291 292 spin_lock_irqsave(&priv->lock, flags); 293 if (priv->hwirq == 7) 294 ts5500_set_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */ 295 else if (priv->hwirq == 6) 296 ts5500_set_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */ 297 else if (priv->hwirq == 1) 298 ts5500_set_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */ 299 else 300 ret = -EINVAL; 301 spin_unlock_irqrestore(&priv->lock, flags); 302 303 return ret; 304 } 305 306 static void ts5500_disable_irq(struct ts5500_priv *priv) 307 { 308 unsigned long flags; 309 310 spin_lock_irqsave(&priv->lock, flags); 311 if (priv->hwirq == 7) 312 ts5500_clear_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */ 313 else if (priv->hwirq == 6) 314 ts5500_clear_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */ 315 else if (priv->hwirq == 1) 316 ts5500_clear_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */ 317 else 318 dev_err(priv->gpio_chip.parent, "invalid hwirq %d\n", 319 priv->hwirq); 320 spin_unlock_irqrestore(&priv->lock, flags); 321 } 322 323 static int ts5500_dio_probe(struct platform_device *pdev) 324 { 325 enum ts5500_blocks block = platform_get_device_id(pdev)->driver_data; 326 struct ts5500_dio_platform_data *pdata = dev_get_platdata(&pdev->dev); 327 struct device *dev = &pdev->dev; 328 const char *name = dev_name(dev); 329 struct ts5500_priv *priv; 330 struct resource *res; 331 unsigned long flags; 332 int ret; 333 334 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 335 if (!res) { 336 dev_err(dev, "missing IRQ resource\n"); 337 return -EINVAL; 338 } 339 340 priv = devm_kzalloc(dev, sizeof(struct ts5500_priv), GFP_KERNEL); 341 if (!priv) 342 return -ENOMEM; 343 344 platform_set_drvdata(pdev, priv); 345 priv->hwirq = res->start; 346 spin_lock_init(&priv->lock); 347 348 priv->gpio_chip.owner = THIS_MODULE; 349 priv->gpio_chip.label = name; 350 priv->gpio_chip.parent = dev; 351 priv->gpio_chip.direction_input = ts5500_gpio_input; 352 priv->gpio_chip.direction_output = ts5500_gpio_output; 353 priv->gpio_chip.get = ts5500_gpio_get; 354 priv->gpio_chip.set = ts5500_gpio_set; 355 priv->gpio_chip.to_irq = ts5500_gpio_to_irq; 356 priv->gpio_chip.base = -1; 357 if (pdata) { 358 priv->gpio_chip.base = pdata->base; 359 priv->strap = pdata->strap; 360 } 361 362 switch (block) { 363 case TS5500_DIO1: 364 priv->pinout = ts5500_dio1; 365 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio1); 366 367 if (!devm_request_region(dev, 0x7a, 3, name)) { 368 dev_err(dev, "failed to request %s ports\n", name); 369 return -EBUSY; 370 } 371 break; 372 case TS5500_DIO2: 373 priv->pinout = ts5500_dio2; 374 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio2); 375 376 if (!devm_request_region(dev, 0x7e, 2, name)) { 377 dev_err(dev, "failed to request %s ports\n", name); 378 return -EBUSY; 379 } 380 381 if (hex7d_reserved) 382 break; 383 384 if (!devm_request_region(dev, 0x7d, 1, name)) { 385 dev_err(dev, "failed to request %s 7D\n", name); 386 return -EBUSY; 387 } 388 389 hex7d_reserved = true; 390 break; 391 case TS5500_LCD: 392 case TS5600_LCD: 393 priv->pinout = ts5500_lcd; 394 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_lcd); 395 396 if (!devm_request_region(dev, 0x72, 2, name)) { 397 dev_err(dev, "failed to request %s ports\n", name); 398 return -EBUSY; 399 } 400 401 if (!hex7d_reserved) { 402 if (!devm_request_region(dev, 0x7d, 1, name)) { 403 dev_err(dev, "failed to request %s 7D\n", name); 404 return -EBUSY; 405 } 406 407 hex7d_reserved = true; 408 } 409 410 /* Ensure usage of LCD port as DIO */ 411 spin_lock_irqsave(&priv->lock, flags); 412 ts5500_clear_mask(BIT(4), 0x7d); 413 spin_unlock_irqrestore(&priv->lock, flags); 414 break; 415 } 416 417 ret = gpiochip_add(&priv->gpio_chip); 418 if (ret) { 419 dev_err(dev, "failed to register the gpio chip\n"); 420 return ret; 421 } 422 423 ret = ts5500_enable_irq(priv); 424 if (ret) { 425 dev_err(dev, "invalid interrupt %d\n", priv->hwirq); 426 goto cleanup; 427 } 428 429 return 0; 430 cleanup: 431 gpiochip_remove(&priv->gpio_chip); 432 return ret; 433 } 434 435 static int ts5500_dio_remove(struct platform_device *pdev) 436 { 437 struct ts5500_priv *priv = platform_get_drvdata(pdev); 438 439 ts5500_disable_irq(priv); 440 gpiochip_remove(&priv->gpio_chip); 441 return 0; 442 } 443 444 static const struct platform_device_id ts5500_dio_ids[] = { 445 { "ts5500-dio1", TS5500_DIO1 }, 446 { "ts5500-dio2", TS5500_DIO2 }, 447 { "ts5500-dio-lcd", TS5500_LCD }, 448 { "ts5600-dio-lcd", TS5600_LCD }, 449 { } 450 }; 451 MODULE_DEVICE_TABLE(platform, ts5500_dio_ids); 452 453 static struct platform_driver ts5500_dio_driver = { 454 .driver = { 455 .name = "ts5500-dio", 456 }, 457 .probe = ts5500_dio_probe, 458 .remove = ts5500_dio_remove, 459 .id_table = ts5500_dio_ids, 460 }; 461 462 module_platform_driver(ts5500_dio_driver); 463 464 MODULE_LICENSE("GPL"); 465 MODULE_AUTHOR("Savoir-faire Linux Inc. <kernel@savoirfairelinux.com>"); 466 MODULE_DESCRIPTION("Technologic Systems TS-5500 Digital I/O driver"); 467