?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux v2.6.13
[linux-2.6/next.git] / drivers / atm / nicstar.c
blobb2a7b754fd1403a4c7dbd4ffe5ab47cd3de70b5e
1 /******************************************************************************
2 *
3 * nicstar.c
4 *
5 * Device driver supporting CBR for IDT 77201/77211 "NICStAR" based cards.
6 *
7 * IMPORTANT: The included file nicstarmac.c was NOT WRITTEN BY ME.
8 * It was taken from the frle-0.22 device driver.
9 * As the file doesn't have a copyright notice, in the file
10 * nicstarmac.copyright I put the copyright notice from the
11 * frle-0.22 device driver.
12 * Some code is based on the nicstar driver by M. Welsh.
13 *
14 * Author: Rui Prior (rprior@inescn.pt)
15 * PowerPC support by Jay Talbott (jay_talbott@mcg.mot.com) April 1999
16 *
17 *
18 * (C) INESC 1999
19 *
20 *
21 ******************************************************************************/
22
23
24 /**** IMPORTANT INFORMATION ***************************************************
25 *
26 * There are currently three types of spinlocks:
27 *
28 * 1 - Per card interrupt spinlock (to protect structures and such)
29 * 2 - Per SCQ scq spinlock
30 * 3 - Per card resource spinlock (to access registers, etc.)
31 *
32 * These must NEVER be grabbed in reverse order.
33 *
34 ******************************************************************************/
35
36 /* Header files ***************************************************************/
37
38 #include <linux/module.h>
39 #include <linux/config.h>
40 #include <linux/kernel.h>
41 #include <linux/skbuff.h>
42 #include <linux/atmdev.h>
43 #include <linux/atm.h>
44 #include <linux/pci.h>
45 #include <linux/types.h>
46 #include <linux/string.h>
47 #include <linux/delay.h>
48 #include <linux/init.h>
49 #include <linux/sched.h>
50 #include <linux/timer.h>
51 #include <linux/interrupt.h>
52 #include <linux/bitops.h>
53 #include <asm/io.h>
54 #include <asm/uaccess.h>
55 #include <asm/atomic.h>
56 #include "nicstar.h"
57 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
58 #include "suni.h"
59 #endif /* CONFIG_ATM_NICSTAR_USE_SUNI */
60 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
61 #include "idt77105.h"
62 #endif /* CONFIG_ATM_NICSTAR_USE_IDT77105 */
63
64 #if BITS_PER_LONG != 32
65 # error FIXME: this driver requires a 32-bit platform
66 #endif
67
68 /* Additional code ************************************************************/
69
70 #include "nicstarmac.c"
71
72
73 /* Configurable parameters ****************************************************/
74
75 #undef PHY_LOOPBACK
76 #undef TX_DEBUG
77 #undef RX_DEBUG
78 #undef GENERAL_DEBUG
79 #undef EXTRA_DEBUG
80
81 #undef NS_USE_DESTRUCTORS /* For now keep this undefined unless you know
82 you're going to use only raw ATM */
83
84
85 /* Do not touch these *********************************************************/
86
87 #ifdef TX_DEBUG
88 #define TXPRINTK(args...) printk(args)
89 #else
90 #define TXPRINTK(args...)
91 #endif /* TX_DEBUG */
92
93 #ifdef RX_DEBUG
94 #define RXPRINTK(args...) printk(args)
95 #else
96 #define RXPRINTK(args...)
97 #endif /* RX_DEBUG */
98
99 #ifdef GENERAL_DEBUG
100 #define PRINTK(args...) printk(args)
101 #else
102 #define PRINTK(args...)
103 #endif /* GENERAL_DEBUG */
104
105 #ifdef EXTRA_DEBUG
106 #define XPRINTK(args...) printk(args)
107 #else
108 #define XPRINTK(args...)
109 #endif /* EXTRA_DEBUG */
110
111
112 /* Macros *********************************************************************/
113
114 #define CMD_BUSY(card) (readl((card)->membase + STAT) & NS_STAT_CMDBZ)
115
116 #define NS_DELAY mdelay(1)
117
118 #define ALIGN_BUS_ADDR(addr, alignment) \
119 ((((u32) (addr)) + (((u32) (alignment)) - 1)) & ~(((u32) (alignment)) - 1))
120 #define ALIGN_ADDRESS(addr, alignment) \
121 bus_to_virt(ALIGN_BUS_ADDR(virt_to_bus(addr), alignment))
122
123 #undef CEIL
124
125 #ifndef ATM_SKB
126 #define ATM_SKB(s) (&(s)->atm)
127 #endif
128
129 /* Spinlock debugging stuff */
130 #ifdef NS_DEBUG_SPINLOCKS /* See nicstar.h */
131 #define ns_grab_int_lock(card,flags) \
132 do { \
133 unsigned long nsdsf, nsdsf2; \
134 local_irq_save(flags); \
135 save_flags(nsdsf); cli();\
136 if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
137 (flags)&(1<<9)?"en":"dis"); \
138 if (spin_is_locked(&(card)->int_lock) && \
139 (card)->cpu_int == smp_processor_id()) { \
140 printk("nicstar.c: line %d (cpu %d) int_lock already locked at line %d (cpu %d)\n", \
141 __LINE__, smp_processor_id(), (card)->has_int_lock, \
142 (card)->cpu_int); \
143 printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
144 } \
145 if (spin_is_locked(&(card)->res_lock) && \
146 (card)->cpu_res == smp_processor_id()) { \
147 printk("nicstar.c: line %d (cpu %d) res_lock locked at line %d (cpu %d)(trying int)\n", \
148 __LINE__, smp_processor_id(), (card)->has_res_lock, \
149 (card)->cpu_res); \
150 printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
151 } \
152 spin_lock_irq(&(card)->int_lock); \
153 (card)->has_int_lock = __LINE__; \
154 (card)->cpu_int = smp_processor_id(); \
155 restore_flags(nsdsf); } while (0)
156 #define ns_grab_res_lock(card,flags) \
157 do { \
158 unsigned long nsdsf, nsdsf2; \
159 local_irq_save(flags); \
160 save_flags(nsdsf); cli();\
161 if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
162 (flags)&(1<<9)?"en":"dis"); \
163 if (spin_is_locked(&(card)->res_lock) && \
164 (card)->cpu_res == smp_processor_id()) { \
165 printk("nicstar.c: line %d (cpu %d) res_lock already locked at line %d (cpu %d)\n", \
166 __LINE__, smp_processor_id(), (card)->has_res_lock, \
167 (card)->cpu_res); \
168 printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
169 } \
170 spin_lock_irq(&(card)->res_lock); \
171 (card)->has_res_lock = __LINE__; \
172 (card)->cpu_res = smp_processor_id(); \
173 restore_flags(nsdsf); } while (0)
174 #define ns_grab_scq_lock(card,scq,flags) \
175 do { \
176 unsigned long nsdsf, nsdsf2; \
177 local_irq_save(flags); \
178 save_flags(nsdsf); cli();\
179 if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
180 (flags)&(1<<9)?"en":"dis"); \
181 if (spin_is_locked(&(scq)->lock) && \
182 (scq)->cpu_lock == smp_processor_id()) { \
183 printk("nicstar.c: line %d (cpu %d) this scq_lock already locked at line %d (cpu %d)\n", \
184 __LINE__, smp_processor_id(), (scq)->has_lock, \
185 (scq)->cpu_lock); \
186 printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
187 } \
188 if (spin_is_locked(&(card)->res_lock) && \
189 (card)->cpu_res == smp_processor_id()) { \
190 printk("nicstar.c: line %d (cpu %d) res_lock locked at line %d (cpu %d)(trying scq)\n", \
191 __LINE__, smp_processor_id(), (card)->has_res_lock, \
192 (card)->cpu_res); \
193 printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
194 } \
195 spin_lock_irq(&(scq)->lock); \
196 (scq)->has_lock = __LINE__; \
197 (scq)->cpu_lock = smp_processor_id(); \
198 restore_flags(nsdsf); } while (0)
199 #else /* !NS_DEBUG_SPINLOCKS */
200 #define ns_grab_int_lock(card,flags) \
201 spin_lock_irqsave(&(card)->int_lock,(flags))
202 #define ns_grab_res_lock(card,flags) \
203 spin_lock_irqsave(&(card)->res_lock,(flags))
204 #define ns_grab_scq_lock(card,scq,flags) \
205 spin_lock_irqsave(&(scq)->lock,flags)
206 #endif /* NS_DEBUG_SPINLOCKS */
207
208
209 /* Function declarations ******************************************************/
210
211 static u32 ns_read_sram(ns_dev *card, u32 sram_address);
212 static void ns_write_sram(ns_dev *card, u32 sram_address, u32 *value, int count);
213 static int __devinit ns_init_card(int i, struct pci_dev *pcidev);
214 static void __devinit ns_init_card_error(ns_dev *card, int error);
215 static scq_info *get_scq(int size, u32 scd);
216 static void free_scq(scq_info *scq, struct atm_vcc *vcc);
217 static void push_rxbufs(ns_dev *card, u32 type, u32 handle1, u32 addr1,
218 u32 handle2, u32 addr2);
219 static irqreturn_t ns_irq_handler(int irq, void *dev_id, struct pt_regs *regs);
220 static int ns_open(struct atm_vcc *vcc);
221 static void ns_close(struct atm_vcc *vcc);
222 static void fill_tst(ns_dev *card, int n, vc_map *vc);
223 static int ns_send(struct atm_vcc *vcc, struct sk_buff *skb);
224 static int push_scqe(ns_dev *card, vc_map *vc, scq_info *scq, ns_scqe *tbd,
225 struct sk_buff *skb);
226 static void process_tsq(ns_dev *card);
227 static void drain_scq(ns_dev *card, scq_info *scq, int pos);
228 static void process_rsq(ns_dev *card);
229 static void dequeue_rx(ns_dev *card, ns_rsqe *rsqe);
230 #ifdef NS_USE_DESTRUCTORS
231 static void ns_sb_destructor(struct sk_buff *sb);
232 static void ns_lb_destructor(struct sk_buff *lb);
233 static void ns_hb_destructor(struct sk_buff *hb);
234 #endif /* NS_USE_DESTRUCTORS */
235 static void recycle_rx_buf(ns_dev *card, struct sk_buff *skb);
236 static void recycle_iovec_rx_bufs(ns_dev *card, struct iovec *iov, int count);
237 static void recycle_iov_buf(ns_dev *card, struct sk_buff *iovb);
238 static void dequeue_sm_buf(ns_dev *card, struct sk_buff *sb);
239 static void dequeue_lg_buf(ns_dev *card, struct sk_buff *lb);
240 static int ns_proc_read(struct atm_dev *dev, loff_t *pos, char *page);
241 static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg);
242 static void which_list(ns_dev *card, struct sk_buff *skb);
243 static void ns_poll(unsigned long arg);
244 static int ns_parse_mac(char *mac, unsigned char *esi);
245 static short ns_h2i(char c);
246 static void ns_phy_put(struct atm_dev *dev, unsigned char value,
247 unsigned long addr);
248 static unsigned char ns_phy_get(struct atm_dev *dev, unsigned long addr);
249
250
251
252 /* Global variables ***********************************************************/
253
254 static struct ns_dev *cards[NS_MAX_CARDS];
255 static unsigned num_cards;
256 static struct atmdev_ops atm_ops =
257 {
258 .open = ns_open,
259 .close = ns_close,
260 .ioctl = ns_ioctl,
261 .send = ns_send,
262 .phy_put = ns_phy_put,
263 .phy_get = ns_phy_get,
264 .proc_read = ns_proc_read,
265 .owner = THIS_MODULE,
266 };
267 static struct timer_list ns_timer;
268 static char *mac[NS_MAX_CARDS];
269 module_param_array(mac, charp, NULL, 0);
270 MODULE_LICENSE("GPL");
271
272
273 /* Functions*******************************************************************/
274
275 static int __devinit nicstar_init_one(struct pci_dev *pcidev,
276 const struct pci_device_id *ent)
277 {
278 static int index = -1;
279 unsigned int error;
280
281 index++;
282 cards[index] = NULL;
283
284 error = ns_init_card(index, pcidev);
285 if (error) {
286 cards[index--] = NULL; /* don't increment index */
287 goto err_out;
288 }
289
290 return 0;
291 err_out:
292 return -ENODEV;
293 }
294
295
296
297 static void __devexit nicstar_remove_one(struct pci_dev *pcidev)
298 {
299 int i, j;
300 ns_dev *card = pci_get_drvdata(pcidev);
301 struct sk_buff *hb;
302 struct sk_buff *iovb;
303 struct sk_buff *lb;
304 struct sk_buff *sb;
305
306 i = card->index;
307
308 if (cards[i] == NULL)
309 return;
310
311 if (card->atmdev->phy && card->atmdev->phy->stop)
312 card->atmdev->phy->stop(card->atmdev);
313
314 /* Stop everything */
315 writel(0x00000000, card->membase + CFG);
316
317 /* De-register device */
318 atm_dev_deregister(card->atmdev);
319
320 /* Disable PCI device */
321 pci_disable_device(pcidev);
322
323 /* Free up resources */
324 j = 0;
325 PRINTK("nicstar%d: freeing %d huge buffers.\n", i, card->hbpool.count);
326 while ((hb = skb_dequeue(&card->hbpool.queue)) != NULL)
327 {
328 dev_kfree_skb_any(hb);
329 j++;
330 }
331 PRINTK("nicstar%d: %d huge buffers freed.\n", i, j);
332 j = 0;
333 PRINTK("nicstar%d: freeing %d iovec buffers.\n", i, card->iovpool.count);
334 while ((iovb = skb_dequeue(&card->iovpool.queue)) != NULL)
335 {
336 dev_kfree_skb_any(iovb);
337 j++;
338 }
339 PRINTK("nicstar%d: %d iovec buffers freed.\n", i, j);
340 while ((lb = skb_dequeue(&card->lbpool.queue)) != NULL)
341 dev_kfree_skb_any(lb);
342 while ((sb = skb_dequeue(&card->sbpool.queue)) != NULL)
343 dev_kfree_skb_any(sb);
344 free_scq(card->scq0, NULL);
345 for (j = 0; j < NS_FRSCD_NUM; j++)
346 {
347 if (card->scd2vc[j] != NULL)
348 free_scq(card->scd2vc[j]->scq, card->scd2vc[j]->tx_vcc);
349 }
350 kfree(card->rsq.org);
351 kfree(card->tsq.org);
352 free_irq(card->pcidev->irq, card);
353 iounmap(card->membase);
354 kfree(card);
355 }
356
357
358
359 static struct pci_device_id nicstar_pci_tbl[] __devinitdata =
360 {
361 {PCI_VENDOR_ID_IDT, PCI_DEVICE_ID_IDT_IDT77201,
362 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
363 {0,} /* terminate list */
364 };
365 MODULE_DEVICE_TABLE(pci, nicstar_pci_tbl);
366
367
368
369 static struct pci_driver nicstar_driver = {
370 .name = "nicstar",
371 .id_table = nicstar_pci_tbl,
372 .probe = nicstar_init_one,
373 .remove = __devexit_p(nicstar_remove_one),
374 };
375
376
377
378 static int __init nicstar_init(void)
379 {
380 unsigned error = 0; /* Initialized to remove compile warning */
381
382 XPRINTK("nicstar: nicstar_init() called.\n");
383
384 error = pci_register_driver(&nicstar_driver);
385
386 TXPRINTK("nicstar: TX debug enabled.\n");
387 RXPRINTK("nicstar: RX debug enabled.\n");
388 PRINTK("nicstar: General debug enabled.\n");
389 #ifdef PHY_LOOPBACK
390 printk("nicstar: using PHY loopback.\n");
391 #endif /* PHY_LOOPBACK */
392 XPRINTK("nicstar: nicstar_init() returned.\n");
393
394 if (!error) {
395 init_timer(&ns_timer);
396 ns_timer.expires = jiffies + NS_POLL_PERIOD;
397 ns_timer.data = 0UL;
398 ns_timer.function = ns_poll;
399 add_timer(&ns_timer);
400 }
401
402 return error;
403 }
404
405
406
407 static void __exit nicstar_cleanup(void)
408 {
409 XPRINTK("nicstar: nicstar_cleanup() called.\n");
410
411 del_timer(&ns_timer);
412
413 pci_unregister_driver(&nicstar_driver);
414
415 XPRINTK("nicstar: nicstar_cleanup() returned.\n");
416 }
417
418
419
420 static u32 ns_read_sram(ns_dev *card, u32 sram_address)
421 {
422 unsigned long flags;
423 u32 data;
424 sram_address <<= 2;
425 sram_address &= 0x0007FFFC; /* address must be dword aligned */
426 sram_address |= 0x50000000; /* SRAM read command */
427 ns_grab_res_lock(card, flags);
428 while (CMD_BUSY(card));
429 writel(sram_address, card->membase + CMD);
430 while (CMD_BUSY(card));
431 data = readl(card->membase + DR0);
432 spin_unlock_irqrestore(&card->res_lock, flags);
433 return data;
434 }
435
436
437
438 static void ns_write_sram(ns_dev *card, u32 sram_address, u32 *value, int count)
439 {
440 unsigned long flags;
441 int i, c;
442 count--; /* count range now is 0..3 instead of 1..4 */
443 c = count;
444 c <<= 2; /* to use increments of 4 */
445 ns_grab_res_lock(card, flags);
446 while (CMD_BUSY(card));
447 for (i = 0; i <= c; i += 4)
448 writel(*(value++), card->membase + i);
449 /* Note: DR# registers are the first 4 dwords in nicstar's memspace,
450 so card->membase + DR0 == card->membase */
451 sram_address <<= 2;
452 sram_address &= 0x0007FFFC;
453 sram_address |= (0x40000000 | count);
454 writel(sram_address, card->membase + CMD);
455 spin_unlock_irqrestore(&card->res_lock, flags);
456 }
457
458
459 static int __devinit ns_init_card(int i, struct pci_dev *pcidev)
460 {
461 int j;
462 struct ns_dev *card = NULL;
463 unsigned char pci_latency;
464 unsigned error;
465 u32 data;
466 u32 u32d[4];
467 u32 ns_cfg_rctsize;
468 int bcount;
469 unsigned long membase;
470
471 error = 0;
472
473 if (pci_enable_device(pcidev))
474 {
475 printk("nicstar%d: can't enable PCI device\n", i);
476 error = 2;
477 ns_init_card_error(card, error);
478 return error;
479 }
480
481 if ((card = kmalloc(sizeof(ns_dev), GFP_KERNEL)) == NULL)
482 {
483 printk("nicstar%d: can't allocate memory for device structure.\n", i);
484 error = 2;
485 ns_init_card_error(card, error);
486 return error;
487 }
488 cards[i] = card;
489 spin_lock_init(&card->int_lock);
490 spin_lock_init(&card->res_lock);
491
492 pci_set_drvdata(pcidev, card);
493
494 card->index = i;
495 card->atmdev = NULL;
496 card->pcidev = pcidev;
497 membase = pci_resource_start(pcidev, 1);
498 card->membase = ioremap(membase, NS_IOREMAP_SIZE);
499 if (card->membase == 0)
500 {
501 printk("nicstar%d: can't ioremap() membase.\n",i);
502 error = 3;
503 ns_init_card_error(card, error);
504 return error;
505 }
506 PRINTK("nicstar%d: membase at 0x%x.\n", i, card->membase);
507
508 pci_set_master(pcidev);
509
510 if (pci_read_config_byte(pcidev, PCI_LATENCY_TIMER, &pci_latency) != 0)
511 {
512 printk("nicstar%d: can't read PCI latency timer.\n", i);
513 error = 6;
514 ns_init_card_error(card, error);
515 return error;
516 }
517 #ifdef NS_PCI_LATENCY
518 if (pci_latency < NS_PCI_LATENCY)
519 {
520 PRINTK("nicstar%d: setting PCI latency timer to %d.\n", i, NS_PCI_LATENCY);
521 for (j = 1; j < 4; j++)
522 {
523 if (pci_write_config_byte(pcidev, PCI_LATENCY_TIMER, NS_PCI_LATENCY) != 0)
524 break;
525 }
526 if (j == 4)
527 {
528 printk("nicstar%d: can't set PCI latency timer to %d.\n", i, NS_PCI_LATENCY);
529 error = 7;
530 ns_init_card_error(card, error);
531 return error;
532 }
533 }
534 #endif /* NS_PCI_LATENCY */
535
536 /* Clear timer overflow */
537 data = readl(card->membase + STAT);
538 if (data & NS_STAT_TMROF)
539 writel(NS_STAT_TMROF, card->membase + STAT);
540
541 /* Software reset */
542 writel(NS_CFG_SWRST, card->membase + CFG);
543 NS_DELAY;
544 writel(0x00000000, card->membase + CFG);
545
546 /* PHY reset */
547 writel(0x00000008, card->membase + GP);
548 NS_DELAY;
549 writel(0x00000001, card->membase + GP);
550 NS_DELAY;
551 while (CMD_BUSY(card));
552 writel(NS_CMD_WRITE_UTILITY | 0x00000100, card->membase + CMD); /* Sync UTOPIA with SAR clock */
553 NS_DELAY;
554
555 /* Detect PHY type */
556 while (CMD_BUSY(card));
557 writel(NS_CMD_READ_UTILITY | 0x00000200, card->membase + CMD);
558 while (CMD_BUSY(card));
559 data = readl(card->membase + DR0);
560 switch(data) {
561 case 0x00000009:
562 printk("nicstar%d: PHY seems to be 25 Mbps.\n", i);
563 card->max_pcr = ATM_25_PCR;
564 while(CMD_BUSY(card));
565 writel(0x00000008, card->membase + DR0);
566 writel(NS_CMD_WRITE_UTILITY | 0x00000200, card->membase + CMD);
567 /* Clear an eventual pending interrupt */
568 writel(NS_STAT_SFBQF, card->membase + STAT);
569 #ifdef PHY_LOOPBACK
570 while(CMD_BUSY(card));
571 writel(0x00000022, card->membase + DR0);
572 writel(NS_CMD_WRITE_UTILITY | 0x00000202, card->membase + CMD);
573 #endif /* PHY_LOOPBACK */
574 break;
575 case 0x00000030:
576 case 0x00000031:
577 printk("nicstar%d: PHY seems to be 155 Mbps.\n", i);
578 card->max_pcr = ATM_OC3_PCR;
579 #ifdef PHY_LOOPBACK
580 while(CMD_BUSY(card));
581 writel(0x00000002, card->membase + DR0);
582 writel(NS_CMD_WRITE_UTILITY | 0x00000205, card->membase + CMD);
583 #endif /* PHY_LOOPBACK */
584 break;
585 default:
586 printk("nicstar%d: unknown PHY type (0x%08X).\n", i, data);
587 error = 8;
588 ns_init_card_error(card, error);
589 return error;
590 }
591 writel(0x00000000, card->membase + GP);
592
593 /* Determine SRAM size */
594 data = 0x76543210;
595 ns_write_sram(card, 0x1C003, &data, 1);
596 data = 0x89ABCDEF;
597 ns_write_sram(card, 0x14003, &data, 1);
598 if (ns_read_sram(card, 0x14003) == 0x89ABCDEF &&
599 ns_read_sram(card, 0x1C003) == 0x76543210)
600 card->sram_size = 128;
601 else
602 card->sram_size = 32;
603 PRINTK("nicstar%d: %dK x 32bit SRAM size.\n", i, card->sram_size);
604
605 card->rct_size = NS_MAX_RCTSIZE;
606
607 #if (NS_MAX_RCTSIZE == 4096)
608 if (card->sram_size == 128)
609 printk("nicstar%d: limiting maximum VCI. See NS_MAX_RCTSIZE in nicstar.h\n", i);
610 #elif (NS_MAX_RCTSIZE == 16384)
611 if (card->sram_size == 32)
612 {
613 printk("nicstar%d: wasting memory. See NS_MAX_RCTSIZE in nicstar.h\n", i);
614 card->rct_size = 4096;
615 }
616 #else
617 #error NS_MAX_RCTSIZE must be either 4096 or 16384 in nicstar.c
618 #endif
619
620 card->vpibits = NS_VPIBITS;
621 if (card->rct_size == 4096)
622 card->vcibits = 12 - NS_VPIBITS;
623 else /* card->rct_size == 16384 */
624 card->vcibits = 14 - NS_VPIBITS;
625
626 /* Initialize the nicstar eeprom/eprom stuff, for the MAC addr */
627 if (mac[i] == NULL)
628 nicstar_init_eprom(card->membase);
629
630 if (request_irq(pcidev->irq, &ns_irq_handler, SA_INTERRUPT | SA_SHIRQ, "nicstar", card) != 0)
631 {
632 printk("nicstar%d: can't allocate IRQ %d.\n", i, pcidev->irq);
633 error = 9;
634 ns_init_card_error(card, error);
635 return error;
636 }
637
638 /* Set the VPI/VCI MSb mask to zero so we can receive OAM cells */
639 writel(0x00000000, card->membase + VPM);
640
641 /* Initialize TSQ */
642 card->tsq.org = kmalloc(NS_TSQSIZE + NS_TSQ_ALIGNMENT, GFP_KERNEL);
643 if (card->tsq.org == NULL)
644 {
645 printk("nicstar%d: can't allocate TSQ.\n", i);
646 error = 10;
647 ns_init_card_error(card, error);
648 return error;
649 }
650 card->tsq.base = (ns_tsi *) ALIGN_ADDRESS(card->tsq.org, NS_TSQ_ALIGNMENT);
651 card->tsq.next = card->tsq.base;
652 card->tsq.last = card->tsq.base + (NS_TSQ_NUM_ENTRIES - 1);
653 for (j = 0; j < NS_TSQ_NUM_ENTRIES; j++)
654 ns_tsi_init(card->tsq.base + j);
655 writel(0x00000000, card->membase + TSQH);
656 writel((u32) virt_to_bus(card->tsq.base), card->membase + TSQB);
657 PRINTK("nicstar%d: TSQ base at 0x%x 0x%x 0x%x.\n", i, (u32) card->tsq.base,
658 (u32) virt_to_bus(card->tsq.base), readl(card->membase + TSQB));
659
660 /* Initialize RSQ */
661 card->rsq.org = kmalloc(NS_RSQSIZE + NS_RSQ_ALIGNMENT, GFP_KERNEL);
662 if (card->rsq.org == NULL)
663 {
664 printk("nicstar%d: can't allocate RSQ.\n", i);
665 error = 11;
666 ns_init_card_error(card, error);
667 return error;
668 }
669 card->rsq.base = (ns_rsqe *) ALIGN_ADDRESS(card->rsq.org, NS_RSQ_ALIGNMENT);
670 card->rsq.next = card->rsq.base;
671 card->rsq.last = card->rsq.base + (NS_RSQ_NUM_ENTRIES - 1);
672 for (j = 0; j < NS_RSQ_NUM_ENTRIES; j++)
673 ns_rsqe_init(card->rsq.base + j);
674 writel(0x00000000, card->membase + RSQH);
675 writel((u32) virt_to_bus(card->rsq.base), card->membase + RSQB);
676 PRINTK("nicstar%d: RSQ base at 0x%x.\n", i, (u32) card->rsq.base);
677
678 /* Initialize SCQ0, the only VBR SCQ used */
679 card->scq1 = NULL;
680 card->scq2 = NULL;
681 card->scq0 = get_scq(VBR_SCQSIZE, NS_VRSCD0);
682 if (card->scq0 == NULL)
683 {
684 printk("nicstar%d: can't get SCQ0.\n", i);
685 error = 12;
686 ns_init_card_error(card, error);
687 return error;
688 }
689 u32d[0] = (u32) virt_to_bus(card->scq0->base);
690 u32d[1] = (u32) 0x00000000;
691 u32d[2] = (u32) 0xffffffff;
692 u32d[3] = (u32) 0x00000000;
693 ns_write_sram(card, NS_VRSCD0, u32d, 4);
694 ns_write_sram(card, NS_VRSCD1, u32d, 4); /* These last two won't be used */
695 ns_write_sram(card, NS_VRSCD2, u32d, 4); /* but are initialized, just in case... */
696 card->scq0->scd = NS_VRSCD0;
697 PRINTK("nicstar%d: VBR-SCQ0 base at 0x%x.\n", i, (u32) card->scq0->base);
698
699 /* Initialize TSTs */
700 card->tst_addr = NS_TST0;
701 card->tst_free_entries = NS_TST_NUM_ENTRIES;
702 data = NS_TST_OPCODE_VARIABLE;
703 for (j = 0; j < NS_TST_NUM_ENTRIES; j++)
704 ns_write_sram(card, NS_TST0 + j, &data, 1);
705 data = ns_tste_make(NS_TST_OPCODE_END, NS_TST0);
706 ns_write_sram(card, NS_TST0 + NS_TST_NUM_ENTRIES, &data, 1);
707 for (j = 0; j < NS_TST_NUM_ENTRIES; j++)
708 ns_write_sram(card, NS_TST1 + j, &data, 1);
709 data = ns_tste_make(NS_TST_OPCODE_END, NS_TST1);
710 ns_write_sram(card, NS_TST1 + NS_TST_NUM_ENTRIES, &data, 1);
711 for (j = 0; j < NS_TST_NUM_ENTRIES; j++)
712 card->tste2vc[j] = NULL;
713 writel(NS_TST0 << 2, card->membase + TSTB);
714
715
716 /* Initialize RCT. AAL type is set on opening the VC. */
717 #ifdef RCQ_SUPPORT
718 u32d[0] = NS_RCTE_RAWCELLINTEN;
719 #else
720 u32d[0] = 0x00000000;
721 #endif /* RCQ_SUPPORT */
722 u32d[1] = 0x00000000;
723 u32d[2] = 0x00000000;
724 u32d[3] = 0xFFFFFFFF;
725 for (j = 0; j < card->rct_size; j++)
726 ns_write_sram(card, j * 4, u32d, 4);
727
728 memset(card->vcmap, 0, NS_MAX_RCTSIZE * sizeof(vc_map));
729
730 for (j = 0; j < NS_FRSCD_NUM; j++)
731 card->scd2vc[j] = NULL;
732
733 /* Initialize buffer levels */
734 card->sbnr.min = MIN_SB;
735 card->sbnr.init = NUM_SB;
736 card->sbnr.max = MAX_SB;
737 card->lbnr.min = MIN_LB;
738 card->lbnr.init = NUM_LB;
739 card->lbnr.max = MAX_LB;
740 card->iovnr.min = MIN_IOVB;
741 card->iovnr.init = NUM_IOVB;
742 card->iovnr.max = MAX_IOVB;
743 card->hbnr.min = MIN_HB;
744 card->hbnr.init = NUM_HB;
745 card->hbnr.max = MAX_HB;
746
747 card->sm_handle = 0x00000000;
748 card->sm_addr = 0x00000000;
749 card->lg_handle = 0x00000000;
750 card->lg_addr = 0x00000000;
751
752 card->efbie = 1; /* To prevent push_rxbufs from enabling the interrupt */
753
754 /* Pre-allocate some huge buffers */
755 skb_queue_head_init(&card->hbpool.queue);
756 card->hbpool.count = 0;
757 for (j = 0; j < NUM_HB; j++)
758 {
759 struct sk_buff *hb;
760 hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL);
761 if (hb == NULL)
762 {
763 printk("nicstar%d: can't allocate %dth of %d huge buffers.\n",
764 i, j, NUM_HB);
765 error = 13;
766 ns_init_card_error(card, error);
767 return error;
768 }
769 skb_queue_tail(&card->hbpool.queue, hb);
770 card->hbpool.count++;
771 }
772
773
774 /* Allocate large buffers */
775 skb_queue_head_init(&card->lbpool.queue);
776 card->lbpool.count = 0; /* Not used */
777 for (j = 0; j < NUM_LB; j++)
778 {
779 struct sk_buff *lb;
780 lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL);
781 if (lb == NULL)
782 {
783 printk("nicstar%d: can't allocate %dth of %d large buffers.\n",
784 i, j, NUM_LB);
785 error = 14;
786 ns_init_card_error(card, error);
787 return error;
788 }
789 skb_queue_tail(&card->lbpool.queue, lb);
790 skb_reserve(lb, NS_SMBUFSIZE);
791 push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
792 /* Due to the implementation of push_rxbufs() this is 1, not 0 */
793 if (j == 1)
794 {
795 card->rcbuf = lb;
796 card->rawch = (u32) virt_to_bus(lb->data);
797 }
798 }
799 /* Test for strange behaviour which leads to crashes */
800 if ((bcount = ns_stat_lfbqc_get(readl(card->membase + STAT))) < card->lbnr.min)
801 {
802 printk("nicstar%d: Strange... Just allocated %d large buffers and lfbqc = %d.\n",
803 i, j, bcount);
804 error = 14;
805 ns_init_card_error(card, error);
806 return error;
807 }
808
809
810 /* Allocate small buffers */
811 skb_queue_head_init(&card->sbpool.queue);
812 card->sbpool.count = 0; /* Not used */
813 for (j = 0; j < NUM_SB; j++)
814 {
815 struct sk_buff *sb;
816 sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL);
817 if (sb == NULL)
818 {
819 printk("nicstar%d: can't allocate %dth of %d small buffers.\n",
820 i, j, NUM_SB);
821 error = 15;
822 ns_init_card_error(card, error);
823 return error;
824 }
825 skb_queue_tail(&card->sbpool.queue, sb);
826 skb_reserve(sb, NS_AAL0_HEADER);
827 push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
828 }
829 /* Test for strange behaviour which leads to crashes */
830 if ((bcount = ns_stat_sfbqc_get(readl(card->membase + STAT))) < card->sbnr.min)
831 {
832 printk("nicstar%d: Strange... Just allocated %d small buffers and sfbqc = %d.\n",
833 i, j, bcount);
834 error = 15;
835 ns_init_card_error(card, error);
836 return error;
837 }
838
839
840 /* Allocate iovec buffers */
841 skb_queue_head_init(&card->iovpool.queue);
842 card->iovpool.count = 0;
843 for (j = 0; j < NUM_IOVB; j++)
844 {
845 struct sk_buff *iovb;
846 iovb = alloc_skb(NS_IOVBUFSIZE, GFP_KERNEL);
847 if (iovb == NULL)
848 {
849 printk("nicstar%d: can't allocate %dth of %d iovec buffers.\n",
850 i, j, NUM_IOVB);
851 error = 16;
852 ns_init_card_error(card, error);
853 return error;
854 }
855 skb_queue_tail(&card->iovpool.queue, iovb);
856 card->iovpool.count++;
857 }
858
859 card->intcnt = 0;
860
861 /* Configure NICStAR */
862 if (card->rct_size == 4096)
863 ns_cfg_rctsize = NS_CFG_RCTSIZE_4096_ENTRIES;
864 else /* (card->rct_size == 16384) */
865 ns_cfg_rctsize = NS_CFG_RCTSIZE_16384_ENTRIES;
866
867 card->efbie = 1;
868
869 /* Register device */
870 card->atmdev = atm_dev_register("nicstar", &atm_ops, -1, NULL);
871 if (card->atmdev == NULL)
872 {
873 printk("nicstar%d: can't register device.\n", i);
874 error = 17;
875 ns_init_card_error(card, error);
876 return error;
877 }
878
879 if (ns_parse_mac(mac[i], card->atmdev->esi)) {
880 nicstar_read_eprom(card->membase, NICSTAR_EPROM_MAC_ADDR_OFFSET,
881 card->atmdev->esi, 6);
882 if (memcmp(card->atmdev->esi, "\x00\x00\x00\x00\x00\x00", 6) == 0) {
883 nicstar_read_eprom(card->membase, NICSTAR_EPROM_MAC_ADDR_OFFSET_ALT,
884 card->atmdev->esi, 6);
885 }
886 }
887
888 printk("nicstar%d: MAC address %02X:%02X:%02X:%02X:%02X:%02X\n", i,
889 card->atmdev->esi[0], card->atmdev->esi[1], card->atmdev->esi[2],
890 card->atmdev->esi[3], card->atmdev->esi[4], card->atmdev->esi[5]);
891
892 card->atmdev->dev_data = card;
893 card->atmdev->ci_range.vpi_bits = card->vpibits;
894 card->atmdev->ci_range.vci_bits = card->vcibits;
895 card->atmdev->link_rate = card->max_pcr;
896 card->atmdev->phy = NULL;
897
898 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
899 if (card->max_pcr == ATM_OC3_PCR)
900 suni_init(card->atmdev);
901 #endif /* CONFIG_ATM_NICSTAR_USE_SUNI */
902
903 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
904 if (card->max_pcr == ATM_25_PCR)
905 idt77105_init(card->atmdev);
906 #endif /* CONFIG_ATM_NICSTAR_USE_IDT77105 */
907
908 if (card->atmdev->phy && card->atmdev->phy->start)
909 card->atmdev->phy->start(card->atmdev);
910
911 writel(NS_CFG_RXPATH |
912 NS_CFG_SMBUFSIZE |
913 NS_CFG_LGBUFSIZE |
914 NS_CFG_EFBIE |
915 NS_CFG_RSQSIZE |
916 NS_CFG_VPIBITS |
917 ns_cfg_rctsize |
918 NS_CFG_RXINT_NODELAY |
919 NS_CFG_RAWIE | /* Only enabled if RCQ_SUPPORT */
920 NS_CFG_RSQAFIE |
921 NS_CFG_TXEN |
922 NS_CFG_TXIE |
923 NS_CFG_TSQFIE_OPT | /* Only enabled if ENABLE_TSQFIE */
924 NS_CFG_PHYIE,
925 card->membase + CFG);
926
927 num_cards++;
928
929 return error;
930 }
931
932
933
934 static void __devinit ns_init_card_error(ns_dev *card, int error)
935 {
936 if (error >= 17)
937 {
938 writel(0x00000000, card->membase + CFG);
939 }
940 if (error >= 16)
941 {
942 struct sk_buff *iovb;
943 while ((iovb = skb_dequeue(&card->iovpool.queue)) != NULL)
944 dev_kfree_skb_any(iovb);
945 }
946 if (error >= 15)
947 {
948 struct sk_buff *sb;
949 while ((sb = skb_dequeue(&card->sbpool.queue)) != NULL)
950 dev_kfree_skb_any(sb);
951 free_scq(card->scq0, NULL);
952 }
953 if (error >= 14)
954 {
955 struct sk_buff *lb;
956 while ((lb = skb_dequeue(&card->lbpool.queue)) != NULL)
957 dev_kfree_skb_any(lb);
958 }
959 if (error >= 13)
960 {
961 struct sk_buff *hb;
962 while ((hb = skb_dequeue(&card->hbpool.queue)) != NULL)
963 dev_kfree_skb_any(hb);
964 }
965 if (error >= 12)
966 {
967 kfree(card->rsq.org);
968 }
969 if (error >= 11)
970 {
971 kfree(card->tsq.org);
972 }
973 if (error >= 10)
974 {
975 free_irq(card->pcidev->irq, card);
976 }
977 if (error >= 4)
978 {
979 iounmap(card->membase);
980 }
981 if (error >= 3)
982 {
983 pci_disable_device(card->pcidev);
984 kfree(card);
985 }
986 }
987
988
989
990 static scq_info *get_scq(int size, u32 scd)
991 {
992 scq_info *scq;
993 int i;
994
995 if (size != VBR_SCQSIZE && size != CBR_SCQSIZE)
996 return NULL;
997
998 scq = (scq_info *) kmalloc(sizeof(scq_info), GFP_KERNEL);
999 if (scq == NULL)
1000 return NULL;
1001 scq->org = kmalloc(2 * size, GFP_KERNEL);
1002 if (scq->org == NULL)
1003 {
1004 kfree(scq);
1005 return NULL;
1006 }
1007 scq->skb = (struct sk_buff **) kmalloc(sizeof(struct sk_buff *) *
1008 (size / NS_SCQE_SIZE), GFP_KERNEL);
1009 if (scq->skb == NULL)
1010 {
1011 kfree(scq->org);
1012 kfree(scq);
1013 return NULL;
1014 }
1015 scq->num_entries = size / NS_SCQE_SIZE;
1016 scq->base = (ns_scqe *) ALIGN_ADDRESS(scq->org, size);
1017 scq->next = scq->base;
1018 scq->last = scq->base + (scq->num_entries - 1);
1019 scq->tail = scq->last;
1020 scq->scd = scd;
1021 scq->num_entries = size / NS_SCQE_SIZE;
1022 scq->tbd_count = 0;
1023 init_waitqueue_head(&scq->scqfull_waitq);
1024 scq->full = 0;
1025 spin_lock_init(&scq->lock);
1026
1027 for (i = 0; i < scq->num_entries; i++)
1028 scq->skb[i] = NULL;
1029
1030 return scq;
1031 }
1032
1033
1034
1035 /* For variable rate SCQ vcc must be NULL */
1036 static void free_scq(scq_info *scq, struct atm_vcc *vcc)
1037 {
1038 int i;
1039
1040 if (scq->num_entries == VBR_SCQ_NUM_ENTRIES)
1041 for (i = 0; i < scq->num_entries; i++)
1042 {
1043 if (scq->skb[i] != NULL)
1044 {
1045 vcc = ATM_SKB(scq->skb[i])->vcc;
1046 if (vcc->pop != NULL)
1047 vcc->pop(vcc, scq->skb[i]);
1048 else
1049 dev_kfree_skb_any(scq->skb[i]);
1050 }
1051 }
1052 else /* vcc must be != NULL */
1053 {
1054 if (vcc == NULL)
1055 {
1056 printk("nicstar: free_scq() called with vcc == NULL for fixed rate scq.");
1057 for (i = 0; i < scq->num_entries; i++)
1058 dev_kfree_skb_any(scq->skb[i]);
1059 }
1060 else
1061 for (i = 0; i < scq->num_entries; i++)
1062 {
1063 if (scq->skb[i] != NULL)
1064 {
1065 if (vcc->pop != NULL)
1066 vcc->pop(vcc, scq->skb[i]);
1067 else
1068 dev_kfree_skb_any(scq->skb[i]);
1069 }
1070 }
1071 }
1072 kfree(scq->skb);
1073 kfree(scq->org);
1074 kfree(scq);
1075 }
1076
1077
1078
1079 /* The handles passed must be pointers to the sk_buff containing the small
1080 or large buffer(s) cast to u32. */
1081 static void push_rxbufs(ns_dev *card, u32 type, u32 handle1, u32 addr1,
1082 u32 handle2, u32 addr2)
1083 {
1084 u32 stat;
1085 unsigned long flags;
1086
1087
1088 #ifdef GENERAL_DEBUG
1089 if (!addr1)
1090 printk("nicstar%d: push_rxbufs called with addr1 = 0.\n", card->index);
1091 #endif /* GENERAL_DEBUG */
1092
1093 stat = readl(card->membase + STAT);
1094 card->sbfqc = ns_stat_sfbqc_get(stat);
1095 card->lbfqc = ns_stat_lfbqc_get(stat);
1096 if (type == BUF_SM)
1097 {
1098 if (!addr2)
1099 {
1100 if (card->sm_addr)
1101 {
1102 addr2 = card->sm_addr;
1103 handle2 = card->sm_handle;
1104 card->sm_addr = 0x00000000;
1105 card->sm_handle = 0x00000000;
1106 }
1107 else /* (!sm_addr) */
1108 {
1109 card->sm_addr = addr1;
1110 card->sm_handle = handle1;
1111 }
1112 }
1113 }
1114 else /* type == BUF_LG */
1115 {
1116 if (!addr2)
1117 {
1118 if (card->lg_addr)
1119 {
1120 addr2 = card->lg_addr;
1121 handle2 = card->lg_handle;
1122 card->lg_addr = 0x00000000;
1123 card->lg_handle = 0x00000000;
1124 }
1125 else /* (!lg_addr) */
1126 {
1127 card->lg_addr = addr1;
1128 card->lg_handle = handle1;
1129 }
1130 }
1131 }
1132
1133 if (addr2)
1134 {
1135 if (type == BUF_SM)
1136 {
1137 if (card->sbfqc >= card->sbnr.max)
1138 {
1139 skb_unlink((struct sk_buff *) handle1);
1140 dev_kfree_skb_any((struct sk_buff *) handle1);
1141 skb_unlink((struct sk_buff *) handle2);
1142 dev_kfree_skb_any((struct sk_buff *) handle2);
1143 return;
1144 }
1145 else
1146 card->sbfqc += 2;
1147 }
1148 else /* (type == BUF_LG) */
1149 {
1150 if (card->lbfqc >= card->lbnr.max)
1151 {
1152 skb_unlink((struct sk_buff *) handle1);
1153 dev_kfree_skb_any((struct sk_buff *) handle1);
1154 skb_unlink((struct sk_buff *) handle2);
1155 dev_kfree_skb_any((struct sk_buff *) handle2);
1156 return;
1157 }
1158 else
1159 card->lbfqc += 2;
1160 }
1161
1162 ns_grab_res_lock(card, flags);
1163
1164 while (CMD_BUSY(card));
1165 writel(addr2, card->membase + DR3);
1166 writel(handle2, card->membase + DR2);
1167 writel(addr1, card->membase + DR1);
1168 writel(handle1, card->membase + DR0);
1169 writel(NS_CMD_WRITE_FREEBUFQ | (u32) type, card->membase + CMD);
1170
1171 spin_unlock_irqrestore(&card->res_lock, flags);
1172
1173 XPRINTK("nicstar%d: Pushing %s buffers at 0x%x and 0x%x.\n", card->index,
1174 (type == BUF_SM ? "small" : "large"), addr1, addr2);
1175 }
1176
1177 if (!card->efbie && card->sbfqc >= card->sbnr.min &&
1178 card->lbfqc >= card->lbnr.min)
1179 {
1180 card->efbie = 1;
1181 writel((readl(card->membase + CFG) | NS_CFG_EFBIE), card->membase + CFG);
1182 }
1183
1184 return;
1185 }
1186
1187
1188
1189 static irqreturn_t ns_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
1190 {
1191 u32 stat_r;
1192 ns_dev *card;
1193 struct atm_dev *dev;
1194 unsigned long flags;
1195
1196 card = (ns_dev *) dev_id;
1197 dev = card->atmdev;
1198 card->intcnt++;
1199
1200 PRINTK("nicstar%d: NICStAR generated an interrupt\n", card->index);
1201
1202 ns_grab_int_lock(card, flags);
1203
1204 stat_r = readl(card->membase + STAT);
1205
1206 /* Transmit Status Indicator has been written to T. S. Queue */
1207 if (stat_r & NS_STAT_TSIF)
1208 {
1209 TXPRINTK("nicstar%d: TSI interrupt\n", card->index);
1210 process_tsq(card);
1211 writel(NS_STAT_TSIF, card->membase + STAT);
1212 }
1213
1214 /* Incomplete CS-PDU has been transmitted */
1215 if (stat_r & NS_STAT_TXICP)
1216 {
1217 writel(NS_STAT_TXICP, card->membase + STAT);
1218 TXPRINTK("nicstar%d: Incomplete CS-PDU transmitted.\n",
1219 card->index);
1220 }
1221
1222 /* Transmit Status Queue 7/8 full */
1223 if (stat_r & NS_STAT_TSQF)
1224 {
1225 writel(NS_STAT_TSQF, card->membase + STAT);
1226 PRINTK("nicstar%d: TSQ full.\n", card->index);
1227 process_tsq(card);
1228 }
1229
1230 /* Timer overflow */
1231 if (stat_r & NS_STAT_TMROF)
1232 {
1233 writel(NS_STAT_TMROF, card->membase + STAT);
1234 PRINTK("nicstar%d: Timer overflow.\n", card->index);
1235 }
1236
1237 /* PHY device interrupt signal active */
1238 if (stat_r & NS_STAT_PHYI)
1239 {
1240 writel(NS_STAT_PHYI, card->membase + STAT);
1241 PRINTK("nicstar%d: PHY interrupt.\n", card->index);
1242 if (dev->phy && dev->phy->interrupt) {
1243 dev->phy->interrupt(dev);
1244 }
1245 }
1246
1247 /* Small Buffer Queue is full */
1248 if (stat_r & NS_STAT_SFBQF)
1249 {
1250 writel(NS_STAT_SFBQF, card->membase + STAT);
1251 printk("nicstar%d: Small free buffer queue is full.\n", card->index);
1252 }
1253
1254 /* Large Buffer Queue is full */
1255 if (stat_r & NS_STAT_LFBQF)
1256 {
1257 writel(NS_STAT_LFBQF, card->membase + STAT);
1258 printk("nicstar%d: Large free buffer queue is full.\n", card->index);
1259 }
1260
1261 /* Receive Status Queue is full */
1262 if (stat_r & NS_STAT_RSQF)
1263 {
1264 writel(NS_STAT_RSQF, card->membase + STAT);
1265 printk("nicstar%d: RSQ full.\n", card->index);
1266 process_rsq(card);
1267 }
1268
1269 /* Complete CS-PDU received */
1270 if (stat_r & NS_STAT_EOPDU)
1271 {
1272 RXPRINTK("nicstar%d: End of CS-PDU received.\n", card->index);
1273 process_rsq(card);
1274 writel(NS_STAT_EOPDU, card->membase + STAT);
1275 }
1276
1277 /* Raw cell received */
1278 if (stat_r & NS_STAT_RAWCF)
1279 {
1280 writel(NS_STAT_RAWCF, card->membase + STAT);
1281 #ifndef RCQ_SUPPORT
1282 printk("nicstar%d: Raw cell received and no support yet...\n",
1283 card->index);
1284 #endif /* RCQ_SUPPORT */
1285 /* NOTE: the following procedure may keep a raw cell pending until the
1286 next interrupt. As this preliminary support is only meant to
1287 avoid buffer leakage, this is not an issue. */
1288 while (readl(card->membase + RAWCT) != card->rawch)
1289 {
1290 ns_rcqe *rawcell;
1291
1292 rawcell = (ns_rcqe *) bus_to_virt(card->rawch);
1293 if (ns_rcqe_islast(rawcell))
1294 {
1295 struct sk_buff *oldbuf;
1296
1297 oldbuf = card->rcbuf;
1298 card->rcbuf = (struct sk_buff *) ns_rcqe_nextbufhandle(rawcell);
1299 card->rawch = (u32) virt_to_bus(card->rcbuf->data);
1300 recycle_rx_buf(card, oldbuf);
1301 }
1302 else
1303 card->rawch += NS_RCQE_SIZE;
1304 }
1305 }
1306
1307 /* Small buffer queue is empty */
1308 if (stat_r & NS_STAT_SFBQE)
1309 {
1310 int i;
1311 struct sk_buff *sb;
1312
1313 writel(NS_STAT_SFBQE, card->membase + STAT);
1314 printk("nicstar%d: Small free buffer queue empty.\n",
1315 card->index);
1316 for (i = 0; i < card->sbnr.min; i++)
1317 {
1318 sb = dev_alloc_skb(NS_SMSKBSIZE);
1319 if (sb == NULL)
1320 {
1321 writel(readl(card->membase + CFG) & ~NS_CFG_EFBIE, card->membase + CFG);
1322 card->efbie = 0;
1323 break;
1324 }
1325 skb_queue_tail(&card->sbpool.queue, sb);
1326 skb_reserve(sb, NS_AAL0_HEADER);
1327 push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
1328 }
1329 card->sbfqc = i;
1330 process_rsq(card);
1331 }
1332
1333 /* Large buffer queue empty */
1334 if (stat_r & NS_STAT_LFBQE)
1335 {
1336 int i;
1337 struct sk_buff *lb;
1338
1339 writel(NS_STAT_LFBQE, card->membase + STAT);
1340 printk("nicstar%d: Large free buffer queue empty.\n",
1341 card->index);
1342 for (i = 0; i < card->lbnr.min; i++)
1343 {
1344 lb = dev_alloc_skb(NS_LGSKBSIZE);
1345 if (lb == NULL)
1346 {
1347 writel(readl(card->membase + CFG) & ~NS_CFG_EFBIE, card->membase + CFG);
1348 card->efbie = 0;
1349 break;
1350 }
1351 skb_queue_tail(&card->lbpool.queue, lb);
1352 skb_reserve(lb, NS_SMBUFSIZE);
1353 push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
1354 }
1355 card->lbfqc = i;
1356 process_rsq(card);
1357 }
1358
1359 /* Receive Status Queue is 7/8 full */
1360 if (stat_r & NS_STAT_RSQAF)
1361 {
1362 writel(NS_STAT_RSQAF, card->membase + STAT);
1363 RXPRINTK("nicstar%d: RSQ almost full.\n", card->index);
1364 process_rsq(card);
1365 }
1366
1367 spin_unlock_irqrestore(&card->int_lock, flags);
1368 PRINTK("nicstar%d: end of interrupt service\n", card->index);
1369 return IRQ_HANDLED;
1370 }
1371
1372
1373
1374 static int ns_open(struct atm_vcc *vcc)
1375 {
1376 ns_dev *card;
1377 vc_map *vc;
1378 unsigned long tmpl, modl;
1379 int tcr, tcra; /* target cell rate, and absolute value */
1380 int n = 0; /* Number of entries in the TST. Initialized to remove
1381 the compiler warning. */
1382 u32 u32d[4];
1383 int frscdi = 0; /* Index of the SCD. Initialized to remove the compiler
1384 warning. How I wish compilers were clever enough to
1385 tell which variables can truly be used
1386 uninitialized... */
1387 int inuse; /* tx or rx vc already in use by another vcc */
1388 short vpi = vcc->vpi;
1389 int vci = vcc->vci;
1390
1391 card = (ns_dev *) vcc->dev->dev_data;
1392 PRINTK("nicstar%d: opening vpi.vci %d.%d \n", card->index, (int) vpi, vci);
1393 if (vcc->qos.aal != ATM_AAL5 && vcc->qos.aal != ATM_AAL0)
1394 {
1395 PRINTK("nicstar%d: unsupported AAL.\n", card->index);
1396 return -EINVAL;
1397 }
1398
1399 vc = &(card->vcmap[vpi << card->vcibits | vci]);
1400 vcc->dev_data = vc;
1401
1402 inuse = 0;
1403 if (vcc->qos.txtp.traffic_class != ATM_NONE && vc->tx)
1404 inuse = 1;
1405 if (vcc->qos.rxtp.traffic_class != ATM_NONE && vc->rx)
1406 inuse += 2;
1407 if (inuse)
1408 {
1409 printk("nicstar%d: %s vci already in use.\n", card->index,
1410 inuse == 1 ? "tx" : inuse == 2 ? "rx" : "tx and rx");
1411 return -EINVAL;
1412 }
1413
1414 set_bit(ATM_VF_ADDR,&vcc->flags);
1415
1416 /* NOTE: You are not allowed to modify an open connection's QOS. To change
1417 that, remove the ATM_VF_PARTIAL flag checking. There may be other changes
1418 needed to do that. */
1419 if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1420 {
1421 scq_info *scq;
1422
1423 set_bit(ATM_VF_PARTIAL,&vcc->flags);
1424 if (vcc->qos.txtp.traffic_class == ATM_CBR)
1425 {
1426 /* Check requested cell rate and availability of SCD */
1427 if (vcc->qos.txtp.max_pcr == 0 && vcc->qos.txtp.pcr == 0 &&
1428 vcc->qos.txtp.min_pcr == 0)
1429 {
1430 PRINTK("nicstar%d: trying to open a CBR vc with cell rate = 0 \n",
1431 card->index);
1432 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1433 clear_bit(ATM_VF_ADDR,&vcc->flags);
1434 return -EINVAL;
1435 }
1436
1437 tcr = atm_pcr_goal(&(vcc->qos.txtp));
1438 tcra = tcr >= 0 ? tcr : -tcr;
1439
1440 PRINTK("nicstar%d: target cell rate = %d.\n", card->index,
1441 vcc->qos.txtp.max_pcr);
1442
1443 tmpl = (unsigned long)tcra * (unsigned long)NS_TST_NUM_ENTRIES;
1444 modl = tmpl % card->max_pcr;
1445
1446 n = (int)(tmpl / card->max_pcr);
1447 if (tcr > 0)
1448 {
1449 if (modl > 0) n++;
1450 }
1451 else if (tcr == 0)
1452 {
1453 if ((n = (card->tst_free_entries - NS_TST_RESERVED)) <= 0)
1454 {
1455 PRINTK("nicstar%d: no CBR bandwidth free.\n", card->index);
1456 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1457 clear_bit(ATM_VF_ADDR,&vcc->flags);
1458 return -EINVAL;
1459 }
1460 }
1461
1462 if (n == 0)
1463 {
1464 printk("nicstar%d: selected bandwidth < granularity.\n", card->index);
1465 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1466 clear_bit(ATM_VF_ADDR,&vcc->flags);
1467 return -EINVAL;
1468 }
1469
1470 if (n > (card->tst_free_entries - NS_TST_RESERVED))
1471 {
1472 PRINTK("nicstar%d: not enough free CBR bandwidth.\n", card->index);
1473 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1474 clear_bit(ATM_VF_ADDR,&vcc->flags);
1475 return -EINVAL;
1476 }
1477 else
1478 card->tst_free_entries -= n;
1479
1480 XPRINTK("nicstar%d: writing %d tst entries.\n", card->index, n);
1481 for (frscdi = 0; frscdi < NS_FRSCD_NUM; frscdi++)
1482 {
1483 if (card->scd2vc[frscdi] == NULL)
1484 {
1485 card->scd2vc[frscdi] = vc;
1486 break;
1487 }
1488 }
1489 if (frscdi == NS_FRSCD_NUM)
1490 {
1491 PRINTK("nicstar%d: no SCD available for CBR channel.\n", card->index);
1492 card->tst_free_entries += n;
1493 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1494 clear_bit(ATM_VF_ADDR,&vcc->flags);
1495 return -EBUSY;
1496 }
1497
1498 vc->cbr_scd = NS_FRSCD + frscdi * NS_FRSCD_SIZE;
1499
1500 scq = get_scq(CBR_SCQSIZE, vc->cbr_scd);
1501 if (scq == NULL)
1502 {
1503 PRINTK("nicstar%d: can't get fixed rate SCQ.\n", card->index);
1504 card->scd2vc[frscdi] = NULL;
1505 card->tst_free_entries += n;
1506 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1507 clear_bit(ATM_VF_ADDR,&vcc->flags);
1508 return -ENOMEM;
1509 }
1510 vc->scq = scq;
1511 u32d[0] = (u32) virt_to_bus(scq->base);
1512 u32d[1] = (u32) 0x00000000;
1513 u32d[2] = (u32) 0xffffffff;
1514 u32d[3] = (u32) 0x00000000;
1515 ns_write_sram(card, vc->cbr_scd, u32d, 4);
1516
1517 fill_tst(card, n, vc);
1518 }
1519 else if (vcc->qos.txtp.traffic_class == ATM_UBR)
1520 {
1521 vc->cbr_scd = 0x00000000;
1522 vc->scq = card->scq0;
1523 }
1524
1525 if (vcc->qos.txtp.traffic_class != ATM_NONE)
1526 {
1527 vc->tx = 1;
1528 vc->tx_vcc = vcc;
1529 vc->tbd_count = 0;
1530 }
1531 if (vcc->qos.rxtp.traffic_class != ATM_NONE)
1532 {
1533 u32 status;
1534
1535 vc->rx = 1;
1536 vc->rx_vcc = vcc;
1537 vc->rx_iov = NULL;
1538
1539 /* Open the connection in hardware */
1540 if (vcc->qos.aal == ATM_AAL5)
1541 status = NS_RCTE_AAL5 | NS_RCTE_CONNECTOPEN;
1542 else /* vcc->qos.aal == ATM_AAL0 */
1543 status = NS_RCTE_AAL0 | NS_RCTE_CONNECTOPEN;
1544 #ifdef RCQ_SUPPORT
1545 status |= NS_RCTE_RAWCELLINTEN;
1546 #endif /* RCQ_SUPPORT */
1547 ns_write_sram(card, NS_RCT + (vpi << card->vcibits | vci) *
1548 NS_RCT_ENTRY_SIZE, &status, 1);
1549 }
1550
1551 }
1552
1553 set_bit(ATM_VF_READY,&vcc->flags);
1554 return 0;
1555 }
1556
1557
1558
1559 static void ns_close(struct atm_vcc *vcc)
1560 {
1561 vc_map *vc;
1562 ns_dev *card;
1563 u32 data;
1564 int i;
1565
1566 vc = vcc->dev_data;
1567 card = vcc->dev->dev_data;
1568 PRINTK("nicstar%d: closing vpi.vci %d.%d \n", card->index,
1569 (int) vcc->vpi, vcc->vci);
1570
1571 clear_bit(ATM_VF_READY,&vcc->flags);
1572
1573 if (vcc->qos.rxtp.traffic_class != ATM_NONE)
1574 {
1575 u32 addr;
1576 unsigned long flags;
1577
1578 addr = NS_RCT + (vcc->vpi << card->vcibits | vcc->vci) * NS_RCT_ENTRY_SIZE;
1579 ns_grab_res_lock(card, flags);
1580 while(CMD_BUSY(card));
1581 writel(NS_CMD_CLOSE_CONNECTION | addr << 2, card->membase + CMD);
1582 spin_unlock_irqrestore(&card->res_lock, flags);
1583
1584 vc->rx = 0;
1585 if (vc->rx_iov != NULL)
1586 {
1587 struct sk_buff *iovb;
1588 u32 stat;
1589
1590 stat = readl(card->membase + STAT);
1591 card->sbfqc = ns_stat_sfbqc_get(stat);
1592 card->lbfqc = ns_stat_lfbqc_get(stat);
1593
1594 PRINTK("nicstar%d: closing a VC with pending rx buffers.\n",
1595 card->index);
1596 iovb = vc->rx_iov;
1597 recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
1598 NS_SKB(iovb)->iovcnt);
1599 NS_SKB(iovb)->iovcnt = 0;
1600 NS_SKB(iovb)->vcc = NULL;
1601 ns_grab_int_lock(card, flags);
1602 recycle_iov_buf(card, iovb);
1603 spin_unlock_irqrestore(&card->int_lock, flags);
1604 vc->rx_iov = NULL;
1605 }
1606 }
1607
1608 if (vcc->qos.txtp.traffic_class != ATM_NONE)
1609 {
1610 vc->tx = 0;
1611 }
1612
1613 if (vcc->qos.txtp.traffic_class == ATM_CBR)
1614 {
1615 unsigned long flags;
1616 ns_scqe *scqep;
1617 scq_info *scq;
1618
1619 scq = vc->scq;
1620
1621 for (;;)
1622 {
1623 ns_grab_scq_lock(card, scq, flags);
1624 scqep = scq->next;
1625 if (scqep == scq->base)
1626 scqep = scq->last;
1627 else
1628 scqep--;
1629 if (scqep == scq->tail)
1630 {
1631 spin_unlock_irqrestore(&scq->lock, flags);
1632 break;
1633 }
1634 /* If the last entry is not a TSR, place one in the SCQ in order to
1635 be able to completely drain it and then close. */
1636 if (!ns_scqe_is_tsr(scqep) && scq->tail != scq->next)
1637 {
1638 ns_scqe tsr;
1639 u32 scdi, scqi;
1640 u32 data;
1641 int index;
1642
1643 tsr.word_1 = ns_tsr_mkword_1(NS_TSR_INTENABLE);
1644 scdi = (vc->cbr_scd - NS_FRSCD) / NS_FRSCD_SIZE;
1645 scqi = scq->next - scq->base;
1646 tsr.word_2 = ns_tsr_mkword_2(scdi, scqi);
1647 tsr.word_3 = 0x00000000;
1648 tsr.word_4 = 0x00000000;
1649 *scq->next = tsr;
1650 index = (int) scqi;
1651 scq->skb[index] = NULL;
1652 if (scq->next == scq->last)
1653 scq->next = scq->base;
1654 else
1655 scq->next++;
1656 data = (u32) virt_to_bus(scq->next);
1657 ns_write_sram(card, scq->scd, &data, 1);
1658 }
1659 spin_unlock_irqrestore(&scq->lock, flags);
1660 schedule();
1661 }
1662
1663 /* Free all TST entries */
1664 data = NS_TST_OPCODE_VARIABLE;
1665 for (i = 0; i < NS_TST_NUM_ENTRIES; i++)
1666 {
1667 if (card->tste2vc[i] == vc)
1668 {
1669 ns_write_sram(card, card->tst_addr + i, &data, 1);
1670 card->tste2vc[i] = NULL;
1671 card->tst_free_entries++;
1672 }
1673 }
1674
1675 card->scd2vc[(vc->cbr_scd - NS_FRSCD) / NS_FRSCD_SIZE] = NULL;
1676 free_scq(vc->scq, vcc);
1677 }
1678
1679 /* remove all references to vcc before deleting it */
1680 if (vcc->qos.txtp.traffic_class != ATM_NONE)
1681 {
1682 unsigned long flags;
1683 scq_info *scq = card->scq0;
1684
1685 ns_grab_scq_lock(card, scq, flags);
1686
1687 for(i = 0; i < scq->num_entries; i++) {
1688 if(scq->skb[i] && ATM_SKB(scq->skb[i])->vcc == vcc) {
1689 ATM_SKB(scq->skb[i])->vcc = NULL;
1690 atm_return(vcc, scq->skb[i]->truesize);
1691 PRINTK("nicstar: deleted pending vcc mapping\n");
1692 }
1693 }
1694
1695 spin_unlock_irqrestore(&scq->lock, flags);
1696 }
1697
1698 vcc->dev_data = NULL;
1699 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1700 clear_bit(ATM_VF_ADDR,&vcc->flags);
1701
1702 #ifdef RX_DEBUG
1703 {
1704 u32 stat, cfg;
1705 stat = readl(card->membase + STAT);
1706 cfg = readl(card->membase + CFG);
1707 printk("STAT = 0x%08X CFG = 0x%08X \n", stat, cfg);
1708 printk("TSQ: base = 0x%08X next = 0x%08X last = 0x%08X TSQT = 0x%08X \n",
1709 (u32) card->tsq.base, (u32) card->tsq.next,(u32) card->tsq.last,
1710 readl(card->membase + TSQT));
1711 printk("RSQ: base = 0x%08X next = 0x%08X last = 0x%08X RSQT = 0x%08X \n",
1712 (u32) card->rsq.base, (u32) card->rsq.next,(u32) card->rsq.last,
1713 readl(card->membase + RSQT));
1714 printk("Empty free buffer queue interrupt %s \n",
1715 card->efbie ? "enabled" : "disabled");
1716 printk("SBCNT = %d count = %d LBCNT = %d count = %d \n",
1717 ns_stat_sfbqc_get(stat), card->sbpool.count,
1718 ns_stat_lfbqc_get(stat), card->lbpool.count);
1719 printk("hbpool.count = %d iovpool.count = %d \n",
1720 card->hbpool.count, card->iovpool.count);
1721 }
1722 #endif /* RX_DEBUG */
1723 }
1724
1725
1726
1727 static void fill_tst(ns_dev *card, int n, vc_map *vc)
1728 {
1729 u32 new_tst;
1730 unsigned long cl;
1731 int e, r;
1732 u32 data;
1733
1734 /* It would be very complicated to keep the two TSTs synchronized while
1735 assuring that writes are only made to the inactive TST. So, for now I
1736 will use only one TST. If problems occur, I will change this again */
1737
1738 new_tst = card->tst_addr;
1739
1740 /* Fill procedure */
1741
1742 for (e = 0; e < NS_TST_NUM_ENTRIES; e++)
1743 {
1744 if (card->tste2vc[e] == NULL)
1745 break;
1746 }
1747 if (e == NS_TST_NUM_ENTRIES) {
1748 printk("nicstar%d: No free TST entries found. \n", card->index);
1749 return;
1750 }
1751
1752 r = n;
1753 cl = NS_TST_NUM_ENTRIES;
1754 data = ns_tste_make(NS_TST_OPCODE_FIXED, vc->cbr_scd);
1755
1756 while (r > 0)
1757 {
1758 if (cl >= NS_TST_NUM_ENTRIES && card->tste2vc[e] == NULL)
1759 {
1760 card->tste2vc[e] = vc;
1761 ns_write_sram(card, new_tst + e, &data, 1);
1762 cl -= NS_TST_NUM_ENTRIES;
1763 r--;
1764 }
1765
1766 if (++e == NS_TST_NUM_ENTRIES) {
1767 e = 0;
1768 }
1769 cl += n;
1770 }
1771
1772 /* End of fill procedure */
1773
1774 data = ns_tste_make(NS_TST_OPCODE_END, new_tst);
1775 ns_write_sram(card, new_tst + NS_TST_NUM_ENTRIES, &data, 1);
1776 ns_write_sram(card, card->tst_addr + NS_TST_NUM_ENTRIES, &data, 1);
1777 card->tst_addr = new_tst;
1778 }
1779
1780
1781
1782 static int ns_send(struct atm_vcc *vcc, struct sk_buff *skb)
1783 {
1784 ns_dev *card;
1785 vc_map *vc;
1786 scq_info *scq;
1787 unsigned long buflen;
1788 ns_scqe scqe;
1789 u32 flags; /* TBD flags, not CPU flags */
1790
1791 card = vcc->dev->dev_data;
1792 TXPRINTK("nicstar%d: ns_send() called.\n", card->index);
1793 if ((vc = (vc_map *) vcc->dev_data) == NULL)
1794 {
1795 printk("nicstar%d: vcc->dev_data == NULL on ns_send().\n", card->index);
1796 atomic_inc(&vcc->stats->tx_err);
1797 dev_kfree_skb_any(skb);
1798 return -EINVAL;
1799 }
1800
1801 if (!vc->tx)
1802 {
1803 printk("nicstar%d: Trying to transmit on a non-tx VC.\n", card->index);
1804 atomic_inc(&vcc->stats->tx_err);
1805 dev_kfree_skb_any(skb);
1806 return -EINVAL;
1807 }
1808
1809 if (vcc->qos.aal != ATM_AAL5 && vcc->qos.aal != ATM_AAL0)
1810 {
1811 printk("nicstar%d: Only AAL0 and AAL5 are supported.\n", card->index);
1812 atomic_inc(&vcc->stats->tx_err);
1813 dev_kfree_skb_any(skb);
1814 return -EINVAL;
1815 }
1816
1817 if (skb_shinfo(skb)->nr_frags != 0)
1818 {
1819 printk("nicstar%d: No scatter-gather yet.\n", card->index);
1820 atomic_inc(&vcc->stats->tx_err);
1821 dev_kfree_skb_any(skb);
1822 return -EINVAL;
1823 }
1824
1825 ATM_SKB(skb)->vcc = vcc;
1826
1827 if (vcc->qos.aal == ATM_AAL5)
1828 {
1829 buflen = (skb->len + 47 + 8) / 48 * 48; /* Multiple of 48 */
1830 flags = NS_TBD_AAL5;
1831 scqe.word_2 = cpu_to_le32((u32) virt_to_bus(skb->data));
1832 scqe.word_3 = cpu_to_le32((u32) skb->len);
1833 scqe.word_4 = ns_tbd_mkword_4(0, (u32) vcc->vpi, (u32) vcc->vci, 0,
1834 ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ? 1 : 0);
1835 flags |= NS_TBD_EOPDU;
1836 }
1837 else /* (vcc->qos.aal == ATM_AAL0) */
1838 {
1839 buflen = ATM_CELL_PAYLOAD; /* i.e., 48 bytes */
1840 flags = NS_TBD_AAL0;
1841 scqe.word_2 = cpu_to_le32((u32) virt_to_bus(skb->data) + NS_AAL0_HEADER);
1842 scqe.word_3 = cpu_to_le32(0x00000000);
1843 if (*skb->data & 0x02) /* Payload type 1 - end of pdu */
1844 flags |= NS_TBD_EOPDU;
1845 scqe.word_4 = cpu_to_le32(*((u32 *) skb->data) & ~NS_TBD_VC_MASK);
1846 /* Force the VPI/VCI to be the same as in VCC struct */
1847 scqe.word_4 |= cpu_to_le32((((u32) vcc->vpi) << NS_TBD_VPI_SHIFT |
1848 ((u32) vcc->vci) << NS_TBD_VCI_SHIFT) &
1849 NS_TBD_VC_MASK);
1850 }
1851
1852 if (vcc->qos.txtp.traffic_class == ATM_CBR)
1853 {
1854 scqe.word_1 = ns_tbd_mkword_1_novbr(flags, (u32) buflen);
1855 scq = ((vc_map *) vcc->dev_data)->scq;
1856 }
1857 else
1858 {
1859 scqe.word_1 = ns_tbd_mkword_1(flags, (u32) 1, (u32) 1, (u32) buflen);
1860 scq = card->scq0;
1861 }
1862
1863 if (push_scqe(card, vc, scq, &scqe, skb) != 0)
1864 {
1865 atomic_inc(&vcc->stats->tx_err);
1866 dev_kfree_skb_any(skb);
1867 return -EIO;
1868 }
1869 atomic_inc(&vcc->stats->tx);
1870
1871 return 0;
1872 }
1873
1874
1875
1876 static int push_scqe(ns_dev *card, vc_map *vc, scq_info *scq, ns_scqe *tbd,
1877 struct sk_buff *skb)
1878 {
1879 unsigned long flags;
1880 ns_scqe tsr;
1881 u32 scdi, scqi;
1882 int scq_is_vbr;
1883 u32 data;
1884 int index;
1885
1886 ns_grab_scq_lock(card, scq, flags);
1887 while (scq->tail == scq->next)
1888 {
1889 if (in_interrupt()) {
1890 spin_unlock_irqrestore(&scq->lock, flags);
1891 printk("nicstar%d: Error pushing TBD.\n", card->index);
1892 return 1;
1893 }
1894
1895 scq->full = 1;
1896 spin_unlock_irqrestore(&scq->lock, flags);
1897 interruptible_sleep_on_timeout(&scq->scqfull_waitq, SCQFULL_TIMEOUT);
1898 ns_grab_scq_lock(card, scq, flags);
1899
1900 if (scq->full) {
1901 spin_unlock_irqrestore(&scq->lock, flags);
1902 printk("nicstar%d: Timeout pushing TBD.\n", card->index);
1903 return 1;
1904 }
1905 }
1906 *scq->next = *tbd;
1907 index = (int) (scq->next - scq->base);
1908 scq->skb[index] = skb;
1909 XPRINTK("nicstar%d: sending skb at 0x%x (pos %d).\n",
1910 card->index, (u32) skb, index);
1911 XPRINTK("nicstar%d: TBD written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%x.\n",
1912 card->index, le32_to_cpu(tbd->word_1), le32_to_cpu(tbd->word_2),
1913 le32_to_cpu(tbd->word_3), le32_to_cpu(tbd->word_4),
1914 (u32) scq->next);
1915 if (scq->next == scq->last)
1916 scq->next = scq->base;
1917 else
1918 scq->next++;
1919
1920 vc->tbd_count++;
1921 if (scq->num_entries == VBR_SCQ_NUM_ENTRIES)
1922 {
1923 scq->tbd_count++;
1924 scq_is_vbr = 1;
1925 }
1926 else
1927 scq_is_vbr = 0;
1928
1929 if (vc->tbd_count >= MAX_TBD_PER_VC || scq->tbd_count >= MAX_TBD_PER_SCQ)
1930 {
1931 int has_run = 0;
1932
1933 while (scq->tail == scq->next)
1934 {
1935 if (in_interrupt()) {
1936 data = (u32) virt_to_bus(scq->next);
1937 ns_write_sram(card, scq->scd, &data, 1);
1938 spin_unlock_irqrestore(&scq->lock, flags);
1939 printk("nicstar%d: Error pushing TSR.\n", card->index);
1940 return 0;
1941 }
1942
1943 scq->full = 1;
1944 if (has_run++) break;
1945 spin_unlock_irqrestore(&scq->lock, flags);
1946 interruptible_sleep_on_timeout(&scq->scqfull_waitq, SCQFULL_TIMEOUT);
1947 ns_grab_scq_lock(card, scq, flags);
1948 }
1949
1950 if (!scq->full)
1951 {
1952 tsr.word_1 = ns_tsr_mkword_1(NS_TSR_INTENABLE);
1953 if (scq_is_vbr)
1954 scdi = NS_TSR_SCDISVBR;
1955 else
1956 scdi = (vc->cbr_scd - NS_FRSCD) / NS_FRSCD_SIZE;
1957 scqi = scq->next - scq->base;
1958 tsr.word_2 = ns_tsr_mkword_2(scdi, scqi);
1959 tsr.word_3 = 0x00000000;
1960 tsr.word_4 = 0x00000000;
1961
1962 *scq->next = tsr;
1963 index = (int) scqi;
1964 scq->skb[index] = NULL;
1965 XPRINTK("nicstar%d: TSR written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%x.\n",
1966 card->index, le32_to_cpu(tsr.word_1), le32_to_cpu(tsr.word_2),
1967 le32_to_cpu(tsr.word_3), le32_to_cpu(tsr.word_4),
1968 (u32) scq->next);
1969 if (scq->next == scq->last)
1970 scq->next = scq->base;
1971 else
1972 scq->next++;
1973 vc->tbd_count = 0;
1974 scq->tbd_count = 0;
1975 }
1976 else
1977 PRINTK("nicstar%d: Timeout pushing TSR.\n", card->index);
1978 }
1979 data = (u32) virt_to_bus(scq->next);
1980 ns_write_sram(card, scq->scd, &data, 1);
1981
1982 spin_unlock_irqrestore(&scq->lock, flags);
1983
1984 return 0;
1985 }
1986
1987
1988
1989 static void process_tsq(ns_dev *card)
1990 {
1991 u32 scdi;
1992 scq_info *scq;
1993 ns_tsi *previous = NULL, *one_ahead, *two_ahead;
1994 int serviced_entries; /* flag indicating at least on entry was serviced */
1995
1996 serviced_entries = 0;
1997
1998 if (card->tsq.next == card->tsq.last)
1999 one_ahead = card->tsq.base;
2000 else
2001 one_ahead = card->tsq.next + 1;
2002
2003 if (one_ahead == card->tsq.last)
2004 two_ahead = card->tsq.base;
2005 else
2006 two_ahead = one_ahead + 1;
2007
2008 while (!ns_tsi_isempty(card->tsq.next) || !ns_tsi_isempty(one_ahead) ||
2009 !ns_tsi_isempty(two_ahead))
2010 /* At most two empty, as stated in the 77201 errata */
2011 {
2012 serviced_entries = 1;
2013
2014 /* Skip the one or two possible empty entries */
2015 while (ns_tsi_isempty(card->tsq.next)) {
2016 if (card->tsq.next == card->tsq.last)
2017 card->tsq.next = card->tsq.base;
2018 else
2019 card->tsq.next++;
2020 }
2021
2022 if (!ns_tsi_tmrof(card->tsq.next))
2023 {
2024 scdi = ns_tsi_getscdindex(card->tsq.next);
2025 if (scdi == NS_TSI_SCDISVBR)
2026 scq = card->scq0;
2027 else
2028 {
2029 if (card->scd2vc[scdi] == NULL)
2030 {
2031 printk("nicstar%d: could not find VC from SCD index.\n",
2032 card->index);
2033 ns_tsi_init(card->tsq.next);
2034 return;
2035 }
2036 scq = card->scd2vc[scdi]->scq;
2037 }
2038 drain_scq(card, scq, ns_tsi_getscqpos(card->tsq.next));
2039 scq->full = 0;
2040 wake_up_interruptible(&(scq->scqfull_waitq));
2041 }
2042
2043 ns_tsi_init(card->tsq.next);
2044 previous = card->tsq.next;
2045 if (card->tsq.next == card->tsq.last)
2046 card->tsq.next = card->tsq.base;
2047 else
2048 card->tsq.next++;
2049
2050 if (card->tsq.next == card->tsq.last)
2051 one_ahead = card->tsq.base;
2052 else
2053 one_ahead = card->tsq.next + 1;
2054
2055 if (one_ahead == card->tsq.last)
2056 two_ahead = card->tsq.base;
2057 else
2058 two_ahead = one_ahead + 1;
2059 }
2060
2061 if (serviced_entries) {
2062 writel((((u32) previous) - ((u32) card->tsq.base)),
2063 card->membase + TSQH);
2064 }
2065 }
2066
2067
2068
2069 static void drain_scq(ns_dev *card, scq_info *scq, int pos)
2070 {
2071 struct atm_vcc *vcc;
2072 struct sk_buff *skb;
2073 int i;
2074 unsigned long flags;
2075
2076 XPRINTK("nicstar%d: drain_scq() called, scq at 0x%x, pos %d.\n",
2077 card->index, (u32) scq, pos);
2078 if (pos >= scq->num_entries)
2079 {
2080 printk("nicstar%d: Bad index on drain_scq().\n", card->index);
2081 return;
2082 }
2083
2084 ns_grab_scq_lock(card, scq, flags);
2085 i = (int) (scq->tail - scq->base);
2086 if (++i == scq->num_entries)
2087 i = 0;
2088 while (i != pos)
2089 {
2090 skb = scq->skb[i];
2091 XPRINTK("nicstar%d: freeing skb at 0x%x (index %d).\n",
2092 card->index, (u32) skb, i);
2093 if (skb != NULL)
2094 {
2095 vcc = ATM_SKB(skb)->vcc;
2096 if (vcc && vcc->pop != NULL) {
2097 vcc->pop(vcc, skb);
2098 } else {
2099 dev_kfree_skb_irq(skb);
2100 }
2101 scq->skb[i] = NULL;
2102 }
2103 if (++i == scq->num_entries)
2104 i = 0;
2105 }
2106 scq->tail = scq->base + pos;
2107 spin_unlock_irqrestore(&scq->lock, flags);
2108 }
2109
2110
2111
2112 static void process_rsq(ns_dev *card)
2113 {
2114 ns_rsqe *previous;
2115
2116 if (!ns_rsqe_valid(card->rsq.next))
2117 return;
2118 while (ns_rsqe_valid(card->rsq.next))
2119 {
2120 dequeue_rx(card, card->rsq.next);
2121 ns_rsqe_init(card->rsq.next);
2122 previous = card->rsq.next;
2123 if (card->rsq.next == card->rsq.last)
2124 card->rsq.next = card->rsq.base;
2125 else
2126 card->rsq.next++;
2127 }
2128 writel((((u32) previous) - ((u32) card->rsq.base)),
2129 card->membase + RSQH);
2130 }
2131
2132
2133
2134 static void dequeue_rx(ns_dev *card, ns_rsqe *rsqe)
2135 {
2136 u32 vpi, vci;
2137 vc_map *vc;
2138 struct sk_buff *iovb;
2139 struct iovec *iov;
2140 struct atm_vcc *vcc;
2141 struct sk_buff *skb;
2142 unsigned short aal5_len;
2143 int len;
2144 u32 stat;
2145
2146 stat = readl(card->membase + STAT);
2147 card->sbfqc = ns_stat_sfbqc_get(stat);
2148 card->lbfqc = ns_stat_lfbqc_get(stat);
2149
2150 skb = (struct sk_buff *) le32_to_cpu(rsqe->buffer_handle);
2151 vpi = ns_rsqe_vpi(rsqe);
2152 vci = ns_rsqe_vci(rsqe);
2153 if (vpi >= 1UL << card->vpibits || vci >= 1UL << card->vcibits)
2154 {
2155 printk("nicstar%d: SDU received for out-of-range vc %d.%d.\n",
2156 card->index, vpi, vci);
2157 recycle_rx_buf(card, skb);
2158 return;
2159 }
2160
2161 vc = &(card->vcmap[vpi << card->vcibits | vci]);
2162 if (!vc->rx)
2163 {
2164 RXPRINTK("nicstar%d: SDU received on non-rx vc %d.%d.\n",
2165 card->index, vpi, vci);
2166 recycle_rx_buf(card, skb);
2167 return;
2168 }
2169
2170 vcc = vc->rx_vcc;
2171
2172 if (vcc->qos.aal == ATM_AAL0)
2173 {
2174 struct sk_buff *sb;
2175 unsigned char *cell;
2176 int i;
2177
2178 cell = skb->data;
2179 for (i = ns_rsqe_cellcount(rsqe); i; i--)
2180 {
2181 if ((sb = dev_alloc_skb(NS_SMSKBSIZE)) == NULL)
2182 {
2183 printk("nicstar%d: Can't allocate buffers for aal0.\n",
2184 card->index);
2185 atomic_add(i,&vcc->stats->rx_drop);
2186 break;
2187 }
2188 if (!atm_charge(vcc, sb->truesize))
2189 {
2190 RXPRINTK("nicstar%d: atm_charge() dropped aal0 packets.\n",
2191 card->index);
2192 atomic_add(i-1,&vcc->stats->rx_drop); /* already increased by 1 */
2193 dev_kfree_skb_any(sb);
2194 break;
2195 }
2196 /* Rebuild the header */
2197 *((u32 *) sb->data) = le32_to_cpu(rsqe->word_1) << 4 |
2198 (ns_rsqe_clp(rsqe) ? 0x00000001 : 0x00000000);
2199 if (i == 1 && ns_rsqe_eopdu(rsqe))
2200 *((u32 *) sb->data) |= 0x00000002;
2201 skb_put(sb, NS_AAL0_HEADER);
2202 memcpy(sb->tail, cell, ATM_CELL_PAYLOAD);
2203 skb_put(sb, ATM_CELL_PAYLOAD);
2204 ATM_SKB(sb)->vcc = vcc;
2205 do_gettimeofday(&sb->stamp);
2206 vcc->push(vcc, sb);
2207 atomic_inc(&vcc->stats->rx);
2208 cell += ATM_CELL_PAYLOAD;
2209 }
2210
2211 recycle_rx_buf(card, skb);
2212 return;
2213 }
2214
2215 /* To reach this point, the AAL layer can only be AAL5 */
2216
2217 if ((iovb = vc->rx_iov) == NULL)
2218 {
2219 iovb = skb_dequeue(&(card->iovpool.queue));
2220 if (iovb == NULL) /* No buffers in the queue */
2221 {
2222 iovb = alloc_skb(NS_IOVBUFSIZE, GFP_ATOMIC);
2223 if (iovb == NULL)
2224 {
2225 printk("nicstar%d: Out of iovec buffers.\n", card->index);
2226 atomic_inc(&vcc->stats->rx_drop);
2227 recycle_rx_buf(card, skb);
2228 return;
2229 }
2230 }
2231 else
2232 if (--card->iovpool.count < card->iovnr.min)
2233 {
2234 struct sk_buff *new_iovb;
2235 if ((new_iovb = alloc_skb(NS_IOVBUFSIZE, GFP_ATOMIC)) != NULL)
2236 {
2237 skb_queue_tail(&card->iovpool.queue, new_iovb);
2238 card->iovpool.count++;
2239 }
2240 }
2241 vc->rx_iov = iovb;
2242 NS_SKB(iovb)->iovcnt = 0;
2243 iovb->len = 0;
2244 iovb->tail = iovb->data = iovb->head;
2245 NS_SKB(iovb)->vcc = vcc;
2246 /* IMPORTANT: a pointer to the sk_buff containing the small or large
2247 buffer is stored as iovec base, NOT a pointer to the
2248 small or large buffer itself. */
2249 }
2250 else if (NS_SKB(iovb)->iovcnt >= NS_MAX_IOVECS)
2251 {
2252 printk("nicstar%d: received too big AAL5 SDU.\n", card->index);
2253 atomic_inc(&vcc->stats->rx_err);
2254 recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data, NS_MAX_IOVECS);
2255 NS_SKB(iovb)->iovcnt = 0;
2256 iovb->len = 0;
2257 iovb->tail = iovb->data = iovb->head;
2258 NS_SKB(iovb)->vcc = vcc;
2259 }
2260 iov = &((struct iovec *) iovb->data)[NS_SKB(iovb)->iovcnt++];
2261 iov->iov_base = (void *) skb;
2262 iov->iov_len = ns_rsqe_cellcount(rsqe) * 48;
2263 iovb->len += iov->iov_len;
2264
2265 if (NS_SKB(iovb)->iovcnt == 1)
2266 {
2267 if (skb->list != &card->sbpool.queue)
2268 {
2269 printk("nicstar%d: Expected a small buffer, and this is not one.\n",
2270 card->index);
2271 which_list(card, skb);
2272 atomic_inc(&vcc->stats->rx_err);
2273 recycle_rx_buf(card, skb);
2274 vc->rx_iov = NULL;
2275 recycle_iov_buf(card, iovb);
2276 return;
2277 }
2278 }
2279 else /* NS_SKB(iovb)->iovcnt >= 2 */
2280 {
2281 if (skb->list != &card->lbpool.queue)
2282 {
2283 printk("nicstar%d: Expected a large buffer, and this is not one.\n",
2284 card->index);
2285 which_list(card, skb);
2286 atomic_inc(&vcc->stats->rx_err);
2287 recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
2288 NS_SKB(iovb)->iovcnt);
2289 vc->rx_iov = NULL;
2290 recycle_iov_buf(card, iovb);
2291 return;
2292 }
2293 }
2294
2295 if (ns_rsqe_eopdu(rsqe))
2296 {
2297 /* This works correctly regardless of the endianness of the host */
2298 unsigned char *L1L2 = (unsigned char *)((u32)skb->data +
2299 iov->iov_len - 6);
2300 aal5_len = L1L2[0] << 8 | L1L2[1];
2301 len = (aal5_len == 0x0000) ? 0x10000 : aal5_len;
2302 if (ns_rsqe_crcerr(rsqe) ||
2303 len + 8 > iovb->len || len + (47 + 8) < iovb->len)
2304 {
2305 printk("nicstar%d: AAL5 CRC error", card->index);
2306 if (len + 8 > iovb->len || len + (47 + 8) < iovb->len)
2307 printk(" - PDU size mismatch.\n");
2308 else
2309 printk(".\n");
2310 atomic_inc(&vcc->stats->rx_err);
2311 recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
2312 NS_SKB(iovb)->iovcnt);
2313 vc->rx_iov = NULL;
2314 recycle_iov_buf(card, iovb);
2315 return;
2316 }
2317
2318 /* By this point we (hopefully) have a complete SDU without errors. */
2319
2320 if (NS_SKB(iovb)->iovcnt == 1) /* Just a small buffer */
2321 {
2322 /* skb points to a small buffer */
2323 if (!atm_charge(vcc, skb->truesize))
2324 {
2325 push_rxbufs(card, BUF_SM, (u32) skb, (u32) virt_to_bus(skb->data),
2326 0, 0);
2327 atomic_inc(&vcc->stats->rx_drop);
2328 }
2329 else
2330 {
2331 skb_put(skb, len);
2332 dequeue_sm_buf(card, skb);
2333 #ifdef NS_USE_DESTRUCTORS
2334 skb->destructor = ns_sb_destructor;
2335 #endif /* NS_USE_DESTRUCTORS */
2336 ATM_SKB(skb)->vcc = vcc;
2337 do_gettimeofday(&skb->stamp);
2338 vcc->push(vcc, skb);
2339 atomic_inc(&vcc->stats->rx);
2340 }
2341 }
2342 else if (NS_SKB(iovb)->iovcnt == 2) /* One small plus one large buffer */
2343 {
2344 struct sk_buff *sb;
2345
2346 sb = (struct sk_buff *) (iov - 1)->iov_base;
2347 /* skb points to a large buffer */
2348
2349 if (len <= NS_SMBUFSIZE)
2350 {
2351 if (!atm_charge(vcc, sb->truesize))
2352 {
2353 push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data),
2354 0, 0);
2355 atomic_inc(&vcc->stats->rx_drop);
2356 }
2357 else
2358 {
2359 skb_put(sb, len);
2360 dequeue_sm_buf(card, sb);
2361 #ifdef NS_USE_DESTRUCTORS
2362 sb->destructor = ns_sb_destructor;
2363 #endif /* NS_USE_DESTRUCTORS */
2364 ATM_SKB(sb)->vcc = vcc;
2365 do_gettimeofday(&sb->stamp);
2366 vcc->push(vcc, sb);
2367 atomic_inc(&vcc->stats->rx);
2368 }
2369
2370 push_rxbufs(card, BUF_LG, (u32) skb,
2371 (u32) virt_to_bus(skb->data), 0, 0);
2372
2373 }
2374 else /* len > NS_SMBUFSIZE, the usual case */
2375 {
2376 if (!atm_charge(vcc, skb->truesize))
2377 {
2378 push_rxbufs(card, BUF_LG, (u32) skb,
2379 (u32) virt_to_bus(skb->data), 0, 0);
2380 atomic_inc(&vcc->stats->rx_drop);
2381 }
2382 else
2383 {
2384 dequeue_lg_buf(card, skb);
2385 #ifdef NS_USE_DESTRUCTORS
2386 skb->destructor = ns_lb_destructor;
2387 #endif /* NS_USE_DESTRUCTORS */
2388 skb_push(skb, NS_SMBUFSIZE);
2389 memcpy(skb->data, sb->data, NS_SMBUFSIZE);
2390 skb_put(skb, len - NS_SMBUFSIZE);
2391 ATM_SKB(skb)->vcc = vcc;
2392 do_gettimeofday(&skb->stamp);
2393 vcc->push(vcc, skb);
2394 atomic_inc(&vcc->stats->rx);
2395 }
2396
2397 push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data),
2398 0, 0);
2399
2400 }
2401
2402 }
2403 else /* Must push a huge buffer */
2404 {
2405 struct sk_buff *hb, *sb, *lb;
2406 int remaining, tocopy;
2407 int j;
2408
2409 hb = skb_dequeue(&(card->hbpool.queue));
2410 if (hb == NULL) /* No buffers in the queue */
2411 {
2412
2413 hb = dev_alloc_skb(NS_HBUFSIZE);
2414 if (hb == NULL)
2415 {
2416 printk("nicstar%d: Out of huge buffers.\n", card->index);
2417 atomic_inc(&vcc->stats->rx_drop);
2418 recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
2419 NS_SKB(iovb)->iovcnt);
2420 vc->rx_iov = NULL;
2421 recycle_iov_buf(card, iovb);
2422 return;
2423 }
2424 else if (card->hbpool.count < card->hbnr.min)
2425 {
2426 struct sk_buff *new_hb;
2427 if ((new_hb = dev_alloc_skb(NS_HBUFSIZE)) != NULL)
2428 {
2429 skb_queue_tail(&card->hbpool.queue, new_hb);
2430 card->hbpool.count++;
2431 }
2432 }
2433 }
2434 else
2435 if (--card->hbpool.count < card->hbnr.min)
2436 {
2437 struct sk_buff *new_hb;
2438 if ((new_hb = dev_alloc_skb(NS_HBUFSIZE)) != NULL)
2439 {
2440 skb_queue_tail(&card->hbpool.queue, new_hb);
2441 card->hbpool.count++;
2442 }
2443 if (card->hbpool.count < card->hbnr.min)
2444 {
2445 if ((new_hb = dev_alloc_skb(NS_HBUFSIZE)) != NULL)
2446 {
2447 skb_queue_tail(&card->hbpool.queue, new_hb);
2448 card->hbpool.count++;
2449 }
2450 }
2451 }
2452
2453 iov = (struct iovec *) iovb->data;
2454
2455 if (!atm_charge(vcc, hb->truesize))
2456 {
2457 recycle_iovec_rx_bufs(card, iov, NS_SKB(iovb)->iovcnt);
2458 if (card->hbpool.count < card->hbnr.max)
2459 {
2460 skb_queue_tail(&card->hbpool.queue, hb);
2461 card->hbpool.count++;
2462 }
2463 else
2464 dev_kfree_skb_any(hb);
2465 atomic_inc(&vcc->stats->rx_drop);
2466 }
2467 else
2468 {
2469 /* Copy the small buffer to the huge buffer */
2470 sb = (struct sk_buff *) iov->iov_base;
2471 memcpy(hb->data, sb->data, iov->iov_len);
2472 skb_put(hb, iov->iov_len);
2473 remaining = len - iov->iov_len;
2474 iov++;
2475 /* Free the small buffer */
2476 push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data),
2477 0, 0);
2478
2479 /* Copy all large buffers to the huge buffer and free them */
2480 for (j = 1; j < NS_SKB(iovb)->iovcnt; j++)
2481 {
2482 lb = (struct sk_buff *) iov->iov_base;
2483 tocopy = min_t(int, remaining, iov->iov_len);
2484 memcpy(hb->tail, lb->data, tocopy);
2485 skb_put(hb, tocopy);
2486 iov++;
2487 remaining -= tocopy;
2488 push_rxbufs(card, BUF_LG, (u32) lb,
2489 (u32) virt_to_bus(lb->data), 0, 0);
2490 }
2491 #ifdef EXTRA_DEBUG
2492 if (remaining != 0 || hb->len != len)
2493 printk("nicstar%d: Huge buffer len mismatch.\n", card->index);
2494 #endif /* EXTRA_DEBUG */
2495 ATM_SKB(hb)->vcc = vcc;
2496 #ifdef NS_USE_DESTRUCTORS
2497 hb->destructor = ns_hb_destructor;
2498 #endif /* NS_USE_DESTRUCTORS */
2499 do_gettimeofday(&hb->stamp);
2500 vcc->push(vcc, hb);
2501 atomic_inc(&vcc->stats->rx);
2502 }
2503 }
2504
2505 vc->rx_iov = NULL;
2506 recycle_iov_buf(card, iovb);
2507 }
2508
2509 }
2510
2511
2512
2513 #ifdef NS_USE_DESTRUCTORS
2514
2515 static void ns_sb_destructor(struct sk_buff *sb)
2516 {
2517 ns_dev *card;
2518 u32 stat;
2519
2520 card = (ns_dev *) ATM_SKB(sb)->vcc->dev->dev_data;
2521 stat = readl(card->membase + STAT);
2522 card->sbfqc = ns_stat_sfbqc_get(stat);
2523 card->lbfqc = ns_stat_lfbqc_get(stat);
2524
2525 do
2526 {
2527 sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL);
2528 if (sb == NULL)
2529 break;
2530 skb_queue_tail(&card->sbpool.queue, sb);
2531 skb_reserve(sb, NS_AAL0_HEADER);
2532 push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
2533 } while (card->sbfqc < card->sbnr.min);
2534 }
2535
2536
2537
2538 static void ns_lb_destructor(struct sk_buff *lb)
2539 {
2540 ns_dev *card;
2541 u32 stat;
2542
2543 card = (ns_dev *) ATM_SKB(lb)->vcc->dev->dev_data;
2544 stat = readl(card->membase + STAT);
2545 card->sbfqc = ns_stat_sfbqc_get(stat);
2546 card->lbfqc = ns_stat_lfbqc_get(stat);
2547
2548 do
2549 {
2550 lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL);
2551 if (lb == NULL)
2552 break;
2553 skb_queue_tail(&card->lbpool.queue, lb);
2554 skb_reserve(lb, NS_SMBUFSIZE);
2555 push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
2556 } while (card->lbfqc < card->lbnr.min);
2557 }
2558
2559
2560
2561 static void ns_hb_destructor(struct sk_buff *hb)
2562 {
2563 ns_dev *card;
2564
2565 card = (ns_dev *) ATM_SKB(hb)->vcc->dev->dev_data;
2566
2567 while (card->hbpool.count < card->hbnr.init)
2568 {
2569 hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL);
2570 if (hb == NULL)
2571 break;
2572 skb_queue_tail(&card->hbpool.queue, hb);
2573 card->hbpool.count++;
2574 }
2575 }
2576
2577 #endif /* NS_USE_DESTRUCTORS */
2578
2579
2580
2581 static void recycle_rx_buf(ns_dev *card, struct sk_buff *skb)
2582 {
2583 if (skb->list == &card->sbpool.queue)
2584 push_rxbufs(card, BUF_SM, (u32) skb, (u32) virt_to_bus(skb->data), 0, 0);
2585 else if (skb->list == &card->lbpool.queue)
2586 push_rxbufs(card, BUF_LG, (u32) skb, (u32) virt_to_bus(skb->data), 0, 0);
2587 else
2588 {
2589 printk("nicstar%d: What kind of rx buffer is this?\n", card->index);
2590 dev_kfree_skb_any(skb);
2591 }
2592 }
2593
2594
2595
2596 static void recycle_iovec_rx_bufs(ns_dev *card, struct iovec *iov, int count)
2597 {
2598 struct sk_buff *skb;
2599
2600 for (; count > 0; count--)
2601 {
2602 skb = (struct sk_buff *) (iov++)->iov_base;
2603 if (skb->list == &card->sbpool.queue)
2604 push_rxbufs(card, BUF_SM, (u32) skb, (u32) virt_to_bus(skb->data),
2605 0, 0);
2606 else if (skb->list == &card->lbpool.queue)
2607 push_rxbufs(card, BUF_LG, (u32) skb, (u32) virt_to_bus(skb->data),
2608 0, 0);
2609 else
2610 {
2611 printk("nicstar%d: What kind of rx buffer is this?\n", card->index);
2612 dev_kfree_skb_any(skb);
2613 }
2614 }
2615 }
2616
2617
2618
2619 static void recycle_iov_buf(ns_dev *card, struct sk_buff *iovb)
2620 {
2621 if (card->iovpool.count < card->iovnr.max)
2622 {
2623 skb_queue_tail(&card->iovpool.queue, iovb);
2624 card->iovpool.count++;
2625 }
2626 else
2627 dev_kfree_skb_any(iovb);
2628 }
2629
2630
2631
2632 static void dequeue_sm_buf(ns_dev *card, struct sk_buff *sb)
2633 {
2634 skb_unlink(sb);
2635 #ifdef NS_USE_DESTRUCTORS
2636 if (card->sbfqc < card->sbnr.min)
2637 #else
2638 if (card->sbfqc < card->sbnr.init)
2639 {
2640 struct sk_buff *new_sb;
2641 if ((new_sb = dev_alloc_skb(NS_SMSKBSIZE)) != NULL)
2642 {
2643 skb_queue_tail(&card->sbpool.queue, new_sb);
2644 skb_reserve(new_sb, NS_AAL0_HEADER);
2645 push_rxbufs(card, BUF_SM, (u32) new_sb,
2646 (u32) virt_to_bus(new_sb->data), 0, 0);
2647 }
2648 }
2649 if (card->sbfqc < card->sbnr.init)
2650 #endif /* NS_USE_DESTRUCTORS */
2651 {
2652 struct sk_buff *new_sb;
2653 if ((new_sb = dev_alloc_skb(NS_SMSKBSIZE)) != NULL)
2654 {
2655 skb_queue_tail(&card->sbpool.queue, new_sb);
2656 skb_reserve(new_sb, NS_AAL0_HEADER);
2657 push_rxbufs(card, BUF_SM, (u32) new_sb,
2658 (u32) virt_to_bus(new_sb->data), 0, 0);
2659 }
2660 }
2661 }
2662
2663
2664
2665 static void dequeue_lg_buf(ns_dev *card, struct sk_buff *lb)
2666 {
2667 skb_unlink(lb);
2668 #ifdef NS_USE_DESTRUCTORS
2669 if (card->lbfqc < card->lbnr.min)
2670 #else
2671 if (card->lbfqc < card->lbnr.init)
2672 {
2673 struct sk_buff *new_lb;
2674 if ((new_lb = dev_alloc_skb(NS_LGSKBSIZE)) != NULL)
2675 {
2676 skb_queue_tail(&card->lbpool.queue, new_lb);
2677 skb_reserve(new_lb, NS_SMBUFSIZE);
2678 push_rxbufs(card, BUF_LG, (u32) new_lb,
2679 (u32) virt_to_bus(new_lb->data), 0, 0);
2680 }
2681 }
2682 if (card->lbfqc < card->lbnr.init)
2683 #endif /* NS_USE_DESTRUCTORS */
2684 {
2685 struct sk_buff *new_lb;
2686 if ((new_lb = dev_alloc_skb(NS_LGSKBSIZE)) != NULL)
2687 {
2688 skb_queue_tail(&card->lbpool.queue, new_lb);
2689 skb_reserve(new_lb, NS_SMBUFSIZE);
2690 push_rxbufs(card, BUF_LG, (u32) new_lb,
2691 (u32) virt_to_bus(new_lb->data), 0, 0);
2692 }
2693 }
2694 }
2695
2696
2697
2698 static int ns_proc_read(struct atm_dev *dev, loff_t *pos, char *page)
2699 {
2700 u32 stat;
2701 ns_dev *card;
2702 int left;
2703
2704 left = (int) *pos;
2705 card = (ns_dev *) dev->dev_data;
2706 stat = readl(card->membase + STAT);
2707 if (!left--)
2708 return sprintf(page, "Pool count min init max \n");
2709 if (!left--)
2710 return sprintf(page, "Small %5d %5d %5d %5d \n",
2711 ns_stat_sfbqc_get(stat), card->sbnr.min, card->sbnr.init,
2712 card->sbnr.max);
2713 if (!left--)
2714 return sprintf(page, "Large %5d %5d %5d %5d \n",
2715 ns_stat_lfbqc_get(stat), card->lbnr.min, card->lbnr.init,
2716 card->lbnr.max);
2717 if (!left--)
2718 return sprintf(page, "Huge %5d %5d %5d %5d \n", card->hbpool.count,
2719 card->hbnr.min, card->hbnr.init, card->hbnr.max);
2720 if (!left--)
2721 return sprintf(page, "Iovec %5d %5d %5d %5d \n", card->iovpool.count,
2722 card->iovnr.min, card->iovnr.init, card->iovnr.max);
2723 if (!left--)
2724 {
2725 int retval;
2726 retval = sprintf(page, "Interrupt counter: %u \n", card->intcnt);
2727 card->intcnt = 0;
2728 return retval;
2729 }
2730 #if 0
2731 /* Dump 25.6 Mbps PHY registers */
2732 /* Now there's a 25.6 Mbps PHY driver this code isn't needed. I left it
2733 here just in case it's needed for debugging. */
2734 if (card->max_pcr == ATM_25_PCR && !left--)
2735 {
2736 u32 phy_regs[4];
2737 u32 i;
2738
2739 for (i = 0; i < 4; i++)
2740 {
2741 while (CMD_BUSY(card));
2742 writel(NS_CMD_READ_UTILITY | 0x00000200 | i, card->membase + CMD);
2743 while (CMD_BUSY(card));
2744 phy_regs[i] = readl(card->membase + DR0) & 0x000000FF;
2745 }
2746
2747 return sprintf(page, "PHY regs: 0x%02X 0x%02X 0x%02X 0x%02X \n",
2748 phy_regs[0], phy_regs[1], phy_regs[2], phy_regs[3]);
2749 }
2750 #endif /* 0 - Dump 25.6 Mbps PHY registers */
2751 #if 0
2752 /* Dump TST */
2753 if (left-- < NS_TST_NUM_ENTRIES)
2754 {
2755 if (card->tste2vc[left + 1] == NULL)
2756 return sprintf(page, "%5d - VBR/UBR \n", left + 1);
2757 else
2758 return sprintf(page, "%5d - %d %d \n", left + 1,
2759 card->tste2vc[left + 1]->tx_vcc->vpi,
2760 card->tste2vc[left + 1]->tx_vcc->vci);
2761 }
2762 #endif /* 0 */
2763 return 0;
2764 }
2765
2766
2767
2768 static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
2769 {
2770 ns_dev *card;
2771 pool_levels pl;
2772 int btype;
2773 unsigned long flags;
2774
2775 card = dev->dev_data;
2776 switch (cmd)
2777 {
2778 case NS_GETPSTAT:
2779 if (get_user(pl.buftype, &((pool_levels __user *) arg)->buftype))
2780 return -EFAULT;
2781 switch (pl.buftype)
2782 {
2783 case NS_BUFTYPE_SMALL:
2784 pl.count = ns_stat_sfbqc_get(readl(card->membase + STAT));
2785 pl.level.min = card->sbnr.min;
2786 pl.level.init = card->sbnr.init;
2787 pl.level.max = card->sbnr.max;
2788 break;
2789
2790 case NS_BUFTYPE_LARGE:
2791 pl.count = ns_stat_lfbqc_get(readl(card->membase + STAT));
2792 pl.level.min = card->lbnr.min;
2793 pl.level.init = card->lbnr.init;
2794 pl.level.max = card->lbnr.max;
2795 break;
2796
2797 case NS_BUFTYPE_HUGE:
2798 pl.count = card->hbpool.count;
2799 pl.level.min = card->hbnr.min;
2800 pl.level.init = card->hbnr.init;
2801 pl.level.max = card->hbnr.max;
2802 break;
2803
2804 case NS_BUFTYPE_IOVEC:
2805 pl.count = card->iovpool.count;
2806 pl.level.min = card->iovnr.min;
2807 pl.level.init = card->iovnr.init;
2808 pl.level.max = card->iovnr.max;
2809 break;
2810
2811 default:
2812 return -ENOIOCTLCMD;
2813
2814 }
2815 if (!copy_to_user((pool_levels __user *) arg, &pl, sizeof(pl)))
2816 return (sizeof(pl));
2817 else
2818 return -EFAULT;
2819
2820 case NS_SETBUFLEV:
2821 if (!capable(CAP_NET_ADMIN))
2822 return -EPERM;
2823 if (copy_from_user(&pl, (pool_levels __user *) arg, sizeof(pl)))
2824 return -EFAULT;
2825 if (pl.level.min >= pl.level.init || pl.level.init >= pl.level.max)
2826 return -EINVAL;
2827 if (pl.level.min == 0)
2828 return -EINVAL;
2829 switch (pl.buftype)
2830 {
2831 case NS_BUFTYPE_SMALL:
2832 if (pl.level.max > TOP_SB)
2833 return -EINVAL;
2834 card->sbnr.min = pl.level.min;
2835 card->sbnr.init = pl.level.init;
2836 card->sbnr.max = pl.level.max;
2837 break;
2838
2839 case NS_BUFTYPE_LARGE:
2840 if (pl.level.max > TOP_LB)
2841 return -EINVAL;
2842 card->lbnr.min = pl.level.min;
2843 card->lbnr.init = pl.level.init;
2844 card->lbnr.max = pl.level.max;
2845 break;
2846
2847 case NS_BUFTYPE_HUGE:
2848 if (pl.level.max > TOP_HB)
2849 return -EINVAL;
2850 card->hbnr.min = pl.level.min;
2851 card->hbnr.init = pl.level.init;
2852 card->hbnr.max = pl.level.max;
2853 break;
2854
2855 case NS_BUFTYPE_IOVEC:
2856 if (pl.level.max > TOP_IOVB)
2857 return -EINVAL;
2858 card->iovnr.min = pl.level.min;
2859 card->iovnr.init = pl.level.init;
2860 card->iovnr.max = pl.level.max;
2861 break;
2862
2863 default:
2864 return -EINVAL;
2865
2866 }
2867 return 0;
2868
2869 case NS_ADJBUFLEV:
2870 if (!capable(CAP_NET_ADMIN))
2871 return -EPERM;
2872 btype = (int) arg; /* an int is the same size as a pointer */
2873 switch (btype)
2874 {
2875 case NS_BUFTYPE_SMALL:
2876 while (card->sbfqc < card->sbnr.init)
2877 {
2878 struct sk_buff *sb;
2879
2880 sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL);
2881 if (sb == NULL)
2882 return -ENOMEM;
2883 skb_queue_tail(&card->sbpool.queue, sb);
2884 skb_reserve(sb, NS_AAL0_HEADER);
2885 push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
2886 }
2887 break;
2888
2889 case NS_BUFTYPE_LARGE:
2890 while (card->lbfqc < card->lbnr.init)
2891 {
2892 struct sk_buff *lb;
2893
2894 lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL);
2895 if (lb == NULL)
2896 return -ENOMEM;
2897 skb_queue_tail(&card->lbpool.queue, lb);
2898 skb_reserve(lb, NS_SMBUFSIZE);
2899 push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
2900 }
2901 break;
2902
2903 case NS_BUFTYPE_HUGE:
2904 while (card->hbpool.count > card->hbnr.init)
2905 {
2906 struct sk_buff *hb;
2907
2908 ns_grab_int_lock(card, flags);
2909 hb = skb_dequeue(&card->hbpool.queue);
2910 card->hbpool.count--;
2911 spin_unlock_irqrestore(&card->int_lock, flags);
2912 if (hb == NULL)
2913 printk("nicstar%d: huge buffer count inconsistent.\n",
2914 card->index);
2915 else
2916 dev_kfree_skb_any(hb);
2917
2918 }
2919 while (card->hbpool.count < card->hbnr.init)
2920 {
2921 struct sk_buff *hb;
2922
2923 hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL);
2924 if (hb == NULL)
2925 return -ENOMEM;
2926 ns_grab_int_lock(card, flags);
2927 skb_queue_tail(&card->hbpool.queue, hb);
2928 card->hbpool.count++;
2929 spin_unlock_irqrestore(&card->int_lock, flags);
2930 }
2931 break;
2932
2933 case NS_BUFTYPE_IOVEC:
2934 while (card->iovpool.count > card->iovnr.init)
2935 {
2936 struct sk_buff *iovb;
2937
2938 ns_grab_int_lock(card, flags);
2939 iovb = skb_dequeue(&card->iovpool.queue);
2940 card->iovpool.count--;
2941 spin_unlock_irqrestore(&card->int_lock, flags);
2942 if (iovb == NULL)
2943 printk("nicstar%d: iovec buffer count inconsistent.\n",
2944 card->index);
2945 else
2946 dev_kfree_skb_any(iovb);
2947
2948 }
2949 while (card->iovpool.count < card->iovnr.init)
2950 {
2951 struct sk_buff *iovb;
2952
2953 iovb = alloc_skb(NS_IOVBUFSIZE, GFP_KERNEL);
2954 if (iovb == NULL)
2955 return -ENOMEM;
2956 ns_grab_int_lock(card, flags);
2957 skb_queue_tail(&card->iovpool.queue, iovb);
2958 card->iovpool.count++;
2959 spin_unlock_irqrestore(&card->int_lock, flags);
2960 }
2961 break;
2962
2963 default:
2964 return -EINVAL;
2965
2966 }
2967 return 0;
2968
2969 default:
2970 if (dev->phy && dev->phy->ioctl) {
2971 return dev->phy->ioctl(dev, cmd, arg);
2972 }
2973 else {
2974 printk("nicstar%d: %s == NULL \n", card->index,
2975 dev->phy ? "dev->phy->ioctl" : "dev->phy");
2976 return -ENOIOCTLCMD;
2977 }
2978 }
2979 }
2980
2981
2982
2983 static void which_list(ns_dev *card, struct sk_buff *skb)
2984 {
2985 printk("It's a %s buffer.\n", skb->list == &card->sbpool.queue ?
2986 "small" : skb->list == &card->lbpool.queue ? "large" :
2987 skb->list == &card->hbpool.queue ? "huge" :
2988 skb->list == &card->iovpool.queue ? "iovec" : "unknown");
2989 }
2990
2991
2992
2993 static void ns_poll(unsigned long arg)
2994 {
2995 int i;
2996 ns_dev *card;
2997 unsigned long flags;
2998 u32 stat_r, stat_w;
2999
3000 PRINTK("nicstar: Entering ns_poll().\n");
3001 for (i = 0; i < num_cards; i++)
3002 {
3003 card = cards[i];
3004 if (spin_is_locked(&card->int_lock)) {
3005 /* Probably it isn't worth spinning */
3006 continue;
3007 }
3008 ns_grab_int_lock(card, flags);
3009
3010 stat_w = 0;
3011 stat_r = readl(card->membase + STAT);
3012 if (stat_r & NS_STAT_TSIF)
3013 stat_w |= NS_STAT_TSIF;
3014 if (stat_r & NS_STAT_EOPDU)
3015 stat_w |= NS_STAT_EOPDU;
3016
3017 process_tsq(card);
3018 process_rsq(card);
3019
3020 writel(stat_w, card->membase + STAT);
3021 spin_unlock_irqrestore(&card->int_lock, flags);
3022 }
3023 mod_timer(&ns_timer, jiffies + NS_POLL_PERIOD);
3024 PRINTK("nicstar: Leaving ns_poll().\n");
3025 }
3026
3027
3028
3029 static int ns_parse_mac(char *mac, unsigned char *esi)
3030 {
3031 int i, j;
3032 short byte1, byte0;
3033
3034 if (mac == NULL || esi == NULL)
3035 return -1;
3036 j = 0;
3037 for (i = 0; i < 6; i++)
3038 {
3039 if ((byte1 = ns_h2i(mac[j++])) < 0)
3040 return -1;
3041 if ((byte0 = ns_h2i(mac[j++])) < 0)
3042 return -1;
3043 esi[i] = (unsigned char) (byte1 * 16 + byte0);
3044 if (i < 5)
3045 {
3046 if (mac[j++] != ':')
3047 return -1;
3048 }
3049 }
3050 return 0;
3051 }
3052
3053
3054
3055 static short ns_h2i(char c)
3056 {
3057 if (c >= '0' && c <= '9')
3058 return (short) (c - '0');
3059 if (c >= 'A' && c <= 'F')
3060 return (short) (c - 'A' + 10);
3061 if (c >= 'a' && c <= 'f')
3062 return (short) (c - 'a' + 10);
3063 return -1;
3064 }
3065
3066
3067
3068 static void ns_phy_put(struct atm_dev *dev, unsigned char value,
3069 unsigned long addr)
3070 {
3071 ns_dev *card;
3072 unsigned long flags;
3073
3074 card = dev->dev_data;
3075 ns_grab_res_lock(card, flags);
3076 while(CMD_BUSY(card));
3077 writel((unsigned long) value, card->membase + DR0);
3078 writel(NS_CMD_WRITE_UTILITY | 0x00000200 | (addr & 0x000000FF),
3079 card->membase + CMD);
3080 spin_unlock_irqrestore(&card->res_lock, flags);
3081 }
3082
3083
3084
3085 static unsigned char ns_phy_get(struct atm_dev *dev, unsigned long addr)
3086 {
3087 ns_dev *card;
3088 unsigned long flags;
3089 unsigned long data;
3090
3091 card = dev->dev_data;
3092 ns_grab_res_lock(card, flags);
3093 while(CMD_BUSY(card));
3094 writel(NS_CMD_READ_UTILITY | 0x00000200 | (addr & 0x000000FF),
3095 card->membase + CMD);
3096 while(CMD_BUSY(card));
3097 data = readl(card->membase + DR0) & 0x000000FF;
3098 spin_unlock_irqrestore(&card->res_lock, flags);
3099 return (unsigned char) data;
3100 }
3101
3102
3103
3104 module_init(nicstar_init);
3105 module_exit(nicstar_cleanup);
linux-next