1 /* 2 * Janz MODULbus VMOD-TTL GPIO Driver 3 * 4 * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation; either version 2 of the License, or (at your 9 * option) any later version. 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/interrupt.h> 16 #include <linux/delay.h> 17 #include <linux/platform_device.h> 18 #include <linux/io.h> 19 #include <linux/gpio.h> 20 #include <linux/slab.h> 21 22 #include <linux/mfd/janz.h> 23 24 #define DRV_NAME "janz-ttl" 25 26 #define PORTA_DIRECTION 0x23 27 #define PORTB_DIRECTION 0x2B 28 #define PORTC_DIRECTION 0x06 29 #define PORTA_IOCTL 0x24 30 #define PORTB_IOCTL 0x2C 31 #define PORTC_IOCTL 0x07 32 33 #define MASTER_INT_CTL 0x00 34 #define MASTER_CONF_CTL 0x01 35 36 #define CONF_PAE (1 << 2) 37 #define CONF_PBE (1 << 7) 38 #define CONF_PCE (1 << 4) 39 40 struct ttl_control_regs { 41 __be16 portc; 42 __be16 portb; 43 __be16 porta; 44 __be16 control; 45 }; 46 47 struct ttl_module { 48 struct gpio_chip gpio; 49 50 /* base address of registers */ 51 struct ttl_control_regs __iomem *regs; 52 53 u8 portc_shadow; 54 u8 portb_shadow; 55 u8 porta_shadow; 56 57 spinlock_t lock; 58 }; 59 60 static int ttl_get_value(struct gpio_chip *gpio, unsigned offset) 61 { 62 struct ttl_module *mod = dev_get_drvdata(gpio->dev); 63 u8 *shadow; 64 int ret; 65 66 if (offset < 8) { 67 shadow = &mod->porta_shadow; 68 } else if (offset < 16) { 69 shadow = &mod->portb_shadow; 70 offset -= 8; 71 } else { 72 shadow = &mod->portc_shadow; 73 offset -= 16; 74 } 75 76 spin_lock(&mod->lock); 77 ret = *shadow & (1 << offset); 78 spin_unlock(&mod->lock); 79 return ret; 80 } 81 82 static void ttl_set_value(struct gpio_chip *gpio, unsigned offset, int value) 83 { 84 struct ttl_module *mod = dev_get_drvdata(gpio->dev); 85 void __iomem *port; 86 u8 *shadow; 87 88 if (offset < 8) { 89 port = &mod->regs->porta; 90 shadow = &mod->porta_shadow; 91 } else if (offset < 16) { 92 port = &mod->regs->portb; 93 shadow = &mod->portb_shadow; 94 offset -= 8; 95 } else { 96 port = &mod->regs->portc; 97 shadow = &mod->portc_shadow; 98 offset -= 16; 99 } 100 101 spin_lock(&mod->lock); 102 if (value) 103 *shadow |= (1 << offset); 104 else 105 *shadow &= ~(1 << offset); 106 107 iowrite16be(*shadow, port); 108 spin_unlock(&mod->lock); 109 } 110 111 static void ttl_write_reg(struct ttl_module *mod, u8 reg, u16 val) 112 { 113 iowrite16be(reg, &mod->regs->control); 114 iowrite16be(val, &mod->regs->control); 115 } 116 117 static void ttl_setup_device(struct ttl_module *mod) 118 { 119 /* reset the device to a known state */ 120 iowrite16be(0x0000, &mod->regs->control); 121 iowrite16be(0x0001, &mod->regs->control); 122 iowrite16be(0x0000, &mod->regs->control); 123 124 /* put all ports in open-drain mode */ 125 ttl_write_reg(mod, PORTA_IOCTL, 0x00ff); 126 ttl_write_reg(mod, PORTB_IOCTL, 0x00ff); 127 ttl_write_reg(mod, PORTC_IOCTL, 0x000f); 128 129 /* set all ports as outputs */ 130 ttl_write_reg(mod, PORTA_DIRECTION, 0x0000); 131 ttl_write_reg(mod, PORTB_DIRECTION, 0x0000); 132 ttl_write_reg(mod, PORTC_DIRECTION, 0x0000); 133 134 /* set all ports to drive zeroes */ 135 iowrite16be(0x0000, &mod->regs->porta); 136 iowrite16be(0x0000, &mod->regs->portb); 137 iowrite16be(0x0000, &mod->regs->portc); 138 139 /* enable all ports */ 140 ttl_write_reg(mod, MASTER_CONF_CTL, CONF_PAE | CONF_PBE | CONF_PCE); 141 } 142 143 static int ttl_probe(struct platform_device *pdev) 144 { 145 struct janz_platform_data *pdata; 146 struct device *dev = &pdev->dev; 147 struct ttl_module *mod; 148 struct gpio_chip *gpio; 149 struct resource *res; 150 int ret; 151 152 pdata = pdev->dev.platform_data; 153 if (!pdata) { 154 dev_err(dev, "no platform data\n"); 155 ret = -ENXIO; 156 goto out_return; 157 } 158 159 mod = kzalloc(sizeof(*mod), GFP_KERNEL); 160 if (!mod) { 161 dev_err(dev, "unable to allocate private data\n"); 162 ret = -ENOMEM; 163 goto out_return; 164 } 165 166 platform_set_drvdata(pdev, mod); 167 spin_lock_init(&mod->lock); 168 169 /* get access to the MODULbus registers for this module */ 170 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 171 if (!res) { 172 dev_err(dev, "MODULbus registers not found\n"); 173 ret = -ENODEV; 174 goto out_free_mod; 175 } 176 177 mod->regs = ioremap(res->start, resource_size(res)); 178 if (!mod->regs) { 179 dev_err(dev, "MODULbus registers not ioremap\n"); 180 ret = -ENOMEM; 181 goto out_free_mod; 182 } 183 184 ttl_setup_device(mod); 185 186 /* Initialize the GPIO data structures */ 187 gpio = &mod->gpio; 188 gpio->dev = &pdev->dev; 189 gpio->label = pdev->name; 190 gpio->get = ttl_get_value; 191 gpio->set = ttl_set_value; 192 gpio->owner = THIS_MODULE; 193 194 /* request dynamic allocation */ 195 gpio->base = -1; 196 gpio->ngpio = 20; 197 198 ret = gpiochip_add(gpio); 199 if (ret) { 200 dev_err(dev, "unable to add GPIO chip\n"); 201 goto out_iounmap_regs; 202 } 203 204 return 0; 205 206 out_iounmap_regs: 207 iounmap(mod->regs); 208 out_free_mod: 209 kfree(mod); 210 out_return: 211 return ret; 212 } 213 214 static int ttl_remove(struct platform_device *pdev) 215 { 216 struct ttl_module *mod = platform_get_drvdata(pdev); 217 struct device *dev = &pdev->dev; 218 int ret; 219 220 ret = gpiochip_remove(&mod->gpio); 221 if (ret) { 222 dev_err(dev, "unable to remove GPIO chip\n"); 223 return ret; 224 } 225 226 iounmap(mod->regs); 227 kfree(mod); 228 return 0; 229 } 230 231 static struct platform_driver ttl_driver = { 232 .driver = { 233 .name = DRV_NAME, 234 .owner = THIS_MODULE, 235 }, 236 .probe = ttl_probe, 237 .remove = ttl_remove, 238 }; 239 240 module_platform_driver(ttl_driver); 241 242 MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>"); 243 MODULE_DESCRIPTION("Janz MODULbus VMOD-TTL Driver"); 244 MODULE_LICENSE("GPL"); 245 MODULE_ALIAS("platform:janz-ttl"); 246