blob: 312987a0321072aa2c9974c8b476ffc97416b7bb [file] [log] [blame]
David Brownell2e10c842006-01-11 11:23:49 -08001/*
2 * spi_butterfly.c - parport-to-butterfly adapter
3 *
4 * Copyright (C) 2005 David Brownell
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
David Brownell2e10c842006-01-11 11:23:49 -080020#include <linux/kernel.h>
21#include <linux/init.h>
22#include <linux/delay.h>
23#include <linux/platform_device.h>
24#include <linux/parport.h>
25
Al Viro914e2632006-10-18 13:55:46 -040026#include <linux/sched.h>
David Brownell2e10c842006-01-11 11:23:49 -080027#include <linux/spi/spi.h>
28#include <linux/spi/spi_bitbang.h>
29#include <linux/spi/flash.h>
30
31#include <linux/mtd/partitions.h>
32
33
34/*
35 * This uses SPI to talk with an "AVR Butterfly", which is a $US20 card
36 * with a battery powered AVR microcontroller and lots of goodies. You
37 * can use GCC to develop firmware for this.
38 *
39 * See Documentation/spi/butterfly for information about how to build
40 * and use this custom parallel port cable.
41 */
42
43#undef HAVE_USI /* nyet */
44
45
46/* DATA output bits (pins 2..9 == D0..D7) */
47#define butterfly_nreset (1 << 1) /* pin 3 */
48
49#define spi_sck_bit (1 << 0) /* pin 2 */
50#define spi_mosi_bit (1 << 7) /* pin 9 */
51
52#define usi_sck_bit (1 << 3) /* pin 5 */
53#define usi_mosi_bit (1 << 4) /* pin 6 */
54
55#define vcc_bits ((1 << 6) | (1 << 5)) /* pins 7, 8 */
56
57/* STATUS input bits */
58#define spi_miso_bit PARPORT_STATUS_BUSY /* pin 11 */
59
60#define usi_miso_bit PARPORT_STATUS_PAPEROUT /* pin 12 */
61
62/* CONTROL output bits */
63#define spi_cs_bit PARPORT_CONTROL_SELECT /* pin 17 */
64/* USI uses no chipselect */
65
66
67
68static inline struct butterfly *spidev_to_pp(struct spi_device *spi)
69{
70 return spi->controller_data;
71}
72
73static inline int is_usidev(struct spi_device *spi)
74{
75#ifdef HAVE_USI
76 return spi->chip_select != 1;
77#else
78 return 0;
79#endif
80}
81
82
83struct butterfly {
84 /* REVISIT ... for now, this must be first */
85 struct spi_bitbang bitbang;
86
87 struct parport *port;
88 struct pardevice *pd;
89
90 u8 lastbyte;
91
92 struct spi_device *dataflash;
93 struct spi_device *butterfly;
94 struct spi_board_info info[2];
95
96};
97
98/*----------------------------------------------------------------------*/
99
100/*
101 * these routines may be slower than necessary because they're hiding
102 * the fact that there are two different SPI busses on this cable: one
103 * to the DataFlash chip (or AVR SPI controller), the other to the
104 * AVR USI controller.
105 */
106
107static inline void
108setsck(struct spi_device *spi, int is_on)
109{
110 struct butterfly *pp = spidev_to_pp(spi);
111 u8 bit, byte = pp->lastbyte;
112
113 if (is_usidev(spi))
114 bit = usi_sck_bit;
115 else
116 bit = spi_sck_bit;
117
118 if (is_on)
119 byte |= bit;
120 else
121 byte &= ~bit;
122 parport_write_data(pp->port, byte);
123 pp->lastbyte = byte;
124}
125
126static inline void
127setmosi(struct spi_device *spi, int is_on)
128{
129 struct butterfly *pp = spidev_to_pp(spi);
130 u8 bit, byte = pp->lastbyte;
131
132 if (is_usidev(spi))
133 bit = usi_mosi_bit;
134 else
135 bit = spi_mosi_bit;
136
137 if (is_on)
138 byte |= bit;
139 else
140 byte &= ~bit;
141 parport_write_data(pp->port, byte);
142 pp->lastbyte = byte;
143}
144
145static inline int getmiso(struct spi_device *spi)
146{
147 struct butterfly *pp = spidev_to_pp(spi);
148 int value;
149 u8 bit;
150
151 if (is_usidev(spi))
152 bit = usi_miso_bit;
153 else
154 bit = spi_miso_bit;
155
156 /* only STATUS_BUSY is NOT negated */
157 value = !(parport_read_status(pp->port) & bit);
158 return (bit == PARPORT_STATUS_BUSY) ? value : !value;
159}
160
161static void butterfly_chipselect(struct spi_device *spi, int value)
162{
163 struct butterfly *pp = spidev_to_pp(spi);
164
165 /* set default clock polarity */
David Brownell9c1da3c2006-01-21 13:21:43 -0800166 if (value != BITBANG_CS_INACTIVE)
David Brownell2e10c842006-01-11 11:23:49 -0800167 setsck(spi, spi->mode & SPI_CPOL);
168
169 /* no chipselect on this USI link config */
170 if (is_usidev(spi))
171 return;
172
David Brownell9c1da3c2006-01-21 13:21:43 -0800173 /* here, value == "activate or not";
174 * most PARPORT_CONTROL_* bits are negated, so we must
175 * morph it to value == "bit value to write in control register"
176 */
David Brownell2e10c842006-01-11 11:23:49 -0800177 if (spi_cs_bit == PARPORT_CONTROL_INIT)
178 value = !value;
179
David Brownell2e10c842006-01-11 11:23:49 -0800180 parport_frob_control(pp->port, spi_cs_bit, value ? spi_cs_bit : 0);
181}
182
183
184/* we only needed to implement one mode here, and choose SPI_MODE_0 */
185
186#define spidelay(X) do{}while(0)
187//#define spidelay ndelay
188
189#define EXPAND_BITBANG_TXRX
190#include <linux/spi/spi_bitbang.h>
191
192static u32
193butterfly_txrx_word_mode0(struct spi_device *spi,
194 unsigned nsecs,
195 u32 word, u8 bits)
196{
197 return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
198}
199
200/*----------------------------------------------------------------------*/
201
202/* override default partitioning with cmdlinepart */
203static struct mtd_partition partitions[] = { {
David Brownell9c1da3c2006-01-21 13:21:43 -0800204 /* JFFS2 wants partitions of 4*N blocks for this device,
205 * so sectors 0 and 1 can't be partitions by themselves.
206 */
David Brownell2e10c842006-01-11 11:23:49 -0800207
208 /* sector 0 = 8 pages * 264 bytes/page (1 block)
209 * sector 1 = 248 pages * 264 bytes/page
210 */
211 .name = "bookkeeping", // 66 KB
212 .offset = 0,
213 .size = (8 + 248) * 264,
214// .mask_flags = MTD_WRITEABLE,
215}, {
216 /* sector 2 = 256 pages * 264 bytes/page
217 * sectors 3-5 = 512 pages * 264 bytes/page
218 */
219 .name = "filesystem", // 462 KB
220 .offset = MTDPART_OFS_APPEND,
221 .size = MTDPART_SIZ_FULL,
222} };
223
224static struct flash_platform_data flash = {
225 .name = "butterflash",
226 .parts = partitions,
227 .nr_parts = ARRAY_SIZE(partitions),
228};
229
230
231/* REVISIT remove this ugly global and its "only one" limitation */
232static struct butterfly *butterfly;
233
234static void butterfly_attach(struct parport *p)
235{
236 struct pardevice *pd;
237 int status;
238 struct butterfly *pp;
239 struct spi_master *master;
240 struct platform_device *pdev;
241
242 if (butterfly)
243 return;
244
245 /* REVISIT: this just _assumes_ a butterfly is there ... no probe,
246 * and no way to be selective about what it binds to.
247 */
248
249 /* FIXME where should master->cdev.dev come from?
250 * e.g. /sys/bus/pnp0/00:0b, some PCI thing, etc
251 * setting up a platform device like this is an ugly kluge...
252 */
253 pdev = platform_device_register_simple("butterfly", -1, NULL, 0);
Akinobu Mita7b92ff02006-12-06 20:39:05 -0800254 if (IS_ERR(pdev))
255 return;
David Brownell2e10c842006-01-11 11:23:49 -0800256
257 master = spi_alloc_master(&pdev->dev, sizeof *pp);
258 if (!master) {
259 status = -ENOMEM;
260 goto done;
261 }
262 pp = spi_master_get_devdata(master);
263
264 /*
265 * SPI and bitbang hookup
266 *
267 * use default setup(), cleanup(), and transfer() methods; and
268 * only bother implementing mode 0. Start it later.
269 */
270 master->bus_num = 42;
271 master->num_chipselect = 2;
272
273 pp->bitbang.master = spi_master_get(master);
274 pp->bitbang.chipselect = butterfly_chipselect;
275 pp->bitbang.txrx_word[SPI_MODE_0] = butterfly_txrx_word_mode0;
276
277 /*
278 * parport hookup
279 */
280 pp->port = p;
281 pd = parport_register_device(p, "spi_butterfly",
282 NULL, NULL, NULL,
283 0 /* FLAGS */, pp);
284 if (!pd) {
285 status = -ENOMEM;
286 goto clean0;
287 }
288 pp->pd = pd;
289
290 status = parport_claim(pd);
291 if (status < 0)
292 goto clean1;
293
294 /*
295 * Butterfly reset, powerup, run firmware
296 */
297 pr_debug("%s: powerup/reset Butterfly\n", p->name);
298
299 /* nCS for dataflash (this bit is inverted on output) */
300 parport_frob_control(pp->port, spi_cs_bit, 0);
301
302 /* stabilize power with chip in reset (nRESET), and
303 * both spi_sck_bit and usi_sck_bit clear (CPOL=0)
304 */
305 pp->lastbyte |= vcc_bits;
306 parport_write_data(pp->port, pp->lastbyte);
307 msleep(5);
308
309 /* take it out of reset; assume long reset delay */
310 pp->lastbyte |= butterfly_nreset;
311 parport_write_data(pp->port, pp->lastbyte);
312 msleep(100);
313
314
315 /*
316 * Start SPI ... for now, hide that we're two physical busses.
317 */
318 status = spi_bitbang_start(&pp->bitbang);
319 if (status < 0)
320 goto clean2;
321
David Brownell9c1da3c2006-01-21 13:21:43 -0800322 /* Bus 1 lets us talk to at45db041b (firmware disables AVR SPI), AVR
323 * (firmware resets at45, acts as spi slave) or neither (we ignore
324 * both, AVR uses AT45). Here we expect firmware for the first option.
David Brownell2e10c842006-01-11 11:23:49 -0800325 */
Ben Dooks1fc75472006-05-20 15:00:17 -0700326
David Brownell2e10c842006-01-11 11:23:49 -0800327 pp->info[0].max_speed_hz = 15 * 1000 * 1000;
328 strcpy(pp->info[0].modalias, "mtd_dataflash");
329 pp->info[0].platform_data = &flash;
330 pp->info[0].chip_select = 1;
331 pp->info[0].controller_data = pp;
332 pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]);
333 if (pp->dataflash)
334 pr_debug("%s: dataflash at %s\n", p->name,
335 pp->dataflash->dev.bus_id);
336
337#ifdef HAVE_USI
David Brownell9c1da3c2006-01-21 13:21:43 -0800338 /* Bus 2 is only for talking to the AVR, and it can work no
339 * matter who masters bus 1; needs appropriate AVR firmware.
340 */
David Brownell2e10c842006-01-11 11:23:49 -0800341 pp->info[1].max_speed_hz = 10 /* ?? */ * 1000 * 1000;
342 strcpy(pp->info[1].modalias, "butterfly");
343 // pp->info[1].platform_data = ... TBD ... ;
344 pp->info[1].chip_select = 2,
345 pp->info[1].controller_data = pp;
346 pp->butterfly = spi_new_device(pp->bitbang.master, &pp->info[1]);
347 if (pp->butterfly)
348 pr_debug("%s: butterfly at %s\n", p->name,
349 pp->butterfly->dev.bus_id);
350
351 /* FIXME setup ACK for the IRQ line ... */
352#endif
353
354 // dev_info(_what?_, ...)
355 pr_info("%s: AVR Butterfly\n", p->name);
356 butterfly = pp;
357 return;
358
359clean2:
360 /* turn off VCC */
361 parport_write_data(pp->port, 0);
362
363 parport_release(pp->pd);
364clean1:
365 parport_unregister_device(pd);
366clean0:
367 (void) spi_master_put(pp->bitbang.master);
368done:
369 platform_device_unregister(pdev);
370 pr_debug("%s: butterfly probe, fail %d\n", p->name, status);
371}
372
373static void butterfly_detach(struct parport *p)
374{
375 struct butterfly *pp;
376 struct platform_device *pdev;
377 int status;
378
379 /* FIXME this global is ugly ... but, how to quickly get from
380 * the parport to the "struct butterfly" associated with it?
381 * "old school" driver-internal device lists?
382 */
383 if (!butterfly || butterfly->port != p)
384 return;
385 pp = butterfly;
386 butterfly = NULL;
387
David Brownell9c1da3c2006-01-21 13:21:43 -0800388 /* stop() unregisters child devices too */
389 pdev = to_platform_device(pp->bitbang.master->cdev.dev);
David Brownell2e10c842006-01-11 11:23:49 -0800390 status = spi_bitbang_stop(&pp->bitbang);
391
392 /* turn off VCC */
393 parport_write_data(pp->port, 0);
394 msleep(10);
395
396 parport_release(pp->pd);
397 parport_unregister_device(pp->pd);
398
David Brownell2e10c842006-01-11 11:23:49 -0800399 (void) spi_master_put(pp->bitbang.master);
400
401 platform_device_unregister(pdev);
402}
403
404static struct parport_driver butterfly_driver = {
405 .name = "spi_butterfly",
406 .attach = butterfly_attach,
407 .detach = butterfly_detach,
408};
409
410
411static int __init butterfly_init(void)
412{
413 return parport_register_driver(&butterfly_driver);
414}
415device_initcall(butterfly_init);
416
417static void __exit butterfly_exit(void)
418{
419 parport_unregister_driver(&butterfly_driver);
420}
421module_exit(butterfly_exit);
422
David Brownell9c1da3c2006-01-21 13:21:43 -0800423MODULE_DESCRIPTION("Parport Adapter driver for AVR Butterfly");
David Brownell2e10c842006-01-11 11:23:49 -0800424MODULE_LICENSE("GPL");