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