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