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"); 459