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>
24 #include <linux/version.h>
26 #include <asm/mach-ath79/rb4xx_cpld.h>
28 #define DRV_NAME "spi-rb4xx-cpld"
29 #define DRV_DESC "RB4xx CPLD driver"
30 #define DRV_VERSION "0.1.0"
32 #define CPLD_CMD_WRITE_NAND 0x08 /* send cmd, n x send data, send indle */
33 #define CPLD_CMD_WRITE_CFG 0x09 /* send cmd, n x send cfg */
34 #define CPLD_CMD_READ_NAND 0x0a /* send cmd, send idle, n x read data */
35 #define CPLD_CMD_READ_FAST 0x0b /* send cmd, 4 x idle, n x read data */
36 #define CPLD_CMD_LED5_ON 0x0c /* send cmd */
37 #define CPLD_CMD_LED5_OFF 0x0d /* send cmd */
40 struct spi_device
*spi
;
42 struct gpio_chip chip
;
46 static struct rb4xx_cpld
*rb4xx_cpld
;
48 static inline struct rb4xx_cpld
*gpio_to_cpld(struct gpio_chip
*chip
)
50 return container_of(chip
, struct rb4xx_cpld
, chip
);
53 static int rb4xx_cpld_write_cmd(struct rb4xx_cpld
*cpld
, unsigned char cmd
)
55 struct spi_transfer t
[1];
57 unsigned char tx_buf
[1];
61 memset(&t
, 0, sizeof(t
));
64 t
[0].len
= sizeof(tx_buf
);
65 spi_message_add_tail(&t
[0], &m
);
69 err
= spi_sync(cpld
->spi
, &m
);
73 static int rb4xx_cpld_write_cfg(struct rb4xx_cpld
*cpld
, unsigned char config
)
75 struct spi_transfer t
[1];
81 memset(&t
, 0, sizeof(t
));
84 t
[0].len
= sizeof(cmd
);
85 spi_message_add_tail(&t
[0], &m
);
87 cmd
[0] = CPLD_CMD_WRITE_CFG
;
90 err
= spi_sync(cpld
->spi
, &m
);
94 static int __rb4xx_cpld_change_cfg(struct rb4xx_cpld
*cpld
, unsigned mask
,
100 config
= cpld
->config
& ~mask
;
103 if ((cpld
->config
^ config
) & 0xff) {
104 err
= rb4xx_cpld_write_cfg(cpld
, config
);
109 if ((cpld
->config
^ config
) & CPLD_CFG_nLED5
) {
110 err
= rb4xx_cpld_write_cmd(cpld
, (value
) ? CPLD_CMD_LED5_ON
:
116 cpld
->config
= config
;
120 int rb4xx_cpld_change_cfg(unsigned mask
, unsigned value
)
124 if (rb4xx_cpld
== NULL
)
127 mutex_lock(&rb4xx_cpld
->lock
);
128 ret
= __rb4xx_cpld_change_cfg(rb4xx_cpld
, mask
, value
);
129 mutex_unlock(&rb4xx_cpld
->lock
);
133 EXPORT_SYMBOL_GPL(rb4xx_cpld_change_cfg
);
135 int rb4xx_cpld_read(unsigned char *rx_buf
, unsigned count
)
137 static const unsigned char cmd
[2] = { CPLD_CMD_READ_NAND
, 0 };
138 struct spi_transfer t
[2] = {
147 struct spi_message m
;
149 if (rb4xx_cpld
== NULL
)
152 spi_message_init(&m
);
153 spi_message_add_tail(&t
[0], &m
);
154 spi_message_add_tail(&t
[1], &m
);
155 return spi_sync(rb4xx_cpld
->spi
, &m
);
157 EXPORT_SYMBOL_GPL(rb4xx_cpld_read
);
159 int rb4xx_cpld_write(const unsigned char *buf
, unsigned count
)
161 static const unsigned char cmd
= CPLD_CMD_WRITE_NAND
;
162 struct spi_transfer t
[3] = {
169 .tx_nbits
= SPI_NBITS_DUAL
,
172 .tx_nbits
= SPI_NBITS_DUAL
,
175 struct spi_message m
;
177 if (rb4xx_cpld
== NULL
)
180 spi_message_init(&m
);
181 spi_message_add_tail(&t
[0], &m
);
182 spi_message_add_tail(&t
[1], &m
);
183 spi_message_add_tail(&t
[2], &m
);
184 return spi_sync(rb4xx_cpld
->spi
, &m
);
186 EXPORT_SYMBOL_GPL(rb4xx_cpld_write
);
188 static int rb4xx_cpld_gpio_get(struct gpio_chip
*chip
, unsigned offset
)
190 struct rb4xx_cpld
*cpld
= gpio_to_cpld(chip
);
193 mutex_lock(&cpld
->lock
);
194 ret
= (cpld
->config
>> offset
) & 1;
195 mutex_unlock(&cpld
->lock
);
200 static void rb4xx_cpld_gpio_set(struct gpio_chip
*chip
, unsigned offset
,
203 struct rb4xx_cpld
*cpld
= gpio_to_cpld(chip
);
205 mutex_lock(&cpld
->lock
);
206 __rb4xx_cpld_change_cfg(cpld
, (1 << offset
), !!value
<< offset
);
207 mutex_unlock(&cpld
->lock
);
210 static int rb4xx_cpld_gpio_direction_input(struct gpio_chip
*chip
,
216 static int rb4xx_cpld_gpio_direction_output(struct gpio_chip
*chip
,
220 struct rb4xx_cpld
*cpld
= gpio_to_cpld(chip
);
223 mutex_lock(&cpld
->lock
);
224 ret
= __rb4xx_cpld_change_cfg(cpld
, (1 << offset
), !!value
<< offset
);
225 mutex_unlock(&cpld
->lock
);
230 static int rb4xx_cpld_gpio_init(struct rb4xx_cpld
*cpld
, unsigned int base
)
235 cpld
->config
= CPLD_CFG_nLED1
| CPLD_CFG_nLED2
| CPLD_CFG_nLED3
|
236 CPLD_CFG_nLED4
| CPLD_CFG_nCE
;
237 rb4xx_cpld_write_cfg(cpld
, cpld
->config
);
239 /* setup GPIO chip */
240 cpld
->chip
.label
= DRV_NAME
;
242 cpld
->chip
.get
= rb4xx_cpld_gpio_get
;
243 cpld
->chip
.set
= rb4xx_cpld_gpio_set
;
244 cpld
->chip
.direction_input
= rb4xx_cpld_gpio_direction_input
;
245 cpld
->chip
.direction_output
= rb4xx_cpld_gpio_direction_output
;
247 cpld
->chip
.base
= base
;
248 cpld
->chip
.ngpio
= CPLD_NUM_GPIOS
;
249 cpld
->chip
.can_sleep
= 1;
250 #if LINUX_VERSION_CODE < KERNEL_VERSION(4,5,0)
251 cpld
->chip
.dev
= &cpld
->spi
->dev
;
253 cpld
->chip
.parent
= &cpld
->spi
->dev
;
255 cpld
->chip
.owner
= THIS_MODULE
;
257 err
= gpiochip_add(&cpld
->chip
);
259 dev_err(&cpld
->spi
->dev
, "adding GPIO chip failed, err=%d\n",
265 static int rb4xx_cpld_probe(struct spi_device
*spi
)
267 struct rb4xx_cpld
*cpld
;
268 struct rb4xx_cpld_platform_data
*pdata
;
271 pdata
= spi
->dev
.platform_data
;
273 dev_dbg(&spi
->dev
, "no platform data\n");
277 cpld
= kzalloc(sizeof(*cpld
), GFP_KERNEL
);
279 dev_err(&spi
->dev
, "no memory for private data\n");
283 mutex_init(&cpld
->lock
);
284 cpld
->spi
= spi_dev_get(spi
);
285 dev_set_drvdata(&spi
->dev
, cpld
);
287 spi
->mode
= SPI_MODE_0
| SPI_TX_DUAL
;
288 spi
->bits_per_word
= 8;
289 err
= spi_setup(spi
);
291 dev_err(&spi
->dev
, "spi_setup failed, err=%d\n", err
);
295 err
= rb4xx_cpld_gpio_init(cpld
, pdata
->gpio_base
);
304 dev_set_drvdata(&spi
->dev
, NULL
);
310 static int rb4xx_cpld_remove(struct spi_device
*spi
)
312 struct rb4xx_cpld
*cpld
;
315 cpld
= dev_get_drvdata(&spi
->dev
);
316 dev_set_drvdata(&spi
->dev
, NULL
);
322 static struct spi_driver rb4xx_cpld_driver
= {
325 .bus
= &spi_bus_type
,
326 .owner
= THIS_MODULE
,
328 .probe
= rb4xx_cpld_probe
,
329 .remove
= rb4xx_cpld_remove
,
332 static int __init
rb4xx_cpld_init(void)
334 return spi_register_driver(&rb4xx_cpld_driver
);
336 module_init(rb4xx_cpld_init
);
338 static void __exit
rb4xx_cpld_exit(void)
340 spi_unregister_driver(&rb4xx_cpld_driver
);
342 module_exit(rb4xx_cpld_exit
);
344 MODULE_DESCRIPTION(DRV_DESC
);
345 MODULE_VERSION(DRV_VERSION
);
346 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
347 MODULE_LICENSE("GPL v2");