Blame view
drivers/spi/spi-butterfly.c
8.49 KB
2e10c84b9 [PATCH] SPI: add ... |
1 |
/* |
ca632f556 spi: reorganize d... |
2 |
* parport-to-butterfly adapter |
2e10c84b9 [PATCH] SPI: add ... |
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
* * Copyright (C) 2005 David Brownell * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
2e10c84b9 [PATCH] SPI: add ... |
20 21 22 |
#include <linux/kernel.h> #include <linux/init.h> #include <linux/delay.h> |
d7614de42 spi: Add module.h... |
23 |
#include <linux/module.h> |
da6752964 layered parport c... |
24 |
#include <linux/device.h> |
2e10c84b9 [PATCH] SPI: add ... |
25 |
#include <linux/parport.h> |
914e26379 [PATCH] severing ... |
26 |
#include <linux/sched.h> |
2e10c84b9 [PATCH] SPI: add ... |
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
#include <linux/spi/spi.h> #include <linux/spi/spi_bitbang.h> #include <linux/spi/flash.h> #include <linux/mtd/partitions.h> /* * This uses SPI to talk with an "AVR Butterfly", which is a $US20 card * with a battery powered AVR microcontroller and lots of goodies. You * can use GCC to develop firmware for this. * * See Documentation/spi/butterfly for information about how to build * and use this custom parallel port cable. */ |
2e10c84b9 [PATCH] SPI: add ... |
42 43 44 45 46 47 |
/* DATA output bits (pins 2..9 == D0..D7) */ #define butterfly_nreset (1 << 1) /* pin 3 */ #define spi_sck_bit (1 << 0) /* pin 2 */ #define spi_mosi_bit (1 << 7) /* pin 9 */ |
2e10c84b9 [PATCH] SPI: add ... |
48 49 50 51 |
#define vcc_bits ((1 << 6) | (1 << 5)) /* pins 7, 8 */ /* STATUS input bits */ #define spi_miso_bit PARPORT_STATUS_BUSY /* pin 11 */ |
2e10c84b9 [PATCH] SPI: add ... |
52 53 |
/* CONTROL output bits */ #define spi_cs_bit PARPORT_CONTROL_SELECT /* pin 17 */ |
2e10c84b9 [PATCH] SPI: add ... |
54 55 56 57 58 59 60 |
static inline struct butterfly *spidev_to_pp(struct spi_device *spi) { return spi->controller_data; } |
2e10c84b9 [PATCH] SPI: add ... |
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
struct butterfly { /* REVISIT ... for now, this must be first */ struct spi_bitbang bitbang; struct parport *port; struct pardevice *pd; u8 lastbyte; struct spi_device *dataflash; struct spi_device *butterfly; struct spi_board_info info[2]; }; /*----------------------------------------------------------------------*/ |
2e10c84b9 [PATCH] SPI: add ... |
78 79 80 81 82 |
static inline void setsck(struct spi_device *spi, int is_on) { struct butterfly *pp = spidev_to_pp(spi); u8 bit, byte = pp->lastbyte; |
735ce95e6 minor spi_butterf... |
83 |
bit = spi_sck_bit; |
2e10c84b9 [PATCH] SPI: add ... |
84 85 86 87 88 89 90 91 92 93 94 95 96 97 |
if (is_on) byte |= bit; else byte &= ~bit; parport_write_data(pp->port, byte); pp->lastbyte = byte; } static inline void setmosi(struct spi_device *spi, int is_on) { struct butterfly *pp = spidev_to_pp(spi); u8 bit, byte = pp->lastbyte; |
735ce95e6 minor spi_butterf... |
98 |
bit = spi_mosi_bit; |
2e10c84b9 [PATCH] SPI: add ... |
99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
if (is_on) byte |= bit; else byte &= ~bit; parport_write_data(pp->port, byte); pp->lastbyte = byte; } static inline int getmiso(struct spi_device *spi) { struct butterfly *pp = spidev_to_pp(spi); int value; u8 bit; |
735ce95e6 minor spi_butterf... |
113 |
bit = spi_miso_bit; |
2e10c84b9 [PATCH] SPI: add ... |
114 115 116 117 118 119 120 121 122 123 124 |
/* only STATUS_BUSY is NOT negated */ value = !(parport_read_status(pp->port) & bit); return (bit == PARPORT_STATUS_BUSY) ? value : !value; } static void butterfly_chipselect(struct spi_device *spi, int value) { struct butterfly *pp = spidev_to_pp(spi); /* set default clock polarity */ |
9c1da3cb4 [PATCH] SPI: spi_... |
125 |
if (value != BITBANG_CS_INACTIVE) |
2e10c84b9 [PATCH] SPI: add ... |
126 |
setsck(spi, spi->mode & SPI_CPOL); |
9c1da3cb4 [PATCH] SPI: spi_... |
127 128 129 130 |
/* here, value == "activate or not"; * most PARPORT_CONTROL_* bits are negated, so we must * morph it to value == "bit value to write in control register" */ |
2e10c84b9 [PATCH] SPI: add ... |
131 132 |
if (spi_cs_bit == PARPORT_CONTROL_INIT) value = !value; |
2e10c84b9 [PATCH] SPI: add ... |
133 134 135 136 137 138 139 140 |
parport_frob_control(pp->port, spi_cs_bit, value ? spi_cs_bit : 0); } /* we only needed to implement one mode here, and choose SPI_MODE_0 */ #define spidelay(X) do{}while(0) //#define spidelay ndelay |
ca632f556 spi: reorganize d... |
141 |
#include "spi-bitbang-txrx.h" |
2e10c84b9 [PATCH] SPI: add ... |
142 143 144 145 146 147 |
static u32 butterfly_txrx_word_mode0(struct spi_device *spi, unsigned nsecs, u32 word, u8 bits) { |
04bb2a031 spi/bitbang: add ... |
148 |
return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits); |
2e10c84b9 [PATCH] SPI: add ... |
149 150 151 152 153 154 |
} /*----------------------------------------------------------------------*/ /* override default partitioning with cmdlinepart */ static struct mtd_partition partitions[] = { { |
9c1da3cb4 [PATCH] SPI: spi_... |
155 156 157 |
/* JFFS2 wants partitions of 4*N blocks for this device, * so sectors 0 and 1 can't be partitions by themselves. */ |
2e10c84b9 [PATCH] SPI: add ... |
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 |
/* sector 0 = 8 pages * 264 bytes/page (1 block) * sector 1 = 248 pages * 264 bytes/page */ .name = "bookkeeping", // 66 KB .offset = 0, .size = (8 + 248) * 264, // .mask_flags = MTD_WRITEABLE, }, { /* sector 2 = 256 pages * 264 bytes/page * sectors 3-5 = 512 pages * 264 bytes/page */ .name = "filesystem", // 462 KB .offset = MTDPART_OFS_APPEND, .size = MTDPART_SIZ_FULL, } }; static struct flash_platform_data flash = { .name = "butterflash", .parts = partitions, .nr_parts = ARRAY_SIZE(partitions), }; /* REVISIT remove this ugly global and its "only one" limitation */ static struct butterfly *butterfly; static void butterfly_attach(struct parport *p) { struct pardevice *pd; int status; struct butterfly *pp; struct spi_master *master; |
da6752964 layered parport c... |
191 |
struct device *dev = p->physport->dev; |
2e10c84b9 [PATCH] SPI: add ... |
192 |
|
da6752964 layered parport c... |
193 |
if (butterfly || !dev) |
2e10c84b9 [PATCH] SPI: add ... |
194 195 196 197 198 |
return; /* REVISIT: this just _assumes_ a butterfly is there ... no probe, * and no way to be selective about what it binds to. */ |
da6752964 layered parport c... |
199 |
master = spi_alloc_master(dev, sizeof *pp); |
2e10c84b9 [PATCH] SPI: add ... |
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 |
if (!master) { status = -ENOMEM; goto done; } pp = spi_master_get_devdata(master); /* * SPI and bitbang hookup * * use default setup(), cleanup(), and transfer() methods; and * only bother implementing mode 0. Start it later. */ master->bus_num = 42; master->num_chipselect = 2; pp->bitbang.master = spi_master_get(master); pp->bitbang.chipselect = butterfly_chipselect; pp->bitbang.txrx_word[SPI_MODE_0] = butterfly_txrx_word_mode0; /* * parport hookup */ pp->port = p; pd = parport_register_device(p, "spi_butterfly", NULL, NULL, NULL, 0 /* FLAGS */, pp); if (!pd) { status = -ENOMEM; goto clean0; } pp->pd = pd; status = parport_claim(pd); if (status < 0) goto clean1; /* * Butterfly reset, powerup, run firmware */ pr_debug("%s: powerup/reset Butterfly ", p->name); /* nCS for dataflash (this bit is inverted on output) */ parport_frob_control(pp->port, spi_cs_bit, 0); /* stabilize power with chip in reset (nRESET), and |
735ce95e6 minor spi_butterf... |
246 |
* spi_sck_bit clear (CPOL=0) |
2e10c84b9 [PATCH] SPI: add ... |
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 |
*/ pp->lastbyte |= vcc_bits; parport_write_data(pp->port, pp->lastbyte); msleep(5); /* take it out of reset; assume long reset delay */ pp->lastbyte |= butterfly_nreset; parport_write_data(pp->port, pp->lastbyte); msleep(100); /* * Start SPI ... for now, hide that we're two physical busses. */ status = spi_bitbang_start(&pp->bitbang); if (status < 0) goto clean2; |
9c1da3cb4 [PATCH] SPI: spi_... |
264 265 266 |
/* Bus 1 lets us talk to at45db041b (firmware disables AVR SPI), AVR * (firmware resets at45, acts as spi slave) or neither (we ignore * both, AVR uses AT45). Here we expect firmware for the first option. |
2e10c84b9 [PATCH] SPI: add ... |
267 |
*/ |
1fc7547d4 [PATCH] S3C24XX: ... |
268 |
|
2e10c84b9 [PATCH] SPI: add ... |
269 270 271 272 273 274 275 276 277 |
pp->info[0].max_speed_hz = 15 * 1000 * 1000; strcpy(pp->info[0].modalias, "mtd_dataflash"); pp->info[0].platform_data = &flash; pp->info[0].chip_select = 1; pp->info[0].controller_data = pp; pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]); if (pp->dataflash) pr_debug("%s: dataflash at %s ", p->name, |
35f74fcab spi: struct devic... |
278 |
dev_name(&pp->dataflash->dev)); |
2e10c84b9 [PATCH] SPI: add ... |
279 |
|
2e10c84b9 [PATCH] SPI: add ... |
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 |
// dev_info(_what?_, ...) pr_info("%s: AVR Butterfly ", p->name); butterfly = pp; return; clean2: /* turn off VCC */ parport_write_data(pp->port, 0); parport_release(pp->pd); clean1: parport_unregister_device(pd); clean0: (void) spi_master_put(pp->bitbang.master); done: |
2e10c84b9 [PATCH] SPI: add ... |
296 297 298 299 300 301 302 |
pr_debug("%s: butterfly probe, fail %d ", p->name, status); } static void butterfly_detach(struct parport *p) { struct butterfly *pp; |
2e10c84b9 [PATCH] SPI: add ... |
303 304 305 306 307 308 309 310 311 312 |
int status; /* FIXME this global is ugly ... but, how to quickly get from * the parport to the "struct butterfly" associated with it? * "old school" driver-internal device lists? */ if (!butterfly || butterfly->port != p) return; pp = butterfly; butterfly = NULL; |
9c1da3cb4 [PATCH] SPI: spi_... |
313 |
/* stop() unregisters child devices too */ |
2e10c84b9 [PATCH] SPI: add ... |
314 315 316 317 318 319 320 321 |
status = spi_bitbang_stop(&pp->bitbang); /* turn off VCC */ parport_write_data(pp->port, 0); msleep(10); parport_release(pp->pd); parport_unregister_device(pp->pd); |
2e10c84b9 [PATCH] SPI: add ... |
322 |
(void) spi_master_put(pp->bitbang.master); |
2e10c84b9 [PATCH] SPI: add ... |
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 |
} static struct parport_driver butterfly_driver = { .name = "spi_butterfly", .attach = butterfly_attach, .detach = butterfly_detach, }; static int __init butterfly_init(void) { return parport_register_driver(&butterfly_driver); } device_initcall(butterfly_init); static void __exit butterfly_exit(void) { parport_unregister_driver(&butterfly_driver); } module_exit(butterfly_exit); |
9c1da3cb4 [PATCH] SPI: spi_... |
343 |
MODULE_DESCRIPTION("Parport Adapter driver for AVR Butterfly"); |
2e10c84b9 [PATCH] SPI: add ... |
344 |
MODULE_LICENSE("GPL"); |