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