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 %3ph\n", buff);
  56
  57         return spi_write(st->us, buff, (st->nr_gpio == 16) ? 3 : 2);
  58 }
  59
  60 static inline int tle62x0_read(struct tle62x0_state *st)
  61 {
  62         unsigned char *txbuff = st->tx_buff;
  63         struct spi_transfer xfer = {
  64                 .tx_buf         = txbuff,
  65                 .rx_buf         = st->rx_buff,
  66                 .len            = (st->nr_gpio * 2) / 8,
  67         };
  68         struct spi_message msg;
  69
  70         txbuff[0] = CMD_READ;
  71         txbuff[1] = 0x00;
  72         txbuff[2] = 0x00;
  73         txbuff[3] = 0x00;
  74
  75         spi_message_init(&msg);
  76         spi_message_add_tail(&xfer, &msg);
  77
  78         return spi_sync(st->us, &msg);
  79 }
  80
  81 static unsigned char *decode_fault(unsigned int fault_code)
  82 {
  83         fault_code &= 3;
  84
  85         switch (fault_code) {
  86         case DIAG_NORMAL:
  87                 return "N";
  88         case DIAG_OVERLOAD:
  89                 return "V";
  90         case DIAG_OPEN:
  91                 return "O";
  92         case DIAG_SHORTGND:
  93                 return "G";
  94         }
  95
  96         return "?";
  97 }
  98
  99 static ssize_t tle62x0_status_show(struct device *dev,
 100                 struct device_attribute *attr, char *buf)
 101 {
 102         struct tle62x0_state *st = dev_get_drvdata(dev);
 103         char *bp = buf;
 104         unsigned char *buff = st->rx_buff;
 105         unsigned long fault = 0;
 106         int ptr;
 107         int ret;
 108
 109         mutex_lock(&st->lock);
 110         ret = tle62x0_read(st);
 111         dev_dbg(dev, "tle62x0_read() returned %d\n", ret);
 112         if (ret < 0) {
 113                 mutex_unlock(&st->lock);
 114                 return ret;
 115         }
 116
 117         for (ptr = 0; ptr < (st->nr_gpio * 2)/8; ptr += 1) {
 118                 fault <<= 8;
 119                 fault  |= ((unsigned long)buff[ptr]);
 120
 121                 dev_dbg(dev, "byte %d is %02x\n", ptr, buff[ptr]);
 122         }
 123
 124         for (ptr = 0; ptr < st->nr_gpio; ptr++) {
 125                 bp += sprintf(bp, "%s ", decode_fault(fault >> (ptr * 2)));
 126         }
 127
 128         *bp++ = '\n';
 129
 130         mutex_unlock(&st->lock);
 131         return bp - buf;
 132 }
 133
 134 static DEVICE_ATTR(status_show, S_IRUGO, tle62x0_status_show, NULL);
 135
 136 static ssize_t tle62x0_gpio_show(struct device *dev,
 137                 struct device_attribute *attr, char *buf)
 138 {
 139         struct tle62x0_state *st = dev_get_drvdata(dev);
 140         int gpio_num = to_gpio_num(attr);
 141         int value;
 142
 143         mutex_lock(&st->lock);
 144         value = (st->gpio_state >> gpio_num) & 1;
 145         mutex_unlock(&st->lock);
 146
 147         return snprintf(buf, PAGE_SIZE, "%d", value);
 148 }
 149
 150 static ssize_t tle62x0_gpio_store(struct device *dev,
 151                 struct device_attribute *attr,
 152                 const char *buf, size_t len)
 153 {
 154         struct tle62x0_state *st = dev_get_drvdata(dev);
 155         int gpio_num = to_gpio_num(attr);
 156         unsigned long val;
 157         char *endp;
 158
 159         val = simple_strtoul(buf, &endp, 0);
 160         if (buf == endp)
 161                 return -EINVAL;
 162
 163         dev_dbg(dev, "setting gpio %d to %ld\n", gpio_num, val);
 164
 165         mutex_lock(&st->lock);
 166
 167         if (val)
 168                 st->gpio_state |= 1 << gpio_num;
 169         else
 170                 st->gpio_state &= ~(1 << gpio_num);
 171
 172         tle62x0_write(st);
 173         mutex_unlock(&st->lock);
 174
 175         return len;
 176 }
 177
 178 static DEVICE_ATTR(gpio1, S_IWUSR|S_IRUGO,
 179                 tle62x0_gpio_show, tle62x0_gpio_store);
 180 static DEVICE_ATTR(gpio2, S_IWUSR|S_IRUGO,
 181                 tle62x0_gpio_show, tle62x0_gpio_store);
 182 static DEVICE_ATTR(gpio3, S_IWUSR|S_IRUGO,
 183                 tle62x0_gpio_show, tle62x0_gpio_store);
 184 static DEVICE_ATTR(gpio4, S_IWUSR|S_IRUGO,
 185                 tle62x0_gpio_show, tle62x0_gpio_store);
 186 static DEVICE_ATTR(gpio5, S_IWUSR|S_IRUGO,
 187                 tle62x0_gpio_show, tle62x0_gpio_store);
 188 static DEVICE_ATTR(gpio6, S_IWUSR|S_IRUGO,
 189                 tle62x0_gpio_show, tle62x0_gpio_store);
 190 static DEVICE_ATTR(gpio7, S_IWUSR|S_IRUGO,
 191                 tle62x0_gpio_show, tle62x0_gpio_store);
 192 static DEVICE_ATTR(gpio8, S_IWUSR|S_IRUGO,
 193                 tle62x0_gpio_show, tle62x0_gpio_store);
 194 static DEVICE_ATTR(gpio9, S_IWUSR|S_IRUGO,
 195                 tle62x0_gpio_show, tle62x0_gpio_store);
 196 static DEVICE_ATTR(gpio10, S_IWUSR|S_IRUGO,
 197                 tle62x0_gpio_show, tle62x0_gpio_store);
 198 static DEVICE_ATTR(gpio11, S_IWUSR|S_IRUGO,
 199                 tle62x0_gpio_show, tle62x0_gpio_store);
 200 static DEVICE_ATTR(gpio12, S_IWUSR|S_IRUGO,
 201                 tle62x0_gpio_show, tle62x0_gpio_store);
 202 static DEVICE_ATTR(gpio13, S_IWUSR|S_IRUGO,
 203                 tle62x0_gpio_show, tle62x0_gpio_store);
 204 static DEVICE_ATTR(gpio14, S_IWUSR|S_IRUGO,
 205                 tle62x0_gpio_show, tle62x0_gpio_store);
 206 static DEVICE_ATTR(gpio15, S_IWUSR|S_IRUGO,
 207                 tle62x0_gpio_show, tle62x0_gpio_store);
 208 static DEVICE_ATTR(gpio16, S_IWUSR|S_IRUGO,
 209                 tle62x0_gpio_show, tle62x0_gpio_store);
 210
 211 static struct device_attribute *gpio_attrs[] = {
 212         [0]             = &dev_attr_gpio1,
 213         [1]             = &dev_attr_gpio2,
 214         [2]             = &dev_attr_gpio3,
 215         [3]             = &dev_attr_gpio4,
 216         [4]             = &dev_attr_gpio5,
 217         [5]             = &dev_attr_gpio6,
 218         [6]             = &dev_attr_gpio7,
 219         [7]             = &dev_attr_gpio8,
 220         [8]             = &dev_attr_gpio9,
 221         [9]             = &dev_attr_gpio10,
 222         [10]            = &dev_attr_gpio11,
 223         [11]            = &dev_attr_gpio12,
 224         [12]            = &dev_attr_gpio13,
 225         [13]            = &dev_attr_gpio14,
 226         [14]            = &dev_attr_gpio15,
 227         [15]            = &dev_attr_gpio16
 228 };
 229
 230 static int to_gpio_num(struct device_attribute *attr)
 231 {
 232         int ptr;
 233
 234         for (ptr = 0; ptr < ARRAY_SIZE(gpio_attrs); ptr++) {
 235                 if (gpio_attrs[ptr] == attr)
 236                         return ptr;
 237         }
 238
 239         return -1;
 240 }
 241
 242 static int tle62x0_probe(struct spi_device *spi)
 243 {
 244         struct tle62x0_state *st;
 245         struct tle62x0_pdata *pdata;
 246         int ptr;
 247         int ret;
 248
 249         pdata = dev_get_platdata(&spi->dev);
 250         if (pdata == NULL) {
 251                 dev_err(&spi->dev, "no device data specified\n");
 252                 return -EINVAL;
 253         }
 254
 255         st = kzalloc(sizeof(struct tle62x0_state), GFP_KERNEL);
 256         if (st == NULL)
 257                 return -ENOMEM;
 258
 259         st->us = spi;
 260         st->nr_gpio = pdata->gpio_count;
 261         st->gpio_state = pdata->init_state;
 262
 263         mutex_init(&st->lock);
 264
 265         ret = device_create_file(&spi->dev, &dev_attr_status_show);
 266         if (ret) {
 267                 dev_err(&spi->dev, "cannot create status attribute\n");
 268                 goto err_status;
 269         }
 270
 271         for (ptr = 0; ptr < pdata->gpio_count; ptr++) {
 272                 ret = device_create_file(&spi->dev, gpio_attrs[ptr]);
 273                 if (ret) {
 274                         dev_err(&spi->dev, "cannot create gpio attribute\n");
 275                         goto err_gpios;
 276                 }
 277         }
 278
 279         /* tle62x0_write(st); */
 280         spi_set_drvdata(spi, st);
 281         return 0;
 282
 283  err_gpios:
 284         while (--ptr >= 0)
 285                 device_remove_file(&spi->dev, gpio_attrs[ptr]);
 286
 287         device_remove_file(&spi->dev, &dev_attr_status_show);
 288
 289  err_status:
 290         kfree(st);
 291         return ret;
 292 }
 293
 294 static int tle62x0_remove(struct spi_device *spi)
 295 {
 296         struct tle62x0_state *st = spi_get_drvdata(spi);
 297         int ptr;
 298
 299         for (ptr = 0; ptr < st->nr_gpio; ptr++)
 300                 device_remove_file(&spi->dev, gpio_attrs[ptr]);
 301
 302         device_remove_file(&spi->dev, &dev_attr_status_show);
 303         kfree(st);
 304         return 0;
 305 }
 306
 307 static struct spi_driver tle62x0_driver = {
 308         .driver = {
 309                 .name   = "tle62x0",
 310         },
 311         .probe          = tle62x0_probe,
 312         .remove         = tle62x0_remove,
 313 };
 314
 315 module_spi_driver(tle62x0_driver);
 316
 317 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
 318 MODULE_DESCRIPTION("TLE62x0 SPI driver");
 319 MODULE_LICENSE("GPL v2");
 320 MODULE_ALIAS("spi:tle62x0");