2 * SPI driver for the CPLD chip on the Mikrotik RB4xx boards
4 * Copyright (C) 2010 Gabor Juhos <juhosg@openwrt.org>
6 * This file was based on the patches for Linux 2.6.27.39 published by
7 * MikroTik for their RouterBoard 4xx series devices.
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.
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>
25 #include <asm/mach-ath79/rb4xx_cpld.h>
27 #define DRV_NAME "spi-rb4xx-cpld"
28 #define DRV_DESC "RB4xx CPLD driver"
29 #define DRV_VERSION "0.1.0"
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 */
39 struct spi_device *spi;
41 struct gpio_chip chip;
45 static struct rb4xx_cpld *rb4xx_cpld;
47 static inline struct rb4xx_cpld *gpio_to_cpld(struct gpio_chip *chip)
49 return container_of(chip, struct rb4xx_cpld, chip);
52 static int rb4xx_cpld_write_cmd(struct rb4xx_cpld *cpld, unsigned char cmd)
54 struct spi_transfer t[1];
56 unsigned char tx_buf[1];
60 memset(&t, 0, sizeof(t));
63 t[0].len = sizeof(tx_buf);
64 spi_message_add_tail(&t[0], &m);
68 err = spi_sync(cpld->spi, &m);
72 static int rb4xx_cpld_write_cfg(struct rb4xx_cpld *cpld, unsigned char config)
74 struct spi_transfer t[1];
80 memset(&t, 0, sizeof(t));
83 t[0].len = sizeof(cmd);
84 spi_message_add_tail(&t[0], &m);
86 cmd[0] = CPLD_CMD_WRITE_CFG;
89 err = spi_sync(cpld->spi, &m);
93 static int __rb4xx_cpld_change_cfg(struct rb4xx_cpld *cpld, unsigned mask,
99 config = cpld->config & ~mask;
102 if ((cpld->config ^ config) & 0xff) {
103 err = rb4xx_cpld_write_cfg(cpld, config);
108 if ((cpld->config ^ config) & CPLD_CFG_nLED5) {
109 err = rb4xx_cpld_write_cmd(cpld, (value) ? CPLD_CMD_LED5_ON :
115 cpld->config = config;
119 int rb4xx_cpld_change_cfg(unsigned mask, unsigned value)
123 if (rb4xx_cpld == NULL)
126 mutex_lock(&rb4xx_cpld->lock);
127 ret = __rb4xx_cpld_change_cfg(rb4xx_cpld, mask, value);
128 mutex_unlock(&rb4xx_cpld->lock);
132 EXPORT_SYMBOL_GPL(rb4xx_cpld_change_cfg);
134 int rb4xx_cpld_read_from(unsigned addr, unsigned char *rx_buf,
135 const unsigned char *verify_buf, unsigned count)
137 const unsigned char cmd[5] = {
144 struct spi_transfer t[2] = {
150 .tx_buf = verify_buf,
153 .verify = (verify_buf != NULL),
156 struct spi_message m;
158 if (rb4xx_cpld == NULL)
161 spi_message_init(&m);
163 spi_message_add_tail(&t[0], &m);
164 spi_message_add_tail(&t[1], &m);
165 return spi_sync(rb4xx_cpld->spi, &m);
167 EXPORT_SYMBOL_GPL(rb4xx_cpld_read_from);
170 int rb4xx_cpld_read(unsigned char *buf, unsigned char *verify_buf,
173 struct spi_transfer t[2];
174 struct spi_message m;
175 unsigned char cmd[2];
177 if (rb4xx_cpld == NULL)
180 spi_message_init(&m);
181 memset(&t, 0, sizeof(t));
185 t[0].len = sizeof(cmd);
186 spi_message_add_tail(&t[0], &m);
188 cmd[0] = CPLD_CMD_READ_NAND;
194 spi_message_add_tail(&t[1], &m);
196 return spi_sync(rb4xx_cpld->spi, &m);
199 int rb4xx_cpld_read(unsigned char *rx_buf, const unsigned char *verify_buf,
202 static const unsigned char cmd[2] = { CPLD_CMD_READ_NAND, 0 };
203 struct spi_transfer t[2] = {
208 .tx_buf = verify_buf,
211 .verify = (verify_buf != NULL),
214 struct spi_message m;
216 if (rb4xx_cpld == NULL)
219 spi_message_init(&m);
220 spi_message_add_tail(&t[0], &m);
221 spi_message_add_tail(&t[1], &m);
222 return spi_sync(rb4xx_cpld->spi, &m);
225 EXPORT_SYMBOL_GPL(rb4xx_cpld_read);
227 int rb4xx_cpld_write(const unsigned char *buf, unsigned count)
230 struct spi_transfer t[3];
231 struct spi_message m;
232 unsigned char cmd[1];
234 if (rb4xx_cpld == NULL)
237 memset(&t, 0, sizeof(t));
238 spi_message_init(&m);
242 t[0].len = sizeof(cmd);
243 spi_message_add_tail(&t[0], &m);
245 cmd[0] = CPLD_CMD_WRITE_NAND;
250 spi_message_add_tail(&t[1], &m);
254 spi_message_add_tail(&t[2], &m);
256 return spi_sync(rb4xx_cpld->spi, &m);
258 static const unsigned char cmd = CPLD_CMD_WRITE_NAND;
259 struct spi_transfer t[3] = {
272 struct spi_message m;
274 if (rb4xx_cpld == NULL)
277 spi_message_init(&m);
278 spi_message_add_tail(&t[0], &m);
279 spi_message_add_tail(&t[1], &m);
280 spi_message_add_tail(&t[2], &m);
281 return spi_sync(rb4xx_cpld->spi, &m);
284 EXPORT_SYMBOL_GPL(rb4xx_cpld_write);
286 static int rb4xx_cpld_gpio_get(struct gpio_chip *chip, unsigned offset)
288 struct rb4xx_cpld *cpld = gpio_to_cpld(chip);
291 mutex_lock(&cpld->lock);
292 ret = (cpld->config >> offset) & 1;
293 mutex_unlock(&cpld->lock);
298 static void rb4xx_cpld_gpio_set(struct gpio_chip *chip, unsigned offset,
301 struct rb4xx_cpld *cpld = gpio_to_cpld(chip);
303 mutex_lock(&cpld->lock);
304 __rb4xx_cpld_change_cfg(cpld, (1 << offset), !!value << offset);
305 mutex_unlock(&cpld->lock);
308 static int rb4xx_cpld_gpio_direction_input(struct gpio_chip *chip,
314 static int rb4xx_cpld_gpio_direction_output(struct gpio_chip *chip,
318 struct rb4xx_cpld *cpld = gpio_to_cpld(chip);
321 mutex_lock(&cpld->lock);
322 ret = __rb4xx_cpld_change_cfg(cpld, (1 << offset), !!value << offset);
323 mutex_unlock(&cpld->lock);
328 static int rb4xx_cpld_gpio_init(struct rb4xx_cpld *cpld, unsigned int base)
333 cpld->config = CPLD_CFG_nLED1 | CPLD_CFG_nLED2 | CPLD_CFG_nLED3 |
334 CPLD_CFG_nLED4 | CPLD_CFG_nCE;
335 rb4xx_cpld_write_cfg(cpld, cpld->config);
337 /* setup GPIO chip */
338 cpld->chip.label = DRV_NAME;
340 cpld->chip.get = rb4xx_cpld_gpio_get;
341 cpld->chip.set = rb4xx_cpld_gpio_set;
342 cpld->chip.direction_input = rb4xx_cpld_gpio_direction_input;
343 cpld->chip.direction_output = rb4xx_cpld_gpio_direction_output;
345 cpld->chip.base = base;
346 cpld->chip.ngpio = CPLD_NUM_GPIOS;
347 cpld->chip.can_sleep = 1;
348 cpld->chip.dev = &cpld->spi->dev;
349 cpld->chip.owner = THIS_MODULE;
351 err = gpiochip_add(&cpld->chip);
353 dev_err(&cpld->spi->dev, "adding GPIO chip failed, err=%d\n",
359 static int rb4xx_cpld_probe(struct spi_device *spi)
361 struct rb4xx_cpld *cpld;
362 struct rb4xx_cpld_platform_data *pdata;
365 pdata = spi->dev.platform_data;
367 dev_dbg(&spi->dev, "no platform data\n");
371 cpld = kzalloc(sizeof(*cpld), GFP_KERNEL);
373 dev_err(&spi->dev, "no memory for private data\n");
377 mutex_init(&cpld->lock);
378 cpld->spi = spi_dev_get(spi);
379 dev_set_drvdata(&spi->dev, cpld);
381 spi->mode = SPI_MODE_0;
382 spi->bits_per_word = 8;
383 err = spi_setup(spi);
385 dev_err(&spi->dev, "spi_setup failed, err=%d\n", err);
389 err = rb4xx_cpld_gpio_init(cpld, pdata->gpio_base);
398 dev_set_drvdata(&spi->dev, NULL);
404 static int rb4xx_cpld_remove(struct spi_device *spi)
406 struct rb4xx_cpld *cpld;
409 cpld = dev_get_drvdata(&spi->dev);
410 dev_set_drvdata(&spi->dev, NULL);
416 static struct spi_driver rb4xx_cpld_driver = {
419 .bus = &spi_bus_type,
420 .owner = THIS_MODULE,
422 .probe = rb4xx_cpld_probe,
423 .remove = rb4xx_cpld_remove,
426 static int __init rb4xx_cpld_init(void)
428 return spi_register_driver(&rb4xx_cpld_driver);
430 module_init(rb4xx_cpld_init);
432 static void __exit rb4xx_cpld_exit(void)
434 spi_unregister_driver(&rb4xx_cpld_driver);
436 module_exit(rb4xx_cpld_exit);
438 MODULE_DESCRIPTION(DRV_DESC);
439 MODULE_VERSION(DRV_VERSION);
440 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
441 MODULE_LICENSE("GPL v2");