projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
made au1000 images srec file ending
[openwrt.git] / target / linux / etrax / patches / cris / 003-drivers-cris.patch
1 diff -urN linux-2.6.19.2.orig/drivers/ide/cris/ide-cris.c linux-2.6.19.2.dev/drivers/ide/cris/ide-cris.c
2 --- linux-2.6.19.2.orig/drivers/ide/cris/ide-cris.c 2007-01-10 20:10:37.000000000 +0100
3 +++ linux-2.6.19.2.dev/drivers/ide/cris/ide-cris.c 2006-12-06 14:17:02.000000000 +0100
4 @@ -1,8 +1,8 @@
5 -/* $Id: cris-ide-driver.patch,v 1.1 2005/06/29 21:39:07 akpm Exp $
6 +/* $Id: ide-cris.c,v 1.10 2006/12/06 13:17:02 starvik Exp $
7 *
8 * Etrax specific IDE functions, like init and PIO-mode setting etc.
9 * Almost the entire ide.c is used for the rest of the Etrax ATA driver.
10 - * Copyright (c) 2000-2005 Axis Communications AB
11 + * Copyright (c) 2000-2006 Axis Communications AB
12 *
13 * Authors: Bjorn Wesen (initial version)
14 * Mikael Starvik (crisv32 port)
15 @@ -43,8 +43,8 @@
16
17 #define IDE_REGISTER_TIMEOUT 300
18
19 -#define LOWDB(x)
20 -#define D(x)
21 +#define LOWDB(x)
22 +#define D(x)
23
24 enum /* Transfer types */
25 {
26 @@ -88,12 +88,50 @@
27 #define ATA_PIO0_STROBE 39
28 #define ATA_PIO0_HOLD 9
29
30 -int
31 +/*
32 + * On ETRAX FS, an interrupt remains latched and active until ack:ed.
33 + * Further, ATA acks are without effect as long as INTRQ is asserted, as the
34 + * corresponding ATA interrupt is continuously set to active. There will be a
35 + * clearing ack at the usual cris_ide_ack_intr call, but that serves just to
36 + * gracefully handle an actual spurious interrupt or similar situation (which
37 + * will cause an early return without further actions, see the ide_intr
38 + * function).
39 + *
40 + * However, the normal case at time of this writing is that nothing has
41 + * changed from when INTRQ was asserted until the cris_ide_ack_intr call; no
42 + * ATA registers written and no status register read, so INTRQ will *remain*
43 + * asserted, thus *another* interrupt will be latched, and will be seen as a
44 + * spurious interrupt after the "real" interrupt is serviced. With lots of
45 + * ATA traffic (as in a trivial file-copy between two drives), this will trig
46 + * the condition desc->irqs_unhandled > 99900 in
47 + * kernel/irq/spurious.c:note_interrupt and the system will halt.
48 + *
49 + * To actually get rid of the interrupt corresponding to the current INTRQ
50 + * assertion, we make a second ack after the next ATA register read or write;
51 + * i.e. when INTRQ must be deasserted. At that time, we don't have the hwif
52 + * pointer available, so we need to stash a local copy (safe, because it'll be
53 + * set and cleared within the same spin_lock_irqsave region). The pointer
54 + * serves doubly as a boolean flag that an ack is needed. The caller must
55 + * NULL the pointer after the "second ack".
56 + */
57 +
58 +static ide_hwif_t *hwif_to_ack;
59 +
60 +static int
61 cris_ide_ack_intr(ide_hwif_t* hwif)
62 {
63 - reg_ata_rw_ctrl2 ctrl2 = REG_TYPE_CONV(reg_ata_rw_ctrl2,
64 + /*
65 + * The interrupt is shared so we need to find the interface bit number
66 + * to ack. We define the ATA I/O register addresses to have the
67 + * format of ata rw_ctrl2 register contents, conveniently holding this
68 + * number.
69 + */
70 + reg_ata_rw_ctrl2 ctrl2 = REG_TYPE_CONV(reg_ata_rw_ctrl2,
71 int, hwif->io_ports[0]);
72 REG_WR_INT(ata, regi_ata, rw_ack_intr, 1 << ctrl2.sel);
73 +
74 + /* Prepare to ack again, see above. */
75 + hwif_to_ack = hwif;
76 return 1;
77 }
78
79 @@ -122,8 +160,24 @@
80
81 static void
82 cris_ide_write_command(unsigned long command)
83 -{
84 +{
85 REG_WR_INT(ata, regi_ata, rw_ctrl2, command); /* write data to the drive's register */
86 +
87 + /*
88 + * Perform a pending ack if needed; see hwif_ack definition. Perhaps
89 + * we should check closer that this call is really a part of the
90 + * preparation to read the ATA status register or write to the ATA
91 + * command register (causing deassert of INTRQ; see the ATA standard),
92 + * but at time of this writing (and expected to sanely remain so), the
93 + * first ATA register activity after an cris_ide_ack_intr call is
94 + * certain to do exactly that.
95 + */
96 + if (hwif_to_ack) {
97 + /* The drive may take this long to deassert INTRQ. */
98 + ndelay(400);
99 + cris_ide_ack_intr(hwif_to_ack);
100 + hwif_to_ack = NULL;
101 + }
102 }
103
104 static void
105 @@ -160,8 +214,8 @@
106 {
107 reg_ata_rw_ctrl2 ctrl2 = {0};
108 ctrl2.addr = addr;
109 - ctrl2.cs1 = cs1;
110 - ctrl2.cs0 = cs0;
111 + ctrl2.cs1 = !cs1;
112 + ctrl2.cs0 = !cs0;
113 return REG_TYPE_CONV(int, reg_ata_rw_ctrl2, ctrl2);
114 }
115
116 @@ -184,14 +238,14 @@
117
118 intr_mask.bus0 = regk_ata_yes;
119 intr_mask.bus1 = regk_ata_yes;
120 - intr_mask.bus2 = regk_ata_yes;
121 + intr_mask.bus2 = regk_ata_yes;
122 intr_mask.bus3 = regk_ata_yes;
123
124 REG_WR(ata, regi_ata, rw_intr_mask, intr_mask);
125
126 crisv32_request_dma(2, "ETRAX FS built-in ATA", DMA_VERBOSE_ON_ERROR, 0, dma_ata);
127 crisv32_request_dma(3, "ETRAX FS built-in ATA", DMA_VERBOSE_ON_ERROR, 0, dma_ata);
128 -
129 +
130 crisv32_pinmux_alloc_fixed(pinmux_ata);
131 crisv32_pinmux_alloc_fixed(pinmux_ata0);
132 crisv32_pinmux_alloc_fixed(pinmux_ata1);
133 @@ -204,14 +258,15 @@
134 DMA_ENABLE(regi_dma3);
135
136 DMA_WR_CMD (regi_dma2, regk_dma_set_w_size2);
137 - DMA_WR_CMD (regi_dma3, regk_dma_set_w_size2);
138 + DMA_WR_CMD (regi_dma3, regk_dma_set_w_size2);
139 }
140
141 static dma_descr_context mycontext __attribute__ ((__aligned__(32)));
142
143 #define cris_dma_descr_type dma_descr_data
144 -#define cris_pio_read regk_ata_rd
145 -#define cris_ultra_mask 0x7
146 +#define cris_pio_read (regk_ata_rd << 24)
147 +#define cris_ultra_mask 0x0 /* 0x7 for UDMA */
148 +#define IRQ ATA_INTR_VECT
149 #define MAX_DESCR_SIZE 0xffffffffUL
150
151 static unsigned long
152 @@ -226,6 +281,8 @@
153 d->buf = (char*)virt_to_phys(buf);
154 d->after = d->buf + len;
155 d->eol = last;
156 + /* assume descriptors are consecutively placed in memory */
157 + d->next = last ? 0 : (cris_dma_descr_type*)virt_to_phys(d+1);
158 }
159
160 static void
161 @@ -237,8 +294,10 @@
162 mycontext.saved_data = (dma_descr_data*)virt_to_phys(d);
163 mycontext.saved_data_buf = d->buf;
164 /* start the dma channel */
165 + if (dir)
166 + flush_dma_context(&mycontext); // Cache bug workaround
167 DMA_START_CONTEXT(dir ? regi_dma3 : regi_dma2, virt_to_phys(&mycontext));
168 -
169 +
170 /* initiate a multi word dma read using PIO handshaking */
171 trf_cnt.cnt = len >> 1;
172 /* Due to a "feature" the transfer count has to be one extra word for UDMA. */
173 @@ -248,7 +307,7 @@
174
175 ctrl2.rw = dir ? regk_ata_rd : regk_ata_wr;
176 ctrl2.trf_mode = regk_ata_dma;
177 - ctrl2.hsh = type == TYPE_PIO ? regk_ata_pio :
178 + ctrl2.hsh = type == TYPE_PIO ? regk_ata_pio :
179 type == TYPE_DMA ? regk_ata_dma : regk_ata_udma;
180 ctrl2.multi = regk_ata_yes;
181 ctrl2.dma_size = regk_ata_word;
182 @@ -339,7 +398,7 @@
183 #define ATA_PIO0_STROBE 19
184 #define ATA_PIO0_HOLD 4
185
186 -int
187 +int
188 cris_ide_ack_intr(ide_hwif_t* hwif)
189 {
190 return 1;
191 @@ -348,13 +407,13 @@
192 static inline int
193 cris_ide_busy(void)
194 {
195 - return *R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy) ;
196 + return *R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy) ;
197 }
198
199 static inline int
200 cris_ide_ready(void)
201 {
202 - return *R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, tr_rdy) ;
203 + return *R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, tr_rdy) ;
204 }
205
206 static inline int
207 @@ -364,12 +423,12 @@
208 *data = (unsigned short)status;
209 return status & IO_MASK(R_ATA_STATUS_DATA, dav);
210 }
211 -
212 +
213 static void
214 cris_ide_write_command(unsigned long command)
215 {
216 - *R_ATA_CTRL_DATA = command;
217 -}
218 + *R_ATA_CTRL_DATA = command;
219 +}
220
221 static void
222 cris_ide_set_speed(int type, int setup, int strobe, int hold)
223 @@ -406,8 +465,8 @@
224 cris_ide_reg_addr(unsigned long addr, int cs0, int cs1)
225 {
226 return IO_FIELD(R_ATA_CTRL_DATA, addr, addr) |
227 - IO_FIELD(R_ATA_CTRL_DATA, cs0, cs0) |
228 - IO_FIELD(R_ATA_CTRL_DATA, cs1, cs1);
229 + IO_FIELD(R_ATA_CTRL_DATA, cs0, cs0 ? 0 : 1) |
230 + IO_FIELD(R_ATA_CTRL_DATA, cs1, cs1 ? 0 : 1);
231 }
232
233 static __init void
234 @@ -484,6 +543,7 @@
235 #define cris_dma_descr_type etrax_dma_descr
236 #define cris_pio_read IO_STATE(R_ATA_CTRL_DATA, rw, read)
237 #define cris_ultra_mask 0x0
238 +#define IRQ 4
239 #define MAX_DESCR_SIZE 0x10000UL
240
241 static unsigned long
242 @@ -497,8 +557,8 @@
243 {
244 d->buf = virt_to_phys(buf);
245 d->sw_len = len == MAX_DESCR_SIZE ? 0 : len;
246 - if (last)
247 - d->ctrl |= d_eol;
248 + d->ctrl = last ? d_eol : 0;
249 + d->next = last ? 0 : virt_to_phys(d+1); /* assumes descr's in array */
250 }
251
252 static void cris_ide_start_dma(ide_drive_t *drive, cris_dma_descr_type *d, int dir, int type, int len)
253 @@ -521,14 +581,14 @@
254 *R_DMA_CH2_FIRST = virt_to_phys(d);
255 *R_DMA_CH2_CMD = IO_STATE(R_DMA_CH2_CMD, cmd, start);
256 }
257 -
258 +
259 /* initiate a multi word dma read using DMA handshaking */
260
261 *R_ATA_TRANSFER_CNT =
262 IO_FIELD(R_ATA_TRANSFER_CNT, count, len >> 1);
263
264 cmd = dir ? IO_STATE(R_ATA_CTRL_DATA, rw, read) : IO_STATE(R_ATA_CTRL_DATA, rw, write);
265 - cmd |= type == TYPE_PIO ? IO_STATE(R_ATA_CTRL_DATA, handsh, pio) :
266 + cmd |= type == TYPE_PIO ? IO_STATE(R_ATA_CTRL_DATA, handsh, pio) :
267 IO_STATE(R_ATA_CTRL_DATA, handsh, dma);
268 *R_ATA_CTRL_DATA =
269 cmd |
270 @@ -570,7 +630,7 @@
271 }
272
273 #endif
274 -
275 +
276 void
277 cris_ide_outw(unsigned short data, unsigned long reg) {
278 int timeleft;
279 @@ -597,7 +657,7 @@
280 if(!timeleft)
281 printk("ATA timeout reg 0x%lx := 0x%x\n", reg, data);
282
283 - cris_ide_write_command(reg|data); /* write data to the drive's register */
284 + cris_ide_write_command(reg|data); /* write data to the drive's register */
285
286 timeleft = IDE_REGISTER_TIMEOUT;
287 /* wait for transmitter ready */
288 @@ -684,13 +744,15 @@
289 static void cris_atapi_output_bytes(ide_drive_t *drive, void *, unsigned int);
290 static int cris_dma_off (ide_drive_t *drive);
291 static int cris_dma_on (ide_drive_t *drive);
292 +static int cris_dma_host_off (ide_drive_t *drive);
293 +static int cris_dma_host_on (ide_drive_t *drive);
294
295 static void tune_cris_ide(ide_drive_t *drive, u8 pio)
296 {
297 int setup, strobe, hold;
298
299 switch(pio)
300 - {
301 + {
302 case 0:
303 setup = ATA_PIO0_SETUP;
304 strobe = ATA_PIO0_STROBE;
305 @@ -715,7 +777,7 @@
306 setup = ATA_PIO4_SETUP;
307 strobe = ATA_PIO4_STROBE;
308 hold = ATA_PIO4_HOLD;
309 - break;
310 + break;
311 default:
312 return;
313 }
314 @@ -733,7 +795,7 @@
315 }
316
317 switch(speed)
318 - {
319 + {
320 case XFER_UDMA_0:
321 cyc = ATA_UDMA0_CYC;
322 dvs = ATA_UDMA0_DVS;
323 @@ -765,7 +827,7 @@
324 if (speed >= XFER_UDMA_0)
325 cris_ide_set_speed(TYPE_UDMA, cyc, dvs, 0);
326 else
327 - cris_ide_set_speed(TYPE_DMA, 0, strobe, hold);
328 + cris_ide_set_speed(TYPE_DMA, 0, strobe, hold);
329
330 return 0;
331 }
332 @@ -790,11 +852,13 @@
333
334 for(h = 0; h < MAX_HWIFS; h++) {
335 ide_hwif_t *hwif = &ide_hwifs[h];
336 - ide_setup_ports(&hw, cris_ide_base_address(h),
337 + memset(&hw, 0, sizeof(hw));
338 + ide_setup_ports(&hw, cris_ide_base_address(h),
339 ide_offsets,
340 0, 0, cris_ide_ack_intr,
341 - ide_default_irq(0));
342 + IRQ);
343 ide_register_hw(&hw, &hwif);
344 + hwif->irq = IRQ;
345 hwif->mmio = 2;
346 hwif->chipset = ide_etrax100;
347 hwif->tuneproc = &tune_cris_ide;
348 @@ -814,13 +878,15 @@
349 hwif->OUTBSYNC = &cris_ide_outbsync;
350 hwif->INB = &cris_ide_inb;
351 hwif->INW = &cris_ide_inw;
352 - hwif->ide_dma_host_off = &cris_dma_off;
353 - hwif->ide_dma_host_on = &cris_dma_on;
354 + hwif->ide_dma_host_off = &cris_dma_host_off;
355 + hwif->ide_dma_host_on = &cris_dma_host_on;
356 hwif->ide_dma_off_quietly = &cris_dma_off;
357 + hwif->ide_dma_on = &cris_dma_on;
358 hwif->udma_four = 0;
359 hwif->ultra_mask = cris_ultra_mask;
360 hwif->mwdma_mask = 0x07; /* Multiword DMA 0-2 */
361 hwif->swdma_mask = 0x07; /* Singleword DMA 0-2 */
362 + hwif->rqsize = 256;
363 }
364
365 /* Reset pulse */
366 @@ -835,13 +901,25 @@
367 cris_ide_set_speed(TYPE_UDMA, ATA_UDMA2_CYC, ATA_UDMA2_DVS, 0);
368 }
369
370 +static int cris_dma_host_off (ide_drive_t *drive)
371 +{
372 + return 0;
373 +}
374 +
375 +static int cris_dma_host_on (ide_drive_t *drive)
376 +{
377 + return 0;
378 +}
379 +
380 static int cris_dma_off (ide_drive_t *drive)
381 {
382 + drive->using_dma = 0;
383 return 0;
384 }
385
386 static int cris_dma_on (ide_drive_t *drive)
387 {
388 + drive->using_dma = 1;
389 return 0;
390 }
391
392 @@ -958,30 +1036,28 @@
393 size += sg_dma_len(sg);
394 }
395
396 - /* did we run out of descriptors? */
397 -
398 - if(count >= MAX_DMA_DESCRS) {
399 - printk("%s: too few DMA descriptors\n", drive->name);
400 - return 1;
401 - }
402 -
403 - /* however, this case is more difficult - rw_trf_cnt cannot be more
404 - than 65536 words per transfer, so in that case we need to either
405 + /* rw_trf_cnt cannot be more than 131072 words per transfer,
406 + (- 1 word for UDMA CRC) so in that case we need to either:
407 1) use a DMA interrupt to re-trigger rw_trf_cnt and continue with
408 the descriptors, or
409 2) simply do the request here, and get dma_intr to only ide_end_request on
410 those blocks that were actually set-up for transfer.
411 + (The ide framework will issue a new request for the remainder)
412 */
413
414 - if(ata_tot_size + size > 131072) {
415 + if(ata_tot_size + size > 262140) {
416 printk("too large total ATA DMA request, %d + %d!\n", ata_tot_size, (int)size);
417 return 1;
418 }
419
420 - /* If size > MAX_DESCR_SIZE it has to be splitted into new descriptors. Since we
421 - don't handle size > 131072 only one split is necessary */
422 + /* If size > MAX_DESCR_SIZE it has to be splitted into new descriptors. */
423
424 - if(size > MAX_DESCR_SIZE) {
425 + while (size > MAX_DESCR_SIZE) {
426 + /* did we run out of descriptors? */
427 + if(count >= MAX_DMA_DESCRS) {
428 + printk("%s: too few DMA descriptors\n", drive->name);
429 + return 1;
430 + }
431 cris_ide_fill_descriptor(&ata_descrs[count], (void*)addr, MAX_DESCR_SIZE, 0);
432 count++;
433 ata_tot_size += MAX_DESCR_SIZE;
434 @@ -989,6 +1065,11 @@
435 addr += MAX_DESCR_SIZE;
436 }
437
438 + /* did we run out of descriptors? */
439 + if(count >= MAX_DMA_DESCRS) {
440 + printk("%s: too few DMA descriptors\n", drive->name);
441 + return 1;
442 + }
443 cris_ide_fill_descriptor(&ata_descrs[count], (void*)addr, size,i ? 0 : 1);
444 count++;
445 ata_tot_size += size;
446 @@ -1050,8 +1131,12 @@
447
448 if (id && (id->capability & 1)) {
449 if (ide_use_dma(drive)) {
450 - if (cris_config_drive_for_dma(drive))
451 - return hwif->ide_dma_on(drive);
452 + if (cris_config_drive_for_dma(drive)) {
453 + if (hwif->ide_dma_on)
454 + return hwif->ide_dma_on(drive);
455 + else
456 + return 1;
457 + }
458 }
459 }
460
461 --- linux-2.6.19.2.orig/drivers/serial/crisv10.c 2007-01-10 20:10:37.000000000 +0100
462 +++ linux-2.6.19.2.dev/drivers/serial/crisv10.c 2007-01-09 10:30:54.000000000 +0100
463 @@ -2,7 +2,7 @@
464 *
465 * Serial port driver for the ETRAX 100LX chip
466 *
467 - * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Axis Communications AB
468 + * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Axis Communications AB
469 *
470 * Many, many authors. Based once upon a time on serial.c for 16x50.
471 *
472 @@ -445,6 +445,7 @@
473
474 #include <asm/io.h>
475 #include <asm/irq.h>
476 +#include <asm/dma.h>
477 #include <asm/system.h>
478 #include <asm/bitops.h>
479 #include <linux/delay.h>
480 @@ -454,8 +455,9 @@
481 /* non-arch dependent serial structures are in linux/serial.h */
482 #include <linux/serial.h>
483 /* while we keep our own stuff (struct e100_serial) in a local .h file */
484 -#include "serial.h"
485 +#include "crisv10.h"
486 #include <asm/fasttimer.h>
487 +#include <asm/arch/io_interface_mux.h>
488
489 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
490 #ifndef CONFIG_ETRAX_FAST_TIMER
491 @@ -586,11 +588,10 @@
492 static void change_speed(struct e100_serial *info);
493 static void rs_throttle(struct tty_struct * tty);
494 static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
495 -static int rs_write(struct tty_struct * tty, int from_user,
496 +static int rs_write(struct tty_struct * tty,
497 const unsigned char *buf, int count);
498 #ifdef CONFIG_ETRAX_RS485
499 -static int e100_write_rs485(struct tty_struct * tty, int from_user,
500 - const unsigned char *buf, int count);
501 +static int e100_write_rs485(struct tty_struct * tty, const unsigned char *buf, int count);
502 #endif
503 static int get_lsr_info(struct e100_serial * info, unsigned int *value);
504
505 @@ -677,20 +678,39 @@
506 .rx_ctrl = DEF_RX,
507 .tx_ctrl = DEF_TX,
508 .iseteop = 2,
509 + .dma_owner = dma_ser0,
510 + .io_if = if_serial_0,
511 #ifdef CONFIG_ETRAX_SERIAL_PORT0
512 .enabled = 1,
513 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
514 .dma_out_enabled = 1,
515 + .dma_out_nbr = SER0_TX_DMA_NBR,
516 + .dma_out_irq_nbr = SER0_DMA_TX_IRQ_NBR,
517 + .dma_out_irq_flags = IRQF_DISABLED,
518 + .dma_out_irq_description = "serial 0 dma tr",
519 #else
520 .dma_out_enabled = 0,
521 + .dma_out_nbr = UINT_MAX,
522 + .dma_out_irq_nbr = 0,
523 + .dma_out_irq_flags = 0,
524 + .dma_out_irq_description = NULL,
525 #endif
526 #ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
527 .dma_in_enabled = 1,
528 + .dma_in_nbr = SER0_RX_DMA_NBR,
529 + .dma_in_irq_nbr = SER0_DMA_RX_IRQ_NBR,
530 + .dma_in_irq_flags = IRQF_DISABLED,
531 + .dma_in_irq_description = "serial 0 dma rec",
532 #else
533 - .dma_in_enabled = 0
534 + .dma_in_enabled = 0,
535 + .dma_in_nbr = UINT_MAX,
536 + .dma_in_irq_nbr = 0,
537 + .dma_in_irq_flags = 0,
538 + .dma_in_irq_description = NULL,
539 #endif
540 #else
541 .enabled = 0,
542 + .io_if_description = NULL,
543 .dma_out_enabled = 0,
544 .dma_in_enabled = 0
545 #endif
546 @@ -712,20 +732,42 @@
547 .rx_ctrl = DEF_RX,
548 .tx_ctrl = DEF_TX,
549 .iseteop = 3,
550 + .dma_owner = dma_ser1,
551 + .io_if = if_serial_1,
552 #ifdef CONFIG_ETRAX_SERIAL_PORT1
553 .enabled = 1,
554 + .io_if_description = "ser1",
555 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA8_OUT
556 .dma_out_enabled = 1,
557 + .dma_out_nbr = SER1_TX_DMA_NBR,
558 + .dma_out_irq_nbr = SER1_DMA_TX_IRQ_NBR,
559 + .dma_out_irq_flags = IRQF_DISABLED,
560 + .dma_out_irq_description = "serial 1 dma tr",
561 #else
562 .dma_out_enabled = 0,
563 + .dma_out_nbr = UINT_MAX,
564 + .dma_out_irq_nbr = 0,
565 + .dma_out_irq_flags = 0,
566 + .dma_out_irq_description = NULL,
567 #endif
568 #ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA9_IN
569 .dma_in_enabled = 1,
570 + .dma_in_nbr = SER1_RX_DMA_NBR,
571 + .dma_in_irq_nbr = SER1_DMA_RX_IRQ_NBR,
572 + .dma_in_irq_flags = IRQF_DISABLED,
573 + .dma_in_irq_description = "serial 1 dma rec",
574 #else
575 - .dma_in_enabled = 0
576 + .dma_in_enabled = 0,
577 + .dma_in_enabled = 0,
578 + .dma_in_nbr = UINT_MAX,
579 + .dma_in_irq_nbr = 0,
580 + .dma_in_irq_flags = 0,
581 + .dma_in_irq_description = NULL,
582 #endif
583 #else
584 .enabled = 0,
585 + .io_if_description = NULL,
586 + .dma_in_irq_nbr = 0,
587 .dma_out_enabled = 0,
588 .dma_in_enabled = 0
589 #endif
590 @@ -746,20 +788,40 @@
591 .rx_ctrl = DEF_RX,
592 .tx_ctrl = DEF_TX,
593 .iseteop = 0,
594 + .dma_owner = dma_ser2,
595 + .io_if = if_serial_2,
596 #ifdef CONFIG_ETRAX_SERIAL_PORT2
597 .enabled = 1,
598 + .io_if_description = "ser2",
599 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
600 .dma_out_enabled = 1,
601 + .dma_out_nbr = SER2_TX_DMA_NBR,
602 + .dma_out_irq_nbr = SER2_DMA_TX_IRQ_NBR,
603 + .dma_out_irq_flags = IRQF_DISABLED,
604 + .dma_out_irq_description = "serial 2 dma tr",
605 #else
606 .dma_out_enabled = 0,
607 + .dma_in_nbr = UINT_MAX,
608 + .dma_in_irq_nbr = 0,
609 + .dma_in_irq_flags = 0,
610 + .dma_in_irq_description = NULL,
611 #endif
612 #ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
613 .dma_in_enabled = 1,
614 + .dma_in_nbr = SER2_RX_DMA_NBR,
615 + .dma_in_irq_nbr = SER2_DMA_RX_IRQ_NBR,
616 + .dma_in_irq_flags = IRQF_DISABLED,
617 + .dma_in_irq_description = "serial 2 dma rec",
618 #else
619 - .dma_in_enabled = 0
620 + .dma_in_enabled = 0,
621 + .dma_in_nbr = UINT_MAX,
622 + .dma_in_irq_nbr = 0,
623 + .dma_in_irq_flags = 0,
624 + .dma_in_irq_description = NULL,
625 #endif
626 #else
627 .enabled = 0,
628 + .io_if_description = NULL,
629 .dma_out_enabled = 0,
630 .dma_in_enabled = 0
631 #endif
632 @@ -780,20 +842,40 @@
633 .rx_ctrl = DEF_RX,
634 .tx_ctrl = DEF_TX,
635 .iseteop = 1,
636 + .dma_owner = dma_ser3,
637 + .io_if = if_serial_3,
638 #ifdef CONFIG_ETRAX_SERIAL_PORT3
639 .enabled = 1,
640 + .io_if_description = "ser3",
641 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA4_OUT
642 .dma_out_enabled = 1,
643 + .dma_out_nbr = SER3_TX_DMA_NBR,
644 + .dma_out_irq_nbr = SER3_DMA_TX_IRQ_NBR,
645 + .dma_out_irq_flags = IRQF_DISABLED,
646 + .dma_out_irq_description = "serial 3 dma tr",
647 #else
648 .dma_out_enabled = 0,
649 + .dma_out_nbr = UINT_MAX,
650 + .dma_out_irq_nbr = 0,
651 + .dma_out_irq_flags = 0,
652 + .dma_out_irq_description = NULL,
653 #endif
654 #ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA5_IN
655 .dma_in_enabled = 1,
656 + .dma_in_nbr = SER3_RX_DMA_NBR,
657 + .dma_in_irq_nbr = SER3_DMA_RX_IRQ_NBR,
658 + .dma_in_irq_flags = IRQF_DISABLED,
659 + .dma_in_irq_description = "serial 3 dma rec",
660 #else
661 - .dma_in_enabled = 0
662 + .dma_in_enabled = 0,
663 + .dma_in_nbr = UINT_MAX,
664 + .dma_in_irq_nbr = 0,
665 + .dma_in_irq_flags = 0,
666 + .dma_in_irq_description = NULL
667 #endif
668 #else
669 .enabled = 0,
670 + .io_if_description = NULL,
671 .dma_out_enabled = 0,
672 .dma_in_enabled = 0
673 #endif
674 @@ -1414,12 +1496,11 @@
675 {
676 unsigned long flags;
677
678 - save_flags(flags);
679 - cli();
680 + local_irq_save(flags);
681 *e100_modem_pins[info->line].dtr_shadow &= ~mask;
682 *e100_modem_pins[info->line].dtr_shadow |= (set ? 0 : mask);
683 *e100_modem_pins[info->line].dtr_port = *e100_modem_pins[info->line].dtr_shadow;
684 - restore_flags(flags);
685 + local_irq_restore(flags);
686 }
687
688 #ifdef SERIAL_DEBUG_IO
689 @@ -1438,12 +1519,11 @@
690 {
691 #ifndef CONFIG_SVINTO_SIM
692 unsigned long flags;
693 - save_flags(flags);
694 - cli();
695 + local_irq_save(flags);
696 info->rx_ctrl &= ~E100_RTS_MASK;
697 info->rx_ctrl |= (set ? 0 : E100_RTS_MASK); /* RTS is active low */
698 info->port[REG_REC_CTRL] = info->rx_ctrl;
699 - restore_flags(flags);
700 + local_irq_restore(flags);
701 #ifdef SERIAL_DEBUG_IO
702 printk("ser%i rts %i\n", info->line, set);
703 #endif
704 @@ -1461,12 +1541,11 @@
705 unsigned char mask = e100_modem_pins[info->line].ri_mask;
706 unsigned long flags;
707
708 - save_flags(flags);
709 - cli();
710 + local_irq_save(flags);
711 *e100_modem_pins[info->line].ri_shadow &= ~mask;
712 *e100_modem_pins[info->line].ri_shadow |= (set ? 0 : mask);
713 *e100_modem_pins[info->line].ri_port = *e100_modem_pins[info->line].ri_shadow;
714 - restore_flags(flags);
715 + local_irq_restore(flags);
716 }
717 #endif
718 }
719 @@ -1479,12 +1558,11 @@
720 unsigned char mask = e100_modem_pins[info->line].cd_mask;
721 unsigned long flags;
722
723 - save_flags(flags);
724 - cli();
725 + local_irq_save(flags);
726 *e100_modem_pins[info->line].cd_shadow &= ~mask;
727 *e100_modem_pins[info->line].cd_shadow |= (set ? 0 : mask);
728 *e100_modem_pins[info->line].cd_port = *e100_modem_pins[info->line].cd_shadow;
729 - restore_flags(flags);
730 + local_irq_restore(flags);
731 }
732 #endif
733 }
734 @@ -1558,8 +1636,7 @@
735 /* Disable output DMA channel for the serial port in question
736 * ( set to something other then serialX)
737 */
738 - save_flags(flags);
739 - cli();
740 + local_irq_save(flags);
741 DFLOW(DEBUG_LOG(info->line, "disable_txdma_channel %i\n", info->line));
742 if (info->line == 0) {
743 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma6)) ==
744 @@ -1587,7 +1664,7 @@
745 }
746 }
747 *R_GEN_CONFIG = genconfig_shadow;
748 - restore_flags(flags);
749 + local_irq_restore(flags);
750 }
751
752
753 @@ -1595,8 +1672,7 @@
754 {
755 unsigned long flags;
756
757 - save_flags(flags);
758 - cli();
759 + local_irq_save(flags);
760 DFLOW(DEBUG_LOG(info->line, "enable_txdma_channel %i\n", info->line));
761 /* Enable output DMA channel for the serial port in question */
762 if (info->line == 0) {
763 @@ -1613,7 +1689,7 @@
764 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma4, serial3);
765 }
766 *R_GEN_CONFIG = genconfig_shadow;
767 - restore_flags(flags);
768 + local_irq_restore(flags);
769 }
770
771 static void e100_disable_rxdma_channel(struct e100_serial *info)
772 @@ -1623,8 +1699,7 @@
773 /* Disable input DMA channel for the serial port in question
774 * ( set to something other then serialX)
775 */
776 - save_flags(flags);
777 - cli();
778 + local_irq_save(flags);
779 if (info->line == 0) {
780 if ((genconfig_shadow & IO_MASK(R_GEN_CONFIG, dma7)) ==
781 IO_STATE(R_GEN_CONFIG, dma7, serial0)) {
782 @@ -1651,7 +1726,7 @@
783 }
784 }
785 *R_GEN_CONFIG = genconfig_shadow;
786 - restore_flags(flags);
787 + local_irq_restore(flags);
788 }
789
790
791 @@ -1659,8 +1734,7 @@
792 {
793 unsigned long flags;
794
795 - save_flags(flags);
796 - cli();
797 + local_irq_save(flags);
798 /* Enable input DMA channel for the serial port in question */
799 if (info->line == 0) {
800 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma7);
801 @@ -1676,7 +1750,7 @@
802 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma5, serial3);
803 }
804 *R_GEN_CONFIG = genconfig_shadow;
805 - restore_flags(flags);
806 + local_irq_restore(flags);
807 }
808
809 #ifdef SERIAL_HANDLE_EARLY_ERRORS
810 @@ -1783,7 +1857,7 @@
811 }
812
813 static int
814 -e100_write_rs485(struct tty_struct *tty, int from_user,
815 +e100_write_rs485(struct tty_struct *tty,
816 const unsigned char *buf, int count)
817 {
818 struct e100_serial * info = (struct e100_serial *)tty->driver_data;
819 @@ -1796,7 +1870,7 @@
820 */
821 info->rs485.enabled = 1;
822 /* rs_write now deals with RS485 if enabled */
823 - count = rs_write(tty, from_user, buf, count);
824 + count = rs_write(tty, buf, count);
825 info->rs485.enabled = old_enabled;
826 return count;
827 }
828 @@ -1834,7 +1908,7 @@
829 unsigned long flags;
830 unsigned long xoff;
831
832 - save_flags(flags); cli();
833 + local_irq_save(flags);
834 DFLOW(DEBUG_LOG(info->line, "XOFF rs_stop xmit %i\n",
835 CIRC_CNT(info->xmit.head,
836 info->xmit.tail,SERIAL_XMIT_SIZE)));
837 @@ -1846,7 +1920,7 @@
838 }
839
840 *((unsigned long *)&info->port[REG_XOFF]) = xoff;
841 - restore_flags(flags);
842 + local_irq_restore(flags);
843 }
844 }
845
846 @@ -1858,7 +1932,7 @@
847 unsigned long flags;
848 unsigned long xoff;
849
850 - save_flags(flags); cli();
851 + local_irq_save(flags);
852 DFLOW(DEBUG_LOG(info->line, "XOFF rs_start xmit %i\n",
853 CIRC_CNT(info->xmit.head,
854 info->xmit.tail,SERIAL_XMIT_SIZE)));
855 @@ -1873,7 +1947,7 @@
856 info->xmit.head != info->xmit.tail && info->xmit.buf)
857 e100_enable_serial_tx_ready_irq(info);
858
859 - restore_flags(flags);
860 + local_irq_restore(flags);
861 }
862 }
863
864 @@ -2053,8 +2127,7 @@
865 static void flush_timeout_function(unsigned long data);
866 #define START_FLUSH_FAST_TIMER_TIME(info, string, usec) {\
867 unsigned long timer_flags; \
868 - save_flags(timer_flags); \
869 - cli(); \
870 + local_irq_save(timer_flags); \
871 if (fast_timers[info->line].function == NULL) { \
872 serial_fast_timer_started++; \
873 TIMERD(DEBUG_LOG(info->line, "start_timer %i ", info->line)); \
874 @@ -2068,7 +2141,7 @@
875 else { \
876 TIMERD(DEBUG_LOG(info->line, "timer %i already running\n", info->line)); \
877 } \
878 - restore_flags(timer_flags); \
879 + local_irq_restore(timer_flags); \
880 }
881 #define START_FLUSH_FAST_TIMER(info, string) START_FLUSH_FAST_TIMER_TIME(info, string, info->flush_time_usec)
882
883 @@ -2097,8 +2170,7 @@
884 {
885 unsigned long flags;
886
887 - save_flags(flags);
888 - cli();
889 + local_irq_save(flags);
890
891 if (!info->first_recv_buffer)
892 info->first_recv_buffer = buffer;
893 @@ -2111,7 +2183,7 @@
894 if (info->recv_cnt > info->max_recv_cnt)
895 info->max_recv_cnt = info->recv_cnt;
896
897 - restore_flags(flags);
898 + local_irq_restore(flags);
899 }
900
901 static int
902 @@ -2131,11 +2203,7 @@
903 info->icount.rx++;
904 } else {
905 struct tty_struct *tty = info->tty;
906 - *tty->flip.char_buf_ptr = data;
907 - *tty->flip.flag_buf_ptr = flag;
908 - tty->flip.flag_buf_ptr++;
909 - tty->flip.char_buf_ptr++;
910 - tty->flip.count++;
911 + tty_insert_flip_char(tty, data, flag);
912 info->icount.rx++;
913 }
914
915 @@ -2320,7 +2388,6 @@
916 */
917 return;
918 #endif
919 - info->tty->flip.count = 0;
920 if (info->uses_dma_in) {
921 /* reset the input dma channel to be sure it works */
922
923 @@ -2482,70 +2549,21 @@
924 {
925 struct tty_struct *tty;
926 struct etrax_recv_buffer *buffer;
927 - unsigned int length;
928 unsigned long flags;
929 - int max_flip_size;
930 -
931 - if (!info->first_recv_buffer)
932 - return;
933
934 - save_flags(flags);
935 - cli();
936 + local_irq_save(flags);
937 + tty = info->tty;
938
939 - if (!(tty = info->tty)) {
940 - restore_flags(flags);
941 + if (!tty) {
942 + local_irq_restore(flags);
943 return;
944 }
945
946 - length = tty->flip.count;
947 - /* Don't flip more than the ldisc has room for.
948 - * The return value from ldisc.receive_room(tty) - might not be up to
949 - * date, the previous flip of up to TTY_FLIPBUF_SIZE might be on the
950 - * processed and not accounted for yet.
951 - * Since we use DMA, 1 SERIAL_DESCR_BUF_SIZE could be on the way.
952 - * Lets buffer data here and let flow control take care of it.
953 - * Since we normally flip large chunks, the ldisc don't react
954 - * with throttle until too late if we flip to much.
955 - */
956 - max_flip_size = tty->ldisc.receive_room(tty);
957 - if (max_flip_size < 0)
958 - max_flip_size = 0;
959 - if (max_flip_size <= (TTY_FLIPBUF_SIZE + /* Maybe not accounted for */
960 - length + info->recv_cnt + /* We have this queued */
961 - 2*SERIAL_DESCR_BUF_SIZE + /* This could be on the way */
962 - TTY_THRESHOLD_THROTTLE)) { /* Some slack */
963 - /* check TTY_THROTTLED first so it indicates our state */
964 - if (!test_and_set_bit(TTY_THROTTLED, &tty->flags)) {
965 - DFLOW(DEBUG_LOG(info->line,"flush_to_flip throttles room %lu\n", max_flip_size));
966 - rs_throttle(tty);
967 - }
968 -#if 0
969 - else if (max_flip_size <= (TTY_FLIPBUF_SIZE + /* Maybe not accounted for */
970 - length + info->recv_cnt + /* We have this queued */
971 - SERIAL_DESCR_BUF_SIZE + /* This could be on the way */
972 - TTY_THRESHOLD_THROTTLE)) { /* Some slack */
973 - DFLOW(DEBUG_LOG(info->line,"flush_to_flip throttles again! %lu\n", max_flip_size));
974 - rs_throttle(tty);
975 - }
976 -#endif
977 - }
978 -
979 - if (max_flip_size > TTY_FLIPBUF_SIZE)
980 - max_flip_size = TTY_FLIPBUF_SIZE;
981 -
982 - while ((buffer = info->first_recv_buffer) && length < max_flip_size) {
983 + while ((buffer = info->first_recv_buffer)) {
984 unsigned int count = buffer->length;
985
986 - if (length + count > max_flip_size)
987 - count = max_flip_size - length;
988 -
989 - memcpy(tty->flip.char_buf_ptr + length, buffer->buffer, count);
990 - memset(tty->flip.flag_buf_ptr + length, TTY_NORMAL, count);
991 - tty->flip.flag_buf_ptr[length] = buffer->error;
992 -
993 - length += count;
994 + tty_insert_flip_string(tty, buffer->buffer, count);
995 info->recv_cnt -= count;
996 - DFLIP(DEBUG_LOG(info->line,"flip: %i\n", length));
997
998 if (count == buffer->length) {
999 info->first_recv_buffer = buffer->next;
1000 @@ -2560,24 +2578,7 @@
1001 if (!info->first_recv_buffer)
1002 info->last_recv_buffer = NULL;
1003
1004 - tty->flip.count = length;
1005 - DFLIP(if (tty->ldisc.chars_in_buffer(tty) > 3500) {
1006 - DEBUG_LOG(info->line, "ldisc %lu\n",
1007 - tty->ldisc.chars_in_buffer(tty));
1008 - DEBUG_LOG(info->line, "flip.count %lu\n",
1009 - tty->flip.count);
1010 - }
1011 - );
1012 - restore_flags(flags);
1013 -
1014 - DFLIP(
1015 - if (1) {
1016 - DEBUG_LOG(info->line, "*** rxtot %i\n", info->icount.rx);
1017 - DEBUG_LOG(info->line, "ldisc %lu\n", tty->ldisc.chars_in_buffer(tty));
1018 - DEBUG_LOG(info->line, "room %lu\n", tty->ldisc.receive_room(tty));
1019 - }
1020 -
1021 - );
1022 + local_irq_restore(flags);
1023
1024 /* this includes a check for low-latency */
1025 tty_flip_buffer_push(tty);
1026 @@ -2722,21 +2723,7 @@
1027 printk("!NO TTY!\n");
1028 return info;
1029 }
1030 - if (tty->flip.count >= TTY_FLIPBUF_SIZE - TTY_THRESHOLD_THROTTLE) {
1031 - /* check TTY_THROTTLED first so it indicates our state */
1032 - if (!test_and_set_bit(TTY_THROTTLED, &tty->flags)) {
1033 - DFLOW(DEBUG_LOG(info->line, "rs_throttle flip.count: %i\n", tty->flip.count));
1034 - rs_throttle(tty);
1035 - }
1036 - }
1037 - if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
1038 - DEBUG_LOG(info->line, "force FLIP! %i\n", tty->flip.count);
1039 - tty->flip.work.func((void *) tty);
1040 - if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
1041 - DEBUG_LOG(info->line, "FLIP FULL! %i\n", tty->flip.count);
1042 - return info; /* if TTY_DONT_FLIP is set */
1043 - }
1044 - }
1045 +
1046 /* Read data and status at the same time */
1047 data_read = *((unsigned long *)&info->port[REG_DATA_STATUS32]);
1048 more_data:
1049 @@ -2789,27 +2776,25 @@
1050 DEBUG_LOG(info->line, "EBRK %i\n", info->break_detected_cnt);
1051 info->errorcode = ERRCODE_INSERT_BREAK;
1052 } else {
1053 + unsigned char data = IO_EXTRACT(R_SERIAL0_READ, data_in, data_read);
1054 + char flag = TTY_NORMAL;
1055 if (info->errorcode == ERRCODE_INSERT_BREAK) {
1056 - info->icount.brk++;
1057 - *tty->flip.char_buf_ptr = 0;
1058 - *tty->flip.flag_buf_ptr = TTY_BREAK;
1059 - tty->flip.flag_buf_ptr++;
1060 - tty->flip.char_buf_ptr++;
1061 - tty->flip.count++;
1062 + struct tty_struct *tty = info->tty;
1063 + tty_insert_flip_char(tty, 0, flag);
1064 info->icount.rx++;
1065 }
1066 - *tty->flip.char_buf_ptr = IO_EXTRACT(R_SERIAL0_READ, data_in, data_read);
1067
1068 if (data_read & IO_MASK(R_SERIAL0_READ, par_err)) {
1069 info->icount.parity++;
1070 - *tty->flip.flag_buf_ptr = TTY_PARITY;
1071 + flag = TTY_PARITY;
1072 } else if (data_read & IO_MASK(R_SERIAL0_READ, overrun)) {
1073 info->icount.overrun++;
1074 - *tty->flip.flag_buf_ptr = TTY_OVERRUN;
1075 + flag = TTY_OVERRUN;
1076 } else if (data_read & IO_MASK(R_SERIAL0_READ, framing_err)) {
1077 info->icount.frame++;
1078 - *tty->flip.flag_buf_ptr = TTY_FRAME;
1079 + flag = TTY_FRAME;
1080 }
1081 + tty_insert_flip_char(tty, data, flag);
1082 info->errorcode = 0;
1083 }
1084 info->break_detected_cnt = 0;
1085 @@ -2825,16 +2810,12 @@
1086 log_int(rdpc(), 0, 0);
1087 }
1088 );
1089 - *tty->flip.char_buf_ptr = IO_EXTRACT(R_SERIAL0_READ, data_in, data_read);
1090 - *tty->flip.flag_buf_ptr = 0;
1091 + tty_insert_flip_char(tty, IO_EXTRACT(R_SERIAL0_READ, data_in, data_read), TTY_NORMAL);
1092 } else {
1093 DEBUG_LOG(info->line, "ser_rx int but no data_avail %08lX\n", data_read);
1094 }
1095
1096
1097 - tty->flip.flag_buf_ptr++;
1098 - tty->flip.char_buf_ptr++;
1099 - tty->flip.count++;
1100 info->icount.rx++;
1101 data_read = *((unsigned long *)&info->port[REG_DATA_STATUS32]);
1102 if (data_read & IO_MASK(R_SERIAL0_READ, data_avail)) {
1103 @@ -2972,7 +2953,7 @@
1104 if (info->x_char) {
1105 unsigned char rstat;
1106 DFLOW(DEBUG_LOG(info->line, "tx_int: xchar 0x%02X\n", info->x_char));
1107 - save_flags(flags); cli();
1108 + local_irq_save(flags);
1109 rstat = info->port[REG_STATUS];
1110 DFLOW(DEBUG_LOG(info->line, "stat %x\n", rstat));
1111
1112 @@ -2981,7 +2962,7 @@
1113 info->x_char = 0;
1114 /* We must enable since it is disabled in ser_interrupt */
1115 e100_enable_serial_tx_ready_irq(info);
1116 - restore_flags(flags);
1117 + local_irq_restore(flags);
1118 return;
1119 }
1120 if (info->uses_dma_out) {
1121 @@ -2989,7 +2970,7 @@
1122 int i;
1123 /* We only use normal tx interrupt when sending x_char */
1124 DFLOW(DEBUG_LOG(info->line, "tx_int: xchar sent\n", 0));
1125 - save_flags(flags); cli();
1126 + local_irq_save(flags);
1127 rstat = info->port[REG_STATUS];
1128 DFLOW(DEBUG_LOG(info->line, "stat %x\n", rstat));
1129 e100_disable_serial_tx_ready_irq(info);
1130 @@ -3002,7 +2983,7 @@
1131 nop();
1132
1133 *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, continue);
1134 - restore_flags(flags);
1135 + local_irq_restore(flags);
1136 return;
1137 }
1138 /* Normal char-by-char interrupt */
1139 @@ -3016,7 +2997,7 @@
1140 }
1141 DINTR2(DEBUG_LOG(info->line, "tx_int %c\n", info->xmit.buf[info->xmit.tail]));
1142 /* Send a byte, rs485 timing is critical so turn of ints */
1143 - save_flags(flags); cli();
1144 + local_irq_save(flags);
1145 info->port[REG_TR_DATA] = info->xmit.buf[info->xmit.tail];
1146 info->xmit.tail = (info->xmit.tail + 1) & (SERIAL_XMIT_SIZE-1);
1147 info->icount.tx++;
1148 @@ -3040,7 +3021,7 @@
1149 /* We must enable since it is disabled in ser_interrupt */
1150 e100_enable_serial_tx_ready_irq(info);
1151 }
1152 - restore_flags(flags);
1153 + local_irq_restore(flags);
1154
1155 if (CIRC_CNT(info->xmit.head,
1156 info->xmit.tail,
1157 @@ -3065,7 +3046,7 @@
1158 int handled = 0;
1159 static volatile unsigned long reentered_ready_mask = 0;
1160
1161 - save_flags(flags); cli();
1162 + local_irq_save(flags);
1163 irq_mask1_rd = *R_IRQ_MASK1_RD;
1164 /* First handle all rx interrupts with ints disabled */
1165 info = rs_table;
1166 @@ -3110,7 +3091,7 @@
1167 /* Unblock the serial interrupt */
1168 *R_VECT_MASK_SET = IO_STATE(R_VECT_MASK_SET, serial, set);
1169
1170 - sti();
1171 + local_irq_enable();
1172 ready_mask = (1 << (8+1+2*0)); /* ser0 tr_ready */
1173 info = rs_table;
1174 for (i = 0; i < NR_PORTS; i++) {
1175 @@ -3123,11 +3104,11 @@
1176 ready_mask <<= 2;
1177 }
1178 /* handle_ser_tx_interrupt enables tr_ready interrupts */
1179 - cli();
1180 + local_irq_disable();
1181 /* Handle reentered TX interrupt */
1182 irq_mask1_rd = reentered_ready_mask;
1183 }
1184 - cli();
1185 + local_irq_disable();
1186 tx_started = 0;
1187 } else {
1188 unsigned long ready_mask;
1189 @@ -3143,7 +3124,7 @@
1190 }
1191 }
1192
1193 - restore_flags(flags);
1194 + local_irq_restore(flags);
1195 return IRQ_RETVAL(handled);
1196 } /* ser_interrupt */
1197 #endif
1198 @@ -3192,13 +3173,12 @@
1199 if (!xmit_page)
1200 return -ENOMEM;
1201
1202 - save_flags(flags);
1203 - cli();
1204 + local_irq_save(flags);
1205
1206 /* if it was already initialized, skip this */
1207
1208 if (info->flags & ASYNC_INITIALIZED) {
1209 - restore_flags(flags);
1210 + local_irq_restore(flags);
1211 free_page(xmit_page);
1212 return 0;
1213 }
1214 @@ -3324,7 +3304,7 @@
1215
1216 info->flags |= ASYNC_INITIALIZED;
1217
1218 - restore_flags(flags);
1219 + local_irq_restore(flags);
1220 return 0;
1221 }
1222
1223 @@ -3375,8 +3355,7 @@
1224 info->irq);
1225 #endif
1226
1227 - save_flags(flags);
1228 - cli(); /* Disable interrupts */
1229 + local_irq_save(flags);
1230
1231 if (info->xmit.buf) {
1232 free_page((unsigned long)info->xmit.buf);
1233 @@ -3400,7 +3379,7 @@
1234 set_bit(TTY_IO_ERROR, &info->tty->flags);
1235
1236 info->flags &= ~ASYNC_INITIALIZED;
1237 - restore_flags(flags);
1238 + local_irq_restore(flags);
1239 }
1240
1241
1242 @@ -3492,8 +3471,7 @@
1243
1244 #ifndef CONFIG_SVINTO_SIM
1245 /* start with default settings and then fill in changes */
1246 - save_flags(flags);
1247 - cli();
1248 + local_irq_save(flags);
1249 /* 8 bit, no/even parity */
1250 info->rx_ctrl &= ~(IO_MASK(R_SERIAL0_REC_CTRL, rec_bitnr) |
1251 IO_MASK(R_SERIAL0_REC_CTRL, rec_par_en) |
1252 @@ -3557,7 +3535,7 @@
1253 }
1254
1255 *((unsigned long *)&info->port[REG_XOFF]) = xoff;
1256 - restore_flags(flags);
1257 + local_irq_restore(flags);
1258 #endif /* !CONFIG_SVINTO_SIM */
1259
1260 update_char_time(info);
1261 @@ -3585,13 +3563,12 @@
1262
1263 /* this protection might not exactly be necessary here */
1264
1265 - save_flags(flags);
1266 - cli();
1267 + local_irq_save(flags);
1268 start_transmit(info);
1269 - restore_flags(flags);
1270 + local_irq_restore(flags);
1271 }
1272
1273 -static int rs_raw_write(struct tty_struct * tty, int from_user,
1274 +static int rs_raw_write(struct tty_struct * tty,
1275 const unsigned char *buf, int count)
1276 {
1277 int c, ret = 0;
1278 @@ -3614,72 +3591,37 @@
1279 SIMCOUT(buf, count);
1280 return count;
1281 #endif
1282 - save_flags(flags);
1283 + local_save_flags(flags);
1284 DFLOW(DEBUG_LOG(info->line, "write count %i ", count));
1285 DFLOW(DEBUG_LOG(info->line, "ldisc %i\n", tty->ldisc.chars_in_buffer(tty)));
1286
1287
1288 - /* the cli/restore_flags pairs below are needed because the
1289 + /* the local_irq_disable/restore_flags pairs below are needed because the
1290 * DMA interrupt handler moves the info->xmit values. the memcpy
1291 * needs to be in the critical region unfortunately, because we
1292 * need to read xmit values, memcpy, write xmit values in one
1293 * atomic operation... this could perhaps be avoided by more clever
1294 * design.
1295 */
1296 - if (from_user) {
1297 - mutex_lock(&tmp_buf_mutex);
1298 - while (1) {
1299 - int c1;
1300 - c = CIRC_SPACE_TO_END(info->xmit.head,
1301 - info->xmit.tail,
1302 - SERIAL_XMIT_SIZE);
1303 - if (count < c)
1304 - c = count;
1305 - if (c <= 0)
1306 - break;
1307 -
1308 - c -= copy_from_user(tmp_buf, buf, c);
1309 - if (!c) {
1310 - if (!ret)
1311 - ret = -EFAULT;
1312 - break;
1313 - }
1314 - cli();
1315 - c1 = CIRC_SPACE_TO_END(info->xmit.head,
1316 - info->xmit.tail,
1317 - SERIAL_XMIT_SIZE);
1318 - if (c1 < c)
1319 - c = c1;
1320 - memcpy(info->xmit.buf + info->xmit.head, tmp_buf, c);
1321 - info->xmit.head = ((info->xmit.head + c) &
1322 - (SERIAL_XMIT_SIZE-1));
1323 - restore_flags(flags);
1324 - buf += c;
1325 - count -= c;
1326 - ret += c;
1327 - }
1328 - mutex_unlock(&tmp_buf_mutex);
1329 - } else {
1330 - cli();
1331 - while (count) {
1332 - c = CIRC_SPACE_TO_END(info->xmit.head,
1333 - info->xmit.tail,
1334 - SERIAL_XMIT_SIZE);
1335 -
1336 - if (count < c)
1337 - c = count;
1338 - if (c <= 0)
1339 - break;
1340 -
1341 - memcpy(info->xmit.buf + info->xmit.head, buf, c);
1342 - info->xmit.head = (info->xmit.head + c) &
1343 - (SERIAL_XMIT_SIZE-1);
1344 - buf += c;
1345 - count -= c;
1346 - ret += c;
1347 - }
1348 - restore_flags(flags);
1349 + local_irq_disable();
1350 + while (count) {
1351 + c = CIRC_SPACE_TO_END(info->xmit.head,
1352 + info->xmit.tail,
1353 + SERIAL_XMIT_SIZE);
1354 +
1355 + if (count < c)
1356 + c = count;
1357 + if (c <= 0)
1358 + break;
1359 +
1360 + memcpy(info->xmit.buf + info->xmit.head, buf, c);
1361 + info->xmit.head = (info->xmit.head + c) &
1362 + (SERIAL_XMIT_SIZE-1);
1363 + buf += c;
1364 + count -= c;
1365 + ret += c;
1366 }
1367 + local_irq_restore(flags);
1368
1369 /* enable transmitter if not running, unless the tty is stopped
1370 * this does not need IRQ protection since if tr_running == 0
1371 @@ -3698,7 +3640,7 @@
1372 } /* raw_raw_write() */
1373
1374 static int
1375 -rs_write(struct tty_struct * tty, int from_user,
1376 +rs_write(struct tty_struct * tty,
1377 const unsigned char *buf, int count)
1378 {
1379 #if defined(CONFIG_ETRAX_RS485)
1380 @@ -3725,7 +3667,7 @@
1381 }
1382 #endif /* CONFIG_ETRAX_RS485 */
1383
1384 - count = rs_raw_write(tty, from_user, buf, count);
1385 + count = rs_raw_write(tty, buf, count);
1386
1387 #if defined(CONFIG_ETRAX_RS485)
1388 if (info->rs485.enabled)
1389 @@ -3793,10 +3735,9 @@
1390 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
1391 unsigned long flags;
1392
1393 - save_flags(flags);
1394 - cli();
1395 + local_irq_save(flags);
1396 info->xmit.head = info->xmit.tail = 0;
1397 - restore_flags(flags);
1398 + local_irq_restore(flags);
1399
1400 wake_up_interruptible(&tty->write_wait);
1401
1402 @@ -3818,7 +3759,7 @@
1403 {
1404 struct e100_serial *info = (struct e100_serial *)tty->driver_data;
1405 unsigned long flags;
1406 - save_flags(flags); cli();
1407 + local_irq_save(flags);
1408 if (info->uses_dma_out) {
1409 /* Put the DMA on hold and disable the channel */
1410 *info->ocmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, hold);
1411 @@ -3835,7 +3776,7 @@
1412 DFLOW(DEBUG_LOG(info->line, "rs_send_xchar 0x%02X\n", ch));
1413 info->x_char = ch;
1414 e100_enable_serial_tx_ready_irq(info);
1415 - restore_flags(flags);
1416 + local_irq_restore(flags);
1417 }
1418
1419 /*
1420 @@ -4085,61 +4026,6 @@
1421 return 0;
1422 }
1423
1424 -
1425 -static int
1426 -set_modem_info(struct e100_serial * info, unsigned int cmd,
1427 - unsigned int *value)
1428 -{
1429 - unsigned int arg;
1430 -
1431 - if (copy_from_user(&arg, value, sizeof(int)))
1432 - return -EFAULT;
1433 -
1434 - switch (cmd) {
1435 - case TIOCMBIS:
1436 - if (arg & TIOCM_RTS) {
1437 - e100_rts(info, 1);
1438 - }
1439 - if (arg & TIOCM_DTR) {
1440 - e100_dtr(info, 1);
1441 - }
1442 - /* Handle FEMALE behaviour */
1443 - if (arg & TIOCM_RI) {
1444 - e100_ri_out(info, 1);
1445 - }
1446 - if (arg & TIOCM_CD) {
1447 - e100_cd_out(info, 1);
1448 - }
1449 - break;
1450 - case TIOCMBIC:
1451 - if (arg & TIOCM_RTS) {
1452 - e100_rts(info, 0);
1453 - }
1454 - if (arg & TIOCM_DTR) {
1455 - e100_dtr(info, 0);
1456 - }
1457 - /* Handle FEMALE behaviour */
1458 - if (arg & TIOCM_RI) {
1459 - e100_ri_out(info, 0);
1460 - }
1461 - if (arg & TIOCM_CD) {
1462 - e100_cd_out(info, 0);
1463 - }
1464 - break;
1465 - case TIOCMSET:
1466 - e100_rts(info, arg & TIOCM_RTS);
1467 - e100_dtr(info, arg & TIOCM_DTR);
1468 - /* Handle FEMALE behaviour */
1469 - e100_ri_out(info, arg & TIOCM_RI);
1470 - e100_cd_out(info, arg & TIOCM_CD);
1471 - break;
1472 - default:
1473 - return -EINVAL;
1474 - }
1475 - return 0;
1476 -}
1477 -
1478 -
1479 static void
1480 rs_break(struct tty_struct *tty, int break_state)
1481 {
1482 @@ -4149,8 +4035,7 @@
1483 if (!info->port)
1484 return;
1485
1486 - save_flags(flags);
1487 - cli();
1488 + local_irq_save(flags);
1489 if (break_state == -1) {
1490 /* Go to manual mode and set the txd pin to 0 */
1491 info->tx_ctrl &= 0x3F; /* Clear bit 7 (txd) and 6 (tr_enable) */
1492 @@ -4158,7 +4043,42 @@
1493 info->tx_ctrl |= (0x80 | 0x40); /* Set bit 7 (txd) and 6 (tr_enable) */
1494 }
1495 info->port[REG_TR_CTRL] = info->tx_ctrl;
1496 - restore_flags(flags);
1497 + local_irq_restore(flags);
1498 +}
1499 +
1500 +static int
1501 +rs_tiocmset(struct tty_struct *tty, struct file * file, unsigned int set, unsigned int clear)
1502 +{
1503 + struct e100_serial * info = (struct e100_serial *)tty->driver_data;
1504 +
1505 + if (clear & TIOCM_RTS) {
1506 + e100_rts(info, 0);
1507 + }
1508 + if (clear & TIOCM_DTR) {
1509 + e100_dtr(info, 0);
1510 + }
1511 + /* Handle FEMALE behaviour */
1512 + if (clear & TIOCM_RI) {
1513 + e100_ri_out(info, 0);
1514 + }
1515 + if (clear & TIOCM_CD) {
1516 + e100_cd_out(info, 0);
1517 + }
1518 +
1519 + if (set & TIOCM_RTS) {
1520 + e100_rts(info, 1);
1521 + }
1522 + if (set & TIOCM_DTR) {
1523 + e100_dtr(info, 1);
1524 + }
1525 + /* Handle FEMALE behaviour */
1526 + if (set & TIOCM_RI) {
1527 + e100_ri_out(info, 1);
1528 + }
1529 + if (set & TIOCM_CD) {
1530 + e100_cd_out(info, 1);
1531 + }
1532 + return 0;
1533 }
1534
1535 static int
1536 @@ -4177,10 +4097,6 @@
1537 switch (cmd) {
1538 case TIOCMGET:
1539 return get_modem_info(info, (unsigned int *) arg);
1540 - case TIOCMBIS:
1541 - case TIOCMBIC:
1542 - case TIOCMSET:
1543 - return set_modem_info(info, cmd, (unsigned int *) arg);
1544 case TIOCGSERIAL:
1545 return get_serial_info(info,
1546 (struct serial_struct *) arg);
1547 @@ -4212,7 +4128,7 @@
1548 if (copy_from_user(&rs485wr, (struct rs485_write*)arg, sizeof(rs485wr)))
1549 return -EFAULT;
1550
1551 - return e100_write_rs485(tty, 1, rs485wr.outc, rs485wr.outc_size);
1552 + return e100_write_rs485(tty, rs485wr.outc, rs485wr.outc_size);
1553 }
1554 #endif
1555
1556 @@ -4242,46 +4158,6 @@
1557
1558 }
1559
1560 -/* In debugport.c - register a console write function that uses the normal
1561 - * serial driver
1562 - */
1563 -typedef int (*debugport_write_function)(int i, const char *buf, unsigned int len);
1564 -
1565 -extern debugport_write_function debug_write_function;
1566 -
1567 -static int rs_debug_write_function(int i, const char *buf, unsigned int len)
1568 -{
1569 - int cnt;
1570 - int written = 0;
1571 - struct tty_struct *tty;
1572 - static int recurse_cnt = 0;
1573 -
1574 - tty = rs_table[i].tty;
1575 - if (tty) {
1576 - unsigned long flags;
1577 - if (recurse_cnt > 5) /* We skip this debug output */
1578 - return 1;
1579 -
1580 - local_irq_save(flags);
1581 - recurse_cnt++;
1582 - local_irq_restore(flags);
1583 - do {
1584 - cnt = rs_write(tty, 0, buf + written, len);
1585 - if (cnt >= 0) {
1586 - written += cnt;
1587 - buf += cnt;
1588 - len -= cnt;
1589 - } else
1590 - len = cnt;
1591 - } while(len > 0);
1592 - local_irq_save(flags);
1593 - recurse_cnt--;
1594 - local_irq_restore(flags);
1595 - return 1;
1596 - }
1597 - return 0;
1598 -}
1599 -
1600 /*
1601 * ------------------------------------------------------------
1602 * rs_close()
1603 @@ -4303,11 +4179,10 @@
1604
1605 /* interrupts are disabled for this entire function */
1606
1607 - save_flags(flags);
1608 - cli();
1609 + local_irq_save(flags);
1610
1611 if (tty_hung_up_p(filp)) {
1612 - restore_flags(flags);
1613 + local_irq_restore(flags);
1614 return;
1615 }
1616
1617 @@ -4334,7 +4209,7 @@
1618 info->count = 0;
1619 }
1620 if (info->count) {
1621 - restore_flags(flags);
1622 + local_irq_restore(flags);
1623 return;
1624 }
1625 info->flags |= ASYNC_CLOSING;
1626 @@ -4388,7 +4263,7 @@
1627 }
1628 info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1629 wake_up_interruptible(&info->close_wait);
1630 - restore_flags(flags);
1631 + local_irq_restore(flags);
1632
1633 /* port closed */
1634
1635 @@ -4410,6 +4285,28 @@
1636 #endif
1637 }
1638 #endif
1639 +
1640 + /*
1641 + * Release any allocated DMA irq's.
1642 + */
1643 + if (info->dma_in_enabled) {
1644 + cris_free_dma(info->dma_in_nbr, info->dma_in_irq_description);
1645 + free_irq(info->dma_in_irq_nbr,
1646 + info);
1647 + info->uses_dma_in = 0;
1648 +#ifdef SERIAL_DEBUG_OPEN
1649 + printk("DMA irq '%s' freed\n", info->dma_in_irq_description);
1650 +#endif
1651 + }
1652 + if (info->dma_out_enabled) {
1653 + free_irq(info->dma_out_irq_nbr,
1654 + info);
1655 + cris_free_dma(info->dma_out_nbr, info->dma_out_irq_description);
1656 + info->uses_dma_out = 0;
1657 +#ifdef SERIAL_DEBUG_OPEN
1658 + printk("DMA irq '%s' freed\n", info->dma_out_irq_description);
1659 +#endif
1660 + }
1661 }
1662
1663 /*
1664 @@ -4485,7 +4382,7 @@
1665 if (tty_hung_up_p(filp) ||
1666 (info->flags & ASYNC_CLOSING)) {
1667 if (info->flags & ASYNC_CLOSING)
1668 - interruptible_sleep_on(&info->close_wait);
1669 + wait_event_interruptible(info->close_wait, 0);
1670 #ifdef SERIAL_DO_RESTART
1671 if (info->flags & ASYNC_HUP_NOTIFY)
1672 return -EAGAIN;
1673 @@ -4523,21 +4420,19 @@
1674 printk("block_til_ready before block: ttyS%d, count = %d\n",
1675 info->line, info->count);
1676 #endif
1677 - save_flags(flags);
1678 - cli();
1679 + local_irq_save(flags);
1680 if (!tty_hung_up_p(filp)) {
1681 extra_count++;
1682 info->count--;
1683 }
1684 - restore_flags(flags);
1685 + local_irq_restore(flags);
1686 info->blocked_open++;
1687 while (1) {
1688 - save_flags(flags);
1689 - cli();
1690 + local_irq_save(flags);
1691 /* assert RTS and DTR */
1692 e100_rts(info, 1);
1693 e100_dtr(info, 1);
1694 - restore_flags(flags);
1695 + local_irq_restore(flags);
1696 set_current_state(TASK_INTERRUPTIBLE);
1697 if (tty_hung_up_p(filp) ||
1698 !(info->flags & ASYNC_INITIALIZED)) {
1699 @@ -4589,9 +4484,9 @@
1700 struct e100_serial *info;
1701 int retval, line;
1702 unsigned long page;
1703 + int allocated_resources = 0;
1704
1705 /* find which port we want to open */
1706 -
1707 line = tty->index;
1708
1709 if (line < 0 || line >= NR_PORTS)
1710 @@ -4632,7 +4527,7 @@
1711 if (tty_hung_up_p(filp) ||
1712 (info->flags & ASYNC_CLOSING)) {
1713 if (info->flags & ASYNC_CLOSING)
1714 - interruptible_sleep_on(&info->close_wait);
1715 + wait_event_interruptible(info->close_wait, 0);
1716 #ifdef SERIAL_DO_RESTART
1717 return ((info->flags & ASYNC_HUP_NOTIFY) ?
1718 -EAGAIN : -ERESTARTSYS);
1719 @@ -4642,12 +4537,79 @@
1720 }
1721
1722 /*
1723 + * If DMA is enabled try to allocate the irq's.
1724 + */
1725 + if (info->count == 1) {
1726 + allocated_resources = 1;
1727 + if (info->dma_in_enabled) {
1728 + if (request_irq(info->dma_in_irq_nbr,
1729 + rec_interrupt,
1730 + info->dma_in_irq_flags,
1731 + info->dma_in_irq_description,
1732 + info)) {
1733 + printk(KERN_WARNING "DMA irq '%s' busy; falling back to non-DMA mode\n", info->dma_in_irq_description);
1734 + /* Make sure we never try to use DMA in for the port again. */
1735 + info->dma_in_enabled = 0;
1736 + } else if (cris_request_dma(info->dma_in_nbr,
1737 + info->dma_in_irq_description,
1738 + DMA_VERBOSE_ON_ERROR,
1739 + info->dma_owner)) {
1740 + free_irq(info->dma_in_irq_nbr, info);
1741 + printk(KERN_WARNING "DMA '%s' busy; falling back to non-DMA mode\n", info->dma_in_irq_description);
1742 + /* Make sure we never try to use DMA in for the port again. */
1743 + info->dma_in_enabled = 0;
1744 + }
1745 +#ifdef SERIAL_DEBUG_OPEN
1746 + else printk("DMA irq '%s' allocated\n", info->dma_in_irq_description);
1747 +#endif
1748 + }
1749 + if (info->dma_out_enabled) {
1750 + if (request_irq(info->dma_out_irq_nbr,
1751 + tr_interrupt,
1752 + info->dma_out_irq_flags,
1753 + info->dma_out_irq_description,
1754 + info)) {
1755 + printk(KERN_WARNING "DMA irq '%s' busy; falling back to non-DMA mode\n", info->dma_out_irq_description);
1756 + /* Make sure we never try to use DMA out for the port again. */
1757 + info->dma_out_enabled = 0;
1758 + } else if (cris_request_dma(info->dma_out_nbr,
1759 + info->dma_out_irq_description,
1760 + DMA_VERBOSE_ON_ERROR,
1761 + info->dma_owner)) {
1762 + free_irq(info->dma_out_irq_nbr, info);
1763 + printk(KERN_WARNING "DMA '%s' busy; falling back to non-DMA mode\n", info->dma_out_irq_description);
1764 + /* Make sure we never try to use DMA in for the port again. */
1765 + info->dma_out_enabled = 0;
1766 + }
1767 +#ifdef SERIAL_DEBUG_OPEN
1768 + else printk("DMA irq '%s' allocated\n", info->dma_out_irq_description);
1769 +#endif
1770 + }
1771 + }
1772 +
1773 + /*
1774 * Start up the serial port
1775 */
1776
1777 retval = startup(info);
1778 - if (retval)
1779 - return retval;
1780 + if (retval) {
1781 + if (allocated_resources) {
1782 + if (info->dma_out_enabled) {
1783 + cris_free_dma(info->dma_out_nbr, info->dma_out_irq_description);
1784 + free_irq(info->dma_out_irq_nbr,
1785 + info);
1786 + }
1787 + if (info->dma_in_enabled) {
1788 + cris_free_dma(info->dma_in_nbr, info->dma_in_irq_description);
1789 + free_irq(info->dma_in_irq_nbr,
1790 + info);
1791 + }
1792 + }
1793 + /* FIXME Decrease count info->count here too? */
1794 + return retval;
1795 +
1796 + }
1797 +
1798
1799 retval = block_til_ready(tty, filp, info);
1800 if (retval) {
1801 @@ -4655,6 +4617,19 @@
1802 printk("rs_open returning after block_til_ready with %d\n",
1803 retval);
1804 #endif
1805 + if (allocated_resources) {
1806 + if (info->dma_out_enabled) {
1807 + cris_free_dma(info->dma_out_nbr, info->dma_out_irq_description);
1808 + free_irq(info->dma_out_irq_nbr,
1809 + info);
1810 + }
1811 + if (info->dma_in_enabled) {
1812 + cris_free_dma(info->dma_in_nbr, info->dma_in_irq_description);
1813 + free_irq(info->dma_in_irq_nbr,
1814 + info);
1815 + }
1816 + }
1817 +
1818 return retval;
1819 }
1820
1821 @@ -4844,6 +4819,7 @@
1822 .send_xchar = rs_send_xchar,
1823 .wait_until_sent = rs_wait_until_sent,
1824 .read_proc = rs_read_proc,
1825 + .tiocmset = rs_tiocmset
1826 };
1827
1828 static int __init
1829 @@ -4863,7 +4839,22 @@
1830 #if !defined(CONFIG_ETRAX_SERIAL_FAST_TIMER)
1831 init_timer(&flush_timer);
1832 flush_timer.function = timed_flush_handler;
1833 - mod_timer(&flush_timer, jiffies + CONFIG_ETRAX_SERIAL_RX_TIMEOUT_TICKS);
1834 + mod_timer(&flush_timer, jiffies + 5);
1835 +#endif
1836 +
1837 +#if defined(CONFIG_ETRAX_RS485)
1838 +#if defined(CONFIG_ETRAX_RS485_ON_PA)
1839 + if (cris_io_interface_allocate_pins(if_ser0, 'a', rs485_pa_bit, rs485_pa_bit)) {
1840 + printk(KERN_CRIT "ETRAX100LX serial: Could not allocate RS485 pin\n");
1841 + return -EBUSY;
1842 + }
1843 +#endif
1844 +#if defined(CONFIG_ETRAX_RS485_ON_PORT_G)
1845 + if (cris_io_interface_allocate_pins(if_ser0, 'g', rs485_pa_bit, rs485_port_g_bit)) {
1846 + printk(KERN_CRIT "ETRAX100LX serial: Could not allocate RS485 pin\n");
1847 + return -EBUSY;
1848 + }
1849 +#endif
1850 #endif
1851
1852 /* Initialize the tty_driver structure */
1853 @@ -4888,6 +4879,14 @@
1854 /* do some initializing for the separate ports */
1855
1856 for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
1857 + if (info->enabled) {
1858 + if (cris_request_io_interface(info->io_if, info->io_if_description)) {
1859 + printk(KERN_CRIT "ETRAX100LX async serial: Could not allocate IO pins for %s, port %d\n",
1860 + info->io_if_description,
1861 + i);
1862 + info->enabled = 0;
1863 + }
1864 + }
1865 info->uses_dma_in = 0;
1866 info->uses_dma_out = 0;
1867 info->line = i;
1868 @@ -4939,64 +4938,16 @@
1869 #endif
1870
1871 #ifndef CONFIG_SVINTO_SIM
1872 +#ifndef CONFIG_ETRAX_KGDB
1873 /* Not needed in simulator. May only complicate stuff. */
1874 /* hook the irq's for DMA channel 6 and 7, serial output and input, and some more... */
1875
1876 - if (request_irq(SERIAL_IRQ_NBR, ser_interrupt, IRQF_SHARED | IRQF_DISABLED, "serial ", NULL))
1877 - panic("irq8");
1878 -
1879 -#ifdef CONFIG_ETRAX_SERIAL_PORT0
1880 -#ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
1881 - if (request_irq(SER0_DMA_TX_IRQ_NBR, tr_interrupt, IRQF_DISABLED, "serial 0 dma tr", NULL))
1882 - panic("irq22");
1883 -#endif
1884 -#ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
1885 - if (request_irq(SER0_DMA_RX_IRQ_NBR, rec_interrupt, IRQF_DISABLED, "serial 0 dma rec", NULL))
1886 - panic("irq23");
1887 -#endif
1888 -#endif
1889 -
1890 -#ifdef CONFIG_ETRAX_SERIAL_PORT1
1891 -#ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA8_OUT
1892 - if (request_irq(SER1_DMA_TX_IRQ_NBR, tr_interrupt, IRQF_DISABLED, "serial 1 dma tr", NULL))
1893 - panic("irq24");
1894 -#endif
1895 -#ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA9_IN
1896 - if (request_irq(SER1_DMA_RX_IRQ_NBR, rec_interrupt, IRQF_DISABLED, "serial 1 dma rec", NULL))
1897 - panic("irq25");
1898 -#endif
1899 -#endif
1900 -#ifdef CONFIG_ETRAX_SERIAL_PORT2
1901 - /* DMA Shared with par0 (and SCSI0 and ATA) */
1902 -#ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
1903 - if (request_irq(SER2_DMA_TX_IRQ_NBR, tr_interrupt, IRQF_SHARED | IRQF_DISABLED, "serial 2 dma tr", NULL))
1904 - panic("irq18");
1905 -#endif
1906 -#ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
1907 - if (request_irq(SER2_DMA_RX_IRQ_NBR, rec_interrupt, IRQF_SHARED | IRQF_DISABLED, "serial 2 dma rec", NULL))
1908 - panic("irq19");
1909 -#endif
1910 -#endif
1911 -#ifdef CONFIG_ETRAX_SERIAL_PORT3
1912 - /* DMA Shared with par1 (and SCSI1 and Extern DMA 0) */
1913 -#ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA4_OUT
1914 - if (request_irq(SER3_DMA_TX_IRQ_NBR, tr_interrupt, IRQF_SHARED | IRQF_DISABLED, "serial 3 dma tr", NULL))
1915 - panic("irq20");
1916 -#endif
1917 -#ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA5_IN
1918 - if (request_irq(SER3_DMA_RX_IRQ_NBR, rec_interrupt, IRQF_SHARED | IRQF_DISABLED, "serial 3 dma rec", NULL))
1919 - panic("irq21");
1920 -#endif
1921 -#endif
1922 + if (request_irq(SERIAL_IRQ_NBR, ser_interrupt, IRQF_SHARED | IRQF_DISABLED, "serial ", driver))
1923 + panic("%s: Failed to request irq8", __FUNCTION__);
1924
1925 -#ifdef CONFIG_ETRAX_SERIAL_FLUSH_DMA_FAST
1926 - if (request_irq(TIMER1_IRQ_NBR, timeout_interrupt, IRQF_SHARED | IRQF_DISABLED,
1927 - "fast serial dma timeout", NULL)) {
1928 - printk(KERN_CRIT "err: timer1 irq\n");
1929 - }
1930 #endif
1931 #endif /* CONFIG_SVINTO_SIM */
1932 - debug_write_function = rs_debug_write_function;
1933 +
1934 return 0;
1935 }
1936
1937 --- linux-2.6.19.2.orig/drivers/serial/crisv10.h 2007-01-10 20:10:37.000000000 +0100
1938 +++ linux-2.6.19.2.dev/drivers/serial/crisv10.h 2006-10-13 14:44:38.000000000 +0200
1939 @@ -9,6 +9,8 @@
1940
1941 #include <linux/circ_buf.h>
1942 #include <asm/termios.h>
1943 +#include <asm/dma.h>
1944 +#include <asm/arch/io_interface_mux.h>
1945
1946 /* Software state per channel */
1947
1948 @@ -61,6 +63,19 @@
1949 u8 dma_in_enabled:1; /* Set to 1 if DMA should be used */
1950
1951 /* end of fields defined in rs_table[] in .c-file */
1952 + int dma_owner;
1953 + unsigned int dma_in_nbr;
1954 + unsigned int dma_out_nbr;
1955 + unsigned int dma_in_irq_nbr;
1956 + unsigned int dma_out_irq_nbr;
1957 + unsigned long dma_in_irq_flags;
1958 + unsigned long dma_out_irq_flags;
1959 + char *dma_in_irq_description;
1960 + char *dma_out_irq_description;
1961 +
1962 + enum cris_io_interface io_if;
1963 + char *io_if_description;
1964 +
1965 u8 uses_dma_in; /* Set to 1 if DMA is used */
1966 u8 uses_dma_out; /* Set to 1 if DMA is used */
1967 u8 forced_eop; /* a fifo eop has been forced */
1968 --- linux-2.6.19.2.orig/drivers/serial/crisv32.c 1970-01-01 01:00:00.000000000 +0100
1969 +++ linux-2.6.19.2.dev/drivers/serial/crisv32.c 2007-01-05 09:59:53.000000000 +0100
1970 @@ -0,0 +1,2333 @@
1971 +/* $Id: crisv32.c,v 1.78 2007/01/05 08:59:53 starvik Exp $
1972 + *
1973 + * Serial port driver for the ETRAX FS chip
1974 + *
1975 + * Copyright (C) 1998-2006 Axis Communications AB
1976 + *
1977 + * Many, many authors. Based once upon a time on serial.c for 16x50.
1978 + *
1979 + * Johan Adolfsson - port to ETRAX FS
1980 + * Mikael Starvik - port to serial_core framework
1981 + *
1982 + */
1983 +
1984 +#include <linux/module.h>
1985 +#include <linux/init.h>
1986 +#include <linux/console.h>
1987 +#include <linux/types.h>
1988 +#include <linux/errno.h>
1989 +#include <linux/serial_core.h>
1990 +
1991 +#include <asm/io.h>
1992 +#include <asm/irq.h>
1993 +#include <asm/system.h>
1994 +#include <asm/uaccess.h>
1995 +
1996 +#include <asm/arch/dma.h>
1997 +#include <asm/arch/system.h>
1998 +#include <asm/arch/pinmux.h>
1999 +#include <asm/arch/hwregs/dma.h>
2000 +#include <asm/arch/hwregs/reg_rdwr.h>
2001 +#include <asm/arch/hwregs/ser_defs.h>
2002 +#include <asm/arch/hwregs/dma_defs.h>
2003 +#include <asm/arch/hwregs/gio_defs.h>
2004 +#include <asm/arch/hwregs/intr_vect_defs.h>
2005 +#include <asm/arch/hwregs/reg_map.h>
2006 +
2007 +#define UART_NR 5 /* 4 ports + dummy port */
2008 +#define SERIAL_RECV_DESCRIPTORS 8
2009 +
2010 +/* We only buffer 255 characters here, no need for more tx descriptors. */
2011 +#define SERIAL_TX_DESCRIPTORS 4
2012 +
2013 +/* Kept for experimental purposes. */
2014 +#define ETRAX_SER_FIFO_SIZE 1
2015 +#define SERIAL_DESCR_BUF_SIZE 256
2016 +#define regi_NULL 0
2017 +#define DMA_WAIT_UNTIL_RESET(inst) \
2018 + do { \
2019 + reg_dma_rw_stat r; \
2020 + do { \
2021 + r = REG_RD(dma, (inst), rw_stat); \
2022 + } while (r.mode != regk_dma_rst); \
2023 + } while (0)
2024 +
2025 +/* Macro to set up control lines for a port. */
2026 +#define SETUP_PINS(port) \
2027 + if (serial_cris_ports[port].used) { \
2028 + if (strcmp(CONFIG_ETRAX_SER##port##_DTR_BIT, "")) \
2029 + crisv32_io_get_name(&serial_cris_ports[port].dtr_pin, \
2030 + CONFIG_ETRAX_SER##port##_DTR_BIT); \
2031 + else \
2032 + serial_cris_ports[port].dtr_pin = dummy_pin; \
2033 + if (strcmp(CONFIG_ETRAX_SER##port##_DSR_BIT, "")) \
2034 + crisv32_io_get_name(&serial_cris_ports[port].dsr_pin, \
2035 + CONFIG_ETRAX_SER##port##_DSR_BIT); \
2036 + else \
2037 + serial_cris_ports[port].dsr_pin = dummy_pin; \
2038 + if (strcmp(CONFIG_ETRAX_SER##port##_RI_BIT, "")) \
2039 + crisv32_io_get_name(&serial_cris_ports[port].ri_pin, \
2040 + CONFIG_ETRAX_SER##port##_RI_BIT); \
2041 + else \
2042 + serial_cris_ports[port].ri_pin = dummy_pin; \
2043 + if (strcmp(CONFIG_ETRAX_SER##port##_CD_BIT, "")) \
2044 + crisv32_io_get_name(&serial_cris_ports[port].cd_pin, \
2045 + CONFIG_ETRAX_SER##port##_CD_BIT); \
2046 + else \
2047 + serial_cris_ports[port].cd_pin = dummy_pin; \
2048 + }
2049 +
2050 +/* Set a serial port register if anything has changed. */
2051 +#define MODIFY_REG(instance, reg, var) \
2052 + if (REG_RD_INT(ser, instance, reg) \
2053 + != REG_TYPE_CONV(int, reg_ser_##reg, var)) \
2054 + REG_WR(ser, instance, reg, var);
2055 +
2056 +/*
2057 + * Regarding RS485 operation in crisv32 serial driver.
2058 + * ---------------------------------------------------
2059 + * RS485 can be run in two modes, full duplex using four wires (485FD) and
2060 + * half duplex using two wires (485HD). The default mode of each serial port
2061 + * is configured in the kernel configuration. The available modes are:
2062 + * RS-232, RS-485 half duplex, and RS-485 full duplex.
2063 + *
2064 + * In the 485HD mode the direction of the data bus must be able to switch.
2065 + * The direction of the transceiver is controlled by the RTS signal. Hence
2066 + * the auto_rts function in the ETRAX FS chip is enabled in this mode, which
2067 + * automatically toggle RTS when transmitting. The initial direction of the
2068 + * port is receiving.
2069 + *
2070 + * In the 485FD mode two transceivers will be used, one in each direction.
2071 + * Usually the hardware can handle both 485HD and 485FD, which implies that
2072 + * one of the transceivers can change direction. Consequently that transceiver
2073 + * must be tied to operate in the opposite direction of the other one, setting
2074 + * and keeping RTS to a fixed value do this.
2075 + *
2076 + * There are two special "ioctl" that can configure the ports. These two are
2077 + * left for backward compatible with older applications. The effects of using
2078 + * them are described below:
2079 + * The TIOCSERSETRS485:
2080 + * This ioctl sets a serial port in 232 mode to 485HD mode or vise versa. The
2081 + * state of the port is kept when closing the port. Note that this ioctl has no
2082 + * effect on a serial port in the 485FD mode.
2083 + * The TIOCSERWRRS485:
2084 + * This ioctl set a serial port in 232 mode to 485HD mode and writes the data
2085 + * "included" in the ioctl to the port. The port will then stay in 485HD mode.
2086 + * Using this ioctl on a serial port in the 485HD mode will transmit the data
2087 + * without changing the mode. Using this ioctl on a serial port in 485FD mode
2088 + * will not change the mode and simply send the data using the 485FD mode.
2089 + */
2090 +
2091 +#define TYPE_232 0
2092 +#define TYPE_485HD 1
2093 +#define TYPE_485FD 2
2094 +
2095 +struct etrax_recv_buffer {
2096 + struct etrax_recv_buffer *next;
2097 + unsigned short length;
2098 + unsigned char error;
2099 + unsigned char pad;
2100 +
2101 + unsigned char buffer[0];
2102 +};
2103 +
2104 +struct uart_cris_port {
2105 + struct uart_port port;
2106 +
2107 + int initialized;
2108 + int used;
2109 + int irq;
2110 +
2111 + /* Used to check if port enabled as well by testing for zero. */
2112 + reg_scope_instances regi_ser;
2113 + reg_scope_instances regi_dmain;
2114 + reg_scope_instances regi_dmaout;
2115 +
2116 + struct crisv32_iopin dtr_pin;
2117 + struct crisv32_iopin dsr_pin;
2118 + struct crisv32_iopin ri_pin;
2119 + struct crisv32_iopin cd_pin;
2120 +
2121 + struct dma_descr_context tr_context_descr
2122 + __attribute__ ((__aligned__(32)));
2123 + struct dma_descr_data tr_descr[SERIAL_TX_DESCRIPTORS]
2124 + __attribute__ ((__aligned__(32)));
2125 + struct dma_descr_context rec_context_descr
2126 + __attribute__ ((__aligned__(32)));
2127 + struct dma_descr_data rec_descr[SERIAL_RECV_DESCRIPTORS]
2128 + __attribute__ ((__aligned__(32)));
2129 +
2130 + /* This is the first one in the list the HW is working on now. */
2131 + struct dma_descr_data* first_tx_descr;
2132 +
2133 + /* This is the last one in the list the HW is working on now. */
2134 + struct dma_descr_data* last_tx_descr;
2135 +
2136 + /* This is how many characters the HW is working on now. */
2137 + unsigned int tx_pending_chars;
2138 +
2139 + int tx_started;
2140 + unsigned int cur_rec_descr;
2141 + struct etrax_recv_buffer *first_recv_buffer;
2142 + struct etrax_recv_buffer *last_recv_buffer;
2143 +
2144 + unsigned int recv_cnt;
2145 + unsigned int max_recv_cnt;
2146 +
2147 + /* The time for 1 char, in usecs. */
2148 + unsigned long char_time_usec;
2149 +
2150 + /* Last tx usec in the jiffies. */
2151 + unsigned long last_tx_active_usec;
2152 +
2153 + /* Last tx time in jiffies. */
2154 + unsigned long last_tx_active;
2155 +
2156 + /* Last rx usec in the jiffies. */
2157 + unsigned long last_rx_active_usec;
2158 +
2159 + /* Last rx time in jiffies. */
2160 + unsigned long last_rx_active;
2161 +
2162 +#ifdef CONFIG_ETRAX_RS485
2163 + /* RS-485 support, duh. */
2164 + struct rs485_control rs485;
2165 +#endif
2166 + int port_type;
2167 +};
2168 +
2169 +extern struct uart_driver serial_cris_driver;
2170 +static struct uart_port *console_port;
2171 +static int console_baud = 115200;
2172 +static struct uart_cris_port serial_cris_ports[UART_NR] = {
2173 +{
2174 +#ifdef CONFIG_ETRAX_SERIAL_PORT0
2175 + .used = 1,
2176 + .irq = SER0_INTR_VECT,
2177 + .regi_ser = regi_ser0,
2178 + /*
2179 + * We initialize the dma stuff like this to get a compiler error
2180 + * if a CONFIG is missing
2181 + */
2182 + .regi_dmain =
2183 +# ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
2184 + regi_dma7,
2185 +# endif
2186 +# ifdef CONFIG_ETRAX_SERIAL_PORT0_NO_DMA_IN
2187 + regi_NULL,
2188 +# endif
2189 +
2190 + .regi_dmaout =
2191 +# ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
2192 + regi_dma6,
2193 +# endif
2194 +# ifdef CONFIG_ETRAX_SERIAL_PORT0_NO_DMA_OUT
2195 + regi_NULL,
2196 +# endif
2197 +
2198 +# ifdef CONFIG_ETRAX_RS485
2199 +# ifdef CONFIG_ETRAX_SERIAL_PORT0_TYPE_485HD
2200 + .port_type = TYPE_485HD,
2201 +# endif
2202 +# ifdef CONFIG_ETRAX_SERIAL_PORT0_TYPE_485FD
2203 + .port_type = TYPE_485FD,
2204 +# endif
2205 +# endif
2206 +#else
2207 + .regi_ser = regi_NULL,
2208 + .regi_dmain = regi_NULL,
2209 + .regi_dmaout = regi_NULL,
2210 +#endif
2211 +}, /* ttyS0 */
2212 +{
2213 +#ifdef CONFIG_ETRAX_SERIAL_PORT1
2214 + .used = 1,
2215 + .irq = SER1_INTR_VECT,
2216 + .regi_ser = regi_ser1,
2217 + .regi_dmain =
2218 +# ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA5_IN
2219 + regi_dma5,
2220 +# endif
2221 +# ifdef CONFIG_ETRAX_SERIAL_PORT1_NO_DMA_IN
2222 + regi_NULL,
2223 +# endif
2224 +
2225 + .regi_dmaout =
2226 +# ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA4_OUT
2227 + regi_dma4,
2228 +# endif
2229 +# ifdef CONFIG_ETRAX_SERIAL_PORT1_NO_DMA_OUT
2230 + regi_NULL,
2231 +# endif
2232 +
2233 +# ifdef CONFIG_ETRAX_RS485
2234 +# ifdef CONFIG_ETRAX_SERIAL_PORT1_TYPE_485HD
2235 + .port_type = TYPE_485HD,
2236 +# endif
2237 +# ifdef CONFIG_ETRAX_SERIAL_PORT1_TYPE_485FD
2238 + .port_type = TYPE_485FD,
2239 +# endif
2240 +# endif
2241 +#else
2242 + .regi_ser = regi_NULL,
2243 + .regi_dmain = regi_NULL,
2244 + .regi_dmaout = regi_NULL,
2245 +#endif
2246 +}, /* ttyS1 */
2247 +{
2248 +#ifdef CONFIG_ETRAX_SERIAL_PORT2
2249 + .used = 1,
2250 + .irq = SER2_INTR_VECT,
2251 + .regi_ser = regi_ser2,
2252 + .regi_dmain =
2253 +# ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
2254 + regi_dma3,
2255 +# endif
2256 +# ifdef CONFIG_ETRAX_SERIAL_PORT2_NO_DMA_IN
2257 + regi_NULL,
2258 +# endif
2259 +
2260 + .regi_dmaout =
2261 +# ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
2262 + regi_dma2,
2263 +# endif
2264 +# ifdef CONFIG_ETRAX_SERIAL_PORT2_NO_DMA_OUT
2265 + regi_NULL,
2266 +# endif
2267 +
2268 +# ifdef CONFIG_ETRAX_RS485
2269 +# ifdef CONFIG_ETRAX_SERIAL_PORT2_TYPE_485HD
2270 + .port_type = TYPE_485HD,
2271 +# endif
2272 +# ifdef CONFIG_ETRAX_SERIAL_PORT2_TYPE_485FD
2273 + .port_type = TYPE_485FD,
2274 +# endif
2275 +# endif
2276 +#else
2277 + .regi_ser = regi_NULL,
2278 + .regi_dmain = regi_NULL,
2279 + .regi_dmaout = regi_NULL,
2280 +#endif
2281 +}, /* ttyS2 */
2282 +{
2283 +#ifdef CONFIG_ETRAX_SERIAL_PORT3
2284 + .used = 1,
2285 + .irq = SER3_INTR_VECT,
2286 + .regi_ser = regi_ser3,
2287 + .regi_dmain =
2288 +# ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA9_IN
2289 + regi_dma9,
2290 +# endif
2291 +# ifdef CONFIG_ETRAX_SERIAL_PORT3_NO_DMA_IN
2292 + regi_NULL,
2293 +# endif
2294 +
2295 + .regi_dmaout =
2296 +# ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA8_OUT
2297 + regi_dma8,
2298 +# endif
2299 +# ifdef CONFIG_ETRAX_SERIAL_PORT3_NO_DMA_OUT
2300 + regi_NULL,
2301 +# endif
2302 +
2303 +# ifdef CONFIG_ETRAX_RS485
2304 +# ifdef CONFIG_ETRAX_SERIAL_PORT3_TYPE_485HD
2305 + .port_type = TYPE_485HD,
2306 +# endif
2307 +# ifdef CONFIG_ETRAX_SERIAL_PORT3_TYPE_485FD
2308 + .port_type = TYPE_485FD,
2309 +# endif
2310 +# endif
2311 +#else
2312 + .regi_ser = regi_NULL,
2313 + .regi_dmain = regi_NULL,
2314 + .regi_dmaout = regi_NULL,
2315 +#endif
2316 +}, /* ttyS3 */
2317 +{
2318 +#ifdef CONFIG_ETRAX_DEBUG_PORT_NULL
2319 + .used = 1,
2320 +#endif
2321 + .regi_ser = regi_NULL
2322 +} /* Dummy console port */
2323 +
2324 +};
2325 +
2326 +/* Dummy pin used for unused CD, DSR, DTR and RI signals. */
2327 +static unsigned long io_dummy;
2328 +static struct crisv32_ioport dummy_port =
2329 +{
2330 + &io_dummy,
2331 + &io_dummy,
2332 + &io_dummy,
2333 + 18
2334 +};
2335 +static struct crisv32_iopin dummy_pin =
2336 +{
2337 + &dummy_port,
2338 + 0
2339 +};
2340 +
2341 +static int selected_console =
2342 +#if defined(CONFIG_ETRAX_DEBUG_PORT0)
2343 +0;
2344 +#elif defined(CONFIG_ETRAX_DEBUG_PORT1)
2345 +1;
2346 +#elif defined(CONFIG_ETRAX_DEBUG_PORT2)
2347 +2;
2348 +#elif defined(CONFIG_ETRAX_DEBUG_PORT3)
2349 +3;
2350 +#else /* CONFIG_ETRAX_DEBUG_PORT_NULL */
2351 +4;
2352 +#endif
2353 +
2354 +extern void reset_watchdog(void);
2355 +
2356 +/*
2357 + * Interrupts are disabled on entering
2358 + */
2359 +static void
2360 +cris_console_write(struct console *co, const char *s, unsigned int count)
2361 +{
2362 + struct uart_cris_port *up;
2363 + int i;
2364 + reg_ser_r_stat_din stat;
2365 + reg_ser_rw_tr_dma_en tr_dma_en, old;
2366 +
2367 + up = &serial_cris_ports[selected_console];
2368 +
2369 + /*
2370 + * This function isn't covered by the struct uart_ops, so we
2371 + * have to check manually that the port really is there,
2372 + * configured and live.
2373 + */
2374 + if (!up->regi_ser)
2375 + return;
2376 +
2377 + /* Switch to manual mode. */
2378 + tr_dma_en = old = REG_RD (ser, up->regi_ser, rw_tr_dma_en);
2379 + if (tr_dma_en.en == regk_ser_yes) {
2380 + tr_dma_en.en = regk_ser_no;
2381 + REG_WR(ser, up->regi_ser, rw_tr_dma_en, tr_dma_en);
2382 + }
2383 +
2384 + /* Send data. */
2385 + for (i = 0; i < count; i++) {
2386 + /* LF -> CRLF */
2387 + if (s[i] == '\n') {
2388 + do {
2389 + stat = REG_RD (ser, up->regi_ser, r_stat_din);
2390 + } while (!stat.tr_rdy);
2391 + REG_WR_INT (ser, up->regi_ser, rw_dout, '\r');
2392 + }
2393 + /* Wait until transmitter is ready and send. */
2394 + do {
2395 + stat = REG_RD (ser, up->regi_ser, r_stat_din);
2396 + } while (!stat.tr_rdy);
2397 + REG_WR_INT (ser, up->regi_ser, rw_dout, s[i]);
2398 +
2399 + /* Feed watchdog, because this may take looong time. */
2400 + reset_watchdog();
2401 + }
2402 +
2403 + /* Restore mode. */
2404 + if (tr_dma_en.en != old.en)
2405 + REG_WR(ser, up->regi_ser, rw_tr_dma_en, old);
2406 +}
2407 +
2408 +static void cris_serial_port_init(struct uart_port *port, int line);
2409 +static int __init
2410 +cris_console_setup(struct console *co, char *options)
2411 +{
2412 + struct uart_port *port;
2413 + int baud = 115200;
2414 + int bits = 8;
2415 + int parity = 'n';
2416 + int flow = 'n';
2417 +
2418 + if (co->index >= UART_NR)
2419 + co->index = 0;
2420 + if (options)
2421 + selected_console = co->index;
2422 + port = &serial_cris_ports[selected_console].port;
2423 + console_port = port;
2424 +
2425 + if (options)
2426 + uart_parse_options(options, &baud, &parity, &bits, &flow);
2427 + console_baud = baud;
2428 + cris_serial_port_init(port, selected_console);
2429 + co->index = port->line;
2430 + uart_set_options(port, co, baud, parity, bits, flow);
2431 +
2432 + return 0;
2433 +}
2434 +
2435 +static struct tty_driver*
2436 +cris_console_device(struct console* co, int *index)
2437 +{
2438 + struct uart_driver *p = co->data;
2439 + *index = selected_console;
2440 + return p->tty_driver;
2441 +}
2442 +
2443 +static struct console cris_console = {
2444 + .name = "ttyS",
2445 + .write = cris_console_write,
2446 + .device = cris_console_device,
2447 + .setup = cris_console_setup,
2448 + .flags = CON_PRINTBUFFER,
2449 + .index = -1,
2450 + .data = &serial_cris_driver,
2451 +};
2452 +
2453 +#define SERIAL_CRIS_CONSOLE &cris_console
2454 +
2455 +struct uart_driver serial_cris_driver = {
2456 + .owner = THIS_MODULE,
2457 + .driver_name = "serial",
2458 + .dev_name = "ttyS",
2459 + .major = TTY_MAJOR,
2460 + .minor = 64,
2461 + .nr = UART_NR,
2462 + .cons = SERIAL_CRIS_CONSOLE,
2463 +};
2464 +
2465 +static int inline crisv32_serial_get_rts(struct uart_cris_port *up)
2466 +{
2467 + reg_scope_instances regi_ser = up->regi_ser;
2468 + /*
2469 + * Return what the user has controlled rts to or
2470 + * what the pin is? (if auto_rts is used it differs during tx)
2471 + */
2472 + reg_ser_r_stat_din rstat = REG_RD(ser, regi_ser, r_stat_din);
2473 + return !(rstat.rts_n == regk_ser_active);
2474 +}
2475 +
2476 +/*
2477 + * A set = 0 means 3.3V on the pin, bitvalue: 0=active, 1=inactive
2478 + * 0=0V , 1=3.3V
2479 + */
2480 +static inline void crisv32_serial_set_rts(struct uart_cris_port *up, int set)
2481 +{
2482 + reg_scope_instances regi_ser = up->regi_ser;
2483 +
2484 +#ifdef CONFIG_ETRAX_RS485
2485 + /* Never toggle RTS if port is in 485 mode. If port is in 485FD mode we
2486 + * do not want to send with the reciever and for 485HD mode auto_rts
2487 + * take care of the RTS for us.
2488 + */
2489 + if (!up->rs485.enabled) {
2490 +#else
2491 + {
2492 +#endif
2493 + unsigned long flags;
2494 + reg_ser_rw_rec_ctrl rec_ctrl;
2495 +
2496 + local_irq_save(flags);
2497 + rec_ctrl = REG_RD(ser, regi_ser, rw_rec_ctrl);
2498 + if (set)
2499 + rec_ctrl.rts_n = regk_ser_active;
2500 + else
2501 + rec_ctrl.rts_n = regk_ser_inactive;
2502 + REG_WR(ser, regi_ser, rw_rec_ctrl, rec_ctrl);
2503 + local_irq_restore(flags);
2504 + }
2505 +}
2506 +
2507 +/* Input */
2508 +static int inline crisv32_serial_get_cts(struct uart_cris_port *up)
2509 +{
2510 + reg_scope_instances regi_ser = up->regi_ser;
2511 + reg_ser_r_stat_din rstat = REG_RD(ser, regi_ser, r_stat_din);
2512 + return (rstat.cts_n == regk_ser_active);
2513 +}
2514 +
2515 +/*
2516 + * Send a single character for XON/XOFF purposes. We do it in this separate
2517 + * function instead of the alternative support port.x_char, in the ...start_tx
2518 + * function, so we don't mix up this case with possibly enabling transmission
2519 + * of queued-up data (in case that's disabled after *receiving* an XOFF or
2520 + * negative CTS). This function is used for both DMA and non-DMA case; see HW
2521 + * docs specifically blessing sending characters manually when DMA for
2522 + * transmission is enabled and running. We may be asked to transmit despite
2523 + * the transmitter being disabled by a ..._stop_tx call so we need to enable
2524 + * it temporarily but restore the state afterwards.
2525 + *
2526 + * Beware: I'm not sure how the RS-485 stuff is supposed to work. Using
2527 + * XON/XOFF seems problematic if there are several controllers, but if it's
2528 + * actually RS-422 (multi-drop; one sender and multiple receivers), it might
2529 + * Just Work, so don't bail out just because it looks a little suspicious.
2530 + */
2531 +
2532 +void serial_cris_send_xchar(struct uart_port *port, char ch)
2533 +{
2534 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2535 + reg_ser_rw_dout dout = { .data = ch };
2536 + reg_ser_rw_ack_intr ack_intr = { .tr_rdy = regk_ser_yes };
2537 + reg_ser_r_stat_din rstat;
2538 + reg_ser_rw_tr_ctrl prev_tr_ctrl, tr_ctrl;
2539 + reg_scope_instances regi_ser = up->regi_ser;
2540 + unsigned long flags;
2541 +
2542 + /*
2543 + * Wait for tr_rdy in case a character is already being output. Make
2544 + * sure we have integrity between the register reads and the writes
2545 + * below, but don't busy-wait with interrupts off and the port lock
2546 + * taken.
2547 + */
2548 + spin_lock_irqsave(&port->lock, flags);
2549 + do {
2550 + spin_unlock_irqrestore(&port->lock, flags);
2551 + spin_lock_irqsave(&port->lock, flags);
2552 + prev_tr_ctrl = tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
2553 + rstat = REG_RD(ser, regi_ser, r_stat_din);
2554 + } while (!rstat.tr_rdy);
2555 +
2556 + /*
2557 + * Ack an interrupt if one was just issued for the previous character
2558 + * that was output. This is required for non-DMA as the interrupt is
2559 + * used as the only indicator that the transmitter is ready and it
2560 + * isn't while this x_char is being transmitted.
2561 + */
2562 + REG_WR(ser, regi_ser, rw_ack_intr, ack_intr);
2563 +
2564 + /* Enable the transmitter in case it was disabled. */
2565 + tr_ctrl.stop = 0;
2566 + REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
2567 +
2568 + /*
2569 + * Finally, send the blessed character; nothing should stop it now,
2570 + * except for an xoff-detected state, which we'll handle below.
2571 + */
2572 + REG_WR(ser, regi_ser, rw_dout, dout);
2573 + up->port.icount.tx++;
2574 +
2575 + /* There might be an xoff state to clear. */
2576 + rstat = REG_RD(ser, up->regi_ser, r_stat_din);
2577 +
2578 + /*
2579 + * Clear any xoff state that *may* have been there to
2580 + * inhibit transmission of the character.
2581 + */
2582 + if (rstat.xoff_detect) {
2583 + reg_ser_rw_xoff_clr xoff_clr = { .clr = 1 };
2584 + REG_WR(ser, regi_ser, rw_xoff_clr, xoff_clr);
2585 + reg_ser_rw_tr_dma_en tr_dma_en
2586 + = REG_RD(ser, regi_ser, rw_tr_dma_en);
2587 +
2588 + /*
2589 + * If we had an xoff state but cleared it, instead sneak in a
2590 + * disabled state for the transmitter, after the character we
2591 + * sent. Thus we keep the port disabled, just as if the xoff
2592 + * state was still in effect (or actually, as if stop_tx had
2593 + * been called, as we stop DMA too).
2594 + */
2595 + prev_tr_ctrl.stop = 1;
2596 +
2597 + tr_dma_en.en = 0;
2598 + REG_WR(ser, regi_ser, rw_tr_dma_en, tr_dma_en);
2599 + }
2600 +
2601 + /* Restore "previous" enabled/disabled state of the transmitter. */
2602 + REG_WR(ser, regi_ser, rw_tr_ctrl, prev_tr_ctrl);
2603 +
2604 + spin_unlock_irqrestore(&port->lock, flags);
2605 +}
2606 +
2607 +static void transmit_chars_dma(struct uart_cris_port *up);
2608 +
2609 +/*
2610 + * Do not spin_lock_irqsave or disable interrupts by other means here; it's
2611 + * already done by the caller.
2612 + */
2613 +
2614 +static void serial_cris_start_tx(struct uart_port *port)
2615 +{
2616 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2617 + reg_scope_instances regi_ser = up->regi_ser;
2618 + reg_ser_rw_tr_ctrl tr_ctrl;
2619 +
2620 + tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
2621 + tr_ctrl.stop = regk_ser_no;
2622 + REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
2623 + if (!up->regi_dmaout) {
2624 + reg_ser_rw_intr_mask intr_mask =
2625 + REG_RD(ser, regi_ser, rw_intr_mask);
2626 + intr_mask.tr_rdy = regk_ser_yes;
2627 + REG_WR(ser, regi_ser, rw_intr_mask, intr_mask);
2628 + } else {
2629 + /*
2630 + * We're called possibly to re-enable transmission after it
2631 + * has been disabled. If so, DMA needs to be re-enabled.
2632 + */
2633 + reg_ser_rw_tr_dma_en tr_dma_en = { .en = 1 };
2634 + REG_WR(ser, regi_ser, rw_tr_dma_en, tr_dma_en);
2635 + transmit_chars_dma(up);
2636 + }
2637 +}
2638 +
2639 +/*
2640 + * This function handles both the DMA and non-DMA case by ordering the
2641 + * transmitter to stop of after the current character. We don't need to wait
2642 + * for any such character to be completely transmitted; we do that where it
2643 + * matters, like in serial_cris_set_termios. Don't busy-wait here; see
2644 + * Documentation/serial/driver: this function is called within
2645 + * spin_lock_irq{,save} and thus separate ones would be disastrous (when SMP).
2646 + * There's no documented need to set the txd pin to any particular value;
2647 + * break setting is controlled solely by serial_cris_break_ctl.
2648 + */
2649 +
2650 +static void serial_cris_stop_tx(struct uart_port *port)
2651 +{
2652 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2653 + reg_scope_instances regi_ser = up->regi_ser;
2654 + reg_ser_rw_tr_ctrl tr_ctrl;
2655 + reg_ser_rw_intr_mask intr_mask;
2656 + reg_ser_rw_tr_dma_en tr_dma_en = {0};
2657 + reg_ser_rw_xoff_clr xoff_clr = {0};
2658 +
2659 + /*
2660 + * For the non-DMA case, we'd get a tr_rdy interrupt that we're not
2661 + * interested in as we're not transmitting any characters. For the
2662 + * DMA case, that interrupt is already turned off, but no reason to
2663 + * waste code on conditionals here.
2664 + */
2665 + intr_mask = REG_RD(ser, regi_ser, rw_intr_mask);
2666 + intr_mask.tr_rdy = regk_ser_no;
2667 + REG_WR(ser, regi_ser, rw_intr_mask, intr_mask);
2668 +
2669 + tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
2670 + tr_ctrl.stop = 1;
2671 + REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
2672 +
2673 + /*
2674 + * Always clear possible hardware xoff-detected state here, no need to
2675 + * unnecessary consider mctrl settings and when they change. We clear
2676 + * it here rather than in start_tx: both functions are called as the
2677 + * effect of XOFF processing, but start_tx is also called when upper
2678 + * levels tell the driver that there are more characters to send, so
2679 + * avoid adding code there.
2680 + */
2681 + xoff_clr.clr = 1;
2682 + REG_WR(ser, regi_ser, rw_xoff_clr, xoff_clr);
2683 +
2684 + /*
2685 + * Disable transmitter DMA, so that if we're in XON/XOFF, we can send
2686 + * those single characters without also giving go-ahead for queued up
2687 + * DMA data.
2688 + */
2689 + tr_dma_en.en = 0;
2690 + REG_WR(ser, regi_ser, rw_tr_dma_en, tr_dma_en);
2691 +}
2692 +
2693 +static void serial_cris_stop_rx(struct uart_port *port)
2694 +{
2695 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2696 + reg_scope_instances regi_ser = up->regi_ser;
2697 + reg_ser_rw_rec_ctrl rec_ctrl = REG_RD(ser, regi_ser, rw_rec_ctrl);
2698 +
2699 + rec_ctrl.en = regk_ser_no;
2700 + REG_WR(ser, regi_ser, rw_rec_ctrl, rec_ctrl);
2701 +}
2702 +
2703 +static void serial_cris_enable_ms(struct uart_port *port)
2704 +{
2705 +}
2706 +
2707 +static void check_modem_status(struct uart_cris_port *up)
2708 +{
2709 +}
2710 +
2711 +static unsigned int serial_cris_tx_empty(struct uart_port *port)
2712 +{
2713 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2714 + unsigned long flags;
2715 + unsigned int ret;
2716 + reg_ser_r_stat_din rstat = {0};
2717 +
2718 + spin_lock_irqsave(&up->port.lock, flags);
2719 + if (up->regi_dmaout) {
2720 + /*
2721 + * For DMA, before looking at r_stat, we need to check that we
2722 + * either haven't actually started or that end-of-list is
2723 + * reached, else a tr_empty indication is just an internal
2724 + * state. The caller qualifies, if needed, that the
2725 + * port->info.xmit buffer is empty, so we don't need to
2726 + * check that.
2727 + */
2728 + reg_dma_rw_stat status = REG_RD(dma, up->regi_dmaout, rw_stat);
2729 +
2730 + if (!up->tx_started) {
2731 + ret = 1;
2732 + goto done;
2733 + }
2734 +
2735 + if (status.list_state != regk_dma_data_at_eol) {
2736 + ret = 0;
2737 + goto done;
2738 + }
2739 + }
2740 +
2741 + rstat = REG_RD(ser, up->regi_ser, r_stat_din);
2742 + ret = rstat.tr_empty ? TIOCSER_TEMT : 0;
2743 +
2744 + done:
2745 + spin_unlock_irqrestore(&up->port.lock, flags);
2746 + return ret;
2747 +}
2748 +static unsigned int serial_cris_get_mctrl(struct uart_port *port)
2749 +{
2750 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2751 + unsigned int ret;
2752 +
2753 + ret = 0;
2754 + if (crisv32_serial_get_rts(up))
2755 + ret |= TIOCM_RTS;
2756 + if (crisv32_io_rd(&up->dtr_pin))
2757 + ret |= TIOCM_DTR;
2758 + if (crisv32_io_rd(&up->cd_pin))
2759 + ret |= TIOCM_CD;
2760 + if (crisv32_io_rd(&up->ri_pin))
2761 + ret |= TIOCM_RI;
2762 + if (!crisv32_io_rd(&up->dsr_pin))
2763 + ret |= TIOCM_DSR;
2764 + if (crisv32_serial_get_cts(up))
2765 + ret |= TIOCM_CTS;
2766 + return ret;
2767 +}
2768 +
2769 +static void serial_cris_set_mctrl(struct uart_port *port, unsigned int mctrl)
2770 +{
2771 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2772 +
2773 + crisv32_serial_set_rts(up, mctrl & TIOCM_RTS ? 1 : 0);
2774 + crisv32_io_set(&up->dtr_pin, mctrl & TIOCM_DTR ? 1 : 0);
2775 + crisv32_io_set(&up->ri_pin, mctrl & TIOCM_RNG ? 1 : 0);
2776 + crisv32_io_set(&up->cd_pin, mctrl & TIOCM_CD ? 1 : 0);
2777 +}
2778 +
2779 +static void serial_cris_break_ctl(struct uart_port *port, int break_state)
2780 +{
2781 + struct uart_cris_port *up = (struct uart_cris_port *)port;
2782 + unsigned long flags;
2783 + reg_ser_rw_tr_ctrl tr_ctrl;
2784 + reg_ser_rw_tr_dma_en tr_dma_en;
2785 + reg_ser_rw_intr_mask intr_mask;
2786 +
2787 + spin_lock_irqsave(&up->port.lock, flags);
2788 + tr_ctrl = REG_RD(ser, up->regi_ser, rw_tr_ctrl);
2789 + tr_dma_en = REG_RD(ser, up->regi_ser, rw_tr_dma_en);
2790 + intr_mask = REG_RD(ser, up->regi_ser, rw_intr_mask);
2791 +
2792 + if (break_state != 0) { /* Send break */
2793 + /*
2794 + * We need to disable DMA (if used) or tr_rdy interrupts if no
2795 + * DMA. No need to make this conditional on use of DMA;
2796 + * disabling will be a no-op for the other mode.
2797 + */
2798 + intr_mask.tr_rdy = regk_ser_no;
2799 + tr_dma_en.en = 0;
2800 +
2801 + /*
2802 + * Stop transmission and set the txd pin to 0 after the
2803 + * current character. The txd setting will take effect after
2804 + * any current transmission has completed.
2805 + */
2806 + tr_ctrl.stop = 1;
2807 + tr_ctrl.txd = 0;
2808 + } else {
2809 + /* Re-enable either transmit DMA or the serial interrupt. */
2810 + if (up->regi_dmaout)
2811 + tr_dma_en.en = 1;
2812 + else
2813 + intr_mask.tr_rdy = regk_ser_yes;
2814 +
2815 +
2816 + tr_ctrl.stop = 0;
2817 + tr_ctrl.txd = 1;
2818 + }
2819 + REG_WR(ser, up->regi_ser, rw_tr_ctrl, tr_ctrl);
2820 + REG_WR(ser, up->regi_ser, rw_tr_dma_en, tr_dma_en);
2821 + REG_WR(ser, up->regi_ser, rw_intr_mask, intr_mask);
2822 +
2823 + spin_unlock_irqrestore(&up->port.lock, flags);
2824 +}
2825 +
2826 +/*
2827 + * The output DMA channel is free - use it to send as many chars as
2828 + * possible.
2829 + */
2830 +
2831 +static void
2832 +transmit_chars_dma(struct uart_cris_port *up)
2833 +{
2834 + struct dma_descr_data *descr, *pending_descr, *dmapos;
2835 + struct dma_descr_data *last_tx_descr;
2836 + struct circ_buf *xmit = &up->port.info->xmit;
2837 + unsigned int sentl = 0;
2838 + reg_dma_rw_ack_intr ack_intr = { .data = regk_dma_yes };
2839 + reg_dma_rw_stat status;
2840 + reg_scope_instances regi_dmaout = up->regi_dmaout;
2841 + unsigned int chars_in_q;
2842 + unsigned int chars_to_send;
2843 +
2844 + /* Acknowledge dma data descriptor irq, if there was one. */
2845 + REG_WR(dma, regi_dmaout, rw_ack_intr, ack_intr);
2846 +
2847 + /*
2848 + * First get the amount of bytes sent during the last DMA transfer,
2849 + * and update xmit accordingly.
2850 + */
2851 + status = REG_RD(dma, regi_dmaout, rw_stat);
2852 + if (status.list_state == regk_dma_data_at_eol || !up->tx_started)
2853 + dmapos = phys_to_virt((int)up->last_tx_descr->next);
2854 + else
2855 + dmapos = phys_to_virt(REG_RD_INT(dma, regi_dmaout, rw_data));
2856 +
2857 + pending_descr = up->first_tx_descr;
2858 + while (pending_descr != dmapos) {
2859 + sentl += pending_descr->after - pending_descr->buf;
2860 + pending_descr->after = pending_descr->buf = NULL;
2861 + pending_descr = phys_to_virt((int)pending_descr->next);
2862 + }
2863 +
2864 + up->first_tx_descr = pending_descr;
2865 + last_tx_descr = up->last_tx_descr;
2866 +
2867 + /* Update stats. */
2868 + up->port.icount.tx += sentl;
2869 +
2870 + up->tx_pending_chars -= sentl;
2871 +
2872 + /* Update xmit buffer. */
2873 + xmit->tail = (xmit->tail + sentl) & (UART_XMIT_SIZE - 1);
2874 +
2875 + /*
2876 + * Find out the largest amount of consecutive bytes we want to send
2877 + * now.
2878 + */
2879 + chars_in_q = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
2880 +
2881 + if (chars_in_q == 0)
2882 + /* Tell upper layers that we're now idle. */
2883 + goto done;
2884 +
2885 + /* Some of those characters are actually pending output. */
2886 + chars_to_send = chars_in_q - up->tx_pending_chars;
2887 +
2888 + /*
2889 + * Clamp the new number of pending chars to the advertised
2890 + * one.
2891 + */
2892 + if (chars_to_send + up->tx_pending_chars > up->port.fifosize)
2893 + chars_to_send = up->port.fifosize - up->tx_pending_chars;
2894 +
2895 + /* If we don't want to send any, we're done. */
2896 + if (chars_to_send == 0)
2897 + goto done;
2898 +
2899 + descr = phys_to_virt((int)last_tx_descr->next);
2900 +
2901 + /*
2902 + * We can't send anything if we could make the condition in
2903 + * the while-loop above (reaping finished descriptors) be met
2904 + * immediately before the first iteration. However, don't
2905 + * mistake the full state for the empty state.
2906 + */
2907 + if ((descr == up->first_tx_descr && up->tx_pending_chars != 0)
2908 + || descr->next == up->first_tx_descr)
2909 + goto done;
2910 +
2911 + /* Set up the descriptor for output. */
2912 + descr->buf = (void*)virt_to_phys(xmit->buf + xmit->tail
2913 + + up->tx_pending_chars);
2914 + descr->after = descr->buf + chars_to_send;
2915 + descr->eol = 1;
2916 + descr->out_eop = 0;
2917 + descr->intr = 1;
2918 + descr->wait = 0;
2919 + descr->in_eop = 0;
2920 + descr->md = 0;
2921 + /*
2922 + * Make sure GCC doesn't move this eol clear before the eol set
2923 + * above.
2924 + */
2925 + barrier();
2926 + last_tx_descr->eol = 0;
2927 +
2928 + up->last_tx_descr = descr;
2929 + up->tx_pending_chars += chars_to_send;
2930 +
2931 + if (!up->tx_started) {
2932 + up->tx_started = 1;
2933 + up->tr_context_descr.next = 0;
2934 + up->tr_context_descr.saved_data
2935 + = (dma_descr_data*)virt_to_phys(descr);
2936 + up->tr_context_descr.saved_data_buf = descr->buf;
2937 + DMA_START_CONTEXT(regi_dmaout,
2938 + virt_to_phys(&up->tr_context_descr));
2939 + } else
2940 + DMA_CONTINUE_DATA(regi_dmaout);
2941 +
2942 + /* DMA is now running (hopefully). */
2943 +
2944 + done:
2945 + if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
2946 + uart_write_wakeup(&up->port);
2947 +}
2948 +
2949 +static void
2950 +transmit_chars_no_dma(struct uart_cris_port *up)
2951 +{
2952 + int count;
2953 + struct circ_buf *xmit = &up->port.info->xmit;
2954 +
2955 + reg_scope_instances regi_ser = up->regi_ser;
2956 + reg_ser_r_stat_din rstat;
2957 + reg_ser_rw_ack_intr ack_intr = { .tr_rdy = regk_ser_yes };
2958 +
2959 + if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
2960 + /* No more to send, so disable the interrupt. */
2961 + reg_ser_rw_intr_mask intr_mask;
2962 + intr_mask = REG_RD(ser, regi_ser, rw_intr_mask);
2963 + intr_mask.tr_rdy = 0;
2964 + intr_mask.tr_empty = 0;
2965 + REG_WR(ser, regi_ser, rw_intr_mask, intr_mask);
2966 + return;
2967 + }
2968 +
2969 + count = ETRAX_SER_FIFO_SIZE;
2970 + do {
2971 + reg_ser_rw_dout dout = { .data = xmit->buf[xmit->tail] };
2972 + REG_WR(ser, regi_ser, rw_dout, dout);
2973 + REG_WR(ser, regi_ser, rw_ack_intr, ack_intr);
2974 + xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
2975 + up->port.icount.tx++;
2976 + if (xmit->head == xmit->tail)
2977 + break;
2978 + rstat = REG_RD(ser, regi_ser, r_stat_din);
2979 + } while ((--count > 0) && rstat.tr_rdy);
2980 +
2981 + if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
2982 + uart_write_wakeup(&up->port);
2983 +} /* transmit_chars_no_dma */
2984 +
2985 +static struct etrax_recv_buffer *
2986 +alloc_recv_buffer(unsigned int size)
2987 +{
2988 + struct etrax_recv_buffer *buffer;
2989 +
2990 + if (!(buffer = kmalloc(sizeof *buffer + size, GFP_ATOMIC)))
2991 + panic("%s: Could not allocate %d bytes buffer\n",
2992 + __FUNCTION__, size);
2993 +
2994 + buffer->next = NULL;
2995 + buffer->length = 0;
2996 + buffer->error = TTY_NORMAL;
2997 +
2998 + return buffer;
2999 +}
3000 +
3001 +static void
3002 +append_recv_buffer(struct uart_cris_port *up,
3003 + struct etrax_recv_buffer *buffer)
3004 +{
3005 + unsigned long flags;
3006 +
3007 + local_irq_save(flags);
3008 +
3009 + if (!up->first_recv_buffer)
3010 + up->first_recv_buffer = buffer;
3011 + else
3012 + up->last_recv_buffer->next = buffer;
3013 +
3014 + up->last_recv_buffer = buffer;
3015 +
3016 + up->recv_cnt += buffer->length;
3017 + if (up->recv_cnt > up->max_recv_cnt)
3018 + up->max_recv_cnt = up->recv_cnt;
3019 +
3020 + local_irq_restore(flags);
3021 +}
3022 +
3023 +static int
3024 +add_char_and_flag(struct uart_cris_port *up, unsigned char data,
3025 + unsigned char flag)
3026 +{
3027 + struct etrax_recv_buffer *buffer;
3028 +
3029 + buffer = alloc_recv_buffer(4);
3030 + buffer->length = 1;
3031 + buffer->error = flag;
3032 + buffer->buffer[0] = data;
3033 +
3034 + append_recv_buffer(up, buffer);
3035 +
3036 + up->port.icount.rx++;
3037 +
3038 + return 1;
3039 +}
3040 +
3041 +static void
3042 +flush_to_flip_buffer(struct uart_cris_port *up)
3043 +{
3044 + struct tty_struct *tty;
3045 + struct etrax_recv_buffer *buffer;
3046 +
3047 + tty = up->port.info->tty;
3048 + if (!up->first_recv_buffer || !tty)
3049 + return;
3050 +
3051 + while ((buffer = up->first_recv_buffer)) {
3052 + unsigned int count = (unsigned int)
3053 + tty_insert_flip_string(tty, buffer->buffer,
3054 + buffer->length);
3055 +
3056 + up->recv_cnt -= count;
3057 +
3058 + if (count == buffer->length) {
3059 + up->first_recv_buffer = buffer->next;
3060 + kfree(buffer);
3061 + } else {
3062 + buffer->length -= count;
3063 + memmove(buffer->buffer, buffer->buffer + count,
3064 + buffer->length);
3065 + buffer->error = TTY_NORMAL;
3066 + }
3067 + }
3068 +
3069 + if (!up->first_recv_buffer)
3070 + up->last_recv_buffer = NULL;
3071 +
3072 + /* This call includes a check for low-latency. */
3073 + tty_flip_buffer_push(tty);
3074 +}
3075 +
3076 +static unsigned int
3077 +handle_descr_data(struct uart_cris_port *up, struct dma_descr_data *descr,
3078 + unsigned int recvl)
3079 +{
3080 + struct etrax_recv_buffer *buffer
3081 + = phys_to_virt((unsigned long)descr->buf) - sizeof *buffer;
3082 +
3083 + if (up->recv_cnt + recvl > 65536) {
3084 + printk(KERN_ERR "Too much pending incoming data on %s!"
3085 + " Dropping %u bytes.\n", up->port.info->tty->name,
3086 + recvl);
3087 + return 0;
3088 + }
3089 +
3090 + buffer->length = recvl;
3091 +
3092 + append_recv_buffer(up, buffer);
3093 +
3094 + flush_to_flip_buffer(up);
3095 +
3096 + buffer = alloc_recv_buffer(SERIAL_DESCR_BUF_SIZE);
3097 + descr->buf = (void*)virt_to_phys(buffer->buffer);
3098 + descr->after = descr->buf + SERIAL_DESCR_BUF_SIZE;
3099 +
3100 + return recvl;
3101 +}
3102 +
3103 +static unsigned int
3104 +handle_all_descr_data(struct uart_cris_port *up)
3105 +{
3106 + struct dma_descr_data *descr
3107 + = &up->rec_descr[(up->cur_rec_descr - 1)
3108 + % SERIAL_RECV_DESCRIPTORS];
3109 + struct dma_descr_data *prev_descr;
3110 + unsigned int recvl;
3111 + unsigned int ret = 0;
3112 + reg_scope_instances regi_dmain = up->regi_dmain;
3113 +
3114 + while (1) {
3115 + prev_descr = descr;
3116 + descr = &up->rec_descr[up->cur_rec_descr];
3117 +
3118 + if (descr == phys_to_virt(REG_RD(dma, regi_dmain, rw_data)))
3119 + break;
3120 +
3121 + if (++up->cur_rec_descr == SERIAL_RECV_DESCRIPTORS)
3122 + up->cur_rec_descr = 0;
3123 +
3124 + /* Find out how many bytes were read. */
3125 + recvl = descr->after - descr->buf;
3126 +
3127 + /* Update stats. */
3128 + up->port.icount.rx += recvl;
3129 +
3130 + ret += handle_descr_data(up, descr, recvl);
3131 + descr->eol = 1;
3132 + /*
3133 + * Make sure GCC doesn't move this eol clear before the
3134 + * eol set above.
3135 + */
3136 + barrier();
3137 + prev_descr->eol = 0;
3138 + flush_dma_descr(descr,1); // Cache bug workaround
3139 + flush_dma_descr(prev_descr,0); // Cache bug workaround
3140 + }
3141 +
3142 + return ret;
3143 +}
3144 +
3145 +static void
3146 +receive_chars_dma(struct uart_cris_port *up)
3147 +{
3148 + reg_ser_r_stat_din rstat;
3149 + reg_dma_rw_ack_intr ack_intr = {0};
3150 +
3151 + /* Acknowledge both dma_descr and dma_eop irq. */
3152 + ack_intr.data = 1;
3153 + ack_intr.in_eop = 1;
3154 + REG_WR(dma, up->regi_dmain, rw_ack_intr, ack_intr);
3155 +
3156 + handle_all_descr_data(up);
3157 +
3158 + /* Read the status register to detect errors. */
3159 + rstat = REG_RD(ser, up->regi_ser, r_stat_din);
3160 +
3161 + if (rstat.framing_err | rstat.par_err | rstat.orun) {
3162 + /*
3163 + * If we got an error, we must reset it by reading the
3164 + * rs_stat_din register and put the data in buffer manually.
3165 + */
3166 + reg_ser_rs_stat_din stat_din;
3167 + stat_din = REG_RD(ser, up->regi_ser, rs_stat_din);
3168 +
3169 + if (stat_din.par_err)
3170 + add_char_and_flag(up, stat_din.data, TTY_PARITY);
3171 + else if (stat_din.orun)
3172 + add_char_and_flag(up, stat_din.data, TTY_OVERRUN);
3173 + else if (stat_din.framing_err)
3174 + add_char_and_flag(up, stat_din.data, TTY_FRAME);
3175 + }
3176 +
3177 + /* Restart the receiving DMA, in case it got stuck on an EOL. */
3178 + DMA_CONTINUE_DATA(up->regi_dmain);
3179 +}
3180 +
3181 +void receive_chars_no_dma(struct uart_cris_port *up)
3182 +{
3183 + reg_ser_rs_stat_din stat_din;
3184 + reg_ser_r_stat_din rstat;
3185 + struct tty_struct *tty;
3186 + struct uart_icount *icount;
3187 + int max_count = 16;
3188 + char flag;
3189 + reg_ser_rw_ack_intr ack_intr = { 0 };
3190 +
3191 + rstat = REG_RD(ser, up->regi_ser, r_stat_din);
3192 + up->last_rx_active_usec = GET_JIFFIES_USEC();
3193 + up->last_rx_active = jiffies;
3194 + icount = &up->port.icount;
3195 + tty = up->port.info->tty;
3196 +
3197 + do {
3198 + stat_din = REG_RD(ser, up->regi_ser, rs_stat_din);
3199 +
3200 + flag = TTY_NORMAL;
3201 + ack_intr.dav = 1;
3202 + REG_WR(ser, up->regi_ser, rw_ack_intr, ack_intr);
3203 + icount->rx++;
3204 +
3205 + if (stat_din.framing_err | stat_din.par_err | stat_din.orun) {
3206 + if (stat_din.data == 0x00 &&
3207 + stat_din.framing_err) {
3208 + /* Most likely a break. */
3209 + flag = TTY_BREAK;
3210 + icount->brk++;
3211 + } else if (stat_din.par_err) {
3212 + flag = TTY_PARITY;
3213 + icount->parity++;
3214 + } else if (stat_din.orun) {
3215 + flag = TTY_OVERRUN;
3216 + icount->overrun++;
3217 + } else if (stat_din.framing_err) {
3218 + flag = TTY_FRAME;
3219 + icount->frame++;
3220 + }
3221 + }
3222 +
3223 + /*
3224 + * If this becomes important, we probably *could* handle this
3225 + * gracefully by keeping track of the unhandled character.
3226 + */
3227 + if (!tty_insert_flip_char(tty, stat_din.data, flag))
3228 + panic("%s: No tty buffer space", __FUNCTION__);
3229 + rstat = REG_RD(ser, up->regi_ser, r_stat_din);
3230 + } while (rstat.dav && (max_count-- > 0));
3231 + spin_unlock(&up->port.lock);
3232 + tty_flip_buffer_push(tty);
3233 + spin_lock(&up->port.lock);
3234 +} /* receive_chars_no_dma */
3235 +
3236 +/*
3237 + * DMA output channel interrupt handler.
3238 + * this interrupt is called from DMA2(ser2), DMA8(ser3), DMA6(ser0) or
3239 + * DMA4(ser1) when they have finished a descriptor with the intr flag set.
3240 + */
3241 +
3242 +static irqreturn_t
3243 +dma_tr_interrupt(int irq, void *dev_id, struct pt_regs * regs)
3244 +{
3245 + struct uart_cris_port *up = (struct uart_cris_port *)dev_id;
3246 + reg_dma_r_masked_intr masked_intr;
3247 + reg_scope_instances regi_dmaout;
3248 + int handled = 0;
3249 +
3250 + spin_lock(&up->port.lock);
3251 + regi_dmaout = up->regi_dmaout;
3252 + if (!regi_dmaout) {
3253 + spin_unlock(&up->port.lock);
3254 + return IRQ_NONE;
3255 + }
3256 +
3257 + /*
3258 + * Check for dma_descr (don't need to check for dma_eop in
3259 + * output DMA for serial).
3260 + */
3261 + masked_intr = REG_RD(dma, regi_dmaout, r_masked_intr);
3262 +
3263 + if (masked_intr.data) {
3264 + /* We can send a new dma bunch. make it so. */
3265 +
3266 + /*
3267 + * Read jiffies_usec first.
3268 + * We want this time to be as late as possible.
3269 + */
3270 + up->last_tx_active_usec = GET_JIFFIES_USEC();
3271 + up->last_tx_active = jiffies;
3272 + transmit_chars_dma(up);
3273 + handled = 1;
3274 + }
3275 + check_modem_status(up);
3276 + spin_unlock(&up->port.lock);
3277 + return IRQ_RETVAL(handled);
3278 +}
3279 +
3280 +/* DMA input channel interrupt handler. */
3281 +
3282 +static irqreturn_t
3283 +dma_rec_interrupt(int irq, void *dev_id, struct pt_regs * regs)
3284 +{
3285 + struct uart_cris_port *up = (struct uart_cris_port *)dev_id;
3286 + reg_dma_r_masked_intr masked_intr;
3287 + reg_scope_instances regi_dmain;
3288 + int handled = 0;
3289 +
3290 + spin_lock(&up->port.lock);
3291 + regi_dmain = up->regi_dmain;
3292 + if (!regi_dmain) {
3293 + spin_unlock(&up->port.lock);
3294 + return IRQ_NONE;
3295 + }
3296 +
3297 + /* Check for both dma_eop and dma_descr for the input dma channel. */
3298 + masked_intr = REG_RD(dma, regi_dmain, r_masked_intr);
3299 + if (masked_intr.data || masked_intr.in_eop) {
3300 + /* We have received something. */
3301 + receive_chars_dma(up);
3302 + handled = 1;
3303 + }
3304 + check_modem_status(up);
3305 + spin_unlock(&up->port.lock);
3306 + return IRQ_RETVAL(handled);
3307 +}
3308 +
3309 +/* "Normal" serial port interrupt handler - both rx and tx. */
3310 +
3311 +static irqreturn_t
3312 +ser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
3313 +{
3314 + struct uart_cris_port *up = (struct uart_cris_port *)dev_id;
3315 + reg_scope_instances regi_ser;
3316 + int handled = 0;
3317 +
3318 + spin_lock(&up->port.lock);
3319 + if (up->regi_dmain && up->regi_dmaout) {
3320 + spin_unlock(&up->port.lock);
3321 + return IRQ_NONE;
3322 + }
3323 +
3324 + regi_ser = up->regi_ser;
3325 +
3326 + if (regi_ser) {
3327 + reg_ser_r_masked_intr masked_intr;
3328 + masked_intr = REG_RD(ser, regi_ser, r_masked_intr);
3329 + /*
3330 + * Check what interrupts are active before taking
3331 + * actions. If DMA is used the interrupt shouldn't
3332 + * be enabled.
3333 + */
3334 + if (masked_intr.dav) {
3335 + receive_chars_no_dma(up);
3336 + handled = 1;
3337 + }
3338 + check_modem_status(up);
3339 +
3340 + if (masked_intr.tr_rdy) {
3341 + transmit_chars_no_dma(up);
3342 + handled = 1;
3343 + }
3344 + }
3345 + spin_unlock(&up->port.lock);
3346 + return IRQ_RETVAL(handled);
3347 +} /* ser_interrupt */
3348 +
3349 +static int start_recv_dma(struct uart_cris_port *up)
3350 +{
3351 + struct dma_descr_data *descr = up->rec_descr;
3352 + struct etrax_recv_buffer *buffer;
3353 + int i;
3354 +
3355 + /* Set up the receiving descriptors. */
3356 + for (i = 0; i < SERIAL_RECV_DESCRIPTORS; i++) {
3357 + buffer = alloc_recv_buffer(SERIAL_DESCR_BUF_SIZE);
3358 + descr[i].next = (void*)virt_to_phys(&descr[i+1]);
3359 + descr[i].buf = (void*)virt_to_phys(buffer->buffer);
3360 + descr[i].after = descr[i].buf + SERIAL_DESCR_BUF_SIZE;
3361 + descr[i].eol = 0;
3362 + descr[i].out_eop = 0;
3363 + descr[i].intr = 1;
3364 + descr[i].wait = 0;
3365 + descr[i].in_eop = 0;
3366 + descr[i].md = 0;
3367 +
3368 + }
3369 +
3370 + /* Link the last descriptor to the first. */
3371 + descr[i-1].next = (void*)virt_to_phys(&descr[0]);
3372 +
3373 + /* And mark it as end of list. */
3374 + descr[i-1].eol = 1;
3375 +
3376 + /* Start with the first descriptor in the list. */
3377 + up->cur_rec_descr = 0;
3378 + up->rec_context_descr.next = 0;
3379 + up->rec_context_descr.saved_data
3380 + = (dma_descr_data *)virt_to_phys(&descr[up->cur_rec_descr]);
3381 + up->rec_context_descr.saved_data_buf = descr[up->cur_rec_descr].buf;
3382 +
3383 + /* Start the DMA. */
3384 + DMA_START_CONTEXT(up->regi_dmain,
3385 + virt_to_phys(&up->rec_context_descr));
3386 +
3387 + /* Input DMA should be running now. */
3388 + return 1;
3389 +}
3390 +
3391 +
3392 +static void start_receive(struct uart_cris_port *up)
3393 +{
3394 + reg_scope_instances regi_dmain = up->regi_dmain;
3395 + if (regi_dmain) {
3396 + start_recv_dma(up);
3397 + }
3398 +}
3399 +
3400 +
3401 +static void start_transmitter(struct uart_cris_port *up)
3402 +{
3403 + int i;
3404 + reg_scope_instances regi_dmaout = up->regi_dmaout;
3405 + if (regi_dmaout) {
3406 + for (i = 0; i < SERIAL_TX_DESCRIPTORS; i++) {
3407 + memset(&up->tr_descr[i], 0, sizeof(up->tr_descr[i]));
3408 + up->tr_descr[i].eol = 1;
3409 + up->tr_descr[i].intr = 1;
3410 + up->tr_descr[i].next = (dma_descr_data *)
3411 + virt_to_phys(&up->tr_descr[i+1]);
3412 + }
3413 + up->tr_descr[i-1].next = (dma_descr_data *)
3414 + virt_to_phys(&up->tr_descr[0]);
3415 + up->first_tx_descr = &up->tr_descr[0];
3416 +
3417 + /*
3418 + * We'll be counting up to up->last_tx_descr->next from
3419 + * up->first_tx_descr when starting DMA, so we should make
3420 + * them the same for the very first round. If instead we'd
3421 + * set last_tx_descr = first_tx_descr, we'd rely on
3422 + * accidentally working code and data as we'd take a pass over
3423 + * the first, unused, descriptor.
3424 + */
3425 + up->last_tx_descr = &up->tr_descr[i-1];
3426 + up->tx_started = 0;
3427 + up->tx_pending_chars = 0;
3428 + }
3429 +}
3430 +
3431 +static int serial_cris_startup(struct uart_port *port)
3432 +{
3433 + struct uart_cris_port *up = (struct uart_cris_port *)port;
3434 + unsigned long flags;
3435 + reg_intr_vect_rw_mask intr_mask;
3436 + reg_ser_rw_intr_mask ser_intr_mask = {0};
3437 + reg_dma_rw_intr_mask dmain_intr_mask = {0};
3438 + reg_dma_rw_intr_mask dmaout_intr_mask = {0};
3439 + reg_dma_rw_cfg cfg = {.en = 1};
3440 + reg_scope_instances regi_dma;
3441 +
3442 + spin_lock_irqsave(&up->port.lock, flags);
3443 +
3444 + intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
3445 +
3446 + dmain_intr_mask.data = dmain_intr_mask.in_eop = regk_dma_yes;
3447 + dmaout_intr_mask.data = regk_dma_yes;
3448 + if (!up->regi_dmain)
3449 + ser_intr_mask.dav = regk_ser_yes;
3450 +
3451 + if (port->line == 0) {
3452 + if (request_irq(SER0_INTR_VECT, ser_interrupt,
3453 + IRQF_SHARED | IRQF_DISABLED, "ser0",
3454 + &serial_cris_ports[0]))
3455 + panic("irq ser0");
3456 + /* Enable the ser0 irq in global config. */
3457 + intr_mask.ser0 = 1;
3458 + /* Port ser0 can use dma6 for tx and dma7 for rx. */
3459 +#ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
3460 + if (request_irq(DMA6_INTR_VECT, dma_tr_interrupt,
3461 + IRQF_DISABLED, "serial 0 dma tr",
3462 + &serial_cris_ports[0]))
3463 + panic("irq ser0txdma");
3464 + crisv32_request_dma(6, "ser0", DMA_PANIC_ON_ERROR, 0,
3465 + dma_ser0);
3466 + /* Enable the dma6 irq in global config. */
3467 + intr_mask.dma6 = 1;
3468 +#endif
3469 +#ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
3470 + if (request_irq(DMA7_INTR_VECT, dma_rec_interrupt,
3471 + IRQF_DISABLED, "serial 0 dma rec",
3472 + &serial_cris_ports[0]))
3473 + panic("irq ser0rxdma");
3474 + crisv32_request_dma(7, "ser0", DMA_PANIC_ON_ERROR, 0,
3475 + dma_ser0);
3476 + /* Enable the dma7 irq in global config. */
3477 + intr_mask.dma7 = 1;
3478 +#endif
3479 + } else if (port->line == 1) {
3480 + if (request_irq(SER1_INTR_VECT, ser_interrupt,
3481 + IRQF_SHARED | IRQF_DISABLED, "ser1",
3482 + &serial_cris_ports[1]))
3483 + panic("irq ser1");
3484 + /* Enable the ser1 irq in global config. */
3485 + intr_mask.ser1 = 1;
3486 +
3487 + /* Port ser1 can use dma4 for tx and dma5 for rx. */
3488 +#ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA4_OUT
3489 + if (request_irq(DMA4_INTR_VECT, dma_tr_interrupt,
3490 + IRQF_DISABLED, "serial 1 dma tr",
3491 + &serial_cris_ports[1]))
3492 + panic("irq ser1txdma");
3493 + crisv32_request_dma(4, "ser1", DMA_PANIC_ON_ERROR, 0,
3494 + dma_ser1);
3495 + /* Enable the dma4 irq in global config. */
3496 + intr_mask.dma4 = 1;
3497 +#endif
3498 +#ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA5_IN
3499 + if (request_irq(DMA5_INTR_VECT, dma_rec_interrupt,
3500 + IRQF_DISABLED, "serial 1 dma rec",
3501 + &serial_cris_ports[1]))
3502 + panic("irq ser1rxdma");
3503 + crisv32_request_dma(5, "ser1", DMA_PANIC_ON_ERROR, 0,
3504 + dma_ser1);
3505 + /* Enable the dma5 irq in global config. */
3506 + intr_mask.dma5 = 1;
3507 +#endif
3508 + } else if (port->line == 2) {
3509 + if (request_irq(SER2_INTR_VECT, ser_interrupt,
3510 + IRQF_SHARED | IRQF_DISABLED, "ser2",
3511 + &serial_cris_ports[2]))
3512 + panic("irq ser2");
3513 + /* Enable the ser2 irq in global config. */
3514 + intr_mask.ser2 = 1;
3515 +
3516 + /* Port ser2 can use dma2 for tx and dma3 for rx. */
3517 +#ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
3518 + if (request_irq(DMA2_INTR_VECT, dma_tr_interrupt,
3519 + IRQF_DISABLED, "serial 2 dma tr",
3520 + &serial_cris_ports[2]))
3521 + panic("irq ser2txdma");
3522 + crisv32_request_dma(2, "ser2", DMA_PANIC_ON_ERROR, 0,
3523 + dma_ser2);
3524 + /* Enable the dma2 irq in global config. */
3525 + intr_mask.dma2 = 1;
3526 +#endif
3527 +#ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
3528 + if (request_irq(DMA3_INTR_VECT, dma_rec_interrupt,
3529 + IRQF_DISABLED, "serial 2 dma rec",
3530 + &serial_cris_ports[2]))
3531 + panic("irq ser2rxdma");
3532 + crisv32_request_dma(3, "ser2", DMA_PANIC_ON_ERROR, 0,
3533 + dma_ser2);
3534 + /* Enable the dma3 irq in global config. */
3535 + intr_mask.dma3 = 1;
3536 +#endif
3537 + } else if (port->line == 3) {
3538 + if (request_irq(SER3_INTR_VECT, ser_interrupt,
3539 + IRQF_SHARED | IRQF_DISABLED, "ser3",
3540 + &serial_cris_ports[3]))
3541 + panic("irq ser3" );
3542 + /* Enable the ser3 irq in global config. */
3543 + intr_mask.ser3 = 1;
3544 +
3545 + /* Port ser3 can use dma8 for tx and dma9 for rx. */
3546 +#ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA8_OUT
3547 + if (request_irq(DMA8_INTR_VECT, dma_tr_interrupt,
3548 + IRQF_DISABLED, "serial 3 dma tr",
3549 + &serial_cris_ports[3]))
3550 + panic("irq ser3txdma");
3551 + crisv32_request_dma(8, "ser3", DMA_PANIC_ON_ERROR, 0,
3552 + dma_ser3);
3553 + /* Enable the dma2 irq in global config. */
3554 + intr_mask.dma8 = 1;
3555 +#endif
3556 +#ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA9_IN
3557 + if (request_irq(DMA9_INTR_VECT, dma_rec_interrupt,
3558 + IRQF_DISABLED, "serial 3 dma rec",
3559 + &serial_cris_ports[3]))
3560 + panic("irq ser3rxdma");
3561 + crisv32_request_dma(9, "ser3", DMA_PANIC_ON_ERROR, 0,
3562 + dma_ser3);
3563 + /* Enable the dma3 irq in global config. */
3564 + intr_mask.dma9 = 1;
3565 +#endif
3566 + }
3567 +
3568 + /*
3569 + * Reset the DMA channels and make sure their interrupts are cleared.
3570 + */
3571 +
3572 + regi_dma = up->regi_dmain;
3573 + if (regi_dma) {
3574 + reg_dma_rw_ack_intr ack_intr = { 0 };
3575 + DMA_RESET(regi_dma);
3576 + /* Wait until reset cycle is complete. */
3577 + DMA_WAIT_UNTIL_RESET(regi_dma);
3578 + REG_WR(dma, regi_dma, rw_cfg, cfg);
3579 + /* Make sure the irqs are cleared. */
3580 + ack_intr.group = 1;
3581 + ack_intr.ctxt = 1;
3582 + ack_intr.data = 1;
3583 + ack_intr.in_eop = 1;
3584 + ack_intr.stream_cmd = 1;
3585 + REG_WR(dma, regi_dma, rw_ack_intr, ack_intr);
3586 + }
3587 + regi_dma = up->regi_dmaout;
3588 + if (regi_dma) {
3589 + reg_dma_rw_ack_intr ack_intr = { 0 };
3590 + DMA_RESET(regi_dma);
3591 + /* Wait until reset cycle is complete. */
3592 + DMA_WAIT_UNTIL_RESET(regi_dma);
3593 + REG_WR(dma, regi_dma, rw_cfg, cfg);
3594 + /* Make sure the irqs are cleared. */
3595 + ack_intr.group = 1;
3596 + ack_intr.ctxt = 1;
3597 + ack_intr.data = 1;
3598 + ack_intr.in_eop = 1;
3599 + ack_intr.stream_cmd = 1;
3600 + REG_WR(dma, regi_dma, rw_ack_intr, ack_intr);
3601 + }
3602 +
3603 + REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
3604 + REG_WR(ser, up->regi_ser, rw_intr_mask, ser_intr_mask);
3605 + if (up->regi_dmain)
3606 + REG_WR(dma, up->regi_dmain, rw_intr_mask, dmain_intr_mask);
3607 + if (up->regi_dmaout)
3608 + REG_WR(dma, up->regi_dmaout, rw_intr_mask, dmaout_intr_mask);
3609 +
3610 + start_receive(up);
3611 + start_transmitter(up);
3612 +
3613 + serial_cris_set_mctrl(&up->port, up->port.mctrl);
3614 + spin_unlock_irqrestore(&up->port.lock, flags);
3615 +
3616 + return 0;
3617 +}
3618 +
3619 +static void serial_cris_shutdown(struct uart_port *port)
3620 +{
3621 + struct uart_cris_port *up = (struct uart_cris_port *)port;
3622 + unsigned long flags;
3623 + reg_intr_vect_rw_mask intr_mask;
3624 +
3625 + spin_lock_irqsave(&up->port.lock, flags);
3626 +
3627 + intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
3628 + serial_cris_stop_tx(port);
3629 + serial_cris_stop_rx(port);
3630 +
3631 + if (port->line == 0) {
3632 + intr_mask.ser0 = 0;
3633 + free_irq(SER0_INTR_VECT, &serial_cris_ports[0]);
3634 +#ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA6_OUT
3635 + intr_mask.dma6 = 0;
3636 + crisv32_free_dma(6);
3637 + free_irq(DMA6_INTR_VECT, &serial_cris_ports[0]);
3638 +#endif
3639 +#ifdef CONFIG_ETRAX_SERIAL_PORT0_DMA7_IN
3640 + intr_mask.dma7 = 0;
3641 + crisv32_free_dma(7);
3642 + free_irq(DMA7_INTR_VECT, &serial_cris_ports[0]);
3643 +#endif
3644 + } else if (port->line == 1) {
3645 + intr_mask.ser1 = 0;
3646 + free_irq(SER1_INTR_VECT, &serial_cris_ports[1]);
3647 +#ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA4_OUT
3648 + intr_mask.dma4 = 0;
3649 + crisv32_free_dma(4);
3650 + free_irq(DMA4_INTR_VECT, &serial_cris_ports[1]);
3651 +#endif
3652 +#ifdef CONFIG_ETRAX_SERIAL_PORT1_DMA5_IN
3653 + intr_mask.dma5 = 0;
3654 + crisv32_free_dma(5);
3655 + free_irq(DMA5_INTR_VECT, &serial_cris_ports[1]);
3656 +#endif
3657 + } else if (port->line == 2) {
3658 + intr_mask.ser2 = 0;
3659 + free_irq(SER2_INTR_VECT, &serial_cris_ports[2]);
3660 +#ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA2_OUT
3661 + intr_mask.dma2 = 0;
3662 + crisv32_free_dma(2);
3663 + free_irq(DMA2_INTR_VECT, &serial_cris_ports[2]);
3664 +#endif
3665 +#ifdef CONFIG_ETRAX_SERIAL_PORT2_DMA3_IN
3666 + intr_mask.dma3 = 0;
3667 + crisv32_free_dma(3);
3668 + free_irq(DMA3_INTR_VECT, &serial_cris_ports[2]);
3669 +#endif
3670 + } else if (port->line == 3) {
3671 + intr_mask.ser3 = 0;
3672 + free_irq(SER3_INTR_VECT, &serial_cris_ports[3]);
3673 +#ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA8_OUT
3674 + intr_mask.dma8 = 0;
3675 + crisv32_free_dma(8);
3676 + free_irq(DMA8_INTR_VECT, &serial_cris_ports[3]);
3677 +#endif
3678 +#ifdef CONFIG_ETRAX_SERIAL_PORT3_DMA9_IN
3679 + intr_mask.dma9 = 0;
3680 + crisv32_free_dma(9);
3681 + free_irq(DMA9_INTR_VECT, &serial_cris_ports[3]);
3682 +#endif
3683 + }
3684 +
3685 + REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
3686 +
3687 + serial_cris_set_mctrl(&up->port, up->port.mctrl);
3688 +
3689 + if (up->regi_dmain) {
3690 + struct etrax_recv_buffer *rb;
3691 + struct etrax_recv_buffer *rb_next;
3692 + int i;
3693 + struct dma_descr_data *descr;
3694 +
3695 + /*
3696 + * In case of DMA and receive errors, there might be pending
3697 + * receive buffers still linked here and not flushed upwards.
3698 + * Release them.
3699 + */
3700 + for (rb = up->first_recv_buffer; rb != NULL; rb = rb_next) {
3701 + rb_next = rb->next;
3702 + kfree (rb);
3703 + }
3704 + up->first_recv_buffer = NULL;
3705 + up->last_recv_buffer = NULL;
3706 +
3707 + /*
3708 + * Also release buffers that were attached to the DMA
3709 + * before we shut down the hardware above.
3710 + */
3711 + for (i = 0, descr = up->rec_descr;
3712 + i < SERIAL_RECV_DESCRIPTORS;
3713 + i++)
3714 + if (descr[i].buf) {
3715 + rb = phys_to_virt((u32) descr[i].buf)
3716 + - sizeof *rb;
3717 + kfree(rb);
3718 + descr[i].buf = NULL;
3719 + }
3720 + }
3721 +
3722 + spin_unlock_irqrestore(&up->port.lock, flags);
3723 +
3724 +}
3725 +
3726 +static void
3727 +serial_cris_set_termios(struct uart_port *port, struct termios *termios,
3728 + struct termios *old)
3729 +{
3730 + struct uart_cris_port *up = (struct uart_cris_port *)port;
3731 + unsigned long flags;
3732 + reg_ser_rw_xoff xoff;
3733 + reg_ser_rw_xoff_clr xoff_clr = {0};
3734 + reg_ser_rw_tr_ctrl tx_ctrl = {0};
3735 + reg_ser_rw_tr_dma_en tx_dma_en = {0};
3736 + reg_ser_rw_rec_ctrl rx_ctrl = {0};
3737 + reg_ser_rw_tr_baud_div tx_baud_div = {0};
3738 + reg_ser_rw_rec_baud_div rx_baud_div = {0};
3739 + reg_ser_r_stat_din rstat;
3740 + int baud;
3741 +
3742 + if (old &&
3743 + termios->c_cflag == old->c_cflag &&
3744 + termios->c_iflag == old->c_iflag)
3745 + return;
3746 +
3747 + /* Start with default settings and then fill in changes. */
3748 +
3749 + /* Tx: 8 bit, no/even parity, 1 stop bit, no cts. */
3750 + tx_ctrl.base_freq = regk_ser_f29_493;
3751 + tx_ctrl.en = 0;
3752 + tx_ctrl.stop = 0;
3753 +#ifdef CONFIG_ETRAX_RS485
3754 + if (up->rs485.enabled && (up->port_type != TYPE_485FD)) {
3755 + tx_ctrl.auto_rts = regk_ser_yes;
3756 + } else
3757 +#endif
3758 + tx_ctrl.auto_rts = regk_ser_no;
3759 + tx_ctrl.txd = 1;
3760 + tx_ctrl.auto_cts = 0;
3761 + /* Rx: 8 bit, no/even parity. */
3762 + if (up->regi_dmain) {
3763 + rx_ctrl.dma_mode = 1;
3764 + rx_ctrl.auto_eop = 1;
3765 + }
3766 + rx_ctrl.dma_err = regk_ser_stop;
3767 + rx_ctrl.sampling = regk_ser_majority;
3768 + rx_ctrl.timeout = 1;
3769 +
3770 +#ifdef CONFIG_ETRAX_RS485
3771 + if (up->rs485.enabled && (up->port_type != TYPE_485FD)) {
3772 +# ifdef CONFIG_ETRAX_RS485_DISABLE_RECEIVER
3773 + rx_ctrl.half_duplex = regk_ser_yes;
3774 +# endif
3775 + rx_ctrl.rts_n = up->rs485.rts_after_sent ?
3776 + regk_ser_active : regk_ser_inactive;
3777 + } else if (up->port_type == TYPE_485FD) {
3778 + rx_ctrl.rts_n = regk_ser_active;
3779 + } else
3780 +#endif
3781 + rx_ctrl.rts_n = regk_ser_inactive;
3782 +
3783 + /* Common for tx and rx: 8N1. */
3784 + tx_ctrl.data_bits = regk_ser_bits8;
3785 + rx_ctrl.data_bits = regk_ser_bits8;
3786 + tx_ctrl.par = regk_ser_even;
3787 + rx_ctrl.par = regk_ser_even;
3788 + tx_ctrl.par_en = regk_ser_no;
3789 + rx_ctrl.par_en = regk_ser_no;
3790 +
3791 + tx_ctrl.stop_bits = regk_ser_bits1;
3792 +
3793 +
3794 + /* Change baud-rate and write it to the hardware. */
3795 +
3796 + /* baud_clock = base_freq / (divisor*8)
3797 + * divisor = base_freq / (baud_clock * 8)
3798 + * base_freq is either:
3799 + * off, ext, 29.493MHz, 32.000 MHz, 32.768 MHz or 100 MHz
3800 + * 20.493MHz is used for standard baudrates
3801 + */
3802 +
3803 + /*
3804 + * For the console port we keep the original baudrate here. Not very
3805 + * beautiful.
3806 + */
3807 + if ((port != console_port) || old)
3808 + baud = uart_get_baud_rate(port, termios, old, 0,
3809 + port->uartclk / 8);
3810 + else
3811 + baud = console_baud;
3812 +
3813 + tx_baud_div.div = 29493000 / (8 * baud);
3814 + /* Rx uses same as tx. */
3815 + rx_baud_div.div = tx_baud_div.div;
3816 + rx_ctrl.base_freq = tx_ctrl.base_freq;
3817 +
3818 + if ((termios->c_cflag & CSIZE) == CS7) {
3819 + /* Set 7 bit mode. */
3820 + tx_ctrl.data_bits = regk_ser_bits7;
3821 + rx_ctrl.data_bits = regk_ser_bits7;
3822 + }
3823 +
3824 + if (termios->c_cflag & CSTOPB) {
3825 + /* Set 2 stop bit mode. */
3826 + tx_ctrl.stop_bits = regk_ser_bits2;
3827 + }
3828 +
3829 + if (termios->c_cflag & PARENB) {
3830 + /* Enable parity. */
3831 + tx_ctrl.par_en = regk_ser_yes;
3832 + rx_ctrl.par_en = regk_ser_yes;
3833 + }
3834 +
3835 + if (termios->c_cflag & CMSPAR) {
3836 + if (termios->c_cflag & PARODD) {
3837 + /* Set mark parity if PARODD and CMSPAR. */
3838 + tx_ctrl.par = regk_ser_mark;
3839 + rx_ctrl.par = regk_ser_mark;
3840 + } else {
3841 + tx_ctrl.par = regk_ser_space;
3842 + rx_ctrl.par = regk_ser_space;
3843 + }
3844 + } else {
3845 + if (termios->c_cflag & PARODD) {
3846 + /* Set odd parity. */
3847 + tx_ctrl.par = regk_ser_odd;
3848 + rx_ctrl.par = regk_ser_odd;
3849 + }
3850 + }
3851 +
3852 + if (termios->c_cflag & CRTSCTS) {
3853 + /* Enable automatic CTS handling. */
3854 + tx_ctrl.auto_cts = regk_ser_yes;
3855 + }
3856 +
3857 + /* Make sure the tx and rx are enabled. */
3858 + tx_ctrl.en = regk_ser_yes;
3859 + rx_ctrl.en = regk_ser_yes;
3860 +
3861 + /*
3862 + * Wait for tr_idle in case a character is being output, so it won't
3863 + * be damaged by the changes we do below. It seems the termios
3864 + * changes "sometimes" (we can't see e.g. a tcsetattr TCSANOW
3865 + * parameter here) should take place no matter what state. However,
3866 + * in case we should wait, we may have a non-empty transmitter state
3867 + * as we tell the upper layers that we're all done when we've passed
3868 + * characters to the hardware, but we don't wait for them being
3869 + * actually shifted out.
3870 + */
3871 + spin_lock_irqsave(&port->lock, flags);
3872 +
3873 + /*
3874 + * None of our interrupts re-enable DMA, so it's thankfully ok to
3875 + * disable it once, outside the loop.
3876 + */
3877 + tx_dma_en.en = 0;
3878 + REG_WR(ser, up->regi_ser, rw_tr_dma_en, tx_dma_en);
3879 + do {
3880 + /*
3881 + * Make sure we have integrity between the read r_stat status
3882 + * and us writing the registers below, but don't busy-wait
3883 + * with interrupts off. We need to keep the port lock though
3884 + * (if we go SMP), so nobody else writes characters.
3885 + */
3886 + local_irq_restore(flags);
3887 + local_irq_save(flags);
3888 + rstat = REG_RD(ser, up->regi_ser, r_stat_din);
3889 + } while (!rstat.tr_idle);
3890 +
3891 + /* Actually write the control regs (if modified) to the hardware. */
3892 +
3893 + uart_update_timeout(port, termios->c_cflag, port->uartclk/8);
3894 + MODIFY_REG(up->regi_ser, rw_rec_baud_div, rx_baud_div);
3895 + MODIFY_REG(up->regi_ser, rw_rec_ctrl, rx_ctrl);
3896 +
3897 + MODIFY_REG(up->regi_ser, rw_tr_baud_div, tx_baud_div);
3898 + MODIFY_REG(up->regi_ser, rw_tr_ctrl, tx_ctrl);
3899 +
3900 + tx_dma_en.en = up->regi_dmaout != 0;
3901 + REG_WR(ser, up->regi_ser, rw_tr_dma_en, tx_dma_en);
3902 +
3903 + xoff = REG_RD(ser, up->regi_ser, rw_xoff);
3904 +
3905 + if (up->port.info && (up->port.info->tty->termios->c_iflag & IXON)) {
3906 + xoff.chr = STOP_CHAR(up->port.info->tty);
3907 + xoff.automatic = regk_ser_yes;
3908 + } else
3909 + xoff.automatic = regk_ser_no;
3910 +
3911 + MODIFY_REG(up->regi_ser, rw_xoff, xoff);
3912 +
3913 + /*
3914 + * Make sure we don't start in an automatically shut-off state due to
3915 + * a previous early exit.
3916 + */
3917 + xoff_clr.clr = 1;
3918 + REG_WR(ser, up->regi_ser, rw_xoff_clr, xoff_clr);
3919 +
3920 + serial_cris_set_mctrl(&up->port, up->port.mctrl);
3921 + spin_unlock_irqrestore(&up->port.lock, flags);
3922 +}
3923 +
3924 +static const char *
3925 +serial_cris_type(struct uart_port *port)
3926 +{
3927 + return "CRISv32";
3928 +}
3929 +
3930 +static void serial_cris_release_port(struct uart_port *port)
3931 +{
3932 +}
3933 +
3934 +static int serial_cris_request_port(struct uart_port *port)
3935 +{
3936 + return 0;
3937 +}
3938 +
3939 +static void serial_cris_config_port(struct uart_port *port, int flags)
3940 +{
3941 + struct uart_cris_port *up = (struct uart_cris_port *)port;
3942 + up->port.type = PORT_CRIS;
3943 +}
3944 +
3945 +#if defined(CONFIG_ETRAX_RS485)
3946 +
3947 +static void cris_set_rs485_mode(struct uart_cris_port* up) {
3948 + reg_ser_rw_tr_ctrl tr_ctrl;
3949 + reg_ser_rw_rec_ctrl rec_ctrl;
3950 + reg_scope_instances regi_ser = up->regi_ser;
3951 +
3952 + if (up->port_type == TYPE_485FD)
3953 + /* We do not want to change anything if we are in 485FD mode */
3954 + return;
3955 +
3956 + tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
3957 + rec_ctrl = REG_RD(ser, regi_ser, rw_rec_ctrl);
3958 +
3959 + /* Set port in RS-485 mode */
3960 + if (up->rs485.enabled) {
3961 + tr_ctrl.auto_rts = regk_ser_yes;
3962 + rec_ctrl.rts_n = up->rs485.rts_after_sent ?
3963 + regk_ser_active : regk_ser_inactive;
3964 +#ifdef CONFIG_ETRAX_RS485_DISABLE_RECEIVER
3965 + rec_ctrl.half_duplex = regk_ser_yes;
3966 +#endif
3967 + }
3968 + /* Set port to RS-232 mode */
3969 + else {
3970 + rec_ctrl.rts_n = regk_ser_inactive;
3971 + tr_ctrl.auto_rts = regk_ser_no;
3972 + rec_ctrl.half_duplex = regk_ser_no;
3973 + }
3974 +
3975 + REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
3976 + REG_WR(ser, regi_ser, rw_rec_ctrl, rec_ctrl);
3977 +}
3978 +
3979 +/* Enable/disable RS-485 mode on selected port. */
3980 +static int
3981 +cris_enable_rs485(struct uart_cris_port* up, struct rs485_control *r)
3982 +{
3983 + if (up->port_type == TYPE_485FD)
3984 + /* Port in 485FD mode can not chage mode */
3985 + goto out;
3986 +
3987 + up->rs485.enabled = 0x1 & r->enabled;
3988 + up->rs485.rts_on_send = 0x01 & r->rts_on_send;
3989 + up->rs485.rts_after_sent = 0x01 & r->rts_after_sent;
3990 + up->rs485.delay_rts_before_send = r->delay_rts_before_send;
3991 +
3992 + cris_set_rs485_mode(up);
3993 + out:
3994 + return 0;
3995 +}
3996 +
3997 +
3998 +/* Enable RS485 mode on port and send the data. Port will stay
3999 + * in 485 mode after the data has been sent.
4000 + */
4001 +static int
4002 +cris_write_rs485(struct uart_cris_port* up, const unsigned char *buf,
4003 + int count)
4004 +{
4005 + up->rs485.enabled = 1;
4006 +
4007 + /* Set the port in RS485 mode */
4008 + cris_set_rs485_mode(up);
4009 +
4010 + /* Send the data */
4011 + count = serial_cris_driver.tty_driver->write(up->port.info->tty, buf, count);
4012 +
4013 + return count;
4014 +}
4015 +
4016 +#endif /* CONFIG_ETRAX_RS485 */
4017 +
4018 +static int serial_cris_ioctl(struct uart_port *port, unsigned int cmd,
4019 + unsigned long arg)
4020 +{
4021 + struct uart_cris_port *up = (struct uart_cris_port *)port;
4022 +
4023 + switch (cmd) {
4024 +#if defined(CONFIG_ETRAX_RS485)
4025 + case TIOCSERSETRS485: {
4026 + struct rs485_control rs485ctrl;
4027 + if (copy_from_user(&rs485ctrl, (struct rs485_control*) arg,
4028 + sizeof(rs485ctrl)))
4029 + return -EFAULT;
4030 +
4031 + return cris_enable_rs485(up, &rs485ctrl);
4032 + }
4033 +
4034 + case TIOCSERWRRS485: {
4035 + struct rs485_write rs485wr;
4036 + if (copy_from_user(&rs485wr, (struct rs485_write*)arg,
4037 + sizeof(rs485wr)))
4038 + return -EFAULT;
4039 +
4040 + return cris_write_rs485(up, rs485wr.outc, rs485wr.outc_size);
4041 + }
4042 +#endif
4043 + default:
4044 + return -ENOIOCTLCMD;
4045 + }
4046 +
4047 + return 0;
4048 +}
4049 +
4050 +static const struct uart_ops serial_cris_pops = {
4051 + .tx_empty = serial_cris_tx_empty,
4052 + .set_mctrl = serial_cris_set_mctrl,
4053 + .get_mctrl = serial_cris_get_mctrl,
4054 + .stop_tx = serial_cris_stop_tx,
4055 + .start_tx = serial_cris_start_tx,
4056 + .send_xchar = serial_cris_send_xchar,
4057 + .stop_rx = serial_cris_stop_rx,
4058 + .enable_ms = serial_cris_enable_ms,
4059 + .break_ctl = serial_cris_break_ctl,
4060 + .startup = serial_cris_startup,
4061 + .shutdown = serial_cris_shutdown,
4062 + .set_termios = serial_cris_set_termios,
4063 + .type = serial_cris_type,
4064 + .release_port = serial_cris_release_port,
4065 + .request_port = serial_cris_request_port,
4066 + .config_port = serial_cris_config_port,
4067 + .ioctl = serial_cris_ioctl,
4068 +};
4069 +
4070 +/*
4071 + * It's too easy to break CONFIG_ETRAX_DEBUG_PORT_NULL and the
4072 + * no-config choices by adding and moving code to before a necessary
4073 + * early exit in all functions for the special case of
4074 + * up->regi_ser == 0. This collection of dummy functions lets us
4075 + * avoid that. Maybe there should be a generic table of dummy serial
4076 + * functions?
4077 + */
4078 +
4079 +static unsigned int serial_cris_tx_empty_dummy(struct uart_port *port)
4080 +{
4081 + return TIOCSER_TEMT;
4082 +}
4083 +
4084 +static void serial_cris_set_mctrl_dummy(struct uart_port *port,
4085 + unsigned int mctrl)
4086 +{
4087 +}
4088 +
4089 +static unsigned int serial_cris_get_mctrl_dummy(struct uart_port *port)
4090 +{
4091 + return 0;
4092 +}
4093 +
4094 +static void serial_cris_stop_tx_dummy(struct uart_port *port)
4095 +{
4096 +}
4097 +
4098 +static void serial_cris_start_tx_dummy(struct uart_port *port)
4099 +{
4100 + /* Discard outbound characters. */
4101 + struct uart_cris_port *up = (struct uart_cris_port *)port;
4102 + struct circ_buf *xmit = &up->port.info->xmit;
4103 + xmit->tail = xmit->head;
4104 + uart_write_wakeup(port);
4105 +}
4106 +
4107 +#define serial_cris_stop_rx_dummy serial_cris_stop_tx_dummy
4108 +
4109 +#define serial_cris_enable_ms_dummy serial_cris_stop_tx_dummy
4110 +
4111 +static void serial_cris_break_ctl_dummy(struct uart_port *port,
4112 + int break_state)
4113 +{
4114 +}
4115 +
4116 +static int serial_cris_startup_dummy(struct uart_port *port)
4117 +{
4118 + return 0;
4119 +}
4120 +
4121 +#define serial_cris_shutdown_dummy serial_cris_stop_tx_dummy
4122 +
4123 +static void
4124 +serial_cris_set_termios_dummy(struct uart_port *port, struct termios *termios,
4125 + struct termios *old)
4126 +{
4127 +}
4128 +
4129 +#define serial_cris_release_port_dummy serial_cris_stop_tx_dummy
4130 +#define serial_cris_request_port_dummy serial_cris_startup_dummy
4131 +
4132 +static const struct uart_ops serial_cris_dummy_pops = {
4133 + /*
4134 + * We *could* save one or two of those with different
4135 + * signature by casting and knowledge of the ABI, but it's
4136 + * just not worth the maintenance headache.
4137 + * For the ones we don't define here, the default (usually meaning
4138 + * "unimplemented") makes sense.
4139 + */
4140 + .tx_empty = serial_cris_tx_empty_dummy,
4141 + .set_mctrl = serial_cris_set_mctrl_dummy,
4142 + .get_mctrl = serial_cris_get_mctrl_dummy,
4143 + .stop_tx = serial_cris_stop_tx_dummy,
4144 + .start_tx = serial_cris_start_tx_dummy,
4145 + .stop_rx = serial_cris_stop_rx_dummy,
4146 + .enable_ms = serial_cris_enable_ms_dummy,
4147 + .break_ctl = serial_cris_break_ctl_dummy,
4148 + .startup = serial_cris_startup_dummy,
4149 + .shutdown = serial_cris_shutdown_dummy,
4150 + .set_termios = serial_cris_set_termios_dummy,
4151 +
4152 + /* This one we keep the same. */
4153 + .type = serial_cris_type,
4154 +
4155 + .release_port = serial_cris_release_port_dummy,
4156 + .request_port = serial_cris_request_port_dummy,
4157 +
4158 + /*
4159 + * This one we keep the same too, as long as it doesn't do
4160 + * anything else but to set the type.
4161 + */
4162 + .config_port = serial_cris_config_port,
4163 +};
4164 +
4165 +static void cris_serial_port_init(struct uart_port *port, int line)
4166 +{
4167 + struct uart_cris_port *up = (struct uart_cris_port *)port;
4168 + static int first = 1;
4169 +
4170 + if (up->initialized)
4171 + return;
4172 + up->initialized = 1;
4173 + port->line = line;
4174 + spin_lock_init(&port->lock);
4175 + port->ops =
4176 + up->regi_ser == 0 ? &serial_cris_dummy_pops :
4177 + &serial_cris_pops;
4178 + port->irq = up->irq;
4179 + port->iobase = up->regi_ser ? up->regi_ser : 1;
4180 + port->uartclk = 29493000;
4181 +
4182 + /*
4183 + * We can't fit any more than 255 here (unsigned char), though
4184 + * actually UART_XMIT_SIZE characters could be pending output (if it
4185 + * wasn't for the single test in transmit_chars_dma). At time of this
4186 + * writing, the definition of "fifosize" is here the amount of
4187 + * characters that can be pending output after a start_tx call until
4188 + * tx_empty returns 1: see serial_core.c:uart_wait_until_sent. This
4189 + * matters for timeout calculations unfortunately, but keeping larger
4190 + * amounts at the DMA wouldn't win much so let's just play nice.
4191 + */
4192 + port->fifosize = 255;
4193 + port->flags = UPF_BOOT_AUTOCONF;
4194 +
4195 +#ifdef CONFIG_ETRAX_RS485
4196 + /* Set sane defaults. */
4197 + up->rs485.rts_on_send = 0;
4198 + up->rs485.rts_after_sent = 1;
4199 + up->rs485.delay_rts_before_send = 0;
4200 + if (up->port_type > TYPE_232)
4201 + up->rs485.enabled = 1;
4202 + else
4203 + up->rs485.enabled = 0;
4204 +#endif
4205 +
4206 + if (first) {
4207 + first = 0;
4208 +#ifdef CONFIG_ETRAX_SERIAL_PORT0
4209 + SETUP_PINS(0);
4210 +#endif
4211 +#ifdef CONFIG_ETRAX_SERIAL_PORT1
4212 + SETUP_PINS(1);
4213 +#endif
4214 +#ifdef CONFIG_ETRAX_SERIAL_PORT2
4215 + SETUP_PINS(2);
4216 +#endif
4217 +#ifdef CONFIG_ETRAX_SERIAL_PORT3
4218 + SETUP_PINS(3);
4219 +#endif
4220 + }
4221 +}
4222 +
4223 +static int __init serial_cris_init(void)
4224 +{
4225 + int ret, i;
4226 + reg_ser_rw_rec_ctrl rec_ctrl;
4227 + printk(KERN_INFO "Serial: CRISv32 driver $Revision: 1.78 $ ");
4228 +
4229 + ret = uart_register_driver(&serial_cris_driver);
4230 + if (ret)
4231 + goto out;
4232 +
4233 + for (i = 0; i < UART_NR; i++) {
4234 + if (serial_cris_ports[i].used) {
4235 +#ifdef CONFIG_ETRAX_RS485
4236 + /* Make sure that the RTS pin stays low when allocating
4237 + * pins for a port in 485 mode.
4238 + */
4239 + if (serial_cris_ports[i].port_type > TYPE_232) {
4240 + rec_ctrl = REG_RD(ser, serial_cris_ports[i].regi_ser, rw_rec_ctrl);
4241 + rec_ctrl.rts_n = regk_ser_active;
4242 + REG_WR(ser, serial_cris_ports[i].regi_ser, rw_rec_ctrl, rec_ctrl);
4243 + }
4244 +#endif
4245 + switch (serial_cris_ports[i].regi_ser) {
4246 + case regi_ser1:
4247 + if (crisv32_pinmux_alloc_fixed(pinmux_ser1)) {
4248 + printk("Failed to allocate pins for ser1, disable port\n");
4249 + serial_cris_ports[i].used = 0;
4250 + continue;
4251 + }
4252 + break;
4253 + case regi_ser2:
4254 + if (crisv32_pinmux_alloc_fixed(pinmux_ser2)) {
4255 + printk("Failed to allocate pins for ser2, disable port\n");
4256 + serial_cris_ports[i].used = 0;
4257 + continue;
4258 + }
4259 + break;
4260 + case regi_ser3:
4261 + if (crisv32_pinmux_alloc_fixed(pinmux_ser3)) {
4262 + printk("Failed to allocate pins for ser3, disable port\n");
4263 + serial_cris_ports[i].used = 0;
4264 + continue;
4265 + }
4266 + break;
4267 + }
4268 +
4269 + struct uart_port *port = &serial_cris_ports[i].port;
4270 + cris_console.index = i;
4271 + cris_serial_port_init(port, i);
4272 + uart_add_one_port(&serial_cris_driver, port);
4273 + }
4274 + }
4275 +
4276 +out:
4277 + return ret;
4278 +}
4279 +
4280 +static void __exit serial_cris_exit(void)
4281 +{
4282 + int i;
4283 + for (i = 0; i < UART_NR; i++)
4284 + if (serial_cris_ports[i].used) {
4285 + switch (serial_cris_ports[i].regi_ser) {
4286 + case regi_ser1:
4287 + crisv32_pinmux_dealloc_fixed(pinmux_ser1);
4288 + break;
4289 + case regi_ser2:
4290 + crisv32_pinmux_dealloc_fixed(pinmux_ser2);
4291 + break;
4292 + case regi_ser3:
4293 + crisv32_pinmux_dealloc_fixed(pinmux_ser3);
4294 + break;
4295 + }
4296 + uart_remove_one_port(&serial_cris_driver,
4297 + &serial_cris_ports[i].port);
4298 + }
4299 + uart_unregister_driver(&serial_cris_driver);
4300 +}
4301 +
4302 +module_init(serial_cris_init);
4303 +module_exit(serial_cris_exit);
4304 --- linux-2.6.19.2.orig/drivers/usb/host/hc_crisv10.c 2007-01-10 20:10:37.000000000 +0100
4305 +++ linux-2.6.19.2.dev/drivers/usb/host/hc-crisv10.c 2007-02-26 20:58:29.000000000 +0100
4306 @@ -1,219 +1,51 @@
4307 /*
4308 - * usb-host.c: ETRAX 100LX USB Host Controller Driver (HCD)
4309 *
4310 - * Copyright (c) 2002, 2003 Axis Communications AB.
4311 + * ETRAX 100LX USB Host Controller Driver
4312 + *
4313 + * Copyright (C) 2005, 2006 Axis Communications AB
4314 + *
4315 + * Author: Konrad Eriksson <konrad.eriksson@axis.se>
4316 + *
4317 */
4318
4319 +#include <linux/module.h>
4320 #include <linux/kernel.h>
4321 -#include <linux/delay.h>
4322 -#include <linux/ioport.h>
4323 -#include <linux/sched.h>
4324 -#include <linux/slab.h>
4325 -#include <linux/errno.h>
4326 -#include <linux/unistd.h>
4327 -#include <linux/interrupt.h>
4328 #include <linux/init.h>
4329 -#include <linux/list.h>
4330 +#include <linux/moduleparam.h>
4331 #include <linux/spinlock.h>
4332 +#include <linux/usb.h>
4333 +#include <linux/platform_device.h>
4334
4335 -#include <asm/uaccess.h>
4336 #include <asm/io.h>
4337 #include <asm/irq.h>
4338 -#include <asm/dma.h>
4339 -#include <asm/system.h>
4340 -#include <asm/arch/svinto.h>
4341 +#include <asm/arch/dma.h>
4342 +#include <asm/arch/io_interface_mux.h>
4343
4344 -#include <linux/usb.h>
4345 -/* Ugly include because we don't live with the other host drivers. */
4346 -#include <../drivers/usb/core/hcd.h>
4347 -#include <../drivers/usb/core/usb.h>
4348 -
4349 -#include "hc_crisv10.h"
4350 +#include "../core/hcd.h"
4351 +#include "../core/hub.h"
4352 +#include "hc-crisv10.h"
4353 +#include "hc-cris-dbg.h"
4354 +
4355 +
4356 +/***************************************************************************/
4357 +/***************************************************************************/
4358 +/* Host Controller settings */
4359 +/***************************************************************************/
4360 +/***************************************************************************/
4361 +
4362 +#define VERSION "1.00"
4363 +#define COPYRIGHT "(c) 2005, 2006 Axis Communications AB"
4364 +#define DESCRIPTION "ETRAX 100LX USB Host Controller"
4365
4366 #define ETRAX_USB_HC_IRQ USB_HC_IRQ_NBR
4367 #define ETRAX_USB_RX_IRQ USB_DMA_RX_IRQ_NBR
4368 #define ETRAX_USB_TX_IRQ USB_DMA_TX_IRQ_NBR
4369
4370 -static const char *usb_hcd_version = "$Revision: 1.2 $";
4371 -
4372 -#undef KERN_DEBUG
4373 -#define KERN_DEBUG ""
4374 -
4375 -
4376 -#undef USB_DEBUG_RH
4377 -#undef USB_DEBUG_EPID
4378 -#undef USB_DEBUG_SB
4379 -#undef USB_DEBUG_DESC
4380 -#undef USB_DEBUG_URB
4381 -#undef USB_DEBUG_TRACE
4382 -#undef USB_DEBUG_BULK
4383 -#undef USB_DEBUG_CTRL
4384 -#undef USB_DEBUG_INTR
4385 -#undef USB_DEBUG_ISOC
4386 -
4387 -#ifdef USB_DEBUG_RH
4388 -#define dbg_rh(format, arg...) printk(KERN_DEBUG __FILE__ ": (RH) " format "\n" , ## arg)
4389 -#else
4390 -#define dbg_rh(format, arg...) do {} while (0)
4391 -#endif
4392 -
4393 -#ifdef USB_DEBUG_EPID
4394 -#define dbg_epid(format, arg...) printk(KERN_DEBUG __FILE__ ": (EPID) " format "\n" , ## arg)
4395 -#else
4396 -#define dbg_epid(format, arg...) do {} while (0)
4397 -#endif
4398 -
4399 -#ifdef USB_DEBUG_SB
4400 -#define dbg_sb(format, arg...) printk(KERN_DEBUG __FILE__ ": (SB) " format "\n" , ## arg)
4401 -#else
4402 -#define dbg_sb(format, arg...) do {} while (0)
4403 -#endif
4404 -
4405 -#ifdef USB_DEBUG_CTRL
4406 -#define dbg_ctrl(format, arg...) printk(KERN_DEBUG __FILE__ ": (CTRL) " format "\n" , ## arg)
4407 -#else
4408 -#define dbg_ctrl(format, arg...) do {} while (0)
4409 -#endif
4410 -
4411 -#ifdef USB_DEBUG_BULK
4412 -#define dbg_bulk(format, arg...) printk(KERN_DEBUG __FILE__ ": (BULK) " format "\n" , ## arg)
4413 -#else
4414 -#define dbg_bulk(format, arg...) do {} while (0)
4415 -#endif
4416 -
4417 -#ifdef USB_DEBUG_INTR
4418 -#define dbg_intr(format, arg...) printk(KERN_DEBUG __FILE__ ": (INTR) " format "\n" , ## arg)
4419 -#else
4420 -#define dbg_intr(format, arg...) do {} while (0)
4421 -#endif
4422 -
4423 -#ifdef USB_DEBUG_ISOC
4424 -#define dbg_isoc(format, arg...) printk(KERN_DEBUG __FILE__ ": (ISOC) " format "\n" , ## arg)
4425 -#else
4426 -#define dbg_isoc(format, arg...) do {} while (0)
4427 -#endif
4428 -
4429 -#ifdef USB_DEBUG_TRACE
4430 -#define DBFENTER (printk(": Entering: %s\n", __FUNCTION__))
4431 -#define DBFEXIT (printk(": Exiting: %s\n", __FUNCTION__))
4432 -#else
4433 -#define DBFENTER do {} while (0)
4434 -#define DBFEXIT do {} while (0)
4435 -#endif
4436 -
4437 -#define usb_pipeslow(pipe) (((pipe) >> 26) & 1)
4438 -
4439 -/*-------------------------------------------------------------------
4440 - Virtual Root Hub
4441 - -------------------------------------------------------------------*/
4442 -
4443 -static __u8 root_hub_dev_des[] =
4444 -{
4445 - 0x12, /* __u8 bLength; */
4446 - 0x01, /* __u8 bDescriptorType; Device */
4447 - 0x00, /* __le16 bcdUSB; v1.0 */
4448 - 0x01,
4449 - 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
4450 - 0x00, /* __u8 bDeviceSubClass; */
4451 - 0x00, /* __u8 bDeviceProtocol; */
4452 - 0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
4453 - 0x00, /* __le16 idVendor; */
4454 - 0x00,
4455 - 0x00, /* __le16 idProduct; */
4456 - 0x00,
4457 - 0x00, /* __le16 bcdDevice; */
4458 - 0x00,
4459 - 0x00, /* __u8 iManufacturer; */
4460 - 0x02, /* __u8 iProduct; */
4461 - 0x01, /* __u8 iSerialNumber; */
4462 - 0x01 /* __u8 bNumConfigurations; */
4463 -};
4464 -
4465 -/* Configuration descriptor */
4466 -static __u8 root_hub_config_des[] =
4467 -{
4468 - 0x09, /* __u8 bLength; */
4469 - 0x02, /* __u8 bDescriptorType; Configuration */
4470 - 0x19, /* __le16 wTotalLength; */
4471 - 0x00,
4472 - 0x01, /* __u8 bNumInterfaces; */
4473 - 0x01, /* __u8 bConfigurationValue; */
4474 - 0x00, /* __u8 iConfiguration; */
4475 - 0x40, /* __u8 bmAttributes; Bit 7: Bus-powered */
4476 - 0x00, /* __u8 MaxPower; */
4477 -
4478 - /* interface */
4479 - 0x09, /* __u8 if_bLength; */
4480 - 0x04, /* __u8 if_bDescriptorType; Interface */
4481 - 0x00, /* __u8 if_bInterfaceNumber; */
4482 - 0x00, /* __u8 if_bAlternateSetting; */
4483 - 0x01, /* __u8 if_bNumEndpoints; */
4484 - 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
4485 - 0x00, /* __u8 if_bInterfaceSubClass; */
4486 - 0x00, /* __u8 if_bInterfaceProtocol; */
4487 - 0x00, /* __u8 if_iInterface; */
4488 -
4489 - /* endpoint */
4490 - 0x07, /* __u8 ep_bLength; */
4491 - 0x05, /* __u8 ep_bDescriptorType; Endpoint */
4492 - 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
4493 - 0x03, /* __u8 ep_bmAttributes; Interrupt */
4494 - 0x08, /* __le16 ep_wMaxPacketSize; 8 Bytes */
4495 - 0x00,
4496 - 0xff /* __u8 ep_bInterval; 255 ms */
4497 -};
4498 -
4499 -static __u8 root_hub_hub_des[] =
4500 -{
4501 - 0x09, /* __u8 bLength; */
4502 - 0x29, /* __u8 bDescriptorType; Hub-descriptor */
4503 - 0x02, /* __u8 bNbrPorts; */
4504 - 0x00, /* __u16 wHubCharacteristics; */
4505 - 0x00,
4506 - 0x01, /* __u8 bPwrOn2pwrGood; 2ms */
4507 - 0x00, /* __u8 bHubContrCurrent; 0 mA */
4508 - 0x00, /* __u8 DeviceRemovable; *** 7 Ports max *** */
4509 - 0xff /* __u8 PortPwrCtrlMask; *** 7 ports max *** */
4510 -};
4511 -
4512 -static DEFINE_TIMER(bulk_start_timer, NULL, 0, 0);
4513 -static DEFINE_TIMER(bulk_eot_timer, NULL, 0, 0);
4514 -
4515 -/* We want the start timer to expire before the eot timer, because the former might start
4516 - traffic, thus making it unnecessary for the latter to time out. */
4517 -#define BULK_START_TIMER_INTERVAL (HZ/10) /* 100 ms */
4518 -#define BULK_EOT_TIMER_INTERVAL (HZ/10+2) /* 120 ms */
4519 -
4520 -#define OK(x) len = (x); dbg_rh("OK(%d): line: %d", x, __LINE__); break
4521 -#define CHECK_ALIGN(x) if (((__u32)(x)) & 0x00000003) \
4522 -{panic("Alignment check (DWORD) failed at %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);}
4523 -
4524 -#define SLAB_FLAG (in_interrupt() ? SLAB_ATOMIC : SLAB_KERNEL)
4525 -#define KMALLOC_FLAG (in_interrupt() ? GFP_ATOMIC : GFP_KERNEL)
4526 -
4527 -/* Most helpful debugging aid */
4528 -#define assert(expr) ((void) ((expr) ? 0 : (err("assert failed at line %d",__LINE__))))
4529 -
4530 -/* Alternative assert define which stops after a failed assert. */
4531 -/*
4532 -#define assert(expr) \
4533 -{ \
4534 - if (!(expr)) { \
4535 - err("assert failed at line %d",__LINE__); \
4536 - while (1); \
4537 - } \
4538 -}
4539 -*/
4540 -
4541 +/* Number of physical ports in Etrax 100LX */
4542 +#define USB_ROOT_HUB_PORTS 2
4543
4544 -/* FIXME: Should RX_BUF_SIZE be a config option, or maybe we should adjust it dynamically?
4545 - To adjust it dynamically we would have to get an interrupt when we reach the end
4546 - of the rx descriptor list, or when we get close to the end, and then allocate more
4547 - descriptors. */
4548 -
4549 -#define NBR_OF_RX_DESC 512
4550 -#define RX_DESC_BUF_SIZE 1024
4551 -#define RX_BUF_SIZE (NBR_OF_RX_DESC * RX_DESC_BUF_SIZE)
4552 +const char hc_name[] = "hc-crisv10";
4553 +const char product_desc[] = DESCRIPTION;
4554
4555 /* The number of epids is, among other things, used for pre-allocating
4556 ctrl, bulk and isoc EP descriptors (one for each epid).
4557 @@ -221,4332 +53,4632 @@
4558 #define NBR_OF_EPIDS 32
4559
4560 /* Support interrupt traffic intervals up to 128 ms. */
4561 -#define MAX_INTR_INTERVAL 128
4562 +#define MAX_INTR_INTERVAL 128
4563
4564 -/* If periodic traffic (intr or isoc) is to be used, then one entry in the EP table
4565 - must be "invalid". By this we mean that we shouldn't care about epid attentions
4566 - for this epid, or at least handle them differently from epid attentions for "valid"
4567 - epids. This define determines which one to use (don't change it). */
4568 -#define INVALID_EPID 31
4569 +/* If periodic traffic (intr or isoc) is to be used, then one entry in the EP
4570 + table must be "invalid". By this we mean that we shouldn't care about epid
4571 + attentions for this epid, or at least handle them differently from epid
4572 + attentions for "valid" epids. This define determines which one to use
4573 + (don't change it). */
4574 +#define INVALID_EPID 31
4575 /* A special epid for the bulk dummys. */
4576 -#define DUMMY_EPID 30
4577 -
4578 -/* This is just a software cache for the valid entries in R_USB_EPT_DATA. */
4579 -static __u32 epid_usage_bitmask;
4580 -
4581 -/* A bitfield to keep information on in/out traffic is needed to uniquely identify
4582 - an endpoint on a device, since the most significant bit which indicates traffic
4583 - direction is lacking in the ep_id field (ETRAX epids can handle both in and
4584 - out traffic on endpoints that are otherwise identical). The USB framework, however,
4585 - relies on them to be handled separately. For example, bulk IN and OUT urbs cannot
4586 - be queued in the same list, since they would block each other. */
4587 -static __u32 epid_out_traffic;
4588 -
4589 -/* DMA IN cache bug. Align the DMA IN buffers to 32 bytes, i.e. a cache line.
4590 - Since RX_DESC_BUF_SIZE is 1024 is a multiple of 32, all rx buffers will be cache aligned. */
4591 -static volatile unsigned char RxBuf[RX_BUF_SIZE] __attribute__ ((aligned (32)));
4592 -static volatile USB_IN_Desc_t RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned (4)));
4593 -
4594 -/* Pointers into RxDescList. */
4595 -static volatile USB_IN_Desc_t *myNextRxDesc;
4596 -static volatile USB_IN_Desc_t *myLastRxDesc;
4597 -static volatile USB_IN_Desc_t *myPrevRxDesc;
4598 -
4599 -/* EP descriptors must be 32-bit aligned. */
4600 -static volatile USB_EP_Desc_t TxCtrlEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
4601 -static volatile USB_EP_Desc_t TxBulkEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
4602 -/* After each enabled bulk EP (IN or OUT) we put two disabled EP descriptors with the eol flag set,
4603 - causing the DMA to stop the DMA channel. The first of these two has the intr flag set, which
4604 - gives us a dma8_sub0_descr interrupt. When we receive this, we advance the DMA one step in the
4605 - EP list and then restart the bulk channel, thus forcing a switch between bulk EP descriptors
4606 - in each frame. */
4607 -static volatile USB_EP_Desc_t TxBulkDummyEPList[NBR_OF_EPIDS][2] __attribute__ ((aligned (4)));
4608 -
4609 -static volatile USB_EP_Desc_t TxIsocEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
4610 -static volatile USB_SB_Desc_t TxIsocSB_zout __attribute__ ((aligned (4)));
4611 -
4612 -static volatile USB_EP_Desc_t TxIntrEPList[MAX_INTR_INTERVAL] __attribute__ ((aligned (4)));
4613 -static volatile USB_SB_Desc_t TxIntrSB_zout __attribute__ ((aligned (4)));
4614 -
4615 -/* A zout transfer makes a memory access at the address of its buf pointer, which means that setting
4616 - this buf pointer to 0 will cause an access to the flash. In addition to this, setting sw_len to 0
4617 - results in a 16/32 bytes (depending on DMA burst size) transfer. Instead, we set it to 1, and point
4618 - it to this buffer. */
4619 -static int zout_buffer[4] __attribute__ ((aligned (4)));
4620 +#define DUMMY_EPID 30
4621
4622 -/* Cache for allocating new EP and SB descriptors. */
4623 -static kmem_cache_t *usb_desc_cache;
4624 +/* Module settings */
4625
4626 -/* Cache for the registers allocated in the top half. */
4627 -static kmem_cache_t *top_half_reg_cache;
4628 +MODULE_DESCRIPTION(DESCRIPTION);
4629 +MODULE_LICENSE("GPL");
4630 +MODULE_AUTHOR("Konrad Eriksson <konrad.eriksson@axis.se>");
4631
4632 -/* Cache for the data allocated in the isoc descr top half. */
4633 -static kmem_cache_t *isoc_compl_cache;
4634
4635 -static struct usb_bus *etrax_usb_bus;
4636 +/* Module parameters */
4637
4638 -/* This is a circular (double-linked) list of the active urbs for each epid.
4639 - The head is never removed, and new urbs are linked onto the list as
4640 - urb_entry_t elements. Don't reference urb_list directly; use the wrapper
4641 - functions instead. Note that working with these lists might require spinlock
4642 - protection. */
4643 -static struct list_head urb_list[NBR_OF_EPIDS];
4644 +/* 0 = No ports enabled
4645 + 1 = Only port 1 enabled (on board ethernet on devboard)
4646 + 2 = Only port 2 enabled (external connector on devboard)
4647 + 3 = Both ports enabled
4648 +*/
4649 +static unsigned int ports = 3;
4650 +module_param(ports, uint, S_IRUGO);
4651 +MODULE_PARM_DESC(ports, "Bitmask indicating USB ports to use");
4652
4653 -/* Read about the need and usage of this lock in submit_ctrl_urb. */
4654 -static spinlock_t urb_list_lock;
4655
4656 -/* Used when unlinking asynchronously. */
4657 -static struct list_head urb_unlink_list;
4658 +/***************************************************************************/
4659 +/***************************************************************************/
4660 +/* Shared global variables for this module */
4661 +/***************************************************************************/
4662 +/***************************************************************************/
4663
4664 -/* for returning string descriptors in UTF-16LE */
4665 -static int ascii2utf (char *ascii, __u8 *utf, int utfmax)
4666 -{
4667 - int retval;
4668 +/* EP descriptor lists for non period transfers. Must be 32-bit aligned. */
4669 +static volatile struct USB_EP_Desc TxBulkEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
4670
4671 - for (retval = 0; *ascii && utfmax > 1; utfmax -= 2, retval += 2) {
4672 - *utf++ = *ascii++ & 0x7f;
4673 - *utf++ = 0;
4674 - }
4675 - return retval;
4676 -}
4677 +static volatile struct USB_EP_Desc TxCtrlEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
4678
4679 -static int usb_root_hub_string (int id, int serial, char *type, __u8 *data, int len)
4680 -{
4681 - char buf [30];
4682 +/* EP descriptor lists for period transfers. Must be 32-bit aligned. */
4683 +static volatile struct USB_EP_Desc TxIntrEPList[MAX_INTR_INTERVAL] __attribute__ ((aligned (4)));
4684 +static volatile struct USB_SB_Desc TxIntrSB_zout __attribute__ ((aligned (4)));
4685
4686 - // assert (len > (2 * (sizeof (buf) + 1)));
4687 - // assert (strlen (type) <= 8);
4688 +static volatile struct USB_EP_Desc TxIsocEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
4689 +static volatile struct USB_SB_Desc TxIsocSB_zout __attribute__ ((aligned (4)));
4690
4691 - // language ids
4692 - if (id == 0) {
4693 - *data++ = 4; *data++ = 3; /* 4 bytes data */
4694 - *data++ = 0; *data++ = 0; /* some language id */
4695 - return 4;
4696 -
4697 - // serial number
4698 - } else if (id == 1) {
4699 - sprintf (buf, "%x", serial);
4700 -
4701 - // product description
4702 - } else if (id == 2) {
4703 - sprintf (buf, "USB %s Root Hub", type);
4704 -
4705 - // id 3 == vendor description
4706 -
4707 - // unsupported IDs --> "stall"
4708 - } else
4709 - return 0;
4710 -
4711 - data [0] = 2 + ascii2utf (buf, data + 2, len - 2);
4712 - data [1] = 3;
4713 - return data [0];
4714 -}
4715 +static volatile struct USB_SB_Desc TxIsocSBList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
4716
4717 -/* Wrappers around the list functions (include/linux/list.h). */
4718 +/* After each enabled bulk EP IN we put two disabled EP descriptors with the eol flag set,
4719 + causing the DMA to stop the DMA channel. The first of these two has the intr flag set, which
4720 + gives us a dma8_sub0_descr interrupt. When we receive this, we advance the DMA one step in the
4721 + EP list and then restart the bulk channel, thus forcing a switch between bulk EP descriptors
4722 + in each frame. */
4723 +static volatile struct USB_EP_Desc TxBulkDummyEPList[NBR_OF_EPIDS][2] __attribute__ ((aligned (4)));
4724
4725 -static inline int urb_list_empty(int epid)
4726 +/* List of URB pointers, where each points to the active URB for a epid.
4727 + For Bulk, Ctrl and Intr this means which URB that currently is added to
4728 + DMA lists (Isoc URBs are all directly added to DMA lists). As soon as
4729 + URB has completed is the queue examined and the first URB in queue is
4730 + removed and moved to the activeUrbList while its state change to STARTED and
4731 + its transfer(s) gets added to DMA list (exception Isoc where URBs enter
4732 + state STARTED directly and added transfers added to DMA lists). */
4733 +static struct urb *activeUrbList[NBR_OF_EPIDS];
4734 +
4735 +/* Additional software state info for each epid */
4736 +static struct etrax_epid epid_state[NBR_OF_EPIDS];
4737 +
4738 +/* Timer handles for bulk traffic timer used to avoid DMA bug where DMA stops
4739 + even if there is new data waiting to be processed */
4740 +static struct timer_list bulk_start_timer = TIMER_INITIALIZER(NULL, 0, 0);
4741 +static struct timer_list bulk_eot_timer = TIMER_INITIALIZER(NULL, 0, 0);
4742 +
4743 +/* We want the start timer to expire before the eot timer, because the former
4744 + might start traffic, thus making it unnecessary for the latter to time
4745 + out. */
4746 +#define BULK_START_TIMER_INTERVAL (HZ/50) /* 20 ms */
4747 +#define BULK_EOT_TIMER_INTERVAL (HZ/16) /* 60 ms */
4748 +
4749 +/* Delay before a URB completion happen when it's scheduled to be delayed */
4750 +#define LATER_TIMER_DELAY (HZ/50) /* 20 ms */
4751 +
4752 +/* Simplifying macros for checking software state info of a epid */
4753 +/* ----------------------------------------------------------------------- */
4754 +#define epid_inuse(epid) epid_state[epid].inuse
4755 +#define epid_out_traffic(epid) epid_state[epid].out_traffic
4756 +#define epid_isoc(epid) (epid_state[epid].type == PIPE_ISOCHRONOUS ? 1 : 0)
4757 +#define epid_intr(epid) (epid_state[epid].type == PIPE_INTERRUPT ? 1 : 0)
4758 +
4759 +
4760 +/***************************************************************************/
4761 +/***************************************************************************/
4762 +/* DEBUG FUNCTIONS */
4763 +/***************************************************************************/
4764 +/***************************************************************************/
4765 +/* Note that these functions are always available in their "__" variants,
4766 + for use in error situations. The "__" missing variants are controlled by
4767 + the USB_DEBUG_DESC/USB_DEBUG_URB macros. */
4768 +static void __dump_urb(struct urb* purb)
4769 {
4770 - return list_empty(&urb_list[epid]);
4771 + struct crisv10_urb_priv *urb_priv = purb->hcpriv;
4772 + int urb_num = -1;
4773 + if(urb_priv) {
4774 + urb_num = urb_priv->urb_num;
4775 + }
4776 + printk("\nURB:0x%x[%d]\n", (unsigned int)purb, urb_num);
4777 + printk("dev :0x%08lx\n", (unsigned long)purb->dev);
4778 + printk("pipe :0x%08x\n", purb->pipe);
4779 + printk("status :%d\n", purb->status);
4780 + printk("transfer_flags :0x%08x\n", purb->transfer_flags);
4781 + printk("transfer_buffer :0x%08lx\n", (unsigned long)purb->transfer_buffer);
4782 + printk("transfer_buffer_length:%d\n", purb->transfer_buffer_length);
4783 + printk("actual_length :%d\n", purb->actual_length);
4784 + printk("setup_packet :0x%08lx\n", (unsigned long)purb->setup_packet);
4785 + printk("start_frame :%d\n", purb->start_frame);
4786 + printk("number_of_packets :%d\n", purb->number_of_packets);
4787 + printk("interval :%d\n", purb->interval);
4788 + printk("error_count :%d\n", purb->error_count);
4789 + printk("context :0x%08lx\n", (unsigned long)purb->context);
4790 + printk("complete :0x%08lx\n\n", (unsigned long)purb->complete);
4791 +}
4792 +
4793 +static void __dump_in_desc(volatile struct USB_IN_Desc *in)
4794 +{
4795 + printk("\nUSB_IN_Desc at 0x%08lx\n", (unsigned long)in);
4796 + printk(" sw_len : 0x%04x (%d)\n", in->sw_len, in->sw_len);
4797 + printk(" command : 0x%04x\n", in->command);
4798 + printk(" next : 0x%08lx\n", in->next);
4799 + printk(" buf : 0x%08lx\n", in->buf);
4800 + printk(" hw_len : 0x%04x (%d)\n", in->hw_len, in->hw_len);
4801 + printk(" status : 0x%04x\n\n", in->status);
4802 +}
4803 +
4804 +static void __dump_sb_desc(volatile struct USB_SB_Desc *sb)
4805 +{
4806 + char tt = (sb->command & 0x30) >> 4;
4807 + char *tt_string;
4808 +
4809 + switch (tt) {
4810 + case 0:
4811 + tt_string = "zout";
4812 + break;
4813 + case 1:
4814 + tt_string = "in";
4815 + break;
4816 + case 2:
4817 + tt_string = "out";
4818 + break;
4819 + case 3:
4820 + tt_string = "setup";
4821 + break;
4822 + default:
4823 + tt_string = "unknown (weird)";
4824 + }
4825 +
4826 + printk(" USB_SB_Desc at 0x%08lx ", (unsigned long)sb);
4827 + printk(" command:0x%04x (", sb->command);
4828 + printk("rem:%d ", (sb->command & 0x3f00) >> 8);
4829 + printk("full:%d ", (sb->command & 0x40) >> 6);
4830 + printk("tt:%d(%s) ", tt, tt_string);
4831 + printk("intr:%d ", (sb->command & 0x8) >> 3);
4832 + printk("eot:%d ", (sb->command & 0x2) >> 1);
4833 + printk("eol:%d)", sb->command & 0x1);
4834 + printk(" sw_len:0x%04x(%d)", sb->sw_len, sb->sw_len);
4835 + printk(" next:0x%08lx", sb->next);
4836 + printk(" buf:0x%08lx\n", sb->buf);
4837 +}
4838 +
4839 +
4840 +static void __dump_ep_desc(volatile struct USB_EP_Desc *ep)
4841 +{
4842 + printk("USB_EP_Desc at 0x%08lx ", (unsigned long)ep);
4843 + printk(" command:0x%04x (", ep->command);
4844 + printk("ep_id:%d ", (ep->command & 0x1f00) >> 8);
4845 + printk("enable:%d ", (ep->command & 0x10) >> 4);
4846 + printk("intr:%d ", (ep->command & 0x8) >> 3);
4847 + printk("eof:%d ", (ep->command & 0x2) >> 1);
4848 + printk("eol:%d)", ep->command & 0x1);
4849 + printk(" hw_len:0x%04x(%d)", ep->hw_len, ep->hw_len);
4850 + printk(" next:0x%08lx", ep->next);
4851 + printk(" sub:0x%08lx\n", ep->sub);
4852 }
4853
4854 -/* Returns first urb for this epid, or NULL if list is empty. */
4855 -static inline struct urb *urb_list_first(int epid)
4856 +static inline void __dump_ep_list(int pipe_type)
4857 {
4858 - struct urb *first_urb = 0;
4859 + volatile struct USB_EP_Desc *ep;
4860 + volatile struct USB_EP_Desc *first_ep;
4861 + volatile struct USB_SB_Desc *sb;
4862 +
4863 + switch (pipe_type)
4864 + {
4865 + case PIPE_BULK:
4866 + first_ep = &TxBulkEPList[0];
4867 + break;
4868 + case PIPE_CONTROL:
4869 + first_ep = &TxCtrlEPList[0];
4870 + break;
4871 + case PIPE_INTERRUPT:
4872 + first_ep = &TxIntrEPList[0];
4873 + break;
4874 + case PIPE_ISOCHRONOUS:
4875 + first_ep = &TxIsocEPList[0];
4876 + break;
4877 + default:
4878 + warn("Cannot dump unknown traffic type");
4879 + return;
4880 + }
4881 + ep = first_ep;
4882 +
4883 + printk("\n\nDumping EP list...\n\n");
4884 +
4885 + do {
4886 + __dump_ep_desc(ep);
4887 + /* Cannot phys_to_virt on 0 as it turns into 80000000, which is != 0. */
4888 + sb = ep->sub ? phys_to_virt(ep->sub) : 0;
4889 + while (sb) {
4890 + __dump_sb_desc(sb);
4891 + sb = sb->next ? phys_to_virt(sb->next) : 0;
4892 + }
4893 + ep = (volatile struct USB_EP_Desc *)(phys_to_virt(ep->next));
4894
4895 - if (!urb_list_empty(epid)) {
4896 - /* Get the first urb (i.e. head->next). */
4897 - urb_entry_t *urb_entry = list_entry((&urb_list[epid])->next, urb_entry_t, list);
4898 - first_urb = urb_entry->urb;
4899 - }
4900 - return first_urb;
4901 + } while (ep != first_ep);
4902 }
4903
4904 -/* Adds an urb_entry last in the list for this epid. */
4905 -static inline void urb_list_add(struct urb *urb, int epid)
4906 +static inline void __dump_ept_data(int epid)
4907 {
4908 - urb_entry_t *urb_entry = (urb_entry_t *)kmalloc(sizeof(urb_entry_t), KMALLOC_FLAG);
4909 - assert(urb_entry);
4910 + unsigned long flags;
4911 + __u32 r_usb_ept_data;
4912
4913 - urb_entry->urb = urb;
4914 - list_add_tail(&urb_entry->list, &urb_list[epid]);
4915 + if (epid < 0 || epid > 31) {
4916 + printk("Cannot dump ept data for invalid epid %d\n", epid);
4917 + return;
4918 + }
4919 +
4920 + local_irq_save(flags);
4921 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
4922 + nop();
4923 + r_usb_ept_data = *R_USB_EPT_DATA;
4924 + local_irq_restore(flags);
4925 +
4926 + printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", r_usb_ept_data, epid);
4927 + if (r_usb_ept_data == 0) {
4928 + /* No need for more detailed printing. */
4929 + return;
4930 + }
4931 + printk(" valid : %d\n", (r_usb_ept_data & 0x80000000) >> 31);
4932 + printk(" hold : %d\n", (r_usb_ept_data & 0x40000000) >> 30);
4933 + printk(" error_count_in : %d\n", (r_usb_ept_data & 0x30000000) >> 28);
4934 + printk(" t_in : %d\n", (r_usb_ept_data & 0x08000000) >> 27);
4935 + printk(" low_speed : %d\n", (r_usb_ept_data & 0x04000000) >> 26);
4936 + printk(" port : %d\n", (r_usb_ept_data & 0x03000000) >> 24);
4937 + printk(" error_code : %d\n", (r_usb_ept_data & 0x00c00000) >> 22);
4938 + printk(" t_out : %d\n", (r_usb_ept_data & 0x00200000) >> 21);
4939 + printk(" error_count_out : %d\n", (r_usb_ept_data & 0x00180000) >> 19);
4940 + printk(" max_len : %d\n", (r_usb_ept_data & 0x0003f800) >> 11);
4941 + printk(" ep : %d\n", (r_usb_ept_data & 0x00000780) >> 7);
4942 + printk(" dev : %d\n", (r_usb_ept_data & 0x0000003f));
4943 +}
4944 +
4945 +static inline void __dump_ept_data_iso(int epid)
4946 +{
4947 + unsigned long flags;
4948 + __u32 ept_data;
4949 +
4950 + if (epid < 0 || epid > 31) {
4951 + printk("Cannot dump ept data for invalid epid %d\n", epid);
4952 + return;
4953 + }
4954 +
4955 + local_irq_save(flags);
4956 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
4957 + nop();
4958 + ept_data = *R_USB_EPT_DATA_ISO;
4959 + local_irq_restore(flags);
4960 +
4961 + printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", ept_data, epid);
4962 + if (ept_data == 0) {
4963 + /* No need for more detailed printing. */
4964 + return;
4965 + }
4966 + printk(" valid : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, valid,
4967 + ept_data));
4968 + printk(" port : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, port,
4969 + ept_data));
4970 + printk(" error_code : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code,
4971 + ept_data));
4972 + printk(" max_len : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, max_len,
4973 + ept_data));
4974 + printk(" ep : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, ep,
4975 + ept_data));
4976 + printk(" dev : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, dev,
4977 + ept_data));
4978 }
4979
4980 -/* Search through the list for an element that contains this urb. (The list
4981 - is expected to be short and the one we are about to delete will often be
4982 - the first in the list.) */
4983 -static inline urb_entry_t *__urb_list_entry(struct urb *urb, int epid)
4984 +static inline void __dump_ept_data_list(void)
4985 {
4986 - struct list_head *entry;
4987 - struct list_head *tmp;
4988 - urb_entry_t *urb_entry;
4989 -
4990 - list_for_each_safe(entry, tmp, &urb_list[epid]) {
4991 - urb_entry = list_entry(entry, urb_entry_t, list);
4992 - assert(urb_entry);
4993 - assert(urb_entry->urb);
4994 -
4995 - if (urb_entry->urb == urb) {
4996 - return urb_entry;
4997 - }
4998 - }
4999 - return 0;
5000 -}
5001 + int i;
5002
5003 -/* Delete an urb from the list. */
5004 -static inline void urb_list_del(struct urb *urb, int epid)
5005 -{
5006 - urb_entry_t *urb_entry = __urb_list_entry(urb, epid);
5007 - assert(urb_entry);
5008 + printk("Dumping the whole R_USB_EPT_DATA list\n");
5009
5010 - /* Delete entry and free. */
5011 - list_del(&urb_entry->list);
5012 - kfree(urb_entry);
5013 + for (i = 0; i < 32; i++) {
5014 + __dump_ept_data(i);
5015 + }
5016 +}
5017 +
5018 +static void debug_epid(int epid) {
5019 + int i;
5020 +
5021 + if(epid_isoc(epid)) {
5022 + __dump_ept_data_iso(epid);
5023 + } else {
5024 + __dump_ept_data(epid);
5025 + }
5026 +
5027 + printk("Bulk:\n");
5028 + for(i = 0; i < 32; i++) {
5029 + if(IO_EXTRACT(USB_EP_command, epid, TxBulkEPList[i].command) ==
5030 + epid) {
5031 + printk("%d: ", i); __dump_ep_desc(&(TxBulkEPList[i]));
5032 + }
5033 + }
5034 +
5035 + printk("Ctrl:\n");
5036 + for(i = 0; i < 32; i++) {
5037 + if(IO_EXTRACT(USB_EP_command, epid, TxCtrlEPList[i].command) ==
5038 + epid) {
5039 + printk("%d: ", i); __dump_ep_desc(&(TxCtrlEPList[i]));
5040 + }
5041 + }
5042 +
5043 + printk("Intr:\n");
5044 + for(i = 0; i < MAX_INTR_INTERVAL; i++) {
5045 + if(IO_EXTRACT(USB_EP_command, epid, TxIntrEPList[i].command) ==
5046 + epid) {
5047 + printk("%d: ", i); __dump_ep_desc(&(TxIntrEPList[i]));
5048 + }
5049 + }
5050 +
5051 + printk("Isoc:\n");
5052 + for(i = 0; i < 32; i++) {
5053 + if(IO_EXTRACT(USB_EP_command, epid, TxIsocEPList[i].command) ==
5054 + epid) {
5055 + printk("%d: ", i); __dump_ep_desc(&(TxIsocEPList[i]));
5056 + }
5057 + }
5058 +
5059 + __dump_ept_data_list();
5060 + __dump_ep_list(PIPE_INTERRUPT);
5061 + printk("\n\n");
5062 +}
5063 +
5064 +
5065 +
5066 +char* hcd_status_to_str(__u8 bUsbStatus) {
5067 + static char hcd_status_str[128];
5068 + hcd_status_str[0] = '\0';
5069 + if(bUsbStatus & IO_STATE(R_USB_STATUS, ourun, yes)) {
5070 + strcat(hcd_status_str, "ourun ");
5071 + }
5072 + if(bUsbStatus & IO_STATE(R_USB_STATUS, perror, yes)) {
5073 + strcat(hcd_status_str, "perror ");
5074 + }
5075 + if(bUsbStatus & IO_STATE(R_USB_STATUS, device_mode, yes)) {
5076 + strcat(hcd_status_str, "device_mode ");
5077 + }
5078 + if(bUsbStatus & IO_STATE(R_USB_STATUS, host_mode, yes)) {
5079 + strcat(hcd_status_str, "host_mode ");
5080 + }
5081 + if(bUsbStatus & IO_STATE(R_USB_STATUS, started, yes)) {
5082 + strcat(hcd_status_str, "started ");
5083 + }
5084 + if(bUsbStatus & IO_STATE(R_USB_STATUS, running, yes)) {
5085 + strcat(hcd_status_str, "running ");
5086 + }
5087 + return hcd_status_str;
5088 +}
5089 +
5090 +
5091 +char* sblist_to_str(struct USB_SB_Desc* sb_desc) {
5092 + static char sblist_to_str_buff[128];
5093 + char tmp[32], tmp2[32];
5094 + sblist_to_str_buff[0] = '\0';
5095 + while(sb_desc != NULL) {
5096 + switch(IO_EXTRACT(USB_SB_command, tt, sb_desc->command)) {
5097 + case 0: sprintf(tmp, "zout"); break;
5098 + case 1: sprintf(tmp, "in"); break;
5099 + case 2: sprintf(tmp, "out"); break;
5100 + case 3: sprintf(tmp, "setup"); break;
5101 + }
5102 + sprintf(tmp2, "(%s %d)", tmp, sb_desc->sw_len);
5103 + strcat(sblist_to_str_buff, tmp2);
5104 + if(sb_desc->next != 0) {
5105 + sb_desc = phys_to_virt(sb_desc->next);
5106 + } else {
5107 + sb_desc = NULL;
5108 + }
5109 + }
5110 + return sblist_to_str_buff;
5111 +}
5112 +
5113 +char* port_status_to_str(__u16 wPortStatus) {
5114 + static char port_status_str[128];
5115 + port_status_str[0] = '\0';
5116 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) {
5117 + strcat(port_status_str, "connected ");
5118 + }
5119 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) {
5120 + strcat(port_status_str, "enabled ");
5121 + }
5122 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, suspended, yes)) {
5123 + strcat(port_status_str, "suspended ");
5124 + }
5125 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, reset, yes)) {
5126 + strcat(port_status_str, "reset ");
5127 + }
5128 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, speed, full)) {
5129 + strcat(port_status_str, "full-speed ");
5130 + } else {
5131 + strcat(port_status_str, "low-speed ");
5132 + }
5133 + return port_status_str;
5134 +}
5135 +
5136 +
5137 +char* endpoint_to_str(struct usb_endpoint_descriptor *ed) {
5138 + static char endpoint_to_str_buff[128];
5139 + char tmp[32];
5140 + int epnum = ed->bEndpointAddress & 0x0F;
5141 + int dir = ed->bEndpointAddress & 0x80;
5142 + int type = ed->bmAttributes & 0x03;
5143 + endpoint_to_str_buff[0] = '\0';
5144 + sprintf(endpoint_to_str_buff, "ep:%d ", epnum);
5145 + switch(type) {
5146 + case 0:
5147 + sprintf(tmp, " ctrl");
5148 + break;
5149 + case 1:
5150 + sprintf(tmp, " isoc");
5151 + break;
5152 + case 2:
5153 + sprintf(tmp, " bulk");
5154 + break;
5155 + case 3:
5156 + sprintf(tmp, " intr");
5157 + break;
5158 + }
5159 + strcat(endpoint_to_str_buff, tmp);
5160 + if(dir) {
5161 + sprintf(tmp, " in");
5162 + } else {
5163 + sprintf(tmp, " out");
5164 + }
5165 + strcat(endpoint_to_str_buff, tmp);
5166 +
5167 + return endpoint_to_str_buff;
5168 +}
5169 +
5170 +/* Debug helper functions for Transfer Controller */
5171 +char* pipe_to_str(unsigned int pipe) {
5172 + static char pipe_to_str_buff[128];
5173 + char tmp[64];
5174 + sprintf(pipe_to_str_buff, "dir:%s", str_dir(pipe));
5175 + sprintf(tmp, " type:%s", str_type(pipe));
5176 + strcat(pipe_to_str_buff, tmp);
5177 +
5178 + sprintf(tmp, " dev:%d", usb_pipedevice(pipe));
5179 + strcat(pipe_to_str_buff, tmp);
5180 + sprintf(tmp, " ep:%d", usb_pipeendpoint(pipe));
5181 + strcat(pipe_to_str_buff, tmp);
5182 + return pipe_to_str_buff;
5183 }
5184
5185 -/* Move an urb to the end of the list. */
5186 -static inline void urb_list_move_last(struct urb *urb, int epid)
5187 -{
5188 - urb_entry_t *urb_entry = __urb_list_entry(urb, epid);
5189 - assert(urb_entry);
5190 -
5191 - list_move_tail(&urb_entry->list, &urb_list[epid]);
5192 -}
5193
5194 -/* Get the next urb in the list. */
5195 -static inline struct urb *urb_list_next(struct urb *urb, int epid)
5196 -{
5197 - urb_entry_t *urb_entry = __urb_list_entry(urb, epid);
5198 +#define USB_DEBUG_DESC 1
5199
5200 - assert(urb_entry);
5201 +#ifdef USB_DEBUG_DESC
5202 +#define dump_in_desc(x) __dump_in_desc(x)
5203 +#define dump_sb_desc(...) __dump_sb_desc(...)
5204 +#define dump_ep_desc(x) __dump_ep_desc(x)
5205 +#define dump_ept_data(x) __dump_ept_data(x)
5206 +#else
5207 +#define dump_in_desc(...) do {} while (0)
5208 +#define dump_sb_desc(...) do {} while (0)
5209 +#define dump_ep_desc(...) do {} while (0)
5210 +#endif
5211
5212 - if (urb_entry->list.next != &urb_list[epid]) {
5213 - struct list_head *elem = urb_entry->list.next;
5214 - urb_entry = list_entry(elem, urb_entry_t, list);
5215 - return urb_entry->urb;
5216 - } else {
5217 - return NULL;
5218 - }
5219 -}
5220
5221 +/* Uncomment this to enable massive function call trace
5222 + #define USB_DEBUG_TRACE */
5223
5224 +#ifdef USB_DEBUG_TRACE
5225 +#define DBFENTER (printk(": Entering: %s\n", __FUNCTION__))
5226 +#define DBFEXIT (printk(": Exiting: %s\n", __FUNCTION__))
5227 +#else
5228 +#define DBFENTER do {} while (0)
5229 +#define DBFEXIT do {} while (0)
5230 +#endif
5231
5232 -/* For debug purposes only. */
5233 -static inline void urb_list_dump(int epid)
5234 -{
5235 - struct list_head *entry;
5236 - struct list_head *tmp;
5237 - urb_entry_t *urb_entry;
5238 - int i = 0;
5239 -
5240 - info("Dumping urb list for epid %d", epid);
5241 -
5242 - list_for_each_safe(entry, tmp, &urb_list[epid]) {
5243 - urb_entry = list_entry(entry, urb_entry_t, list);
5244 - info(" entry %d, urb = 0x%lx", i, (unsigned long)urb_entry->urb);
5245 - }
5246 -}
5247 +#define CHECK_ALIGN(x) if (((__u32)(x)) & 0x00000003) \
5248 +{panic("Alignment check (DWORD) failed at %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);}
5249
5250 -static void init_rx_buffers(void);
5251 -static int etrax_rh_unlink_urb(struct urb *urb);
5252 -static void etrax_rh_send_irq(struct urb *urb);
5253 -static void etrax_rh_init_int_timer(struct urb *urb);
5254 -static void etrax_rh_int_timer_do(unsigned long ptr);
5255 -
5256 -static int etrax_usb_setup_epid(struct urb *urb);
5257 -static int etrax_usb_lookup_epid(struct urb *urb);
5258 -static int etrax_usb_allocate_epid(void);
5259 -static void etrax_usb_free_epid(int epid);
5260 -
5261 -static int etrax_remove_from_sb_list(struct urb *urb);
5262 -
5263 -static void* etrax_usb_buffer_alloc(struct usb_bus* bus, size_t size,
5264 - unsigned mem_flags, dma_addr_t *dma);
5265 -static void etrax_usb_buffer_free(struct usb_bus *bus, size_t size, void *addr, dma_addr_t dma);
5266 -
5267 -static void etrax_usb_add_to_bulk_sb_list(struct urb *urb, int epid);
5268 -static void etrax_usb_add_to_ctrl_sb_list(struct urb *urb, int epid);
5269 -static void etrax_usb_add_to_intr_sb_list(struct urb *urb, int epid);
5270 -static void etrax_usb_add_to_isoc_sb_list(struct urb *urb, int epid);
5271 -
5272 -static int etrax_usb_submit_bulk_urb(struct urb *urb);
5273 -static int etrax_usb_submit_ctrl_urb(struct urb *urb);
5274 -static int etrax_usb_submit_intr_urb(struct urb *urb);
5275 -static int etrax_usb_submit_isoc_urb(struct urb *urb);
5276 -
5277 -static int etrax_usb_submit_urb(struct urb *urb, unsigned mem_flags);
5278 -static int etrax_usb_unlink_urb(struct urb *urb, int status);
5279 -static int etrax_usb_get_frame_number(struct usb_device *usb_dev);
5280 -
5281 -static irqreturn_t etrax_usb_tx_interrupt(int irq, void *vhc);
5282 -static irqreturn_t etrax_usb_rx_interrupt(int irq, void *vhc);
5283 -static irqreturn_t etrax_usb_hc_interrupt_top_half(int irq, void *vhc);
5284 -static void etrax_usb_hc_interrupt_bottom_half(void *data);
5285 -
5286 -static void etrax_usb_isoc_descr_interrupt_bottom_half(void *data);
5287 -
5288 -
5289 -/* The following is a list of interrupt handlers for the host controller interrupts we use.
5290 - They are called from etrax_usb_hc_interrupt_bottom_half. */
5291 -static void etrax_usb_hc_isoc_eof_interrupt(void);
5292 -static void etrax_usb_hc_bulk_eot_interrupt(int timer_induced);
5293 -static void etrax_usb_hc_epid_attn_interrupt(usb_interrupt_registers_t *reg);
5294 -static void etrax_usb_hc_port_status_interrupt(usb_interrupt_registers_t *reg);
5295 -static void etrax_usb_hc_ctl_status_interrupt(usb_interrupt_registers_t *reg);
5296 -
5297 -static int etrax_rh_submit_urb (struct urb *urb);
5298 -
5299 -/* Forward declaration needed because they are used in the rx interrupt routine. */
5300 -static void etrax_usb_complete_urb(struct urb *urb, int status);
5301 -static void etrax_usb_complete_bulk_urb(struct urb *urb, int status);
5302 -static void etrax_usb_complete_ctrl_urb(struct urb *urb, int status);
5303 -static void etrax_usb_complete_intr_urb(struct urb *urb, int status);
5304 -static void etrax_usb_complete_isoc_urb(struct urb *urb, int status);
5305 +/* Most helpful debugging aid */
5306 +#define ASSERT(expr) ((void) ((expr) ? 0 : (err("assert failed at: %s %d",__FUNCTION__, __LINE__))))
5307
5308 -static int etrax_usb_hc_init(void);
5309 -static void etrax_usb_hc_cleanup(void);
5310
5311 -static struct usb_operations etrax_usb_device_operations =
5312 -{
5313 - .get_frame_number = etrax_usb_get_frame_number,
5314 - .submit_urb = etrax_usb_submit_urb,
5315 - .unlink_urb = etrax_usb_unlink_urb,
5316 - .buffer_alloc = etrax_usb_buffer_alloc,
5317 - .buffer_free = etrax_usb_buffer_free
5318 -};
5319 +/***************************************************************************/
5320 +/***************************************************************************/
5321 +/* Forward declarations */
5322 +/***************************************************************************/
5323 +/***************************************************************************/
5324 +void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg);
5325 +void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg);
5326 +void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg);
5327 +void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg);
5328 +
5329 +void rh_port_status_change(__u16[]);
5330 +int rh_clear_port_feature(__u8, __u16);
5331 +int rh_set_port_feature(__u8, __u16);
5332 +static void rh_disable_port(unsigned int port);
5333 +
5334 +static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
5335 + int timer);
5336 +
5337 +static int tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
5338 + int mem_flags);
5339 +static void tc_free_epid(struct usb_host_endpoint *ep);
5340 +static int tc_allocate_epid(void);
5341 +static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status);
5342 +static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
5343 + int status);
5344 +
5345 +static int urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
5346 + int mem_flags);
5347 +static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb);
5348 +
5349 +static inline struct urb *urb_list_first(int epid);
5350 +static inline void urb_list_add(struct urb *urb, int epid,
5351 + int mem_flags);
5352 +static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid);
5353 +static inline void urb_list_del(struct urb *urb, int epid);
5354 +static inline void urb_list_move_last(struct urb *urb, int epid);
5355 +static inline struct urb *urb_list_next(struct urb *urb, int epid);
5356 +
5357 +int create_sb_for_urb(struct urb *urb, int mem_flags);
5358 +int init_intr_urb(struct urb *urb, int mem_flags);
5359 +
5360 +static inline void etrax_epid_set(__u8 index, __u32 data);
5361 +static inline void etrax_epid_clear_error(__u8 index);
5362 +static inline void etrax_epid_set_toggle(__u8 index, __u8 dirout,
5363 + __u8 toggle);
5364 +static inline __u8 etrax_epid_get_toggle(__u8 index, __u8 dirout);
5365 +static inline __u32 etrax_epid_get(__u8 index);
5366 +
5367 +/* We're accessing the same register position in Etrax so
5368 + when we do full access the internal difference doesn't matter */
5369 +#define etrax_epid_iso_set(index, data) etrax_epid_set(index, data)
5370 +#define etrax_epid_iso_get(index) etrax_epid_get(index)
5371 +
5372 +
5373 +static void tc_dma_process_isoc_urb(struct urb *urb);
5374 +static void tc_dma_process_queue(int epid);
5375 +static void tc_dma_unlink_intr_urb(struct urb *urb);
5376 +static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc);
5377 +static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc);
5378 +
5379 +static void tc_bulk_start_timer_func(unsigned long dummy);
5380 +static void tc_bulk_eot_timer_func(unsigned long dummy);
5381 +
5382 +
5383 +/*************************************************************/
5384 +/*************************************************************/
5385 +/* Host Controler Driver block */
5386 +/*************************************************************/
5387 +/*************************************************************/
5388 +
5389 +/* HCD operations */
5390 +static irqreturn_t crisv10_hcd_top_irq(int irq, void*);
5391 +static int crisv10_hcd_reset(struct usb_hcd *);
5392 +static int crisv10_hcd_start(struct usb_hcd *);
5393 +static void crisv10_hcd_stop(struct usb_hcd *);
5394 +#ifdef CONFIG_PM
5395 +static int crisv10_hcd_suspend(struct device *, u32, u32);
5396 +static int crisv10_hcd_resume(struct device *, u32);
5397 +#endif /* CONFIG_PM */
5398 +static int crisv10_hcd_get_frame(struct usb_hcd *);
5399 +
5400 +static int tc_urb_enqueue(struct usb_hcd *, struct usb_host_endpoint *ep, struct urb *, gfp_t mem_flags);
5401 +static int tc_urb_dequeue(struct usb_hcd *, struct urb *);
5402 +static void tc_endpoint_disable(struct usb_hcd *, struct usb_host_endpoint *ep);
5403 +
5404 +static int rh_status_data_request(struct usb_hcd *, char *);
5405 +static int rh_control_request(struct usb_hcd *, u16, u16, u16, char*, u16);
5406 +
5407 +#ifdef CONFIG_PM
5408 +static int crisv10_hcd_hub_suspend(struct usb_hcd *);
5409 +static int crisv10_hcd_hub_resume(struct usb_hcd *);
5410 +#endif /* CONFIG_PM */
5411 +#ifdef CONFIG_USB_OTG
5412 +static int crisv10_hcd_start_port_reset(struct usb_hcd *, unsigned);
5413 +#endif /* CONFIG_USB_OTG */
5414 +
5415 +/* host controller driver interface */
5416 +static const struct hc_driver crisv10_hc_driver =
5417 + {
5418 + .description = hc_name,
5419 + .product_desc = product_desc,
5420 + .hcd_priv_size = sizeof(struct crisv10_hcd),
5421 +
5422 + /* Attaching IRQ handler manualy in probe() */
5423 + /* .irq = crisv10_hcd_irq, */
5424 +
5425 + .flags = HCD_USB11,
5426 +
5427 + /* called to init HCD and root hub */
5428 + .reset = crisv10_hcd_reset,
5429 + .start = crisv10_hcd_start,
5430 +
5431 + /* cleanly make HCD stop writing memory and doing I/O */
5432 + .stop = crisv10_hcd_stop,
5433 +
5434 + /* return current frame number */
5435 + .get_frame_number = crisv10_hcd_get_frame,
5436 +
5437 +
5438 + /* Manage i/o requests via the Transfer Controller */
5439 + .urb_enqueue = tc_urb_enqueue,
5440 + .urb_dequeue = tc_urb_dequeue,
5441 +
5442 + /* hw synch, freeing endpoint resources that urb_dequeue can't */
5443 + .endpoint_disable = tc_endpoint_disable,
5444 +
5445 +
5446 + /* Root Hub support */
5447 + .hub_status_data = rh_status_data_request,
5448 + .hub_control = rh_control_request,
5449 +#ifdef CONFIG_PM
5450 + .hub_suspend = rh_suspend_request,
5451 + .hub_resume = rh_resume_request,
5452 +#endif /* CONFIG_PM */
5453 +#ifdef CONFIG_USB_OTG
5454 + .start_port_reset = crisv10_hcd_start_port_reset,
5455 +#endif /* CONFIG_USB_OTG */
5456 + };
5457
5458 -/* Note that these functions are always available in their "__" variants, for use in
5459 - error situations. The "__" missing variants are controlled by the USB_DEBUG_DESC/
5460 - USB_DEBUG_URB macros. */
5461 -static void __dump_urb(struct urb* purb)
5462 -{
5463 - printk("\nurb :0x%08lx\n", (unsigned long)purb);
5464 - printk("dev :0x%08lx\n", (unsigned long)purb->dev);
5465 - printk("pipe :0x%08x\n", purb->pipe);
5466 - printk("status :%d\n", purb->status);
5467 - printk("transfer_flags :0x%08x\n", purb->transfer_flags);
5468 - printk("transfer_buffer :0x%08lx\n", (unsigned long)purb->transfer_buffer);
5469 - printk("transfer_buffer_length:%d\n", purb->transfer_buffer_length);
5470 - printk("actual_length :%d\n", purb->actual_length);
5471 - printk("setup_packet :0x%08lx\n", (unsigned long)purb->setup_packet);
5472 - printk("start_frame :%d\n", purb->start_frame);
5473 - printk("number_of_packets :%d\n", purb->number_of_packets);
5474 - printk("interval :%d\n", purb->interval);
5475 - printk("error_count :%d\n", purb->error_count);
5476 - printk("context :0x%08lx\n", (unsigned long)purb->context);
5477 - printk("complete :0x%08lx\n\n", (unsigned long)purb->complete);
5478 -}
5479
5480 -static void __dump_in_desc(volatile USB_IN_Desc_t *in)
5481 -{
5482 - printk("\nUSB_IN_Desc at 0x%08lx\n", (unsigned long)in);
5483 - printk(" sw_len : 0x%04x (%d)\n", in->sw_len, in->sw_len);
5484 - printk(" command : 0x%04x\n", in->command);
5485 - printk(" next : 0x%08lx\n", in->next);
5486 - printk(" buf : 0x%08lx\n", in->buf);
5487 - printk(" hw_len : 0x%04x (%d)\n", in->hw_len, in->hw_len);
5488 - printk(" status : 0x%04x\n\n", in->status);
5489 -}
5490 +/*
5491 + * conversion between pointers to a hcd and the corresponding
5492 + * crisv10_hcd
5493 + */
5494
5495 -static void __dump_sb_desc(volatile USB_SB_Desc_t *sb)
5496 +static inline struct crisv10_hcd *hcd_to_crisv10_hcd(struct usb_hcd *hcd)
5497 {
5498 - char tt = (sb->command & 0x30) >> 4;
5499 - char *tt_string;
5500 -
5501 - switch (tt) {
5502 - case 0:
5503 - tt_string = "zout";
5504 - break;
5505 - case 1:
5506 - tt_string = "in";
5507 - break;
5508 - case 2:
5509 - tt_string = "out";
5510 - break;
5511 - case 3:
5512 - tt_string = "setup";
5513 - break;
5514 - default:
5515 - tt_string = "unknown (weird)";
5516 - }
5517 -
5518 - printk("\n USB_SB_Desc at 0x%08lx\n", (unsigned long)sb);
5519 - printk(" command : 0x%04x\n", sb->command);
5520 - printk(" rem : %d\n", (sb->command & 0x3f00) >> 8);
5521 - printk(" full : %d\n", (sb->command & 0x40) >> 6);
5522 - printk(" tt : %d (%s)\n", tt, tt_string);
5523 - printk(" intr : %d\n", (sb->command & 0x8) >> 3);
5524 - printk(" eot : %d\n", (sb->command & 0x2) >> 1);
5525 - printk(" eol : %d\n", sb->command & 0x1);
5526 - printk(" sw_len : 0x%04x (%d)\n", sb->sw_len, sb->sw_len);
5527 - printk(" next : 0x%08lx\n", sb->next);
5528 - printk(" buf : 0x%08lx\n\n", sb->buf);
5529 + return (struct crisv10_hcd *) hcd->hcd_priv;
5530 }
5531
5532 -
5533 -static void __dump_ep_desc(volatile USB_EP_Desc_t *ep)
5534 +static inline struct usb_hcd *crisv10_hcd_to_hcd(struct crisv10_hcd *hcd)
5535 {
5536 - printk("\nUSB_EP_Desc at 0x%08lx\n", (unsigned long)ep);
5537 - printk(" command : 0x%04x\n", ep->command);
5538 - printk(" ep_id : %d\n", (ep->command & 0x1f00) >> 8);
5539 - printk(" enable : %d\n", (ep->command & 0x10) >> 4);
5540 - printk(" intr : %d\n", (ep->command & 0x8) >> 3);
5541 - printk(" eof : %d\n", (ep->command & 0x2) >> 1);
5542 - printk(" eol : %d\n", ep->command & 0x1);
5543 - printk(" hw_len : 0x%04x (%d)\n", ep->hw_len, ep->hw_len);
5544 - printk(" next : 0x%08lx\n", ep->next);
5545 - printk(" sub : 0x%08lx\n\n", ep->sub);
5546 + return container_of((void *) hcd, struct usb_hcd, hcd_priv);
5547 }
5548
5549 -static inline void __dump_ep_list(int pipe_type)
5550 +/* check if specified port is in use */
5551 +static inline int port_in_use(unsigned int port)
5552 {
5553 - volatile USB_EP_Desc_t *ep;
5554 - volatile USB_EP_Desc_t *first_ep;
5555 - volatile USB_SB_Desc_t *sb;
5556 -
5557 - switch (pipe_type)
5558 - {
5559 - case PIPE_BULK:
5560 - first_ep = &TxBulkEPList[0];
5561 - break;
5562 - case PIPE_CONTROL:
5563 - first_ep = &TxCtrlEPList[0];
5564 - break;
5565 - case PIPE_INTERRUPT:
5566 - first_ep = &TxIntrEPList[0];
5567 - break;
5568 - case PIPE_ISOCHRONOUS:
5569 - first_ep = &TxIsocEPList[0];
5570 - break;
5571 - default:
5572 - warn("Cannot dump unknown traffic type");
5573 - return;
5574 - }
5575 - ep = first_ep;
5576 -
5577 - printk("\n\nDumping EP list...\n\n");
5578 -
5579 - do {
5580 - __dump_ep_desc(ep);
5581 - /* Cannot phys_to_virt on 0 as it turns into 80000000, which is != 0. */
5582 - sb = ep->sub ? phys_to_virt(ep->sub) : 0;
5583 - while (sb) {
5584 - __dump_sb_desc(sb);
5585 - sb = sb->next ? phys_to_virt(sb->next) : 0;
5586 - }
5587 - ep = (volatile USB_EP_Desc_t *)(phys_to_virt(ep->next));
5588 -
5589 - } while (ep != first_ep);
5590 + return ports & (1 << port);
5591 }
5592
5593 -static inline void __dump_ept_data(int epid)
5594 +/* number of ports in use */
5595 +static inline unsigned int num_ports(void)
5596 {
5597 - unsigned long flags;
5598 - __u32 r_usb_ept_data;
5599 -
5600 - if (epid < 0 || epid > 31) {
5601 - printk("Cannot dump ept data for invalid epid %d\n", epid);
5602 - return;
5603 - }
5604 -
5605 - save_flags(flags);
5606 - cli();
5607 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
5608 - nop();
5609 - r_usb_ept_data = *R_USB_EPT_DATA;
5610 - restore_flags(flags);
5611 -
5612 - printk("\nR_USB_EPT_DATA = 0x%x for epid %d :\n", r_usb_ept_data, epid);
5613 - if (r_usb_ept_data == 0) {
5614 - /* No need for more detailed printing. */
5615 - return;
5616 - }
5617 - printk(" valid : %d\n", (r_usb_ept_data & 0x80000000) >> 31);
5618 - printk(" hold : %d\n", (r_usb_ept_data & 0x40000000) >> 30);
5619 - printk(" error_count_in : %d\n", (r_usb_ept_data & 0x30000000) >> 28);
5620 - printk(" t_in : %d\n", (r_usb_ept_data & 0x08000000) >> 27);
5621 - printk(" low_speed : %d\n", (r_usb_ept_data & 0x04000000) >> 26);
5622 - printk(" port : %d\n", (r_usb_ept_data & 0x03000000) >> 24);
5623 - printk(" error_code : %d\n", (r_usb_ept_data & 0x00c00000) >> 22);
5624 - printk(" t_out : %d\n", (r_usb_ept_data & 0x00200000) >> 21);
5625 - printk(" error_count_out : %d\n", (r_usb_ept_data & 0x00180000) >> 19);
5626 - printk(" max_len : %d\n", (r_usb_ept_data & 0x0003f800) >> 11);
5627 - printk(" ep : %d\n", (r_usb_ept_data & 0x00000780) >> 7);
5628 - printk(" dev : %d\n", (r_usb_ept_data & 0x0000003f));
5629 + unsigned int i, num = 0;
5630 + for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
5631 + if (port_in_use(i))
5632 + num++;
5633 + return num;
5634 }
5635
5636 -static inline void __dump_ept_data_list(void)
5637 +/* map hub port number to the port number used internally by the HC */
5638 +static inline unsigned int map_port(unsigned int port)
5639 {
5640 - int i;
5641 -
5642 - printk("Dumping the whole R_USB_EPT_DATA list\n");
5643 -
5644 - for (i = 0; i < 32; i++) {
5645 - __dump_ept_data(i);
5646 - }
5647 + unsigned int i, num = 0;
5648 + for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
5649 + if (port_in_use(i))
5650 + if (++num == port)
5651 + return i;
5652 + return -1;
5653 }
5654 -#ifdef USB_DEBUG_DESC
5655 -#define dump_in_desc(...) __dump_in_desc(...)
5656 -#define dump_sb_desc(...) __dump_sb_desc(...)
5657 -#define dump_ep_desc(...) __dump_ep_desc(...)
5658 -#else
5659 -#define dump_in_desc(...) do {} while (0)
5660 -#define dump_sb_desc(...) do {} while (0)
5661 -#define dump_ep_desc(...) do {} while (0)
5662 -#endif
5663
5664 -#ifdef USB_DEBUG_URB
5665 -#define dump_urb(x) __dump_urb(x)
5666 -#else
5667 -#define dump_urb(x) do {} while (0)
5668 +/* size of descriptors in slab cache */
5669 +#ifndef MAX
5670 +#define MAX(x, y) ((x) > (y) ? (x) : (y))
5671 #endif
5672
5673 -static void init_rx_buffers(void)
5674 -{
5675 - int i;
5676
5677 - DBFENTER;
5678 +/******************************************************************/
5679 +/* Hardware Interrupt functions */
5680 +/******************************************************************/
5681 +
5682 +/* Fast interrupt handler for HC */
5683 +static irqreturn_t crisv10_hcd_top_irq(int irq, void *vcd)
5684 +{
5685 + struct usb_hcd *hcd = vcd;
5686 + struct crisv10_irq_reg reg;
5687 + __u32 irq_mask;
5688 + unsigned long flags;
5689 +
5690 + DBFENTER;
5691 +
5692 + ASSERT(hcd != NULL);
5693 + reg.hcd = hcd;
5694 +
5695 + /* Turn of other interrupts while handling these sensitive cases */
5696 + local_irq_save(flags);
5697 +
5698 + /* Read out which interrupts that are flaged */
5699 + irq_mask = *R_USB_IRQ_MASK_READ;
5700 + reg.r_usb_irq_mask_read = irq_mask;
5701 +
5702 + /* Reading R_USB_STATUS clears the ctl_status interrupt. Note that
5703 + R_USB_STATUS must be read before R_USB_EPID_ATTN since reading the latter
5704 + clears the ourun and perror fields of R_USB_STATUS. */
5705 + reg.r_usb_status = *R_USB_STATUS;
5706 +
5707 + /* Reading R_USB_EPID_ATTN clears the iso_eof, bulk_eot and epid_attn
5708 + interrupts. */
5709 + reg.r_usb_epid_attn = *R_USB_EPID_ATTN;
5710 +
5711 + /* Reading R_USB_RH_PORT_STATUS_1 and R_USB_RH_PORT_STATUS_2 clears the
5712 + port_status interrupt. */
5713 + reg.r_usb_rh_port_status_1 = *R_USB_RH_PORT_STATUS_1;
5714 + reg.r_usb_rh_port_status_2 = *R_USB_RH_PORT_STATUS_2;
5715 +
5716 + /* Reading R_USB_FM_NUMBER clears the sof interrupt. */
5717 + /* Note: the lower 11 bits contain the actual frame number, sent with each
5718 + sof. */
5719 + reg.r_usb_fm_number = *R_USB_FM_NUMBER;
5720 +
5721 + /* Interrupts are handled in order of priority. */
5722 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, port_status)) {
5723 + crisv10_hcd_port_status_irq(&reg);
5724 + }
5725 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, epid_attn)) {
5726 + crisv10_hcd_epid_attn_irq(&reg);
5727 + }
5728 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, ctl_status)) {
5729 + crisv10_hcd_ctl_status_irq(&reg);
5730 + }
5731 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, iso_eof)) {
5732 + crisv10_hcd_isoc_eof_irq(&reg);
5733 + }
5734 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, bulk_eot)) {
5735 + /* Update/restart the bulk start timer since obviously the channel is
5736 + running. */
5737 + mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
5738 + /* Update/restart the bulk eot timer since we just received an bulk eot
5739 + interrupt. */
5740 + mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
5741 +
5742 + /* Check for finished bulk transfers on epids */
5743 + check_finished_bulk_tx_epids(hcd, 0);
5744 + }
5745 + local_irq_restore(flags);
5746 +
5747 + DBFEXIT;
5748 + return IRQ_HANDLED;
5749 +}
5750 +
5751 +
5752 +void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg) {
5753 + struct usb_hcd *hcd = reg->hcd;
5754 + struct crisv10_urb_priv *urb_priv;
5755 + int epid;
5756 + DBFENTER;
5757 +
5758 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
5759 + if (test_bit(epid, (void *)&reg->r_usb_epid_attn)) {
5760 + struct urb *urb;
5761 + __u32 ept_data;
5762 + int error_code;
5763 +
5764 + if (epid == DUMMY_EPID || epid == INVALID_EPID) {
5765 + /* We definitely don't care about these ones. Besides, they are
5766 + always disabled, so any possible disabling caused by the
5767 + epid attention interrupt is irrelevant. */
5768 + warn("Got epid_attn for INVALID_EPID or DUMMY_EPID (%d).", epid);
5769 + continue;
5770 + }
5771 +
5772 + if(!epid_inuse(epid)) {
5773 + irq_err("Epid attention on epid:%d that isn't in use\n", epid);
5774 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
5775 + debug_epid(epid);
5776 + continue;
5777 + }
5778 +
5779 + /* Note that although there are separate R_USB_EPT_DATA and
5780 + R_USB_EPT_DATA_ISO registers, they are located at the same address and
5781 + are of the same size. In other words, this read should be ok for isoc
5782 + also. */
5783 + ept_data = etrax_epid_get(epid);
5784 + error_code = IO_EXTRACT(R_USB_EPT_DATA, error_code, ept_data);
5785 +
5786 + /* Get the active URB for this epid. We blatantly assume
5787 + that only this URB could have caused the epid attention. */
5788 + urb = activeUrbList[epid];
5789 + if (urb == NULL) {
5790 + irq_err("Attention on epid:%d error:%d with no active URB.\n",
5791 + epid, error_code);
5792 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
5793 + debug_epid(epid);
5794 + continue;
5795 + }
5796 +
5797 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
5798 + ASSERT(urb_priv);
5799 +
5800 + /* Using IO_STATE_VALUE on R_USB_EPT_DATA should be ok for isoc also. */
5801 + if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
5802 +
5803 + /* Isoc traffic doesn't have error_count_in/error_count_out. */
5804 + if ((usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) &&
5805 + (IO_EXTRACT(R_USB_EPT_DATA, error_count_in, ept_data) == 3 ||
5806 + IO_EXTRACT(R_USB_EPT_DATA, error_count_out, ept_data) == 3)) {
5807 + /* Check if URB allready is marked for late-finish, we can get
5808 + several 3rd error for Intr traffic when a device is unplugged */
5809 + if(urb_priv->later_data == NULL) {
5810 + /* 3rd error. */
5811 + irq_warn("3rd error for epid:%d (%s %s) URB:0x%x[%d]\n", epid,
5812 + str_dir(urb->pipe), str_type(urb->pipe),
5813 + (unsigned int)urb, urb_priv->urb_num);
5814 +
5815 + tc_finish_urb_later(hcd, urb, -EPROTO);
5816 + }
5817 +
5818 + } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
5819 + irq_warn("Perror for epid:%d\n", epid);
5820 + printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
5821 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
5822 + __dump_urb(urb);
5823 + debug_epid(epid);
5824 +
5825 + if (!(ept_data & IO_MASK(R_USB_EPT_DATA, valid))) {
5826 + /* invalid ep_id */
5827 + panic("Perror because of invalid epid."
5828 + " Deconfigured too early?");
5829 + } else {
5830 + /* past eof1, near eof, zout transfer, setup transfer */
5831 + /* Dump the urb and the relevant EP descriptor. */
5832 + panic("Something wrong with DMA descriptor contents."
5833 + " Too much traffic inserted?");
5834 + }
5835 + } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
5836 + /* buffer ourun */
5837 + printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
5838 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
5839 + __dump_urb(urb);
5840 + debug_epid(epid);
5841
5842 - for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) {
5843 - RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
5844 - RxDescList[i].command = 0;
5845 - RxDescList[i].next = virt_to_phys(&RxDescList[i + 1]);
5846 - RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
5847 - RxDescList[i].hw_len = 0;
5848 - RxDescList[i].status = 0;
5849 -
5850 - /* DMA IN cache bug. (struct etrax_dma_descr has the same layout as USB_IN_Desc
5851 - for the relevant fields.) */
5852 - prepare_rx_descriptor((struct etrax_dma_descr*)&RxDescList[i]);
5853 + panic("Buffer overrun/underrun for epid:%d. DMA too busy?", epid);
5854 + } else {
5855 + irq_warn("Attention on epid:%d (%s %s) with no error code\n", epid,
5856 + str_dir(urb->pipe), str_type(urb->pipe));
5857 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
5858 + __dump_urb(urb);
5859 + debug_epid(epid);
5860 + }
5861
5862 + } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
5863 + stall)) {
5864 + /* Not really a protocol error, just says that the endpoint gave
5865 + a stall response. Note that error_code cannot be stall for isoc. */
5866 + if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
5867 + panic("Isoc traffic cannot stall");
5868 }
5869
5870 - RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
5871 - RxDescList[i].command = IO_STATE(USB_IN_command, eol, yes);
5872 - RxDescList[i].next = virt_to_phys(&RxDescList[0]);
5873 - RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
5874 - RxDescList[i].hw_len = 0;
5875 - RxDescList[i].status = 0;
5876 + tc_dbg("Stall for epid:%d (%s %s) URB:0x%x\n", epid,
5877 + str_dir(urb->pipe), str_type(urb->pipe), (unsigned int)urb);
5878 + tc_finish_urb(hcd, urb, -EPIPE);
5879 +
5880 + } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
5881 + bus_error)) {
5882 + /* Two devices responded to a transaction request. Must be resolved
5883 + by software. FIXME: Reset ports? */
5884 + panic("Bus error for epid %d."
5885 + " Two devices responded to transaction request\n",
5886 + epid);
5887 +
5888 + } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
5889 + buffer_error)) {
5890 + /* DMA overrun or underrun. */
5891 + irq_warn("Buffer overrun/underrun for epid:%d (%s %s)\n", epid,
5892 + str_dir(urb->pipe), str_type(urb->pipe));
5893 +
5894 + /* It seems that error_code = buffer_error in
5895 + R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
5896 + are the same error. */
5897 + tc_finish_urb(hcd, urb, -EPROTO);
5898 + } else {
5899 + irq_warn("Unknown attention on epid:%d (%s %s)\n", epid,
5900 + str_dir(urb->pipe), str_type(urb->pipe));
5901 + dump_ept_data(epid);
5902 + }
5903 + }
5904 + }
5905 + DBFEXIT;
5906 +}
5907 +
5908 +void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg)
5909 +{
5910 + __u16 port_reg[USB_ROOT_HUB_PORTS];
5911 + DBFENTER;
5912 + port_reg[0] = reg->r_usb_rh_port_status_1;
5913 + port_reg[1] = reg->r_usb_rh_port_status_2;
5914 + rh_port_status_change(port_reg);
5915 + DBFEXIT;
5916 +}
5917 +
5918 +void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg)
5919 +{
5920 + int epid;
5921 + struct urb *urb;
5922 + struct crisv10_urb_priv *urb_priv;
5923 +
5924 + DBFENTER;
5925 +
5926 + for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
5927 +
5928 + /* Only check epids that are in use, is valid and has SB list */
5929 + if (!epid_inuse(epid) || epid == INVALID_EPID ||
5930 + TxIsocEPList[epid].sub == 0 || epid == DUMMY_EPID) {
5931 + /* Nothing here to see. */
5932 + continue;
5933 + }
5934 + ASSERT(epid_isoc(epid));
5935 +
5936 + /* Get the active URB for this epid (if any). */
5937 + urb = activeUrbList[epid];
5938 + if (urb == 0) {
5939 + isoc_warn("Ignoring NULL urb for epid:%d\n", epid);
5940 + continue;
5941 + }
5942 + if(!epid_out_traffic(epid)) {
5943 + /* Sanity check. */
5944 + ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
5945 +
5946 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
5947 + ASSERT(urb_priv);
5948 +
5949 + if (urb_priv->urb_state == NOT_STARTED) {
5950 + /* If ASAP is not set and urb->start_frame is the current frame,
5951 + start the transfer. */
5952 + if (!(urb->transfer_flags & URB_ISO_ASAP) &&
5953 + (urb->start_frame == (*R_USB_FM_NUMBER & 0x7ff))) {
5954 + /* EP should not be enabled if we're waiting for start_frame */
5955 + ASSERT((TxIsocEPList[epid].command &
5956 + IO_STATE(USB_EP_command, enable, yes)) == 0);
5957 +
5958 + isoc_warn("Enabling isoc IN EP descr for epid %d\n", epid);
5959 + TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
5960 +
5961 + /* This urb is now active. */
5962 + urb_priv->urb_state = STARTED;
5963 + continue;
5964 + }
5965 + }
5966 + }
5967 + }
5968 +
5969 + DBFEXIT;
5970 +}
5971 +
5972 +void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg)
5973 +{
5974 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(reg->hcd);
5975 +
5976 + DBFENTER;
5977 + ASSERT(crisv10_hcd);
5978 +
5979 + irq_dbg("ctr_status_irq, controller status: %s\n",
5980 + hcd_status_to_str(reg->r_usb_status));
5981 +
5982 + /* FIXME: What should we do if we get ourun or perror? Dump the EP and SB
5983 + list for the corresponding epid? */
5984 + if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
5985 + panic("USB controller got ourun.");
5986 + }
5987 + if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
5988 +
5989 + /* Before, etrax_usb_do_intr_recover was called on this epid if it was
5990 + an interrupt pipe. I don't see how re-enabling all EP descriptors
5991 + will help if there was a programming error. */
5992 + panic("USB controller got perror.");
5993 + }
5994 +
5995 + /* Keep track of USB Controller, if it's running or not */
5996 + if(reg->r_usb_status & IO_STATE(R_USB_STATUS, running, yes)) {
5997 + crisv10_hcd->running = 1;
5998 + } else {
5999 + crisv10_hcd->running = 0;
6000 + }
6001 +
6002 + if (reg->r_usb_status & IO_MASK(R_USB_STATUS, device_mode)) {
6003 + /* We should never operate in device mode. */
6004 + panic("USB controller in device mode.");
6005 + }
6006 +
6007 + /* Set the flag to avoid getting "Unlink after no-IRQ? Controller is probably
6008 + using the wrong IRQ" from hcd_unlink_urb() in drivers/usb/core/hcd.c */
6009 + set_bit(HCD_FLAG_SAW_IRQ, &reg->hcd->flags);
6010 +
6011 + DBFEXIT;
6012 +}
6013 +
6014 +
6015 +/******************************************************************/
6016 +/* Host Controller interface functions */
6017 +/******************************************************************/
6018 +
6019 +static inline void crisv10_ready_wait(void) {
6020 + volatile int timeout = 10000;
6021 + /* Check the busy bit of USB controller in Etrax */
6022 + while((*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)) &&
6023 + (timeout-- > 0));
6024 + if(timeout == 0) {
6025 + warn("Timeout while waiting for USB controller to be idle\n");
6026 + }
6027 +}
6028 +
6029 +/* reset host controller */
6030 +static int crisv10_hcd_reset(struct usb_hcd *hcd)
6031 +{
6032 + DBFENTER;
6033 + hcd_dbg(hcd, "reset\n");
6034 +
6035 +
6036 + /* Reset the USB interface. */
6037 + /*
6038 + *R_USB_COMMAND =
6039 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
6040 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
6041 + IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
6042 + nop();
6043 + */
6044 + DBFEXIT;
6045 + return 0;
6046 +}
6047 +
6048 +/* start host controller */
6049 +static int crisv10_hcd_start(struct usb_hcd *hcd)
6050 +{
6051 + DBFENTER;
6052 + hcd_dbg(hcd, "start\n");
6053 +
6054 + crisv10_ready_wait();
6055 +
6056 + /* Start processing of USB traffic. */
6057 + *R_USB_COMMAND =
6058 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
6059 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
6060 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
6061 +
6062 + nop();
6063 +
6064 + hcd->state = HC_STATE_RUNNING;
6065 +
6066 + DBFEXIT;
6067 + return 0;
6068 +}
6069 +
6070 +/* stop host controller */
6071 +static void crisv10_hcd_stop(struct usb_hcd *hcd)
6072 +{
6073 + DBFENTER;
6074 + hcd_dbg(hcd, "stop\n");
6075 + crisv10_hcd_reset(hcd);
6076 + DBFEXIT;
6077 +}
6078 +
6079 +/* return the current frame number */
6080 +static int crisv10_hcd_get_frame(struct usb_hcd *hcd)
6081 +{
6082 + DBFENTER;
6083 + DBFEXIT;
6084 + return (*R_USB_FM_NUMBER & 0x7ff);
6085 +}
6086 +
6087 +#ifdef CONFIG_USB_OTG
6088 +
6089 +static int crisv10_hcd_start_port_reset(struct usb_hcd *hcd, unsigned port)
6090 +{
6091 + return 0; /* no-op for now */
6092 +}
6093 +
6094 +#endif /* CONFIG_USB_OTG */
6095 +
6096 +
6097 +/******************************************************************/
6098 +/* Root Hub functions */
6099 +/******************************************************************/
6100 +
6101 +/* root hub status */
6102 +static const struct usb_hub_status rh_hub_status =
6103 + {
6104 + .wHubStatus = 0,
6105 + .wHubChange = 0,
6106 + };
6107 +
6108 +/* root hub descriptor */
6109 +static const u8 rh_hub_descr[] =
6110 + {
6111 + 0x09, /* bDescLength */
6112 + 0x29, /* bDescriptorType */
6113 + USB_ROOT_HUB_PORTS, /* bNbrPorts */
6114 + 0x00, /* wHubCharacteristics */
6115 + 0x00,
6116 + 0x01, /* bPwrOn2pwrGood */
6117 + 0x00, /* bHubContrCurrent */
6118 + 0x00, /* DeviceRemovable */
6119 + 0xff /* PortPwrCtrlMask */
6120 + };
6121 +
6122 +/* Actual holder of root hub status*/
6123 +struct crisv10_rh rh;
6124 +
6125 +/* Initialize root hub data structures (called from dvdrv_hcd_probe()) */
6126 +int rh_init(void) {
6127 + int i;
6128 + /* Reset port status flags */
6129 + for (i = 0; i < USB_ROOT_HUB_PORTS; i++) {
6130 + rh.wPortChange[i] = 0;
6131 + rh.wPortStatusPrev[i] = 0;
6132 + }
6133 + return 0;
6134 +}
6135 +
6136 +#define RH_FEAT_MASK ((1<<USB_PORT_FEAT_CONNECTION)|\
6137 + (1<<USB_PORT_FEAT_ENABLE)|\
6138 + (1<<USB_PORT_FEAT_SUSPEND)|\
6139 + (1<<USB_PORT_FEAT_RESET))
6140 +
6141 +/* Handle port status change interrupt (called from bottom part interrupt) */
6142 +void rh_port_status_change(__u16 port_reg[]) {
6143 + int i;
6144 + __u16 wChange;
6145 +
6146 + for(i = 0; i < USB_ROOT_HUB_PORTS; i++) {
6147 + /* Xor out changes since last read, masked for important flags */
6148 + wChange = (port_reg[i] & RH_FEAT_MASK) ^ rh.wPortStatusPrev[i];
6149 + /* Or changes together with (if any) saved changes */
6150 + rh.wPortChange[i] |= wChange;
6151 + /* Save new status */
6152 + rh.wPortStatusPrev[i] = port_reg[i];
6153 +
6154 + if(wChange) {
6155 + rh_dbg("Interrupt port_status change port%d: %s Current-status:%s\n", i+1,
6156 + port_status_to_str(wChange),
6157 + port_status_to_str(port_reg[i]));
6158 + }
6159 + }
6160 +}
6161 +
6162 +/* Construct port status change bitmap for the root hub */
6163 +static int rh_status_data_request(struct usb_hcd *hcd, char *buf)
6164 +{
6165 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
6166 + unsigned int i;
6167 +
6168 + DBFENTER;
6169 + /*
6170 + * corresponds to hub status change EP (USB 2.0 spec section 11.13.4)
6171 + * return bitmap indicating ports with status change
6172 + */
6173 + *buf = 0;
6174 + spin_lock(&crisv10_hcd->lock);
6175 + for (i = 1; i <= crisv10_hcd->num_ports; i++) {
6176 + if (rh.wPortChange[map_port(i)]) {
6177 + *buf |= (1 << i);
6178 + rh_dbg("rh_status_data_request, change on port %d: %s Current Status: %s\n", i,
6179 + port_status_to_str(rh.wPortChange[map_port(i)]),
6180 + port_status_to_str(rh.wPortStatusPrev[map_port(i)]));
6181 + }
6182 + }
6183 + spin_unlock(&crisv10_hcd->lock);
6184 + DBFEXIT;
6185 + return *buf == 0 ? 0 : 1;
6186 +}
6187 +
6188 +/* Handle a control request for the root hub (called from hcd_driver) */
6189 +static int rh_control_request(struct usb_hcd *hcd,
6190 + u16 typeReq,
6191 + u16 wValue,
6192 + u16 wIndex,
6193 + char *buf,
6194 + u16 wLength) {
6195 +
6196 + struct crisv10_hcd *crisv10_hcd = hcd_to_crisv10_hcd(hcd);
6197 + int retval = 0;
6198 + int len;
6199 + DBFENTER;
6200 +
6201 + switch (typeReq) {
6202 + case GetHubDescriptor:
6203 + rh_dbg("GetHubDescriptor\n");
6204 + len = min_t(unsigned int, sizeof rh_hub_descr, wLength);
6205 + memcpy(buf, rh_hub_descr, len);
6206 + buf[2] = crisv10_hcd->num_ports;
6207 + break;
6208 + case GetHubStatus:
6209 + rh_dbg("GetHubStatus\n");
6210 + len = min_t(unsigned int, sizeof rh_hub_status, wLength);
6211 + memcpy(buf, &rh_hub_status, len);
6212 + break;
6213 + case GetPortStatus:
6214 + if (!wIndex || wIndex > crisv10_hcd->num_ports)
6215 + goto error;
6216 + rh_dbg("GetportStatus, port:%d change:%s status:%s\n", wIndex,
6217 + port_status_to_str(rh.wPortChange[map_port(wIndex)]),
6218 + port_status_to_str(rh.wPortStatusPrev[map_port(wIndex)]));
6219 + *(u16 *) buf = cpu_to_le16(rh.wPortStatusPrev[map_port(wIndex)]);
6220 + *(u16 *) (buf + 2) = cpu_to_le16(rh.wPortChange[map_port(wIndex)]);
6221 + break;
6222 + case SetHubFeature:
6223 + rh_dbg("SetHubFeature\n");
6224 + case ClearHubFeature:
6225 + rh_dbg("ClearHubFeature\n");
6226 + switch (wValue) {
6227 + case C_HUB_OVER_CURRENT:
6228 + case C_HUB_LOCAL_POWER:
6229 + rh_warn("Not implemented hub request:%d \n", typeReq);
6230 + /* not implemented */
6231 + break;
6232 + default:
6233 + goto error;
6234 + }
6235 + break;
6236 + case SetPortFeature:
6237 + if (!wIndex || wIndex > crisv10_hcd->num_ports)
6238 + goto error;
6239 + if(rh_set_port_feature(map_port(wIndex), wValue))
6240 + goto error;
6241 + break;
6242 + case ClearPortFeature:
6243 + if (!wIndex || wIndex > crisv10_hcd->num_ports)
6244 + goto error;
6245 + if(rh_clear_port_feature(map_port(wIndex), wValue))
6246 + goto error;
6247 + break;
6248 + default:
6249 + rh_warn("Unknown hub request: %d\n", typeReq);
6250 + error:
6251 + retval = -EPIPE;
6252 + }
6253 + DBFEXIT;
6254 + return retval;
6255 +}
6256 +
6257 +int rh_set_port_feature(__u8 bPort, __u16 wFeature) {
6258 + __u8 bUsbCommand = 0;
6259 + switch(wFeature) {
6260 + case USB_PORT_FEAT_RESET:
6261 + rh_dbg("SetPortFeature: reset\n");
6262 + bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, reset);
6263 + goto set;
6264 + break;
6265 + case USB_PORT_FEAT_SUSPEND:
6266 + rh_dbg("SetPortFeature: suspend\n");
6267 + bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, suspend);
6268 + goto set;
6269 + break;
6270 + case USB_PORT_FEAT_POWER:
6271 + rh_dbg("SetPortFeature: power\n");
6272 + break;
6273 + case USB_PORT_FEAT_C_CONNECTION:
6274 + rh_dbg("SetPortFeature: c_connection\n");
6275 + break;
6276 + case USB_PORT_FEAT_C_RESET:
6277 + rh_dbg("SetPortFeature: c_reset\n");
6278 + break;
6279 + case USB_PORT_FEAT_C_OVER_CURRENT:
6280 + rh_dbg("SetPortFeature: c_over_current\n");
6281 + break;
6282 +
6283 + set:
6284 + /* Select which port via the port_sel field */
6285 + bUsbCommand |= IO_FIELD(R_USB_COMMAND, port_sel, bPort+1);
6286 +
6287 + /* Make sure the controller isn't busy. */
6288 + crisv10_ready_wait();
6289 + /* Send out the actual command to the USB controller */
6290 + *R_USB_COMMAND = bUsbCommand;
6291 +
6292 + /* If port reset then also bring USB controller into running state */
6293 + if(wFeature == USB_PORT_FEAT_RESET) {
6294 + /* Wait a while for controller to first become started after port reset */
6295 + udelay(12000); /* 12ms blocking wait */
6296 +
6297 + /* Make sure the controller isn't busy. */
6298 + crisv10_ready_wait();
6299 +
6300 + /* If all enabled ports were disabled the host controller goes down into
6301 + started mode, so we need to bring it back into the running state.
6302 + (This is safe even if it's already in the running state.) */
6303 + *R_USB_COMMAND =
6304 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
6305 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
6306 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
6307 + }
6308 +
6309 + break;
6310 + default:
6311 + rh_dbg("SetPortFeature: unknown feature\n");
6312 + return -1;
6313 + }
6314 + return 0;
6315 +}
6316 +
6317 +int rh_clear_port_feature(__u8 bPort, __u16 wFeature) {
6318 + switch(wFeature) {
6319 + case USB_PORT_FEAT_ENABLE:
6320 + rh_dbg("ClearPortFeature: enable\n");
6321 + rh_disable_port(bPort);
6322 + break;
6323 + case USB_PORT_FEAT_SUSPEND:
6324 + rh_dbg("ClearPortFeature: suspend\n");
6325 + break;
6326 + case USB_PORT_FEAT_POWER:
6327 + rh_dbg("ClearPortFeature: power\n");
6328 + break;
6329 +
6330 + case USB_PORT_FEAT_C_ENABLE:
6331 + rh_dbg("ClearPortFeature: c_enable\n");
6332 + goto clear;
6333 + case USB_PORT_FEAT_C_SUSPEND:
6334 + rh_dbg("ClearPortFeature: c_suspend\n");
6335 + goto clear;
6336 + case USB_PORT_FEAT_C_CONNECTION:
6337 + rh_dbg("ClearPortFeature: c_connection\n");
6338 + goto clear;
6339 + case USB_PORT_FEAT_C_OVER_CURRENT:
6340 + rh_dbg("ClearPortFeature: c_over_current\n");
6341 + goto clear;
6342 + case USB_PORT_FEAT_C_RESET:
6343 + rh_dbg("ClearPortFeature: c_reset\n");
6344 + goto clear;
6345 + clear:
6346 + rh.wPortChange[bPort] &= ~(1 << (wFeature - 16));
6347 + break;
6348 + default:
6349 + rh_dbg("ClearPortFeature: unknown feature\n");
6350 + return -1;
6351 + }
6352 + return 0;
6353 +}
6354 +
6355 +
6356 +#ifdef CONFIG_PM
6357 +/* Handle a suspend request for the root hub (called from hcd_driver) */
6358 +static int rh_suspend_request(struct usb_hcd *hcd)
6359 +{
6360 + return 0; /* no-op for now */
6361 +}
6362 +
6363 +/* Handle a resume request for the root hub (called from hcd_driver) */
6364 +static int rh_resume_request(struct usb_hcd *hcd)
6365 +{
6366 + return 0; /* no-op for now */
6367 +}
6368 +#endif /* CONFIG_PM */
6369 +
6370 +
6371 +
6372 +/* Wrapper function for workaround port disable registers in USB controller */
6373 +static void rh_disable_port(unsigned int port) {
6374 + volatile int timeout = 10000;
6375 + volatile char* usb_portx_disable;
6376 + switch(port) {
6377 + case 0:
6378 + usb_portx_disable = R_USB_PORT1_DISABLE;
6379 + break;
6380 + case 1:
6381 + usb_portx_disable = R_USB_PORT2_DISABLE;
6382 + break;
6383 + default:
6384 + /* Invalid port index */
6385 + return;
6386 + }
6387 + /* Set disable flag in special register */
6388 + *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
6389 + /* Wait until not enabled anymore */
6390 + while((rh.wPortStatusPrev[port] &
6391 + IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) &&
6392 + (timeout-- > 0));
6393 + if(timeout == 0) {
6394 + warn("Timeout while waiting for port %d to become disabled\n", port);
6395 + }
6396 + /* clear disable flag in special register */
6397 + *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
6398 + rh_info("Physical port %d disabled\n", port+1);
6399 +}
6400 +
6401 +
6402 +/******************************************************************/
6403 +/* Transfer Controller (TC) functions */
6404 +/******************************************************************/
6405 +
6406 +/* FIXME: Should RX_BUF_SIZE be a config option, or maybe we should adjust it
6407 + dynamically?
6408 + To adjust it dynamically we would have to get an interrupt when we reach
6409 + the end of the rx descriptor list, or when we get close to the end, and
6410 + then allocate more descriptors. */
6411 +#define NBR_OF_RX_DESC 512
6412 +#define RX_DESC_BUF_SIZE 1024
6413 +#define RX_BUF_SIZE (NBR_OF_RX_DESC * RX_DESC_BUF_SIZE)
6414
6415 - myNextRxDesc = &RxDescList[0];
6416 - myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
6417 - myPrevRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
6418
6419 - *R_DMA_CH9_FIRST = virt_to_phys(myNextRxDesc);
6420 - *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, start);
6421 +/* Local variables for Transfer Controller */
6422 +/* --------------------------------------- */
6423
6424 - DBFEXIT;
6425 -}
6426 +/* This is a circular (double-linked) list of the active urbs for each epid.
6427 + The head is never removed, and new urbs are linked onto the list as
6428 + urb_entry_t elements. Don't reference urb_list directly; use the wrapper
6429 + functions instead (which includes spin_locks) */
6430 +static struct list_head urb_list[NBR_OF_EPIDS];
6431
6432 -static void init_tx_bulk_ep(void)
6433 -{
6434 - int i;
6435 +/* Read about the need and usage of this lock in submit_ctrl_urb. */
6436 +/* Lock for URB lists for each EPID */
6437 +static spinlock_t urb_list_lock;
6438
6439 - DBFENTER;
6440 +/* Lock for EPID array register (R_USB_EPT_x) in Etrax */
6441 +static spinlock_t etrax_epid_lock;
6442
6443 - for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
6444 - CHECK_ALIGN(&TxBulkEPList[i]);
6445 - TxBulkEPList[i].hw_len = 0;
6446 - TxBulkEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
6447 - TxBulkEPList[i].sub = 0;
6448 - TxBulkEPList[i].next = virt_to_phys(&TxBulkEPList[i + 1]);
6449 -
6450 - /* Initiate two EPs, disabled and with the eol flag set. No need for any
6451 - preserved epid. */
6452 -
6453 - /* The first one has the intr flag set so we get an interrupt when the DMA
6454 - channel is about to become disabled. */
6455 - CHECK_ALIGN(&TxBulkDummyEPList[i][0]);
6456 - TxBulkDummyEPList[i][0].hw_len = 0;
6457 - TxBulkDummyEPList[i][0].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
6458 - IO_STATE(USB_EP_command, eol, yes) |
6459 - IO_STATE(USB_EP_command, intr, yes));
6460 - TxBulkDummyEPList[i][0].sub = 0;
6461 - TxBulkDummyEPList[i][0].next = virt_to_phys(&TxBulkDummyEPList[i][1]);
6462 -
6463 - /* The second one. */
6464 - CHECK_ALIGN(&TxBulkDummyEPList[i][1]);
6465 - TxBulkDummyEPList[i][1].hw_len = 0;
6466 - TxBulkDummyEPList[i][1].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
6467 - IO_STATE(USB_EP_command, eol, yes));
6468 - TxBulkDummyEPList[i][1].sub = 0;
6469 - /* The last dummy's next pointer is the same as the current EP's next pointer. */
6470 - TxBulkDummyEPList[i][1].next = virt_to_phys(&TxBulkEPList[i + 1]);
6471 - }
6472 +/* Lock for dma8 sub0 handling */
6473 +static spinlock_t etrax_dma8_sub0_lock;
6474
6475 - /* Configure the last one. */
6476 - CHECK_ALIGN(&TxBulkEPList[i]);
6477 - TxBulkEPList[i].hw_len = 0;
6478 - TxBulkEPList[i].command = (IO_STATE(USB_EP_command, eol, yes) |
6479 - IO_FIELD(USB_EP_command, epid, i));
6480 - TxBulkEPList[i].sub = 0;
6481 - TxBulkEPList[i].next = virt_to_phys(&TxBulkEPList[0]);
6482 -
6483 - /* No need configuring dummy EPs for the last one as it will never be used for
6484 - bulk traffic (i == INVALD_EPID at this point). */
6485 -
6486 - /* Set up to start on the last EP so we will enable it when inserting traffic
6487 - for the first time (imitating the situation where the DMA has stopped
6488 - because there was no more traffic). */
6489 - *R_DMA_CH8_SUB0_EP = virt_to_phys(&TxBulkEPList[i]);
6490 - /* No point in starting the bulk channel yet.
6491 - *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
6492 - DBFEXIT;
6493 -}
6494 +/* DMA IN cache bug. Align the DMA IN buffers to 32 bytes, i.e. a cache line.
6495 + Since RX_DESC_BUF_SIZE is 1024 is a multiple of 32, all rx buffers will be
6496 + cache aligned. */
6497 +static volatile unsigned char RxBuf[RX_BUF_SIZE] __attribute__ ((aligned (32)));
6498 +static volatile struct USB_IN_Desc RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned (4)));
6499
6500 -static void init_tx_ctrl_ep(void)
6501 -{
6502 - int i;
6503 +/* Pointers into RxDescList. */
6504 +static volatile struct USB_IN_Desc *myNextRxDesc;
6505 +static volatile struct USB_IN_Desc *myLastRxDesc;
6506
6507 - DBFENTER;
6508 +/* A zout transfer makes a memory access at the address of its buf pointer,
6509 + which means that setting this buf pointer to 0 will cause an access to the
6510 + flash. In addition to this, setting sw_len to 0 results in a 16/32 bytes
6511 + (depending on DMA burst size) transfer.
6512 + Instead, we set it to 1, and point it to this buffer. */
6513 +static int zout_buffer[4] __attribute__ ((aligned (4)));
6514
6515 - for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
6516 - CHECK_ALIGN(&TxCtrlEPList[i]);
6517 - TxCtrlEPList[i].hw_len = 0;
6518 - TxCtrlEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
6519 - TxCtrlEPList[i].sub = 0;
6520 - TxCtrlEPList[i].next = virt_to_phys(&TxCtrlEPList[i + 1]);
6521 - }
6522 +/* Cache for allocating new EP and SB descriptors. */
6523 +static kmem_cache_t *usb_desc_cache;
6524
6525 - CHECK_ALIGN(&TxCtrlEPList[i]);
6526 - TxCtrlEPList[i].hw_len = 0;
6527 - TxCtrlEPList[i].command = (IO_STATE(USB_EP_command, eol, yes) |
6528 - IO_FIELD(USB_EP_command, epid, i));
6529 +/* Cache for the data allocated in the isoc descr top half. */
6530 +static kmem_cache_t *isoc_compl_cache;
6531
6532 - TxCtrlEPList[i].sub = 0;
6533 - TxCtrlEPList[i].next = virt_to_phys(&TxCtrlEPList[0]);
6534 +/* Cache for the data allocated when delayed finishing of URBs */
6535 +static kmem_cache_t *later_data_cache;
6536
6537 - *R_DMA_CH8_SUB1_EP = virt_to_phys(&TxCtrlEPList[0]);
6538 - *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
6539
6540 - DBFEXIT;
6541 +/* Counter to keep track of how many Isoc EP we have sat up. Used to enable
6542 + and disable iso_eof interrupt. We only need these interrupts when we have
6543 + Isoc data endpoints (consumes CPU cycles).
6544 + FIXME: This could be more fine granular, so this interrupt is only enabled
6545 + when we have a In Isoc URB not URB_ISO_ASAP flaged queued. */
6546 +static int isoc_epid_counter;
6547 +
6548 +/* Protecting wrapper functions for R_USB_EPT_x */
6549 +/* -------------------------------------------- */
6550 +static inline void etrax_epid_set(__u8 index, __u32 data) {
6551 + unsigned long flags;
6552 + spin_lock_irqsave(&etrax_epid_lock, flags);
6553 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
6554 + nop();
6555 + *R_USB_EPT_DATA = data;
6556 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
6557 +}
6558 +
6559 +static inline void etrax_epid_clear_error(__u8 index) {
6560 + unsigned long flags;
6561 + spin_lock_irqsave(&etrax_epid_lock, flags);
6562 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
6563 + nop();
6564 + *R_USB_EPT_DATA &=
6565 + ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
6566 + IO_MASK(R_USB_EPT_DATA, error_count_out) |
6567 + IO_MASK(R_USB_EPT_DATA, error_code));
6568 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
6569 +}
6570 +
6571 +static inline void etrax_epid_set_toggle(__u8 index, __u8 dirout,
6572 + __u8 toggle) {
6573 + unsigned long flags;
6574 + spin_lock_irqsave(&etrax_epid_lock, flags);
6575 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
6576 + nop();
6577 + if(dirout) {
6578 + *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_out);
6579 + *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_out, toggle);
6580 + } else {
6581 + *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_in);
6582 + *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_in, toggle);
6583 + }
6584 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
6585 +}
6586 +
6587 +static inline __u8 etrax_epid_get_toggle(__u8 index, __u8 dirout) {
6588 + unsigned long flags;
6589 + __u8 toggle;
6590 + spin_lock_irqsave(&etrax_epid_lock, flags);
6591 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
6592 + nop();
6593 + if (dirout) {
6594 + toggle = IO_EXTRACT(R_USB_EPT_DATA, t_out, *R_USB_EPT_DATA);
6595 + } else {
6596 + toggle = IO_EXTRACT(R_USB_EPT_DATA, t_in, *R_USB_EPT_DATA);
6597 + }
6598 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
6599 + return toggle;
6600 +}
6601 +
6602 +
6603 +static inline __u32 etrax_epid_get(__u8 index) {
6604 + unsigned long flags;
6605 + __u32 data;
6606 + spin_lock_irqsave(&etrax_epid_lock, flags);
6607 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
6608 + nop();
6609 + data = *R_USB_EPT_DATA;
6610 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
6611 + return data;
6612 +}
6613 +
6614 +
6615 +
6616 +
6617 +/* Main functions for Transfer Controller */
6618 +/* -------------------------------------- */
6619 +
6620 +/* Init structs, memories and lists used by Transfer Controller */
6621 +int tc_init(struct usb_hcd *hcd) {
6622 + int i;
6623 + /* Clear software state info for all epids */
6624 + memset(epid_state, 0, sizeof(struct etrax_epid) * NBR_OF_EPIDS);
6625 +
6626 + /* Set Invalid and Dummy as being in use and disabled */
6627 + epid_state[INVALID_EPID].inuse = 1;
6628 + epid_state[DUMMY_EPID].inuse = 1;
6629 + epid_state[INVALID_EPID].disabled = 1;
6630 + epid_state[DUMMY_EPID].disabled = 1;
6631 +
6632 + /* Clear counter for how many Isoc epids we have sat up */
6633 + isoc_epid_counter = 0;
6634 +
6635 + /* Initialize the urb list by initiating a head for each list.
6636 + Also reset list hodling active URB for each epid */
6637 + for (i = 0; i < NBR_OF_EPIDS; i++) {
6638 + INIT_LIST_HEAD(&urb_list[i]);
6639 + activeUrbList[i] = NULL;
6640 + }
6641 +
6642 + /* Init lock for URB lists */
6643 + spin_lock_init(&urb_list_lock);
6644 + /* Init lock for Etrax R_USB_EPT register */
6645 + spin_lock_init(&etrax_epid_lock);
6646 + /* Init lock for Etrax dma8 sub0 handling */
6647 + spin_lock_init(&etrax_dma8_sub0_lock);
6648 +
6649 + /* We use kmem_cache_* to make sure that all DMA desc. are dword aligned */
6650 +
6651 + /* Note that we specify sizeof(struct USB_EP_Desc) as the size, but also
6652 + allocate SB descriptors from this cache. This is ok since
6653 + sizeof(struct USB_EP_Desc) == sizeof(struct USB_SB_Desc). */
6654 + usb_desc_cache = kmem_cache_create("usb_desc_cache",
6655 + sizeof(struct USB_EP_Desc), 0,
6656 + SLAB_HWCACHE_ALIGN, 0, 0);
6657 + if(usb_desc_cache == NULL) {
6658 + return -ENOMEM;
6659 + }
6660 +
6661 + /* Create slab cache for speedy allocation of memory for isoc bottom-half
6662 + interrupt handling */
6663 + isoc_compl_cache =
6664 + kmem_cache_create("isoc_compl_cache",
6665 + sizeof(struct crisv10_isoc_complete_data),
6666 + 0, SLAB_HWCACHE_ALIGN, 0, 0);
6667 + if(isoc_compl_cache == NULL) {
6668 + return -ENOMEM;
6669 + }
6670 +
6671 + /* Create slab cache for speedy allocation of memory for later URB finish
6672 + struct */
6673 + later_data_cache =
6674 + kmem_cache_create("later_data_cache",
6675 + sizeof(struct urb_later_data),
6676 + 0, SLAB_HWCACHE_ALIGN, 0, 0);
6677 + if(later_data_cache == NULL) {
6678 + return -ENOMEM;
6679 + }
6680 +
6681 +
6682 + /* Initiate the bulk start timer. */
6683 + init_timer(&bulk_start_timer);
6684 + bulk_start_timer.expires = jiffies + BULK_START_TIMER_INTERVAL;
6685 + bulk_start_timer.function = tc_bulk_start_timer_func;
6686 + add_timer(&bulk_start_timer);
6687 +
6688 +
6689 + /* Initiate the bulk eot timer. */
6690 + init_timer(&bulk_eot_timer);
6691 + bulk_eot_timer.expires = jiffies + BULK_EOT_TIMER_INTERVAL;
6692 + bulk_eot_timer.function = tc_bulk_eot_timer_func;
6693 + bulk_eot_timer.data = (unsigned long)hcd;
6694 + add_timer(&bulk_eot_timer);
6695 +
6696 + return 0;
6697 +}
6698 +
6699 +/* Uninitialize all resources used by Transfer Controller */
6700 +void tc_destroy(void) {
6701 +
6702 + /* Destroy all slab cache */
6703 + kmem_cache_destroy(usb_desc_cache);
6704 + kmem_cache_destroy(isoc_compl_cache);
6705 + kmem_cache_destroy(later_data_cache);
6706 +
6707 + /* Remove timers */
6708 + del_timer(&bulk_start_timer);
6709 + del_timer(&bulk_eot_timer);
6710 +}
6711 +
6712 +static void restart_dma8_sub0(void) {
6713 + unsigned long flags;
6714 + spin_lock_irqsave(&etrax_dma8_sub0_lock, flags);
6715 + /* Verify that the dma is not running */
6716 + if ((*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd)) == 0) {
6717 + struct USB_EP_Desc *ep = (struct USB_EP_Desc *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
6718 + while (DUMMY_EPID == IO_EXTRACT(USB_EP_command, epid, ep->command)) {
6719 + ep = (struct USB_EP_Desc *)phys_to_virt(ep->next);
6720 + }
6721 + /* Advance the DMA to the next EP descriptor that is not a DUMMY_EPID.
6722 + * ep->next is already a physical address; no need for a virt_to_phys. */
6723 + *R_DMA_CH8_SUB0_EP = ep->next;
6724 + /* Restart the DMA */
6725 + *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
6726 + }
6727 + spin_unlock_irqrestore(&etrax_dma8_sub0_lock, flags);
6728 +}
6729 +
6730 +/* queue an URB with the transfer controller (called from hcd_driver) */
6731 +static int tc_urb_enqueue(struct usb_hcd *hcd,
6732 + struct usb_host_endpoint *ep,
6733 + struct urb *urb,
6734 + gfp_t mem_flags) {
6735 + int epid;
6736 + int retval;
6737 + int bustime = 0;
6738 + int maxpacket;
6739 + unsigned long flags;
6740 + struct crisv10_urb_priv *urb_priv;
6741 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
6742 + DBFENTER;
6743 +
6744 + if(!(crisv10_hcd->running)) {
6745 + /* The USB Controller is not running, probably because no device is
6746 + attached. No idea to enqueue URBs then */
6747 + tc_warn("Rejected enqueueing of URB:0x%x because no dev attached\n",
6748 + (unsigned int)urb);
6749 + return -ENOENT;
6750 + }
6751 +
6752 + maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
6753 + /* Special case check for In Isoc transfers. Specification states that each
6754 + In Isoc transfer consists of one packet and therefore it should fit into
6755 + the transfer-buffer of an URB.
6756 + We do the check here to be sure (an invalid scenario can be produced with
6757 + parameters to the usbtest suite) */
6758 + if(usb_pipeisoc(urb->pipe) && usb_pipein(urb->pipe) &&
6759 + (urb->transfer_buffer_length < maxpacket)) {
6760 + tc_err("Submit In Isoc URB with buffer length:%d to pipe with maxpacketlen: %d\n", urb->transfer_buffer_length, maxpacket);
6761 + return -EMSGSIZE;
6762 + }
6763 +
6764 + /* Check if there is enough bandwidth for periodic transfer */
6765 + if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe)) {
6766 + /* only check (and later claim) if not already claimed */
6767 + if (urb->bandwidth == 0) {
6768 + bustime = usb_check_bandwidth(urb->dev, urb);
6769 + if (bustime < 0) {
6770 + tc_err("Not enough periodic bandwidth\n");
6771 + return -ENOSPC;
6772 + }
6773 + }
6774 + }
6775 +
6776 + /* Check if there is a epid for URBs destination, if not this function
6777 + set up one. */
6778 + epid = tc_setup_epid(ep, urb, mem_flags);
6779 + if (epid < 0) {
6780 + tc_err("Failed setup epid:%d for URB:0x%x\n", epid, (unsigned int)urb);
6781 + DBFEXIT;
6782 + return -ENOMEM;
6783 + }
6784 +
6785 + if(urb == activeUrbList[epid]) {
6786 + tc_err("Resubmition of allready active URB:0x%x\n", (unsigned int)urb);
6787 + return -ENXIO;
6788 + }
6789 +
6790 + if(urb_list_entry(urb, epid)) {
6791 + tc_err("Resubmition of allready queued URB:0x%x\n", (unsigned int)urb);
6792 + return -ENXIO;
6793 + }
6794 +
6795 + /* If we actively have flaged endpoint as disabled then refuse submition */
6796 + if(epid_state[epid].disabled) {
6797 + return -ENOENT;
6798 + }
6799 +
6800 + /* Allocate and init HC-private data for URB */
6801 + if(urb_priv_create(hcd, urb, epid, mem_flags) != 0) {
6802 + DBFEXIT;
6803 + return -ENOMEM;
6804 + }
6805 + urb_priv = urb->hcpriv;
6806 +
6807 + tc_dbg("Enqueue URB:0x%x[%d] epid:%d (%s) bufflen:%d\n",
6808 + (unsigned int)urb, urb_priv->urb_num, epid,
6809 + pipe_to_str(urb->pipe), urb->transfer_buffer_length);
6810 +
6811 + /* Create and link SBs required for this URB */
6812 + retval = create_sb_for_urb(urb, mem_flags);
6813 + if(retval != 0) {
6814 + tc_err("Failed to create SBs for URB:0x%x[%d]\n", (unsigned int)urb,
6815 + urb_priv->urb_num);
6816 + urb_priv_free(hcd, urb);
6817 + DBFEXIT;
6818 + return retval;
6819 + }
6820 +
6821 + /* Init intr EP pool if this URB is a INTR transfer. This pool is later
6822 + used when inserting EPs in the TxIntrEPList. We do the alloc here
6823 + so we can't run out of memory later */
6824 + if(usb_pipeint(urb->pipe)) {
6825 + retval = init_intr_urb(urb, mem_flags);
6826 + if(retval != 0) {
6827 + tc_warn("Failed to init Intr URB\n");
6828 + urb_priv_free(hcd, urb);
6829 + DBFEXIT;
6830 + return retval;
6831 + }
6832 + }
6833 +
6834 + /* Disable other access when inserting USB */
6835 + local_irq_save(flags);
6836 +
6837 + /* Claim bandwidth, if needed */
6838 + if(bustime) {
6839 + usb_claim_bandwidth(urb->dev, urb, bustime, 0);
6840 + }
6841 +
6842 + /* Add URB to EP queue */
6843 + urb_list_add(urb, epid, mem_flags);
6844 +
6845 + if(usb_pipeisoc(urb->pipe)) {
6846 + /* Special processing of Isoc URBs. */
6847 + tc_dma_process_isoc_urb(urb);
6848 + } else {
6849 + /* Process EP queue for rest of the URB types (Bulk, Ctrl, Intr) */
6850 + tc_dma_process_queue(epid);
6851 + }
6852 +
6853 + local_irq_restore(flags);
6854 +
6855 + DBFEXIT;
6856 + return 0;
6857 +}
6858 +
6859 +/* remove an URB from the transfer controller queues (called from hcd_driver)*/
6860 +static int tc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb) {
6861 + struct crisv10_urb_priv *urb_priv;
6862 + unsigned long flags;
6863 + int epid;
6864 +
6865 + DBFENTER;
6866 + /* Disable interrupts here since a descriptor interrupt for the isoc epid
6867 + will modify the sb list. This could possibly be done more granular, but
6868 + urb_dequeue should not be used frequently anyway.
6869 + */
6870 + local_irq_save(flags);
6871 +
6872 + urb_priv = urb->hcpriv;
6873 +
6874 + if (!urb_priv) {
6875 + /* This happens if a device driver calls unlink on an urb that
6876 + was never submitted (lazy driver) or if the urb was completed
6877 + while dequeue was being called. */
6878 + tc_warn("Dequeing of not enqueued URB:0x%x\n", (unsigned int)urb);
6879 + local_irq_restore(flags);
6880 + return 0;
6881 + }
6882 + epid = urb_priv->epid;
6883 +
6884 + tc_warn("Dequeing %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
6885 + (urb == activeUrbList[epid]) ? "active" : "queued",
6886 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
6887 + str_type(urb->pipe), epid, urb->status,
6888 + (urb_priv->later_data) ? "later-sched" : "");
6889 +
6890 + /* For Bulk, Ctrl and Intr are only one URB active at a time. So any URB
6891 + that isn't active can be dequeued by just removing it from the queue */
6892 + if(usb_pipebulk(urb->pipe) || usb_pipecontrol(urb->pipe) ||
6893 + usb_pipeint(urb->pipe)) {
6894 +
6895 + /* Check if URB haven't gone further than the queue */
6896 + if(urb != activeUrbList[epid]) {
6897 + ASSERT(urb_priv->later_data == NULL);
6898 + tc_warn("Dequeing URB:0x%x[%d] (%s %s epid:%d) from queue"
6899 + " (not active)\n", (unsigned int)urb, urb_priv->urb_num,
6900 + str_dir(urb->pipe), str_type(urb->pipe), epid);
6901 +
6902 + /* Finish the URB with error status from USB core */
6903 + tc_finish_urb(hcd, urb, urb->status);
6904 + local_irq_restore(flags);
6905 + return 0;
6906 + }
6907 + }
6908 +
6909 + /* Set URB status to Unlink for handling when interrupt comes. */
6910 + urb_priv->urb_state = UNLINK;
6911 +
6912 + /* Differentiate dequeing of Bulk and Ctrl from Isoc and Intr */
6913 + switch(usb_pipetype(urb->pipe)) {
6914 + case PIPE_BULK:
6915 + /* Check if EP still is enabled */
6916 + if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
6917 + /* The EP was enabled, disable it. */
6918 + TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
6919 + }
6920 + /* Kicking dummy list out of the party. */
6921 + TxBulkEPList[epid].next = virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
6922 + break;
6923 + case PIPE_CONTROL:
6924 + /* Check if EP still is enabled */
6925 + if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
6926 + /* The EP was enabled, disable it. */
6927 + TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
6928 + }
6929 + break;
6930 + case PIPE_ISOCHRONOUS:
6931 + /* Disabling, busy-wait and unlinking of Isoc SBs will be done in
6932 + finish_isoc_urb(). Because there might the case when URB is dequeued
6933 + but there are other valid URBs waiting */
6934 +
6935 + /* Check if In Isoc EP still is enabled */
6936 + if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
6937 + /* The EP was enabled, disable it. */
6938 + TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
6939 + }
6940 + break;
6941 + case PIPE_INTERRUPT:
6942 + /* Special care is taken for interrupt URBs. EPs are unlinked in
6943 + tc_finish_urb */
6944 + break;
6945 + default:
6946 + break;
6947 + }
6948 +
6949 + /* Asynchronous unlink, finish the URB later from scheduled or other
6950 + event (data finished, error) */
6951 + tc_finish_urb_later(hcd, urb, urb->status);
6952 +
6953 + local_irq_restore(flags);
6954 + DBFEXIT;
6955 + return 0;
6956 +}
6957 +
6958 +
6959 +static void tc_sync_finish_epid(struct usb_hcd *hcd, int epid) {
6960 + volatile int timeout = 10000;
6961 + struct urb* urb;
6962 + struct crisv10_urb_priv* urb_priv;
6963 + unsigned long flags;
6964 +
6965 + volatile struct USB_EP_Desc *first_ep; /* First EP in the list. */
6966 + volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
6967 + volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
6968 +
6969 + int type = epid_state[epid].type;
6970 +
6971 + /* Setting this flag will cause enqueue() to return -ENOENT for new
6972 + submitions on this endpoint and finish_urb() wont process queue further */
6973 + epid_state[epid].disabled = 1;
6974 +
6975 + switch(type) {
6976 + case PIPE_BULK:
6977 + /* Check if EP still is enabled */
6978 + if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
6979 + /* The EP was enabled, disable it. */
6980 + TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
6981 + tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
6982 +
6983 + /* Do busy-wait until DMA not using this EP descriptor anymore */
6984 + while((*R_DMA_CH8_SUB0_EP ==
6985 + virt_to_phys(&TxBulkEPList[epid])) &&
6986 + (timeout-- > 0));
6987 + if(timeout == 0) {
6988 + warn("Timeout while waiting for DMA-TX-Bulk to leave EP for"
6989 + " epid:%d\n", epid);
6990 + }
6991 + }
6992 + break;
6993 +
6994 + case PIPE_CONTROL:
6995 + /* Check if EP still is enabled */
6996 + if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
6997 + /* The EP was enabled, disable it. */
6998 + TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
6999 + tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
7000 +
7001 + /* Do busy-wait until DMA not using this EP descriptor anymore */
7002 + while((*R_DMA_CH8_SUB1_EP ==
7003 + virt_to_phys(&TxCtrlEPList[epid])) &&
7004 + (timeout-- > 0));
7005 + if(timeout == 0) {
7006 + warn("Timeout while waiting for DMA-TX-Ctrl to leave EP for"
7007 + " epid:%d\n", epid);
7008 + }
7009 + }
7010 + break;
7011 +
7012 + case PIPE_INTERRUPT:
7013 + local_irq_save(flags);
7014 + /* Disable all Intr EPs belonging to epid */
7015 + first_ep = &TxIntrEPList[0];
7016 + curr_ep = first_ep;
7017 + do {
7018 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
7019 + if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
7020 + /* Disable EP */
7021 + next_ep->command &= ~IO_MASK(USB_EP_command, enable);
7022 + }
7023 + curr_ep = phys_to_virt(curr_ep->next);
7024 + } while (curr_ep != first_ep);
7025 +
7026 + local_irq_restore(flags);
7027 + break;
7028 +
7029 + case PIPE_ISOCHRONOUS:
7030 + /* Check if EP still is enabled */
7031 + if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
7032 + tc_warn("sync_finish: Disabling Isoc EP for epid:%d\n", epid);
7033 + /* The EP was enabled, disable it. */
7034 + TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
7035 +
7036 + while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
7037 + (timeout-- > 0));
7038 + if(timeout == 0) {
7039 + warn("Timeout while waiting for DMA-TX-Isoc to leave EP for"
7040 + " epid:%d\n", epid);
7041 + }
7042 + }
7043 + break;
7044 + }
7045 +
7046 + local_irq_save(flags);
7047 +
7048 + /* Finish if there is active URB for this endpoint */
7049 + if(activeUrbList[epid] != NULL) {
7050 + urb = activeUrbList[epid];
7051 + urb_priv = urb->hcpriv;
7052 + ASSERT(urb_priv);
7053 + tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
7054 + (urb == activeUrbList[epid]) ? "active" : "queued",
7055 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
7056 + str_type(urb->pipe), epid, urb->status,
7057 + (urb_priv->later_data) ? "later-sched" : "");
7058 +
7059 + tc_finish_urb(hcd, activeUrbList[epid], -ENOENT);
7060 + ASSERT(activeUrbList[epid] == NULL);
7061 + }
7062 +
7063 + /* Finish any queued URBs for this endpoint. There won't be any resubmitions
7064 + because epid_disabled causes enqueue() to fail for this endpoint */
7065 + while((urb = urb_list_first(epid)) != NULL) {
7066 + urb_priv = urb->hcpriv;
7067 + ASSERT(urb_priv);
7068 +
7069 + tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
7070 + (urb == activeUrbList[epid]) ? "active" : "queued",
7071 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
7072 + str_type(urb->pipe), epid, urb->status,
7073 + (urb_priv->later_data) ? "later-sched" : "");
7074 +
7075 + tc_finish_urb(hcd, urb, -ENOENT);
7076 + }
7077 + epid_state[epid].disabled = 0;
7078 + local_irq_restore(flags);
7079 +}
7080 +
7081 +/* free resources associated with an endpoint (called from hcd_driver) */
7082 +static void tc_endpoint_disable(struct usb_hcd *hcd,
7083 + struct usb_host_endpoint *ep) {
7084 + DBFENTER;
7085 + /* Only free epid if it has been allocated. We get two endpoint_disable
7086 + requests for ctrl endpoints so ignore the second one */
7087 + if(ep->hcpriv != NULL) {
7088 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
7089 + int epid = ep_priv->epid;
7090 + tc_warn("endpoint_disable ep:0x%x ep-priv:0x%x (%s) (epid:%d freed)\n",
7091 + (unsigned int)ep, (unsigned int)ep->hcpriv,
7092 + endpoint_to_str(&(ep->desc)), epid);
7093 +
7094 + tc_sync_finish_epid(hcd, epid);
7095 +
7096 + ASSERT(activeUrbList[epid] == NULL);
7097 + ASSERT(list_empty(&urb_list[epid]));
7098 +
7099 + tc_free_epid(ep);
7100 + } else {
7101 + tc_dbg("endpoint_disable ep:0x%x ep-priv:0x%x (%s)\n", (unsigned int)ep,
7102 + (unsigned int)ep->hcpriv, endpoint_to_str(&(ep->desc)));
7103 + }
7104 + DBFEXIT;
7105 +}
7106 +
7107 +static void tc_finish_urb_later_proc(void *data) {
7108 + unsigned long flags;
7109 + struct urb_later_data* uld = (struct urb_later_data*)data;
7110 + local_irq_save(flags);
7111 + if(uld->urb == NULL) {
7112 + late_dbg("Later finish of URB = NULL (allready finished)\n");
7113 + } else {
7114 + struct crisv10_urb_priv* urb_priv = uld->urb->hcpriv;
7115 + ASSERT(urb_priv);
7116 + if(urb_priv->urb_num == uld->urb_num) {
7117 + late_dbg("Later finish of URB:0x%x[%d]\n", (unsigned int)(uld->urb),
7118 + urb_priv->urb_num);
7119 + if(uld->status != uld->urb->status) {
7120 + errno_dbg("Later-finish URB with status:%d, later-status:%d\n",
7121 + uld->urb->status, uld->status);
7122 + }
7123 + if(uld != urb_priv->later_data) {
7124 + panic("Scheduled uld not same as URBs uld\n");
7125 + }
7126 + tc_finish_urb(uld->hcd, uld->urb, uld->status);
7127 + } else {
7128 + late_warn("Ignoring later finish of URB:0x%x[%d]"
7129 + ", urb_num doesn't match current URB:0x%x[%d]",
7130 + (unsigned int)(uld->urb), uld->urb_num,
7131 + (unsigned int)(uld->urb), urb_priv->urb_num);
7132 + }
7133 + }
7134 + local_irq_restore(flags);
7135 + kmem_cache_free(later_data_cache, uld);
7136 +}
7137 +
7138 +static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
7139 + int status) {
7140 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
7141 + struct urb_later_data* uld;
7142 +
7143 + ASSERT(urb_priv);
7144 +
7145 + if(urb_priv->later_data != NULL) {
7146 + /* Later-finish allready scheduled for this URB, just update status to
7147 + return when finishing later */
7148 + errno_dbg("Later-finish schedule change URB status:%d with new"
7149 + " status:%d\n", urb_priv->later_data->status, status);
7150 +
7151 + urb_priv->later_data->status = status;
7152 + return;
7153 + }
7154 +
7155 + uld = kmem_cache_alloc(later_data_cache, SLAB_ATOMIC);
7156 + ASSERT(uld);
7157 +
7158 + uld->hcd = hcd;
7159 + uld->urb = urb;
7160 + uld->urb_num = urb_priv->urb_num;
7161 + uld->status = status;
7162 +
7163 + INIT_WORK(&uld->ws, tc_finish_urb_later_proc, uld);
7164 + urb_priv->later_data = uld;
7165 +
7166 + /* Schedule the finishing of the URB to happen later */
7167 + schedule_delayed_work(&uld->ws, LATER_TIMER_DELAY);
7168 +}
7169 +
7170 +static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
7171 + int status);
7172 +
7173 +static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status) {
7174 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
7175 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
7176 + int epid;
7177 + char toggle;
7178 + int urb_num;
7179 +
7180 + DBFENTER;
7181 + ASSERT(urb_priv != NULL);
7182 + epid = urb_priv->epid;
7183 + urb_num = urb_priv->urb_num;
7184 +
7185 + if(urb != activeUrbList[epid]) {
7186 + if(urb_list_entry(urb, epid)) {
7187 + /* Remove this URB from the list. Only happens when URB are finished
7188 + before having been processed (dequeing) */
7189 + urb_list_del(urb, epid);
7190 + } else {
7191 + tc_warn("Finishing of URB:0x%x[%d] neither active or in queue for"
7192 + " epid:%d\n", (unsigned int)urb, urb_num, epid);
7193 + }
7194 + }
7195 +
7196 + /* Cancel any pending later-finish of this URB */
7197 + if(urb_priv->later_data) {
7198 + urb_priv->later_data->urb = NULL;
7199 + }
7200 +
7201 + /* For an IN pipe, we always set the actual length, regardless of whether
7202 + there was an error or not (which means the device driver can use the data
7203 + if it wants to). */
7204 + if(usb_pipein(urb->pipe)) {
7205 + urb->actual_length = urb_priv->rx_offset;
7206 + } else {
7207 + /* Set actual_length for OUT urbs also; the USB mass storage driver seems
7208 + to want that. */
7209 + if (status == 0 && urb->status == -EINPROGRESS) {
7210 + urb->actual_length = urb->transfer_buffer_length;
7211 + } else {
7212 + /* We wouldn't know of any partial writes if there was an error. */
7213 + urb->actual_length = 0;
7214 + }
7215 + }
7216 +
7217 +
7218 + /* URB status mangling */
7219 + if(urb->status == -EINPROGRESS) {
7220 + /* The USB core hasn't changed the status, let's set our finish status */
7221 + urb->status = status;
7222 +
7223 + if ((status == 0) && (urb->transfer_flags & URB_SHORT_NOT_OK) &&
7224 + usb_pipein(urb->pipe) &&
7225 + (urb->actual_length != urb->transfer_buffer_length)) {
7226 + /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's
7227 + max length) is to be treated as an error. */
7228 + errno_dbg("Finishing URB:0x%x[%d] with SHORT_NOT_OK flag and short"
7229 + " data:%d\n", (unsigned int)urb, urb_num,
7230 + urb->actual_length);
7231 + urb->status = -EREMOTEIO;
7232 + }
7233 +
7234 + if(urb_priv->urb_state == UNLINK) {
7235 + /* URB has been requested to be unlinked asynchronously */
7236 + urb->status = -ECONNRESET;
7237 + errno_dbg("Fixing unlink status of URB:0x%x[%d] to:%d\n",
7238 + (unsigned int)urb, urb_num, urb->status);
7239 + }
7240 + } else {
7241 + /* The USB Core wants to signal some error via the URB, pass it through */
7242 + }
7243 +
7244 + /* use completely different finish function for Isoc URBs */
7245 + if(usb_pipeisoc(urb->pipe)) {
7246 + tc_finish_isoc_urb(hcd, urb, status);
7247 + return;
7248 + }
7249 +
7250 + /* Do special unlinking of EPs for Intr traffic */
7251 + if(usb_pipeint(urb->pipe)) {
7252 + tc_dma_unlink_intr_urb(urb);
7253 + }
7254 +
7255 + /* Release allocated bandwidth for periodic transfers */
7256 + if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe))
7257 + usb_release_bandwidth(urb->dev, urb, 0);
7258 +
7259 + /* This URB is active on EP */
7260 + if(urb == activeUrbList[epid]) {
7261 + /* We need to fiddle with the toggle bits because the hardware doesn't do
7262 + it for us. */
7263 + toggle = etrax_epid_get_toggle(epid, usb_pipeout(urb->pipe));
7264 + usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
7265 + usb_pipeout(urb->pipe), toggle);
7266 +
7267 + /* Checks for Ctrl and Bulk EPs */
7268 + switch(usb_pipetype(urb->pipe)) {
7269 + case PIPE_BULK:
7270 + /* Check so Bulk EP realy is disabled before finishing active URB */
7271 + ASSERT((TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
7272 + IO_STATE(USB_EP_command, enable, no));
7273 + /* Disable sub-pointer for EP to avoid next tx_interrupt() to
7274 + process Bulk EP. */
7275 + TxBulkEPList[epid].sub = 0;
7276 + /* No need to wait for the DMA before changing the next pointer.
7277 + The modulo NBR_OF_EPIDS isn't actually necessary, since we will never use
7278 + the last one (INVALID_EPID) for actual traffic. */
7279 + TxBulkEPList[epid].next =
7280 + virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
7281 + break;
7282 + case PIPE_CONTROL:
7283 + /* Check so Ctrl EP realy is disabled before finishing active URB */
7284 + ASSERT((TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
7285 + IO_STATE(USB_EP_command, enable, no));
7286 + /* Disable sub-pointer for EP to avoid next tx_interrupt() to
7287 + process Ctrl EP. */
7288 + TxCtrlEPList[epid].sub = 0;
7289 + break;
7290 + }
7291 + }
7292 +
7293 + /* Free HC-private URB data*/
7294 + urb_priv_free(hcd, urb);
7295 +
7296 + if(urb->status) {
7297 + errno_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
7298 + (unsigned int)urb, urb_num, str_dir(urb->pipe),
7299 + str_type(urb->pipe), urb->actual_length, urb->status);
7300 + } else {
7301 + tc_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
7302 + (unsigned int)urb, urb_num, str_dir(urb->pipe),
7303 + str_type(urb->pipe), urb->actual_length, urb->status);
7304 + }
7305 +
7306 + /* If we just finished an active URB, clear active pointer. */
7307 + if (urb == activeUrbList[epid]) {
7308 + /* Make URB not active on EP anymore */
7309 + activeUrbList[epid] = NULL;
7310 +
7311 + if(urb->status == 0) {
7312 + /* URB finished sucessfully, process queue to see if there are any more
7313 + URBs waiting before we call completion function.*/
7314 + if(crisv10_hcd->running) {
7315 + /* Only process queue if USB controller is running */
7316 + tc_dma_process_queue(epid);
7317 + } else {
7318 + tc_warn("No processing of queue for epid:%d, USB Controller not"
7319 + " running\n", epid);
7320 + }
7321 + }
7322 + }
7323 +
7324 + /* Hand the URB from HCD to its USB device driver, using its completion
7325 + functions */
7326 + usb_hcd_giveback_urb (hcd, urb);
7327 +
7328 + /* Check the queue once more if the URB returned with error, because we
7329 + didn't do it before the completion function because the specification
7330 + states that the queue should not restart until all it's unlinked
7331 + URBs have been fully retired, with the completion functions run */
7332 + if(crisv10_hcd->running) {
7333 + /* Only process queue if USB controller is running */
7334 + tc_dma_process_queue(epid);
7335 + } else {
7336 + tc_warn("No processing of queue for epid:%d, USB Controller not running\n",
7337 + epid);
7338 + }
7339 +
7340 + DBFEXIT;
7341 +}
7342 +
7343 +static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
7344 + int status) {
7345 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
7346 + int epid, i;
7347 + volatile int timeout = 10000;
7348 +
7349 + ASSERT(urb_priv);
7350 + epid = urb_priv->epid;
7351 +
7352 + ASSERT(usb_pipeisoc(urb->pipe));
7353 +
7354 + /* Set that all isoc packets have status and length set before
7355 + completing the urb. */
7356 + for (i = urb_priv->isoc_packet_counter; i < urb->number_of_packets; i++){
7357 + urb->iso_frame_desc[i].actual_length = 0;
7358 + urb->iso_frame_desc[i].status = -EPROTO;
7359 + }
7360 +
7361 + /* Check if the URB is currently active (done or error) */
7362 + if(urb == activeUrbList[epid]) {
7363 + /* Check if there are another In Isoc URB queued for this epid */
7364 + if (!list_empty(&urb_list[epid])&& !epid_state[epid].disabled) {
7365 + /* Move it from queue to active and mark it started so Isoc transfers
7366 + won't be interrupted.
7367 + All Isoc URBs data transfers are already added to DMA lists so we
7368 + don't have to insert anything in DMA lists here. */
7369 + activeUrbList[epid] = urb_list_first(epid);
7370 + ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_state =
7371 + STARTED;
7372 + urb_list_del(activeUrbList[epid], epid);
7373 +
7374 + if(urb->status) {
7375 + errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
7376 + " status:%d, new waiting URB:0x%x[%d]\n",
7377 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
7378 + str_type(urb->pipe), urb_priv->isoc_packet_counter,
7379 + urb->number_of_packets, urb->status,
7380 + (unsigned int)activeUrbList[epid],
7381 + ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_num);
7382 + }
7383 +
7384 + } else { /* No other URB queued for this epid */
7385 + if(urb->status) {
7386 + errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
7387 + " status:%d, no new URB waiting\n",
7388 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
7389 + str_type(urb->pipe), urb_priv->isoc_packet_counter,
7390 + urb->number_of_packets, urb->status);
7391 + }
7392 +
7393 + /* Check if EP is still enabled, then shut it down. */
7394 + if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
7395 + isoc_dbg("Isoc EP enabled for epid:%d, disabling it\n", epid);
7396 +
7397 + /* Should only occur for In Isoc EPs where SB isn't consumed. */
7398 + ASSERT(usb_pipein(urb->pipe));
7399 +
7400 + /* Disable it and wait for it to stop */
7401 + TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
7402 +
7403 + /* Ah, the luxury of busy-wait. */
7404 + while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
7405 + (timeout-- > 0));
7406 + if(timeout == 0) {
7407 + warn("Timeout while waiting for DMA-TX-Isoc to leave EP for epid:%d\n", epid);
7408 + }
7409 + }
7410 +
7411 + /* Unlink SB to say that epid is finished. */
7412 + TxIsocEPList[epid].sub = 0;
7413 + TxIsocEPList[epid].hw_len = 0;
7414 +
7415 + /* No URB active for EP anymore */
7416 + activeUrbList[epid] = NULL;
7417 + }
7418 + } else { /* Finishing of not active URB (queued up with SBs thought) */
7419 + isoc_warn("finish_isoc_urb (URB:0x%x %s) (%d of %d packets) status:%d,"
7420 + " SB queued but not active\n",
7421 + (unsigned int)urb, str_dir(urb->pipe),
7422 + urb_priv->isoc_packet_counter, urb->number_of_packets,
7423 + urb->status);
7424 + if(usb_pipeout(urb->pipe)) {
7425 + /* Finishing of not yet active Out Isoc URB needs unlinking of SBs. */
7426 + struct USB_SB_Desc *iter_sb, *prev_sb, *next_sb;
7427 +
7428 + iter_sb = TxIsocEPList[epid].sub ?
7429 + phys_to_virt(TxIsocEPList[epid].sub) : 0;
7430 + prev_sb = 0;
7431 +
7432 + /* SB that is linked before this URBs first SB */
7433 + while (iter_sb && (iter_sb != urb_priv->first_sb)) {
7434 + prev_sb = iter_sb;
7435 + iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
7436 + }
7437 +
7438 + if (iter_sb == 0) {
7439 + /* Unlink of the URB currently being transmitted. */
7440 + prev_sb = 0;
7441 + iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
7442 + }
7443 +
7444 + while (iter_sb && (iter_sb != urb_priv->last_sb)) {
7445 + iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
7446 + }
7447 +
7448 + if (iter_sb) {
7449 + next_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
7450 + } else {
7451 + /* This should only happen if the DMA has completed
7452 + processing the SB list for this EP while interrupts
7453 + are disabled. */
7454 + isoc_dbg("Isoc urb not found, already sent?\n");
7455 + next_sb = 0;
7456 + }
7457 + if (prev_sb) {
7458 + prev_sb->next = next_sb ? virt_to_phys(next_sb) : 0;
7459 + } else {
7460 + TxIsocEPList[epid].sub = next_sb ? virt_to_phys(next_sb) : 0;
7461 + }
7462 + }
7463 + }
7464 +
7465 + /* Free HC-private URB data*/
7466 + urb_priv_free(hcd, urb);
7467 +
7468 + usb_release_bandwidth(urb->dev, urb, 0);
7469 +
7470 + /* Hand the URB from HCD to its USB device driver, using its completion
7471 + functions */
7472 + usb_hcd_giveback_urb (hcd, urb);
7473 +}
7474 +
7475 +static __u32 urb_num = 0;
7476 +
7477 +/* allocate and initialize URB private data */
7478 +static int urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
7479 + int mem_flags) {
7480 + struct crisv10_urb_priv *urb_priv;
7481 +
7482 + urb_priv = kmalloc(sizeof *urb_priv, mem_flags);
7483 + if (!urb_priv)
7484 + return -ENOMEM;
7485 + memset(urb_priv, 0, sizeof *urb_priv);
7486 +
7487 + urb_priv->epid = epid;
7488 + urb_priv->urb_state = NOT_STARTED;
7489 +
7490 + urb->hcpriv = urb_priv;
7491 + /* Assign URB a sequence number, and increment counter */
7492 + urb_priv->urb_num = urb_num;
7493 + urb_num++;
7494 + return 0;
7495 +}
7496 +
7497 +/* free URB private data */
7498 +static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb) {
7499 + int i;
7500 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
7501 + ASSERT(urb_priv != 0);
7502 +
7503 + /* Check it has any SBs linked that needs to be freed*/
7504 + if(urb_priv->first_sb != NULL) {
7505 + struct USB_SB_Desc *next_sb, *first_sb, *last_sb;
7506 + int i = 0;
7507 + first_sb = urb_priv->first_sb;
7508 + last_sb = urb_priv->last_sb;
7509 + ASSERT(last_sb);
7510 + while(first_sb != last_sb) {
7511 + next_sb = (struct USB_SB_Desc *)phys_to_virt(first_sb->next);
7512 + kmem_cache_free(usb_desc_cache, first_sb);
7513 + first_sb = next_sb;
7514 + i++;
7515 + }
7516 + kmem_cache_free(usb_desc_cache, last_sb);
7517 + i++;
7518 + }
7519 +
7520 + /* Check if it has any EPs in its Intr pool that also needs to be freed */
7521 + if(urb_priv->intr_ep_pool_length > 0) {
7522 + for(i = 0; i < urb_priv->intr_ep_pool_length; i++) {
7523 + kfree(urb_priv->intr_ep_pool[i]);
7524 + }
7525 + /*
7526 + tc_dbg("Freed %d EPs from URB:0x%x EP pool\n",
7527 + urb_priv->intr_ep_pool_length, (unsigned int)urb);
7528 + */
7529 + }
7530 +
7531 + kfree(urb_priv);
7532 + urb->hcpriv = NULL;
7533 +}
7534 +
7535 +static int ep_priv_create(struct usb_host_endpoint *ep, int mem_flags) {
7536 + struct crisv10_ep_priv *ep_priv;
7537 +
7538 + ep_priv = kmalloc(sizeof *ep_priv, mem_flags);
7539 + if (!ep_priv)
7540 + return -ENOMEM;
7541 + memset(ep_priv, 0, sizeof *ep_priv);
7542 +
7543 + ep->hcpriv = ep_priv;
7544 + return 0;
7545 +}
7546 +
7547 +static void ep_priv_free(struct usb_host_endpoint *ep) {
7548 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
7549 + ASSERT(ep_priv);
7550 + kfree(ep_priv);
7551 + ep->hcpriv = NULL;
7552 +}
7553 +
7554 +/* EPID handling functions, managing EP-list in Etrax through wrappers */
7555 +/* ------------------------------------------------------------------- */
7556 +
7557 +/* Sets up a new EPID for an endpoint or returns existing if found */
7558 +static int tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
7559 + int mem_flags) {
7560 + int epid;
7561 + char devnum, endpoint, out_traffic, slow;
7562 + int maxlen;
7563 + __u32 epid_data;
7564 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
7565 +
7566 + DBFENTER;
7567 +
7568 + /* Check if a valid epid already is setup for this endpoint */
7569 + if(ep_priv != NULL) {
7570 + return ep_priv->epid;
7571 + }
7572 +
7573 + /* We must find and initiate a new epid for this urb. */
7574 + epid = tc_allocate_epid();
7575 +
7576 + if (epid == -1) {
7577 + /* Failed to allocate a new epid. */
7578 + DBFEXIT;
7579 + return epid;
7580 + }
7581 +
7582 + /* We now have a new epid to use. Claim it. */
7583 + epid_state[epid].inuse = 1;
7584 +
7585 + /* Init private data for new endpoint */
7586 + if(ep_priv_create(ep, mem_flags) != 0) {
7587 + return -ENOMEM;
7588 + }
7589 + ep_priv = ep->hcpriv;
7590 + ep_priv->epid = epid;
7591 +
7592 + devnum = usb_pipedevice(urb->pipe);
7593 + endpoint = usb_pipeendpoint(urb->pipe);
7594 + slow = (urb->dev->speed == USB_SPEED_LOW);
7595 + maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
7596 +
7597 + if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
7598 + /* We want both IN and OUT control traffic to be put on the same
7599 + EP/SB list. */
7600 + out_traffic = 1;
7601 + } else {
7602 + out_traffic = usb_pipeout(urb->pipe);
7603 + }
7604 +
7605 + if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
7606 + epid_data = IO_STATE(R_USB_EPT_DATA_ISO, valid, yes) |
7607 + /* FIXME: Change any to the actual port? */
7608 + IO_STATE(R_USB_EPT_DATA_ISO, port, any) |
7609 + IO_FIELD(R_USB_EPT_DATA_ISO, max_len, maxlen) |
7610 + IO_FIELD(R_USB_EPT_DATA_ISO, ep, endpoint) |
7611 + IO_FIELD(R_USB_EPT_DATA_ISO, dev, devnum);
7612 + etrax_epid_iso_set(epid, epid_data);
7613 + } else {
7614 + epid_data = IO_STATE(R_USB_EPT_DATA, valid, yes) |
7615 + IO_FIELD(R_USB_EPT_DATA, low_speed, slow) |
7616 + /* FIXME: Change any to the actual port? */
7617 + IO_STATE(R_USB_EPT_DATA, port, any) |
7618 + IO_FIELD(R_USB_EPT_DATA, max_len, maxlen) |
7619 + IO_FIELD(R_USB_EPT_DATA, ep, endpoint) |
7620 + IO_FIELD(R_USB_EPT_DATA, dev, devnum);
7621 + etrax_epid_set(epid, epid_data);
7622 + }
7623 +
7624 + epid_state[epid].out_traffic = out_traffic;
7625 + epid_state[epid].type = usb_pipetype(urb->pipe);
7626 +
7627 + tc_warn("Setting up ep:0x%x epid:%d (addr:%d endp:%d max_len:%d %s %s %s)\n",
7628 + (unsigned int)ep, epid, devnum, endpoint, maxlen,
7629 + str_type(urb->pipe), out_traffic ? "out" : "in",
7630 + slow ? "low" : "full");
7631 +
7632 + /* Enable Isoc eof interrupt if we set up the first Isoc epid */
7633 + if(usb_pipeisoc(urb->pipe)) {
7634 + isoc_epid_counter++;
7635 + if(isoc_epid_counter == 1) {
7636 + isoc_warn("Enabled Isoc eof interrupt\n");
7637 + *R_USB_IRQ_MASK_SET |= IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set);
7638 + }
7639 + }
7640 +
7641 + DBFEXIT;
7642 + return epid;
7643 +}
7644 +
7645 +static void tc_free_epid(struct usb_host_endpoint *ep) {
7646 + unsigned long flags;
7647 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
7648 + int epid;
7649 + volatile int timeout = 10000;
7650 +
7651 + DBFENTER;
7652 +
7653 + if (ep_priv == NULL) {
7654 + tc_warn("Trying to free unused epid on ep:0x%x\n", (unsigned int)ep);
7655 + DBFEXIT;
7656 + return;
7657 + }
7658 +
7659 + epid = ep_priv->epid;
7660 +
7661 + /* Disable Isoc eof interrupt if we free the last Isoc epid */
7662 + if(epid_isoc(epid)) {
7663 + ASSERT(isoc_epid_counter > 0);
7664 + isoc_epid_counter--;
7665 + if(isoc_epid_counter == 0) {
7666 + *R_USB_IRQ_MASK_SET &= ~IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set);
7667 + isoc_warn("Disabled Isoc eof interrupt\n");
7668 + }
7669 + }
7670 +
7671 + /* Take lock manualy instead of in epid_x_x wrappers,
7672 + because we need to be polling here */
7673 + spin_lock_irqsave(&etrax_epid_lock, flags);
7674 +
7675 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
7676 + nop();
7677 + while((*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) &&
7678 + (timeout-- > 0));
7679 + if(timeout == 0) {
7680 + warn("Timeout while waiting for epid:%d to drop hold\n", epid);
7681 + }
7682 + /* This will, among other things, set the valid field to 0. */
7683 + *R_USB_EPT_DATA = 0;
7684 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
7685 +
7686 + /* Free resource in software state info list */
7687 + epid_state[epid].inuse = 0;
7688 +
7689 + /* Free private endpoint data */
7690 + ep_priv_free(ep);
7691 +
7692 + DBFEXIT;
7693 +}
7694 +
7695 +static int tc_allocate_epid(void) {
7696 + int i;
7697 + DBFENTER;
7698 + for (i = 0; i < NBR_OF_EPIDS; i++) {
7699 + if (!epid_inuse(i)) {
7700 + DBFEXIT;
7701 + return i;
7702 + }
7703 + }
7704 +
7705 + tc_warn("Found no free epids\n");
7706 + DBFEXIT;
7707 + return -1;
7708 }
7709
7710
7711 -static void init_tx_intr_ep(void)
7712 -{
7713 - int i;
7714 +/* Wrappers around the list functions (include/linux/list.h). */
7715 +/* ---------------------------------------------------------- */
7716 +static inline int __urb_list_empty(int epid) {
7717 + int retval;
7718 + retval = list_empty(&urb_list[epid]);
7719 + return retval;
7720 +}
7721
7722 - DBFENTER;
7723 +/* Returns first urb for this epid, or NULL if list is empty. */
7724 +static inline struct urb *urb_list_first(int epid) {
7725 + unsigned long flags;
7726 + struct urb *first_urb = 0;
7727 + spin_lock_irqsave(&urb_list_lock, flags);
7728 + if (!__urb_list_empty(epid)) {
7729 + /* Get the first urb (i.e. head->next). */
7730 + urb_entry_t *urb_entry = list_entry((&urb_list[epid])->next, urb_entry_t, list);
7731 + first_urb = urb_entry->urb;
7732 + }
7733 + spin_unlock_irqrestore(&urb_list_lock, flags);
7734 + return first_urb;
7735 +}
7736
7737 - /* Read comment at zout_buffer declaration for an explanation to this. */
7738 - TxIntrSB_zout.sw_len = 1;
7739 - TxIntrSB_zout.next = 0;
7740 - TxIntrSB_zout.buf = virt_to_phys(&zout_buffer[0]);
7741 - TxIntrSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
7742 - IO_STATE(USB_SB_command, tt, zout) |
7743 - IO_STATE(USB_SB_command, full, yes) |
7744 - IO_STATE(USB_SB_command, eot, yes) |
7745 - IO_STATE(USB_SB_command, eol, yes));
7746 -
7747 - for (i = 0; i < (MAX_INTR_INTERVAL - 1); i++) {
7748 - CHECK_ALIGN(&TxIntrEPList[i]);
7749 - TxIntrEPList[i].hw_len = 0;
7750 - TxIntrEPList[i].command =
7751 - (IO_STATE(USB_EP_command, eof, yes) |
7752 - IO_STATE(USB_EP_command, enable, yes) |
7753 - IO_FIELD(USB_EP_command, epid, INVALID_EPID));
7754 - TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
7755 - TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[i + 1]);
7756 - }
7757 +/* Adds an urb_entry last in the list for this epid. */
7758 +static inline void urb_list_add(struct urb *urb, int epid, int mem_flags) {
7759 + unsigned long flags;
7760 + urb_entry_t *urb_entry = (urb_entry_t *)kmalloc(sizeof(urb_entry_t), mem_flags);
7761 + ASSERT(urb_entry);
7762 +
7763 + urb_entry->urb = urb;
7764 + spin_lock_irqsave(&urb_list_lock, flags);
7765 + list_add_tail(&urb_entry->list, &urb_list[epid]);
7766 + spin_unlock_irqrestore(&urb_list_lock, flags);
7767 +}
7768
7769 - CHECK_ALIGN(&TxIntrEPList[i]);
7770 - TxIntrEPList[i].hw_len = 0;
7771 - TxIntrEPList[i].command =
7772 - (IO_STATE(USB_EP_command, eof, yes) |
7773 - IO_STATE(USB_EP_command, eol, yes) |
7774 - IO_STATE(USB_EP_command, enable, yes) |
7775 - IO_FIELD(USB_EP_command, epid, INVALID_EPID));
7776 - TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
7777 - TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[0]);
7778 -
7779 - *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]);
7780 - *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
7781 - DBFEXIT;
7782 +/* Search through the list for an element that contains this urb. (The list
7783 + is expected to be short and the one we are about to delete will often be
7784 + the first in the list.)
7785 + Should be protected by spin_locks in calling function */
7786 +static inline urb_entry_t *__urb_list_entry(struct urb *urb, int epid) {
7787 + struct list_head *entry;
7788 + struct list_head *tmp;
7789 + urb_entry_t *urb_entry;
7790 +
7791 + list_for_each_safe(entry, tmp, &urb_list[epid]) {
7792 + urb_entry = list_entry(entry, urb_entry_t, list);
7793 + ASSERT(urb_entry);
7794 + ASSERT(urb_entry->urb);
7795 +
7796 + if (urb_entry->urb == urb) {
7797 + return urb_entry;
7798 + }
7799 + }
7800 + return 0;
7801 +}
7802 +
7803 +/* Same function as above but for global use. Protects list by spinlock */
7804 +static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid) {
7805 + unsigned long flags;
7806 + urb_entry_t *urb_entry;
7807 + spin_lock_irqsave(&urb_list_lock, flags);
7808 + urb_entry = __urb_list_entry(urb, epid);
7809 + spin_unlock_irqrestore(&urb_list_lock, flags);
7810 + return (urb_entry);
7811 }
7812
7813 -static void init_tx_isoc_ep(void)
7814 -{
7815 - int i;
7816 +/* Delete an urb from the list. */
7817 +static inline void urb_list_del(struct urb *urb, int epid) {
7818 + unsigned long flags;
7819 + urb_entry_t *urb_entry;
7820 +
7821 + /* Delete entry and free. */
7822 + spin_lock_irqsave(&urb_list_lock, flags);
7823 + urb_entry = __urb_list_entry(urb, epid);
7824 + ASSERT(urb_entry);
7825 +
7826 + list_del(&urb_entry->list);
7827 + spin_unlock_irqrestore(&urb_list_lock, flags);
7828 + kfree(urb_entry);
7829 +}
7830
7831 - DBFENTER;
7832 +/* Move an urb to the end of the list. */
7833 +static inline void urb_list_move_last(struct urb *urb, int epid) {
7834 + unsigned long flags;
7835 + urb_entry_t *urb_entry;
7836 +
7837 + spin_lock_irqsave(&urb_list_lock, flags);
7838 + urb_entry = __urb_list_entry(urb, epid);
7839 + ASSERT(urb_entry);
7840 +
7841 + list_del(&urb_entry->list);
7842 + list_add_tail(&urb_entry->list, &urb_list[epid]);
7843 + spin_unlock_irqrestore(&urb_list_lock, flags);
7844 +}
7845
7846 - /* Read comment at zout_buffer declaration for an explanation to this. */
7847 - TxIsocSB_zout.sw_len = 1;
7848 - TxIsocSB_zout.next = 0;
7849 - TxIsocSB_zout.buf = virt_to_phys(&zout_buffer[0]);
7850 - TxIsocSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
7851 - IO_STATE(USB_SB_command, tt, zout) |
7852 - IO_STATE(USB_SB_command, full, yes) |
7853 - IO_STATE(USB_SB_command, eot, yes) |
7854 - IO_STATE(USB_SB_command, eol, yes));
7855 -
7856 - /* The last isochronous EP descriptor is a dummy. */
7857 -
7858 - for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
7859 - CHECK_ALIGN(&TxIsocEPList[i]);
7860 - TxIsocEPList[i].hw_len = 0;
7861 - TxIsocEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
7862 - TxIsocEPList[i].sub = 0;
7863 - TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[i + 1]);
7864 +/* Get the next urb in the list. */
7865 +static inline struct urb *urb_list_next(struct urb *urb, int epid) {
7866 + unsigned long flags;
7867 + urb_entry_t *urb_entry;
7868 +
7869 + spin_lock_irqsave(&urb_list_lock, flags);
7870 + urb_entry = __urb_list_entry(urb, epid);
7871 + ASSERT(urb_entry);
7872 +
7873 + if (urb_entry->list.next != &urb_list[epid]) {
7874 + struct list_head *elem = urb_entry->list.next;
7875 + urb_entry = list_entry(elem, urb_entry_t, list);
7876 + spin_unlock_irqrestore(&urb_list_lock, flags);
7877 + return urb_entry->urb;
7878 + } else {
7879 + spin_unlock_irqrestore(&urb_list_lock, flags);
7880 + return NULL;
7881 + }
7882 +}
7883 +
7884 +struct USB_EP_Desc* create_ep(int epid, struct USB_SB_Desc* sb_desc,
7885 + int mem_flags) {
7886 + struct USB_EP_Desc *ep_desc;
7887 + ep_desc = (struct USB_EP_Desc *) kmem_cache_alloc(usb_desc_cache, mem_flags);
7888 + if(ep_desc == NULL)
7889 + return NULL;
7890 + memset(ep_desc, 0, sizeof(struct USB_EP_Desc));
7891 +
7892 + ep_desc->hw_len = 0;
7893 + ep_desc->command = (IO_FIELD(USB_EP_command, epid, epid) |
7894 + IO_STATE(USB_EP_command, enable, yes));
7895 + if(sb_desc == NULL) {
7896 + ep_desc->sub = 0;
7897 + } else {
7898 + ep_desc->sub = virt_to_phys(sb_desc);
7899 + }
7900 + return ep_desc;
7901 +}
7902 +
7903 +#define TT_ZOUT 0
7904 +#define TT_IN 1
7905 +#define TT_OUT 2
7906 +#define TT_SETUP 3
7907 +
7908 +#define CMD_EOL IO_STATE(USB_SB_command, eol, yes)
7909 +#define CMD_INTR IO_STATE(USB_SB_command, intr, yes)
7910 +#define CMD_FULL IO_STATE(USB_SB_command, full, yes)
7911 +
7912 +/* Allocation and setup of a generic SB. Used to create SETUP, OUT and ZOUT
7913 + SBs. Also used by create_sb_in() to avoid same allocation procedure at two
7914 + places */
7915 +struct USB_SB_Desc* create_sb(struct USB_SB_Desc* sb_prev, int tt, void* data,
7916 + int datalen, int mem_flags) {
7917 + struct USB_SB_Desc *sb_desc;
7918 + sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
7919 + if(sb_desc == NULL)
7920 + return NULL;
7921 + memset(sb_desc, 0, sizeof(struct USB_SB_Desc));
7922 +
7923 + sb_desc->command = IO_FIELD(USB_SB_command, tt, tt) |
7924 + IO_STATE(USB_SB_command, eot, yes);
7925 +
7926 + sb_desc->sw_len = datalen;
7927 + if(data != NULL) {
7928 + sb_desc->buf = virt_to_phys(data);
7929 + } else {
7930 + sb_desc->buf = 0;
7931 + }
7932 + if(sb_prev != NULL) {
7933 + sb_prev->next = virt_to_phys(sb_desc);
7934 + }
7935 + return sb_desc;
7936 +}
7937 +
7938 +/* Creates a copy of an existing SB by allocation space for it and copy
7939 + settings */
7940 +struct USB_SB_Desc* create_sb_copy(struct USB_SB_Desc* sb_orig, int mem_flags) {
7941 + struct USB_SB_Desc *sb_desc;
7942 + sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
7943 + if(sb_desc == NULL)
7944 + return NULL;
7945 +
7946 + memcpy(sb_desc, sb_orig, sizeof(struct USB_SB_Desc));
7947 + return sb_desc;
7948 +}
7949 +
7950 +/* A specific create_sb function for creation of in SBs. This is due to
7951 + that datalen in In SBs shows how many packets we are expecting. It also
7952 + sets up the rem field to show if how many bytes we expect in last packet
7953 + if it's not a full one */
7954 +struct USB_SB_Desc* create_sb_in(struct USB_SB_Desc* sb_prev, int datalen,
7955 + int maxlen, int mem_flags) {
7956 + struct USB_SB_Desc *sb_desc;
7957 + sb_desc = create_sb(sb_prev, TT_IN, NULL,
7958 + datalen ? (datalen - 1) / maxlen + 1 : 0, mem_flags);
7959 + if(sb_desc == NULL)
7960 + return NULL;
7961 + sb_desc->command |= IO_FIELD(USB_SB_command, rem, datalen % maxlen);
7962 + return sb_desc;
7963 +}
7964 +
7965 +void set_sb_cmds(struct USB_SB_Desc *sb_desc, __u16 flags) {
7966 + sb_desc->command |= flags;
7967 +}
7968 +
7969 +int create_sb_for_urb(struct urb *urb, int mem_flags) {
7970 + int is_out = !usb_pipein(urb->pipe);
7971 + int type = usb_pipetype(urb->pipe);
7972 + int maxlen = usb_maxpacket(urb->dev, urb->pipe, is_out);
7973 + int buf_len = urb->transfer_buffer_length;
7974 + void *buf = buf_len > 0 ? urb->transfer_buffer : NULL;
7975 + struct USB_SB_Desc *sb_desc = NULL;
7976 +
7977 + struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
7978 + ASSERT(urb_priv != NULL);
7979 +
7980 + switch(type) {
7981 + case PIPE_CONTROL:
7982 + /* Setup stage */
7983 + sb_desc = create_sb(NULL, TT_SETUP, urb->setup_packet, 8, mem_flags);
7984 + if(sb_desc == NULL)
7985 + return -ENOMEM;
7986 + set_sb_cmds(sb_desc, CMD_FULL);
7987 +
7988 + /* Attach first SB to URB */
7989 + urb_priv->first_sb = sb_desc;
7990 +
7991 + if (is_out) { /* Out Control URB */
7992 + /* If this Control OUT transfer has an optional data stage we add
7993 + an OUT token before the mandatory IN (status) token */
7994 + if ((buf_len > 0) && buf) {
7995 + sb_desc = create_sb(sb_desc, TT_OUT, buf, buf_len, mem_flags);
7996 + if(sb_desc == NULL)
7997 + return -ENOMEM;
7998 + set_sb_cmds(sb_desc, CMD_FULL);
7999 + }
8000 +
8001 + /* Status stage */
8002 + /* The data length has to be exactly 1. This is due to a requirement
8003 + of the USB specification that a host must be prepared to receive
8004 + data in the status phase */
8005 + sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
8006 + if(sb_desc == NULL)
8007 + return -ENOMEM;
8008 + } else { /* In control URB */
8009 + /* Data stage */
8010 + sb_desc = create_sb_in(sb_desc, buf_len, maxlen, mem_flags);
8011 + if(sb_desc == NULL)
8012 + return -ENOMEM;
8013 +
8014 + /* Status stage */
8015 + /* Read comment at zout_buffer declaration for an explanation to this. */
8016 + sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
8017 + if(sb_desc == NULL)
8018 + return -ENOMEM;
8019 + /* Set descriptor interrupt flag for in URBs so we can finish URB after
8020 + zout-packet has been sent */
8021 + set_sb_cmds(sb_desc, CMD_INTR | CMD_FULL);
8022 + }
8023 + /* Set end-of-list flag in last SB */
8024 + set_sb_cmds(sb_desc, CMD_EOL);
8025 + /* Attach last SB to URB */
8026 + urb_priv->last_sb = sb_desc;
8027 + break;
8028 +
8029 + case PIPE_BULK:
8030 + if (is_out) { /* Out Bulk URB */
8031 + sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
8032 + if(sb_desc == NULL)
8033 + return -ENOMEM;
8034 + /* The full field is set to yes, even if we don't actually check that
8035 + this is a full-length transfer (i.e., that transfer_buffer_length %
8036 + maxlen = 0).
8037 + Setting full prevents the USB controller from sending an empty packet
8038 + in that case. However, if URB_ZERO_PACKET was set we want that. */
8039 + if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
8040 + set_sb_cmds(sb_desc, CMD_FULL);
8041 + }
8042 + } else { /* In Bulk URB */
8043 + sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
8044 + if(sb_desc == NULL)
8045 + return -ENOMEM;
8046 + }
8047 + /* Set end-of-list flag for last SB */
8048 + set_sb_cmds(sb_desc, CMD_EOL);
8049 +
8050 + /* Attach SB to URB */
8051 + urb_priv->first_sb = sb_desc;
8052 + urb_priv->last_sb = sb_desc;
8053 + break;
8054 +
8055 + case PIPE_INTERRUPT:
8056 + if(is_out) { /* Out Intr URB */
8057 + sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
8058 + if(sb_desc == NULL)
8059 + return -ENOMEM;
8060 +
8061 + /* The full field is set to yes, even if we don't actually check that
8062 + this is a full-length transfer (i.e., that transfer_buffer_length %
8063 + maxlen = 0).
8064 + Setting full prevents the USB controller from sending an empty packet
8065 + in that case. However, if URB_ZERO_PACKET was set we want that. */
8066 + if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
8067 + set_sb_cmds(sb_desc, CMD_FULL);
8068 + }
8069 + /* Only generate TX interrupt if it's a Out URB*/
8070 + set_sb_cmds(sb_desc, CMD_INTR);
8071 +
8072 + } else { /* In Intr URB */
8073 + sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
8074 + if(sb_desc == NULL)
8075 + return -ENOMEM;
8076 + }
8077 + /* Set end-of-list flag for last SB */
8078 + set_sb_cmds(sb_desc, CMD_EOL);
8079 +
8080 + /* Attach SB to URB */
8081 + urb_priv->first_sb = sb_desc;
8082 + urb_priv->last_sb = sb_desc;
8083 +
8084 + break;
8085 + case PIPE_ISOCHRONOUS:
8086 + if(is_out) { /* Out Isoc URB */
8087 + int i;
8088 + if(urb->number_of_packets == 0) {
8089 + tc_err("Can't create SBs for Isoc URB with zero packets\n");
8090 + return -EPIPE;
8091 + }
8092 + /* Create one SB descriptor for each packet and link them together. */
8093 + for(i = 0; i < urb->number_of_packets; i++) {
8094 + if (urb->iso_frame_desc[i].length > 0) {
8095 +
8096 + sb_desc = create_sb(sb_desc, TT_OUT, urb->transfer_buffer +
8097 + urb->iso_frame_desc[i].offset,
8098 + urb->iso_frame_desc[i].length, mem_flags);
8099 + if(sb_desc == NULL)
8100 + return -ENOMEM;
8101 +
8102 + /* Check if it's a full length packet */
8103 + if (urb->iso_frame_desc[i].length ==
8104 + usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
8105 + set_sb_cmds(sb_desc, CMD_FULL);
8106 + }
8107 +
8108 + } else { /* zero length packet */
8109 + sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
8110 + if(sb_desc == NULL)
8111 + return -ENOMEM;
8112 + set_sb_cmds(sb_desc, CMD_FULL);
8113 + }
8114 + /* Attach first SB descriptor to URB */
8115 + if (i == 0) {
8116 + urb_priv->first_sb = sb_desc;
8117 + }
8118 + }
8119 + /* Set interrupt and end-of-list flags in last SB */
8120 + set_sb_cmds(sb_desc, CMD_INTR | CMD_EOL);
8121 + /* Attach last SB descriptor to URB */
8122 + urb_priv->last_sb = sb_desc;
8123 + tc_dbg("Created %d out SBs for Isoc URB:0x%x\n",
8124 + urb->number_of_packets, (unsigned int)urb);
8125 + } else { /* In Isoc URB */
8126 + /* Actual number of packets is not relevant for periodic in traffic as
8127 + long as it is more than zero. Set to 1 always. */
8128 + sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
8129 + if(sb_desc == NULL)
8130 + return -ENOMEM;
8131 + /* Set end-of-list flags for SB */
8132 + set_sb_cmds(sb_desc, CMD_EOL);
8133 +
8134 + /* Attach SB to URB */
8135 + urb_priv->first_sb = sb_desc;
8136 + urb_priv->last_sb = sb_desc;
8137 + }
8138 + break;
8139 + default:
8140 + tc_err("Unknown pipe-type\n");
8141 + return -EPIPE;
8142 + break;
8143 + }
8144 + return 0;
8145 +}
8146 +
8147 +int init_intr_urb(struct urb *urb, int mem_flags) {
8148 + struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
8149 + struct USB_EP_Desc* ep_desc;
8150 + int interval;
8151 + int i;
8152 + int ep_count;
8153 +
8154 + ASSERT(urb_priv != NULL);
8155 + ASSERT(usb_pipeint(urb->pipe));
8156 + /* We can't support interval longer than amount of eof descriptors in
8157 + TxIntrEPList */
8158 + if(urb->interval > MAX_INTR_INTERVAL) {
8159 + tc_err("Interrupt interval %dms too big (max: %dms)\n", urb->interval,
8160 + MAX_INTR_INTERVAL);
8161 + return -EINVAL;
8162 + }
8163 +
8164 + /* We assume that the SB descriptors already have been setup */
8165 + ASSERT(urb_priv->first_sb != NULL);
8166 +
8167 + /* Round of the interval to 2^n, it is obvious that this code favours
8168 + smaller numbers, but that is actually a good thing */
8169 + /* FIXME: The "rounding error" for larger intervals will be quite
8170 + large. For in traffic this shouldn't be a problem since it will only
8171 + mean that we "poll" more often. */
8172 + interval = urb->interval;
8173 + for (i = 0; interval; i++) {
8174 + interval = interval >> 1;
8175 + }
8176 + urb_priv->interval = 1 << (i - 1);
8177 +
8178 + /* We can only have max interval for Out Interrupt due to that we can only
8179 + handle one linked in EP for a certain epid in the Intr descr array at the
8180 + time. The USB Controller in the Etrax 100LX continues to process Intr EPs
8181 + so we have no way of knowing which one that caused the actual transfer if
8182 + we have several linked in. */
8183 + if(usb_pipeout(urb->pipe)) {
8184 + urb_priv->interval = MAX_INTR_INTERVAL;
8185 + }
8186 +
8187 + /* Calculate amount of EPs needed */
8188 + ep_count = MAX_INTR_INTERVAL / urb_priv->interval;
8189 +
8190 + for(i = 0; i < ep_count; i++) {
8191 + ep_desc = create_ep(urb_priv->epid, urb_priv->first_sb, mem_flags);
8192 + if(ep_desc == NULL) {
8193 + /* Free any descriptors that we may have allocated before failure */
8194 + while(i > 0) {
8195 + i--;
8196 + kfree(urb_priv->intr_ep_pool[i]);
8197 + }
8198 + return -ENOMEM;
8199 + }
8200 + urb_priv->intr_ep_pool[i] = ep_desc;
8201 + }
8202 + urb_priv->intr_ep_pool_length = ep_count;
8203 + return 0;
8204 +}
8205 +
8206 +/* DMA RX/TX functions */
8207 +/* ----------------------- */
8208 +
8209 +static void tc_dma_init_rx_list(void) {
8210 + int i;
8211 +
8212 + /* Setup descriptor list except last one */
8213 + for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) {
8214 + RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
8215 + RxDescList[i].command = 0;
8216 + RxDescList[i].next = virt_to_phys(&RxDescList[i + 1]);
8217 + RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
8218 + RxDescList[i].hw_len = 0;
8219 + RxDescList[i].status = 0;
8220 +
8221 + /* DMA IN cache bug. (struct etrax_dma_descr has the same layout as
8222 + USB_IN_Desc for the relevant fields.) */
8223 + prepare_rx_descriptor((struct etrax_dma_descr*)&RxDescList[i]);
8224 +
8225 + }
8226 + /* Special handling of last descriptor */
8227 + RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
8228 + RxDescList[i].command = IO_STATE(USB_IN_command, eol, yes);
8229 + RxDescList[i].next = virt_to_phys(&RxDescList[0]);
8230 + RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
8231 + RxDescList[i].hw_len = 0;
8232 + RxDescList[i].status = 0;
8233 +
8234 + /* Setup list pointers that show progress in list */
8235 + myNextRxDesc = &RxDescList[0];
8236 + myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
8237 +
8238 + flush_etrax_cache();
8239 + /* Point DMA to first descriptor in list and start it */
8240 + *R_DMA_CH9_FIRST = virt_to_phys(myNextRxDesc);
8241 + *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, start);
8242 +}
8243 +
8244 +
8245 +static void tc_dma_init_tx_bulk_list(void) {
8246 + int i;
8247 + volatile struct USB_EP_Desc *epDescr;
8248 +
8249 + for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
8250 + epDescr = &(TxBulkEPList[i]);
8251 + CHECK_ALIGN(epDescr);
8252 + epDescr->hw_len = 0;
8253 + epDescr->command = IO_FIELD(USB_EP_command, epid, i);
8254 + epDescr->sub = 0;
8255 + epDescr->next = virt_to_phys(&TxBulkEPList[i + 1]);
8256 +
8257 + /* Initiate two EPs, disabled and with the eol flag set. No need for any
8258 + preserved epid. */
8259 +
8260 + /* The first one has the intr flag set so we get an interrupt when the DMA
8261 + channel is about to become disabled. */
8262 + CHECK_ALIGN(&TxBulkDummyEPList[i][0]);
8263 + TxBulkDummyEPList[i][0].hw_len = 0;
8264 + TxBulkDummyEPList[i][0].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
8265 + IO_STATE(USB_EP_command, eol, yes) |
8266 + IO_STATE(USB_EP_command, intr, yes));
8267 + TxBulkDummyEPList[i][0].sub = 0;
8268 + TxBulkDummyEPList[i][0].next = virt_to_phys(&TxBulkDummyEPList[i][1]);
8269 +
8270 + /* The second one. */
8271 + CHECK_ALIGN(&TxBulkDummyEPList[i][1]);
8272 + TxBulkDummyEPList[i][1].hw_len = 0;
8273 + TxBulkDummyEPList[i][1].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
8274 + IO_STATE(USB_EP_command, eol, yes));
8275 + TxBulkDummyEPList[i][1].sub = 0;
8276 + /* The last dummy's next pointer is the same as the current EP's next pointer. */
8277 + TxBulkDummyEPList[i][1].next = virt_to_phys(&TxBulkEPList[i + 1]);
8278 + }
8279 +
8280 + /* Special handling of last descr in list, make list circular */
8281 + epDescr = &TxBulkEPList[i];
8282 + CHECK_ALIGN(epDescr);
8283 + epDescr->hw_len = 0;
8284 + epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
8285 + IO_FIELD(USB_EP_command, epid, i);
8286 + epDescr->sub = 0;
8287 + epDescr->next = virt_to_phys(&TxBulkEPList[0]);
8288 +
8289 + /* Init DMA sub-channel pointers to last item in each list */
8290 + *R_DMA_CH8_SUB0_EP = virt_to_phys(&TxBulkEPList[i]);
8291 + /* No point in starting the bulk channel yet.
8292 + *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
8293 +}
8294 +
8295 +static void tc_dma_init_tx_ctrl_list(void) {
8296 + int i;
8297 + volatile struct USB_EP_Desc *epDescr;
8298 +
8299 + for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
8300 + epDescr = &(TxCtrlEPList[i]);
8301 + CHECK_ALIGN(epDescr);
8302 + epDescr->hw_len = 0;
8303 + epDescr->command = IO_FIELD(USB_EP_command, epid, i);
8304 + epDescr->sub = 0;
8305 + epDescr->next = virt_to_phys(&TxCtrlEPList[i + 1]);
8306 + }
8307 + /* Special handling of last descr in list, make list circular */
8308 + epDescr = &TxCtrlEPList[i];
8309 + CHECK_ALIGN(epDescr);
8310 + epDescr->hw_len = 0;
8311 + epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
8312 + IO_FIELD(USB_EP_command, epid, i);
8313 + epDescr->sub = 0;
8314 + epDescr->next = virt_to_phys(&TxCtrlEPList[0]);
8315 +
8316 + /* Init DMA sub-channel pointers to last item in each list */
8317 + *R_DMA_CH8_SUB1_EP = virt_to_phys(&TxCtrlEPList[i]);
8318 + /* No point in starting the ctrl channel yet.
8319 + *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
8320 +}
8321 +
8322 +
8323 +static void tc_dma_init_tx_intr_list(void) {
8324 + int i;
8325 +
8326 + TxIntrSB_zout.sw_len = 1;
8327 + TxIntrSB_zout.next = 0;
8328 + TxIntrSB_zout.buf = virt_to_phys(&zout_buffer[0]);
8329 + TxIntrSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
8330 + IO_STATE(USB_SB_command, tt, zout) |
8331 + IO_STATE(USB_SB_command, full, yes) |
8332 + IO_STATE(USB_SB_command, eot, yes) |
8333 + IO_STATE(USB_SB_command, eol, yes));
8334 +
8335 + for (i = 0; i < (MAX_INTR_INTERVAL - 1); i++) {
8336 + CHECK_ALIGN(&TxIntrEPList[i]);
8337 + TxIntrEPList[i].hw_len = 0;
8338 + TxIntrEPList[i].command =
8339 + (IO_STATE(USB_EP_command, eof, yes) |
8340 + IO_STATE(USB_EP_command, enable, yes) |
8341 + IO_FIELD(USB_EP_command, epid, INVALID_EPID));
8342 + TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
8343 + TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[i + 1]);
8344 + }
8345 +
8346 + /* Special handling of last descr in list, make list circular */
8347 + CHECK_ALIGN(&TxIntrEPList[i]);
8348 + TxIntrEPList[i].hw_len = 0;
8349 + TxIntrEPList[i].command =
8350 + (IO_STATE(USB_EP_command, eof, yes) |
8351 + IO_STATE(USB_EP_command, eol, yes) |
8352 + IO_STATE(USB_EP_command, enable, yes) |
8353 + IO_FIELD(USB_EP_command, epid, INVALID_EPID));
8354 + TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
8355 + TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[0]);
8356 +
8357 + intr_dbg("Initiated Intr EP descriptor list\n");
8358 +
8359 +
8360 + /* Connect DMA 8 sub-channel 2 to first in list */
8361 + *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]);
8362 +}
8363 +
8364 +static void tc_dma_init_tx_isoc_list(void) {
8365 + int i;
8366 +
8367 + DBFENTER;
8368 +
8369 + /* Read comment at zout_buffer declaration for an explanation to this. */
8370 + TxIsocSB_zout.sw_len = 1;
8371 + TxIsocSB_zout.next = 0;
8372 + TxIsocSB_zout.buf = virt_to_phys(&zout_buffer[0]);
8373 + TxIsocSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
8374 + IO_STATE(USB_SB_command, tt, zout) |
8375 + IO_STATE(USB_SB_command, full, yes) |
8376 + IO_STATE(USB_SB_command, eot, yes) |
8377 + IO_STATE(USB_SB_command, eol, yes));
8378 +
8379 + /* The last isochronous EP descriptor is a dummy. */
8380 + for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
8381 + CHECK_ALIGN(&TxIsocEPList[i]);
8382 + TxIsocEPList[i].hw_len = 0;
8383 + TxIsocEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
8384 + TxIsocEPList[i].sub = 0;
8385 + TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[i + 1]);
8386 + }
8387 +
8388 + CHECK_ALIGN(&TxIsocEPList[i]);
8389 + TxIsocEPList[i].hw_len = 0;
8390 +
8391 + /* Must enable the last EP descr to get eof interrupt. */
8392 + TxIsocEPList[i].command = (IO_STATE(USB_EP_command, enable, yes) |
8393 + IO_STATE(USB_EP_command, eof, yes) |
8394 + IO_STATE(USB_EP_command, eol, yes) |
8395 + IO_FIELD(USB_EP_command, epid, INVALID_EPID));
8396 + TxIsocEPList[i].sub = virt_to_phys(&TxIsocSB_zout);
8397 + TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[0]);
8398 +
8399 + *R_DMA_CH8_SUB3_EP = virt_to_phys(&TxIsocEPList[0]);
8400 + *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
8401 +}
8402 +
8403 +static int tc_dma_init(struct usb_hcd *hcd) {
8404 + tc_dma_init_rx_list();
8405 + tc_dma_init_tx_bulk_list();
8406 + tc_dma_init_tx_ctrl_list();
8407 + tc_dma_init_tx_intr_list();
8408 + tc_dma_init_tx_isoc_list();
8409 +
8410 + if (cris_request_dma(USB_TX_DMA_NBR,
8411 + "ETRAX 100LX built-in USB (Tx)",
8412 + DMA_VERBOSE_ON_ERROR,
8413 + dma_usb)) {
8414 + err("Could not allocate DMA ch 8 for USB");
8415 + return -EBUSY;
8416 + }
8417 +
8418 + if (cris_request_dma(USB_RX_DMA_NBR,
8419 + "ETRAX 100LX built-in USB (Rx)",
8420 + DMA_VERBOSE_ON_ERROR,
8421 + dma_usb)) {
8422 + err("Could not allocate DMA ch 9 for USB");
8423 + return -EBUSY;
8424 + }
8425 +
8426 + *R_IRQ_MASK2_SET =
8427 + /* Note that these interrupts are not used. */
8428 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub0_descr, set) |
8429 + /* Sub channel 1 (ctrl) descr. interrupts are used. */
8430 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub1_descr, set) |
8431 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub2_descr, set) |
8432 + /* Sub channel 3 (isoc) descr. interrupts are used. */
8433 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub3_descr, set);
8434 +
8435 + /* Note that the dma9_descr interrupt is not used. */
8436 + *R_IRQ_MASK2_SET =
8437 + IO_STATE(R_IRQ_MASK2_SET, dma9_eop, set) |
8438 + IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set);
8439 +
8440 + if (request_irq(ETRAX_USB_RX_IRQ, tc_dma_rx_interrupt, 0,
8441 + "ETRAX 100LX built-in USB (Rx)", hcd)) {
8442 + err("Could not allocate IRQ %d for USB", ETRAX_USB_RX_IRQ);
8443 + return -EBUSY;
8444 + }
8445 +
8446 + if (request_irq(ETRAX_USB_TX_IRQ, tc_dma_tx_interrupt, 0,
8447 + "ETRAX 100LX built-in USB (Tx)", hcd)) {
8448 + err("Could not allocate IRQ %d for USB", ETRAX_USB_TX_IRQ);
8449 + return -EBUSY;
8450 + }
8451 +
8452 + return 0;
8453 +}
8454 +
8455 +static void tc_dma_destroy(void) {
8456 + free_irq(ETRAX_USB_RX_IRQ, NULL);
8457 + free_irq(ETRAX_USB_TX_IRQ, NULL);
8458 +
8459 + cris_free_dma(USB_TX_DMA_NBR, "ETRAX 100LX built-in USB (Tx)");
8460 + cris_free_dma(USB_RX_DMA_NBR, "ETRAX 100LX built-in USB (Rx)");
8461 +
8462 +}
8463 +
8464 +static void tc_dma_link_intr_urb(struct urb *urb);
8465 +
8466 +/* Handle processing of Bulk, Ctrl and Intr queues */
8467 +static void tc_dma_process_queue(int epid) {
8468 + struct urb *urb;
8469 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
8470 + unsigned long flags;
8471 + char toggle;
8472 +
8473 + if(epid_state[epid].disabled) {
8474 + /* Don't process any URBs on a disabled endpoint */
8475 + return;
8476 + }
8477 +
8478 + /* Do not disturb us while fiddling with EPs and epids */
8479 + local_irq_save(flags);
8480 +
8481 + /* For bulk, Ctrl and Intr can we only have one URB active at a time for
8482 + a specific EP. */
8483 + if(activeUrbList[epid] != NULL) {
8484 + /* An URB is already active on EP, skip checking queue */
8485 + local_irq_restore(flags);
8486 + return;
8487 + }
8488 +
8489 + urb = urb_list_first(epid);
8490 + if(urb == NULL) {
8491 + /* No URB waiting in EP queue. Nothing do to */
8492 + local_irq_restore(flags);
8493 + return;
8494 + }
8495 +
8496 + urb_priv = urb->hcpriv;
8497 + ASSERT(urb_priv != NULL);
8498 + ASSERT(urb_priv->urb_state == NOT_STARTED);
8499 + ASSERT(!usb_pipeisoc(urb->pipe));
8500 +
8501 + /* Remove this URB from the queue and move it to active */
8502 + activeUrbList[epid] = urb;
8503 + urb_list_del(urb, epid);
8504 +
8505 + urb_priv->urb_state = STARTED;
8506 +
8507 + /* Reset error counters (regardless of which direction this traffic is). */
8508 + etrax_epid_clear_error(epid);
8509 +
8510 + /* Special handling of Intr EP lists */
8511 + if(usb_pipeint(urb->pipe)) {
8512 + tc_dma_link_intr_urb(urb);
8513 + local_irq_restore(flags);
8514 + return;
8515 + }
8516 +
8517 + /* Software must preset the toggle bits for Bulk and Ctrl */
8518 + if(usb_pipecontrol(urb->pipe)) {
8519 + /* Toggle bits are initialized only during setup transaction in a
8520 + CTRL transfer */
8521 + etrax_epid_set_toggle(epid, 0, 0);
8522 + etrax_epid_set_toggle(epid, 1, 0);
8523 + } else {
8524 + toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
8525 + usb_pipeout(urb->pipe));
8526 + etrax_epid_set_toggle(epid, usb_pipeout(urb->pipe), toggle);
8527 + }
8528 +
8529 + tc_dbg("Added SBs from (URB:0x%x %s %s) to epid %d: %s\n",
8530 + (unsigned int)urb, str_dir(urb->pipe), str_type(urb->pipe), epid,
8531 + sblist_to_str(urb_priv->first_sb));
8532 +
8533 + /* We start the DMA sub channel without checking if it's running or not,
8534 + because:
8535 + 1) If it's already running, issuing the start command is a nop.
8536 + 2) We avoid a test-and-set race condition. */
8537 + switch(usb_pipetype(urb->pipe)) {
8538 + case PIPE_BULK:
8539 + /* Assert that the EP descriptor is disabled. */
8540 + ASSERT(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
8541 +
8542 + /* Set up and enable the EP descriptor. */
8543 + TxBulkEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
8544 + TxBulkEPList[epid].hw_len = 0;
8545 + TxBulkEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
8546 +
8547 + /* Check if the dummy list is already with us (if several urbs were queued). */
8548 + if (usb_pipein(urb->pipe) && (TxBulkEPList[epid].next != virt_to_phys(&TxBulkDummyEPList[epid][0]))) {
8549 + tc_dbg("Inviting dummy list to the party for urb 0x%lx, epid %d",
8550 + (unsigned long)urb, epid);
8551 +
8552 + /* We don't need to check if the DMA is at this EP or not before changing the
8553 + next pointer, since we will do it in one 32-bit write (EP descriptors are
8554 + 32-bit aligned). */
8555 + TxBulkEPList[epid].next = virt_to_phys(&TxBulkDummyEPList[epid][0]);
8556 + }
8557 +
8558 + restart_dma8_sub0();
8559 +
8560 + /* Update/restart the bulk start timer since we just started the channel.*/
8561 + mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
8562 + /* Update/restart the bulk eot timer since we just inserted traffic. */
8563 + mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
8564 + break;
8565 + case PIPE_CONTROL:
8566 + /* Assert that the EP descriptor is disabled. */
8567 + ASSERT(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
8568 +
8569 + /* Set up and enable the EP descriptor. */
8570 + TxCtrlEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
8571 + TxCtrlEPList[epid].hw_len = 0;
8572 + TxCtrlEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
8573 +
8574 + *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
8575 + break;
8576 + }
8577 + local_irq_restore(flags);
8578 +}
8579 +
8580 +static void tc_dma_link_intr_urb(struct urb *urb) {
8581 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
8582 + volatile struct USB_EP_Desc *tmp_ep;
8583 + struct USB_EP_Desc *ep_desc;
8584 + int i = 0, epid;
8585 + int pool_idx = 0;
8586 +
8587 + ASSERT(urb_priv != NULL);
8588 + epid = urb_priv->epid;
8589 + ASSERT(urb_priv->interval > 0);
8590 + ASSERT(urb_priv->intr_ep_pool_length > 0);
8591 +
8592 + tmp_ep = &TxIntrEPList[0];
8593 +
8594 + /* Only insert one EP descriptor in list for Out Intr URBs.
8595 + We can only handle Out Intr with interval of 128ms because
8596 + it's not possible to insert several Out Intr EPs because they
8597 + are not consumed by the DMA. */
8598 + if(usb_pipeout(urb->pipe)) {
8599 + ep_desc = urb_priv->intr_ep_pool[0];
8600 + ASSERT(ep_desc);
8601 + ep_desc->next = tmp_ep->next;
8602 + tmp_ep->next = virt_to_phys(ep_desc);
8603 + i++;
8604 + } else {
8605 + /* Loop through Intr EP descriptor list and insert EP for URB at
8606 + specified interval */
8607 + do {
8608 + /* Each EP descriptor with eof flag sat signals a new frame */
8609 + if (tmp_ep->command & IO_MASK(USB_EP_command, eof)) {
8610 + /* Insert a EP from URBs EP pool at correct interval */
8611 + if ((i % urb_priv->interval) == 0) {
8612 + ep_desc = urb_priv->intr_ep_pool[pool_idx];
8613 + ASSERT(ep_desc);
8614 + ep_desc->next = tmp_ep->next;
8615 + tmp_ep->next = virt_to_phys(ep_desc);
8616 + pool_idx++;
8617 + ASSERT(pool_idx <= urb_priv->intr_ep_pool_length);
8618 }
8619 + i++;
8620 + }
8621 + tmp_ep = (struct USB_EP_Desc *)phys_to_virt(tmp_ep->next);
8622 + } while(tmp_ep != &TxIntrEPList[0]);
8623 + }
8624 +
8625 + intr_dbg("Added SBs to intr epid %d: %s interval:%d (%d EP)\n", epid,
8626 + sblist_to_str(urb_priv->first_sb), urb_priv->interval, pool_idx);
8627 +
8628 + /* We start the DMA sub channel without checking if it's running or not,
8629 + because:
8630 + 1) If it's already running, issuing the start command is a nop.
8631 + 2) We avoid a test-and-set race condition. */
8632 + *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
8633 +}
8634 +
8635 +static void tc_dma_process_isoc_urb(struct urb *urb) {
8636 + unsigned long flags;
8637 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
8638 + int epid;
8639 +
8640 + /* Do not disturb us while fiddling with EPs and epids */
8641 + local_irq_save(flags);
8642 +
8643 + ASSERT(urb_priv);
8644 + ASSERT(urb_priv->first_sb);
8645 + epid = urb_priv->epid;
8646 +
8647 + if(activeUrbList[epid] == NULL) {
8648 + /* EP is idle, so make this URB active */
8649 + activeUrbList[epid] = urb;
8650 + urb_list_del(urb, epid);
8651 + ASSERT(TxIsocEPList[epid].sub == 0);
8652 + ASSERT(!(TxIsocEPList[epid].command &
8653 + IO_STATE(USB_EP_command, enable, yes)));
8654 +
8655 + /* Differentiate between In and Out Isoc. Because In SBs are not consumed*/
8656 + if(usb_pipein(urb->pipe)) {
8657 + /* Each EP for In Isoc will have only one SB descriptor, setup when
8658 + submitting the first active urb. We do it here by copying from URBs
8659 + pre-allocated SB. */
8660 + memcpy((void *)&(TxIsocSBList[epid]), urb_priv->first_sb,
8661 + sizeof(TxIsocSBList[epid]));
8662 + TxIsocEPList[epid].hw_len = 0;
8663 + TxIsocEPList[epid].sub = virt_to_phys(&(TxIsocSBList[epid]));
8664 + } else {
8665 + /* For Out Isoc we attach the pre-allocated list of SBs for the URB */
8666 + TxIsocEPList[epid].hw_len = 0;
8667 + TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
8668 +
8669 + isoc_dbg("Attached first URB:0x%x[%d] to epid:%d first_sb:0x%x"
8670 + " last_sb::0x%x\n",
8671 + (unsigned int)urb, urb_priv->urb_num, epid,
8672 + (unsigned int)(urb_priv->first_sb),
8673 + (unsigned int)(urb_priv->last_sb));
8674 + }
8675 +
8676 + if (urb->transfer_flags & URB_ISO_ASAP) {
8677 + /* The isoc transfer should be started as soon as possible. The
8678 + start_frame field is a return value if URB_ISO_ASAP was set. Comparing
8679 + R_USB_FM_NUMBER with a USB Chief trace shows that the first isoc IN
8680 + token is sent 2 frames later. I'm not sure how this affects usage of
8681 + the start_frame field by the device driver, or how it affects things
8682 + when USB_ISO_ASAP is not set, so therefore there's no compensation for
8683 + the 2 frame "lag" here. */
8684 + urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
8685 + TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
8686 + urb_priv->urb_state = STARTED;
8687 + isoc_dbg("URB_ISO_ASAP set, urb->start_frame set to %d\n",
8688 + urb->start_frame);
8689 + } else {
8690 + /* Not started yet. */
8691 + urb_priv->urb_state = NOT_STARTED;
8692 + isoc_warn("urb_priv->urb_state set to NOT_STARTED for URB:0x%x\n",
8693 + (unsigned int)urb);
8694 + }
8695 +
8696 + } else {
8697 + /* An URB is already active on the EP. Leave URB in queue and let
8698 + finish_isoc_urb process it after current active URB */
8699 + ASSERT(TxIsocEPList[epid].sub != 0);
8700 +
8701 + if(usb_pipein(urb->pipe)) {
8702 + /* Because there already is a active In URB on this epid we do nothing
8703 + and the finish_isoc_urb() function will handle switching to next URB*/
8704 +
8705 + } else { /* For Out Isoc, insert new URBs traffic last in SB-list. */
8706 + struct USB_SB_Desc *temp_sb_desc;
8707 +
8708 + /* Set state STARTED to all Out Isoc URBs added to SB list because we
8709 + don't know how many of them that are finished before descr interrupt*/
8710 + urb_priv->urb_state = STARTED;
8711 +
8712 + /* Find end of current SB list by looking for SB with eol flag sat */
8713 + temp_sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
8714 + while ((temp_sb_desc->command & IO_MASK(USB_SB_command, eol)) !=
8715 + IO_STATE(USB_SB_command, eol, yes)) {
8716 + ASSERT(temp_sb_desc->next);
8717 + temp_sb_desc = phys_to_virt(temp_sb_desc->next);
8718 + }
8719 +
8720 + isoc_dbg("Appended URB:0x%x[%d] (first:0x%x last:0x%x) to epid:%d"
8721 + " sub:0x%x eol:0x%x\n",
8722 + (unsigned int)urb, urb_priv->urb_num,
8723 + (unsigned int)(urb_priv->first_sb),
8724 + (unsigned int)(urb_priv->last_sb), epid,
8725 + (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
8726 + (unsigned int)temp_sb_desc);
8727 +
8728 + /* Next pointer must be set before eol is removed. */
8729 + temp_sb_desc->next = virt_to_phys(urb_priv->first_sb);
8730 + /* Clear the previous end of list flag since there is a new in the
8731 + added SB descriptor list. */
8732 + temp_sb_desc->command &= ~IO_MASK(USB_SB_command, eol);
8733 +
8734 + if (!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
8735 + __u32 epid_data;
8736 + /* 8.8.5 in Designer's Reference says we should check for and correct
8737 + any errors in the EP here. That should not be necessary if
8738 + epid_attn is handled correctly, so we assume all is ok. */
8739 + epid_data = etrax_epid_iso_get(epid);
8740 + if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) !=
8741 + IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
8742 + isoc_err("Disabled Isoc EP with error:%d on epid:%d when appending"
8743 + " URB:0x%x[%d]\n",
8744 + IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data), epid,
8745 + (unsigned int)urb, urb_priv->urb_num);
8746 + }
8747 +
8748 + /* The SB list was exhausted. */
8749 + if (virt_to_phys(urb_priv->last_sb) != TxIsocEPList[epid].sub) {
8750 + /* The new sublist did not get processed before the EP was
8751 + disabled. Setup the EP again. */
8752 +
8753 + if(virt_to_phys(temp_sb_desc) == TxIsocEPList[epid].sub) {
8754 + isoc_dbg("EP for epid:%d stoped at SB:0x%x before newly inserted"
8755 + ", restarting from this URBs SB:0x%x\n",
8756 + epid, (unsigned int)temp_sb_desc,
8757 + (unsigned int)(urb_priv->first_sb));
8758 + TxIsocEPList[epid].hw_len = 0;
8759 + TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
8760 + urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
8761 + /* Enable the EP again so data gets processed this time */
8762 + TxIsocEPList[epid].command |=
8763 + IO_STATE(USB_EP_command, enable, yes);
8764 +
8765 + } else {
8766 + /* The EP has been disabled but not at end this URB (god knows
8767 + where). This should generate an epid_attn so we should not be
8768 + here */
8769 + isoc_warn("EP was disabled on sb:0x%x before SB list for"
8770 + " URB:0x%x[%d] got processed\n",
8771 + (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
8772 + (unsigned int)urb, urb_priv->urb_num);
8773 + }
8774 + } else {
8775 + /* This might happend if we are slow on this function and isn't
8776 + an error. */
8777 + isoc_dbg("EP was disabled and finished with SBs from appended"
8778 + " URB:0x%x[%d]\n", (unsigned int)urb, urb_priv->urb_num);
8779 + }
8780 + }
8781 + }
8782 + }
8783 +
8784 + /* Start the DMA sub channel */
8785 + *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
8786 +
8787 + local_irq_restore(flags);
8788 +}
8789 +
8790 +static void tc_dma_unlink_intr_urb(struct urb *urb) {
8791 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
8792 + volatile struct USB_EP_Desc *first_ep; /* First EP in the list. */
8793 + volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
8794 + volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
8795 + volatile struct USB_EP_Desc *unlink_ep; /* The one we should remove from
8796 + the list. */
8797 + int count = 0;
8798 + volatile int timeout = 10000;
8799 + int epid;
8800 +
8801 + /* Read 8.8.4 in Designer's Reference, "Removing an EP Descriptor from the
8802 + List". */
8803 + ASSERT(urb_priv);
8804 + ASSERT(urb_priv->intr_ep_pool_length > 0);
8805 + epid = urb_priv->epid;
8806 +
8807 + /* First disable all Intr EPs belonging to epid for this URB */
8808 + first_ep = &TxIntrEPList[0];
8809 + curr_ep = first_ep;
8810 + do {
8811 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
8812 + if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
8813 + /* Disable EP */
8814 + next_ep->command &= ~IO_MASK(USB_EP_command, enable);
8815 + }
8816 + curr_ep = phys_to_virt(curr_ep->next);
8817 + } while (curr_ep != first_ep);
8818 +
8819 +
8820 + /* Now unlink all EPs belonging to this epid from Descr list */
8821 + first_ep = &TxIntrEPList[0];
8822 + curr_ep = first_ep;
8823 + do {
8824 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
8825 + if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
8826 + /* This is the one we should unlink. */
8827 + unlink_ep = next_ep;
8828 +
8829 + /* Actually unlink the EP from the DMA list. */
8830 + curr_ep->next = unlink_ep->next;
8831 +
8832 + /* Wait until the DMA is no longer at this descriptor. */
8833 + while((*R_DMA_CH8_SUB2_EP == virt_to_phys(unlink_ep)) &&
8834 + (timeout-- > 0));
8835 + if(timeout == 0) {
8836 + warn("Timeout while waiting for DMA-TX-Intr to leave unlink EP\n");
8837 + }
8838 +
8839 + count++;
8840 + }
8841 + curr_ep = phys_to_virt(curr_ep->next);
8842 + } while (curr_ep != first_ep);
8843 +
8844 + if(count != urb_priv->intr_ep_pool_length) {
8845 + intr_warn("Unlinked %d of %d Intr EPs for URB:0x%x[%d]\n", count,
8846 + urb_priv->intr_ep_pool_length, (unsigned int)urb,
8847 + urb_priv->urb_num);
8848 + } else {
8849 + intr_dbg("Unlinked %d of %d interrupt EPs for URB:0x%x\n", count,
8850 + urb_priv->intr_ep_pool_length, (unsigned int)urb);
8851 + }
8852 +}
8853 +
8854 +static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
8855 + int timer) {
8856 + unsigned long flags;
8857 + int epid;
8858 + struct urb *urb;
8859 + struct crisv10_urb_priv * urb_priv;
8860 + __u32 epid_data;
8861 +
8862 + /* Protect TxEPList */
8863 + local_irq_save(flags);
8864 +
8865 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
8866 + /* A finished EP descriptor is disabled and has a valid sub pointer */
8867 + if (!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
8868 + (TxBulkEPList[epid].sub != 0)) {
8869 +
8870 + /* Get the active URB for this epid */
8871 + urb = activeUrbList[epid];
8872 + /* Sanity checks */
8873 + ASSERT(urb);
8874 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
8875 + ASSERT(urb_priv);
8876 +
8877 + /* Only handle finished out Bulk EPs here,
8878 + and let RX interrupt take care of the rest */
8879 + if(!epid_out_traffic(epid)) {
8880 + continue;
8881 + }
8882 +
8883 + if(timer) {
8884 + tc_warn("Found finished %s Bulk epid:%d URB:0x%x[%d] from timeout\n",
8885 + epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
8886 + urb_priv->urb_num);
8887 + } else {
8888 + tc_dbg("Found finished %s Bulk epid:%d URB:0x%x[%d] from interrupt\n",
8889 + epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
8890 + urb_priv->urb_num);
8891 + }
8892 +
8893 + if(urb_priv->urb_state == UNLINK) {
8894 + /* This Bulk URB is requested to be unlinked, that means that the EP
8895 + has been disabled and we might not have sent all data */
8896 + tc_finish_urb(hcd, urb, urb->status);
8897 + continue;
8898 + }
8899 +
8900 + ASSERT(urb_priv->urb_state == STARTED);
8901 + if (phys_to_virt(TxBulkEPList[epid].sub) != urb_priv->last_sb) {
8902 + tc_err("Endpoint got disabled before reaching last sb\n");
8903 + }
8904 +
8905 + epid_data = etrax_epid_get(epid);
8906 + if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
8907 + IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
8908 + /* This means that the endpoint has no error, is disabled
8909 + and had inserted traffic, i.e. transfer successfully completed. */
8910 + tc_finish_urb(hcd, urb, 0);
8911 + } else {
8912 + /* Shouldn't happen. We expect errors to be caught by epid
8913 + attention. */
8914 + tc_err("Found disabled bulk EP desc (epid:%d error:%d)\n",
8915 + epid, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
8916 + }
8917 + } else {
8918 + tc_dbg("Ignoring In Bulk epid:%d, let RX interrupt handle it\n", epid);
8919 + }
8920 + }
8921 +
8922 + local_irq_restore(flags);
8923 +}
8924 +
8925 +static void check_finished_ctrl_tx_epids(struct usb_hcd *hcd) {
8926 + unsigned long flags;
8927 + int epid;
8928 + struct urb *urb;
8929 + struct crisv10_urb_priv * urb_priv;
8930 + __u32 epid_data;
8931 +
8932 + /* Protect TxEPList */
8933 + local_irq_save(flags);
8934 +
8935 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
8936 + if(epid == DUMMY_EPID)
8937 + continue;
8938 +
8939 + /* A finished EP descriptor is disabled and has a valid sub pointer */
8940 + if (!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
8941 + (TxCtrlEPList[epid].sub != 0)) {
8942 +
8943 + /* Get the active URB for this epid */
8944 + urb = activeUrbList[epid];
8945 +
8946 + if(urb == NULL) {
8947 + tc_warn("Found finished Ctrl epid:%d with no active URB\n", epid);
8948 + continue;
8949 + }
8950 +
8951 + /* Sanity checks */
8952 + ASSERT(usb_pipein(urb->pipe));
8953 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
8954 + ASSERT(urb_priv);
8955 + if (phys_to_virt(TxCtrlEPList[epid].sub) != urb_priv->last_sb) {
8956 + tc_err("Endpoint got disabled before reaching last sb\n");
8957 + }
8958 +
8959 + epid_data = etrax_epid_get(epid);
8960 + if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
8961 + IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
8962 + /* This means that the endpoint has no error, is disabled
8963 + and had inserted traffic, i.e. transfer successfully completed. */
8964 +
8965 + /* Check if RX-interrupt for In Ctrl has been processed before
8966 + finishing the URB */
8967 + if(urb_priv->ctrl_rx_done) {
8968 + tc_dbg("Finishing In Ctrl URB:0x%x[%d] in tx_interrupt\n",
8969 + (unsigned int)urb, urb_priv->urb_num);
8970 + tc_finish_urb(hcd, urb, 0);
8971 + } else {
8972 + /* If we get zout descriptor interrupt before RX was done for a
8973 + In Ctrl transfer, then we flag that and it will be finished
8974 + in the RX-Interrupt */
8975 + urb_priv->ctrl_zout_done = 1;
8976 + tc_dbg("Got zout descr interrupt before RX interrupt\n");
8977 + }
8978 + } else {
8979 + /* Shouldn't happen. We expect errors to be caught by epid
8980 + attention. */
8981 + tc_err("Found disabled Ctrl EP desc (epid:%d URB:0x%x[%d]) error_code:%d\n", epid, (unsigned int)urb, urb_priv->urb_num, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
8982 + __dump_ep_desc(&(TxCtrlEPList[epid]));
8983 + __dump_ept_data(epid);
8984 + }
8985 + }
8986 + }
8987 + local_irq_restore(flags);
8988 +}
8989 +
8990 +/* This function goes through all epids that are setup for Out Isoc transfers
8991 + and marks (isoc_out_done) all queued URBs that the DMA has finished
8992 + transfer for.
8993 + No URB completetion is done here to make interrupt routine return quickly.
8994 + URBs are completed later with help of complete_isoc_bottom_half() that
8995 + becomes schedules when this functions is finished. */
8996 +static void check_finished_isoc_tx_epids(void) {
8997 + unsigned long flags;
8998 + int epid;
8999 + struct urb *urb;
9000 + struct crisv10_urb_priv * urb_priv;
9001 + struct USB_SB_Desc* sb_desc;
9002 + int epid_done;
9003 +
9004 + /* Protect TxIsocEPList */
9005 + local_irq_save(flags);
9006 +
9007 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
9008 + if (TxIsocEPList[epid].sub == 0 || epid == INVALID_EPID ||
9009 + !epid_out_traffic(epid)) {
9010 + /* Nothing here to see. */
9011 + continue;
9012 + }
9013 + ASSERT(epid_inuse(epid));
9014 + ASSERT(epid_isoc(epid));
9015 +
9016 + sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
9017 + /* Find the last descriptor of the currently active URB for this ep.
9018 + This is the first descriptor in the sub list marked for a descriptor
9019 + interrupt. */
9020 + while (sb_desc && !IO_EXTRACT(USB_SB_command, intr, sb_desc->command)) {
9021 + sb_desc = sb_desc->next ? phys_to_virt(sb_desc->next) : 0;
9022 + }
9023 + ASSERT(sb_desc);
9024 +
9025 + isoc_dbg("Descr IRQ checking epid:%d sub:0x%x intr:0x%x\n",
9026 + epid, (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
9027 + (unsigned int)sb_desc);
9028 +
9029 + urb = activeUrbList[epid];
9030 + if(urb == NULL) {
9031 + isoc_err("Isoc Descr irq on epid:%d with no active URB\n", epid);
9032 + continue;
9033 + }
9034 +
9035 + epid_done = 0;
9036 + while(urb && !epid_done) {
9037 + /* Sanity check. */
9038 + ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
9039 + ASSERT(usb_pipeout(urb->pipe));
9040 +
9041 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
9042 + ASSERT(urb_priv);
9043 + ASSERT(urb_priv->urb_state == STARTED ||
9044 + urb_priv->urb_state == UNLINK);
9045 +
9046 + if (sb_desc != urb_priv->last_sb) {
9047 + /* This urb has been sent. */
9048 + urb_priv->isoc_out_done = 1;
9049 +
9050 + } else { /* Found URB that has last_sb as the interrupt reason */
9051 +
9052 + /* Check if EP has been disabled, meaning that all transfers are done*/
9053 + if(!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
9054 + ASSERT((sb_desc->command & IO_MASK(USB_SB_command, eol)) ==
9055 + IO_STATE(USB_SB_command, eol, yes));
9056 + ASSERT(sb_desc->next == 0);
9057 + urb_priv->isoc_out_done = 1;
9058 + } else {
9059 + isoc_dbg("Skipping URB:0x%x[%d] because EP not disabled yet\n",
9060 + (unsigned int)urb, urb_priv->urb_num);
9061 + }
9062 + /* Stop looking any further in queue */
9063 + epid_done = 1;
9064 + }
9065 +
9066 + if (!epid_done) {
9067 + if(urb == activeUrbList[epid]) {
9068 + urb = urb_list_first(epid);
9069 + } else {
9070 + urb = urb_list_next(urb, epid);
9071 + }
9072 + }
9073 + } /* END: while(urb && !epid_done) */
9074 + }
9075 +
9076 + local_irq_restore(flags);
9077 +}
9078 +
9079 +
9080 +/* This is where the Out Isoc URBs are realy completed. This function is
9081 + scheduled from tc_dma_tx_interrupt() when one or more Out Isoc transfers
9082 + are done. This functions completes all URBs earlier marked with
9083 + isoc_out_done by fast interrupt routine check_finished_isoc_tx_epids() */
9084 +
9085 +static void complete_isoc_bottom_half(void *data) {
9086 + struct crisv10_isoc_complete_data *comp_data;
9087 + struct usb_iso_packet_descriptor *packet;
9088 + struct crisv10_urb_priv * urb_priv;
9089 + unsigned long flags;
9090 + struct urb* urb;
9091 + int epid_done;
9092 + int epid;
9093 + int i;
9094 +
9095 + comp_data = (struct crisv10_isoc_complete_data*)data;
9096 +
9097 + local_irq_save(flags);
9098 +
9099 + for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
9100 + if(!epid_inuse(epid) || !epid_isoc(epid) || !epid_out_traffic(epid) || epid == DUMMY_EPID) {
9101 + /* Only check valid Out Isoc epids */
9102 + continue;
9103 + }
9104 +
9105 + isoc_dbg("Isoc bottom-half checking epid:%d, sub:0x%x\n", epid,
9106 + (unsigned int)phys_to_virt(TxIsocEPList[epid].sub));
9107 +
9108 + /* The descriptor interrupt handler has marked all transmitted Out Isoc
9109 + URBs with isoc_out_done. Now we traverse all epids and for all that
9110 + have out Isoc traffic we traverse its URB list and complete the
9111 + transmitted URBs. */
9112 + epid_done = 0;
9113 + while (!epid_done) {
9114 +
9115 + /* Get the active urb (if any) */
9116 + urb = activeUrbList[epid];
9117 + if (urb == 0) {
9118 + isoc_dbg("No active URB on epid:%d anymore\n", epid);
9119 + epid_done = 1;
9120 + continue;
9121 + }
9122 +
9123 + /* Sanity check. */
9124 + ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
9125 + ASSERT(usb_pipeout(urb->pipe));
9126 +
9127 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
9128 + ASSERT(urb_priv);
9129 +
9130 + if (!(urb_priv->isoc_out_done)) {
9131 + /* We have reached URB that isn't flaged done yet, stop traversing. */
9132 + isoc_dbg("Stoped traversing Out Isoc URBs on epid:%d"
9133 + " before not yet flaged URB:0x%x[%d]\n",
9134 + epid, (unsigned int)urb, urb_priv->urb_num);
9135 + epid_done = 1;
9136 + continue;
9137 + }
9138 +
9139 + /* This urb has been sent. */
9140 + isoc_dbg("Found URB:0x%x[%d] that is flaged isoc_out_done\n",
9141 + (unsigned int)urb, urb_priv->urb_num);
9142 +
9143 + /* Set ok on transfered packets for this URB and finish it */
9144 + for (i = 0; i < urb->number_of_packets; i++) {
9145 + packet = &urb->iso_frame_desc[i];
9146 + packet->status = 0;
9147 + packet->actual_length = packet->length;
9148 + }
9149 + urb_priv->isoc_packet_counter = urb->number_of_packets;
9150 + tc_finish_urb(comp_data->hcd, urb, 0);
9151 +
9152 + } /* END: while(!epid_done) */
9153 + } /* END: for(epid...) */
9154 +
9155 + local_irq_restore(flags);
9156 + kmem_cache_free(isoc_compl_cache, comp_data);
9157 +}
9158 +
9159 +
9160 +static void check_finished_intr_tx_epids(struct usb_hcd *hcd) {
9161 + unsigned long flags;
9162 + int epid;
9163 + struct urb *urb;
9164 + struct crisv10_urb_priv * urb_priv;
9165 + volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
9166 + volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
9167 +
9168 + /* Protect TxintrEPList */
9169 + local_irq_save(flags);
9170 +
9171 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
9172 + if(!epid_inuse(epid) || !epid_intr(epid) || !epid_out_traffic(epid)) {
9173 + /* Nothing to see on this epid. Only check valid Out Intr epids */
9174 + continue;
9175 + }
9176 +
9177 + urb = activeUrbList[epid];
9178 + if(urb == 0) {
9179 + intr_warn("Found Out Intr epid:%d with no active URB\n", epid);
9180 + continue;
9181 + }
9182 +
9183 + /* Sanity check. */
9184 + ASSERT(usb_pipetype(urb->pipe) == PIPE_INTERRUPT);
9185 + ASSERT(usb_pipeout(urb->pipe));
9186 +
9187 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
9188 + ASSERT(urb_priv);
9189 +
9190 + /* Go through EPs between first and second sof-EP. It's here Out Intr EPs
9191 + are inserted.*/
9192 + curr_ep = &TxIntrEPList[0];
9193 + do {
9194 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
9195 + if(next_ep == urb_priv->intr_ep_pool[0]) {
9196 + /* We found the Out Intr EP for this epid */
9197 +
9198 + /* Disable it so it doesn't get processed again */
9199 + next_ep->command &= ~IO_MASK(USB_EP_command, enable);
9200 +
9201 + /* Finish the active Out Intr URB with status OK */
9202 + tc_finish_urb(hcd, urb, 0);
9203 + }
9204 + curr_ep = phys_to_virt(curr_ep->next);
9205 + } while (curr_ep != &TxIntrEPList[1]);
9206 +
9207 + }
9208 + local_irq_restore(flags);
9209 +}
9210 +
9211 +/* Interrupt handler for DMA8/IRQ24 with subchannels (called from hardware intr) */
9212 +static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc) {
9213 + struct usb_hcd *hcd = (struct usb_hcd*)vhc;
9214 + ASSERT(hcd);
9215 +
9216 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub0_descr)) {
9217 + /* Clear this interrupt */
9218 + *R_DMA_CH8_SUB0_CLR_INTR = IO_STATE(R_DMA_CH8_SUB0_CLR_INTR, clr_descr, do);
9219 + restart_dma8_sub0();
9220 + }
9221 +
9222 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub1_descr)) {
9223 + /* Clear this interrupt */
9224 + *R_DMA_CH8_SUB1_CLR_INTR = IO_STATE(R_DMA_CH8_SUB1_CLR_INTR, clr_descr, do);
9225 + check_finished_ctrl_tx_epids(hcd);
9226 + }
9227 +
9228 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub2_descr)) {
9229 + /* Clear this interrupt */
9230 + *R_DMA_CH8_SUB2_CLR_INTR = IO_STATE(R_DMA_CH8_SUB2_CLR_INTR, clr_descr, do);
9231 + check_finished_intr_tx_epids(hcd);
9232 + }
9233 +
9234 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub3_descr)) {
9235 + struct crisv10_isoc_complete_data* comp_data;
9236 +
9237 + /* Flag done Out Isoc for later completion */
9238 + check_finished_isoc_tx_epids();
9239 +
9240 + /* Clear this interrupt */
9241 + *R_DMA_CH8_SUB3_CLR_INTR = IO_STATE(R_DMA_CH8_SUB3_CLR_INTR, clr_descr, do);
9242 + /* Schedule bottom half of Out Isoc completion function. This function
9243 + finishes the URBs marked with isoc_out_done */
9244 + comp_data = (struct crisv10_isoc_complete_data*)
9245 + kmem_cache_alloc(isoc_compl_cache, SLAB_ATOMIC);
9246 + ASSERT(comp_data != NULL);
9247 + comp_data ->hcd = hcd;
9248 +
9249 + INIT_WORK(&comp_data->usb_bh, complete_isoc_bottom_half, comp_data);
9250 + schedule_work(&comp_data->usb_bh);
9251 + }
9252 +
9253 + return IRQ_HANDLED;
9254 +}
9255 +
9256 +/* Interrupt handler for DMA9/IRQ25 (called from hardware intr) */
9257 +static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc) {
9258 + unsigned long flags;
9259 + struct urb *urb;
9260 + struct usb_hcd *hcd = (struct usb_hcd*)vhc;
9261 + struct crisv10_urb_priv *urb_priv;
9262 + int epid = 0;
9263 + int real_error;
9264 +
9265 + ASSERT(hcd);
9266 +
9267 + /* Clear this interrupt. */
9268 + *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do);
9269 +
9270 + /* Custom clear interrupt for this interrupt */
9271 + /* The reason we cli here is that we call the driver's callback functions. */
9272 + local_irq_save(flags);
9273 +
9274 + /* Note that this while loop assumes that all packets span only
9275 + one rx descriptor. */
9276 + while(myNextRxDesc->status & IO_MASK(USB_IN_status, eop)) {
9277 + epid = IO_EXTRACT(USB_IN_status, epid, myNextRxDesc->status);
9278 + /* Get the active URB for this epid */
9279 + urb = activeUrbList[epid];
9280 +
9281 + ASSERT(epid_inuse(epid));
9282 + if (!urb) {
9283 + dma_err("No urb for epid %d in rx interrupt\n", epid);
9284 + goto skip_out;
9285 + }
9286 +
9287 + /* Check if any errors on epid */
9288 + real_error = 0;
9289 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, error)) {
9290 + __u32 r_usb_ept_data;
9291 +
9292 + if (usb_pipeisoc(urb->pipe)) {
9293 + r_usb_ept_data = etrax_epid_iso_get(epid);
9294 + if((r_usb_ept_data & IO_MASK(R_USB_EPT_DATA_ISO, valid)) &&
9295 + (IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data) == 0) &&
9296 + (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata))) {
9297 + /* Not an error, just a failure to receive an expected iso
9298 + in packet in this frame. This is not documented
9299 + in the designers reference. Continue processing.
9300 + */
9301 + } else real_error = 1;
9302 + } else real_error = 1;
9303 + }
9304 +
9305 + if(real_error) {
9306 + dma_err("Error in RX descr on epid:%d for URB 0x%x",
9307 + epid, (unsigned int)urb);
9308 + dump_ept_data(epid);
9309 + dump_in_desc(myNextRxDesc);
9310 + goto skip_out;
9311 + }
9312 +
9313 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
9314 + ASSERT(urb_priv);
9315 + ASSERT(urb_priv->urb_state == STARTED ||
9316 + urb_priv->urb_state == UNLINK);
9317 +
9318 + if ((usb_pipetype(urb->pipe) == PIPE_BULK) ||
9319 + (usb_pipetype(urb->pipe) == PIPE_CONTROL) ||
9320 + (usb_pipetype(urb->pipe) == PIPE_INTERRUPT)) {
9321 +
9322 + /* We get nodata for empty data transactions, and the rx descriptor's
9323 + hw_len field is not valid in that case. No data to copy in other
9324 + words. */
9325 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
9326 + /* No data to copy */
9327 + } else {
9328 + /*
9329 + dma_dbg("Processing RX for URB:0x%x epid:%d (data:%d ofs:%d)\n",
9330 + (unsigned int)urb, epid, myNextRxDesc->hw_len,
9331 + urb_priv->rx_offset);
9332 + */
9333 + /* Only copy data if URB isn't flaged to be unlinked*/
9334 + if(urb_priv->urb_state != UNLINK) {
9335 + /* Make sure the data fits in the buffer. */
9336 + if(urb_priv->rx_offset + myNextRxDesc->hw_len
9337 + <= urb->transfer_buffer_length) {
9338 +
9339 + /* Copy the data to URBs buffer */
9340 + memcpy(urb->transfer_buffer + urb_priv->rx_offset,
9341 + phys_to_virt(myNextRxDesc->buf), myNextRxDesc->hw_len);
9342 + urb_priv->rx_offset += myNextRxDesc->hw_len;
9343 + } else {
9344 + /* Signal overflow when returning URB */
9345 + urb->status = -EOVERFLOW;
9346 + tc_finish_urb_later(hcd, urb, urb->status);
9347 + }
9348 + }
9349 + }
9350 +
9351 + /* Check if it was the last packet in the transfer */
9352 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, eot)) {
9353 + /* Special handling for In Ctrl URBs. */
9354 + if(usb_pipecontrol(urb->pipe) && usb_pipein(urb->pipe) &&
9355 + !(urb_priv->ctrl_zout_done)) {
9356 + /* Flag that RX part of Ctrl transfer is done. Because zout descr
9357 + interrupt hasn't happend yet will the URB be finished in the
9358 + TX-Interrupt. */
9359 + urb_priv->ctrl_rx_done = 1;
9360 + tc_dbg("Not finishing In Ctrl URB:0x%x from rx_interrupt, waiting"
9361 + " for zout\n", (unsigned int)urb);
9362 + } else {
9363 + tc_finish_urb(hcd, urb, 0);
9364 + }
9365 + }
9366 + } else { /* ISOC RX */
9367 + /*
9368 + isoc_dbg("Processing RX for epid:%d (URB:0x%x) ISOC pipe\n",
9369 + epid, (unsigned int)urb);
9370 + */
9371 +
9372 + struct usb_iso_packet_descriptor *packet;
9373 +
9374 + if (urb_priv->urb_state == UNLINK) {
9375 + isoc_warn("Ignoring Isoc Rx data for urb being unlinked.\n");
9376 + goto skip_out;
9377 + } else if (urb_priv->urb_state == NOT_STARTED) {
9378 + isoc_err("What? Got Rx data for Isoc urb that isn't started?\n");
9379 + goto skip_out;
9380 + }
9381 +
9382 + packet = &urb->iso_frame_desc[urb_priv->isoc_packet_counter];
9383 + ASSERT(packet);
9384 + packet->status = 0;
9385 +
9386 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
9387 + /* We get nodata for empty data transactions, and the rx descriptor's
9388 + hw_len field is not valid in that case. We copy 0 bytes however to
9389 + stay in synch. */
9390 + packet->actual_length = 0;
9391 + } else {
9392 + packet->actual_length = myNextRxDesc->hw_len;
9393 + /* Make sure the data fits in the buffer. */
9394 + ASSERT(packet->actual_length <= packet->length);
9395 + memcpy(urb->transfer_buffer + packet->offset,
9396 + phys_to_virt(myNextRxDesc->buf), packet->actual_length);
9397 + if(packet->actual_length > 0)
9398 + isoc_dbg("Copied %d bytes, packet %d for URB:0x%x[%d]\n",
9399 + packet->actual_length, urb_priv->isoc_packet_counter,
9400 + (unsigned int)urb, urb_priv->urb_num);
9401 + }
9402 +
9403 + /* Increment the packet counter. */
9404 + urb_priv->isoc_packet_counter++;
9405 +
9406 + /* Note that we don't care about the eot field in the rx descriptor's
9407 + status. It will always be set for isoc traffic. */
9408 + if (urb->number_of_packets == urb_priv->isoc_packet_counter) {
9409 + /* Complete the urb with status OK. */
9410 + tc_finish_urb(hcd, urb, 0);
9411 + }
9412 + }
9413 +
9414 + skip_out:
9415 + myNextRxDesc->status = 0;
9416 + myNextRxDesc->command |= IO_MASK(USB_IN_command, eol);
9417 + myLastRxDesc->command &= ~IO_MASK(USB_IN_command, eol);
9418 + myLastRxDesc = myNextRxDesc;
9419 + myNextRxDesc = phys_to_virt(myNextRxDesc->next);
9420 + flush_etrax_cache();
9421 + *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, restart);
9422 + }
9423 +
9424 + local_irq_restore(flags);
9425 +
9426 + return IRQ_HANDLED;
9427 +}
9428 +
9429 +static void tc_bulk_start_timer_func(unsigned long dummy) {
9430 + /* We might enable an EP descriptor behind the current DMA position when
9431 + it's about to decide that there are no more bulk traffic and it should
9432 + stop the bulk channel.
9433 + Therefore we periodically check if the bulk channel is stopped and there
9434 + is an enabled bulk EP descriptor, in which case we start the bulk
9435 + channel. */
9436 +
9437 + if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
9438 + int epid;
9439 +
9440 + timer_dbg("bulk_start_timer: Bulk DMA channel not running.\n");
9441 +
9442 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
9443 + if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
9444 + timer_warn("Found enabled EP for epid %d, starting bulk channel.\n",
9445 + epid);
9446 + restart_dma8_sub0();
9447 +
9448 + /* Restart the bulk eot timer since we just started the bulk channel.*/
9449 + mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
9450 +
9451 + /* No need to search any further. */
9452 + break;
9453 + }
9454 + }
9455 + } else {
9456 + timer_dbg("bulk_start_timer: Bulk DMA channel running.\n");
9457 + }
9458 +}
9459 +
9460 +static void tc_bulk_eot_timer_func(unsigned long dummy) {
9461 + struct usb_hcd *hcd = (struct usb_hcd*)dummy;
9462 + ASSERT(hcd);
9463 + /* Because of a race condition in the top half, we might miss a bulk eot.
9464 + This timer "simulates" a bulk eot if we don't get one for a while,
9465 + hopefully correcting the situation. */
9466 + timer_dbg("bulk_eot_timer timed out.\n");
9467 + check_finished_bulk_tx_epids(hcd, 1);
9468 +}
9469 +
9470 +
9471 +/*************************************************************/
9472 +/*************************************************************/
9473 +/* Device driver block */
9474 +/*************************************************************/
9475 +/*************************************************************/
9476 +
9477 +/* Forward declarations for device driver functions */
9478 +static int devdrv_hcd_probe(struct device *);
9479 +static int devdrv_hcd_remove(struct device *);
9480 +#ifdef CONFIG_PM
9481 +static int devdrv_hcd_suspend(struct device *, u32, u32);
9482 +static int devdrv_hcd_resume(struct device *, u32);
9483 +#endif /* CONFIG_PM */
9484 +
9485 +/* the device */
9486 +static struct platform_device *devdrv_hc_platform_device;
9487 +
9488 +/* device driver interface */
9489 +static struct device_driver devdrv_hc_device_driver = {
9490 + .name = (char *) hc_name,
9491 + .bus = &platform_bus_type,
9492 +
9493 + .probe = devdrv_hcd_probe,
9494 + .remove = devdrv_hcd_remove,
9495 +
9496 +#ifdef CONFIG_PM
9497 + .suspend = devdrv_hcd_suspend,
9498 + .resume = devdrv_hcd_resume,
9499 +#endif /* CONFIG_PM */
9500 +};
9501
9502 - CHECK_ALIGN(&TxIsocEPList[i]);
9503 - TxIsocEPList[i].hw_len = 0;
9504 -
9505 - /* Must enable the last EP descr to get eof interrupt. */
9506 - TxIsocEPList[i].command = (IO_STATE(USB_EP_command, enable, yes) |
9507 - IO_STATE(USB_EP_command, eof, yes) |
9508 - IO_STATE(USB_EP_command, eol, yes) |
9509 - IO_FIELD(USB_EP_command, epid, INVALID_EPID));
9510 - TxIsocEPList[i].sub = virt_to_phys(&TxIsocSB_zout);
9511 - TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[0]);
9512 -
9513 - *R_DMA_CH8_SUB3_EP = virt_to_phys(&TxIsocEPList[0]);
9514 - *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
9515 -
9516 - DBFEXIT;
9517 -}
9518 -
9519 -static void etrax_usb_unlink_intr_urb(struct urb *urb)
9520 +/* initialize the host controller and driver */
9521 +static int __init_or_module devdrv_hcd_probe(struct device *dev)
9522 {
9523 - volatile USB_EP_Desc_t *first_ep; /* First EP in the list. */
9524 - volatile USB_EP_Desc_t *curr_ep; /* Current EP, the iterator. */
9525 - volatile USB_EP_Desc_t *next_ep; /* The EP after current. */
9526 - volatile USB_EP_Desc_t *unlink_ep; /* The one we should remove from the list. */
9527 -
9528 - int epid;
9529 -
9530 - /* Read 8.8.4 in Designer's Reference, "Removing an EP Descriptor from the List". */
9531 -
9532 - DBFENTER;
9533 -
9534 - epid = ((etrax_urb_priv_t *)urb->hcpriv)->epid;
9535 -
9536 - first_ep = &TxIntrEPList[0];
9537 - curr_ep = first_ep;
9538 -
9539 -
9540 - /* Note that this loop removes all EP descriptors with this epid. This assumes
9541 - that all EP descriptors belong to the one and only urb for this epid. */
9542 -
9543 - do {
9544 - next_ep = (USB_EP_Desc_t *)phys_to_virt(curr_ep->next);
9545 -
9546 - if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
9547 -
9548 - dbg_intr("Found EP to unlink for epid %d", epid);
9549 -
9550 - /* This is the one we should unlink. */
9551 - unlink_ep = next_ep;
9552 -
9553 - /* Actually unlink the EP from the DMA list. */
9554 - curr_ep->next = unlink_ep->next;
9555 -
9556 - /* Wait until the DMA is no longer at this descriptor. */
9557 - while (*R_DMA_CH8_SUB2_EP == virt_to_phys(unlink_ep));
9558 + struct usb_hcd *hcd;
9559 + struct crisv10_hcd *crisv10_hcd;
9560 + int retval;
9561 +
9562 + /* Check DMA burst length */
9563 + if(IO_EXTRACT(R_BUS_CONFIG, dma_burst, *R_BUS_CONFIG) !=
9564 + IO_STATE(R_BUS_CONFIG, dma_burst, burst32)) {
9565 + devdrv_err("Invalid DMA burst length in Etrax 100LX,"
9566 + " needs to be 32\n");
9567 + return -EPERM;
9568 + }
9569 +
9570 + hcd = usb_create_hcd(&crisv10_hc_driver, dev, dev->bus_id);
9571 + if (!hcd)
9572 + return -ENOMEM;
9573 +
9574 + crisv10_hcd = hcd_to_crisv10_hcd(hcd);
9575 + spin_lock_init(&crisv10_hcd->lock);
9576 + crisv10_hcd->num_ports = num_ports();
9577 + crisv10_hcd->running = 0;
9578 +
9579 + dev_set_drvdata(dev, crisv10_hcd);
9580 +
9581 + devdrv_dbg("ETRAX USB IRQs HC:%d RX:%d TX:%d\n", ETRAX_USB_HC_IRQ,
9582 + ETRAX_USB_RX_IRQ, ETRAX_USB_TX_IRQ);
9583 +
9584 + /* Print out chip version read from registers */
9585 + int rev_maj = *R_USB_REVISION & IO_MASK(R_USB_REVISION, major);
9586 + int rev_min = *R_USB_REVISION & IO_MASK(R_USB_REVISION, minor);
9587 + if(rev_min == 0) {
9588 + devdrv_info("Etrax 100LX USB Revision %d v1,2\n", rev_maj);
9589 + } else {
9590 + devdrv_info("Etrax 100LX USB Revision %d v%d\n", rev_maj, rev_min);
9591 + }
9592 +
9593 + devdrv_info("Bulk timer interval, start:%d eot:%d\n",
9594 + BULK_START_TIMER_INTERVAL,
9595 + BULK_EOT_TIMER_INTERVAL);
9596 +
9597 +
9598 + /* Init root hub data structures */
9599 + if(rh_init()) {
9600 + devdrv_err("Failed init data for Root Hub\n");
9601 + retval = -ENOMEM;
9602 + }
9603 +
9604 + if(port_in_use(0)) {
9605 + if (cris_request_io_interface(if_usb_1, "ETRAX100LX USB-HCD")) {
9606 + printk(KERN_CRIT "usb-host: request IO interface usb1 failed");
9607 + retval = -EBUSY;
9608 + goto out;
9609 + }
9610 + devdrv_info("Claimed interface for USB physical port 1\n");
9611 + }
9612 + if(port_in_use(1)) {
9613 + if (cris_request_io_interface(if_usb_2, "ETRAX100LX USB-HCD")) {
9614 + /* Free first interface if second failed to be claimed */
9615 + if(port_in_use(0)) {
9616 + cris_free_io_interface(if_usb_1);
9617 + }
9618 + printk(KERN_CRIT "usb-host: request IO interface usb2 failed");
9619 + retval = -EBUSY;
9620 + goto out;
9621 + }
9622 + devdrv_info("Claimed interface for USB physical port 2\n");
9623 + }
9624 +
9625 + /* Init transfer controller structs and locks */
9626 + if((retval = tc_init(hcd)) != 0) {
9627 + goto out;
9628 + }
9629 +
9630 + /* Attach interrupt functions for DMA and init DMA controller */
9631 + if((retval = tc_dma_init(hcd)) != 0) {
9632 + goto out;
9633 + }
9634 +
9635 + /* Attach the top IRQ handler for USB controller interrupts */
9636 + if (request_irq(ETRAX_USB_HC_IRQ, crisv10_hcd_top_irq, 0,
9637 + "ETRAX 100LX built-in USB (HC)", hcd)) {
9638 + err("Could not allocate IRQ %d for USB", ETRAX_USB_HC_IRQ);
9639 + retval = -EBUSY;
9640 + goto out;
9641 + }
9642 +
9643 + /* iso_eof is only enabled when isoc traffic is running. */
9644 + *R_USB_IRQ_MASK_SET =
9645 + /* IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set) | */
9646 + IO_STATE(R_USB_IRQ_MASK_SET, bulk_eot, set) |
9647 + IO_STATE(R_USB_IRQ_MASK_SET, epid_attn, set) |
9648 + IO_STATE(R_USB_IRQ_MASK_SET, port_status, set) |
9649 + IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
9650 +
9651 +
9652 + crisv10_ready_wait();
9653 + /* Reset the USB interface. */
9654 + *R_USB_COMMAND =
9655 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
9656 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
9657 + IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
9658 +
9659 + /* Designer's Reference, p. 8 - 10 says we should Initate R_USB_FM_PSTART to
9660 + 0x2A30 (10800), to guarantee that control traffic gets 10% of the
9661 + bandwidth, and periodic transfer may allocate the rest (90%).
9662 + This doesn't work though.
9663 + The value 11960 is chosen to be just after the SOF token, with a couple
9664 + of bit times extra for possible bit stuffing. */
9665 + *R_USB_FM_PSTART = IO_FIELD(R_USB_FM_PSTART, value, 11960);
9666 +
9667 + crisv10_ready_wait();
9668 + /* Configure the USB interface as a host controller. */
9669 + *R_USB_COMMAND =
9670 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
9671 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
9672 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_config);
9673 +
9674 +
9675 + /* Check so controller not busy before enabling ports */
9676 + crisv10_ready_wait();
9677 +
9678 + /* Enable selected USB ports */
9679 + if(port_in_use(0)) {
9680 + *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
9681 + } else {
9682 + *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
9683 + }
9684 + if(port_in_use(1)) {
9685 + *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
9686 + } else {
9687 + *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
9688 + }
9689 +
9690 + crisv10_ready_wait();
9691 + /* Start processing of USB traffic. */
9692 + *R_USB_COMMAND =
9693 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
9694 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
9695 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
9696 +
9697 + /* Do not continue probing initialization before USB interface is done */
9698 + crisv10_ready_wait();
9699 +
9700 + /* Register our Host Controller to USB Core
9701 + * Finish the remaining parts of generic HCD initialization: allocate the
9702 + * buffers of consistent memory, register the bus
9703 + * and call the driver's reset() and start() routines. */
9704 + retval = usb_add_hcd(hcd, ETRAX_USB_HC_IRQ, IRQF_DISABLED);
9705 + if (retval != 0) {
9706 + devdrv_err("Failed registering HCD driver\n");
9707 + goto out;
9708 + }
9709 +
9710 + return 0;
9711 +
9712 + out:
9713 + devdrv_hcd_remove(dev);
9714 + return retval;
9715 +}
9716 +
9717 +
9718 +/* cleanup after the host controller and driver */
9719 +static int __init_or_module devdrv_hcd_remove(struct device *dev)
9720 +{
9721 + struct crisv10_hcd *crisv10_hcd = dev_get_drvdata(dev);
9722 + struct usb_hcd *hcd;
9723 +
9724 + if (!crisv10_hcd)
9725 + return 0;
9726 + hcd = crisv10_hcd_to_hcd(crisv10_hcd);
9727 +
9728 +
9729 + /* Stop USB Controller in Etrax 100LX */
9730 + crisv10_hcd_reset(hcd);
9731 +
9732 + usb_remove_hcd(hcd);
9733 + devdrv_dbg("Removed HCD from USB Core\n");
9734 +
9735 + /* Free USB Controller IRQ */
9736 + free_irq(ETRAX_USB_HC_IRQ, NULL);
9737 +
9738 + /* Free resources */
9739 + tc_dma_destroy();
9740 + tc_destroy();
9741 +
9742 +
9743 + if(port_in_use(0)) {
9744 + cris_free_io_interface(if_usb_1);
9745 + }
9746 + if(port_in_use(1)) {
9747 + cris_free_io_interface(if_usb_2);
9748 + }
9749 +
9750 + devdrv_dbg("Freed all claimed resources\n");
9751 +
9752 + return 0;
9753 +}
9754 +
9755 +
9756 +#ifdef CONFIG_PM
9757 +
9758 +static int devdrv_hcd_suspend(struct usb_hcd *hcd, u32 state, u32 level)
9759 +{
9760 + return 0; /* no-op for now */
9761 +}
9762 +
9763 +static int devdrv_hcd_resume(struct usb_hcd *hcd, u32 level)
9764 +{
9765 + return 0; /* no-op for now */
9766 +}
9767 +
9768 +#endif /* CONFIG_PM */
9769 +
9770 +
9771 +
9772 +/*************************************************************/
9773 +/*************************************************************/
9774 +/* Module block */
9775 +/*************************************************************/
9776 +/*************************************************************/
9777 +
9778 +/* register driver */
9779 +static int __init module_hcd_init(void)
9780 +{
9781 +
9782 + if (usb_disabled())
9783 + return -ENODEV;
9784 +
9785 + /* Here we select enabled ports by following defines created from
9786 + menuconfig */
9787 +#ifndef CONFIG_ETRAX_USB_HOST_PORT1
9788 + ports &= ~(1<<0);
9789 +#endif
9790 +#ifndef CONFIG_ETRAX_USB_HOST_PORT2
9791 + ports &= ~(1<<1);
9792 +#endif
9793
9794 - /* Now we are free to remove it and its SB descriptor.
9795 - Note that it is assumed here that there is only one sb in the
9796 - sb list for this ep. */
9797 - kmem_cache_free(usb_desc_cache, phys_to_virt(unlink_ep->sub));
9798 - kmem_cache_free(usb_desc_cache, (USB_EP_Desc_t *)unlink_ep);
9799 - }
9800 + printk(KERN_INFO "%s version "VERSION" "COPYRIGHT"\n", product_desc);
9801
9802 - curr_ep = phys_to_virt(curr_ep->next);
9803 + devdrv_hc_platform_device =
9804 + platform_device_register_simple((char *) hc_name, 0, NULL, 0);
9805
9806 - } while (curr_ep != first_ep);
9807 - urb->hcpriv = NULL;
9808 + if (IS_ERR(devdrv_hc_platform_device))
9809 + return PTR_ERR(devdrv_hc_platform_device);
9810 + return driver_register(&devdrv_hc_device_driver);
9811 + /*
9812 + * Note that we do not set the DMA mask for the device,
9813 + * i.e. we pretend that we will use PIO, since no specific
9814 + * allocation routines are needed for DMA buffers. This will
9815 + * cause the HCD buffer allocation routines to fall back to
9816 + * kmalloc().
9817 + */
9818 }
9819
9820 -void etrax_usb_do_intr_recover(int epid)
9821 -{
9822 - USB_EP_Desc_t *first_ep, *tmp_ep;
9823 +/* unregister driver */
9824 +static void __exit module_hcd_exit(void)
9825 +{
9826 + driver_unregister(&devdrv_hc_device_driver);
9827 +}
9828
9829 - DBFENTER;
9830 -
9831 - first_ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB2_EP);
9832 - tmp_ep = first_ep;
9833 -
9834 - /* What this does is simply to walk the list of interrupt
9835 - ep descriptors and enable those that are disabled. */
9836 -
9837 - do {
9838 - if (IO_EXTRACT(USB_EP_command, epid, tmp_ep->command) == epid &&
9839 - !(tmp_ep->command & IO_MASK(USB_EP_command, enable))) {
9840 - tmp_ep->command |= IO_STATE(USB_EP_command, enable, yes);
9841 - }
9842 -
9843 - tmp_ep = (USB_EP_Desc_t *)phys_to_virt(tmp_ep->next);
9844 -
9845 - } while (tmp_ep != first_ep);
9846 -
9847 -
9848 - DBFEXIT;
9849 -}
9850 -
9851 -static int etrax_rh_unlink_urb (struct urb *urb)
9852 -{
9853 - etrax_hc_t *hc;
9854 -
9855 - DBFENTER;
9856 -
9857 - hc = urb->dev->bus->hcpriv;
9858 -
9859 - if (hc->rh.urb == urb) {
9860 - hc->rh.send = 0;
9861 - del_timer(&hc->rh.rh_int_timer);
9862 - }
9863 -
9864 - DBFEXIT;
9865 - return 0;
9866 -}
9867 -
9868 -static void etrax_rh_send_irq(struct urb *urb)
9869 -{
9870 - __u16 data = 0;
9871 - etrax_hc_t *hc = urb->dev->bus->hcpriv;
9872 - DBFENTER;
9873 -
9874 -/*
9875 - dbg_rh("R_USB_FM_NUMBER : 0x%08X", *R_USB_FM_NUMBER);
9876 - dbg_rh("R_USB_FM_REMAINING: 0x%08X", *R_USB_FM_REMAINING);
9877 -*/
9878 -
9879 - data |= (hc->rh.wPortChange_1) ? (1 << 1) : 0;
9880 - data |= (hc->rh.wPortChange_2) ? (1 << 2) : 0;
9881 -
9882 - *((__u16 *)urb->transfer_buffer) = cpu_to_le16(data);
9883 - /* FIXME: Why is actual_length set to 1 when data is 2 bytes?
9884 - Since only 1 byte is used, why not declare data as __u8? */
9885 - urb->actual_length = 1;
9886 - urb->status = 0;
9887 -
9888 - if (hc->rh.send && urb->complete) {
9889 - dbg_rh("wPortChange_1: 0x%04X", hc->rh.wPortChange_1);
9890 - dbg_rh("wPortChange_2: 0x%04X", hc->rh.wPortChange_2);
9891 -
9892 - urb->complete(urb, NULL);
9893 - }
9894 -
9895 - DBFEXIT;
9896 -}
9897 -
9898 -static void etrax_rh_init_int_timer(struct urb *urb)
9899 -{
9900 - etrax_hc_t *hc;
9901 -
9902 - DBFENTER;
9903 -
9904 - hc = urb->dev->bus->hcpriv;
9905 - hc->rh.interval = urb->interval;
9906 - init_timer(&hc->rh.rh_int_timer);
9907 - hc->rh.rh_int_timer.function = etrax_rh_int_timer_do;
9908 - hc->rh.rh_int_timer.data = (unsigned long)urb;
9909 - /* FIXME: Is the jiffies resolution enough? All intervals < 10 ms will be mapped
9910 - to 0, and the rest to the nearest lower 10 ms. */
9911 - hc->rh.rh_int_timer.expires = jiffies + ((HZ * hc->rh.interval) / 1000);
9912 - add_timer(&hc->rh.rh_int_timer);
9913 -
9914 - DBFEXIT;
9915 -}
9916 -
9917 -static void etrax_rh_int_timer_do(unsigned long ptr)
9918 -{
9919 - struct urb *urb;
9920 - etrax_hc_t *hc;
9921 -
9922 - DBFENTER;
9923 -
9924 - urb = (struct urb*)ptr;
9925 - hc = urb->dev->bus->hcpriv;
9926 -
9927 - if (hc->rh.send) {
9928 - etrax_rh_send_irq(urb);
9929 - }
9930 -
9931 - DBFEXIT;
9932 -}
9933 -
9934 -static int etrax_usb_setup_epid(struct urb *urb)
9935 -{
9936 - int epid;
9937 - char devnum, endpoint, out_traffic, slow;
9938 - int maxlen;
9939 - unsigned long flags;
9940 -
9941 - DBFENTER;
9942 -
9943 - epid = etrax_usb_lookup_epid(urb);
9944 - if ((epid != -1)){
9945 - /* An epid that fits this urb has been found. */
9946 - DBFEXIT;
9947 - return epid;
9948 - }
9949 -
9950 - /* We must find and initiate a new epid for this urb. */
9951 - epid = etrax_usb_allocate_epid();
9952 -
9953 - if (epid == -1) {
9954 - /* Failed to allocate a new epid. */
9955 - DBFEXIT;
9956 - return epid;
9957 - }
9958 -
9959 - /* We now have a new epid to use. Initiate it. */
9960 - set_bit(epid, (void *)&epid_usage_bitmask);
9961 -
9962 - devnum = usb_pipedevice(urb->pipe);
9963 - endpoint = usb_pipeendpoint(urb->pipe);
9964 - slow = usb_pipeslow(urb->pipe);
9965 - maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
9966 - if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
9967 - /* We want both IN and OUT control traffic to be put on the same EP/SB list. */
9968 - out_traffic = 1;
9969 - } else {
9970 - out_traffic = usb_pipeout(urb->pipe);
9971 - }
9972 -
9973 - save_flags(flags);
9974 - cli();
9975 -
9976 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
9977 - nop();
9978 -
9979 - if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
9980 - *R_USB_EPT_DATA_ISO = IO_STATE(R_USB_EPT_DATA_ISO, valid, yes) |
9981 - /* FIXME: Change any to the actual port? */
9982 - IO_STATE(R_USB_EPT_DATA_ISO, port, any) |
9983 - IO_FIELD(R_USB_EPT_DATA_ISO, max_len, maxlen) |
9984 - IO_FIELD(R_USB_EPT_DATA_ISO, ep, endpoint) |
9985 - IO_FIELD(R_USB_EPT_DATA_ISO, dev, devnum);
9986 - } else {
9987 - *R_USB_EPT_DATA = IO_STATE(R_USB_EPT_DATA, valid, yes) |
9988 - IO_FIELD(R_USB_EPT_DATA, low_speed, slow) |
9989 - /* FIXME: Change any to the actual port? */
9990 - IO_STATE(R_USB_EPT_DATA, port, any) |
9991 - IO_FIELD(R_USB_EPT_DATA, max_len, maxlen) |
9992 - IO_FIELD(R_USB_EPT_DATA, ep, endpoint) |
9993 - IO_FIELD(R_USB_EPT_DATA, dev, devnum);
9994 - }
9995 -
9996 - restore_flags(flags);
9997 -
9998 - if (out_traffic) {
9999 - set_bit(epid, (void *)&epid_out_traffic);
10000 - } else {
10001 - clear_bit(epid, (void *)&epid_out_traffic);
10002 - }
10003 -
10004 - dbg_epid("Setting up epid %d with devnum %d, endpoint %d and max_len %d (%s)",
10005 - epid, devnum, endpoint, maxlen, out_traffic ? "OUT" : "IN");
10006 -
10007 - DBFEXIT;
10008 - return epid;
10009 -}
10010 -
10011 -static void etrax_usb_free_epid(int epid)
10012 -{
10013 - unsigned long flags;
10014 -
10015 - DBFENTER;
10016 -
10017 - if (!test_bit(epid, (void *)&epid_usage_bitmask)) {
10018 - warn("Trying to free unused epid %d", epid);
10019 - DBFEXIT;
10020 - return;
10021 - }
10022 -
10023 - save_flags(flags);
10024 - cli();
10025 -
10026 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
10027 - nop();
10028 - while (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold));
10029 - /* This will, among other things, set the valid field to 0. */
10030 - *R_USB_EPT_DATA = 0;
10031 - restore_flags(flags);
10032 -
10033 - clear_bit(epid, (void *)&epid_usage_bitmask);
10034 -
10035 -
10036 - dbg_epid("Freed epid %d", epid);
10037 -
10038 - DBFEXIT;
10039 -}
10040 -
10041 -static int etrax_usb_lookup_epid(struct urb *urb)
10042 -{
10043 - int i;
10044 - __u32 data;
10045 - char devnum, endpoint, slow, out_traffic;
10046 - int maxlen;
10047 - unsigned long flags;
10048 -
10049 - DBFENTER;
10050 -
10051 - devnum = usb_pipedevice(urb->pipe);
10052 - endpoint = usb_pipeendpoint(urb->pipe);
10053 - slow = usb_pipeslow(urb->pipe);
10054 - maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
10055 - if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
10056 - /* We want both IN and OUT control traffic to be put on the same EP/SB list. */
10057 - out_traffic = 1;
10058 - } else {
10059 - out_traffic = usb_pipeout(urb->pipe);
10060 - }
10061 -
10062 - /* Step through att epids. */
10063 - for (i = 0; i < NBR_OF_EPIDS; i++) {
10064 - if (test_bit(i, (void *)&epid_usage_bitmask) &&
10065 - test_bit(i, (void *)&epid_out_traffic) == out_traffic) {
10066 -
10067 - save_flags(flags);
10068 - cli();
10069 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, i);
10070 - nop();
10071 -
10072 - if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
10073 - data = *R_USB_EPT_DATA_ISO;
10074 - restore_flags(flags);
10075 -
10076 - if ((IO_MASK(R_USB_EPT_DATA_ISO, valid) & data) &&
10077 - (IO_EXTRACT(R_USB_EPT_DATA_ISO, dev, data) == devnum) &&
10078 - (IO_EXTRACT(R_USB_EPT_DATA_ISO, ep, data) == endpoint) &&
10079 - (IO_EXTRACT(R_USB_EPT_DATA_ISO, max_len, data) == maxlen)) {
10080 - dbg_epid("Found epid %d for devnum %d, endpoint %d (%s)",
10081 - i, devnum, endpoint, out_traffic ? "OUT" : "IN");
10082 - DBFEXIT;
10083 - return i;
10084 - }
10085 - } else {
10086 - data = *R_USB_EPT_DATA;
10087 - restore_flags(flags);
10088 -
10089 - if ((IO_MASK(R_USB_EPT_DATA, valid) & data) &&
10090 - (IO_EXTRACT(R_USB_EPT_DATA, dev, data) == devnum) &&
10091 - (IO_EXTRACT(R_USB_EPT_DATA, ep, data) == endpoint) &&
10092 - (IO_EXTRACT(R_USB_EPT_DATA, low_speed, data) == slow) &&
10093 - (IO_EXTRACT(R_USB_EPT_DATA, max_len, data) == maxlen)) {
10094 - dbg_epid("Found epid %d for devnum %d, endpoint %d (%s)",
10095 - i, devnum, endpoint, out_traffic ? "OUT" : "IN");
10096 - DBFEXIT;
10097 - return i;
10098 - }
10099 - }
10100 - }
10101 - }
10102 -
10103 - DBFEXIT;
10104 - return -1;
10105 -}
10106 -
10107 -static int etrax_usb_allocate_epid(void)
10108 -{
10109 - int i;
10110 -
10111 - DBFENTER;
10112 -
10113 - for (i = 0; i < NBR_OF_EPIDS; i++) {
10114 - if (!test_bit(i, (void *)&epid_usage_bitmask)) {
10115 - dbg_epid("Found free epid %d", i);
10116 - DBFEXIT;
10117 - return i;
10118 - }
10119 - }
10120 -
10121 - dbg_epid("Found no free epids");
10122 - DBFEXIT;
10123 - return -1;
10124 -}
10125 -
10126 -static int etrax_usb_submit_urb(struct urb *urb, unsigned mem_flags)
10127 -{
10128 - etrax_hc_t *hc;
10129 - int ret = -EINVAL;
10130 -
10131 - DBFENTER;
10132 -
10133 - if (!urb->dev || !urb->dev->bus) {
10134 - return -ENODEV;
10135 - }
10136 - if (usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)) <= 0) {
10137 - info("Submit urb to pipe with maxpacketlen 0, pipe 0x%X\n", urb->pipe);
10138 - return -EMSGSIZE;
10139 - }
10140 -
10141 - if (urb->timeout) {
10142 - /* FIXME. */
10143 - warn("urb->timeout specified, ignoring.");
10144 - }
10145 -
10146 - hc = (etrax_hc_t*)urb->dev->bus->hcpriv;
10147 -
10148 - if (usb_pipedevice(urb->pipe) == hc->rh.devnum) {
10149 - /* This request is for the Virtual Root Hub. */
10150 - ret = etrax_rh_submit_urb(urb);
10151 -
10152 - } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
10153 -
10154 - ret = etrax_usb_submit_bulk_urb(urb);
10155 -
10156 - } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
10157 -
10158 - ret = etrax_usb_submit_ctrl_urb(urb);
10159 -
10160 - } else if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
10161 - int bustime;
10162 -
10163 - if (urb->bandwidth == 0) {
10164 - bustime = usb_check_bandwidth(urb->dev, urb);
10165 - if (bustime < 0) {
10166 - ret = bustime;
10167 - } else {
10168 - ret = etrax_usb_submit_intr_urb(urb);
10169 - if (ret == 0)
10170 - usb_claim_bandwidth(urb->dev, urb, bustime, 0);
10171 - }
10172 - } else {
10173 - /* Bandwidth already set. */
10174 - ret = etrax_usb_submit_intr_urb(urb);
10175 - }
10176 -
10177 - } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
10178 - int bustime;
10179 -
10180 - if (urb->bandwidth == 0) {
10181 - bustime = usb_check_bandwidth(urb->dev, urb);
10182 - if (bustime < 0) {
10183 - ret = bustime;
10184 - } else {
10185 - ret = etrax_usb_submit_isoc_urb(urb);
10186 - if (ret == 0)
10187 - usb_claim_bandwidth(urb->dev, urb, bustime, 0);
10188 - }
10189 - } else {
10190 - /* Bandwidth already set. */
10191 - ret = etrax_usb_submit_isoc_urb(urb);
10192 - }
10193 - }
10194 -
10195 - DBFEXIT;
10196 -
10197 - if (ret != 0)
10198 - printk("Submit URB error %d\n", ret);
10199 -
10200 - return ret;
10201 -}
10202 -
10203 -static int etrax_usb_unlink_urb(struct urb *urb, int status)
10204 -{
10205 - etrax_hc_t *hc;
10206 - etrax_urb_priv_t *urb_priv;
10207 - int epid;
10208 - unsigned int flags;
10209 -
10210 - DBFENTER;
10211 -
10212 - if (!urb) {
10213 - return -EINVAL;
10214 - }
10215 -
10216 - /* Disable interrupts here since a descriptor interrupt for the isoc epid
10217 - will modify the sb list. This could possibly be done more granular, but
10218 - unlink_urb should not be used frequently anyway.
10219 - */
10220 -
10221 - save_flags(flags);
10222 - cli();
10223 -
10224 - if (!urb->dev || !urb->dev->bus) {
10225 - restore_flags(flags);
10226 - return -ENODEV;
10227 - }
10228 - if (!urb->hcpriv) {
10229 - /* This happens if a device driver calls unlink on an urb that
10230 - was never submitted (lazy driver) or if the urb was completed
10231 - while unlink was being called. */
10232 - restore_flags(flags);
10233 - return 0;
10234 - }
10235 - if (urb->transfer_flags & URB_ASYNC_UNLINK) {
10236 - /* FIXME. */
10237 - /* If URB_ASYNC_UNLINK is set:
10238 - unlink
10239 - move to a separate urb list
10240 - call complete at next sof with ECONNRESET
10241 -
10242 - If not:
10243 - wait 1 ms
10244 - unlink
10245 - call complete with ENOENT
10246 - */
10247 - warn("URB_ASYNC_UNLINK set, ignoring.");
10248 - }
10249 -
10250 - /* One might think that urb->status = -EINPROGRESS would be a requirement for unlinking,
10251 - but that doesn't work for interrupt and isochronous traffic since they are completed
10252 - repeatedly, and urb->status is set then. That may in itself be a bug though. */
10253 -
10254 - hc = urb->dev->bus->hcpriv;
10255 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
10256 - epid = urb_priv->epid;
10257 -
10258 - /* Set the urb status (synchronous unlink). */
10259 - urb->status = -ENOENT;
10260 - urb_priv->urb_state = UNLINK;
10261 -
10262 - if (usb_pipedevice(urb->pipe) == hc->rh.devnum) {
10263 - int ret;
10264 - ret = etrax_rh_unlink_urb(urb);
10265 - DBFEXIT;
10266 - restore_flags(flags);
10267 - return ret;
10268 -
10269 - } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
10270 -
10271 - dbg_bulk("Unlink of bulk urb (0x%lx)", (unsigned long)urb);
10272 -
10273 - if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
10274 - /* The EP was enabled, disable it and wait. */
10275 - TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
10276 -
10277 - /* Ah, the luxury of busy-wait. */
10278 - while (*R_DMA_CH8_SUB0_EP == virt_to_phys(&TxBulkEPList[epid]));
10279 - }
10280 - /* Kicking dummy list out of the party. */
10281 - TxBulkEPList[epid].next = virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
10282 -
10283 - } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
10284 -
10285 - dbg_ctrl("Unlink of ctrl urb (0x%lx)", (unsigned long)urb);
10286 -
10287 - if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
10288 - /* The EP was enabled, disable it and wait. */
10289 - TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
10290 -
10291 - /* Ah, the luxury of busy-wait. */
10292 - while (*R_DMA_CH8_SUB1_EP == virt_to_phys(&TxCtrlEPList[epid]));
10293 - }
10294 -
10295 - } else if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
10296 -
10297 - dbg_intr("Unlink of intr urb (0x%lx)", (unsigned long)urb);
10298 -
10299 - /* Separate function because it's a tad more complicated. */
10300 - etrax_usb_unlink_intr_urb(urb);
10301 -
10302 - } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
10303 -
10304 - dbg_isoc("Unlink of isoc urb (0x%lx)", (unsigned long)urb);
10305 -
10306 - if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
10307 - /* The EP was enabled, disable it and wait. */
10308 - TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
10309 -
10310 - /* Ah, the luxury of busy-wait. */
10311 - while (*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid]));
10312 - }
10313 - }
10314 -
10315 - /* Note that we need to remove the urb from the urb list *before* removing its SB
10316 - descriptors. (This means that the isoc eof handler might get a null urb when we
10317 - are unlinking the last urb.) */
10318 -
10319 - if (usb_pipetype(urb->pipe) == PIPE_BULK) {
10320 -
10321 - urb_list_del(urb, epid);
10322 - TxBulkEPList[epid].sub = 0;
10323 - etrax_remove_from_sb_list(urb);
10324 -
10325 - } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
10326 -
10327 - urb_list_del(urb, epid);
10328 - TxCtrlEPList[epid].sub = 0;
10329 - etrax_remove_from_sb_list(urb);
10330 -
10331 - } else if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
10332 -
10333 - urb_list_del(urb, epid);
10334 - /* Sanity check (should never happen). */
10335 - assert(urb_list_empty(epid));
10336 -
10337 - /* Release allocated bandwidth. */
10338 - usb_release_bandwidth(urb->dev, urb, 0);
10339 -
10340 - } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
10341 -
10342 - if (usb_pipeout(urb->pipe)) {
10343 -
10344 - USB_SB_Desc_t *iter_sb, *prev_sb, *next_sb;
10345 -
10346 - if (__urb_list_entry(urb, epid)) {
10347 -
10348 - urb_list_del(urb, epid);
10349 - iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
10350 - prev_sb = 0;
10351 - while (iter_sb && (iter_sb != urb_priv->first_sb)) {
10352 - prev_sb = iter_sb;
10353 - iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
10354 - }
10355 -
10356 - if (iter_sb == 0) {
10357 - /* Unlink of the URB currently being transmitted. */
10358 - prev_sb = 0;
10359 - iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
10360 - }
10361 -
10362 - while (iter_sb && (iter_sb != urb_priv->last_sb)) {
10363 - iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
10364 - }
10365 - if (iter_sb) {
10366 - next_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
10367 - } else {
10368 - /* This should only happen if the DMA has completed
10369 - processing the SB list for this EP while interrupts
10370 - are disabled. */
10371 - dbg_isoc("Isoc urb not found, already sent?");
10372 - next_sb = 0;
10373 - }
10374 - if (prev_sb) {
10375 - prev_sb->next = next_sb ? virt_to_phys(next_sb) : 0;
10376 - } else {
10377 - TxIsocEPList[epid].sub = next_sb ? virt_to_phys(next_sb) : 0;
10378 - }
10379 -
10380 - etrax_remove_from_sb_list(urb);
10381 - if (urb_list_empty(epid)) {
10382 - TxIsocEPList[epid].sub = 0;
10383 - dbg_isoc("Last isoc out urb epid %d", epid);
10384 - } else if (next_sb || prev_sb) {
10385 - dbg_isoc("Re-enable isoc out epid %d", epid);
10386 -
10387 - TxIsocEPList[epid].hw_len = 0;
10388 - TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
10389 - } else {
10390 - TxIsocEPList[epid].sub = 0;
10391 - dbg_isoc("URB list non-empty and no SB list, EP disabled");
10392 - }
10393 - } else {
10394 - dbg_isoc("Urb 0x%p not found, completed already?", urb);
10395 - }
10396 - } else {
10397 -
10398 - urb_list_del(urb, epid);
10399 -
10400 - /* For in traffic there is only one SB descriptor for each EP even
10401 - though there may be several urbs (all urbs point at the same SB). */
10402 - if (urb_list_empty(epid)) {
10403 - /* No more urbs, remove the SB. */
10404 - TxIsocEPList[epid].sub = 0;
10405 - etrax_remove_from_sb_list(urb);
10406 - } else {
10407 - TxIsocEPList[epid].hw_len = 0;
10408 - TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
10409 - }
10410 - }
10411 - /* Release allocated bandwidth. */
10412 - usb_release_bandwidth(urb->dev, urb, 1);
10413 - }
10414 - /* Free the epid if urb list is empty. */
10415 - if (urb_list_empty(epid)) {
10416 - etrax_usb_free_epid(epid);
10417 - }
10418 - restore_flags(flags);
10419 -
10420 - /* Must be done before calling completion handler. */
10421 - kfree(urb_priv);
10422 - urb->hcpriv = 0;
10423 -
10424 - if (urb->complete) {
10425 - urb->complete(urb, NULL);
10426 - }
10427 -
10428 - DBFEXIT;
10429 - return 0;
10430 -}
10431 -
10432 -static int etrax_usb_get_frame_number(struct usb_device *usb_dev)
10433 -{
10434 - DBFENTER;
10435 - DBFEXIT;
10436 - return (*R_USB_FM_NUMBER & 0x7ff);
10437 -}
10438 -
10439 -static irqreturn_t etrax_usb_tx_interrupt(int irq, void *vhc)
10440 -{
10441 - DBFENTER;
10442 -
10443 - /* This interrupt handler could be used when unlinking EP descriptors. */
10444 -
10445 - if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub0_descr)) {
10446 - USB_EP_Desc_t *ep;
10447 -
10448 - //dbg_bulk("dma8_sub0_descr (BULK) intr.");
10449 -
10450 - /* It should be safe clearing the interrupt here, since we don't expect to get a new
10451 - one until we restart the bulk channel. */
10452 - *R_DMA_CH8_SUB0_CLR_INTR = IO_STATE(R_DMA_CH8_SUB0_CLR_INTR, clr_descr, do);
10453 -
10454 - /* Wait while the DMA is running (though we don't expect it to be). */
10455 - while (*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd));
10456 -
10457 - /* Advance the DMA to the next EP descriptor. */
10458 - ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
10459 -
10460 - //dbg_bulk("descr intr: DMA is at 0x%lx", (unsigned long)ep);
10461 -
10462 - /* ep->next is already a physical address; no need for a virt_to_phys. */
10463 - *R_DMA_CH8_SUB0_EP = ep->next;
10464 -
10465 - /* Start the DMA bulk channel again. */
10466 - *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
10467 - }
10468 - if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub1_descr)) {
10469 - struct urb *urb;
10470 - int epid;
10471 - etrax_urb_priv_t *urb_priv;
10472 - unsigned long int flags;
10473 -
10474 - dbg_ctrl("dma8_sub1_descr (CTRL) intr.");
10475 - *R_DMA_CH8_SUB1_CLR_INTR = IO_STATE(R_DMA_CH8_SUB1_CLR_INTR, clr_descr, do);
10476 -
10477 - /* The complete callback gets called so we cli. */
10478 - save_flags(flags);
10479 - cli();
10480 -
10481 - for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
10482 - if ((TxCtrlEPList[epid].sub == 0) ||
10483 - (epid == DUMMY_EPID) ||
10484 - (epid == INVALID_EPID)) {
10485 - /* Nothing here to see. */
10486 - continue;
10487 - }
10488 -
10489 - /* Get the first urb (if any). */
10490 - urb = urb_list_first(epid);
10491 -
10492 - if (urb) {
10493 -
10494 - /* Sanity check. */
10495 - assert(usb_pipetype(urb->pipe) == PIPE_CONTROL);
10496 -
10497 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
10498 - assert(urb_priv);
10499 -
10500 - if (urb_priv->urb_state == WAITING_FOR_DESCR_INTR) {
10501 - assert(!(TxCtrlEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)));
10502 -
10503 - etrax_usb_complete_urb(urb, 0);
10504 - }
10505 - }
10506 - }
10507 - restore_flags(flags);
10508 - }
10509 - if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub2_descr)) {
10510 - dbg_intr("dma8_sub2_descr (INTR) intr.");
10511 - *R_DMA_CH8_SUB2_CLR_INTR = IO_STATE(R_DMA_CH8_SUB2_CLR_INTR, clr_descr, do);
10512 - }
10513 - if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub3_descr)) {
10514 - struct urb *urb;
10515 - int epid;
10516 - int epid_done;
10517 - etrax_urb_priv_t *urb_priv;
10518 - USB_SB_Desc_t *sb_desc;
10519 -
10520 - usb_isoc_complete_data_t *comp_data = NULL;
10521 -
10522 - /* One or more isoc out transfers are done. */
10523 - dbg_isoc("dma8_sub3_descr (ISOC) intr.");
10524 -
10525 - /* For each isoc out EP search for the first sb_desc with the intr flag
10526 - set. This descriptor must be the last packet from an URB. Then
10527 - traverse the URB list for the EP until the URB with urb_priv->last_sb
10528 - matching the intr-marked sb_desc is found. All URBs before this have
10529 - been sent.
10530 - */
10531 -
10532 - for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
10533 - /* Skip past epids with no SB lists, epids used for in traffic,
10534 - and special (dummy, invalid) epids. */
10535 - if ((TxIsocEPList[epid].sub == 0) ||
10536 - (test_bit(epid, (void *)&epid_out_traffic) == 0) ||
10537 - (epid == DUMMY_EPID) ||
10538 - (epid == INVALID_EPID)) {
10539 - /* Nothing here to see. */
10540 - continue;
10541 - }
10542 - sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
10543 -
10544 - /* Find the last descriptor of the currently active URB for this ep.
10545 - This is the first descriptor in the sub list marked for a descriptor
10546 - interrupt. */
10547 - while (sb_desc && !IO_EXTRACT(USB_SB_command, intr, sb_desc->command)) {
10548 - sb_desc = sb_desc->next ? phys_to_virt(sb_desc->next) : 0;
10549 - }
10550 - assert(sb_desc);
10551 -
10552 - dbg_isoc("Check epid %d, sub 0x%p, SB 0x%p",
10553 - epid,
10554 - phys_to_virt(TxIsocEPList[epid].sub),
10555 - sb_desc);
10556 -
10557 - epid_done = 0;
10558 -
10559 - /* Get the first urb (if any). */
10560 - urb = urb_list_first(epid);
10561 - assert(urb);
10562 -
10563 - while (urb && !epid_done) {
10564 -
10565 - /* Sanity check. */
10566 - assert(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
10567 -
10568 - if (!usb_pipeout(urb->pipe)) {
10569 - /* descr interrupts are generated only for out pipes. */
10570 - epid_done = 1;
10571 - continue;
10572 - }
10573 -
10574 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
10575 - assert(urb_priv);
10576 -
10577 - if (sb_desc != urb_priv->last_sb) {
10578 -
10579 - /* This urb has been sent. */
10580 - dbg_isoc("out URB 0x%p sent", urb);
10581 -
10582 - urb_priv->urb_state = TRANSFER_DONE;
10583 -
10584 - } else if ((sb_desc == urb_priv->last_sb) &&
10585 - !(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
10586 -
10587 - assert((sb_desc->command & IO_MASK(USB_SB_command, eol)) == IO_STATE(USB_SB_command, eol, yes));
10588 - assert(sb_desc->next == 0);
10589 -
10590 - dbg_isoc("out URB 0x%p last in list, epid disabled", urb);
10591 - TxIsocEPList[epid].sub = 0;
10592 - TxIsocEPList[epid].hw_len = 0;
10593 - urb_priv->urb_state = TRANSFER_DONE;
10594 -
10595 - epid_done = 1;
10596 -
10597 - } else {
10598 - epid_done = 1;
10599 - }
10600 - if (!epid_done) {
10601 - urb = urb_list_next(urb, epid);
10602 - }
10603 - }
10604 -
10605 - }
10606 -
10607 - *R_DMA_CH8_SUB3_CLR_INTR = IO_STATE(R_DMA_CH8_SUB3_CLR_INTR, clr_descr, do);
10608 -
10609 - comp_data = (usb_isoc_complete_data_t*)kmem_cache_alloc(isoc_compl_cache, SLAB_ATOMIC);
10610 - assert(comp_data != NULL);
10611 -
10612 - INIT_WORK(&comp_data->usb_bh, etrax_usb_isoc_descr_interrupt_bottom_half, comp_data);
10613 - schedule_work(&comp_data->usb_bh);
10614 - }
10615 -
10616 - DBFEXIT;
10617 - return IRQ_HANDLED;
10618 -}
10619 -
10620 -static void etrax_usb_isoc_descr_interrupt_bottom_half(void *data)
10621 -{
10622 - usb_isoc_complete_data_t *comp_data = (usb_isoc_complete_data_t*)data;
10623 -
10624 - struct urb *urb;
10625 - int epid;
10626 - int epid_done;
10627 - etrax_urb_priv_t *urb_priv;
10628 -
10629 - DBFENTER;
10630 -
10631 - dbg_isoc("dma8_sub3_descr (ISOC) bottom half.");
10632 -
10633 - for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
10634 - unsigned long flags;
10635 -
10636 - save_flags(flags);
10637 - cli();
10638 -
10639 - epid_done = 0;
10640 -
10641 - /* The descriptor interrupt handler has marked all transmitted isoch. out
10642 - URBs with TRANSFER_DONE. Now we traverse all epids and for all that
10643 - have isoch. out traffic traverse its URB list and complete the
10644 - transmitted URB.
10645 - */
10646 -
10647 - while (!epid_done) {
10648 -
10649 - /* Get the first urb (if any). */
10650 - urb = urb_list_first(epid);
10651 - if (urb == 0) {
10652 - epid_done = 1;
10653 - continue;
10654 - }
10655 -
10656 - if (usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) {
10657 - epid_done = 1;
10658 - continue;
10659 - }
10660 -
10661 - if (!usb_pipeout(urb->pipe)) {
10662 - /* descr interrupts are generated only for out pipes. */
10663 - epid_done = 1;
10664 - continue;
10665 - }
10666 -
10667 - dbg_isoc("Check epid %d, SB 0x%p", epid, (char*)TxIsocEPList[epid].sub);
10668 -
10669 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
10670 - assert(urb_priv);
10671 -
10672 - if (urb_priv->urb_state == TRANSFER_DONE) {
10673 - int i;
10674 - struct usb_iso_packet_descriptor *packet;
10675 -
10676 - /* This urb has been sent. */
10677 - dbg_isoc("Completing isoc out URB 0x%p", urb);
10678 -
10679 - for (i = 0; i < urb->number_of_packets; i++) {
10680 - packet = &urb->iso_frame_desc[i];
10681 - packet->status = 0;
10682 - packet->actual_length = packet->length;
10683 - }
10684 -
10685 - etrax_usb_complete_isoc_urb(urb, 0);
10686 -
10687 - if (urb_list_empty(epid)) {
10688 - etrax_usb_free_epid(epid);
10689 - epid_done = 1;
10690 - }
10691 - } else {
10692 - epid_done = 1;
10693 - }
10694 - }
10695 - restore_flags(flags);
10696 -
10697 - }
10698 - kmem_cache_free(isoc_compl_cache, comp_data);
10699 -
10700 - DBFEXIT;
10701 -}
10702 -
10703 -
10704 -
10705 -static irqreturn_t etrax_usb_rx_interrupt(int irq, void *vhc)
10706 -{
10707 - struct urb *urb;
10708 - etrax_urb_priv_t *urb_priv;
10709 - int epid = 0;
10710 - unsigned long flags;
10711 -
10712 - /* Isoc diagnostics. */
10713 - static int curr_fm = 0;
10714 - static int prev_fm = 0;
10715 -
10716 - DBFENTER;
10717 -
10718 - /* Clear this interrupt. */
10719 - *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do);
10720 -
10721 - /* Note that this while loop assumes that all packets span only
10722 - one rx descriptor. */
10723 -
10724 - /* The reason we cli here is that we call the driver's callback functions. */
10725 - save_flags(flags);
10726 - cli();
10727 -
10728 - while (myNextRxDesc->status & IO_MASK(USB_IN_status, eop)) {
10729 -
10730 - epid = IO_EXTRACT(USB_IN_status, epid, myNextRxDesc->status);
10731 - urb = urb_list_first(epid);
10732 -
10733 - //printk("eop for epid %d, first urb 0x%lx\n", epid, (unsigned long)urb);
10734 -
10735 - if (!urb) {
10736 - err("No urb for epid %d in rx interrupt", epid);
10737 - __dump_ept_data(epid);
10738 - goto skip_out;
10739 - }
10740 -
10741 - /* Note that we cannot indescriminately assert(usb_pipein(urb->pipe)) since
10742 - ctrl pipes are not. */
10743 -
10744 - if (myNextRxDesc->status & IO_MASK(USB_IN_status, error)) {
10745 - __u32 r_usb_ept_data;
10746 - int no_error = 0;
10747 -
10748 - assert(test_bit(epid, (void *)&epid_usage_bitmask));
10749 -
10750 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
10751 - nop();
10752 - if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
10753 - r_usb_ept_data = *R_USB_EPT_DATA_ISO;
10754 -
10755 - if ((r_usb_ept_data & IO_MASK(R_USB_EPT_DATA_ISO, valid)) &&
10756 - (IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data) == 0) &&
10757 - (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata))) {
10758 - /* Not an error, just a failure to receive an expected iso
10759 - in packet in this frame. This is not documented
10760 - in the designers reference.
10761 - */
10762 - no_error++;
10763 - } else {
10764 - warn("R_USB_EPT_DATA_ISO for epid %d = 0x%x", epid, r_usb_ept_data);
10765 - }
10766 - } else {
10767 - r_usb_ept_data = *R_USB_EPT_DATA;
10768 - warn("R_USB_EPT_DATA for epid %d = 0x%x", epid, r_usb_ept_data);
10769 - }
10770 -
10771 - if (!no_error){
10772 - warn("error in rx desc->status, epid %d, first urb = 0x%lx",
10773 - epid, (unsigned long)urb);
10774 - __dump_in_desc(myNextRxDesc);
10775 -
10776 - warn("R_USB_STATUS = 0x%x", *R_USB_STATUS);
10777 -
10778 - /* Check that ept was disabled when error occurred. */
10779 - switch (usb_pipetype(urb->pipe)) {
10780 - case PIPE_BULK:
10781 - assert(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
10782 - break;
10783 - case PIPE_CONTROL:
10784 - assert(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
10785 - break;
10786 - case PIPE_INTERRUPT:
10787 - assert(!(TxIntrEPList[epid].command & IO_MASK(USB_EP_command, enable)));
10788 - break;
10789 - case PIPE_ISOCHRONOUS:
10790 - assert(!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)));
10791 - break;
10792 - default:
10793 - warn("etrax_usb_rx_interrupt: bad pipetype %d in urb 0x%p",
10794 - usb_pipetype(urb->pipe),
10795 - urb);
10796 - }
10797 - etrax_usb_complete_urb(urb, -EPROTO);
10798 - goto skip_out;
10799 - }
10800 - }
10801 -
10802 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
10803 - assert(urb_priv);
10804 -
10805 - if ((usb_pipetype(urb->pipe) == PIPE_BULK) ||
10806 - (usb_pipetype(urb->pipe) == PIPE_CONTROL) ||
10807 - (usb_pipetype(urb->pipe) == PIPE_INTERRUPT)) {
10808 -
10809 - if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
10810 - /* We get nodata for empty data transactions, and the rx descriptor's
10811 - hw_len field is not valid in that case. No data to copy in other
10812 - words. */
10813 - } else {
10814 - /* Make sure the data fits in the buffer. */
10815 - assert(urb_priv->rx_offset + myNextRxDesc->hw_len
10816 - <= urb->transfer_buffer_length);
10817 -
10818 - memcpy(urb->transfer_buffer + urb_priv->rx_offset,
10819 - phys_to_virt(myNextRxDesc->buf), myNextRxDesc->hw_len);
10820 - urb_priv->rx_offset += myNextRxDesc->hw_len;
10821 - }
10822 -
10823 - if (myNextRxDesc->status & IO_MASK(USB_IN_status, eot)) {
10824 - if ((usb_pipetype(urb->pipe) == PIPE_CONTROL) &&
10825 - ((TxCtrlEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)) ==
10826 - IO_STATE(USB_EP_command, enable, yes))) {
10827 - /* The EP is still enabled, so the OUT packet used to ack
10828 - the in data is probably not processed yet. If the EP
10829 - sub pointer has not moved beyond urb_priv->last_sb mark
10830 - it for a descriptor interrupt and complete the urb in
10831 - the descriptor interrupt handler.
10832 - */
10833 - USB_SB_Desc_t *sub = TxCtrlEPList[urb_priv->epid].sub ? phys_to_virt(TxCtrlEPList[urb_priv->epid].sub) : 0;
10834 -
10835 - while ((sub != NULL) && (sub != urb_priv->last_sb)) {
10836 - sub = sub->next ? phys_to_virt(sub->next) : 0;
10837 - }
10838 - if (sub != NULL) {
10839 - /* The urb has not been fully processed. */
10840 - urb_priv->urb_state = WAITING_FOR_DESCR_INTR;
10841 - } else {
10842 - warn("(CTRL) epid enabled and urb (0x%p) processed, ep->sub=0x%p", urb, (char*)TxCtrlEPList[urb_priv->epid].sub);
10843 - etrax_usb_complete_urb(urb, 0);
10844 - }
10845 - } else {
10846 - etrax_usb_complete_urb(urb, 0);
10847 - }
10848 - }
10849 -
10850 - } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
10851 -
10852 - struct usb_iso_packet_descriptor *packet;
10853 -
10854 - if (urb_priv->urb_state == UNLINK) {
10855 - info("Ignoring rx data for urb being unlinked.");
10856 - goto skip_out;
10857 - } else if (urb_priv->urb_state == NOT_STARTED) {
10858 - info("What? Got rx data for urb that isn't started?");
10859 - goto skip_out;
10860 - }
10861 -
10862 - packet = &urb->iso_frame_desc[urb_priv->isoc_packet_counter];
10863 - packet->status = 0;
10864 -
10865 - if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
10866 - /* We get nodata for empty data transactions, and the rx descriptor's
10867 - hw_len field is not valid in that case. We copy 0 bytes however to
10868 - stay in synch. */
10869 - packet->actual_length = 0;
10870 - } else {
10871 - packet->actual_length = myNextRxDesc->hw_len;
10872 - /* Make sure the data fits in the buffer. */
10873 - assert(packet->actual_length <= packet->length);
10874 - memcpy(urb->transfer_buffer + packet->offset,
10875 - phys_to_virt(myNextRxDesc->buf), packet->actual_length);
10876 - }
10877 -
10878 - /* Increment the packet counter. */
10879 - urb_priv->isoc_packet_counter++;
10880 -
10881 - /* Note that we don't care about the eot field in the rx descriptor's status.
10882 - It will always be set for isoc traffic. */
10883 - if (urb->number_of_packets == urb_priv->isoc_packet_counter) {
10884 -
10885 - /* Out-of-synch diagnostics. */
10886 - curr_fm = (*R_USB_FM_NUMBER & 0x7ff);
10887 - if (((prev_fm + urb_priv->isoc_packet_counter) % (0x7ff + 1)) != curr_fm) {
10888 - /* This test is wrong, if there is more than one isoc
10889 - in endpoint active it will always calculate wrong
10890 - since prev_fm is shared by all endpoints.
10891 -
10892 - FIXME Make this check per URB using urb->start_frame.
10893 - */
10894 - dbg_isoc("Out of synch? Previous frame = %d, current frame = %d",
10895 - prev_fm, curr_fm);
10896 -
10897 - }
10898 - prev_fm = curr_fm;
10899 -
10900 - /* Complete the urb with status OK. */
10901 - etrax_usb_complete_isoc_urb(urb, 0);
10902 - }
10903 - }
10904 -
10905 - skip_out:
10906 -
10907 - /* DMA IN cache bug. Flush the DMA IN buffer from the cache. (struct etrax_dma_descr
10908 - has the same layout as USB_IN_Desc for the relevant fields.) */
10909 - prepare_rx_descriptor((struct etrax_dma_descr*)myNextRxDesc);
10910 -
10911 - myPrevRxDesc = myNextRxDesc;
10912 - myPrevRxDesc->command |= IO_MASK(USB_IN_command, eol);
10913 - myLastRxDesc->command &= ~IO_MASK(USB_IN_command, eol);
10914 - myLastRxDesc = myPrevRxDesc;
10915 -
10916 - myNextRxDesc->status = 0;
10917 - myNextRxDesc = phys_to_virt(myNextRxDesc->next);
10918 - }
10919 -
10920 - restore_flags(flags);
10921 -
10922 - DBFEXIT;
10923 -
10924 - return IRQ_HANDLED;
10925 -}
10926 -
10927 -
10928 -/* This function will unlink the SB descriptors associated with this urb. */
10929 -static int etrax_remove_from_sb_list(struct urb *urb)
10930 -{
10931 - USB_SB_Desc_t *next_sb, *first_sb, *last_sb;
10932 - etrax_urb_priv_t *urb_priv;
10933 - int i = 0;
10934 -
10935 - DBFENTER;
10936 -
10937 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
10938 - assert(urb_priv);
10939 -
10940 - /* Just a sanity check. Since we don't fiddle with the DMA list the EP descriptor
10941 - doesn't really need to be disabled, it's just that we expect it to be. */
10942 - if (usb_pipetype(urb->pipe) == PIPE_BULK) {
10943 - assert(!(TxBulkEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)));
10944 - } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
10945 - assert(!(TxCtrlEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)));
10946 - }
10947 -
10948 - first_sb = urb_priv->first_sb;
10949 - last_sb = urb_priv->last_sb;
10950 -
10951 - assert(first_sb);
10952 - assert(last_sb);
10953 -
10954 - while (first_sb != last_sb) {
10955 - next_sb = (USB_SB_Desc_t *)phys_to_virt(first_sb->next);
10956 - kmem_cache_free(usb_desc_cache, first_sb);
10957 - first_sb = next_sb;
10958 - i++;
10959 - }
10960 - kmem_cache_free(usb_desc_cache, last_sb);
10961 - i++;
10962 - dbg_sb("%d SB descriptors freed", i);
10963 - /* Compare i with urb->number_of_packets for Isoc traffic.
10964 - Should be same when calling unlink_urb */
10965 -
10966 - DBFEXIT;
10967 -
10968 - return i;
10969 -}
10970 -
10971 -static int etrax_usb_submit_bulk_urb(struct urb *urb)
10972 -{
10973 - int epid;
10974 - int empty;
10975 - unsigned long flags;
10976 - etrax_urb_priv_t *urb_priv;
10977 -
10978 - DBFENTER;
10979 -
10980 - /* Epid allocation, empty check and list add must be protected.
10981 - Read about this in etrax_usb_submit_ctrl_urb. */
10982 -
10983 - spin_lock_irqsave(&urb_list_lock, flags);
10984 - epid = etrax_usb_setup_epid(urb);
10985 - if (epid == -1) {
10986 - DBFEXIT;
10987 - spin_unlock_irqrestore(&urb_list_lock, flags);
10988 - return -ENOMEM;
10989 - }
10990 - empty = urb_list_empty(epid);
10991 - urb_list_add(urb, epid);
10992 - spin_unlock_irqrestore(&urb_list_lock, flags);
10993 -
10994 - dbg_bulk("Adding bulk %s urb 0x%lx to %s list, epid %d",
10995 - usb_pipein(urb->pipe) ? "IN" : "OUT", (unsigned long)urb, empty ? "empty" : "", epid);
10996 -
10997 - /* Mark the urb as being in progress. */
10998 - urb->status = -EINPROGRESS;
10999 -
11000 - /* Setup the hcpriv data. */
11001 - urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
11002 - assert(urb_priv != NULL);
11003 - /* This sets rx_offset to 0. */
11004 - urb_priv->urb_state = NOT_STARTED;
11005 - urb->hcpriv = urb_priv;
11006 -
11007 - if (empty) {
11008 - etrax_usb_add_to_bulk_sb_list(urb, epid);
11009 - }
11010 -
11011 - DBFEXIT;
11012 -
11013 - return 0;
11014 -}
11015 -
11016 -static void etrax_usb_add_to_bulk_sb_list(struct urb *urb, int epid)
11017 -{
11018 - USB_SB_Desc_t *sb_desc;
11019 - etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
11020 - unsigned long flags;
11021 - char maxlen;
11022 -
11023 - DBFENTER;
11024 -
11025 - dbg_bulk("etrax_usb_add_to_bulk_sb_list, urb 0x%lx", (unsigned long)urb);
11026 -
11027 - maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
11028 -
11029 - sb_desc = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
11030 - assert(sb_desc != NULL);
11031 - memset(sb_desc, 0, sizeof(USB_SB_Desc_t));
11032 -
11033 -
11034 - if (usb_pipeout(urb->pipe)) {
11035 -
11036 - dbg_bulk("Grabbing bulk OUT, urb 0x%lx, epid %d", (unsigned long)urb, epid);
11037 -
11038 - /* This is probably a sanity check of the bulk transaction length
11039 - not being larger than 64 kB. */
11040 - if (urb->transfer_buffer_length > 0xffff) {
11041 - panic("urb->transfer_buffer_length > 0xffff");
11042 - }
11043 -
11044 - sb_desc->sw_len = urb->transfer_buffer_length;
11045 -
11046 - /* The rem field is don't care if it's not a full-length transfer, so setting
11047 - it shouldn't hurt. Also, rem isn't used for OUT traffic. */
11048 - sb_desc->command = (IO_FIELD(USB_SB_command, rem, 0) |
11049 - IO_STATE(USB_SB_command, tt, out) |
11050 - IO_STATE(USB_SB_command, eot, yes) |
11051 - IO_STATE(USB_SB_command, eol, yes));
11052 -
11053 - /* The full field is set to yes, even if we don't actually check that this is
11054 - a full-length transfer (i.e., that transfer_buffer_length % maxlen = 0).
11055 - Setting full prevents the USB controller from sending an empty packet in
11056 - that case. However, if URB_ZERO_PACKET was set we want that. */
11057 - if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
11058 - sb_desc->command |= IO_STATE(USB_SB_command, full, yes);
11059 - }
11060 -
11061 - sb_desc->buf = virt_to_phys(urb->transfer_buffer);
11062 - sb_desc->next = 0;
11063 -
11064 - } else if (usb_pipein(urb->pipe)) {
11065 -
11066 - dbg_bulk("Grabbing bulk IN, urb 0x%lx, epid %d", (unsigned long)urb, epid);
11067 -
11068 - sb_desc->sw_len = urb->transfer_buffer_length ?
11069 - (urb->transfer_buffer_length - 1) / maxlen + 1 : 0;
11070 -
11071 - /* The rem field is don't care if it's not a full-length transfer, so setting
11072 - it shouldn't hurt. */
11073 - sb_desc->command =
11074 - (IO_FIELD(USB_SB_command, rem,
11075 - urb->transfer_buffer_length % maxlen) |
11076 - IO_STATE(USB_SB_command, tt, in) |
11077 - IO_STATE(USB_SB_command, eot, yes) |
11078 - IO_STATE(USB_SB_command, eol, yes));
11079 -
11080 - sb_desc->buf = 0;
11081 - sb_desc->next = 0;
11082 - }
11083 -
11084 - urb_priv->first_sb = sb_desc;
11085 - urb_priv->last_sb = sb_desc;
11086 - urb_priv->epid = epid;
11087 -
11088 - urb->hcpriv = urb_priv;
11089 -
11090 - /* Reset toggle bits and reset error count. */
11091 - save_flags(flags);
11092 - cli();
11093 -
11094 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
11095 - nop();
11096 -
11097 - /* FIXME: Is this a special case since the hold field is checked,
11098 - or should we check hold in a lot of other cases as well? */
11099 - if (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) {
11100 - panic("Hold was set in %s", __FUNCTION__);
11101 - }
11102 -
11103 - /* Reset error counters (regardless of which direction this traffic is). */
11104 - *R_USB_EPT_DATA &=
11105 - ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
11106 - IO_MASK(R_USB_EPT_DATA, error_count_out));
11107 -
11108 - /* Software must preset the toggle bits. */
11109 - if (usb_pipeout(urb->pipe)) {
11110 - char toggle =
11111 - usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe));
11112 - *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_out);
11113 - *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_out, toggle);
11114 - } else {
11115 - char toggle =
11116 - usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe));
11117 - *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_in);
11118 - *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_in, toggle);
11119 - }
11120 -
11121 - /* Assert that the EP descriptor is disabled. */
11122 - assert(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
11123 -
11124 - /* The reason we set the EP's sub pointer directly instead of
11125 - walking the SB list and linking it last in the list is that we only
11126 - have one active urb at a time (the rest are queued). */
11127 -
11128 - /* Note that we cannot have interrupts running when we have set the SB descriptor
11129 - but the EP is not yet enabled. If a bulk eot happens for another EP, we will
11130 - find this EP disabled and with a SB != 0, which will make us think that it's done. */
11131 - TxBulkEPList[epid].sub = virt_to_phys(sb_desc);
11132 - TxBulkEPList[epid].hw_len = 0;
11133 - /* Note that we don't have to fill in the ep_id field since this
11134 - was done when we allocated the EP descriptors in init_tx_bulk_ep. */
11135 -
11136 - /* Check if the dummy list is already with us (if several urbs were queued). */
11137 - if (TxBulkEPList[epid].next != virt_to_phys(&TxBulkDummyEPList[epid][0])) {
11138 -
11139 - dbg_bulk("Inviting dummy list to the party for urb 0x%lx, epid %d",
11140 - (unsigned long)urb, epid);
11141 -
11142 - /* The last EP in the dummy list already has its next pointer set to
11143 - TxBulkEPList[epid].next. */
11144 -
11145 - /* We don't need to check if the DMA is at this EP or not before changing the
11146 - next pointer, since we will do it in one 32-bit write (EP descriptors are
11147 - 32-bit aligned). */
11148 - TxBulkEPList[epid].next = virt_to_phys(&TxBulkDummyEPList[epid][0]);
11149 - }
11150 - /* Enable the EP descr. */
11151 - dbg_bulk("Enabling bulk EP for urb 0x%lx, epid %d", (unsigned long)urb, epid);
11152 - TxBulkEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
11153 -
11154 - /* Everything is set up, safe to enable interrupts again. */
11155 - restore_flags(flags);
11156 -
11157 - /* If the DMA bulk channel isn't running, we need to restart it if it
11158 - has stopped at the last EP descriptor (DMA stopped because there was
11159 - no more traffic) or if it has stopped at a dummy EP with the intr flag
11160 - set (DMA stopped because we were too slow in inserting new traffic). */
11161 - if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
11162 -
11163 - USB_EP_Desc_t *ep;
11164 - ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
11165 - dbg_bulk("DMA channel not running in add");
11166 - dbg_bulk("DMA is at 0x%lx", (unsigned long)ep);
11167 -
11168 - if (*R_DMA_CH8_SUB0_EP == virt_to_phys(&TxBulkEPList[NBR_OF_EPIDS - 1]) ||
11169 - (ep->command & 0x8) >> 3) {
11170 - *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
11171 - /* Update/restart the bulk start timer since we just started the channel. */
11172 - mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
11173 - /* Update/restart the bulk eot timer since we just inserted traffic. */
11174 - mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
11175 - }
11176 - }
11177 -
11178 - DBFEXIT;
11179 -}
11180 -
11181 -static void etrax_usb_complete_bulk_urb(struct urb *urb, int status)
11182 -{
11183 - etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
11184 - int epid = urb_priv->epid;
11185 - unsigned long flags;
11186 -
11187 - DBFENTER;
11188 -
11189 - if (status)
11190 - warn("Completing bulk urb with status %d.", status);
11191 -
11192 - dbg_bulk("Completing bulk urb 0x%lx for epid %d", (unsigned long)urb, epid);
11193 -
11194 - /* Update the urb list. */
11195 - urb_list_del(urb, epid);
11196 -
11197 - /* For an IN pipe, we always set the actual length, regardless of whether there was
11198 - an error or not (which means the device driver can use the data if it wants to). */
11199 - if (usb_pipein(urb->pipe)) {
11200 - urb->actual_length = urb_priv->rx_offset;
11201 - } else {
11202 - /* Set actual_length for OUT urbs also; the USB mass storage driver seems
11203 - to want that. We wouldn't know of any partial writes if there was an error. */
11204 - if (status == 0) {
11205 - urb->actual_length = urb->transfer_buffer_length;
11206 - } else {
11207 - urb->actual_length = 0;
11208 - }
11209 - }
11210 -
11211 - /* FIXME: Is there something of the things below we shouldn't do if there was an error?
11212 - Like, maybe we shouldn't toggle the toggle bits, or maybe we shouldn't insert more traffic. */
11213 -
11214 - save_flags(flags);
11215 - cli();
11216 -
11217 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
11218 - nop();
11219 -
11220 - /* We need to fiddle with the toggle bits because the hardware doesn't do it for us. */
11221 - if (usb_pipeout(urb->pipe)) {
11222 - char toggle =
11223 - IO_EXTRACT(R_USB_EPT_DATA, t_out, *R_USB_EPT_DATA);
11224 - usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
11225 - usb_pipeout(urb->pipe), toggle);
11226 - } else {
11227 - char toggle =
11228 - IO_EXTRACT(R_USB_EPT_DATA, t_in, *R_USB_EPT_DATA);
11229 - usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
11230 - usb_pipeout(urb->pipe), toggle);
11231 - }
11232 - restore_flags(flags);
11233 -
11234 - /* Remember to free the SBs. */
11235 - etrax_remove_from_sb_list(urb);
11236 - kfree(urb_priv);
11237 - urb->hcpriv = 0;
11238 -
11239 - /* If there are any more urb's in the list we'd better start sending */
11240 - if (!urb_list_empty(epid)) {
11241 -
11242 - struct urb *new_urb;
11243 -
11244 - /* Get the first urb. */
11245 - new_urb = urb_list_first(epid);
11246 - assert(new_urb);
11247 -
11248 - dbg_bulk("More bulk for epid %d", epid);
11249 -
11250 - etrax_usb_add_to_bulk_sb_list(new_urb, epid);
11251 - }
11252 -
11253 - urb->status = status;
11254 -
11255 - /* We let any non-zero status from the layer above have precedence. */
11256 - if (status == 0) {
11257 - /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's max length)
11258 - is to be treated as an error. */
11259 - if (urb->transfer_flags & URB_SHORT_NOT_OK) {
11260 - if (usb_pipein(urb->pipe) &&
11261 - (urb->actual_length !=
11262 - usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)))) {
11263 - urb->status = -EREMOTEIO;
11264 - }
11265 - }
11266 - }
11267 -
11268 - if (urb->complete) {
11269 - urb->complete(urb, NULL);
11270 - }
11271 -
11272 - if (urb_list_empty(epid)) {
11273 - /* This means that this EP is now free, deconfigure it. */
11274 - etrax_usb_free_epid(epid);
11275 -
11276 - /* No more traffic; time to clean up.
11277 - Must set sub pointer to 0, since we look at the sub pointer when handling
11278 - the bulk eot interrupt. */
11279 -
11280 - dbg_bulk("No bulk for epid %d", epid);
11281 -
11282 - TxBulkEPList[epid].sub = 0;
11283 -
11284 - /* Unlink the dummy list. */
11285 -
11286 - dbg_bulk("Kicking dummy list out of party for urb 0x%lx, epid %d",
11287 - (unsigned long)urb, epid);
11288 -
11289 - /* No need to wait for the DMA before changing the next pointer.
11290 - The modulo NBR_OF_EPIDS isn't actually necessary, since we will never use
11291 - the last one (INVALID_EPID) for actual traffic. */
11292 - TxBulkEPList[epid].next =
11293 - virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
11294 - }
11295 -
11296 - DBFEXIT;
11297 -}
11298 -
11299 -static int etrax_usb_submit_ctrl_urb(struct urb *urb)
11300 -{
11301 - int epid;
11302 - int empty;
11303 - unsigned long flags;
11304 - etrax_urb_priv_t *urb_priv;
11305 -
11306 - DBFENTER;
11307 -
11308 - /* FIXME: Return -ENXIO if there is already a queued urb for this endpoint? */
11309 -
11310 - /* Epid allocation, empty check and list add must be protected.
11311 -
11312 - Epid allocation because if we find an existing epid for this endpoint an urb might be
11313 - completed (emptying the list) before we add the new urb to the list, causing the epid
11314 - to be de-allocated. We would then start the transfer with an invalid epid -> epid attn.
11315 -
11316 - Empty check and add because otherwise we might conclude that the list is not empty,
11317 - after which it becomes empty before we add the new urb to the list, causing us not to
11318 - insert the new traffic into the SB list. */
11319 -
11320 - spin_lock_irqsave(&urb_list_lock, flags);
11321 - epid = etrax_usb_setup_epid(urb);
11322 - if (epid == -1) {
11323 - spin_unlock_irqrestore(&urb_list_lock, flags);
11324 - DBFEXIT;
11325 - return -ENOMEM;
11326 - }
11327 - empty = urb_list_empty(epid);
11328 - urb_list_add(urb, epid);
11329 - spin_unlock_irqrestore(&urb_list_lock, flags);
11330 -
11331 - dbg_ctrl("Adding ctrl urb 0x%lx to %s list, epid %d",
11332 - (unsigned long)urb, empty ? "empty" : "", epid);
11333 -
11334 - /* Mark the urb as being in progress. */
11335 - urb->status = -EINPROGRESS;
11336 -
11337 - /* Setup the hcpriv data. */
11338 - urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
11339 - assert(urb_priv != NULL);
11340 - /* This sets rx_offset to 0. */
11341 - urb_priv->urb_state = NOT_STARTED;
11342 - urb->hcpriv = urb_priv;
11343 -
11344 - if (empty) {
11345 - etrax_usb_add_to_ctrl_sb_list(urb, epid);
11346 - }
11347 -
11348 - DBFEXIT;
11349 -
11350 - return 0;
11351 -}
11352 -
11353 -static void etrax_usb_add_to_ctrl_sb_list(struct urb *urb, int epid)
11354 -{
11355 - USB_SB_Desc_t *sb_desc_setup;
11356 - USB_SB_Desc_t *sb_desc_data;
11357 - USB_SB_Desc_t *sb_desc_status;
11358 -
11359 - etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
11360 -
11361 - unsigned long flags;
11362 - char maxlen;
11363 -
11364 - DBFENTER;
11365 -
11366 - maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
11367 -
11368 - sb_desc_setup = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
11369 - assert(sb_desc_setup != NULL);
11370 - sb_desc_status = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
11371 - assert(sb_desc_status != NULL);
11372 -
11373 - /* Initialize the mandatory setup SB descriptor (used only in control transfers) */
11374 - sb_desc_setup->sw_len = 8;
11375 - sb_desc_setup->command = (IO_FIELD(USB_SB_command, rem, 0) |
11376 - IO_STATE(USB_SB_command, tt, setup) |
11377 - IO_STATE(USB_SB_command, full, yes) |
11378 - IO_STATE(USB_SB_command, eot, yes));
11379 -
11380 - sb_desc_setup->buf = virt_to_phys(urb->setup_packet);
11381 -
11382 - if (usb_pipeout(urb->pipe)) {
11383 - dbg_ctrl("Transfer for epid %d is OUT", epid);
11384 -
11385 - /* If this Control OUT transfer has an optional data stage we add an OUT token
11386 - before the mandatory IN (status) token, hence the reordered SB list */
11387 -
11388 - sb_desc_setup->next = virt_to_phys(sb_desc_status);
11389 - if (urb->transfer_buffer) {
11390 -
11391 - dbg_ctrl("This OUT transfer has an extra data stage");
11392 -
11393 - sb_desc_data = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
11394 - assert(sb_desc_data != NULL);
11395 -
11396 - sb_desc_setup->next = virt_to_phys(sb_desc_data);
11397 -
11398 - sb_desc_data->sw_len = urb->transfer_buffer_length;
11399 - sb_desc_data->command = (IO_STATE(USB_SB_command, tt, out) |
11400 - IO_STATE(USB_SB_command, full, yes) |
11401 - IO_STATE(USB_SB_command, eot, yes));
11402 - sb_desc_data->buf = virt_to_phys(urb->transfer_buffer);
11403 - sb_desc_data->next = virt_to_phys(sb_desc_status);
11404 - }
11405 -
11406 - sb_desc_status->sw_len = 1;
11407 - sb_desc_status->command = (IO_FIELD(USB_SB_command, rem, 0) |
11408 - IO_STATE(USB_SB_command, tt, in) |
11409 - IO_STATE(USB_SB_command, eot, yes) |
11410 - IO_STATE(USB_SB_command, intr, yes) |
11411 - IO_STATE(USB_SB_command, eol, yes));
11412 -
11413 - sb_desc_status->buf = 0;
11414 - sb_desc_status->next = 0;
11415 -
11416 - } else if (usb_pipein(urb->pipe)) {
11417 -
11418 - dbg_ctrl("Transfer for epid %d is IN", epid);
11419 - dbg_ctrl("transfer_buffer_length = %d", urb->transfer_buffer_length);
11420 - dbg_ctrl("rem is calculated to %d", urb->transfer_buffer_length % maxlen);
11421 -
11422 - sb_desc_data = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
11423 - assert(sb_desc_data != NULL);
11424 -
11425 - sb_desc_setup->next = virt_to_phys(sb_desc_data);
11426 -
11427 - sb_desc_data->sw_len = urb->transfer_buffer_length ?
11428 - (urb->transfer_buffer_length - 1) / maxlen + 1 : 0;
11429 - dbg_ctrl("sw_len got %d", sb_desc_data->sw_len);
11430 -
11431 - sb_desc_data->command =
11432 - (IO_FIELD(USB_SB_command, rem,
11433 - urb->transfer_buffer_length % maxlen) |
11434 - IO_STATE(USB_SB_command, tt, in) |
11435 - IO_STATE(USB_SB_command, eot, yes));
11436 -
11437 - sb_desc_data->buf = 0;
11438 - sb_desc_data->next = virt_to_phys(sb_desc_status);
11439 -
11440 - /* Read comment at zout_buffer declaration for an explanation to this. */
11441 - sb_desc_status->sw_len = 1;
11442 - sb_desc_status->command = (IO_FIELD(USB_SB_command, rem, 0) |
11443 - IO_STATE(USB_SB_command, tt, zout) |
11444 - IO_STATE(USB_SB_command, full, yes) |
11445 - IO_STATE(USB_SB_command, eot, yes) |
11446 - IO_STATE(USB_SB_command, intr, yes) |
11447 - IO_STATE(USB_SB_command, eol, yes));
11448 -
11449 - sb_desc_status->buf = virt_to_phys(&zout_buffer[0]);
11450 - sb_desc_status->next = 0;
11451 - }
11452 -
11453 - urb_priv->first_sb = sb_desc_setup;
11454 - urb_priv->last_sb = sb_desc_status;
11455 - urb_priv->epid = epid;
11456 -
11457 - urb_priv->urb_state = STARTED;
11458 -
11459 - /* Reset toggle bits and reset error count, remember to di and ei */
11460 - /* Warning: it is possible that this locking doesn't work with bottom-halves */
11461 -
11462 - save_flags(flags);
11463 - cli();
11464 -
11465 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
11466 - nop();
11467 - if (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) {
11468 - panic("Hold was set in %s", __FUNCTION__);
11469 - }
11470 -
11471 -
11472 - /* FIXME: Compare with etrax_usb_add_to_bulk_sb_list where the toggle bits
11473 - are set to a specific value. Why the difference? Read "Transfer and Toggle Bits
11474 - in Designer's Reference, p. 8 - 11. */
11475 - *R_USB_EPT_DATA &=
11476 - ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
11477 - IO_MASK(R_USB_EPT_DATA, error_count_out) |
11478 - IO_MASK(R_USB_EPT_DATA, t_in) |
11479 - IO_MASK(R_USB_EPT_DATA, t_out));
11480 -
11481 - /* Since we use the rx interrupt to complete ctrl urbs, we can enable interrupts now
11482 - (i.e. we don't check the sub pointer on an eot interrupt like we do for bulk traffic). */
11483 - restore_flags(flags);
11484 -
11485 - /* Assert that the EP descriptor is disabled. */
11486 - assert(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
11487 -
11488 - /* Set up and enable the EP descriptor. */
11489 - TxCtrlEPList[epid].sub = virt_to_phys(sb_desc_setup);
11490 - TxCtrlEPList[epid].hw_len = 0;
11491 - TxCtrlEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
11492 -
11493 - /* We start the DMA sub channel without checking if it's running or not, because:
11494 - 1) If it's already running, issuing the start command is a nop.
11495 - 2) We avoid a test-and-set race condition. */
11496 - *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
11497 -
11498 - DBFEXIT;
11499 -}
11500 -
11501 -static void etrax_usb_complete_ctrl_urb(struct urb *urb, int status)
11502 -{
11503 - etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
11504 - int epid = urb_priv->epid;
11505 -
11506 - DBFENTER;
11507 -
11508 - if (status)
11509 - warn("Completing ctrl urb with status %d.", status);
11510 -
11511 - dbg_ctrl("Completing ctrl epid %d, urb 0x%lx", epid, (unsigned long)urb);
11512 -
11513 - /* Remove this urb from the list. */
11514 - urb_list_del(urb, epid);
11515 -
11516 - /* For an IN pipe, we always set the actual length, regardless of whether there was
11517 - an error or not (which means the device driver can use the data if it wants to). */
11518 - if (usb_pipein(urb->pipe)) {
11519 - urb->actual_length = urb_priv->rx_offset;
11520 - }
11521 -
11522 - /* FIXME: Is there something of the things below we shouldn't do if there was an error?
11523 - Like, maybe we shouldn't insert more traffic. */
11524 -
11525 - /* Remember to free the SBs. */
11526 - etrax_remove_from_sb_list(urb);
11527 - kfree(urb_priv);
11528 - urb->hcpriv = 0;
11529 -
11530 - /* If there are any more urbs in the list we'd better start sending. */
11531 - if (!urb_list_empty(epid)) {
11532 - struct urb *new_urb;
11533 -
11534 - /* Get the first urb. */
11535 - new_urb = urb_list_first(epid);
11536 - assert(new_urb);
11537 -
11538 - dbg_ctrl("More ctrl for epid %d, first urb = 0x%lx", epid, (unsigned long)new_urb);
11539 -
11540 - etrax_usb_add_to_ctrl_sb_list(new_urb, epid);
11541 - }
11542 -
11543 - urb->status = status;
11544 -
11545 - /* We let any non-zero status from the layer above have precedence. */
11546 - if (status == 0) {
11547 - /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's max length)
11548 - is to be treated as an error. */
11549 - if (urb->transfer_flags & URB_SHORT_NOT_OK) {
11550 - if (usb_pipein(urb->pipe) &&
11551 - (urb->actual_length !=
11552 - usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)))) {
11553 - urb->status = -EREMOTEIO;
11554 - }
11555 - }
11556 - }
11557 -
11558 - if (urb->complete) {
11559 - urb->complete(urb, NULL);
11560 - }
11561 -
11562 - if (urb_list_empty(epid)) {
11563 - /* No more traffic. Time to clean up. */
11564 - etrax_usb_free_epid(epid);
11565 - /* Must set sub pointer to 0. */
11566 - dbg_ctrl("No ctrl for epid %d", epid);
11567 - TxCtrlEPList[epid].sub = 0;
11568 - }
11569 -
11570 - DBFEXIT;
11571 -}
11572 -
11573 -static int etrax_usb_submit_intr_urb(struct urb *urb)
11574 -{
11575 -
11576 - int epid;
11577 -
11578 - DBFENTER;
11579 -
11580 - if (usb_pipeout(urb->pipe)) {
11581 - /* Unsupported transfer type.
11582 - We don't support interrupt out traffic. (If we do, we can't support
11583 - intervals for neither in or out traffic, but are forced to schedule all
11584 - interrupt traffic in one frame.) */
11585 - return -EINVAL;
11586 - }
11587 -
11588 - epid = etrax_usb_setup_epid(urb);
11589 - if (epid == -1) {
11590 - DBFEXIT;
11591 - return -ENOMEM;
11592 - }
11593 -
11594 - if (!urb_list_empty(epid)) {
11595 - /* There is already a queued urb for this endpoint. */
11596 - etrax_usb_free_epid(epid);
11597 - return -ENXIO;
11598 - }
11599 -
11600 - urb->status = -EINPROGRESS;
11601 -
11602 - dbg_intr("Add intr urb 0x%lx, to list, epid %d", (unsigned long)urb, epid);
11603 -
11604 - urb_list_add(urb, epid);
11605 - etrax_usb_add_to_intr_sb_list(urb, epid);
11606 -
11607 - return 0;
11608 -
11609 - DBFEXIT;
11610 -}
11611 -
11612 -static void etrax_usb_add_to_intr_sb_list(struct urb *urb, int epid)
11613 -{
11614 -
11615 - volatile USB_EP_Desc_t *tmp_ep;
11616 - volatile USB_EP_Desc_t *first_ep;
11617 -
11618 - char maxlen;
11619 - int interval;
11620 - int i;
11621 -
11622 - etrax_urb_priv_t *urb_priv;
11623 -
11624 - DBFENTER;
11625 -
11626 - maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
11627 - interval = urb->interval;
11628 -
11629 - urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
11630 - assert(urb_priv != NULL);
11631 - urb->hcpriv = urb_priv;
11632 -
11633 - first_ep = &TxIntrEPList[0];
11634 -
11635 - /* Round of the interval to 2^n, it is obvious that this code favours
11636 - smaller numbers, but that is actually a good thing */
11637 - /* FIXME: The "rounding error" for larger intervals will be quite
11638 - large. For in traffic this shouldn't be a problem since it will only
11639 - mean that we "poll" more often. */
11640 - for (i = 0; interval; i++) {
11641 - interval = interval >> 1;
11642 - }
11643 - interval = 1 << (i - 1);
11644 -
11645 - dbg_intr("Interval rounded to %d", interval);
11646 -
11647 - tmp_ep = first_ep;
11648 - i = 0;
11649 - do {
11650 - if (tmp_ep->command & IO_MASK(USB_EP_command, eof)) {
11651 - if ((i % interval) == 0) {
11652 - /* Insert the traffic ep after tmp_ep */
11653 - USB_EP_Desc_t *ep_desc;
11654 - USB_SB_Desc_t *sb_desc;
11655 -
11656 - dbg_intr("Inserting EP for epid %d", epid);
11657 -
11658 - ep_desc = (USB_EP_Desc_t *)
11659 - kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
11660 - sb_desc = (USB_SB_Desc_t *)
11661 - kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
11662 - assert(ep_desc != NULL);
11663 - CHECK_ALIGN(ep_desc);
11664 - assert(sb_desc != NULL);
11665 -
11666 - ep_desc->sub = virt_to_phys(sb_desc);
11667 - ep_desc->hw_len = 0;
11668 - ep_desc->command = (IO_FIELD(USB_EP_command, epid, epid) |
11669 - IO_STATE(USB_EP_command, enable, yes));
11670 -
11671 -
11672 - /* Round upwards the number of packets of size maxlen
11673 - that this SB descriptor should receive. */
11674 - sb_desc->sw_len = urb->transfer_buffer_length ?
11675 - (urb->transfer_buffer_length - 1) / maxlen + 1 : 0;
11676 - sb_desc->next = 0;
11677 - sb_desc->buf = 0;
11678 - sb_desc->command =
11679 - (IO_FIELD(USB_SB_command, rem, urb->transfer_buffer_length % maxlen) |
11680 - IO_STATE(USB_SB_command, tt, in) |
11681 - IO_STATE(USB_SB_command, eot, yes) |
11682 - IO_STATE(USB_SB_command, eol, yes));
11683 -
11684 - ep_desc->next = tmp_ep->next;
11685 - tmp_ep->next = virt_to_phys(ep_desc);
11686 - }
11687 - i++;
11688 - }
11689 - tmp_ep = (USB_EP_Desc_t *)phys_to_virt(tmp_ep->next);
11690 - } while (tmp_ep != first_ep);
11691 -
11692 -
11693 - /* Note that first_sb/last_sb doesn't apply to interrupt traffic. */
11694 - urb_priv->epid = epid;
11695 -
11696 - /* We start the DMA sub channel without checking if it's running or not, because:
11697 - 1) If it's already running, issuing the start command is a nop.
11698 - 2) We avoid a test-and-set race condition. */
11699 - *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
11700 -
11701 - DBFEXIT;
11702 -}
11703 -
11704 -
11705 -
11706 -static void etrax_usb_complete_intr_urb(struct urb *urb, int status)
11707 -{
11708 - etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
11709 - int epid = urb_priv->epid;
11710 -
11711 - DBFENTER;
11712 -
11713 - if (status)
11714 - warn("Completing intr urb with status %d.", status);
11715 -
11716 - dbg_intr("Completing intr epid %d, urb 0x%lx", epid, (unsigned long)urb);
11717 -
11718 - urb->status = status;
11719 - urb->actual_length = urb_priv->rx_offset;
11720 -
11721 - dbg_intr("interrupt urb->actual_length = %d", urb->actual_length);
11722 -
11723 - /* We let any non-zero status from the layer above have precedence. */
11724 - if (status == 0) {
11725 - /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's max length)
11726 - is to be treated as an error. */
11727 - if (urb->transfer_flags & URB_SHORT_NOT_OK) {
11728 - if (urb->actual_length !=
11729 - usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
11730 - urb->status = -EREMOTEIO;
11731 - }
11732 - }
11733 - }
11734 -
11735 - /* The driver will resubmit the URB so we need to remove it first */
11736 - etrax_usb_unlink_urb(urb, 0);
11737 - if (urb->complete) {
11738 - urb->complete(urb, NULL);
11739 - }
11740 -
11741 - DBFEXIT;
11742 -}
11743 -
11744 -
11745 -static int etrax_usb_submit_isoc_urb(struct urb *urb)
11746 -{
11747 - int epid;
11748 - unsigned long flags;
11749 -
11750 - DBFENTER;
11751 -
11752 - dbg_isoc("Submitting isoc urb = 0x%lx", (unsigned long)urb);
11753 -
11754 - /* Epid allocation, empty check and list add must be protected.
11755 - Read about this in etrax_usb_submit_ctrl_urb. */
11756 -
11757 - spin_lock_irqsave(&urb_list_lock, flags);
11758 - /* Is there an active epid for this urb ? */
11759 - epid = etrax_usb_setup_epid(urb);
11760 - if (epid == -1) {
11761 - DBFEXIT;
11762 - spin_unlock_irqrestore(&urb_list_lock, flags);
11763 - return -ENOMEM;
11764 - }
11765 -
11766 - /* Ok, now we got valid endpoint, lets insert some traffic */
11767 -
11768 - urb->status = -EINPROGRESS;
11769 -
11770 - /* Find the last urb in the URB_List and add this urb after that one.
11771 - Also add the traffic, that is do an etrax_usb_add_to_isoc_sb_list. This
11772 - is important to make this in "real time" since isochronous traffic is
11773 - time sensitive. */
11774 -
11775 - dbg_isoc("Adding isoc urb to (possibly empty) list");
11776 - urb_list_add(urb, epid);
11777 - etrax_usb_add_to_isoc_sb_list(urb, epid);
11778 - spin_unlock_irqrestore(&urb_list_lock, flags);
11779 -
11780 - DBFEXIT;
11781 -
11782 - return 0;
11783 -}
11784 -
11785 -static void etrax_usb_check_error_isoc_ep(const int epid)
11786 -{
11787 - unsigned long int flags;
11788 - int error_code;
11789 - __u32 r_usb_ept_data;
11790 -
11791 - /* We can't read R_USB_EPID_ATTN here since it would clear the iso_eof,
11792 - bulk_eot and epid_attn interrupts. So we just check the status of
11793 - the epid without testing if for it in R_USB_EPID_ATTN. */
11794 -
11795 -
11796 - save_flags(flags);
11797 - cli();
11798 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
11799 - nop();
11800 - /* Note that although there are separate R_USB_EPT_DATA and R_USB_EPT_DATA_ISO
11801 - registers, they are located at the same address and are of the same size.
11802 - In other words, this read should be ok for isoc also. */
11803 - r_usb_ept_data = *R_USB_EPT_DATA;
11804 - restore_flags(flags);
11805 -
11806 - error_code = IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data);
11807 -
11808 - if (r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, hold)) {
11809 - warn("Hold was set for epid %d.", epid);
11810 - return;
11811 - }
11812 -
11813 - if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA_ISO, error_code, no_error)) {
11814 -
11815 - /* This indicates that the SB list of the ept was completed before
11816 - new data was appended to it. This is not an error, but indicates
11817 - large system or USB load and could possibly cause trouble for
11818 - very timing sensitive USB device drivers so we log it.
11819 - */
11820 - info("Isoc. epid %d disabled with no error", epid);
11821 - return;
11822 -
11823 - } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA_ISO, error_code, stall)) {
11824 - /* Not really a protocol error, just says that the endpoint gave
11825 - a stall response. Note that error_code cannot be stall for isoc. */
11826 - panic("Isoc traffic cannot stall");
11827 -
11828 - } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA_ISO, error_code, bus_error)) {
11829 - /* Two devices responded to a transaction request. Must be resolved
11830 - by software. FIXME: Reset ports? */
11831 - panic("Bus error for epid %d."
11832 - " Two devices responded to transaction request",
11833 - epid);
11834 -
11835 - } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, buffer_error)) {
11836 - /* DMA overrun or underrun. */
11837 - warn("Buffer overrun/underrun for epid %d. DMA too busy?", epid);
11838 -
11839 - /* It seems that error_code = buffer_error in
11840 - R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
11841 - are the same error. */
11842 - }
11843 -}
11844 -
11845 -
11846 -static void etrax_usb_add_to_isoc_sb_list(struct urb *urb, int epid)
11847 -{
11848 -
11849 - int i = 0;
11850 -
11851 - etrax_urb_priv_t *urb_priv;
11852 - USB_SB_Desc_t *prev_sb_desc, *next_sb_desc, *temp_sb_desc;
11853 -
11854 - DBFENTER;
11855 -
11856 - prev_sb_desc = next_sb_desc = temp_sb_desc = NULL;
11857 -
11858 - urb_priv = kzalloc(sizeof(etrax_urb_priv_t), GFP_ATOMIC);
11859 - assert(urb_priv != NULL);
11860 -
11861 - urb->hcpriv = urb_priv;
11862 - urb_priv->epid = epid;
11863 -
11864 - if (usb_pipeout(urb->pipe)) {
11865 -
11866 - if (urb->number_of_packets == 0) panic("etrax_usb_add_to_isoc_sb_list 0 packets\n");
11867 -
11868 - dbg_isoc("Transfer for epid %d is OUT", epid);
11869 - dbg_isoc("%d packets in URB", urb->number_of_packets);
11870 -
11871 - /* Create one SB descriptor for each packet and link them together. */
11872 - for (i = 0; i < urb->number_of_packets; i++) {
11873 - if (!urb->iso_frame_desc[i].length)
11874 - continue;
11875 -
11876 - next_sb_desc = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_ATOMIC);
11877 - assert(next_sb_desc != NULL);
11878 -
11879 - if (urb->iso_frame_desc[i].length > 0) {
11880 -
11881 - next_sb_desc->command = (IO_STATE(USB_SB_command, tt, out) |
11882 - IO_STATE(USB_SB_command, eot, yes));
11883 -
11884 - next_sb_desc->sw_len = urb->iso_frame_desc[i].length;
11885 - next_sb_desc->buf = virt_to_phys((char*)urb->transfer_buffer + urb->iso_frame_desc[i].offset);
11886 -
11887 - /* Check if full length transfer. */
11888 - if (urb->iso_frame_desc[i].length ==
11889 - usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
11890 - next_sb_desc->command |= IO_STATE(USB_SB_command, full, yes);
11891 - }
11892 - } else {
11893 - dbg_isoc("zero len packet");
11894 - next_sb_desc->command = (IO_FIELD(USB_SB_command, rem, 0) |
11895 - IO_STATE(USB_SB_command, tt, zout) |
11896 - IO_STATE(USB_SB_command, eot, yes) |
11897 - IO_STATE(USB_SB_command, full, yes));
11898 -
11899 - next_sb_desc->sw_len = 1;
11900 - next_sb_desc->buf = virt_to_phys(&zout_buffer[0]);
11901 - }
11902 -
11903 - /* First SB descriptor that belongs to this urb */
11904 - if (i == 0)
11905 - urb_priv->first_sb = next_sb_desc;
11906 - else
11907 - prev_sb_desc->next = virt_to_phys(next_sb_desc);
11908 -
11909 - prev_sb_desc = next_sb_desc;
11910 - }
11911 -
11912 - next_sb_desc->command |= (IO_STATE(USB_SB_command, intr, yes) |
11913 - IO_STATE(USB_SB_command, eol, yes));
11914 - next_sb_desc->next = 0;
11915 - urb_priv->last_sb = next_sb_desc;
11916 -
11917 - } else if (usb_pipein(urb->pipe)) {
11918 -
11919 - dbg_isoc("Transfer for epid %d is IN", epid);
11920 - dbg_isoc("transfer_buffer_length = %d", urb->transfer_buffer_length);
11921 - dbg_isoc("rem is calculated to %d", urb->iso_frame_desc[urb->number_of_packets - 1].length);
11922 -
11923 - /* Note that in descriptors for periodic traffic are not consumed. This means that
11924 - the USB controller never propagates in the SB list. In other words, if there already
11925 - is an SB descriptor in the list for this EP we don't have to do anything. */
11926 - if (TxIsocEPList[epid].sub == 0) {
11927 - dbg_isoc("Isoc traffic not already running, allocating SB");
11928 -
11929 - next_sb_desc = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_ATOMIC);
11930 - assert(next_sb_desc != NULL);
11931 -
11932 - next_sb_desc->command = (IO_STATE(USB_SB_command, tt, in) |
11933 - IO_STATE(USB_SB_command, eot, yes) |
11934 - IO_STATE(USB_SB_command, eol, yes));
11935 -
11936 - next_sb_desc->next = 0;
11937 - next_sb_desc->sw_len = 1; /* Actual number of packets is not relevant
11938 - for periodic in traffic as long as it is more
11939 - than zero. Set to 1 always. */
11940 - next_sb_desc->buf = 0;
11941 -
11942 - /* The rem field is don't care for isoc traffic, so we don't set it. */
11943 -
11944 - /* Only one SB descriptor that belongs to this urb. */
11945 - urb_priv->first_sb = next_sb_desc;
11946 - urb_priv->last_sb = next_sb_desc;
11947 -
11948 - } else {
11949 -
11950 - dbg_isoc("Isoc traffic already running, just setting first/last_sb");
11951 -
11952 - /* Each EP for isoc in will have only one SB descriptor, setup when submitting the
11953 - already active urb. Note that even though we may have several first_sb/last_sb
11954 - pointing at the same SB descriptor, they are freed only once (when the list has
11955 - become empty). */
11956 - urb_priv->first_sb = phys_to_virt(TxIsocEPList[epid].sub);
11957 - urb_priv->last_sb = phys_to_virt(TxIsocEPList[epid].sub);
11958 - return;
11959 - }
11960 -
11961 - }
11962 -
11963 - /* Find the spot to insert this urb and add it. */
11964 - if (TxIsocEPList[epid].sub == 0) {
11965 - /* First SB descriptor inserted in this list (in or out). */
11966 - dbg_isoc("Inserting SB desc first in list");
11967 - TxIsocEPList[epid].hw_len = 0;
11968 - TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
11969 -
11970 - } else {
11971 - /* Isochronous traffic is already running, insert new traffic last (only out). */
11972 - dbg_isoc("Inserting SB desc last in list");
11973 - temp_sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
11974 - while ((temp_sb_desc->command & IO_MASK(USB_SB_command, eol)) !=
11975 - IO_STATE(USB_SB_command, eol, yes)) {
11976 - assert(temp_sb_desc->next);
11977 - temp_sb_desc = phys_to_virt(temp_sb_desc->next);
11978 - }
11979 - dbg_isoc("Appending list on desc 0x%p", temp_sb_desc);
11980 -
11981 - /* Next pointer must be set before eol is removed. */
11982 - temp_sb_desc->next = virt_to_phys(urb_priv->first_sb);
11983 - /* Clear the previous end of list flag since there is a new in the
11984 - added SB descriptor list. */
11985 - temp_sb_desc->command &= ~IO_MASK(USB_SB_command, eol);
11986 -
11987 - if (!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
11988 - /* 8.8.5 in Designer's Reference says we should check for and correct
11989 - any errors in the EP here. That should not be necessary if epid_attn
11990 - is handled correctly, so we assume all is ok. */
11991 - dbg_isoc("EP disabled");
11992 - etrax_usb_check_error_isoc_ep(epid);
11993 -
11994 - /* The SB list was exhausted. */
11995 - if (virt_to_phys(urb_priv->last_sb) != TxIsocEPList[epid].sub) {
11996 - /* The new sublist did not get processed before the EP was
11997 - disabled. Setup the EP again. */
11998 - dbg_isoc("Set EP sub to new list");
11999 - TxIsocEPList[epid].hw_len = 0;
12000 - TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
12001 - }
12002 - }
12003 - }
12004 -
12005 - if (urb->transfer_flags & URB_ISO_ASAP) {
12006 - /* The isoc transfer should be started as soon as possible. The start_frame
12007 - field is a return value if URB_ISO_ASAP was set. Comparing R_USB_FM_NUMBER
12008 - with a USB Chief trace shows that the first isoc IN token is sent 2 frames
12009 - later. I'm not sure how this affects usage of the start_frame field by the
12010 - device driver, or how it affects things when USB_ISO_ASAP is not set, so
12011 - therefore there's no compensation for the 2 frame "lag" here. */
12012 - urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
12013 - TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
12014 - urb_priv->urb_state = STARTED;
12015 - dbg_isoc("URB_ISO_ASAP set, urb->start_frame set to %d", urb->start_frame);
12016 - } else {
12017 - /* Not started yet. */
12018 - urb_priv->urb_state = NOT_STARTED;
12019 - dbg_isoc("urb_priv->urb_state set to NOT_STARTED");
12020 - }
12021 -
12022 - /* We start the DMA sub channel without checking if it's running or not, because:
12023 - 1) If it's already running, issuing the start command is a nop.
12024 - 2) We avoid a test-and-set race condition. */
12025 - *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
12026 -
12027 - DBFEXIT;
12028 -}
12029 -
12030 -static void etrax_usb_complete_isoc_urb(struct urb *urb, int status)
12031 -{
12032 - etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
12033 - int epid = urb_priv->epid;
12034 - int auto_resubmit = 0;
12035 -
12036 - DBFENTER;
12037 - dbg_isoc("complete urb 0x%p, status %d", urb, status);
12038 -
12039 - if (status)
12040 - warn("Completing isoc urb with status %d.", status);
12041 -
12042 - if (usb_pipein(urb->pipe)) {
12043 - int i;
12044 -
12045 - /* Make that all isoc packets have status and length set before
12046 - completing the urb. */
12047 - for (i = urb_priv->isoc_packet_counter; i < urb->number_of_packets; i++) {
12048 - urb->iso_frame_desc[i].actual_length = 0;
12049 - urb->iso_frame_desc[i].status = -EPROTO;
12050 - }
12051 -
12052 - urb_list_del(urb, epid);
12053 -
12054 - if (!list_empty(&urb_list[epid])) {
12055 - ((etrax_urb_priv_t *)(urb_list_first(epid)->hcpriv))->urb_state = STARTED;
12056 - } else {
12057 - unsigned long int flags;
12058 - if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
12059 - /* The EP was enabled, disable it and wait. */
12060 - TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
12061 -
12062 - /* Ah, the luxury of busy-wait. */
12063 - while (*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid]));
12064 - }
12065 -
12066 - etrax_remove_from_sb_list(urb);
12067 - TxIsocEPList[epid].sub = 0;
12068 - TxIsocEPList[epid].hw_len = 0;
12069 -
12070 - save_flags(flags);
12071 - cli();
12072 - etrax_usb_free_epid(epid);
12073 - restore_flags(flags);
12074 - }
12075 -
12076 - urb->hcpriv = 0;
12077 - kfree(urb_priv);
12078 -
12079 - /* Release allocated bandwidth. */
12080 - usb_release_bandwidth(urb->dev, urb, 0);
12081 - } else if (usb_pipeout(urb->pipe)) {
12082 - int freed_descr;
12083 -
12084 - dbg_isoc("Isoc out urb complete 0x%p", urb);
12085 -
12086 - /* Update the urb list. */
12087 - urb_list_del(urb, epid);
12088 -
12089 - freed_descr = etrax_remove_from_sb_list(urb);
12090 - dbg_isoc("freed %d descriptors of %d packets", freed_descr, urb->number_of_packets);
12091 - assert(freed_descr == urb->number_of_packets);
12092 - urb->hcpriv = 0;
12093 - kfree(urb_priv);
12094 -
12095 - /* Release allocated bandwidth. */
12096 - usb_release_bandwidth(urb->dev, urb, 0);
12097 - }
12098 -
12099 - urb->status = status;
12100 - if (urb->complete) {
12101 - urb->complete(urb, NULL);
12102 - }
12103 -
12104 - if (auto_resubmit) {
12105 - /* Check that urb was not unlinked by the complete callback. */
12106 - if (__urb_list_entry(urb, epid)) {
12107 - /* Move this one down the list. */
12108 - urb_list_move_last(urb, epid);
12109 -
12110 - /* Mark the now first urb as started (may already be). */
12111 - ((etrax_urb_priv_t *)(urb_list_first(epid)->hcpriv))->urb_state = STARTED;
12112 -
12113 - /* Must set this to 0 since this urb is still active after
12114 - completion. */
12115 - urb_priv->isoc_packet_counter = 0;
12116 - } else {
12117 - warn("(ISOC) automatic resubmit urb 0x%p removed by complete.", urb);
12118 - }
12119 - }
12120 -
12121 - DBFEXIT;
12122 -}
12123 -
12124 -static void etrax_usb_complete_urb(struct urb *urb, int status)
12125 -{
12126 - switch (usb_pipetype(urb->pipe)) {
12127 - case PIPE_BULK:
12128 - etrax_usb_complete_bulk_urb(urb, status);
12129 - break;
12130 - case PIPE_CONTROL:
12131 - etrax_usb_complete_ctrl_urb(urb, status);
12132 - break;
12133 - case PIPE_INTERRUPT:
12134 - etrax_usb_complete_intr_urb(urb, status);
12135 - break;
12136 - case PIPE_ISOCHRONOUS:
12137 - etrax_usb_complete_isoc_urb(urb, status);
12138 - break;
12139 - default:
12140 - err("Unknown pipetype");
12141 - }
12142 -}
12143 -
12144 -
12145 -
12146 -static irqreturn_t etrax_usb_hc_interrupt_top_half(int irq, void *vhc)
12147 -{
12148 - usb_interrupt_registers_t *reg;
12149 - unsigned long flags;
12150 - __u32 irq_mask;
12151 - __u8 status;
12152 - __u32 epid_attn;
12153 - __u16 port_status_1;
12154 - __u16 port_status_2;
12155 - __u32 fm_number;
12156 -
12157 - DBFENTER;
12158 -
12159 - /* Read critical registers into local variables, do kmalloc afterwards. */
12160 - save_flags(flags);
12161 - cli();
12162 -
12163 - irq_mask = *R_USB_IRQ_MASK_READ;
12164 - /* Reading R_USB_STATUS clears the ctl_status interrupt. Note that R_USB_STATUS
12165 - must be read before R_USB_EPID_ATTN since reading the latter clears the
12166 - ourun and perror fields of R_USB_STATUS. */
12167 - status = *R_USB_STATUS;
12168 -
12169 - /* Reading R_USB_EPID_ATTN clears the iso_eof, bulk_eot and epid_attn interrupts. */
12170 - epid_attn = *R_USB_EPID_ATTN;
12171 -
12172 - /* Reading R_USB_RH_PORT_STATUS_1 and R_USB_RH_PORT_STATUS_2 clears the
12173 - port_status interrupt. */
12174 - port_status_1 = *R_USB_RH_PORT_STATUS_1;
12175 - port_status_2 = *R_USB_RH_PORT_STATUS_2;
12176 -
12177 - /* Reading R_USB_FM_NUMBER clears the sof interrupt. */
12178 - /* Note: the lower 11 bits contain the actual frame number, sent with each sof. */
12179 - fm_number = *R_USB_FM_NUMBER;
12180 -
12181 - restore_flags(flags);
12182 -
12183 - reg = (usb_interrupt_registers_t *)kmem_cache_alloc(top_half_reg_cache, SLAB_ATOMIC);
12184 -
12185 - assert(reg != NULL);
12186 -
12187 - reg->hc = (etrax_hc_t *)vhc;
12188 -
12189 - /* Now put register values into kmalloc'd area. */
12190 - reg->r_usb_irq_mask_read = irq_mask;
12191 - reg->r_usb_status = status;
12192 - reg->r_usb_epid_attn = epid_attn;
12193 - reg->r_usb_rh_port_status_1 = port_status_1;
12194 - reg->r_usb_rh_port_status_2 = port_status_2;
12195 - reg->r_usb_fm_number = fm_number;
12196 -
12197 - INIT_WORK(&reg->usb_bh, etrax_usb_hc_interrupt_bottom_half, reg);
12198 - schedule_work(&reg->usb_bh);
12199 -
12200 - DBFEXIT;
12201 -
12202 - return IRQ_HANDLED;
12203 -}
12204 -
12205 -static void etrax_usb_hc_interrupt_bottom_half(void *data)
12206 -{
12207 - usb_interrupt_registers_t *reg = (usb_interrupt_registers_t *)data;
12208 - __u32 irq_mask = reg->r_usb_irq_mask_read;
12209 -
12210 - DBFENTER;
12211 -
12212 - /* Interrupts are handled in order of priority. */
12213 - if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, epid_attn)) {
12214 - etrax_usb_hc_epid_attn_interrupt(reg);
12215 - }
12216 - if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, port_status)) {
12217 - etrax_usb_hc_port_status_interrupt(reg);
12218 - }
12219 - if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, ctl_status)) {
12220 - etrax_usb_hc_ctl_status_interrupt(reg);
12221 - }
12222 - if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, iso_eof)) {
12223 - etrax_usb_hc_isoc_eof_interrupt();
12224 - }
12225 - if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, bulk_eot)) {
12226 - /* Update/restart the bulk start timer since obviously the channel is running. */
12227 - mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
12228 - /* Update/restart the bulk eot timer since we just received an bulk eot interrupt. */
12229 - mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
12230 -
12231 - etrax_usb_hc_bulk_eot_interrupt(0);
12232 - }
12233 -
12234 - kmem_cache_free(top_half_reg_cache, reg);
12235 -
12236 - DBFEXIT;
12237 -}
12238 -
12239 -
12240 -void etrax_usb_hc_isoc_eof_interrupt(void)
12241 -{
12242 - struct urb *urb;
12243 - etrax_urb_priv_t *urb_priv;
12244 - int epid;
12245 - unsigned long flags;
12246 -
12247 - DBFENTER;
12248 -
12249 - /* Do not check the invalid epid (it has a valid sub pointer). */
12250 - for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
12251 -
12252 - /* Do not check the invalid epid (it has a valid sub pointer). */
12253 - if ((epid == DUMMY_EPID) || (epid == INVALID_EPID))
12254 - continue;
12255 -
12256 - /* Disable interrupts to block the isoc out descriptor interrupt handler
12257 - from being called while the isoc EPID list is being checked.
12258 - */
12259 - save_flags(flags);
12260 - cli();
12261 -
12262 - if (TxIsocEPList[epid].sub == 0) {
12263 - /* Nothing here to see. */
12264 - restore_flags(flags);
12265 - continue;
12266 - }
12267 -
12268 - /* Get the first urb (if any). */
12269 - urb = urb_list_first(epid);
12270 - if (urb == 0) {
12271 - warn("Ignoring NULL urb");
12272 - restore_flags(flags);
12273 - continue;
12274 - }
12275 - if (usb_pipein(urb->pipe)) {
12276 -
12277 - /* Sanity check. */
12278 - assert(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
12279 -
12280 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
12281 - assert(urb_priv);
12282 -
12283 - if (urb_priv->urb_state == NOT_STARTED) {
12284 -
12285 - /* If ASAP is not set and urb->start_frame is the current frame,
12286 - start the transfer. */
12287 - if (!(urb->transfer_flags & URB_ISO_ASAP) &&
12288 - (urb->start_frame == (*R_USB_FM_NUMBER & 0x7ff))) {
12289 -
12290 - dbg_isoc("Enabling isoc IN EP descr for epid %d", epid);
12291 - TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
12292 -
12293 - /* This urb is now active. */
12294 - urb_priv->urb_state = STARTED;
12295 - continue;
12296 - }
12297 - }
12298 - }
12299 - restore_flags(flags);
12300 - }
12301 -
12302 - DBFEXIT;
12303 -
12304 -}
12305 -
12306 -void etrax_usb_hc_bulk_eot_interrupt(int timer_induced)
12307 -{
12308 - int epid;
12309 -
12310 - /* The technique is to run one urb at a time, wait for the eot interrupt at which
12311 - point the EP descriptor has been disabled. */
12312 -
12313 - DBFENTER;
12314 - dbg_bulk("bulk eot%s", timer_induced ? ", called by timer" : "");
12315 -
12316 - for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
12317 -
12318 - if (!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
12319 - (TxBulkEPList[epid].sub != 0)) {
12320 -
12321 - struct urb *urb;
12322 - etrax_urb_priv_t *urb_priv;
12323 - unsigned long flags;
12324 - __u32 r_usb_ept_data;
12325 -
12326 - /* Found a disabled EP descriptor which has a non-null sub pointer.
12327 - Verify that this ctrl EP descriptor got disabled no errors.
12328 - FIXME: Necessary to check error_code? */
12329 - dbg_bulk("for epid %d?", epid);
12330 -
12331 - /* Get the first urb. */
12332 - urb = urb_list_first(epid);
12333 -
12334 - /* FIXME: Could this happen for valid reasons? Why did it disappear? Because of
12335 - wrong unlinking? */
12336 - if (!urb) {
12337 - warn("NULL urb for epid %d", epid);
12338 - continue;
12339 - }
12340 -
12341 - assert(urb);
12342 - urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
12343 - assert(urb_priv);
12344 -
12345 - /* Sanity checks. */
12346 - assert(usb_pipetype(urb->pipe) == PIPE_BULK);
12347 - if (phys_to_virt(TxBulkEPList[epid].sub) != urb_priv->last_sb) {
12348 - err("bulk endpoint got disabled before reaching last sb");
12349 - }
12350 -
12351 - /* For bulk IN traffic, there seems to be a race condition between
12352 - between the bulk eot and eop interrupts, or rather an uncertainty regarding
12353 - the order in which they happen. Normally we expect the eop interrupt from
12354 - DMA channel 9 to happen before the eot interrupt.
12355 -
12356 - Therefore, we complete the bulk IN urb in the rx interrupt handler instead. */
12357 -
12358 - if (usb_pipein(urb->pipe)) {
12359 - dbg_bulk("in urb, continuing");
12360 - continue;
12361 - }
12362 -
12363 - save_flags(flags);
12364 - cli();
12365 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
12366 - nop();
12367 - r_usb_ept_data = *R_USB_EPT_DATA;
12368 - restore_flags(flags);
12369 -
12370 - if (IO_EXTRACT(R_USB_EPT_DATA, error_code, r_usb_ept_data) ==
12371 - IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
12372 - /* This means that the endpoint has no error, is disabled
12373 - and had inserted traffic, i.e. transfer successfully completed. */
12374 - etrax_usb_complete_bulk_urb(urb, 0);
12375 - } else {
12376 - /* Shouldn't happen. We expect errors to be caught by epid attention. */
12377 - err("Found disabled bulk EP desc, error_code != no_error");
12378 - }
12379 - }
12380 - }
12381 -
12382 - /* Normally, we should find (at least) one disabled EP descriptor with a valid sub pointer.
12383 - However, because of the uncertainty in the deliverance of the eop/eot interrupts, we may
12384 - not. Also, we might find two disabled EPs when handling an eot interrupt, and then find
12385 - none the next time. */
12386 -
12387 - DBFEXIT;
12388 -
12389 -}
12390 -
12391 -void etrax_usb_hc_epid_attn_interrupt(usb_interrupt_registers_t *reg)
12392 -{
12393 - /* This function handles the epid attention interrupt. There are a variety of reasons
12394 - for this interrupt to happen (Designer's Reference, p. 8 - 22 for the details):
12395 -
12396 - invalid ep_id - Invalid epid in an EP (EP disabled).
12397 - stall - Not strictly an error condition (EP disabled).
12398 - 3rd error - Three successive transaction errors (EP disabled).
12399 - buffer ourun - Buffer overrun or underrun (EP disabled).
12400 - past eof1 - Intr or isoc transaction proceeds past EOF1.
12401 - near eof - Intr or isoc transaction would not fit inside the frame.
12402 - zout transfer - If zout transfer for a bulk endpoint (EP disabled).
12403 - setup transfer - If setup transfer for a non-ctrl endpoint (EP disabled). */
12404 -
12405 - int epid;
12406 -
12407 -
12408 - DBFENTER;
12409 -
12410 - assert(reg != NULL);
12411 -
12412 - /* Note that we loop through all epids. We still want to catch errors for
12413 - the invalid one, even though we might handle them differently. */
12414 - for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
12415 -
12416 - if (test_bit(epid, (void *)&reg->r_usb_epid_attn)) {
12417 -
12418 - struct urb *urb;
12419 - __u32 r_usb_ept_data;
12420 - unsigned long flags;
12421 - int error_code;
12422 -
12423 - save_flags(flags);
12424 - cli();
12425 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
12426 - nop();
12427 - /* Note that although there are separate R_USB_EPT_DATA and R_USB_EPT_DATA_ISO
12428 - registers, they are located at the same address and are of the same size.
12429 - In other words, this read should be ok for isoc also. */
12430 - r_usb_ept_data = *R_USB_EPT_DATA;
12431 - restore_flags(flags);
12432 -
12433 - /* First some sanity checks. */
12434 - if (epid == INVALID_EPID) {
12435 - /* FIXME: What if it became disabled? Could seriously hurt interrupt
12436 - traffic. (Use do_intr_recover.) */
12437 - warn("Got epid_attn for INVALID_EPID (%d).", epid);
12438 - err("R_USB_EPT_DATA = 0x%x", r_usb_ept_data);
12439 - err("R_USB_STATUS = 0x%x", reg->r_usb_status);
12440 - continue;
12441 - } else if (epid == DUMMY_EPID) {
12442 - /* We definitely don't care about these ones. Besides, they are
12443 - always disabled, so any possible disabling caused by the
12444 - epid attention interrupt is irrelevant. */
12445 - warn("Got epid_attn for DUMMY_EPID (%d).", epid);
12446 - continue;
12447 - }
12448 -
12449 - /* Get the first urb in the urb list for this epid. We blatantly assume
12450 - that only the first urb could have caused the epid attention.
12451 - (For bulk and ctrl, only one urb is active at any one time. For intr
12452 - and isoc we remove them once they are completed.) */
12453 - urb = urb_list_first(epid);
12454 -
12455 - if (urb == NULL) {
12456 - err("Got epid_attn for epid %i with no urb.", epid);
12457 - err("R_USB_EPT_DATA = 0x%x", r_usb_ept_data);
12458 - err("R_USB_STATUS = 0x%x", reg->r_usb_status);
12459 - continue;
12460 - }
12461 -
12462 - switch (usb_pipetype(urb->pipe)) {
12463 - case PIPE_BULK:
12464 - warn("Got epid attn for bulk endpoint, epid %d", epid);
12465 - break;
12466 - case PIPE_CONTROL:
12467 - warn("Got epid attn for control endpoint, epid %d", epid);
12468 - break;
12469 - case PIPE_INTERRUPT:
12470 - warn("Got epid attn for interrupt endpoint, epid %d", epid);
12471 - break;
12472 - case PIPE_ISOCHRONOUS:
12473 - warn("Got epid attn for isochronous endpoint, epid %d", epid);
12474 - break;
12475 - }
12476 -
12477 - if (usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) {
12478 - if (r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, hold)) {
12479 - warn("Hold was set for epid %d.", epid);
12480 - continue;
12481 - }
12482 - }
12483 -
12484 - /* Even though error_code occupies bits 22 - 23 in both R_USB_EPT_DATA and
12485 - R_USB_EPT_DATA_ISOC, we separate them here so we don't forget in other places. */
12486 - if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
12487 - error_code = IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data);
12488 - } else {
12489 - error_code = IO_EXTRACT(R_USB_EPT_DATA, error_code, r_usb_ept_data);
12490 - }
12491 -
12492 - /* Using IO_STATE_VALUE on R_USB_EPT_DATA should be ok for isoc also. */
12493 - if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
12494 -
12495 - /* Isoc traffic doesn't have error_count_in/error_count_out. */
12496 - if ((usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) &&
12497 - (IO_EXTRACT(R_USB_EPT_DATA, error_count_in, r_usb_ept_data) == 3 ||
12498 - IO_EXTRACT(R_USB_EPT_DATA, error_count_out, r_usb_ept_data) == 3)) {
12499 - /* 3rd error. */
12500 - warn("3rd error for epid %i", epid);
12501 - etrax_usb_complete_urb(urb, -EPROTO);
12502 -
12503 - } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
12504 -
12505 - warn("Perror for epid %d", epid);
12506 -
12507 - if (!(r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, valid))) {
12508 - /* invalid ep_id */
12509 - panic("Perror because of invalid epid."
12510 - " Deconfigured too early?");
12511 - } else {
12512 - /* past eof1, near eof, zout transfer, setup transfer */
12513 -
12514 - /* Dump the urb and the relevant EP descriptor list. */
12515 -
12516 - __dump_urb(urb);
12517 - __dump_ept_data(epid);
12518 - __dump_ep_list(usb_pipetype(urb->pipe));
12519 -
12520 - panic("Something wrong with DMA descriptor contents."
12521 - " Too much traffic inserted?");
12522 - }
12523 - } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
12524 - /* buffer ourun */
12525 - panic("Buffer overrun/underrun for epid %d. DMA too busy?", epid);
12526 - }
12527 -
12528 - } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, stall)) {
12529 - /* Not really a protocol error, just says that the endpoint gave
12530 - a stall response. Note that error_code cannot be stall for isoc. */
12531 - if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
12532 - panic("Isoc traffic cannot stall");
12533 - }
12534 -
12535 - warn("Stall for epid %d", epid);
12536 - etrax_usb_complete_urb(urb, -EPIPE);
12537 -
12538 - } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, bus_error)) {
12539 - /* Two devices responded to a transaction request. Must be resolved
12540 - by software. FIXME: Reset ports? */
12541 - panic("Bus error for epid %d."
12542 - " Two devices responded to transaction request",
12543 - epid);
12544 -
12545 - } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, buffer_error)) {
12546 - /* DMA overrun or underrun. */
12547 - warn("Buffer overrun/underrun for epid %d. DMA too busy?", epid);
12548 -
12549 - /* It seems that error_code = buffer_error in
12550 - R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
12551 - are the same error. */
12552 - etrax_usb_complete_urb(urb, -EPROTO);
12553 - }
12554 - }
12555 - }
12556 -
12557 - DBFEXIT;
12558 -
12559 -}
12560 -
12561 -void etrax_usb_bulk_start_timer_func(unsigned long dummy)
12562 -{
12563 -
12564 - /* We might enable an EP descriptor behind the current DMA position when it's about
12565 - to decide that there are no more bulk traffic and it should stop the bulk channel.
12566 - Therefore we periodically check if the bulk channel is stopped and there is an
12567 - enabled bulk EP descriptor, in which case we start the bulk channel. */
12568 - dbg_bulk("bulk_start_timer timed out.");
12569 -
12570 - if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
12571 - int epid;
12572 -
12573 - dbg_bulk("Bulk DMA channel not running.");
12574 -
12575 - for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
12576 - if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
12577 - dbg_bulk("Found enabled EP for epid %d, starting bulk channel.\n",
12578 - epid);
12579 - *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
12580 -
12581 - /* Restart the bulk eot timer since we just started the bulk channel. */
12582 - mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
12583 -
12584 - /* No need to search any further. */
12585 - break;
12586 - }
12587 - }
12588 - } else {
12589 - dbg_bulk("Bulk DMA channel running.");
12590 - }
12591 -}
12592 -
12593 -void etrax_usb_hc_port_status_interrupt(usb_interrupt_registers_t *reg)
12594 -{
12595 - etrax_hc_t *hc = reg->hc;
12596 - __u16 r_usb_rh_port_status_1 = reg->r_usb_rh_port_status_1;
12597 - __u16 r_usb_rh_port_status_2 = reg->r_usb_rh_port_status_2;
12598 -
12599 - DBFENTER;
12600 -
12601 - /* The Etrax RH does not include a wPortChange register, so this has to be handled in software
12602 - (by saving the old port status value for comparison when the port status interrupt happens).
12603 - See section 11.16.2.6.2 in the USB 1.1 spec for details. */
12604 -
12605 - dbg_rh("hc->rh.prev_wPortStatus_1 = 0x%x", hc->rh.prev_wPortStatus_1);
12606 - dbg_rh("hc->rh.prev_wPortStatus_2 = 0x%x", hc->rh.prev_wPortStatus_2);
12607 - dbg_rh("r_usb_rh_port_status_1 = 0x%x", r_usb_rh_port_status_1);
12608 - dbg_rh("r_usb_rh_port_status_2 = 0x%x", r_usb_rh_port_status_2);
12609 -
12610 - /* C_PORT_CONNECTION is set on any transition. */
12611 - hc->rh.wPortChange_1 |=
12612 - ((r_usb_rh_port_status_1 & (1 << RH_PORT_CONNECTION)) !=
12613 - (hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_CONNECTION))) ?
12614 - (1 << RH_PORT_CONNECTION) : 0;
12615 -
12616 - hc->rh.wPortChange_2 |=
12617 - ((r_usb_rh_port_status_2 & (1 << RH_PORT_CONNECTION)) !=
12618 - (hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_CONNECTION))) ?
12619 - (1 << RH_PORT_CONNECTION) : 0;
12620 -
12621 - /* C_PORT_ENABLE is _only_ set on a one to zero transition, i.e. when
12622 - the port is disabled, not when it's enabled. */
12623 - hc->rh.wPortChange_1 |=
12624 - ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_ENABLE))
12625 - && !(r_usb_rh_port_status_1 & (1 << RH_PORT_ENABLE))) ?
12626 - (1 << RH_PORT_ENABLE) : 0;
12627 -
12628 - hc->rh.wPortChange_2 |=
12629 - ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_ENABLE))
12630 - && !(r_usb_rh_port_status_2 & (1 << RH_PORT_ENABLE))) ?
12631 - (1 << RH_PORT_ENABLE) : 0;
12632 -
12633 - /* C_PORT_SUSPEND is set to one when the device has transitioned out
12634 - of the suspended state, i.e. when suspend goes from one to zero. */
12635 - hc->rh.wPortChange_1 |=
12636 - ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_SUSPEND))
12637 - && !(r_usb_rh_port_status_1 & (1 << RH_PORT_SUSPEND))) ?
12638 - (1 << RH_PORT_SUSPEND) : 0;
12639 -
12640 - hc->rh.wPortChange_2 |=
12641 - ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_SUSPEND))
12642 - && !(r_usb_rh_port_status_2 & (1 << RH_PORT_SUSPEND))) ?
12643 - (1 << RH_PORT_SUSPEND) : 0;
12644 -
12645 -
12646 - /* C_PORT_RESET is set when reset processing on this port is complete. */
12647 - hc->rh.wPortChange_1 |=
12648 - ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_RESET))
12649 - && !(r_usb_rh_port_status_1 & (1 << RH_PORT_RESET))) ?
12650 - (1 << RH_PORT_RESET) : 0;
12651 -
12652 - hc->rh.wPortChange_2 |=
12653 - ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_RESET))
12654 - && !(r_usb_rh_port_status_2 & (1 << RH_PORT_RESET))) ?
12655 - (1 << RH_PORT_RESET) : 0;
12656 -
12657 - /* Save the new values for next port status change. */
12658 - hc->rh.prev_wPortStatus_1 = r_usb_rh_port_status_1;
12659 - hc->rh.prev_wPortStatus_2 = r_usb_rh_port_status_2;
12660 -
12661 - dbg_rh("hc->rh.wPortChange_1 set to 0x%x", hc->rh.wPortChange_1);
12662 - dbg_rh("hc->rh.wPortChange_2 set to 0x%x", hc->rh.wPortChange_2);
12663 -
12664 - DBFEXIT;
12665 -
12666 -}
12667 -
12668 -void etrax_usb_hc_ctl_status_interrupt(usb_interrupt_registers_t *reg)
12669 -{
12670 - DBFENTER;
12671 -
12672 - /* FIXME: What should we do if we get ourun or perror? Dump the EP and SB
12673 - list for the corresponding epid? */
12674 - if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
12675 - panic("USB controller got ourun.");
12676 - }
12677 - if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
12678 -
12679 - /* Before, etrax_usb_do_intr_recover was called on this epid if it was
12680 - an interrupt pipe. I don't see how re-enabling all EP descriptors
12681 - will help if there was a programming error. */
12682 - panic("USB controller got perror.");
12683 - }
12684 -
12685 - if (reg->r_usb_status & IO_MASK(R_USB_STATUS, device_mode)) {
12686 - /* We should never operate in device mode. */
12687 - panic("USB controller in device mode.");
12688 - }
12689 -
12690 - /* These if-statements could probably be nested. */
12691 - if (reg->r_usb_status & IO_MASK(R_USB_STATUS, host_mode)) {
12692 - info("USB controller in host mode.");
12693 - }
12694 - if (reg->r_usb_status & IO_MASK(R_USB_STATUS, started)) {
12695 - info("USB controller started.");
12696 - }
12697 - if (reg->r_usb_status & IO_MASK(R_USB_STATUS, running)) {
12698 - info("USB controller running.");
12699 - }
12700 -
12701 - DBFEXIT;
12702 -
12703 -}
12704 -
12705 -
12706 -static int etrax_rh_submit_urb(struct urb *urb)
12707 -{
12708 - struct usb_device *usb_dev = urb->dev;
12709 - etrax_hc_t *hc = usb_dev->bus->hcpriv;
12710 - unsigned int pipe = urb->pipe;
12711 - struct usb_ctrlrequest *cmd = (struct usb_ctrlrequest *) urb->setup_packet;
12712 - void *data = urb->transfer_buffer;
12713 - int leni = urb->transfer_buffer_length;
12714 - int len = 0;
12715 - int stat = 0;
12716 -
12717 - __u16 bmRType_bReq;
12718 - __u16 wValue;
12719 - __u16 wIndex;
12720 - __u16 wLength;
12721 -
12722 - DBFENTER;
12723 -
12724 - /* FIXME: What is this interrupt urb that is sent to the root hub? */
12725 - if (usb_pipetype (pipe) == PIPE_INTERRUPT) {
12726 - dbg_rh("Root-Hub submit IRQ: every %d ms", urb->interval);
12727 - hc->rh.urb = urb;
12728 - hc->rh.send = 1;
12729 - /* FIXME: We could probably remove this line since it's done
12730 - in etrax_rh_init_int_timer. (Don't remove it from
12731 - etrax_rh_init_int_timer though.) */
12732 - hc->rh.interval = urb->interval;
12733 - etrax_rh_init_int_timer(urb);
12734 - DBFEXIT;
12735 -
12736 - return 0;
12737 - }
12738 -
12739 - bmRType_bReq = cmd->bRequestType | (cmd->bRequest << 8);
12740 - wValue = le16_to_cpu(cmd->wValue);
12741 - wIndex = le16_to_cpu(cmd->wIndex);
12742 - wLength = le16_to_cpu(cmd->wLength);
12743 -
12744 - dbg_rh("bmRType_bReq : 0x%04x (%d)", bmRType_bReq, bmRType_bReq);
12745 - dbg_rh("wValue : 0x%04x (%d)", wValue, wValue);
12746 - dbg_rh("wIndex : 0x%04x (%d)", wIndex, wIndex);
12747 - dbg_rh("wLength : 0x%04x (%d)", wLength, wLength);
12748 -
12749 - switch (bmRType_bReq) {
12750 -
12751 - /* Request Destination:
12752 - without flags: Device,
12753 - RH_INTERFACE: interface,
12754 - RH_ENDPOINT: endpoint,
12755 - RH_CLASS means HUB here,
12756 - RH_OTHER | RH_CLASS almost ever means HUB_PORT here
12757 - */
12758 -
12759 - case RH_GET_STATUS:
12760 - *(__u16 *) data = cpu_to_le16 (1);
12761 - OK (2);
12762 -
12763 - case RH_GET_STATUS | RH_INTERFACE:
12764 - *(__u16 *) data = cpu_to_le16 (0);
12765 - OK (2);
12766 -
12767 - case RH_GET_STATUS | RH_ENDPOINT:
12768 - *(__u16 *) data = cpu_to_le16 (0);
12769 - OK (2);
12770 -
12771 - case RH_GET_STATUS | RH_CLASS:
12772 - *(__u32 *) data = cpu_to_le32 (0);
12773 - OK (4); /* hub power ** */
12774 -
12775 - case RH_GET_STATUS | RH_OTHER | RH_CLASS:
12776 - if (wIndex == 1) {
12777 - *((__u16*)data) = cpu_to_le16(hc->rh.prev_wPortStatus_1);
12778 - *((__u16*)data + 1) = cpu_to_le16(hc->rh.wPortChange_1);
12779 - } else if (wIndex == 2) {
12780 - *((__u16*)data) = cpu_to_le16(hc->rh.prev_wPortStatus_2);
12781 - *((__u16*)data + 1) = cpu_to_le16(hc->rh.wPortChange_2);
12782 - } else {
12783 - dbg_rh("RH_GET_STATUS whith invalid wIndex!");
12784 - OK(0);
12785 - }
12786 -
12787 - OK(4);
12788 -
12789 - case RH_CLEAR_FEATURE | RH_ENDPOINT:
12790 - switch (wValue) {
12791 - case (RH_ENDPOINT_STALL):
12792 - OK (0);
12793 - }
12794 - break;
12795 -
12796 - case RH_CLEAR_FEATURE | RH_CLASS:
12797 - switch (wValue) {
12798 - case (RH_C_HUB_OVER_CURRENT):
12799 - OK (0); /* hub power over current ** */
12800 - }
12801 - break;
12802 -
12803 - case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
12804 - switch (wValue) {
12805 - case (RH_PORT_ENABLE):
12806 - if (wIndex == 1) {
12807 -
12808 - dbg_rh("trying to do disable port 1");
12809 -
12810 - *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
12811 -
12812 - while (hc->rh.prev_wPortStatus_1 &
12813 - IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes));
12814 - *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
12815 - dbg_rh("Port 1 is disabled");
12816 -
12817 - } else if (wIndex == 2) {
12818 -
12819 - dbg_rh("trying to do disable port 2");
12820 -
12821 - *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
12822 -
12823 - while (hc->rh.prev_wPortStatus_2 &
12824 - IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes));
12825 - *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
12826 - dbg_rh("Port 2 is disabled");
12827 -
12828 - } else {
12829 - dbg_rh("RH_CLEAR_FEATURE->RH_PORT_ENABLE "
12830 - "with invalid wIndex == %d!", wIndex);
12831 - }
12832 -
12833 - OK (0);
12834 - case (RH_PORT_SUSPEND):
12835 - /* Opposite to suspend should be resume, so we'll do a resume. */
12836 - /* FIXME: USB 1.1, 11.16.2.2 says:
12837 - "Clearing the PORT_SUSPEND feature causes a host-initiated resume
12838 - on the specified port. If the port is not in the Suspended state,
12839 - the hub should treat this request as a functional no-operation."
12840 - Shouldn't we check if the port is in a suspended state before
12841 - resuming? */
12842 -
12843 - /* Make sure the controller isn't busy. */
12844 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
12845 -
12846 - if (wIndex == 1) {
12847 - *R_USB_COMMAND =
12848 - IO_STATE(R_USB_COMMAND, port_sel, port1) |
12849 - IO_STATE(R_USB_COMMAND, port_cmd, resume) |
12850 - IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
12851 - } else if (wIndex == 2) {
12852 - *R_USB_COMMAND =
12853 - IO_STATE(R_USB_COMMAND, port_sel, port2) |
12854 - IO_STATE(R_USB_COMMAND, port_cmd, resume) |
12855 - IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
12856 - } else {
12857 - dbg_rh("RH_CLEAR_FEATURE->RH_PORT_SUSPEND "
12858 - "with invalid wIndex == %d!", wIndex);
12859 - }
12860 -
12861 - OK (0);
12862 - case (RH_PORT_POWER):
12863 - OK (0); /* port power ** */
12864 - case (RH_C_PORT_CONNECTION):
12865 - if (wIndex == 1) {
12866 - hc->rh.wPortChange_1 &= ~(1 << RH_PORT_CONNECTION);
12867 - } else if (wIndex == 2) {
12868 - hc->rh.wPortChange_2 &= ~(1 << RH_PORT_CONNECTION);
12869 - } else {
12870 - dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_CONNECTION "
12871 - "with invalid wIndex == %d!", wIndex);
12872 - }
12873 -
12874 - OK (0);
12875 - case (RH_C_PORT_ENABLE):
12876 - if (wIndex == 1) {
12877 - hc->rh.wPortChange_1 &= ~(1 << RH_PORT_ENABLE);
12878 - } else if (wIndex == 2) {
12879 - hc->rh.wPortChange_2 &= ~(1 << RH_PORT_ENABLE);
12880 - } else {
12881 - dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_ENABLE "
12882 - "with invalid wIndex == %d!", wIndex);
12883 - }
12884 - OK (0);
12885 - case (RH_C_PORT_SUSPEND):
12886 -/*** WR_RH_PORTSTAT(RH_PS_PSSC); */
12887 - OK (0);
12888 - case (RH_C_PORT_OVER_CURRENT):
12889 - OK (0); /* port power over current ** */
12890 - case (RH_C_PORT_RESET):
12891 - if (wIndex == 1) {
12892 - hc->rh.wPortChange_1 &= ~(1 << RH_PORT_RESET);
12893 - } else if (wIndex == 2) {
12894 - hc->rh.wPortChange_2 &= ~(1 << RH_PORT_RESET);
12895 - } else {
12896 - dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_RESET "
12897 - "with invalid index == %d!", wIndex);
12898 - }
12899 -
12900 - OK (0);
12901 -
12902 - }
12903 - break;
12904 -
12905 - case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
12906 - switch (wValue) {
12907 - case (RH_PORT_SUSPEND):
12908 -
12909 - /* Make sure the controller isn't busy. */
12910 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
12911 -
12912 - if (wIndex == 1) {
12913 - *R_USB_COMMAND =
12914 - IO_STATE(R_USB_COMMAND, port_sel, port1) |
12915 - IO_STATE(R_USB_COMMAND, port_cmd, suspend) |
12916 - IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
12917 - } else if (wIndex == 2) {
12918 - *R_USB_COMMAND =
12919 - IO_STATE(R_USB_COMMAND, port_sel, port2) |
12920 - IO_STATE(R_USB_COMMAND, port_cmd, suspend) |
12921 - IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
12922 - } else {
12923 - dbg_rh("RH_SET_FEATURE->RH_PORT_SUSPEND "
12924 - "with invalid wIndex == %d!", wIndex);
12925 - }
12926 -
12927 - OK (0);
12928 - case (RH_PORT_RESET):
12929 - if (wIndex == 1) {
12930 -
12931 - port_1_reset:
12932 - dbg_rh("Doing reset of port 1");
12933 -
12934 - /* Make sure the controller isn't busy. */
12935 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
12936 -
12937 - *R_USB_COMMAND =
12938 - IO_STATE(R_USB_COMMAND, port_sel, port1) |
12939 - IO_STATE(R_USB_COMMAND, port_cmd, reset) |
12940 - IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
12941 -
12942 - /* We must wait at least 10 ms for the device to recover.
12943 - 15 ms should be enough. */
12944 - udelay(15000);
12945 -
12946 - /* Wait for reset bit to go low (should be done by now). */
12947 - while (hc->rh.prev_wPortStatus_1 &
12948 - IO_STATE(R_USB_RH_PORT_STATUS_1, reset, yes));
12949 -
12950 - /* If the port status is
12951 - 1) connected and enabled then there is a device and everything is fine
12952 - 2) neither connected nor enabled then there is no device, also fine
12953 - 3) connected and not enabled then we try again
12954 - (Yes, there are other port status combinations besides these.) */
12955 -
12956 - if ((hc->rh.prev_wPortStatus_1 &
12957 - IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) &&
12958 - (hc->rh.prev_wPortStatus_1 &
12959 - IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, no))) {
12960 - dbg_rh("Connected device on port 1, but port not enabled?"
12961 - " Trying reset again.");
12962 - goto port_2_reset;
12963 - }
12964 -
12965 - /* Diagnostic printouts. */
12966 - if ((hc->rh.prev_wPortStatus_1 &
12967 - IO_STATE(R_USB_RH_PORT_STATUS_1, connected, no)) &&
12968 - (hc->rh.prev_wPortStatus_1 &
12969 - IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, no))) {
12970 - dbg_rh("No connected device on port 1");
12971 - } else if ((hc->rh.prev_wPortStatus_1 &
12972 - IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) &&
12973 - (hc->rh.prev_wPortStatus_1 &
12974 - IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes))) {
12975 - dbg_rh("Connected device on port 1, port 1 enabled");
12976 - }
12977 -
12978 - } else if (wIndex == 2) {
12979 -
12980 - port_2_reset:
12981 - dbg_rh("Doing reset of port 2");
12982 -
12983 - /* Make sure the controller isn't busy. */
12984 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
12985 -
12986 - /* Issue the reset command. */
12987 - *R_USB_COMMAND =
12988 - IO_STATE(R_USB_COMMAND, port_sel, port2) |
12989 - IO_STATE(R_USB_COMMAND, port_cmd, reset) |
12990 - IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
12991 -
12992 - /* We must wait at least 10 ms for the device to recover.
12993 - 15 ms should be enough. */
12994 - udelay(15000);
12995 -
12996 - /* Wait for reset bit to go low (should be done by now). */
12997 - while (hc->rh.prev_wPortStatus_2 &
12998 - IO_STATE(R_USB_RH_PORT_STATUS_2, reset, yes));
12999 -
13000 - /* If the port status is
13001 - 1) connected and enabled then there is a device and everything is fine
13002 - 2) neither connected nor enabled then there is no device, also fine
13003 - 3) connected and not enabled then we try again
13004 - (Yes, there are other port status combinations besides these.) */
13005 -
13006 - if ((hc->rh.prev_wPortStatus_2 &
13007 - IO_STATE(R_USB_RH_PORT_STATUS_2, connected, yes)) &&
13008 - (hc->rh.prev_wPortStatus_2 &
13009 - IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, no))) {
13010 - dbg_rh("Connected device on port 2, but port not enabled?"
13011 - " Trying reset again.");
13012 - goto port_2_reset;
13013 - }
13014 -
13015 - /* Diagnostic printouts. */
13016 - if ((hc->rh.prev_wPortStatus_2 &
13017 - IO_STATE(R_USB_RH_PORT_STATUS_2, connected, no)) &&
13018 - (hc->rh.prev_wPortStatus_2 &
13019 - IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, no))) {
13020 - dbg_rh("No connected device on port 2");
13021 - } else if ((hc->rh.prev_wPortStatus_2 &
13022 - IO_STATE(R_USB_RH_PORT_STATUS_2, connected, yes)) &&
13023 - (hc->rh.prev_wPortStatus_2 &
13024 - IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes))) {
13025 - dbg_rh("Connected device on port 2, port 2 enabled");
13026 - }
13027 -
13028 - } else {
13029 - dbg_rh("RH_SET_FEATURE->RH_PORT_RESET with invalid wIndex = %d", wIndex);
13030 - }
13031 -
13032 - /* Make sure the controller isn't busy. */
13033 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
13034 -
13035 - /* If all enabled ports were disabled the host controller goes down into
13036 - started mode, so we need to bring it back into the running state.
13037 - (This is safe even if it's already in the running state.) */
13038 - *R_USB_COMMAND =
13039 - IO_STATE(R_USB_COMMAND, port_sel, nop) |
13040 - IO_STATE(R_USB_COMMAND, port_cmd, reset) |
13041 - IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
13042 -
13043 - dbg_rh("...Done");
13044 - OK(0);
13045 -
13046 - case (RH_PORT_POWER):
13047 - OK (0); /* port power ** */
13048 - case (RH_PORT_ENABLE):
13049 - /* There is no port enable command in the host controller, so if the
13050 - port is already enabled, we do nothing. If not, we reset the port
13051 - (with an ugly goto). */
13052 -
13053 - if (wIndex == 1) {
13054 - if (hc->rh.prev_wPortStatus_1 &
13055 - IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, no)) {
13056 - goto port_1_reset;
13057 - }
13058 - } else if (wIndex == 2) {
13059 - if (hc->rh.prev_wPortStatus_2 &
13060 - IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, no)) {
13061 - goto port_2_reset;
13062 - }
13063 - } else {
13064 - dbg_rh("RH_SET_FEATURE->RH_GET_STATUS with invalid wIndex = %d", wIndex);
13065 - }
13066 - OK (0);
13067 - }
13068 - break;
13069 -
13070 - case RH_SET_ADDRESS:
13071 - hc->rh.devnum = wValue;
13072 - dbg_rh("RH address set to: %d", hc->rh.devnum);
13073 - OK (0);
13074 -
13075 - case RH_GET_DESCRIPTOR:
13076 - switch ((wValue & 0xff00) >> 8) {
13077 - case (0x01): /* device descriptor */
13078 - len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_dev_des), wLength));
13079 - memcpy (data, root_hub_dev_des, len);
13080 - OK (len);
13081 - case (0x02): /* configuration descriptor */
13082 - len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_config_des), wLength));
13083 - memcpy (data, root_hub_config_des, len);
13084 - OK (len);
13085 - case (0x03): /* string descriptors */
13086 - len = usb_root_hub_string (wValue & 0xff,
13087 - 0xff, "ETRAX 100LX",
13088 - data, wLength);
13089 - if (len > 0) {
13090 - OK(min(leni, len));
13091 - } else {
13092 - stat = -EPIPE;
13093 - }
13094 -
13095 - }
13096 - break;
13097 -
13098 - case RH_GET_DESCRIPTOR | RH_CLASS:
13099 - root_hub_hub_des[2] = hc->rh.numports;
13100 - len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_hub_des), wLength));
13101 - memcpy (data, root_hub_hub_des, len);
13102 - OK (len);
13103 -
13104 - case RH_GET_CONFIGURATION:
13105 - *(__u8 *) data = 0x01;
13106 - OK (1);
13107 -
13108 - case RH_SET_CONFIGURATION:
13109 - OK (0);
13110 -
13111 - default:
13112 - stat = -EPIPE;
13113 - }
13114 -
13115 - urb->actual_length = len;
13116 - urb->status = stat;
13117 - urb->dev = NULL;
13118 - if (urb->complete) {
13119 - urb->complete(urb, NULL);
13120 - }
13121 - DBFEXIT;
13122 -
13123 - return 0;
13124 -}
13125 -
13126 -static void
13127 -etrax_usb_bulk_eot_timer_func(unsigned long dummy)
13128 -{
13129 - /* Because of a race condition in the top half, we might miss a bulk eot.
13130 - This timer "simulates" a bulk eot if we don't get one for a while, hopefully
13131 - correcting the situation. */
13132 - dbg_bulk("bulk_eot_timer timed out.");
13133 - etrax_usb_hc_bulk_eot_interrupt(1);
13134 -}
13135 -
13136 -static void*
13137 -etrax_usb_buffer_alloc(struct usb_bus* bus, size_t size,
13138 - unsigned mem_flags, dma_addr_t *dma)
13139 -{
13140 - return kmalloc(size, mem_flags);
13141 -}
13142 -
13143 -static void
13144 -etrax_usb_buffer_free(struct usb_bus *bus, size_t size, void *addr, dma_addr_t dma)
13145 -{
13146 - kfree(addr);
13147 -}
13148 -
13149 -
13150 -static struct device fake_device;
13151 -
13152 -static int __init etrax_usb_hc_init(void)
13153 -{
13154 - static etrax_hc_t *hc;
13155 - struct usb_bus *bus;
13156 - struct usb_device *usb_rh;
13157 - int i;
13158 -
13159 - DBFENTER;
13160 -
13161 - info("ETRAX 100LX USB-HCD %s (c) 2001-2003 Axis Communications AB\n", usb_hcd_version);
13162 -
13163 - hc = kmalloc(sizeof(etrax_hc_t), GFP_KERNEL);
13164 - assert(hc != NULL);
13165 -
13166 - /* We use kmem_cache_* to make sure that all DMA desc. are dword aligned */
13167 - /* Note that we specify sizeof(USB_EP_Desc_t) as the size, but also allocate
13168 - SB descriptors from this cache. This is ok since sizeof(USB_EP_Desc_t) ==
13169 - sizeof(USB_SB_Desc_t). */
13170 -
13171 - usb_desc_cache = kmem_cache_create("usb_desc_cache", sizeof(USB_EP_Desc_t), 0,
13172 - SLAB_HWCACHE_ALIGN, 0, 0);
13173 - assert(usb_desc_cache != NULL);
13174 -
13175 - top_half_reg_cache = kmem_cache_create("top_half_reg_cache",
13176 - sizeof(usb_interrupt_registers_t),
13177 - 0, SLAB_HWCACHE_ALIGN, 0, 0);
13178 - assert(top_half_reg_cache != NULL);
13179 -
13180 - isoc_compl_cache = kmem_cache_create("isoc_compl_cache",
13181 - sizeof(usb_isoc_complete_data_t),
13182 - 0, SLAB_HWCACHE_ALIGN, 0, 0);
13183 - assert(isoc_compl_cache != NULL);
13184 -
13185 - etrax_usb_bus = bus = usb_alloc_bus(&etrax_usb_device_operations);
13186 - hc->bus = bus;
13187 - bus->bus_name="ETRAX 100LX";
13188 - bus->hcpriv = hc;
13189 -
13190 - /* Initialize RH to the default address.
13191 - And make sure that we have no status change indication */
13192 - hc->rh.numports = 2; /* The RH has two ports */
13193 - hc->rh.devnum = 1;
13194 - hc->rh.wPortChange_1 = 0;
13195 - hc->rh.wPortChange_2 = 0;
13196 -
13197 - /* Also initate the previous values to zero */
13198 - hc->rh.prev_wPortStatus_1 = 0;
13199 - hc->rh.prev_wPortStatus_2 = 0;
13200 -
13201 - /* Initialize the intr-traffic flags */
13202 - /* FIXME: This isn't used. (Besides, the error field isn't initialized.) */
13203 - hc->intr.sleeping = 0;
13204 - hc->intr.wq = NULL;
13205 -
13206 - epid_usage_bitmask = 0;
13207 - epid_out_traffic = 0;
13208 -
13209 - /* Mark the invalid epid as being used. */
13210 - set_bit(INVALID_EPID, (void *)&epid_usage_bitmask);
13211 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, INVALID_EPID);
13212 - nop();
13213 - /* The valid bit should still be set ('invalid' is in our world; not the hardware's). */
13214 - *R_USB_EPT_DATA = (IO_STATE(R_USB_EPT_DATA, valid, yes) |
13215 - IO_FIELD(R_USB_EPT_DATA, max_len, 1));
13216 -
13217 - /* Mark the dummy epid as being used. */
13218 - set_bit(DUMMY_EPID, (void *)&epid_usage_bitmask);
13219 - *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, DUMMY_EPID);
13220 - nop();
13221 - *R_USB_EPT_DATA = (IO_STATE(R_USB_EPT_DATA, valid, no) |
13222 - IO_FIELD(R_USB_EPT_DATA, max_len, 1));
13223 -
13224 - /* Initialize the urb list by initiating a head for each list. */
13225 - for (i = 0; i < NBR_OF_EPIDS; i++) {
13226 - INIT_LIST_HEAD(&urb_list[i]);
13227 - }
13228 - spin_lock_init(&urb_list_lock);
13229 -
13230 - INIT_LIST_HEAD(&urb_unlink_list);
13231 -
13232 -
13233 - /* Initiate the bulk start timer. */
13234 - init_timer(&bulk_start_timer);
13235 - bulk_start_timer.expires = jiffies + BULK_START_TIMER_INTERVAL;
13236 - bulk_start_timer.function = etrax_usb_bulk_start_timer_func;
13237 - add_timer(&bulk_start_timer);
13238 -
13239 -
13240 - /* Initiate the bulk eot timer. */
13241 - init_timer(&bulk_eot_timer);
13242 - bulk_eot_timer.expires = jiffies + BULK_EOT_TIMER_INTERVAL;
13243 - bulk_eot_timer.function = etrax_usb_bulk_eot_timer_func;
13244 - add_timer(&bulk_eot_timer);
13245 -
13246 - /* Set up the data structures for USB traffic. Note that this must be done before
13247 - any interrupt that relies on sane DMA list occurrs. */
13248 - init_rx_buffers();
13249 - init_tx_bulk_ep();
13250 - init_tx_ctrl_ep();
13251 - init_tx_intr_ep();
13252 - init_tx_isoc_ep();
13253 -
13254 - device_initialize(&fake_device);
13255 - kobject_set_name(&fake_device.kobj, "etrax_usb");
13256 - kobject_add(&fake_device.kobj);
13257 - kobject_uevent(&fake_device.kobj, KOBJ_ADD);
13258 - hc->bus->controller = &fake_device;
13259 - usb_register_bus(hc->bus);
13260 -
13261 - *R_IRQ_MASK2_SET =
13262 - /* Note that these interrupts are not used. */
13263 - IO_STATE(R_IRQ_MASK2_SET, dma8_sub0_descr, set) |
13264 - /* Sub channel 1 (ctrl) descr. interrupts are used. */
13265 - IO_STATE(R_IRQ_MASK2_SET, dma8_sub1_descr, set) |
13266 - IO_STATE(R_IRQ_MASK2_SET, dma8_sub2_descr, set) |
13267 - /* Sub channel 3 (isoc) descr. interrupts are used. */
13268 - IO_STATE(R_IRQ_MASK2_SET, dma8_sub3_descr, set);
13269 -
13270 - /* Note that the dma9_descr interrupt is not used. */
13271 - *R_IRQ_MASK2_SET =
13272 - IO_STATE(R_IRQ_MASK2_SET, dma9_eop, set) |
13273 - IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set);
13274 -
13275 - /* FIXME: Enable iso_eof only when isoc traffic is running. */
13276 - *R_USB_IRQ_MASK_SET =
13277 - IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set) |
13278 - IO_STATE(R_USB_IRQ_MASK_SET, bulk_eot, set) |
13279 - IO_STATE(R_USB_IRQ_MASK_SET, epid_attn, set) |
13280 - IO_STATE(R_USB_IRQ_MASK_SET, port_status, set) |
13281 - IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
13282 -
13283 -
13284 - if (request_irq(ETRAX_USB_HC_IRQ, etrax_usb_hc_interrupt_top_half, 0,
13285 - "ETRAX 100LX built-in USB (HC)", hc)) {
13286 - err("Could not allocate IRQ %d for USB", ETRAX_USB_HC_IRQ);
13287 - etrax_usb_hc_cleanup();
13288 - DBFEXIT;
13289 - return -1;
13290 - }
13291 -
13292 - if (request_irq(ETRAX_USB_RX_IRQ, etrax_usb_rx_interrupt, 0,
13293 - "ETRAX 100LX built-in USB (Rx)", hc)) {
13294 - err("Could not allocate IRQ %d for USB", ETRAX_USB_RX_IRQ);
13295 - etrax_usb_hc_cleanup();
13296 - DBFEXIT;
13297 - return -1;
13298 - }
13299 -
13300 - if (request_irq(ETRAX_USB_TX_IRQ, etrax_usb_tx_interrupt, 0,
13301 - "ETRAX 100LX built-in USB (Tx)", hc)) {
13302 - err("Could not allocate IRQ %d for USB", ETRAX_USB_TX_IRQ);
13303 - etrax_usb_hc_cleanup();
13304 - DBFEXIT;
13305 - return -1;
13306 - }
13307 -
13308 - /* R_USB_COMMAND:
13309 - USB commands in host mode. The fields in this register should all be
13310 - written to in one write. Do not read-modify-write one field at a time. A
13311 - write to this register will trigger events in the USB controller and an
13312 - incomplete command may lead to unpredictable results, and in worst case
13313 - even to a deadlock in the controller.
13314 - (Note however that the busy field is read-only, so no need to write to it.) */
13315 -
13316 - /* Check the busy bit before writing to R_USB_COMMAND. */
13317 -
13318 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
13319 -
13320 - /* Reset the USB interface. */
13321 - *R_USB_COMMAND =
13322 - IO_STATE(R_USB_COMMAND, port_sel, nop) |
13323 - IO_STATE(R_USB_COMMAND, port_cmd, reset) |
13324 - IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
13325 -
13326 - /* Designer's Reference, p. 8 - 10 says we should Initate R_USB_FM_PSTART to 0x2A30 (10800),
13327 - to guarantee that control traffic gets 10% of the bandwidth, and periodic transfer may
13328 - allocate the rest (90%). This doesn't work though. Read on for a lenghty explanation.
13329 -
13330 - While there is a difference between rev. 2 and rev. 3 of the ETRAX 100LX regarding the NAK
13331 - behaviour, it doesn't solve this problem. What happens is that a control transfer will not
13332 - be interrupted in its data stage when PSTART happens (the point at which periodic traffic
13333 - is started). Thus, if PSTART is set to 10800 and its IN or OUT token is NAKed until just before
13334 - PSTART happens, it will continue the IN/OUT transfer as long as it's ACKed. After it's done,
13335 - there may be too little time left for an isochronous transfer, causing an epid attention
13336 - interrupt due to perror. The work-around for this is to let the control transfers run at the
13337 - end of the frame instead of at the beginning, and will be interrupted just fine if it doesn't
13338 - fit into the frame. However, since there will *always* be a control transfer at the beginning
13339 - of the frame, regardless of what we set PSTART to, that transfer might be a 64-byte transfer
13340 - which consumes up to 15% of the frame, leaving only 85% for periodic traffic. The solution to
13341 - this would be to 'dummy allocate' 5% of the frame with the usb_claim_bandwidth function to make
13342 - sure that the periodic transfers that are inserted will always fit in the frame.
13343 -
13344 - The idea was suggested that a control transfer could be split up into several 8 byte transfers,
13345 - so that it would be interrupted by PSTART, but since this can't be done for an IN transfer this
13346 - hasn't been implemented.
13347 -
13348 - The value 11960 is chosen to be just after the SOF token, with a couple of bit times extra
13349 - for possible bit stuffing. */
13350 -
13351 - *R_USB_FM_PSTART = IO_FIELD(R_USB_FM_PSTART, value, 11960);
13352 -
13353 -#ifdef CONFIG_ETRAX_USB_HOST_PORT1
13354 - *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
13355 -#endif
13356 -
13357 -#ifdef CONFIG_ETRAX_USB_HOST_PORT2
13358 - *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
13359 -#endif
13360 -
13361 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
13362 -
13363 - /* Configure the USB interface as a host controller. */
13364 - *R_USB_COMMAND =
13365 - IO_STATE(R_USB_COMMAND, port_sel, nop) |
13366 - IO_STATE(R_USB_COMMAND, port_cmd, reset) |
13367 - IO_STATE(R_USB_COMMAND, ctrl_cmd, host_config);
13368 -
13369 - /* Note: Do not reset any ports here. Await the port status interrupts, to have a controlled
13370 - sequence of resetting the ports. If we reset both ports now, and there are devices
13371 - on both ports, we will get a bus error because both devices will answer the set address
13372 - request. */
13373 -
13374 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
13375 -
13376 - /* Start processing of USB traffic. */
13377 - *R_USB_COMMAND =
13378 - IO_STATE(R_USB_COMMAND, port_sel, nop) |
13379 - IO_STATE(R_USB_COMMAND, port_cmd, reset) |
13380 - IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
13381 -
13382 - while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
13383 -
13384 - usb_rh = usb_alloc_dev(NULL, hc->bus, 0);
13385 - hc->bus->root_hub = usb_rh;
13386 - usb_rh->state = USB_STATE_ADDRESS;
13387 - usb_rh->speed = USB_SPEED_FULL;
13388 - usb_rh->devnum = 1;
13389 - hc->bus->devnum_next = 2;
13390 - usb_rh->ep0.desc.wMaxPacketSize = __const_cpu_to_le16(64);
13391 - usb_get_device_descriptor(usb_rh, USB_DT_DEVICE_SIZE);
13392 - usb_new_device(usb_rh);
13393 -
13394 - DBFEXIT;
13395 -
13396 - return 0;
13397 -}
13398 -
13399 -static void etrax_usb_hc_cleanup(void)
13400 -{
13401 - DBFENTER;
13402 -
13403 - free_irq(ETRAX_USB_HC_IRQ, NULL);
13404 - free_irq(ETRAX_USB_RX_IRQ, NULL);
13405 - free_irq(ETRAX_USB_TX_IRQ, NULL);
13406 -
13407 - usb_deregister_bus(etrax_usb_bus);
13408 -
13409 - /* FIXME: call kmem_cache_destroy here? */
13410 -
13411 - DBFEXIT;
13412 -}
13413
13414 -module_init(etrax_usb_hc_init);
13415 -module_exit(etrax_usb_hc_cleanup);
13416 +/* Module hooks */
13417 +module_init(module_hcd_init);
13418 +module_exit(module_hcd_exit);
13419 --- linux-2.6.19.2.orig/drivers/usb/host/hc-crisv10.c 1970-01-01 01:00:00.000000000 +0100
13420 +++ linux-2.6.19.2.dev/drivers/usb/host/hc-crisv10.c 2007-02-26 20:58:29.000000000 +0100
13421 @@ -0,0 +1,4684 @@
13422 +/*
13423 + *
13424 + * ETRAX 100LX USB Host Controller Driver
13425 + *
13426 + * Copyright (C) 2005, 2006 Axis Communications AB
13427 + *
13428 + * Author: Konrad Eriksson <konrad.eriksson@axis.se>
13429 + *
13430 + */
13431 +
13432 +#include <linux/module.h>
13433 +#include <linux/kernel.h>
13434 +#include <linux/init.h>
13435 +#include <linux/moduleparam.h>
13436 +#include <linux/spinlock.h>
13437 +#include <linux/usb.h>
13438 +#include <linux/platform_device.h>
13439 +
13440 +#include <asm/io.h>
13441 +#include <asm/irq.h>
13442 +#include <asm/arch/dma.h>
13443 +#include <asm/arch/io_interface_mux.h>
13444 +
13445 +#include "../core/hcd.h"
13446 +#include "../core/hub.h"
13447 +#include "hc-crisv10.h"
13448 +#include "hc-cris-dbg.h"
13449 +
13450 +
13451 +/***************************************************************************/
13452 +/***************************************************************************/
13453 +/* Host Controller settings */
13454 +/***************************************************************************/
13455 +/***************************************************************************/
13456 +
13457 +#define VERSION "1.00"
13458 +#define COPYRIGHT "(c) 2005, 2006 Axis Communications AB"
13459 +#define DESCRIPTION "ETRAX 100LX USB Host Controller"
13460 +
13461 +#define ETRAX_USB_HC_IRQ USB_HC_IRQ_NBR
13462 +#define ETRAX_USB_RX_IRQ USB_DMA_RX_IRQ_NBR
13463 +#define ETRAX_USB_TX_IRQ USB_DMA_TX_IRQ_NBR
13464 +
13465 +/* Number of physical ports in Etrax 100LX */
13466 +#define USB_ROOT_HUB_PORTS 2
13467 +
13468 +const char hc_name[] = "hc-crisv10";
13469 +const char product_desc[] = DESCRIPTION;
13470 +
13471 +/* The number of epids is, among other things, used for pre-allocating
13472 + ctrl, bulk and isoc EP descriptors (one for each epid).
13473 + Assumed to be > 1 when initiating the DMA lists. */
13474 +#define NBR_OF_EPIDS 32
13475 +
13476 +/* Support interrupt traffic intervals up to 128 ms. */
13477 +#define MAX_INTR_INTERVAL 128
13478 +
13479 +/* If periodic traffic (intr or isoc) is to be used, then one entry in the EP
13480 + table must be "invalid". By this we mean that we shouldn't care about epid
13481 + attentions for this epid, or at least handle them differently from epid
13482 + attentions for "valid" epids. This define determines which one to use
13483 + (don't change it). */
13484 +#define INVALID_EPID 31
13485 +/* A special epid for the bulk dummys. */
13486 +#define DUMMY_EPID 30
13487 +
13488 +/* Module settings */
13489 +
13490 +MODULE_DESCRIPTION(DESCRIPTION);
13491 +MODULE_LICENSE("GPL");
13492 +MODULE_AUTHOR("Konrad Eriksson <konrad.eriksson@axis.se>");
13493 +
13494 +
13495 +/* Module parameters */
13496 +
13497 +/* 0 = No ports enabled
13498 + 1 = Only port 1 enabled (on board ethernet on devboard)
13499 + 2 = Only port 2 enabled (external connector on devboard)
13500 + 3 = Both ports enabled
13501 +*/
13502 +static unsigned int ports = 3;
13503 +module_param(ports, uint, S_IRUGO);
13504 +MODULE_PARM_DESC(ports, "Bitmask indicating USB ports to use");
13505 +
13506 +
13507 +/***************************************************************************/
13508 +/***************************************************************************/
13509 +/* Shared global variables for this module */
13510 +/***************************************************************************/
13511 +/***************************************************************************/
13512 +
13513 +/* EP descriptor lists for non period transfers. Must be 32-bit aligned. */
13514 +static volatile struct USB_EP_Desc TxBulkEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
13515 +
13516 +static volatile struct USB_EP_Desc TxCtrlEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
13517 +
13518 +/* EP descriptor lists for period transfers. Must be 32-bit aligned. */
13519 +static volatile struct USB_EP_Desc TxIntrEPList[MAX_INTR_INTERVAL] __attribute__ ((aligned (4)));
13520 +static volatile struct USB_SB_Desc TxIntrSB_zout __attribute__ ((aligned (4)));
13521 +
13522 +static volatile struct USB_EP_Desc TxIsocEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
13523 +static volatile struct USB_SB_Desc TxIsocSB_zout __attribute__ ((aligned (4)));
13524 +
13525 +static volatile struct USB_SB_Desc TxIsocSBList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
13526 +
13527 +/* After each enabled bulk EP IN we put two disabled EP descriptors with the eol flag set,
13528 + causing the DMA to stop the DMA channel. The first of these two has the intr flag set, which
13529 + gives us a dma8_sub0_descr interrupt. When we receive this, we advance the DMA one step in the
13530 + EP list and then restart the bulk channel, thus forcing a switch between bulk EP descriptors
13531 + in each frame. */
13532 +static volatile struct USB_EP_Desc TxBulkDummyEPList[NBR_OF_EPIDS][2] __attribute__ ((aligned (4)));
13533 +
13534 +/* List of URB pointers, where each points to the active URB for a epid.
13535 + For Bulk, Ctrl and Intr this means which URB that currently is added to
13536 + DMA lists (Isoc URBs are all directly added to DMA lists). As soon as
13537 + URB has completed is the queue examined and the first URB in queue is
13538 + removed and moved to the activeUrbList while its state change to STARTED and
13539 + its transfer(s) gets added to DMA list (exception Isoc where URBs enter
13540 + state STARTED directly and added transfers added to DMA lists). */
13541 +static struct urb *activeUrbList[NBR_OF_EPIDS];
13542 +
13543 +/* Additional software state info for each epid */
13544 +static struct etrax_epid epid_state[NBR_OF_EPIDS];
13545 +
13546 +/* Timer handles for bulk traffic timer used to avoid DMA bug where DMA stops
13547 + even if there is new data waiting to be processed */
13548 +static struct timer_list bulk_start_timer = TIMER_INITIALIZER(NULL, 0, 0);
13549 +static struct timer_list bulk_eot_timer = TIMER_INITIALIZER(NULL, 0, 0);
13550 +
13551 +/* We want the start timer to expire before the eot timer, because the former
13552 + might start traffic, thus making it unnecessary for the latter to time
13553 + out. */
13554 +#define BULK_START_TIMER_INTERVAL (HZ/50) /* 20 ms */
13555 +#define BULK_EOT_TIMER_INTERVAL (HZ/16) /* 60 ms */
13556 +
13557 +/* Delay before a URB completion happen when it's scheduled to be delayed */
13558 +#define LATER_TIMER_DELAY (HZ/50) /* 20 ms */
13559 +
13560 +/* Simplifying macros for checking software state info of a epid */
13561 +/* ----------------------------------------------------------------------- */
13562 +#define epid_inuse(epid) epid_state[epid].inuse
13563 +#define epid_out_traffic(epid) epid_state[epid].out_traffic
13564 +#define epid_isoc(epid) (epid_state[epid].type == PIPE_ISOCHRONOUS ? 1 : 0)
13565 +#define epid_intr(epid) (epid_state[epid].type == PIPE_INTERRUPT ? 1 : 0)
13566 +
13567 +
13568 +/***************************************************************************/
13569 +/***************************************************************************/
13570 +/* DEBUG FUNCTIONS */
13571 +/***************************************************************************/
13572 +/***************************************************************************/
13573 +/* Note that these functions are always available in their "__" variants,
13574 + for use in error situations. The "__" missing variants are controlled by
13575 + the USB_DEBUG_DESC/USB_DEBUG_URB macros. */
13576 +static void __dump_urb(struct urb* purb)
13577 +{
13578 + struct crisv10_urb_priv *urb_priv = purb->hcpriv;
13579 + int urb_num = -1;
13580 + if(urb_priv) {
13581 + urb_num = urb_priv->urb_num;
13582 + }
13583 + printk("\nURB:0x%x[%d]\n", (unsigned int)purb, urb_num);
13584 + printk("dev :0x%08lx\n", (unsigned long)purb->dev);
13585 + printk("pipe :0x%08x\n", purb->pipe);
13586 + printk("status :%d\n", purb->status);
13587 + printk("transfer_flags :0x%08x\n", purb->transfer_flags);
13588 + printk("transfer_buffer :0x%08lx\n", (unsigned long)purb->transfer_buffer);
13589 + printk("transfer_buffer_length:%d\n", purb->transfer_buffer_length);
13590 + printk("actual_length :%d\n", purb->actual_length);
13591 + printk("setup_packet :0x%08lx\n", (unsigned long)purb->setup_packet);
13592 + printk("start_frame :%d\n", purb->start_frame);
13593 + printk("number_of_packets :%d\n", purb->number_of_packets);
13594 + printk("interval :%d\n", purb->interval);
13595 + printk("error_count :%d\n", purb->error_count);
13596 + printk("context :0x%08lx\n", (unsigned long)purb->context);
13597 + printk("complete :0x%08lx\n\n", (unsigned long)purb->complete);
13598 +}
13599 +
13600 +static void __dump_in_desc(volatile struct USB_IN_Desc *in)
13601 +{
13602 + printk("\nUSB_IN_Desc at 0x%08lx\n", (unsigned long)in);
13603 + printk(" sw_len : 0x%04x (%d)\n", in->sw_len, in->sw_len);
13604 + printk(" command : 0x%04x\n", in->command);
13605 + printk(" next : 0x%08lx\n", in->next);
13606 + printk(" buf : 0x%08lx\n", in->buf);
13607 + printk(" hw_len : 0x%04x (%d)\n", in->hw_len, in->hw_len);
13608 + printk(" status : 0x%04x\n\n", in->status);
13609 +}
13610 +
13611 +static void __dump_sb_desc(volatile struct USB_SB_Desc *sb)
13612 +{
13613 + char tt = (sb->command & 0x30) >> 4;
13614 + char *tt_string;
13615 +
13616 + switch (tt) {
13617 + case 0:
13618 + tt_string = "zout";
13619 + break;
13620 + case 1:
13621 + tt_string = "in";
13622 + break;
13623 + case 2:
13624 + tt_string = "out";
13625 + break;
13626 + case 3:
13627 + tt_string = "setup";
13628 + break;
13629 + default:
13630 + tt_string = "unknown (weird)";
13631 + }
13632 +
13633 + printk(" USB_SB_Desc at 0x%08lx ", (unsigned long)sb);
13634 + printk(" command:0x%04x (", sb->command);
13635 + printk("rem:%d ", (sb->command & 0x3f00) >> 8);
13636 + printk("full:%d ", (sb->command & 0x40) >> 6);
13637 + printk("tt:%d(%s) ", tt, tt_string);
13638 + printk("intr:%d ", (sb->command & 0x8) >> 3);
13639 + printk("eot:%d ", (sb->command & 0x2) >> 1);
13640 + printk("eol:%d)", sb->command & 0x1);
13641 + printk(" sw_len:0x%04x(%d)", sb->sw_len, sb->sw_len);
13642 + printk(" next:0x%08lx", sb->next);
13643 + printk(" buf:0x%08lx\n", sb->buf);
13644 +}
13645 +
13646 +
13647 +static void __dump_ep_desc(volatile struct USB_EP_Desc *ep)
13648 +{
13649 + printk("USB_EP_Desc at 0x%08lx ", (unsigned long)ep);
13650 + printk(" command:0x%04x (", ep->command);
13651 + printk("ep_id:%d ", (ep->command & 0x1f00) >> 8);
13652 + printk("enable:%d ", (ep->command & 0x10) >> 4);
13653 + printk("intr:%d ", (ep->command & 0x8) >> 3);
13654 + printk("eof:%d ", (ep->command & 0x2) >> 1);
13655 + printk("eol:%d)", ep->command & 0x1);
13656 + printk(" hw_len:0x%04x(%d)", ep->hw_len, ep->hw_len);
13657 + printk(" next:0x%08lx", ep->next);
13658 + printk(" sub:0x%08lx\n", ep->sub);
13659 +}
13660 +
13661 +static inline void __dump_ep_list(int pipe_type)
13662 +{
13663 + volatile struct USB_EP_Desc *ep;
13664 + volatile struct USB_EP_Desc *first_ep;
13665 + volatile struct USB_SB_Desc *sb;
13666 +
13667 + switch (pipe_type)
13668 + {
13669 + case PIPE_BULK:
13670 + first_ep = &TxBulkEPList[0];
13671 + break;
13672 + case PIPE_CONTROL:
13673 + first_ep = &TxCtrlEPList[0];
13674 + break;
13675 + case PIPE_INTERRUPT:
13676 + first_ep = &TxIntrEPList[0];
13677 + break;
13678 + case PIPE_ISOCHRONOUS:
13679 + first_ep = &TxIsocEPList[0];
13680 + break;
13681 + default:
13682 + warn("Cannot dump unknown traffic type");
13683 + return;
13684 + }
13685 + ep = first_ep;
13686 +
13687 + printk("\n\nDumping EP list...\n\n");
13688 +
13689 + do {
13690 + __dump_ep_desc(ep);
13691 + /* Cannot phys_to_virt on 0 as it turns into 80000000, which is != 0. */
13692 + sb = ep->sub ? phys_to_virt(ep->sub) : 0;
13693 + while (sb) {
13694 + __dump_sb_desc(sb);
13695 + sb = sb->next ? phys_to_virt(sb->next) : 0;
13696 + }
13697 + ep = (volatile struct USB_EP_Desc *)(phys_to_virt(ep->next));
13698 +
13699 + } while (ep != first_ep);
13700 +}
13701 +
13702 +static inline void __dump_ept_data(int epid)
13703 +{
13704 + unsigned long flags;
13705 + __u32 r_usb_ept_data;
13706 +
13707 + if (epid < 0 || epid > 31) {
13708 + printk("Cannot dump ept data for invalid epid %d\n", epid);
13709 + return;
13710 + }
13711 +
13712 + local_irq_save(flags);
13713 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
13714 + nop();
13715 + r_usb_ept_data = *R_USB_EPT_DATA;
13716 + local_irq_restore(flags);
13717 +
13718 + printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", r_usb_ept_data, epid);
13719 + if (r_usb_ept_data == 0) {
13720 + /* No need for more detailed printing. */
13721 + return;
13722 + }
13723 + printk(" valid : %d\n", (r_usb_ept_data & 0x80000000) >> 31);
13724 + printk(" hold : %d\n", (r_usb_ept_data & 0x40000000) >> 30);
13725 + printk(" error_count_in : %d\n", (r_usb_ept_data & 0x30000000) >> 28);
13726 + printk(" t_in : %d\n", (r_usb_ept_data & 0x08000000) >> 27);
13727 + printk(" low_speed : %d\n", (r_usb_ept_data & 0x04000000) >> 26);
13728 + printk(" port : %d\n", (r_usb_ept_data & 0x03000000) >> 24);
13729 + printk(" error_code : %d\n", (r_usb_ept_data & 0x00c00000) >> 22);
13730 + printk(" t_out : %d\n", (r_usb_ept_data & 0x00200000) >> 21);
13731 + printk(" error_count_out : %d\n", (r_usb_ept_data & 0x00180000) >> 19);
13732 + printk(" max_len : %d\n", (r_usb_ept_data & 0x0003f800) >> 11);
13733 + printk(" ep : %d\n", (r_usb_ept_data & 0x00000780) >> 7);
13734 + printk(" dev : %d\n", (r_usb_ept_data & 0x0000003f));
13735 +}
13736 +
13737 +static inline void __dump_ept_data_iso(int epid)
13738 +{
13739 + unsigned long flags;
13740 + __u32 ept_data;
13741 +
13742 + if (epid < 0 || epid > 31) {
13743 + printk("Cannot dump ept data for invalid epid %d\n", epid);
13744 + return;
13745 + }
13746 +
13747 + local_irq_save(flags);
13748 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
13749 + nop();
13750 + ept_data = *R_USB_EPT_DATA_ISO;
13751 + local_irq_restore(flags);
13752 +
13753 + printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", ept_data, epid);
13754 + if (ept_data == 0) {
13755 + /* No need for more detailed printing. */
13756 + return;
13757 + }
13758 + printk(" valid : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, valid,
13759 + ept_data));
13760 + printk(" port : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, port,
13761 + ept_data));
13762 + printk(" error_code : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code,
13763 + ept_data));
13764 + printk(" max_len : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, max_len,
13765 + ept_data));
13766 + printk(" ep : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, ep,
13767 + ept_data));
13768 + printk(" dev : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, dev,
13769 + ept_data));
13770 +}
13771 +
13772 +static inline void __dump_ept_data_list(void)
13773 +{
13774 + int i;
13775 +
13776 + printk("Dumping the whole R_USB_EPT_DATA list\n");
13777 +
13778 + for (i = 0; i < 32; i++) {
13779 + __dump_ept_data(i);
13780 + }
13781 +}
13782 +
13783 +static void debug_epid(int epid) {
13784 + int i;
13785 +
13786 + if(epid_isoc(epid)) {
13787 + __dump_ept_data_iso(epid);
13788 + } else {
13789 + __dump_ept_data(epid);
13790 + }
13791 +
13792 + printk("Bulk:\n");
13793 + for(i = 0; i < 32; i++) {
13794 + if(IO_EXTRACT(USB_EP_command, epid, TxBulkEPList[i].command) ==
13795 + epid) {
13796 + printk("%d: ", i); __dump_ep_desc(&(TxBulkEPList[i]));
13797 + }
13798 + }
13799 +
13800 + printk("Ctrl:\n");
13801 + for(i = 0; i < 32; i++) {
13802 + if(IO_EXTRACT(USB_EP_command, epid, TxCtrlEPList[i].command) ==
13803 + epid) {
13804 + printk("%d: ", i); __dump_ep_desc(&(TxCtrlEPList[i]));
13805 + }
13806 + }
13807 +
13808 + printk("Intr:\n");
13809 + for(i = 0; i < MAX_INTR_INTERVAL; i++) {
13810 + if(IO_EXTRACT(USB_EP_command, epid, TxIntrEPList[i].command) ==
13811 + epid) {
13812 + printk("%d: ", i); __dump_ep_desc(&(TxIntrEPList[i]));
13813 + }
13814 + }
13815 +
13816 + printk("Isoc:\n");
13817 + for(i = 0; i < 32; i++) {
13818 + if(IO_EXTRACT(USB_EP_command, epid, TxIsocEPList[i].command) ==
13819 + epid) {
13820 + printk("%d: ", i); __dump_ep_desc(&(TxIsocEPList[i]));
13821 + }
13822 + }
13823 +
13824 + __dump_ept_data_list();
13825 + __dump_ep_list(PIPE_INTERRUPT);
13826 + printk("\n\n");
13827 +}
13828 +
13829 +
13830 +
13831 +char* hcd_status_to_str(__u8 bUsbStatus) {
13832 + static char hcd_status_str[128];
13833 + hcd_status_str[0] = '\0';
13834 + if(bUsbStatus & IO_STATE(R_USB_STATUS, ourun, yes)) {
13835 + strcat(hcd_status_str, "ourun ");
13836 + }
13837 + if(bUsbStatus & IO_STATE(R_USB_STATUS, perror, yes)) {
13838 + strcat(hcd_status_str, "perror ");
13839 + }
13840 + if(bUsbStatus & IO_STATE(R_USB_STATUS, device_mode, yes)) {
13841 + strcat(hcd_status_str, "device_mode ");
13842 + }
13843 + if(bUsbStatus & IO_STATE(R_USB_STATUS, host_mode, yes)) {
13844 + strcat(hcd_status_str, "host_mode ");
13845 + }
13846 + if(bUsbStatus & IO_STATE(R_USB_STATUS, started, yes)) {
13847 + strcat(hcd_status_str, "started ");
13848 + }
13849 + if(bUsbStatus & IO_STATE(R_USB_STATUS, running, yes)) {
13850 + strcat(hcd_status_str, "running ");
13851 + }
13852 + return hcd_status_str;
13853 +}
13854 +
13855 +
13856 +char* sblist_to_str(struct USB_SB_Desc* sb_desc) {
13857 + static char sblist_to_str_buff[128];
13858 + char tmp[32], tmp2[32];
13859 + sblist_to_str_buff[0] = '\0';
13860 + while(sb_desc != NULL) {
13861 + switch(IO_EXTRACT(USB_SB_command, tt, sb_desc->command)) {
13862 + case 0: sprintf(tmp, "zout"); break;
13863 + case 1: sprintf(tmp, "in"); break;
13864 + case 2: sprintf(tmp, "out"); break;
13865 + case 3: sprintf(tmp, "setup"); break;
13866 + }
13867 + sprintf(tmp2, "(%s %d)", tmp, sb_desc->sw_len);
13868 + strcat(sblist_to_str_buff, tmp2);
13869 + if(sb_desc->next != 0) {
13870 + sb_desc = phys_to_virt(sb_desc->next);
13871 + } else {
13872 + sb_desc = NULL;
13873 + }
13874 + }
13875 + return sblist_to_str_buff;
13876 +}
13877 +
13878 +char* port_status_to_str(__u16 wPortStatus) {
13879 + static char port_status_str[128];
13880 + port_status_str[0] = '\0';
13881 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) {
13882 + strcat(port_status_str, "connected ");
13883 + }
13884 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) {
13885 + strcat(port_status_str, "enabled ");
13886 + }
13887 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, suspended, yes)) {
13888 + strcat(port_status_str, "suspended ");
13889 + }
13890 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, reset, yes)) {
13891 + strcat(port_status_str, "reset ");
13892 + }
13893 + if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, speed, full)) {
13894 + strcat(port_status_str, "full-speed ");
13895 + } else {
13896 + strcat(port_status_str, "low-speed ");
13897 + }
13898 + return port_status_str;
13899 +}
13900 +
13901 +
13902 +char* endpoint_to_str(struct usb_endpoint_descriptor *ed) {
13903 + static char endpoint_to_str_buff[128];
13904 + char tmp[32];
13905 + int epnum = ed->bEndpointAddress & 0x0F;
13906 + int dir = ed->bEndpointAddress & 0x80;
13907 + int type = ed->bmAttributes & 0x03;
13908 + endpoint_to_str_buff[0] = '\0';
13909 + sprintf(endpoint_to_str_buff, "ep:%d ", epnum);
13910 + switch(type) {
13911 + case 0:
13912 + sprintf(tmp, " ctrl");
13913 + break;
13914 + case 1:
13915 + sprintf(tmp, " isoc");
13916 + break;
13917 + case 2:
13918 + sprintf(tmp, " bulk");
13919 + break;
13920 + case 3:
13921 + sprintf(tmp, " intr");
13922 + break;
13923 + }
13924 + strcat(endpoint_to_str_buff, tmp);
13925 + if(dir) {
13926 + sprintf(tmp, " in");
13927 + } else {
13928 + sprintf(tmp, " out");
13929 + }
13930 + strcat(endpoint_to_str_buff, tmp);
13931 +
13932 + return endpoint_to_str_buff;
13933 +}
13934 +
13935 +/* Debug helper functions for Transfer Controller */
13936 +char* pipe_to_str(unsigned int pipe) {
13937 + static char pipe_to_str_buff[128];
13938 + char tmp[64];
13939 + sprintf(pipe_to_str_buff, "dir:%s", str_dir(pipe));
13940 + sprintf(tmp, " type:%s", str_type(pipe));
13941 + strcat(pipe_to_str_buff, tmp);
13942 +
13943 + sprintf(tmp, " dev:%d", usb_pipedevice(pipe));
13944 + strcat(pipe_to_str_buff, tmp);
13945 + sprintf(tmp, " ep:%d", usb_pipeendpoint(pipe));
13946 + strcat(pipe_to_str_buff, tmp);
13947 + return pipe_to_str_buff;
13948 +}
13949 +
13950 +
13951 +#define USB_DEBUG_DESC 1
13952 +
13953 +#ifdef USB_DEBUG_DESC
13954 +#define dump_in_desc(x) __dump_in_desc(x)
13955 +#define dump_sb_desc(...) __dump_sb_desc(...)
13956 +#define dump_ep_desc(x) __dump_ep_desc(x)
13957 +#define dump_ept_data(x) __dump_ept_data(x)
13958 +#else
13959 +#define dump_in_desc(...) do {} while (0)
13960 +#define dump_sb_desc(...) do {} while (0)
13961 +#define dump_ep_desc(...) do {} while (0)
13962 +#endif
13963 +
13964 +
13965 +/* Uncomment this to enable massive function call trace
13966 + #define USB_DEBUG_TRACE */
13967 +
13968 +#ifdef USB_DEBUG_TRACE
13969 +#define DBFENTER (printk(": Entering: %s\n", __FUNCTION__))
13970 +#define DBFEXIT (printk(": Exiting: %s\n", __FUNCTION__))
13971 +#else
13972 +#define DBFENTER do {} while (0)
13973 +#define DBFEXIT do {} while (0)
13974 +#endif
13975 +
13976 +#define CHECK_ALIGN(x) if (((__u32)(x)) & 0x00000003) \
13977 +{panic("Alignment check (DWORD) failed at %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);}
13978 +
13979 +/* Most helpful debugging aid */
13980 +#define ASSERT(expr) ((void) ((expr) ? 0 : (err("assert failed at: %s %d",__FUNCTION__, __LINE__))))
13981 +
13982 +
13983 +/***************************************************************************/
13984 +/***************************************************************************/
13985 +/* Forward declarations */
13986 +/***************************************************************************/
13987 +/***************************************************************************/
13988 +void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg);
13989 +void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg);
13990 +void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg);
13991 +void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg);
13992 +
13993 +void rh_port_status_change(__u16[]);
13994 +int rh_clear_port_feature(__u8, __u16);
13995 +int rh_set_port_feature(__u8, __u16);
13996 +static void rh_disable_port(unsigned int port);
13997 +
13998 +static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
13999 + int timer);
14000 +
14001 +static int tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
14002 + int mem_flags);
14003 +static void tc_free_epid(struct usb_host_endpoint *ep);
14004 +static int tc_allocate_epid(void);
14005 +static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status);
14006 +static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
14007 + int status);
14008 +
14009 +static int urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
14010 + int mem_flags);
14011 +static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb);
14012 +
14013 +static inline struct urb *urb_list_first(int epid);
14014 +static inline void urb_list_add(struct urb *urb, int epid,
14015 + int mem_flags);
14016 +static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid);
14017 +static inline void urb_list_del(struct urb *urb, int epid);
14018 +static inline void urb_list_move_last(struct urb *urb, int epid);
14019 +static inline struct urb *urb_list_next(struct urb *urb, int epid);
14020 +
14021 +int create_sb_for_urb(struct urb *urb, int mem_flags);
14022 +int init_intr_urb(struct urb *urb, int mem_flags);
14023 +
14024 +static inline void etrax_epid_set(__u8 index, __u32 data);
14025 +static inline void etrax_epid_clear_error(__u8 index);
14026 +static inline void etrax_epid_set_toggle(__u8 index, __u8 dirout,
14027 + __u8 toggle);
14028 +static inline __u8 etrax_epid_get_toggle(__u8 index, __u8 dirout);
14029 +static inline __u32 etrax_epid_get(__u8 index);
14030 +
14031 +/* We're accessing the same register position in Etrax so
14032 + when we do full access the internal difference doesn't matter */
14033 +#define etrax_epid_iso_set(index, data) etrax_epid_set(index, data)
14034 +#define etrax_epid_iso_get(index) etrax_epid_get(index)
14035 +
14036 +
14037 +static void tc_dma_process_isoc_urb(struct urb *urb);
14038 +static void tc_dma_process_queue(int epid);
14039 +static void tc_dma_unlink_intr_urb(struct urb *urb);
14040 +static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc);
14041 +static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc);
14042 +
14043 +static void tc_bulk_start_timer_func(unsigned long dummy);
14044 +static void tc_bulk_eot_timer_func(unsigned long dummy);
14045 +
14046 +
14047 +/*************************************************************/
14048 +/*************************************************************/
14049 +/* Host Controler Driver block */
14050 +/*************************************************************/
14051 +/*************************************************************/
14052 +
14053 +/* HCD operations */
14054 +static irqreturn_t crisv10_hcd_top_irq(int irq, void*);
14055 +static int crisv10_hcd_reset(struct usb_hcd *);
14056 +static int crisv10_hcd_start(struct usb_hcd *);
14057 +static void crisv10_hcd_stop(struct usb_hcd *);
14058 +#ifdef CONFIG_PM
14059 +static int crisv10_hcd_suspend(struct device *, u32, u32);
14060 +static int crisv10_hcd_resume(struct device *, u32);
14061 +#endif /* CONFIG_PM */
14062 +static int crisv10_hcd_get_frame(struct usb_hcd *);
14063 +
14064 +static int tc_urb_enqueue(struct usb_hcd *, struct usb_host_endpoint *ep, struct urb *, gfp_t mem_flags);
14065 +static int tc_urb_dequeue(struct usb_hcd *, struct urb *);
14066 +static void tc_endpoint_disable(struct usb_hcd *, struct usb_host_endpoint *ep);
14067 +
14068 +static int rh_status_data_request(struct usb_hcd *, char *);
14069 +static int rh_control_request(struct usb_hcd *, u16, u16, u16, char*, u16);
14070 +
14071 +#ifdef CONFIG_PM
14072 +static int crisv10_hcd_hub_suspend(struct usb_hcd *);
14073 +static int crisv10_hcd_hub_resume(struct usb_hcd *);
14074 +#endif /* CONFIG_PM */
14075 +#ifdef CONFIG_USB_OTG
14076 +static int crisv10_hcd_start_port_reset(struct usb_hcd *, unsigned);
14077 +#endif /* CONFIG_USB_OTG */
14078 +
14079 +/* host controller driver interface */
14080 +static const struct hc_driver crisv10_hc_driver =
14081 + {
14082 + .description = hc_name,
14083 + .product_desc = product_desc,
14084 + .hcd_priv_size = sizeof(struct crisv10_hcd),
14085 +
14086 + /* Attaching IRQ handler manualy in probe() */
14087 + /* .irq = crisv10_hcd_irq, */
14088 +
14089 + .flags = HCD_USB11,
14090 +
14091 + /* called to init HCD and root hub */
14092 + .reset = crisv10_hcd_reset,
14093 + .start = crisv10_hcd_start,
14094 +
14095 + /* cleanly make HCD stop writing memory and doing I/O */
14096 + .stop = crisv10_hcd_stop,
14097 +
14098 + /* return current frame number */
14099 + .get_frame_number = crisv10_hcd_get_frame,
14100 +
14101 +
14102 + /* Manage i/o requests via the Transfer Controller */
14103 + .urb_enqueue = tc_urb_enqueue,
14104 + .urb_dequeue = tc_urb_dequeue,
14105 +
14106 + /* hw synch, freeing endpoint resources that urb_dequeue can't */
14107 + .endpoint_disable = tc_endpoint_disable,
14108 +
14109 +
14110 + /* Root Hub support */
14111 + .hub_status_data = rh_status_data_request,
14112 + .hub_control = rh_control_request,
14113 +#ifdef CONFIG_PM
14114 + .hub_suspend = rh_suspend_request,
14115 + .hub_resume = rh_resume_request,
14116 +#endif /* CONFIG_PM */
14117 +#ifdef CONFIG_USB_OTG
14118 + .start_port_reset = crisv10_hcd_start_port_reset,
14119 +#endif /* CONFIG_USB_OTG */
14120 + };
14121 +
14122 +
14123 +/*
14124 + * conversion between pointers to a hcd and the corresponding
14125 + * crisv10_hcd
14126 + */
14127 +
14128 +static inline struct crisv10_hcd *hcd_to_crisv10_hcd(struct usb_hcd *hcd)
14129 +{
14130 + return (struct crisv10_hcd *) hcd->hcd_priv;
14131 +}
14132 +
14133 +static inline struct usb_hcd *crisv10_hcd_to_hcd(struct crisv10_hcd *hcd)
14134 +{
14135 + return container_of((void *) hcd, struct usb_hcd, hcd_priv);
14136 +}
14137 +
14138 +/* check if specified port is in use */
14139 +static inline int port_in_use(unsigned int port)
14140 +{
14141 + return ports & (1 << port);
14142 +}
14143 +
14144 +/* number of ports in use */
14145 +static inline unsigned int num_ports(void)
14146 +{
14147 + unsigned int i, num = 0;
14148 + for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
14149 + if (port_in_use(i))
14150 + num++;
14151 + return num;
14152 +}
14153 +
14154 +/* map hub port number to the port number used internally by the HC */
14155 +static inline unsigned int map_port(unsigned int port)
14156 +{
14157 + unsigned int i, num = 0;
14158 + for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
14159 + if (port_in_use(i))
14160 + if (++num == port)
14161 + return i;
14162 + return -1;
14163 +}
14164 +
14165 +/* size of descriptors in slab cache */
14166 +#ifndef MAX
14167 +#define MAX(x, y) ((x) > (y) ? (x) : (y))
14168 +#endif
14169 +
14170 +
14171 +/******************************************************************/
14172 +/* Hardware Interrupt functions */
14173 +/******************************************************************/
14174 +
14175 +/* Fast interrupt handler for HC */
14176 +static irqreturn_t crisv10_hcd_top_irq(int irq, void *vcd)
14177 +{
14178 + struct usb_hcd *hcd = vcd;
14179 + struct crisv10_irq_reg reg;
14180 + __u32 irq_mask;
14181 + unsigned long flags;
14182 +
14183 + DBFENTER;
14184 +
14185 + ASSERT(hcd != NULL);
14186 + reg.hcd = hcd;
14187 +
14188 + /* Turn of other interrupts while handling these sensitive cases */
14189 + local_irq_save(flags);
14190 +
14191 + /* Read out which interrupts that are flaged */
14192 + irq_mask = *R_USB_IRQ_MASK_READ;
14193 + reg.r_usb_irq_mask_read = irq_mask;
14194 +
14195 + /* Reading R_USB_STATUS clears the ctl_status interrupt. Note that
14196 + R_USB_STATUS must be read before R_USB_EPID_ATTN since reading the latter
14197 + clears the ourun and perror fields of R_USB_STATUS. */
14198 + reg.r_usb_status = *R_USB_STATUS;
14199 +
14200 + /* Reading R_USB_EPID_ATTN clears the iso_eof, bulk_eot and epid_attn
14201 + interrupts. */
14202 + reg.r_usb_epid_attn = *R_USB_EPID_ATTN;
14203 +
14204 + /* Reading R_USB_RH_PORT_STATUS_1 and R_USB_RH_PORT_STATUS_2 clears the
14205 + port_status interrupt. */
14206 + reg.r_usb_rh_port_status_1 = *R_USB_RH_PORT_STATUS_1;
14207 + reg.r_usb_rh_port_status_2 = *R_USB_RH_PORT_STATUS_2;
14208 +
14209 + /* Reading R_USB_FM_NUMBER clears the sof interrupt. */
14210 + /* Note: the lower 11 bits contain the actual frame number, sent with each
14211 + sof. */
14212 + reg.r_usb_fm_number = *R_USB_FM_NUMBER;
14213 +
14214 + /* Interrupts are handled in order of priority. */
14215 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, port_status)) {
14216 + crisv10_hcd_port_status_irq(&reg);
14217 + }
14218 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, epid_attn)) {
14219 + crisv10_hcd_epid_attn_irq(&reg);
14220 + }
14221 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, ctl_status)) {
14222 + crisv10_hcd_ctl_status_irq(&reg);
14223 + }
14224 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, iso_eof)) {
14225 + crisv10_hcd_isoc_eof_irq(&reg);
14226 + }
14227 + if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, bulk_eot)) {
14228 + /* Update/restart the bulk start timer since obviously the channel is
14229 + running. */
14230 + mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
14231 + /* Update/restart the bulk eot timer since we just received an bulk eot
14232 + interrupt. */
14233 + mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
14234 +
14235 + /* Check for finished bulk transfers on epids */
14236 + check_finished_bulk_tx_epids(hcd, 0);
14237 + }
14238 + local_irq_restore(flags);
14239 +
14240 + DBFEXIT;
14241 + return IRQ_HANDLED;
14242 +}
14243 +
14244 +
14245 +void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg) {
14246 + struct usb_hcd *hcd = reg->hcd;
14247 + struct crisv10_urb_priv *urb_priv;
14248 + int epid;
14249 + DBFENTER;
14250 +
14251 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
14252 + if (test_bit(epid, (void *)&reg->r_usb_epid_attn)) {
14253 + struct urb *urb;
14254 + __u32 ept_data;
14255 + int error_code;
14256 +
14257 + if (epid == DUMMY_EPID || epid == INVALID_EPID) {
14258 + /* We definitely don't care about these ones. Besides, they are
14259 + always disabled, so any possible disabling caused by the
14260 + epid attention interrupt is irrelevant. */
14261 + warn("Got epid_attn for INVALID_EPID or DUMMY_EPID (%d).", epid);
14262 + continue;
14263 + }
14264 +
14265 + if(!epid_inuse(epid)) {
14266 + irq_err("Epid attention on epid:%d that isn't in use\n", epid);
14267 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
14268 + debug_epid(epid);
14269 + continue;
14270 + }
14271 +
14272 + /* Note that although there are separate R_USB_EPT_DATA and
14273 + R_USB_EPT_DATA_ISO registers, they are located at the same address and
14274 + are of the same size. In other words, this read should be ok for isoc
14275 + also. */
14276 + ept_data = etrax_epid_get(epid);
14277 + error_code = IO_EXTRACT(R_USB_EPT_DATA, error_code, ept_data);
14278 +
14279 + /* Get the active URB for this epid. We blatantly assume
14280 + that only this URB could have caused the epid attention. */
14281 + urb = activeUrbList[epid];
14282 + if (urb == NULL) {
14283 + irq_err("Attention on epid:%d error:%d with no active URB.\n",
14284 + epid, error_code);
14285 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
14286 + debug_epid(epid);
14287 + continue;
14288 + }
14289 +
14290 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
14291 + ASSERT(urb_priv);
14292 +
14293 + /* Using IO_STATE_VALUE on R_USB_EPT_DATA should be ok for isoc also. */
14294 + if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
14295 +
14296 + /* Isoc traffic doesn't have error_count_in/error_count_out. */
14297 + if ((usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) &&
14298 + (IO_EXTRACT(R_USB_EPT_DATA, error_count_in, ept_data) == 3 ||
14299 + IO_EXTRACT(R_USB_EPT_DATA, error_count_out, ept_data) == 3)) {
14300 + /* Check if URB allready is marked for late-finish, we can get
14301 + several 3rd error for Intr traffic when a device is unplugged */
14302 + if(urb_priv->later_data == NULL) {
14303 + /* 3rd error. */
14304 + irq_warn("3rd error for epid:%d (%s %s) URB:0x%x[%d]\n", epid,
14305 + str_dir(urb->pipe), str_type(urb->pipe),
14306 + (unsigned int)urb, urb_priv->urb_num);
14307 +
14308 + tc_finish_urb_later(hcd, urb, -EPROTO);
14309 + }
14310 +
14311 + } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
14312 + irq_warn("Perror for epid:%d\n", epid);
14313 + printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
14314 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
14315 + __dump_urb(urb);
14316 + debug_epid(epid);
14317 +
14318 + if (!(ept_data & IO_MASK(R_USB_EPT_DATA, valid))) {
14319 + /* invalid ep_id */
14320 + panic("Perror because of invalid epid."
14321 + " Deconfigured too early?");
14322 + } else {
14323 + /* past eof1, near eof, zout transfer, setup transfer */
14324 + /* Dump the urb and the relevant EP descriptor. */
14325 + panic("Something wrong with DMA descriptor contents."
14326 + " Too much traffic inserted?");
14327 + }
14328 + } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
14329 + /* buffer ourun */
14330 + printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
14331 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
14332 + __dump_urb(urb);
14333 + debug_epid(epid);
14334 +
14335 + panic("Buffer overrun/underrun for epid:%d. DMA too busy?", epid);
14336 + } else {
14337 + irq_warn("Attention on epid:%d (%s %s) with no error code\n", epid,
14338 + str_dir(urb->pipe), str_type(urb->pipe));
14339 + printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
14340 + __dump_urb(urb);
14341 + debug_epid(epid);
14342 + }
14343 +
14344 + } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
14345 + stall)) {
14346 + /* Not really a protocol error, just says that the endpoint gave
14347 + a stall response. Note that error_code cannot be stall for isoc. */
14348 + if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
14349 + panic("Isoc traffic cannot stall");
14350 + }
14351 +
14352 + tc_dbg("Stall for epid:%d (%s %s) URB:0x%x\n", epid,
14353 + str_dir(urb->pipe), str_type(urb->pipe), (unsigned int)urb);
14354 + tc_finish_urb(hcd, urb, -EPIPE);
14355 +
14356 + } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
14357 + bus_error)) {
14358 + /* Two devices responded to a transaction request. Must be resolved
14359 + by software. FIXME: Reset ports? */
14360 + panic("Bus error for epid %d."
14361 + " Two devices responded to transaction request\n",
14362 + epid);
14363 +
14364 + } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
14365 + buffer_error)) {
14366 + /* DMA overrun or underrun. */
14367 + irq_warn("Buffer overrun/underrun for epid:%d (%s %s)\n", epid,
14368 + str_dir(urb->pipe), str_type(urb->pipe));
14369 +
14370 + /* It seems that error_code = buffer_error in
14371 + R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
14372 + are the same error. */
14373 + tc_finish_urb(hcd, urb, -EPROTO);
14374 + } else {
14375 + irq_warn("Unknown attention on epid:%d (%s %s)\n", epid,
14376 + str_dir(urb->pipe), str_type(urb->pipe));
14377 + dump_ept_data(epid);
14378 + }
14379 + }
14380 + }
14381 + DBFEXIT;
14382 +}
14383 +
14384 +void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg)
14385 +{
14386 + __u16 port_reg[USB_ROOT_HUB_PORTS];
14387 + DBFENTER;
14388 + port_reg[0] = reg->r_usb_rh_port_status_1;
14389 + port_reg[1] = reg->r_usb_rh_port_status_2;
14390 + rh_port_status_change(port_reg);
14391 + DBFEXIT;
14392 +}
14393 +
14394 +void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg)
14395 +{
14396 + int epid;
14397 + struct urb *urb;
14398 + struct crisv10_urb_priv *urb_priv;
14399 +
14400 + DBFENTER;
14401 +
14402 + for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
14403 +
14404 + /* Only check epids that are in use, is valid and has SB list */
14405 + if (!epid_inuse(epid) || epid == INVALID_EPID ||
14406 + TxIsocEPList[epid].sub == 0 || epid == DUMMY_EPID) {
14407 + /* Nothing here to see. */
14408 + continue;
14409 + }
14410 + ASSERT(epid_isoc(epid));
14411 +
14412 + /* Get the active URB for this epid (if any). */
14413 + urb = activeUrbList[epid];
14414 + if (urb == 0) {
14415 + isoc_warn("Ignoring NULL urb for epid:%d\n", epid);
14416 + continue;
14417 + }
14418 + if(!epid_out_traffic(epid)) {
14419 + /* Sanity check. */
14420 + ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
14421 +
14422 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
14423 + ASSERT(urb_priv);
14424 +
14425 + if (urb_priv->urb_state == NOT_STARTED) {
14426 + /* If ASAP is not set and urb->start_frame is the current frame,
14427 + start the transfer. */
14428 + if (!(urb->transfer_flags & URB_ISO_ASAP) &&
14429 + (urb->start_frame == (*R_USB_FM_NUMBER & 0x7ff))) {
14430 + /* EP should not be enabled if we're waiting for start_frame */
14431 + ASSERT((TxIsocEPList[epid].command &
14432 + IO_STATE(USB_EP_command, enable, yes)) == 0);
14433 +
14434 + isoc_warn("Enabling isoc IN EP descr for epid %d\n", epid);
14435 + TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
14436 +
14437 + /* This urb is now active. */
14438 + urb_priv->urb_state = STARTED;
14439 + continue;
14440 + }
14441 + }
14442 + }
14443 + }
14444 +
14445 + DBFEXIT;
14446 +}
14447 +
14448 +void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg)
14449 +{
14450 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(reg->hcd);
14451 +
14452 + DBFENTER;
14453 + ASSERT(crisv10_hcd);
14454 +
14455 + irq_dbg("ctr_status_irq, controller status: %s\n",
14456 + hcd_status_to_str(reg->r_usb_status));
14457 +
14458 + /* FIXME: What should we do if we get ourun or perror? Dump the EP and SB
14459 + list for the corresponding epid? */
14460 + if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
14461 + panic("USB controller got ourun.");
14462 + }
14463 + if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
14464 +
14465 + /* Before, etrax_usb_do_intr_recover was called on this epid if it was
14466 + an interrupt pipe. I don't see how re-enabling all EP descriptors
14467 + will help if there was a programming error. */
14468 + panic("USB controller got perror.");
14469 + }
14470 +
14471 + /* Keep track of USB Controller, if it's running or not */
14472 + if(reg->r_usb_status & IO_STATE(R_USB_STATUS, running, yes)) {
14473 + crisv10_hcd->running = 1;
14474 + } else {
14475 + crisv10_hcd->running = 0;
14476 + }
14477 +
14478 + if (reg->r_usb_status & IO_MASK(R_USB_STATUS, device_mode)) {
14479 + /* We should never operate in device mode. */
14480 + panic("USB controller in device mode.");
14481 + }
14482 +
14483 + /* Set the flag to avoid getting "Unlink after no-IRQ? Controller is probably
14484 + using the wrong IRQ" from hcd_unlink_urb() in drivers/usb/core/hcd.c */
14485 + set_bit(HCD_FLAG_SAW_IRQ, &reg->hcd->flags);
14486 +
14487 + DBFEXIT;
14488 +}
14489 +
14490 +
14491 +/******************************************************************/
14492 +/* Host Controller interface functions */
14493 +/******************************************************************/
14494 +
14495 +static inline void crisv10_ready_wait(void) {
14496 + volatile int timeout = 10000;
14497 + /* Check the busy bit of USB controller in Etrax */
14498 + while((*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)) &&
14499 + (timeout-- > 0));
14500 + if(timeout == 0) {
14501 + warn("Timeout while waiting for USB controller to be idle\n");
14502 + }
14503 +}
14504 +
14505 +/* reset host controller */
14506 +static int crisv10_hcd_reset(struct usb_hcd *hcd)
14507 +{
14508 + DBFENTER;
14509 + hcd_dbg(hcd, "reset\n");
14510 +
14511 +
14512 + /* Reset the USB interface. */
14513 + /*
14514 + *R_USB_COMMAND =
14515 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
14516 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
14517 + IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
14518 + nop();
14519 + */
14520 + DBFEXIT;
14521 + return 0;
14522 +}
14523 +
14524 +/* start host controller */
14525 +static int crisv10_hcd_start(struct usb_hcd *hcd)
14526 +{
14527 + DBFENTER;
14528 + hcd_dbg(hcd, "start\n");
14529 +
14530 + crisv10_ready_wait();
14531 +
14532 + /* Start processing of USB traffic. */
14533 + *R_USB_COMMAND =
14534 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
14535 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
14536 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
14537 +
14538 + nop();
14539 +
14540 + hcd->state = HC_STATE_RUNNING;
14541 +
14542 + DBFEXIT;
14543 + return 0;
14544 +}
14545 +
14546 +/* stop host controller */
14547 +static void crisv10_hcd_stop(struct usb_hcd *hcd)
14548 +{
14549 + DBFENTER;
14550 + hcd_dbg(hcd, "stop\n");
14551 + crisv10_hcd_reset(hcd);
14552 + DBFEXIT;
14553 +}
14554 +
14555 +/* return the current frame number */
14556 +static int crisv10_hcd_get_frame(struct usb_hcd *hcd)
14557 +{
14558 + DBFENTER;
14559 + DBFEXIT;
14560 + return (*R_USB_FM_NUMBER & 0x7ff);
14561 +}
14562 +
14563 +#ifdef CONFIG_USB_OTG
14564 +
14565 +static int crisv10_hcd_start_port_reset(struct usb_hcd *hcd, unsigned port)
14566 +{
14567 + return 0; /* no-op for now */
14568 +}
14569 +
14570 +#endif /* CONFIG_USB_OTG */
14571 +
14572 +
14573 +/******************************************************************/
14574 +/* Root Hub functions */
14575 +/******************************************************************/
14576 +
14577 +/* root hub status */
14578 +static const struct usb_hub_status rh_hub_status =
14579 + {
14580 + .wHubStatus = 0,
14581 + .wHubChange = 0,
14582 + };
14583 +
14584 +/* root hub descriptor */
14585 +static const u8 rh_hub_descr[] =
14586 + {
14587 + 0x09, /* bDescLength */
14588 + 0x29, /* bDescriptorType */
14589 + USB_ROOT_HUB_PORTS, /* bNbrPorts */
14590 + 0x00, /* wHubCharacteristics */
14591 + 0x00,
14592 + 0x01, /* bPwrOn2pwrGood */
14593 + 0x00, /* bHubContrCurrent */
14594 + 0x00, /* DeviceRemovable */
14595 + 0xff /* PortPwrCtrlMask */
14596 + };
14597 +
14598 +/* Actual holder of root hub status*/
14599 +struct crisv10_rh rh;
14600 +
14601 +/* Initialize root hub data structures (called from dvdrv_hcd_probe()) */
14602 +int rh_init(void) {
14603 + int i;
14604 + /* Reset port status flags */
14605 + for (i = 0; i < USB_ROOT_HUB_PORTS; i++) {
14606 + rh.wPortChange[i] = 0;
14607 + rh.wPortStatusPrev[i] = 0;
14608 + }
14609 + return 0;
14610 +}
14611 +
14612 +#define RH_FEAT_MASK ((1<<USB_PORT_FEAT_CONNECTION)|\
14613 + (1<<USB_PORT_FEAT_ENABLE)|\
14614 + (1<<USB_PORT_FEAT_SUSPEND)|\
14615 + (1<<USB_PORT_FEAT_RESET))
14616 +
14617 +/* Handle port status change interrupt (called from bottom part interrupt) */
14618 +void rh_port_status_change(__u16 port_reg[]) {
14619 + int i;
14620 + __u16 wChange;
14621 +
14622 + for(i = 0; i < USB_ROOT_HUB_PORTS; i++) {
14623 + /* Xor out changes since last read, masked for important flags */
14624 + wChange = (port_reg[i] & RH_FEAT_MASK) ^ rh.wPortStatusPrev[i];
14625 + /* Or changes together with (if any) saved changes */
14626 + rh.wPortChange[i] |= wChange;
14627 + /* Save new status */
14628 + rh.wPortStatusPrev[i] = port_reg[i];
14629 +
14630 + if(wChange) {
14631 + rh_dbg("Interrupt port_status change port%d: %s Current-status:%s\n", i+1,
14632 + port_status_to_str(wChange),
14633 + port_status_to_str(port_reg[i]));
14634 + }
14635 + }
14636 +}
14637 +
14638 +/* Construct port status change bitmap for the root hub */
14639 +static int rh_status_data_request(struct usb_hcd *hcd, char *buf)
14640 +{
14641 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
14642 + unsigned int i;
14643 +
14644 + DBFENTER;
14645 + /*
14646 + * corresponds to hub status change EP (USB 2.0 spec section 11.13.4)
14647 + * return bitmap indicating ports with status change
14648 + */
14649 + *buf = 0;
14650 + spin_lock(&crisv10_hcd->lock);
14651 + for (i = 1; i <= crisv10_hcd->num_ports; i++) {
14652 + if (rh.wPortChange[map_port(i)]) {
14653 + *buf |= (1 << i);
14654 + rh_dbg("rh_status_data_request, change on port %d: %s Current Status: %s\n", i,
14655 + port_status_to_str(rh.wPortChange[map_port(i)]),
14656 + port_status_to_str(rh.wPortStatusPrev[map_port(i)]));
14657 + }
14658 + }
14659 + spin_unlock(&crisv10_hcd->lock);
14660 + DBFEXIT;
14661 + return *buf == 0 ? 0 : 1;
14662 +}
14663 +
14664 +/* Handle a control request for the root hub (called from hcd_driver) */
14665 +static int rh_control_request(struct usb_hcd *hcd,
14666 + u16 typeReq,
14667 + u16 wValue,
14668 + u16 wIndex,
14669 + char *buf,
14670 + u16 wLength) {
14671 +
14672 + struct crisv10_hcd *crisv10_hcd = hcd_to_crisv10_hcd(hcd);
14673 + int retval = 0;
14674 + int len;
14675 + DBFENTER;
14676 +
14677 + switch (typeReq) {
14678 + case GetHubDescriptor:
14679 + rh_dbg("GetHubDescriptor\n");
14680 + len = min_t(unsigned int, sizeof rh_hub_descr, wLength);
14681 + memcpy(buf, rh_hub_descr, len);
14682 + buf[2] = crisv10_hcd->num_ports;
14683 + break;
14684 + case GetHubStatus:
14685 + rh_dbg("GetHubStatus\n");
14686 + len = min_t(unsigned int, sizeof rh_hub_status, wLength);
14687 + memcpy(buf, &rh_hub_status, len);
14688 + break;
14689 + case GetPortStatus:
14690 + if (!wIndex || wIndex > crisv10_hcd->num_ports)
14691 + goto error;
14692 + rh_dbg("GetportStatus, port:%d change:%s status:%s\n", wIndex,
14693 + port_status_to_str(rh.wPortChange[map_port(wIndex)]),
14694 + port_status_to_str(rh.wPortStatusPrev[map_port(wIndex)]));
14695 + *(u16 *) buf = cpu_to_le16(rh.wPortStatusPrev[map_port(wIndex)]);
14696 + *(u16 *) (buf + 2) = cpu_to_le16(rh.wPortChange[map_port(wIndex)]);
14697 + break;
14698 + case SetHubFeature:
14699 + rh_dbg("SetHubFeature\n");
14700 + case ClearHubFeature:
14701 + rh_dbg("ClearHubFeature\n");
14702 + switch (wValue) {
14703 + case C_HUB_OVER_CURRENT:
14704 + case C_HUB_LOCAL_POWER:
14705 + rh_warn("Not implemented hub request:%d \n", typeReq);
14706 + /* not implemented */
14707 + break;
14708 + default:
14709 + goto error;
14710 + }
14711 + break;
14712 + case SetPortFeature:
14713 + if (!wIndex || wIndex > crisv10_hcd->num_ports)
14714 + goto error;
14715 + if(rh_set_port_feature(map_port(wIndex), wValue))
14716 + goto error;
14717 + break;
14718 + case ClearPortFeature:
14719 + if (!wIndex || wIndex > crisv10_hcd->num_ports)
14720 + goto error;
14721 + if(rh_clear_port_feature(map_port(wIndex), wValue))
14722 + goto error;
14723 + break;
14724 + default:
14725 + rh_warn("Unknown hub request: %d\n", typeReq);
14726 + error:
14727 + retval = -EPIPE;
14728 + }
14729 + DBFEXIT;
14730 + return retval;
14731 +}
14732 +
14733 +int rh_set_port_feature(__u8 bPort, __u16 wFeature) {
14734 + __u8 bUsbCommand = 0;
14735 + switch(wFeature) {
14736 + case USB_PORT_FEAT_RESET:
14737 + rh_dbg("SetPortFeature: reset\n");
14738 + bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, reset);
14739 + goto set;
14740 + break;
14741 + case USB_PORT_FEAT_SUSPEND:
14742 + rh_dbg("SetPortFeature: suspend\n");
14743 + bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, suspend);
14744 + goto set;
14745 + break;
14746 + case USB_PORT_FEAT_POWER:
14747 + rh_dbg("SetPortFeature: power\n");
14748 + break;
14749 + case USB_PORT_FEAT_C_CONNECTION:
14750 + rh_dbg("SetPortFeature: c_connection\n");
14751 + break;
14752 + case USB_PORT_FEAT_C_RESET:
14753 + rh_dbg("SetPortFeature: c_reset\n");
14754 + break;
14755 + case USB_PORT_FEAT_C_OVER_CURRENT:
14756 + rh_dbg("SetPortFeature: c_over_current\n");
14757 + break;
14758 +
14759 + set:
14760 + /* Select which port via the port_sel field */
14761 + bUsbCommand |= IO_FIELD(R_USB_COMMAND, port_sel, bPort+1);
14762 +
14763 + /* Make sure the controller isn't busy. */
14764 + crisv10_ready_wait();
14765 + /* Send out the actual command to the USB controller */
14766 + *R_USB_COMMAND = bUsbCommand;
14767 +
14768 + /* If port reset then also bring USB controller into running state */
14769 + if(wFeature == USB_PORT_FEAT_RESET) {
14770 + /* Wait a while for controller to first become started after port reset */
14771 + udelay(12000); /* 12ms blocking wait */
14772 +
14773 + /* Make sure the controller isn't busy. */
14774 + crisv10_ready_wait();
14775 +
14776 + /* If all enabled ports were disabled the host controller goes down into
14777 + started mode, so we need to bring it back into the running state.
14778 + (This is safe even if it's already in the running state.) */
14779 + *R_USB_COMMAND =
14780 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
14781 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
14782 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
14783 + }
14784 +
14785 + break;
14786 + default:
14787 + rh_dbg("SetPortFeature: unknown feature\n");
14788 + return -1;
14789 + }
14790 + return 0;
14791 +}
14792 +
14793 +int rh_clear_port_feature(__u8 bPort, __u16 wFeature) {
14794 + switch(wFeature) {
14795 + case USB_PORT_FEAT_ENABLE:
14796 + rh_dbg("ClearPortFeature: enable\n");
14797 + rh_disable_port(bPort);
14798 + break;
14799 + case USB_PORT_FEAT_SUSPEND:
14800 + rh_dbg("ClearPortFeature: suspend\n");
14801 + break;
14802 + case USB_PORT_FEAT_POWER:
14803 + rh_dbg("ClearPortFeature: power\n");
14804 + break;
14805 +
14806 + case USB_PORT_FEAT_C_ENABLE:
14807 + rh_dbg("ClearPortFeature: c_enable\n");
14808 + goto clear;
14809 + case USB_PORT_FEAT_C_SUSPEND:
14810 + rh_dbg("ClearPortFeature: c_suspend\n");
14811 + goto clear;
14812 + case USB_PORT_FEAT_C_CONNECTION:
14813 + rh_dbg("ClearPortFeature: c_connection\n");
14814 + goto clear;
14815 + case USB_PORT_FEAT_C_OVER_CURRENT:
14816 + rh_dbg("ClearPortFeature: c_over_current\n");
14817 + goto clear;
14818 + case USB_PORT_FEAT_C_RESET:
14819 + rh_dbg("ClearPortFeature: c_reset\n");
14820 + goto clear;
14821 + clear:
14822 + rh.wPortChange[bPort] &= ~(1 << (wFeature - 16));
14823 + break;
14824 + default:
14825 + rh_dbg("ClearPortFeature: unknown feature\n");
14826 + return -1;
14827 + }
14828 + return 0;
14829 +}
14830 +
14831 +
14832 +#ifdef CONFIG_PM
14833 +/* Handle a suspend request for the root hub (called from hcd_driver) */
14834 +static int rh_suspend_request(struct usb_hcd *hcd)
14835 +{
14836 + return 0; /* no-op for now */
14837 +}
14838 +
14839 +/* Handle a resume request for the root hub (called from hcd_driver) */
14840 +static int rh_resume_request(struct usb_hcd *hcd)
14841 +{
14842 + return 0; /* no-op for now */
14843 +}
14844 +#endif /* CONFIG_PM */
14845 +
14846 +
14847 +
14848 +/* Wrapper function for workaround port disable registers in USB controller */
14849 +static void rh_disable_port(unsigned int port) {
14850 + volatile int timeout = 10000;
14851 + volatile char* usb_portx_disable;
14852 + switch(port) {
14853 + case 0:
14854 + usb_portx_disable = R_USB_PORT1_DISABLE;
14855 + break;
14856 + case 1:
14857 + usb_portx_disable = R_USB_PORT2_DISABLE;
14858 + break;
14859 + default:
14860 + /* Invalid port index */
14861 + return;
14862 + }
14863 + /* Set disable flag in special register */
14864 + *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
14865 + /* Wait until not enabled anymore */
14866 + while((rh.wPortStatusPrev[port] &
14867 + IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) &&
14868 + (timeout-- > 0));
14869 + if(timeout == 0) {
14870 + warn("Timeout while waiting for port %d to become disabled\n", port);
14871 + }
14872 + /* clear disable flag in special register */
14873 + *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
14874 + rh_info("Physical port %d disabled\n", port+1);
14875 +}
14876 +
14877 +
14878 +/******************************************************************/
14879 +/* Transfer Controller (TC) functions */
14880 +/******************************************************************/
14881 +
14882 +/* FIXME: Should RX_BUF_SIZE be a config option, or maybe we should adjust it
14883 + dynamically?
14884 + To adjust it dynamically we would have to get an interrupt when we reach
14885 + the end of the rx descriptor list, or when we get close to the end, and
14886 + then allocate more descriptors. */
14887 +#define NBR_OF_RX_DESC 512
14888 +#define RX_DESC_BUF_SIZE 1024
14889 +#define RX_BUF_SIZE (NBR_OF_RX_DESC * RX_DESC_BUF_SIZE)
14890 +
14891 +
14892 +/* Local variables for Transfer Controller */
14893 +/* --------------------------------------- */
14894 +
14895 +/* This is a circular (double-linked) list of the active urbs for each epid.
14896 + The head is never removed, and new urbs are linked onto the list as
14897 + urb_entry_t elements. Don't reference urb_list directly; use the wrapper
14898 + functions instead (which includes spin_locks) */
14899 +static struct list_head urb_list[NBR_OF_EPIDS];
14900 +
14901 +/* Read about the need and usage of this lock in submit_ctrl_urb. */
14902 +/* Lock for URB lists for each EPID */
14903 +static spinlock_t urb_list_lock;
14904 +
14905 +/* Lock for EPID array register (R_USB_EPT_x) in Etrax */
14906 +static spinlock_t etrax_epid_lock;
14907 +
14908 +/* Lock for dma8 sub0 handling */
14909 +static spinlock_t etrax_dma8_sub0_lock;
14910 +
14911 +/* DMA IN cache bug. Align the DMA IN buffers to 32 bytes, i.e. a cache line.
14912 + Since RX_DESC_BUF_SIZE is 1024 is a multiple of 32, all rx buffers will be
14913 + cache aligned. */
14914 +static volatile unsigned char RxBuf[RX_BUF_SIZE] __attribute__ ((aligned (32)));
14915 +static volatile struct USB_IN_Desc RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned (4)));
14916 +
14917 +/* Pointers into RxDescList. */
14918 +static volatile struct USB_IN_Desc *myNextRxDesc;
14919 +static volatile struct USB_IN_Desc *myLastRxDesc;
14920 +
14921 +/* A zout transfer makes a memory access at the address of its buf pointer,
14922 + which means that setting this buf pointer to 0 will cause an access to the
14923 + flash. In addition to this, setting sw_len to 0 results in a 16/32 bytes
14924 + (depending on DMA burst size) transfer.
14925 + Instead, we set it to 1, and point it to this buffer. */
14926 +static int zout_buffer[4] __attribute__ ((aligned (4)));
14927 +
14928 +/* Cache for allocating new EP and SB descriptors. */
14929 +static kmem_cache_t *usb_desc_cache;
14930 +
14931 +/* Cache for the data allocated in the isoc descr top half. */
14932 +static kmem_cache_t *isoc_compl_cache;
14933 +
14934 +/* Cache for the data allocated when delayed finishing of URBs */
14935 +static kmem_cache_t *later_data_cache;
14936 +
14937 +
14938 +/* Counter to keep track of how many Isoc EP we have sat up. Used to enable
14939 + and disable iso_eof interrupt. We only need these interrupts when we have
14940 + Isoc data endpoints (consumes CPU cycles).
14941 + FIXME: This could be more fine granular, so this interrupt is only enabled
14942 + when we have a In Isoc URB not URB_ISO_ASAP flaged queued. */
14943 +static int isoc_epid_counter;
14944 +
14945 +/* Protecting wrapper functions for R_USB_EPT_x */
14946 +/* -------------------------------------------- */
14947 +static inline void etrax_epid_set(__u8 index, __u32 data) {
14948 + unsigned long flags;
14949 + spin_lock_irqsave(&etrax_epid_lock, flags);
14950 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
14951 + nop();
14952 + *R_USB_EPT_DATA = data;
14953 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
14954 +}
14955 +
14956 +static inline void etrax_epid_clear_error(__u8 index) {
14957 + unsigned long flags;
14958 + spin_lock_irqsave(&etrax_epid_lock, flags);
14959 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
14960 + nop();
14961 + *R_USB_EPT_DATA &=
14962 + ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
14963 + IO_MASK(R_USB_EPT_DATA, error_count_out) |
14964 + IO_MASK(R_USB_EPT_DATA, error_code));
14965 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
14966 +}
14967 +
14968 +static inline void etrax_epid_set_toggle(__u8 index, __u8 dirout,
14969 + __u8 toggle) {
14970 + unsigned long flags;
14971 + spin_lock_irqsave(&etrax_epid_lock, flags);
14972 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
14973 + nop();
14974 + if(dirout) {
14975 + *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_out);
14976 + *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_out, toggle);
14977 + } else {
14978 + *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_in);
14979 + *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_in, toggle);
14980 + }
14981 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
14982 +}
14983 +
14984 +static inline __u8 etrax_epid_get_toggle(__u8 index, __u8 dirout) {
14985 + unsigned long flags;
14986 + __u8 toggle;
14987 + spin_lock_irqsave(&etrax_epid_lock, flags);
14988 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
14989 + nop();
14990 + if (dirout) {
14991 + toggle = IO_EXTRACT(R_USB_EPT_DATA, t_out, *R_USB_EPT_DATA);
14992 + } else {
14993 + toggle = IO_EXTRACT(R_USB_EPT_DATA, t_in, *R_USB_EPT_DATA);
14994 + }
14995 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
14996 + return toggle;
14997 +}
14998 +
14999 +
15000 +static inline __u32 etrax_epid_get(__u8 index) {
15001 + unsigned long flags;
15002 + __u32 data;
15003 + spin_lock_irqsave(&etrax_epid_lock, flags);
15004 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
15005 + nop();
15006 + data = *R_USB_EPT_DATA;
15007 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
15008 + return data;
15009 +}
15010 +
15011 +
15012 +
15013 +
15014 +/* Main functions for Transfer Controller */
15015 +/* -------------------------------------- */
15016 +
15017 +/* Init structs, memories and lists used by Transfer Controller */
15018 +int tc_init(struct usb_hcd *hcd) {
15019 + int i;
15020 + /* Clear software state info for all epids */
15021 + memset(epid_state, 0, sizeof(struct etrax_epid) * NBR_OF_EPIDS);
15022 +
15023 + /* Set Invalid and Dummy as being in use and disabled */
15024 + epid_state[INVALID_EPID].inuse = 1;
15025 + epid_state[DUMMY_EPID].inuse = 1;
15026 + epid_state[INVALID_EPID].disabled = 1;
15027 + epid_state[DUMMY_EPID].disabled = 1;
15028 +
15029 + /* Clear counter for how many Isoc epids we have sat up */
15030 + isoc_epid_counter = 0;
15031 +
15032 + /* Initialize the urb list by initiating a head for each list.
15033 + Also reset list hodling active URB for each epid */
15034 + for (i = 0; i < NBR_OF_EPIDS; i++) {
15035 + INIT_LIST_HEAD(&urb_list[i]);
15036 + activeUrbList[i] = NULL;
15037 + }
15038 +
15039 + /* Init lock for URB lists */
15040 + spin_lock_init(&urb_list_lock);
15041 + /* Init lock for Etrax R_USB_EPT register */
15042 + spin_lock_init(&etrax_epid_lock);
15043 + /* Init lock for Etrax dma8 sub0 handling */
15044 + spin_lock_init(&etrax_dma8_sub0_lock);
15045 +
15046 + /* We use kmem_cache_* to make sure that all DMA desc. are dword aligned */
15047 +
15048 + /* Note that we specify sizeof(struct USB_EP_Desc) as the size, but also
15049 + allocate SB descriptors from this cache. This is ok since
15050 + sizeof(struct USB_EP_Desc) == sizeof(struct USB_SB_Desc). */
15051 + usb_desc_cache = kmem_cache_create("usb_desc_cache",
15052 + sizeof(struct USB_EP_Desc), 0,
15053 + SLAB_HWCACHE_ALIGN, 0, 0);
15054 + if(usb_desc_cache == NULL) {
15055 + return -ENOMEM;
15056 + }
15057 +
15058 + /* Create slab cache for speedy allocation of memory for isoc bottom-half
15059 + interrupt handling */
15060 + isoc_compl_cache =
15061 + kmem_cache_create("isoc_compl_cache",
15062 + sizeof(struct crisv10_isoc_complete_data),
15063 + 0, SLAB_HWCACHE_ALIGN, 0, 0);
15064 + if(isoc_compl_cache == NULL) {
15065 + return -ENOMEM;
15066 + }
15067 +
15068 + /* Create slab cache for speedy allocation of memory for later URB finish
15069 + struct */
15070 + later_data_cache =
15071 + kmem_cache_create("later_data_cache",
15072 + sizeof(struct urb_later_data),
15073 + 0, SLAB_HWCACHE_ALIGN, 0, 0);
15074 + if(later_data_cache == NULL) {
15075 + return -ENOMEM;
15076 + }
15077 +
15078 +
15079 + /* Initiate the bulk start timer. */
15080 + init_timer(&bulk_start_timer);
15081 + bulk_start_timer.expires = jiffies + BULK_START_TIMER_INTERVAL;
15082 + bulk_start_timer.function = tc_bulk_start_timer_func;
15083 + add_timer(&bulk_start_timer);
15084 +
15085 +
15086 + /* Initiate the bulk eot timer. */
15087 + init_timer(&bulk_eot_timer);
15088 + bulk_eot_timer.expires = jiffies + BULK_EOT_TIMER_INTERVAL;
15089 + bulk_eot_timer.function = tc_bulk_eot_timer_func;
15090 + bulk_eot_timer.data = (unsigned long)hcd;
15091 + add_timer(&bulk_eot_timer);
15092 +
15093 + return 0;
15094 +}
15095 +
15096 +/* Uninitialize all resources used by Transfer Controller */
15097 +void tc_destroy(void) {
15098 +
15099 + /* Destroy all slab cache */
15100 + kmem_cache_destroy(usb_desc_cache);
15101 + kmem_cache_destroy(isoc_compl_cache);
15102 + kmem_cache_destroy(later_data_cache);
15103 +
15104 + /* Remove timers */
15105 + del_timer(&bulk_start_timer);
15106 + del_timer(&bulk_eot_timer);
15107 +}
15108 +
15109 +static void restart_dma8_sub0(void) {
15110 + unsigned long flags;
15111 + spin_lock_irqsave(&etrax_dma8_sub0_lock, flags);
15112 + /* Verify that the dma is not running */
15113 + if ((*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd)) == 0) {
15114 + struct USB_EP_Desc *ep = (struct USB_EP_Desc *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
15115 + while (DUMMY_EPID == IO_EXTRACT(USB_EP_command, epid, ep->command)) {
15116 + ep = (struct USB_EP_Desc *)phys_to_virt(ep->next);
15117 + }
15118 + /* Advance the DMA to the next EP descriptor that is not a DUMMY_EPID.
15119 + * ep->next is already a physical address; no need for a virt_to_phys. */
15120 + *R_DMA_CH8_SUB0_EP = ep->next;
15121 + /* Restart the DMA */
15122 + *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
15123 + }
15124 + spin_unlock_irqrestore(&etrax_dma8_sub0_lock, flags);
15125 +}
15126 +
15127 +/* queue an URB with the transfer controller (called from hcd_driver) */
15128 +static int tc_urb_enqueue(struct usb_hcd *hcd,
15129 + struct usb_host_endpoint *ep,
15130 + struct urb *urb,
15131 + gfp_t mem_flags) {
15132 + int epid;
15133 + int retval;
15134 + int bustime = 0;
15135 + int maxpacket;
15136 + unsigned long flags;
15137 + struct crisv10_urb_priv *urb_priv;
15138 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
15139 + DBFENTER;
15140 +
15141 + if(!(crisv10_hcd->running)) {
15142 + /* The USB Controller is not running, probably because no device is
15143 + attached. No idea to enqueue URBs then */
15144 + tc_warn("Rejected enqueueing of URB:0x%x because no dev attached\n",
15145 + (unsigned int)urb);
15146 + return -ENOENT;
15147 + }
15148 +
15149 + maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
15150 + /* Special case check for In Isoc transfers. Specification states that each
15151 + In Isoc transfer consists of one packet and therefore it should fit into
15152 + the transfer-buffer of an URB.
15153 + We do the check here to be sure (an invalid scenario can be produced with
15154 + parameters to the usbtest suite) */
15155 + if(usb_pipeisoc(urb->pipe) && usb_pipein(urb->pipe) &&
15156 + (urb->transfer_buffer_length < maxpacket)) {
15157 + tc_err("Submit In Isoc URB with buffer length:%d to pipe with maxpacketlen: %d\n", urb->transfer_buffer_length, maxpacket);
15158 + return -EMSGSIZE;
15159 + }
15160 +
15161 + /* Check if there is enough bandwidth for periodic transfer */
15162 + if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe)) {
15163 + /* only check (and later claim) if not already claimed */
15164 + if (urb->bandwidth == 0) {
15165 + bustime = usb_check_bandwidth(urb->dev, urb);
15166 + if (bustime < 0) {
15167 + tc_err("Not enough periodic bandwidth\n");
15168 + return -ENOSPC;
15169 + }
15170 + }
15171 + }
15172 +
15173 + /* Check if there is a epid for URBs destination, if not this function
15174 + set up one. */
15175 + epid = tc_setup_epid(ep, urb, mem_flags);
15176 + if (epid < 0) {
15177 + tc_err("Failed setup epid:%d for URB:0x%x\n", epid, (unsigned int)urb);
15178 + DBFEXIT;
15179 + return -ENOMEM;
15180 + }
15181 +
15182 + if(urb == activeUrbList[epid]) {
15183 + tc_err("Resubmition of allready active URB:0x%x\n", (unsigned int)urb);
15184 + return -ENXIO;
15185 + }
15186 +
15187 + if(urb_list_entry(urb, epid)) {
15188 + tc_err("Resubmition of allready queued URB:0x%x\n", (unsigned int)urb);
15189 + return -ENXIO;
15190 + }
15191 +
15192 + /* If we actively have flaged endpoint as disabled then refuse submition */
15193 + if(epid_state[epid].disabled) {
15194 + return -ENOENT;
15195 + }
15196 +
15197 + /* Allocate and init HC-private data for URB */
15198 + if(urb_priv_create(hcd, urb, epid, mem_flags) != 0) {
15199 + DBFEXIT;
15200 + return -ENOMEM;
15201 + }
15202 + urb_priv = urb->hcpriv;
15203 +
15204 + tc_dbg("Enqueue URB:0x%x[%d] epid:%d (%s) bufflen:%d\n",
15205 + (unsigned int)urb, urb_priv->urb_num, epid,
15206 + pipe_to_str(urb->pipe), urb->transfer_buffer_length);
15207 +
15208 + /* Create and link SBs required for this URB */
15209 + retval = create_sb_for_urb(urb, mem_flags);
15210 + if(retval != 0) {
15211 + tc_err("Failed to create SBs for URB:0x%x[%d]\n", (unsigned int)urb,
15212 + urb_priv->urb_num);
15213 + urb_priv_free(hcd, urb);
15214 + DBFEXIT;
15215 + return retval;
15216 + }
15217 +
15218 + /* Init intr EP pool if this URB is a INTR transfer. This pool is later
15219 + used when inserting EPs in the TxIntrEPList. We do the alloc here
15220 + so we can't run out of memory later */
15221 + if(usb_pipeint(urb->pipe)) {
15222 + retval = init_intr_urb(urb, mem_flags);
15223 + if(retval != 0) {
15224 + tc_warn("Failed to init Intr URB\n");
15225 + urb_priv_free(hcd, urb);
15226 + DBFEXIT;
15227 + return retval;
15228 + }
15229 + }
15230 +
15231 + /* Disable other access when inserting USB */
15232 + local_irq_save(flags);
15233 +
15234 + /* Claim bandwidth, if needed */
15235 + if(bustime) {
15236 + usb_claim_bandwidth(urb->dev, urb, bustime, 0);
15237 + }
15238 +
15239 + /* Add URB to EP queue */
15240 + urb_list_add(urb, epid, mem_flags);
15241 +
15242 + if(usb_pipeisoc(urb->pipe)) {
15243 + /* Special processing of Isoc URBs. */
15244 + tc_dma_process_isoc_urb(urb);
15245 + } else {
15246 + /* Process EP queue for rest of the URB types (Bulk, Ctrl, Intr) */
15247 + tc_dma_process_queue(epid);
15248 + }
15249 +
15250 + local_irq_restore(flags);
15251 +
15252 + DBFEXIT;
15253 + return 0;
15254 +}
15255 +
15256 +/* remove an URB from the transfer controller queues (called from hcd_driver)*/
15257 +static int tc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb) {
15258 + struct crisv10_urb_priv *urb_priv;
15259 + unsigned long flags;
15260 + int epid;
15261 +
15262 + DBFENTER;
15263 + /* Disable interrupts here since a descriptor interrupt for the isoc epid
15264 + will modify the sb list. This could possibly be done more granular, but
15265 + urb_dequeue should not be used frequently anyway.
15266 + */
15267 + local_irq_save(flags);
15268 +
15269 + urb_priv = urb->hcpriv;
15270 +
15271 + if (!urb_priv) {
15272 + /* This happens if a device driver calls unlink on an urb that
15273 + was never submitted (lazy driver) or if the urb was completed
15274 + while dequeue was being called. */
15275 + tc_warn("Dequeing of not enqueued URB:0x%x\n", (unsigned int)urb);
15276 + local_irq_restore(flags);
15277 + return 0;
15278 + }
15279 + epid = urb_priv->epid;
15280 +
15281 + tc_warn("Dequeing %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
15282 + (urb == activeUrbList[epid]) ? "active" : "queued",
15283 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
15284 + str_type(urb->pipe), epid, urb->status,
15285 + (urb_priv->later_data) ? "later-sched" : "");
15286 +
15287 + /* For Bulk, Ctrl and Intr are only one URB active at a time. So any URB
15288 + that isn't active can be dequeued by just removing it from the queue */
15289 + if(usb_pipebulk(urb->pipe) || usb_pipecontrol(urb->pipe) ||
15290 + usb_pipeint(urb->pipe)) {
15291 +
15292 + /* Check if URB haven't gone further than the queue */
15293 + if(urb != activeUrbList[epid]) {
15294 + ASSERT(urb_priv->later_data == NULL);
15295 + tc_warn("Dequeing URB:0x%x[%d] (%s %s epid:%d) from queue"
15296 + " (not active)\n", (unsigned int)urb, urb_priv->urb_num,
15297 + str_dir(urb->pipe), str_type(urb->pipe), epid);
15298 +
15299 + /* Finish the URB with error status from USB core */
15300 + tc_finish_urb(hcd, urb, urb->status);
15301 + local_irq_restore(flags);
15302 + return 0;
15303 + }
15304 + }
15305 +
15306 + /* Set URB status to Unlink for handling when interrupt comes. */
15307 + urb_priv->urb_state = UNLINK;
15308 +
15309 + /* Differentiate dequeing of Bulk and Ctrl from Isoc and Intr */
15310 + switch(usb_pipetype(urb->pipe)) {
15311 + case PIPE_BULK:
15312 + /* Check if EP still is enabled */
15313 + if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
15314 + /* The EP was enabled, disable it. */
15315 + TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
15316 + }
15317 + /* Kicking dummy list out of the party. */
15318 + TxBulkEPList[epid].next = virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
15319 + break;
15320 + case PIPE_CONTROL:
15321 + /* Check if EP still is enabled */
15322 + if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
15323 + /* The EP was enabled, disable it. */
15324 + TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
15325 + }
15326 + break;
15327 + case PIPE_ISOCHRONOUS:
15328 + /* Disabling, busy-wait and unlinking of Isoc SBs will be done in
15329 + finish_isoc_urb(). Because there might the case when URB is dequeued
15330 + but there are other valid URBs waiting */
15331 +
15332 + /* Check if In Isoc EP still is enabled */
15333 + if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
15334 + /* The EP was enabled, disable it. */
15335 + TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
15336 + }
15337 + break;
15338 + case PIPE_INTERRUPT:
15339 + /* Special care is taken for interrupt URBs. EPs are unlinked in
15340 + tc_finish_urb */
15341 + break;
15342 + default:
15343 + break;
15344 + }
15345 +
15346 + /* Asynchronous unlink, finish the URB later from scheduled or other
15347 + event (data finished, error) */
15348 + tc_finish_urb_later(hcd, urb, urb->status);
15349 +
15350 + local_irq_restore(flags);
15351 + DBFEXIT;
15352 + return 0;
15353 +}
15354 +
15355 +
15356 +static void tc_sync_finish_epid(struct usb_hcd *hcd, int epid) {
15357 + volatile int timeout = 10000;
15358 + struct urb* urb;
15359 + struct crisv10_urb_priv* urb_priv;
15360 + unsigned long flags;
15361 +
15362 + volatile struct USB_EP_Desc *first_ep; /* First EP in the list. */
15363 + volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
15364 + volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
15365 +
15366 + int type = epid_state[epid].type;
15367 +
15368 + /* Setting this flag will cause enqueue() to return -ENOENT for new
15369 + submitions on this endpoint and finish_urb() wont process queue further */
15370 + epid_state[epid].disabled = 1;
15371 +
15372 + switch(type) {
15373 + case PIPE_BULK:
15374 + /* Check if EP still is enabled */
15375 + if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
15376 + /* The EP was enabled, disable it. */
15377 + TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
15378 + tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
15379 +
15380 + /* Do busy-wait until DMA not using this EP descriptor anymore */
15381 + while((*R_DMA_CH8_SUB0_EP ==
15382 + virt_to_phys(&TxBulkEPList[epid])) &&
15383 + (timeout-- > 0));
15384 + if(timeout == 0) {
15385 + warn("Timeout while waiting for DMA-TX-Bulk to leave EP for"
15386 + " epid:%d\n", epid);
15387 + }
15388 + }
15389 + break;
15390 +
15391 + case PIPE_CONTROL:
15392 + /* Check if EP still is enabled */
15393 + if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
15394 + /* The EP was enabled, disable it. */
15395 + TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
15396 + tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
15397 +
15398 + /* Do busy-wait until DMA not using this EP descriptor anymore */
15399 + while((*R_DMA_CH8_SUB1_EP ==
15400 + virt_to_phys(&TxCtrlEPList[epid])) &&
15401 + (timeout-- > 0));
15402 + if(timeout == 0) {
15403 + warn("Timeout while waiting for DMA-TX-Ctrl to leave EP for"
15404 + " epid:%d\n", epid);
15405 + }
15406 + }
15407 + break;
15408 +
15409 + case PIPE_INTERRUPT:
15410 + local_irq_save(flags);
15411 + /* Disable all Intr EPs belonging to epid */
15412 + first_ep = &TxIntrEPList[0];
15413 + curr_ep = first_ep;
15414 + do {
15415 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
15416 + if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
15417 + /* Disable EP */
15418 + next_ep->command &= ~IO_MASK(USB_EP_command, enable);
15419 + }
15420 + curr_ep = phys_to_virt(curr_ep->next);
15421 + } while (curr_ep != first_ep);
15422 +
15423 + local_irq_restore(flags);
15424 + break;
15425 +
15426 + case PIPE_ISOCHRONOUS:
15427 + /* Check if EP still is enabled */
15428 + if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
15429 + tc_warn("sync_finish: Disabling Isoc EP for epid:%d\n", epid);
15430 + /* The EP was enabled, disable it. */
15431 + TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
15432 +
15433 + while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
15434 + (timeout-- > 0));
15435 + if(timeout == 0) {
15436 + warn("Timeout while waiting for DMA-TX-Isoc to leave EP for"
15437 + " epid:%d\n", epid);
15438 + }
15439 + }
15440 + break;
15441 + }
15442 +
15443 + local_irq_save(flags);
15444 +
15445 + /* Finish if there is active URB for this endpoint */
15446 + if(activeUrbList[epid] != NULL) {
15447 + urb = activeUrbList[epid];
15448 + urb_priv = urb->hcpriv;
15449 + ASSERT(urb_priv);
15450 + tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
15451 + (urb == activeUrbList[epid]) ? "active" : "queued",
15452 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
15453 + str_type(urb->pipe), epid, urb->status,
15454 + (urb_priv->later_data) ? "later-sched" : "");
15455 +
15456 + tc_finish_urb(hcd, activeUrbList[epid], -ENOENT);
15457 + ASSERT(activeUrbList[epid] == NULL);
15458 + }
15459 +
15460 + /* Finish any queued URBs for this endpoint. There won't be any resubmitions
15461 + because epid_disabled causes enqueue() to fail for this endpoint */
15462 + while((urb = urb_list_first(epid)) != NULL) {
15463 + urb_priv = urb->hcpriv;
15464 + ASSERT(urb_priv);
15465 +
15466 + tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
15467 + (urb == activeUrbList[epid]) ? "active" : "queued",
15468 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
15469 + str_type(urb->pipe), epid, urb->status,
15470 + (urb_priv->later_data) ? "later-sched" : "");
15471 +
15472 + tc_finish_urb(hcd, urb, -ENOENT);
15473 + }
15474 + epid_state[epid].disabled = 0;
15475 + local_irq_restore(flags);
15476 +}
15477 +
15478 +/* free resources associated with an endpoint (called from hcd_driver) */
15479 +static void tc_endpoint_disable(struct usb_hcd *hcd,
15480 + struct usb_host_endpoint *ep) {
15481 + DBFENTER;
15482 + /* Only free epid if it has been allocated. We get two endpoint_disable
15483 + requests for ctrl endpoints so ignore the second one */
15484 + if(ep->hcpriv != NULL) {
15485 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
15486 + int epid = ep_priv->epid;
15487 + tc_warn("endpoint_disable ep:0x%x ep-priv:0x%x (%s) (epid:%d freed)\n",
15488 + (unsigned int)ep, (unsigned int)ep->hcpriv,
15489 + endpoint_to_str(&(ep->desc)), epid);
15490 +
15491 + tc_sync_finish_epid(hcd, epid);
15492 +
15493 + ASSERT(activeUrbList[epid] == NULL);
15494 + ASSERT(list_empty(&urb_list[epid]));
15495 +
15496 + tc_free_epid(ep);
15497 + } else {
15498 + tc_dbg("endpoint_disable ep:0x%x ep-priv:0x%x (%s)\n", (unsigned int)ep,
15499 + (unsigned int)ep->hcpriv, endpoint_to_str(&(ep->desc)));
15500 + }
15501 + DBFEXIT;
15502 +}
15503 +
15504 +static void tc_finish_urb_later_proc(void *data) {
15505 + unsigned long flags;
15506 + struct urb_later_data* uld = (struct urb_later_data*)data;
15507 + local_irq_save(flags);
15508 + if(uld->urb == NULL) {
15509 + late_dbg("Later finish of URB = NULL (allready finished)\n");
15510 + } else {
15511 + struct crisv10_urb_priv* urb_priv = uld->urb->hcpriv;
15512 + ASSERT(urb_priv);
15513 + if(urb_priv->urb_num == uld->urb_num) {
15514 + late_dbg("Later finish of URB:0x%x[%d]\n", (unsigned int)(uld->urb),
15515 + urb_priv->urb_num);
15516 + if(uld->status != uld->urb->status) {
15517 + errno_dbg("Later-finish URB with status:%d, later-status:%d\n",
15518 + uld->urb->status, uld->status);
15519 + }
15520 + if(uld != urb_priv->later_data) {
15521 + panic("Scheduled uld not same as URBs uld\n");
15522 + }
15523 + tc_finish_urb(uld->hcd, uld->urb, uld->status);
15524 + } else {
15525 + late_warn("Ignoring later finish of URB:0x%x[%d]"
15526 + ", urb_num doesn't match current URB:0x%x[%d]",
15527 + (unsigned int)(uld->urb), uld->urb_num,
15528 + (unsigned int)(uld->urb), urb_priv->urb_num);
15529 + }
15530 + }
15531 + local_irq_restore(flags);
15532 + kmem_cache_free(later_data_cache, uld);
15533 +}
15534 +
15535 +static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
15536 + int status) {
15537 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
15538 + struct urb_later_data* uld;
15539 +
15540 + ASSERT(urb_priv);
15541 +
15542 + if(urb_priv->later_data != NULL) {
15543 + /* Later-finish allready scheduled for this URB, just update status to
15544 + return when finishing later */
15545 + errno_dbg("Later-finish schedule change URB status:%d with new"
15546 + " status:%d\n", urb_priv->later_data->status, status);
15547 +
15548 + urb_priv->later_data->status = status;
15549 + return;
15550 + }
15551 +
15552 + uld = kmem_cache_alloc(later_data_cache, SLAB_ATOMIC);
15553 + ASSERT(uld);
15554 +
15555 + uld->hcd = hcd;
15556 + uld->urb = urb;
15557 + uld->urb_num = urb_priv->urb_num;
15558 + uld->status = status;
15559 +
15560 + INIT_WORK(&uld->ws, tc_finish_urb_later_proc, uld);
15561 + urb_priv->later_data = uld;
15562 +
15563 + /* Schedule the finishing of the URB to happen later */
15564 + schedule_delayed_work(&uld->ws, LATER_TIMER_DELAY);
15565 +}
15566 +
15567 +static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
15568 + int status);
15569 +
15570 +static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status) {
15571 + struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
15572 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
15573 + int epid;
15574 + char toggle;
15575 + int urb_num;
15576 +
15577 + DBFENTER;
15578 + ASSERT(urb_priv != NULL);
15579 + epid = urb_priv->epid;
15580 + urb_num = urb_priv->urb_num;
15581 +
15582 + if(urb != activeUrbList[epid]) {
15583 + if(urb_list_entry(urb, epid)) {
15584 + /* Remove this URB from the list. Only happens when URB are finished
15585 + before having been processed (dequeing) */
15586 + urb_list_del(urb, epid);
15587 + } else {
15588 + tc_warn("Finishing of URB:0x%x[%d] neither active or in queue for"
15589 + " epid:%d\n", (unsigned int)urb, urb_num, epid);
15590 + }
15591 + }
15592 +
15593 + /* Cancel any pending later-finish of this URB */
15594 + if(urb_priv->later_data) {
15595 + urb_priv->later_data->urb = NULL;
15596 + }
15597 +
15598 + /* For an IN pipe, we always set the actual length, regardless of whether
15599 + there was an error or not (which means the device driver can use the data
15600 + if it wants to). */
15601 + if(usb_pipein(urb->pipe)) {
15602 + urb->actual_length = urb_priv->rx_offset;
15603 + } else {
15604 + /* Set actual_length for OUT urbs also; the USB mass storage driver seems
15605 + to want that. */
15606 + if (status == 0 && urb->status == -EINPROGRESS) {
15607 + urb->actual_length = urb->transfer_buffer_length;
15608 + } else {
15609 + /* We wouldn't know of any partial writes if there was an error. */
15610 + urb->actual_length = 0;
15611 + }
15612 + }
15613 +
15614 +
15615 + /* URB status mangling */
15616 + if(urb->status == -EINPROGRESS) {
15617 + /* The USB core hasn't changed the status, let's set our finish status */
15618 + urb->status = status;
15619 +
15620 + if ((status == 0) && (urb->transfer_flags & URB_SHORT_NOT_OK) &&
15621 + usb_pipein(urb->pipe) &&
15622 + (urb->actual_length != urb->transfer_buffer_length)) {
15623 + /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's
15624 + max length) is to be treated as an error. */
15625 + errno_dbg("Finishing URB:0x%x[%d] with SHORT_NOT_OK flag and short"
15626 + " data:%d\n", (unsigned int)urb, urb_num,
15627 + urb->actual_length);
15628 + urb->status = -EREMOTEIO;
15629 + }
15630 +
15631 + if(urb_priv->urb_state == UNLINK) {
15632 + /* URB has been requested to be unlinked asynchronously */
15633 + urb->status = -ECONNRESET;
15634 + errno_dbg("Fixing unlink status of URB:0x%x[%d] to:%d\n",
15635 + (unsigned int)urb, urb_num, urb->status);
15636 + }
15637 + } else {
15638 + /* The USB Core wants to signal some error via the URB, pass it through */
15639 + }
15640 +
15641 + /* use completely different finish function for Isoc URBs */
15642 + if(usb_pipeisoc(urb->pipe)) {
15643 + tc_finish_isoc_urb(hcd, urb, status);
15644 + return;
15645 + }
15646 +
15647 + /* Do special unlinking of EPs for Intr traffic */
15648 + if(usb_pipeint(urb->pipe)) {
15649 + tc_dma_unlink_intr_urb(urb);
15650 + }
15651 +
15652 + /* Release allocated bandwidth for periodic transfers */
15653 + if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe))
15654 + usb_release_bandwidth(urb->dev, urb, 0);
15655 +
15656 + /* This URB is active on EP */
15657 + if(urb == activeUrbList[epid]) {
15658 + /* We need to fiddle with the toggle bits because the hardware doesn't do
15659 + it for us. */
15660 + toggle = etrax_epid_get_toggle(epid, usb_pipeout(urb->pipe));
15661 + usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
15662 + usb_pipeout(urb->pipe), toggle);
15663 +
15664 + /* Checks for Ctrl and Bulk EPs */
15665 + switch(usb_pipetype(urb->pipe)) {
15666 + case PIPE_BULK:
15667 + /* Check so Bulk EP realy is disabled before finishing active URB */
15668 + ASSERT((TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
15669 + IO_STATE(USB_EP_command, enable, no));
15670 + /* Disable sub-pointer for EP to avoid next tx_interrupt() to
15671 + process Bulk EP. */
15672 + TxBulkEPList[epid].sub = 0;
15673 + /* No need to wait for the DMA before changing the next pointer.
15674 + The modulo NBR_OF_EPIDS isn't actually necessary, since we will never use
15675 + the last one (INVALID_EPID) for actual traffic. */
15676 + TxBulkEPList[epid].next =
15677 + virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
15678 + break;
15679 + case PIPE_CONTROL:
15680 + /* Check so Ctrl EP realy is disabled before finishing active URB */
15681 + ASSERT((TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
15682 + IO_STATE(USB_EP_command, enable, no));
15683 + /* Disable sub-pointer for EP to avoid next tx_interrupt() to
15684 + process Ctrl EP. */
15685 + TxCtrlEPList[epid].sub = 0;
15686 + break;
15687 + }
15688 + }
15689 +
15690 + /* Free HC-private URB data*/
15691 + urb_priv_free(hcd, urb);
15692 +
15693 + if(urb->status) {
15694 + errno_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
15695 + (unsigned int)urb, urb_num, str_dir(urb->pipe),
15696 + str_type(urb->pipe), urb->actual_length, urb->status);
15697 + } else {
15698 + tc_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
15699 + (unsigned int)urb, urb_num, str_dir(urb->pipe),
15700 + str_type(urb->pipe), urb->actual_length, urb->status);
15701 + }
15702 +
15703 + /* If we just finished an active URB, clear active pointer. */
15704 + if (urb == activeUrbList[epid]) {
15705 + /* Make URB not active on EP anymore */
15706 + activeUrbList[epid] = NULL;
15707 +
15708 + if(urb->status == 0) {
15709 + /* URB finished sucessfully, process queue to see if there are any more
15710 + URBs waiting before we call completion function.*/
15711 + if(crisv10_hcd->running) {
15712 + /* Only process queue if USB controller is running */
15713 + tc_dma_process_queue(epid);
15714 + } else {
15715 + tc_warn("No processing of queue for epid:%d, USB Controller not"
15716 + " running\n", epid);
15717 + }
15718 + }
15719 + }
15720 +
15721 + /* Hand the URB from HCD to its USB device driver, using its completion
15722 + functions */
15723 + usb_hcd_giveback_urb (hcd, urb);
15724 +
15725 + /* Check the queue once more if the URB returned with error, because we
15726 + didn't do it before the completion function because the specification
15727 + states that the queue should not restart until all it's unlinked
15728 + URBs have been fully retired, with the completion functions run */
15729 + if(crisv10_hcd->running) {
15730 + /* Only process queue if USB controller is running */
15731 + tc_dma_process_queue(epid);
15732 + } else {
15733 + tc_warn("No processing of queue for epid:%d, USB Controller not running\n",
15734 + epid);
15735 + }
15736 +
15737 + DBFEXIT;
15738 +}
15739 +
15740 +static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
15741 + int status) {
15742 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
15743 + int epid, i;
15744 + volatile int timeout = 10000;
15745 +
15746 + ASSERT(urb_priv);
15747 + epid = urb_priv->epid;
15748 +
15749 + ASSERT(usb_pipeisoc(urb->pipe));
15750 +
15751 + /* Set that all isoc packets have status and length set before
15752 + completing the urb. */
15753 + for (i = urb_priv->isoc_packet_counter; i < urb->number_of_packets; i++){
15754 + urb->iso_frame_desc[i].actual_length = 0;
15755 + urb->iso_frame_desc[i].status = -EPROTO;
15756 + }
15757 +
15758 + /* Check if the URB is currently active (done or error) */
15759 + if(urb == activeUrbList[epid]) {
15760 + /* Check if there are another In Isoc URB queued for this epid */
15761 + if (!list_empty(&urb_list[epid])&& !epid_state[epid].disabled) {
15762 + /* Move it from queue to active and mark it started so Isoc transfers
15763 + won't be interrupted.
15764 + All Isoc URBs data transfers are already added to DMA lists so we
15765 + don't have to insert anything in DMA lists here. */
15766 + activeUrbList[epid] = urb_list_first(epid);
15767 + ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_state =
15768 + STARTED;
15769 + urb_list_del(activeUrbList[epid], epid);
15770 +
15771 + if(urb->status) {
15772 + errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
15773 + " status:%d, new waiting URB:0x%x[%d]\n",
15774 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
15775 + str_type(urb->pipe), urb_priv->isoc_packet_counter,
15776 + urb->number_of_packets, urb->status,
15777 + (unsigned int)activeUrbList[epid],
15778 + ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_num);
15779 + }
15780 +
15781 + } else { /* No other URB queued for this epid */
15782 + if(urb->status) {
15783 + errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
15784 + " status:%d, no new URB waiting\n",
15785 + (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
15786 + str_type(urb->pipe), urb_priv->isoc_packet_counter,
15787 + urb->number_of_packets, urb->status);
15788 + }
15789 +
15790 + /* Check if EP is still enabled, then shut it down. */
15791 + if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
15792 + isoc_dbg("Isoc EP enabled for epid:%d, disabling it\n", epid);
15793 +
15794 + /* Should only occur for In Isoc EPs where SB isn't consumed. */
15795 + ASSERT(usb_pipein(urb->pipe));
15796 +
15797 + /* Disable it and wait for it to stop */
15798 + TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
15799 +
15800 + /* Ah, the luxury of busy-wait. */
15801 + while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
15802 + (timeout-- > 0));
15803 + if(timeout == 0) {
15804 + warn("Timeout while waiting for DMA-TX-Isoc to leave EP for epid:%d\n", epid);
15805 + }
15806 + }
15807 +
15808 + /* Unlink SB to say that epid is finished. */
15809 + TxIsocEPList[epid].sub = 0;
15810 + TxIsocEPList[epid].hw_len = 0;
15811 +
15812 + /* No URB active for EP anymore */
15813 + activeUrbList[epid] = NULL;
15814 + }
15815 + } else { /* Finishing of not active URB (queued up with SBs thought) */
15816 + isoc_warn("finish_isoc_urb (URB:0x%x %s) (%d of %d packets) status:%d,"
15817 + " SB queued but not active\n",
15818 + (unsigned int)urb, str_dir(urb->pipe),
15819 + urb_priv->isoc_packet_counter, urb->number_of_packets,
15820 + urb->status);
15821 + if(usb_pipeout(urb->pipe)) {
15822 + /* Finishing of not yet active Out Isoc URB needs unlinking of SBs. */
15823 + struct USB_SB_Desc *iter_sb, *prev_sb, *next_sb;
15824 +
15825 + iter_sb = TxIsocEPList[epid].sub ?
15826 + phys_to_virt(TxIsocEPList[epid].sub) : 0;
15827 + prev_sb = 0;
15828 +
15829 + /* SB that is linked before this URBs first SB */
15830 + while (iter_sb && (iter_sb != urb_priv->first_sb)) {
15831 + prev_sb = iter_sb;
15832 + iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
15833 + }
15834 +
15835 + if (iter_sb == 0) {
15836 + /* Unlink of the URB currently being transmitted. */
15837 + prev_sb = 0;
15838 + iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
15839 + }
15840 +
15841 + while (iter_sb && (iter_sb != urb_priv->last_sb)) {
15842 + iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
15843 + }
15844 +
15845 + if (iter_sb) {
15846 + next_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
15847 + } else {
15848 + /* This should only happen if the DMA has completed
15849 + processing the SB list for this EP while interrupts
15850 + are disabled. */
15851 + isoc_dbg("Isoc urb not found, already sent?\n");
15852 + next_sb = 0;
15853 + }
15854 + if (prev_sb) {
15855 + prev_sb->next = next_sb ? virt_to_phys(next_sb) : 0;
15856 + } else {
15857 + TxIsocEPList[epid].sub = next_sb ? virt_to_phys(next_sb) : 0;
15858 + }
15859 + }
15860 + }
15861 +
15862 + /* Free HC-private URB data*/
15863 + urb_priv_free(hcd, urb);
15864 +
15865 + usb_release_bandwidth(urb->dev, urb, 0);
15866 +
15867 + /* Hand the URB from HCD to its USB device driver, using its completion
15868 + functions */
15869 + usb_hcd_giveback_urb (hcd, urb);
15870 +}
15871 +
15872 +static __u32 urb_num = 0;
15873 +
15874 +/* allocate and initialize URB private data */
15875 +static int urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
15876 + int mem_flags) {
15877 + struct crisv10_urb_priv *urb_priv;
15878 +
15879 + urb_priv = kmalloc(sizeof *urb_priv, mem_flags);
15880 + if (!urb_priv)
15881 + return -ENOMEM;
15882 + memset(urb_priv, 0, sizeof *urb_priv);
15883 +
15884 + urb_priv->epid = epid;
15885 + urb_priv->urb_state = NOT_STARTED;
15886 +
15887 + urb->hcpriv = urb_priv;
15888 + /* Assign URB a sequence number, and increment counter */
15889 + urb_priv->urb_num = urb_num;
15890 + urb_num++;
15891 + return 0;
15892 +}
15893 +
15894 +/* free URB private data */
15895 +static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb) {
15896 + int i;
15897 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
15898 + ASSERT(urb_priv != 0);
15899 +
15900 + /* Check it has any SBs linked that needs to be freed*/
15901 + if(urb_priv->first_sb != NULL) {
15902 + struct USB_SB_Desc *next_sb, *first_sb, *last_sb;
15903 + int i = 0;
15904 + first_sb = urb_priv->first_sb;
15905 + last_sb = urb_priv->last_sb;
15906 + ASSERT(last_sb);
15907 + while(first_sb != last_sb) {
15908 + next_sb = (struct USB_SB_Desc *)phys_to_virt(first_sb->next);
15909 + kmem_cache_free(usb_desc_cache, first_sb);
15910 + first_sb = next_sb;
15911 + i++;
15912 + }
15913 + kmem_cache_free(usb_desc_cache, last_sb);
15914 + i++;
15915 + }
15916 +
15917 + /* Check if it has any EPs in its Intr pool that also needs to be freed */
15918 + if(urb_priv->intr_ep_pool_length > 0) {
15919 + for(i = 0; i < urb_priv->intr_ep_pool_length; i++) {
15920 + kfree(urb_priv->intr_ep_pool[i]);
15921 + }
15922 + /*
15923 + tc_dbg("Freed %d EPs from URB:0x%x EP pool\n",
15924 + urb_priv->intr_ep_pool_length, (unsigned int)urb);
15925 + */
15926 + }
15927 +
15928 + kfree(urb_priv);
15929 + urb->hcpriv = NULL;
15930 +}
15931 +
15932 +static int ep_priv_create(struct usb_host_endpoint *ep, int mem_flags) {
15933 + struct crisv10_ep_priv *ep_priv;
15934 +
15935 + ep_priv = kmalloc(sizeof *ep_priv, mem_flags);
15936 + if (!ep_priv)
15937 + return -ENOMEM;
15938 + memset(ep_priv, 0, sizeof *ep_priv);
15939 +
15940 + ep->hcpriv = ep_priv;
15941 + return 0;
15942 +}
15943 +
15944 +static void ep_priv_free(struct usb_host_endpoint *ep) {
15945 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
15946 + ASSERT(ep_priv);
15947 + kfree(ep_priv);
15948 + ep->hcpriv = NULL;
15949 +}
15950 +
15951 +/* EPID handling functions, managing EP-list in Etrax through wrappers */
15952 +/* ------------------------------------------------------------------- */
15953 +
15954 +/* Sets up a new EPID for an endpoint or returns existing if found */
15955 +static int tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
15956 + int mem_flags) {
15957 + int epid;
15958 + char devnum, endpoint, out_traffic, slow;
15959 + int maxlen;
15960 + __u32 epid_data;
15961 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
15962 +
15963 + DBFENTER;
15964 +
15965 + /* Check if a valid epid already is setup for this endpoint */
15966 + if(ep_priv != NULL) {
15967 + return ep_priv->epid;
15968 + }
15969 +
15970 + /* We must find and initiate a new epid for this urb. */
15971 + epid = tc_allocate_epid();
15972 +
15973 + if (epid == -1) {
15974 + /* Failed to allocate a new epid. */
15975 + DBFEXIT;
15976 + return epid;
15977 + }
15978 +
15979 + /* We now have a new epid to use. Claim it. */
15980 + epid_state[epid].inuse = 1;
15981 +
15982 + /* Init private data for new endpoint */
15983 + if(ep_priv_create(ep, mem_flags) != 0) {
15984 + return -ENOMEM;
15985 + }
15986 + ep_priv = ep->hcpriv;
15987 + ep_priv->epid = epid;
15988 +
15989 + devnum = usb_pipedevice(urb->pipe);
15990 + endpoint = usb_pipeendpoint(urb->pipe);
15991 + slow = (urb->dev->speed == USB_SPEED_LOW);
15992 + maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
15993 +
15994 + if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
15995 + /* We want both IN and OUT control traffic to be put on the same
15996 + EP/SB list. */
15997 + out_traffic = 1;
15998 + } else {
15999 + out_traffic = usb_pipeout(urb->pipe);
16000 + }
16001 +
16002 + if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
16003 + epid_data = IO_STATE(R_USB_EPT_DATA_ISO, valid, yes) |
16004 + /* FIXME: Change any to the actual port? */
16005 + IO_STATE(R_USB_EPT_DATA_ISO, port, any) |
16006 + IO_FIELD(R_USB_EPT_DATA_ISO, max_len, maxlen) |
16007 + IO_FIELD(R_USB_EPT_DATA_ISO, ep, endpoint) |
16008 + IO_FIELD(R_USB_EPT_DATA_ISO, dev, devnum);
16009 + etrax_epid_iso_set(epid, epid_data);
16010 + } else {
16011 + epid_data = IO_STATE(R_USB_EPT_DATA, valid, yes) |
16012 + IO_FIELD(R_USB_EPT_DATA, low_speed, slow) |
16013 + /* FIXME: Change any to the actual port? */
16014 + IO_STATE(R_USB_EPT_DATA, port, any) |
16015 + IO_FIELD(R_USB_EPT_DATA, max_len, maxlen) |
16016 + IO_FIELD(R_USB_EPT_DATA, ep, endpoint) |
16017 + IO_FIELD(R_USB_EPT_DATA, dev, devnum);
16018 + etrax_epid_set(epid, epid_data);
16019 + }
16020 +
16021 + epid_state[epid].out_traffic = out_traffic;
16022 + epid_state[epid].type = usb_pipetype(urb->pipe);
16023 +
16024 + tc_warn("Setting up ep:0x%x epid:%d (addr:%d endp:%d max_len:%d %s %s %s)\n",
16025 + (unsigned int)ep, epid, devnum, endpoint, maxlen,
16026 + str_type(urb->pipe), out_traffic ? "out" : "in",
16027 + slow ? "low" : "full");
16028 +
16029 + /* Enable Isoc eof interrupt if we set up the first Isoc epid */
16030 + if(usb_pipeisoc(urb->pipe)) {
16031 + isoc_epid_counter++;
16032 + if(isoc_epid_counter == 1) {
16033 + isoc_warn("Enabled Isoc eof interrupt\n");
16034 + *R_USB_IRQ_MASK_SET |= IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set);
16035 + }
16036 + }
16037 +
16038 + DBFEXIT;
16039 + return epid;
16040 +}
16041 +
16042 +static void tc_free_epid(struct usb_host_endpoint *ep) {
16043 + unsigned long flags;
16044 + struct crisv10_ep_priv *ep_priv = ep->hcpriv;
16045 + int epid;
16046 + volatile int timeout = 10000;
16047 +
16048 + DBFENTER;
16049 +
16050 + if (ep_priv == NULL) {
16051 + tc_warn("Trying to free unused epid on ep:0x%x\n", (unsigned int)ep);
16052 + DBFEXIT;
16053 + return;
16054 + }
16055 +
16056 + epid = ep_priv->epid;
16057 +
16058 + /* Disable Isoc eof interrupt if we free the last Isoc epid */
16059 + if(epid_isoc(epid)) {
16060 + ASSERT(isoc_epid_counter > 0);
16061 + isoc_epid_counter--;
16062 + if(isoc_epid_counter == 0) {
16063 + *R_USB_IRQ_MASK_SET &= ~IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set);
16064 + isoc_warn("Disabled Isoc eof interrupt\n");
16065 + }
16066 + }
16067 +
16068 + /* Take lock manualy instead of in epid_x_x wrappers,
16069 + because we need to be polling here */
16070 + spin_lock_irqsave(&etrax_epid_lock, flags);
16071 +
16072 + *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
16073 + nop();
16074 + while((*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) &&
16075 + (timeout-- > 0));
16076 + if(timeout == 0) {
16077 + warn("Timeout while waiting for epid:%d to drop hold\n", epid);
16078 + }
16079 + /* This will, among other things, set the valid field to 0. */
16080 + *R_USB_EPT_DATA = 0;
16081 + spin_unlock_irqrestore(&etrax_epid_lock, flags);
16082 +
16083 + /* Free resource in software state info list */
16084 + epid_state[epid].inuse = 0;
16085 +
16086 + /* Free private endpoint data */
16087 + ep_priv_free(ep);
16088 +
16089 + DBFEXIT;
16090 +}
16091 +
16092 +static int tc_allocate_epid(void) {
16093 + int i;
16094 + DBFENTER;
16095 + for (i = 0; i < NBR_OF_EPIDS; i++) {
16096 + if (!epid_inuse(i)) {
16097 + DBFEXIT;
16098 + return i;
16099 + }
16100 + }
16101 +
16102 + tc_warn("Found no free epids\n");
16103 + DBFEXIT;
16104 + return -1;
16105 +}
16106 +
16107 +
16108 +/* Wrappers around the list functions (include/linux/list.h). */
16109 +/* ---------------------------------------------------------- */
16110 +static inline int __urb_list_empty(int epid) {
16111 + int retval;
16112 + retval = list_empty(&urb_list[epid]);
16113 + return retval;
16114 +}
16115 +
16116 +/* Returns first urb for this epid, or NULL if list is empty. */
16117 +static inline struct urb *urb_list_first(int epid) {
16118 + unsigned long flags;
16119 + struct urb *first_urb = 0;
16120 + spin_lock_irqsave(&urb_list_lock, flags);
16121 + if (!__urb_list_empty(epid)) {
16122 + /* Get the first urb (i.e. head->next). */
16123 + urb_entry_t *urb_entry = list_entry((&urb_list[epid])->next, urb_entry_t, list);
16124 + first_urb = urb_entry->urb;
16125 + }
16126 + spin_unlock_irqrestore(&urb_list_lock, flags);
16127 + return first_urb;
16128 +}
16129 +
16130 +/* Adds an urb_entry last in the list for this epid. */
16131 +static inline void urb_list_add(struct urb *urb, int epid, int mem_flags) {
16132 + unsigned long flags;
16133 + urb_entry_t *urb_entry = (urb_entry_t *)kmalloc(sizeof(urb_entry_t), mem_flags);
16134 + ASSERT(urb_entry);
16135 +
16136 + urb_entry->urb = urb;
16137 + spin_lock_irqsave(&urb_list_lock, flags);
16138 + list_add_tail(&urb_entry->list, &urb_list[epid]);
16139 + spin_unlock_irqrestore(&urb_list_lock, flags);
16140 +}
16141 +
16142 +/* Search through the list for an element that contains this urb. (The list
16143 + is expected to be short and the one we are about to delete will often be
16144 + the first in the list.)
16145 + Should be protected by spin_locks in calling function */
16146 +static inline urb_entry_t *__urb_list_entry(struct urb *urb, int epid) {
16147 + struct list_head *entry;
16148 + struct list_head *tmp;
16149 + urb_entry_t *urb_entry;
16150 +
16151 + list_for_each_safe(entry, tmp, &urb_list[epid]) {
16152 + urb_entry = list_entry(entry, urb_entry_t, list);
16153 + ASSERT(urb_entry);
16154 + ASSERT(urb_entry->urb);
16155 +
16156 + if (urb_entry->urb == urb) {
16157 + return urb_entry;
16158 + }
16159 + }
16160 + return 0;
16161 +}
16162 +
16163 +/* Same function as above but for global use. Protects list by spinlock */
16164 +static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid) {
16165 + unsigned long flags;
16166 + urb_entry_t *urb_entry;
16167 + spin_lock_irqsave(&urb_list_lock, flags);
16168 + urb_entry = __urb_list_entry(urb, epid);
16169 + spin_unlock_irqrestore(&urb_list_lock, flags);
16170 + return (urb_entry);
16171 +}
16172 +
16173 +/* Delete an urb from the list. */
16174 +static inline void urb_list_del(struct urb *urb, int epid) {
16175 + unsigned long flags;
16176 + urb_entry_t *urb_entry;
16177 +
16178 + /* Delete entry and free. */
16179 + spin_lock_irqsave(&urb_list_lock, flags);
16180 + urb_entry = __urb_list_entry(urb, epid);
16181 + ASSERT(urb_entry);
16182 +
16183 + list_del(&urb_entry->list);
16184 + spin_unlock_irqrestore(&urb_list_lock, flags);
16185 + kfree(urb_entry);
16186 +}
16187 +
16188 +/* Move an urb to the end of the list. */
16189 +static inline void urb_list_move_last(struct urb *urb, int epid) {
16190 + unsigned long flags;
16191 + urb_entry_t *urb_entry;
16192 +
16193 + spin_lock_irqsave(&urb_list_lock, flags);
16194 + urb_entry = __urb_list_entry(urb, epid);
16195 + ASSERT(urb_entry);
16196 +
16197 + list_del(&urb_entry->list);
16198 + list_add_tail(&urb_entry->list, &urb_list[epid]);
16199 + spin_unlock_irqrestore(&urb_list_lock, flags);
16200 +}
16201 +
16202 +/* Get the next urb in the list. */
16203 +static inline struct urb *urb_list_next(struct urb *urb, int epid) {
16204 + unsigned long flags;
16205 + urb_entry_t *urb_entry;
16206 +
16207 + spin_lock_irqsave(&urb_list_lock, flags);
16208 + urb_entry = __urb_list_entry(urb, epid);
16209 + ASSERT(urb_entry);
16210 +
16211 + if (urb_entry->list.next != &urb_list[epid]) {
16212 + struct list_head *elem = urb_entry->list.next;
16213 + urb_entry = list_entry(elem, urb_entry_t, list);
16214 + spin_unlock_irqrestore(&urb_list_lock, flags);
16215 + return urb_entry->urb;
16216 + } else {
16217 + spin_unlock_irqrestore(&urb_list_lock, flags);
16218 + return NULL;
16219 + }
16220 +}
16221 +
16222 +struct USB_EP_Desc* create_ep(int epid, struct USB_SB_Desc* sb_desc,
16223 + int mem_flags) {
16224 + struct USB_EP_Desc *ep_desc;
16225 + ep_desc = (struct USB_EP_Desc *) kmem_cache_alloc(usb_desc_cache, mem_flags);
16226 + if(ep_desc == NULL)
16227 + return NULL;
16228 + memset(ep_desc, 0, sizeof(struct USB_EP_Desc));
16229 +
16230 + ep_desc->hw_len = 0;
16231 + ep_desc->command = (IO_FIELD(USB_EP_command, epid, epid) |
16232 + IO_STATE(USB_EP_command, enable, yes));
16233 + if(sb_desc == NULL) {
16234 + ep_desc->sub = 0;
16235 + } else {
16236 + ep_desc->sub = virt_to_phys(sb_desc);
16237 + }
16238 + return ep_desc;
16239 +}
16240 +
16241 +#define TT_ZOUT 0
16242 +#define TT_IN 1
16243 +#define TT_OUT 2
16244 +#define TT_SETUP 3
16245 +
16246 +#define CMD_EOL IO_STATE(USB_SB_command, eol, yes)
16247 +#define CMD_INTR IO_STATE(USB_SB_command, intr, yes)
16248 +#define CMD_FULL IO_STATE(USB_SB_command, full, yes)
16249 +
16250 +/* Allocation and setup of a generic SB. Used to create SETUP, OUT and ZOUT
16251 + SBs. Also used by create_sb_in() to avoid same allocation procedure at two
16252 + places */
16253 +struct USB_SB_Desc* create_sb(struct USB_SB_Desc* sb_prev, int tt, void* data,
16254 + int datalen, int mem_flags) {
16255 + struct USB_SB_Desc *sb_desc;
16256 + sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
16257 + if(sb_desc == NULL)
16258 + return NULL;
16259 + memset(sb_desc, 0, sizeof(struct USB_SB_Desc));
16260 +
16261 + sb_desc->command = IO_FIELD(USB_SB_command, tt, tt) |
16262 + IO_STATE(USB_SB_command, eot, yes);
16263 +
16264 + sb_desc->sw_len = datalen;
16265 + if(data != NULL) {
16266 + sb_desc->buf = virt_to_phys(data);
16267 + } else {
16268 + sb_desc->buf = 0;
16269 + }
16270 + if(sb_prev != NULL) {
16271 + sb_prev->next = virt_to_phys(sb_desc);
16272 + }
16273 + return sb_desc;
16274 +}
16275 +
16276 +/* Creates a copy of an existing SB by allocation space for it and copy
16277 + settings */
16278 +struct USB_SB_Desc* create_sb_copy(struct USB_SB_Desc* sb_orig, int mem_flags) {
16279 + struct USB_SB_Desc *sb_desc;
16280 + sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
16281 + if(sb_desc == NULL)
16282 + return NULL;
16283 +
16284 + memcpy(sb_desc, sb_orig, sizeof(struct USB_SB_Desc));
16285 + return sb_desc;
16286 +}
16287 +
16288 +/* A specific create_sb function for creation of in SBs. This is due to
16289 + that datalen in In SBs shows how many packets we are expecting. It also
16290 + sets up the rem field to show if how many bytes we expect in last packet
16291 + if it's not a full one */
16292 +struct USB_SB_Desc* create_sb_in(struct USB_SB_Desc* sb_prev, int datalen,
16293 + int maxlen, int mem_flags) {
16294 + struct USB_SB_Desc *sb_desc;
16295 + sb_desc = create_sb(sb_prev, TT_IN, NULL,
16296 + datalen ? (datalen - 1) / maxlen + 1 : 0, mem_flags);
16297 + if(sb_desc == NULL)
16298 + return NULL;
16299 + sb_desc->command |= IO_FIELD(USB_SB_command, rem, datalen % maxlen);
16300 + return sb_desc;
16301 +}
16302 +
16303 +void set_sb_cmds(struct USB_SB_Desc *sb_desc, __u16 flags) {
16304 + sb_desc->command |= flags;
16305 +}
16306 +
16307 +int create_sb_for_urb(struct urb *urb, int mem_flags) {
16308 + int is_out = !usb_pipein(urb->pipe);
16309 + int type = usb_pipetype(urb->pipe);
16310 + int maxlen = usb_maxpacket(urb->dev, urb->pipe, is_out);
16311 + int buf_len = urb->transfer_buffer_length;
16312 + void *buf = buf_len > 0 ? urb->transfer_buffer : NULL;
16313 + struct USB_SB_Desc *sb_desc = NULL;
16314 +
16315 + struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
16316 + ASSERT(urb_priv != NULL);
16317 +
16318 + switch(type) {
16319 + case PIPE_CONTROL:
16320 + /* Setup stage */
16321 + sb_desc = create_sb(NULL, TT_SETUP, urb->setup_packet, 8, mem_flags);
16322 + if(sb_desc == NULL)
16323 + return -ENOMEM;
16324 + set_sb_cmds(sb_desc, CMD_FULL);
16325 +
16326 + /* Attach first SB to URB */
16327 + urb_priv->first_sb = sb_desc;
16328 +
16329 + if (is_out) { /* Out Control URB */
16330 + /* If this Control OUT transfer has an optional data stage we add
16331 + an OUT token before the mandatory IN (status) token */
16332 + if ((buf_len > 0) && buf) {
16333 + sb_desc = create_sb(sb_desc, TT_OUT, buf, buf_len, mem_flags);
16334 + if(sb_desc == NULL)
16335 + return -ENOMEM;
16336 + set_sb_cmds(sb_desc, CMD_FULL);
16337 + }
16338 +
16339 + /* Status stage */
16340 + /* The data length has to be exactly 1. This is due to a requirement
16341 + of the USB specification that a host must be prepared to receive
16342 + data in the status phase */
16343 + sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
16344 + if(sb_desc == NULL)
16345 + return -ENOMEM;
16346 + } else { /* In control URB */
16347 + /* Data stage */
16348 + sb_desc = create_sb_in(sb_desc, buf_len, maxlen, mem_flags);
16349 + if(sb_desc == NULL)
16350 + return -ENOMEM;
16351 +
16352 + /* Status stage */
16353 + /* Read comment at zout_buffer declaration for an explanation to this. */
16354 + sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
16355 + if(sb_desc == NULL)
16356 + return -ENOMEM;
16357 + /* Set descriptor interrupt flag for in URBs so we can finish URB after
16358 + zout-packet has been sent */
16359 + set_sb_cmds(sb_desc, CMD_INTR | CMD_FULL);
16360 + }
16361 + /* Set end-of-list flag in last SB */
16362 + set_sb_cmds(sb_desc, CMD_EOL);
16363 + /* Attach last SB to URB */
16364 + urb_priv->last_sb = sb_desc;
16365 + break;
16366 +
16367 + case PIPE_BULK:
16368 + if (is_out) { /* Out Bulk URB */
16369 + sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
16370 + if(sb_desc == NULL)
16371 + return -ENOMEM;
16372 + /* The full field is set to yes, even if we don't actually check that
16373 + this is a full-length transfer (i.e., that transfer_buffer_length %
16374 + maxlen = 0).
16375 + Setting full prevents the USB controller from sending an empty packet
16376 + in that case. However, if URB_ZERO_PACKET was set we want that. */
16377 + if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
16378 + set_sb_cmds(sb_desc, CMD_FULL);
16379 + }
16380 + } else { /* In Bulk URB */
16381 + sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
16382 + if(sb_desc == NULL)
16383 + return -ENOMEM;
16384 + }
16385 + /* Set end-of-list flag for last SB */
16386 + set_sb_cmds(sb_desc, CMD_EOL);
16387 +
16388 + /* Attach SB to URB */
16389 + urb_priv->first_sb = sb_desc;
16390 + urb_priv->last_sb = sb_desc;
16391 + break;
16392 +
16393 + case PIPE_INTERRUPT:
16394 + if(is_out) { /* Out Intr URB */
16395 + sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
16396 + if(sb_desc == NULL)
16397 + return -ENOMEM;
16398 +
16399 + /* The full field is set to yes, even if we don't actually check that
16400 + this is a full-length transfer (i.e., that transfer_buffer_length %
16401 + maxlen = 0).
16402 + Setting full prevents the USB controller from sending an empty packet
16403 + in that case. However, if URB_ZERO_PACKET was set we want that. */
16404 + if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
16405 + set_sb_cmds(sb_desc, CMD_FULL);
16406 + }
16407 + /* Only generate TX interrupt if it's a Out URB*/
16408 + set_sb_cmds(sb_desc, CMD_INTR);
16409 +
16410 + } else { /* In Intr URB */
16411 + sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
16412 + if(sb_desc == NULL)
16413 + return -ENOMEM;
16414 + }
16415 + /* Set end-of-list flag for last SB */
16416 + set_sb_cmds(sb_desc, CMD_EOL);
16417 +
16418 + /* Attach SB to URB */
16419 + urb_priv->first_sb = sb_desc;
16420 + urb_priv->last_sb = sb_desc;
16421 +
16422 + break;
16423 + case PIPE_ISOCHRONOUS:
16424 + if(is_out) { /* Out Isoc URB */
16425 + int i;
16426 + if(urb->number_of_packets == 0) {
16427 + tc_err("Can't create SBs for Isoc URB with zero packets\n");
16428 + return -EPIPE;
16429 + }
16430 + /* Create one SB descriptor for each packet and link them together. */
16431 + for(i = 0; i < urb->number_of_packets; i++) {
16432 + if (urb->iso_frame_desc[i].length > 0) {
16433 +
16434 + sb_desc = create_sb(sb_desc, TT_OUT, urb->transfer_buffer +
16435 + urb->iso_frame_desc[i].offset,
16436 + urb->iso_frame_desc[i].length, mem_flags);
16437 + if(sb_desc == NULL)
16438 + return -ENOMEM;
16439 +
16440 + /* Check if it's a full length packet */
16441 + if (urb->iso_frame_desc[i].length ==
16442 + usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
16443 + set_sb_cmds(sb_desc, CMD_FULL);
16444 + }
16445 +
16446 + } else { /* zero length packet */
16447 + sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
16448 + if(sb_desc == NULL)
16449 + return -ENOMEM;
16450 + set_sb_cmds(sb_desc, CMD_FULL);
16451 + }
16452 + /* Attach first SB descriptor to URB */
16453 + if (i == 0) {
16454 + urb_priv->first_sb = sb_desc;
16455 + }
16456 + }
16457 + /* Set interrupt and end-of-list flags in last SB */
16458 + set_sb_cmds(sb_desc, CMD_INTR | CMD_EOL);
16459 + /* Attach last SB descriptor to URB */
16460 + urb_priv->last_sb = sb_desc;
16461 + tc_dbg("Created %d out SBs for Isoc URB:0x%x\n",
16462 + urb->number_of_packets, (unsigned int)urb);
16463 + } else { /* In Isoc URB */
16464 + /* Actual number of packets is not relevant for periodic in traffic as
16465 + long as it is more than zero. Set to 1 always. */
16466 + sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
16467 + if(sb_desc == NULL)
16468 + return -ENOMEM;
16469 + /* Set end-of-list flags for SB */
16470 + set_sb_cmds(sb_desc, CMD_EOL);
16471 +
16472 + /* Attach SB to URB */
16473 + urb_priv->first_sb = sb_desc;
16474 + urb_priv->last_sb = sb_desc;
16475 + }
16476 + break;
16477 + default:
16478 + tc_err("Unknown pipe-type\n");
16479 + return -EPIPE;
16480 + break;
16481 + }
16482 + return 0;
16483 +}
16484 +
16485 +int init_intr_urb(struct urb *urb, int mem_flags) {
16486 + struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
16487 + struct USB_EP_Desc* ep_desc;
16488 + int interval;
16489 + int i;
16490 + int ep_count;
16491 +
16492 + ASSERT(urb_priv != NULL);
16493 + ASSERT(usb_pipeint(urb->pipe));
16494 + /* We can't support interval longer than amount of eof descriptors in
16495 + TxIntrEPList */
16496 + if(urb->interval > MAX_INTR_INTERVAL) {
16497 + tc_err("Interrupt interval %dms too big (max: %dms)\n", urb->interval,
16498 + MAX_INTR_INTERVAL);
16499 + return -EINVAL;
16500 + }
16501 +
16502 + /* We assume that the SB descriptors already have been setup */
16503 + ASSERT(urb_priv->first_sb != NULL);
16504 +
16505 + /* Round of the interval to 2^n, it is obvious that this code favours
16506 + smaller numbers, but that is actually a good thing */
16507 + /* FIXME: The "rounding error" for larger intervals will be quite
16508 + large. For in traffic this shouldn't be a problem since it will only
16509 + mean that we "poll" more often. */
16510 + interval = urb->interval;
16511 + for (i = 0; interval; i++) {
16512 + interval = interval >> 1;
16513 + }
16514 + urb_priv->interval = 1 << (i - 1);
16515 +
16516 + /* We can only have max interval for Out Interrupt due to that we can only
16517 + handle one linked in EP for a certain epid in the Intr descr array at the
16518 + time. The USB Controller in the Etrax 100LX continues to process Intr EPs
16519 + so we have no way of knowing which one that caused the actual transfer if
16520 + we have several linked in. */
16521 + if(usb_pipeout(urb->pipe)) {
16522 + urb_priv->interval = MAX_INTR_INTERVAL;
16523 + }
16524 +
16525 + /* Calculate amount of EPs needed */
16526 + ep_count = MAX_INTR_INTERVAL / urb_priv->interval;
16527 +
16528 + for(i = 0; i < ep_count; i++) {
16529 + ep_desc = create_ep(urb_priv->epid, urb_priv->first_sb, mem_flags);
16530 + if(ep_desc == NULL) {
16531 + /* Free any descriptors that we may have allocated before failure */
16532 + while(i > 0) {
16533 + i--;
16534 + kfree(urb_priv->intr_ep_pool[i]);
16535 + }
16536 + return -ENOMEM;
16537 + }
16538 + urb_priv->intr_ep_pool[i] = ep_desc;
16539 + }
16540 + urb_priv->intr_ep_pool_length = ep_count;
16541 + return 0;
16542 +}
16543 +
16544 +/* DMA RX/TX functions */
16545 +/* ----------------------- */
16546 +
16547 +static void tc_dma_init_rx_list(void) {
16548 + int i;
16549 +
16550 + /* Setup descriptor list except last one */
16551 + for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) {
16552 + RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
16553 + RxDescList[i].command = 0;
16554 + RxDescList[i].next = virt_to_phys(&RxDescList[i + 1]);
16555 + RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
16556 + RxDescList[i].hw_len = 0;
16557 + RxDescList[i].status = 0;
16558 +
16559 + /* DMA IN cache bug. (struct etrax_dma_descr has the same layout as
16560 + USB_IN_Desc for the relevant fields.) */
16561 + prepare_rx_descriptor((struct etrax_dma_descr*)&RxDescList[i]);
16562 +
16563 + }
16564 + /* Special handling of last descriptor */
16565 + RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
16566 + RxDescList[i].command = IO_STATE(USB_IN_command, eol, yes);
16567 + RxDescList[i].next = virt_to_phys(&RxDescList[0]);
16568 + RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
16569 + RxDescList[i].hw_len = 0;
16570 + RxDescList[i].status = 0;
16571 +
16572 + /* Setup list pointers that show progress in list */
16573 + myNextRxDesc = &RxDescList[0];
16574 + myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
16575 +
16576 + flush_etrax_cache();
16577 + /* Point DMA to first descriptor in list and start it */
16578 + *R_DMA_CH9_FIRST = virt_to_phys(myNextRxDesc);
16579 + *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, start);
16580 +}
16581 +
16582 +
16583 +static void tc_dma_init_tx_bulk_list(void) {
16584 + int i;
16585 + volatile struct USB_EP_Desc *epDescr;
16586 +
16587 + for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
16588 + epDescr = &(TxBulkEPList[i]);
16589 + CHECK_ALIGN(epDescr);
16590 + epDescr->hw_len = 0;
16591 + epDescr->command = IO_FIELD(USB_EP_command, epid, i);
16592 + epDescr->sub = 0;
16593 + epDescr->next = virt_to_phys(&TxBulkEPList[i + 1]);
16594 +
16595 + /* Initiate two EPs, disabled and with the eol flag set. No need for any
16596 + preserved epid. */
16597 +
16598 + /* The first one has the intr flag set so we get an interrupt when the DMA
16599 + channel is about to become disabled. */
16600 + CHECK_ALIGN(&TxBulkDummyEPList[i][0]);
16601 + TxBulkDummyEPList[i][0].hw_len = 0;
16602 + TxBulkDummyEPList[i][0].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
16603 + IO_STATE(USB_EP_command, eol, yes) |
16604 + IO_STATE(USB_EP_command, intr, yes));
16605 + TxBulkDummyEPList[i][0].sub = 0;
16606 + TxBulkDummyEPList[i][0].next = virt_to_phys(&TxBulkDummyEPList[i][1]);
16607 +
16608 + /* The second one. */
16609 + CHECK_ALIGN(&TxBulkDummyEPList[i][1]);
16610 + TxBulkDummyEPList[i][1].hw_len = 0;
16611 + TxBulkDummyEPList[i][1].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
16612 + IO_STATE(USB_EP_command, eol, yes));
16613 + TxBulkDummyEPList[i][1].sub = 0;
16614 + /* The last dummy's next pointer is the same as the current EP's next pointer. */
16615 + TxBulkDummyEPList[i][1].next = virt_to_phys(&TxBulkEPList[i + 1]);
16616 + }
16617 +
16618 + /* Special handling of last descr in list, make list circular */
16619 + epDescr = &TxBulkEPList[i];
16620 + CHECK_ALIGN(epDescr);
16621 + epDescr->hw_len = 0;
16622 + epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
16623 + IO_FIELD(USB_EP_command, epid, i);
16624 + epDescr->sub = 0;
16625 + epDescr->next = virt_to_phys(&TxBulkEPList[0]);
16626 +
16627 + /* Init DMA sub-channel pointers to last item in each list */
16628 + *R_DMA_CH8_SUB0_EP = virt_to_phys(&TxBulkEPList[i]);
16629 + /* No point in starting the bulk channel yet.
16630 + *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
16631 +}
16632 +
16633 +static void tc_dma_init_tx_ctrl_list(void) {
16634 + int i;
16635 + volatile struct USB_EP_Desc *epDescr;
16636 +
16637 + for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
16638 + epDescr = &(TxCtrlEPList[i]);
16639 + CHECK_ALIGN(epDescr);
16640 + epDescr->hw_len = 0;
16641 + epDescr->command = IO_FIELD(USB_EP_command, epid, i);
16642 + epDescr->sub = 0;
16643 + epDescr->next = virt_to_phys(&TxCtrlEPList[i + 1]);
16644 + }
16645 + /* Special handling of last descr in list, make list circular */
16646 + epDescr = &TxCtrlEPList[i];
16647 + CHECK_ALIGN(epDescr);
16648 + epDescr->hw_len = 0;
16649 + epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
16650 + IO_FIELD(USB_EP_command, epid, i);
16651 + epDescr->sub = 0;
16652 + epDescr->next = virt_to_phys(&TxCtrlEPList[0]);
16653 +
16654 + /* Init DMA sub-channel pointers to last item in each list */
16655 + *R_DMA_CH8_SUB1_EP = virt_to_phys(&TxCtrlEPList[i]);
16656 + /* No point in starting the ctrl channel yet.
16657 + *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
16658 +}
16659 +
16660 +
16661 +static void tc_dma_init_tx_intr_list(void) {
16662 + int i;
16663 +
16664 + TxIntrSB_zout.sw_len = 1;
16665 + TxIntrSB_zout.next = 0;
16666 + TxIntrSB_zout.buf = virt_to_phys(&zout_buffer[0]);
16667 + TxIntrSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
16668 + IO_STATE(USB_SB_command, tt, zout) |
16669 + IO_STATE(USB_SB_command, full, yes) |
16670 + IO_STATE(USB_SB_command, eot, yes) |
16671 + IO_STATE(USB_SB_command, eol, yes));
16672 +
16673 + for (i = 0; i < (MAX_INTR_INTERVAL - 1); i++) {
16674 + CHECK_ALIGN(&TxIntrEPList[i]);
16675 + TxIntrEPList[i].hw_len = 0;
16676 + TxIntrEPList[i].command =
16677 + (IO_STATE(USB_EP_command, eof, yes) |
16678 + IO_STATE(USB_EP_command, enable, yes) |
16679 + IO_FIELD(USB_EP_command, epid, INVALID_EPID));
16680 + TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
16681 + TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[i + 1]);
16682 + }
16683 +
16684 + /* Special handling of last descr in list, make list circular */
16685 + CHECK_ALIGN(&TxIntrEPList[i]);
16686 + TxIntrEPList[i].hw_len = 0;
16687 + TxIntrEPList[i].command =
16688 + (IO_STATE(USB_EP_command, eof, yes) |
16689 + IO_STATE(USB_EP_command, eol, yes) |
16690 + IO_STATE(USB_EP_command, enable, yes) |
16691 + IO_FIELD(USB_EP_command, epid, INVALID_EPID));
16692 + TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
16693 + TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[0]);
16694 +
16695 + intr_dbg("Initiated Intr EP descriptor list\n");
16696 +
16697 +
16698 + /* Connect DMA 8 sub-channel 2 to first in list */
16699 + *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]);
16700 +}
16701 +
16702 +static void tc_dma_init_tx_isoc_list(void) {
16703 + int i;
16704 +
16705 + DBFENTER;
16706 +
16707 + /* Read comment at zout_buffer declaration for an explanation to this. */
16708 + TxIsocSB_zout.sw_len = 1;
16709 + TxIsocSB_zout.next = 0;
16710 + TxIsocSB_zout.buf = virt_to_phys(&zout_buffer[0]);
16711 + TxIsocSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
16712 + IO_STATE(USB_SB_command, tt, zout) |
16713 + IO_STATE(USB_SB_command, full, yes) |
16714 + IO_STATE(USB_SB_command, eot, yes) |
16715 + IO_STATE(USB_SB_command, eol, yes));
16716 +
16717 + /* The last isochronous EP descriptor is a dummy. */
16718 + for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
16719 + CHECK_ALIGN(&TxIsocEPList[i]);
16720 + TxIsocEPList[i].hw_len = 0;
16721 + TxIsocEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
16722 + TxIsocEPList[i].sub = 0;
16723 + TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[i + 1]);
16724 + }
16725 +
16726 + CHECK_ALIGN(&TxIsocEPList[i]);
16727 + TxIsocEPList[i].hw_len = 0;
16728 +
16729 + /* Must enable the last EP descr to get eof interrupt. */
16730 + TxIsocEPList[i].command = (IO_STATE(USB_EP_command, enable, yes) |
16731 + IO_STATE(USB_EP_command, eof, yes) |
16732 + IO_STATE(USB_EP_command, eol, yes) |
16733 + IO_FIELD(USB_EP_command, epid, INVALID_EPID));
16734 + TxIsocEPList[i].sub = virt_to_phys(&TxIsocSB_zout);
16735 + TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[0]);
16736 +
16737 + *R_DMA_CH8_SUB3_EP = virt_to_phys(&TxIsocEPList[0]);
16738 + *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
16739 +}
16740 +
16741 +static int tc_dma_init(struct usb_hcd *hcd) {
16742 + tc_dma_init_rx_list();
16743 + tc_dma_init_tx_bulk_list();
16744 + tc_dma_init_tx_ctrl_list();
16745 + tc_dma_init_tx_intr_list();
16746 + tc_dma_init_tx_isoc_list();
16747 +
16748 + if (cris_request_dma(USB_TX_DMA_NBR,
16749 + "ETRAX 100LX built-in USB (Tx)",
16750 + DMA_VERBOSE_ON_ERROR,
16751 + dma_usb)) {
16752 + err("Could not allocate DMA ch 8 for USB");
16753 + return -EBUSY;
16754 + }
16755 +
16756 + if (cris_request_dma(USB_RX_DMA_NBR,
16757 + "ETRAX 100LX built-in USB (Rx)",
16758 + DMA_VERBOSE_ON_ERROR,
16759 + dma_usb)) {
16760 + err("Could not allocate DMA ch 9 for USB");
16761 + return -EBUSY;
16762 + }
16763 +
16764 + *R_IRQ_MASK2_SET =
16765 + /* Note that these interrupts are not used. */
16766 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub0_descr, set) |
16767 + /* Sub channel 1 (ctrl) descr. interrupts are used. */
16768 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub1_descr, set) |
16769 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub2_descr, set) |
16770 + /* Sub channel 3 (isoc) descr. interrupts are used. */
16771 + IO_STATE(R_IRQ_MASK2_SET, dma8_sub3_descr, set);
16772 +
16773 + /* Note that the dma9_descr interrupt is not used. */
16774 + *R_IRQ_MASK2_SET =
16775 + IO_STATE(R_IRQ_MASK2_SET, dma9_eop, set) |
16776 + IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set);
16777 +
16778 + if (request_irq(ETRAX_USB_RX_IRQ, tc_dma_rx_interrupt, 0,
16779 + "ETRAX 100LX built-in USB (Rx)", hcd)) {
16780 + err("Could not allocate IRQ %d for USB", ETRAX_USB_RX_IRQ);
16781 + return -EBUSY;
16782 + }
16783 +
16784 + if (request_irq(ETRAX_USB_TX_IRQ, tc_dma_tx_interrupt, 0,
16785 + "ETRAX 100LX built-in USB (Tx)", hcd)) {
16786 + err("Could not allocate IRQ %d for USB", ETRAX_USB_TX_IRQ);
16787 + return -EBUSY;
16788 + }
16789 +
16790 + return 0;
16791 +}
16792 +
16793 +static void tc_dma_destroy(void) {
16794 + free_irq(ETRAX_USB_RX_IRQ, NULL);
16795 + free_irq(ETRAX_USB_TX_IRQ, NULL);
16796 +
16797 + cris_free_dma(USB_TX_DMA_NBR, "ETRAX 100LX built-in USB (Tx)");
16798 + cris_free_dma(USB_RX_DMA_NBR, "ETRAX 100LX built-in USB (Rx)");
16799 +
16800 +}
16801 +
16802 +static void tc_dma_link_intr_urb(struct urb *urb);
16803 +
16804 +/* Handle processing of Bulk, Ctrl and Intr queues */
16805 +static void tc_dma_process_queue(int epid) {
16806 + struct urb *urb;
16807 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
16808 + unsigned long flags;
16809 + char toggle;
16810 +
16811 + if(epid_state[epid].disabled) {
16812 + /* Don't process any URBs on a disabled endpoint */
16813 + return;
16814 + }
16815 +
16816 + /* Do not disturb us while fiddling with EPs and epids */
16817 + local_irq_save(flags);
16818 +
16819 + /* For bulk, Ctrl and Intr can we only have one URB active at a time for
16820 + a specific EP. */
16821 + if(activeUrbList[epid] != NULL) {
16822 + /* An URB is already active on EP, skip checking queue */
16823 + local_irq_restore(flags);
16824 + return;
16825 + }
16826 +
16827 + urb = urb_list_first(epid);
16828 + if(urb == NULL) {
16829 + /* No URB waiting in EP queue. Nothing do to */
16830 + local_irq_restore(flags);
16831 + return;
16832 + }
16833 +
16834 + urb_priv = urb->hcpriv;
16835 + ASSERT(urb_priv != NULL);
16836 + ASSERT(urb_priv->urb_state == NOT_STARTED);
16837 + ASSERT(!usb_pipeisoc(urb->pipe));
16838 +
16839 + /* Remove this URB from the queue and move it to active */
16840 + activeUrbList[epid] = urb;
16841 + urb_list_del(urb, epid);
16842 +
16843 + urb_priv->urb_state = STARTED;
16844 +
16845 + /* Reset error counters (regardless of which direction this traffic is). */
16846 + etrax_epid_clear_error(epid);
16847 +
16848 + /* Special handling of Intr EP lists */
16849 + if(usb_pipeint(urb->pipe)) {
16850 + tc_dma_link_intr_urb(urb);
16851 + local_irq_restore(flags);
16852 + return;
16853 + }
16854 +
16855 + /* Software must preset the toggle bits for Bulk and Ctrl */
16856 + if(usb_pipecontrol(urb->pipe)) {
16857 + /* Toggle bits are initialized only during setup transaction in a
16858 + CTRL transfer */
16859 + etrax_epid_set_toggle(epid, 0, 0);
16860 + etrax_epid_set_toggle(epid, 1, 0);
16861 + } else {
16862 + toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
16863 + usb_pipeout(urb->pipe));
16864 + etrax_epid_set_toggle(epid, usb_pipeout(urb->pipe), toggle);
16865 + }
16866 +
16867 + tc_dbg("Added SBs from (URB:0x%x %s %s) to epid %d: %s\n",
16868 + (unsigned int)urb, str_dir(urb->pipe), str_type(urb->pipe), epid,
16869 + sblist_to_str(urb_priv->first_sb));
16870 +
16871 + /* We start the DMA sub channel without checking if it's running or not,
16872 + because:
16873 + 1) If it's already running, issuing the start command is a nop.
16874 + 2) We avoid a test-and-set race condition. */
16875 + switch(usb_pipetype(urb->pipe)) {
16876 + case PIPE_BULK:
16877 + /* Assert that the EP descriptor is disabled. */
16878 + ASSERT(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
16879 +
16880 + /* Set up and enable the EP descriptor. */
16881 + TxBulkEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
16882 + TxBulkEPList[epid].hw_len = 0;
16883 + TxBulkEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
16884 +
16885 + /* Check if the dummy list is already with us (if several urbs were queued). */
16886 + if (usb_pipein(urb->pipe) && (TxBulkEPList[epid].next != virt_to_phys(&TxBulkDummyEPList[epid][0]))) {
16887 + tc_dbg("Inviting dummy list to the party for urb 0x%lx, epid %d",
16888 + (unsigned long)urb, epid);
16889 +
16890 + /* We don't need to check if the DMA is at this EP or not before changing the
16891 + next pointer, since we will do it in one 32-bit write (EP descriptors are
16892 + 32-bit aligned). */
16893 + TxBulkEPList[epid].next = virt_to_phys(&TxBulkDummyEPList[epid][0]);
16894 + }
16895 +
16896 + restart_dma8_sub0();
16897 +
16898 + /* Update/restart the bulk start timer since we just started the channel.*/
16899 + mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
16900 + /* Update/restart the bulk eot timer since we just inserted traffic. */
16901 + mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
16902 + break;
16903 + case PIPE_CONTROL:
16904 + /* Assert that the EP descriptor is disabled. */
16905 + ASSERT(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
16906 +
16907 + /* Set up and enable the EP descriptor. */
16908 + TxCtrlEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
16909 + TxCtrlEPList[epid].hw_len = 0;
16910 + TxCtrlEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
16911 +
16912 + *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
16913 + break;
16914 + }
16915 + local_irq_restore(flags);
16916 +}
16917 +
16918 +static void tc_dma_link_intr_urb(struct urb *urb) {
16919 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
16920 + volatile struct USB_EP_Desc *tmp_ep;
16921 + struct USB_EP_Desc *ep_desc;
16922 + int i = 0, epid;
16923 + int pool_idx = 0;
16924 +
16925 + ASSERT(urb_priv != NULL);
16926 + epid = urb_priv->epid;
16927 + ASSERT(urb_priv->interval > 0);
16928 + ASSERT(urb_priv->intr_ep_pool_length > 0);
16929 +
16930 + tmp_ep = &TxIntrEPList[0];
16931 +
16932 + /* Only insert one EP descriptor in list for Out Intr URBs.
16933 + We can only handle Out Intr with interval of 128ms because
16934 + it's not possible to insert several Out Intr EPs because they
16935 + are not consumed by the DMA. */
16936 + if(usb_pipeout(urb->pipe)) {
16937 + ep_desc = urb_priv->intr_ep_pool[0];
16938 + ASSERT(ep_desc);
16939 + ep_desc->next = tmp_ep->next;
16940 + tmp_ep->next = virt_to_phys(ep_desc);
16941 + i++;
16942 + } else {
16943 + /* Loop through Intr EP descriptor list and insert EP for URB at
16944 + specified interval */
16945 + do {
16946 + /* Each EP descriptor with eof flag sat signals a new frame */
16947 + if (tmp_ep->command & IO_MASK(USB_EP_command, eof)) {
16948 + /* Insert a EP from URBs EP pool at correct interval */
16949 + if ((i % urb_priv->interval) == 0) {
16950 + ep_desc = urb_priv->intr_ep_pool[pool_idx];
16951 + ASSERT(ep_desc);
16952 + ep_desc->next = tmp_ep->next;
16953 + tmp_ep->next = virt_to_phys(ep_desc);
16954 + pool_idx++;
16955 + ASSERT(pool_idx <= urb_priv->intr_ep_pool_length);
16956 + }
16957 + i++;
16958 + }
16959 + tmp_ep = (struct USB_EP_Desc *)phys_to_virt(tmp_ep->next);
16960 + } while(tmp_ep != &TxIntrEPList[0]);
16961 + }
16962 +
16963 + intr_dbg("Added SBs to intr epid %d: %s interval:%d (%d EP)\n", epid,
16964 + sblist_to_str(urb_priv->first_sb), urb_priv->interval, pool_idx);
16965 +
16966 + /* We start the DMA sub channel without checking if it's running or not,
16967 + because:
16968 + 1) If it's already running, issuing the start command is a nop.
16969 + 2) We avoid a test-and-set race condition. */
16970 + *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
16971 +}
16972 +
16973 +static void tc_dma_process_isoc_urb(struct urb *urb) {
16974 + unsigned long flags;
16975 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
16976 + int epid;
16977 +
16978 + /* Do not disturb us while fiddling with EPs and epids */
16979 + local_irq_save(flags);
16980 +
16981 + ASSERT(urb_priv);
16982 + ASSERT(urb_priv->first_sb);
16983 + epid = urb_priv->epid;
16984 +
16985 + if(activeUrbList[epid] == NULL) {
16986 + /* EP is idle, so make this URB active */
16987 + activeUrbList[epid] = urb;
16988 + urb_list_del(urb, epid);
16989 + ASSERT(TxIsocEPList[epid].sub == 0);
16990 + ASSERT(!(TxIsocEPList[epid].command &
16991 + IO_STATE(USB_EP_command, enable, yes)));
16992 +
16993 + /* Differentiate between In and Out Isoc. Because In SBs are not consumed*/
16994 + if(usb_pipein(urb->pipe)) {
16995 + /* Each EP for In Isoc will have only one SB descriptor, setup when
16996 + submitting the first active urb. We do it here by copying from URBs
16997 + pre-allocated SB. */
16998 + memcpy((void *)&(TxIsocSBList[epid]), urb_priv->first_sb,
16999 + sizeof(TxIsocSBList[epid]));
17000 + TxIsocEPList[epid].hw_len = 0;
17001 + TxIsocEPList[epid].sub = virt_to_phys(&(TxIsocSBList[epid]));
17002 + } else {
17003 + /* For Out Isoc we attach the pre-allocated list of SBs for the URB */
17004 + TxIsocEPList[epid].hw_len = 0;
17005 + TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
17006 +
17007 + isoc_dbg("Attached first URB:0x%x[%d] to epid:%d first_sb:0x%x"
17008 + " last_sb::0x%x\n",
17009 + (unsigned int)urb, urb_priv->urb_num, epid,
17010 + (unsigned int)(urb_priv->first_sb),
17011 + (unsigned int)(urb_priv->last_sb));
17012 + }
17013 +
17014 + if (urb->transfer_flags & URB_ISO_ASAP) {
17015 + /* The isoc transfer should be started as soon as possible. The
17016 + start_frame field is a return value if URB_ISO_ASAP was set. Comparing
17017 + R_USB_FM_NUMBER with a USB Chief trace shows that the first isoc IN
17018 + token is sent 2 frames later. I'm not sure how this affects usage of
17019 + the start_frame field by the device driver, or how it affects things
17020 + when USB_ISO_ASAP is not set, so therefore there's no compensation for
17021 + the 2 frame "lag" here. */
17022 + urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
17023 + TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
17024 + urb_priv->urb_state = STARTED;
17025 + isoc_dbg("URB_ISO_ASAP set, urb->start_frame set to %d\n",
17026 + urb->start_frame);
17027 + } else {
17028 + /* Not started yet. */
17029 + urb_priv->urb_state = NOT_STARTED;
17030 + isoc_warn("urb_priv->urb_state set to NOT_STARTED for URB:0x%x\n",
17031 + (unsigned int)urb);
17032 + }
17033 +
17034 + } else {
17035 + /* An URB is already active on the EP. Leave URB in queue and let
17036 + finish_isoc_urb process it after current active URB */
17037 + ASSERT(TxIsocEPList[epid].sub != 0);
17038 +
17039 + if(usb_pipein(urb->pipe)) {
17040 + /* Because there already is a active In URB on this epid we do nothing
17041 + and the finish_isoc_urb() function will handle switching to next URB*/
17042 +
17043 + } else { /* For Out Isoc, insert new URBs traffic last in SB-list. */
17044 + struct USB_SB_Desc *temp_sb_desc;
17045 +
17046 + /* Set state STARTED to all Out Isoc URBs added to SB list because we
17047 + don't know how many of them that are finished before descr interrupt*/
17048 + urb_priv->urb_state = STARTED;
17049 +
17050 + /* Find end of current SB list by looking for SB with eol flag sat */
17051 + temp_sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
17052 + while ((temp_sb_desc->command & IO_MASK(USB_SB_command, eol)) !=
17053 + IO_STATE(USB_SB_command, eol, yes)) {
17054 + ASSERT(temp_sb_desc->next);
17055 + temp_sb_desc = phys_to_virt(temp_sb_desc->next);
17056 + }
17057 +
17058 + isoc_dbg("Appended URB:0x%x[%d] (first:0x%x last:0x%x) to epid:%d"
17059 + " sub:0x%x eol:0x%x\n",
17060 + (unsigned int)urb, urb_priv->urb_num,
17061 + (unsigned int)(urb_priv->first_sb),
17062 + (unsigned int)(urb_priv->last_sb), epid,
17063 + (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
17064 + (unsigned int)temp_sb_desc);
17065 +
17066 + /* Next pointer must be set before eol is removed. */
17067 + temp_sb_desc->next = virt_to_phys(urb_priv->first_sb);
17068 + /* Clear the previous end of list flag since there is a new in the
17069 + added SB descriptor list. */
17070 + temp_sb_desc->command &= ~IO_MASK(USB_SB_command, eol);
17071 +
17072 + if (!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
17073 + __u32 epid_data;
17074 + /* 8.8.5 in Designer's Reference says we should check for and correct
17075 + any errors in the EP here. That should not be necessary if
17076 + epid_attn is handled correctly, so we assume all is ok. */
17077 + epid_data = etrax_epid_iso_get(epid);
17078 + if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) !=
17079 + IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
17080 + isoc_err("Disabled Isoc EP with error:%d on epid:%d when appending"
17081 + " URB:0x%x[%d]\n",
17082 + IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data), epid,
17083 + (unsigned int)urb, urb_priv->urb_num);
17084 + }
17085 +
17086 + /* The SB list was exhausted. */
17087 + if (virt_to_phys(urb_priv->last_sb) != TxIsocEPList[epid].sub) {
17088 + /* The new sublist did not get processed before the EP was
17089 + disabled. Setup the EP again. */
17090 +
17091 + if(virt_to_phys(temp_sb_desc) == TxIsocEPList[epid].sub) {
17092 + isoc_dbg("EP for epid:%d stoped at SB:0x%x before newly inserted"
17093 + ", restarting from this URBs SB:0x%x\n",
17094 + epid, (unsigned int)temp_sb_desc,
17095 + (unsigned int)(urb_priv->first_sb));
17096 + TxIsocEPList[epid].hw_len = 0;
17097 + TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
17098 + urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
17099 + /* Enable the EP again so data gets processed this time */
17100 + TxIsocEPList[epid].command |=
17101 + IO_STATE(USB_EP_command, enable, yes);
17102 +
17103 + } else {
17104 + /* The EP has been disabled but not at end this URB (god knows
17105 + where). This should generate an epid_attn so we should not be
17106 + here */
17107 + isoc_warn("EP was disabled on sb:0x%x before SB list for"
17108 + " URB:0x%x[%d] got processed\n",
17109 + (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
17110 + (unsigned int)urb, urb_priv->urb_num);
17111 + }
17112 + } else {
17113 + /* This might happend if we are slow on this function and isn't
17114 + an error. */
17115 + isoc_dbg("EP was disabled and finished with SBs from appended"
17116 + " URB:0x%x[%d]\n", (unsigned int)urb, urb_priv->urb_num);
17117 + }
17118 + }
17119 + }
17120 + }
17121 +
17122 + /* Start the DMA sub channel */
17123 + *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
17124 +
17125 + local_irq_restore(flags);
17126 +}
17127 +
17128 +static void tc_dma_unlink_intr_urb(struct urb *urb) {
17129 + struct crisv10_urb_priv *urb_priv = urb->hcpriv;
17130 + volatile struct USB_EP_Desc *first_ep; /* First EP in the list. */
17131 + volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
17132 + volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
17133 + volatile struct USB_EP_Desc *unlink_ep; /* The one we should remove from
17134 + the list. */
17135 + int count = 0;
17136 + volatile int timeout = 10000;
17137 + int epid;
17138 +
17139 + /* Read 8.8.4 in Designer's Reference, "Removing an EP Descriptor from the
17140 + List". */
17141 + ASSERT(urb_priv);
17142 + ASSERT(urb_priv->intr_ep_pool_length > 0);
17143 + epid = urb_priv->epid;
17144 +
17145 + /* First disable all Intr EPs belonging to epid for this URB */
17146 + first_ep = &TxIntrEPList[0];
17147 + curr_ep = first_ep;
17148 + do {
17149 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
17150 + if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
17151 + /* Disable EP */
17152 + next_ep->command &= ~IO_MASK(USB_EP_command, enable);
17153 + }
17154 + curr_ep = phys_to_virt(curr_ep->next);
17155 + } while (curr_ep != first_ep);
17156 +
17157 +
17158 + /* Now unlink all EPs belonging to this epid from Descr list */
17159 + first_ep = &TxIntrEPList[0];
17160 + curr_ep = first_ep;
17161 + do {
17162 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
17163 + if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
17164 + /* This is the one we should unlink. */
17165 + unlink_ep = next_ep;
17166 +
17167 + /* Actually unlink the EP from the DMA list. */
17168 + curr_ep->next = unlink_ep->next;
17169 +
17170 + /* Wait until the DMA is no longer at this descriptor. */
17171 + while((*R_DMA_CH8_SUB2_EP == virt_to_phys(unlink_ep)) &&
17172 + (timeout-- > 0));
17173 + if(timeout == 0) {
17174 + warn("Timeout while waiting for DMA-TX-Intr to leave unlink EP\n");
17175 + }
17176 +
17177 + count++;
17178 + }
17179 + curr_ep = phys_to_virt(curr_ep->next);
17180 + } while (curr_ep != first_ep);
17181 +
17182 + if(count != urb_priv->intr_ep_pool_length) {
17183 + intr_warn("Unlinked %d of %d Intr EPs for URB:0x%x[%d]\n", count,
17184 + urb_priv->intr_ep_pool_length, (unsigned int)urb,
17185 + urb_priv->urb_num);
17186 + } else {
17187 + intr_dbg("Unlinked %d of %d interrupt EPs for URB:0x%x\n", count,
17188 + urb_priv->intr_ep_pool_length, (unsigned int)urb);
17189 + }
17190 +}
17191 +
17192 +static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
17193 + int timer) {
17194 + unsigned long flags;
17195 + int epid;
17196 + struct urb *urb;
17197 + struct crisv10_urb_priv * urb_priv;
17198 + __u32 epid_data;
17199 +
17200 + /* Protect TxEPList */
17201 + local_irq_save(flags);
17202 +
17203 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
17204 + /* A finished EP descriptor is disabled and has a valid sub pointer */
17205 + if (!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
17206 + (TxBulkEPList[epid].sub != 0)) {
17207 +
17208 + /* Get the active URB for this epid */
17209 + urb = activeUrbList[epid];
17210 + /* Sanity checks */
17211 + ASSERT(urb);
17212 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
17213 + ASSERT(urb_priv);
17214 +
17215 + /* Only handle finished out Bulk EPs here,
17216 + and let RX interrupt take care of the rest */
17217 + if(!epid_out_traffic(epid)) {
17218 + continue;
17219 + }
17220 +
17221 + if(timer) {
17222 + tc_warn("Found finished %s Bulk epid:%d URB:0x%x[%d] from timeout\n",
17223 + epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
17224 + urb_priv->urb_num);
17225 + } else {
17226 + tc_dbg("Found finished %s Bulk epid:%d URB:0x%x[%d] from interrupt\n",
17227 + epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
17228 + urb_priv->urb_num);
17229 + }
17230 +
17231 + if(urb_priv->urb_state == UNLINK) {
17232 + /* This Bulk URB is requested to be unlinked, that means that the EP
17233 + has been disabled and we might not have sent all data */
17234 + tc_finish_urb(hcd, urb, urb->status);
17235 + continue;
17236 + }
17237 +
17238 + ASSERT(urb_priv->urb_state == STARTED);
17239 + if (phys_to_virt(TxBulkEPList[epid].sub) != urb_priv->last_sb) {
17240 + tc_err("Endpoint got disabled before reaching last sb\n");
17241 + }
17242 +
17243 + epid_data = etrax_epid_get(epid);
17244 + if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
17245 + IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
17246 + /* This means that the endpoint has no error, is disabled
17247 + and had inserted traffic, i.e. transfer successfully completed. */
17248 + tc_finish_urb(hcd, urb, 0);
17249 + } else {
17250 + /* Shouldn't happen. We expect errors to be caught by epid
17251 + attention. */
17252 + tc_err("Found disabled bulk EP desc (epid:%d error:%d)\n",
17253 + epid, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
17254 + }
17255 + } else {
17256 + tc_dbg("Ignoring In Bulk epid:%d, let RX interrupt handle it\n", epid);
17257 + }
17258 + }
17259 +
17260 + local_irq_restore(flags);
17261 +}
17262 +
17263 +static void check_finished_ctrl_tx_epids(struct usb_hcd *hcd) {
17264 + unsigned long flags;
17265 + int epid;
17266 + struct urb *urb;
17267 + struct crisv10_urb_priv * urb_priv;
17268 + __u32 epid_data;
17269 +
17270 + /* Protect TxEPList */
17271 + local_irq_save(flags);
17272 +
17273 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
17274 + if(epid == DUMMY_EPID)
17275 + continue;
17276 +
17277 + /* A finished EP descriptor is disabled and has a valid sub pointer */
17278 + if (!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
17279 + (TxCtrlEPList[epid].sub != 0)) {
17280 +
17281 + /* Get the active URB for this epid */
17282 + urb = activeUrbList[epid];
17283 +
17284 + if(urb == NULL) {
17285 + tc_warn("Found finished Ctrl epid:%d with no active URB\n", epid);
17286 + continue;
17287 + }
17288 +
17289 + /* Sanity checks */
17290 + ASSERT(usb_pipein(urb->pipe));
17291 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
17292 + ASSERT(urb_priv);
17293 + if (phys_to_virt(TxCtrlEPList[epid].sub) != urb_priv->last_sb) {
17294 + tc_err("Endpoint got disabled before reaching last sb\n");
17295 + }
17296 +
17297 + epid_data = etrax_epid_get(epid);
17298 + if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
17299 + IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
17300 + /* This means that the endpoint has no error, is disabled
17301 + and had inserted traffic, i.e. transfer successfully completed. */
17302 +
17303 + /* Check if RX-interrupt for In Ctrl has been processed before
17304 + finishing the URB */
17305 + if(urb_priv->ctrl_rx_done) {
17306 + tc_dbg("Finishing In Ctrl URB:0x%x[%d] in tx_interrupt\n",
17307 + (unsigned int)urb, urb_priv->urb_num);
17308 + tc_finish_urb(hcd, urb, 0);
17309 + } else {
17310 + /* If we get zout descriptor interrupt before RX was done for a
17311 + In Ctrl transfer, then we flag that and it will be finished
17312 + in the RX-Interrupt */
17313 + urb_priv->ctrl_zout_done = 1;
17314 + tc_dbg("Got zout descr interrupt before RX interrupt\n");
17315 + }
17316 + } else {
17317 + /* Shouldn't happen. We expect errors to be caught by epid
17318 + attention. */
17319 + tc_err("Found disabled Ctrl EP desc (epid:%d URB:0x%x[%d]) error_code:%d\n", epid, (unsigned int)urb, urb_priv->urb_num, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
17320 + __dump_ep_desc(&(TxCtrlEPList[epid]));
17321 + __dump_ept_data(epid);
17322 + }
17323 + }
17324 + }
17325 + local_irq_restore(flags);
17326 +}
17327 +
17328 +/* This function goes through all epids that are setup for Out Isoc transfers
17329 + and marks (isoc_out_done) all queued URBs that the DMA has finished
17330 + transfer for.
17331 + No URB completetion is done here to make interrupt routine return quickly.
17332 + URBs are completed later with help of complete_isoc_bottom_half() that
17333 + becomes schedules when this functions is finished. */
17334 +static void check_finished_isoc_tx_epids(void) {
17335 + unsigned long flags;
17336 + int epid;
17337 + struct urb *urb;
17338 + struct crisv10_urb_priv * urb_priv;
17339 + struct USB_SB_Desc* sb_desc;
17340 + int epid_done;
17341 +
17342 + /* Protect TxIsocEPList */
17343 + local_irq_save(flags);
17344 +
17345 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
17346 + if (TxIsocEPList[epid].sub == 0 || epid == INVALID_EPID ||
17347 + !epid_out_traffic(epid)) {
17348 + /* Nothing here to see. */
17349 + continue;
17350 + }
17351 + ASSERT(epid_inuse(epid));
17352 + ASSERT(epid_isoc(epid));
17353 +
17354 + sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
17355 + /* Find the last descriptor of the currently active URB for this ep.
17356 + This is the first descriptor in the sub list marked for a descriptor
17357 + interrupt. */
17358 + while (sb_desc && !IO_EXTRACT(USB_SB_command, intr, sb_desc->command)) {
17359 + sb_desc = sb_desc->next ? phys_to_virt(sb_desc->next) : 0;
17360 + }
17361 + ASSERT(sb_desc);
17362 +
17363 + isoc_dbg("Descr IRQ checking epid:%d sub:0x%x intr:0x%x\n",
17364 + epid, (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
17365 + (unsigned int)sb_desc);
17366 +
17367 + urb = activeUrbList[epid];
17368 + if(urb == NULL) {
17369 + isoc_err("Isoc Descr irq on epid:%d with no active URB\n", epid);
17370 + continue;
17371 + }
17372 +
17373 + epid_done = 0;
17374 + while(urb && !epid_done) {
17375 + /* Sanity check. */
17376 + ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
17377 + ASSERT(usb_pipeout(urb->pipe));
17378 +
17379 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
17380 + ASSERT(urb_priv);
17381 + ASSERT(urb_priv->urb_state == STARTED ||
17382 + urb_priv->urb_state == UNLINK);
17383 +
17384 + if (sb_desc != urb_priv->last_sb) {
17385 + /* This urb has been sent. */
17386 + urb_priv->isoc_out_done = 1;
17387 +
17388 + } else { /* Found URB that has last_sb as the interrupt reason */
17389 +
17390 + /* Check if EP has been disabled, meaning that all transfers are done*/
17391 + if(!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
17392 + ASSERT((sb_desc->command & IO_MASK(USB_SB_command, eol)) ==
17393 + IO_STATE(USB_SB_command, eol, yes));
17394 + ASSERT(sb_desc->next == 0);
17395 + urb_priv->isoc_out_done = 1;
17396 + } else {
17397 + isoc_dbg("Skipping URB:0x%x[%d] because EP not disabled yet\n",
17398 + (unsigned int)urb, urb_priv->urb_num);
17399 + }
17400 + /* Stop looking any further in queue */
17401 + epid_done = 1;
17402 + }
17403 +
17404 + if (!epid_done) {
17405 + if(urb == activeUrbList[epid]) {
17406 + urb = urb_list_first(epid);
17407 + } else {
17408 + urb = urb_list_next(urb, epid);
17409 + }
17410 + }
17411 + } /* END: while(urb && !epid_done) */
17412 + }
17413 +
17414 + local_irq_restore(flags);
17415 +}
17416 +
17417 +
17418 +/* This is where the Out Isoc URBs are realy completed. This function is
17419 + scheduled from tc_dma_tx_interrupt() when one or more Out Isoc transfers
17420 + are done. This functions completes all URBs earlier marked with
17421 + isoc_out_done by fast interrupt routine check_finished_isoc_tx_epids() */
17422 +
17423 +static void complete_isoc_bottom_half(void *data) {
17424 + struct crisv10_isoc_complete_data *comp_data;
17425 + struct usb_iso_packet_descriptor *packet;
17426 + struct crisv10_urb_priv * urb_priv;
17427 + unsigned long flags;
17428 + struct urb* urb;
17429 + int epid_done;
17430 + int epid;
17431 + int i;
17432 +
17433 + comp_data = (struct crisv10_isoc_complete_data*)data;
17434 +
17435 + local_irq_save(flags);
17436 +
17437 + for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
17438 + if(!epid_inuse(epid) || !epid_isoc(epid) || !epid_out_traffic(epid) || epid == DUMMY_EPID) {
17439 + /* Only check valid Out Isoc epids */
17440 + continue;
17441 + }
17442 +
17443 + isoc_dbg("Isoc bottom-half checking epid:%d, sub:0x%x\n", epid,
17444 + (unsigned int)phys_to_virt(TxIsocEPList[epid].sub));
17445 +
17446 + /* The descriptor interrupt handler has marked all transmitted Out Isoc
17447 + URBs with isoc_out_done. Now we traverse all epids and for all that
17448 + have out Isoc traffic we traverse its URB list and complete the
17449 + transmitted URBs. */
17450 + epid_done = 0;
17451 + while (!epid_done) {
17452 +
17453 + /* Get the active urb (if any) */
17454 + urb = activeUrbList[epid];
17455 + if (urb == 0) {
17456 + isoc_dbg("No active URB on epid:%d anymore\n", epid);
17457 + epid_done = 1;
17458 + continue;
17459 + }
17460 +
17461 + /* Sanity check. */
17462 + ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
17463 + ASSERT(usb_pipeout(urb->pipe));
17464 +
17465 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
17466 + ASSERT(urb_priv);
17467 +
17468 + if (!(urb_priv->isoc_out_done)) {
17469 + /* We have reached URB that isn't flaged done yet, stop traversing. */
17470 + isoc_dbg("Stoped traversing Out Isoc URBs on epid:%d"
17471 + " before not yet flaged URB:0x%x[%d]\n",
17472 + epid, (unsigned int)urb, urb_priv->urb_num);
17473 + epid_done = 1;
17474 + continue;
17475 + }
17476 +
17477 + /* This urb has been sent. */
17478 + isoc_dbg("Found URB:0x%x[%d] that is flaged isoc_out_done\n",
17479 + (unsigned int)urb, urb_priv->urb_num);
17480 +
17481 + /* Set ok on transfered packets for this URB and finish it */
17482 + for (i = 0; i < urb->number_of_packets; i++) {
17483 + packet = &urb->iso_frame_desc[i];
17484 + packet->status = 0;
17485 + packet->actual_length = packet->length;
17486 + }
17487 + urb_priv->isoc_packet_counter = urb->number_of_packets;
17488 + tc_finish_urb(comp_data->hcd, urb, 0);
17489 +
17490 + } /* END: while(!epid_done) */
17491 + } /* END: for(epid...) */
17492 +
17493 + local_irq_restore(flags);
17494 + kmem_cache_free(isoc_compl_cache, comp_data);
17495 +}
17496 +
17497 +
17498 +static void check_finished_intr_tx_epids(struct usb_hcd *hcd) {
17499 + unsigned long flags;
17500 + int epid;
17501 + struct urb *urb;
17502 + struct crisv10_urb_priv * urb_priv;
17503 + volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
17504 + volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
17505 +
17506 + /* Protect TxintrEPList */
17507 + local_irq_save(flags);
17508 +
17509 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
17510 + if(!epid_inuse(epid) || !epid_intr(epid) || !epid_out_traffic(epid)) {
17511 + /* Nothing to see on this epid. Only check valid Out Intr epids */
17512 + continue;
17513 + }
17514 +
17515 + urb = activeUrbList[epid];
17516 + if(urb == 0) {
17517 + intr_warn("Found Out Intr epid:%d with no active URB\n", epid);
17518 + continue;
17519 + }
17520 +
17521 + /* Sanity check. */
17522 + ASSERT(usb_pipetype(urb->pipe) == PIPE_INTERRUPT);
17523 + ASSERT(usb_pipeout(urb->pipe));
17524 +
17525 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
17526 + ASSERT(urb_priv);
17527 +
17528 + /* Go through EPs between first and second sof-EP. It's here Out Intr EPs
17529 + are inserted.*/
17530 + curr_ep = &TxIntrEPList[0];
17531 + do {
17532 + next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
17533 + if(next_ep == urb_priv->intr_ep_pool[0]) {
17534 + /* We found the Out Intr EP for this epid */
17535 +
17536 + /* Disable it so it doesn't get processed again */
17537 + next_ep->command &= ~IO_MASK(USB_EP_command, enable);
17538 +
17539 + /* Finish the active Out Intr URB with status OK */
17540 + tc_finish_urb(hcd, urb, 0);
17541 + }
17542 + curr_ep = phys_to_virt(curr_ep->next);
17543 + } while (curr_ep != &TxIntrEPList[1]);
17544 +
17545 + }
17546 + local_irq_restore(flags);
17547 +}
17548 +
17549 +/* Interrupt handler for DMA8/IRQ24 with subchannels (called from hardware intr) */
17550 +static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc) {
17551 + struct usb_hcd *hcd = (struct usb_hcd*)vhc;
17552 + ASSERT(hcd);
17553 +
17554 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub0_descr)) {
17555 + /* Clear this interrupt */
17556 + *R_DMA_CH8_SUB0_CLR_INTR = IO_STATE(R_DMA_CH8_SUB0_CLR_INTR, clr_descr, do);
17557 + restart_dma8_sub0();
17558 + }
17559 +
17560 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub1_descr)) {
17561 + /* Clear this interrupt */
17562 + *R_DMA_CH8_SUB1_CLR_INTR = IO_STATE(R_DMA_CH8_SUB1_CLR_INTR, clr_descr, do);
17563 + check_finished_ctrl_tx_epids(hcd);
17564 + }
17565 +
17566 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub2_descr)) {
17567 + /* Clear this interrupt */
17568 + *R_DMA_CH8_SUB2_CLR_INTR = IO_STATE(R_DMA_CH8_SUB2_CLR_INTR, clr_descr, do);
17569 + check_finished_intr_tx_epids(hcd);
17570 + }
17571 +
17572 + if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub3_descr)) {
17573 + struct crisv10_isoc_complete_data* comp_data;
17574 +
17575 + /* Flag done Out Isoc for later completion */
17576 + check_finished_isoc_tx_epids();
17577 +
17578 + /* Clear this interrupt */
17579 + *R_DMA_CH8_SUB3_CLR_INTR = IO_STATE(R_DMA_CH8_SUB3_CLR_INTR, clr_descr, do);
17580 + /* Schedule bottom half of Out Isoc completion function. This function
17581 + finishes the URBs marked with isoc_out_done */
17582 + comp_data = (struct crisv10_isoc_complete_data*)
17583 + kmem_cache_alloc(isoc_compl_cache, SLAB_ATOMIC);
17584 + ASSERT(comp_data != NULL);
17585 + comp_data ->hcd = hcd;
17586 +
17587 + INIT_WORK(&comp_data->usb_bh, complete_isoc_bottom_half, comp_data);
17588 + schedule_work(&comp_data->usb_bh);
17589 + }
17590 +
17591 + return IRQ_HANDLED;
17592 +}
17593 +
17594 +/* Interrupt handler for DMA9/IRQ25 (called from hardware intr) */
17595 +static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc) {
17596 + unsigned long flags;
17597 + struct urb *urb;
17598 + struct usb_hcd *hcd = (struct usb_hcd*)vhc;
17599 + struct crisv10_urb_priv *urb_priv;
17600 + int epid = 0;
17601 + int real_error;
17602 +
17603 + ASSERT(hcd);
17604 +
17605 + /* Clear this interrupt. */
17606 + *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do);
17607 +
17608 + /* Custom clear interrupt for this interrupt */
17609 + /* The reason we cli here is that we call the driver's callback functions. */
17610 + local_irq_save(flags);
17611 +
17612 + /* Note that this while loop assumes that all packets span only
17613 + one rx descriptor. */
17614 + while(myNextRxDesc->status & IO_MASK(USB_IN_status, eop)) {
17615 + epid = IO_EXTRACT(USB_IN_status, epid, myNextRxDesc->status);
17616 + /* Get the active URB for this epid */
17617 + urb = activeUrbList[epid];
17618 +
17619 + ASSERT(epid_inuse(epid));
17620 + if (!urb) {
17621 + dma_err("No urb for epid %d in rx interrupt\n", epid);
17622 + goto skip_out;
17623 + }
17624 +
17625 + /* Check if any errors on epid */
17626 + real_error = 0;
17627 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, error)) {
17628 + __u32 r_usb_ept_data;
17629 +
17630 + if (usb_pipeisoc(urb->pipe)) {
17631 + r_usb_ept_data = etrax_epid_iso_get(epid);
17632 + if((r_usb_ept_data & IO_MASK(R_USB_EPT_DATA_ISO, valid)) &&
17633 + (IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data) == 0) &&
17634 + (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata))) {
17635 + /* Not an error, just a failure to receive an expected iso
17636 + in packet in this frame. This is not documented
17637 + in the designers reference. Continue processing.
17638 + */
17639 + } else real_error = 1;
17640 + } else real_error = 1;
17641 + }
17642 +
17643 + if(real_error) {
17644 + dma_err("Error in RX descr on epid:%d for URB 0x%x",
17645 + epid, (unsigned int)urb);
17646 + dump_ept_data(epid);
17647 + dump_in_desc(myNextRxDesc);
17648 + goto skip_out;
17649 + }
17650 +
17651 + urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
17652 + ASSERT(urb_priv);
17653 + ASSERT(urb_priv->urb_state == STARTED ||
17654 + urb_priv->urb_state == UNLINK);
17655 +
17656 + if ((usb_pipetype(urb->pipe) == PIPE_BULK) ||
17657 + (usb_pipetype(urb->pipe) == PIPE_CONTROL) ||
17658 + (usb_pipetype(urb->pipe) == PIPE_INTERRUPT)) {
17659 +
17660 + /* We get nodata for empty data transactions, and the rx descriptor's
17661 + hw_len field is not valid in that case. No data to copy in other
17662 + words. */
17663 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
17664 + /* No data to copy */
17665 + } else {
17666 + /*
17667 + dma_dbg("Processing RX for URB:0x%x epid:%d (data:%d ofs:%d)\n",
17668 + (unsigned int)urb, epid, myNextRxDesc->hw_len,
17669 + urb_priv->rx_offset);
17670 + */
17671 + /* Only copy data if URB isn't flaged to be unlinked*/
17672 + if(urb_priv->urb_state != UNLINK) {
17673 + /* Make sure the data fits in the buffer. */
17674 + if(urb_priv->rx_offset + myNextRxDesc->hw_len
17675 + <= urb->transfer_buffer_length) {
17676 +
17677 + /* Copy the data to URBs buffer */
17678 + memcpy(urb->transfer_buffer + urb_priv->rx_offset,
17679 + phys_to_virt(myNextRxDesc->buf), myNextRxDesc->hw_len);
17680 + urb_priv->rx_offset += myNextRxDesc->hw_len;
17681 + } else {
17682 + /* Signal overflow when returning URB */
17683 + urb->status = -EOVERFLOW;
17684 + tc_finish_urb_later(hcd, urb, urb->status);
17685 + }
17686 + }
17687 + }
17688 +
17689 + /* Check if it was the last packet in the transfer */
17690 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, eot)) {
17691 + /* Special handling for In Ctrl URBs. */
17692 + if(usb_pipecontrol(urb->pipe) && usb_pipein(urb->pipe) &&
17693 + !(urb_priv->ctrl_zout_done)) {
17694 + /* Flag that RX part of Ctrl transfer is done. Because zout descr
17695 + interrupt hasn't happend yet will the URB be finished in the
17696 + TX-Interrupt. */
17697 + urb_priv->ctrl_rx_done = 1;
17698 + tc_dbg("Not finishing In Ctrl URB:0x%x from rx_interrupt, waiting"
17699 + " for zout\n", (unsigned int)urb);
17700 + } else {
17701 + tc_finish_urb(hcd, urb, 0);
17702 + }
17703 + }
17704 + } else { /* ISOC RX */
17705 + /*
17706 + isoc_dbg("Processing RX for epid:%d (URB:0x%x) ISOC pipe\n",
17707 + epid, (unsigned int)urb);
17708 + */
17709 +
17710 + struct usb_iso_packet_descriptor *packet;
17711 +
17712 + if (urb_priv->urb_state == UNLINK) {
17713 + isoc_warn("Ignoring Isoc Rx data for urb being unlinked.\n");
17714 + goto skip_out;
17715 + } else if (urb_priv->urb_state == NOT_STARTED) {
17716 + isoc_err("What? Got Rx data for Isoc urb that isn't started?\n");
17717 + goto skip_out;
17718 + }
17719 +
17720 + packet = &urb->iso_frame_desc[urb_priv->isoc_packet_counter];
17721 + ASSERT(packet);
17722 + packet->status = 0;
17723 +
17724 + if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
17725 + /* We get nodata for empty data transactions, and the rx descriptor's
17726 + hw_len field is not valid in that case. We copy 0 bytes however to
17727 + stay in synch. */
17728 + packet->actual_length = 0;
17729 + } else {
17730 + packet->actual_length = myNextRxDesc->hw_len;
17731 + /* Make sure the data fits in the buffer. */
17732 + ASSERT(packet->actual_length <= packet->length);
17733 + memcpy(urb->transfer_buffer + packet->offset,
17734 + phys_to_virt(myNextRxDesc->buf), packet->actual_length);
17735 + if(packet->actual_length > 0)
17736 + isoc_dbg("Copied %d bytes, packet %d for URB:0x%x[%d]\n",
17737 + packet->actual_length, urb_priv->isoc_packet_counter,
17738 + (unsigned int)urb, urb_priv->urb_num);
17739 + }
17740 +
17741 + /* Increment the packet counter. */
17742 + urb_priv->isoc_packet_counter++;
17743 +
17744 + /* Note that we don't care about the eot field in the rx descriptor's
17745 + status. It will always be set for isoc traffic. */
17746 + if (urb->number_of_packets == urb_priv->isoc_packet_counter) {
17747 + /* Complete the urb with status OK. */
17748 + tc_finish_urb(hcd, urb, 0);
17749 + }
17750 + }
17751 +
17752 + skip_out:
17753 + myNextRxDesc->status = 0;
17754 + myNextRxDesc->command |= IO_MASK(USB_IN_command, eol);
17755 + myLastRxDesc->command &= ~IO_MASK(USB_IN_command, eol);
17756 + myLastRxDesc = myNextRxDesc;
17757 + myNextRxDesc = phys_to_virt(myNextRxDesc->next);
17758 + flush_etrax_cache();
17759 + *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, restart);
17760 + }
17761 +
17762 + local_irq_restore(flags);
17763 +
17764 + return IRQ_HANDLED;
17765 +}
17766 +
17767 +static void tc_bulk_start_timer_func(unsigned long dummy) {
17768 + /* We might enable an EP descriptor behind the current DMA position when
17769 + it's about to decide that there are no more bulk traffic and it should
17770 + stop the bulk channel.
17771 + Therefore we periodically check if the bulk channel is stopped and there
17772 + is an enabled bulk EP descriptor, in which case we start the bulk
17773 + channel. */
17774 +
17775 + if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
17776 + int epid;
17777 +
17778 + timer_dbg("bulk_start_timer: Bulk DMA channel not running.\n");
17779 +
17780 + for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
17781 + if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
17782 + timer_warn("Found enabled EP for epid %d, starting bulk channel.\n",
17783 + epid);
17784 + restart_dma8_sub0();
17785 +
17786 + /* Restart the bulk eot timer since we just started the bulk channel.*/
17787 + mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
17788 +
17789 + /* No need to search any further. */
17790 + break;
17791 + }
17792 + }
17793 + } else {
17794 + timer_dbg("bulk_start_timer: Bulk DMA channel running.\n");
17795 + }
17796 +}
17797 +
17798 +static void tc_bulk_eot_timer_func(unsigned long dummy) {
17799 + struct usb_hcd *hcd = (struct usb_hcd*)dummy;
17800 + ASSERT(hcd);
17801 + /* Because of a race condition in the top half, we might miss a bulk eot.
17802 + This timer "simulates" a bulk eot if we don't get one for a while,
17803 + hopefully correcting the situation. */
17804 + timer_dbg("bulk_eot_timer timed out.\n");
17805 + check_finished_bulk_tx_epids(hcd, 1);
17806 +}
17807 +
17808 +
17809 +/*************************************************************/
17810 +/*************************************************************/
17811 +/* Device driver block */
17812 +/*************************************************************/
17813 +/*************************************************************/
17814 +
17815 +/* Forward declarations for device driver functions */
17816 +static int devdrv_hcd_probe(struct device *);
17817 +static int devdrv_hcd_remove(struct device *);
17818 +#ifdef CONFIG_PM
17819 +static int devdrv_hcd_suspend(struct device *, u32, u32);
17820 +static int devdrv_hcd_resume(struct device *, u32);
17821 +#endif /* CONFIG_PM */
17822 +
17823 +/* the device */
17824 +static struct platform_device *devdrv_hc_platform_device;
17825 +
17826 +/* device driver interface */
17827 +static struct device_driver devdrv_hc_device_driver = {
17828 + .name = (char *) hc_name,
17829 + .bus = &platform_bus_type,
17830 +
17831 + .probe = devdrv_hcd_probe,
17832 + .remove = devdrv_hcd_remove,
17833 +
17834 +#ifdef CONFIG_PM
17835 + .suspend = devdrv_hcd_suspend,
17836 + .resume = devdrv_hcd_resume,
17837 +#endif /* CONFIG_PM */
17838 +};
17839 +
17840 +/* initialize the host controller and driver */
17841 +static int __init_or_module devdrv_hcd_probe(struct device *dev)
17842 +{
17843 + struct usb_hcd *hcd;
17844 + struct crisv10_hcd *crisv10_hcd;
17845 + int retval;
17846 +
17847 + /* Check DMA burst length */
17848 + if(IO_EXTRACT(R_BUS_CONFIG, dma_burst, *R_BUS_CONFIG) !=
17849 + IO_STATE(R_BUS_CONFIG, dma_burst, burst32)) {
17850 + devdrv_err("Invalid DMA burst length in Etrax 100LX,"
17851 + " needs to be 32\n");
17852 + return -EPERM;
17853 + }
17854 +
17855 + hcd = usb_create_hcd(&crisv10_hc_driver, dev, dev->bus_id);
17856 + if (!hcd)
17857 + return -ENOMEM;
17858 +
17859 + crisv10_hcd = hcd_to_crisv10_hcd(hcd);
17860 + spin_lock_init(&crisv10_hcd->lock);
17861 + crisv10_hcd->num_ports = num_ports();
17862 + crisv10_hcd->running = 0;
17863 +
17864 + dev_set_drvdata(dev, crisv10_hcd);
17865 +
17866 + devdrv_dbg("ETRAX USB IRQs HC:%d RX:%d TX:%d\n", ETRAX_USB_HC_IRQ,
17867 + ETRAX_USB_RX_IRQ, ETRAX_USB_TX_IRQ);
17868 +
17869 + /* Print out chip version read from registers */
17870 + int rev_maj = *R_USB_REVISION & IO_MASK(R_USB_REVISION, major);
17871 + int rev_min = *R_USB_REVISION & IO_MASK(R_USB_REVISION, minor);
17872 + if(rev_min == 0) {
17873 + devdrv_info("Etrax 100LX USB Revision %d v1,2\n", rev_maj);
17874 + } else {
17875 + devdrv_info("Etrax 100LX USB Revision %d v%d\n", rev_maj, rev_min);
17876 + }
17877 +
17878 + devdrv_info("Bulk timer interval, start:%d eot:%d\n",
17879 + BULK_START_TIMER_INTERVAL,
17880 + BULK_EOT_TIMER_INTERVAL);
17881 +
17882 +
17883 + /* Init root hub data structures */
17884 + if(rh_init()) {
17885 + devdrv_err("Failed init data for Root Hub\n");
17886 + retval = -ENOMEM;
17887 + }
17888 +
17889 + if(port_in_use(0)) {
17890 + if (cris_request_io_interface(if_usb_1, "ETRAX100LX USB-HCD")) {
17891 + printk(KERN_CRIT "usb-host: request IO interface usb1 failed");
17892 + retval = -EBUSY;
17893 + goto out;
17894 + }
17895 + devdrv_info("Claimed interface for USB physical port 1\n");
17896 + }
17897 + if(port_in_use(1)) {
17898 + if (cris_request_io_interface(if_usb_2, "ETRAX100LX USB-HCD")) {
17899 + /* Free first interface if second failed to be claimed */
17900 + if(port_in_use(0)) {
17901 + cris_free_io_interface(if_usb_1);
17902 + }
17903 + printk(KERN_CRIT "usb-host: request IO interface usb2 failed");
17904 + retval = -EBUSY;
17905 + goto out;
17906 + }
17907 + devdrv_info("Claimed interface for USB physical port 2\n");
17908 + }
17909 +
17910 + /* Init transfer controller structs and locks */
17911 + if((retval = tc_init(hcd)) != 0) {
17912 + goto out;
17913 + }
17914 +
17915 + /* Attach interrupt functions for DMA and init DMA controller */
17916 + if((retval = tc_dma_init(hcd)) != 0) {
17917 + goto out;
17918 + }
17919 +
17920 + /* Attach the top IRQ handler for USB controller interrupts */
17921 + if (request_irq(ETRAX_USB_HC_IRQ, crisv10_hcd_top_irq, 0,
17922 + "ETRAX 100LX built-in USB (HC)", hcd)) {
17923 + err("Could not allocate IRQ %d for USB", ETRAX_USB_HC_IRQ);
17924 + retval = -EBUSY;
17925 + goto out;
17926 + }
17927 +
17928 + /* iso_eof is only enabled when isoc traffic is running. */
17929 + *R_USB_IRQ_MASK_SET =
17930 + /* IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set) | */
17931 + IO_STATE(R_USB_IRQ_MASK_SET, bulk_eot, set) |
17932 + IO_STATE(R_USB_IRQ_MASK_SET, epid_attn, set) |
17933 + IO_STATE(R_USB_IRQ_MASK_SET, port_status, set) |
17934 + IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
17935 +
17936 +
17937 + crisv10_ready_wait();
17938 + /* Reset the USB interface. */
17939 + *R_USB_COMMAND =
17940 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
17941 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
17942 + IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
17943 +
17944 + /* Designer's Reference, p. 8 - 10 says we should Initate R_USB_FM_PSTART to
17945 + 0x2A30 (10800), to guarantee that control traffic gets 10% of the
17946 + bandwidth, and periodic transfer may allocate the rest (90%).
17947 + This doesn't work though.
17948 + The value 11960 is chosen to be just after the SOF token, with a couple
17949 + of bit times extra for possible bit stuffing. */
17950 + *R_USB_FM_PSTART = IO_FIELD(R_USB_FM_PSTART, value, 11960);
17951 +
17952 + crisv10_ready_wait();
17953 + /* Configure the USB interface as a host controller. */
17954 + *R_USB_COMMAND =
17955 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
17956 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
17957 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_config);
17958 +
17959 +
17960 + /* Check so controller not busy before enabling ports */
17961 + crisv10_ready_wait();
17962 +
17963 + /* Enable selected USB ports */
17964 + if(port_in_use(0)) {
17965 + *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
17966 + } else {
17967 + *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
17968 + }
17969 + if(port_in_use(1)) {
17970 + *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
17971 + } else {
17972 + *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
17973 + }
17974 +
17975 + crisv10_ready_wait();
17976 + /* Start processing of USB traffic. */
17977 + *R_USB_COMMAND =
17978 + IO_STATE(R_USB_COMMAND, port_sel, nop) |
17979 + IO_STATE(R_USB_COMMAND, port_cmd, reset) |
17980 + IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
17981 +
17982 + /* Do not continue probing initialization before USB interface is done */
17983 + crisv10_ready_wait();
17984 +
17985 + /* Register our Host Controller to USB Core
17986 + * Finish the remaining parts of generic HCD initialization: allocate the
17987 + * buffers of consistent memory, register the bus
17988 + * and call the driver's reset() and start() routines. */
17989 + retval = usb_add_hcd(hcd, ETRAX_USB_HC_IRQ, IRQF_DISABLED);
17990 + if (retval != 0) {
17991 + devdrv_err("Failed registering HCD driver\n");
17992 + goto out;
17993 + }
17994 +
17995 + return 0;
17996 +
17997 + out:
17998 + devdrv_hcd_remove(dev);
17999 + return retval;
18000 +}
18001 +
18002 +
18003 +/* cleanup after the host controller and driver */
18004 +static int __init_or_module devdrv_hcd_remove(struct device *dev)
18005 +{
18006 + struct crisv10_hcd *crisv10_hcd = dev_get_drvdata(dev);
18007 + struct usb_hcd *hcd;
18008 +
18009 + if (!crisv10_hcd)
18010 + return 0;
18011 + hcd = crisv10_hcd_to_hcd(crisv10_hcd);
18012 +
18013 +
18014 + /* Stop USB Controller in Etrax 100LX */
18015 + crisv10_hcd_reset(hcd);
18016 +
18017 + usb_remove_hcd(hcd);
18018 + devdrv_dbg("Removed HCD from USB Core\n");
18019 +
18020 + /* Free USB Controller IRQ */
18021 + free_irq(ETRAX_USB_HC_IRQ, NULL);
18022 +
18023 + /* Free resources */
18024 + tc_dma_destroy();
18025 + tc_destroy();
18026 +
18027 +
18028 + if(port_in_use(0)) {
18029 + cris_free_io_interface(if_usb_1);
18030 + }
18031 + if(port_in_use(1)) {
18032 + cris_free_io_interface(if_usb_2);
18033 + }
18034 +
18035 + devdrv_dbg("Freed all claimed resources\n");
18036 +
18037 + return 0;
18038 +}
18039 +
18040 +
18041 +#ifdef CONFIG_PM
18042 +
18043 +static int devdrv_hcd_suspend(struct usb_hcd *hcd, u32 state, u32 level)
18044 +{
18045 + return 0; /* no-op for now */
18046 +}
18047 +
18048 +static int devdrv_hcd_resume(struct usb_hcd *hcd, u32 level)
18049 +{
18050 + return 0; /* no-op for now */
18051 +}
18052 +
18053 +#endif /* CONFIG_PM */
18054 +
18055 +
18056 +
18057 +/*************************************************************/
18058 +/*************************************************************/
18059 +/* Module block */
18060 +/*************************************************************/
18061 +/*************************************************************/
18062 +
18063 +/* register driver */
18064 +static int __init module_hcd_init(void)
18065 +{
18066 +
18067 + if (usb_disabled())
18068 + return -ENODEV;
18069 +
18070 + /* Here we select enabled ports by following defines created from
18071 + menuconfig */
18072 +#ifndef CONFIG_ETRAX_USB_HOST_PORT1
18073 + ports &= ~(1<<0);
18074 +#endif
18075 +#ifndef CONFIG_ETRAX_USB_HOST_PORT2
18076 + ports &= ~(1<<1);
18077 +#endif
18078 +
18079 + printk(KERN_INFO "%s version "VERSION" "COPYRIGHT"\n", product_desc);
18080 +
18081 + devdrv_hc_platform_device =
18082 + platform_device_register_simple((char *) hc_name, 0, NULL, 0);
18083 +
18084 + if (IS_ERR(devdrv_hc_platform_device))
18085 + return PTR_ERR(devdrv_hc_platform_device);
18086 + return driver_register(&devdrv_hc_device_driver);
18087 + /*
18088 + * Note that we do not set the DMA mask for the device,
18089 + * i.e. we pretend that we will use PIO, since no specific
18090 + * allocation routines are needed for DMA buffers. This will
18091 + * cause the HCD buffer allocation routines to fall back to
18092 + * kmalloc().
18093 + */
18094 +}
18095 +
18096 +/* unregister driver */
18097 +static void __exit module_hcd_exit(void)
18098 +{
18099 + driver_unregister(&devdrv_hc_device_driver);
18100 +}
18101 +
18102 +
18103 +/* Module hooks */
18104 +module_init(module_hcd_init);
18105 +module_exit(module_hcd_exit);
18106 --- linux-2.6.19.2.orig/drivers/usb/host/hc_crisv10.h 2007-01-10 20:10:37.000000000 +0100
18107 +++ linux-2.6.19.2.dev/drivers/usb/host/hc_crisv10.h 1970-01-01 01:00:00.000000000 +0100
18108 @@ -1,289 +0,0 @@
18109 -#ifndef __LINUX_ETRAX_USB_H
18110 -#define __LINUX_ETRAX_USB_H
18111 -
18112 -#include <linux/types.h>
18113 -#include <linux/list.h>
18114 -
18115 -typedef struct USB_IN_Desc {
18116 - volatile __u16 sw_len;
18117 - volatile __u16 command;
18118 - volatile unsigned long next;
18119 - volatile unsigned long buf;
18120 - volatile __u16 hw_len;
18121 - volatile __u16 status;
18122 -} USB_IN_Desc_t;
18123 -
18124 -typedef struct USB_SB_Desc {
18125 - volatile __u16 sw_len;
18126 - volatile __u16 command;
18127 - volatile unsigned long next;
18128 - volatile unsigned long buf;
18129 - __u32 dummy;
18130 -} USB_SB_Desc_t;
18131 -
18132 -typedef struct USB_EP_Desc {
18133 - volatile __u16 hw_len;
18134 - volatile __u16 command;
18135 - volatile unsigned long sub;
18136 - volatile unsigned long next;
18137 - __u32 dummy;
18138 -} USB_EP_Desc_t;
18139 -
18140 -struct virt_root_hub {
18141 - int devnum;
18142 - void *urb;
18143 - void *int_addr;
18144 - int send;
18145 - int interval;
18146 - int numports;
18147 - struct timer_list rh_int_timer;
18148 - volatile __u16 wPortChange_1;
18149 - volatile __u16 wPortChange_2;
18150 - volatile __u16 prev_wPortStatus_1;
18151 - volatile __u16 prev_wPortStatus_2;
18152 -};
18153 -
18154 -struct etrax_usb_intr_traffic {
18155 - int sleeping;
18156 - int error;
18157 - struct wait_queue *wq;
18158 -};
18159 -
18160 -typedef struct etrax_usb_hc {
18161 - struct usb_bus *bus;
18162 - struct virt_root_hub rh;
18163 - struct etrax_usb_intr_traffic intr;
18164 -} etrax_hc_t;
18165 -
18166 -typedef enum {
18167 - STARTED,
18168 - NOT_STARTED,
18169 - UNLINK,
18170 - TRANSFER_DONE,
18171 - WAITING_FOR_DESCR_INTR
18172 -} etrax_usb_urb_state_t;
18173 -
18174 -
18175 -
18176 -typedef struct etrax_usb_urb_priv {
18177 - /* The first_sb field is used for freeing all SB descriptors belonging
18178 - to an urb. The corresponding ep descriptor's sub pointer cannot be
18179 - used for this since the DMA advances the sub pointer as it processes
18180 - the sb list. */
18181 - USB_SB_Desc_t *first_sb;
18182 - /* The last_sb field referes to the last SB descriptor that belongs to
18183 - this urb. This is important to know so we can free the SB descriptors
18184 - that ranges between first_sb and last_sb. */
18185 - USB_SB_Desc_t *last_sb;
18186 -
18187 - /* The rx_offset field is used in ctrl and bulk traffic to keep track
18188 - of the offset in the urb's transfer_buffer where incoming data should be
18189 - copied to. */
18190 - __u32 rx_offset;
18191 -
18192 - /* Counter used in isochronous transfers to keep track of the
18193 - number of packets received/transmitted. */
18194 - __u32 isoc_packet_counter;
18195 -
18196 - /* This field is used to pass information about the urb's current state between
18197 - the various interrupt handlers (thus marked volatile). */
18198 - volatile etrax_usb_urb_state_t urb_state;
18199 -
18200 - /* Connection between the submitted urb and ETRAX epid number */
18201 - __u8 epid;
18202 -
18203 - /* The rx_data_list field is used for periodic traffic, to hold
18204 - received data for later processing in the the complete_urb functions,
18205 - where the data us copied to the urb's transfer_buffer. Basically, we
18206 - use this intermediate storage because we don't know when it's safe to
18207 - reuse the transfer_buffer (FIXME?). */
18208 - struct list_head rx_data_list;
18209 -} etrax_urb_priv_t;
18210 -
18211 -/* This struct is for passing data from the top half to the bottom half. */
18212 -typedef struct usb_interrupt_registers
18213 -{
18214 - etrax_hc_t *hc;
18215 - __u32 r_usb_epid_attn;
18216 - __u8 r_usb_status;
18217 - __u16 r_usb_rh_port_status_1;
18218 - __u16 r_usb_rh_port_status_2;
18219 - __u32 r_usb_irq_mask_read;
18220 - __u32 r_usb_fm_number;
18221 - struct work_struct usb_bh;
18222 -} usb_interrupt_registers_t;
18223 -
18224 -/* This struct is for passing data from the isoc top half to the isoc bottom half. */
18225 -typedef struct usb_isoc_complete_data
18226 -{
18227 - struct urb *urb;
18228 - struct work_struct usb_bh;
18229 -} usb_isoc_complete_data_t;
18230 -
18231 -/* This struct holds data we get from the rx descriptors for DMA channel 9
18232 - for periodic traffic (intr and isoc). */
18233 -typedef struct rx_data
18234 -{
18235 - void *data;
18236 - int length;
18237 - struct list_head list;
18238 -} rx_data_t;
18239 -
18240 -typedef struct urb_entry
18241 -{
18242 - struct urb *urb;
18243 - struct list_head list;
18244 -} urb_entry_t;
18245 -
18246 -/* ---------------------------------------------------------------------------
18247 - Virtual Root HUB
18248 - ------------------------------------------------------------------------- */
18249 -/* destination of request */
18250 -#define RH_INTERFACE 0x01
18251 -#define RH_ENDPOINT 0x02
18252 -#define RH_OTHER 0x03
18253 -
18254 -#define RH_CLASS 0x20
18255 -#define RH_VENDOR 0x40
18256 -
18257 -/* Requests: bRequest << 8 | bmRequestType */
18258 -#define RH_GET_STATUS 0x0080
18259 -#define RH_CLEAR_FEATURE 0x0100
18260 -#define RH_SET_FEATURE 0x0300
18261 -#define RH_SET_ADDRESS 0x0500
18262 -#define RH_GET_DESCRIPTOR 0x0680
18263 -#define RH_SET_DESCRIPTOR 0x0700
18264 -#define RH_GET_CONFIGURATION 0x0880
18265 -#define RH_SET_CONFIGURATION 0x0900
18266 -#define RH_GET_STATE 0x0280
18267 -#define RH_GET_INTERFACE 0x0A80
18268 -#define RH_SET_INTERFACE 0x0B00
18269 -#define RH_SYNC_FRAME 0x0C80
18270 -/* Our Vendor Specific Request */
18271 -#define RH_SET_EP 0x2000
18272 -
18273 -
18274 -/* Hub port features */
18275 -#define RH_PORT_CONNECTION 0x00
18276 -#define RH_PORT_ENABLE 0x01
18277 -#define RH_PORT_SUSPEND 0x02
18278 -#define RH_PORT_OVER_CURRENT 0x03
18279 -#define RH_PORT_RESET 0x04
18280 -#define RH_PORT_POWER 0x08
18281 -#define RH_PORT_LOW_SPEED 0x09
18282 -#define RH_C_PORT_CONNECTION 0x10
18283 -#define RH_C_PORT_ENABLE 0x11
18284 -#define RH_C_PORT_SUSPEND 0x12
18285 -#define RH_C_PORT_OVER_CURRENT 0x13
18286 -#define RH_C_PORT_RESET 0x14
18287 -
18288 -/* Hub features */
18289 -#define RH_C_HUB_LOCAL_POWER 0x00
18290 -#define RH_C_HUB_OVER_CURRENT 0x01
18291 -
18292 -#define RH_DEVICE_REMOTE_WAKEUP 0x00
18293 -#define RH_ENDPOINT_STALL 0x01
18294 -
18295 -/* Our Vendor Specific feature */
18296 -#define RH_REMOVE_EP 0x00
18297 -
18298 -
18299 -#define RH_ACK 0x01
18300 -#define RH_REQ_ERR -1
18301 -#define RH_NACK 0x00
18302 -
18303 -/* Field definitions for */
18304 -
18305 -#define USB_IN_command__eol__BITNR 0 /* command macros */
18306 -#define USB_IN_command__eol__WIDTH 1
18307 -#define USB_IN_command__eol__no 0
18308 -#define USB_IN_command__eol__yes 1
18309 -
18310 -#define USB_IN_command__intr__BITNR 3
18311 -#define USB_IN_command__intr__WIDTH 1
18312 -#define USB_IN_command__intr__no 0
18313 -#define USB_IN_command__intr__yes 1
18314 -
18315 -#define USB_IN_status__eop__BITNR 1 /* status macros. */
18316 -#define USB_IN_status__eop__WIDTH 1
18317 -#define USB_IN_status__eop__no 0
18318 -#define USB_IN_status__eop__yes 1
18319 -
18320 -#define USB_IN_status__eot__BITNR 5
18321 -#define USB_IN_status__eot__WIDTH 1
18322 -#define USB_IN_status__eot__no 0
18323 -#define USB_IN_status__eot__yes 1
18324 -
18325 -#define USB_IN_status__error__BITNR 6
18326 -#define USB_IN_status__error__WIDTH 1
18327 -#define USB_IN_status__error__no 0
18328 -#define USB_IN_status__error__yes 1
18329 -
18330 -#define USB_IN_status__nodata__BITNR 7
18331 -#define USB_IN_status__nodata__WIDTH 1
18332 -#define USB_IN_status__nodata__no 0
18333 -#define USB_IN_status__nodata__yes 1
18334 -
18335 -#define USB_IN_status__epid__BITNR 8
18336 -#define USB_IN_status__epid__WIDTH 5
18337 -
18338 -#define USB_EP_command__eol__BITNR 0
18339 -#define USB_EP_command__eol__WIDTH 1
18340 -#define USB_EP_command__eol__no 0
18341 -#define USB_EP_command__eol__yes 1
18342 -
18343 -#define USB_EP_command__eof__BITNR 1
18344 -#define USB_EP_command__eof__WIDTH 1
18345 -#define USB_EP_command__eof__no 0
18346 -#define USB_EP_command__eof__yes 1
18347 -
18348 -#define USB_EP_command__intr__BITNR 3
18349 -#define USB_EP_command__intr__WIDTH 1
18350 -#define USB_EP_command__intr__no 0
18351 -#define USB_EP_command__intr__yes 1
18352 -
18353 -#define USB_EP_command__enable__BITNR 4
18354 -#define USB_EP_command__enable__WIDTH 1
18355 -#define USB_EP_command__enable__no 0
18356 -#define USB_EP_command__enable__yes 1
18357 -
18358 -#define USB_EP_command__hw_valid__BITNR 5
18359 -#define USB_EP_command__hw_valid__WIDTH 1
18360 -#define USB_EP_command__hw_valid__no 0
18361 -#define USB_EP_command__hw_valid__yes 1
18362 -
18363 -#define USB_EP_command__epid__BITNR 8
18364 -#define USB_EP_command__epid__WIDTH 5
18365 -
18366 -#define USB_SB_command__eol__BITNR 0 /* command macros. */
18367 -#define USB_SB_command__eol__WIDTH 1
18368 -#define USB_SB_command__eol__no 0
18369 -#define USB_SB_command__eol__yes 1
18370 -
18371 -#define USB_SB_command__eot__BITNR 1
18372 -#define USB_SB_command__eot__WIDTH 1
18373 -#define USB_SB_command__eot__no 0
18374 -#define USB_SB_command__eot__yes 1
18375 -
18376 -#define USB_SB_command__intr__BITNR 3
18377 -#define USB_SB_command__intr__WIDTH 1
18378 -#define USB_SB_command__intr__no 0
18379 -#define USB_SB_command__intr__yes 1
18380 -
18381 -#define USB_SB_command__tt__BITNR 4
18382 -#define USB_SB_command__tt__WIDTH 2
18383 -#define USB_SB_command__tt__zout 0
18384 -#define USB_SB_command__tt__in 1
18385 -#define USB_SB_command__tt__out 2
18386 -#define USB_SB_command__tt__setup 3
18387 -
18388 -
18389 -#define USB_SB_command__rem__BITNR 8
18390 -#define USB_SB_command__rem__WIDTH 6
18391 -
18392 -#define USB_SB_command__full__BITNR 6
18393 -#define USB_SB_command__full__WIDTH 1
18394 -#define USB_SB_command__full__no 0
18395 -#define USB_SB_command__full__yes 1
18396 -
18397 -#endif
18398 --- linux-2.6.19.2.orig/drivers/usb/host/hc-crisv10.h 1970-01-01 01:00:00.000000000 +0100
18399 +++ linux-2.6.19.2.dev/drivers/usb/host/hc-crisv10.h 2006-01-27 13:59:58.000000000 +0100
18400 @@ -0,0 +1,330 @@
18401 +#ifndef __LINUX_ETRAX_USB_H
18402 +#define __LINUX_ETRAX_USB_H
18403 +
18404 +#include <linux/types.h>
18405 +#include <linux/list.h>
18406 +
18407 +struct USB_IN_Desc {
18408 + volatile __u16 sw_len;
18409 + volatile __u16 command;
18410 + volatile unsigned long next;
18411 + volatile unsigned long buf;
18412 + volatile __u16 hw_len;
18413 + volatile __u16 status;
18414 +};
18415 +
18416 +struct USB_SB_Desc {
18417 + volatile __u16 sw_len;
18418 + volatile __u16 command;
18419 + volatile unsigned long next;
18420 + volatile unsigned long buf;
18421 +};
18422 +
18423 +struct USB_EP_Desc {
18424 + volatile __u16 hw_len;
18425 + volatile __u16 command;
18426 + volatile unsigned long sub;
18427 + volatile unsigned long next;
18428 +};
18429 +
18430 +
18431 +/* Root Hub port status struct */
18432 +struct crisv10_rh {
18433 + volatile __u16 wPortChange[2];
18434 + volatile __u16 wPortStatusPrev[2];
18435 +};
18436 +
18437 +/* HCD description */
18438 +struct crisv10_hcd {
18439 + spinlock_t lock;
18440 + __u8 num_ports;
18441 + __u8 running;
18442 +};
18443 +
18444 +
18445 +/* Endpoint HC private data description */
18446 +struct crisv10_ep_priv {
18447 + int epid;
18448 +};
18449 +
18450 +/* Additional software state info for a USB Controller epid */
18451 +struct etrax_epid {
18452 + __u8 inuse; /* !0 = setup in Etrax and used for a endpoint */
18453 + __u8 disabled; /* !0 = Temporarly disabled to avoid resubmission */
18454 + __u8 type; /* Setup as: PIPE_BULK, PIPE_CONTROL ... */
18455 + __u8 out_traffic; /* !0 = This epid is for out traffic */
18456 +};
18457 +
18458 +/* Struct to hold information of scheduled later URB completion */
18459 +struct urb_later_data {
18460 + struct work_struct ws;
18461 + struct usb_hcd *hcd;
18462 + struct urb *urb;
18463 + int urb_num;
18464 + int status;
18465 +};
18466 +
18467 +
18468 +typedef enum {
18469 + STARTED,
18470 + NOT_STARTED,
18471 + UNLINK,
18472 +} crisv10_urb_state_t;
18473 +
18474 +
18475 +struct crisv10_urb_priv {
18476 + /* Sequence number for this URB. Every new submited URB gets this from
18477 + a incrementing counter. Used when a URB is scheduled for later finish to
18478 + be sure that the intended URB hasn't already been completed (device
18479 + drivers has a tendency to reuse URBs once they are completed, causing us
18480 + to not be able to single old ones out only based on the URB pointer.) */
18481 + __u32 urb_num;
18482 +
18483 + /* The first_sb field is used for freeing all SB descriptors belonging
18484 + to an urb. The corresponding ep descriptor's sub pointer cannot be
18485 + used for this since the DMA advances the sub pointer as it processes
18486 + the sb list. */
18487 + struct USB_SB_Desc *first_sb;
18488 +
18489 + /* The last_sb field referes to the last SB descriptor that belongs to
18490 + this urb. This is important to know so we can free the SB descriptors
18491 + that ranges between first_sb and last_sb. */
18492 + struct USB_SB_Desc *last_sb;
18493 +
18494 + /* The rx_offset field is used in ctrl and bulk traffic to keep track
18495 + of the offset in the urb's transfer_buffer where incoming data should be
18496 + copied to. */
18497 + __u32 rx_offset;
18498 +
18499 + /* Counter used in isochronous transfers to keep track of the
18500 + number of packets received/transmitted. */
18501 + __u32 isoc_packet_counter;
18502 +
18503 + /* Flag that marks if this Isoc Out URB has finished it's transfer. Used
18504 + because several URBs can be finished before list is processed */
18505 + __u8 isoc_out_done;
18506 +
18507 + /* This field is used to pass information about the urb's current state
18508 + between the various interrupt handlers (thus marked volatile). */
18509 + volatile crisv10_urb_state_t urb_state;
18510 +
18511 + /* In Ctrl transfers consist of (at least) 3 packets: SETUP, IN and ZOUT.
18512 + When DMA8 sub-channel 2 has processed the SB list for this sequence we
18513 + get a interrupt. We also get a interrupt for In transfers and which
18514 + one of these interrupts that comes first depends of data size and device.
18515 + To be sure that we have got both interrupts before we complete the URB
18516 + we have these to flags that shows which part that has completed.
18517 + We can then check when we get one of the interrupts that if the other has
18518 + occured it's safe for us to complete the URB, otherwise we set appropriate
18519 + flag and do the completion when we get the other interrupt. */
18520 + volatile unsigned char ctrl_zout_done;
18521 + volatile unsigned char ctrl_rx_done;
18522 +
18523 + /* Connection between the submitted urb and ETRAX epid number */
18524 + __u8 epid;
18525 +
18526 + /* The rx_data_list field is used for periodic traffic, to hold
18527 + received data for later processing in the the complete_urb functions,
18528 + where the data us copied to the urb's transfer_buffer. Basically, we
18529 + use this intermediate storage because we don't know when it's safe to
18530 + reuse the transfer_buffer (FIXME?). */
18531 + struct list_head rx_data_list;
18532 +
18533 +
18534 + /* The interval time rounded up to closest 2^N */
18535 + int interval;
18536 +
18537 + /* Pool of EP descriptors needed if it's a INTR transfer.
18538 + Amount of EPs in pool correspons to how many INTR that should
18539 + be inserted in TxIntrEPList (max 128, defined by MAX_INTR_INTERVAL) */
18540 + struct USB_EP_Desc* intr_ep_pool[128];
18541 +
18542 + /* The mount of EPs allocated for this INTR URB */
18543 + int intr_ep_pool_length;
18544 +
18545 + /* Pointer to info struct if URB is scheduled to be finished later */
18546 + struct urb_later_data* later_data;
18547 +};
18548 +
18549 +
18550 +/* This struct is for passing data from the top half to the bottom half irq
18551 + handlers */
18552 +struct crisv10_irq_reg {
18553 + struct usb_hcd* hcd;
18554 + __u32 r_usb_epid_attn;
18555 + __u8 r_usb_status;
18556 + __u16 r_usb_rh_port_status_1;
18557 + __u16 r_usb_rh_port_status_2;
18558 + __u32 r_usb_irq_mask_read;
18559 + __u32 r_usb_fm_number;
18560 + struct work_struct usb_bh;
18561 +};
18562 +
18563 +
18564 +/* This struct is for passing data from the isoc top half to the isoc bottom
18565 + half. */
18566 +struct crisv10_isoc_complete_data {
18567 + struct usb_hcd *hcd;
18568 + struct urb *urb;
18569 + struct work_struct usb_bh;
18570 +};
18571 +
18572 +/* Entry item for URB lists for each endpint */
18573 +typedef struct urb_entry
18574 +{
18575 + struct urb *urb;
18576 + struct list_head list;
18577 +} urb_entry_t;
18578 +
18579 +/* ---------------------------------------------------------------------------
18580 + Virtual Root HUB
18581 + ------------------------------------------------------------------------- */
18582 +/* destination of request */
18583 +#define RH_INTERFACE 0x01
18584 +#define RH_ENDPOINT 0x02
18585 +#define RH_OTHER 0x03
18586 +
18587 +#define RH_CLASS 0x20
18588 +#define RH_VENDOR 0x40
18589 +
18590 +/* Requests: bRequest << 8 | bmRequestType */
18591 +#define RH_GET_STATUS 0x0080
18592 +#define RH_CLEAR_FEATURE 0x0100
18593 +#define RH_SET_FEATURE 0x0300
18594 +#define RH_SET_ADDRESS 0x0500
18595 +#define RH_GET_DESCRIPTOR 0x0680
18596 +#define RH_SET_DESCRIPTOR 0x0700
18597 +#define RH_GET_CONFIGURATION 0x0880
18598 +#define RH_SET_CONFIGURATION 0x0900
18599 +#define RH_GET_STATE 0x0280
18600 +#define RH_GET_INTERFACE 0x0A80
18601 +#define RH_SET_INTERFACE 0x0B00
18602 +#define RH_SYNC_FRAME 0x0C80
18603 +/* Our Vendor Specific Request */
18604 +#define RH_SET_EP 0x2000
18605 +
18606 +
18607 +/* Hub port features */
18608 +#define RH_PORT_CONNECTION 0x00
18609 +#define RH_PORT_ENABLE 0x01
18610 +#define RH_PORT_SUSPEND 0x02
18611 +#define RH_PORT_OVER_CURRENT 0x03
18612 +#define RH_PORT_RESET 0x04
18613 +#define RH_PORT_POWER 0x08
18614 +#define RH_PORT_LOW_SPEED 0x09
18615 +#define RH_C_PORT_CONNECTION 0x10
18616 +#define RH_C_PORT_ENABLE 0x11
18617 +#define RH_C_PORT_SUSPEND 0x12
18618 +#define RH_C_PORT_OVER_CURRENT 0x13
18619 +#define RH_C_PORT_RESET 0x14
18620 +
18621 +/* Hub features */
18622 +#define RH_C_HUB_LOCAL_POWER 0x00
18623 +#define RH_C_HUB_OVER_CURRENT 0x01
18624 +
18625 +#define RH_DEVICE_REMOTE_WAKEUP 0x00
18626 +#define RH_ENDPOINT_STALL 0x01
18627 +
18628 +/* Our Vendor Specific feature */
18629 +#define RH_REMOVE_EP 0x00
18630 +
18631 +
18632 +#define RH_ACK 0x01
18633 +#define RH_REQ_ERR -1
18634 +#define RH_NACK 0x00
18635 +
18636 +/* Field definitions for */
18637 +
18638 +#define USB_IN_command__eol__BITNR 0 /* command macros */
18639 +#define USB_IN_command__eol__WIDTH 1
18640 +#define USB_IN_command__eol__no 0
18641 +#define USB_IN_command__eol__yes 1
18642 +
18643 +#define USB_IN_command__intr__BITNR 3
18644 +#define USB_IN_command__intr__WIDTH 1
18645 +#define USB_IN_command__intr__no 0
18646 +#define USB_IN_command__intr__yes 1
18647 +
18648 +#define USB_IN_status__eop__BITNR 1 /* status macros. */
18649 +#define USB_IN_status__eop__WIDTH 1
18650 +#define USB_IN_status__eop__no 0
18651 +#define USB_IN_status__eop__yes 1
18652 +
18653 +#define USB_IN_status__eot__BITNR 5
18654 +#define USB_IN_status__eot__WIDTH 1
18655 +#define USB_IN_status__eot__no 0
18656 +#define USB_IN_status__eot__yes 1
18657 +
18658 +#define USB_IN_status__error__BITNR 6
18659 +#define USB_IN_status__error__WIDTH 1
18660 +#define USB_IN_status__error__no 0
18661 +#define USB_IN_status__error__yes 1
18662 +
18663 +#define USB_IN_status__nodata__BITNR 7
18664 +#define USB_IN_status__nodata__WIDTH 1
18665 +#define USB_IN_status__nodata__no 0
18666 +#define USB_IN_status__nodata__yes 1
18667 +
18668 +#define USB_IN_status__epid__BITNR 8
18669 +#define USB_IN_status__epid__WIDTH 5
18670 +
18671 +#define USB_EP_command__eol__BITNR 0
18672 +#define USB_EP_command__eol__WIDTH 1
18673 +#define USB_EP_command__eol__no 0
18674 +#define USB_EP_command__eol__yes 1
18675 +
18676 +#define USB_EP_command__eof__BITNR 1
18677 +#define USB_EP_command__eof__WIDTH 1
18678 +#define USB_EP_command__eof__no 0
18679 +#define USB_EP_command__eof__yes 1
18680 +
18681 +#define USB_EP_command__intr__BITNR 3
18682 +#define USB_EP_command__intr__WIDTH 1
18683 +#define USB_EP_command__intr__no 0
18684 +#define USB_EP_command__intr__yes 1
18685 +
18686 +#define USB_EP_command__enable__BITNR 4
18687 +#define USB_EP_command__enable__WIDTH 1
18688 +#define USB_EP_command__enable__no 0
18689 +#define USB_EP_command__enable__yes 1
18690 +
18691 +#define USB_EP_command__hw_valid__BITNR 5
18692 +#define USB_EP_command__hw_valid__WIDTH 1
18693 +#define USB_EP_command__hw_valid__no 0
18694 +#define USB_EP_command__hw_valid__yes 1
18695 +
18696 +#define USB_EP_command__epid__BITNR 8
18697 +#define USB_EP_command__epid__WIDTH 5
18698 +
18699 +#define USB_SB_command__eol__BITNR 0 /* command macros. */
18700 +#define USB_SB_command__eol__WIDTH 1
18701 +#define USB_SB_command__eol__no 0
18702 +#define USB_SB_command__eol__yes 1
18703 +
18704 +#define USB_SB_command__eot__BITNR 1
18705 +#define USB_SB_command__eot__WIDTH 1
18706 +#define USB_SB_command__eot__no 0
18707 +#define USB_SB_command__eot__yes 1
18708 +
18709 +#define USB_SB_command__intr__BITNR 3
18710 +#define USB_SB_command__intr__WIDTH 1
18711 +#define USB_SB_command__intr__no 0
18712 +#define USB_SB_command__intr__yes 1
18713 +
18714 +#define USB_SB_command__tt__BITNR 4
18715 +#define USB_SB_command__tt__WIDTH 2
18716 +#define USB_SB_command__tt__zout 0
18717 +#define USB_SB_command__tt__in 1
18718 +#define USB_SB_command__tt__out 2
18719 +#define USB_SB_command__tt__setup 3
18720 +
18721 +
18722 +#define USB_SB_command__rem__BITNR 8
18723 +#define USB_SB_command__rem__WIDTH 6
18724 +
18725 +#define USB_SB_command__full__BITNR 6
18726 +#define USB_SB_command__full__WIDTH 1
18727 +#define USB_SB_command__full__no 0
18728 +#define USB_SB_command__full__yes 1
18729 +
18730 +#endif
18731 diff -urN linux-2.6.19.2.orig/drivers/net/cris/Makefile linux-2.6.19.2.dev/drivers/net/cris/Makefile
18732 --- linux-2.6.19.2.orig/drivers/net/cris/Makefile 2007-01-10 20:10:37.000000000 +0100
18733 +++ linux-2.6.19.2.dev/drivers/net/cris/Makefile 2005-01-04 13:09:12.000000000 +0100
18734 @@ -1 +1,2 @@
18735 obj-$(CONFIG_ETRAX_ARCH_V10) += eth_v10.o
18736 +obj-$(CONFIG_ETRAX_ARCH_V32) += eth_v32.o
18737 diff -urN linux-2.6.19.2.orig/drivers/net/cris/eth_v10.c linux-2.6.19.2.dev/drivers/net/cris/eth_v10.c
18738 --- linux-2.6.19.2.orig/drivers/net/cris/eth_v10.c 2007-01-10 20:10:37.000000000 +0100
18739 +++ linux-2.6.19.2.dev/drivers/net/cris/eth_v10.c 2007-01-15 16:35:48.000000000 +0100
18740 @@ -1,221 +1,10 @@
18741 -/* $Id: ethernet.c,v 1.31 2004/10/18 14:49:03 starvik Exp $
18742 - *
18743 - * e100net.c: A network driver for the ETRAX 100LX network controller.
18744 +/*
18745 + * Driver for the ETRAX 100LX network controller.
18746 *
18747 - * Copyright (c) 1998-2002 Axis Communications AB.
18748 + * Copyright (c) 1998-2006 Axis Communications AB.
18749 *
18750 * The outline of this driver comes from skeleton.c.
18751 *
18752 - * $Log: ethernet.c,v $
18753 - * Revision 1.31 2004/10/18 14:49:03 starvik
18754 - * Use RX interrupt as random source
18755 - *
18756 - * Revision 1.30 2004/09/29 10:44:04 starvik
18757 - * Enabed MAC-address output again
18758 - *
18759 - * Revision 1.29 2004/08/24 07:14:05 starvik
18760 - * Make use of generic MDIO interface and constants.
18761 - *
18762 - * Revision 1.28 2004/08/20 09:37:11 starvik
18763 - * Added support for Intel LXT972A. Creds to Randy Scarborough.
18764 - *
18765 - * Revision 1.27 2004/08/16 12:37:22 starvik
18766 - * Merge of Linux 2.6.8
18767 - *
18768 - * Revision 1.25 2004/06/21 10:29:57 starvik
18769 - * Merge of Linux 2.6.7
18770 - *
18771 - * Revision 1.23 2004/06/09 05:29:22 starvik
18772 - * Avoid any race where R_DMA_CH1_FIRST is NULL (may trigger cache bug).
18773 - *
18774 - * Revision 1.22 2004/05/14 07:58:03 starvik
18775 - * Merge of changes from 2.4
18776 - *
18777 - * Revision 1.20 2004/03/11 11:38:40 starvik
18778 - * Merge of Linux 2.6.4
18779 - *
18780 - * Revision 1.18 2003/12/03 13:45:46 starvik
18781 - * Use hardware pad for short packets to prevent information leakage.
18782 - *
18783 - * Revision 1.17 2003/07/04 08:27:37 starvik
18784 - * Merge of Linux 2.5.74
18785 - *
18786 - * Revision 1.16 2003/04/24 08:28:22 starvik
18787 - * New LED behaviour: LED off when no link
18788 - *
18789 - * Revision 1.15 2003/04/09 05:20:47 starvik
18790 - * Merge of Linux 2.5.67
18791 - *
18792 - * Revision 1.13 2003/03/06 16:11:01 henriken
18793 - * Off by one error in group address register setting.
18794 - *
18795 - * Revision 1.12 2003/02/27 17:24:19 starvik
18796 - * Corrected Rev to Revision
18797 - *
18798 - * Revision 1.11 2003/01/24 09:53:21 starvik
18799 - * Oops. Initialize GA to 0, not to 1
18800 - *
18801 - * Revision 1.10 2003/01/24 09:50:55 starvik
18802 - * Initialize GA_0 and GA_1 to 0 to avoid matching of unwanted packets
18803 - *
18804 - * Revision 1.9 2002/12/13 07:40:58 starvik
18805 - * Added basic ethtool interface
18806 - * Handled out of memory when allocating new buffers
18807 - *
18808 - * Revision 1.8 2002/12/11 13:13:57 starvik
18809 - * Added arch/ to v10 specific includes
18810 - * Added fix from Linux 2.4 in serial.c (flush_to_flip_buffer)
18811 - *
18812 - * Revision 1.7 2002/11/26 09:41:42 starvik
18813 - * Added e100_set_config (standard interface to set media type)
18814 - * Added protection against preemptive scheduling
18815 - * Added standard MII ioctls
18816 - *
18817 - * Revision 1.6 2002/11/21 07:18:18 starvik
18818 - * Timers must be initialized in 2.5.48
18819 - *
18820 - * Revision 1.5 2002/11/20 11:56:11 starvik
18821 - * Merge of Linux 2.5.48
18822 - *
18823 - * Revision 1.4 2002/11/18 07:26:46 starvik
18824 - * Linux 2.5 port of latest Linux 2.4 ethernet driver
18825 - *
18826 - * Revision 1.33 2002/10/02 20:16:17 hp
18827 - * SETF, SETS: Use underscored IO_x_ macros rather than incorrect token concatenation
18828 - *
18829 - * Revision 1.32 2002/09/16 06:05:58 starvik
18830 - * Align memory returned by dev_alloc_skb
18831 - * Moved handling of sent packets to interrupt to avoid reference counting problem
18832 - *
18833 - * Revision 1.31 2002/09/10 13:28:23 larsv
18834 - * Return -EINVAL for unknown ioctls to avoid confusing tools that tests
18835 - * for supported functionality by issuing special ioctls, i.e. wireless
18836 - * extensions.
18837 - *
18838 - * Revision 1.30 2002/05/07 18:50:08 johana
18839 - * Correct spelling in comments.
18840 - *
18841 - * Revision 1.29 2002/05/06 05:38:49 starvik
18842 - * Performance improvements:
18843 - * Large packets are not copied (breakpoint set to 256 bytes)
18844 - * The cache bug workaround is delayed until half of the receive list
18845 - * has been used
18846 - * Added transmit list
18847 - * Transmit interrupts are only enabled when transmit queue is full
18848 - *
18849 - * Revision 1.28.2.1 2002/04/30 08:15:51 starvik
18850 - * Performance improvements:
18851 - * Large packets are not copied (breakpoint set to 256 bytes)
18852 - * The cache bug workaround is delayed until half of the receive list
18853 - * has been used.
18854 - * Added transmit list
18855 - * Transmit interrupts are only enabled when transmit queue is full
18856 - *
18857 - * Revision 1.28 2002/04/22 11:47:21 johana
18858 - * Fix according to 2.4.19-pre7. time_after/time_before and
18859 - * missing end of comment.
18860 - * The patch has a typo for ethernet.c in e100_clear_network_leds(),
18861 - * that is fixed here.
18862 - *
18863 - * Revision 1.27 2002/04/12 11:55:11 bjornw
18864 - * Added TODO
18865 - *
18866 - * Revision 1.26 2002/03/15 17:11:02 bjornw
18867 - * Use prepare_rx_descriptor after the CPU has touched the receiving descs
18868 - *
18869 - * Revision 1.25 2002/03/08 13:07:53 bjornw
18870 - * Unnecessary spinlock removed
18871 - *
18872 - * Revision 1.24 2002/02/20 12:57:43 fredriks
18873 - * Replaced MIN() with min().
18874 - *
18875 - * Revision 1.23 2002/02/20 10:58:14 fredriks
18876 - * Strip the Ethernet checksum (4 bytes) before forwarding a frame to upper layers.
18877 - *
18878 - * Revision 1.22 2002/01/30 07:48:22 matsfg
18879 - * Initiate R_NETWORK_TR_CTRL
18880 - *
18881 - * Revision 1.21 2001/11/23 11:54:49 starvik
18882 - * Added IFF_PROMISC and IFF_ALLMULTI handling in set_multicast_list
18883 - * Removed compiler warnings
18884 - *
18885 - * Revision 1.20 2001/11/12 19:26:00 pkj
18886 - * * Corrected e100_negotiate() to not assign half to current_duplex when
18887 - * it was supposed to compare them...
18888 - * * Cleaned up failure handling in e100_open().
18889 - * * Fixed compiler warnings.
18890 - *
18891 - * Revision 1.19 2001/11/09 07:43:09 starvik
18892 - * Added full duplex support
18893 - * Added ioctl to set speed and duplex
18894 - * Clear LED timer only runs when LED is lit
18895 - *
18896 - * Revision 1.18 2001/10/03 14:40:43 jonashg
18897 - * Update rx_bytes counter.
18898 - *
18899 - * Revision 1.17 2001/06/11 12:43:46 olof
18900 - * Modified defines for network LED behavior
18901 - *
18902 - * Revision 1.16 2001/05/30 06:12:46 markusl
18903 - * TxDesc.next should not be set to NULL
18904 - *
18905 - * Revision 1.15 2001/05/29 10:27:04 markusl
18906 - * Updated after review remarks:
18907 - * +Use IO_EXTRACT
18908 - * +Handle underrun
18909 - *
18910 - * Revision 1.14 2001/05/29 09:20:14 jonashg
18911 - * Use driver name on printk output so one can tell which driver that complains.
18912 - *
18913 - * Revision 1.13 2001/05/09 12:35:59 johana
18914 - * Use DMA_NBR and IRQ_NBR defines from dma.h and irq.h
18915 - *
18916 - * Revision 1.12 2001/04/05 11:43:11 tobiasa
18917 - * Check dev before panic.
18918 - *
18919 - * Revision 1.11 2001/04/04 11:21:05 markusl
18920 - * Updated according to review remarks
18921 - *
18922 - * Revision 1.10 2001/03/26 16:03:06 bjornw
18923 - * Needs linux/config.h
18924 - *
18925 - * Revision 1.9 2001/03/19 14:47:48 pkj
18926 - * * Make sure there is always a pause after the network LEDs are
18927 - * changed so they will not look constantly lit during heavy traffic.
18928 - * * Always use HZ when setting times relative to jiffies.
18929 - * * Use LED_NETWORK_SET() when setting the network LEDs.
18930 - *
18931 - * Revision 1.8 2001/02/27 13:52:48 bjornw
18932 - * malloc.h -> slab.h
18933 - *
18934 - * Revision 1.7 2001/02/23 13:46:38 bjornw
18935 - * Spellling check
18936 - *
18937 - * Revision 1.6 2001/01/26 15:21:04 starvik
18938 - * Don't disable interrupts while reading MDIO registers (MDIO is slow)
18939 - * Corrected promiscuous mode
18940 - * Improved deallocation of IRQs ("ifconfig eth0 down" now works)
18941 - *
18942 - * Revision 1.5 2000/11/29 17:22:22 bjornw
18943 - * Get rid of the udword types legacy stuff
18944 - *
18945 - * Revision 1.4 2000/11/22 16:36:09 bjornw
18946 - * Please marketing by using the correct case when spelling Etrax.
18947 - *
18948 - * Revision 1.3 2000/11/21 16:43:04 bjornw
18949 - * Minor short->int change
18950 - *
18951 - * Revision 1.2 2000/11/08 14:27:57 bjornw
18952 - * 2.4 port
18953 - *
18954 - * Revision 1.1 2000/11/06 13:56:00 bjornw
18955 - * Verbatim copy of the 1.24 version of e100net.c from elinux
18956 - *
18957 - * Revision 1.24 2000/10/04 15:55:23 bjornw
18958 - * * Use virt_to_phys etc. for DMA addresses
18959 - * * Removed bogus CHECKSUM_UNNECESSARY
18960 - *
18961 - *
18962 */
18963
18964
18965 @@ -251,6 +40,7 @@
18966 #include <asm/bitops.h>
18967 #include <asm/ethernet.h>
18968 #include <asm/cache.h>
18969 +#include <asm/arch/io_interface_mux.h>
18970
18971 //#define ETHDEBUG
18972 #define D(x)
18973 @@ -280,6 +70,9 @@
18974 * by this lock as well.
18975 */
18976 spinlock_t lock;
18977 +
18978 + spinlock_t led_lock; /* Protect LED state */
18979 + spinlock_t transceiver_lock; /* Protect transceiver state. */
18980 };
18981
18982 typedef struct etrax_eth_descr
18983 @@ -296,8 +89,6 @@
18984 void (*check_duplex)(struct net_device* dev);
18985 };
18986
18987 -struct transceiver_ops* transceiver;
18988 -
18989 /* Duplex settings */
18990 enum duplex
18991 {
18992 @@ -308,7 +99,7 @@
18993
18994 /* Dma descriptors etc. */
18995
18996 -#define MAX_MEDIA_DATA_SIZE 1518
18997 +#define MAX_MEDIA_DATA_SIZE 1522
18998
18999 #define MIN_PACKET_LEN 46
19000 #define ETHER_HEAD_LEN 14
19001 @@ -332,9 +123,9 @@
19002 #define MDIO_TDK_DIAGNOSTIC_DPLX 0x800
19003
19004 /*Intel LXT972A specific*/
19005 -#define MDIO_INT_STATUS_REG_2 0x0011
19006 -#define MDIO_INT_FULL_DUPLEX_IND ( 1 << 9 )
19007 -#define MDIO_INT_SPEED ( 1 << 14 )
19008 +#define MDIO_INT_STATUS_REG_2 0x0011
19009 +#define MDIO_INT_FULL_DUPLEX_IND (1 << 9)
19010 +#define MDIO_INT_SPEED (1 << 14)
19011
19012 /* Network flash constants */
19013 #define NET_FLASH_TIME (HZ/50) /* 20 ms */
19014 @@ -345,8 +136,8 @@
19015 #define NO_NETWORK_ACTIVITY 0
19016 #define NETWORK_ACTIVITY 1
19017
19018 -#define NBR_OF_RX_DESC 64
19019 -#define NBR_OF_TX_DESC 256
19020 +#define NBR_OF_RX_DESC 32
19021 +#define NBR_OF_TX_DESC 16
19022
19023 /* Large packets are sent directly to upper layers while small packets are */
19024 /* copied (to reduce memory waste). The following constant decides the breakpoint */
19025 @@ -368,7 +159,6 @@
19026 static etrax_eth_descr *myNextRxDesc; /* Points to the next descriptor to
19027 to be processed */
19028 static etrax_eth_descr *myLastRxDesc; /* The last processed descriptor */
19029 -static etrax_eth_descr *myPrevRxDesc; /* The descriptor right before myNextRxDesc */
19030
19031 static etrax_eth_descr RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned(32)));
19032
19033 @@ -378,7 +168,6 @@
19034 static etrax_eth_descr TxDescList[NBR_OF_TX_DESC] __attribute__ ((aligned(32)));
19035
19036 static unsigned int network_rec_config_shadow = 0;
19037 -static unsigned int mdio_phy_addr; /* Transciever address */
19038
19039 static unsigned int network_tr_ctrl_shadow = 0;
19040
19041 @@ -412,7 +201,7 @@
19042 static void e100_tx_timeout(struct net_device *dev);
19043 static struct net_device_stats *e100_get_stats(struct net_device *dev);
19044 static void set_multicast_list(struct net_device *dev);
19045 -static void e100_hardware_send_packet(char *buf, int length);
19046 +static void e100_hardware_send_packet(struct net_local* np, char *buf, int length);
19047 static void update_rx_stats(struct net_device_stats *);
19048 static void update_tx_stats(struct net_device_stats *);
19049 static int e100_probe_transceiver(struct net_device* dev);
19050 @@ -435,7 +224,10 @@
19051 static void e100_set_network_leds(int active);
19052
19053 static const struct ethtool_ops e100_ethtool_ops;
19054 -
19055 +#if defined(CONFIG_ETRAX_NO_PHY)
19056 +static void dummy_check_speed(struct net_device* dev);
19057 +static void dummy_check_duplex(struct net_device* dev);
19058 +#else
19059 static void broadcom_check_speed(struct net_device* dev);
19060 static void broadcom_check_duplex(struct net_device* dev);
19061 static void tdk_check_speed(struct net_device* dev);
19062 @@ -444,16 +236,29 @@
19063 static void intel_check_duplex(struct net_device* dev);
19064 static void generic_check_speed(struct net_device* dev);
19065 static void generic_check_duplex(struct net_device* dev);
19066 +#endif
19067 +#ifdef CONFIG_NET_POLL_CONTROLLER
19068 +static void e100_netpoll(struct net_device* dev);
19069 +#endif
19070 +
19071 +static int autoneg_normal = 1;
19072
19073 struct transceiver_ops transceivers[] =
19074 {
19075 +#if defined(CONFIG_ETRAX_NO_PHY)
19076 + {0x0000, dummy_check_speed, dummy_check_duplex} /* Dummy */
19077 +#else
19078 {0x1018, broadcom_check_speed, broadcom_check_duplex}, /* Broadcom */
19079 {0xC039, tdk_check_speed, tdk_check_duplex}, /* TDK 2120 */
19080 {0x039C, tdk_check_speed, tdk_check_duplex}, /* TDK 2120C */
19081 - {0x04de, intel_check_speed, intel_check_duplex}, /* Intel LXT972A*/
19082 + {0x04de, intel_check_speed, intel_check_duplex}, /* Intel LXT972A*/
19083 {0x0000, generic_check_speed, generic_check_duplex} /* Generic, must be last */
19084 +#endif
19085 };
19086
19087 +struct transceiver_ops* transceiver = &transceivers[0];
19088 +static unsigned int mdio_phy_addr = 0; /* PHY address on MDIO bus */
19089 +
19090 #define tx_done(dev) (*R_DMA_CH0_CMD == 0)
19091
19092 /*
19093 @@ -468,18 +273,26 @@
19094 etrax_ethernet_init(void)
19095 {
19096 struct net_device *dev;
19097 - struct net_local* np;
19098 + struct net_local* np;
19099 int i, err;
19100
19101 printk(KERN_INFO
19102 - "ETRAX 100LX 10/100MBit ethernet v2.0 (c) 2000-2003 Axis Communications AB\n");
19103 -
19104 + "ETRAX 100LX 10/100MBit ethernet v2.0 (c) 1998-2006 Axis Communications AB\n");
19105 +
19106 + if (cris_request_io_interface(if_eth, cardname)) {
19107 + printk(KERN_CRIT "etrax_ethernet_init failed to get IO interface\n");
19108 + return -EBUSY;
19109 + }
19110 +
19111 dev = alloc_etherdev(sizeof(struct net_local));
19112 - np = dev->priv;
19113 -
19114 if (!dev)
19115 return -ENOMEM;
19116 +
19117 + np = netdev_priv(dev);
19118
19119 + /* we do our own locking */
19120 + dev->features |= NETIF_F_LLTX;
19121 +
19122 dev->base_addr = (unsigned int)R_NETWORK_SA_0; /* just to have something to show */
19123
19124 /* now setup our etrax specific stuff */
19125 @@ -495,18 +308,26 @@
19126 dev->get_stats = e100_get_stats;
19127 dev->set_multicast_list = set_multicast_list;
19128 dev->set_mac_address = e100_set_mac_address;
19129 - dev->ethtool_ops = &e100_ethtool_ops;
19130 + dev->ethtool_ops = &e100_ethtool_ops;
19131 dev->do_ioctl = e100_ioctl;
19132 - dev->set_config = e100_set_config;
19133 + dev->set_config = e100_set_config;
19134 dev->tx_timeout = e100_tx_timeout;
19135 +#ifdef CONFIG_NET_POLL_CONTROLLER
19136 + dev->poll_controller = e100_netpoll;
19137 +#endif
19138 +
19139 + spin_lock_init(&np->lock);
19140 + spin_lock_init(&np->led_lock);
19141 + spin_lock_init(&np->transceiver_lock);
19142
19143 /* Initialise the list of Etrax DMA-descriptors */
19144
19145 /* Initialise receive descriptors */
19146
19147 for (i = 0; i < NBR_OF_RX_DESC; i++) {
19148 - /* Allocate two extra cachelines to make sure that buffer used by DMA
19149 - * does not share cacheline with any other data (to avoid cache bug)
19150 + /* Allocate two extra cachelines to make sure that buffer used
19151 + * by DMA does not share cacheline with any other data (to
19152 + * avoid cache bug)
19153 */
19154 RxDescList[i].skb = dev_alloc_skb(MAX_MEDIA_DATA_SIZE + 2 * L1_CACHE_BYTES);
19155 if (!RxDescList[i].skb)
19156 @@ -517,6 +338,7 @@
19157 RxDescList[i].descr.buf = L1_CACHE_ALIGN(virt_to_phys(RxDescList[i].skb->data));
19158 RxDescList[i].descr.status = 0;
19159 RxDescList[i].descr.hw_len = 0;
19160 +
19161 prepare_rx_descriptor(&RxDescList[i].descr);
19162 }
19163
19164 @@ -542,7 +364,6 @@
19165
19166 myNextRxDesc = &RxDescList[0];
19167 myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
19168 - myPrevRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
19169 myFirstTxDesc = &TxDescList[0];
19170 myNextTxDesc = &TxDescList[0];
19171 myLastTxDesc = &TxDescList[NBR_OF_TX_DESC - 1];
19172 @@ -563,18 +384,19 @@
19173 current_speed = 10;
19174 current_speed_selection = 0; /* Auto */
19175 speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
19176 - duplex_timer.data = (unsigned long)dev;
19177 + speed_timer.data = (unsigned long)dev;
19178 speed_timer.function = e100_check_speed;
19179
19180 clear_led_timer.function = e100_clear_network_leds;
19181 + clear_led_timer.data = (unsigned long)dev;
19182
19183 full_duplex = 0;
19184 current_duplex = autoneg;
19185 duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
19186 - duplex_timer.data = (unsigned long)dev;
19187 + duplex_timer.data = (unsigned long)dev;
19188 duplex_timer.function = e100_check_duplex;
19189
19190 - /* Initialize mii interface */
19191 + /* Initialize mii interface */
19192 np->mii_if.phy_id = mdio_phy_addr;
19193 np->mii_if.phy_id_mask = 0x1f;
19194 np->mii_if.reg_num_mask = 0x1f;
19195 @@ -586,6 +408,9 @@
19196 /* unwanted addresses are matched */
19197 *R_NETWORK_GA_0 = 0x00000000;
19198 *R_NETWORK_GA_1 = 0x00000000;
19199 +
19200 + /* Initialize next time the led can flash */
19201 + led_next_time = jiffies;
19202 return 0;
19203 }
19204
19205 @@ -596,7 +421,7 @@
19206 static int
19207 e100_set_mac_address(struct net_device *dev, void *p)
19208 {
19209 - struct net_local *np = (struct net_local *)dev->priv;
19210 + struct net_local *np = netdev_priv(dev);
19211 struct sockaddr *addr = p;
19212 int i;
19213
19214 @@ -680,17 +505,36 @@
19215 /* allocate the irq corresponding to the transmitting DMA */
19216
19217 if (request_irq(NETWORK_DMA_TX_IRQ_NBR, e100rxtx_interrupt, 0,
19218 - cardname, (void *)dev)) {
19219 + cardname, (void *)dev)) {
19220 goto grace_exit1;
19221 }
19222
19223 /* allocate the irq corresponding to the network errors etc */
19224
19225 if (request_irq(NETWORK_STATUS_IRQ_NBR, e100nw_interrupt, 0,
19226 - cardname, (void *)dev)) {
19227 + cardname, (void *)dev)) {
19228 goto grace_exit2;
19229 }
19230
19231 + /*
19232 + * Always allocate the DMA channels after the IRQ,
19233 + * and clean up on failure.
19234 + */
19235 +
19236 + if (cris_request_dma(NETWORK_TX_DMA_NBR,
19237 + cardname,
19238 + DMA_VERBOSE_ON_ERROR,
19239 + dma_eth)) {
19240 + goto grace_exit3;
19241 + }
19242 +
19243 + if (cris_request_dma(NETWORK_RX_DMA_NBR,
19244 + cardname,
19245 + DMA_VERBOSE_ON_ERROR,
19246 + dma_eth)) {
19247 + goto grace_exit4;
19248 + }
19249 +
19250 /* give the HW an idea of what MAC address we want */
19251
19252 *R_NETWORK_SA_0 = dev->dev_addr[0] | (dev->dev_addr[1] << 8) |
19253 @@ -705,6 +549,7 @@
19254
19255 *R_NETWORK_REC_CONFIG = 0xd; /* broadcast rec, individ. rec, ma0 enabled */
19256 #else
19257 + SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, max_size, size1522);
19258 SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, broadcast, receive);
19259 SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, ma0, enable);
19260 SETF(network_rec_config_shadow, R_NETWORK_REC_CONFIG, duplex, full_duplex);
19261 @@ -724,8 +569,7 @@
19262 SETS(network_tr_ctrl_shadow, R_NETWORK_TR_CTRL, crc, enable);
19263 *R_NETWORK_TR_CTRL = network_tr_ctrl_shadow;
19264
19265 - save_flags(flags);
19266 - cli();
19267 + local_irq_save(flags);
19268
19269 /* enable the irq's for ethernet DMA */
19270
19271 @@ -757,12 +601,13 @@
19272
19273 *R_DMA_CH0_FIRST = 0;
19274 *R_DMA_CH0_DESCR = virt_to_phys(myLastTxDesc);
19275 + netif_start_queue(dev);
19276
19277 - restore_flags(flags);
19278 + local_irq_restore(flags);
19279
19280 /* Probe for transceiver */
19281 if (e100_probe_transceiver(dev))
19282 - goto grace_exit3;
19283 + goto grace_exit5;
19284
19285 /* Start duplex/speed timers */
19286 add_timer(&speed_timer);
19287 @@ -771,10 +616,14 @@
19288 /* We are now ready to accept transmit requeusts from
19289 * the queueing layer of the networking.
19290 */
19291 - netif_start_queue(dev);
19292 + netif_carrier_on(dev);
19293
19294 return 0;
19295
19296 +grace_exit5:
19297 + cris_free_dma(NETWORK_RX_DMA_NBR, cardname);
19298 +grace_exit4:
19299 + cris_free_dma(NETWORK_TX_DMA_NBR, cardname);
19300 grace_exit3:
19301 free_irq(NETWORK_STATUS_IRQ_NBR, (void *)dev);
19302 grace_exit2:
19303 @@ -785,7 +634,13 @@
19304 return -EAGAIN;
19305 }
19306
19307 -
19308 +#if defined(CONFIG_ETRAX_NO_PHY)
19309 +static void
19310 +dummy_check_speed(struct net_device* dev)
19311 +{
19312 + current_speed = 100;
19313 +}
19314 +#else
19315 static void
19316 generic_check_speed(struct net_device* dev)
19317 {
19318 @@ -821,15 +676,18 @@
19319 data = e100_get_mdio_reg(dev, mdio_phy_addr, MDIO_INT_STATUS_REG_2);
19320 current_speed = (data & MDIO_INT_SPEED ? 100 : 10);
19321 }
19322 -
19323 +#endif
19324 static void
19325 e100_check_speed(unsigned long priv)
19326 {
19327 struct net_device* dev = (struct net_device*)priv;
19328 + struct net_local *np = netdev_priv(dev);
19329 static int led_initiated = 0;
19330 unsigned long data;
19331 int old_speed = current_speed;
19332
19333 + spin_lock(&np->transceiver_lock);
19334 +
19335 data = e100_get_mdio_reg(dev, mdio_phy_addr, MII_BMSR);
19336 if (!(data & BMSR_LSTATUS)) {
19337 current_speed = 0;
19338 @@ -837,14 +695,22 @@
19339 transceiver->check_speed(dev);
19340 }
19341
19342 + spin_lock(&np->led_lock);
19343 if ((old_speed != current_speed) || !led_initiated) {
19344 led_initiated = 1;
19345 e100_set_network_leds(NO_NETWORK_ACTIVITY);
19346 + if (current_speed)
19347 + netif_carrier_on(dev);
19348 + else
19349 + netif_carrier_off(dev);
19350 }
19351 + spin_unlock(&np->led_lock);
19352
19353 /* Reinitialize the timer. */
19354 speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
19355 add_timer(&speed_timer);
19356 +
19357 + spin_unlock(&np->transceiver_lock);
19358 }
19359
19360 static void
19361 @@ -857,7 +723,7 @@
19362 ADVERTISE_10HALF | ADVERTISE_10FULL);
19363
19364 switch (current_speed_selection) {
19365 - case 10 :
19366 + case 10:
19367 if (current_duplex == full)
19368 data |= ADVERTISE_10FULL;
19369 else if (current_duplex == half)
19370 @@ -866,7 +732,7 @@
19371 data |= ADVERTISE_10HALF | ADVERTISE_10FULL;
19372 break;
19373
19374 - case 100 :
19375 + case 100:
19376 if (current_duplex == full)
19377 data |= ADVERTISE_100FULL;
19378 else if (current_duplex == half)
19379 @@ -875,45 +741,54 @@
19380 data |= ADVERTISE_100HALF | ADVERTISE_100FULL;
19381 break;
19382
19383 - case 0 : /* Auto */
19384 + case 0: /* Auto */
19385 if (current_duplex == full)
19386 data |= ADVERTISE_100FULL | ADVERTISE_10FULL;
19387 else if (current_duplex == half)
19388 data |= ADVERTISE_100HALF | ADVERTISE_10HALF;
19389 else
19390 data |= ADVERTISE_10HALF | ADVERTISE_10FULL |
19391 - ADVERTISE_100HALF | ADVERTISE_100FULL;
19392 + ADVERTISE_100HALF | ADVERTISE_100FULL;
19393 break;
19394
19395 - default : /* assume autoneg speed and duplex */
19396 + default: /* assume autoneg speed and duplex */
19397 data |= ADVERTISE_10HALF | ADVERTISE_10FULL |
19398 - ADVERTISE_100HALF | ADVERTISE_100FULL;
19399 + ADVERTISE_100HALF | ADVERTISE_100FULL;
19400 + break;
19401 }
19402
19403 e100_set_mdio_reg(dev, mdio_phy_addr, MII_ADVERTISE, data);
19404
19405 /* Renegotiate with link partner */
19406 - data = e100_get_mdio_reg(dev, mdio_phy_addr, MII_BMCR);
19407 - data |= BMCR_ANENABLE | BMCR_ANRESTART;
19408 -
19409 + if (autoneg_normal) {
19410 + data = e100_get_mdio_reg(dev, mdio_phy_addr, MII_BMCR);
19411 + data |= BMCR_ANENABLE | BMCR_ANRESTART;
19412 + }
19413 e100_set_mdio_reg(dev, mdio_phy_addr, MII_BMCR, data);
19414 }
19415
19416 static void
19417 e100_set_speed(struct net_device* dev, unsigned long speed)
19418 {
19419 + struct net_local *np = netdev_priv(dev);
19420 +
19421 + spin_lock(&np->transceiver_lock);
19422 if (speed != current_speed_selection) {
19423 current_speed_selection = speed;
19424 e100_negotiate(dev);
19425 }
19426 + spin_unlock(&np->transceiver_lock);
19427 }
19428
19429 static void
19430 e100_check_duplex(unsigned long priv)
19431 {
19432 struct net_device *dev = (struct net_device *)priv;
19433 - struct net_local *np = (struct net_local *)dev->priv;
19434 - int old_duplex = full_duplex;
19435 + struct net_local *np = netdev_priv(dev);
19436 + int old_duplex;
19437 +
19438 + spin_lock(&np->transceiver_lock);
19439 + old_duplex = full_duplex;
19440 transceiver->check_duplex(dev);
19441 if (old_duplex != full_duplex) {
19442 /* Duplex changed */
19443 @@ -925,12 +800,20 @@
19444 duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
19445 add_timer(&duplex_timer);
19446 np->mii_if.full_duplex = full_duplex;
19447 + spin_unlock(&np->transceiver_lock);
19448 }
19449 -
19450 +#if defined(CONFIG_ETRAX_NO_PHY)
19451 +static void
19452 +dummy_check_duplex(struct net_device* dev)
19453 +{
19454 + full_duplex = 1;
19455 +}
19456 +#else
19457 static void
19458 generic_check_duplex(struct net_device* dev)
19459 {
19460 unsigned long data;
19461 +
19462 data = e100_get_mdio_reg(dev, mdio_phy_addr, MII_ADVERTISE);
19463 if ((data & ADVERTISE_10FULL) ||
19464 (data & ADVERTISE_100FULL))
19465 @@ -943,6 +826,7 @@
19466 tdk_check_duplex(struct net_device* dev)
19467 {
19468 unsigned long data;
19469 +
19470 data = e100_get_mdio_reg(dev, mdio_phy_addr, MDIO_TDK_DIAGNOSTIC_REG);
19471 full_duplex = (data & MDIO_TDK_DIAGNOSTIC_DPLX) ? 1 : 0;
19472 }
19473 @@ -951,6 +835,7 @@
19474 broadcom_check_duplex(struct net_device* dev)
19475 {
19476 unsigned long data;
19477 +
19478 data = e100_get_mdio_reg(dev, mdio_phy_addr, MDIO_AUX_CTRL_STATUS_REG);
19479 full_duplex = (data & MDIO_BC_FULL_DUPLEX_IND) ? 1 : 0;
19480 }
19481 @@ -959,26 +844,35 @@
19482 intel_check_duplex(struct net_device* dev)
19483 {
19484 unsigned long data;
19485 +
19486 data = e100_get_mdio_reg(dev, mdio_phy_addr, MDIO_INT_STATUS_REG_2);
19487 full_duplex = (data & MDIO_INT_FULL_DUPLEX_IND) ? 1 : 0;
19488 }
19489 -
19490 +#endif
19491 static void
19492 e100_set_duplex(struct net_device* dev, enum duplex new_duplex)
19493 {
19494 + struct net_local *np = netdev_priv(dev);
19495 +
19496 + spin_lock(&np->transceiver_lock);
19497 if (new_duplex != current_duplex) {
19498 current_duplex = new_duplex;
19499 e100_negotiate(dev);
19500 }
19501 + spin_unlock(&np->transceiver_lock);
19502 }
19503
19504 static int
19505 e100_probe_transceiver(struct net_device* dev)
19506 {
19507 +#if !defined(CONFIG_ETRAX_NO_PHY)
19508 unsigned int phyid_high;
19509 unsigned int phyid_low;
19510 unsigned int oui;
19511 struct transceiver_ops* ops = NULL;
19512 + struct net_local *np = netdev_priv(dev);
19513 +
19514 + spin_lock(&np->transceiver_lock);
19515
19516 /* Probe MDIO physical address */
19517 for (mdio_phy_addr = 0; mdio_phy_addr <= 31; mdio_phy_addr++) {
19518 @@ -986,7 +880,7 @@
19519 break;
19520 }
19521 if (mdio_phy_addr == 32)
19522 - return -ENODEV;
19523 + return -ENODEV;
19524
19525 /* Get manufacturer */
19526 phyid_high = e100_get_mdio_reg(dev, mdio_phy_addr, MII_PHYSID1);
19527 @@ -999,6 +893,8 @@
19528 }
19529 transceiver = ops;
19530
19531 + spin_unlock(&np->transceiver_lock);
19532 +#endif
19533 return 0;
19534 }
19535
19536 @@ -1006,7 +902,7 @@
19537 e100_get_mdio_reg(struct net_device *dev, int phy_id, int location)
19538 {
19539 unsigned short cmd; /* Data to be sent on MDIO port */
19540 - int data; /* Data read from MDIO */
19541 + int data; /* Data read from MDIO */
19542 int bitCounter;
19543
19544 /* Start of frame, OP Code, Physical Address, Register Address */
19545 @@ -1082,6 +978,7 @@
19546 e100_receive_mdio_bit()
19547 {
19548 unsigned char bit;
19549 +
19550 *R_NETWORK_MGM_CTRL = 0;
19551 bit = IO_EXTRACT(R_NETWORK_STAT, mdio, *R_NETWORK_STAT);
19552 udelay(1);
19553 @@ -1117,7 +1014,7 @@
19554 static void
19555 e100_tx_timeout(struct net_device *dev)
19556 {
19557 - struct net_local *np = (struct net_local *)dev->priv;
19558 + struct net_local *np = netdev_priv(dev);
19559 unsigned long flags;
19560
19561 spin_lock_irqsave(&np->lock, flags);
19562 @@ -1139,8 +1036,7 @@
19563 e100_reset_transceiver(dev);
19564
19565 /* and get rid of the packets that never got an interrupt */
19566 - while (myFirstTxDesc != myNextTxDesc)
19567 - {
19568 + while (myFirstTxDesc != myNextTxDesc) {
19569 dev_kfree_skb(myFirstTxDesc->skb);
19570 myFirstTxDesc->skb = 0;
19571 myFirstTxDesc = phys_to_virt(myFirstTxDesc->descr.next);
19572 @@ -1166,7 +1062,7 @@
19573 static int
19574 e100_send_packet(struct sk_buff *skb, struct net_device *dev)
19575 {
19576 - struct net_local *np = (struct net_local *)dev->priv;
19577 + struct net_local *np = netdev_priv(dev);
19578 unsigned char *buf = skb->data;
19579 unsigned long flags;
19580
19581 @@ -1179,7 +1075,7 @@
19582
19583 dev->trans_start = jiffies;
19584
19585 - e100_hardware_send_packet(buf, skb->len);
19586 + e100_hardware_send_packet(np, buf, skb->len);
19587
19588 myNextTxDesc = phys_to_virt(myNextTxDesc->descr.next);
19589
19590 @@ -1202,13 +1098,15 @@
19591 e100rxtx_interrupt(int irq, void *dev_id)
19592 {
19593 struct net_device *dev = (struct net_device *)dev_id;
19594 - struct net_local *np = (struct net_local *)dev->priv;
19595 - unsigned long irqbits = *R_IRQ_MASK2_RD;
19596 + struct net_local *np = netdev_priv(dev);
19597 + unsigned long irqbits;
19598
19599 - /* Disable RX/TX IRQs to avoid reentrancy */
19600 - *R_IRQ_MASK2_CLR =
19601 - IO_STATE(R_IRQ_MASK2_CLR, dma0_eop, clr) |
19602 - IO_STATE(R_IRQ_MASK2_CLR, dma1_eop, clr);
19603 + /*
19604 + * Note that both rx and tx interrupts are blocked at this point,
19605 + * regardless of which got us here.
19606 + */
19607 +
19608 + irqbits = *R_IRQ_MASK2_RD;
19609
19610 /* Handle received packets */
19611 if (irqbits & IO_STATE(R_IRQ_MASK2_RD, dma1_eop, active)) {
19612 @@ -1224,7 +1122,7 @@
19613 * allocate a new buffer to put a packet in.
19614 */
19615 e100_rx(dev);
19616 - ((struct net_local *)dev->priv)->stats.rx_packets++;
19617 + np->stats.rx_packets++;
19618 /* restart/continue on the channel, for safety */
19619 *R_DMA_CH1_CMD = IO_STATE(R_DMA_CH1_CMD, cmd, restart);
19620 /* clear dma channel 1 eop/descr irq bits */
19621 @@ -1239,8 +1137,7 @@
19622
19623 /* Report any packets that have been sent */
19624 while (myFirstTxDesc != phys_to_virt(*R_DMA_CH0_FIRST) &&
19625 - myFirstTxDesc != myNextTxDesc)
19626 - {
19627 + (netif_queue_stopped(dev) || myFirstTxDesc != myNextTxDesc)) {
19628 np->stats.tx_bytes += myFirstTxDesc->skb->len;
19629 np->stats.tx_packets++;
19630
19631 @@ -1249,19 +1146,15 @@
19632 dev_kfree_skb_irq(myFirstTxDesc->skb);
19633 myFirstTxDesc->skb = 0;
19634 myFirstTxDesc = phys_to_virt(myFirstTxDesc->descr.next);
19635 + /* Wake up queue. */
19636 + netif_wake_queue(dev);
19637 }
19638
19639 if (irqbits & IO_STATE(R_IRQ_MASK2_RD, dma0_eop, active)) {
19640 - /* acknowledge the eop interrupt and wake up queue */
19641 + /* acknowledge the eop interrupt. */
19642 *R_DMA_CH0_CLR_INTR = IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do);
19643 - netif_wake_queue(dev);
19644 }
19645
19646 - /* Enable RX/TX IRQs again */
19647 - *R_IRQ_MASK2_SET =
19648 - IO_STATE(R_IRQ_MASK2_SET, dma0_eop, set) |
19649 - IO_STATE(R_IRQ_MASK2_SET, dma1_eop, set);
19650 -
19651 return IRQ_HANDLED;
19652 }
19653
19654 @@ -1269,7 +1162,7 @@
19655 e100nw_interrupt(int irq, void *dev_id)
19656 {
19657 struct net_device *dev = (struct net_device *)dev_id;
19658 - struct net_local *np = (struct net_local *)dev->priv;
19659 + struct net_local *np = netdev_priv(dev);
19660 unsigned long irqbits = *R_IRQ_MASK0_RD;
19661
19662 /* check for underrun irq */
19663 @@ -1291,7 +1184,6 @@
19664 SETS(network_tr_ctrl_shadow, R_NETWORK_TR_CTRL, clr_error, clr);
19665 *R_NETWORK_TR_CTRL = network_tr_ctrl_shadow;
19666 SETS(network_tr_ctrl_shadow, R_NETWORK_TR_CTRL, clr_error, nop);
19667 - *R_NETWORK_TR_CTRL = IO_STATE(R_NETWORK_TR_CTRL, clr_error, clr);
19668 np->stats.tx_errors++;
19669 D(printk("ethernet excessive collisions!\n"));
19670 }
19671 @@ -1304,12 +1196,13 @@
19672 {
19673 struct sk_buff *skb;
19674 int length = 0;
19675 - struct net_local *np = (struct net_local *)dev->priv;
19676 + struct net_local *np = netdev_priv(dev);
19677 unsigned char *skb_data_ptr;
19678 #ifdef ETHDEBUG
19679 int i;
19680 #endif
19681 -
19682 + etrax_eth_descr *prevRxDesc; /* The descriptor right before myNextRxDesc */
19683 + spin_lock(&np->led_lock);
19684 if (!led_active && time_after(jiffies, led_next_time)) {
19685 /* light the network leds depending on the current speed. */
19686 e100_set_network_leds(NETWORK_ACTIVITY);
19687 @@ -1319,9 +1212,10 @@
19688 led_active = 1;
19689 mod_timer(&clear_led_timer, jiffies + HZ/10);
19690 }
19691 + spin_unlock(&np->led_lock);
19692
19693 length = myNextRxDesc->descr.hw_len - 4;
19694 - ((struct net_local *)dev->priv)->stats.rx_bytes += length;
19695 + np->stats.rx_bytes += length;
19696
19697 #ifdef ETHDEBUG
19698 printk("Got a packet of length %d:\n", length);
19699 @@ -1341,7 +1235,7 @@
19700 if (!skb) {
19701 np->stats.rx_errors++;
19702 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
19703 - return;
19704 + goto update_nextrxdesc;
19705 }
19706
19707 skb_put(skb, length - ETHER_HEAD_LEN); /* allocate room for the packet body */
19708 @@ -1358,15 +1252,15 @@
19709 else {
19710 /* Large packet, send directly to upper layers and allocate new
19711 * memory (aligned to cache line boundary to avoid bug).
19712 - * Before sending the skb to upper layers we must make sure that
19713 - * skb->data points to the aligned start of the packet.
19714 + * Before sending the skb to upper layers we must make sure
19715 + * that skb->data points to the aligned start of the packet.
19716 */
19717 int align;
19718 struct sk_buff *new_skb = dev_alloc_skb(MAX_MEDIA_DATA_SIZE + 2 * L1_CACHE_BYTES);
19719 if (!new_skb) {
19720 np->stats.rx_errors++;
19721 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
19722 - return;
19723 + goto update_nextrxdesc;
19724 }
19725 skb = myNextRxDesc->skb;
19726 align = (int)phys_to_virt(myNextRxDesc->descr.buf) - (int)skb->data;
19727 @@ -1382,9 +1276,10 @@
19728 /* Send the packet to the upper layers */
19729 netif_rx(skb);
19730
19731 + update_nextrxdesc:
19732 /* Prepare for next packet */
19733 myNextRxDesc->descr.status = 0;
19734 - myPrevRxDesc = myNextRxDesc;
19735 + prevRxDesc = myNextRxDesc;
19736 myNextRxDesc = phys_to_virt(myNextRxDesc->descr.next);
19737
19738 rx_queue_len++;
19739 @@ -1392,9 +1287,9 @@
19740 /* Check if descriptors should be returned */
19741 if (rx_queue_len == RX_QUEUE_THRESHOLD) {
19742 flush_etrax_cache();
19743 - myPrevRxDesc->descr.ctrl |= d_eol;
19744 + prevRxDesc->descr.ctrl |= d_eol;
19745 myLastRxDesc->descr.ctrl &= ~d_eol;
19746 - myLastRxDesc = myPrevRxDesc;
19747 + myLastRxDesc = prevRxDesc;
19748 rx_queue_len = 0;
19749 }
19750 }
19751 @@ -1403,7 +1298,7 @@
19752 static int
19753 e100_close(struct net_device *dev)
19754 {
19755 - struct net_local *np = (struct net_local *)dev->priv;
19756 + struct net_local *np = netdev_priv(dev);
19757
19758 printk(KERN_INFO "Closing %s.\n", dev->name);
19759
19760 @@ -1431,6 +1326,9 @@
19761 free_irq(NETWORK_DMA_TX_IRQ_NBR, (void *)dev);
19762 free_irq(NETWORK_STATUS_IRQ_NBR, (void *)dev);
19763
19764 + cris_free_dma(NETWORK_TX_DMA_NBR, cardname);
19765 + cris_free_dma(NETWORK_RX_DMA_NBR, cardname);
19766 +
19767 /* Update the statistics here. */
19768
19769 update_rx_stats(&np->stats);
19770 @@ -1448,46 +1346,56 @@
19771 {
19772 struct mii_ioctl_data *data = if_mii(ifr);
19773 struct net_local *np = netdev_priv(dev);
19774 + int ret = 0;
19775 + int old_autoneg;
19776
19777 spin_lock(&np->lock); /* Preempt protection */
19778 switch (cmd) {
19779 - case SIOCGMIIPHY: /* Get PHY address */
19780 + case SIOCGMIIPHY: /* Get PHY address */
19781 data->phy_id = mdio_phy_addr;
19782 break;
19783 - case SIOCGMIIREG: /* Read MII register */
19784 + case SIOCGMIIREG: /* Read MII register */
19785 data->val_out = e100_get_mdio_reg(dev, mdio_phy_addr, data->reg_num);
19786 break;
19787 - case SIOCSMIIREG: /* Write MII register */
19788 + case SIOCSMIIREG: /* Write MII register */
19789 e100_set_mdio_reg(dev, mdio_phy_addr, data->reg_num, data->val_in);
19790 break;
19791 +
19792 /* The ioctls below should be considered obsolete but are */
19793 /* still present for compatability with old scripts/apps */
19794 - case SET_ETH_SPEED_10: /* 10 Mbps */
19795 + case SET_ETH_SPEED_10: /* 10 Mbps */
19796 e100_set_speed(dev, 10);
19797 break;
19798 - case SET_ETH_SPEED_100: /* 100 Mbps */
19799 + case SET_ETH_SPEED_100: /* 100 Mbps */
19800 e100_set_speed(dev, 100);
19801 break;
19802 - case SET_ETH_SPEED_AUTO: /* Auto negotiate speed */
19803 + case SET_ETH_SPEED_AUTO: /* Auto-negotiate speed */
19804 e100_set_speed(dev, 0);
19805 break;
19806 - case SET_ETH_DUPLEX_HALF: /* Half duplex. */
19807 + case SET_ETH_DUPLEX_HALF: /* Half duplex */
19808 e100_set_duplex(dev, half);
19809 break;
19810 - case SET_ETH_DUPLEX_FULL: /* Full duplex. */
19811 + case SET_ETH_DUPLEX_FULL: /* Full duplex */
19812 e100_set_duplex(dev, full);
19813 break;
19814 - case SET_ETH_DUPLEX_AUTO: /* Autonegotiate duplex*/
19815 + case SET_ETH_DUPLEX_AUTO: /* Auto-negotiate duplex */
19816 e100_set_duplex(dev, autoneg);
19817 break;
19818 + case SET_ETH_AUTONEG:
19819 + old_autoneg = autoneg_normal;
19820 + autoneg_normal = *(int*)data;
19821 + if (autoneg_normal != old_autoneg)
19822 + e100_negotiate(dev);
19823 + break;
19824 default:
19825 + spin_unlock(&np->lock);
19826 return -EINVAL;
19827 }
19828 spin_unlock(&np->lock);
19829 - return 0;
19830 + return ret;
19831 }
19832
19833 -static int e100_set_settings(struct net_device *dev,
19834 +static int e100_get_settings(struct net_device *dev,
19835 struct ethtool_cmd *ecmd)
19836 {
19837 ecmd->supported = SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII |
19838 @@ -1565,7 +1473,8 @@
19839 static int
19840 e100_set_config(struct net_device *dev, struct ifmap *map)
19841 {
19842 - struct net_local *np = (struct net_local *)dev->priv;
19843 + struct net_local *np = netdev_priv(dev);
19844 +
19845 spin_lock(&np->lock); /* Preempt protection */
19846
19847 switch(map->port) {
19848 @@ -1574,21 +1483,25 @@
19849 e100_set_speed(dev, 0);
19850 e100_set_duplex(dev, autoneg);
19851 break;
19852 +
19853 case IF_PORT_10BASET:
19854 e100_set_speed(dev, 10);
19855 e100_set_duplex(dev, autoneg);
19856 break;
19857 +
19858 case IF_PORT_100BASET:
19859 case IF_PORT_100BASETX:
19860 e100_set_speed(dev, 100);
19861 e100_set_duplex(dev, autoneg);
19862 break;
19863 +
19864 case IF_PORT_100BASEFX:
19865 case IF_PORT_10BASE2:
19866 case IF_PORT_AUI:
19867 spin_unlock(&np->lock);
19868 return -EOPNOTSUPP;
19869 break;
19870 +
19871 default:
19872 printk(KERN_ERR "%s: Invalid media selected", dev->name);
19873 spin_unlock(&np->lock);
19874 @@ -1602,6 +1515,7 @@
19875 update_rx_stats(struct net_device_stats *es)
19876 {
19877 unsigned long r = *R_REC_COUNTERS;
19878 +
19879 /* update stats relevant to reception errors */
19880 es->rx_fifo_errors += IO_EXTRACT(R_REC_COUNTERS, congestion, r);
19881 es->rx_crc_errors += IO_EXTRACT(R_REC_COUNTERS, crc_error, r);
19882 @@ -1613,11 +1527,11 @@
19883 update_tx_stats(struct net_device_stats *es)
19884 {
19885 unsigned long r = *R_TR_COUNTERS;
19886 +
19887 /* update stats relevant to transmission errors */
19888 es->collisions +=
19889 IO_EXTRACT(R_TR_COUNTERS, single_col, r) +
19890 IO_EXTRACT(R_TR_COUNTERS, multiple_col, r);
19891 - es->tx_errors += IO_EXTRACT(R_TR_COUNTERS, deferred, r);
19892 }
19893
19894 /*
19895 @@ -1627,8 +1541,9 @@
19896 static struct net_device_stats *
19897 e100_get_stats(struct net_device *dev)
19898 {
19899 - struct net_local *lp = (struct net_local *)dev->priv;
19900 + struct net_local *lp = netdev_priv(dev);
19901 unsigned long flags;
19902 +
19903 spin_lock_irqsave(&lp->lock, flags);
19904
19905 update_rx_stats(&lp->stats);
19906 @@ -1640,21 +1555,21 @@
19907
19908 /*
19909 * Set or clear the multicast filter for this adaptor.
19910 - * num_addrs == -1 Promiscuous mode, receive all packets
19911 - * num_addrs == 0 Normal mode, clear multicast list
19912 - * num_addrs > 0 Multicast mode, receive normal and MC packets,
19913 - * and do best-effort filtering.
19914 + * num_addrs == -1 Promiscuous mode, receive all packets
19915 + * num_addrs == 0 Normal mode, clear multicast list
19916 + * num_addrs > 0 Multicast mode, receive normal and MC packets,
19917 + * and do best-effort filtering.
19918 */
19919 static void
19920 set_multicast_list(struct net_device *dev)
19921 {
19922 - struct net_local *lp = (struct net_local *)dev->priv;
19923 + struct net_local *lp = netdev_priv(dev);
19924 int num_addr = dev->mc_count;
19925 unsigned long int lo_bits;
19926 unsigned long int hi_bits;
19927 +
19928 spin_lock(&lp->lock);
19929 - if (dev->flags & IFF_PROMISC)
19930 - {
19931 + if (dev->flags & IFF_PROMISC) {
19932 /* promiscuous mode */
19933 lo_bits = 0xfffffffful;
19934 hi_bits = 0xfffffffful;
19935 @@ -1684,9 +1599,10 @@
19936 struct dev_mc_list *dmi = dev->mc_list;
19937 int i;
19938 char *baddr;
19939 +
19940 lo_bits = 0x00000000ul;
19941 hi_bits = 0x00000000ul;
19942 - for (i=0; i<num_addr; i++) {
19943 + for (i = 0; i < num_addr; i++) {
19944 /* Calculate the hash index for the GA registers */
19945
19946 hash_ix = 0;
19947 @@ -1713,8 +1629,7 @@
19948
19949 if (hash_ix >= 32) {
19950 hi_bits |= (1 << (hash_ix-32));
19951 - }
19952 - else {
19953 + } else {
19954 lo_bits |= (1 << hash_ix);
19955 }
19956 dmi = dmi->next;
19957 @@ -1729,10 +1644,11 @@
19958 }
19959
19960 void
19961 -e100_hardware_send_packet(char *buf, int length)
19962 +e100_hardware_send_packet(struct net_local *np, char *buf, int length)
19963 {
19964 D(printk("e100 send pack, buf 0x%x len %d\n", buf, length));
19965
19966 + spin_lock(&np->led_lock);
19967 if (!led_active && time_after(jiffies, led_next_time)) {
19968 /* light the network leds depending on the current speed. */
19969 e100_set_network_leds(NETWORK_ACTIVITY);
19970 @@ -1742,15 +1658,16 @@
19971 led_active = 1;
19972 mod_timer(&clear_led_timer, jiffies + HZ/10);
19973 }
19974 + spin_unlock(&np->led_lock);
19975
19976 /* configure the tx dma descriptor */
19977 myNextTxDesc->descr.sw_len = length;
19978 myNextTxDesc->descr.ctrl = d_eop | d_eol | d_wait;
19979 myNextTxDesc->descr.buf = virt_to_phys(buf);
19980
19981 - /* Move end of list */
19982 - myLastTxDesc->descr.ctrl &= ~d_eol;
19983 - myLastTxDesc = myNextTxDesc;
19984 + /* Move end of list */
19985 + myLastTxDesc->descr.ctrl &= ~d_eol;
19986 + myLastTxDesc = myNextTxDesc;
19987
19988 /* Restart DMA channel */
19989 *R_DMA_CH0_CMD = IO_STATE(R_DMA_CH0_CMD, cmd, restart);
19990 @@ -1759,6 +1676,11 @@
19991 static void
19992 e100_clear_network_leds(unsigned long dummy)
19993 {
19994 + struct net_device *dev = (struct net_device *)dummy;
19995 + struct net_local *np = netdev_priv(dev);
19996 +
19997 + spin_lock(&np->led_lock);
19998 +
19999 if (led_active && time_after(jiffies, led_next_time)) {
20000 e100_set_network_leds(NO_NETWORK_ACTIVITY);
20001
20002 @@ -1766,6 +1688,8 @@
20003 led_next_time = jiffies + NET_FLASH_PAUSE;
20004 led_active = 0;
20005 }
20006 +
20007 + spin_unlock(&np->led_lock);
20008 }
20009
20010 static void
20011 @@ -1786,19 +1710,25 @@
20012 #else
20013 LED_NETWORK_SET(LED_OFF);
20014 #endif
20015 - }
20016 - else if (light_leds) {
20017 + } else if (light_leds) {
20018 if (current_speed == 10) {
20019 LED_NETWORK_SET(LED_ORANGE);
20020 } else {
20021 LED_NETWORK_SET(LED_GREEN);
20022 }
20023 - }
20024 - else {
20025 + } else {
20026 LED_NETWORK_SET(LED_OFF);
20027 }
20028 }
20029
20030 +#ifdef CONFIG_NET_POLL_CONTROLLER
20031 +static void
20032 +e100_netpoll(struct net_device* netdev)
20033 +{
20034 + e100rxtx_interrupt(NETWORK_DMA_TX_IRQ_NBR, netdev, NULL);
20035 +}
20036 +#endif
20037 +
20038 static int
20039 etrax_init_module(void)
20040 {
20041 diff -urN linux-2.6.19.2.orig/drivers/net/cris/eth_v32.c linux-2.6.19.2.dev/drivers/net/cris/eth_v32.c
20042 --- linux-2.6.19.2.orig/drivers/net/cris/eth_v32.c 1970-01-01 01:00:00.000000000 +0100
20043 +++ linux-2.6.19.2.dev/drivers/net/cris/eth_v32.c 2007-02-06 11:10:37.000000000 +0100
20044 @@ -0,0 +1,2305 @@
20045 +/*
20046 + * Driver for the ETRAX FS network controller.
20047 + *
20048 + * Copyright (c) 2003-2006 Axis Communications AB.
20049 + */
20050 +
20051 +#include <linux/module.h>
20052 +
20053 +#include <linux/kernel.h>
20054 +#include <linux/sched.h>
20055 +#include <linux/delay.h>
20056 +#include <linux/types.h>
20057 +#include <linux/fcntl.h>
20058 +#include <linux/interrupt.h>
20059 +#include <linux/ptrace.h>
20060 +#include <linux/ioport.h>
20061 +#include <linux/in.h>
20062 +#include <linux/slab.h>
20063 +#include <linux/string.h>
20064 +#include <linux/spinlock.h>
20065 +#include <linux/errno.h>
20066 +#include <linux/init.h>
20067 +#include <linux/cpufreq.h>
20068 +
20069 +#include <linux/netdevice.h>
20070 +#include <linux/etherdevice.h>
20071 +#include <linux/skbuff.h>
20072 +#include <linux/ethtool.h>
20073 +#include <linux/mii.h>
20074 +
20075 +#include <asm/io.h> /* LED_* I/O functions */
20076 +#include <asm/irq.h>
20077 +#include <asm/arch/hwregs/reg_map.h>
20078 +#include <asm/arch/hwregs/reg_rdwr.h>
20079 +#include <asm/arch/hwregs/dma.h>
20080 +#include <asm/arch/hwregs/eth_defs.h>
20081 +#include <asm/arch/hwregs/config_defs.h>
20082 +#include <asm/arch/hwregs/intr_vect_defs.h>
20083 +#include <asm/system.h>
20084 +#include <asm/bitops.h>
20085 +#include <asm/ethernet.h>
20086 +#include <asm/arch/dma.h>
20087 +#include <asm/arch/intmem.h>
20088 +#include <asm/arch/pinmux.h>
20089 +
20090 +#include "eth_v32.h"
20091 +
20092 +#define DEBUG(x)
20093 +#define GET_BIT(bit,val) (((val) >> (bit)) & 0x01)
20094 +
20095 +/* Toggle network LEDs on/off at runtime */
20096 +static int use_network_leds = 1;
20097 +
20098 +static void update_rx_stats(struct crisv32_ethernet_local *np);
20099 +static void update_tx_stats(struct crisv32_ethernet_local *np);
20100 +static void crisv32_eth_setup_controller(struct net_device *dev);
20101 +static int crisv32_eth_request_irqdma(struct net_device *dev);
20102 +static void crisv32_eth_init_rings(struct net_device *dev);
20103 +static void crisv32_eth_reset_rings(struct net_device *dev);
20104 +static void crisv32_ethernet_bug(struct net_device *dev);
20105 +
20106 +/*
20107 + * The name of the card. Is used for messages and in the requests for
20108 + * io regions, irqs and dma channels.
20109 + */
20110 +static const char *cardname = "ETRAX FS built-in ethernet controller";
20111 +
20112 +static int autoneg_normal = 1;
20113 +
20114 +/* Some chipset needs special care. */
20115 +struct transceiver_ops transceivers[] = {
20116 + {0x1018, broadcom_check_speed, broadcom_check_duplex},
20117 + /* TDK 2120 and TDK 2120C */
20118 + {0xC039, tdk_check_speed, tdk_check_duplex},
20119 + {0x039C, tdk_check_speed, tdk_check_duplex},
20120 + /* Intel LXT972A*/
20121 + {0x04de, intel_check_speed, intel_check_duplex},
20122 + /* National Semiconductor DP83865 */
20123 + {0x0017, national_check_speed, national_check_duplex},
20124 + /* Generic, must be last. */
20125 + {0x0000, generic_check_speed, generic_check_duplex}
20126 +};
20127 +
20128 +static struct net_device *crisv32_dev[2];
20129 +static struct crisv32_eth_leds *crisv32_leds[3];
20130 +
20131 +#ifdef CONFIG_CPU_FREQ
20132 +static int
20133 +crisv32_ethernet_freq_notifier(struct notifier_block *nb, unsigned long val,
20134 + void *data);
20135 +
20136 +static struct notifier_block crisv32_ethernet_freq_notifier_block = {
20137 + .notifier_call = crisv32_ethernet_freq_notifier
20138 +};
20139 +#endif
20140 +
20141 +/*
20142 + * mask in and out tx/rx interrupts.
20143 + */
20144 +static inline void crisv32_disable_tx_ints(struct crisv32_ethernet_local *np)
20145 +{
20146 + reg_dma_rw_intr_mask intr_mask_tx = { .data = regk_dma_no };
20147 + REG_WR(dma, np->dma_out_inst, rw_intr_mask, intr_mask_tx);
20148 +}
20149 +
20150 +static inline void crisv32_enable_tx_ints(struct crisv32_ethernet_local *np)
20151 +{
20152 + reg_dma_rw_intr_mask intr_mask_tx = { .data = regk_dma_yes };
20153 + REG_WR(dma, np->dma_out_inst, rw_intr_mask, intr_mask_tx);
20154 +}
20155 +
20156 +static inline void crisv32_disable_rx_ints(struct crisv32_ethernet_local *np)
20157 +{
20158 + reg_dma_rw_intr_mask intr_mask_rx = { .in_eop = regk_dma_no };
20159 + REG_WR(dma, np->dma_in_inst, rw_intr_mask, intr_mask_rx);
20160 +}
20161 +
20162 +static inline void crisv32_enable_rx_ints(struct crisv32_ethernet_local *np)
20163 +{
20164 + reg_dma_rw_intr_mask intr_mask_rx = { .in_eop = regk_dma_yes };
20165 + REG_WR(dma, np->dma_in_inst, rw_intr_mask, intr_mask_rx);
20166 +}
20167 +
20168 +/* start/stop receiver */
20169 +static inline void crisv32_start_receiver(struct crisv32_ethernet_local *np)
20170 +{
20171 + reg_eth_rw_rec_ctrl rec_ctrl;
20172 +
20173 + rec_ctrl = REG_RD(eth, np->eth_inst, rw_rec_ctrl);
20174 + rec_ctrl.ma0 = regk_eth_yes;
20175 + rec_ctrl.broadcast = regk_eth_rec;
20176 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
20177 +}
20178 +
20179 +static inline void crisv32_stop_receiver(struct crisv32_ethernet_local *np)
20180 +{
20181 + reg_eth_rw_rec_ctrl rec_ctrl;
20182 +
20183 + rec_ctrl = REG_RD(eth, np->eth_inst, rw_rec_ctrl);
20184 + rec_ctrl.ma0 = regk_eth_no;
20185 + rec_ctrl.broadcast = regk_eth_discard;
20186 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
20187 +}
20188 +
20189 +static int __init
20190 +crisv32_eth_request_irqdma(struct net_device *dev)
20191 +{
20192 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20193 +
20194 + /* Allocate IRQs and DMAs. */
20195 + if (np->eth_inst == regi_eth0) {
20196 + if (request_irq(DMA0_INTR_VECT, crisv32tx_eth_interrupt,
20197 + 0, cardname, dev)) {
20198 + return -EAGAIN;
20199 + }
20200 +
20201 + if (request_irq(DMA1_INTR_VECT, crisv32rx_eth_interrupt,
20202 + IRQF_SAMPLE_RANDOM, cardname, dev)) {
20203 + goto err0_1;
20204 + }
20205 +
20206 + if (crisv32_request_dma(0, cardname, DMA_VERBOSE_ON_ERROR,
20207 + 12500000, dma_eth0))
20208 + goto err0_2;
20209 +
20210 + if (crisv32_request_dma(1, cardname, DMA_VERBOSE_ON_ERROR,
20211 + 12500000, dma_eth0))
20212 + goto err0_3;
20213 +
20214 + if (request_irq(ETH0_INTR_VECT, crisv32nw_eth_interrupt, 0,
20215 + cardname, dev)) {
20216 + crisv32_free_dma(1);
20217 + err0_3:
20218 + crisv32_free_dma(0);
20219 + err0_2:
20220 + free_irq(DMA1_INTR_VECT, dev);
20221 + err0_1:
20222 + free_irq(DMA0_INTR_VECT, dev);
20223 + return -EAGAIN;
20224 + }
20225 + } else {
20226 + if (request_irq(DMA6_INTR_VECT, crisv32tx_eth_interrupt,
20227 + 0, cardname, dev))
20228 + return -EAGAIN;
20229 +
20230 + if (request_irq(DMA7_INTR_VECT, crisv32rx_eth_interrupt,
20231 + IRQF_SAMPLE_RANDOM, cardname, dev))
20232 + goto err1_1;
20233 +
20234 + if (crisv32_request_dma(6, cardname, DMA_VERBOSE_ON_ERROR,
20235 + 0, dma_eth1))
20236 + goto err1_2;
20237 +
20238 + if (crisv32_request_dma(7, cardname, DMA_VERBOSE_ON_ERROR,
20239 + 0, dma_eth1))
20240 + goto err1_3;
20241 +
20242 + if (request_irq(ETH1_INTR_VECT, crisv32nw_eth_interrupt, 0,
20243 + cardname, dev)) {
20244 + crisv32_free_dma(7);
20245 + err1_3:
20246 + crisv32_free_dma(6);
20247 + err1_2:
20248 + free_irq(DMA7_INTR_VECT, dev);
20249 + err1_1:
20250 + free_irq(DMA6_INTR_VECT, dev);
20251 + return -EAGAIN;
20252 + }
20253 + }
20254 + return 0;
20255 +}
20256 +
20257 +static void __init
20258 +crisv32_eth_setup_controller(struct net_device *dev)
20259 +{
20260 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20261 +
20262 + reg_config_rw_pad_ctrl pad_ctrl;
20263 +
20264 + reg_eth_rw_tr_ctrl tr_ctrl = {
20265 + .retry = regk_eth_yes,
20266 + .pad = regk_eth_yes,
20267 + .crc = regk_eth_yes
20268 + };
20269 +
20270 + reg_eth_rw_rec_ctrl rec_ctrl = {
20271 + .ma0 = regk_eth_no, /* enable at open() */
20272 + .broadcast = regk_eth_no,
20273 + .max_size = regk_eth_size1522
20274 + };
20275 +
20276 + reg_eth_rw_ga_lo ga_lo = { 0 };
20277 + reg_eth_rw_ga_hi ga_hi = { 0 };
20278 +
20279 + reg_eth_rw_gen_ctrl gen_ctrl = {
20280 + .phy = regk_eth_mii_clk,
20281 + .flow_ctrl = regk_eth_yes
20282 + };
20283 +
20284 + /*
20285 + * Initialize group address registers to make sure that no
20286 + * unwanted addresses are matched.
20287 + */
20288 + REG_WR(eth, np->eth_inst, rw_ga_lo, ga_lo);
20289 + REG_WR(eth, np->eth_inst, rw_ga_hi, ga_hi);
20290 +
20291 + /* Configure receiver and transmitter */
20292 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
20293 + REG_WR(eth, np->eth_inst, rw_tr_ctrl, tr_ctrl);
20294 +
20295 + /* Enable ethernet controller with mii clk. */
20296 + REG_WR(eth, np->eth_inst, rw_gen_ctrl, gen_ctrl);
20297 + gen_ctrl.en = regk_eth_yes;
20298 + REG_WR(eth, np->eth_inst, rw_gen_ctrl, gen_ctrl);
20299 +
20300 + /* keep reset low (RESET_LEN) */
20301 + udelay(500);
20302 +
20303 + /* done */
20304 + pad_ctrl = REG_RD(config, regi_config, rw_pad_ctrl);
20305 + pad_ctrl.phyrst_n = 1;
20306 + REG_WR(config, regi_config, rw_pad_ctrl, pad_ctrl);
20307 +
20308 + /* Let the PHY reset (RESET_WAIT) */
20309 + udelay(200);
20310 +
20311 + crisv32_eth_probe_transceiver(dev);
20312 +}
20313 +
20314 +static void __init
20315 +crisv32_eth_init_rings(struct net_device *dev)
20316 +{
20317 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20318 + int i;
20319 +
20320 + /* Initialise receive descriptors for interface. */
20321 + for (i = 0; i < NBR_RX_DESC; i++) {
20322 + struct sk_buff *skb = dev_alloc_skb(MAX_MEDIA_DATA_SIZE);
20323 +
20324 + np->dma_rx_descr_list[i].skb = skb;
20325 + np->dma_rx_descr_list[i].descr.buf =
20326 + (char*)virt_to_phys(skb->data);
20327 + np->dma_rx_descr_list[i].descr.after =
20328 + (char*)virt_to_phys(skb->data + MAX_MEDIA_DATA_SIZE);
20329 +
20330 + np->dma_rx_descr_list[i].descr.eol = 0;
20331 + np->dma_rx_descr_list[i].descr.in_eop = 0;
20332 + np->dma_rx_descr_list[i].descr.next =
20333 + (void *) virt_to_phys(&np->dma_rx_descr_list[i + 1].descr);
20334 + }
20335 + /* bend the list into a ring */
20336 + np->dma_rx_descr_list[NBR_RX_DESC - 1].descr.next =
20337 + (void *) virt_to_phys(&np->dma_rx_descr_list[0].descr);
20338 +
20339 + /* Initialize transmit descriptors. */
20340 + for (i = 0; i < NBR_TX_DESC; i++) {
20341 + np->dma_tx_descr_list[i].descr.wait = 1;
20342 + np->dma_tx_descr_list[i].descr.eol = 0;
20343 + np->dma_tx_descr_list[i].descr.out_eop = 0;
20344 + np->dma_tx_descr_list[i].descr.next =
20345 + (void*)virt_to_phys(&np->dma_tx_descr_list[i+1].descr);
20346 + }
20347 + /* bend the list into a ring */
20348 + np->dma_tx_descr_list[NBR_TX_DESC - 1].descr.next =
20349 + (void *) virt_to_phys(&np->dma_tx_descr_list[0].descr);
20350 +
20351 + crisv32_eth_reset_rings(dev);
20352 +}
20353 +
20354 +static void
20355 +crisv32_eth_reset_rings(struct net_device *dev)
20356 +{
20357 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20358 + int i;
20359 +
20360 + /* free un-handled tx packets */
20361 + while(np->txpackets
20362 + || np->catch_tx_desc != np->active_tx_desc) {
20363 + np->txpackets--;
20364 + if (np->catch_tx_desc->skb)
20365 + dev_kfree_skb(np->catch_tx_desc->skb);
20366 +
20367 + np->catch_tx_desc->skb = 0;
20368 + np->catch_tx_desc =
20369 + phys_to_virt((int)np->catch_tx_desc->descr.next);
20370 + } while (np->catch_tx_desc != np->active_tx_desc);
20371 + WARN_ON(np->txpackets != 0);
20372 + np->txpackets = 0;
20373 +
20374 + /* cleanup the rx-ring */
20375 + for (i = 0; i < NBR_RX_DESC; i++) {
20376 + struct sk_buff *skb;
20377 + skb = np->dma_rx_descr_list[i].skb;
20378 + if (!skb
20379 + || (np->dma_rx_descr_list[i].descr.buf !=
20380 + (void *)virt_to_phys(skb->data)))
20381 + {
20382 + printk("%s:%d: damaged rx-ring! "
20383 + "i=%d skb=%p %lx %lx %p %p\n",
20384 + __func__, __LINE__, i,
20385 + skb,
20386 + virt_to_phys(skb->data),
20387 + virt_to_phys(skb->data + MAX_MEDIA_DATA_SIZE),
20388 + np->dma_rx_descr_list[i].descr.buf,
20389 + np->dma_rx_descr_list[i].descr.after);
20390 + WARN_ON(1);
20391 + crisv32_ethernet_bug(dev);
20392 + if (skb)
20393 + dev_kfree_skb(skb);
20394 + skb = dev_alloc_skb(MAX_MEDIA_DATA_SIZE);
20395 + np->dma_rx_descr_list[i].skb = skb;
20396 + np->dma_rx_descr_list[i].descr.buf =
20397 + (char*)virt_to_phys(skb->data);
20398 + }
20399 + np->dma_rx_descr_list[i].descr.after =
20400 + (char*)virt_to_phys(skb->data
20401 + + MAX_MEDIA_DATA_SIZE);
20402 + np->dma_rx_descr_list[i].descr.eol = 0;
20403 + np->dma_rx_descr_list[i].descr.in_eop = 0;
20404 + /* Workaround cache bug */
20405 + flush_dma_descr(&np->dma_rx_descr_list[i].descr, 1);
20406 + }
20407 +
20408 + /* reset rx-ring */
20409 + np->active_rx_desc = &np->dma_rx_descr_list[0];
20410 + np->prev_rx_desc = &np->dma_rx_descr_list[NBR_RX_DESC - 1];
20411 + np->last_rx_desc = np->prev_rx_desc;
20412 + np->dma_rx_descr_list[NBR_RX_DESC - 1].descr.eol = 1;
20413 +
20414 + /* reset tx-ring */
20415 + np->dma_tx_descr_list[0].descr.buf =
20416 + np->dma_tx_descr_list[0].descr.after = 0;
20417 + np->dma_rx_descr_list[i].descr.in_eop = 0;
20418 + np->dma_tx_descr_list[0].descr.eol = 1;
20419 +
20420 + np->active_tx_desc = &np->dma_tx_descr_list[0];
20421 + np->prev_tx_desc = &np->dma_tx_descr_list[NBR_TX_DESC - 1];
20422 + np->catch_tx_desc = &np->dma_tx_descr_list[0];
20423 +
20424 + /* Fill context descriptors. */
20425 + np->ctxt_in.next = 0;
20426 + np->ctxt_in.saved_data =
20427 + (void *)virt_to_phys(&np->active_rx_desc->descr);
20428 + np->ctxt_in.saved_data_buf = np->active_rx_desc->descr.buf;
20429 +
20430 + np->ctxt_out.next = 0;
20431 + np->ctxt_out.saved_data =
20432 + (void *)virt_to_phys(&np->dma_tx_descr_list[0].descr);
20433 +}
20434 +
20435 +static void __init
20436 +crisv32_init_leds(int ledgrp, struct net_device* dev)
20437 +{
20438 + struct timer_list timer_init = TIMER_INITIALIZER(NULL, 0, 0);
20439 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20440 +
20441 + /* Use already allocated led grp if initialized */
20442 + if (crisv32_leds[ledgrp] != NULL) {
20443 + np->leds = crisv32_leds[ledgrp];
20444 + return;
20445 + }
20446 +
20447 + crisv32_leds[ledgrp] = kmalloc(sizeof(struct crisv32_eth_leds),GFP_KERNEL);
20448 +
20449 + crisv32_leds[ledgrp]->ledgrp = ledgrp;
20450 + crisv32_leds[ledgrp]->led_active = 0;
20451 + /* NOTE: Should this value be set to zero as the jiffies timer can wrap? */
20452 + crisv32_leds[ledgrp]->led_next_time = jiffies;
20453 +
20454 + crisv32_leds[ledgrp]->clear_led_timer = timer_init;
20455 + crisv32_leds[ledgrp]->clear_led_timer.function = crisv32_clear_network_leds;
20456 + crisv32_leds[ledgrp]->clear_led_timer.data = (unsigned long) dev;
20457 +
20458 + spin_lock_init(&crisv32_leds[ledgrp]->led_lock);
20459 +
20460 + np->leds = crisv32_leds[ledgrp];
20461 +}
20462 +
20463 +static int __init
20464 +crisv32_ethernet_init(void)
20465 +{
20466 + struct crisv32_ethernet_local *np;
20467 + int ret = 0;
20468 +
20469 + printk("ETRAX FS 10/100MBit ethernet v0.01 (c)"
20470 + " 2003 Axis Communications AB\n");
20471 +
20472 +#ifdef CONFIG_ETRAX_ETHERNET_IFACE0
20473 +{
20474 + int iface0 = 0;
20475 + /* Default MAC address for interface 0.
20476 + * The real one will be set later. */
20477 + static struct sockaddr default_mac_iface0 =
20478 + {0, {0x00, 0x40, 0x8C, 0xCD, 0x00, 0x00}};
20479 +
20480 + if (!(crisv32_dev[iface0] = alloc_etherdev(sizeof *np)))
20481 + return -ENOMEM;
20482 +
20483 + ret |= crisv32_ethernet_device_init(crisv32_dev[iface0]);
20484 +
20485 +#if defined(CONFIG_ETRAX_ETH0_USE_LEDGRP0)
20486 + crisv32_init_leds(LED_GRP_0,crisv32_dev[iface0]);
20487 +#elif defined(CONFIG_ETRAX_ETH0_USE_LEDGRP1)
20488 + crisv32_init_leds(LED_GRP_1,crisv32_dev[iface0]);
20489 +#else
20490 + crisv32_init_leds(LED_GRP_NONE,crisv32_dev[iface0]);
20491 +#endif
20492 +
20493 + np = (struct crisv32_ethernet_local *) crisv32_dev[iface0]->priv;
20494 + np->eth_inst = regi_eth0;
20495 + np->dma_out_inst = regi_dma0;
20496 + np->dma_in_inst = regi_dma1;
20497 +
20498 + register_netdev(crisv32_dev[iface0]);
20499 +
20500 + /* Set up default MAC address */
20501 + memcpy(crisv32_dev[iface0]->dev_addr, default_mac_iface0.sa_data, 6);
20502 + crisv32_eth_set_mac_address(crisv32_dev[iface0], &default_mac_iface0);
20503 + if (crisv32_eth_request_irqdma(crisv32_dev[iface0]))
20504 + printk("%s: eth0 unable to allocate IRQ and DMA resources\n",
20505 + __func__);
20506 + np->txpackets = 0;
20507 + crisv32_eth_init_rings(crisv32_dev[iface0]);
20508 + crisv32_eth_setup_controller(crisv32_dev[iface0]);
20509 +}
20510 +#endif /* CONFIG_ETRAX_ETHERNET_IFACE0 */
20511 +
20512 +#ifdef CONFIG_ETRAX_ETHERNET_IFACE1
20513 +{
20514 + int iface1 = 0;
20515 + /* Default MAC address for interface 1.
20516 + * The real one will be set later. */
20517 + static struct sockaddr default_mac_iface1 =
20518 + {0, {0x00, 0x40, 0x8C, 0xCD, 0x00, 0x01}};
20519 +
20520 + if (crisv32_pinmux_alloc_fixed(pinmux_eth1))
20521 + panic("Eth pinmux\n");
20522 +
20523 + /* Increase index to device array if interface 0 is enabled as well.*/
20524 +#ifdef CONFIG_ETRAX_ETHERNET_IFACE0
20525 + iface1++;
20526 +#endif
20527 + if (!(crisv32_dev[iface1] = alloc_etherdev(sizeof *np)))
20528 + return -ENOMEM;
20529 +
20530 + ret |= crisv32_ethernet_device_init(crisv32_dev[iface1]);
20531 +
20532 +#if defined(CONFIG_ETRAX_ETH1_USE_LEDGRP0)
20533 + crisv32_init_leds(LED_GRP_0,crisv32_dev[iface1]);
20534 +#elif defined(CONFIG_ETRAX_ETH1_USE_LEDGRP1)
20535 + crisv32_init_leds(LED_GRP_1,crisv32_dev[iface1]);
20536 +#else
20537 + crisv32_init_leds(LED_GRP_NONE,crisv32_dev[iface1]);
20538 +#endif
20539 +
20540 + np = (struct crisv32_ethernet_local *) crisv32_dev[iface1]->priv;
20541 + np->eth_inst = regi_eth1;
20542 + np->dma_out_inst = regi_dma6;
20543 + np->dma_in_inst = regi_dma7;
20544 +
20545 + register_netdev(crisv32_dev[iface1]);
20546 +
20547 + /* Set up default MAC address */
20548 + memcpy(crisv32_dev[iface1]->dev_addr, default_mac_iface1.sa_data, 6);
20549 + crisv32_eth_set_mac_address(crisv32_dev[iface1], &default_mac_iface1);
20550 +
20551 + if (crisv32_eth_request_irqdma(crisv32_dev[iface1]))
20552 + printk("%s: eth1 unable to allocate IRQ and DMA resources\n",
20553 + __func__);
20554 + np->txpackets = 0;
20555 + crisv32_eth_init_rings(crisv32_dev[iface1]);
20556 + crisv32_eth_setup_controller(crisv32_dev[iface1]);
20557 +}
20558 +#endif /* CONFIG_ETRAX_ETHERNET_IFACE1 */
20559 +
20560 +#ifdef CONFIG_CPU_FREQ
20561 + cpufreq_register_notifier(&crisv32_ethernet_freq_notifier_block,
20562 + CPUFREQ_TRANSITION_NOTIFIER);
20563 +#endif
20564 +
20565 + return ret;
20566 +}
20567 +
20568 +static int __init
20569 +crisv32_ethernet_device_init(struct net_device* dev)
20570 +{
20571 + struct timer_list timer_init = TIMER_INITIALIZER(NULL, 0, 0);
20572 + struct crisv32_ethernet_local *np;
20573 +
20574 + dev->base_addr = 0; /* Just to have something to show. */
20575 +
20576 + /* we do our own locking */
20577 + dev->features |= NETIF_F_LLTX;
20578 +
20579 + /* We use several IRQs and DMAs so just report 0 here. */
20580 + dev->irq = 0;
20581 + dev->dma = 0;
20582 +
20583 + /*
20584 + * Fill in our handlers so the network layer can talk to us in the
20585 + * future.
20586 + */
20587 + dev->open = crisv32_eth_open;
20588 + dev->hard_start_xmit = crisv32_eth_send_packet;
20589 + dev->stop = crisv32_eth_close;
20590 + dev->get_stats = crisv32_get_stats;
20591 + dev->set_multicast_list = crisv32_eth_set_multicast_list;
20592 + dev->set_mac_address = crisv32_eth_set_mac_address;
20593 + dev->ethtool_ops = &crisv32_ethtool_ops;
20594 + dev->do_ioctl = crisv32_eth_ioctl;
20595 + dev->set_config = crisv32_eth_set_config;
20596 + dev->tx_timeout = crisv32_eth_tx_timeout;
20597 +#ifdef CONFIG_NET_POLL_CONTROLLER
20598 + dev->poll_controller = crisv32_netpoll;
20599 +#endif
20600 +
20601 + np = netdev_priv(dev);
20602 +
20603 + spin_lock_init(&np->lock);
20604 + spin_lock_init(&np->transceiver_lock);
20605 +
20606 + /* Initialize speed indicator stuff. */
20607 + np->current_speed = 10;
20608 + np->current_speed_selection = 0; /* Auto. */
20609 + np->speed_timer = timer_init;
20610 + np->speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
20611 + np->speed_timer.data = (unsigned long) dev;
20612 + np->speed_timer.function = crisv32_eth_check_speed;
20613 +
20614 + np->full_duplex = 0;
20615 + np->current_duplex = autoneg;
20616 + np->duplex_timer = timer_init;
20617 + np->duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
20618 + np->duplex_timer.data = (unsigned long) dev;
20619 + np->duplex_timer.function = crisv32_eth_check_duplex;
20620 +
20621 + return 0;
20622 +}
20623 +
20624 +static int
20625 +crisv32_eth_open(struct net_device *dev)
20626 +{
20627 + struct sockaddr mac_addr;
20628 + reg_dma_rw_ack_intr ack_intr = { .data = 1,.in_eop = 1 };
20629 + reg_dma_rw_cfg dma_cfg = { .en = 1 };
20630 + reg_eth_rw_clr_err clr_err = {.clr = regk_eth_yes};
20631 + int intr_mask_nw = 0x1cff;
20632 + int eth_ack_intr = 0xffff;
20633 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20634 +
20635 + spin_lock(&np->lock);
20636 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
20637 + np->gigabit_mode = 0;
20638 +#endif
20639 + crisv32_disable_tx_ints(np);
20640 + crisv32_disable_rx_ints(np);
20641 +
20642 + REG_WR(eth, np->eth_inst, rw_clr_err, clr_err);
20643 + REG_WR_INT(eth, np->eth_inst, rw_ack_intr, eth_ack_intr);
20644 + REG_WR_INT(eth, np->eth_inst, rw_intr_mask, intr_mask_nw);
20645 + crisv32_eth_reset_rings(dev);
20646 +
20647 + /* Give the hardware an idea of what MAC address we want. */
20648 + memcpy(mac_addr.sa_data, dev->dev_addr, dev->addr_len);
20649 + crisv32_eth_set_mac_address(dev, &mac_addr);
20650 +
20651 + /* Enable irq and make sure that the irqs are cleared. */
20652 + REG_WR(dma, np->dma_out_inst, rw_ack_intr, ack_intr);
20653 + REG_WR(dma, np->dma_in_inst, rw_ack_intr, ack_intr);
20654 +
20655 + /* Prepare input DMA. */
20656 + DMA_RESET(np->dma_in_inst);
20657 + DMA_ENABLE(np->dma_in_inst);
20658 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
20659 + DMA_WR_CMD(np->dma_in_inst, regk_dma_set_w_size2);
20660 +#endif
20661 + DMA_START_CONTEXT( np->dma_in_inst, virt_to_phys(&np->ctxt_in));
20662 + DMA_CONTINUE(np->dma_in_inst);
20663 + crisv32_enable_rx_ints(np);
20664 + crisv32_start_receiver(np);
20665 +
20666 + /* Prepare output DMA. */
20667 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
20668 + DMA_WR_CMD(np->dma_out_inst, regk_dma_set_w_size4);
20669 +#endif
20670 + REG_WR(dma, np->dma_out_inst, rw_cfg, dma_cfg);
20671 + netif_start_queue(dev);
20672 + crisv32_enable_tx_ints(np);
20673 +
20674 + /* Start duplex/speed timers */
20675 + add_timer(&np->speed_timer);
20676 + add_timer(&np->duplex_timer);
20677 +
20678 + spin_unlock(&np->lock);
20679 + /*
20680 + * We are now ready to accept transmit requeusts from the queueing
20681 + * layer of the networking.
20682 + */
20683 + netif_carrier_on(dev);
20684 +
20685 + return 0;
20686 +}
20687 +
20688 +static int
20689 +crisv32_eth_close(struct net_device *dev)
20690 +{
20691 + reg_dma_rw_ack_intr ack_intr = {0};
20692 +
20693 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20694 + unsigned long flags;
20695 +
20696 + printk(KERN_INFO "Closing %s.\n", dev->name);
20697 +
20698 + /* stop the receiver before the DMA channels to avoid overruns. */
20699 + crisv32_stop_receiver(np);
20700 +
20701 + spin_lock_irqsave(&np->lock, flags);
20702 + netif_stop_queue(dev);
20703 +
20704 + /* Reset the TX DMA in case it has hung on something. */
20705 + DMA_RESET(np->dma_in_inst);
20706 +
20707 + /* Stop DMA */
20708 + DMA_STOP(np->dma_in_inst);
20709 + DMA_STOP(np->dma_out_inst);
20710 +
20711 + /* Disable irq and make sure that the irqs are cleared. */
20712 + crisv32_disable_tx_ints(np);
20713 + ack_intr.data = 1;
20714 + REG_WR(dma, np->dma_out_inst, rw_ack_intr, ack_intr);
20715 +
20716 + crisv32_disable_rx_ints(np);
20717 + ack_intr.in_eop = 1;
20718 + REG_WR(dma, np->dma_in_inst, rw_ack_intr, ack_intr);
20719 +
20720 + np->sender_started = 0;
20721 + spin_unlock_irqrestore(&np->lock, flags);
20722 +
20723 + /* Update the statistics. */
20724 + update_rx_stats(np);
20725 + update_tx_stats(np);
20726 +
20727 + /* Stop speed/duplex timers */
20728 + del_timer(&np->speed_timer);
20729 + del_timer(&np->duplex_timer);
20730 +
20731 + return 0;
20732 +}
20733 +
20734 +static int
20735 +crisv32_eth_set_mac_address(struct net_device *dev, void *vpntr)
20736 +{
20737 + int i;
20738 + unsigned char *addr = ((struct sockaddr*)vpntr)->sa_data;
20739 +
20740 + reg_eth_rw_ma0_lo ma0_lo =
20741 + { addr[0] | (addr[1] << 8) | (addr[2] << 16) | (addr[3] << 24)};
20742 +
20743 + reg_eth_rw_ma0_hi ma0_hi = { addr[4] | (addr[5] << 8) };
20744 +
20745 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20746 +
20747 + /* Remember the address. */
20748 + memcpy(dev->dev_addr, addr, dev->addr_len);
20749 +
20750 + /*
20751 + * Write the address to the hardware.
20752 + * Note the way the address is wrapped:
20753 + * ma0_l0 = a0_0 | (a0_1 << 8) | (a0_2 << 16) | (a0_3 << 24);
20754 + * ma0_hi = a0_4 | (a0_5 << 8);
20755 + */
20756 + REG_WR(eth, np->eth_inst, rw_ma0_lo, ma0_lo);
20757 + REG_WR(eth, np->eth_inst, rw_ma0_hi, ma0_hi);
20758 +
20759 + printk(KERN_INFO "%s: changed MAC to ", dev->name);
20760 +
20761 + for (i = 0; i < 5; i++)
20762 + printk("%02X:", dev->dev_addr[i]);
20763 +
20764 + printk("%02X\n", dev->dev_addr[i]);
20765 +
20766 + return 0;
20767 +}
20768 +
20769 +static irqreturn_t
20770 +crisv32rx_eth_interrupt(int irq, void *dev_id)
20771 +{
20772 + reg_dma_r_masked_intr masked_in;
20773 + reg_dma_rw_cmd cmd = {0};
20774 + reg_dma_rw_ack_intr ack_intr = {0};
20775 + struct net_device *dev = (struct net_device *) dev_id;
20776 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20777 +
20778 + masked_in = REG_RD(dma, np->dma_in_inst, r_masked_intr);
20779 +
20780 + if (masked_in.in_eop) {
20781 + DEBUG(printk("EOP_IN interrupt\n"));
20782 +
20783 + /* Acknowledge input dma interrupt. */
20784 + ack_intr.in_eop = 1;
20785 + REG_WR(dma, np->dma_in_inst, rw_ack_intr, ack_intr);
20786 +
20787 + np->new_rx_package = 1;
20788 + /* Check if complete packets were indeed received. */
20789 + while (np->active_rx_desc->descr.in_eop == 1
20790 + && np->new_rx_package) {
20791 + /*
20792 + * Take out the buffer and give it to the OS, then
20793 + * allocate a new buffer to put a packet in.
20794 + */
20795 + crisv32_eth_receive_packet(dev);
20796 +
20797 + /* Update number of packets received. */
20798 + np->stats.rx_packets++;
20799 +
20800 + /* Restarts input dma. */
20801 + cmd.cont_data = 1;
20802 + REG_WR(dma, np->dma_in_inst, rw_cmd, cmd);
20803 +
20804 + /* Acknowledge input dma interrupt. */
20805 + REG_WR(dma, np->dma_in_inst, rw_ack_intr, ack_intr);
20806 + }
20807 + }
20808 + return IRQ_HANDLED;
20809 +}
20810 +
20811 +static irqreturn_t
20812 +crisv32tx_eth_interrupt(int irq, void *dev_id)
20813 +{
20814 + reg_dma_rw_stat stat;
20815 + dma_descr_data *dma_pos;
20816 + reg_dma_rw_ack_intr ack_intr = { .data = 1 };
20817 + reg_dma_r_masked_intr masked_out;
20818 +
20819 + struct net_device *dev = (struct net_device *) dev_id;
20820 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20821 + unsigned long flags;
20822 +
20823 + masked_out = REG_RD(dma, np->dma_out_inst, r_masked_intr);
20824 +
20825 + /* Get the current output dma position. */
20826 + stat = REG_RD(dma, np->dma_out_inst, rw_stat);
20827 + if (stat.list_state == regk_dma_data_at_eol)
20828 + dma_pos = &np->active_tx_desc->descr;
20829 + else
20830 + dma_pos = phys_to_virt(REG_RD_INT(dma, np->dma_out_inst,
20831 + rw_data));
20832 +
20833 + /* ack the interrupt */
20834 + REG_WR(dma, np->dma_out_inst, rw_ack_intr, ack_intr);
20835 +
20836 + /* protect against ethernet excessive-col interrupts */
20837 + spin_lock_irqsave(&np->lock, flags);
20838 +
20839 + /* Take care of transmited dma descriptors and report sent packet. */
20840 + while (np->txpackets && ((&np->catch_tx_desc->descr != dma_pos)
20841 + || netif_queue_stopped(dev))) {
20842 + /* Update sent packet statistics. */
20843 + np->stats.tx_bytes += np->catch_tx_desc->skb->len;
20844 + np->stats.tx_packets++;
20845 +
20846 + dev_kfree_skb_irq(np->catch_tx_desc->skb);
20847 + np->catch_tx_desc->skb = 0;
20848 + np->txpackets--;
20849 + np->catch_tx_desc =
20850 + phys_to_virt((int)np->catch_tx_desc->descr.next);
20851 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
20852 + if (np->gigabit_mode) {
20853 + np->intmem_tx_buf_catch->free = 1;
20854 + np->intmem_tx_buf_catch = np->intmem_tx_buf_catch->next;
20855 + }
20856 +#endif
20857 + netif_wake_queue(dev);
20858 + }
20859 + spin_unlock_irqrestore(&np->lock, flags);
20860 + return IRQ_HANDLED;
20861 +}
20862 +
20863 +
20864 +/* Update receive errors. */
20865 +static void
20866 +update_rx_stats(struct crisv32_ethernet_local *np)
20867 +{
20868 + reg_eth_rs_rec_cnt r;
20869 + reg_eth_rs_phy_cnt rp;
20870 +
20871 + r = REG_RD(eth, np->eth_inst, rs_rec_cnt);
20872 + rp = REG_RD(eth, np->eth_inst, rs_phy_cnt);
20873 +
20874 + np->stats.rx_fifo_errors += r.congestion;
20875 + np->stats.rx_crc_errors += r.crc_err;
20876 + np->stats.rx_frame_errors += r.align_err;
20877 + np->stats.rx_length_errors += r.oversize;
20878 +}
20879 +
20880 +/* Update transmit errors. */
20881 +static void
20882 +update_tx_stats(struct crisv32_ethernet_local *np)
20883 +{
20884 + reg_eth_rs_tr_cnt r;
20885 +
20886 + r = REG_RD(eth, np->eth_inst, rs_tr_cnt);
20887 +
20888 + np->stats.collisions += r.single_col + r.mult_col;
20889 + np->stats.tx_errors += r.deferred;
20890 +}
20891 +
20892 +/* Get current statistics. */
20893 +static struct net_device_stats *
20894 +crisv32_get_stats(struct net_device *dev)
20895 +{
20896 + unsigned long flags;
20897 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20898 +
20899 + spin_lock_irqsave(&np->lock, flags);
20900 +
20901 + update_rx_stats(np);
20902 + update_tx_stats(np);
20903 +
20904 + spin_unlock_irqrestore(&np->lock, flags);
20905 +
20906 + return &np->stats;
20907 +}
20908 +
20909 +/* Check for network errors. This acknowledge the received interrupt. */
20910 +static irqreturn_t
20911 +crisv32nw_eth_interrupt(int irq, void *dev_id)
20912 +{
20913 + struct net_device *dev = (struct net_device *) dev_id;
20914 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20915 + reg_eth_r_masked_intr intr_mask;
20916 + int ack_intr = 0xffff;
20917 + reg_eth_rw_clr_err clr_err;
20918 +
20919 + intr_mask = REG_RD(eth, np->eth_inst, r_masked_intr);
20920 +
20921 + /*
20922 + * Check for underrun and/or excessive collisions. Note that the
20923 + * rw_clr_err register clears both underrun and excessive collision
20924 + * errors, so there's no need to check them separately.
20925 + */
20926 + if (np->sender_started
20927 + && (intr_mask.urun || intr_mask.exc_col)) {
20928 + unsigned long flags;
20929 + dma_descr_data *dma_pos;
20930 + reg_dma_rw_stat stat;
20931 +
20932 + /* Get the current output dma position. */
20933 + stat = REG_RD(dma, np->dma_out_inst, rw_stat);
20934 + if (stat.list_state == regk_dma_data_at_eol)
20935 + dma_pos = &np->active_tx_desc->descr;
20936 + else
20937 + dma_pos = phys_to_virt(REG_RD_INT(dma,
20938 + np->dma_out_inst,
20939 + rw_data));
20940 +
20941 + /*
20942 + * Protect against the tx-interrupt messing with
20943 + * the tx-ring.
20944 + */
20945 + spin_lock_irqsave(&np->lock, flags);
20946 + /*
20947 + * If we have more than one packet in the tx-ring
20948 + * drop one and move ahead. Upper layers rely on
20949 + * packeloss when doing congestion control.
20950 + */
20951 + if (intr_mask.exc_col && np->txpackets > 1) {
20952 + dev_kfree_skb_irq(np->catch_tx_desc->skb);
20953 + np->catch_tx_desc->skb = 0;
20954 + np->catch_tx_desc =
20955 + phys_to_virt((int)
20956 + np->catch_tx_desc->descr.next);
20957 + np->txpackets--;
20958 + netif_wake_queue(dev);
20959 + }
20960 + np->ctxt_out.next = 0;
20961 + if (np->txpackets) {
20962 + np->ctxt_out.saved_data = (void *)
20963 + virt_to_phys(&np->catch_tx_desc->descr);
20964 + np->ctxt_out.saved_data_buf =
20965 + np->catch_tx_desc->descr.buf;
20966 +
20967 + /* restart the DMA */
20968 + DMA_START_CONTEXT(np->dma_out_inst,
20969 + (int) virt_to_phys(&np->ctxt_out));
20970 + }
20971 + else {
20972 + /* let the next packet restart the DMA */
20973 + np->ctxt_out.saved_data = (void *)
20974 + virt_to_phys(&np->active_tx_desc->descr);
20975 + np->sender_started = 0;
20976 + }
20977 +
20978 + spin_unlock_irqrestore(&np->lock, flags);
20979 + np->stats.tx_errors++;
20980 + }
20981 +
20982 + REG_WR_INT(eth, np->eth_inst, rw_ack_intr, ack_intr);
20983 + clr_err.clr = 1;
20984 + REG_WR(eth, np->eth_inst, rw_clr_err, clr_err);
20985 +
20986 + update_rx_stats(np);
20987 + update_tx_stats(np);
20988 +
20989 + return IRQ_HANDLED;
20990 +}
20991 +
20992 +/* We have a good packet(s), get it/them out of the buffers. */
20993 +static void
20994 +crisv32_eth_receive_packet(struct net_device *dev)
20995 +{
20996 + int length;
20997 + struct sk_buff *skb;
20998 + struct crisv32_ethernet_local *np = netdev_priv(dev);
20999 + struct sk_buff *tmp;
21000 + unsigned long flags;
21001 +
21002 + DEBUG(printk("crisv32_receive_packet\n"));
21003 +
21004 + /* Activate LED */
21005 + spin_lock_irqsave(&np->leds->led_lock, flags);
21006 + if (!np->leds->led_active && time_after(jiffies, np->leds->led_next_time)) {
21007 + /* light the network leds depending on the current speed. */
21008 + crisv32_set_network_leds(LED_ACTIVITY, dev);
21009 +
21010 + /* Set the earliest time we may clear the LED */
21011 + np->leds->led_next_time = jiffies + NET_FLASH_TIME;
21012 + np->leds->led_active = 1;
21013 + np->leds->clear_led_timer.data = (unsigned long) dev;
21014 + mod_timer(&np->leds->clear_led_timer, jiffies + HZ/10);
21015 + }
21016 + spin_unlock_irqrestore(&np->leds->led_lock, flags);
21017 +
21018 + /* Discard CRC (4 bytes). */
21019 + length = (np->active_rx_desc->descr.after) -
21020 + (np->active_rx_desc->descr.buf) - 4;
21021 +
21022 + /* Update received packet statistics. */
21023 + np->stats.rx_bytes += length;
21024 +
21025 + if (np->active_rx_desc != np->last_rx_desc) {
21026 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21027 + if (np->gigabit_mode) {
21028 + skb = dev_alloc_skb(length);
21029 + if(!skb) {
21030 + np->stats.rx_errors++;
21031 + printk(KERN_NOTICE "%s: memory squeeze,"
21032 + " dropping packet.", dev->name);
21033 + return;
21034 + }
21035 + /* Allocate room for the packet body. */
21036 + skb_put(skb, length - ETHER_HEAD_LEN);
21037 + /* Allocate room for the header and copy the data to
21038 + * the SKB */
21039 + memcpy(skb_push(skb, ETHER_HEAD_LEN),
21040 + crisv32_intmem_phys_to_virt((unsigned long)np->active_rx_desc->descr.buf), length);
21041 + skb->dev = dev;
21042 + skb->protocol = eth_type_trans(skb, dev);
21043 + skb->ip_summed = CHECKSUM_NONE;
21044 + /* Send the packet to the upper layer. */
21045 + netif_rx(skb);
21046 + np->last_rx_desc =
21047 + (void *) phys_to_virt(np->last_rx_desc->descr.next);
21048 + } else {
21049 +#endif
21050 + tmp = dev_alloc_skb(MAX_MEDIA_DATA_SIZE);
21051 + if (!tmp) {
21052 + np->stats.rx_errors++;
21053 + printk(KERN_NOTICE "%s: memory squeeze,"
21054 + " dropping packet.",
21055 + dev->name);
21056 + return;
21057 + }
21058 + skb = np->active_rx_desc->skb;
21059 + np->active_rx_desc->skb = tmp;
21060 + skb_put(skb, length);
21061 +
21062 + np->active_rx_desc->descr.buf =
21063 + (void *) virt_to_phys(np->active_rx_desc->skb->data);
21064 + np->active_rx_desc->descr.after =
21065 + np->active_rx_desc->descr.buf + MAX_MEDIA_DATA_SIZE;
21066 +
21067 + skb->dev = dev;
21068 + skb->protocol = eth_type_trans(skb, dev);
21069 + skb->ip_summed = CHECKSUM_NONE;
21070 +
21071 + /* Send the packet to the upper layer. */
21072 + netif_rx(skb);
21073 + np->last_rx_desc =
21074 + phys_to_virt((int)
21075 + np->last_rx_desc->descr.next);
21076 + }
21077 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21078 + }
21079 +#endif
21080 + /*
21081 + * When the input DMA reaches eol precaution must be taken, otherwise
21082 + * the DMA could stop. The problem occurs if the eol flag is re-placed
21083 + * on the descriptor that the DMA stands on before the DMA proceed to
21084 + * the next descriptor. This case could, for example, happen if there
21085 + * is a traffic burst and then the network goes silent. To prevent this
21086 + * we make sure that we do not set the eol flag on the descriptor that
21087 + * the DMA stands on.
21088 + */
21089 + if(virt_to_phys(&np->active_rx_desc->descr) !=
21090 + REG_RD_INT(dma, np->dma_in_inst, rw_saved_data)) {
21091 + np->active_rx_desc->descr.after =
21092 + np->active_rx_desc->descr.buf + MAX_MEDIA_DATA_SIZE;
21093 + np->active_rx_desc->descr.eol = 1;
21094 + np->active_rx_desc->descr.in_eop = 0;
21095 + np->active_rx_desc =
21096 + phys_to_virt((int)np->active_rx_desc->descr.next);
21097 + barrier();
21098 + np->prev_rx_desc->descr.eol = 0;
21099 + flush_dma_descr(&np->prev_rx_desc->descr, 0); // Workaround cache bug
21100 + np->prev_rx_desc =
21101 + phys_to_virt((int)np->prev_rx_desc->descr.next);
21102 + flush_dma_descr(&np->prev_rx_desc->descr, 1); // Workaround cache bug
21103 + } else {
21104 + np->new_rx_package = 0;
21105 + }
21106 +}
21107 +
21108 +/*
21109 + * This function (i.e. hard_start_xmit) is protected from concurent calls by a
21110 + * spinlock (xmit_lock) in the net_device structure.
21111 + */
21112 +static int
21113 +crisv32_eth_send_packet(struct sk_buff *skb, struct net_device *dev)
21114 +{
21115 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21116 + unsigned char *buf = skb->data;
21117 + unsigned long flags;
21118 +
21119 + dev->trans_start = jiffies;
21120 +
21121 + spin_lock_irqsave(&np->leds->led_lock, flags);
21122 + if (!np->leds->led_active && time_after(jiffies, np->leds->led_next_time)) {
21123 + /* light the network leds depending on the current speed. */
21124 + crisv32_set_network_leds(LED_ACTIVITY, dev);
21125 +
21126 + /* Set the earliest time we may clear the LED */
21127 + np->leds->led_next_time = jiffies + NET_FLASH_TIME;
21128 + np->leds->led_active = 1;
21129 + np->leds->clear_led_timer.data = (unsigned long) dev;
21130 + mod_timer(&np->leds->clear_led_timer, jiffies + HZ/10);
21131 + }
21132 + spin_unlock_irqrestore(&np->leds->led_lock, flags);
21133 +
21134 + /*
21135 + * Need to disable irq to avoid updating pointer in interrupt while
21136 + * sending packets.
21137 + */
21138 + spin_lock_irqsave(&np->lock, flags);
21139 +
21140 + np->active_tx_desc->skb = skb;
21141 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21142 + if (np->gigabit_mode) {
21143 + if(np->intmem_tx_buf_active->free) {
21144 + memcpy(np->intmem_tx_buf_active->buf,
21145 + skb->data, skb->len);
21146 + np->intmem_tx_buf_active->free = 0;
21147 + crisv32_eth_hw_send_packet(
21148 + np->intmem_tx_buf_active->buf, skb->len, np);
21149 + np->intmem_tx_buf_active =
21150 + np->intmem_tx_buf_active->next;
21151 + } else {
21152 + printk("%s: Internal tx memory buffer not free!\n\r",
21153 + __FILE__);
21154 + spin_unlock_irqrestore(&np->lock, flags);
21155 + return 1;
21156 + }
21157 + }
21158 + else
21159 +#endif
21160 + {
21161 + crisv32_eth_hw_send_packet(buf, skb->len, np);
21162 + }
21163 + /* Stop queue if full. */
21164 + if (np->active_tx_desc == np->catch_tx_desc)
21165 + netif_stop_queue(dev);
21166 +
21167 + np->txpackets++;
21168 + spin_unlock_irqrestore(&np->lock, flags);
21169 +
21170 + return 0;
21171 +}
21172 +
21173 +
21174 +static void
21175 +crisv32_eth_hw_send_packet(unsigned char *buf, int length, void *priv)
21176 +{
21177 + struct crisv32_ethernet_local *np =
21178 + (struct crisv32_ethernet_local *) priv;
21179 +
21180 + /* Configure the tx dma descriptor. */
21181 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21182 + if (np->gigabit_mode) {
21183 + np->active_tx_desc->descr.buf = (unsigned char *) crisv32_intmem_virt_to_phys(buf);
21184 + } else
21185 +#endif
21186 + {
21187 + np->active_tx_desc->descr.buf = (unsigned char *) virt_to_phys(buf);
21188 + }
21189 +
21190 + np->active_tx_desc->descr.after = np->active_tx_desc->descr.buf +
21191 + length;
21192 + np->active_tx_desc->descr.intr = 1;
21193 + np->active_tx_desc->descr.out_eop = 1;
21194 +
21195 + /* Move eol. */
21196 + np->active_tx_desc->descr.eol = 1;
21197 + np->prev_tx_desc->descr.eol = 0;
21198 +
21199 +
21200 + /* Update pointers. */
21201 + np->prev_tx_desc = np->active_tx_desc;
21202 + np->active_tx_desc = phys_to_virt((int)np->active_tx_desc->descr.next);
21203 +
21204 + /* Start DMA. */
21205 + crisv32_start_dma_out(np);
21206 +}
21207 +
21208 +static void
21209 +crisv32_start_dma_out(struct crisv32_ethernet_local* np)
21210 +{
21211 + if (!np->sender_started) {
21212 + /* Start DMA for the first time. */
21213 + np->ctxt_out.saved_data_buf = np->prev_tx_desc->descr.buf;
21214 + REG_WR(dma, np->dma_out_inst, rw_group_down,
21215 + (int) virt_to_phys(&np->ctxt_out));
21216 + DMA_WR_CMD(np->dma_out_inst, regk_dma_load_c);
21217 + DMA_WR_CMD(np->dma_out_inst, regk_dma_load_d | regk_dma_burst);
21218 + np->sender_started = 1;
21219 + } else {
21220 + DMA_CONTINUE_DATA(np->dma_out_inst);
21221 + }
21222 +}
21223 +
21224 +/*
21225 + * Called by upper layers if they decide it took too long to complete sending
21226 + * a packet - we need to reset and stuff.
21227 + */
21228 +static void
21229 +crisv32_eth_tx_timeout(struct net_device *dev)
21230 +{
21231 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21232 + reg_dma_rw_cfg cfg = {0};
21233 + reg_dma_rw_stat stat = {0};
21234 + unsigned long flags;
21235 +
21236 + printk(KERN_WARNING "%s: transmit timed out\n", dev->name);
21237 +
21238 +
21239 + spin_lock_irqsave(&np->lock, flags);
21240 + crisv32_ethernet_bug(dev);
21241 +
21242 + np->txpackets = 0;
21243 + /* Update error stats. */
21244 + np->stats.tx_errors++;
21245 +
21246 + /* Reset the TX DMA in case it has hung on something. */
21247 + cfg.en = 0;
21248 + REG_WR(dma, np->dma_out_inst, rw_cfg, cfg);
21249 +
21250 + do {
21251 + stat = REG_RD(dma, np->dma_out_inst, rw_stat);
21252 + } while (stat.mode != regk_dma_rst);
21253 +
21254 + /* Reset the tranceiver. */
21255 + crisv32_eth_reset_tranceiver(dev);
21256 +
21257 + /* Get rid of the packets that never got an interrupt. */
21258 + do {
21259 + if (np->catch_tx_desc->skb)
21260 + dev_kfree_skb(np->catch_tx_desc->skb);
21261 +
21262 + np->catch_tx_desc->skb = 0;
21263 + np->catch_tx_desc =
21264 + phys_to_virt((int)np->catch_tx_desc->descr.next);
21265 + } while (np->catch_tx_desc != np->active_tx_desc);
21266 +
21267 +
21268 + /* Start output DMA. */
21269 + REG_WR(dma, np->dma_out_inst, rw_group_down,
21270 + (int) virt_to_phys(&np->ctxt_out));
21271 + DMA_WR_CMD(np->dma_out_inst, regk_dma_load_c);
21272 + DMA_WR_CMD(np->dma_out_inst, regk_dma_load_d | regk_dma_burst);
21273 + spin_unlock_irqrestore(&np->lock, flags);
21274 +
21275 + /* Tell the upper layers we're ok again. */
21276 + netif_wake_queue(dev);
21277 +}
21278 +
21279 +/*
21280 + * Set or clear the multicast filter for this adaptor.
21281 + * num_addrs == -1 Promiscuous mode, receive all packets
21282 + * num_addrs == 0 Normal mode, clear multicast list
21283 + * num_addrs > 0 Multicast mode, receive normal and MC packets,
21284 + * and do best-effort filtering.
21285 + */
21286 +static void
21287 +crisv32_eth_set_multicast_list(struct net_device *dev)
21288 +{
21289 + int num_addr = dev->mc_count;
21290 + unsigned long int lo_bits;
21291 + unsigned long int hi_bits;
21292 + reg_eth_rw_rec_ctrl rec_ctrl = {0};
21293 + reg_eth_rw_ga_lo ga_lo = {0};
21294 + reg_eth_rw_ga_hi ga_hi = {0};
21295 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21296 +
21297 + if (dev->flags & IFF_PROMISC) {
21298 + /* Promiscuous mode. */
21299 + lo_bits = 0xfffffffful;
21300 + hi_bits = 0xfffffffful;
21301 +
21302 + /* Enable individual receive. */
21303 + rec_ctrl = (reg_eth_rw_rec_ctrl) REG_RD(eth, np->eth_inst,
21304 + rw_rec_ctrl);
21305 + rec_ctrl.individual = regk_eth_yes;
21306 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
21307 + } else if (dev->flags & IFF_ALLMULTI) {
21308 + /* Enable all multicasts. */
21309 + lo_bits = 0xfffffffful;
21310 + hi_bits = 0xfffffffful;
21311 +
21312 + /* Disable individual receive */
21313 + rec_ctrl =
21314 + (reg_eth_rw_rec_ctrl) REG_RD(eth, np->eth_inst, rw_rec_ctrl);
21315 + rec_ctrl.individual = regk_eth_no;
21316 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
21317 + } else if (num_addr == 0) {
21318 + /* Normal, clear the mc list. */
21319 + lo_bits = 0x00000000ul;
21320 + hi_bits = 0x00000000ul;
21321 +
21322 + /* Disable individual receive */
21323 + rec_ctrl =
21324 + (reg_eth_rw_rec_ctrl) REG_RD(eth, np->eth_inst, rw_rec_ctrl);
21325 + rec_ctrl.individual = regk_eth_no;
21326 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
21327 + } else {
21328 + /* MC mode, receive normal and MC packets. */
21329 + char hash_ix;
21330 + struct dev_mc_list *dmi = dev->mc_list;
21331 + int i;
21332 + char *baddr;
21333 + lo_bits = 0x00000000ul;
21334 + hi_bits = 0x00000000ul;
21335 +
21336 + for (i = 0; i < num_addr; i++) {
21337 + /* Calculate the hash index for the GA registers. */
21338 + hash_ix = 0;
21339 + baddr = dmi->dmi_addr;
21340 + hash_ix ^= (*baddr) & 0x3f;
21341 + hash_ix ^= ((*baddr) >> 6) & 0x03;
21342 + ++baddr;
21343 + hash_ix ^= ((*baddr) << 2) & 0x03c;
21344 + hash_ix ^= ((*baddr) >> 4) & 0xf;
21345 + ++baddr;
21346 + hash_ix ^= ((*baddr) << 4) & 0x30;
21347 + hash_ix ^= ((*baddr) >> 2) & 0x3f;
21348 + ++baddr;
21349 + hash_ix ^= (*baddr) & 0x3f;
21350 + hash_ix ^= ((*baddr) >> 6) & 0x03;
21351 + ++baddr;
21352 + hash_ix ^= ((*baddr) << 2) & 0x03c;
21353 + hash_ix ^= ((*baddr) >> 4) & 0xf;
21354 + ++baddr;
21355 + hash_ix ^= ((*baddr) << 4) & 0x30;
21356 + hash_ix ^= ((*baddr) >> 2) & 0x3f;
21357 +
21358 + hash_ix &= 0x3f;
21359 +
21360 + if (hash_ix > 32)
21361 + hi_bits |= (1 << (hash_ix - 32));
21362 + else
21363 + lo_bits |= (1 << hash_ix);
21364 +
21365 + dmi = dmi->next;
21366 + }
21367 +
21368 + /* Disable individual receive. */
21369 + rec_ctrl =
21370 + (reg_eth_rw_rec_ctrl) REG_RD(eth, np->eth_inst, rw_rec_ctrl);
21371 + rec_ctrl.individual = regk_eth_no;
21372 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
21373 + }
21374 +
21375 + ga_lo.tbl = (unsigned int) lo_bits;
21376 + ga_hi.tbl = (unsigned int) hi_bits;
21377 +
21378 + REG_WR(eth, np->eth_inst, rw_ga_lo, ga_lo);
21379 + REG_WR(eth, np->eth_inst, rw_ga_hi, ga_hi);
21380 +}
21381 +
21382 +static int
21383 +crisv32_eth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
21384 +{
21385 + struct mii_ioctl_data *data = if_mii(ifr);
21386 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21387 + int old_autoneg;
21388 +
21389 + spin_lock(&np->lock); /* Preempt protection */
21390 + switch (cmd) {
21391 + case SIOCGMIIPHY: /* Get PHY address */
21392 + data->phy_id = np->mdio_phy_addr;
21393 + break;
21394 + case SIOCGMIIREG: /* Read MII register */
21395 + data->val_out = crisv32_eth_get_mdio_reg(dev,
21396 + data->reg_num);
21397 + break;
21398 + case SIOCSMIIREG: /* Write MII register */
21399 + crisv32_eth_set_mdio_reg(dev, data->reg_num,
21400 + data->val_in);
21401 + break;
21402 + case SET_ETH_ENABLE_LEDS:
21403 + use_network_leds = 1;
21404 + break;
21405 + case SET_ETH_DISABLE_LEDS:
21406 + use_network_leds = 0;
21407 + break;
21408 + case SET_ETH_AUTONEG:
21409 + old_autoneg = autoneg_normal;
21410 + autoneg_normal = *(int*)data;
21411 + if (autoneg_normal != old_autoneg)
21412 + crisv32_eth_negotiate(dev);
21413 + break;
21414 + default:
21415 + spin_unlock(&np->lock); /* Preempt protection */
21416 + return -EINVAL;
21417 + }
21418 + spin_unlock(&np->lock);
21419 + return 0;
21420 +}
21421 +
21422 +static int crisv32_eth_get_settings(struct net_device *dev,
21423 + struct ethtool_cmd *ecmd)
21424 +{
21425 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21426 + /* What about GMII and 1000xpause? not included in ethtool.h */
21427 + ecmd->supported = SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII |
21428 + SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
21429 + SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full;
21430 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21431 + ecmd->supported |= SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full;
21432 +#endif
21433 + ecmd->port = PORT_TP;
21434 + ecmd->transceiver = XCVR_EXTERNAL;
21435 + ecmd->phy_address = np->mdio_phy_addr;
21436 + ecmd->speed = np->current_speed;
21437 + ecmd->duplex = np->full_duplex;
21438 + ecmd->advertising = ADVERTISED_TP;
21439 +
21440 + if (np->current_duplex == autoneg && np->current_speed_selection == 0)
21441 + ecmd->advertising |= ADVERTISED_Autoneg;
21442 + else {
21443 + ecmd->advertising |=
21444 + ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
21445 + ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full;
21446 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21447 + ecmd->advertising |= ADVERTISED_1000baseT_Half |
21448 + ADVERTISED_1000baseT_Full;
21449 +#endif
21450 + if (np->current_speed_selection == 10)
21451 + ecmd->advertising &= ~(ADVERTISED_100baseT_Half |
21452 + ADVERTISED_100baseT_Full |
21453 + ADVERTISED_1000baseT_Half |
21454 + ADVERTISED_1000baseT_Full);
21455 +
21456 + else if (np->current_speed_selection == 100)
21457 + ecmd->advertising &= ~(ADVERTISED_10baseT_Half |
21458 + ADVERTISED_10baseT_Full |
21459 + ADVERTISED_1000baseT_Half |
21460 + ADVERTISED_1000baseT_Full);
21461 +
21462 + else if (np->current_speed_selection == 1000)
21463 + ecmd->advertising &= ~(ADVERTISED_10baseT_Half |
21464 + ADVERTISED_10baseT_Full |
21465 + ADVERTISED_100baseT_Half |
21466 + ADVERTISED_100baseT_Full);
21467 +
21468 + if (np->current_duplex == half)
21469 + ecmd->advertising &= ~(ADVERTISED_10baseT_Full |
21470 + ADVERTISED_100baseT_Full |
21471 + ADVERTISED_1000baseT_Full);
21472 + else if (np->current_duplex == full)
21473 + ecmd->advertising &= ~(ADVERTISED_10baseT_Half |
21474 + ADVERTISED_100baseT_Half |
21475 + ADVERTISED_1000baseT_Half);
21476 + }
21477 +
21478 + ecmd->autoneg = AUTONEG_ENABLE;
21479 + return 0;
21480 +}
21481 +
21482 +static int crisv32_eth_set_settings(struct net_device *dev,
21483 + struct ethtool_cmd *ecmd)
21484 +{
21485 + if (ecmd->autoneg == AUTONEG_ENABLE) {
21486 + crisv32_eth_set_duplex(dev, autoneg);
21487 + crisv32_eth_set_speed(dev, 0);
21488 + } else {
21489 + crisv32_eth_set_duplex(dev, ecmd->duplex);
21490 + crisv32_eth_set_speed(dev, ecmd->speed);
21491 + }
21492 +
21493 + return 0;
21494 +}
21495 +
21496 +static void crisv32_eth_get_drvinfo(struct net_device *dev,
21497 + struct ethtool_drvinfo *info)
21498 +{
21499 + strncpy(info->driver, "ETRAX FS", sizeof(info->driver) - 1);
21500 + strncpy(info->version, "$Revision: 1.96 $", sizeof(info->version) - 1);
21501 + strncpy(info->fw_version, "N/A", sizeof(info->fw_version) - 1);
21502 + strncpy(info->bus_info, "N/A", sizeof(info->bus_info) - 1);
21503 +}
21504 +
21505 +static int crisv32_eth_nway_reset(struct net_device *dev)
21506 +{
21507 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21508 +
21509 + if (np->current_duplex == autoneg && np->current_speed_selection == 0)
21510 + crisv32_eth_negotiate(dev);
21511 + return 0;
21512 +}
21513 +
21514 +static struct ethtool_ops crisv32_ethtool_ops = {
21515 + .get_settings = crisv32_eth_get_settings,
21516 + .set_settings = crisv32_eth_set_settings,
21517 + .get_drvinfo = crisv32_eth_get_drvinfo,
21518 + .nway_reset = crisv32_eth_nway_reset,
21519 + .get_link = ethtool_op_get_link,
21520 +};
21521 +
21522 +/* Is this function really needed? Use ethtool instead? */
21523 +static int
21524 +crisv32_eth_set_config(struct net_device *dev, struct ifmap *map)
21525 +{
21526 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21527 +
21528 + spin_lock(&np->lock); /* Preempt protection */
21529 +
21530 + switch(map->port) {
21531 + case IF_PORT_UNKNOWN:
21532 + /* Use autoneg */
21533 + crisv32_eth_set_speed(dev, 0);
21534 + crisv32_eth_set_duplex(dev, autoneg);
21535 + break;
21536 + case IF_PORT_10BASET:
21537 + crisv32_eth_set_speed(dev, 10);
21538 + crisv32_eth_set_duplex(dev, autoneg);
21539 + break;
21540 + case IF_PORT_100BASET:
21541 + case IF_PORT_100BASETX:
21542 + crisv32_eth_set_speed(dev, 100);
21543 + crisv32_eth_set_duplex(dev, autoneg);
21544 + break;
21545 + case IF_PORT_100BASEFX:
21546 + case IF_PORT_10BASE2:
21547 + case IF_PORT_AUI:
21548 + spin_unlock(&np->lock);
21549 + return -EOPNOTSUPP;
21550 + break;
21551 + default:
21552 + printk(KERN_ERR "%s: Invalid media selected",
21553 + dev->name);
21554 + spin_unlock(&np->lock);
21555 + return -EINVAL;
21556 + }
21557 + spin_unlock(&np->lock);
21558 + return 0;
21559 +}
21560 +
21561 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21562 +/*
21563 + * Switch the behaviour of the tx and rx buffers using
21564 + * external or internal memory. Usage of the internal
21565 + * memory is required for gigabit operation.
21566 + */
21567 +static void
21568 +crisv32_eth_switch_intmem_usage(struct net_device *dev)
21569 +{
21570 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21571 +
21572 + int i;
21573 + reg_dma_rw_stat stat;
21574 + reg_dma_rw_cfg cfg = {0};
21575 + reg_dma_rw_intr_mask intr_mask_in = { .in_eop = regk_dma_yes };
21576 + reg_dma_rw_ack_intr ack_intr = { .data = 1,.in_eop = 1 };
21577 + unsigned char *intmem_tmp;
21578 +
21579 + /* Notify the kernel that the interface has stopped */
21580 + netif_stop_queue(dev);
21581 +
21582 + /* Stop the receiver DMA */
21583 + cfg.en = regk_dma_no;
21584 + REG_WR(dma, np->dma_in_inst, rw_cfg, cfg);
21585 +
21586 + if (!(np->gigabit_mode)) {
21587 + /* deallocate SKBs in rx_desc */
21588 + for (i = 0; i < NBR_RX_DESC; i++)
21589 + dev_kfree_skb(np->dma_rx_descr_list[i].skb);
21590 +
21591 + /* Init TX*/
21592 + for(i=0; i < NBR_INTMEM_TX_BUF; i++) {
21593 + /* Allocate internal memory */
21594 + intmem_tmp = NULL;
21595 + intmem_tmp = crisv32_intmem_alloc(MAX_MEDIA_DATA_SIZE,
21596 + 32);
21597 + /* Check that we really got the memory */
21598 + if (intmem_tmp == NULL) {
21599 + printk(KERN_ERR "%s: Can't allocate intmem for"
21600 + " RX buffer nbr: %d\n", dev->name, i);
21601 + return;
21602 + }
21603 + /* Setup the list entry */
21604 + np->tx_intmem_buf_list[i].free = 1;
21605 + np->tx_intmem_buf_list[i].buf = intmem_tmp;
21606 + np->tx_intmem_buf_list[i].next = &np->tx_intmem_buf_list[i + 1];
21607 + }
21608 + /* Setup the last list entry */
21609 + np->tx_intmem_buf_list[NBR_INTMEM_TX_BUF - 1].next = &np->tx_intmem_buf_list[0];
21610 + /* Setup initial pointer */
21611 + np->intmem_tx_buf_active = np->tx_intmem_buf_list;
21612 + np->intmem_tx_buf_catch = np->tx_intmem_buf_list;
21613 +
21614 + /* Init RX */
21615 + for (i=0; i < NBR_INTMEM_RX_DESC; i++) {
21616 + /* Allocate internal memory */
21617 + intmem_tmp = NULL;
21618 + intmem_tmp = crisv32_intmem_alloc(MAX_MEDIA_DATA_SIZE, 32);
21619 + /* Check that we really got the memory */
21620 + if (intmem_tmp == NULL) {
21621 + printk(KERN_ERR "%s: Can't allocate intmem for"
21622 + " desc nbr: %d\n", dev->name, i);
21623 + return;
21624 + }
21625 + /* Setup the descriptors*/
21626 + np->dma_rx_descr_list[i].skb = NULL;
21627 + np->dma_rx_descr_list[i].descr.buf =
21628 + (void *) crisv32_intmem_virt_to_phys(intmem_tmp);
21629 + np->dma_rx_descr_list[i].descr.after =
21630 + (void *) crisv32_intmem_virt_to_phys(intmem_tmp + MAX_MEDIA_DATA_SIZE);
21631 + np->dma_rx_descr_list[i].descr.eol = 0;
21632 + np->dma_rx_descr_list[i].descr.in_eop = 0;
21633 + np->dma_rx_descr_list[i].descr.next =
21634 + (void *) virt_to_phys(&np->dma_rx_descr_list[i+1].descr);
21635 + }
21636 + /* Setup the last rx descriptor */
21637 + np->dma_rx_descr_list[NBR_INTMEM_RX_DESC - 1].descr.eol = 1;
21638 + np->dma_rx_descr_list[NBR_INTMEM_RX_DESC - 1].descr.next =
21639 + (void*) virt_to_phys(&np->dma_rx_descr_list[0].descr);
21640 + /* Initialise initial receive pointers. */
21641 + np->active_rx_desc = &np->dma_rx_descr_list[0];
21642 + np->prev_rx_desc = &np->dma_rx_descr_list[NBR_INTMEM_RX_DESC - 1];
21643 + np->last_rx_desc = np->prev_rx_desc;
21644 +
21645 + np->gigabit_mode = 1;
21646 + } else {
21647 + /* dealloc TX intmem */
21648 + for(i=0; i < NBR_INTMEM_TX_BUF; i++)
21649 + crisv32_intmem_free(np->tx_intmem_buf_list[i].buf);
21650 +
21651 + /* dealloc RX intmem */
21652 + for (i=0; i < NBR_INTMEM_RX_DESC; i++)
21653 + crisv32_intmem_free(crisv32_intmem_phys_to_virt((unsigned long)np->dma_rx_descr_list[i].descr.buf));
21654 +
21655 + /* Setup new rx_desc and alloc SKBs */
21656 + for (i = 0; i < NBR_RX_DESC; i++) {
21657 + struct sk_buff *skb;
21658 +
21659 + skb = dev_alloc_skb(MAX_MEDIA_DATA_SIZE);
21660 + np->dma_rx_descr_list[i].skb = skb;
21661 + np->dma_rx_descr_list[i].descr.buf =
21662 + (char*)virt_to_phys(skb->data);
21663 + np->dma_rx_descr_list[i].descr.after =
21664 + (char*)virt_to_phys(skb->data + MAX_MEDIA_DATA_SIZE);
21665 +
21666 + np->dma_rx_descr_list[i].descr.eol = 0;
21667 + np->dma_rx_descr_list[i].descr.in_eop = 0;
21668 + np->dma_rx_descr_list[i].descr.next =
21669 + (void *) virt_to_phys(&np->dma_rx_descr_list[i + 1].descr);
21670 + }
21671 +
21672 + np->dma_rx_descr_list[NBR_RX_DESC - 1].descr.eol = 1;
21673 + np->dma_rx_descr_list[NBR_RX_DESC - 1].descr.next =
21674 + (void *) virt_to_phys(&np->dma_rx_descr_list[0].descr);
21675 +
21676 + /* Initialise initial receive pointers. */
21677 + np->active_rx_desc = &np->dma_rx_descr_list[0];
21678 + np->prev_rx_desc = &np->dma_rx_descr_list[NBR_RX_DESC - 1];
21679 + np->last_rx_desc = np->prev_rx_desc;
21680 +
21681 + np->gigabit_mode = 0;
21682 + }
21683 +
21684 + /* Fill context descriptors. */
21685 + np->ctxt_in.next = 0;
21686 + np->ctxt_in.saved_data =
21687 + (dma_descr_data *) virt_to_phys(&np->dma_rx_descr_list[0].descr);
21688 + np->ctxt_in.saved_data_buf = np->dma_rx_descr_list[0].descr.buf;
21689 +
21690 + /* Enable irq and make sure that the irqs are cleared. */
21691 + REG_WR(dma, np->dma_in_inst, rw_intr_mask, intr_mask_in);
21692 + REG_WR(dma, np->dma_in_inst, rw_ack_intr, ack_intr);
21693 +
21694 + /* Start input dma */
21695 + cfg.en = regk_dma_yes;
21696 + REG_WR(dma, np->dma_in_inst, rw_cfg, cfg);
21697 + REG_WR(dma, np->dma_in_inst, rw_group_down,
21698 + (int) virt_to_phys(&np->ctxt_in));
21699 +
21700 + DMA_WR_CMD(np->dma_in_inst, regk_dma_load_c);
21701 + DMA_WR_CMD(np->dma_in_inst, regk_dma_load_d | regk_dma_burst);
21702 +
21703 + netif_wake_queue(dev);
21704 +
21705 + stat = REG_RD(dma, np->dma_in_inst, rw_stat);
21706 +}
21707 +#endif
21708 +
21709 +static void
21710 +crisv32_eth_negotiate(struct net_device *dev)
21711 +{
21712 + unsigned short data =
21713 + crisv32_eth_get_mdio_reg(dev, MII_ADVERTISE);
21714 + unsigned short ctrl1000 =
21715 + crisv32_eth_get_mdio_reg(dev, MII_CTRL1000);
21716 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21717 +
21718 + /* Make all capabilities available */
21719 + data |= ADVERTISE_10HALF | ADVERTISE_10FULL |
21720 + ADVERTISE_100HALF | ADVERTISE_100FULL;
21721 + ctrl1000 |= ADVERTISE_1000HALF | ADVERTISE_1000FULL;
21722 +
21723 + /* Remove the speed capabilities that we that do not want */
21724 + switch (np->current_speed_selection) {
21725 + case 10 :
21726 + data &= ~(ADVERTISE_100HALF | ADVERTISE_100FULL);
21727 + ctrl1000 &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
21728 + break;
21729 + case 100 :
21730 + data &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL);
21731 + ctrl1000 &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
21732 + break;
21733 + case 1000 :
21734 + data &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL |
21735 + ADVERTISE_100HALF | ADVERTISE_100FULL);
21736 + break;
21737 + }
21738 +
21739 + /* Remove the duplex capabilites that we do not want */
21740 + if (np->current_duplex == full) {
21741 + data &= ~(ADVERTISE_10HALF | ADVERTISE_100HALF);
21742 + ctrl1000 &= ~(ADVERTISE_1000HALF);
21743 + }
21744 + else if (np->current_duplex == half) {
21745 + data &= ~(ADVERTISE_10FULL | ADVERTISE_100FULL);
21746 + ctrl1000 &= ~(ADVERTISE_1000FULL);
21747 + }
21748 +
21749 + crisv32_eth_set_mdio_reg(dev, MII_ADVERTISE, data);
21750 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21751 + crisv32_eth_set_mdio_reg(dev, MII_CTRL1000, ctrl1000);
21752 +#endif
21753 +
21754 + /* Renegotiate with link partner */
21755 + if (autoneg_normal) {
21756 + data = crisv32_eth_get_mdio_reg(dev, MII_BMCR);
21757 + data |= BMCR_ANENABLE | BMCR_ANRESTART;
21758 + }
21759 + crisv32_eth_set_mdio_reg(dev, MII_BMCR, data);
21760 +}
21761 +static void
21762 +crisv32_eth_check_speed(unsigned long idev)
21763 +{
21764 + static int led_initiated = 0;
21765 + struct net_device *dev = (struct net_device *) idev;
21766 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21767 +
21768 + unsigned long data;
21769 + int old_speed;
21770 + unsigned long flags;
21771 +
21772 + BUG_ON(!np);
21773 + BUG_ON(!np->transceiver);
21774 +
21775 + spin_lock(&np->transceiver_lock);
21776 +
21777 + old_speed = np->current_speed;
21778 + data = crisv32_eth_get_mdio_reg(dev, MII_BMSR);
21779 +
21780 + if (!(data & BMSR_LSTATUS))
21781 + np->current_speed = 0;
21782 + else
21783 + np->transceiver->check_speed(dev);
21784 +
21785 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
21786 + if ((old_speed != np->current_speed)
21787 + && ((old_speed == 1000) || (np->current_speed == 1000))) {
21788 + /* Switch between mii and gmii */
21789 + reg_eth_rw_gen_ctrl gen_ctrl = REG_RD(eth, np->eth_inst,
21790 + rw_gen_ctrl);
21791 + reg_eth_rw_tr_ctrl tr_ctrl = REG_RD(eth, np->eth_inst,
21792 + rw_tr_ctrl);
21793 + if (old_speed == 1000) {
21794 + gen_ctrl.phy = regk_eth_mii;
21795 + gen_ctrl.gtxclk_out = regk_eth_no;
21796 + tr_ctrl.carrier_ext = regk_eth_no;
21797 + }
21798 + else {
21799 + gen_ctrl.phy = regk_eth_gmii;
21800 + gen_ctrl.gtxclk_out = regk_eth_yes;
21801 + tr_ctrl.carrier_ext = regk_eth_yes;
21802 + }
21803 + REG_WR(eth, np->eth_inst, rw_tr_ctrl, tr_ctrl);
21804 + REG_WR(eth, np->eth_inst, rw_gen_ctrl, gen_ctrl);
21805 +
21806 + crisv32_eth_switch_intmem_usage(dev);
21807 + }
21808 +#endif
21809 +
21810 + spin_lock_irqsave(&np->leds->led_lock, flags);
21811 + if ((old_speed != np->current_speed) || !led_initiated) {
21812 + led_initiated = 1;
21813 + np->leds->clear_led_timer.data = (unsigned long) dev;
21814 + if (np->current_speed) {
21815 + netif_carrier_on(dev);
21816 + crisv32_set_network_leds(LED_LINK, dev);
21817 + } else {
21818 + netif_carrier_off(dev);
21819 + crisv32_set_network_leds(LED_NOLINK, dev);
21820 + }
21821 + }
21822 + spin_unlock_irqrestore(&np->leds->led_lock, flags);
21823 +
21824 + /* Reinitialize the timer. */
21825 + np->speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
21826 + add_timer(&np->speed_timer);
21827 +
21828 + spin_unlock(&np->transceiver_lock);
21829 +}
21830 +
21831 +static void
21832 +crisv32_eth_set_speed(struct net_device *dev, unsigned long speed)
21833 +{
21834 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21835 +
21836 + spin_lock(&np->transceiver_lock);
21837 + if (np->current_speed_selection != speed) {
21838 + np->current_speed_selection = speed;
21839 + crisv32_eth_negotiate(dev);
21840 + }
21841 + spin_unlock(&np->transceiver_lock);
21842 +}
21843 +
21844 +static void
21845 +crisv32_eth_check_duplex(unsigned long idev)
21846 +{
21847 + struct net_device *dev = (struct net_device *) idev;
21848 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21849 + reg_eth_rw_rec_ctrl rec_ctrl;
21850 + int old_duplex = np->full_duplex;
21851 +
21852 + np->transceiver->check_duplex(dev);
21853 +
21854 + if (old_duplex != np->full_duplex) {
21855 + /* Duplex changed. */
21856 + rec_ctrl = (reg_eth_rw_rec_ctrl) REG_RD(eth, np->eth_inst,
21857 + rw_rec_ctrl);
21858 + rec_ctrl.duplex = np->full_duplex;
21859 + REG_WR(eth, np->eth_inst, rw_rec_ctrl, rec_ctrl);
21860 + }
21861 +
21862 + /* Reinitialize the timer. */
21863 + np->duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
21864 + add_timer(&np->duplex_timer);
21865 +}
21866 +
21867 +static void
21868 +crisv32_eth_set_duplex(struct net_device *dev, enum duplex new_duplex)
21869 +{
21870 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21871 + spin_lock(&np->transceiver_lock);
21872 + if (np->current_duplex != new_duplex) {
21873 + np->current_duplex = new_duplex;
21874 + crisv32_eth_negotiate(dev);
21875 + }
21876 + spin_unlock(&np->transceiver_lock);
21877 +}
21878 +
21879 +static int
21880 +crisv32_eth_probe_transceiver(struct net_device *dev)
21881 +{
21882 + unsigned int phyid_high;
21883 + unsigned int phyid_low;
21884 + unsigned int oui;
21885 + struct transceiver_ops *ops = NULL;
21886 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21887 +
21888 + /* Probe MDIO physical address. */
21889 + for (np->mdio_phy_addr = 0;
21890 + np->mdio_phy_addr <= 31; np->mdio_phy_addr++) {
21891 + if (crisv32_eth_get_mdio_reg(dev, MII_BMSR) != 0xffff)
21892 + break;
21893 + }
21894 +
21895 + if (np->mdio_phy_addr == 32)
21896 + return -ENODEV;
21897 +
21898 + /* Get manufacturer. */
21899 + phyid_high = crisv32_eth_get_mdio_reg(dev, MII_PHYSID1);
21900 + phyid_low = crisv32_eth_get_mdio_reg(dev, MII_PHYSID2);
21901 +
21902 + oui = (phyid_high << 6) | (phyid_low >> 10);
21903 +
21904 + for (ops = &transceivers[0]; ops->oui; ops++) {
21905 + if (ops->oui == oui)
21906 + break;
21907 + }
21908 +
21909 + np->transceiver = ops;
21910 + return 0;
21911 +}
21912 +
21913 +static void
21914 +generic_check_speed(struct net_device *dev)
21915 +{
21916 + unsigned long data;
21917 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21918 +
21919 + data = crisv32_eth_get_mdio_reg(dev, MII_ADVERTISE);
21920 + if ((data & ADVERTISE_100FULL) ||
21921 + (data & ADVERTISE_100HALF))
21922 + np->current_speed = 100;
21923 + else
21924 + np->current_speed = 10;
21925 +}
21926 +
21927 +static void
21928 +generic_check_duplex(struct net_device *dev)
21929 +{
21930 + unsigned long data;
21931 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21932 +
21933 + data = crisv32_eth_get_mdio_reg(dev, MII_ADVERTISE);
21934 + if ((data & ADVERTISE_10FULL) ||
21935 + (data & ADVERTISE_100FULL))
21936 + np->full_duplex = 1;
21937 + else
21938 + np->full_duplex = 0;
21939 +}
21940 +
21941 +static void
21942 +broadcom_check_speed(struct net_device *dev)
21943 +{
21944 + unsigned long data;
21945 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21946 +
21947 + data = crisv32_eth_get_mdio_reg(dev, MDIO_AUX_CTRL_STATUS_REG);
21948 + np->current_speed = (data & MDIO_BC_SPEED ? 100 : 10);
21949 +}
21950 +
21951 +static void
21952 +broadcom_check_duplex(struct net_device *dev)
21953 +{
21954 + unsigned long data;
21955 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21956 +
21957 + data = crisv32_eth_get_mdio_reg(dev, MDIO_AUX_CTRL_STATUS_REG);
21958 + np->full_duplex = (data & MDIO_BC_FULL_DUPLEX_IND) ? 1 : 0;
21959 +}
21960 +
21961 +static void
21962 +tdk_check_speed(struct net_device *dev)
21963 +{
21964 + unsigned long data;
21965 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21966 +
21967 + data = crisv32_eth_get_mdio_reg(dev, MDIO_TDK_DIAGNOSTIC_REG);
21968 + np->current_speed = (data & MDIO_TDK_DIAGNOSTIC_RATE ? 100 : 10);
21969 +}
21970 +
21971 +static void
21972 +tdk_check_duplex(struct net_device *dev)
21973 +{
21974 + unsigned long data;
21975 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21976 +
21977 + data = crisv32_eth_get_mdio_reg(dev, MDIO_TDK_DIAGNOSTIC_REG);
21978 + np->full_duplex = (data & MDIO_TDK_DIAGNOSTIC_DPLX) ? 1 : 0;
21979 +
21980 +}
21981 +
21982 +static void
21983 +intel_check_speed(struct net_device *dev)
21984 +{
21985 + unsigned long data;
21986 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21987 + data = crisv32_eth_get_mdio_reg(dev, MDIO_INT_STATUS_REG_2);
21988 + np->current_speed = (data & MDIO_INT_SPEED ? 100 : 10);
21989 +}
21990 +
21991 +static void
21992 +intel_check_duplex(struct net_device *dev)
21993 +{
21994 + unsigned long data;
21995 + struct crisv32_ethernet_local *np = netdev_priv(dev);
21996 +
21997 + data = crisv32_eth_get_mdio_reg(dev, MDIO_INT_STATUS_REG_2);
21998 + np->full_duplex = (data & MDIO_INT_FULL_DUPLEX_IND) ? 1 : 0;
21999 +}
22000 +
22001 +static void
22002 +national_check_speed(struct net_device *dev)
22003 +{
22004 + unsigned long data;
22005 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22006 +
22007 + data = crisv32_eth_get_mdio_reg(dev, MDIO_NAT_LINK_AN_REG);
22008 + if (data & MDIO_NAT_1000)
22009 + np->current_speed = 1000;
22010 + else if (data & MDIO_NAT_100)
22011 + np->current_speed = 100;
22012 + else
22013 + np->current_speed = 10;
22014 +}
22015 +
22016 +static void
22017 +national_check_duplex(struct net_device *dev)
22018 +{
22019 + unsigned long data;
22020 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22021 +
22022 + data = crisv32_eth_get_mdio_reg(dev, MDIO_NAT_LINK_AN_REG);
22023 + if (data & MDIO_NAT_FULL_DUPLEX_IND)
22024 + np->full_duplex = 1;
22025 + else
22026 + np->full_duplex = 0;
22027 +}
22028 +
22029 +static void
22030 +crisv32_eth_reset_tranceiver(struct net_device *dev)
22031 +{
22032 + int i;
22033 + unsigned short cmd;
22034 + unsigned short data;
22035 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22036 +
22037 + data = crisv32_eth_get_mdio_reg(dev, MII_BMCR);
22038 +
22039 + cmd = (MDIO_START << 14)
22040 + | (MDIO_WRITE << 12)
22041 + | (np->mdio_phy_addr << 7)
22042 + | (MII_BMCR << 2);
22043 +
22044 + crisv32_eth_send_mdio_cmd(dev, cmd, 1);
22045 +
22046 + data |= 0x8000;
22047 +
22048 + /* Magic value is number of bits. */
22049 + for (i = 15; i >= 0; i--)
22050 + crisv32_eth_send_mdio_bit(dev, GET_BIT(i, data));
22051 +}
22052 +
22053 +static unsigned short
22054 +crisv32_eth_get_mdio_reg(struct net_device *dev, unsigned char reg_num)
22055 +{
22056 + int i;
22057 + unsigned short cmd; /* Data to be sent on MDIO port. */
22058 + unsigned short data; /* Data read from MDIO. */
22059 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22060 +
22061 + /* Start of frame, OP Code, Physical Address, Register Address. */
22062 + cmd = (MDIO_START << 14)
22063 + | (MDIO_READ << 12)
22064 + | (np->mdio_phy_addr << 7)
22065 + | (reg_num << 2);
22066 +
22067 + crisv32_eth_send_mdio_cmd(dev, cmd, 0);
22068 +
22069 + data = 0;
22070 +
22071 + /* Receive data. Magic value is number of bits. */
22072 + for (i = 15; i >= 0; i--)
22073 + data |= (crisv32_eth_receive_mdio_bit(dev) << i);
22074 +
22075 + return data;
22076 +}
22077 +
22078 +static void
22079 +crisv32_eth_set_mdio_reg(struct net_device *dev, unsigned char reg, int value)
22080 +{
22081 + int bitCounter;
22082 + unsigned short cmd;
22083 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22084 +
22085 + cmd = (MDIO_START << 14)
22086 + | (MDIO_WRITE << 12)
22087 + | (np->mdio_phy_addr << 7)
22088 + | (reg << 2);
22089 +
22090 + crisv32_eth_send_mdio_cmd(dev, cmd, 1);
22091 +
22092 + /* Data... */
22093 + for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
22094 + crisv32_eth_send_mdio_bit(dev, GET_BIT(bitCounter, value));
22095 + }
22096 +}
22097 +
22098 +static void
22099 +crisv32_eth_send_mdio_cmd(struct net_device *dev, unsigned short cmd,
22100 + int write_cmd)
22101 +{
22102 + int i;
22103 + unsigned char data = 0x2;
22104 +
22105 + /* Preamble. Magic value is number of bits. */
22106 + for (i = 31; i >= 0; i--)
22107 + crisv32_eth_send_mdio_bit(dev, GET_BIT(i, MDIO_PREAMBLE));
22108 +
22109 + for (i = 15; i >= 2; i--)
22110 + crisv32_eth_send_mdio_bit(dev, GET_BIT(i, cmd));
22111 +
22112 + /* Turnaround. */
22113 + for (i = 1; i >= 0; i--)
22114 + if (write_cmd)
22115 + crisv32_eth_send_mdio_bit(dev, GET_BIT(i, data));
22116 + else
22117 + crisv32_eth_receive_mdio_bit(dev);
22118 +}
22119 +
22120 +static void
22121 +crisv32_eth_send_mdio_bit(struct net_device *dev, unsigned char bit)
22122 +{
22123 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22124 +
22125 + reg_eth_rw_mgm_ctrl mgm_ctrl = {
22126 + .mdoe = regk_eth_yes,
22127 + .mdio = bit & 1
22128 + };
22129 +
22130 + REG_WR(eth, np->eth_inst, rw_mgm_ctrl, mgm_ctrl);
22131 +
22132 + udelay(1);
22133 +
22134 + mgm_ctrl.mdc = 1;
22135 + REG_WR(eth, np->eth_inst, rw_mgm_ctrl, mgm_ctrl);
22136 +
22137 + udelay(1);
22138 +}
22139 +
22140 +static unsigned char
22141 +crisv32_eth_receive_mdio_bit(struct net_device *dev)
22142 +{
22143 + reg_eth_r_stat stat;
22144 + reg_eth_rw_mgm_ctrl mgm_ctrl = {0};
22145 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22146 +
22147 + REG_WR(eth, np->eth_inst, rw_mgm_ctrl, mgm_ctrl);
22148 + stat = REG_RD(eth, np->eth_inst, r_stat);
22149 +
22150 + udelay(1);
22151 +
22152 + mgm_ctrl.mdc = 1;
22153 + REG_WR(eth, np->eth_inst, rw_mgm_ctrl, mgm_ctrl);
22154 +
22155 + udelay(1);
22156 + return stat.mdio;
22157 +}
22158 +
22159 +static void
22160 +crisv32_clear_network_leds(unsigned long priv)
22161 +{
22162 + struct net_device *dev = (struct net_device*)priv;
22163 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22164 + unsigned long flags;
22165 +
22166 + spin_lock_irqsave(&np->leds->led_lock, flags);
22167 + if (np->leds->led_active && time_after(jiffies, np->leds->led_next_time)) {
22168 + crisv32_set_network_leds(LED_NOACTIVITY, dev);
22169 +
22170 + /* Set the earliest time we may set the LED */
22171 + np->leds->led_next_time = jiffies + NET_FLASH_PAUSE;
22172 + np->leds->led_active = 0;
22173 + }
22174 + spin_unlock_irqrestore(&np->leds->led_lock, flags);
22175 +}
22176 +
22177 +static void
22178 +crisv32_set_network_leds(int active, struct net_device *dev)
22179 +{
22180 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22181 + int light_leds = 0;
22182 +
22183 + if (np->leds->ledgrp == LED_GRP_NONE)
22184 + return;
22185 +
22186 + if (active == LED_NOLINK) {
22187 + if (dev == crisv32_dev[0])
22188 + np->leds->ifisup[0] = 0;
22189 + else
22190 + np->leds->ifisup[1] = 0;
22191 + }
22192 + else if (active == LED_LINK) {
22193 + if (dev == crisv32_dev[0])
22194 + np->leds->ifisup[0] = 1;
22195 + else
22196 + np->leds->ifisup[1] = 1;
22197 +#if defined(CONFIG_ETRAX_NETWORK_LED_ON_WHEN_LINK)
22198 + light_leds = 1;
22199 + } else {
22200 + light_leds = (active == LED_NOACTIVITY);
22201 +#elif defined(CONFIG_ETRAX_NETWORK_LED_ON_WHEN_ACTIVITY)
22202 + light_leds = 0;
22203 + } else {
22204 + light_leds = (active == LED_ACTIVITY);
22205 +#else
22206 +#error "Define either CONFIG_ETRAX_NETWORK_LED_ON_WHEN_LINK or CONFIG_ETRAX_NETWORK_LED_ON_WHEN_ACTIVITY"
22207 +#endif
22208 + }
22209 +
22210 + if (!use_network_leds) {
22211 + NET_LED_SET(np->leds->ledgrp,LED_OFF);
22212 + return;
22213 + }
22214 +
22215 + if (!np->current_speed) {
22216 + /* Set link down if none of the interfaces that use this led group is up */
22217 + if ((np->leds->ifisup[0] + np->leds->ifisup[1]) == 0) {
22218 +#if defined(CONFIG_ETRAX_NETWORK_RED_ON_NO_CONNECTION)
22219 + /* Make LED red, link is down */
22220 + NET_LED_SET(np->leds->ledgrp,LED_RED);
22221 +#else
22222 + NET_LED_SET(np->leds->ledgrp,LED_OFF);
22223 +#endif
22224 + }
22225 + }
22226 + else if (light_leds) {
22227 + if (np->current_speed == 10) {
22228 + NET_LED_SET(np->leds->ledgrp,LED_ORANGE);
22229 + } else {
22230 + NET_LED_SET(np->leds->ledgrp,LED_GREEN);
22231 + }
22232 + }
22233 + else {
22234 + NET_LED_SET(np->leds->ledgrp,LED_OFF);
22235 + }
22236 +}
22237 +
22238 +#ifdef CONFIG_NET_POLL_CONTROLLER
22239 +static void
22240 +crisv32_netpoll(struct net_device* netdev)
22241 +{
22242 + crisv32rx_eth_interrupt(DMA0_INTR_VECT, netdev, NULL);
22243 +}
22244 +#endif
22245 +
22246 +#ifdef CONFIG_CPU_FREQ
22247 +static int
22248 +crisv32_ethernet_freq_notifier(struct notifier_block *nb,
22249 + unsigned long val, void *data)
22250 +{
22251 + struct cpufreq_freqs *freqs = data;
22252 + if (val == CPUFREQ_POSTCHANGE) {
22253 + int i;
22254 + for (i = 0; i < 2; i++) {
22255 + struct net_device* dev = crisv32_dev[i];
22256 + unsigned short data;
22257 + if (dev == NULL)
22258 + continue;
22259 +
22260 + data = crisv32_eth_get_mdio_reg(dev, MII_BMCR);
22261 + if (freqs->new == 200000)
22262 + data &= ~BMCR_PDOWN;
22263 + else
22264 + data |= BMCR_PDOWN;
22265 + crisv32_eth_set_mdio_reg(dev, MII_BMCR, data);
22266 + }
22267 + }
22268 + return 0;
22269 +}
22270 +#endif
22271 +
22272 +/*
22273 + * Must be called with the np->lock held.
22274 + */
22275 +static void crisv32_ethernet_bug(struct net_device *dev)
22276 +{
22277 + struct crisv32_ethernet_local *np = netdev_priv(dev);
22278 + dma_descr_data *dma_pos;
22279 + dma_descr_data *in_dma_pos;
22280 + reg_dma_rw_stat stat = {0};
22281 + reg_dma_rw_stat in_stat = {0};
22282 + int i;
22283 +
22284 + /* Get the current output dma position. */
22285 + stat = REG_RD(dma, np->dma_out_inst, rw_stat);
22286 + dma_pos = phys_to_virt(REG_RD_INT(dma, np->dma_out_inst, rw_data));
22287 + in_stat = REG_RD(dma, np->dma_in_inst, rw_stat);
22288 + in_dma_pos = phys_to_virt(REG_RD_INT(dma, np->dma_in_inst, rw_data));
22289 +
22290 + printk("%s:\n"
22291 + "stat.list_state=%x\n"
22292 + "stat.mode=%x\n"
22293 + "stat.stream_cmd_src=%x\n"
22294 + "dma_pos=%x\n"
22295 + "in_stat.list_state=%x\n"
22296 + "in_stat.mode=%x\n"
22297 + "in_stat.stream_cmd_src=%x\n"
22298 + "in_dma_pos=%x\n"
22299 + "catch=%x active=%x\n"
22300 + "packets=%d queue=%d\n"
22301 + "intr_vect.r_vect=%x\n"
22302 + "dma.r_masked_intr=%x dma.rw_ack_intr=%x "
22303 + "dma.r_intr=%x dma.rw_intr_masked=%x\n"
22304 + "eth.r_stat=%x\n",
22305 + __func__,
22306 + stat.list_state, stat.mode, stat.stream_cmd_src,
22307 + (unsigned int)dma_pos,
22308 + in_stat.list_state, in_stat.mode, in_stat.stream_cmd_src,
22309 + (unsigned int)in_dma_pos,
22310 + (unsigned int)&np->catch_tx_desc->descr,
22311 + (unsigned int)&np->active_tx_desc->descr,
22312 + np->txpackets,
22313 + netif_queue_stopped(dev),
22314 + REG_RD_INT(intr_vect, regi_irq, r_vect),
22315 + REG_RD_INT(dma, np->dma_out_inst, r_masked_intr),
22316 + REG_RD_INT(dma, np->dma_out_inst, rw_ack_intr),
22317 + REG_RD_INT(dma, np->dma_out_inst, r_intr),
22318 + REG_RD_INT(dma, np->dma_out_inst, rw_intr_mask),
22319 + REG_RD_INT(eth, np->eth_inst, r_stat));
22320 +
22321 + printk("tx-descriptors:\n");
22322 + for (i = 0; i < NBR_TX_DESC; i++) {
22323 + printk("txdesc[%d]=0x%x\n", i, (unsigned int)
22324 + virt_to_phys(&np->dma_tx_descr_list[i].descr));
22325 + printk("txdesc[%d].skb=0x%x\n", i,
22326 + (unsigned int)np->dma_tx_descr_list[i].skb);
22327 + printk("txdesc[%d].buf=0x%x\n", i,
22328 + (unsigned int)np->dma_tx_descr_list[i].descr.buf);
22329 + printk("txdesc[%d].after=0x%x\n", i,
22330 + (unsigned int)np->dma_tx_descr_list[i].descr.after);
22331 + printk("txdesc[%d].intr=%x\n", i,
22332 + np->dma_tx_descr_list[i].descr.intr);
22333 + printk("txdesc[%d].eol=%x\n", i,
22334 + np->dma_tx_descr_list[i].descr.eol);
22335 + printk("txdesc[%d].out_eop=%x\n", i,
22336 + np->dma_tx_descr_list[i].descr.out_eop);
22337 + printk("txdesc[%d].wait=%x\n", i,
22338 + np->dma_tx_descr_list[i].descr.wait);
22339 + }
22340 +}
22341 +
22342 +
22343 +static int
22344 +crisv32_init_module(void)
22345 +{
22346 + return crisv32_ethernet_init();
22347 +}
22348 +
22349 +module_init(crisv32_init_module);
22350 diff -urN linux-2.6.19.2.orig/drivers/net/cris/eth_v32.h linux-2.6.19.2.dev/drivers/net/cris/eth_v32.h
22351 --- linux-2.6.19.2.orig/drivers/net/cris/eth_v32.h 1970-01-01 01:00:00.000000000 +0100
22352 +++ linux-2.6.19.2.dev/drivers/net/cris/eth_v32.h 2007-02-06 11:10:37.000000000 +0100
22353 @@ -0,0 +1,248 @@
22354 +/*
22355 + * Definitions for ETRAX FS ethernet driver.
22356 + *
22357 + * Copyright (C) 2003, 2004, 2005 Axis Communications.
22358 + */
22359 +
22360 +#ifndef _ETRAX_ETHERNET_H_
22361 +#define _ETRAX_ETHERNET_H_
22362 +
22363 +#include <asm/arch/hwregs/dma.h>
22364 +
22365 +
22366 +#define MAX_MEDIA_DATA_SIZE 1522 /* Max packet size. */
22367 +
22368 +#define NBR_RX_DESC 64 /* Number of RX descriptors. */
22369 +#define NBR_TX_DESC 16 /* Number of TX descriptors. */
22370 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
22371 +#define NBR_INTMEM_RX_DESC 5 /* Number of RX descriptors in int. mem.
22372 + * when running in gigabit mode.
22373 + * Should be less then NBR_RX_DESC
22374 + */
22375 +#define NBR_INTMEM_TX_BUF 4 /* Number of TX buffers in int. mem
22376 + * when running in gigabit mode.
22377 + * Should be less than NBR_TX_DESC
22378 + */
22379 +#endif
22380 +
22381 +/* Large packets are sent directly to upper layers while small packets
22382 + * are copied (to reduce memory waste). The following constant
22383 + * decides the breakpoint.
22384 + */
22385 +#define RX_COPYBREAK (256)
22386 +
22387 +#define ETHER_HEAD_LEN (14)
22388 +
22389 +/*
22390 +** MDIO constants.
22391 +*/
22392 +#define MDIO_START 0x1
22393 +#define MDIO_READ 0x2
22394 +#define MDIO_WRITE 0x1
22395 +#define MDIO_PREAMBLE 0xfffffffful
22396 +
22397 +/* Broadcom specific */
22398 +#define MDIO_AUX_CTRL_STATUS_REG 0x18
22399 +#define MDIO_BC_FULL_DUPLEX_IND 0x1
22400 +#define MDIO_BC_SPEED 0x2
22401 +
22402 +/* TDK specific */
22403 +#define MDIO_TDK_DIAGNOSTIC_REG 18
22404 +#define MDIO_TDK_DIAGNOSTIC_RATE 0x400
22405 +#define MDIO_TDK_DIAGNOSTIC_DPLX 0x800
22406 +
22407 +/*Intel LXT972A specific*/
22408 +#define MDIO_INT_STATUS_REG_2 0x0011
22409 +#define MDIO_INT_FULL_DUPLEX_IND ( 0x0001 << 9 )
22410 +#define MDIO_INT_SPEED ( 0x0001 << 14 )
22411 +
22412 +/*National Semiconductor DP83865 specific*/
22413 +#define MDIO_NAT_LINK_AN_REG 0x11
22414 +#define MDIO_NAT_1000 (0x0001 << 4)
22415 +#define MDIO_NAT_100 (0x0001 << 3)
22416 +#define MDIO_NAT_FULL_DUPLEX_IND (0x0001 << 1)
22417 +
22418 +/* Network flash constants */
22419 +#define NET_FLASH_TIME (HZ/50) /* 20 ms */
22420 +#define NET_FLASH_PAUSE (HZ/100) /* 10 ms */
22421 +#define NET_LINK_UP_CHECK_INTERVAL (2*HZ) /* 2 seconds. */
22422 +#define NET_DUPLEX_CHECK_INTERVAL (2*HZ) /* 2 seconds. */
22423 +
22424 +/* Duplex settings. */
22425 +enum duplex {
22426 + half,
22427 + full,
22428 + autoneg
22429 +};
22430 +
22431 +/* Some transceivers requires special handling. */
22432 +struct transceiver_ops {
22433 + unsigned int oui;
22434 + void (*check_speed) (struct net_device * dev);
22435 + void (*check_duplex) (struct net_device * dev);
22436 +};
22437 +
22438 +typedef struct crisv32_eth_descr {
22439 + dma_descr_data descr __attribute__ ((__aligned__(32)));
22440 + struct sk_buff *skb;
22441 + unsigned char *linearized_packet;
22442 +} crisv32_eth_descr;
22443 +
22444 +
22445 +
22446 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
22447 +struct tx_buffer_list {
22448 + struct tx_buffer_list *next;
22449 + unsigned char *buf;
22450 + char free;
22451 +};
22452 +#endif
22453 +
22454 +/* LED stuff */
22455 +#define LED_GRP_0 0
22456 +#define LED_GRP_1 1
22457 +#define LED_GRP_NONE 2
22458 +
22459 +#define LED_ACTIVITY 0
22460 +#define LED_NOACTIVITY 1
22461 +#define LED_LINK 2
22462 +#define LED_NOLINK 3
22463 +
22464 +struct crisv32_eth_leds {
22465 + unsigned int ledgrp;
22466 + int led_active;
22467 + unsigned long led_next_time;
22468 + struct timer_list clear_led_timer;
22469 + spinlock_t led_lock; /* Protect LED state */
22470 + int ifisup[2];
22471 +};
22472 +
22473 +#define NET_LED_SET(x,y) \
22474 + do { \
22475 + if (x == 0) LED_NETWORK_GRP0_SET(y); \
22476 + if (x == 1) LED_NETWORK_GRP1_SET(y); \
22477 + } while (0)
22478 +
22479 +/* Information that need to be kept for each device. */
22480 +struct crisv32_ethernet_local {
22481 + dma_descr_context ctxt_in __attribute__ ((__aligned__(32)));
22482 + dma_descr_context ctxt_out __attribute__ ((__aligned__(32)));
22483 +
22484 + crisv32_eth_descr *active_rx_desc;
22485 + crisv32_eth_descr *prev_rx_desc;
22486 + crisv32_eth_descr *last_rx_desc;
22487 +
22488 + crisv32_eth_descr *active_tx_desc;
22489 + crisv32_eth_descr *prev_tx_desc;
22490 + crisv32_eth_descr *catch_tx_desc;
22491 +
22492 + crisv32_eth_descr dma_rx_descr_list[NBR_RX_DESC];
22493 + crisv32_eth_descr dma_tx_descr_list[NBR_TX_DESC];
22494 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
22495 + struct tx_buffer_list tx_intmem_buf_list[NBR_INTMEM_TX_BUF];
22496 + struct tx_buffer_list *intmem_tx_buf_active;
22497 + struct tx_buffer_list *intmem_tx_buf_catch;
22498 + char gigabit_mode;
22499 +#endif
22500 + char new_rx_package;
22501 +
22502 + /* DMA and ethernet registers for the device. */
22503 + int eth_inst;
22504 + int dma_in_inst;
22505 + int dma_out_inst;
22506 +
22507 + /* Network speed indication. */
22508 + struct timer_list speed_timer;
22509 + int current_speed; /* Speed read from tranceiver */
22510 + int current_speed_selection; /* Speed selected by user */
22511 + int sender_started;
22512 + int txpackets;
22513 +
22514 + struct crisv32_eth_leds *leds;
22515 +
22516 + /* Duplex. */
22517 + struct timer_list duplex_timer;
22518 + int full_duplex;
22519 + enum duplex current_duplex;
22520 +
22521 + struct net_device_stats stats;
22522 +
22523 + /* Transciever address. */
22524 + unsigned int mdio_phy_addr;
22525 +
22526 + struct transceiver_ops *transceiver;
22527 +
22528 + /*
22529 + * TX control lock. This protects the transmit buffer ring state along
22530 + * with the "tx full" state of the driver. This means all netif_queue
22531 + * flow control actions are protected by this lock as well.
22532 + */
22533 + spinlock_t lock;
22534 + spinlock_t transceiver_lock; /* Protect transceiver state. */
22535 +};
22536 +
22537 +/* Function prototypes. */
22538 +static int crisv32_ethernet_init(void);
22539 +static int crisv32_ethernet_device_init(struct net_device* dev);
22540 +static int crisv32_eth_open(struct net_device *dev);
22541 +static int crisv32_eth_close(struct net_device *dev);
22542 +static int crisv32_eth_set_mac_address(struct net_device *dev, void *vpntr);
22543 +static irqreturn_t crisv32rx_eth_interrupt(int irq, void *dev_id);
22544 +static irqreturn_t crisv32tx_eth_interrupt(int irq, void *dev_id);
22545 +static irqreturn_t crisv32nw_eth_interrupt(int irq, void *dev_id);
22546 +static void crisv32_eth_receive_packet(struct net_device *dev);
22547 +static int crisv32_eth_send_packet(struct sk_buff *skb, struct net_device *dev);
22548 +static void crisv32_eth_hw_send_packet(unsigned char *buf, int length,
22549 + void *priv);
22550 +static void crisv32_eth_tx_timeout(struct net_device *dev);
22551 +static void crisv32_eth_set_multicast_list(struct net_device *dev);
22552 +static int crisv32_eth_ioctl(struct net_device *dev, struct ifreq *ifr,
22553 + int cmd);
22554 +static int crisv32_eth_set_config(struct net_device* dev, struct ifmap* map);
22555 +#ifdef CONFIG_CRIS_MACH_ARTPEC3
22556 +static void crisv32_eth_switch_intmem_usage(struct net_device *dev);
22557 +#endif
22558 +static void crisv32_eth_negotiate(struct net_device *dev);
22559 +static void crisv32_eth_check_speed(unsigned long idev);
22560 +static void crisv32_eth_set_speed(struct net_device *dev, unsigned long speed);
22561 +static void crisv32_eth_check_duplex(unsigned long idev);
22562 +static void crisv32_eth_set_duplex(struct net_device *dev, enum duplex);
22563 +static int crisv32_eth_probe_transceiver(struct net_device *dev);
22564 +
22565 +static struct ethtool_ops crisv32_ethtool_ops;
22566 +
22567 +static void generic_check_speed(struct net_device *dev);
22568 +static void generic_check_duplex(struct net_device *dev);
22569 +static void broadcom_check_speed(struct net_device *dev);
22570 +static void broadcom_check_duplex(struct net_device *dev);
22571 +static void tdk_check_speed(struct net_device *dev);
22572 +static void tdk_check_duplex(struct net_device *dev);
22573 +static void intel_check_speed(struct net_device* dev);
22574 +static void intel_check_duplex(struct net_device *dev);
22575 +static void national_check_speed(struct net_device* dev);
22576 +static void national_check_duplex(struct net_device *dev);
22577 +
22578 +#ifdef CONFIG_NET_POLL_CONTROLLER
22579 +static void crisv32_netpoll(struct net_device* dev);
22580 +#endif
22581 +
22582 +static void crisv32_clear_network_leds(unsigned long dummy);
22583 +static void crisv32_set_network_leds(int active, struct net_device* dev);
22584 +
22585 +static void crisv32_eth_reset_tranceiver(struct net_device *dev);
22586 +static unsigned short crisv32_eth_get_mdio_reg(struct net_device *dev,
22587 + unsigned char reg_num);
22588 +static void crisv32_eth_set_mdio_reg(struct net_device *dev,
22589 + unsigned char reg_num,
22590 + int val);
22591 +static void crisv32_eth_send_mdio_cmd(struct net_device *dev,
22592 + unsigned short cmd, int write_cmd);
22593 +static void crisv32_eth_send_mdio_bit(struct net_device *dev,
22594 + unsigned char bit);
22595 +static unsigned char crisv32_eth_receive_mdio_bit(struct net_device *dev);
22596 +
22597 +static struct net_device_stats *crisv32_get_stats(struct net_device *dev);
22598 +static void crisv32_start_dma_out(struct crisv32_ethernet_local* np);
22599 +
22600 +
22601 +#endif /* _ETRAX_ETHERNET_H_ */
Personal OpenWRT clone
This page took 1.097052 seconds and 5 git commands to generate.