target/linux/ar71xx/files/drivers/spi/spi-rb4xx-cpld.c

   1 /*
   2  * SPI driver for the CPLD chip on the Mikrotik RB4xx boards
   3  *
   4  * Copyright (C) 2010 Gabor Juhos <juhosg@openwrt.org>
   5  *
   6  * This file was based on the patches for Linux 2.6.27.39 published by
   7  * MikroTik for their RouterBoard 4xx series devices.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License version 2 as published
  11  * by the Free Software Foundation.
  12  */
  13
  14 #include <linux/types.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/init.h>
  18 #include <linux/module.h>
  19 #include <linux/device.h>
  20 #include <linux/bitops.h>
  21 #include <linux/spi/spi.h>
  22 #include <linux/gpio.h>
  23 #include <linux/slab.h>
  24
  25 #include <asm/mach-ath79/rb4xx_cpld.h>
  26
  27 #define DRV_NAME        "spi-rb4xx-cpld"
  28 #define DRV_DESC        "RB4xx CPLD driver"
  29 #define DRV_VERSION     "0.1.0"
  30
  31 #define CPLD_CMD_WRITE_NAND     0x08 /* send cmd, n x send data, send indle */
  32 #define CPLD_CMD_WRITE_CFG      0x09 /* send cmd, n x send cfg */
  33 #define CPLD_CMD_READ_NAND      0x0a /* send cmd, send idle, n x read data */
  34 #define CPLD_CMD_READ_FAST      0x0b /* send cmd, 4 x idle, n x read data */
  35 #define CPLD_CMD_LED5_ON        0x0c /* send cmd */
  36 #define CPLD_CMD_LED5_OFF       0x0d /* send cmd */
  37
  38 struct rb4xx_cpld {
  39         struct spi_device       *spi;
  40         struct mutex            lock;
  41         struct gpio_chip        chip;
  42         unsigned int            config;
  43 };
  44
  45 static struct rb4xx_cpld *rb4xx_cpld;
  46
  47 static inline struct rb4xx_cpld *gpio_to_cpld(struct gpio_chip *chip)
  48 {
  49         return container_of(chip, struct rb4xx_cpld, chip);
  50 }
  51
  52 static int rb4xx_cpld_write_cmd(struct rb4xx_cpld *cpld, unsigned char cmd)
  53 {
  54         struct spi_transfer t[1];
  55         struct spi_message m;
  56         unsigned char tx_buf[1];
  57         int err;
  58
  59         spi_message_init(&m);
  60         memset(&t, 0, sizeof(t));
  61
  62         t[0].tx_buf = tx_buf;
  63         t[0].len = sizeof(tx_buf);
  64         spi_message_add_tail(&t[0], &m);
  65
  66         tx_buf[0] = cmd;
  67
  68         err = spi_sync(cpld->spi, &m);
  69         return err;
  70 }
  71
  72 static int rb4xx_cpld_write_cfg(struct rb4xx_cpld *cpld, unsigned char config)
  73 {
  74         struct spi_transfer t[1];
  75         struct spi_message m;
  76         unsigned char cmd[2];
  77         int err;
  78
  79         spi_message_init(&m);
  80         memset(&t, 0, sizeof(t));
  81
  82         t[0].tx_buf = cmd;
  83         t[0].len = sizeof(cmd);
  84         spi_message_add_tail(&t[0], &m);
  85
  86         cmd[0] = CPLD_CMD_WRITE_CFG;
  87         cmd[1] = config;
  88
  89         err = spi_sync(cpld->spi, &m);
  90         return err;
  91 }
  92
  93 static int __rb4xx_cpld_change_cfg(struct rb4xx_cpld *cpld, unsigned mask,
  94                                    unsigned value)
  95 {
  96         unsigned int config;
  97         int err;
  98
  99         config = cpld->config & ~mask;
 100         config |= value;
 101
 102         if ((cpld->config ^ config) & 0xff) {
 103                 err = rb4xx_cpld_write_cfg(cpld, config);
 104                 if (err)
 105                         return err;
 106         }
 107
 108         if ((cpld->config ^ config) & CPLD_CFG_nLED5) {
 109                 err = rb4xx_cpld_write_cmd(cpld, (value) ? CPLD_CMD_LED5_ON :
 110                                                            CPLD_CMD_LED5_OFF);
 111                 if (err)
 112                         return err;
 113         }
 114
 115         cpld->config = config;
 116         return 0;
 117 }
 118
 119 int rb4xx_cpld_change_cfg(unsigned mask, unsigned value)
 120 {
 121         int ret;
 122
 123         if (rb4xx_cpld == NULL)
 124                 return -ENODEV;
 125
 126         mutex_lock(&rb4xx_cpld->lock);
 127         ret = __rb4xx_cpld_change_cfg(rb4xx_cpld, mask, value);
 128         mutex_unlock(&rb4xx_cpld->lock);
 129
 130         return ret;
 131 }
 132 EXPORT_SYMBOL_GPL(rb4xx_cpld_change_cfg);
 133
 134 int rb4xx_cpld_read(unsigned char *rx_buf, unsigned count)
 135 {
 136         static const unsigned char cmd[2] = { CPLD_CMD_READ_NAND, 0 };
 137         struct spi_transfer t[2] = {
 138                 {
 139                         .tx_buf = &cmd,
 140                         .len = 2,
 141                 }, {
 142                         .rx_buf = rx_buf,
 143                         .len = count,
 144                 },
 145         };
 146         struct spi_message m;
 147
 148         if (rb4xx_cpld == NULL)
 149                 return -ENODEV;
 150
 151         spi_message_init(&m);
 152         spi_message_add_tail(&t[0], &m);
 153         spi_message_add_tail(&t[1], &m);
 154         return spi_sync(rb4xx_cpld->spi, &m);
 155 }
 156 EXPORT_SYMBOL_GPL(rb4xx_cpld_read);
 157
 158 int rb4xx_cpld_write(const unsigned char *buf, unsigned count)
 159 {
 160         static const unsigned char cmd = CPLD_CMD_WRITE_NAND;
 161         struct spi_transfer t[3] = {
 162                 {
 163                         .tx_buf = &cmd,
 164                         .len = 1,
 165                 }, {
 166                         .tx_buf = buf,
 167                         .len = count,
 168                         .tx_nbits = SPI_NBITS_DUAL,
 169                 }, {
 170                         .len = 1,
 171                         .tx_nbits = SPI_NBITS_DUAL,
 172                 },
 173         };
 174         struct spi_message m;
 175
 176         if (rb4xx_cpld == NULL)
 177                 return -ENODEV;
 178
 179         spi_message_init(&m);
 180         spi_message_add_tail(&t[0], &m);
 181         spi_message_add_tail(&t[1], &m);
 182         spi_message_add_tail(&t[2], &m);
 183         return spi_sync(rb4xx_cpld->spi, &m);
 184 }
 185 EXPORT_SYMBOL_GPL(rb4xx_cpld_write);
 186
 187 static int rb4xx_cpld_gpio_get(struct gpio_chip *chip, unsigned offset)
 188 {
 189         struct rb4xx_cpld *cpld = gpio_to_cpld(chip);
 190         int ret;
 191
 192         mutex_lock(&cpld->lock);
 193         ret = (cpld->config >> offset) & 1;
 194         mutex_unlock(&cpld->lock);
 195
 196         return ret;
 197 }
 198
 199 static void rb4xx_cpld_gpio_set(struct gpio_chip *chip, unsigned offset,
 200                                 int value)
 201 {
 202         struct rb4xx_cpld *cpld = gpio_to_cpld(chip);
 203
 204         mutex_lock(&cpld->lock);
 205         __rb4xx_cpld_change_cfg(cpld, (1 << offset), !!value << offset);
 206         mutex_unlock(&cpld->lock);
 207 }
 208
 209 static int rb4xx_cpld_gpio_direction_input(struct gpio_chip *chip,
 210                                            unsigned offset)
 211 {
 212         return -EOPNOTSUPP;
 213 }
 214
 215 static int rb4xx_cpld_gpio_direction_output(struct gpio_chip *chip,
 216                                             unsigned offset,
 217                                             int value)
 218 {
 219         struct rb4xx_cpld *cpld = gpio_to_cpld(chip);
 220         int ret;
 221
 222         mutex_lock(&cpld->lock);
 223         ret = __rb4xx_cpld_change_cfg(cpld, (1 << offset), !!value << offset);
 224         mutex_unlock(&cpld->lock);
 225
 226         return ret;
 227 }
 228
 229 static int rb4xx_cpld_gpio_init(struct rb4xx_cpld *cpld, unsigned int base)
 230 {
 231         int err;
 232
 233         /* init config */
 234         cpld->config = CPLD_CFG_nLED1 | CPLD_CFG_nLED2 | CPLD_CFG_nLED3 |
 235                        CPLD_CFG_nLED4 | CPLD_CFG_nCE;
 236         rb4xx_cpld_write_cfg(cpld, cpld->config);
 237
 238         /* setup GPIO chip */
 239         cpld->chip.label = DRV_NAME;
 240
 241         cpld->chip.get = rb4xx_cpld_gpio_get;
 242         cpld->chip.set = rb4xx_cpld_gpio_set;
 243         cpld->chip.direction_input = rb4xx_cpld_gpio_direction_input;
 244         cpld->chip.direction_output = rb4xx_cpld_gpio_direction_output;
 245
 246         cpld->chip.base = base;
 247         cpld->chip.ngpio = CPLD_NUM_GPIOS;
 248         cpld->chip.can_sleep = 1;
 249         cpld->chip.dev = &cpld->spi->dev;
 250         cpld->chip.owner = THIS_MODULE;
 251
 252         err = gpiochip_add(&cpld->chip);
 253         if (err)
 254                 dev_err(&cpld->spi->dev, "adding GPIO chip failed, err=%d\n",
 255                         err);
 256
 257         return err;
 258 }
 259
 260 static int rb4xx_cpld_probe(struct spi_device *spi)
 261 {
 262         struct rb4xx_cpld *cpld;
 263         struct rb4xx_cpld_platform_data *pdata;
 264         int err;
 265
 266         pdata = spi->dev.platform_data;
 267         if (!pdata) {
 268                 dev_dbg(&spi->dev, "no platform data\n");
 269                 return -EINVAL;
 270         }
 271
 272         cpld = kzalloc(sizeof(*cpld), GFP_KERNEL);
 273         if (!cpld) {
 274                 dev_err(&spi->dev, "no memory for private data\n");
 275                 return -ENOMEM;
 276         }
 277
 278         mutex_init(&cpld->lock);
 279         cpld->spi = spi_dev_get(spi);
 280         dev_set_drvdata(&spi->dev, cpld);
 281
 282         spi->mode = SPI_MODE_0;
 283         spi->bits_per_word = 8;
 284         err = spi_setup(spi);
 285         if (err) {
 286                 dev_err(&spi->dev, "spi_setup failed, err=%d\n", err);
 287                 goto err_drvdata;
 288         }
 289
 290         err = rb4xx_cpld_gpio_init(cpld, pdata->gpio_base);
 291         if (err)
 292                 goto err_drvdata;
 293
 294         rb4xx_cpld = cpld;
 295
 296         return 0;
 297
 298 err_drvdata:
 299         dev_set_drvdata(&spi->dev, NULL);
 300         kfree(cpld);
 301
 302         return err;
 303 }
 304
 305 static int rb4xx_cpld_remove(struct spi_device *spi)
 306 {
 307         struct rb4xx_cpld *cpld;
 308
 309         rb4xx_cpld = NULL;
 310         cpld = dev_get_drvdata(&spi->dev);
 311         dev_set_drvdata(&spi->dev, NULL);
 312         kfree(cpld);
 313
 314         return 0;
 315 }
 316
 317 static struct spi_driver rb4xx_cpld_driver = {
 318         .driver = {
 319                 .name           = DRV_NAME,
 320                 .bus            = &spi_bus_type,
 321                 .owner          = THIS_MODULE,
 322         },
 323         .probe          = rb4xx_cpld_probe,
 324         .remove         = rb4xx_cpld_remove,
 325 };
 326
 327 static int __init rb4xx_cpld_init(void)
 328 {
 329         return spi_register_driver(&rb4xx_cpld_driver);
 330 }
 331 module_init(rb4xx_cpld_init);
 332
 333 static void __exit rb4xx_cpld_exit(void)
 334 {
 335         spi_unregister_driver(&rb4xx_cpld_driver);
 336 }
 337 module_exit(rb4xx_cpld_exit);
 338
 339 MODULE_DESCRIPTION(DRV_DESC);
 340 MODULE_VERSION(DRV_VERSION);
 341 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
 342 MODULE_LICENSE("GPL v2");