]> nv-tegra.nvidia Code Review - linux-3.10.git/blob - drivers/net/tlan.c
[PATCH] tlan: restore deleted module parameters.
[linux-3.10.git] / drivers / net / tlan.c
1 /*******************************************************************************
2  *
3  *  Linux ThunderLAN Driver
4  *
5  *  tlan.c
6  *  by James Banks
7  *
8  *  (C) 1997-1998 Caldera, Inc.
9  *  (C) 1998 James Banks
10  *  (C) 1999-2001 Torben Mathiasen
11  *  (C) 2002 Samuel Chessman
12  *
13  *  This software may be used and distributed according to the terms
14  *  of the GNU General Public License, incorporated herein by reference.
15  *
16  ** This file is best viewed/edited with columns>=132.
17  *
18  ** Useful (if not required) reading:
19  *
20  *              Texas Instruments, ThunderLAN Programmer's Guide,
21  *                      TI Literature Number SPWU013A
22  *                      available in PDF format from www.ti.com
23  *              Level One, LXT901 and LXT970 Data Sheets
24  *                      available in PDF format from www.level1.com
25  *              National Semiconductor, DP83840A Data Sheet
26  *                      available in PDF format from www.national.com
27  *              Microchip Technology, 24C01A/02A/04A Data Sheet
28  *                      available in PDF format from www.microchip.com
29  *
30  * Change History
31  *
32  *      Tigran Aivazian <tigran@sco.com>:       TLan_PciProbe() now uses
33  *                                              new PCI BIOS interface.
34  *      Alan Cox        <alan@redhat.com>:      Fixed the out of memory
35  *                                              handling.
36  *      
37  *      Torben Mathiasen <torben.mathiasen@compaq.com> New Maintainer!
38  *
39  *      v1.1 Dec 20, 1999    - Removed linux version checking
40  *                             Patch from Tigran Aivazian. 
41  *                           - v1.1 includes Alan's SMP updates.
42  *                           - We still have problems on SMP though,
43  *                             but I'm looking into that. 
44  *                      
45  *      v1.2 Jan 02, 2000    - Hopefully fixed the SMP deadlock.
46  *                           - Removed dependency of HZ being 100.
47  *                           - We now allow higher priority timers to 
48  *                             overwrite timers like TLAN_TIMER_ACTIVITY
49  *                             Patch from John Cagle <john.cagle@compaq.com>.
50  *                           - Fixed a few compiler warnings.
51  *
52  *      v1.3 Feb 04, 2000    - Fixed the remaining HZ issues.
53  *                           - Removed call to pci_present(). 
54  *                           - Removed SA_INTERRUPT flag from irq handler.
55  *                           - Added __init and __initdata to reduce resisdent 
56  *                             code size.
57  *                           - Driver now uses module_init/module_exit.
58  *                           - Rewrote init_module and tlan_probe to
59  *                             share a lot more code. We now use tlan_probe
60  *                             with builtin and module driver.
61  *                           - Driver ported to new net API. 
62  *                           - tlan.txt has been reworked to reflect current 
63  *                             driver (almost)
64  *                           - Other minor stuff
65  *
66  *      v1.4 Feb 10, 2000    - Updated with more changes required after Dave's
67  *                             network cleanup in 2.3.43pre7 (Tigran & myself)
68  *                           - Minor stuff.
69  *
70  *      v1.5 March 22, 2000  - Fixed another timer bug that would hang the driver
71  *                             if no cable/link were present.
72  *                           - Cosmetic changes.
73  *                           - TODO: Port completely to new PCI/DMA API
74  *                                   Auto-Neg fallback.
75  *
76  *      v1.6 April 04, 2000  - Fixed driver support for kernel-parameters. Haven't
77  *                             tested it though, as the kernel support is currently 
78  *                             broken (2.3.99p4p3).
79  *                           - Updated tlan.txt accordingly.
80  *                           - Adjusted minimum/maximum frame length.
81  *                           - There is now a TLAN website up at 
82  *                             http://tlan.kernel.dk
83  *
84  *      v1.7 April 07, 2000  - Started to implement custom ioctls. Driver now
85  *                             reports PHY information when used with Donald
86  *                             Beckers userspace MII diagnostics utility.
87  *
88  *      v1.8 April 23, 2000  - Fixed support for forced speed/duplex settings.
89  *                           - Added link information to Auto-Neg and forced
90  *                             modes. When NIC operates with auto-neg the driver
91  *                             will report Link speed & duplex modes as well as
92  *                             link partner abilities. When forced link is used,
93  *                             the driver will report status of the established
94  *                             link.
95  *                             Please read tlan.txt for additional information. 
96  *                           - Removed call to check_region(), and used 
97  *                             return value of request_region() instead.
98  *      
99  *      v1.8a May 28, 2000   - Minor updates.
100  *
101  *      v1.9 July 25, 2000   - Fixed a few remaining Full-Duplex issues.
102  *                           - Updated with timer fixes from Andrew Morton.
103  *                           - Fixed module race in TLan_Open.
104  *                           - Added routine to monitor PHY status.
105  *                           - Added activity led support for Proliant devices.
106  *
107  *      v1.10 Aug 30, 2000   - Added support for EISA based tlan controllers 
108  *                             like the Compaq NetFlex3/E. 
109  *                           - Rewrote tlan_probe to better handle multiple
110  *                             bus probes. Probing and device setup is now
111  *                             done through TLan_Probe and TLan_init_one. Actual
112  *                             hardware probe is done with kernel API and 
113  *                             TLan_EisaProbe.
114  *                           - Adjusted debug information for probing.
115  *                           - Fixed bug that would cause general debug information 
116  *                             to be printed after driver removal. 
117  *                           - Added transmit timeout handling.
118  *                           - Fixed OOM return values in tlan_probe. 
119  *                           - Fixed possible mem leak in tlan_exit 
120  *                             (now tlan_remove_one).
121  *                           - Fixed timer bug in TLan_phyMonitor.
122  *                           - This driver version is alpha quality, please
123  *                             send me any bug issues you may encounter.
124  *
125  *      v1.11 Aug 31, 2000   - Do not try to register irq 0 if no irq line was 
126  *                             set for EISA cards.
127  *                           - Added support for NetFlex3/E with nibble-rate
128  *                             10Base-T PHY. This is untestet as I haven't got
129  *                             one of these cards.
130  *                           - Fixed timer being added twice.
131  *                           - Disabled PhyMonitoring by default as this is
132  *                             work in progress. Define MONITOR to enable it.
133  *                           - Now we don't display link info with PHYs that
134  *                             doesn't support it (level1).
135  *                           - Incresed tx_timeout beacuse of auto-neg.
136  *                           - Adjusted timers for forced speeds.
137  *
138  *      v1.12 Oct 12, 2000   - Minor fixes (memleak, init, etc.)
139  *
140  *      v1.13 Nov 28, 2000   - Stop flooding console with auto-neg issues
141  *                             when link can't be established.
142  *                           - Added the bbuf option as a kernel parameter.
143  *                           - Fixed ioaddr probe bug.
144  *                           - Fixed stupid deadlock with MII interrupts.
145  *                           - Added support for speed/duplex selection with 
146  *                             multiple nics.
147  *                           - Added partly fix for TX Channel lockup with
148  *                             TLAN v1.0 silicon. This needs to be investigated
149  *                             further.
150  *
151  *      v1.14 Dec 16, 2000   - Added support for servicing multiple frames per.
152  *                             interrupt. Thanks goes to
153  *                             Adam Keys <adam@ti.com>
154  *                             Denis Beaudoin <dbeaudoin@ti.com>
155  *                             for providing the patch.
156  *                           - Fixed auto-neg output when using multiple
157  *                             adapters.
158  *                           - Converted to use new taskq interface.
159  *
160  *      v1.14a Jan 6, 2001   - Minor adjustments (spinlocks, etc.)
161  *
162  *      Samuel Chessman <chessman@tux.org> New Maintainer!
163  *
164  *      v1.15 Apr 4, 2002    - Correct operation when aui=1 to be
165  *                             10T half duplex no loopback
166  *                             Thanks to Gunnar Eikman
167  *******************************************************************************/
168
169 #include <linux/module.h>
170 #include <linux/init.h>
171 #include <linux/ioport.h>
172 #include <linux/eisa.h>
173 #include <linux/pci.h>
174 #include <linux/netdevice.h>
175 #include <linux/etherdevice.h>
176 #include <linux/delay.h>
177 #include <linux/spinlock.h>
178 #include <linux/workqueue.h>
179 #include <linux/mii.h>
180
181 #include "tlan.h"
182
183 typedef u32 (TLanIntVectorFunc)( struct net_device *, u16 );
184
185
186 /* For removing EISA devices */
187 static  struct net_device       *TLan_Eisa_Devices;
188
189 static  int             TLanDevicesInstalled;
190
191 /* Set speed, duplex and aui settings */
192 static  int aui[MAX_TLAN_BOARDS];
193 static  int duplex[MAX_TLAN_BOARDS];
194 static  int speed[MAX_TLAN_BOARDS];
195 static  int boards_found;
196 module_param_array(aui, int, NULL, 0);
197 module_param_array(duplex, int, NULL, 0);
198 module_param_array(speed, int, NULL, 0);
199 MODULE_PARM_DESC(aui, "ThunderLAN use AUI port(s) (0-1)");
200 MODULE_PARM_DESC(duplex, "ThunderLAN duplex setting(s) (0-default, 1-half, 2-full)");
201 MODULE_PARM_DESC(speed, "ThunderLAN port speen setting(s) (0,10,100)");
202
203 MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>");
204 MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
205 MODULE_LICENSE("GPL");
206
207
208 /* Define this to enable Link beat monitoring */
209 #undef MONITOR
210
211 /* Turn on debugging. See Documentation/networking/tlan.txt for details */
212 static  int             debug;
213 module_param(debug, int, 0);
214 MODULE_PARM_DESC(debug, "ThunderLAN debug mask");
215
216 static  int             bbuf;
217 module_param(bbuf, int, 0);
218 MODULE_PARM_DESC(bbuf, "ThunderLAN use big buffer (0-1)");
219
220 static  u8              *TLanPadBuffer;
221 static  dma_addr_t      TLanPadBufferDMA;
222 static  char            TLanSignature[] = "TLAN";
223 static  const char tlan_banner[] = "ThunderLAN driver v1.15\n";
224 static  int tlan_have_pci;
225 static  int tlan_have_eisa;
226
227 static const char *media[] = {
228         "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ", 
229         "100baseTx-FD", "100baseT4", NULL
230 };
231
232 static struct board {
233         const char      *deviceLabel;
234         u32             flags;
235         u16             addrOfs;
236 } board_info[] = {
237         { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
238         { "Compaq Netelligent 10/100 TX PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
239         { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
240         { "Compaq NetFlex-3/P", TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
241         { "Compaq NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
242         { "Compaq Netelligent Integrated 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
243         { "Compaq Netelligent Dual 10/100 TX PCI UTP", TLAN_ADAPTER_NONE, 0x83 },
244         { "Compaq Netelligent 10/100 TX Embedded UTP", TLAN_ADAPTER_NONE, 0x83 },
245         { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 },
246         { "Olicom OC-2325", TLAN_ADAPTER_UNMANAGED_PHY, 0xF8 },
247         { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xF8 },
248         { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
249         { "Compaq Netelligent 10 T/2 PCI UTP/Coax", TLAN_ADAPTER_NONE, 0x83 },
250         { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED |     /* EISA card */
251                                 TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 }, 
252         { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */
253 };
254
255 static struct pci_device_id tlan_pci_tbl[] = {
256         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
257                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
258         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
259                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
260         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I,
261                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
262         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER,
263                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
264         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B,
265                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
266         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI,
267                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
268         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D,
269                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
270         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I,
271                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
272         { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183,
273                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
274         { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325,
275                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
276         { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326,
277                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
278         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100,
279                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
280         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2,
281                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
282         { 0,}
283 };
284 MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);         
285
286 static void     TLan_EisaProbe( void );
287 static void     TLan_Eisa_Cleanup( void );
288 static int      TLan_Init( struct net_device * );
289 static int      TLan_Open( struct net_device *dev );
290 static int      TLan_StartTx( struct sk_buff *, struct net_device *);
291 static irqreturn_t TLan_HandleInterrupt( int, void *, struct pt_regs *);
292 static int      TLan_Close( struct net_device *);
293 static struct   net_device_stats *TLan_GetStats( struct net_device *);
294 static void     TLan_SetMulticastList( struct net_device *);
295 static int      TLan_ioctl( struct net_device *dev, struct ifreq *rq, int cmd);
296 static int      TLan_probe1( struct pci_dev *pdev, long ioaddr, int irq, int rev, const struct pci_device_id *ent);
297 static void     TLan_tx_timeout( struct net_device *dev);
298 static int      tlan_init_one( struct pci_dev *pdev, const struct pci_device_id *ent);
299
300 static u32      TLan_HandleInvalid( struct net_device *, u16 );
301 static u32      TLan_HandleTxEOF( struct net_device *, u16 );
302 static u32      TLan_HandleStatOverflow( struct net_device *, u16 );
303 static u32      TLan_HandleRxEOF( struct net_device *, u16 );
304 static u32      TLan_HandleDummy( struct net_device *, u16 );
305 static u32      TLan_HandleTxEOC( struct net_device *, u16 );
306 static u32      TLan_HandleStatusCheck( struct net_device *, u16 );
307 static u32      TLan_HandleRxEOC( struct net_device *, u16 );
308
309 static void     TLan_Timer( unsigned long );
310
311 static void     TLan_ResetLists( struct net_device * );
312 static void     TLan_FreeLists( struct net_device * );
313 static void     TLan_PrintDio( u16 );
314 static void     TLan_PrintList( TLanList *, char *, int );
315 static void     TLan_ReadAndClearStats( struct net_device *, int );
316 static void     TLan_ResetAdapter( struct net_device * );
317 static void     TLan_FinishReset( struct net_device * );
318 static void     TLan_SetMac( struct net_device *, int areg, char *mac );
319
320 static void     TLan_PhyPrint( struct net_device * );
321 static void     TLan_PhyDetect( struct net_device * );
322 static void     TLan_PhyPowerDown( struct net_device * );
323 static void     TLan_PhyPowerUp( struct net_device * );
324 static void     TLan_PhyReset( struct net_device * );
325 static void     TLan_PhyStartLink( struct net_device * );
326 static void     TLan_PhyFinishAutoNeg( struct net_device * );
327 #ifdef MONITOR
328 static void     TLan_PhyMonitor( struct net_device * );
329 #endif
330
331 /*
332 static int      TLan_PhyNop( struct net_device * );
333 static int      TLan_PhyInternalCheck( struct net_device * );
334 static int      TLan_PhyInternalService( struct net_device * );
335 static int      TLan_PhyDp83840aCheck( struct net_device * );
336 */
337
338 static int      TLan_MiiReadReg( struct net_device *, u16, u16, u16 * );
339 static void     TLan_MiiSendData( u16, u32, unsigned );
340 static void     TLan_MiiSync( u16 );
341 static void     TLan_MiiWriteReg( struct net_device *, u16, u16, u16 );
342
343 static void     TLan_EeSendStart( u16 );
344 static int      TLan_EeSendByte( u16, u8, int );
345 static void     TLan_EeReceiveByte( u16, u8 *, int );
346 static int      TLan_EeReadByte( struct net_device *, u8, u8 * );
347
348
349 static void 
350 TLan_StoreSKB( struct tlan_list_tag *tag, struct sk_buff *skb)
351 {
352         unsigned long addr = (unsigned long)skb;
353         tag->buffer[9].address = (u32)addr;
354         addr >>= 31;    /* >>= 32 is undefined for 32bit arch, stupid C */
355         addr >>= 1;
356         tag->buffer[8].address = (u32)addr;
357 }
358
359 static struct sk_buff *
360 TLan_GetSKB( struct tlan_list_tag *tag)
361 {
362         unsigned long addr = tag->buffer[8].address;
363         addr <<= 31;
364         addr <<= 1;
365         addr |= tag->buffer[9].address;
366         return (struct sk_buff *) addr;
367 }
368
369
370 static TLanIntVectorFunc *TLanIntVector[TLAN_INT_NUMBER_OF_INTS] = {
371         TLan_HandleInvalid,
372         TLan_HandleTxEOF,
373         TLan_HandleStatOverflow,
374         TLan_HandleRxEOF,
375         TLan_HandleDummy,
376         TLan_HandleTxEOC,
377         TLan_HandleStatusCheck,
378         TLan_HandleRxEOC
379 };
380
381 static inline void
382 TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type )
383 {
384         TLanPrivateInfo *priv = netdev_priv(dev);
385         unsigned long flags = 0;
386         
387         if (!in_irq())
388                 spin_lock_irqsave(&priv->lock, flags);
389         if ( priv->timer.function != NULL &&
390                 priv->timerType != TLAN_TIMER_ACTIVITY ) { 
391                 if (!in_irq())
392                         spin_unlock_irqrestore(&priv->lock, flags);
393                 return;
394         }
395         priv->timer.function = &TLan_Timer;
396         if (!in_irq())
397                 spin_unlock_irqrestore(&priv->lock, flags);
398
399         priv->timer.data = (unsigned long) dev;
400         priv->timerSetAt = jiffies;
401         priv->timerType = type;
402         mod_timer(&priv->timer, jiffies + ticks);
403         
404 } /* TLan_SetTimer */
405
406
407 /*****************************************************************************
408 ******************************************************************************
409
410         ThunderLAN Driver Primary Functions
411
412         These functions are more or less common to all Linux network drivers.
413
414 ******************************************************************************
415 *****************************************************************************/
416
417
418
419
420
421         /***************************************************************
422          *      tlan_remove_one
423          *
424          *      Returns:
425          *              Nothing
426          *      Parms:
427          *              None
428          *
429          *      Goes through the TLanDevices list and frees the device
430          *      structs and memory associated with each device (lists
431          *      and buffers).  It also ureserves the IO port regions
432          *      associated with this device.
433          *
434          **************************************************************/
435
436
437 static void __devexit tlan_remove_one( struct pci_dev *pdev)
438 {
439         struct net_device *dev = pci_get_drvdata( pdev );
440         TLanPrivateInfo *priv = netdev_priv(dev);
441         
442         unregister_netdev( dev );
443
444         if ( priv->dmaStorage ) {
445                 pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
446         }
447
448 #ifdef CONFIG_PCI
449         pci_release_regions(pdev);
450 #endif
451         
452         free_netdev( dev );
453                 
454         pci_set_drvdata( pdev, NULL );
455
456
457 static struct pci_driver tlan_driver = {
458         .name           = "tlan",
459         .id_table       = tlan_pci_tbl,
460         .probe          = tlan_init_one,
461         .remove         = __devexit_p(tlan_remove_one), 
462 };
463
464 static int __init tlan_probe(void)
465 {
466         static int      pad_allocated;
467         
468         printk(KERN_INFO "%s", tlan_banner);
469         
470         TLanPadBuffer = (u8 *) pci_alloc_consistent(NULL, TLAN_MIN_FRAME_SIZE, &TLanPadBufferDMA);
471
472         if (TLanPadBuffer == NULL) {
473                 printk(KERN_ERR "TLAN: Could not allocate memory for pad buffer.\n");
474                 return -ENOMEM;
475         }
476
477         memset(TLanPadBuffer, 0, TLAN_MIN_FRAME_SIZE);
478         pad_allocated = 1;
479
480         TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....\n");
481         
482         /* Use new style PCI probing. Now the kernel will
483            do most of this for us */
484         pci_register_driver(&tlan_driver);
485
486         TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n");
487         TLan_EisaProbe();
488                 
489         printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d  EISA: %d\n", 
490                  TLanDevicesInstalled, TLanDevicesInstalled == 1 ? "" : "s",
491                  tlan_have_pci, tlan_have_eisa);
492
493         if (TLanDevicesInstalled == 0) {
494                 pci_unregister_driver(&tlan_driver);
495                 pci_free_consistent(NULL, TLAN_MIN_FRAME_SIZE, TLanPadBuffer, TLanPadBufferDMA);
496                 return -ENODEV;
497         }
498         return 0;
499 }
500         
501
502 static int __devinit tlan_init_one( struct pci_dev *pdev,
503                                     const struct pci_device_id *ent)
504 {
505         return TLan_probe1( pdev, -1, -1, 0, ent);
506 }
507
508
509 /*
510         ***************************************************************
511          *      tlan_probe1
512          *
513          *      Returns:
514          *              0 on success, error code on error
515          *      Parms: 
516          *              none
517          *
518          *      The name is lower case to fit in with all the rest of
519          *      the netcard_probe names.  This function looks for 
520          *      another TLan based adapter, setting it up with the
521          *      allocated device struct if one is found.
522          *      tlan_probe has been ported to the new net API and
523          *      now allocates its own device structure. This function
524          *      is also used by modules.
525          *
526          **************************************************************/
527
528 static int __devinit TLan_probe1(struct pci_dev *pdev, 
529                                 long ioaddr, int irq, int rev, const struct pci_device_id *ent )
530 {
531
532         struct net_device  *dev;
533         TLanPrivateInfo    *priv;
534         u8                 pci_rev;
535         u16                device_id;
536         int                reg, rc = -ENODEV;
537
538         if (pdev) {
539                 rc = pci_enable_device(pdev);
540                 if (rc)
541                         return rc;
542
543                 rc = pci_request_regions(pdev, TLanSignature);
544                 if (rc) {
545                         printk(KERN_ERR "TLAN: Could not reserve IO regions\n");
546                         goto err_out;
547                 }
548         }
549
550         dev = alloc_etherdev(sizeof(TLanPrivateInfo));
551         if (dev == NULL) {
552                 printk(KERN_ERR "TLAN: Could not allocate memory for device.\n");
553                 rc = -ENOMEM;
554                 goto err_out_regions;
555         }
556         SET_MODULE_OWNER(dev);
557         SET_NETDEV_DEV(dev, &pdev->dev);
558         
559         priv = netdev_priv(dev);
560
561         priv->pciDev = pdev;
562         
563         /* Is this a PCI device? */
564         if (pdev) {
565                 u32                pci_io_base = 0;
566
567                 priv->adapter = &board_info[ent->driver_data];
568
569                 rc = pci_set_dma_mask(pdev, 0xFFFFFFFF);
570                 if (rc) {
571                         printk(KERN_ERR "TLAN: No suitable PCI mapping available.\n");
572                         goto err_out_free_dev;
573                 }
574
575                 pci_read_config_byte ( pdev, PCI_REVISION_ID, &pci_rev);
576
577                 for ( reg= 0; reg <= 5; reg ++ ) {
578                         if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
579                                 pci_io_base = pci_resource_start(pdev, reg);
580                                 TLAN_DBG( TLAN_DEBUG_GNRL, "IO mapping is available at %x.\n",
581                                                 pci_io_base);
582                                 break;
583                         }
584                 }
585                 if (!pci_io_base) {
586                         printk(KERN_ERR "TLAN: No IO mappings available\n");
587                         rc = -EIO;
588                         goto err_out_free_dev;
589                 }
590                 
591                 dev->base_addr = pci_io_base;
592                 dev->irq = pdev->irq;
593                 priv->adapterRev = pci_rev; 
594                 pci_set_master(pdev);
595                 pci_set_drvdata(pdev, dev);
596
597         } else  {     /* EISA card */
598                 /* This is a hack. We need to know which board structure
599                  * is suited for this adapter */
600                 device_id = inw(ioaddr + EISA_ID2);
601                 priv->is_eisa = 1;
602                 if (device_id == 0x20F1) {
603                         priv->adapter = &board_info[13];        /* NetFlex-3/E */
604                         priv->adapterRev = 23;                  /* TLAN 2.3 */
605                 } else {
606                         priv->adapter = &board_info[14];
607                         priv->adapterRev = 10;                  /* TLAN 1.0 */
608                 }
609                 dev->base_addr = ioaddr;
610                 dev->irq = irq;
611         }
612
613         /* Kernel parameters */
614         if (dev->mem_start) {
615                 priv->aui    = dev->mem_start & 0x01;
616                 priv->duplex = ((dev->mem_start & 0x06) == 0x06) ? 0 : (dev->mem_start & 0x06) >> 1;
617                 priv->speed  = ((dev->mem_start & 0x18) == 0x18) ? 0 : (dev->mem_start & 0x18) >> 3;
618         
619                 if (priv->speed == 0x1) {
620                         priv->speed = TLAN_SPEED_10;
621                 } else if (priv->speed == 0x2) {
622                         priv->speed = TLAN_SPEED_100;
623                 }
624                 debug = priv->debug = dev->mem_end;
625         } else {
626                 priv->aui    = aui[boards_found];
627                 priv->speed  = speed[boards_found];
628                 priv->duplex = duplex[boards_found];
629                 priv->debug = debug;
630         }
631         
632         /* This will be used when we get an adapter error from
633          * within our irq handler */
634         INIT_WORK(&priv->tlan_tqueue, (void *)(void*)TLan_tx_timeout, dev);
635
636         spin_lock_init(&priv->lock);
637         
638         rc = TLan_Init(dev);
639         if (rc) {
640                 printk(KERN_ERR "TLAN: Could not set up device.\n");
641                 goto err_out_free_dev;
642         }
643
644         rc = register_netdev(dev);
645         if (rc) {
646                 printk(KERN_ERR "TLAN: Could not register device.\n");
647                 goto err_out_uninit;
648         }
649
650         
651         TLanDevicesInstalled++;
652         boards_found++;
653         
654         /* pdev is NULL if this is an EISA device */
655         if (pdev)
656                 tlan_have_pci++;
657         else {
658                 priv->nextDevice = TLan_Eisa_Devices;
659                 TLan_Eisa_Devices = dev;
660                 tlan_have_eisa++;
661         }
662         
663         printk(KERN_INFO "TLAN: %s irq=%2d, io=%04x, %s, Rev. %d\n",
664                         dev->name,
665                         (int) dev->irq,
666                         (int) dev->base_addr,
667                         priv->adapter->deviceLabel,
668                         priv->adapterRev);
669         return 0;
670
671 err_out_uninit:
672         pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage,
673                             priv->dmaStorageDMA );
674 err_out_free_dev:
675         free_netdev(dev);
676 err_out_regions:
677 #ifdef CONFIG_PCI
678         if (pdev)
679                 pci_release_regions(pdev);
680 #endif
681 err_out:
682         if (pdev)
683                 pci_disable_device(pdev);
684         return rc;
685 }
686
687
688 static void TLan_Eisa_Cleanup(void)
689 {
690         struct net_device *dev;
691         TLanPrivateInfo *priv;
692         
693         while( tlan_have_eisa ) {
694                 dev = TLan_Eisa_Devices;
695                 priv = netdev_priv(dev);
696                 if (priv->dmaStorage) {
697                         pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
698                 }
699                 release_region( dev->base_addr, 0x10);
700                 unregister_netdev( dev );
701                 TLan_Eisa_Devices = priv->nextDevice;
702                 free_netdev( dev );
703                 tlan_have_eisa--;
704         }
705 }
706         
707                 
708 static void __exit tlan_exit(void)
709 {
710         pci_unregister_driver(&tlan_driver);
711
712         if (tlan_have_eisa)
713                 TLan_Eisa_Cleanup();
714
715         pci_free_consistent(NULL, TLAN_MIN_FRAME_SIZE, TLanPadBuffer, TLanPadBufferDMA);
716
717 }
718
719
720 /* Module loading/unloading */
721 module_init(tlan_probe);
722 module_exit(tlan_exit);
723
724
725
726         /**************************************************************
727          *      TLan_EisaProbe
728          *
729          *      Returns: 0 on success, 1 otherwise
730          *
731          *      Parms:   None
732          *
733          *
734          *      This functions probes for EISA devices and calls 
735          *      TLan_probe1 when one is found. 
736          *
737          *************************************************************/
738
739 static void  __init TLan_EisaProbe (void) 
740 {
741         long    ioaddr;
742         int     rc = -ENODEV;
743         int     irq;
744         u16     device_id;
745
746         if (!EISA_bus) {        
747                 TLAN_DBG(TLAN_DEBUG_PROBE, "No EISA bus present\n");
748                 return;
749         }
750         
751         /* Loop through all slots of the EISA bus */
752         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
753                 
754         TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID));       
755         TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2));
756
757
758                 TLAN_DBG(TLAN_DEBUG_PROBE, "Probing for EISA adapter at IO: 0x%4x : ",
759                                         (int) ioaddr);
760                 if (request_region(ioaddr, 0x10, TLanSignature) == NULL) 
761                         goto out;
762
763                 if (inw(ioaddr + EISA_ID) != 0x110E) {          
764                         release_region(ioaddr, 0x10);
765                         goto out;
766                 }
767                 
768                 device_id = inw(ioaddr + EISA_ID2);
769                 if (device_id !=  0x20F1 && device_id != 0x40F1) {              
770                         release_region (ioaddr, 0x10);
771                         goto out;
772                 }
773                 
774                 if (inb(ioaddr + EISA_CR) != 0x1) {     /* Check if adapter is enabled */
775                         release_region (ioaddr, 0x10);
776                         goto out2;
777                 }
778                 
779                 if (debug == 0x10)              
780                         printk("Found one\n");
781
782
783                 /* Get irq from board */
784                 switch (inb(ioaddr + 0xCC0)) {
785                         case(0x10):
786                                 irq=5;
787                                 break;
788                         case(0x20):
789                                 irq=9;
790                                 break;
791                         case(0x40):
792                                 irq=10;
793                                 break;
794                         case(0x80):
795                                 irq=11;
796                                 break;
797                         default:
798                                 goto out;
799                 }               
800                 
801                 
802                 /* Setup the newly found eisa adapter */
803                 rc = TLan_probe1( NULL, ioaddr, irq,
804                                         12, NULL);
805                 continue;
806                 
807                 out:
808                         if (debug == 0x10)
809                                 printk("None found\n");
810                         continue;
811
812                 out2:   if (debug == 0x10)
813                                 printk("Card found but it is not enabled, skipping\n");
814                         continue;
815                 
816         }
817
818 } /* TLan_EisaProbe */
819
820 #ifdef CONFIG_NET_POLL_CONTROLLER
821 static void TLan_Poll(struct net_device *dev)
822 {
823         disable_irq(dev->irq);
824         TLan_HandleInterrupt(dev->irq, dev, NULL);
825         enable_irq(dev->irq);
826 }
827 #endif
828
829         
830
831
832         /***************************************************************
833          *      TLan_Init
834          *
835          *      Returns:
836          *              0 on success, error code otherwise.
837          *      Parms:
838          *              dev     The structure of the device to be
839          *                      init'ed.
840          *
841          *      This function completes the initialization of the
842          *      device structure and driver.  It reserves the IO
843          *      addresses, allocates memory for the lists and bounce
844          *      buffers, retrieves the MAC address from the eeprom
845          *      and assignes the device's methods.
846          *      
847          **************************************************************/
848
849 static int TLan_Init( struct net_device *dev )
850 {
851         int             dma_size;
852         int             err;
853         int             i;
854         TLanPrivateInfo *priv;
855
856         priv = netdev_priv(dev);
857         
858         if ( bbuf ) {
859                 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
860                    * ( sizeof(TLanList) + TLAN_MAX_FRAME_SIZE );
861         } else {
862                 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
863                    * ( sizeof(TLanList) );
864         }
865         priv->dmaStorage = pci_alloc_consistent(priv->pciDev, dma_size, &priv->dmaStorageDMA);
866         priv->dmaSize = dma_size;
867         
868         if ( priv->dmaStorage == NULL ) {
869                 printk(KERN_ERR "TLAN:  Could not allocate lists and buffers for %s.\n",
870                         dev->name );
871                 return -ENOMEM;
872         }
873         memset( priv->dmaStorage, 0, dma_size );
874         priv->rxList = (TLanList *) 
875                        ( ( ( (u32) priv->dmaStorage ) + 7 ) & 0xFFFFFFF8 );
876         priv->rxListDMA = ( ( ( (u32) priv->dmaStorageDMA ) + 7 ) & 0xFFFFFFF8 );
877         priv->txList = priv->rxList + TLAN_NUM_RX_LISTS;
878         priv->txListDMA = priv->rxListDMA + sizeof(TLanList) * TLAN_NUM_RX_LISTS;
879         if ( bbuf ) {
880                 priv->rxBuffer = (u8 *) ( priv->txList + TLAN_NUM_TX_LISTS );
881                 priv->rxBufferDMA =priv->txListDMA + sizeof(TLanList) * TLAN_NUM_TX_LISTS;
882                 priv->txBuffer = priv->rxBuffer + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
883                 priv->txBufferDMA = priv->rxBufferDMA + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
884         }
885
886         err = 0;
887         for ( i = 0;  i < 6 ; i++ )
888                 err |= TLan_EeReadByte( dev,
889                                         (u8) priv->adapter->addrOfs + i,
890                                         (u8 *) &dev->dev_addr[i] );
891         if ( err ) {
892                 printk(KERN_ERR "TLAN: %s: Error reading MAC from eeprom: %d\n",
893                         dev->name,
894                         err );
895         }
896         dev->addr_len = 6;
897
898         netif_carrier_off(dev);
899
900         /* Device methods */
901         dev->open = &TLan_Open;
902         dev->hard_start_xmit = &TLan_StartTx;
903         dev->stop = &TLan_Close;
904         dev->get_stats = &TLan_GetStats;
905         dev->set_multicast_list = &TLan_SetMulticastList;
906         dev->do_ioctl = &TLan_ioctl;
907 #ifdef CONFIG_NET_POLL_CONTROLLER
908         dev->poll_controller = &TLan_Poll;
909 #endif
910         dev->tx_timeout = &TLan_tx_timeout;
911         dev->watchdog_timeo = TX_TIMEOUT;
912
913         return 0;
914
915 } /* TLan_Init */
916
917
918
919
920         /***************************************************************
921          *      TLan_Open
922          *
923          *      Returns:
924          *              0 on success, error code otherwise.
925          *      Parms:
926          *              dev     Structure of device to be opened.
927          *
928          *      This routine puts the driver and TLAN adapter in a
929          *      state where it is ready to send and receive packets.
930          *      It allocates the IRQ, resets and brings the adapter
931          *      out of reset, and allows interrupts.  It also delays
932          *      the startup for autonegotiation or sends a Rx GO
933          *      command to the adapter, as appropriate.
934          *
935          **************************************************************/
936
937 static int TLan_Open( struct net_device *dev )
938 {
939         TLanPrivateInfo *priv = netdev_priv(dev);
940         int             err;
941         
942         priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
943         err = request_irq( dev->irq, TLan_HandleInterrupt, SA_SHIRQ, TLanSignature, dev );
944         
945         if ( err ) {
946                 printk(KERN_ERR "TLAN:  Cannot open %s because IRQ %d is already in use.\n", dev->name, dev->irq );
947                 return err;
948         }
949         
950         init_timer(&priv->timer);
951         netif_start_queue(dev);
952         
953         /* NOTE: It might not be necessary to read the stats before a
954                          reset if you don't care what the values are.
955         */
956         TLan_ResetLists( dev );
957         TLan_ReadAndClearStats( dev, TLAN_IGNORE );
958         TLan_ResetAdapter( dev );
959
960         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened.  TLAN Chip Rev: %x\n", dev->name, priv->tlanRev );
961
962         return 0;
963
964 } /* TLan_Open */
965
966
967
968         /**************************************************************
969          *      TLan_ioctl
970          *      
971          *      Returns:
972          *              0 on success, error code otherwise
973          *      Params:
974          *              dev     structure of device to receive ioctl.
975          *              
976          *              rq      ifreq structure to hold userspace data.
977          *
978          *              cmd     ioctl command.
979          *
980          *
981          *************************************************************/
982
983 static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
984 {
985         TLanPrivateInfo *priv = netdev_priv(dev);
986         struct mii_ioctl_data *data = if_mii(rq);
987         u32 phy   = priv->phy[priv->phyNum];
988         
989         if (!priv->phyOnline)
990                 return -EAGAIN;
991
992         switch(cmd) {
993         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
994                         data->phy_id = phy;
995
996
997         case SIOCGMIIREG:               /* Read MII PHY register. */
998                         TLan_MiiReadReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, &data->val_out);
999                         return 0;
1000                 
1001
1002         case SIOCSMIIREG:               /* Write MII PHY register. */
1003                         if (!capable(CAP_NET_ADMIN))
1004                                 return -EPERM;
1005                         TLan_MiiWriteReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1006                         return 0;
1007                 default:
1008                         return -EOPNOTSUPP;
1009         }
1010 } /* tlan_ioctl */
1011
1012
1013         /***************************************************************
1014          *      TLan_tx_timeout
1015          *
1016          *      Returns: nothing
1017          *
1018          *      Params:
1019          *              dev     structure of device which timed out 
1020          *                      during transmit.
1021          *
1022          **************************************************************/
1023
1024 static void TLan_tx_timeout(struct net_device *dev)
1025 {
1026         
1027         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Transmit timed out.\n", dev->name);
1028         
1029         /* Ok so we timed out, lets see what we can do about it...*/
1030         TLan_FreeLists( dev );
1031         TLan_ResetLists( dev );         
1032         TLan_ReadAndClearStats( dev, TLAN_IGNORE );
1033         TLan_ResetAdapter( dev );
1034         dev->trans_start = jiffies;
1035         netif_wake_queue( dev );        
1036
1037 }
1038         
1039
1040
1041         /***************************************************************
1042          *      TLan_StartTx
1043          *  
1044          *      Returns:
1045          *              0 on success, non-zero on failure.
1046          *      Parms:
1047          *              skb     A pointer to the sk_buff containing the
1048          *                      frame to be sent.
1049          *              dev     The device to send the data on.
1050          *
1051          *      This function adds a frame to the Tx list to be sent
1052          *      ASAP.  First it verifies that the adapter is ready and
1053          *      there is room in the queue.  Then it sets up the next
1054          *      available list, copies the frame to the corresponding
1055          *      buffer.  If the adapter Tx channel is idle, it gives
1056          *      the adapter a Tx Go command on the list, otherwise it
1057          *      sets the forward address of the previous list to point
1058          *      to this one.  Then it frees the sk_buff.
1059          *
1060          **************************************************************/
1061
1062 static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
1063 {
1064         TLanPrivateInfo *priv = netdev_priv(dev);
1065         TLanList        *tail_list;
1066         dma_addr_t      tail_list_phys;
1067         u8              *tail_buffer;
1068         int             pad;
1069         unsigned long   flags;
1070
1071         if ( ! priv->phyOnline ) {
1072                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s PHY is not ready\n", dev->name );
1073                 dev_kfree_skb_any(skb);
1074                 return 0;
1075         }
1076
1077         tail_list = priv->txList + priv->txTail;
1078         tail_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txTail;
1079         
1080         if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) {
1081                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s is busy (Head=%d Tail=%d)\n", dev->name, priv->txHead, priv->txTail );
1082                 netif_stop_queue(dev);
1083                 priv->txBusyCount++;
1084                 return 1;
1085         }
1086
1087         tail_list->forward = 0;
1088
1089         if ( bbuf ) {
1090                 tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
1091                 memcpy( tail_buffer, skb->data, skb->len );
1092         } else {
1093                 tail_list->buffer[0].address = pci_map_single(priv->pciDev, skb->data, skb->len, PCI_DMA_TODEVICE);
1094                 TLan_StoreSKB(tail_list, skb);
1095         }
1096
1097         pad = TLAN_MIN_FRAME_SIZE - skb->len;
1098
1099         if ( pad > 0 ) {
1100                 tail_list->frameSize = (u16) skb->len + pad;
1101                 tail_list->buffer[0].count = (u32) skb->len;
1102                 tail_list->buffer[1].count = TLAN_LAST_BUFFER | (u32) pad;
1103                 tail_list->buffer[1].address = TLanPadBufferDMA;
1104         } else {
1105                 tail_list->frameSize = (u16) skb->len;
1106                 tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len;
1107                 tail_list->buffer[1].count = 0;
1108                 tail_list->buffer[1].address = 0;
1109         }
1110
1111         spin_lock_irqsave(&priv->lock, flags);
1112         tail_list->cStat = TLAN_CSTAT_READY;
1113         if ( ! priv->txInProgress ) {
1114                 priv->txInProgress = 1;
1115                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Starting TX on buffer %d\n", priv->txTail );
1116                 outl( tail_list_phys, dev->base_addr + TLAN_CH_PARM );
1117                 outl( TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD );
1118         } else {
1119                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Adding buffer %d to TX channel\n", priv->txTail );
1120                 if ( priv->txTail == 0 ) {
1121                         ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward = tail_list_phys;
1122                 } else {
1123                         ( priv->txList + ( priv->txTail - 1 ) )->forward = tail_list_phys;
1124                 }
1125         }
1126         spin_unlock_irqrestore(&priv->lock, flags);
1127
1128         CIRC_INC( priv->txTail, TLAN_NUM_TX_LISTS );
1129
1130         if ( bbuf )
1131                 dev_kfree_skb_any(skb);
1132                 
1133         dev->trans_start = jiffies;
1134         return 0;
1135
1136 } /* TLan_StartTx */
1137
1138
1139
1140
1141         /***************************************************************
1142          *      TLan_HandleInterrupt
1143          *  
1144          *      Returns:        
1145          *              Nothing
1146          *      Parms:
1147          *              irq     The line on which the interrupt
1148          *                      occurred.
1149          *              dev_id  A pointer to the device assigned to
1150          *                      this irq line.
1151          *              regs    ???
1152          *
1153          *      This function handles an interrupt generated by its
1154          *      assigned TLAN adapter.  The function deactivates
1155          *      interrupts on its adapter, records the type of
1156          *      interrupt, executes the appropriate subhandler, and
1157          *      acknowdges the interrupt to the adapter (thus
1158          *      re-enabling adapter interrupts.
1159          *
1160          **************************************************************/
1161
1162 static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id, struct pt_regs *regs)
1163 {
1164         u32             ack;
1165         struct net_device       *dev;
1166         u32             host_cmd;
1167         u16             host_int;
1168         int             type;
1169         TLanPrivateInfo *priv;
1170
1171         dev = dev_id;
1172         priv = netdev_priv(dev);
1173
1174         spin_lock(&priv->lock);
1175
1176         host_int = inw( dev->base_addr + TLAN_HOST_INT );
1177         outw( host_int, dev->base_addr + TLAN_HOST_INT );
1178
1179         type = ( host_int & TLAN_HI_IT_MASK ) >> 2;
1180
1181         ack = TLanIntVector[type]( dev, host_int );
1182
1183         if ( ack ) {
1184                 host_cmd = TLAN_HC_ACK | ack | ( type << 18 );
1185                 outl( host_cmd, dev->base_addr + TLAN_HOST_CMD );
1186         }
1187
1188         spin_unlock(&priv->lock);
1189
1190         return IRQ_HANDLED;
1191 } /* TLan_HandleInterrupts */
1192
1193
1194
1195
1196         /***************************************************************
1197          *      TLan_Close
1198          *  
1199          *      Returns:
1200          *              An error code.
1201          *      Parms:
1202          *              dev     The device structure of the device to
1203          *                      close.
1204          *
1205          *      This function shuts down the adapter.  It records any
1206          *      stats, puts the adapter into reset state, deactivates
1207          *      its time as needed, and frees the irq it is using.
1208          *
1209          **************************************************************/
1210
1211 static int TLan_Close(struct net_device *dev)
1212 {
1213         TLanPrivateInfo *priv = netdev_priv(dev);
1214
1215         netif_stop_queue(dev);
1216         priv->neg_be_verbose = 0;
1217
1218         TLan_ReadAndClearStats( dev, TLAN_RECORD );
1219         outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1220         if ( priv->timer.function != NULL ) {
1221                 del_timer_sync( &priv->timer );
1222                 priv->timer.function = NULL;
1223         }
1224         
1225         free_irq( dev->irq, dev );
1226         TLan_FreeLists( dev );
1227         TLAN_DBG( TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name );
1228
1229         return 0;
1230
1231 } /* TLan_Close */
1232
1233
1234
1235
1236         /***************************************************************
1237          *      TLan_GetStats
1238          *  
1239          *      Returns:
1240          *              A pointer to the device's statistics structure.
1241          *      Parms:
1242          *              dev     The device structure to return the
1243          *                      stats for.
1244          *
1245          *      This function updates the devices statistics by reading
1246          *      the TLAN chip's onboard registers.  Then it returns the
1247          *      address of the statistics structure.
1248          *
1249          **************************************************************/
1250
1251 static struct net_device_stats *TLan_GetStats( struct net_device *dev )
1252 {
1253         TLanPrivateInfo *priv = netdev_priv(dev);
1254         int i;
1255
1256         /* Should only read stats if open ? */
1257         TLan_ReadAndClearStats( dev, TLAN_RECORD );
1258
1259         TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  %s EOC count = %d\n", dev->name, priv->rxEocCount );
1260         TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s Busy count = %d\n", dev->name, priv->txBusyCount );
1261         if ( debug & TLAN_DEBUG_GNRL ) {
1262                 TLan_PrintDio( dev->base_addr );
1263                 TLan_PhyPrint( dev );           
1264         }
1265         if ( debug & TLAN_DEBUG_LIST ) {
1266                 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ )
1267                         TLan_PrintList( priv->rxList + i, "RX", i );
1268                 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ )
1269                         TLan_PrintList( priv->txList + i, "TX", i );
1270         }
1271         
1272         return ( &( (TLanPrivateInfo *) netdev_priv(dev) )->stats );
1273
1274 } /* TLan_GetStats */
1275
1276
1277
1278
1279         /***************************************************************
1280          *      TLan_SetMulticastList
1281          *  
1282          *      Returns:
1283          *              Nothing
1284          *      Parms:
1285          *              dev     The device structure to set the
1286          *                      multicast list for.
1287          *
1288          *      This function sets the TLAN adaptor to various receive
1289          *      modes.  If the IFF_PROMISC flag is set, promiscuous
1290          *      mode is acitviated.  Otherwise, promiscuous mode is
1291          *      turned off.  If the IFF_ALLMULTI flag is set, then
1292          *      the hash table is set to receive all group addresses.
1293          *      Otherwise, the first three multicast addresses are
1294          *      stored in AREG_1-3, and the rest are selected via the
1295          *      hash table, as necessary.
1296          *
1297          **************************************************************/
1298
1299 static void TLan_SetMulticastList( struct net_device *dev )
1300 {       
1301         struct dev_mc_list      *dmi = dev->mc_list;
1302         u32                     hash1 = 0;
1303         u32                     hash2 = 0;
1304         int                     i;
1305         u32                     offset;
1306         u8                      tmp;
1307
1308         if ( dev->flags & IFF_PROMISC ) {
1309                 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1310                 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF );
1311         } else {
1312                 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1313                 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF );
1314                 if ( dev->flags & IFF_ALLMULTI ) {
1315                         for ( i = 0; i < 3; i++ ) 
1316                                 TLan_SetMac( dev, i + 1, NULL );
1317                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF );
1318                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF );
1319                 } else {
1320                         for ( i = 0; i < dev->mc_count; i++ ) {
1321                                 if ( i < 3 ) {
1322                                         TLan_SetMac( dev, i + 1, (char *) &dmi->dmi_addr );
1323                                 } else {
1324                                         offset = TLan_HashFunc( (u8 *) &dmi->dmi_addr );
1325                                         if ( offset < 32 ) 
1326                                                 hash1 |= ( 1 << offset );
1327                                         else
1328                                                 hash2 |= ( 1 << ( offset - 32 ) );
1329                                 }
1330                                 dmi = dmi->next;
1331                         }
1332                         for ( ; i < 3; i++ ) 
1333                                 TLan_SetMac( dev, i + 1, NULL );
1334                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 );
1335                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 );
1336                 }
1337         }
1338
1339 } /* TLan_SetMulticastList */
1340
1341
1342
1343 /*****************************************************************************
1344 ******************************************************************************
1345
1346         ThunderLAN Driver Interrupt Vectors and Table
1347
1348         Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN
1349         Programmer's Guide" for more informations on handling interrupts
1350         generated by TLAN based adapters.  
1351
1352 ******************************************************************************
1353 *****************************************************************************/
1354
1355
1356         /***************************************************************
1357          *      TLan_HandleInvalid
1358          *
1359          *      Returns:
1360          *              0
1361          *      Parms:
1362          *              dev             Device assigned the IRQ that was
1363          *                              raised.
1364          *              host_int        The contents of the HOST_INT
1365          *                              port.
1366          *
1367          *      This function handles invalid interrupts.  This should
1368          *      never happen unless some other adapter is trying to use
1369          *      the IRQ line assigned to the device.
1370          *
1371          **************************************************************/
1372
1373 u32 TLan_HandleInvalid( struct net_device *dev, u16 host_int )
1374 {
1375         /* printk( "TLAN:  Invalid interrupt on %s.\n", dev->name ); */
1376         return 0;
1377
1378 } /* TLan_HandleInvalid */
1379
1380
1381
1382
1383         /***************************************************************
1384          *      TLan_HandleTxEOF
1385          *
1386          *      Returns:
1387          *              1
1388          *      Parms:
1389          *              dev             Device assigned the IRQ that was
1390          *                              raised.
1391          *              host_int        The contents of the HOST_INT
1392          *                              port.
1393          *
1394          *      This function handles Tx EOF interrupts which are raised
1395          *      by the adapter when it has completed sending the
1396          *      contents of a buffer.  If detemines which list/buffer
1397          *      was completed and resets it.  If the buffer was the last
1398          *      in the channel (EOC), then the function checks to see if
1399          *      another buffer is ready to send, and if so, sends a Tx
1400          *      Go command.  Finally, the driver activates/continues the
1401          *      activity LED.
1402          *
1403          **************************************************************/
1404
1405 u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
1406 {
1407         TLanPrivateInfo *priv = netdev_priv(dev);
1408         int             eoc = 0;
1409         TLanList        *head_list;
1410         dma_addr_t      head_list_phys;
1411         u32             ack = 0;
1412         u16             tmpCStat;
1413         
1414         TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOF (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
1415         head_list = priv->txList + priv->txHead;
1416
1417         while (((tmpCStat = head_list->cStat ) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1418                 ack++;
1419                 if ( ! bbuf ) {
1420                         struct sk_buff *skb = TLan_GetSKB(head_list);
1421                         pci_unmap_single(priv->pciDev, head_list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
1422                         dev_kfree_skb_any(skb);
1423                         head_list->buffer[8].address = 0;
1424                         head_list->buffer[9].address = 0;
1425                 }
1426         
1427                 if ( tmpCStat & TLAN_CSTAT_EOC )
1428                         eoc = 1;
1429                         
1430                 priv->stats.tx_bytes += head_list->frameSize;
1431
1432                 head_list->cStat = TLAN_CSTAT_UNUSED;
1433                 netif_start_queue(dev);         
1434                 CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS ); 
1435                 head_list = priv->txList + priv->txHead;
1436         }
1437
1438         if (!ack)
1439                 printk(KERN_INFO "TLAN: Received interrupt for uncompleted TX frame.\n");
1440         
1441         if ( eoc ) {
1442                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
1443                 head_list = priv->txList + priv->txHead;
1444                 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1445                 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1446                         outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1447                         ack |= TLAN_HC_GO;
1448                 } else {
1449                         priv->txInProgress = 0;
1450                 }
1451         }
1452         
1453         if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1454                 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1455                 if ( priv->timer.function == NULL ) {
1456                          priv->timer.function = &TLan_Timer;
1457                          priv->timer.data = (unsigned long) dev;
1458                          priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1459                          priv->timerSetAt = jiffies;
1460                          priv->timerType = TLAN_TIMER_ACTIVITY;
1461                          add_timer(&priv->timer);
1462                 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1463                         priv->timerSetAt = jiffies;
1464                 }
1465         }
1466
1467         return ack;
1468
1469 } /* TLan_HandleTxEOF */
1470
1471
1472
1473
1474         /***************************************************************
1475          *      TLan_HandleStatOverflow
1476          *
1477          *      Returns:
1478          *              1
1479          *      Parms:
1480          *              dev             Device assigned the IRQ that was
1481          *                              raised.
1482          *              host_int        The contents of the HOST_INT
1483          *                              port.
1484          *
1485          *      This function handles the Statistics Overflow interrupt
1486          *      which means that one or more of the TLAN statistics
1487          *      registers has reached 1/2 capacity and needs to be read.
1488          *
1489          **************************************************************/
1490
1491 u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
1492 {
1493         TLan_ReadAndClearStats( dev, TLAN_RECORD );
1494
1495         return 1;
1496
1497 } /* TLan_HandleStatOverflow */
1498
1499
1500
1501
1502         /***************************************************************
1503          *      TLan_HandleRxEOF
1504          *
1505          *      Returns:
1506          *              1
1507          *      Parms:
1508          *              dev             Device assigned the IRQ that was
1509          *                              raised.
1510          *              host_int        The contents of the HOST_INT
1511          *                              port.
1512          *
1513          *      This function handles the Rx EOF interrupt which
1514          *      indicates a frame has been received by the adapter from
1515          *      the net and the frame has been transferred to memory.
1516          *      The function determines the bounce buffer the frame has
1517          *      been loaded into, creates a new sk_buff big enough to
1518          *      hold the frame, and sends it to protocol stack.  It
1519          *      then resets the used buffer and appends it to the end
1520          *      of the list.  If the frame was the last in the Rx
1521          *      channel (EOC), the function restarts the receive channel
1522          *      by sending an Rx Go command to the adapter.  Then it
1523          *      activates/continues the activity LED.
1524          *
1525          **************************************************************/
1526
1527 u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
1528 {
1529         TLanPrivateInfo *priv = netdev_priv(dev);
1530         u32             ack = 0;
1531         int             eoc = 0;
1532         u8              *head_buffer;
1533         TLanList        *head_list;
1534         struct sk_buff  *skb;
1535         TLanList        *tail_list;
1536         void            *t;
1537         u32             frameSize;
1538         u16             tmpCStat;
1539         dma_addr_t      head_list_phys;
1540
1541         TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOF (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
1542         head_list = priv->rxList + priv->rxHead;
1543         head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1544         
1545         while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1546                 frameSize = head_list->frameSize;
1547                 ack++;
1548                 if (tmpCStat & TLAN_CSTAT_EOC)
1549                         eoc = 1;
1550                 
1551                 if (bbuf) {
1552                         skb = dev_alloc_skb(frameSize + 7);
1553                         if (skb == NULL)
1554                                 printk(KERN_INFO "TLAN: Couldn't allocate memory for received data.\n");
1555                         else {
1556                                 head_buffer = priv->rxBuffer + (priv->rxHead * TLAN_MAX_FRAME_SIZE);
1557                                 skb->dev = dev;
1558                                 skb_reserve(skb, 2);
1559                                 t = (void *) skb_put(skb, frameSize);
1560                 
1561                                 priv->stats.rx_bytes += head_list->frameSize;
1562
1563                                 memcpy( t, head_buffer, frameSize );
1564                                 skb->protocol = eth_type_trans( skb, dev );
1565                                 netif_rx( skb );
1566                         }
1567                 } else {
1568                         struct sk_buff *new_skb;
1569                 
1570                         /*
1571                          *      I changed the algorithm here. What we now do
1572                          *      is allocate the new frame. If this fails we
1573                          *      simply recycle the frame.
1574                          */
1575                 
1576                         new_skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
1577                         
1578                         if ( new_skb != NULL ) {
1579                                 skb = TLan_GetSKB(head_list);
1580                                 pci_unmap_single(priv->pciDev, head_list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1581                                 skb_trim( skb, frameSize );
1582
1583                                 priv->stats.rx_bytes += frameSize;
1584
1585                                 skb->protocol = eth_type_trans( skb, dev );
1586                                 netif_rx( skb );
1587         
1588                                 new_skb->dev = dev;
1589                                 skb_reserve( new_skb, 2 );
1590                                 t = (void *) skb_put( new_skb, TLAN_MAX_FRAME_SIZE );
1591                                 head_list->buffer[0].address = pci_map_single(priv->pciDev, new_skb->data, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1592                                 head_list->buffer[8].address = (u32) t;
1593                                 TLan_StoreSKB(head_list, new_skb);
1594                         } else 
1595                                 printk(KERN_WARNING "TLAN:  Couldn't allocate memory for received data.\n" );
1596                 }
1597
1598                 head_list->forward = 0;
1599                 head_list->cStat = 0;
1600                 tail_list = priv->rxList + priv->rxTail;
1601                 tail_list->forward = head_list_phys;
1602
1603                 CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS );
1604                 CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS );
1605                 head_list = priv->rxList + priv->rxHead;
1606                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1607         }
1608
1609         if (!ack)
1610                 printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.\n");
1611         
1612
1613
1614
1615         if ( eoc ) { 
1616                 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
1617                 head_list = priv->rxList + priv->rxHead;
1618                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1619                 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1620                 ack |= TLAN_HC_GO | TLAN_HC_RT;
1621                 priv->rxEocCount++;
1622         }
1623
1624         if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1625                 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1626                 if ( priv->timer.function == NULL )  {
1627                         priv->timer.function = &TLan_Timer;
1628                         priv->timer.data = (unsigned long) dev;
1629                         priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1630                         priv->timerSetAt = jiffies;
1631                         priv->timerType = TLAN_TIMER_ACTIVITY;
1632                         add_timer(&priv->timer);
1633                 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1634                         priv->timerSetAt = jiffies;
1635                 }
1636         }
1637
1638         dev->last_rx = jiffies;
1639         
1640         return ack;
1641
1642 } /* TLan_HandleRxEOF */
1643
1644
1645
1646
1647         /***************************************************************
1648          *      TLan_HandleDummy
1649          *
1650          *      Returns:
1651          *              1
1652          *      Parms:
1653          *              dev             Device assigned the IRQ that was
1654          *                              raised.
1655          *              host_int        The contents of the HOST_INT
1656          *                              port.
1657          *
1658          *      This function handles the Dummy interrupt, which is
1659          *      raised whenever a test interrupt is generated by setting
1660          *      the Req_Int bit of HOST_CMD to 1.
1661          *
1662          **************************************************************/
1663
1664 u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
1665 {
1666         printk( "TLAN:  Test interrupt on %s.\n", dev->name );
1667         return 1;
1668
1669 } /* TLan_HandleDummy */
1670
1671
1672
1673
1674         /***************************************************************
1675          *      TLan_HandleTxEOC
1676          *
1677          *      Returns:
1678          *              1
1679          *      Parms:
1680          *              dev             Device assigned the IRQ that was
1681          *                              raised.
1682          *              host_int        The contents of the HOST_INT
1683          *                              port.
1684          *
1685          *      This driver is structured to determine EOC occurrences by
1686          *      reading the CSTAT member of the list structure.  Tx EOC
1687          *      interrupts are disabled via the DIO INTDIS register.
1688          *      However, TLAN chips before revision 3.0 didn't have this
1689          *      functionality, so process EOC events if this is the
1690          *      case.
1691          *
1692          **************************************************************/
1693
1694 u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
1695 {
1696         TLanPrivateInfo *priv = netdev_priv(dev);
1697         TLanList                *head_list;
1698         dma_addr_t              head_list_phys;
1699         u32                     ack = 1;
1700         
1701         host_int = 0;
1702         if ( priv->tlanRev < 0x30 ) {
1703                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d) -- IRQ\n", priv->txHead, priv->txTail );
1704                 head_list = priv->txList + priv->txHead;
1705                 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1706                 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1707                         netif_stop_queue(dev);
1708                         outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1709                         ack |= TLAN_HC_GO;
1710                 } else {
1711                         priv->txInProgress = 0;
1712                 }
1713         }
1714
1715         return ack;
1716
1717 } /* TLan_HandleTxEOC */
1718
1719
1720
1721
1722         /***************************************************************
1723          *      TLan_HandleStatusCheck
1724          *
1725          *      Returns:
1726          *              0 if Adapter check, 1 if Network Status check.
1727          *      Parms:
1728          *              dev             Device assigned the IRQ that was
1729          *                              raised.
1730          *              host_int        The contents of the HOST_INT
1731          *                              port.
1732          *
1733          *      This function handles Adapter Check/Network Status
1734          *      interrupts generated by the adapter.  It checks the
1735          *      vector in the HOST_INT register to determine if it is
1736          *      an Adapter Check interrupt.  If so, it resets the
1737          *      adapter.  Otherwise it clears the status registers
1738          *      and services the PHY.
1739          *
1740          **************************************************************/
1741
1742 u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
1743 {       
1744         TLanPrivateInfo *priv = netdev_priv(dev);
1745         u32             ack;
1746         u32             error;
1747         u8              net_sts;
1748         u32             phy;
1749         u16             tlphy_ctl;
1750         u16             tlphy_sts;
1751         
1752         ack = 1;
1753         if ( host_int & TLAN_HI_IV_MASK ) {
1754                 netif_stop_queue( dev );
1755                 error = inl( dev->base_addr + TLAN_CH_PARM );
1756                 printk( "TLAN:  %s: Adaptor Error = 0x%x\n", dev->name, error );
1757                 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1758                 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1759
1760                 schedule_work(&priv->tlan_tqueue);
1761
1762                 netif_wake_queue(dev);
1763                 ack = 0;
1764         } else {
1765                 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name );
1766                 phy = priv->phy[priv->phyNum];
1767
1768                 net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS );
1769                 if ( net_sts ) {
1770                         TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts );
1771                         TLAN_DBG( TLAN_DEBUG_GNRL, "%s:    Net_Sts = %x\n", dev->name, (unsigned) net_sts );
1772                 }
1773                 if ( ( net_sts & TLAN_NET_STS_MIRQ ) &&  ( priv->phyNum == 0 ) ) {
1774                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts );
1775                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
1776                         if ( ! ( tlphy_sts & TLAN_TS_POLOK ) && ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1777                                 tlphy_ctl |= TLAN_TC_SWAPOL;
1778                                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1779                         } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1780                                 tlphy_ctl &= ~TLAN_TC_SWAPOL;
1781                                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1782                         }
1783
1784                         if (debug) {
1785                                 TLan_PhyPrint( dev );           
1786                         }
1787                 }
1788         }
1789
1790         return ack;
1791
1792 } /* TLan_HandleStatusCheck */
1793
1794
1795
1796
1797         /***************************************************************
1798          *      TLan_HandleRxEOC
1799          *
1800          *      Returns:
1801          *              1
1802          *      Parms:
1803          *              dev             Device assigned the IRQ that was
1804          *                              raised.
1805          *              host_int        The contents of the HOST_INT
1806          *                              port.
1807          *
1808          *      This driver is structured to determine EOC occurrences by
1809          *      reading the CSTAT member of the list structure.  Rx EOC
1810          *      interrupts are disabled via the DIO INTDIS register.
1811          *      However, TLAN chips before revision 3.0 didn't have this
1812          *      CSTAT member or a INTDIS register, so if this chip is
1813          *      pre-3.0, process EOC interrupts normally.
1814          *
1815          **************************************************************/
1816
1817 u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
1818 {
1819         TLanPrivateInfo *priv = netdev_priv(dev);
1820         dma_addr_t      head_list_phys;
1821         u32             ack = 1;
1822
1823         if (  priv->tlanRev < 0x30 ) {
1824                 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d) -- IRQ\n", priv->rxHead, priv->rxTail );
1825                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1826                 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1827                 ack |= TLAN_HC_GO | TLAN_HC_RT;
1828                 priv->rxEocCount++;
1829         }
1830
1831         return ack;
1832
1833 } /* TLan_HandleRxEOC */
1834
1835
1836
1837
1838 /*****************************************************************************
1839 ******************************************************************************
1840
1841         ThunderLAN Driver Timer Function
1842
1843 ******************************************************************************
1844 *****************************************************************************/
1845
1846
1847         /***************************************************************
1848          *      TLan_Timer
1849          *
1850          *      Returns:
1851          *              Nothing
1852          *      Parms:
1853          *              data    A value given to add timer when
1854          *                      add_timer was called.
1855          *
1856          *      This function handles timed functionality for the
1857          *      TLAN driver.  The two current timer uses are for
1858          *      delaying for autonegotionation and driving the ACT LED.
1859          *      -       Autonegotiation requires being allowed about
1860          *              2 1/2 seconds before attempting to transmit a
1861          *              packet.  It would be a very bad thing to hang
1862          *              the kernel this long, so the driver doesn't
1863          *              allow transmission 'til after this time, for
1864          *              certain PHYs.  It would be much nicer if all
1865          *              PHYs were interrupt-capable like the internal
1866          *              PHY.
1867          *      -       The ACT LED, which shows adapter activity, is
1868          *              driven by the driver, and so must be left on
1869          *              for a short period to power up the LED so it
1870          *              can be seen.  This delay can be changed by
1871          *              changing the TLAN_TIMER_ACT_DELAY in tlan.h,
1872          *              if desired.  100 ms  produces a slightly
1873          *              sluggish response.
1874          *
1875          **************************************************************/
1876
1877 void TLan_Timer( unsigned long data )
1878 {
1879         struct net_device       *dev = (struct net_device *) data;
1880         TLanPrivateInfo *priv = netdev_priv(dev);
1881         u32             elapsed;
1882         unsigned long   flags = 0;
1883
1884         priv->timer.function = NULL;
1885
1886         switch ( priv->timerType ) {
1887 #ifdef MONITOR          
1888                 case TLAN_TIMER_LINK_BEAT:
1889                         TLan_PhyMonitor( dev );
1890                         break;
1891 #endif
1892                 case TLAN_TIMER_PHY_PDOWN:
1893                         TLan_PhyPowerDown( dev );
1894                         break;
1895                 case TLAN_TIMER_PHY_PUP:
1896                         TLan_PhyPowerUp( dev );
1897                         break;
1898                 case TLAN_TIMER_PHY_RESET:
1899                         TLan_PhyReset( dev );
1900                         break;
1901                 case TLAN_TIMER_PHY_START_LINK:
1902                         TLan_PhyStartLink( dev );
1903                         break;
1904                 case TLAN_TIMER_PHY_FINISH_AN:
1905                         TLan_PhyFinishAutoNeg( dev );
1906                         break;
1907                 case TLAN_TIMER_FINISH_RESET:
1908                         TLan_FinishReset( dev );
1909                         break;
1910                 case TLAN_TIMER_ACTIVITY:
1911                         spin_lock_irqsave(&priv->lock, flags);
1912                         if ( priv->timer.function == NULL ) {
1913                                 elapsed = jiffies - priv->timerSetAt;
1914                                 if ( elapsed >= TLAN_TIMER_ACT_DELAY ) {
1915                                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
1916                                 } else  {
1917                                         priv->timer.function = &TLan_Timer;
1918                                         priv->timer.expires = priv->timerSetAt + TLAN_TIMER_ACT_DELAY;
1919                                         spin_unlock_irqrestore(&priv->lock, flags);
1920                                         add_timer( &priv->timer );
1921                                         break;
1922                                 }
1923                         }
1924                         spin_unlock_irqrestore(&priv->lock, flags);
1925                         break;
1926                 default:
1927                         break;
1928         }
1929
1930 } /* TLan_Timer */
1931
1932
1933
1934
1935 /*****************************************************************************
1936 ******************************************************************************
1937
1938         ThunderLAN Driver Adapter Related Routines
1939
1940 ******************************************************************************
1941 *****************************************************************************/
1942
1943
1944         /***************************************************************
1945          *      TLan_ResetLists
1946          *  
1947          *      Returns:
1948          *              Nothing
1949          *      Parms:
1950          *              dev     The device structure with the list
1951          *                      stuctures to be reset.
1952          *
1953          *      This routine sets the variables associated with managing
1954          *      the TLAN lists to their initial values.
1955          *
1956          **************************************************************/
1957
1958 void TLan_ResetLists( struct net_device *dev )
1959 {
1960         TLanPrivateInfo *priv = netdev_priv(dev);
1961         int             i;
1962         TLanList        *list;
1963         dma_addr_t      list_phys;
1964         struct sk_buff  *skb;
1965         void            *t = NULL;
1966
1967         priv->txHead = 0;
1968         priv->txTail = 0;
1969         for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
1970                 list = priv->txList + i;
1971                 list->cStat = TLAN_CSTAT_UNUSED;
1972                 if ( bbuf ) {
1973                         list->buffer[0].address = priv->txBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
1974                 } else {
1975                         list->buffer[0].address = 0;
1976                 }
1977                 list->buffer[2].count = 0;
1978                 list->buffer[2].address = 0;
1979                 list->buffer[8].address = 0;
1980                 list->buffer[9].address = 0;
1981         }
1982
1983         priv->rxHead = 0;
1984         priv->rxTail = TLAN_NUM_RX_LISTS - 1;
1985         for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
1986                 list = priv->rxList + i;
1987                 list_phys = priv->rxListDMA + sizeof(TLanList) * i;
1988                 list->cStat = TLAN_CSTAT_READY;
1989                 list->frameSize = TLAN_MAX_FRAME_SIZE;
1990                 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
1991                 if ( bbuf ) {
1992                         list->buffer[0].address = priv->rxBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
1993                 } else {
1994                         skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
1995                         if ( skb == NULL ) {
1996                                 printk( "TLAN:  Couldn't allocate memory for received data.\n" );
1997                                 /* If this ever happened it would be a problem */
1998                         } else {
1999                                 skb->dev = dev;
2000                                 skb_reserve( skb, 2 );
2001                                 t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE );
2002                         }
2003                         list->buffer[0].address = pci_map_single(priv->pciDev, t, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
2004                         list->buffer[8].address = (u32) t;
2005                         TLan_StoreSKB(list, skb);
2006                 }
2007                 list->buffer[1].count = 0;
2008                 list->buffer[1].address = 0;
2009                 if ( i < TLAN_NUM_RX_LISTS - 1 )
2010                         list->forward = list_phys + sizeof(TLanList);
2011                 else
2012                         list->forward = 0;
2013         }
2014
2015 } /* TLan_ResetLists */
2016
2017
2018 void TLan_FreeLists( struct net_device *dev )
2019 {
2020         TLanPrivateInfo *priv = netdev_priv(dev);
2021         int             i;
2022         TLanList        *list;
2023         struct sk_buff  *skb;
2024
2025         if ( ! bbuf ) {
2026                 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
2027                         list = priv->txList + i;
2028                         skb = TLan_GetSKB(list);
2029                         if ( skb ) {
2030                                 pci_unmap_single(priv->pciDev, list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
2031                                 dev_kfree_skb_any( skb );
2032                                 list->buffer[8].address = 0;
2033                                 list->buffer[9].address = 0;
2034                         }
2035                 }
2036
2037                 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
2038                         list = priv->rxList + i;
2039                         skb = TLan_GetSKB(list);
2040                         if ( skb ) {
2041                                 pci_unmap_single(priv->pciDev, list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
2042                                 dev_kfree_skb_any( skb );
2043                                 list->buffer[8].address = 0;
2044                                 list->buffer[9].address = 0;
2045                         }
2046                 }
2047         }
2048 } /* TLan_FreeLists */
2049
2050
2051
2052
2053         /***************************************************************
2054          *      TLan_PrintDio
2055          *  
2056          *      Returns:
2057          *              Nothing
2058          *      Parms:
2059          *              io_base         Base IO port of the device of
2060          *                              which to print DIO registers.
2061          *
2062          *      This function prints out all the internal (DIO)
2063          *      registers of a TLAN chip.
2064          *
2065          **************************************************************/
2066
2067 void TLan_PrintDio( u16 io_base )
2068 {
2069         u32 data0, data1;
2070         int     i;
2071
2072         printk( "TLAN:   Contents of internal registers for io base 0x%04hx.\n", io_base );
2073         printk( "TLAN:      Off.  +0         +4\n" );
2074         for ( i = 0; i < 0x4C; i+= 8 ) {
2075                 data0 = TLan_DioRead32( io_base, i );
2076                 data1 = TLan_DioRead32( io_base, i + 0x4 );
2077                 printk( "TLAN:      0x%02x  0x%08x 0x%08x\n", i, data0, data1 );
2078         }
2079
2080 } /* TLan_PrintDio */
2081
2082
2083
2084
2085         /***************************************************************
2086          *      TLan_PrintList
2087          *  
2088          *      Returns:
2089          *              Nothing
2090          *      Parms:
2091          *              list    A pointer to the TLanList structure to
2092          *                      be printed.
2093          *              type    A string to designate type of list,
2094          *                      "Rx" or "Tx".
2095          *              num     The index of the list.
2096          *
2097          *      This function prints out the contents of the list
2098          *      pointed to by the list parameter.
2099          *
2100          **************************************************************/
2101
2102 void TLan_PrintList( TLanList *list, char *type, int num)
2103 {
2104         int i;
2105
2106         printk( "TLAN:   %s List %d at 0x%08x\n", type, num, (u32) list );
2107         printk( "TLAN:      Forward    = 0x%08x\n",  list->forward );
2108         printk( "TLAN:      CSTAT      = 0x%04hx\n", list->cStat );
2109         printk( "TLAN:      Frame Size = 0x%04hx\n", list->frameSize );
2110         /* for ( i = 0; i < 10; i++ ) { */
2111         for ( i = 0; i < 2; i++ ) {
2112                 printk( "TLAN:      Buffer[%d].count, addr = 0x%08x, 0x%08x\n", i, list->buffer[i].count, list->buffer[i].address );
2113         }
2114
2115 } /* TLan_PrintList */
2116
2117
2118
2119
2120         /***************************************************************
2121          *      TLan_ReadAndClearStats
2122          *
2123          *      Returns:
2124          *              Nothing
2125          *      Parms:
2126          *              dev     Pointer to device structure of adapter
2127          *                      to which to read stats.
2128          *              record  Flag indicating whether to add 
2129          *
2130          *      This functions reads all the internal status registers
2131          *      of the TLAN chip, which clears them as a side effect.
2132          *      It then either adds the values to the device's status
2133          *      struct, or discards them, depending on whether record
2134          *      is TLAN_RECORD (!=0)  or TLAN_IGNORE (==0).
2135          *
2136          **************************************************************/
2137
2138 void TLan_ReadAndClearStats( struct net_device *dev, int record )
2139 {
2140         TLanPrivateInfo *priv = netdev_priv(dev);
2141         u32             tx_good, tx_under;
2142         u32             rx_good, rx_over;
2143         u32             def_tx, crc, code;
2144         u32             multi_col, single_col;
2145         u32             excess_col, late_col, loss;
2146
2147         outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2148         tx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2149         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2150         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2151         tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2152
2153         outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2154         rx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2155         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2156         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2157         rx_over  = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2158                 
2159         outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
2160         def_tx  = inb( dev->base_addr + TLAN_DIO_DATA );
2161         def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2162         crc     = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2163         code    = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2164         
2165         outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2166         multi_col   = inb( dev->base_addr + TLAN_DIO_DATA );
2167         multi_col  += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2168         single_col  = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2169         single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8;
2170
2171         outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2172         excess_col = inb( dev->base_addr + TLAN_DIO_DATA );
2173         late_col   = inb( dev->base_addr + TLAN_DIO_DATA + 1 );
2174         loss       = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2175
2176         if ( record ) {
2177                 priv->stats.rx_packets += rx_good;
2178                 priv->stats.rx_errors  += rx_over + crc + code;
2179                 priv->stats.tx_packets += tx_good;
2180                 priv->stats.tx_errors  += tx_under + loss;
2181                 priv->stats.collisions += multi_col + single_col + excess_col + late_col;
2182
2183                 priv->stats.rx_over_errors    += rx_over;
2184                 priv->stats.rx_crc_errors     += crc;
2185                 priv->stats.rx_frame_errors   += code;
2186
2187                 priv->stats.tx_aborted_errors += tx_under;
2188                 priv->stats.tx_carrier_errors += loss;
2189         }
2190                         
2191 } /* TLan_ReadAndClearStats */
2192
2193
2194
2195
2196         /***************************************************************
2197          *      TLan_Reset
2198          *
2199          *      Returns:
2200          *              0
2201          *      Parms:
2202          *              dev     Pointer to device structure of adapter
2203          *                      to be reset.
2204          *
2205          *      This function resets the adapter and it's physical
2206          *      device.  See Chap. 3, pp. 9-10 of the "ThunderLAN
2207          *      Programmer's Guide" for details.  The routine tries to
2208          *      implement what is detailed there, though adjustments
2209          *      have been made.
2210          *
2211          **************************************************************/
2212
2213 void
2214 TLan_ResetAdapter( struct net_device *dev )
2215 {
2216         TLanPrivateInfo *priv = netdev_priv(dev);
2217         int             i;
2218         u32             addr;
2219         u32             data;
2220         u8              data8;
2221
2222         priv->tlanFullDuplex = FALSE;
2223         priv->phyOnline=0;
2224         netif_carrier_off(dev);
2225
2226 /*  1.  Assert reset bit. */
2227
2228         data = inl(dev->base_addr + TLAN_HOST_CMD);
2229         data |= TLAN_HC_AD_RST;
2230         outl(data, dev->base_addr + TLAN_HOST_CMD);
2231         
2232         udelay(1000);
2233
2234 /*  2.  Turn off interrupts. ( Probably isn't necessary ) */
2235
2236         data = inl(dev->base_addr + TLAN_HOST_CMD);
2237         data |= TLAN_HC_INT_OFF;
2238         outl(data, dev->base_addr + TLAN_HOST_CMD);
2239
2240 /*  3.  Clear AREGs and HASHs. */
2241
2242         for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) {
2243                 TLan_DioWrite32( dev->base_addr, (u16) i, 0 );
2244         }
2245
2246 /*  4.  Setup NetConfig register. */
2247
2248         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2249         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2250
2251 /*  5.  Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2252
2253         outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD );
2254         outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD );
2255
2256 /*  6.  Unreset the MII by setting NMRST (in NetSio) to 1. */
2257
2258         outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR );
2259         addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2260         TLan_SetBit( TLAN_NET_SIO_NMRST, addr );
2261
2262 /*  7.  Setup the remaining registers. */
2263
2264         if ( priv->tlanRev >= 0x30 ) {
2265                 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
2266                 TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 );
2267         }
2268         TLan_PhyDetect( dev );
2269         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
2270         
2271         if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
2272                 data |= TLAN_NET_CFG_BIT;
2273                 if ( priv->aui == 1 ) {
2274                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a );
2275                 } else if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2276                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 );
2277                         priv->tlanFullDuplex = TRUE;
2278                 } else {
2279                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 );
2280                 }
2281         }
2282
2283         if ( priv->phyNum == 0 ) {
2284                 data |= TLAN_NET_CFG_PHY_EN;
2285         }
2286         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2287
2288         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2289                 TLan_FinishReset( dev );
2290         } else {
2291                 TLan_PhyPowerDown( dev );
2292         }
2293
2294 } /* TLan_ResetAdapter */
2295
2296
2297
2298
2299 void
2300 TLan_FinishReset( struct net_device *dev )
2301 {
2302         TLanPrivateInfo *priv = netdev_priv(dev);
2303         u8              data;
2304         u32             phy;
2305         u8              sio;
2306         u16             status;
2307         u16             partner;
2308         u16             tlphy_ctl;
2309         u16             tlphy_par;
2310         u16             tlphy_id1, tlphy_id2;
2311         int             i;
2312
2313         phy = priv->phy[priv->phyNum];
2314
2315         data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
2316         if ( priv->tlanFullDuplex ) {
2317                 data |= TLAN_NET_CMD_DUPLEX;
2318         }
2319         TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
2320         data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5; 
2321         if ( priv->phyNum == 0 ) {
2322                 data |= TLAN_NET_MASK_MASK7; 
2323         }
2324         TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
2325         TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
2326         TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
2327         TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
2328         
2329         if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) {
2330                 status = MII_GS_LINK;
2331                 printk( "TLAN:  %s: Link forced.\n", dev->name );
2332         } else {
2333                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2334                 udelay( 1000 );
2335                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2336                 if ( (status & MII_GS_LINK) &&   /* We only support link info on Nat.Sem. PHY's */ 
2337                         (tlphy_id1 == NAT_SEM_ID1) &&
2338                         (tlphy_id2 == NAT_SEM_ID2) ) {
2339                         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
2340                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
2341                         
2342                         printk( "TLAN: %s: Link active with ", dev->name );
2343                         if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
2344                                  printk( "forced 10%sMbps %s-Duplex\n", 
2345                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2346                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2347                         } else {
2348                                 printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
2349                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2350                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2351                                 printk("TLAN: Partner capability: ");
2352                                         for (i = 5; i <= 10; i++)
2353                                                 if (partner & (1<<i))
2354                                                         printk("%s",media[i-5]);
2355                                 printk("\n");
2356                         }
2357
2358                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2359 #ifdef MONITOR                  
2360                         /* We have link beat..for now anyway */
2361                         priv->link = 1;
2362                         /*Enabling link beat monitoring */
2363                         TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
2364 #endif 
2365                 } else if (status & MII_GS_LINK)  {
2366                         printk( "TLAN: %s: Link active\n", dev->name );
2367                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2368                 }
2369         }
2370
2371         if ( priv->phyNum == 0 ) {
2372                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
2373                 tlphy_ctl |= TLAN_TC_INTEN;
2374                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl );
2375                 sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO );
2376                 sio |= TLAN_NET_SIO_MINTEN;
2377                 TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio );
2378         }
2379
2380         if ( status & MII_GS_LINK ) {
2381                 TLan_SetMac( dev, 0, dev->dev_addr );
2382                 priv->phyOnline = 1;
2383                 outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2384                 if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
2385                         outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2386                 }
2387                 outl( priv->rxListDMA, dev->base_addr + TLAN_CH_PARM );
2388                 outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
2389                 netif_carrier_on(dev);
2390         } else {
2391                 printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", dev->name );
2392                 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
2393                 return;
2394         }
2395
2396 } /* TLan_FinishReset */
2397
2398
2399
2400
2401         /***************************************************************
2402          *      TLan_SetMac
2403          *
2404          *      Returns:
2405          *              Nothing
2406          *      Parms:
2407          *              dev     Pointer to device structure of adapter
2408          *                      on which to change the AREG.
2409          *              areg    The AREG to set the address in (0 - 3).
2410          *              mac     A pointer to an array of chars.  Each
2411          *                      element stores one byte of the address.
2412          *                      IE, it isn't in ascii.
2413          *
2414          *      This function transfers a MAC address to one of the
2415          *      TLAN AREGs (address registers).  The TLAN chip locks
2416          *      the register on writing to offset 0 and unlocks the
2417          *      register after writing to offset 5.  If NULL is passed
2418          *      in mac, then the AREG is filled with 0's.
2419          *
2420          **************************************************************/
2421
2422 void TLan_SetMac( struct net_device *dev, int areg, char *mac )
2423 {
2424         int i;
2425                         
2426         areg *= 6;
2427
2428         if ( mac != NULL ) {
2429                 for ( i = 0; i < 6; i++ )
2430                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] );
2431         } else {
2432                 for ( i = 0; i < 6; i++ )
2433                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 );
2434         }
2435
2436 } /* TLan_SetMac */
2437
2438
2439
2440
2441 /*****************************************************************************
2442 ******************************************************************************
2443
2444         ThunderLAN Driver PHY Layer Routines
2445
2446 ******************************************************************************
2447 *****************************************************************************/
2448
2449
2450
2451         /*********************************************************************
2452          *      TLan_PhyPrint
2453          *
2454          *      Returns:
2455          *              Nothing
2456          *      Parms:
2457          *              dev     A pointer to the device structure of the
2458          *                      TLAN device having the PHYs to be detailed.
2459          *                              
2460          *      This function prints the registers a PHY (aka transceiver).
2461          *
2462          ********************************************************************/
2463
2464 void TLan_PhyPrint( struct net_device *dev )
2465 {
2466         TLanPrivateInfo *priv = netdev_priv(dev);
2467         u16 i, data0, data1, data2, data3, phy;
2468
2469         phy = priv->phy[priv->phyNum];
2470
2471         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2472                 printk( "TLAN:   Device %s, Unmanaged PHY.\n", dev->name );
2473         } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
2474                 printk( "TLAN:   Device %s, PHY 0x%02x.\n", dev->name, phy );
2475                 printk( "TLAN:      Off.  +0     +1     +2     +3 \n" );
2476                 for ( i = 0; i < 0x20; i+= 4 ) {
2477                         printk( "TLAN:      0x%02x", i );
2478                         TLan_MiiReadReg( dev, phy, i, &data0 );
2479                         printk( " 0x%04hx", data0 );
2480                         TLan_MiiReadReg( dev, phy, i + 1, &data1 );
2481                         printk( " 0x%04hx", data1 );
2482                         TLan_MiiReadReg( dev, phy, i + 2, &data2 );
2483                         printk( " 0x%04hx", data2 );
2484                         TLan_MiiReadReg( dev, phy, i + 3, &data3 );
2485                         printk( " 0x%04hx\n", data3 );
2486                 }
2487         } else {
2488                 printk( "TLAN:   Device %s, Invalid PHY.\n", dev->name );
2489         }
2490
2491 } /* TLan_PhyPrint */
2492
2493
2494
2495
2496         /*********************************************************************
2497          *      TLan_PhyDetect
2498          *
2499          *      Returns:
2500          *              Nothing
2501          *      Parms:
2502          *              dev     A pointer to the device structure of the adapter
2503          *                      for which the PHY needs determined.
2504          *
2505          *      So far I've found that adapters which have external PHYs
2506          *      may also use the internal PHY for part of the functionality.
2507          *      (eg, AUI/Thinnet).  This function finds out if this TLAN
2508          *      chip has an internal PHY, and then finds the first external
2509          *      PHY (starting from address 0) if it exists).
2510          *
2511          ********************************************************************/
2512
2513 void TLan_PhyDetect( struct net_device *dev )
2514 {
2515         TLanPrivateInfo *priv = netdev_priv(dev);
2516         u16             control;
2517         u16             hi;
2518         u16             lo;
2519         u32             phy;
2520
2521         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2522                 priv->phyNum = 0xFFFF;
2523                 return;
2524         }
2525
2526         TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
2527         
2528         if ( hi != 0xFFFF ) {
2529                 priv->phy[0] = TLAN_PHY_MAX_ADDR;
2530         } else {
2531                 priv->phy[0] = TLAN_PHY_NONE;
2532         }
2533
2534         priv->phy[1] = TLAN_PHY_NONE;
2535         for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) {
2536                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
2537                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
2538                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
2539                 if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
2540                         TLAN_DBG( TLAN_DEBUG_GNRL, "PHY found at %02x %04x %04x %04x\n", phy, control, hi, lo );
2541                         if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) {
2542                                 priv->phy[1] = phy;
2543                         }
2544                 }
2545         }
2546
2547         if ( priv->phy[1] != TLAN_PHY_NONE ) {
2548                 priv->phyNum = 1;
2549         } else if ( priv->phy[0] != TLAN_PHY_NONE ) {
2550                 priv->phyNum = 0;
2551         } else {
2552                 printk( "TLAN:  Cannot initialize device, no PHY was found!\n" );
2553         }
2554
2555 } /* TLan_PhyDetect */
2556
2557
2558
2559
2560 void TLan_PhyPowerDown( struct net_device *dev )
2561 {
2562         TLanPrivateInfo *priv = netdev_priv(dev);
2563         u16             value;
2564
2565         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name );
2566         value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
2567         TLan_MiiSync( dev->base_addr );
2568         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2569         if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
2570                 TLan_MiiSync( dev->base_addr );
2571                 TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
2572         }
2573
2574         /* Wait for 50 ms and powerup
2575          * This is abitrary.  It is intended to make sure the
2576          * transceiver settles.
2577          */
2578         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP );
2579
2580 } /* TLan_PhyPowerDown */
2581
2582
2583
2584
2585 void TLan_PhyPowerUp( struct net_device *dev )
2586 {
2587         TLanPrivateInfo *priv = netdev_priv(dev);
2588         u16             value;
2589
2590         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name );
2591         TLan_MiiSync( dev->base_addr );
2592         value = MII_GC_LOOPBK;
2593         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2594         TLan_MiiSync(dev->base_addr);
2595         /* Wait for 500 ms and reset the
2596          * transceiver.  The TLAN docs say both 50 ms and
2597          * 500 ms, so do the longer, just in case.
2598          */
2599         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET );
2600
2601 } /* TLan_PhyPowerUp */
2602
2603
2604
2605
2606 void TLan_PhyReset( struct net_device *dev )
2607 {
2608         TLanPrivateInfo *priv = netdev_priv(dev);
2609         u16             phy;
2610         u16             value;
2611
2612         phy = priv->phy[priv->phyNum];
2613
2614         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name );
2615         TLan_MiiSync( dev->base_addr );
2616         value = MII_GC_LOOPBK | MII_GC_RESET;
2617         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value );
2618         TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2619         while ( value & MII_GC_RESET ) {
2620                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2621         }
2622
2623         /* Wait for 500 ms and initialize.
2624          * I don't remember why I wait this long.
2625          * I've changed this to 50ms, as it seems long enough.
2626          */
2627         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK );
2628
2629 } /* TLan_PhyReset */
2630
2631
2632
2633
2634 void TLan_PhyStartLink( struct net_device *dev )
2635 {
2636         TLanPrivateInfo *priv = netdev_priv(dev);
2637         u16             ability;
2638         u16             control;
2639         u16             data;
2640         u16             phy;
2641         u16             status;
2642         u16             tctl;
2643
2644         phy = priv->phy[priv->phyNum];
2645         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name );
2646         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2647         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
2648
2649         if ( ( status & MII_GS_AUTONEG ) && 
2650              ( ! priv->aui ) ) {
2651                 ability = status >> 11;
2652                 if ( priv->speed  == TLAN_SPEED_10 && 
2653                      priv->duplex == TLAN_DUPLEX_HALF) {
2654                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
2655                 } else if ( priv->speed == TLAN_SPEED_10 &&
2656                             priv->duplex == TLAN_DUPLEX_FULL) {
2657                         priv->tlanFullDuplex = TRUE;
2658                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100);
2659                 } else if ( priv->speed == TLAN_SPEED_100 &&
2660                             priv->duplex == TLAN_DUPLEX_HALF) {
2661                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000);
2662                 } else if ( priv->speed == TLAN_SPEED_100 &&
2663                             priv->duplex == TLAN_DUPLEX_FULL) {
2664                         priv->tlanFullDuplex = TRUE;
2665                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
2666                 } else {
2667         
2668                         /* Set Auto-Neg advertisement */
2669                         TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
2670                         /* Enablee Auto-Neg */
2671                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 );
2672                         /* Restart Auto-Neg */
2673                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 );
2674                         /* Wait for 4 sec for autonegotiation
2675                         * to complete.  The max spec time is less than this
2676                         * but the card need additional time to start AN.
2677                         * .5 sec should be plenty extra.
2678                         */
2679                         printk( "TLAN: %s: Starting autonegotiation.\n", dev->name );
2680                         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
2681                         return;
2682                 }
2683                 
2684         }       
2685         
2686         if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
2687                 priv->phyNum = 0;
2688                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2689                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2690                 TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2691                 return;
2692         }  else if ( priv->phyNum == 0 ) {
2693                 control = 0;
2694                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
2695                 if ( priv->aui ) {
2696                         tctl |= TLAN_TC_AUISEL;
2697                 } else { 
2698                         tctl &= ~TLAN_TC_AUISEL;
2699                         if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2700                                 control |= MII_GC_DUPLEX;
2701                                 priv->tlanFullDuplex = TRUE;
2702                         }
2703                         if ( priv->speed == TLAN_SPEED_100 ) {
2704                                 control |= MII_GC_SPEEDSEL;
2705                         }
2706                 }
2707                 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control );
2708                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl );
2709         }
2710
2711         /* Wait for 2 sec to give the transceiver time
2712          * to establish link.
2713          */
2714         TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET );
2715
2716 } /* TLan_PhyStartLink */
2717
2718
2719
2720
2721 void TLan_PhyFinishAutoNeg( struct net_device *dev )
2722 {
2723         TLanPrivateInfo *priv = netdev_priv(dev);
2724         u16             an_adv;
2725         u16             an_lpa;
2726         u16             data;
2727         u16             mode;
2728         u16             phy;
2729         u16             status;
2730         
2731         phy = priv->phy[priv->phyNum];
2732
2733         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2734         udelay( 1000 );
2735         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2736
2737         if ( ! ( status & MII_GS_AUTOCMPLT ) ) {
2738                 /* Wait for 8 sec to give the process
2739                  * more time.  Perhaps we should fail after a while.
2740                  */
2741                  if (!priv->neg_be_verbose++) {
2742                          printk(KERN_INFO "TLAN:  Giving autonegotiation more time.\n");
2743                          printk(KERN_INFO "TLAN:  Please check that your adapter has\n");
2744                          printk(KERN_INFO "TLAN:  been properly connected to a HUB or Switch.\n");
2745                          printk(KERN_INFO "TLAN:  Trying to establish link in the background...\n");
2746                  }
2747                 TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
2748                 return;
2749         }
2750
2751         printk( "TLAN: %s: Autonegotiation complete.\n", dev->name );
2752         TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv );
2753         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa );
2754         mode = an_adv & an_lpa & 0x03E0;
2755         if ( mode & 0x0100 ) {
2756                 priv->tlanFullDuplex = TRUE;
2757         } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) {
2758                 priv->tlanFullDuplex = TRUE;
2759         }
2760
2761         if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) {
2762                 priv->phyNum = 0;
2763                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2764                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2765                 TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2766                 return;
2767         }
2768
2769         if ( priv->phyNum == 0 ) {
2770                 if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) {
2771                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX );
2772                         printk( "TLAN:  Starting internal PHY with FULL-DUPLEX\n" );
2773                 } else {
2774                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
2775                         printk( "TLAN:  Starting internal PHY with HALF-DUPLEX\n" );
2776                 }
2777         }
2778
2779         /* Wait for 100 ms.  No reason in partiticular.
2780          */
2781         TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
2782                 
2783 } /* TLan_PhyFinishAutoNeg */
2784
2785 #ifdef MONITOR
2786
2787         /*********************************************************************
2788         *
2789         *      TLan_phyMonitor
2790         *
2791         *      Returns: 
2792         *              None
2793         *
2794         *      Params:
2795         *              dev             The device structure of this device.
2796         *
2797         *      
2798         *      This function monitors PHY condition by reading the status
2799         *      register via the MII bus. This can be used to give info
2800         *      about link changes (up/down), and possible switch to alternate
2801         *      media.
2802         *
2803         * ******************************************************************/
2804
2805 void TLan_PhyMonitor( struct net_device *dev )
2806 {
2807         TLanPrivateInfo *priv = netdev_priv(dev);
2808         u16     phy;
2809         u16     phy_status;
2810
2811         phy = priv->phy[priv->phyNum];
2812
2813         /* Get PHY status register */
2814         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
2815
2816         /* Check if link has been lost */
2817         if (!(phy_status & MII_GS_LINK)) { 
2818                if (priv->link) {
2819                       priv->link = 0;
2820                       printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name);
2821                       dev->flags &= ~IFF_RUNNING;
2822                       TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2823                       return;
2824                 }
2825         }
2826
2827         /* Link restablished? */
2828         if ((phy_status & MII_GS_LINK) && !priv->link) {
2829                 priv->link = 1;
2830                 printk(KERN_DEBUG "TLAN: %s has reestablished link\n", dev->name);
2831                 dev->flags |= IFF_RUNNING;
2832         }
2833
2834         /* Setup a new monitor */
2835         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2836 }       
2837
2838 #endif /* MONITOR */
2839
2840
2841 /*****************************************************************************
2842 ******************************************************************************
2843
2844         ThunderLAN Driver MII Routines
2845
2846         These routines are based on the information in Chap. 2 of the
2847         "ThunderLAN Programmer's Guide", pp. 15-24.
2848
2849 ******************************************************************************
2850 *****************************************************************************/
2851
2852
2853         /***************************************************************
2854          *      TLan_MiiReadReg
2855          *
2856          *      Returns:
2857          *              0       if ack received ok
2858          *              1       otherwise.
2859          *
2860          *      Parms:
2861          *              dev             The device structure containing
2862          *                              The io address and interrupt count
2863          *                              for this device.
2864          *              phy             The address of the PHY to be queried.
2865          *              reg             The register whose contents are to be
2866          *                              retreived.
2867          *              val             A pointer to a variable to store the
2868          *                              retrieved value.
2869          *
2870          *      This function uses the TLAN's MII bus to retreive the contents
2871          *      of a given register on a PHY.  It sends the appropriate info
2872          *      and then reads the 16-bit register value from the MII bus via
2873          *      the TLAN SIO register.
2874          *
2875          **************************************************************/
2876
2877 int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
2878 {
2879         u8      nack;
2880         u16     sio, tmp;
2881         u32     i;
2882         int     err;
2883         int     minten;
2884         TLanPrivateInfo *priv = netdev_priv(dev);
2885         unsigned long flags = 0;
2886
2887         err = FALSE;
2888         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2889         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2890         
2891         if (!in_irq())
2892                 spin_lock_irqsave(&priv->lock, flags);
2893
2894         TLan_MiiSync(dev->base_addr);
2895
2896         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
2897         if ( minten )
2898                 TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);
2899
2900         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
2901         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Read  ( 10b ) */
2902         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
2903         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
2904
2905
2906         TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio);         /* Change direction */
2907
2908         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Clock Idle bit */
2909         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2910         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Wait 300ns */
2911
2912         nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio);    /* Check for ACK */
2913         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);            /* Finish ACK */
2914         if (nack) {                                     /* No ACK, so fake it */
2915                 for (i = 0; i < 16; i++) {
2916                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2917                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2918                 }
2919                 tmp = 0xffff;
2920                 err = TRUE;
2921         } else {                                        /* ACK, so read data */
2922                 for (tmp = 0, i = 0x8000; i; i >>= 1) {
2923                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2924                         if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
2925                                 tmp |= i;
2926                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2927                 }
2928         }
2929
2930
2931         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Idle cycle */
2932         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2933
2934         if ( minten )
2935                 TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
2936
2937         *val = tmp;
2938         
2939         if (!in_irq())
2940                 spin_unlock_irqrestore(&priv->lock, flags);
2941
2942         return err;
2943
2944 } /* TLan_MiiReadReg */
2945
2946
2947
2948
2949         /***************************************************************
2950          *      TLan_MiiSendData
2951          *
2952          *      Returns:
2953          *              Nothing
2954          *      Parms:
2955          *              base_port       The base IO port of the adapter in
2956          *                              question.
2957          *              dev             The address of the PHY to be queried.
2958          *              data            The value to be placed on the MII bus.
2959          *              num_bits        The number of bits in data that are to
2960          *                              be placed on the MII bus.
2961          *
2962          *      This function sends on sequence of bits on the MII
2963          *      configuration bus.
2964          *
2965          **************************************************************/
2966
2967 void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
2968 {
2969         u16 sio;
2970         u32 i;
2971
2972         if ( num_bits == 0 )
2973                 return;
2974
2975         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
2976         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
2977         TLan_SetBit( TLAN_NET_SIO_MTXEN, sio );
2978
2979         for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) {
2980                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
2981                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2982                 if ( data & i )
2983                         TLan_SetBit( TLAN_NET_SIO_MDATA, sio );
2984                 else
2985                         TLan_ClearBit( TLAN_NET_SIO_MDATA, sio );
2986                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
2987                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2988         }
2989
2990 } /* TLan_MiiSendData */
2991
2992
2993
2994
2995         /***************************************************************
2996          *      TLan_MiiSync
2997          *
2998          *      Returns:
2999          *              Nothing
3000          *      Parms:
3001          *              base_port       The base IO port of the adapter in
3002          *                              question.
3003          *
3004          *      This functions syncs all PHYs in terms of the MII configuration
3005          *      bus.
3006          *
3007          **************************************************************/
3008
3009 void TLan_MiiSync( u16 base_port )
3010 {
3011         int i;
3012         u16 sio;
3013
3014         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
3015         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3016
3017         TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio );
3018         for ( i = 0; i < 32; i++ ) {
3019                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3020                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3021         }
3022
3023 } /* TLan_MiiSync */
3024
3025
3026
3027
3028         /***************************************************************
3029          *      TLan_MiiWriteReg
3030          *
3031          *      Returns:
3032          *              Nothing
3033          *      Parms:
3034          *              dev             The device structure for the device
3035          *                              to write to.
3036          *              phy             The address of the PHY to be written to.
3037          *              reg             The register whose contents are to be
3038          *                              written.
3039          *              val             The value to be written to the register.
3040          *
3041          *      This function uses the TLAN's MII bus to write the contents of a
3042          *      given register on a PHY.  It sends the appropriate info and then
3043          *      writes the 16-bit register value from the MII configuration bus
3044          *      via the TLAN SIO register.
3045          *
3046          **************************************************************/
3047
3048 void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
3049 {
3050         u16     sio;
3051         int     minten;
3052         unsigned long flags = 0;
3053         TLanPrivateInfo *priv = netdev_priv(dev);
3054
3055         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3056         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
3057         
3058         if (!in_irq())
3059                 spin_lock_irqsave(&priv->lock, flags);
3060
3061         TLan_MiiSync( dev->base_addr );
3062
3063         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
3064         if ( minten )
3065                 TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio );
3066
3067         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
3068         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Write ( 01b ) */
3069         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
3070         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
3071
3072         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Send ACK */
3073         TLan_MiiSendData( dev->base_addr, val, 16 );    /* Send Data */
3074
3075         TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );        /* Idle cycle */
3076         TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3077
3078         if ( minten )
3079                 TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
3080         
3081         if (!in_irq())
3082                 spin_unlock_irqrestore(&priv->lock, flags);
3083
3084 } /* TLan_MiiWriteReg */
3085
3086
3087
3088
3089 /*****************************************************************************
3090 ******************************************************************************
3091
3092         ThunderLAN Driver Eeprom routines
3093
3094         The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A
3095         EEPROM.  These functions are based on information in Microchip's
3096         data sheet.  I don't know how well this functions will work with
3097         other EEPROMs.
3098
3099 ******************************************************************************
3100 *****************************************************************************/
3101
3102
3103         /***************************************************************
3104          *      TLan_EeSendStart
3105          *
3106          *      Returns:
3107          *              Nothing
3108          *      Parms:  
3109          *              io_base         The IO port base address for the
3110          *                              TLAN device with the EEPROM to
3111          *                              use.
3112          *
3113          *      This function sends a start cycle to an EEPROM attached
3114          *      to a TLAN chip.
3115          *
3116          **************************************************************/
3117
3118 void TLan_EeSendStart( u16 io_base )
3119 {
3120         u16     sio;
3121
3122         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3123         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3124
3125         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3126         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3127         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3128         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3129         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3130
3131 } /* TLan_EeSendStart */
3132
3133
3134
3135
3136         /***************************************************************
3137          *      TLan_EeSendByte
3138          *
3139          *      Returns:
3140          *              If the correct ack was received, 0, otherwise 1
3141          *      Parms:  io_base         The IO port base address for the
3142          *                              TLAN device with the EEPROM to
3143          *                              use.
3144          *              data            The 8 bits of information to
3145          *                              send to the EEPROM.
3146          *              stop            If TLAN_EEPROM_STOP is passed, a
3147          *                              stop cycle is sent after the
3148          *                              byte is sent after the ack is
3149          *                              read.
3150          *
3151          *      This function sends a byte on the serial EEPROM line,
3152          *      driving the clock to send each bit. The function then
3153          *      reverses transmission direction and reads an acknowledge
3154          *      bit.
3155          *
3156          **************************************************************/
3157
3158 int TLan_EeSendByte( u16 io_base, u8 data, int stop )
3159 {
3160         int     err;
3161         u8      place;
3162         u16     sio;
3163
3164         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3165         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3166
3167         /* Assume clock is low, tx is enabled; */
3168         for ( place = 0x80; place != 0; place >>= 1 ) {
3169                 if ( place & data )
3170                         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3171                 else
3172                         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3173                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3174                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3175         }
3176         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3177         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3178         err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio );
3179         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3180         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3181
3182         if ( ( ! err ) && stop ) {
3183                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3184                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3185                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3186         }
3187
3188         return ( err );
3189
3190 } /* TLan_EeSendByte */
3191
3192
3193
3194
3195         /***************************************************************
3196          *      TLan_EeReceiveByte
3197          *
3198          *      Returns:
3199          *              Nothing
3200          *      Parms:
3201          *              io_base         The IO port base address for the
3202          *                              TLAN device with the EEPROM to
3203          *                              use.
3204          *              data            An address to a char to hold the
3205          *                              data sent from the EEPROM.
3206          *              stop            If TLAN_EEPROM_STOP is passed, a
3207          *                              stop cycle is sent after the
3208          *                              byte is received, and no ack is
3209          *                              sent.
3210          *
3211          *      This function receives 8 bits of data from the EEPROM
3212          *      over the serial link.  It then sends and ack bit, or no
3213          *      ack and a stop bit.  This function is used to retrieve
3214          *      data after the address of a byte in the EEPROM has been
3215          *      sent.
3216          *
3217          **************************************************************/
3218
3219 void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
3220 {
3221         u8  place;
3222         u16 sio;
3223
3224         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3225         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3226         *data = 0;
3227
3228         /* Assume clock is low, tx is enabled; */
3229         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3230         for ( place = 0x80; place; place >>= 1 ) {
3231                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3232                 if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) )
3233                         *data |= place;
3234                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3235         }
3236
3237         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3238         if ( ! stop ) {
3239                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* Ack = 0 */
3240                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3241                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3242         } else {
3243                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );         /* No ack = 1 (?) */
3244                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3245                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3246                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3247                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3248                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3249         }
3250
3251 } /* TLan_EeReceiveByte */
3252
3253
3254
3255
3256         /***************************************************************
3257          *      TLan_EeReadByte
3258          *
3259          *      Returns:
3260          *              No error = 0, else, the stage at which the error
3261          *              occurred.
3262          *      Parms:
3263          *              io_base         The IO port base address for the
3264          *                              TLAN device with the EEPROM to
3265          *                              use.
3266          *              ee_addr         The address of the byte in the
3267          *                              EEPROM whose contents are to be
3268          *                              retrieved.
3269          *              data            An address to a char to hold the
3270          *                              data obtained from the EEPROM.
3271          *
3272          *      This function reads a byte of information from an byte
3273          *      cell in the EEPROM.
3274          *
3275          **************************************************************/
3276
3277 int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
3278 {
3279         int err;
3280         TLanPrivateInfo *priv = netdev_priv(dev);
3281         unsigned long flags = 0;
3282         int ret=0;
3283
3284         spin_lock_irqsave(&priv->lock, flags);
3285
3286         TLan_EeSendStart( dev->base_addr );
3287         err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK );
3288         if (err)
3289         {
3290                 ret=1;
3291                 goto fail;
3292         }
3293         err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK );
3294         if (err)
3295         {
3296                 ret=2;
3297                 goto fail;
3298         }
3299         TLan_EeSendStart( dev->base_addr );
3300         err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK );
3301         if (err)
3302         {
3303                 ret=3;
3304                 goto fail;
3305         }
3306         TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP );
3307 fail:
3308         spin_unlock_irqrestore(&priv->lock, flags);
3309
3310         return ret;
3311
3312 } /* TLan_EeReadByte */
3313
3314
3315