?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
KVM: MMU: Adjust pte accessors to explicitly indicate guest or shadow pte
[linux/fpc-iii.git] / drivers / atm / he.c
blob2de64065aa1b203b113f62e8428319f140b0b382
1 /*
2
3 he.c
4
5 ForeRunnerHE ATM Adapter driver for ATM on Linux
6 Copyright (C) 1999-2001 Naval Research Laboratory
7
8 This library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Lesser General Public
10 License as published by the Free Software Foundation; either
11 version 2.1 of the License, or (at your option) any later version.
12
13 This library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public
19 License along with this library; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
22 */
23
24 /*
25
26 he.c
27
28 ForeRunnerHE ATM Adapter driver for ATM on Linux
29 Copyright (C) 1999-2001 Naval Research Laboratory
30
31 Permission to use, copy, modify and distribute this software and its
32 documentation is hereby granted, provided that both the copyright
33 notice and this permission notice appear in all copies of the software,
34 derivative works or modified versions, and any portions thereof, and
35 that both notices appear in supporting documentation.
36
37 NRL ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION AND
38 DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER
39 RESULTING FROM THE USE OF THIS SOFTWARE.
40
41 This driver was written using the "Programmer's Reference Manual for
42 ForeRunnerHE(tm)", MANU0361-01 - Rev. A, 08/21/98.
43
44 AUTHORS:
45 chas williams <chas@cmf.nrl.navy.mil>
46 eric kinzie <ekinzie@cmf.nrl.navy.mil>
47
48 NOTES:
49 4096 supported 'connections'
50 group 0 is used for all traffic
51 interrupt queue 0 is used for all interrupts
52 aal0 support (based on work from ulrich.u.muller@nokia.com)
53
54 */
55
56 #include <linux/module.h>
57 #include <linux/kernel.h>
58 #include <linux/skbuff.h>
59 #include <linux/pci.h>
60 #include <linux/errno.h>
61 #include <linux/types.h>
62 #include <linux/string.h>
63 #include <linux/delay.h>
64 #include <linux/init.h>
65 #include <linux/mm.h>
66 #include <linux/sched.h>
67 #include <linux/timer.h>
68 #include <linux/interrupt.h>
69 #include <linux/dma-mapping.h>
70 #include <asm/io.h>
71 #include <asm/byteorder.h>
72 #include <asm/uaccess.h>
73
74 #include <linux/atmdev.h>
75 #include <linux/atm.h>
76 #include <linux/sonet.h>
77
78 #undef USE_SCATTERGATHER
79 #undef USE_CHECKSUM_HW /* still confused about this */
80 /* #undef HE_DEBUG */
81
82 #include "he.h"
83 #include "suni.h"
84 #include <linux/atm_he.h>
85
86 #define hprintk(fmt,args...) printk(KERN_ERR DEV_LABEL "%d: " fmt, he_dev->number , ##args)
87
88 #ifdef HE_DEBUG
89 #define HPRINTK(fmt,args...) printk(KERN_DEBUG DEV_LABEL "%d: " fmt, he_dev->number , ##args)
90 #else /* !HE_DEBUG */
91 #define HPRINTK(fmt,args...) do { } while (0)
92 #endif /* HE_DEBUG */
93
94 /* declarations */
95
96 static int he_open(struct atm_vcc *vcc);
97 static void he_close(struct atm_vcc *vcc);
98 static int he_send(struct atm_vcc *vcc, struct sk_buff *skb);
99 static int he_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg);
100 static irqreturn_t he_irq_handler(int irq, void *dev_id);
101 static void he_tasklet(unsigned long data);
102 static int he_proc_read(struct atm_dev *dev,loff_t *pos,char *page);
103 static int he_start(struct atm_dev *dev);
104 static void he_stop(struct he_dev *dev);
105 static void he_phy_put(struct atm_dev *, unsigned char, unsigned long);
106 static unsigned char he_phy_get(struct atm_dev *, unsigned long);
107
108 static u8 read_prom_byte(struct he_dev *he_dev, int addr);
109
110 /* globals */
111
112 static struct he_dev *he_devs;
113 static int disable64;
114 static short nvpibits = -1;
115 static short nvcibits = -1;
116 static short rx_skb_reserve = 16;
117 static int irq_coalesce = 1;
118 static int sdh = 0;
119
120 /* Read from EEPROM = 0000 0011b */
121 static unsigned int readtab[] = {
122 CS_HIGH | CLK_HIGH,
123 CS_LOW | CLK_LOW,
124 CLK_HIGH, /* 0 */
125 CLK_LOW,
126 CLK_HIGH, /* 0 */
127 CLK_LOW,
128 CLK_HIGH, /* 0 */
129 CLK_LOW,
130 CLK_HIGH, /* 0 */
131 CLK_LOW,
132 CLK_HIGH, /* 0 */
133 CLK_LOW,
134 CLK_HIGH, /* 0 */
135 CLK_LOW | SI_HIGH,
136 CLK_HIGH | SI_HIGH, /* 1 */
137 CLK_LOW | SI_HIGH,
138 CLK_HIGH | SI_HIGH /* 1 */
139 };
140
141 /* Clock to read from/write to the EEPROM */
142 static unsigned int clocktab[] = {
143 CLK_LOW,
144 CLK_HIGH,
145 CLK_LOW,
146 CLK_HIGH,
147 CLK_LOW,
148 CLK_HIGH,
149 CLK_LOW,
150 CLK_HIGH,
151 CLK_LOW,
152 CLK_HIGH,
153 CLK_LOW,
154 CLK_HIGH,
155 CLK_LOW,
156 CLK_HIGH,
157 CLK_LOW,
158 CLK_HIGH,
159 CLK_LOW
160 };
161
162 static struct atmdev_ops he_ops =
163 {
164 .open = he_open,
165 .close = he_close,
166 .ioctl = he_ioctl,
167 .send = he_send,
168 .phy_put = he_phy_put,
169 .phy_get = he_phy_get,
170 .proc_read = he_proc_read,
171 .owner = THIS_MODULE
172 };
173
174 #define he_writel(dev, val, reg) do { writel(val, (dev)->membase + (reg)); wmb(); } while (0)
175 #define he_readl(dev, reg) readl((dev)->membase + (reg))
176
177 /* section 2.12 connection memory access */
178
179 static __inline__ void
180 he_writel_internal(struct he_dev *he_dev, unsigned val, unsigned addr,
181 unsigned flags)
182 {
183 he_writel(he_dev, val, CON_DAT);
184 (void) he_readl(he_dev, CON_DAT); /* flush posted writes */
185 he_writel(he_dev, flags | CON_CTL_WRITE | CON_CTL_ADDR(addr), CON_CTL);
186 while (he_readl(he_dev, CON_CTL) & CON_CTL_BUSY);
187 }
188
189 #define he_writel_rcm(dev, val, reg) \
190 he_writel_internal(dev, val, reg, CON_CTL_RCM)
191
192 #define he_writel_tcm(dev, val, reg) \
193 he_writel_internal(dev, val, reg, CON_CTL_TCM)
194
195 #define he_writel_mbox(dev, val, reg) \
196 he_writel_internal(dev, val, reg, CON_CTL_MBOX)
197
198 static unsigned
199 he_readl_internal(struct he_dev *he_dev, unsigned addr, unsigned flags)
200 {
201 he_writel(he_dev, flags | CON_CTL_READ | CON_CTL_ADDR(addr), CON_CTL);
202 while (he_readl(he_dev, CON_CTL) & CON_CTL_BUSY);
203 return he_readl(he_dev, CON_DAT);
204 }
205
206 #define he_readl_rcm(dev, reg) \
207 he_readl_internal(dev, reg, CON_CTL_RCM)
208
209 #define he_readl_tcm(dev, reg) \
210 he_readl_internal(dev, reg, CON_CTL_TCM)
211
212 #define he_readl_mbox(dev, reg) \
213 he_readl_internal(dev, reg, CON_CTL_MBOX)
214
215
216 /* figure 2.2 connection id */
217
218 #define he_mkcid(dev, vpi, vci) (((vpi << (dev)->vcibits) | vci) & 0x1fff)
219
220 /* 2.5.1 per connection transmit state registers */
221
222 #define he_writel_tsr0(dev, val, cid) \
223 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 0)
224 #define he_readl_tsr0(dev, cid) \
225 he_readl_tcm(dev, CONFIG_TSRA | (cid << 3) | 0)
226
227 #define he_writel_tsr1(dev, val, cid) \
228 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 1)
229
230 #define he_writel_tsr2(dev, val, cid) \
231 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 2)
232
233 #define he_writel_tsr3(dev, val, cid) \
234 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 3)
235
236 #define he_writel_tsr4(dev, val, cid) \
237 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 4)
238
239 /* from page 2-20
240 *
241 * NOTE While the transmit connection is active, bits 23 through 0
242 * of this register must not be written by the host. Byte
243 * enables should be used during normal operation when writing
244 * the most significant byte.
245 */
246
247 #define he_writel_tsr4_upper(dev, val, cid) \
248 he_writel_internal(dev, val, CONFIG_TSRA | (cid << 3) | 4, \
249 CON_CTL_TCM \
250 | CON_BYTE_DISABLE_2 \
251 | CON_BYTE_DISABLE_1 \
252 | CON_BYTE_DISABLE_0)
253
254 #define he_readl_tsr4(dev, cid) \
255 he_readl_tcm(dev, CONFIG_TSRA | (cid << 3) | 4)
256
257 #define he_writel_tsr5(dev, val, cid) \
258 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 5)
259
260 #define he_writel_tsr6(dev, val, cid) \
261 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 6)
262
263 #define he_writel_tsr7(dev, val, cid) \
264 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 7)
265
266
267 #define he_writel_tsr8(dev, val, cid) \
268 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 0)
269
270 #define he_writel_tsr9(dev, val, cid) \
271 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 1)
272
273 #define he_writel_tsr10(dev, val, cid) \
274 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 2)
275
276 #define he_writel_tsr11(dev, val, cid) \
277 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 3)
278
279
280 #define he_writel_tsr12(dev, val, cid) \
281 he_writel_tcm(dev, val, CONFIG_TSRC | (cid << 1) | 0)
282
283 #define he_writel_tsr13(dev, val, cid) \
284 he_writel_tcm(dev, val, CONFIG_TSRC | (cid << 1) | 1)
285
286
287 #define he_writel_tsr14(dev, val, cid) \
288 he_writel_tcm(dev, val, CONFIG_TSRD | cid)
289
290 #define he_writel_tsr14_upper(dev, val, cid) \
291 he_writel_internal(dev, val, CONFIG_TSRD | cid, \
292 CON_CTL_TCM \
293 | CON_BYTE_DISABLE_2 \
294 | CON_BYTE_DISABLE_1 \
295 | CON_BYTE_DISABLE_0)
296
297 /* 2.7.1 per connection receive state registers */
298
299 #define he_writel_rsr0(dev, val, cid) \
300 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 0)
301 #define he_readl_rsr0(dev, cid) \
302 he_readl_rcm(dev, 0x00000 | (cid << 3) | 0)
303
304 #define he_writel_rsr1(dev, val, cid) \
305 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 1)
306
307 #define he_writel_rsr2(dev, val, cid) \
308 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 2)
309
310 #define he_writel_rsr3(dev, val, cid) \
311 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 3)
312
313 #define he_writel_rsr4(dev, val, cid) \
314 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 4)
315
316 #define he_writel_rsr5(dev, val, cid) \
317 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 5)
318
319 #define he_writel_rsr6(dev, val, cid) \
320 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 6)
321
322 #define he_writel_rsr7(dev, val, cid) \
323 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 7)
324
325 static __inline__ struct atm_vcc*
326 __find_vcc(struct he_dev *he_dev, unsigned cid)
327 {
328 struct hlist_head *head;
329 struct atm_vcc *vcc;
330 struct hlist_node *node;
331 struct sock *s;
332 short vpi;
333 int vci;
334
335 vpi = cid >> he_dev->vcibits;
336 vci = cid & ((1 << he_dev->vcibits) - 1);
337 head = &vcc_hash[vci & (VCC_HTABLE_SIZE -1)];
338
339 sk_for_each(s, node, head) {
340 vcc = atm_sk(s);
341 if (vcc->dev == he_dev->atm_dev &&
342 vcc->vci == vci && vcc->vpi == vpi &&
343 vcc->qos.rxtp.traffic_class != ATM_NONE) {
344 return vcc;
345 }
346 }
347 return NULL;
348 }
349
350 static int __devinit
351 he_init_one(struct pci_dev *pci_dev, const struct pci_device_id *pci_ent)
352 {
353 struct atm_dev *atm_dev = NULL;
354 struct he_dev *he_dev = NULL;
355 int err = 0;
356
357 printk(KERN_INFO "ATM he driver\n");
358
359 if (pci_enable_device(pci_dev))
360 return -EIO;
361 if (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)) != 0) {
362 printk(KERN_WARNING "he: no suitable dma available\n");
363 err = -EIO;
364 goto init_one_failure;
365 }
366
367 atm_dev = atm_dev_register(DEV_LABEL, &he_ops, -1, NULL);
368 if (!atm_dev) {
369 err = -ENODEV;
370 goto init_one_failure;
371 }
372 pci_set_drvdata(pci_dev, atm_dev);
373
374 he_dev = kzalloc(sizeof(struct he_dev),
375 GFP_KERNEL);
376 if (!he_dev) {
377 err = -ENOMEM;
378 goto init_one_failure;
379 }
380 he_dev->pci_dev = pci_dev;
381 he_dev->atm_dev = atm_dev;
382 he_dev->atm_dev->dev_data = he_dev;
383 atm_dev->dev_data = he_dev;
384 he_dev->number = atm_dev->number;
385 tasklet_init(&he_dev->tasklet, he_tasklet, (unsigned long) he_dev);
386 spin_lock_init(&he_dev->global_lock);
387
388 if (he_start(atm_dev)) {
389 he_stop(he_dev);
390 err = -ENODEV;
391 goto init_one_failure;
392 }
393 he_dev->next = NULL;
394 if (he_devs)
395 he_dev->next = he_devs;
396 he_devs = he_dev;
397 return 0;
398
399 init_one_failure:
400 if (atm_dev)
401 atm_dev_deregister(atm_dev);
402 kfree(he_dev);
403 pci_disable_device(pci_dev);
404 return err;
405 }
406
407 static void __devexit
408 he_remove_one (struct pci_dev *pci_dev)
409 {
410 struct atm_dev *atm_dev;
411 struct he_dev *he_dev;
412
413 atm_dev = pci_get_drvdata(pci_dev);
414 he_dev = HE_DEV(atm_dev);
415
416 /* need to remove from he_devs */
417
418 he_stop(he_dev);
419 atm_dev_deregister(atm_dev);
420 kfree(he_dev);
421
422 pci_set_drvdata(pci_dev, NULL);
423 pci_disable_device(pci_dev);
424 }
425
426
427 static unsigned
428 rate_to_atmf(unsigned rate) /* cps to atm forum format */
429 {
430 #define NONZERO (1 << 14)
431
432 unsigned exp = 0;
433
434 if (rate == 0)
435 return 0;
436
437 rate <<= 9;
438 while (rate > 0x3ff) {
439 ++exp;
440 rate >>= 1;
441 }
442
443 return (NONZERO | (exp << 9) | (rate & 0x1ff));
444 }
445
446 static void __devinit
447 he_init_rx_lbfp0(struct he_dev *he_dev)
448 {
449 unsigned i, lbm_offset, lbufd_index, lbuf_addr, lbuf_count;
450 unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf;
451 unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD;
452 unsigned row_offset = he_dev->r0_startrow * he_dev->bytes_per_row;
453
454 lbufd_index = 0;
455 lbm_offset = he_readl(he_dev, RCMLBM_BA);
456
457 he_writel(he_dev, lbufd_index, RLBF0_H);
458
459 for (i = 0, lbuf_count = 0; i < he_dev->r0_numbuffs; ++i) {
460 lbufd_index += 2;
461 lbuf_addr = (row_offset + (lbuf_count * lbuf_bufsize)) / 32;
462
463 he_writel_rcm(he_dev, lbuf_addr, lbm_offset);
464 he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1);
465
466 if (++lbuf_count == lbufs_per_row) {
467 lbuf_count = 0;
468 row_offset += he_dev->bytes_per_row;
469 }
470 lbm_offset += 4;
471 }
472
473 he_writel(he_dev, lbufd_index - 2, RLBF0_T);
474 he_writel(he_dev, he_dev->r0_numbuffs, RLBF0_C);
475 }
476
477 static void __devinit
478 he_init_rx_lbfp1(struct he_dev *he_dev)
479 {
480 unsigned i, lbm_offset, lbufd_index, lbuf_addr, lbuf_count;
481 unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf;
482 unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD;
483 unsigned row_offset = he_dev->r1_startrow * he_dev->bytes_per_row;
484
485 lbufd_index = 1;
486 lbm_offset = he_readl(he_dev, RCMLBM_BA) + (2 * lbufd_index);
487
488 he_writel(he_dev, lbufd_index, RLBF1_H);
489
490 for (i = 0, lbuf_count = 0; i < he_dev->r1_numbuffs; ++i) {
491 lbufd_index += 2;
492 lbuf_addr = (row_offset + (lbuf_count * lbuf_bufsize)) / 32;
493
494 he_writel_rcm(he_dev, lbuf_addr, lbm_offset);
495 he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1);
496
497 if (++lbuf_count == lbufs_per_row) {
498 lbuf_count = 0;
499 row_offset += he_dev->bytes_per_row;
500 }
501 lbm_offset += 4;
502 }
503
504 he_writel(he_dev, lbufd_index - 2, RLBF1_T);
505 he_writel(he_dev, he_dev->r1_numbuffs, RLBF1_C);
506 }
507
508 static void __devinit
509 he_init_tx_lbfp(struct he_dev *he_dev)
510 {
511 unsigned i, lbm_offset, lbufd_index, lbuf_addr, lbuf_count;
512 unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf;
513 unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD;
514 unsigned row_offset = he_dev->tx_startrow * he_dev->bytes_per_row;
515
516 lbufd_index = he_dev->r0_numbuffs + he_dev->r1_numbuffs;
517 lbm_offset = he_readl(he_dev, RCMLBM_BA) + (2 * lbufd_index);
518
519 he_writel(he_dev, lbufd_index, TLBF_H);
520
521 for (i = 0, lbuf_count = 0; i < he_dev->tx_numbuffs; ++i) {
522 lbufd_index += 1;
523 lbuf_addr = (row_offset + (lbuf_count * lbuf_bufsize)) / 32;
524
525 he_writel_rcm(he_dev, lbuf_addr, lbm_offset);
526 he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1);
527
528 if (++lbuf_count == lbufs_per_row) {
529 lbuf_count = 0;
530 row_offset += he_dev->bytes_per_row;
531 }
532 lbm_offset += 2;
533 }
534
535 he_writel(he_dev, lbufd_index - 1, TLBF_T);
536 }
537
538 static int __devinit
539 he_init_tpdrq(struct he_dev *he_dev)
540 {
541 he_dev->tpdrq_base = pci_alloc_consistent(he_dev->pci_dev,
542 CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq), &he_dev->tpdrq_phys);
543 if (he_dev->tpdrq_base == NULL) {
544 hprintk("failed to alloc tpdrq\n");
545 return -ENOMEM;
546 }
547 memset(he_dev->tpdrq_base, 0,
548 CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq));
549
550 he_dev->tpdrq_tail = he_dev->tpdrq_base;
551 he_dev->tpdrq_head = he_dev->tpdrq_base;
552
553 he_writel(he_dev, he_dev->tpdrq_phys, TPDRQ_B_H);
554 he_writel(he_dev, 0, TPDRQ_T);
555 he_writel(he_dev, CONFIG_TPDRQ_SIZE - 1, TPDRQ_S);
556
557 return 0;
558 }
559
560 static void __devinit
561 he_init_cs_block(struct he_dev *he_dev)
562 {
563 unsigned clock, rate, delta;
564 int reg;
565
566 /* 5.1.7 cs block initialization */
567
568 for (reg = 0; reg < 0x20; ++reg)
569 he_writel_mbox(he_dev, 0x0, CS_STTIM0 + reg);
570
571 /* rate grid timer reload values */
572
573 clock = he_is622(he_dev) ? 66667000 : 50000000;
574 rate = he_dev->atm_dev->link_rate;
575 delta = rate / 16 / 2;
576
577 for (reg = 0; reg < 0x10; ++reg) {
578 /* 2.4 internal transmit function
579 *
580 * we initialize the first row in the rate grid.
581 * values are period (in clock cycles) of timer
582 */
583 unsigned period = clock / rate;
584
585 he_writel_mbox(he_dev, period, CS_TGRLD0 + reg);
586 rate -= delta;
587 }
588
589 if (he_is622(he_dev)) {
590 /* table 5.2 (4 cells per lbuf) */
591 he_writel_mbox(he_dev, 0x000800fa, CS_ERTHR0);
592 he_writel_mbox(he_dev, 0x000c33cb, CS_ERTHR1);
593 he_writel_mbox(he_dev, 0x0010101b, CS_ERTHR2);
594 he_writel_mbox(he_dev, 0x00181dac, CS_ERTHR3);
595 he_writel_mbox(he_dev, 0x00280600, CS_ERTHR4);
596
597 /* table 5.3, 5.4, 5.5, 5.6, 5.7 */
598 he_writel_mbox(he_dev, 0x023de8b3, CS_ERCTL0);
599 he_writel_mbox(he_dev, 0x1801, CS_ERCTL1);
600 he_writel_mbox(he_dev, 0x68b3, CS_ERCTL2);
601 he_writel_mbox(he_dev, 0x1280, CS_ERSTAT0);
602 he_writel_mbox(he_dev, 0x68b3, CS_ERSTAT1);
603 he_writel_mbox(he_dev, 0x14585, CS_RTFWR);
604
605 he_writel_mbox(he_dev, 0x4680, CS_RTATR);
606
607 /* table 5.8 */
608 he_writel_mbox(he_dev, 0x00159ece, CS_TFBSET);
609 he_writel_mbox(he_dev, 0x68b3, CS_WCRMAX);
610 he_writel_mbox(he_dev, 0x5eb3, CS_WCRMIN);
611 he_writel_mbox(he_dev, 0xe8b3, CS_WCRINC);
612 he_writel_mbox(he_dev, 0xdeb3, CS_WCRDEC);
613 he_writel_mbox(he_dev, 0x68b3, CS_WCRCEIL);
614
615 /* table 5.9 */
616 he_writel_mbox(he_dev, 0x5, CS_OTPPER);
617 he_writel_mbox(he_dev, 0x14, CS_OTWPER);
618 } else {
619 /* table 5.1 (4 cells per lbuf) */
620 he_writel_mbox(he_dev, 0x000400ea, CS_ERTHR0);
621 he_writel_mbox(he_dev, 0x00063388, CS_ERTHR1);
622 he_writel_mbox(he_dev, 0x00081018, CS_ERTHR2);
623 he_writel_mbox(he_dev, 0x000c1dac, CS_ERTHR3);
624 he_writel_mbox(he_dev, 0x0014051a, CS_ERTHR4);
625
626 /* table 5.3, 5.4, 5.5, 5.6, 5.7 */
627 he_writel_mbox(he_dev, 0x0235e4b1, CS_ERCTL0);
628 he_writel_mbox(he_dev, 0x4701, CS_ERCTL1);
629 he_writel_mbox(he_dev, 0x64b1, CS_ERCTL2);
630 he_writel_mbox(he_dev, 0x1280, CS_ERSTAT0);
631 he_writel_mbox(he_dev, 0x64b1, CS_ERSTAT1);
632 he_writel_mbox(he_dev, 0xf424, CS_RTFWR);
633
634 he_writel_mbox(he_dev, 0x4680, CS_RTATR);
635
636 /* table 5.8 */
637 he_writel_mbox(he_dev, 0x000563b7, CS_TFBSET);
638 he_writel_mbox(he_dev, 0x64b1, CS_WCRMAX);
639 he_writel_mbox(he_dev, 0x5ab1, CS_WCRMIN);
640 he_writel_mbox(he_dev, 0xe4b1, CS_WCRINC);
641 he_writel_mbox(he_dev, 0xdab1, CS_WCRDEC);
642 he_writel_mbox(he_dev, 0x64b1, CS_WCRCEIL);
643
644 /* table 5.9 */
645 he_writel_mbox(he_dev, 0x6, CS_OTPPER);
646 he_writel_mbox(he_dev, 0x1e, CS_OTWPER);
647 }
648
649 he_writel_mbox(he_dev, 0x8, CS_OTTLIM);
650
651 for (reg = 0; reg < 0x8; ++reg)
652 he_writel_mbox(he_dev, 0x0, CS_HGRRT0 + reg);
653
654 }
655
656 static int __devinit
657 he_init_cs_block_rcm(struct he_dev *he_dev)
658 {
659 unsigned (*rategrid)[16][16];
660 unsigned rate, delta;
661 int i, j, reg;
662
663 unsigned rate_atmf, exp, man;
664 unsigned long long rate_cps;
665 int mult, buf, buf_limit = 4;
666
667 rategrid = kmalloc( sizeof(unsigned) * 16 * 16, GFP_KERNEL);
668 if (!rategrid)
669 return -ENOMEM;
670
671 /* initialize rate grid group table */
672
673 for (reg = 0x0; reg < 0xff; ++reg)
674 he_writel_rcm(he_dev, 0x0, CONFIG_RCMABR + reg);
675
676 /* initialize rate controller groups */
677
678 for (reg = 0x100; reg < 0x1ff; ++reg)
679 he_writel_rcm(he_dev, 0x0, CONFIG_RCMABR + reg);
680
681 /* initialize tNrm lookup table */
682
683 /* the manual makes reference to a routine in a sample driver
684 for proper configuration; fortunately, we only need this
685 in order to support abr connection */
686
687 /* initialize rate to group table */
688
689 rate = he_dev->atm_dev->link_rate;
690 delta = rate / 32;
691
692 /*
693 * 2.4 transmit internal functions
694 *
695 * we construct a copy of the rate grid used by the scheduler
696 * in order to construct the rate to group table below
697 */
698
699 for (j = 0; j < 16; j++) {
700 (*rategrid)[0][j] = rate;
701 rate -= delta;
702 }
703
704 for (i = 1; i < 16; i++)
705 for (j = 0; j < 16; j++)
706 if (i > 14)
707 (*rategrid)[i][j] = (*rategrid)[i - 1][j] / 4;
708 else
709 (*rategrid)[i][j] = (*rategrid)[i - 1][j] / 2;
710
711 /*
712 * 2.4 transmit internal function
713 *
714 * this table maps the upper 5 bits of exponent and mantissa
715 * of the atm forum representation of the rate into an index
716 * on rate grid
717 */
718
719 rate_atmf = 0;
720 while (rate_atmf < 0x400) {
721 man = (rate_atmf & 0x1f) << 4;
722 exp = rate_atmf >> 5;
723
724 /*
725 instead of '/ 512', use '>> 9' to prevent a call
726 to divdu3 on x86 platforms
727 */
728 rate_cps = (unsigned long long) (1 << exp) * (man + 512) >> 9;
729
730 if (rate_cps < 10)
731 rate_cps = 10; /* 2.2.1 minimum payload rate is 10 cps */
732
733 for (i = 255; i > 0; i--)
734 if ((*rategrid)[i/16][i%16] >= rate_cps)
735 break; /* pick nearest rate instead? */
736
737 /*
738 * each table entry is 16 bits: (rate grid index (8 bits)
739 * and a buffer limit (8 bits)
740 * there are two table entries in each 32-bit register
741 */
742
743 #ifdef notdef
744 buf = rate_cps * he_dev->tx_numbuffs /
745 (he_dev->atm_dev->link_rate * 2);
746 #else
747 /* this is pretty, but avoids _divdu3 and is mostly correct */
748 mult = he_dev->atm_dev->link_rate / ATM_OC3_PCR;
749 if (rate_cps > (272 * mult))
750 buf = 4;
751 else if (rate_cps > (204 * mult))
752 buf = 3;
753 else if (rate_cps > (136 * mult))
754 buf = 2;
755 else if (rate_cps > (68 * mult))
756 buf = 1;
757 else
758 buf = 0;
759 #endif
760 if (buf > buf_limit)
761 buf = buf_limit;
762 reg = (reg << 16) | ((i << 8) | buf);
763
764 #define RTGTBL_OFFSET 0x400
765
766 if (rate_atmf & 0x1)
767 he_writel_rcm(he_dev, reg,
768 CONFIG_RCMABR + RTGTBL_OFFSET + (rate_atmf >> 1));
769
770 ++rate_atmf;
771 }
772
773 kfree(rategrid);
774 return 0;
775 }
776
777 static int __devinit
778 he_init_group(struct he_dev *he_dev, int group)
779 {
780 int i;
781
782 /* small buffer pool */
783 he_dev->rbps_pool = pci_pool_create("rbps", he_dev->pci_dev,
784 CONFIG_RBPS_BUFSIZE, 8, 0);
785 if (he_dev->rbps_pool == NULL) {
786 hprintk("unable to create rbps pages\n");
787 return -ENOMEM;
788 }
789
790 he_dev->rbps_base = pci_alloc_consistent(he_dev->pci_dev,
791 CONFIG_RBPS_SIZE * sizeof(struct he_rbp), &he_dev->rbps_phys);
792 if (he_dev->rbps_base == NULL) {
793 hprintk("failed to alloc rbps\n");
794 return -ENOMEM;
795 }
796 memset(he_dev->rbps_base, 0, CONFIG_RBPS_SIZE * sizeof(struct he_rbp));
797 he_dev->rbps_virt = kmalloc(CONFIG_RBPS_SIZE * sizeof(struct he_virt), GFP_KERNEL);
798
799 for (i = 0; i < CONFIG_RBPS_SIZE; ++i) {
800 dma_addr_t dma_handle;
801 void *cpuaddr;
802
803 cpuaddr = pci_pool_alloc(he_dev->rbps_pool, GFP_KERNEL|GFP_DMA, &dma_handle);
804 if (cpuaddr == NULL)
805 return -ENOMEM;
806
807 he_dev->rbps_virt[i].virt = cpuaddr;
808 he_dev->rbps_base[i].status = RBP_LOANED | RBP_SMALLBUF | (i << RBP_INDEX_OFF);
809 he_dev->rbps_base[i].phys = dma_handle;
810
811 }
812 he_dev->rbps_tail = &he_dev->rbps_base[CONFIG_RBPS_SIZE - 1];
813
814 he_writel(he_dev, he_dev->rbps_phys, G0_RBPS_S + (group * 32));
815 he_writel(he_dev, RBPS_MASK(he_dev->rbps_tail),
816 G0_RBPS_T + (group * 32));
817 he_writel(he_dev, CONFIG_RBPS_BUFSIZE/4,
818 G0_RBPS_BS + (group * 32));
819 he_writel(he_dev,
820 RBP_THRESH(CONFIG_RBPS_THRESH) |
821 RBP_QSIZE(CONFIG_RBPS_SIZE - 1) |
822 RBP_INT_ENB,
823 G0_RBPS_QI + (group * 32));
824
825 /* large buffer pool */
826 he_dev->rbpl_pool = pci_pool_create("rbpl", he_dev->pci_dev,
827 CONFIG_RBPL_BUFSIZE, 8, 0);
828 if (he_dev->rbpl_pool == NULL) {
829 hprintk("unable to create rbpl pool\n");
830 return -ENOMEM;
831 }
832
833 he_dev->rbpl_base = pci_alloc_consistent(he_dev->pci_dev,
834 CONFIG_RBPL_SIZE * sizeof(struct he_rbp), &he_dev->rbpl_phys);
835 if (he_dev->rbpl_base == NULL) {
836 hprintk("failed to alloc rbpl\n");
837 return -ENOMEM;
838 }
839 memset(he_dev->rbpl_base, 0, CONFIG_RBPL_SIZE * sizeof(struct he_rbp));
840 he_dev->rbpl_virt = kmalloc(CONFIG_RBPL_SIZE * sizeof(struct he_virt), GFP_KERNEL);
841
842 for (i = 0; i < CONFIG_RBPL_SIZE; ++i) {
843 dma_addr_t dma_handle;
844 void *cpuaddr;
845
846 cpuaddr = pci_pool_alloc(he_dev->rbpl_pool, GFP_KERNEL|GFP_DMA, &dma_handle);
847 if (cpuaddr == NULL)
848 return -ENOMEM;
849
850 he_dev->rbpl_virt[i].virt = cpuaddr;
851 he_dev->rbpl_base[i].status = RBP_LOANED | (i << RBP_INDEX_OFF);
852 he_dev->rbpl_base[i].phys = dma_handle;
853 }
854 he_dev->rbpl_tail = &he_dev->rbpl_base[CONFIG_RBPL_SIZE - 1];
855
856 he_writel(he_dev, he_dev->rbpl_phys, G0_RBPL_S + (group * 32));
857 he_writel(he_dev, RBPL_MASK(he_dev->rbpl_tail),
858 G0_RBPL_T + (group * 32));
859 he_writel(he_dev, CONFIG_RBPL_BUFSIZE/4,
860 G0_RBPL_BS + (group * 32));
861 he_writel(he_dev,
862 RBP_THRESH(CONFIG_RBPL_THRESH) |
863 RBP_QSIZE(CONFIG_RBPL_SIZE - 1) |
864 RBP_INT_ENB,
865 G0_RBPL_QI + (group * 32));
866
867 /* rx buffer ready queue */
868
869 he_dev->rbrq_base = pci_alloc_consistent(he_dev->pci_dev,
870 CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), &he_dev->rbrq_phys);
871 if (he_dev->rbrq_base == NULL) {
872 hprintk("failed to allocate rbrq\n");
873 return -ENOMEM;
874 }
875 memset(he_dev->rbrq_base, 0, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq));
876
877 he_dev->rbrq_head = he_dev->rbrq_base;
878 he_writel(he_dev, he_dev->rbrq_phys, G0_RBRQ_ST + (group * 16));
879 he_writel(he_dev, 0, G0_RBRQ_H + (group * 16));
880 he_writel(he_dev,
881 RBRQ_THRESH(CONFIG_RBRQ_THRESH) | RBRQ_SIZE(CONFIG_RBRQ_SIZE - 1),
882 G0_RBRQ_Q + (group * 16));
883 if (irq_coalesce) {
884 hprintk("coalescing interrupts\n");
885 he_writel(he_dev, RBRQ_TIME(768) | RBRQ_COUNT(7),
886 G0_RBRQ_I + (group * 16));
887 } else
888 he_writel(he_dev, RBRQ_TIME(0) | RBRQ_COUNT(1),
889 G0_RBRQ_I + (group * 16));
890
891 /* tx buffer ready queue */
892
893 he_dev->tbrq_base = pci_alloc_consistent(he_dev->pci_dev,
894 CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), &he_dev->tbrq_phys);
895 if (he_dev->tbrq_base == NULL) {
896 hprintk("failed to allocate tbrq\n");
897 return -ENOMEM;
898 }
899 memset(he_dev->tbrq_base, 0, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq));
900
901 he_dev->tbrq_head = he_dev->tbrq_base;
902
903 he_writel(he_dev, he_dev->tbrq_phys, G0_TBRQ_B_T + (group * 16));
904 he_writel(he_dev, 0, G0_TBRQ_H + (group * 16));
905 he_writel(he_dev, CONFIG_TBRQ_SIZE - 1, G0_TBRQ_S + (group * 16));
906 he_writel(he_dev, CONFIG_TBRQ_THRESH, G0_TBRQ_THRESH + (group * 16));
907
908 return 0;
909 }
910
911 static int __devinit
912 he_init_irq(struct he_dev *he_dev)
913 {
914 int i;
915
916 /* 2.9.3.5 tail offset for each interrupt queue is located after the
917 end of the interrupt queue */
918
919 he_dev->irq_base = pci_alloc_consistent(he_dev->pci_dev,
920 (CONFIG_IRQ_SIZE+1) * sizeof(struct he_irq), &he_dev->irq_phys);
921 if (he_dev->irq_base == NULL) {
922 hprintk("failed to allocate irq\n");
923 return -ENOMEM;
924 }
925 he_dev->irq_tailoffset = (unsigned *)
926 &he_dev->irq_base[CONFIG_IRQ_SIZE];
927 *he_dev->irq_tailoffset = 0;
928 he_dev->irq_head = he_dev->irq_base;
929 he_dev->irq_tail = he_dev->irq_base;
930
931 for (i = 0; i < CONFIG_IRQ_SIZE; ++i)
932 he_dev->irq_base[i].isw = ITYPE_INVALID;
933
934 he_writel(he_dev, he_dev->irq_phys, IRQ0_BASE);
935 he_writel(he_dev,
936 IRQ_SIZE(CONFIG_IRQ_SIZE) | IRQ_THRESH(CONFIG_IRQ_THRESH),
937 IRQ0_HEAD);
938 he_writel(he_dev, IRQ_INT_A | IRQ_TYPE_LINE, IRQ0_CNTL);
939 he_writel(he_dev, 0x0, IRQ0_DATA);
940
941 he_writel(he_dev, 0x0, IRQ1_BASE);
942 he_writel(he_dev, 0x0, IRQ1_HEAD);
943 he_writel(he_dev, 0x0, IRQ1_CNTL);
944 he_writel(he_dev, 0x0, IRQ1_DATA);
945
946 he_writel(he_dev, 0x0, IRQ2_BASE);
947 he_writel(he_dev, 0x0, IRQ2_HEAD);
948 he_writel(he_dev, 0x0, IRQ2_CNTL);
949 he_writel(he_dev, 0x0, IRQ2_DATA);
950
951 he_writel(he_dev, 0x0, IRQ3_BASE);
952 he_writel(he_dev, 0x0, IRQ3_HEAD);
953 he_writel(he_dev, 0x0, IRQ3_CNTL);
954 he_writel(he_dev, 0x0, IRQ3_DATA);
955
956 /* 2.9.3.2 interrupt queue mapping registers */
957
958 he_writel(he_dev, 0x0, GRP_10_MAP);
959 he_writel(he_dev, 0x0, GRP_32_MAP);
960 he_writel(he_dev, 0x0, GRP_54_MAP);
961 he_writel(he_dev, 0x0, GRP_76_MAP);
962
963 if (request_irq(he_dev->pci_dev->irq, he_irq_handler, IRQF_DISABLED|IRQF_SHARED, DEV_LABEL, he_dev)) {
964 hprintk("irq %d already in use\n", he_dev->pci_dev->irq);
965 return -EINVAL;
966 }
967
968 he_dev->irq = he_dev->pci_dev->irq;
969
970 return 0;
971 }
972
973 static int __devinit
974 he_start(struct atm_dev *dev)
975 {
976 struct he_dev *he_dev;
977 struct pci_dev *pci_dev;
978 unsigned long membase;
979
980 u16 command;
981 u32 gen_cntl_0, host_cntl, lb_swap;
982 u8 cache_size, timer;
983
984 unsigned err;
985 unsigned int status, reg;
986 int i, group;
987
988 he_dev = HE_DEV(dev);
989 pci_dev = he_dev->pci_dev;
990
991 membase = pci_resource_start(pci_dev, 0);
992 HPRINTK("membase = 0x%lx irq = %d.\n", membase, pci_dev->irq);
993
994 /*
995 * pci bus controller initialization
996 */
997
998 /* 4.3 pci bus controller-specific initialization */
999 if (pci_read_config_dword(pci_dev, GEN_CNTL_0, &gen_cntl_0) != 0) {
1000 hprintk("can't read GEN_CNTL_0\n");
1001 return -EINVAL;
1002 }
1003 gen_cntl_0 |= (MRL_ENB | MRM_ENB | IGNORE_TIMEOUT);
1004 if (pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0) != 0) {
1005 hprintk("can't write GEN_CNTL_0.\n");
1006 return -EINVAL;
1007 }
1008
1009 if (pci_read_config_word(pci_dev, PCI_COMMAND, &command) != 0) {
1010 hprintk("can't read PCI_COMMAND.\n");
1011 return -EINVAL;
1012 }
1013
1014 command |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE);
1015 if (pci_write_config_word(pci_dev, PCI_COMMAND, command) != 0) {
1016 hprintk("can't enable memory.\n");
1017 return -EINVAL;
1018 }
1019
1020 if (pci_read_config_byte(pci_dev, PCI_CACHE_LINE_SIZE, &cache_size)) {
1021 hprintk("can't read cache line size?\n");
1022 return -EINVAL;
1023 }
1024
1025 if (cache_size < 16) {
1026 cache_size = 16;
1027 if (pci_write_config_byte(pci_dev, PCI_CACHE_LINE_SIZE, cache_size))
1028 hprintk("can't set cache line size to %d\n", cache_size);
1029 }
1030
1031 if (pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &timer)) {
1032 hprintk("can't read latency timer?\n");
1033 return -EINVAL;
1034 }
1035
1036 /* from table 3.9
1037 *
1038 * LAT_TIMER = 1 + AVG_LAT + BURST_SIZE/BUS_SIZE
1039 *
1040 * AVG_LAT: The average first data read/write latency [maximum 16 clock cycles]
1041 * BURST_SIZE: 1536 bytes (read) for 622, 768 bytes (read) for 155 [192 clock cycles]
1042 *
1043 */
1044 #define LAT_TIMER 209
1045 if (timer < LAT_TIMER) {
1046 HPRINTK("latency timer was %d, setting to %d\n", timer, LAT_TIMER);
1047 timer = LAT_TIMER;
1048 if (pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, timer))
1049 hprintk("can't set latency timer to %d\n", timer);
1050 }
1051
1052 if (!(he_dev->membase = ioremap(membase, HE_REGMAP_SIZE))) {
1053 hprintk("can't set up page mapping\n");
1054 return -EINVAL;
1055 }
1056
1057 /* 4.4 card reset */
1058 he_writel(he_dev, 0x0, RESET_CNTL);
1059 he_writel(he_dev, 0xff, RESET_CNTL);
1060
1061 udelay(16*1000); /* 16 ms */
1062 status = he_readl(he_dev, RESET_CNTL);
1063 if ((status & BOARD_RST_STATUS) == 0) {
1064 hprintk("reset failed\n");
1065 return -EINVAL;
1066 }
1067
1068 /* 4.5 set bus width */
1069 host_cntl = he_readl(he_dev, HOST_CNTL);
1070 if (host_cntl & PCI_BUS_SIZE64)
1071 gen_cntl_0 |= ENBL_64;
1072 else
1073 gen_cntl_0 &= ~ENBL_64;
1074
1075 if (disable64 == 1) {
1076 hprintk("disabling 64-bit pci bus transfers\n");
1077 gen_cntl_0 &= ~ENBL_64;
1078 }
1079
1080 if (gen_cntl_0 & ENBL_64)
1081 hprintk("64-bit transfers enabled\n");
1082
1083 pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0);
1084
1085 /* 4.7 read prom contents */
1086 for (i = 0; i < PROD_ID_LEN; ++i)
1087 he_dev->prod_id[i] = read_prom_byte(he_dev, PROD_ID + i);
1088
1089 he_dev->media = read_prom_byte(he_dev, MEDIA);
1090
1091 for (i = 0; i < 6; ++i)
1092 dev->esi[i] = read_prom_byte(he_dev, MAC_ADDR + i);
1093
1094 hprintk("%s%s, %x:%x:%x:%x:%x:%x\n",
1095 he_dev->prod_id,
1096 he_dev->media & 0x40 ? "SM" : "MM",
1097 dev->esi[0],
1098 dev->esi[1],
1099 dev->esi[2],
1100 dev->esi[3],
1101 dev->esi[4],
1102 dev->esi[5]);
1103 he_dev->atm_dev->link_rate = he_is622(he_dev) ?
1104 ATM_OC12_PCR : ATM_OC3_PCR;
1105
1106 /* 4.6 set host endianess */
1107 lb_swap = he_readl(he_dev, LB_SWAP);
1108 if (he_is622(he_dev))
1109 lb_swap &= ~XFER_SIZE; /* 4 cells */
1110 else
1111 lb_swap |= XFER_SIZE; /* 8 cells */
1112 #ifdef __BIG_ENDIAN
1113 lb_swap |= DESC_WR_SWAP | INTR_SWAP | BIG_ENDIAN_HOST;
1114 #else
1115 lb_swap &= ~(DESC_WR_SWAP | INTR_SWAP | BIG_ENDIAN_HOST |
1116 DATA_WR_SWAP | DATA_RD_SWAP | DESC_RD_SWAP);
1117 #endif /* __BIG_ENDIAN */
1118 he_writel(he_dev, lb_swap, LB_SWAP);
1119
1120 /* 4.8 sdram controller initialization */
1121 he_writel(he_dev, he_is622(he_dev) ? LB_64_ENB : 0x0, SDRAM_CTL);
1122
1123 /* 4.9 initialize rnum value */
1124 lb_swap |= SWAP_RNUM_MAX(0xf);
1125 he_writel(he_dev, lb_swap, LB_SWAP);
1126
1127 /* 4.10 initialize the interrupt queues */
1128 if ((err = he_init_irq(he_dev)) != 0)
1129 return err;
1130
1131 /* 4.11 enable pci bus controller state machines */
1132 host_cntl |= (OUTFF_ENB | CMDFF_ENB |
1133 QUICK_RD_RETRY | QUICK_WR_RETRY | PERR_INT_ENB);
1134 he_writel(he_dev, host_cntl, HOST_CNTL);
1135
1136 gen_cntl_0 |= INT_PROC_ENBL|INIT_ENB;
1137 pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0);
1138
1139 /*
1140 * atm network controller initialization
1141 */
1142
1143 /* 5.1.1 generic configuration state */
1144
1145 /*
1146 * local (cell) buffer memory map
1147 *
1148 * HE155 HE622
1149 *
1150 * 0 ____________1023 bytes 0 _______________________2047 bytes
1151 * | | | | |
1152 * | utility | | rx0 | |
1153 * 5|____________| 255|___________________| u |
1154 * 6| | 256| | t |
1155 * | | | | i |
1156 * | rx0 | row | tx | l |
1157 * | | | | i |
1158 * | | 767|___________________| t |
1159 * 517|____________| 768| | y |
1160 * row 518| | | rx1 | |
1161 * | | 1023|___________________|___|
1162 * | |
1163 * | tx |
1164 * | |
1165 * | |
1166 * 1535|____________|
1167 * 1536| |
1168 * | rx1 |
1169 * 2047|____________|
1170 *
1171 */
1172
1173 /* total 4096 connections */
1174 he_dev->vcibits = CONFIG_DEFAULT_VCIBITS;
1175 he_dev->vpibits = CONFIG_DEFAULT_VPIBITS;
1176
1177 if (nvpibits != -1 && nvcibits != -1 && nvpibits+nvcibits != HE_MAXCIDBITS) {
1178 hprintk("nvpibits + nvcibits != %d\n", HE_MAXCIDBITS);
1179 return -ENODEV;
1180 }
1181
1182 if (nvpibits != -1) {
1183 he_dev->vpibits = nvpibits;
1184 he_dev->vcibits = HE_MAXCIDBITS - nvpibits;
1185 }
1186
1187 if (nvcibits != -1) {
1188 he_dev->vcibits = nvcibits;
1189 he_dev->vpibits = HE_MAXCIDBITS - nvcibits;
1190 }
1191
1192
1193 if (he_is622(he_dev)) {
1194 he_dev->cells_per_row = 40;
1195 he_dev->bytes_per_row = 2048;
1196 he_dev->r0_numrows = 256;
1197 he_dev->tx_numrows = 512;
1198 he_dev->r1_numrows = 256;
1199 he_dev->r0_startrow = 0;
1200 he_dev->tx_startrow = 256;
1201 he_dev->r1_startrow = 768;
1202 } else {
1203 he_dev->cells_per_row = 20;
1204 he_dev->bytes_per_row = 1024;
1205 he_dev->r0_numrows = 512;
1206 he_dev->tx_numrows = 1018;
1207 he_dev->r1_numrows = 512;
1208 he_dev->r0_startrow = 6;
1209 he_dev->tx_startrow = 518;
1210 he_dev->r1_startrow = 1536;
1211 }
1212
1213 he_dev->cells_per_lbuf = 4;
1214 he_dev->buffer_limit = 4;
1215 he_dev->r0_numbuffs = he_dev->r0_numrows *
1216 he_dev->cells_per_row / he_dev->cells_per_lbuf;
1217 if (he_dev->r0_numbuffs > 2560)
1218 he_dev->r0_numbuffs = 2560;
1219
1220 he_dev->r1_numbuffs = he_dev->r1_numrows *
1221 he_dev->cells_per_row / he_dev->cells_per_lbuf;
1222 if (he_dev->r1_numbuffs > 2560)
1223 he_dev->r1_numbuffs = 2560;
1224
1225 he_dev->tx_numbuffs = he_dev->tx_numrows *
1226 he_dev->cells_per_row / he_dev->cells_per_lbuf;
1227 if (he_dev->tx_numbuffs > 5120)
1228 he_dev->tx_numbuffs = 5120;
1229
1230 /* 5.1.2 configure hardware dependent registers */
1231
1232 he_writel(he_dev,
1233 SLICE_X(0x2) | ARB_RNUM_MAX(0xf) | TH_PRTY(0x3) |
1234 RH_PRTY(0x3) | TL_PRTY(0x2) | RL_PRTY(0x1) |
1235 (he_is622(he_dev) ? BUS_MULTI(0x28) : BUS_MULTI(0x46)) |
1236 (he_is622(he_dev) ? NET_PREF(0x50) : NET_PREF(0x8c)),
1237 LBARB);
1238
1239 he_writel(he_dev, BANK_ON |
1240 (he_is622(he_dev) ? (REF_RATE(0x384) | WIDE_DATA) : REF_RATE(0x150)),
1241 SDRAMCON);
1242
1243 he_writel(he_dev,
1244 (he_is622(he_dev) ? RM_BANK_WAIT(1) : RM_BANK_WAIT(0)) |
1245 RM_RW_WAIT(1), RCMCONFIG);
1246 he_writel(he_dev,
1247 (he_is622(he_dev) ? TM_BANK_WAIT(2) : TM_BANK_WAIT(1)) |
1248 TM_RW_WAIT(1), TCMCONFIG);
1249
1250 he_writel(he_dev, he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD, LB_CONFIG);
1251
1252 he_writel(he_dev,
1253 (he_is622(he_dev) ? UT_RD_DELAY(8) : UT_RD_DELAY(0)) |
1254 (he_is622(he_dev) ? RC_UT_MODE(0) : RC_UT_MODE(1)) |
1255 RX_VALVP(he_dev->vpibits) |
1256 RX_VALVC(he_dev->vcibits), RC_CONFIG);
1257
1258 he_writel(he_dev, DRF_THRESH(0x20) |
1259 (he_is622(he_dev) ? TX_UT_MODE(0) : TX_UT_MODE(1)) |
1260 TX_VCI_MASK(he_dev->vcibits) |
1261 LBFREE_CNT(he_dev->tx_numbuffs), TX_CONFIG);
1262
1263 he_writel(he_dev, 0x0, TXAAL5_PROTO);
1264
1265 he_writel(he_dev, PHY_INT_ENB |
1266 (he_is622(he_dev) ? PTMR_PRE(67 - 1) : PTMR_PRE(50 - 1)),
1267 RH_CONFIG);
1268
1269 /* 5.1.3 initialize connection memory */
1270
1271 for (i = 0; i < TCM_MEM_SIZE; ++i)
1272 he_writel_tcm(he_dev, 0, i);
1273
1274 for (i = 0; i < RCM_MEM_SIZE; ++i)
1275 he_writel_rcm(he_dev, 0, i);
1276
1277 /*
1278 * transmit connection memory map
1279 *
1280 * tx memory
1281 * 0x0 ___________________
1282 * | |
1283 * | |
1284 * | TSRa |
1285 * | |
1286 * | |
1287 * 0x8000|___________________|
1288 * | |
1289 * | TSRb |
1290 * 0xc000|___________________|
1291 * | |
1292 * | TSRc |
1293 * 0xe000|___________________|
1294 * | TSRd |
1295 * 0xf000|___________________|
1296 * | tmABR |
1297 * 0x10000|___________________|
1298 * | |
1299 * | tmTPD |
1300 * |___________________|
1301 * | |
1302 * ....
1303 * 0x1ffff|___________________|
1304 *
1305 *
1306 */
1307
1308 he_writel(he_dev, CONFIG_TSRB, TSRB_BA);
1309 he_writel(he_dev, CONFIG_TSRC, TSRC_BA);
1310 he_writel(he_dev, CONFIG_TSRD, TSRD_BA);
1311 he_writel(he_dev, CONFIG_TMABR, TMABR_BA);
1312 he_writel(he_dev, CONFIG_TPDBA, TPD_BA);
1313
1314
1315 /*
1316 * receive connection memory map
1317 *
1318 * 0x0 ___________________
1319 * | |
1320 * | |
1321 * | RSRa |
1322 * | |
1323 * | |
1324 * 0x8000|___________________|
1325 * | |
1326 * | rx0/1 |
1327 * | LBM | link lists of local
1328 * | tx | buffer memory
1329 * | |
1330 * 0xd000|___________________|
1331 * | |
1332 * | rmABR |
1333 * 0xe000|___________________|
1334 * | |
1335 * | RSRb |
1336 * |___________________|
1337 * | |
1338 * ....
1339 * 0xffff|___________________|
1340 */
1341
1342 he_writel(he_dev, 0x08000, RCMLBM_BA);
1343 he_writel(he_dev, 0x0e000, RCMRSRB_BA);
1344 he_writel(he_dev, 0x0d800, RCMABR_BA);
1345
1346 /* 5.1.4 initialize local buffer free pools linked lists */
1347
1348 he_init_rx_lbfp0(he_dev);
1349 he_init_rx_lbfp1(he_dev);
1350
1351 he_writel(he_dev, 0x0, RLBC_H);
1352 he_writel(he_dev, 0x0, RLBC_T);
1353 he_writel(he_dev, 0x0, RLBC_H2);
1354
1355 he_writel(he_dev, 512, RXTHRSH); /* 10% of r0+r1 buffers */
1356 he_writel(he_dev, 256, LITHRSH); /* 5% of r0+r1 buffers */
1357
1358 he_init_tx_lbfp(he_dev);
1359
1360 he_writel(he_dev, he_is622(he_dev) ? 0x104780 : 0x800, UBUFF_BA);
1361
1362 /* 5.1.5 initialize intermediate receive queues */
1363
1364 if (he_is622(he_dev)) {
1365 he_writel(he_dev, 0x000f, G0_INMQ_S);
1366 he_writel(he_dev, 0x200f, G0_INMQ_L);
1367
1368 he_writel(he_dev, 0x001f, G1_INMQ_S);
1369 he_writel(he_dev, 0x201f, G1_INMQ_L);
1370
1371 he_writel(he_dev, 0x002f, G2_INMQ_S);
1372 he_writel(he_dev, 0x202f, G2_INMQ_L);
1373
1374 he_writel(he_dev, 0x003f, G3_INMQ_S);
1375 he_writel(he_dev, 0x203f, G3_INMQ_L);
1376
1377 he_writel(he_dev, 0x004f, G4_INMQ_S);
1378 he_writel(he_dev, 0x204f, G4_INMQ_L);
1379
1380 he_writel(he_dev, 0x005f, G5_INMQ_S);
1381 he_writel(he_dev, 0x205f, G5_INMQ_L);
1382
1383 he_writel(he_dev, 0x006f, G6_INMQ_S);
1384 he_writel(he_dev, 0x206f, G6_INMQ_L);
1385
1386 he_writel(he_dev, 0x007f, G7_INMQ_S);
1387 he_writel(he_dev, 0x207f, G7_INMQ_L);
1388 } else {
1389 he_writel(he_dev, 0x0000, G0_INMQ_S);
1390 he_writel(he_dev, 0x0008, G0_INMQ_L);
1391
1392 he_writel(he_dev, 0x0001, G1_INMQ_S);
1393 he_writel(he_dev, 0x0009, G1_INMQ_L);
1394
1395 he_writel(he_dev, 0x0002, G2_INMQ_S);
1396 he_writel(he_dev, 0x000a, G2_INMQ_L);
1397
1398 he_writel(he_dev, 0x0003, G3_INMQ_S);
1399 he_writel(he_dev, 0x000b, G3_INMQ_L);
1400
1401 he_writel(he_dev, 0x0004, G4_INMQ_S);
1402 he_writel(he_dev, 0x000c, G4_INMQ_L);
1403
1404 he_writel(he_dev, 0x0005, G5_INMQ_S);
1405 he_writel(he_dev, 0x000d, G5_INMQ_L);
1406
1407 he_writel(he_dev, 0x0006, G6_INMQ_S);
1408 he_writel(he_dev, 0x000e, G6_INMQ_L);
1409
1410 he_writel(he_dev, 0x0007, G7_INMQ_S);
1411 he_writel(he_dev, 0x000f, G7_INMQ_L);
1412 }
1413
1414 /* 5.1.6 application tunable parameters */
1415
1416 he_writel(he_dev, 0x0, MCC);
1417 he_writel(he_dev, 0x0, OEC);
1418 he_writel(he_dev, 0x0, DCC);
1419 he_writel(he_dev, 0x0, CEC);
1420
1421 /* 5.1.7 cs block initialization */
1422
1423 he_init_cs_block(he_dev);
1424
1425 /* 5.1.8 cs block connection memory initialization */
1426
1427 if (he_init_cs_block_rcm(he_dev) < 0)
1428 return -ENOMEM;
1429
1430 /* 5.1.10 initialize host structures */
1431
1432 he_init_tpdrq(he_dev);
1433
1434 he_dev->tpd_pool = pci_pool_create("tpd", he_dev->pci_dev,
1435 sizeof(struct he_tpd), TPD_ALIGNMENT, 0);
1436 if (he_dev->tpd_pool == NULL) {
1437 hprintk("unable to create tpd pci_pool\n");
1438 return -ENOMEM;
1439 }
1440
1441 INIT_LIST_HEAD(&he_dev->outstanding_tpds);
1442
1443 if (he_init_group(he_dev, 0) != 0)
1444 return -ENOMEM;
1445
1446 for (group = 1; group < HE_NUM_GROUPS; ++group) {
1447 he_writel(he_dev, 0x0, G0_RBPS_S + (group * 32));
1448 he_writel(he_dev, 0x0, G0_RBPS_T + (group * 32));
1449 he_writel(he_dev, 0x0, G0_RBPS_QI + (group * 32));
1450 he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0),
1451 G0_RBPS_BS + (group * 32));
1452
1453 he_writel(he_dev, 0x0, G0_RBPL_S + (group * 32));
1454 he_writel(he_dev, 0x0, G0_RBPL_T + (group * 32));
1455 he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0),
1456 G0_RBPL_QI + (group * 32));
1457 he_writel(he_dev, 0x0, G0_RBPL_BS + (group * 32));
1458
1459 he_writel(he_dev, 0x0, G0_RBRQ_ST + (group * 16));
1460 he_writel(he_dev, 0x0, G0_RBRQ_H + (group * 16));
1461 he_writel(he_dev, RBRQ_THRESH(0x1) | RBRQ_SIZE(0x0),
1462 G0_RBRQ_Q + (group * 16));
1463 he_writel(he_dev, 0x0, G0_RBRQ_I + (group * 16));
1464
1465 he_writel(he_dev, 0x0, G0_TBRQ_B_T + (group * 16));
1466 he_writel(he_dev, 0x0, G0_TBRQ_H + (group * 16));
1467 he_writel(he_dev, TBRQ_THRESH(0x1),
1468 G0_TBRQ_THRESH + (group * 16));
1469 he_writel(he_dev, 0x0, G0_TBRQ_S + (group * 16));
1470 }
1471
1472 /* host status page */
1473
1474 he_dev->hsp = pci_alloc_consistent(he_dev->pci_dev,
1475 sizeof(struct he_hsp), &he_dev->hsp_phys);
1476 if (he_dev->hsp == NULL) {
1477 hprintk("failed to allocate host status page\n");
1478 return -ENOMEM;
1479 }
1480 memset(he_dev->hsp, 0, sizeof(struct he_hsp));
1481 he_writel(he_dev, he_dev->hsp_phys, HSP_BA);
1482
1483 /* initialize framer */
1484
1485 #ifdef CONFIG_ATM_HE_USE_SUNI
1486 if (he_isMM(he_dev))
1487 suni_init(he_dev->atm_dev);
1488 if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->start)
1489 he_dev->atm_dev->phy->start(he_dev->atm_dev);
1490 #endif /* CONFIG_ATM_HE_USE_SUNI */
1491
1492 if (sdh) {
1493 /* this really should be in suni.c but for now... */
1494 int val;
1495
1496 val = he_phy_get(he_dev->atm_dev, SUNI_TPOP_APM);
1497 val = (val & ~SUNI_TPOP_APM_S) | (SUNI_TPOP_S_SDH << SUNI_TPOP_APM_S_SHIFT);
1498 he_phy_put(he_dev->atm_dev, val, SUNI_TPOP_APM);
1499 he_phy_put(he_dev->atm_dev, SUNI_TACP_IUCHP_CLP, SUNI_TACP_IUCHP);
1500 }
1501
1502 /* 5.1.12 enable transmit and receive */
1503
1504 reg = he_readl_mbox(he_dev, CS_ERCTL0);
1505 reg |= TX_ENABLE|ER_ENABLE;
1506 he_writel_mbox(he_dev, reg, CS_ERCTL0);
1507
1508 reg = he_readl(he_dev, RC_CONFIG);
1509 reg |= RX_ENABLE;
1510 he_writel(he_dev, reg, RC_CONFIG);
1511
1512 for (i = 0; i < HE_NUM_CS_STPER; ++i) {
1513 he_dev->cs_stper[i].inuse = 0;
1514 he_dev->cs_stper[i].pcr = -1;
1515 }
1516 he_dev->total_bw = 0;
1517
1518
1519 /* atm linux initialization */
1520
1521 he_dev->atm_dev->ci_range.vpi_bits = he_dev->vpibits;
1522 he_dev->atm_dev->ci_range.vci_bits = he_dev->vcibits;
1523
1524 he_dev->irq_peak = 0;
1525 he_dev->rbrq_peak = 0;
1526 he_dev->rbpl_peak = 0;
1527 he_dev->tbrq_peak = 0;
1528
1529 HPRINTK("hell bent for leather!\n");
1530
1531 return 0;
1532 }
1533
1534 static void
1535 he_stop(struct he_dev *he_dev)
1536 {
1537 u16 command;
1538 u32 gen_cntl_0, reg;
1539 struct pci_dev *pci_dev;
1540
1541 pci_dev = he_dev->pci_dev;
1542
1543 /* disable interrupts */
1544
1545 if (he_dev->membase) {
1546 pci_read_config_dword(pci_dev, GEN_CNTL_0, &gen_cntl_0);
1547 gen_cntl_0 &= ~(INT_PROC_ENBL | INIT_ENB);
1548 pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0);
1549
1550 tasklet_disable(&he_dev->tasklet);
1551
1552 /* disable recv and transmit */
1553
1554 reg = he_readl_mbox(he_dev, CS_ERCTL0);
1555 reg &= ~(TX_ENABLE|ER_ENABLE);
1556 he_writel_mbox(he_dev, reg, CS_ERCTL0);
1557
1558 reg = he_readl(he_dev, RC_CONFIG);
1559 reg &= ~(RX_ENABLE);
1560 he_writel(he_dev, reg, RC_CONFIG);
1561 }
1562
1563 #ifdef CONFIG_ATM_HE_USE_SUNI
1564 if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->stop)
1565 he_dev->atm_dev->phy->stop(he_dev->atm_dev);
1566 #endif /* CONFIG_ATM_HE_USE_SUNI */
1567
1568 if (he_dev->irq)
1569 free_irq(he_dev->irq, he_dev);
1570
1571 if (he_dev->irq_base)
1572 pci_free_consistent(he_dev->pci_dev, (CONFIG_IRQ_SIZE+1)
1573 * sizeof(struct he_irq), he_dev->irq_base, he_dev->irq_phys);
1574
1575 if (he_dev->hsp)
1576 pci_free_consistent(he_dev->pci_dev, sizeof(struct he_hsp),
1577 he_dev->hsp, he_dev->hsp_phys);
1578
1579 if (he_dev->rbpl_base) {
1580 int i;
1581
1582 for (i = 0; i < CONFIG_RBPL_SIZE; ++i) {
1583 void *cpuaddr = he_dev->rbpl_virt[i].virt;
1584 dma_addr_t dma_handle = he_dev->rbpl_base[i].phys;
1585
1586 pci_pool_free(he_dev->rbpl_pool, cpuaddr, dma_handle);
1587 }
1588 pci_free_consistent(he_dev->pci_dev, CONFIG_RBPL_SIZE
1589 * sizeof(struct he_rbp), he_dev->rbpl_base, he_dev->rbpl_phys);
1590 }
1591
1592 if (he_dev->rbpl_pool)
1593 pci_pool_destroy(he_dev->rbpl_pool);
1594
1595 if (he_dev->rbps_base) {
1596 int i;
1597
1598 for (i = 0; i < CONFIG_RBPS_SIZE; ++i) {
1599 void *cpuaddr = he_dev->rbps_virt[i].virt;
1600 dma_addr_t dma_handle = he_dev->rbps_base[i].phys;
1601
1602 pci_pool_free(he_dev->rbps_pool, cpuaddr, dma_handle);
1603 }
1604 pci_free_consistent(he_dev->pci_dev, CONFIG_RBPS_SIZE
1605 * sizeof(struct he_rbp), he_dev->rbps_base, he_dev->rbps_phys);
1606 }
1607
1608 if (he_dev->rbps_pool)
1609 pci_pool_destroy(he_dev->rbps_pool);
1610
1611 if (he_dev->rbrq_base)
1612 pci_free_consistent(he_dev->pci_dev, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq),
1613 he_dev->rbrq_base, he_dev->rbrq_phys);
1614
1615 if (he_dev->tbrq_base)
1616 pci_free_consistent(he_dev->pci_dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq),
1617 he_dev->tbrq_base, he_dev->tbrq_phys);
1618
1619 if (he_dev->tpdrq_base)
1620 pci_free_consistent(he_dev->pci_dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq),
1621 he_dev->tpdrq_base, he_dev->tpdrq_phys);
1622
1623 if (he_dev->tpd_pool)
1624 pci_pool_destroy(he_dev->tpd_pool);
1625
1626 if (he_dev->pci_dev) {
1627 pci_read_config_word(he_dev->pci_dev, PCI_COMMAND, &command);
1628 command &= ~(PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
1629 pci_write_config_word(he_dev->pci_dev, PCI_COMMAND, command);
1630 }
1631
1632 if (he_dev->membase)
1633 iounmap(he_dev->membase);
1634 }
1635
1636 static struct he_tpd *
1637 __alloc_tpd(struct he_dev *he_dev)
1638 {
1639 struct he_tpd *tpd;
1640 dma_addr_t dma_handle;
1641
1642 tpd = pci_pool_alloc(he_dev->tpd_pool, GFP_ATOMIC|GFP_DMA, &dma_handle);
1643 if (tpd == NULL)
1644 return NULL;
1645
1646 tpd->status = TPD_ADDR(dma_handle);
1647 tpd->reserved = 0;
1648 tpd->iovec[0].addr = 0; tpd->iovec[0].len = 0;
1649 tpd->iovec[1].addr = 0; tpd->iovec[1].len = 0;
1650 tpd->iovec[2].addr = 0; tpd->iovec[2].len = 0;
1651
1652 return tpd;
1653 }
1654
1655 #define AAL5_LEN(buf,len) \
1656 ((((unsigned char *)(buf))[(len)-6] << 8) | \
1657 (((unsigned char *)(buf))[(len)-5]))
1658
1659 /* 2.10.1.2 receive
1660 *
1661 * aal5 packets can optionally return the tcp checksum in the lower
1662 * 16 bits of the crc (RSR0_TCP_CKSUM)
1663 */
1664
1665 #define TCP_CKSUM(buf,len) \
1666 ((((unsigned char *)(buf))[(len)-2] << 8) | \
1667 (((unsigned char *)(buf))[(len-1)]))
1668
1669 static int
1670 he_service_rbrq(struct he_dev *he_dev, int group)
1671 {
1672 struct he_rbrq *rbrq_tail = (struct he_rbrq *)
1673 ((unsigned long)he_dev->rbrq_base |
1674 he_dev->hsp->group[group].rbrq_tail);
1675 struct he_rbp *rbp = NULL;
1676 unsigned cid, lastcid = -1;
1677 unsigned buf_len = 0;
1678 struct sk_buff *skb;
1679 struct atm_vcc *vcc = NULL;
1680 struct he_vcc *he_vcc;
1681 struct he_iovec *iov;
1682 int pdus_assembled = 0;
1683 int updated = 0;
1684
1685 read_lock(&vcc_sklist_lock);
1686 while (he_dev->rbrq_head != rbrq_tail) {
1687 ++updated;
1688
1689 HPRINTK("%p rbrq%d 0x%x len=%d cid=0x%x %s%s%s%s%s%s\n",
1690 he_dev->rbrq_head, group,
1691 RBRQ_ADDR(he_dev->rbrq_head),
1692 RBRQ_BUFLEN(he_dev->rbrq_head),
1693 RBRQ_CID(he_dev->rbrq_head),
1694 RBRQ_CRC_ERR(he_dev->rbrq_head) ? " CRC_ERR" : "",
1695 RBRQ_LEN_ERR(he_dev->rbrq_head) ? " LEN_ERR" : "",
1696 RBRQ_END_PDU(he_dev->rbrq_head) ? " END_PDU" : "",
1697 RBRQ_AAL5_PROT(he_dev->rbrq_head) ? " AAL5_PROT" : "",
1698 RBRQ_CON_CLOSED(he_dev->rbrq_head) ? " CON_CLOSED" : "",
1699 RBRQ_HBUF_ERR(he_dev->rbrq_head) ? " HBUF_ERR" : "");
1700
1701 if (RBRQ_ADDR(he_dev->rbrq_head) & RBP_SMALLBUF)
1702 rbp = &he_dev->rbps_base[RBP_INDEX(RBRQ_ADDR(he_dev->rbrq_head))];
1703 else
1704 rbp = &he_dev->rbpl_base[RBP_INDEX(RBRQ_ADDR(he_dev->rbrq_head))];
1705
1706 buf_len = RBRQ_BUFLEN(he_dev->rbrq_head) * 4;
1707 cid = RBRQ_CID(he_dev->rbrq_head);
1708
1709 if (cid != lastcid)
1710 vcc = __find_vcc(he_dev, cid);
1711 lastcid = cid;
1712
1713 if (vcc == NULL) {
1714 hprintk("vcc == NULL (cid 0x%x)\n", cid);
1715 if (!RBRQ_HBUF_ERR(he_dev->rbrq_head))
1716 rbp->status &= ~RBP_LOANED;
1717
1718 goto next_rbrq_entry;
1719 }
1720
1721 he_vcc = HE_VCC(vcc);
1722 if (he_vcc == NULL) {
1723 hprintk("he_vcc == NULL (cid 0x%x)\n", cid);
1724 if (!RBRQ_HBUF_ERR(he_dev->rbrq_head))
1725 rbp->status &= ~RBP_LOANED;
1726 goto next_rbrq_entry;
1727 }
1728
1729 if (RBRQ_HBUF_ERR(he_dev->rbrq_head)) {
1730 hprintk("HBUF_ERR! (cid 0x%x)\n", cid);
1731 atomic_inc(&vcc->stats->rx_drop);
1732 goto return_host_buffers;
1733 }
1734
1735 he_vcc->iov_tail->iov_base = RBRQ_ADDR(he_dev->rbrq_head);
1736 he_vcc->iov_tail->iov_len = buf_len;
1737 he_vcc->pdu_len += buf_len;
1738 ++he_vcc->iov_tail;
1739
1740 if (RBRQ_CON_CLOSED(he_dev->rbrq_head)) {
1741 lastcid = -1;
1742 HPRINTK("wake_up rx_waitq (cid 0x%x)\n", cid);
1743 wake_up(&he_vcc->rx_waitq);
1744 goto return_host_buffers;
1745 }
1746
1747 #ifdef notdef
1748 if ((he_vcc->iov_tail - he_vcc->iov_head) > HE_MAXIOV) {
1749 hprintk("iovec full! cid 0x%x\n", cid);
1750 goto return_host_buffers;
1751 }
1752 #endif
1753 if (!RBRQ_END_PDU(he_dev->rbrq_head))
1754 goto next_rbrq_entry;
1755
1756 if (RBRQ_LEN_ERR(he_dev->rbrq_head)
1757 || RBRQ_CRC_ERR(he_dev->rbrq_head)) {
1758 HPRINTK("%s%s (%d.%d)\n",
1759 RBRQ_CRC_ERR(he_dev->rbrq_head)
1760 ? "CRC_ERR " : "",
1761 RBRQ_LEN_ERR(he_dev->rbrq_head)
1762 ? "LEN_ERR" : "",
1763 vcc->vpi, vcc->vci);
1764 atomic_inc(&vcc->stats->rx_err);
1765 goto return_host_buffers;
1766 }
1767
1768 skb = atm_alloc_charge(vcc, he_vcc->pdu_len + rx_skb_reserve,
1769 GFP_ATOMIC);
1770 if (!skb) {
1771 HPRINTK("charge failed (%d.%d)\n", vcc->vpi, vcc->vci);
1772 goto return_host_buffers;
1773 }
1774
1775 if (rx_skb_reserve > 0)
1776 skb_reserve(skb, rx_skb_reserve);
1777
1778 __net_timestamp(skb);
1779
1780 for (iov = he_vcc->iov_head;
1781 iov < he_vcc->iov_tail; ++iov) {
1782 if (iov->iov_base & RBP_SMALLBUF)
1783 memcpy(skb_put(skb, iov->iov_len),
1784 he_dev->rbps_virt[RBP_INDEX(iov->iov_base)].virt, iov->iov_len);
1785 else
1786 memcpy(skb_put(skb, iov->iov_len),
1787 he_dev->rbpl_virt[RBP_INDEX(iov->iov_base)].virt, iov->iov_len);
1788 }
1789
1790 switch (vcc->qos.aal) {
1791 case ATM_AAL0:
1792 /* 2.10.1.5 raw cell receive */
1793 skb->len = ATM_AAL0_SDU;
1794 skb_set_tail_pointer(skb, skb->len);
1795 break;
1796 case ATM_AAL5:
1797 /* 2.10.1.2 aal5 receive */
1798
1799 skb->len = AAL5_LEN(skb->data, he_vcc->pdu_len);
1800 skb_set_tail_pointer(skb, skb->len);
1801 #ifdef USE_CHECKSUM_HW
1802 if (vcc->vpi == 0 && vcc->vci >= ATM_NOT_RSV_VCI) {
1803 skb->ip_summed = CHECKSUM_COMPLETE;
1804 skb->csum = TCP_CKSUM(skb->data,
1805 he_vcc->pdu_len);
1806 }
1807 #endif
1808 break;
1809 }
1810
1811 #ifdef should_never_happen
1812 if (skb->len > vcc->qos.rxtp.max_sdu)
1813 hprintk("pdu_len (%d) > vcc->qos.rxtp.max_sdu (%d)! cid 0x%x\n", skb->len, vcc->qos.rxtp.max_sdu, cid);
1814 #endif
1815
1816 #ifdef notdef
1817 ATM_SKB(skb)->vcc = vcc;
1818 #endif
1819 spin_unlock(&he_dev->global_lock);
1820 vcc->push(vcc, skb);
1821 spin_lock(&he_dev->global_lock);
1822
1823 atomic_inc(&vcc->stats->rx);
1824
1825 return_host_buffers:
1826 ++pdus_assembled;
1827
1828 for (iov = he_vcc->iov_head;
1829 iov < he_vcc->iov_tail; ++iov) {
1830 if (iov->iov_base & RBP_SMALLBUF)
1831 rbp = &he_dev->rbps_base[RBP_INDEX(iov->iov_base)];
1832 else
1833 rbp = &he_dev->rbpl_base[RBP_INDEX(iov->iov_base)];
1834
1835 rbp->status &= ~RBP_LOANED;
1836 }
1837
1838 he_vcc->iov_tail = he_vcc->iov_head;
1839 he_vcc->pdu_len = 0;
1840
1841 next_rbrq_entry:
1842 he_dev->rbrq_head = (struct he_rbrq *)
1843 ((unsigned long) he_dev->rbrq_base |
1844 RBRQ_MASK(++he_dev->rbrq_head));
1845
1846 }
1847 read_unlock(&vcc_sklist_lock);
1848
1849 if (updated) {
1850 if (updated > he_dev->rbrq_peak)
1851 he_dev->rbrq_peak = updated;
1852
1853 he_writel(he_dev, RBRQ_MASK(he_dev->rbrq_head),
1854 G0_RBRQ_H + (group * 16));
1855 }
1856
1857 return pdus_assembled;
1858 }
1859
1860 static void
1861 he_service_tbrq(struct he_dev *he_dev, int group)
1862 {
1863 struct he_tbrq *tbrq_tail = (struct he_tbrq *)
1864 ((unsigned long)he_dev->tbrq_base |
1865 he_dev->hsp->group[group].tbrq_tail);
1866 struct he_tpd *tpd;
1867 int slot, updated = 0;
1868 struct he_tpd *__tpd;
1869
1870 /* 2.1.6 transmit buffer return queue */
1871
1872 while (he_dev->tbrq_head != tbrq_tail) {
1873 ++updated;
1874
1875 HPRINTK("tbrq%d 0x%x%s%s\n",
1876 group,
1877 TBRQ_TPD(he_dev->tbrq_head),
1878 TBRQ_EOS(he_dev->tbrq_head) ? " EOS" : "",
1879 TBRQ_MULTIPLE(he_dev->tbrq_head) ? " MULTIPLE" : "");
1880 tpd = NULL;
1881 list_for_each_entry(__tpd, &he_dev->outstanding_tpds, entry) {
1882 if (TPD_ADDR(__tpd->status) == TBRQ_TPD(he_dev->tbrq_head)) {
1883 tpd = __tpd;
1884 list_del(&__tpd->entry);
1885 break;
1886 }
1887 }
1888
1889 if (tpd == NULL) {
1890 hprintk("unable to locate tpd for dma buffer %x\n",
1891 TBRQ_TPD(he_dev->tbrq_head));
1892 goto next_tbrq_entry;
1893 }
1894
1895 if (TBRQ_EOS(he_dev->tbrq_head)) {
1896 HPRINTK("wake_up(tx_waitq) cid 0x%x\n",
1897 he_mkcid(he_dev, tpd->vcc->vpi, tpd->vcc->vci));
1898 if (tpd->vcc)
1899 wake_up(&HE_VCC(tpd->vcc)->tx_waitq);
1900
1901 goto next_tbrq_entry;
1902 }
1903
1904 for (slot = 0; slot < TPD_MAXIOV; ++slot) {
1905 if (tpd->iovec[slot].addr)
1906 pci_unmap_single(he_dev->pci_dev,
1907 tpd->iovec[slot].addr,
1908 tpd->iovec[slot].len & TPD_LEN_MASK,
1909 PCI_DMA_TODEVICE);
1910 if (tpd->iovec[slot].len & TPD_LST)
1911 break;
1912
1913 }
1914
1915 if (tpd->skb) { /* && !TBRQ_MULTIPLE(he_dev->tbrq_head) */
1916 if (tpd->vcc && tpd->vcc->pop)
1917 tpd->vcc->pop(tpd->vcc, tpd->skb);
1918 else
1919 dev_kfree_skb_any(tpd->skb);
1920 }
1921
1922 next_tbrq_entry:
1923 if (tpd)
1924 pci_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status));
1925 he_dev->tbrq_head = (struct he_tbrq *)
1926 ((unsigned long) he_dev->tbrq_base |
1927 TBRQ_MASK(++he_dev->tbrq_head));
1928 }
1929
1930 if (updated) {
1931 if (updated > he_dev->tbrq_peak)
1932 he_dev->tbrq_peak = updated;
1933
1934 he_writel(he_dev, TBRQ_MASK(he_dev->tbrq_head),
1935 G0_TBRQ_H + (group * 16));
1936 }
1937 }
1938
1939
1940 static void
1941 he_service_rbpl(struct he_dev *he_dev, int group)
1942 {
1943 struct he_rbp *newtail;
1944 struct he_rbp *rbpl_head;
1945 int moved = 0;
1946
1947 rbpl_head = (struct he_rbp *) ((unsigned long)he_dev->rbpl_base |
1948 RBPL_MASK(he_readl(he_dev, G0_RBPL_S)));
1949
1950 for (;;) {
1951 newtail = (struct he_rbp *) ((unsigned long)he_dev->rbpl_base |
1952 RBPL_MASK(he_dev->rbpl_tail+1));
1953
1954 /* table 3.42 -- rbpl_tail should never be set to rbpl_head */
1955 if ((newtail == rbpl_head) || (newtail->status & RBP_LOANED))
1956 break;
1957
1958 newtail->status |= RBP_LOANED;
1959 he_dev->rbpl_tail = newtail;
1960 ++moved;
1961 }
1962
1963 if (moved)
1964 he_writel(he_dev, RBPL_MASK(he_dev->rbpl_tail), G0_RBPL_T);
1965 }
1966
1967 static void
1968 he_service_rbps(struct he_dev *he_dev, int group)
1969 {
1970 struct he_rbp *newtail;
1971 struct he_rbp *rbps_head;
1972 int moved = 0;
1973
1974 rbps_head = (struct he_rbp *) ((unsigned long)he_dev->rbps_base |
1975 RBPS_MASK(he_readl(he_dev, G0_RBPS_S)));
1976
1977 for (;;) {
1978 newtail = (struct he_rbp *) ((unsigned long)he_dev->rbps_base |
1979 RBPS_MASK(he_dev->rbps_tail+1));
1980
1981 /* table 3.42 -- rbps_tail should never be set to rbps_head */
1982 if ((newtail == rbps_head) || (newtail->status & RBP_LOANED))
1983 break;
1984
1985 newtail->status |= RBP_LOANED;
1986 he_dev->rbps_tail = newtail;
1987 ++moved;
1988 }
1989
1990 if (moved)
1991 he_writel(he_dev, RBPS_MASK(he_dev->rbps_tail), G0_RBPS_T);
1992 }
1993
1994 static void
1995 he_tasklet(unsigned long data)
1996 {
1997 unsigned long flags;
1998 struct he_dev *he_dev = (struct he_dev *) data;
1999 int group, type;
2000 int updated = 0;
2001
2002 HPRINTK("tasklet (0x%lx)\n", data);
2003 spin_lock_irqsave(&he_dev->global_lock, flags);
2004
2005 while (he_dev->irq_head != he_dev->irq_tail) {
2006 ++updated;
2007
2008 type = ITYPE_TYPE(he_dev->irq_head->isw);
2009 group = ITYPE_GROUP(he_dev->irq_head->isw);
2010
2011 switch (type) {
2012 case ITYPE_RBRQ_THRESH:
2013 HPRINTK("rbrq%d threshold\n", group);
2014 /* fall through */
2015 case ITYPE_RBRQ_TIMER:
2016 if (he_service_rbrq(he_dev, group)) {
2017 he_service_rbpl(he_dev, group);
2018 he_service_rbps(he_dev, group);
2019 }
2020 break;
2021 case ITYPE_TBRQ_THRESH:
2022 HPRINTK("tbrq%d threshold\n", group);
2023 /* fall through */
2024 case ITYPE_TPD_COMPLETE:
2025 he_service_tbrq(he_dev, group);
2026 break;
2027 case ITYPE_RBPL_THRESH:
2028 he_service_rbpl(he_dev, group);
2029 break;
2030 case ITYPE_RBPS_THRESH:
2031 he_service_rbps(he_dev, group);
2032 break;
2033 case ITYPE_PHY:
2034 HPRINTK("phy interrupt\n");
2035 #ifdef CONFIG_ATM_HE_USE_SUNI
2036 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2037 if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->interrupt)
2038 he_dev->atm_dev->phy->interrupt(he_dev->atm_dev);
2039 spin_lock_irqsave(&he_dev->global_lock, flags);
2040 #endif
2041 break;
2042 case ITYPE_OTHER:
2043 switch (type|group) {
2044 case ITYPE_PARITY:
2045 hprintk("parity error\n");
2046 break;
2047 case ITYPE_ABORT:
2048 hprintk("abort 0x%x\n", he_readl(he_dev, ABORT_ADDR));
2049 break;
2050 }
2051 break;
2052 case ITYPE_TYPE(ITYPE_INVALID):
2053 /* see 8.1.1 -- check all queues */
2054
2055 HPRINTK("isw not updated 0x%x\n", he_dev->irq_head->isw);
2056
2057 he_service_rbrq(he_dev, 0);
2058 he_service_rbpl(he_dev, 0);
2059 he_service_rbps(he_dev, 0);
2060 he_service_tbrq(he_dev, 0);
2061 break;
2062 default:
2063 hprintk("bad isw 0x%x?\n", he_dev->irq_head->isw);
2064 }
2065
2066 he_dev->irq_head->isw = ITYPE_INVALID;
2067
2068 he_dev->irq_head = (struct he_irq *) NEXT_ENTRY(he_dev->irq_base, he_dev->irq_head, IRQ_MASK);
2069 }
2070
2071 if (updated) {
2072 if (updated > he_dev->irq_peak)
2073 he_dev->irq_peak = updated;
2074
2075 he_writel(he_dev,
2076 IRQ_SIZE(CONFIG_IRQ_SIZE) |
2077 IRQ_THRESH(CONFIG_IRQ_THRESH) |
2078 IRQ_TAIL(he_dev->irq_tail), IRQ0_HEAD);
2079 (void) he_readl(he_dev, INT_FIFO); /* 8.1.2 controller errata; flush posted writes */
2080 }
2081 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2082 }
2083
2084 static irqreturn_t
2085 he_irq_handler(int irq, void *dev_id)
2086 {
2087 unsigned long flags;
2088 struct he_dev *he_dev = (struct he_dev * )dev_id;
2089 int handled = 0;
2090
2091 if (he_dev == NULL)
2092 return IRQ_NONE;
2093
2094 spin_lock_irqsave(&he_dev->global_lock, flags);
2095
2096 he_dev->irq_tail = (struct he_irq *) (((unsigned long)he_dev->irq_base) |
2097 (*he_dev->irq_tailoffset << 2));
2098
2099 if (he_dev->irq_tail == he_dev->irq_head) {
2100 HPRINTK("tailoffset not updated?\n");
2101 he_dev->irq_tail = (struct he_irq *) ((unsigned long)he_dev->irq_base |
2102 ((he_readl(he_dev, IRQ0_BASE) & IRQ_MASK) << 2));
2103 (void) he_readl(he_dev, INT_FIFO); /* 8.1.2 controller errata */
2104 }
2105
2106 #ifdef DEBUG
2107 if (he_dev->irq_head == he_dev->irq_tail /* && !IRQ_PENDING */)
2108 hprintk("spurious (or shared) interrupt?\n");
2109 #endif
2110
2111 if (he_dev->irq_head != he_dev->irq_tail) {
2112 handled = 1;
2113 tasklet_schedule(&he_dev->tasklet);
2114 he_writel(he_dev, INT_CLEAR_A, INT_FIFO); /* clear interrupt */
2115 (void) he_readl(he_dev, INT_FIFO); /* flush posted writes */
2116 }
2117 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2118 return IRQ_RETVAL(handled);
2119
2120 }
2121
2122 static __inline__ void
2123 __enqueue_tpd(struct he_dev *he_dev, struct he_tpd *tpd, unsigned cid)
2124 {
2125 struct he_tpdrq *new_tail;
2126
2127 HPRINTK("tpdrq %p cid 0x%x -> tpdrq_tail %p\n",
2128 tpd, cid, he_dev->tpdrq_tail);
2129
2130 /* new_tail = he_dev->tpdrq_tail; */
2131 new_tail = (struct he_tpdrq *) ((unsigned long) he_dev->tpdrq_base |
2132 TPDRQ_MASK(he_dev->tpdrq_tail+1));
2133
2134 /*
2135 * check to see if we are about to set the tail == head
2136 * if true, update the head pointer from the adapter
2137 * to see if this is really the case (reading the queue
2138 * head for every enqueue would be unnecessarily slow)
2139 */
2140
2141 if (new_tail == he_dev->tpdrq_head) {
2142 he_dev->tpdrq_head = (struct he_tpdrq *)
2143 (((unsigned long)he_dev->tpdrq_base) |
2144 TPDRQ_MASK(he_readl(he_dev, TPDRQ_B_H)));
2145
2146 if (new_tail == he_dev->tpdrq_head) {
2147 int slot;
2148
2149 hprintk("tpdrq full (cid 0x%x)\n", cid);
2150 /*
2151 * FIXME
2152 * push tpd onto a transmit backlog queue
2153 * after service_tbrq, service the backlog
2154 * for now, we just drop the pdu
2155 */
2156 for (slot = 0; slot < TPD_MAXIOV; ++slot) {
2157 if (tpd->iovec[slot].addr)
2158 pci_unmap_single(he_dev->pci_dev,
2159 tpd->iovec[slot].addr,
2160 tpd->iovec[slot].len & TPD_LEN_MASK,
2161 PCI_DMA_TODEVICE);
2162 }
2163 if (tpd->skb) {
2164 if (tpd->vcc->pop)
2165 tpd->vcc->pop(tpd->vcc, tpd->skb);
2166 else
2167 dev_kfree_skb_any(tpd->skb);
2168 atomic_inc(&tpd->vcc->stats->tx_err);
2169 }
2170 pci_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status));
2171 return;
2172 }
2173 }
2174
2175 /* 2.1.5 transmit packet descriptor ready queue */
2176 list_add_tail(&tpd->entry, &he_dev->outstanding_tpds);
2177 he_dev->tpdrq_tail->tpd = TPD_ADDR(tpd->status);
2178 he_dev->tpdrq_tail->cid = cid;
2179 wmb();
2180
2181 he_dev->tpdrq_tail = new_tail;
2182
2183 he_writel(he_dev, TPDRQ_MASK(he_dev->tpdrq_tail), TPDRQ_T);
2184 (void) he_readl(he_dev, TPDRQ_T); /* flush posted writes */
2185 }
2186
2187 static int
2188 he_open(struct atm_vcc *vcc)
2189 {
2190 unsigned long flags;
2191 struct he_dev *he_dev = HE_DEV(vcc->dev);
2192 struct he_vcc *he_vcc;
2193 int err = 0;
2194 unsigned cid, rsr0, rsr1, rsr4, tsr0, tsr0_aal, tsr4, period, reg, clock;
2195 short vpi = vcc->vpi;
2196 int vci = vcc->vci;
2197
2198 if (vci == ATM_VCI_UNSPEC || vpi == ATM_VPI_UNSPEC)
2199 return 0;
2200
2201 HPRINTK("open vcc %p %d.%d\n", vcc, vpi, vci);
2202
2203 set_bit(ATM_VF_ADDR, &vcc->flags);
2204
2205 cid = he_mkcid(he_dev, vpi, vci);
2206
2207 he_vcc = kmalloc(sizeof(struct he_vcc), GFP_ATOMIC);
2208 if (he_vcc == NULL) {
2209 hprintk("unable to allocate he_vcc during open\n");
2210 return -ENOMEM;
2211 }
2212
2213 he_vcc->iov_tail = he_vcc->iov_head;
2214 he_vcc->pdu_len = 0;
2215 he_vcc->rc_index = -1;
2216
2217 init_waitqueue_head(&he_vcc->rx_waitq);
2218 init_waitqueue_head(&he_vcc->tx_waitq);
2219
2220 vcc->dev_data = he_vcc;
2221
2222 if (vcc->qos.txtp.traffic_class != ATM_NONE) {
2223 int pcr_goal;
2224
2225 pcr_goal = atm_pcr_goal(&vcc->qos.txtp);
2226 if (pcr_goal == 0)
2227 pcr_goal = he_dev->atm_dev->link_rate;
2228 if (pcr_goal < 0) /* means round down, technically */
2229 pcr_goal = -pcr_goal;
2230
2231 HPRINTK("open tx cid 0x%x pcr_goal %d\n", cid, pcr_goal);
2232
2233 switch (vcc->qos.aal) {
2234 case ATM_AAL5:
2235 tsr0_aal = TSR0_AAL5;
2236 tsr4 = TSR4_AAL5;
2237 break;
2238 case ATM_AAL0:
2239 tsr0_aal = TSR0_AAL0_SDU;
2240 tsr4 = TSR4_AAL0_SDU;
2241 break;
2242 default:
2243 err = -EINVAL;
2244 goto open_failed;
2245 }
2246
2247 spin_lock_irqsave(&he_dev->global_lock, flags);
2248 tsr0 = he_readl_tsr0(he_dev, cid);
2249 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2250
2251 if (TSR0_CONN_STATE(tsr0) != 0) {
2252 hprintk("cid 0x%x not idle (tsr0 = 0x%x)\n", cid, tsr0);
2253 err = -EBUSY;
2254 goto open_failed;
2255 }
2256
2257 switch (vcc->qos.txtp.traffic_class) {
2258 case ATM_UBR:
2259 /* 2.3.3.1 open connection ubr */
2260
2261 tsr0 = TSR0_UBR | TSR0_GROUP(0) | tsr0_aal |
2262 TSR0_USE_WMIN | TSR0_UPDATE_GER;
2263 break;
2264
2265 case ATM_CBR:
2266 /* 2.3.3.2 open connection cbr */
2267
2268 /* 8.2.3 cbr scheduler wrap problem -- limit to 90% total link rate */
2269 if ((he_dev->total_bw + pcr_goal)
2270 > (he_dev->atm_dev->link_rate * 9 / 10))
2271 {
2272 err = -EBUSY;
2273 goto open_failed;
2274 }
2275
2276 spin_lock_irqsave(&he_dev->global_lock, flags); /* also protects he_dev->cs_stper[] */
2277
2278 /* find an unused cs_stper register */
2279 for (reg = 0; reg < HE_NUM_CS_STPER; ++reg)
2280 if (he_dev->cs_stper[reg].inuse == 0 ||
2281 he_dev->cs_stper[reg].pcr == pcr_goal)
2282 break;
2283
2284 if (reg == HE_NUM_CS_STPER) {
2285 err = -EBUSY;
2286 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2287 goto open_failed;
2288 }
2289
2290 he_dev->total_bw += pcr_goal;
2291
2292 he_vcc->rc_index = reg;
2293 ++he_dev->cs_stper[reg].inuse;
2294 he_dev->cs_stper[reg].pcr = pcr_goal;
2295
2296 clock = he_is622(he_dev) ? 66667000 : 50000000;
2297 period = clock / pcr_goal;
2298
2299 HPRINTK("rc_index = %d period = %d\n",
2300 reg, period);
2301
2302 he_writel_mbox(he_dev, rate_to_atmf(period/2),
2303 CS_STPER0 + reg);
2304 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2305
2306 tsr0 = TSR0_CBR | TSR0_GROUP(0) | tsr0_aal |
2307 TSR0_RC_INDEX(reg);
2308
2309 break;
2310 default:
2311 err = -EINVAL;
2312 goto open_failed;
2313 }
2314
2315 spin_lock_irqsave(&he_dev->global_lock, flags);
2316
2317 he_writel_tsr0(he_dev, tsr0, cid);
2318 he_writel_tsr4(he_dev, tsr4 | 1, cid);
2319 he_writel_tsr1(he_dev, TSR1_MCR(rate_to_atmf(0)) |
2320 TSR1_PCR(rate_to_atmf(pcr_goal)), cid);
2321 he_writel_tsr2(he_dev, TSR2_ACR(rate_to_atmf(pcr_goal)), cid);
2322 he_writel_tsr9(he_dev, TSR9_OPEN_CONN, cid);
2323
2324 he_writel_tsr3(he_dev, 0x0, cid);
2325 he_writel_tsr5(he_dev, 0x0, cid);
2326 he_writel_tsr6(he_dev, 0x0, cid);
2327 he_writel_tsr7(he_dev, 0x0, cid);
2328 he_writel_tsr8(he_dev, 0x0, cid);
2329 he_writel_tsr10(he_dev, 0x0, cid);
2330 he_writel_tsr11(he_dev, 0x0, cid);
2331 he_writel_tsr12(he_dev, 0x0, cid);
2332 he_writel_tsr13(he_dev, 0x0, cid);
2333 he_writel_tsr14(he_dev, 0x0, cid);
2334 (void) he_readl_tsr0(he_dev, cid); /* flush posted writes */
2335 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2336 }
2337
2338 if (vcc->qos.rxtp.traffic_class != ATM_NONE) {
2339 unsigned aal;
2340
2341 HPRINTK("open rx cid 0x%x (rx_waitq %p)\n", cid,
2342 &HE_VCC(vcc)->rx_waitq);
2343
2344 switch (vcc->qos.aal) {
2345 case ATM_AAL5:
2346 aal = RSR0_AAL5;
2347 break;
2348 case ATM_AAL0:
2349 aal = RSR0_RAWCELL;
2350 break;
2351 default:
2352 err = -EINVAL;
2353 goto open_failed;
2354 }
2355
2356 spin_lock_irqsave(&he_dev->global_lock, flags);
2357
2358 rsr0 = he_readl_rsr0(he_dev, cid);
2359 if (rsr0 & RSR0_OPEN_CONN) {
2360 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2361
2362 hprintk("cid 0x%x not idle (rsr0 = 0x%x)\n", cid, rsr0);
2363 err = -EBUSY;
2364 goto open_failed;
2365 }
2366
2367 rsr1 = RSR1_GROUP(0);
2368 rsr4 = RSR4_GROUP(0);
2369 rsr0 = vcc->qos.rxtp.traffic_class == ATM_UBR ?
2370 (RSR0_EPD_ENABLE|RSR0_PPD_ENABLE) : 0;
2371
2372 #ifdef USE_CHECKSUM_HW
2373 if (vpi == 0 && vci >= ATM_NOT_RSV_VCI)
2374 rsr0 |= RSR0_TCP_CKSUM;
2375 #endif
2376
2377 he_writel_rsr4(he_dev, rsr4, cid);
2378 he_writel_rsr1(he_dev, rsr1, cid);
2379 /* 5.1.11 last parameter initialized should be
2380 the open/closed indication in rsr0 */
2381 he_writel_rsr0(he_dev,
2382 rsr0 | RSR0_START_PDU | RSR0_OPEN_CONN | aal, cid);
2383 (void) he_readl_rsr0(he_dev, cid); /* flush posted writes */
2384
2385 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2386 }
2387
2388 open_failed:
2389
2390 if (err) {
2391 kfree(he_vcc);
2392 clear_bit(ATM_VF_ADDR, &vcc->flags);
2393 }
2394 else
2395 set_bit(ATM_VF_READY, &vcc->flags);
2396
2397 return err;
2398 }
2399
2400 static void
2401 he_close(struct atm_vcc *vcc)
2402 {
2403 unsigned long flags;
2404 DECLARE_WAITQUEUE(wait, current);
2405 struct he_dev *he_dev = HE_DEV(vcc->dev);
2406 struct he_tpd *tpd;
2407 unsigned cid;
2408 struct he_vcc *he_vcc = HE_VCC(vcc);
2409 #define MAX_RETRY 30
2410 int retry = 0, sleep = 1, tx_inuse;
2411
2412 HPRINTK("close vcc %p %d.%d\n", vcc, vcc->vpi, vcc->vci);
2413
2414 clear_bit(ATM_VF_READY, &vcc->flags);
2415 cid = he_mkcid(he_dev, vcc->vpi, vcc->vci);
2416
2417 if (vcc->qos.rxtp.traffic_class != ATM_NONE) {
2418 int timeout;
2419
2420 HPRINTK("close rx cid 0x%x\n", cid);
2421
2422 /* 2.7.2.2 close receive operation */
2423
2424 /* wait for previous close (if any) to finish */
2425
2426 spin_lock_irqsave(&he_dev->global_lock, flags);
2427 while (he_readl(he_dev, RCC_STAT) & RCC_BUSY) {
2428 HPRINTK("close cid 0x%x RCC_BUSY\n", cid);
2429 udelay(250);
2430 }
2431
2432 set_current_state(TASK_UNINTERRUPTIBLE);
2433 add_wait_queue(&he_vcc->rx_waitq, &wait);
2434
2435 he_writel_rsr0(he_dev, RSR0_CLOSE_CONN, cid);
2436 (void) he_readl_rsr0(he_dev, cid); /* flush posted writes */
2437 he_writel_mbox(he_dev, cid, RXCON_CLOSE);
2438 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2439
2440 timeout = schedule_timeout(30*HZ);
2441
2442 remove_wait_queue(&he_vcc->rx_waitq, &wait);
2443 set_current_state(TASK_RUNNING);
2444
2445 if (timeout == 0)
2446 hprintk("close rx timeout cid 0x%x\n", cid);
2447
2448 HPRINTK("close rx cid 0x%x complete\n", cid);
2449
2450 }
2451
2452 if (vcc->qos.txtp.traffic_class != ATM_NONE) {
2453 volatile unsigned tsr4, tsr0;
2454 int timeout;
2455
2456 HPRINTK("close tx cid 0x%x\n", cid);
2457
2458 /* 2.1.2
2459 *
2460 * ... the host must first stop queueing packets to the TPDRQ
2461 * on the connection to be closed, then wait for all outstanding
2462 * packets to be transmitted and their buffers returned to the
2463 * TBRQ. When the last packet on the connection arrives in the
2464 * TBRQ, the host issues the close command to the adapter.
2465 */
2466
2467 while (((tx_inuse = atomic_read(&sk_atm(vcc)->sk_wmem_alloc)) > 0) &&
2468 (retry < MAX_RETRY)) {
2469 msleep(sleep);
2470 if (sleep < 250)
2471 sleep = sleep * 2;
2472
2473 ++retry;
2474 }
2475
2476 if (tx_inuse)
2477 hprintk("close tx cid 0x%x tx_inuse = %d\n", cid, tx_inuse);
2478
2479 /* 2.3.1.1 generic close operations with flush */
2480
2481 spin_lock_irqsave(&he_dev->global_lock, flags);
2482 he_writel_tsr4_upper(he_dev, TSR4_FLUSH_CONN, cid);
2483 /* also clears TSR4_SESSION_ENDED */
2484
2485 switch (vcc->qos.txtp.traffic_class) {
2486 case ATM_UBR:
2487 he_writel_tsr1(he_dev,
2488 TSR1_MCR(rate_to_atmf(200000))
2489 | TSR1_PCR(0), cid);
2490 break;
2491 case ATM_CBR:
2492 he_writel_tsr14_upper(he_dev, TSR14_DELETE, cid);
2493 break;
2494 }
2495 (void) he_readl_tsr4(he_dev, cid); /* flush posted writes */
2496
2497 tpd = __alloc_tpd(he_dev);
2498 if (tpd == NULL) {
2499 hprintk("close tx he_alloc_tpd failed cid 0x%x\n", cid);
2500 goto close_tx_incomplete;
2501 }
2502 tpd->status |= TPD_EOS | TPD_INT;
2503 tpd->skb = NULL;
2504 tpd->vcc = vcc;
2505 wmb();
2506
2507 set_current_state(TASK_UNINTERRUPTIBLE);
2508 add_wait_queue(&he_vcc->tx_waitq, &wait);
2509 __enqueue_tpd(he_dev, tpd, cid);
2510 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2511
2512 timeout = schedule_timeout(30*HZ);
2513
2514 remove_wait_queue(&he_vcc->tx_waitq, &wait);
2515 set_current_state(TASK_RUNNING);
2516
2517 spin_lock_irqsave(&he_dev->global_lock, flags);
2518
2519 if (timeout == 0) {
2520 hprintk("close tx timeout cid 0x%x\n", cid);
2521 goto close_tx_incomplete;
2522 }
2523
2524 while (!((tsr4 = he_readl_tsr4(he_dev, cid)) & TSR4_SESSION_ENDED)) {
2525 HPRINTK("close tx cid 0x%x !TSR4_SESSION_ENDED (tsr4 = 0x%x)\n", cid, tsr4);
2526 udelay(250);
2527 }
2528
2529 while (TSR0_CONN_STATE(tsr0 = he_readl_tsr0(he_dev, cid)) != 0) {
2530 HPRINTK("close tx cid 0x%x TSR0_CONN_STATE != 0 (tsr0 = 0x%x)\n", cid, tsr0);
2531 udelay(250);
2532 }
2533
2534 close_tx_incomplete:
2535
2536 if (vcc->qos.txtp.traffic_class == ATM_CBR) {
2537 int reg = he_vcc->rc_index;
2538
2539 HPRINTK("cs_stper reg = %d\n", reg);
2540
2541 if (he_dev->cs_stper[reg].inuse == 0)
2542 hprintk("cs_stper[%d].inuse = 0!\n", reg);
2543 else
2544 --he_dev->cs_stper[reg].inuse;
2545
2546 he_dev->total_bw -= he_dev->cs_stper[reg].pcr;
2547 }
2548 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2549
2550 HPRINTK("close tx cid 0x%x complete\n", cid);
2551 }
2552
2553 kfree(he_vcc);
2554
2555 clear_bit(ATM_VF_ADDR, &vcc->flags);
2556 }
2557
2558 static int
2559 he_send(struct atm_vcc *vcc, struct sk_buff *skb)
2560 {
2561 unsigned long flags;
2562 struct he_dev *he_dev = HE_DEV(vcc->dev);
2563 unsigned cid = he_mkcid(he_dev, vcc->vpi, vcc->vci);
2564 struct he_tpd *tpd;
2565 #ifdef USE_SCATTERGATHER
2566 int i, slot = 0;
2567 #endif
2568
2569 #define HE_TPD_BUFSIZE 0xffff
2570
2571 HPRINTK("send %d.%d\n", vcc->vpi, vcc->vci);
2572
2573 if ((skb->len > HE_TPD_BUFSIZE) ||
2574 ((vcc->qos.aal == ATM_AAL0) && (skb->len != ATM_AAL0_SDU))) {
2575 hprintk("buffer too large (or small) -- %d bytes\n", skb->len );
2576 if (vcc->pop)
2577 vcc->pop(vcc, skb);
2578 else
2579 dev_kfree_skb_any(skb);
2580 atomic_inc(&vcc->stats->tx_err);
2581 return -EINVAL;
2582 }
2583
2584 #ifndef USE_SCATTERGATHER
2585 if (skb_shinfo(skb)->nr_frags) {
2586 hprintk("no scatter/gather support\n");
2587 if (vcc->pop)
2588 vcc->pop(vcc, skb);
2589 else
2590 dev_kfree_skb_any(skb);
2591 atomic_inc(&vcc->stats->tx_err);
2592 return -EINVAL;
2593 }
2594 #endif
2595 spin_lock_irqsave(&he_dev->global_lock, flags);
2596
2597 tpd = __alloc_tpd(he_dev);
2598 if (tpd == NULL) {
2599 if (vcc->pop)
2600 vcc->pop(vcc, skb);
2601 else
2602 dev_kfree_skb_any(skb);
2603 atomic_inc(&vcc->stats->tx_err);
2604 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2605 return -ENOMEM;
2606 }
2607
2608 if (vcc->qos.aal == ATM_AAL5)
2609 tpd->status |= TPD_CELLTYPE(TPD_USERCELL);
2610 else {
2611 char *pti_clp = (void *) (skb->data + 3);
2612 int clp, pti;
2613
2614 pti = (*pti_clp & ATM_HDR_PTI_MASK) >> ATM_HDR_PTI_SHIFT;
2615 clp = (*pti_clp & ATM_HDR_CLP);
2616 tpd->status |= TPD_CELLTYPE(pti);
2617 if (clp)
2618 tpd->status |= TPD_CLP;
2619
2620 skb_pull(skb, ATM_AAL0_SDU - ATM_CELL_PAYLOAD);
2621 }
2622
2623 #ifdef USE_SCATTERGATHER
2624 tpd->iovec[slot].addr = pci_map_single(he_dev->pci_dev, skb->data,
2625 skb->len - skb->data_len, PCI_DMA_TODEVICE);
2626 tpd->iovec[slot].len = skb->len - skb->data_len;
2627 ++slot;
2628
2629 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2630 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2631
2632 if (slot == TPD_MAXIOV) { /* queue tpd; start new tpd */
2633 tpd->vcc = vcc;
2634 tpd->skb = NULL; /* not the last fragment
2635 so dont ->push() yet */
2636 wmb();
2637
2638 __enqueue_tpd(he_dev, tpd, cid);
2639 tpd = __alloc_tpd(he_dev);
2640 if (tpd == NULL) {
2641 if (vcc->pop)
2642 vcc->pop(vcc, skb);
2643 else
2644 dev_kfree_skb_any(skb);
2645 atomic_inc(&vcc->stats->tx_err);
2646 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2647 return -ENOMEM;
2648 }
2649 tpd->status |= TPD_USERCELL;
2650 slot = 0;
2651 }
2652
2653 tpd->iovec[slot].addr = pci_map_single(he_dev->pci_dev,
2654 (void *) page_address(frag->page) + frag->page_offset,
2655 frag->size, PCI_DMA_TODEVICE);
2656 tpd->iovec[slot].len = frag->size;
2657 ++slot;
2658
2659 }
2660
2661 tpd->iovec[slot - 1].len |= TPD_LST;
2662 #else
2663 tpd->address0 = pci_map_single(he_dev->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE);
2664 tpd->length0 = skb->len | TPD_LST;
2665 #endif
2666 tpd->status |= TPD_INT;
2667
2668 tpd->vcc = vcc;
2669 tpd->skb = skb;
2670 wmb();
2671 ATM_SKB(skb)->vcc = vcc;
2672
2673 __enqueue_tpd(he_dev, tpd, cid);
2674 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2675
2676 atomic_inc(&vcc->stats->tx);
2677
2678 return 0;
2679 }
2680
2681 static int
2682 he_ioctl(struct atm_dev *atm_dev, unsigned int cmd, void __user *arg)
2683 {
2684 unsigned long flags;
2685 struct he_dev *he_dev = HE_DEV(atm_dev);
2686 struct he_ioctl_reg reg;
2687 int err = 0;
2688
2689 switch (cmd) {
2690 case HE_GET_REG:
2691 if (!capable(CAP_NET_ADMIN))
2692 return -EPERM;
2693
2694 if (copy_from_user(&reg, arg,
2695 sizeof(struct he_ioctl_reg)))
2696 return -EFAULT;
2697
2698 spin_lock_irqsave(&he_dev->global_lock, flags);
2699 switch (reg.type) {
2700 case HE_REGTYPE_PCI:
2701 if (reg.addr < 0 || reg.addr >= HE_REGMAP_SIZE) {
2702 err = -EINVAL;
2703 break;
2704 }
2705
2706 reg.val = he_readl(he_dev, reg.addr);
2707 break;
2708 case HE_REGTYPE_RCM:
2709 reg.val =
2710 he_readl_rcm(he_dev, reg.addr);
2711 break;
2712 case HE_REGTYPE_TCM:
2713 reg.val =
2714 he_readl_tcm(he_dev, reg.addr);
2715 break;
2716 case HE_REGTYPE_MBOX:
2717 reg.val =
2718 he_readl_mbox(he_dev, reg.addr);
2719 break;
2720 default:
2721 err = -EINVAL;
2722 break;
2723 }
2724 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2725 if (err == 0)
2726 if (copy_to_user(arg, &reg,
2727 sizeof(struct he_ioctl_reg)))
2728 return -EFAULT;
2729 break;
2730 default:
2731 #ifdef CONFIG_ATM_HE_USE_SUNI
2732 if (atm_dev->phy && atm_dev->phy->ioctl)
2733 err = atm_dev->phy->ioctl(atm_dev, cmd, arg);
2734 #else /* CONFIG_ATM_HE_USE_SUNI */
2735 err = -EINVAL;
2736 #endif /* CONFIG_ATM_HE_USE_SUNI */
2737 break;
2738 }
2739
2740 return err;
2741 }
2742
2743 static void
2744 he_phy_put(struct atm_dev *atm_dev, unsigned char val, unsigned long addr)
2745 {
2746 unsigned long flags;
2747 struct he_dev *he_dev = HE_DEV(atm_dev);
2748
2749 HPRINTK("phy_put(val 0x%x, addr 0x%lx)\n", val, addr);
2750
2751 spin_lock_irqsave(&he_dev->global_lock, flags);
2752 he_writel(he_dev, val, FRAMER + (addr*4));
2753 (void) he_readl(he_dev, FRAMER + (addr*4)); /* flush posted writes */
2754 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2755 }
2756
2757
2758 static unsigned char
2759 he_phy_get(struct atm_dev *atm_dev, unsigned long addr)
2760 {
2761 unsigned long flags;
2762 struct he_dev *he_dev = HE_DEV(atm_dev);
2763 unsigned reg;
2764
2765 spin_lock_irqsave(&he_dev->global_lock, flags);
2766 reg = he_readl(he_dev, FRAMER + (addr*4));
2767 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2768
2769 HPRINTK("phy_get(addr 0x%lx) =0x%x\n", addr, reg);
2770 return reg;
2771 }
2772
2773 static int
2774 he_proc_read(struct atm_dev *dev, loff_t *pos, char *page)
2775 {
2776 unsigned long flags;
2777 struct he_dev *he_dev = HE_DEV(dev);
2778 int left, i;
2779 #ifdef notdef
2780 struct he_rbrq *rbrq_tail;
2781 struct he_tpdrq *tpdrq_head;
2782 int rbpl_head, rbpl_tail;
2783 #endif
2784 static long mcc = 0, oec = 0, dcc = 0, cec = 0;
2785
2786
2787 left = *pos;
2788 if (!left--)
2789 return sprintf(page, "ATM he driver\n");
2790
2791 if (!left--)
2792 return sprintf(page, "%s%s\n\n",
2793 he_dev->prod_id, he_dev->media & 0x40 ? "SM" : "MM");
2794
2795 if (!left--)
2796 return sprintf(page, "Mismatched Cells VPI/VCI Not Open Dropped Cells RCM Dropped Cells\n");
2797
2798 spin_lock_irqsave(&he_dev->global_lock, flags);
2799 mcc += he_readl(he_dev, MCC);
2800 oec += he_readl(he_dev, OEC);
2801 dcc += he_readl(he_dev, DCC);
2802 cec += he_readl(he_dev, CEC);
2803 spin_unlock_irqrestore(&he_dev->global_lock, flags);
2804
2805 if (!left--)
2806 return sprintf(page, "%16ld %16ld %13ld %17ld\n\n",
2807 mcc, oec, dcc, cec);
2808
2809 if (!left--)
2810 return sprintf(page, "irq_size = %d inuse = ? peak = %d\n",
2811 CONFIG_IRQ_SIZE, he_dev->irq_peak);
2812
2813 if (!left--)
2814 return sprintf(page, "tpdrq_size = %d inuse = ?\n",
2815 CONFIG_TPDRQ_SIZE);
2816
2817 if (!left--)
2818 return sprintf(page, "rbrq_size = %d inuse = ? peak = %d\n",
2819 CONFIG_RBRQ_SIZE, he_dev->rbrq_peak);
2820
2821 if (!left--)
2822 return sprintf(page, "tbrq_size = %d peak = %d\n",
2823 CONFIG_TBRQ_SIZE, he_dev->tbrq_peak);
2824
2825
2826 #ifdef notdef
2827 rbpl_head = RBPL_MASK(he_readl(he_dev, G0_RBPL_S));
2828 rbpl_tail = RBPL_MASK(he_readl(he_dev, G0_RBPL_T));
2829
2830 inuse = rbpl_head - rbpl_tail;
2831 if (inuse < 0)
2832 inuse += CONFIG_RBPL_SIZE * sizeof(struct he_rbp);
2833 inuse /= sizeof(struct he_rbp);
2834
2835 if (!left--)
2836 return sprintf(page, "rbpl_size = %d inuse = %d\n\n",
2837 CONFIG_RBPL_SIZE, inuse);
2838 #endif
2839
2840 if (!left--)
2841 return sprintf(page, "rate controller periods (cbr)\n pcr #vc\n");
2842
2843 for (i = 0; i < HE_NUM_CS_STPER; ++i)
2844 if (!left--)
2845 return sprintf(page, "cs_stper%-2d %8ld %3d\n", i,
2846 he_dev->cs_stper[i].pcr,
2847 he_dev->cs_stper[i].inuse);
2848
2849 if (!left--)
2850 return sprintf(page, "total bw (cbr): %d (limit %d)\n",
2851 he_dev->total_bw, he_dev->atm_dev->link_rate * 10 / 9);
2852
2853 return 0;
2854 }
2855
2856 /* eeprom routines -- see 4.7 */
2857
2858 static u8 read_prom_byte(struct he_dev *he_dev, int addr)
2859 {
2860 u32 val = 0, tmp_read = 0;
2861 int i, j = 0;
2862 u8 byte_read = 0;
2863
2864 val = readl(he_dev->membase + HOST_CNTL);
2865 val &= 0xFFFFE0FF;
2866
2867 /* Turn on write enable */
2868 val |= 0x800;
2869 he_writel(he_dev, val, HOST_CNTL);
2870
2871 /* Send READ instruction */
2872 for (i = 0; i < ARRAY_SIZE(readtab); i++) {
2873 he_writel(he_dev, val | readtab[i], HOST_CNTL);
2874 udelay(EEPROM_DELAY);
2875 }
2876
2877 /* Next, we need to send the byte address to read from */
2878 for (i = 7; i >= 0; i--) {
2879 he_writel(he_dev, val | clocktab[j++] | (((addr >> i) & 1) << 9), HOST_CNTL);
2880 udelay(EEPROM_DELAY);
2881 he_writel(he_dev, val | clocktab[j++] | (((addr >> i) & 1) << 9), HOST_CNTL);
2882 udelay(EEPROM_DELAY);
2883 }
2884
2885 j = 0;
2886
2887 val &= 0xFFFFF7FF; /* Turn off write enable */
2888 he_writel(he_dev, val, HOST_CNTL);
2889
2890 /* Now, we can read data from the EEPROM by clocking it in */
2891 for (i = 7; i >= 0; i--) {
2892 he_writel(he_dev, val | clocktab[j++], HOST_CNTL);
2893 udelay(EEPROM_DELAY);
2894 tmp_read = he_readl(he_dev, HOST_CNTL);
2895 byte_read |= (unsigned char)
2896 ((tmp_read & ID_DOUT) >> ID_DOFFSET << i);
2897 he_writel(he_dev, val | clocktab[j++], HOST_CNTL);
2898 udelay(EEPROM_DELAY);
2899 }
2900
2901 he_writel(he_dev, val | ID_CS, HOST_CNTL);
2902 udelay(EEPROM_DELAY);
2903
2904 return byte_read;
2905 }
2906
2907 MODULE_LICENSE("GPL");
2908 MODULE_AUTHOR("chas williams <chas@cmf.nrl.navy.mil>");
2909 MODULE_DESCRIPTION("ForeRunnerHE ATM Adapter driver");
2910 module_param(disable64, bool, 0);
2911 MODULE_PARM_DESC(disable64, "disable 64-bit pci bus transfers");
2912 module_param(nvpibits, short, 0);
2913 MODULE_PARM_DESC(nvpibits, "numbers of bits for vpi (default 0)");
2914 module_param(nvcibits, short, 0);
2915 MODULE_PARM_DESC(nvcibits, "numbers of bits for vci (default 12)");
2916 module_param(rx_skb_reserve, short, 0);
2917 MODULE_PARM_DESC(rx_skb_reserve, "padding for receive skb (default 16)");
2918 module_param(irq_coalesce, bool, 0);
2919 MODULE_PARM_DESC(irq_coalesce, "use interrupt coalescing (default 1)");
2920 module_param(sdh, bool, 0);
2921 MODULE_PARM_DESC(sdh, "use SDH framing (default 0)");
2922
2923 static struct pci_device_id he_pci_tbl[] = {
2924 { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_HE, PCI_ANY_ID, PCI_ANY_ID,
2925 0, 0, 0 },
2926 { 0, }
2927 };
2928
2929 MODULE_DEVICE_TABLE(pci, he_pci_tbl);
2930
2931 static struct pci_driver he_driver = {
2932 .name = "he",
2933 .probe = he_init_one,
2934 .remove = __devexit_p(he_remove_one),
2935 .id_table = he_pci_tbl,
2936 };
2937
2938 static int __init he_init(void)
2939 {
2940 return pci_register_driver(&he_driver);
2941 }
2942
2943 static void __exit he_cleanup(void)
2944 {
2945 pci_unregister_driver(&he_driver);
2946 }
2947
2948 module_init(he_init);
2949 module_exit(he_cleanup);
Linux with added FPC-III support