![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hp100.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to hp100.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 root 1: /*
2: ** hp100.c
3: ** HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters
4: **
5: ** $Id: hp100.c,v 1.1 1999/04/26 05:52:18 tb Exp $
6: **
7: ** Based on the HP100 driver written by Jaroslav Kysela <[email protected]>
8: ** Extended for new busmaster capable chipsets by
9: ** Siegfried "Frieder" Loeffler (dg1sek) <[email protected]>
10: **
11: ** Maintained by: Jaroslav Kysela <[email protected]>
12: **
13: ** This driver has only been tested with
14: ** -- HP J2585B 10/100 Mbit/s PCI Busmaster
15: ** -- HP J2585A 10/100 Mbit/s PCI
16: ** -- HP J2970 10 Mbit/s PCI Combo 10base-T/BNC
17: ** -- HP J2973 10 Mbit/s PCI 10base-T
18: ** -- HP J2573 10/100 ISA
19: ** -- Compex ReadyLink ENET100-VG4 10/100 Mbit/s PCI / EISA
20: ** -- Compex FreedomLine 100/VG 10/100 Mbit/s ISA / EISA / PCI
21: **
22: ** but it should also work with the other CASCADE based adapters.
23: **
24: ** TODO:
25: ** - J2573 seems to hang sometimes when in shared memory mode.
26: ** - Mode for Priority TX
27: ** - Check PCI registers, performance might be improved?
28: ** - To reduce interrupt load in busmaster, one could switch off
29: ** the interrupts that are used to refill the queues whenever the
30: ** queues are filled up to more than a certain threshold.
31: ** - some updates for EISA version of card
32: **
33: **
34: ** This source/code is public free; you can distribute it and/or modify
35: ** it under terms of the GNU General Public License (published by the
36: ** Free Software Foundation) either version two of this License, or any
37: ** later version.
38: **
39: ** 1.55 -> 1.56
40: ** - removed printk in misc. interrupt and update statistics to allow
41: ** monitoring of card status
42: ** - timing changes in xmit routines, relogin to 100VG hub added when
43: ** driver does reset
44: ** - included fix for Compex FreedomLine PCI adapter
45: **
46: ** 1.54 -> 1.55
47: ** - fixed bad initialization in init_module
48: ** - added Compex FreedomLine adapter
49: ** - some fixes in card initialization
50: **
51: ** 1.53 -> 1.54
52: ** - added hardware multicast filter support (doesn't work)
53: ** - little changes in hp100_sense_lan routine
54: ** - added support for Coax and AUI (J2970)
55: ** - fix for multiple cards and hp100_mode parameter (insmod)
56: ** - fix for shared IRQ
57: **
58: ** 1.52 -> 1.53
59: ** - fixed bug in multicast support
60: **
61: */
62:
63: #define HP100_DEFAULT_PRIORITY_TX 0
64:
65: #undef HP100_DEBUG
66: #undef HP100_DEBUG_B /* Trace */
67: #undef HP100_DEBUG_BM /* Debug busmaster code (PDL stuff) */
68:
69: #undef HP100_DEBUG_TRAINING /* Debug login-to-hub procedure */
70: #undef HP100_DEBUG_TX
71: #undef HP100_DEBUG_IRQ
72: #undef HP100_DEBUG_RX
73:
74: #undef HP100_MULTICAST_FILTER /* Need to be debugged... */
75:
76: #include <linux/version.h>
77: #include <linux/module.h>
78: #include <linux/kernel.h>
79: #include <linux/sched.h>
80: #include <linux/string.h>
81: #include <linux/errno.h>
82: #include <linux/ioport.h>
83: #include <linux/malloc.h>
84: #include <linux/interrupt.h>
85: #include <linux/pci.h>
86: #include <linux/bios32.h>
87: #include <asm/bitops.h>
88: #include <asm/io.h>
89:
90: #include <linux/netdevice.h>
91: #include <linux/etherdevice.h>
92: #include <linux/skbuff.h>
93:
94: #include <linux/types.h>
95: #include <linux/config.h> /* for CONFIG_PCI */
96: #include <linux/delay.h>
97:
98: #if LINUX_VERSION_CODE < 0x020100
99: #define ioremap vremap
100: #define iounmap vfree
101: typedef struct enet_statistics hp100_stats_t;
102: #else
103: #define LINUX_2_1
104: typedef struct net_device_stats hp100_stats_t;
105: #endif
106:
107: #ifndef __initfunc
108: #define __initfunc(__initarg) __initarg
109: #else
110: #include <linux/init.h>
111: #endif
112:
113: #include "hp100.h"
114:
115: /*
116: * defines
117: */
118:
119: #define HP100_BUS_ISA 0
120: #define HP100_BUS_EISA 1
121: #define HP100_BUS_PCI 2
122:
123: #ifndef PCI_DEVICE_ID_HP_J2585B
124: #define PCI_DEVICE_ID_HP_J2585B 0x1031
125: #endif
126: #ifndef PCI_VENDOR_ID_COMPEX
127: #define PCI_VENDOR_ID_COMPEX 0x11f6
128: #endif
129: #ifndef PCI_DEVICE_ID_COMPEX_ENET100VG4
130: #define PCI_DEVICE_ID_COMPEX_ENET100VG4 0x0112
131: #endif
132: #ifndef PCI_VENDOR_ID_COMPEX2
133: #define PCI_VENDOR_ID_COMPEX2 0x101a
134: #endif
135: #ifndef PCI_DEVICE_ID_COMPEX2_100VG
136: #define PCI_DEVICE_ID_COMPEX2_100VG 0x0005
137: #endif
138:
139: #define HP100_REGION_SIZE 0x20 /* for ioports */
140:
141: #define HP100_MAX_PACKET_SIZE (1536+4)
142: #define HP100_MIN_PACKET_SIZE 60
143:
144: #ifndef HP100_DEFAULT_RX_RATIO
145: /* default - 75% onboard memory on the card are used for RX packets */
146: #define HP100_DEFAULT_RX_RATIO 75
147: #endif
148:
149: #ifndef HP100_DEFAULT_PRIORITY_TX
150: /* default - don't enable transmit outgoing packets as priority */
151: #define HP100_DEFAULT_PRIORITY_TX 0
152: #endif
153:
154: /*
155: * structures
156: */
157:
158: struct hp100_eisa_id {
159: u_int id;
160: const char *name;
161: u_char bus;
162: };
163:
164: struct hp100_pci_id {
165: u_short vendor;
166: u_short device;
167: };
168:
169: struct hp100_private {
170: struct hp100_eisa_id *id;
171: u_short chip;
172: u_short soft_model;
173: u_int memory_size;
174: u_int virt_memory_size;
175: u_short rx_ratio; /* 1 - 99 */
176: u_short priority_tx; /* != 0 - priority tx */
177: u_short mode; /* PIO, Shared Mem or Busmaster */
178: u_char bus;
179: u_char pci_bus;
180: u_char pci_device_fn;
181: short mem_mapped; /* memory mapped access */
182: u_int *mem_ptr_virt; /* virtual memory mapped area, maybe NULL */
183: u_int *mem_ptr_phys; /* physical memory mapped area */
184: short lan_type; /* 10Mb/s, 100Mb/s or -1 (error) */
185: int hub_status; /* was login to hub successful? */
186: u_char mac1_mode;
187: u_char mac2_mode;
188: u_char hash_bytes[ 8 ];
189: hp100_stats_t stats;
190:
191: /* Rings for busmaster mode: */
192: hp100_ring_t *rxrhead; /* Head (oldest) index into rxring */
193: hp100_ring_t *rxrtail; /* Tail (newest) index into rxring */
194: hp100_ring_t *txrhead; /* Head (oldest) index into txring */
195: hp100_ring_t *txrtail; /* Tail (newest) index into txring */
196:
197: hp100_ring_t rxring[ MAX_RX_PDL ];
198: hp100_ring_t txring[ MAX_TX_PDL ];
199:
200: u_int *page_vaddr; /* Virtual address of allocated page */
201: u_int *page_vaddr_algn; /* Aligned virtual address of allocated page */
202: int rxrcommit; /* # Rx PDLs commited to adapter */
203: int txrcommit; /* # Tx PDLs commited to adapter */
204: };
205:
206: /*
207: * variables
208: */
209:
210: static struct hp100_eisa_id hp100_eisa_ids[] = {
211:
212: /* 10/100 EISA card with revision A Cascade chip */
213: { 0x80F1F022, "HP J2577 rev A", HP100_BUS_EISA },
214:
215: /* 10/100 ISA card with revision A Cascade chip */
216: { 0x50F1F022, "HP J2573 rev A", HP100_BUS_ISA },
217:
218: /* 10 only EISA card with Cascade chip */
219: { 0x2019F022, "HP 27248B", HP100_BUS_EISA },
220:
221: /* 10/100 EISA card with Cascade chip */
222: { 0x4019F022, "HP J2577", HP100_BUS_EISA },
223:
224: /* 10/100 ISA card with Cascade chip */
225: { 0x5019F022, "HP J2573", HP100_BUS_ISA },
226:
227: /* 10/100 PCI card - old J2585A */
228: { 0x1030103c, "HP J2585A", HP100_BUS_PCI },
229:
230: /* 10/100 PCI card - new J2585B - master capable */
231: { 0x1041103c, "HP J2585B", HP100_BUS_PCI },
232:
233: /* 10 Mbit Combo Adapter */
234: { 0x1042103c, "HP J2970", HP100_BUS_PCI },
235:
236: /* 10 Mbit 10baseT Adapter */
237: { 0x1040103c, "HP J2973", HP100_BUS_PCI },
238:
239: /* 10/100 EISA card from Compex */
240: { 0x0103180e, "ReadyLink ENET100-VG4", HP100_BUS_EISA },
241:
242: /* 10/100 EISA card from Compex - FreedomLine (sq5bpf) */
243: /* Note: [email protected] reported that same ID have ISA */
244: /* version of adapter, too... */
245: { 0x0104180e, "FreedomLine 100/VG", HP100_BUS_EISA },
246:
247: /* 10/100 PCI card from Compex - FreedomLine
248: *
249: * I think this card doesn't like aic7178 scsi controller, but
250: * I haven't tested this much. It works fine on diskless machines.
251: * Jacek Lipkowski <[email protected]>
252: */
253: { 0x021211f6, "FreedomLine 100/VG", HP100_BUS_PCI },
254:
255: /* 10/100 PCI card from Compex (J2585A compatible) */
256: { 0x011211f6, "ReadyLink ENET100-VG4", HP100_BUS_PCI }
257:
258: };
259:
260: #define HP100_EISA_IDS_SIZE (sizeof(hp100_eisa_ids)/sizeof(struct hp100_eisa_id))
261:
262: static struct hp100_pci_id hp100_pci_ids[] = {
263: { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A },
264: { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B },
265: { PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_ENET100VG4 },
266: { PCI_VENDOR_ID_COMPEX2, PCI_DEVICE_ID_COMPEX2_100VG }
267: };
268:
269: #define HP100_PCI_IDS_SIZE (sizeof(hp100_pci_ids)/sizeof(struct hp100_pci_id))
270:
271: static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
272: static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
273: static int hp100_mode = 1;
274:
275: #ifdef LINUX_2_1
276: MODULE_PARM( hp100_rx_ratio, "1i" );
277: MODULE_PARM( hp100_priority_tx, "1i" );
278: MODULE_PARM( hp100_mode, "1i" );
279: #endif
280:
281: /*
282: * prototypes
283: */
284:
285: static int hp100_probe1( struct device *dev, int ioaddr, u_char bus, u_char pci_bus, u_char pci_device_fn );
286: static int hp100_open( struct device *dev );
287: static int hp100_close( struct device *dev );
288: static int hp100_start_xmit( struct sk_buff *skb, struct device *dev );
289: static int hp100_start_xmit_bm (struct sk_buff *skb, struct device *dev );
290: static void hp100_rx( struct device *dev );
291: static hp100_stats_t *hp100_get_stats( struct device *dev );
292: static void hp100_misc_interrupt( struct device *dev );
293: static void hp100_update_stats( struct device *dev );
294: static void hp100_clear_stats( int ioaddr );
295: static void hp100_set_multicast_list( struct device *dev);
296: static void hp100_interrupt( int irq, void *dev_id, struct pt_regs *regs );
297: static void hp100_start_interface( struct device *dev );
298: static void hp100_stop_interface( struct device *dev );
299: static void hp100_load_eeprom( struct device *dev, u_short ioaddr );
300: static int hp100_sense_lan( struct device *dev );
301: static int hp100_login_to_vg_hub( struct device *dev, u_short force_relogin );
302: static int hp100_down_vg_link( struct device *dev );
303: static void hp100_cascade_reset( struct device *dev, u_short enable );
304: static void hp100_BM_shutdown( struct device *dev );
305: static void hp100_mmuinit( struct device *dev );
306: static void hp100_init_pdls( struct device *dev );
307: static int hp100_init_rxpdl( struct device *dev, register hp100_ring_t *ringptr, register u_int *pdlptr);
308: static int hp100_init_txpdl( struct device *dev, register hp100_ring_t *ringptr, register u_int *pdlptr);
309: static void hp100_rxfill( struct device *dev );
310: static void hp100_hwinit( struct device *dev );
311: static void hp100_clean_txring( struct device *dev );
312: #ifdef HP100_DEBUG
313: static void hp100_RegisterDump( struct device *dev );
314: #endif
315:
316: /* TODO: This function should not really be needed in a good design... */
317: static void wait( void )
318: {
319: udelay( 1000 );
320: }
321:
322: /*
323: * probe functions
324: * These functions should - if possible - avoid doing write operations
325: * since this could cause problems when the card is not installed.
326: */
327:
328: __initfunc(int hp100_probe( struct device *dev ))
329: {
330: int base_addr = dev ? dev -> base_addr : 0;
331: int ioaddr = 0;
332: #ifdef CONFIG_PCI
333: int pci_start_index = 0;
334: #endif
335:
336: #ifdef HP100_DEBUG_B
337: hp100_outw( 0x4200, TRACE );
338: printk( "hp100: %s: probe\n", dev->name );
339: #endif
340:
341: if ( base_addr > 0xff ) /* Check a single specified location. */
342: {
343: if ( check_region( base_addr, HP100_REGION_SIZE ) ) return -EINVAL;
344: if ( base_addr < 0x400 )
345: return hp100_probe1( dev, base_addr, HP100_BUS_ISA, 0, 0 );
346: if ( EISA_bus && base_addr >= 0x1c38 && ( (base_addr - 0x1c38) & 0x3ff ) == 0 )
347: return hp100_probe1( dev, base_addr, HP100_BUS_EISA, 0, 0 );
348: #ifdef CONFIG_PCI
349: printk( "hp100: %s: You may specify card # in i/o address parameter for PCI bus...", dev->name );
350: return hp100_probe1( dev, base_addr, HP100_BUS_PCI, 0, 0 );
351: #else
352: return -ENODEV;
353: #endif
354: }
355: else
356: #ifdef CONFIG_PCI
357: if ( base_addr > 0 && base_addr < 8 + 1 )
358: pci_start_index = 0x100 | ( base_addr - 1 );
359: else
360: #endif
361: if ( base_addr != 0 ) return -ENXIO;
362:
363: /* at first - scan PCI bus(es) */
364:
365: #ifdef CONFIG_PCI
366: if ( pcibios_present() )
367: {
368: int pci_index;
369:
370: #ifdef HP100_DEBUG_PCI
371: printk( "hp100: %s: PCI BIOS is present, checking for devices..\n", dev->name );
372: #endif
373: for ( pci_index = pci_start_index & 7; pci_index < 8; pci_index++ )
374: {
375: u_char pci_bus, pci_device_fn;
376: u_short pci_command;
377: int pci_id_index;
378:
379: for ( pci_id_index = 0; pci_id_index < HP100_PCI_IDS_SIZE; pci_id_index++ )
380: if ( pcibios_find_device( hp100_pci_ids[ pci_id_index ].vendor,
381: hp100_pci_ids[ pci_id_index ].device,
382: pci_index, &pci_bus,
383: &pci_device_fn ) == 0 ) goto __pci_found;
384: break;
385:
386: __pci_found:
387: pcibios_read_config_dword( pci_bus, pci_device_fn,
388: PCI_BASE_ADDRESS_0, &ioaddr );
389:
390: ioaddr &= ~3; /* remove I/O space marker in bit 0. */
391:
392: if ( check_region( ioaddr, HP100_REGION_SIZE ) ) continue;
393:
394: pcibios_read_config_word( pci_bus, pci_device_fn,
395: PCI_COMMAND, &pci_command );
396: if ( !( pci_command & PCI_COMMAND_IO ) )
397: {
398: #ifdef HP100_DEBUG
399: printk( "hp100: %s: PCI I/O Bit has not been set. Setting...\n", dev->name );
400: #endif
401: pci_command |= PCI_COMMAND_IO;
402: pcibios_write_config_word( pci_bus, pci_device_fn,
403: PCI_COMMAND, pci_command );
404: }
405: if ( !( pci_command & PCI_COMMAND_MASTER ) )
406: {
407: #ifdef HP100_DEBUG
408: printk( "hp100: %s: PCI Master Bit has not been set. Setting...\n", dev->name );
409: #endif
410: pci_command |= PCI_COMMAND_MASTER;
411: pcibios_write_config_word( pci_bus, pci_device_fn,
412: PCI_COMMAND, pci_command );
413: }
414: #ifdef HP100_DEBUG
415: printk( "hp100: %s: PCI adapter found at 0x%x\n", dev->name, ioaddr );
416: #endif
417: if ( hp100_probe1( dev, ioaddr, HP100_BUS_PCI, pci_bus, pci_device_fn ) == 0 )
418: return 0;
419: }
420: }
421: if ( pci_start_index > 0 ) return -ENODEV;
422: #endif /* CONFIG_PCI */
423:
424: /* Second: Probe all EISA possible port regions (if EISA bus present) */
425: for ( ioaddr = 0x1c38; EISA_bus && ioaddr < 0x10000; ioaddr += 0x400 )
426: {
427: if ( check_region( ioaddr, HP100_REGION_SIZE ) ) continue;
428: if ( hp100_probe1( dev, ioaddr, HP100_BUS_EISA, 0, 0 ) == 0 ) return 0;
429: }
430:
431: /* Third Probe all ISA possible port regions */
432: for ( ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20 )
433: {
434: if ( check_region( ioaddr, HP100_REGION_SIZE ) ) continue;
435: if ( hp100_probe1( dev, ioaddr, HP100_BUS_ISA, 0, 0 ) == 0 ) return 0;
436: }
437:
438: return -ENODEV;
439: }
440:
441:
442: __initfunc(static int hp100_probe1( struct device *dev, int ioaddr, u_char bus, u_char pci_bus, u_char pci_device_fn ))
443: {
444: int i;
445:
446: u_char uc, uc_1;
447: u_int eisa_id;
448: u_int chip;
449: u_int memory_size = 0, virt_memory_size = 0;
450: u_short local_mode, lsw;
451: short mem_mapped;
452: u_int *mem_ptr_phys, *mem_ptr_virt;
453: struct hp100_private *lp;
454: struct hp100_eisa_id *eid;
455:
456: #ifdef HP100_DEBUG_B
457: hp100_outw( 0x4201, TRACE );
458: printk("hp100: %s: probe1\n",dev->name);
459: #endif
460:
461: if ( dev == NULL )
462: {
463: #ifdef HP100_DEBUG
464: printk( "hp100_probe1: %s: dev == NULL ?\n", dev->name );
465: #endif
466: return EIO;
467: }
468:
469: if ( hp100_inw( HW_ID ) != HP100_HW_ID_CASCADE )
470: {
471: return -ENODEV;
472: }
473: else
474: {
475: chip = hp100_inw( PAGING ) & HP100_CHIPID_MASK;
476: #ifdef HP100_DEBUG
477: if ( chip == HP100_CHIPID_SHASTA )
478: printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name);
479: else if ( chip == HP100_CHIPID_RAINIER )
480: printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name);
481: else if ( chip == HP100_CHIPID_LASSEN )
482: printk("hp100: %s: Lassen Chip detected.\n", dev->name);
483: else
484: printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n",dev->name,chip);
485: #endif
486: }
487:
488: dev->base_addr = ioaddr;
489:
490: hp100_page( ID_MAC_ADDR );
491: for ( i = uc = eisa_id = 0; i < 4; i++ )
492: {
493: eisa_id >>= 8;
494: uc_1 = hp100_inb( BOARD_ID + i );
495: eisa_id |= uc_1 << 24;
496: uc += uc_1;
497: }
498: uc += hp100_inb( BOARD_ID + 4 );
499:
500: if ( uc != 0xff ) /* bad checksum? */
501: {
502: printk("hp100_probe: %s: bad EISA ID checksum at base port 0x%x\n", dev->name, ioaddr );
503: return -ENODEV;
504: }
505:
506: for ( i=0; i < HP100_EISA_IDS_SIZE; i++)
507: if ( hp100_eisa_ids[ i ].id == eisa_id )
508: break;
509: if ( i >= HP100_EISA_IDS_SIZE ) {
510: for ( i = 0; i < HP100_EISA_IDS_SIZE; i++)
511: if ( ( hp100_eisa_ids[ i ].id & 0xf0ffffff ) == ( eisa_id & 0xf0ffffff ) )
512: break;
513: if ( i >= HP100_EISA_IDS_SIZE ) {
514: printk( "hp100_probe: %s: card at port 0x%x isn't known (id = 0x%x)\n", dev -> name, ioaddr, eisa_id );
515: return -ENODEV;
516: }
517: }
518: eid = &hp100_eisa_ids[ i ];
519: if ( ( eid->id & 0x0f000000 ) < ( eisa_id & 0x0f000000 ) )
520: {
521: printk( "hp100_probe: %s: newer version of card %s at port 0x%x - unsupported\n",
522: dev->name, eid->name, ioaddr );
523: return -ENODEV;
524: }
525:
526: for ( i = uc = 0; i < 7; i++ )
527: uc += hp100_inb( LAN_ADDR + i );
528: if ( uc != 0xff )
529: {
530: printk("hp100_probe: %s: bad lan address checksum (card %s at port 0x%x)\n",
531: dev->name, eid->name, ioaddr );
532: return -EIO;
533: }
534:
535: /* Make sure, that all registers are correctly updated... */
536:
537: hp100_load_eeprom( dev, ioaddr );
538: wait();
539:
540: /*
541: * Determine driver operation mode
542: *
543: * Use the variable "hp100_mode" upon insmod or as kernel parameter to
544: * force driver modes:
545: * hp100_mode=1 -> default, use busmaster mode if configured.
546: * hp100_mode=2 -> enable shared memory mode
547: * hp100_mode=3 -> force use of i/o mapped mode.
548: * hp100_mode=4 -> same as 1, but re-set the enable bit on the card.
549: */
550:
551: /*
552: * LSW values:
553: * 0x2278 -> J2585B, PnP shared memory mode
554: * 0x2270 -> J2585B, shared memory mode, 0xdc000
555: * 0xa23c -> J2585B, I/O mapped mode
556: * 0x2240 -> EISA COMPEX, BusMaster (Shasta Chip)
557: * 0x2220 -> EISA HP, I/O (Shasta Chip)
558: * 0x2260 -> EISA HP, BusMaster (Shasta Chip)
559: */
560:
561: #if 0
562: local_mode = 0x2270;
563: hp100_outw(0xfefe,OPTION_LSW);
564: hp100_outw(local_mode|HP100_SET_LB|HP100_SET_HB,OPTION_LSW);
565: #endif
566:
567: /* hp100_mode value maybe used in future by another card */
568: local_mode=hp100_mode;
569: if ( local_mode < 1 || local_mode > 4 )
570: local_mode = 1; /* default */
571: #ifdef HP100_DEBUG
572: printk( "hp100: %s: original LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW) );
573: #endif
574:
575: if(local_mode==3)
576: {
577: hp100_outw(HP100_MEM_EN|HP100_RESET_LB, OPTION_LSW);
578: hp100_outw(HP100_IO_EN|HP100_SET_LB, OPTION_LSW);
579: hp100_outw(HP100_BM_WRITE|HP100_BM_READ|HP100_RESET_HB, OPTION_LSW);
580: printk("hp100: %s: IO mapped mode forced.\n", dev->name);
581: }
582: else if(local_mode==2)
583: {
584: hp100_outw(HP100_MEM_EN|HP100_SET_LB, OPTION_LSW);
585: hp100_outw(HP100_IO_EN |HP100_SET_LB, OPTION_LSW);
586: hp100_outw(HP100_BM_WRITE|HP100_BM_READ|HP100_RESET_HB, OPTION_LSW);
587: printk("hp100: %s: Shared memory mode requested.\n", dev->name);
588: }
589: else if(local_mode==4)
590: {
591: if(chip==HP100_CHIPID_LASSEN)
592: {
593: hp100_outw(HP100_BM_WRITE|
594: HP100_BM_READ | HP100_SET_HB, OPTION_LSW);
595: hp100_outw(HP100_IO_EN |
596: HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
597: printk("hp100: %s: Busmaster mode requested.\n",dev->name);
598: }
599: local_mode=1;
600: }
601:
602: if(local_mode==1) /* default behaviour */
603: {
604: lsw = hp100_inw(OPTION_LSW);
605:
606: if ( (lsw & HP100_IO_EN) &&
607: (~lsw & HP100_MEM_EN) &&
608: (~lsw & (HP100_BM_WRITE|HP100_BM_READ)) )
609: {
610: #ifdef HP100_DEBUG
611: printk("hp100: %s: IO_EN bit is set on card.\n",dev->name);
612: #endif
613: local_mode=3;
614: }
615: else if ( chip == HP100_CHIPID_LASSEN &&
616: ( lsw & (HP100_BM_WRITE|HP100_BM_READ) ) ==
617: (HP100_BM_WRITE|HP100_BM_READ) )
618: {
619: printk("hp100: %s: Busmaster mode enabled.\n",dev->name);
620: hp100_outw(HP100_MEM_EN|HP100_IO_EN|HP100_RESET_LB, OPTION_LSW);
621: }
622: else
623: {
624: #ifdef HP100_DEBUG
625: printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name );
626: printk("hp100: %s: Trying shared memory mode.\n", dev->name);
627: #endif
628: /* In this case, try shared memory mode */
629: local_mode=2;
630: hp100_outw(HP100_MEM_EN|HP100_SET_LB, OPTION_LSW);
631: /* hp100_outw(HP100_IO_EN|HP100_RESET_LB, OPTION_LSW); */
632: }
633: }
634:
635: #ifdef HP100_DEBUG
636: printk( "hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW) );
637: #endif
638:
639: /* Check for shared memory on the card, eventually remap it */
640: hp100_page( HW_MAP );
641: mem_mapped = (( hp100_inw( OPTION_LSW ) & ( HP100_MEM_EN ) ) != 0);
642: mem_ptr_phys = mem_ptr_virt = NULL;
643: memory_size = (8192<<( (hp100_inb(SRAM)>>5)&0x07));
644: virt_memory_size = 0;
645:
646: /* For memory mapped or busmaster mode, we want the memory address */
647: if ( mem_mapped || (local_mode==1))
648: {
649: mem_ptr_phys = (u_int *)( hp100_inw( MEM_MAP_LSW ) |
650: ( hp100_inw( MEM_MAP_MSW ) << 16 ) );
651: (u_int)mem_ptr_phys &= ~0x1fff; /* 8k alignment */
652:
653: if ( bus == HP100_BUS_ISA && ( (u_long)mem_ptr_phys & ~0xfffff ) != 0 )
654: {
655: printk("hp100: %s: Can only use programmed i/o mode.\n", dev->name);
656: mem_ptr_phys = NULL;
657: mem_mapped = 0;
658: local_mode=3; /* Use programmed i/o */
659: }
660:
661: /* We do not need access to shared memory in busmaster mode */
662: /* However in slave mode we need to remap high (>1GB) card memory */
663: if(local_mode!=1) /* = not busmaster */
664: {
665: if ( bus == HP100_BUS_PCI && mem_ptr_phys >= (u_int *)0x100000 )
666: {
667: /* We try with smaller memory sizes, if ioremap fails */
668: for(virt_memory_size = memory_size; virt_memory_size>16383; virt_memory_size>>=1)
669: {
670: if((mem_ptr_virt=ioremap((u_long)mem_ptr_phys,virt_memory_size))==NULL)
671: {
672: #ifdef HP100_DEBUG
673: printk( "hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, (u_long)mem_ptr_phys );
674: #endif
675: }
676: else
677: {
678: #ifdef HP100_DEBUG
679: printk( "hp100: %s: remapped 0x%x bytes high PCI memory at 0x%lx to 0x%lx.\n", dev->name, virt_memory_size, (u_long)mem_ptr_phys, (u_long)mem_ptr_virt);
680: #endif
681: break;
682: }
683: }
684:
685: if(mem_ptr_virt==NULL) /* all ioremap tries failed */
686: {
687: printk("hp100: %s: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n", dev->name);
688: local_mode=3;
689: virt_memory_size = 0;
690: }
691: }
692: }
693:
694: }
695:
696: if(local_mode==3) /* io mapped forced */
697: {
698: mem_mapped = 0;
699: mem_ptr_phys = mem_ptr_virt = NULL;
700: printk("hp100: %s: Using (slow) programmed i/o mode.\n", dev->name);
701: }
702:
703: /* Initialise the "private" data structure for this card. */
704: if ( (dev->priv=kmalloc(sizeof(struct hp100_private), GFP_KERNEL)) == NULL)
705: return -ENOMEM;
706: memset( dev->priv, 0, sizeof(struct hp100_private) );
707:
708: lp = (struct hp100_private *)dev->priv;
709: lp->id = eid;
710: lp->chip = chip;
711: lp->mode = local_mode;
712: lp->pci_bus = pci_bus;
713: lp->bus = bus;
714: lp->pci_device_fn = pci_device_fn;
715: lp->priority_tx = hp100_priority_tx;
716: lp->rx_ratio = hp100_rx_ratio;
717: lp->mem_ptr_phys = mem_ptr_phys;
718: lp->mem_ptr_virt = mem_ptr_virt;
719: hp100_page( ID_MAC_ADDR );
720: lp->soft_model = hp100_inb( SOFT_MODEL );
721: lp->mac1_mode = HP100_MAC1MODE3;
722: lp->mac2_mode = HP100_MAC2MODE3;
723: memset( &lp->hash_bytes, 0x00, 8 );
724:
725: dev->base_addr = ioaddr;
726:
727: lp->memory_size = memory_size;
728: lp->virt_memory_size = virt_memory_size;
729: lp->rx_ratio = hp100_rx_ratio; /* can be conf'd with insmod */
730:
731: /* memory region for programmed i/o */
732: request_region( dev->base_addr, HP100_REGION_SIZE, eid->name );
733:
734: dev->open = hp100_open;
735: dev->stop = hp100_close;
736:
737: if (lp->mode==1) /* busmaster */
738: dev->hard_start_xmit = hp100_start_xmit_bm;
739: else
740: dev->hard_start_xmit = hp100_start_xmit;
741:
742: dev->get_stats = hp100_get_stats;
743: dev->set_multicast_list = &hp100_set_multicast_list;
744:
745: /* Ask the card for which IRQ line it is configured */
746: hp100_page( HW_MAP );
747: dev->irq = hp100_inb( IRQ_CHANNEL ) & HP100_IRQMASK;
748: if ( dev->irq == 2 )
749: dev->irq = 9;
750:
751: if(lp->mode==1) /* busmaster */
752: dev->dma=4;
753:
754: /* Ask the card for its MAC address and store it for later use. */
755: hp100_page( ID_MAC_ADDR );
756: for ( i = uc = 0; i < 6; i++ )
757: dev->dev_addr[ i ] = hp100_inb( LAN_ADDR + i );
758:
759: /* Reset statistics (counters) */
760: hp100_clear_stats( ioaddr );
761:
762: ether_setup( dev );
763:
764: /* If busmaster mode is wanted, a dma-capable memory area is needed for
765: * the rx and tx PDLs
766: * PCI cards can access the whole PC memory. Therefore GFP_DMA is not
767: * needed for the allocation of the memory area.
768: */
769:
770: /* TODO: We do not need this with old cards, where PDLs are stored
771: * in the cards shared memory area. But currently, busmaster has been
772: * implemented/tested only with the lassen chip anyway... */
773: if(lp->mode==1) /* busmaster */
774: {
775: /* Get physically continous memory for TX & RX PDLs */
776: if ( (lp->page_vaddr=kmalloc(MAX_RINGSIZE+0x0f,GFP_KERNEL) ) == NULL)
777: return -ENOMEM;
778: lp->page_vaddr_algn=((u_int *) ( ((u_int)(lp->page_vaddr)+0x0f) &~0x0f));
779: memset(lp->page_vaddr, 0, MAX_RINGSIZE+0x0f);
780:
781: #ifdef HP100_DEBUG_BM
782: printk("hp100: %s: Reserved DMA memory from 0x%x to 0x%x\n",
783: dev->name,
784: (u_int)lp->page_vaddr_algn,
785: (u_int)lp->page_vaddr_algn+MAX_RINGSIZE);
786: #endif
787: lp->rxrcommit = lp->txrcommit = 0;
788: lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
789: lp->txrhead = lp->txrtail = &(lp->txring[0]);
790: }
791:
792: /* Initialise the card. */
793: /* (I'm not really sure if it's a good idea to do this during probing, but
794: * like this it's assured that the lan connection type can be sensed
795: * correctly)
796: */
797: hp100_hwinit( dev );
798:
799: /* Try to find out which kind of LAN the card is connected to. */
800: lp->lan_type = hp100_sense_lan( dev );
801:
802: /* Print out a message what about what we think we have probed. */
803: printk( "hp100: %s: %s at 0x%x, IRQ %d, ",
804: dev->name, lp->id->name, ioaddr, dev->irq );
805: switch ( bus ) {
806: case HP100_BUS_EISA: printk( "EISA" ); break;
807: case HP100_BUS_PCI: printk( "PCI" ); break;
808: default: printk( "ISA" ); break;
809: }
810: printk( " bus, %dk SRAM (rx/tx %d%%).\n",
811: lp->memory_size >> 10, lp->rx_ratio );
812:
813: if ( lp->mode==2 ) /* memory mapped */
814: {
815: printk( "hp100: %s: Memory area at 0x%lx-0x%lx",
816: dev->name,(u_long)mem_ptr_phys,
817: ((u_long)mem_ptr_phys+(mem_ptr_phys>(u_int *)0x100000?(u_long)lp->memory_size:16*1024))-1 );
818: if ( mem_ptr_virt )
819: printk( " (virtual base 0x%lx)", (u_long)mem_ptr_virt );
820: printk( ".\n" );
821:
822: /* Set for info when doing ifconfig */
823: dev->mem_start = (u_long)mem_ptr_phys;
824: dev->mem_end = (u_long)mem_ptr_phys+(u_long)lp->memory_size;
825: }
826: printk( "hp100: %s: ", dev->name );
827: if ( lp->lan_type != HP100_LAN_ERR )
828: printk( "Adapter is attached to " );
829: switch ( lp->lan_type ) {
830: case HP100_LAN_100:
831: printk( "100Mb/s Voice Grade AnyLAN network.\n" );
832: break;
833: case HP100_LAN_10:
834: printk( "10Mb/s network.\n" );
835: break;
836: default:
837: printk( "Warning! Link down.\n" );
838: }
839:
840: return 0;
841: }
842:
843:
844: /* This procedure puts the card into a stable init state */
845: static void hp100_hwinit( struct device *dev )
846: {
847: int ioaddr = dev->base_addr;
848: struct hp100_private *lp = (struct hp100_private *)dev->priv;
849:
850: #ifdef HP100_DEBUG_B
851: hp100_outw( 0x4202, TRACE );
852: printk("hp100: %s: hwinit\n", dev->name);
853: #endif
854:
855: /* Initialise the card. -------------------------------------------- */
856:
857: /* Clear all pending Ints and disable Ints */
858: hp100_page( PERFORMANCE );
859: hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all ints */
860: hp100_outw( 0xffff, IRQ_STATUS ); /* clear all pending ints */
861:
862: hp100_outw( HP100_INT_EN | HP100_RESET_LB, OPTION_LSW );
863: hp100_outw( HP100_TRI_INT | HP100_SET_HB, OPTION_LSW );
864:
865: if(lp->mode==1)
866: {
867: hp100_BM_shutdown( dev ); /* disables BM, puts cascade in reset */
868: wait();
869: }
870: else
871: {
872: hp100_outw( HP100_INT_EN | HP100_RESET_LB, OPTION_LSW );
873: hp100_cascade_reset( dev, TRUE );
874: hp100_page( MAC_CTRL );
875: hp100_andb( ~(HP100_RX_EN|HP100_TX_EN), MAC_CFG_1);
876: }
877:
878: /* Initiate EEPROM reload */
879: hp100_load_eeprom( dev, 0 );
880:
881: wait();
882:
883: /* Go into reset again. */
884: hp100_cascade_reset( dev, TRUE );
885:
886: /* Set Option Registers to a safe state */
887: hp100_outw( HP100_DEBUG_EN |
888: HP100_RX_HDR |
889: HP100_EE_EN |
890: HP100_BM_WRITE |
891: HP100_BM_READ | HP100_RESET_HB |
892: HP100_FAKE_INT |
893: HP100_INT_EN |
894: HP100_MEM_EN |
895: HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
896:
897: hp100_outw( HP100_TRI_INT |
898: HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW );
899:
900: hp100_outb( HP100_PRIORITY_TX |
901: HP100_ADV_NXT_PKT |
902: HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW );
903:
904: /* TODO: Configure MMU for Ram Test. */
905: /* TODO: Ram Test. */
906:
907: /* Re-check if adapter is still at same i/o location */
908: /* (If the base i/o in eeprom has been changed but the */
909: /* registers had not been changed, a reload of the eeprom */
910: /* would move the adapter to the address stored in eeprom */
911:
912: /* TODO: Code to implement. */
913:
914: /* Until here it was code from HWdiscover procedure. */
915: /* Next comes code from mmuinit procedure of SCO BM driver which is
916: * called from HWconfigure in the SCO driver. */
917:
918: /* Initialise MMU, eventually switch on Busmaster Mode, initialise
919: * multicast filter...
920: */
921: hp100_mmuinit( dev );
922:
923: /* We don't turn the interrupts on here - this is done by start_interface. */
924: wait(); /* TODO: Do we really need this? */
925:
926: /* Enable Hardware (e.g. unreset) */
927: hp100_cascade_reset( dev, FALSE );
928:
929: /* ------- initialisation complete ----------- */
930:
931: /* Finally try to log in the Hub if there may be a VG connection. */
932: if( lp->lan_type != HP100_LAN_10 )
933: hp100_login_to_vg_hub( dev, FALSE ); /* relogin */
934: }
935:
936:
937: /*
938: * mmuinit - Reinitialise Cascade MMU and MAC settings.
939: * Note: Must already be in reset and leaves card in reset.
940: */
941: static void hp100_mmuinit( struct device *dev )
942: {
943: int ioaddr = dev->base_addr;
944: struct hp100_private *lp = (struct hp100_private *)dev->priv;
945: int i;
946:
947: #ifdef HP100_DEBUG_B
948: hp100_outw( 0x4203, TRACE );
949: printk("hp100: %s: mmuinit\n",dev->name);
950: #endif
951:
952: #ifdef HP100_DEBUG
953: if( 0!=(hp100_inw(OPTION_LSW)&HP100_HW_RST) )
954: {
955: printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n",dev->name);
956: return;
957: }
958: #endif
959:
960: /* Make sure IRQs are masked off and ack'ed. */
961: hp100_page( PERFORMANCE );
962: hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all ints */
963: hp100_outw( 0xffff, IRQ_STATUS ); /* ack IRQ */
964:
965: /*
966: * Enable Hardware
967: * - Clear Debug En, Rx Hdr Pipe, EE En, I/O En, Fake Int and Intr En
968: * - Set Tri-State Int, Bus Master Rd/Wr, and Mem Map Disable
969: * - Clear Priority, Advance Pkt and Xmit Cmd
970: */
971:
972: hp100_outw( HP100_DEBUG_EN |
973: HP100_RX_HDR |
974: HP100_EE_EN | HP100_RESET_HB |
975: HP100_IO_EN |
976: HP100_FAKE_INT |
977: HP100_INT_EN | HP100_RESET_LB, OPTION_LSW );
978:
979: hp100_outw( HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
980:
981: if(lp->mode==1) /* busmaster */
982: {
983: hp100_outw( HP100_BM_WRITE |
984: HP100_BM_READ |
985: HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW );
986: }
987: else if(lp->mode==2) /* memory mapped */
988: {
989: hp100_outw( HP100_BM_WRITE |
990: HP100_BM_READ | HP100_RESET_HB, OPTION_LSW );
991: hp100_outw( HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW );
992: hp100_outw( HP100_MEM_EN | HP100_SET_LB, OPTION_LSW );
993: hp100_outw( HP100_IO_EN | HP100_SET_LB, OPTION_LSW );
994: }
995: else if( lp->mode==3 ) /* i/o mapped mode */
996: {
997: hp100_outw( HP100_MMAP_DIS | HP100_SET_HB |
998: HP100_IO_EN | HP100_SET_LB, OPTION_LSW );
999: }
1000:
1001: hp100_page( HW_MAP );
1002: hp100_outb( 0, EARLYRXCFG );
1003: hp100_outw( 0, EARLYTXCFG );
1004:
1005: /*
1006: * Enable Bus Master mode
1007: */
1008: if(lp->mode==1) /* busmaster */
1009: {
1010: /* Experimental: Set some PCI configuration bits */
1011: hp100_page( HW_MAP );
1012: hp100_andb( ~HP100_PDL_USE3, MODECTRL1 ); /* BM engine read maximum */
1013: hp100_andb( ~HP100_TX_DUALQ, MODECTRL1 ); /* No Queue for Priority TX */
1014:
1015: /* PCI Bus failures should result in a Misc. Interrupt */
1016: hp100_orb( HP100_EN_BUS_FAIL, MODECTRL2);
1017:
1018: hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW );
1019: hp100_page( HW_MAP );
1020: /* Use Burst Mode and switch on PAGE_CK */
1021: hp100_orb( HP100_BM_BURST_RD |
1022: HP100_BM_BURST_WR, BM);
1023: if((lp->chip==HP100_CHIPID_RAINIER)||(lp->chip==HP100_CHIPID_SHASTA))
1024: hp100_orb( HP100_BM_PAGE_CK, BM );
1025: hp100_orb( HP100_BM_MASTER, BM );
1026: }
1027: else /* not busmaster */
1028: {
1029: hp100_page(HW_MAP);
1030: hp100_andb(~HP100_BM_MASTER, BM );
1031: }
1032:
1033: /*
1034: * Divide card memory into regions for Rx, Tx and, if non-ETR chip, PDLs
1035: */
1036: hp100_page( MMU_CFG );
1037: if(lp->mode==1) /* only needed for Busmaster */
1038: {
1039: int xmit_stop, recv_stop;
1040:
1041: if((lp->chip==HP100_CHIPID_RAINIER)||(lp->chip==HP100_CHIPID_SHASTA))
1042: {
1043: int pdl_stop;
1044:
1045: /*
1046: * Each pdl is 508 bytes long. (63 frags * 4 bytes for address and
1047: * 4 bytes for header). We will leave NUM_RXPDLS * 508 (rounded
1048: * to the next higher 1k boundary) bytes for the rx-pdl's
1049: * Note: For non-etr chips the transmit stop register must be
1050: * programmed on a 1k boundary, i.e. bits 9:0 must be zero.
1051: */
1052: pdl_stop = lp->memory_size;
1053: xmit_stop = ( pdl_stop-508*(MAX_RX_PDL)-16 )& ~(0x03ff);
1054: recv_stop = ( xmit_stop * (lp->rx_ratio)/100 ) &~(0x03ff);
1055: hp100_outw( (pdl_stop>>4)-1, PDL_MEM_STOP );
1056: #ifdef HP100_DEBUG_BM
1057: printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop);
1058: #endif
1059: }
1060: else /* ETR chip (Lassen) in busmaster mode */
1061: {
1062: xmit_stop = ( lp->memory_size ) - 1;
1063: recv_stop = ( ( lp->memory_size * lp->rx_ratio ) / 100 ) & ~(0x03ff);
1064: }
1065:
1066: hp100_outw( xmit_stop>>4 , TX_MEM_STOP );
1067: hp100_outw( recv_stop>>4 , RX_MEM_STOP );
1068: #ifdef HP100_DEBUG_BM
1069: printk("hp100: %s: TX_STOP = 0x%x\n",dev->name,xmit_stop>>4);
1070: printk("hp100: %s: RX_STOP = 0x%x\n",dev->name,recv_stop>>4);
1071: #endif
1072: }
1073: else /* Slave modes (memory mapped and programmed io) */
1074: {
1075: hp100_outw( (((lp->memory_size*lp->rx_ratio)/100)>>4), RX_MEM_STOP );
1076: hp100_outw( ((lp->memory_size - 1 )>>4), TX_MEM_STOP );
1077: #ifdef HP100_DEBUG
1078: printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name,hp100_inw(TX_MEM_STOP));
1079: printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name,hp100_inw(RX_MEM_STOP));
1080: #endif
1081: }
1082:
1083: /* Write MAC address into page 1 */
1084: hp100_page( MAC_ADDRESS );
1085: for ( i = 0; i < 6; i++ )
1086: hp100_outb( dev->dev_addr[ i ], MAC_ADDR + i );
1087:
1088: /* Zero the multicast hash registers */
1089: for ( i = 0; i < 8; i++ )
1090: hp100_outb( 0x0, HASH_BYTE0 + i );
1091:
1092: /* Set up MAC defaults */
1093: hp100_page( MAC_CTRL );
1094:
1095: /* Go to LAN Page and zero all filter bits */
1096: /* Zero accept error, accept multicast, accept broadcast and accept */
1097: /* all directed packet bits */
1098: hp100_andb( ~(HP100_RX_EN|
1099: HP100_TX_EN|
1100: HP100_ACC_ERRORED|
1101: HP100_ACC_MC|
1102: HP100_ACC_BC|
1103: HP100_ACC_PHY), MAC_CFG_1 );
1104:
1105: hp100_outb( 0x00, MAC_CFG_2 );
1106:
1107: /* Zero the frame format bit. This works around a training bug in the */
1108: /* new hubs. */
1109: hp100_outb( 0x00, VG_LAN_CFG_2); /* (use 802.3) */
1110:
1111: if(lp->priority_tx)
1112: hp100_outb( HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW );
1113: else
1114: hp100_outb( HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW );
1115:
1116: hp100_outb( HP100_ADV_NXT_PKT |
1117: HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW );
1118:
1119: /* If busmaster, initialize the PDLs */
1120: if(lp->mode==1)
1121: hp100_init_pdls( dev );
1122:
1123: /* Go to performance page and initalize isr and imr registers */
1124: hp100_page( PERFORMANCE );
1125: hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all ints */
1126: hp100_outw( 0xffff, IRQ_STATUS ); /* ack IRQ */
1127: }
1128:
1129:
1130: /*
1131: * open/close functions
1132: */
1133:
1134: static int hp100_open( struct device *dev )
1135: {
1136: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1137: #ifdef HP100_DEBUG_B
1138: int ioaddr=dev->base_addr;
1139: #endif
1140:
1141: #ifdef HP100_DEBUG_B
1142: hp100_outw( 0x4204, TRACE );
1143: printk("hp100: %s: open\n",dev->name);
1144: #endif
1145:
1146: /* New: if bus is PCI or EISA, interrupts might be shared interrupts */
1147: if ( request_irq(dev->irq, hp100_interrupt,
1148: lp->bus==HP100_BUS_PCI||lp->bus==HP100_BUS_EISA?SA_SHIRQ:SA_INTERRUPT,
1149: lp->id->name, dev))
1150: {
1151: printk( "hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq );
1152: return -EAGAIN;
1153: }
1154:
1155: MOD_INC_USE_COUNT;
1156:
1157: dev->tbusy = 0;
1158: dev->trans_start = jiffies;
1159: dev->interrupt = 0;
1160: dev->start = 1;
1161:
1162: lp->lan_type = hp100_sense_lan( dev );
1163: lp->mac1_mode = HP100_MAC1MODE3;
1164: lp->mac2_mode = HP100_MAC2MODE3;
1165: memset( &lp->hash_bytes, 0x00, 8 );
1166:
1167: hp100_stop_interface( dev );
1168:
1169: hp100_hwinit( dev );
1170:
1171: hp100_start_interface( dev ); /* sets mac modes, enables interrupts */
1172:
1173: return 0;
1174: }
1175:
1176:
1177: /* The close function is called when the interface is to be brought down */
1178: static int hp100_close( struct device *dev )
1179: {
1180: int ioaddr = dev->base_addr;
1181: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1182:
1183: #ifdef HP100_DEBUG_B
1184: hp100_outw( 0x4205, TRACE );
1185: printk("hp100: %s: close\n", dev->name);
1186: #endif
1187:
1188: hp100_page( PERFORMANCE );
1189: hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all IRQs */
1190:
1191: hp100_stop_interface( dev );
1192:
1193: if ( lp->lan_type == HP100_LAN_100 )
1194: lp->hub_status=hp100_login_to_vg_hub( dev, FALSE );
1195:
1196: dev->tbusy = 1;
1197: dev->start = 0;
1198:
1199: free_irq( dev->irq, dev );
1200:
1201: #ifdef HP100_DEBUG
1202: printk( "hp100: %s: close LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW) );
1203: #endif
1204:
1205: MOD_DEC_USE_COUNT;
1206: return 0;
1207: }
1208:
1209:
1210: /*
1211: * Configure the PDL Rx rings and LAN
1212: */
1213: static void hp100_init_pdls( struct device *dev )
1214: {
1215: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1216: hp100_ring_t *ringptr;
1217: u_int *pageptr;
1218: int i;
1219:
1220: #ifdef HP100_DEBUG_B
1221: int ioaddr = dev->base_addr;
1222: #endif
1223:
1224: #ifdef HP100_DEBUG_B
1225: hp100_outw( 0x4206, TRACE );
1226: printk("hp100: %s: init pdls\n", dev->name);
1227: #endif
1228:
1229: if(0==lp->page_vaddr_algn)
1230: printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n",dev->name);
1231: else
1232: {
1233: /* pageptr shall point into the DMA accessible memory region */
1234: /* we use this pointer to status the upper limit of allocated */
1235: /* memory in the allocated page. */
1236: /* note: align the pointers to the pci cache line size */
1237: memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE); /* Zero Rx/Tx ring page */
1238: pageptr=lp->page_vaddr_algn;
1239:
1240: lp->rxrcommit =0;
1241: ringptr = lp->rxrhead = lp-> rxrtail = &(lp->rxring[0]);
1242:
1243: /* Initialise Rx Ring */
1244: for (i=MAX_RX_PDL-1; i>=0; i--)
1245: {
1246: lp->rxring[i].next = ringptr;
1247: ringptr=&(lp->rxring[i]);
1248: pageptr+=hp100_init_rxpdl(dev, ringptr, pageptr);
1249: }
1250:
1251: /* Initialise Tx Ring */
1252: lp->txrcommit = 0;
1253: ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]);
1254: for (i=MAX_TX_PDL-1; i>=0; i--)
1255: {
1256: lp->txring[i].next = ringptr;
1257: ringptr=&(lp->txring[i]);
1258: pageptr+=hp100_init_txpdl(dev, ringptr, pageptr);
1259: }
1260: }
1261: }
1262:
1263:
1264: /* These functions "format" the entries in the pdl structure */
1265: /* They return how much memory the fragments need. */
1266: static int hp100_init_rxpdl( struct device *dev, register hp100_ring_t *ringptr, register u32 *pdlptr )
1267: {
1268: /* pdlptr is starting adress for this pdl */
1269:
1270: if( 0!=( ((unsigned)pdlptr) & 0xf) )
1271: printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%x.\n",dev->name,(unsigned)pdlptr);
1272:
1273: ringptr->pdl = pdlptr+1;
1274: ringptr->pdl_paddr = virt_to_bus(pdlptr+1);
1275: ringptr->skb = (void *) NULL;
1276:
1277: /*
1278: * Write address and length of first PDL Fragment (which is used for
1279: * storing the RX-Header
1280: * We use the 4 bytes _before_ the PDH in the pdl memory area to
1281: * store this information. (PDH is at offset 0x04)
1282: */
1283: /* Note that pdlptr+1 and not pdlptr is the pointer to the PDH */
1284:
1285: *(pdlptr+2) =(u_int) virt_to_bus(pdlptr); /* Address Frag 1 */
1286: *(pdlptr+3) = 4; /* Length Frag 1 */
1287:
1288: return( ( ((MAX_RX_FRAG*2+2)+3) /4)*4 );
1289: }
1290:
1291:
1292: static int hp100_init_txpdl( struct device *dev, register hp100_ring_t *ringptr, register u32 *pdlptr )
1293: {
1294: if( 0!=( ((unsigned)pdlptr) & 0xf) )
1295: printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%x.\n",dev->name,(unsigned) pdlptr);
1296:
1297: ringptr->pdl = pdlptr; /* +1; */
1298: ringptr->pdl_paddr = virt_to_bus(pdlptr); /* +1 */
1299: ringptr->skb = (void *) NULL;
1300:
1301: return((((MAX_TX_FRAG*2+2)+3)/4)*4);
1302: }
1303:
1304:
1305: /*
1306: * hp100_build_rx_pdl allocates an skb_buff of maximum size plus two bytes
1307: * for possible odd word alignment rounding up to next dword and set PDL
1308: * address for fragment#2
1309: * Returns: 0 if unable to allocate skb_buff
1310: * 1 if successful
1311: */
1312: int hp100_build_rx_pdl( hp100_ring_t *ringptr, struct device *dev )
1313: {
1314: #ifdef HP100_DEBUG_B
1315: int ioaddr = dev->base_addr;
1316: #endif
1317: #ifdef HP100_DEBUG_BM
1318: u_int *p;
1319: #endif
1320:
1321: #ifdef HP100_DEBUG_B
1322: hp100_outw( 0x4207, TRACE );
1323: printk("hp100: %s: build rx pdl\n", dev->name);
1324: #endif
1325:
1326: /* Allocate skb buffer of maximum size */
1327: /* Note: This depends on the alloc_skb functions allocating more
1328: * space than requested, i.e. aligning to 16bytes */
1329:
1330: ringptr->skb = dev_alloc_skb( ((MAX_ETHER_SIZE+2+3)/4)*4 );
1331:
1332: if(NULL!=ringptr->skb)
1333: {
1334: /*
1335: * Reserve 2 bytes at the head of the buffer to land the IP header
1336: * on a long word boundary (According to the Network Driver section
1337: * in the Linux KHG, this should help to increase performance.)
1338: */
1339: skb_reserve(ringptr->skb, 2);
1340:
1341: ringptr->skb->dev=dev;
1342: ringptr->skb->data=(u_char *)skb_put(ringptr->skb, MAX_ETHER_SIZE );
1343:
1344: /* ringptr->pdl points to the beginning of the PDL, i.e. the PDH */
1345: /* Note: 1st Fragment is used for the 4 byte packet status
1346: * (receive header). Its PDL entries are set up by init_rxpdl. So
1347: * here we only have to set up the PDL fragment entries for the data
1348: * part. Those 4 bytes will be stored in the DMA memory region
1349: * directly before the PDL.
1350: */
1351: #ifdef HP100_DEBUG_BM
1352: printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n",
1353: dev->name,
1354: (u_int) ringptr->pdl,
1355: ((MAX_ETHER_SIZE+2+3)/4)*4,
1356: (unsigned int) ringptr->skb->data);
1357: #endif
1358:
1359: ringptr->pdl[0] = 0x00020000; /* Write PDH */
1360: ringptr->pdl[3] = ((u_int)virt_to_bus(ringptr->skb->data));
1361: ringptr->pdl[4] = MAX_ETHER_SIZE; /* Length of Data */
1362:
1363: #ifdef HP100_DEBUG_BM
1364: for(p=(ringptr->pdl); p<(ringptr->pdl+5); p++)
1365: printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n",dev->name,(u_int) p,(u_int) *p );
1366: #endif
1367: return(1);
1368: }
1369: /* else: */
1370: /* alloc_skb failed (no memory) -> still can receive the header
1371: * fragment into PDL memory. make PDL safe by clearing msgptr and
1372: * making the PDL only 1 fragment (i.e. the 4 byte packet status)
1373: */
1374: #ifdef HP100_DEBUG_BM
1375: printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n",
1376: dev->name,
1377: (u_int) ringptr->pdl);
1378: #endif
1379:
1380: ringptr->pdl[0]=0x00010000; /* PDH: Count=1 Fragment */
1381:
1382: return(0);
1383: }
1384:
1385:
1386: /*
1387: * hp100_rxfill - attempt to fill the Rx Ring will empty skb's
1388: *
1389: * Makes assumption that skb's are always contiguous memory areas and
1390: * therefore PDLs contain only 2 physical fragments.
1391: * - While the number of Rx PDLs with buffers is less than maximum
1392: * a. Get a maximum packet size skb
1393: * b. Put the physical address of the buffer into the PDL.
1394: * c. Output physical address of PDL to adapter.
1395: */
1396: static void hp100_rxfill( struct device *dev )
1397: {
1398: int ioaddr=dev->base_addr;
1399:
1400: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1401: hp100_ring_t *ringptr;
1402:
1403: #ifdef HP100_DEBUG_B
1404: hp100_outw( 0x4208, TRACE );
1405: printk("hp100: %s: rxfill\n",dev->name);
1406: #endif
1407:
1408: hp100_page( PERFORMANCE );
1409:
1410: while (lp->rxrcommit < MAX_RX_PDL)
1411: {
1412: /*
1413: ** Attempt to get a buffer and build a Rx PDL.
1414: */
1415: ringptr = lp->rxrtail;
1416: if (0 == hp100_build_rx_pdl( ringptr, dev ))
1417: {
1418: return; /* None available, return */
1419: }
1420:
1421: /* Hand this PDL over to the card */
1422: /* Note: This needs performance page selected! */
1423: #ifdef HP100_DEBUG_BM
1424: printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n",
1425: dev->name,
1426: lp->rxrcommit,
1427: (u_int)ringptr->pdl,
1428: (u_int)ringptr->pdl_paddr,
1429: (u_int)ringptr->pdl[3]);
1430: #endif
1431:
1432: hp100_outl( (u32)ringptr->pdl_paddr, RX_PDA);
1433:
1434: lp->rxrcommit += 1;
1435: lp->rxrtail = ringptr->next;
1436: }
1437: }
1438:
1439:
1440: /*
1441: * BM_shutdown - shutdown bus mastering and leave chip in reset state
1442: */
1443:
1444: static void hp100_BM_shutdown( struct device *dev )
1445: {
1446: int ioaddr = dev->base_addr;
1447: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1448: unsigned long time;
1449:
1450: #ifdef HP100_DEBUG_B
1451: hp100_outw( 0x4209, TRACE );
1452: printk("hp100: %s: bm shutdown\n",dev->name);
1453: #endif
1454:
1455: hp100_page( PERFORMANCE );
1456: hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all ints */
1457: hp100_outw( 0xffff, IRQ_STATUS ); /* Ack all ints */
1458:
1459: /* Ensure Interrupts are off */
1460: hp100_outw( HP100_INT_EN | HP100_RESET_LB , OPTION_LSW );
1461:
1462: /* Disable all MAC activity */
1463: hp100_page( MAC_CTRL );
1464: hp100_andb( ~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1 ); /* stop rx/tx */
1465:
1466: /* If cascade MMU is not already in reset */
1467: if (0 != (hp100_inw(OPTION_LSW)&HP100_HW_RST) )
1468: {
1469: /* Wait 1.3ms (10Mb max packet time) to ensure MAC is idle so
1470: * MMU pointers will not be reset out from underneath
1471: */
1472: hp100_page( MAC_CTRL );
1473: for(time=0; time<5000; time++)
1474: {
1475: if( (hp100_inb(MAC_CFG_1)&(HP100_TX_IDLE|HP100_RX_IDLE))==
1476: (HP100_TX_IDLE|HP100_RX_IDLE) ) break;
1477: }
1478:
1479: /* Shutdown algorithm depends on the generation of Cascade */
1480: if( lp->chip==HP100_CHIPID_LASSEN )
1481: { /* ETR shutdown/reset */
1482: /* Disable Busmaster mode and wait for bit to go to zero. */
1483: hp100_page(HW_MAP);
1484: hp100_andb( ~HP100_BM_MASTER, BM );
1485: /* 100 ms timeout */
1486: for(time=0; time<32000; time++)
1487: {
1488: if ( 0 == (hp100_inb( BM ) & HP100_BM_MASTER) ) break;
1489: }
1490: }
1491: else
1492: { /* Shasta or Rainier Shutdown/Reset */
1493: /* To ensure all bus master inloading activity has ceased,
1494: * wait for no Rx PDAs or no Rx packets on card.
1495: */
1496: hp100_page( PERFORMANCE );
1497: /* 100 ms timeout */
1498: for(time=0; time<10000; time++)
1499: {
1500: /* RX_PDL: PDLs not executed. */
1501: /* RX_PKT_CNT: RX'd packets on card. */
1502: if ( (hp100_inb( RX_PDL ) == 0) &&
1503: (hp100_inb( RX_PKT_CNT ) == 0) ) break;
1504: }
1505:
1506: if(time>=10000)
1507: printk("hp100: %s: BM shutdown error.\n", dev->name);
1508:
1509: /* To ensure all bus master outloading activity has ceased,
1510: * wait until the Tx PDA count goes to zero or no more Tx space
1511: * available in the Tx region of the card.
1512: */
1513: /* 100 ms timeout */
1514: for(time=0; time<10000; time++) {
1515: if ( (0 == hp100_inb( TX_PKT_CNT )) &&
1516: (0 != (hp100_inb( TX_MEM_FREE )&HP100_AUTO_COMPARE))) break;
1517: }
1518:
1519: /* Disable Busmaster mode */
1520: hp100_page(HW_MAP);
1521: hp100_andb( ~HP100_BM_MASTER, BM );
1522: } /* end of shutdown procedure for non-etr parts */
1523:
1524: hp100_cascade_reset( dev, TRUE );
1525: }
1526: hp100_page( PERFORMANCE );
1527: /* hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_RESET_HB, OPTION_LSW ); */
1528: /* Busmaster mode should be shut down now. */
1529: }
1530:
1531:
1532:
1533: /*
1534: * transmit functions
1535: */
1536:
1537: /* tx function for busmaster mode */
1538: static int hp100_start_xmit_bm( struct sk_buff *skb, struct device *dev )
1539: {
1540: unsigned long flags;
1541: int i, ok_flag;
1542: int ioaddr = dev->base_addr;
1543: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1544: hp100_ring_t *ringptr;
1545:
1546: #ifdef HP100_DEBUG_B
1547: hp100_outw( 0x4210, TRACE );
1548: printk("hp100: %s: start_xmit_bm\n",dev->name);
1549: #endif
1550:
1551: if ( skb==NULL )
1552: {
1553: #ifndef LINUX_2_1
1554: dev_tint( dev );
1555: #endif
1556: return 0;
1557: }
1558:
1559: if ( skb->len <= 0 ) return 0;
1560:
1561: /* Get Tx ring tail pointer */
1562: if( lp->txrtail->next==lp->txrhead )
1563: {
1564: /* No memory. */
1565: #ifdef HP100_DEBUG
1566: printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name);
1567: #endif
1568: /* not waited long enough since last tx? */
1569: if ( jiffies - dev->trans_start < HZ ) return -EAGAIN;
1570:
1571: if ( lp->lan_type < 0 ) /* no LAN type detected yet? */
1572: {
1573: hp100_stop_interface( dev );
1574: if ( ( lp->lan_type = hp100_sense_lan( dev ) ) < 0 )
1575: {
1576: printk( "hp100: %s: no connection found - check wire\n", dev->name );
1577: hp100_start_interface( dev ); /* 10Mb/s RX pkts maybe handled */
1578: return -EIO;
1579: }
1580: if ( lp->lan_type == HP100_LAN_100 )
1581: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE ); /* relogin */
1582: hp100_start_interface( dev );
1583: }
1584:
1585: if ( lp->lan_type == HP100_LAN_100 && lp->hub_status < 0 )
1586: /* we have a 100Mb/s adapter but it isn't connected to hub */
1587: {
1588: printk( "hp100: %s: login to 100Mb/s hub retry\n", dev->name );
1589: hp100_stop_interface( dev );
1590: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE );
1591: hp100_start_interface( dev );
1592: }
1593: else
1594: {
1595: hp100_ints_off();
1596: i = hp100_sense_lan( dev );
1597: hp100_ints_on();
1598: if ( i == HP100_LAN_ERR )
1599: printk( "hp100: %s: link down detected\n", dev->name );
1600: else
1601: if ( lp->lan_type != i ) /* cable change! */
1602: {
1603: /* it's very hard - all network setting must be changed!!! */
1604: printk( "hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name );
1605: lp->lan_type = i;
1606: hp100_stop_interface( dev );
1607: if ( lp->lan_type == HP100_LAN_100 )
1608: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE );
1609: hp100_start_interface( dev );
1610: }
1611: else
1612: {
1613: printk( "hp100: %s: interface reset\n", dev->name );
1614: hp100_stop_interface( dev );
1615: if ( lp->lan_type == HP100_LAN_100 )
1616: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE );
1617: hp100_start_interface( dev );
1618: }
1619: }
1620:
1621: dev->trans_start = jiffies;
1622: return -EAGAIN;
1623: }
1624:
1625: /*
1626: * we have to turn int's off before modifying this, otherwise
1627: * a tx_pdl_cleanup could occur at the same time
1628: */
1629: save_flags( flags );
1630: cli();
1631: ringptr=lp->txrtail;
1632: lp->txrtail=ringptr->next;
1633:
1634: /* Check whether packet has minimal packet size */
1635: ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1636: i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1637:
1638: ringptr->skb=skb;
1639: ringptr->pdl[0]=((1<<16) | i); /* PDH: 1 Fragment & length */
1640: ringptr->pdl[1]=(u32)virt_to_bus(skb->data); /* 1st Frag: Adr. of data */
1641: if(lp->chip==HP100_CHIPID_SHASTA)
1642: {
1643: /* TODO:Could someone who has the EISA card please check if this works? */
1644: ringptr->pdl[2]=i;
1645: }
1646: else /* Lassen */
1647: {
1648: /* In the PDL, don't use the padded size but the real packet size: */
1649: ringptr->pdl[2]=skb->len; /* 1st Frag: Length of frag */
1650: }
1651:
1652: /* Hand this PDL to the card. */
1653: hp100_outl( ringptr->pdl_paddr, TX_PDA_L ); /* Low Prio. Queue */
1654:
1655: lp->txrcommit++;
1656: restore_flags( flags );
1657:
1658: /* Update statistics */
1659: lp->stats.tx_packets++;
1660: #ifdef LINUX_2_1
1661: lp->stats.tx_bytes += skb->len;
1662: #endif
1663: dev->trans_start = jiffies;
1664:
1665: return 0;
1666: }
1667:
1668:
1669: /* clean_txring checks if packets have been sent by the card by reading
1670: * the TX_PDL register from the performance page and comparing it to the
1671: * number of commited packets. It then frees the skb's of the packets that
1672: * obviously have been sent to the network.
1673: *
1674: * Needs the PERFORMANCE page selected.
1675: */
1676: static void hp100_clean_txring( struct device *dev )
1677: {
1678: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1679: int ioaddr = dev->base_addr;
1680: int donecount;
1681:
1682: #ifdef HP100_DEBUG_B
1683: hp100_outw( 0x4211, TRACE );
1684: printk("hp100: %s: clean txring\n", dev->name);
1685: #endif
1686:
1687: /* How many PDLs have been transmitted? */
1688: donecount=(lp->txrcommit)-hp100_inb(TX_PDL);
1689:
1690: #ifdef HP100_DEBUG
1691: if(donecount>MAX_TX_PDL)
1692: printk("hp100: %s: Warning: More PDLs transmitted than commited to card???\n",dev->name);
1693: #endif
1694:
1695: for( ; 0!=donecount; donecount-- )
1696: {
1697: #ifdef HP100_DEBUG_BM
1698: printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n",
1699: dev->name,
1700: (u_int) lp->txrhead->skb->data,
1701: lp->txrcommit,
1702: hp100_inb(TX_PDL),
1703: donecount);
1704: #endif
1705: #ifdef LINUX_2_1
1706: dev_kfree_skb( lp->txrhead->skb );
1707: #else
1708: dev_kfree_skb( lp->txrhead->skb, FREE_WRITE );
1709: #endif
1710: lp->txrhead->skb=(void *)NULL;
1711: lp->txrhead=lp->txrhead->next;
1712: lp->txrcommit--;
1713: }
1714: }
1715:
1716:
1717: /* tx function for slave modes */
1718: static int hp100_start_xmit( struct sk_buff *skb, struct device *dev )
1719: {
1720: int i, ok_flag;
1721: int ioaddr = dev->base_addr;
1722: u_short val;
1723: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1724:
1725: #ifdef HP100_DEBUG_B
1726: hp100_outw( 0x4212, TRACE );
1727: printk("hp100: %s: start_xmit\n", dev->name);
1728: #endif
1729:
1730: if ( skb==NULL )
1731: {
1732: #ifndef LINUX_2_1
1733: dev_tint( dev );
1734: #endif
1735: return 0;
1736: }
1737:
1738: if ( skb->len <= 0 ) return 0;
1739:
1740: if ( lp->lan_type < 0 ) /* no LAN type detected yet? */
1741: {
1742: hp100_stop_interface( dev );
1743: if ( ( lp->lan_type = hp100_sense_lan( dev ) ) < 0 )
1744: {
1745: printk( "hp100: %s: no connection found - check wire\n", dev->name );
1746: hp100_start_interface( dev ); /* 10Mb/s RX packets maybe handled */
1747: return -EIO;
1748: }
1749: if ( lp->lan_type == HP100_LAN_100 )
1750: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE ); /* relogin */
1751: hp100_start_interface( dev );
1752: }
1753:
1754: /* If there is not enough free memory on the card... */
1755: i=hp100_inl(TX_MEM_FREE)&0x7fffffff;
1756: if ( !(((i/2)-539)>(skb->len+16) && (hp100_inb(TX_PKT_CNT)<255)) )
1757: {
1758: #ifdef HP100_DEBUG
1759: printk( "hp100: %s: start_xmit: tx free mem = 0x%x\n", dev->name, i );
1760: #endif
1761: /* not waited long enough since last failed tx try? */
1762: if ( jiffies - dev->trans_start < HZ )
1763: {
1764: #ifdef HP100_DEBUG
1765: printk("hp100: %s: trans_start timing problem\n", dev->name);
1766: #endif
1767: return -EAGAIN;
1768: }
1769: if ( lp->lan_type == HP100_LAN_100 && lp->hub_status < 0 )
1770: /* we have a 100Mb/s adapter but it isn't connected to hub */
1771: {
1772: printk( "hp100: %s: login to 100Mb/s hub retry\n", dev->name );
1773: hp100_stop_interface( dev );
1774: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE );
1775: hp100_start_interface( dev );
1776: }
1777: else
1778: {
1779: hp100_ints_off();
1780: i = hp100_sense_lan( dev );
1781: hp100_ints_on();
1782: if ( i == HP100_LAN_ERR )
1783: printk( "hp100: %s: link down detected\n", dev->name );
1784: else
1785: if ( lp->lan_type != i ) /* cable change! */
1786: {
1787: /* it's very hard - all network setting must be changed!!! */
1788: printk( "hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name );
1789: lp->lan_type = i;
1790: hp100_stop_interface( dev );
1791: if ( lp->lan_type == HP100_LAN_100 )
1792: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE );
1793: hp100_start_interface( dev );
1794: }
1795: else
1796: {
1797: printk( "hp100: %s: interface reset\n", dev->name );
1798: hp100_stop_interface( dev );
1799: if ( lp->lan_type == HP100_LAN_100 )
1800: lp->hub_status = hp100_login_to_vg_hub( dev, FALSE );
1801: hp100_start_interface( dev );
1802: udelay(1000);
1803: }
1804: }
1805: dev->trans_start = jiffies;
1806: return -EAGAIN;
1807: }
1808:
1809: for ( i=0; i<6000 && ( hp100_inb( OPTION_MSW ) & HP100_TX_CMD ); i++ )
1810: {
1811: #ifdef HP100_DEBUG_TX
1812: printk( "hp100: %s: start_xmit: busy\n", dev->name );
1813: #endif
1814: }
1815:
1816: hp100_ints_off();
1817: val = hp100_inw( IRQ_STATUS );
1818: /* Ack / clear the interrupt TX_COMPLETE interrupt - this interrupt is set
1819: * when the current packet being transmitted on the wire is completed. */
1820: hp100_outw( HP100_TX_COMPLETE, IRQ_STATUS );
1821: #ifdef HP100_DEBUG_TX
1822: printk("hp100: %s: start_xmit: irq_status=0x%.4x, irqmask=0x%.4x, len=%d\n",dev->name,val,hp100_inw(IRQ_MASK),(int)skb->len );
1823: #endif
1824:
1825: ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1826: i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1827:
1828: hp100_outw( i, DATA32 ); /* tell card the total packet length */
1829: hp100_outw( i, FRAGMENT_LEN ); /* and first/only fragment length */
1830:
1831: if ( lp->mode==2 ) /* memory mapped */
1832: {
1833: if ( lp->mem_ptr_virt ) /* high pci memory was remapped */
1834: {
1835: /* Note: The J2585B needs alignment to 32bits here! */
1836: memcpy( lp->mem_ptr_virt, skb->data, ( skb->len + 3 ) & ~3 );
1837: if ( !ok_flag )
1838: memset( lp->mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb->len );
1839: }
1840: else
1841: {
1842: /* Note: The J2585B needs alignment to 32bits here! */
1843: memcpy_toio( lp->mem_ptr_phys, skb->data, (skb->len + 3) & ~3 );
1844: if ( !ok_flag )
1845: memset_io( lp->mem_ptr_phys, 0, HP100_MIN_PACKET_SIZE - skb->len );
1846: }
1847: }
1848: else /* programmed i/o */
1849: {
1850: outsl( ioaddr + HP100_REG_DATA32, skb->data, ( skb->len + 3 ) >> 2 );
1851: if ( !ok_flag )
1852: for ( i = ( skb->len + 3 ) & ~3; i < HP100_MIN_PACKET_SIZE; i += 4 )
1853: hp100_outl( 0, DATA32 );
1854: }
1855:
1856: hp100_outb( HP100_TX_CMD | HP100_SET_LB, OPTION_MSW ); /* send packet */
1857:
1858: lp->stats.tx_packets++;
1859: #ifdef LINUX_2_1
1860: lp->stats.tx_bytes += skb->len;
1861: #endif
1862: dev->trans_start=jiffies;
1863: hp100_ints_on();
1864:
1865: #ifdef LINUX_2_1
1866: dev_kfree_skb( skb );
1867: #else
1868: dev_kfree_skb( skb, FREE_WRITE );
1869: #endif
1870:
1871: #ifdef HP100_DEBUG_TX
1872: printk( "hp100: %s: start_xmit: end\n", dev->name );
1873: #endif
1874:
1875: return 0;
1876: }
1877:
1878:
1879: /*
1880: * Receive Function (Non-Busmaster mode)
1881: * Called when an "Receive Packet" interrupt occurs, i.e. the receive
1882: * packet counter is non-zero.
1883: * For non-busmaster, this function does the whole work of transfering
1884: * the packet to the host memory and then up to higher layers via skb
1885: * and netif_rx.
1886: */
1887:
1888: static void hp100_rx( struct device *dev )
1889: {
1890: int packets, pkt_len;
1891: int ioaddr = dev->base_addr;
1892: struct hp100_private *lp = (struct hp100_private *)dev->priv;
1893: u_int header;
1894: struct sk_buff *skb;
1895:
1896: #ifdef DEBUG_B
1897: hp100_outw( 0x4213, TRACE );
1898: printk("hp100: %s: rx\n", dev->name);
1899: #endif
1900:
1901: /* First get indication of received lan packet */
1902: /* RX_PKT_CND indicates the number of packets which have been fully */
1903: /* received onto the card but have not been fully transfered of the card */
1904: packets = hp100_inb( RX_PKT_CNT );
1905: #ifdef HP100_DEBUG_RX
1906: if ( packets > 1 )
1907: printk( "hp100: %s: rx: waiting packets = %d\n", dev->name,packets );
1908: #endif
1909:
1910: while ( packets-- > 0 )
1911: {
1912: /* If ADV_NXT_PKT is still set, we have to wait until the card has */
1913: /* really advanced to the next packet. */
1914: for (pkt_len=0; pkt_len<6000 &&(hp100_inb(OPTION_MSW)&HP100_ADV_NXT_PKT);
1915: pkt_len++ )
1916: {
1917: #ifdef HP100_DEBUG_RX
1918: printk( "hp100: %s: rx: busy, remaining packets = %d\n", dev->name, packets );
1919: #endif
1920: }
1921:
1922: /* First we get the header, which contains information about the */
1923: /* actual length of the received packet. */
1924: if( lp->mode==2 ) /* memory mapped mode */
1925: {
1926: if ( lp->mem_ptr_virt ) /* if memory was remapped */
1927: header = *(__u32 *)lp->mem_ptr_virt;
1928: else
1929: header = readl( lp->mem_ptr_phys );
1930: }
1931: else /* programmed i/o */
1932: header = hp100_inl( DATA32 );
1933:
1934: pkt_len = ((header & HP100_PKT_LEN_MASK) + 3) & ~3;
1935:
1936: #ifdef HP100_DEBUG_RX
1937: printk( "hp100: %s: rx: new packet - length=%d, errors=0x%x, dest=0x%x\n",
1938: dev->name,
1939: header & HP100_PKT_LEN_MASK, (header>>16)&0xfff8,
1940: (header>>16)&7);
1941: #endif
1942:
1943: /* Now we allocate the skb and transfer the data into it. */
1944: skb = dev_alloc_skb( pkt_len );
1945: if ( skb == NULL ) /* Not enough memory->drop packet */
1946: {
1947: #ifdef HP100_DEBUG
1948: printk( "hp100: %s: rx: couldn't allocate a sk_buff of size %d\n", dev->name, pkt_len );
1949: #endif
1950: lp->stats.rx_dropped++;
1951: }
1952: else /* skb successfully allocated */
1953: {
1954: u_char *ptr;
1955:
1956: skb->dev = dev;
1957:
1958: /* ptr to start of the sk_buff data area */
1959: ptr = (u_char *)skb_put( skb, pkt_len );
1960:
1961: /* Now transfer the data from the card into that area */
1962: if ( lp->mode==2 )
1963: {
1964: if ( lp->mem_ptr_virt )
1965: memcpy( ptr, lp->mem_ptr_virt, pkt_len );
1966: /* Note alignment to 32bit transfers */
1967: else
1968: memcpy_fromio( ptr, lp->mem_ptr_phys, pkt_len );
1969: }
1970: else /* io mapped */
1971: insl( ioaddr + HP100_REG_DATA32, ptr, pkt_len >> 2 );
1972:
1973: skb->protocol = eth_type_trans( skb, dev );
1974:
1975: netif_rx( skb );
1976: lp->stats.rx_packets++;
1977: #ifdef LINUX_2_1
1978: lp->stats.rx_bytes += skb->len;
1979: #endif
1980:
1981: #ifdef HP100_DEBUG_RX
1982: printk( "hp100: %s: rx: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1983: dev->name,
1984: ptr[ 0 ], ptr[ 1 ], ptr[ 2 ], ptr[ 3 ], ptr[ 4 ], ptr[ 5 ],
1985: ptr[ 6 ], ptr[ 7 ], ptr[ 8 ], ptr[ 9 ], ptr[ 10 ], ptr[ 11 ] );
1986: #endif
1987: }
1988:
1989: /* Indicate the card that we have got the packet */
1990: hp100_outb( HP100_ADV_NXT_PKT | HP100_SET_LB, OPTION_MSW );
1991:
1992: switch ( header & 0x00070000 ) {
1993: case (HP100_MULTI_ADDR_HASH<<16):
1994: case (HP100_MULTI_ADDR_NO_HASH<<16):
1995: lp->stats.multicast++; break;
1996: }
1997: } /* end of while(there are packets) loop */
1998: #ifdef HP100_DEBUG_RX
1999: printk( "hp100_rx: %s: end\n", dev->name );
2000: #endif
2001: }
2002:
2003:
2004: /*
2005: * Receive Function for Busmaster Mode
2006: */
2007: static void hp100_rx_bm( struct device *dev )
2008: {
2009: int ioaddr = dev->base_addr;
2010: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2011: hp100_ring_t *ptr;
2012: u_int header;
2013: int pkt_len;
2014:
2015: #ifdef HP100_DEBUG_B
2016: hp100_outw( 0x4214, TRACE );
2017: printk("hp100: %s: rx_bm\n", dev->name);
2018: #endif
2019:
2020: #ifdef HP100_DEBUG
2021: if(0==lp->rxrcommit)
2022: {
2023: printk("hp100: %s: rx_bm called although no PDLs were committed to adapter?\n", dev->name);
2024: return;
2025: }
2026: else
2027:
2028: /* RX_PKT_CNT states how many PDLs are currently formatted and available to
2029: * the cards BM engine */
2030: if( (hp100_inw(RX_PKT_CNT)&0x00ff) >= lp->rxrcommit)
2031: {
2032: printk("hp100: %s: More packets received than commited? RX_PKT_CNT=0x%x, commit=0x%x\n", dev->name, hp100_inw(RX_PKT_CNT)&0x00ff, lp->rxrcommit);
2033: return;
2034: }
2035: #endif
2036:
2037: while( (lp->rxrcommit > hp100_inb(RX_PDL)) )
2038: {
2039: /*
2040: * The packet was received into the pdl pointed to by lp->rxrhead (
2041: * the oldest pdl in the ring
2042: */
2043:
2044: /* First we get the header, which contains information about the */
2045: /* actual length of the received packet. */
2046:
2047: ptr=lp->rxrhead;
2048:
2049: header = *(ptr->pdl-1);
2050: pkt_len = (header & HP100_PKT_LEN_MASK);
2051:
2052: #ifdef HP100_DEBUG_BM
2053: printk( "hp100: %s: rx_bm: header@0x%x=0x%x length=%d, errors=0x%x, dest=0x%x\n",
2054: dev->name,
2055: (u_int) (ptr->pdl-1),(u_int) header,
2056: pkt_len,
2057: (header>>16)&0xfff8,
2058: (header>>16)&7);
2059: printk( "hp100: %s: RX_PDL_COUNT:0x%x TX_PDL_COUNT:0x%x, RX_PKT_CNT=0x%x PDH=0x%x, Data@0x%x len=0x%x\n",
2060: dev->name,
2061: hp100_inb( RX_PDL ),
2062: hp100_inb( TX_PDL ),
2063: hp100_inb( RX_PKT_CNT ),
2064: (u_int) *(ptr->pdl),
2065: (u_int) *(ptr->pdl+3),
2066: (u_int) *(ptr->pdl+4));
2067: #endif
2068:
2069: if( (pkt_len>=MIN_ETHER_SIZE) &&
2070: (pkt_len<=MAX_ETHER_SIZE) )
2071: {
2072: if(ptr->skb==NULL)
2073: {
2074: printk("hp100: %s: rx_bm: skb null\n", dev->name);
2075: /* can happen if we only allocated room for the pdh due to memory shortage. */
2076: lp->stats.rx_dropped++;
2077: }
2078: else
2079: {
2080: skb_trim( ptr->skb, pkt_len ); /* Shorten it */
2081: ptr->skb->protocol = eth_type_trans( ptr->skb, dev );
2082:
2083: netif_rx( ptr->skb ); /* Up and away... */
2084:
2085: lp->stats.rx_packets++;
2086: #ifdef LINUX_2_1
2087: lp->stats.rx_bytes += ptr->skb->len;
2088: #endif
2089: }
2090:
2091: switch ( header & 0x00070000 ) {
2092: case (HP100_MULTI_ADDR_HASH<<16):
2093: case (HP100_MULTI_ADDR_NO_HASH<<16):
2094: lp->stats.multicast++; break;
2095: }
2096: }
2097: else
2098: {
2099: #ifdef HP100_DEBUG
2100: printk("hp100: %s: rx_bm: Received bad packet (length=%d)\n",dev->name,pkt_len);
2101: #endif
2102: if(ptr->skb!=NULL)
2103: #ifdef LINUX_2_1
2104: dev_kfree_skb( ptr->skb );
2105: #else
2106: dev_kfree_skb( ptr->skb, FREE_READ );
2107: #endif
2108: lp->stats.rx_errors++;
2109: }
2110:
2111: lp->rxrhead=lp->rxrhead->next;
2112:
2113: /* Allocate a new rx PDL (so lp->rxrcommit stays the same) */
2114: if (0 == hp100_build_rx_pdl( lp->rxrtail, dev ))
2115: {
2116: /* No space for skb, header can still be received. */
2117: #ifdef HP100_DEBUG
2118: printk("hp100: %s: rx_bm: No space for new PDL.\n", dev->name);
2119: #endif
2120: return;
2121: }
2122: else
2123: { /* successfully allocated new PDL - put it in ringlist at tail. */
2124: hp100_outl((u32)lp->rxrtail->pdl_paddr, RX_PDA);
2125: lp->rxrtail=lp->rxrtail->next;
2126: }
2127:
2128: }
2129: }
2130:
2131:
2132:
2133: /*
2134: * statistics
2135: */
2136: static hp100_stats_t *hp100_get_stats( struct device *dev )
2137: {
2138: int ioaddr = dev->base_addr;
2139:
2140: #ifdef HP100_DEBUG_B
2141: hp100_outw( 0x4215, TRACE );
2142: #endif
2143:
2144: hp100_ints_off();
2145: hp100_update_stats( dev );
2146: hp100_ints_on();
2147: return &((struct hp100_private *)dev->priv)->stats;
2148: }
2149:
2150: static void hp100_update_stats( struct device *dev )
2151: {
2152: int ioaddr = dev->base_addr;
2153: u_short val;
2154: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2155:
2156: #ifdef HP100_DEBUG_B
2157: hp100_outw( 0x4216, TRACE );
2158: printk("hp100: %s: update-stats\n", dev->name);
2159: #endif
2160:
2161: /* Note: Statistics counters clear when read. */
2162: hp100_page( MAC_CTRL );
2163: val = hp100_inw( DROPPED ) & 0x0fff;
2164: lp->stats.rx_errors += val;
2165: lp->stats.rx_over_errors += val;
2166: val = hp100_inb( CRC );
2167: lp->stats.rx_errors += val;
2168: lp->stats.rx_crc_errors += val;
2169: val = hp100_inb( ABORT );
2170: lp->stats.tx_errors += val;
2171: lp->stats.tx_aborted_errors += val;
2172: hp100_page( PERFORMANCE );
2173: }
2174:
2175: static void hp100_misc_interrupt( struct device *dev )
2176: {
2177: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2178:
2179: #ifdef HP100_DEBUG_B
2180: hp100_outw( 0x4216, TRACE );
2181: printk("hp100: %s: misc_interrupt\n", dev->name);
2182: #endif
2183:
2184: /* Note: Statistics counters clear when read. */
2185: lp->stats.rx_errors++;
2186: lp->stats.tx_errors++;
2187: }
2188:
2189: static void hp100_clear_stats( int ioaddr )
2190: {
2191: unsigned long flags;
2192:
2193: #ifdef HP100_DEBUG_B
2194: hp100_outw( 0x4217, TRACE );
2195: printk("hp100: %s: clear_stats\n", dev->name);
2196: #endif
2197:
2198: save_flags( flags );
2199: cli();
2200: hp100_page( MAC_CTRL ); /* get all statistics bytes */
2201: hp100_inw( DROPPED );
2202: hp100_inb( CRC );
2203: hp100_inb( ABORT );
2204: hp100_page( PERFORMANCE );
2205: restore_flags( flags );
2206: }
2207:
2208:
2209: /*
2210: * multicast setup
2211: */
2212:
2213: /*
2214: * Set or clear the multicast filter for this adapter.
2215: */
2216:
2217: static void hp100_set_multicast_list( struct device *dev )
2218: {
2219: unsigned long flags;
2220: int ioaddr = dev->base_addr;
2221: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2222:
2223: #ifdef HP100_DEBUG_B
2224: hp100_outw( 0x4218, TRACE );
2225: printk("hp100: %s: set_mc_list\n", dev->name);
2226: #endif
2227:
2228: save_flags( flags );
2229: cli();
2230: hp100_ints_off();
2231: hp100_page( MAC_CTRL );
2232: hp100_andb( ~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1 ); /* stop rx/tx */
2233:
2234: if ( dev->flags & IFF_PROMISC )
2235: {
2236: lp->mac2_mode = HP100_MAC2MODE6; /* promiscuous mode = get all good */
2237: lp->mac1_mode = HP100_MAC1MODE6; /* packets on the net */
2238: memset( &lp->hash_bytes, 0xff, 8 );
2239: }
2240: else if ( dev->mc_count || (dev->flags&IFF_ALLMULTI) )
2241: {
2242: lp->mac2_mode = HP100_MAC2MODE5; /* multicast mode = get packets for */
2243: lp->mac1_mode = HP100_MAC1MODE5; /* me, broadcasts and all multicasts */
2244: #ifdef HP100_MULTICAST_FILTER /* doesn't work!!! */
2245: if ( dev -> flags & IFF_ALLMULTI )
2246: {
2247: /* set hash filter to receive all multicast packets */
2248: memset( &lp->hash_bytes, 0xff, 8 );
2249: }
2250: else
2251: {
2252: int i, j, idx;
2253: u_char *addrs;
2254: struct dev_mc_list *dmi;
2255:
2256: memset( &lp->hash_bytes, 0x00, 8 );
2257: #ifdef HP100_DEBUG
2258: printk("hp100: %s: computing hash filter - mc_count = %i\n", dev -> name, dev -> mc_count );
2259: #endif
2260: for ( i = 0, dmi = dev -> mc_list; i < dev -> mc_count; i++, dmi = dmi -> next )
2261: {
2262: addrs = dmi -> dmi_addr;
2263: if ( ( *addrs & 0x01 ) == 0x01 ) /* multicast address? */
2264: {
2265: #ifdef HP100_DEBUG
2266: printk("hp100: %s: multicast = %02x:%02x:%02x:%02x:%02x:%02x, ",
2267: dev -> name,
2268: addrs[ 0 ], addrs[ 1 ], addrs[ 2 ],
2269: addrs[ 3 ], addrs[ 4 ], addrs[ 5 ] );
2270: #endif
2271: for ( j = idx = 0; j < 6; j++ )
2272: {
2273: idx ^= *addrs++ & 0x3f;
2274: printk( ":%02x:", idx );
2275: }
2276: #ifdef HP100_DEBUG
2277: printk("idx = %i\n", idx );
2278: #endif
2279: lp->hash_bytes[ idx >> 3 ] |= ( 1 << ( idx & 7 ) );
2280: }
2281: }
2282: }
2283: #else
2284: memset( &lp->hash_bytes, 0xff, 8 );
2285: #endif
2286: }
2287: else
2288: {
2289: lp->mac2_mode = HP100_MAC2MODE3; /* normal mode = get packets for me */
2290: lp->mac1_mode = HP100_MAC1MODE3; /* and broadcasts */
2291: memset( &lp->hash_bytes, 0x00, 8 );
2292: }
2293:
2294: if ( ( (hp100_inb(MAC_CFG_1) & 0x0f)!=lp->mac1_mode ) ||
2295: ( hp100_inb(MAC_CFG_2)!=lp->mac2_mode ) )
2296: {
2297: int i;
2298:
2299: hp100_outb( lp->mac2_mode, MAC_CFG_2 );
2300: hp100_andb( HP100_MAC1MODEMASK, MAC_CFG_1 ); /* clear mac1 mode bits */
2301: hp100_orb( lp->mac1_mode, MAC_CFG_1 ); /* and set the new mode */
2302:
2303: hp100_page( MAC_ADDRESS );
2304: for ( i = 0; i < 8; i++ )
2305: hp100_outb( lp->hash_bytes[ i ], HASH_BYTE0 + i );
2306: #ifdef HP100_DEBUG
2307: printk("hp100: %s: mac1 = 0x%x, mac2 = 0x%x, multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2308: dev->name, lp->mac1_mode, lp->mac2_mode,
2309: lp->hash_bytes[ 0 ], lp->hash_bytes[ 1 ],
2310: lp->hash_bytes[ 2 ], lp->hash_bytes[ 3 ],
2311: lp->hash_bytes[ 4 ], lp->hash_bytes[ 5 ],
2312: lp->hash_bytes[ 6 ], lp->hash_bytes[ 7 ]
2313: );
2314: #endif
2315:
2316: if(lp->lan_type==HP100_LAN_100)
2317: {
2318: #ifdef HP100_DEBUG
2319: printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2320: #endif
2321: lp->hub_status=hp100_login_to_vg_hub( dev, TRUE ); /* force a relogin to the hub */
2322: }
2323: }
2324: else
2325: {
2326: int i;
2327: u_char old_hash_bytes[ 8 ];
2328:
2329: hp100_page( MAC_ADDRESS );
2330: for ( i = 0; i < 8; i++ )
2331: old_hash_bytes[ i ] = hp100_inb( HASH_BYTE0 + i );
2332: if ( memcmp( old_hash_bytes, &lp->hash_bytes, 8 ) )
2333: {
2334: for ( i = 0; i < 8; i++ )
2335: hp100_outb( lp->hash_bytes[ i ], HASH_BYTE0 + i );
2336: #ifdef HP100_DEBUG
2337: printk("hp100: %s: multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2338: dev->name,
2339: lp->hash_bytes[ 0 ], lp->hash_bytes[ 1 ],
2340: lp->hash_bytes[ 2 ], lp->hash_bytes[ 3 ],
2341: lp->hash_bytes[ 4 ], lp->hash_bytes[ 5 ],
2342: lp->hash_bytes[ 6 ], lp->hash_bytes[ 7 ]
2343: );
2344: #endif
2345:
2346: if(lp->lan_type==HP100_LAN_100)
2347: {
2348: #ifdef HP100_DEBUG
2349: printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2350: #endif
2351: lp->hub_status=hp100_login_to_vg_hub( dev, TRUE ); /* force a relogin to the hub */
2352: }
2353: }
2354: }
2355:
2356: hp100_page( MAC_CTRL );
2357: hp100_orb( HP100_RX_EN | HP100_RX_IDLE | /* enable rx */
2358: HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1 ); /* enable tx */
2359:
2360: hp100_page( PERFORMANCE );
2361: hp100_ints_on();
2362: restore_flags( flags );
2363: }
2364:
2365:
2366: /*
2367: * hardware interrupt handling
2368: */
2369:
2370: static void hp100_interrupt( int irq, void *dev_id, struct pt_regs *regs )
2371: {
2372: struct device *dev = (struct device *)dev_id;
2373: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2374:
2375: int ioaddr;
2376: u_int val;
2377:
2378: if ( dev == NULL ) return;
2379: ioaddr = dev->base_addr;
2380:
2381: if ( dev->interrupt )
2382: printk( "hp100: %s: re-entering the interrupt handler\n", dev->name );
2383: hp100_ints_off();
2384: dev->interrupt = 1; /* mark that we are inside the handler */
2385:
2386: #ifdef HP100_DEBUG_B
2387: hp100_outw( 0x4219, TRACE );
2388: #endif
2389:
2390: /* hp100_page( PERFORMANCE ); */
2391: val = hp100_inw( IRQ_STATUS );
2392: #ifdef HP100_DEBUG_IRQ
2393: printk( "hp100: %s: mode=%x,IRQ_STAT=0x%.4x,RXPKTCNT=0x%.2x RXPDL=0x%.2x TXPKTCNT=0x%.2x TXPDL=0x%.2x\n",
2394: dev->name,
2395: lp->mode,
2396: (u_int)val,
2397: hp100_inb( RX_PKT_CNT ),
2398: hp100_inb( RX_PDL ),
2399: hp100_inb( TX_PKT_CNT ),
2400: hp100_inb( TX_PDL )
2401: );
2402: #endif
2403:
2404: if(val==0) /* might be a shared interrupt */
2405: {
2406: dev->interrupt=0;
2407: hp100_ints_on();
2408: return;
2409: }
2410: /* We're only interested in those interrupts we really enabled. */
2411: /* val &= hp100_inw( IRQ_MASK ); */
2412:
2413: /*
2414: * RX_PDL_FILL_COMPL is set whenever a RX_PDL has been executed. A RX_PDL
2415: * is considered executed whenever the RX_PDL data structure is no longer
2416: * needed.
2417: */
2418: if ( val & HP100_RX_PDL_FILL_COMPL )
2419: {
2420: if(lp->mode==1)
2421: hp100_rx_bm( dev );
2422: else
2423: {
2424: printk("hp100: %s: rx_pdl_fill_compl interrupt although not busmaster?\n", dev->name);
2425: }
2426: }
2427:
2428: /*
2429: * The RX_PACKET interrupt is set, when the receive packet counter is
2430: * non zero. We use this interrupt for receiving in slave mode. In
2431: * busmaster mode, we use it to make sure we did not miss any rx_pdl_fill
2432: * interrupts. If rx_pdl_fill_compl is not set and rx_packet is set, then
2433: * we somehow have missed a rx_pdl_fill_compl interrupt.
2434: */
2435:
2436: if ( val & HP100_RX_PACKET ) /* Receive Packet Counter is non zero */
2437: {
2438: if(lp->mode!=1) /* non busmaster */
2439: hp100_rx( dev );
2440: else if ( !(val & HP100_RX_PDL_FILL_COMPL ))
2441: {
2442: /* Shouldnt happen - maybe we missed a RX_PDL_FILL Interrupt? */
2443: hp100_rx_bm( dev );
2444: }
2445: }
2446:
2447: /*
2448: * Ack. that we have noticed the interrupt and thereby allow next one.
2449: * Note that this is now done after the slave rx function, since first
2450: * acknowledging and then setting ADV_NXT_PKT caused an extra interrupt
2451: * on the J2573.
2452: */
2453: hp100_outw( val, IRQ_STATUS );
2454:
2455: /*
2456: * RX_ERROR is set when a packet is dropped due to no memory resources on
2457: * the card or when a RCV_ERR occurs.
2458: * TX_ERROR is set when a TX_ABORT condition occurs in the MAC->exists
2459: * only in the 802.3 MAC and happens when 16 collisions occur during a TX
2460: */
2461: if ( val & ( HP100_TX_ERROR | HP100_RX_ERROR ) )
2462: {
2463: #ifdef HP100_DEBUG_IRQ
2464: printk("hp100: %s: TX/RX Error IRQ\n", dev->name);
2465: #endif
2466: hp100_update_stats( dev );
2467: if(lp->mode==1)
2468: {
2469: hp100_rxfill( dev );
2470: hp100_clean_txring( dev );
2471: }
2472: }
2473:
2474: /*
2475: * RX_PDA_ZERO is set when the PDA count goes from non-zero to zero.
2476: */
2477: if ( (lp->mode==1)&&(val &(HP100_RX_PDA_ZERO)) )
2478: hp100_rxfill( dev );
2479:
2480: /*
2481: * HP100_TX_COMPLETE interrupt occurs when packet transmitted on wire
2482: * is completed
2483: */
2484: if ( (lp->mode==1) && ( val & ( HP100_TX_COMPLETE )) )
2485: hp100_clean_txring( dev );
2486:
2487: /*
2488: * MISC_ERROR is set when either the LAN link goes down or a detected
2489: * bus error occurs.
2490: */
2491: if ( val & HP100_MISC_ERROR ) /* New for J2585B */
2492: {
2493: #ifdef HP100_DEBUG_IRQ
2494: printk("hp100: %s: Misc. Error Interrupt - Check cabling.\n", dev->name);
2495: #endif
2496: if(lp->mode==1)
2497: {
2498: hp100_clean_txring( dev );
2499: hp100_rxfill( dev );
2500: }
2501: hp100_misc_interrupt( dev );
2502: }
2503:
2504: dev->interrupt = 0;
2505: hp100_ints_on();
2506: }
2507:
2508:
2509: /*
2510: * some misc functions
2511: */
2512:
2513: static void hp100_start_interface( struct device *dev )
2514: {
2515: unsigned long flags;
2516: int ioaddr = dev->base_addr;
2517: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2518:
2519: #ifdef HP100_DEBUG_B
2520: hp100_outw( 0x4220, TRACE );
2521: printk("hp100: %s: hp100_start_interface\n",dev->name);
2522: #endif
2523:
2524: save_flags( flags );
2525: cli();
2526:
2527: /* Ensure the adapter does not want to request an interrupt when */
2528: /* enabling the IRQ line to be active on the bus (i.e. not tri-stated) */
2529: hp100_page( PERFORMANCE );
2530: hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all ints */
2531: hp100_outw( 0xffff, IRQ_STATUS ); /* ack all IRQs */
2532: hp100_outw( HP100_FAKE_INT|HP100_INT_EN|HP100_RESET_LB, OPTION_LSW);
2533: /* Un Tri-state int. TODO: Check if shared interrupts can be realised? */
2534: hp100_outw( HP100_TRI_INT | HP100_RESET_HB, OPTION_LSW );
2535:
2536: if(lp->mode==1)
2537: {
2538: /* Make sure BM bit is set... */
2539: hp100_page(HW_MAP);
2540: hp100_orb( HP100_BM_MASTER, BM );
2541: hp100_rxfill( dev );
2542: }
2543: else if(lp->mode==2)
2544: {
2545: /* Enable memory mapping. Note: Don't do this when busmaster. */
2546: hp100_outw( HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW );
2547: }
2548:
2549: hp100_page(PERFORMANCE);
2550: hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all ints */
2551: hp100_outw( 0xffff, IRQ_STATUS ); /* ack IRQ */
2552:
2553: /* enable a few interrupts: */
2554: if(lp->mode==1) /* busmaster mode */
2555: {
2556: hp100_outw( HP100_RX_PDL_FILL_COMPL |
2557: HP100_RX_PDA_ZERO |
2558: HP100_RX_ERROR |
2559: /* HP100_RX_PACKET | */
2560: /* HP100_RX_EARLY_INT | */ HP100_SET_HB |
2561: /* HP100_TX_PDA_ZERO | */
2562: HP100_TX_COMPLETE |
2563: /* HP100_MISC_ERROR | */
2564: HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK );
2565: }
2566: else
2567: {
2568: hp100_outw( HP100_RX_PACKET |
2569: HP100_RX_ERROR | HP100_SET_HB |
2570: HP100_TX_ERROR | HP100_SET_LB , IRQ_MASK );
2571: }
2572:
2573: /* Enable MAC Tx and RX, set MAC modes, ... */
2574: hp100_set_multicast_list( dev );
2575:
2576: restore_flags( flags );
2577: }
2578:
2579:
2580: static void hp100_stop_interface( struct device *dev )
2581: {
2582: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2583: int ioaddr = dev->base_addr;
2584: u_int val;
2585:
2586: #ifdef HP100_DEBUG_B
2587: printk("hp100: %s: hp100_stop_interface\n",dev->name);
2588: hp100_outw( 0x4221, TRACE );
2589: #endif
2590:
2591: if (lp->mode==1)
2592: hp100_BM_shutdown( dev );
2593: else
2594: {
2595: /* Note: MMAP_DIS will be reenabled by start_interface */
2596: hp100_outw( HP100_INT_EN | HP100_RESET_LB |
2597: HP100_TRI_INT | HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW );
2598: val = hp100_inw( OPTION_LSW );
2599:
2600: hp100_page( MAC_CTRL );
2601: hp100_andb( ~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1 );
2602:
2603: if ( !(val & HP100_HW_RST) ) return; /* If reset, imm. return ... */
2604: /* ... else: busy wait until idle */
2605: for ( val = 0; val < 6000; val++ )
2606: if ( ( hp100_inb( MAC_CFG_1 ) & (HP100_TX_IDLE | HP100_RX_IDLE) ) ==
2607: (HP100_TX_IDLE | HP100_RX_IDLE) )
2608: {
2609: hp100_page(PERFORMANCE);
2610: return;
2611: }
2612: printk( "hp100: %s: hp100_stop_interface - timeout\n", dev->name );
2613: hp100_page(PERFORMANCE);
2614: }
2615: }
2616:
2617:
2618: static void hp100_load_eeprom( struct device *dev, u_short probe_ioaddr )
2619: {
2620: int i;
2621: int ioaddr = probe_ioaddr > 0 ? probe_ioaddr : dev->base_addr;
2622:
2623: #ifdef HP100_DEBUG_B
2624: hp100_outw( 0x4222, TRACE );
2625: #endif
2626:
2627: hp100_page( EEPROM_CTRL );
2628: hp100_andw( ~HP100_EEPROM_LOAD, EEPROM_CTRL );
2629: hp100_orw( HP100_EEPROM_LOAD, EEPROM_CTRL );
2630: for ( i = 0; i < 10000; i++ )
2631: if ( !( hp100_inb( OPTION_MSW ) & HP100_EE_LOAD ) ) return;
2632: printk( "hp100: %s: hp100_load_eeprom - timeout\n", dev->name );
2633: }
2634:
2635:
2636: /* Sense connection status.
2637: * return values: LAN_10 - Connected to 10Mbit/s network
2638: * LAN_100 - Connected to 100Mbit/s network
2639: * LAN_ERR - not connected or 100Mbit/s Hub down
2640: */
2641: static int hp100_sense_lan( struct device *dev )
2642: {
2643: int ioaddr = dev->base_addr;
2644: u_short val_VG, val_10;
2645: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2646:
2647: #ifdef HP100_DEBUG_B
2648: hp100_outw( 0x4223, TRACE );
2649: #endif
2650:
2651: hp100_page( MAC_CTRL );
2652: val_10 = hp100_inb( 10_LAN_CFG_1 );
2653: val_VG = hp100_inb( VG_LAN_CFG_1 );
2654: hp100_page( PERFORMANCE );
2655: #ifdef HP100_DEBUG
2656: printk( "hp100: %s: sense_lan: val_VG = 0x%04x, val_10 = 0x%04x\n", dev->name, val_VG, val_10 );
2657: #endif
2658:
2659: if ( val_10 & HP100_LINK_BEAT_ST ) /* 10Mb connection is active */
2660: return HP100_LAN_10;
2661:
2662: if ( val_10 & HP100_AUI_ST ) /* have we BNC or AUI onboard? */
2663: {
2664: val_10 |= HP100_AUI_SEL | HP100_LOW_TH;
2665: hp100_page( MAC_CTRL );
2666: hp100_outb( val_10, 10_LAN_CFG_1 );
2667: hp100_page( PERFORMANCE );
2668: return HP100_LAN_10;
2669: }
2670:
2671: if ( (lp->id->id == 0x02019F022) ||
2672: (lp->id->id == 0x01042103c) ||
2673: (lp->id->id == 0x01040103c) )
2674: return HP100_LAN_ERR; /* Those cards don't have a 100 Mbit connector */
2675:
2676: if ( val_VG & HP100_LINK_CABLE_ST ) /* Can hear the HUBs tone. */
2677: return HP100_LAN_100;
2678: return HP100_LAN_ERR;
2679: }
2680:
2681:
2682:
2683: static int hp100_down_vg_link( struct device *dev )
2684: {
2685: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2686: int ioaddr = dev->base_addr;
2687: unsigned long time;
2688: long savelan, newlan;
2689:
2690: #ifdef HP100_DEBUG_B
2691: hp100_outw( 0x4224, TRACE );
2692: printk("hp100: %s: down_vg_link\n", dev->name);
2693: #endif
2694:
2695: hp100_page( MAC_CTRL );
2696: time=jiffies+(HZ/4);
2697: do{
2698: if ( hp100_inb( VG_LAN_CFG_1 ) & HP100_LINK_CABLE_ST ) break;
2699: } while (time>jiffies);
2700:
2701: if ( jiffies >= time ) /* no signal->no logout */
2702: return 0;
2703:
2704: /* Drop the VG Link by clearing the link up cmd and load addr.*/
2705:
2706: hp100_andb( ~( HP100_LOAD_ADDR| HP100_LINK_CMD), VG_LAN_CFG_1);
2707: hp100_orb( HP100_VG_SEL, VG_LAN_CFG_1);
2708:
2709: /* Conditionally stall for >250ms on Link-Up Status (to go down) */
2710: time=jiffies+(HZ/2);
2711: do{
2712: if ( !(hp100_inb( VG_LAN_CFG_1) & HP100_LINK_UP_ST) ) break;
2713: } while(time>jiffies);
2714:
2715: #ifdef HP100_DEBUG
2716: if (jiffies>=time)
2717: printk("hp100: %s: down_vg_link: Link does not go down?\n", dev->name);
2718: #endif
2719:
2720: /* To prevent condition where Rev 1 VG MAC and old hubs do not complete */
2721: /* logout under traffic (even though all the status bits are cleared), */
2722: /* do this workaround to get the Rev 1 MAC in its idle state */
2723: if ( lp->chip==HP100_CHIPID_LASSEN )
2724: {
2725: /* Reset VG MAC to insure it leaves the logoff state even if */
2726: /* the Hub is still emitting tones */
2727: hp100_andb(~HP100_VG_RESET, VG_LAN_CFG_1);
2728: udelay(1500); /* wait for >1ms */
2729: hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1); /* Release Reset */
2730: udelay(1500);
2731: }
2732:
2733: /* New: For lassen, switch to 10 Mbps mac briefly to clear training ACK */
2734: /* to get the VG mac to full reset. This is not req.d with later chips */
2735: /* Note: It will take the between 1 and 2 seconds for the VG mac to be */
2736: /* selected again! This will be left to the connect hub function to */
2737: /* perform if desired. */
2738: if (lp->chip==HP100_CHIPID_LASSEN)
2739: {
2740: /* Have to write to 10 and 100VG control registers simultaneously */
2741: savelan=newlan=hp100_inl(10_LAN_CFG_1); /* read 10+100 LAN_CFG regs */
2742: newlan &= ~(HP100_VG_SEL<<16);
2743: newlan |= (HP100_DOT3_MAC)<<8;
2744: hp100_andb( ~HP100_AUTO_MODE, MAC_CFG_3); /* Autosel off */
2745: hp100_outl(newlan, 10_LAN_CFG_1);
2746:
2747: /* Conditionally stall for 5sec on VG selected. */
2748: time=jiffies+(HZ*5);
2749: do{
2750: if( !(hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST) ) break;
2751: } while(time>jiffies);
2752:
2753: hp100_orb( HP100_AUTO_MODE, MAC_CFG_3); /* Autosel back on */
2754: hp100_outl(savelan, 10_LAN_CFG_1);
2755: }
2756:
2757: time=jiffies+(3*HZ); /* Timeout 3s */
2758: do {
2759: if ( (hp100_inb( VG_LAN_CFG_1 )&HP100_LINK_CABLE_ST) == 0) break;
2760: } while (time>jiffies);
2761:
2762: if(time<=jiffies)
2763: {
2764: #ifdef HP100_DEBUG
2765: printk( "hp100: %s: down_vg_link: timeout\n", dev->name );
2766: #endif
2767: return -EIO;
2768: }
2769:
2770: time=jiffies+(2*HZ); /* This seems to take a while.... */
2771: do {} while (time>jiffies);
2772:
2773: return 0;
2774: }
2775:
2776:
2777: static int hp100_login_to_vg_hub( struct device *dev, u_short force_relogin )
2778: {
2779: int ioaddr = dev->base_addr;
2780: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2781: u_short val=0;
2782: unsigned long time;
2783: int startst;
2784:
2785: #ifdef HP100_DEBUG_B
2786: hp100_outw( 0x4225, TRACE );
2787: printk("hp100: %s: login_to_vg_hub\n", dev->name);
2788: #endif
2789:
2790: /* Initiate a login sequence iff VG MAC is enabled and either Load Address
2791: * bit is zero or the force relogin flag is set (e.g. due to MAC address or
2792: * promiscuous mode change)
2793: */
2794: hp100_page( MAC_CTRL );
2795: startst=hp100_inb( VG_LAN_CFG_1 );
2796: if((force_relogin==TRUE)||(hp100_inb( MAC_CFG_4 )&HP100_MAC_SEL_ST))
2797: {
2798: #ifdef HP100_DEBUG_TRAINING
2799: printk("hp100: %s: Start training\n", dev->name);
2800: #endif
2801:
2802: /* Ensure VG Reset bit is 1 (i.e., do not reset)*/
2803: hp100_orb( HP100_VG_RESET , VG_LAN_CFG_1 );
2804:
2805: /* If Lassen AND auto-select-mode AND VG tones were sensed on */
2806: /* entry then temporarily put them into force 100Mbit mode */
2807: if((lp->chip==HP100_CHIPID_LASSEN)&&( startst & HP100_LINK_CABLE_ST ) )
2808: hp100_andb( ~HP100_DOT3_MAC, 10_LAN_CFG_2 );
2809:
2810: /* Drop the VG link by zeroing Link Up Command and Load Address */
2811: hp100_andb( ~(HP100_LINK_CMD/* |HP100_LOAD_ADDR */), VG_LAN_CFG_1);
2812:
2813: #ifdef HP100_DEBUG_TRAINING
2814: printk("hp100: %s: Bring down the link\n", dev->name);
2815: #endif
2816:
2817: /* Wait for link to drop */
2818: time = jiffies + (HZ/10);
2819: do {
2820: if (~(hp100_inb( VG_LAN_CFG_1 )& HP100_LINK_UP_ST) ) break;
2821: } while (time>jiffies);
2822:
2823: /* Start an addressed training and optionally request promiscuous port */
2824: if ( (dev->flags) & IFF_PROMISC )
2825: {
2826: hp100_orb( HP100_PROM_MODE, VG_LAN_CFG_2);
2827: if(lp->chip==HP100_CHIPID_LASSEN)
2828: hp100_orw( HP100_MACRQ_PROMSC, TRAIN_REQUEST );
2829: }
2830: else
2831: {
2832: hp100_andb( ~HP100_PROM_MODE, VG_LAN_CFG_2);
2833: /* For ETR parts we need to reset the prom. bit in the training
2834: * register, otherwise promiscious mode won't be disabled.
2835: */
2836: if(lp->chip==HP100_CHIPID_LASSEN)
2837: {
2838: hp100_andw( ~HP100_MACRQ_PROMSC, TRAIN_REQUEST );
2839: }
2840: }
2841:
2842: /* With ETR parts, frame format request bits can be set. */
2843: if(lp->chip==HP100_CHIPID_LASSEN)
2844: hp100_orb( HP100_MACRQ_FRAMEFMT_EITHER, TRAIN_REQUEST);
2845:
2846: hp100_orb( HP100_LINK_CMD|HP100_LOAD_ADDR|HP100_VG_RESET, VG_LAN_CFG_1);
2847:
2848: /* Note: Next wait could be omitted for Hood and earlier chips under */
2849: /* certain circumstances */
2850: /* TODO: check if hood/earlier and skip wait. */
2851:
2852: /* Wait for either short timeout for VG tones or long for login */
2853: /* Wait for the card hardware to signalise link cable status ok... */
2854: hp100_page( MAC_CTRL );
2855: time = jiffies + ( 1*HZ ); /* 1 sec timeout for cable st */
2856: do {
2857: if ( hp100_inb( VG_LAN_CFG_1 ) & HP100_LINK_CABLE_ST ) break;
2858: } while ( jiffies < time );
2859:
2860: if ( jiffies >= time )
2861: {
2862: #ifdef HP100_DEBUG_TRAINING
2863: printk( "hp100: %s: Link cable status not ok? Training aborted.\n", dev->name );
2864: #endif
2865: }
2866: else
2867: {
2868: #ifdef HP100_DEBUG_TRAINING
2869: printk( "hp100: %s: HUB tones detected. Trying to train.\n", dev->name);
2870: #endif
2871:
2872: time = jiffies + ( 2*HZ ); /* again a timeout */
2873: do {
2874: val = hp100_inb( VG_LAN_CFG_1 );
2875: if ( (val & ( HP100_LINK_UP_ST )) )
2876: {
2877: #ifdef HP100_DEBUG_TRAINING
2878: printk( "hp100: %s: Passed training.\n", dev->name);
2879: #endif
2880: break;
2881: }
2882: } while ( time > jiffies );
2883: }
2884:
2885: /* If LINK_UP_ST is set, then we are logged into the hub. */
2886: if ( (jiffies<=time) && (val & HP100_LINK_UP_ST) )
2887: {
2888: #ifdef HP100_DEBUG_TRAINING
2889: printk( "hp100: %s: Successfully logged into the HUB.\n", dev->name);
2890: if(lp->chip==HP100_CHIPID_LASSEN)
2891: {
2892: val = hp100_inw(TRAIN_ALLOW);
2893: printk( "hp100: %s: Card supports 100VG MAC Version \"%s\" ",
2894: dev->name,(hp100_inw(TRAIN_REQUEST)&HP100_CARD_MACVER) ? "802.12" : "Pre");
2895: printk( "Driver will use MAC Version \"%s\"\n",
2896: ( val & HP100_HUB_MACVER) ? "802.12" : "Pre" );
2897: printk( "hp100: %s: Frame format is %s.\n",dev->name,(val&HP100_MALLOW_FRAMEFMT)?"802.5":"802.3");
2898: }
2899: #endif
2900: }
2901: else
2902: {
2903: /* If LINK_UP_ST is not set, login was not successful */
2904: printk("hp100: %s: Problem logging into the HUB.\n",dev->name);
2905: if(lp->chip==HP100_CHIPID_LASSEN)
2906: {
2907: /* Check allowed Register to find out why there is a problem. */
2908: val = hp100_inw( TRAIN_ALLOW ); /* wont work on non-ETR card */
2909: #ifdef HP100_DEBUG_TRAINING
2910: printk("hp100: %s: MAC Configuration requested: 0x%04x, HUB allowed: 0x%04x\n", dev->name, hp100_inw(TRAIN_REQUEST), val);
2911: #endif
2912: if ( val & HP100_MALLOW_ACCDENIED )
2913: printk("hp100: %s: HUB access denied.\n", dev->name);
2914: if ( val & HP100_MALLOW_CONFIGURE )
2915: printk("hp100: %s: MAC Configuration is incompatible with the Network.\n", dev->name);
2916: if ( val & HP100_MALLOW_DUPADDR )
2917: printk("hp100: %s: Duplicate MAC Address on the Network.\n", dev->name);
2918: }
2919: }
2920:
2921: /* If we have put the chip into forced 100 Mbit mode earlier, go back */
2922: /* to auto-select mode */
2923:
2924: if( (lp->chip==HP100_CHIPID_LASSEN)&&(startst & HP100_LINK_CABLE_ST) )
2925: {
2926: hp100_page( MAC_CTRL );
2927: hp100_orb( HP100_DOT3_MAC, 10_LAN_CFG_2 );
2928: }
2929:
2930: val=hp100_inb(VG_LAN_CFG_1);
2931:
2932: /* Clear the MISC_ERROR Interrupt, which might be generated when doing the relogin */
2933: hp100_page(PERFORMANCE);
2934: hp100_outw( HP100_MISC_ERROR, IRQ_STATUS);
2935:
2936: if (val&HP100_LINK_UP_ST)
2937: return(0); /* login was ok */
2938: else
2939: {
2940: printk("hp100: %s: Training failed.\n", dev->name);
2941: hp100_down_vg_link( dev );
2942: return -EIO;
2943: }
2944: }
2945: /* no forced relogin & already link there->no training. */
2946: return -EIO;
2947: }
2948:
2949:
2950: static void hp100_cascade_reset( struct device *dev, u_short enable )
2951: {
2952: int ioaddr = dev->base_addr;
2953: struct hp100_private *lp = (struct hp100_private *)dev->priv;
2954: int i;
2955:
2956: #ifdef HP100_DEBUG_B
2957: hp100_outw( 0x4226, TRACE );
2958: printk("hp100: %s: cascade_reset\n", dev->name);
2959: #endif
2960:
2961: if (enable==TRUE)
2962: {
2963: hp100_outw( HP100_HW_RST | HP100_RESET_LB, OPTION_LSW );
2964: if(lp->chip==HP100_CHIPID_LASSEN)
2965: {
2966: /* Lassen requires a PCI transmit fifo reset */
2967: hp100_page( HW_MAP );
2968: hp100_andb( ~HP100_PCI_RESET, PCICTRL2 );
2969: hp100_orb( HP100_PCI_RESET, PCICTRL2 );
2970: /* Wait for min. 300 ns */
2971: /* we cant use jiffies here, because it may be */
2972: /* that we have disabled the timer... */
2973: for (i=0; i<0xffff; i++);
2974: hp100_andb( ~HP100_PCI_RESET, PCICTRL2 );
2975: hp100_page( PERFORMANCE );
2976: }
2977: }
2978: else
2979: { /* bring out of reset */
2980: hp100_outw(HP100_HW_RST|HP100_SET_LB, OPTION_LSW);
2981: for (i=0; i<0xffff; i++ );
2982: hp100_page(PERFORMANCE);
2983: }
2984: }
2985:
2986: #ifdef HP100_DEBUG
2987: void hp100_RegisterDump( struct device *dev )
2988: {
2989: int ioaddr=dev->base_addr;
2990: int Page;
2991: int Register;
2992:
2993: /* Dump common registers */
2994: printk("hp100: %s: Cascade Register Dump\n", dev->name);
2995: printk("hardware id #1: 0x%.2x\n",hp100_inb(HW_ID));
2996: printk("hardware id #2/paging: 0x%.2x\n",hp100_inb(PAGING));
2997: printk("option #1: 0x%.4x\n",hp100_inw(OPTION_LSW));
2998: printk("option #2: 0x%.4x\n",hp100_inw(OPTION_MSW));
2999:
3000: /* Dump paged registers */
3001: for (Page = 0; Page < 8; Page++)
3002: {
3003: /* Dump registers */
3004: printk("page: 0x%.2x\n",Page);
3005: outw( Page, ioaddr+0x02);
3006: for (Register = 0x8; Register < 0x22; Register += 2)
3007: {
3008: /* Display Register contents except data port */
3009: if (((Register != 0x10) && (Register != 0x12)) || (Page > 0))
3010: {
3011: printk("0x%.2x = 0x%.4x\n",Register,inw(ioaddr+Register));
3012: }
3013: }
3014: }
3015: hp100_page(PERFORMANCE);
3016: }
3017: #endif
3018:
3019:
3020:
3021: /*
3022: * module section
3023: */
3024:
3025: #ifdef MODULE
3026:
3027: /* Parameters set by insmod */
3028: int hp100_port[5] = { 0, -1, -1, -1, -1 };
3029: #ifdef LINUX_2_1
3030: MODULE_PARM(hp100_port, "1-5i");
3031: #endif
3032:
3033: #ifdef LINUX_2_1
3034: char hp100_name[5][IFNAMSIZ] = { "", "", "", "", "" };
3035: MODULE_PARM(hp100_name, "1-5c" __MODULE_STRING(IFNAMSIZ));
3036: #else
3037: static char devname[5][IFNAMSIZ] = { "", "", "", "", "" };
3038: static char *hp100_name[5] = { devname[0], devname[1],
3039: devname[2], devname[3],
3040: devname[4] };
3041: #endif
3042:
3043: /* List of devices */
3044: static struct device *hp100_devlist[5] = { NULL, NULL, NULL, NULL, NULL };
3045:
3046: /*
3047: * Note: if you have more than five 100vg cards in your pc, feel free to
3048: * increase this value
3049: */
3050:
3051: /*
3052: * Note: to register three eisa or pci devices, use:
3053: * option hp100 hp100_port=0,0,0
3054: * to register one card at io 0x280 as eth239, use:
3055: * option hp100 hp100_port=0x280 hp100_name=eth239
3056: */
3057:
3058: int init_module( void )
3059: {
3060: int i, cards;
3061:
3062: if (hp100_port == 0 && !EISA_bus && !pcibios_present())
3063: printk("hp100: You should not use auto-probing with insmod!\n");
3064:
3065: /* Loop on all possible base addresses */
3066: i = -1; cards = 0;
3067: while((hp100_port[++i] != -1) && (i < 5))
3068: {
3069: /* Create device and set basics args */
3070: hp100_devlist[i] = kmalloc(sizeof(struct device), GFP_KERNEL);
3071: memset(hp100_devlist[i], 0x00, sizeof(struct device));
3072: hp100_devlist[i]->name = hp100_name[i];
3073: hp100_devlist[i]->base_addr = hp100_port[i];
3074: hp100_devlist[i]->init = &hp100_probe;
3075:
3076: /* Try to create the device */
3077: if(register_netdev(hp100_devlist[i]) != 0)
3078: {
3079: /* DeAllocate everything */
3080: /* Note: if dev->priv is mallocated, there is no way to fail */
3081: kfree_s(hp100_devlist[i], sizeof(struct device));
3082: hp100_devlist[i] = (struct device *) NULL;
3083: }
3084: else
3085: cards++;
3086: } /* Loop over all devices */
3087:
3088: return cards > 0 ? 0 : -ENODEV;
3089: }
3090:
3091: void cleanup_module( void )
3092: {
3093: int i;
3094:
3095: /* TODO: Check if all skb's are released/freed. */
3096: for(i = 0; i < 5; i++)
3097: if(hp100_devlist[i] != (struct device *) NULL)
3098: {
3099: unregister_netdev( hp100_devlist[i] );
3100: release_region( hp100_devlist[i]->base_addr, HP100_REGION_SIZE );
3101: if( ((struct hp100_private *)hp100_devlist[i]->priv)->mode==1 ) /* busmaster */
3102: kfree_s( ((struct hp100_private *)hp100_devlist[i]->priv)->page_vaddr, MAX_RINGSIZE+0x0f);
3103: if ( ((struct hp100_private *)hp100_devlist[i]->priv) -> mem_ptr_virt )
3104: iounmap( ((struct hp100_private *)hp100_devlist[i]->priv) -> mem_ptr_virt );
3105: kfree_s( hp100_devlist[i]->priv, sizeof( struct hp100_private ) );
3106: hp100_devlist[i]->priv = NULL;
3107: kfree_s(hp100_devlist[i], sizeof(struct device));
3108: hp100_devlist[i] = (struct device *) NULL;
3109: }
3110: }
3111:
3112: #endif /* MODULE */
3113:
3114:
3115:
3116: /*
3117: * Local variables:
3118: * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c hp100.c"
3119: * c-indent-level: 2
3120: * tab-width: 8
3121: * End:
3122: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.