Commit | Line | Data |
---|---|---|
447aef1a | 1 | /* |
ca632f55 | 2 | * Support Infineon TLE62x0 driver chips |
447aef1a BD |
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> | |
d7614de4 | 14 | #include <linux/module.h> |
5a0e3ad6 | 15 | #include <linux/slab.h> |
447aef1a BD |
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 | ||
cd4c4244 | 55 | dev_dbg(&st->us->dev, "buff %3ph\n", buff); |
447aef1a BD |
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); | |
447aef1a | 111 | dev_dbg(dev, "tle62x0_read() returned %d\n", ret); |
822bd5aa DB |
112 | if (ret < 0) { |
113 | mutex_unlock(&st->lock); | |
114 | return ret; | |
115 | } | |
447aef1a BD |
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 | ||
fd4a319b | 242 | static int tle62x0_probe(struct spi_device *spi) |
447aef1a BD |
243 | { |
244 | struct tle62x0_state *st; | |
245 | struct tle62x0_pdata *pdata; | |
246 | int ptr; | |
247 | int ret; | |
248 | ||
8074cf06 | 249 | pdata = dev_get_platdata(&spi->dev); |
447aef1a BD |
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); | |
9f48e54b | 256 | if (st == NULL) |
447aef1a | 257 | return -ENOMEM; |
447aef1a BD |
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: | |
80b40370 | 284 | while (--ptr >= 0) |
447aef1a BD |
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 | ||
fd4a319b | 294 | static int tle62x0_remove(struct spi_device *spi) |
447aef1a BD |
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 | ||
80b40370 | 302 | device_remove_file(&spi->dev, &dev_attr_status_show); |
447aef1a BD |
303 | kfree(st); |
304 | return 0; | |
305 | } | |
306 | ||
307 | static struct spi_driver tle62x0_driver = { | |
308 | .driver = { | |
309 | .name = "tle62x0", | |
310 | .owner = THIS_MODULE, | |
311 | }, | |
312 | .probe = tle62x0_probe, | |
fd4a319b | 313 | .remove = tle62x0_remove, |
447aef1a BD |
314 | }; |
315 | ||
38e271cd | 316 | module_spi_driver(tle62x0_driver); |
447aef1a BD |
317 | |
318 | MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>"); | |
319 | MODULE_DESCRIPTION("TLE62x0 SPI driver"); | |
320 | MODULE_LICENSE("GPL v2"); | |
e0626e38 | 321 | MODULE_ALIAS("spi:tle62x0"); |