drivers/spi/spi-tle62x0.c

   1 /*
   2  * Support Infineon TLE62x0 driver chips
   3  *
   4  * Copyright (c) 2007 Simtec Electronics
   5  *      Ben Dooks, <ben@simtec.co.uk>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/device.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16
  17 #include <linux/spi/spi.h>
  18 #include <linux/spi/tle62x0.h>
  19
  20
  21 #define CMD_READ        0x00
  22 #define CMD_SET         0xff
  23
  24 #define DIAG_NORMAL     0x03
  25 #define DIAG_OVERLOAD   0x02
  26 #define DIAG_OPEN       0x01
  27 #define DIAG_SHORTGND   0x00
  28
  29 struct tle62x0_state {
  30         struct spi_device       *us;
  31         struct mutex            lock;
  32         unsigned int            nr_gpio;
  33         unsigned int            gpio_state;
  34
  35         unsigned char           tx_buff[4];
  36         unsigned char           rx_buff[4];
  37 };
  38
  39 static int to_gpio_num(struct device_attribute *attr);
  40
  41 static inline int tle62x0_write(struct tle62x0_state *st)
  42 {
  43         unsigned char *buff = st->tx_buff;
  44         unsigned int gpio_state = st->gpio_state;
  45
  46         buff[0] = CMD_SET;
  47
  48         if (st->nr_gpio == 16) {
  49                 buff[1] = gpio_state >> 8;
  50                 buff[2] = gpio_state;
  51         } else {
  52                 buff[1] = gpio_state;
  53         }
  54
  55         dev_dbg(&st->us->dev, "buff %02x,%02x,%02x\n",
  56                 buff[0], buff[1], buff[2]);
  57
  58         return spi_write(st->us, buff, (st->nr_gpio == 16) ? 3 : 2);
  59 }
  60
  61 static inline int tle62x0_read(struct tle62x0_state *st)
  62 {
  63         unsigned char *txbuff = st->tx_buff;
  64         struct spi_transfer xfer = {
  65                 .tx_buf         = txbuff,
  66                 .rx_buf         = st->rx_buff,
  67                 .len            = (st->nr_gpio * 2) / 8,
  68         };
  69         struct spi_message msg;
  70
  71         txbuff[0] = CMD_READ;
  72         txbuff[1] = 0x00;
  73         txbuff[2] = 0x00;
  74         txbuff[3] = 0x00;
  75
  76         spi_message_init(&msg);
  77         spi_message_add_tail(&xfer, &msg);
  78
  79         return spi_sync(st->us, &msg);
  80 }
  81
  82 static unsigned char *decode_fault(unsigned int fault_code)
  83 {
  84         fault_code &= 3;
  85
  86         switch (fault_code) {
  87         case DIAG_NORMAL:
  88                 return "N";
  89         case DIAG_OVERLOAD:
  90                 return "V";
  91         case DIAG_OPEN:
  92                 return "O";
  93         case DIAG_SHORTGND:
  94                 return "G";
  95         }
  96
  97         return "?";
  98 }
  99
 100 static ssize_t tle62x0_status_show(struct device *dev,
 101                 struct device_attribute *attr, char *buf)
 102 {
 103         struct tle62x0_state *st = dev_get_drvdata(dev);
 104         char *bp = buf;
 105         unsigned char *buff = st->rx_buff;
 106         unsigned long fault = 0;
 107         int ptr;
 108         int ret;
 109
 110         mutex_lock(&st->lock);
 111         ret = tle62x0_read(st);
 112         dev_dbg(dev, "tle62x0_read() returned %d\n", ret);
 113         if (ret < 0) {
 114                 mutex_unlock(&st->lock);
 115                 return ret;
 116         }
 117
 118         for (ptr = 0; ptr < (st->nr_gpio * 2)/8; ptr += 1) {
 119                 fault <<= 8;
 120                 fault  |= ((unsigned long)buff[ptr]);
 121
 122                 dev_dbg(dev, "byte %d is %02x\n", ptr, buff[ptr]);
 123         }
 124
 125         for (ptr = 0; ptr < st->nr_gpio; ptr++) {
 126                 bp += sprintf(bp, "%s ", decode_fault(fault >> (ptr * 2)));
 127         }
 128
 129         *bp++ = '\n';
 130
 131         mutex_unlock(&st->lock);
 132         return bp - buf;
 133 }
 134
 135 static DEVICE_ATTR(status_show, S_IRUGO, tle62x0_status_show, NULL);
 136
 137 static ssize_t tle62x0_gpio_show(struct device *dev,
 138                 struct device_attribute *attr, char *buf)
 139 {
 140         struct tle62x0_state *st = dev_get_drvdata(dev);
 141         int gpio_num = to_gpio_num(attr);
 142         int value;
 143
 144         mutex_lock(&st->lock);
 145         value = (st->gpio_state >> gpio_num) & 1;
 146         mutex_unlock(&st->lock);
 147
 148         return snprintf(buf, PAGE_SIZE, "%d", value);
 149 }
 150
 151 static ssize_t tle62x0_gpio_store(struct device *dev,
 152                 struct device_attribute *attr,
 153                 const char *buf, size_t len)
 154 {
 155         struct tle62x0_state *st = dev_get_drvdata(dev);
 156         int gpio_num = to_gpio_num(attr);
 157         unsigned long val;
 158         char *endp;
 159
 160         val = simple_strtoul(buf, &endp, 0);
 161         if (buf == endp)
 162                 return -EINVAL;
 163
 164         dev_dbg(dev, "setting gpio %d to %ld\n", gpio_num, val);
 165
 166         mutex_lock(&st->lock);
 167
 168         if (val)
 169                 st->gpio_state |= 1 << gpio_num;
 170         else
 171                 st->gpio_state &= ~(1 << gpio_num);
 172
 173         tle62x0_write(st);
 174         mutex_unlock(&st->lock);
 175
 176         return len;
 177 }
 178
 179 static DEVICE_ATTR(gpio1, S_IWUSR|S_IRUGO,
 180                 tle62x0_gpio_show, tle62x0_gpio_store);
 181 static DEVICE_ATTR(gpio2, S_IWUSR|S_IRUGO,
 182                 tle62x0_gpio_show, tle62x0_gpio_store);
 183 static DEVICE_ATTR(gpio3, S_IWUSR|S_IRUGO,
 184                 tle62x0_gpio_show, tle62x0_gpio_store);
 185 static DEVICE_ATTR(gpio4, S_IWUSR|S_IRUGO,
 186                 tle62x0_gpio_show, tle62x0_gpio_store);
 187 static DEVICE_ATTR(gpio5, S_IWUSR|S_IRUGO,
 188                 tle62x0_gpio_show, tle62x0_gpio_store);
 189 static DEVICE_ATTR(gpio6, S_IWUSR|S_IRUGO,
 190                 tle62x0_gpio_show, tle62x0_gpio_store);
 191 static DEVICE_ATTR(gpio7, S_IWUSR|S_IRUGO,
 192                 tle62x0_gpio_show, tle62x0_gpio_store);
 193 static DEVICE_ATTR(gpio8, S_IWUSR|S_IRUGO,
 194                 tle62x0_gpio_show, tle62x0_gpio_store);
 195 static DEVICE_ATTR(gpio9, S_IWUSR|S_IRUGO,
 196                 tle62x0_gpio_show, tle62x0_gpio_store);
 197 static DEVICE_ATTR(gpio10, S_IWUSR|S_IRUGO,
 198                 tle62x0_gpio_show, tle62x0_gpio_store);
 199 static DEVICE_ATTR(gpio11, S_IWUSR|S_IRUGO,
 200                 tle62x0_gpio_show, tle62x0_gpio_store);
 201 static DEVICE_ATTR(gpio12, S_IWUSR|S_IRUGO,
 202                 tle62x0_gpio_show, tle62x0_gpio_store);
 203 static DEVICE_ATTR(gpio13, S_IWUSR|S_IRUGO,
 204                 tle62x0_gpio_show, tle62x0_gpio_store);
 205 static DEVICE_ATTR(gpio14, S_IWUSR|S_IRUGO,
 206                 tle62x0_gpio_show, tle62x0_gpio_store);
 207 static DEVICE_ATTR(gpio15, S_IWUSR|S_IRUGO,
 208                 tle62x0_gpio_show, tle62x0_gpio_store);
 209 static DEVICE_ATTR(gpio16, S_IWUSR|S_IRUGO,
 210                 tle62x0_gpio_show, tle62x0_gpio_store);
 211
 212 static struct device_attribute *gpio_attrs[] = {
 213         [0]             = &dev_attr_gpio1,
 214         [1]             = &dev_attr_gpio2,
 215         [2]             = &dev_attr_gpio3,
 216         [3]             = &dev_attr_gpio4,
 217         [4]             = &dev_attr_gpio5,
 218         [5]             = &dev_attr_gpio6,
 219         [6]             = &dev_attr_gpio7,
 220         [7]             = &dev_attr_gpio8,
 221         [8]             = &dev_attr_gpio9,
 222         [9]             = &dev_attr_gpio10,
 223         [10]            = &dev_attr_gpio11,
 224         [11]            = &dev_attr_gpio12,
 225         [12]            = &dev_attr_gpio13,
 226         [13]            = &dev_attr_gpio14,
 227         [14]            = &dev_attr_gpio15,
 228         [15]            = &dev_attr_gpio16
 229 };
 230
 231 static int to_gpio_num(struct device_attribute *attr)
 232 {
 233         int ptr;
 234
 235         for (ptr = 0; ptr < ARRAY_SIZE(gpio_attrs); ptr++) {
 236                 if (gpio_attrs[ptr] == attr)
 237                         return ptr;
 238         }
 239
 240         return -1;
 241 }
 242
 243 static int __devinit tle62x0_probe(struct spi_device *spi)
 244 {
 245         struct tle62x0_state *st;
 246         struct tle62x0_pdata *pdata;
 247         int ptr;
 248         int ret;
 249
 250         pdata = spi->dev.platform_data;
 251         if (pdata == NULL) {
 252                 dev_err(&spi->dev, "no device data specified\n");
 253                 return -EINVAL;
 254         }
 255
 256         st = kzalloc(sizeof(struct tle62x0_state), GFP_KERNEL);
 257         if (st == NULL) {
 258                 dev_err(&spi->dev, "no memory for device state\n");
 259                 return -ENOMEM;
 260         }
 261
 262         st->us = spi;
 263         st->nr_gpio = pdata->gpio_count;
 264         st->gpio_state = pdata->init_state;
 265
 266         mutex_init(&st->lock);
 267
 268         ret = device_create_file(&spi->dev, &dev_attr_status_show);
 269         if (ret) {
 270                 dev_err(&spi->dev, "cannot create status attribute\n");
 271                 goto err_status;
 272         }
 273
 274         for (ptr = 0; ptr < pdata->gpio_count; ptr++) {
 275                 ret = device_create_file(&spi->dev, gpio_attrs[ptr]);
 276                 if (ret) {
 277                         dev_err(&spi->dev, "cannot create gpio attribute\n");
 278                         goto err_gpios;
 279                 }
 280         }
 281
 282         /* tle62x0_write(st); */
 283         spi_set_drvdata(spi, st);
 284         return 0;
 285
 286  err_gpios:
 287         while (--ptr >= 0)
 288                 device_remove_file(&spi->dev, gpio_attrs[ptr]);
 289
 290         device_remove_file(&spi->dev, &dev_attr_status_show);
 291
 292  err_status:
 293         kfree(st);
 294         return ret;
 295 }
 296
 297 static int __devexit tle62x0_remove(struct spi_device *spi)
 298 {
 299         struct tle62x0_state *st = spi_get_drvdata(spi);
 300         int ptr;
 301
 302         for (ptr = 0; ptr < st->nr_gpio; ptr++)
 303                 device_remove_file(&spi->dev, gpio_attrs[ptr]);
 304
 305         device_remove_file(&spi->dev, &dev_attr_status_show);
 306         kfree(st);
 307         return 0;
 308 }
 309
 310 static struct spi_driver tle62x0_driver = {
 311         .driver = {
 312                 .name   = "tle62x0",
 313                 .owner  = THIS_MODULE,
 314         },
 315         .probe          = tle62x0_probe,
 316         .remove         = __devexit_p(tle62x0_remove),
 317 };
 318
 319 static __init int tle62x0_init(void)
 320 {
 321         return spi_register_driver(&tle62x0_driver);
 322 }
 323
 324 static __exit void tle62x0_exit(void)
 325 {
 326         spi_unregister_driver(&tle62x0_driver);
 327 }
 328
 329 module_init(tle62x0_init);
 330 module_exit(tle62x0_exit);
 331
 332 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
 333 MODULE_DESCRIPTION("TLE62x0 SPI driver");
 334 MODULE_LICENSE("GPL v2");
 335 MODULE_ALIAS("spi:tle62x0");