1 /*******************************************************************************
3 * Linux ThunderLAN Driver
8 * (C) 1997-1998 Caldera, Inc.
10 * (C) 1999-2001 Torben Mathiasen
11 * (C) 2002 Samuel Chessman
13 * This software may be used and distributed according to the terms
14 * of the GNU General Public License, incorporated herein by reference.
16 ** This file is best viewed/edited with columns>=132.
18 ** Useful (if not required) reading:
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
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
37 * Torben Mathiasen <torben.mathiasen@compaq.com> New Maintainer!
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.
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.
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
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
66 * v1.4 Feb 10, 2000 - Updated with more changes required after Dave's
67 * network cleanup in 2.3.43pre7 (Tigran & myself)
70 * v1.5 March 22, 2000 - Fixed another timer bug that would hang the driver
71 * if no cable/link were present.
73 * - TODO: Port completely to new PCI/DMA API
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
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.
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
95 * Please read tlan.txt for additional information.
96 * - Removed call to check_region(), and used
97 * return value of request_region() instead.
99 * v1.8a May 28, 2000 - Minor updates.
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.
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
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.
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.
138 * v1.12 Oct 12, 2000 - Minor fixes (memleak, init, etc.)
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
147 * - Added partly fix for TX Channel lockup with
148 * TLAN v1.0 silicon. This needs to be investigated
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
158 * - Converted to use new taskq interface.
160 * v1.14a Jan 6, 2001 - Minor adjustments (spinlocks, etc.)
162 * Samuel Chessman <chessman@tux.org> New Maintainer!
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 *******************************************************************************/
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>
184 typedef u32 (TLanIntVectorFunc)( struct net_device *, u16 );
187 /* For removing EISA devices */
188 static struct net_device *TLan_Eisa_Devices;
190 static int TLanDevicesInstalled;
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)");
204 MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>");
205 MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
206 MODULE_LICENSE("GPL");
209 /* Define this to enable Link beat monitoring */
212 /* Turn on debugging. See Documentation/networking/tlan.txt for details */
214 module_param(debug, int, 0);
215 MODULE_PARM_DESC(debug, "ThunderLAN debug mask");
218 module_param(bbuf, int, 0);
219 MODULE_PARM_DESC(bbuf, "ThunderLAN use big buffer (0-1)");
221 static char TLanSignature[] = "TLAN";
222 static const char tlan_banner[] = "ThunderLAN driver v1.15\n";
223 static int tlan_have_pci;
224 static int tlan_have_eisa;
226 static const char *media[] = {
227 "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ",
228 "100baseTx-FD", "100baseT4", NULL
231 static struct board {
232 const char *deviceLabel;
236 { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
237 { "Compaq Netelligent 10/100 TX PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
238 { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
239 { "Compaq NetFlex-3/P", TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
240 { "Compaq NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
241 { "Compaq Netelligent Integrated 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
242 { "Compaq Netelligent Dual 10/100 TX PCI UTP", TLAN_ADAPTER_NONE, 0x83 },
243 { "Compaq Netelligent 10/100 TX Embedded UTP", TLAN_ADAPTER_NONE, 0x83 },
244 { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 },
245 { "Olicom OC-2325", TLAN_ADAPTER_UNMANAGED_PHY, 0xF8 },
246 { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xF8 },
247 { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
248 { "Compaq Netelligent 10 T/2 PCI UTP/Coax", TLAN_ADAPTER_NONE, 0x83 },
249 { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED | /* EISA card */
250 TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
251 { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */
254 static struct pci_device_id tlan_pci_tbl[] = {
255 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
256 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
257 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
258 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
259 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I,
260 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
261 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER,
262 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
263 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B,
264 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
265 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI,
266 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
267 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D,
268 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
269 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I,
270 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
271 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183,
272 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
273 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325,
274 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
275 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326,
276 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
277 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100,
278 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
279 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2,
280 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
283 MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);
285 static void TLan_EisaProbe( void );
286 static void TLan_Eisa_Cleanup( void );
287 static int TLan_Init( struct net_device * );
288 static int TLan_Open( struct net_device *dev );
289 static int TLan_StartTx( struct sk_buff *, struct net_device *);
290 static irqreturn_t TLan_HandleInterrupt( int, void *);
291 static int TLan_Close( struct net_device *);
292 static struct net_device_stats *TLan_GetStats( struct net_device *);
293 static void TLan_SetMulticastList( struct net_device *);
294 static int TLan_ioctl( struct net_device *dev, struct ifreq *rq, int cmd);
295 static int TLan_probe1( struct pci_dev *pdev, long ioaddr, int irq, int rev, const struct pci_device_id *ent);
296 static void TLan_tx_timeout( struct net_device *dev);
297 static void TLan_tx_timeout_work(struct work_struct *work);
298 static int tlan_init_one( struct pci_dev *pdev, const struct pci_device_id *ent);
300 static u32 TLan_HandleInvalid( struct net_device *, u16 );
301 static u32 TLan_HandleTxEOF( struct net_device *, u16 );
302 static u32 TLan_HandleStatOverflow( struct net_device *, u16 );
303 static u32 TLan_HandleRxEOF( struct net_device *, u16 );
304 static u32 TLan_HandleDummy( struct net_device *, u16 );
305 static u32 TLan_HandleTxEOC( struct net_device *, u16 );
306 static u32 TLan_HandleStatusCheck( struct net_device *, u16 );
307 static u32 TLan_HandleRxEOC( struct net_device *, u16 );
309 static void TLan_Timer( unsigned long );
311 static void TLan_ResetLists( struct net_device * );
312 static void TLan_FreeLists( struct net_device * );
313 static void TLan_PrintDio( u16 );
314 static void TLan_PrintList( TLanList *, char *, int );
315 static void TLan_ReadAndClearStats( struct net_device *, int );
316 static void TLan_ResetAdapter( struct net_device * );
317 static void TLan_FinishReset( struct net_device * );
318 static void TLan_SetMac( struct net_device *, int areg, char *mac );
320 static void TLan_PhyPrint( struct net_device * );
321 static void TLan_PhyDetect( struct net_device * );
322 static void TLan_PhyPowerDown( struct net_device * );
323 static void TLan_PhyPowerUp( struct net_device * );
324 static void TLan_PhyReset( struct net_device * );
325 static void TLan_PhyStartLink( struct net_device * );
326 static void TLan_PhyFinishAutoNeg( struct net_device * );
328 static void TLan_PhyMonitor( struct net_device * );
332 static int TLan_PhyNop( struct net_device * );
333 static int TLan_PhyInternalCheck( struct net_device * );
334 static int TLan_PhyInternalService( struct net_device * );
335 static int TLan_PhyDp83840aCheck( struct net_device * );
338 static int TLan_MiiReadReg( struct net_device *, u16, u16, u16 * );
339 static void TLan_MiiSendData( u16, u32, unsigned );
340 static void TLan_MiiSync( u16 );
341 static void TLan_MiiWriteReg( struct net_device *, u16, u16, u16 );
343 static void TLan_EeSendStart( u16 );
344 static int TLan_EeSendByte( u16, u8, int );
345 static void TLan_EeReceiveByte( u16, u8 *, int );
346 static int TLan_EeReadByte( struct net_device *, u8, u8 * );
350 TLan_StoreSKB( struct tlan_list_tag *tag, struct sk_buff *skb)
352 unsigned long addr = (unsigned long)skb;
353 tag->buffer[9].address = (u32)addr;
354 addr >>= 31; /* >>= 32 is undefined for 32bit arch, stupid C */
356 tag->buffer[8].address = (u32)addr;
359 static struct sk_buff *
360 TLan_GetSKB( struct tlan_list_tag *tag)
362 unsigned long addr = tag->buffer[8].address;
365 addr |= tag->buffer[9].address;
366 return (struct sk_buff *) addr;
370 static TLanIntVectorFunc *TLanIntVector[TLAN_INT_NUMBER_OF_INTS] = {
373 TLan_HandleStatOverflow,
377 TLan_HandleStatusCheck,
382 TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type )
384 TLanPrivateInfo *priv = netdev_priv(dev);
385 unsigned long flags = 0;
388 spin_lock_irqsave(&priv->lock, flags);
389 if ( priv->timer.function != NULL &&
390 priv->timerType != TLAN_TIMER_ACTIVITY ) {
392 spin_unlock_irqrestore(&priv->lock, flags);
395 priv->timer.function = &TLan_Timer;
397 spin_unlock_irqrestore(&priv->lock, flags);
399 priv->timer.data = (unsigned long) dev;
400 priv->timerSetAt = jiffies;
401 priv->timerType = type;
402 mod_timer(&priv->timer, jiffies + ticks);
404 } /* TLan_SetTimer */
407 /*****************************************************************************
408 ******************************************************************************
410 ThunderLAN Driver Primary Functions
412 These functions are more or less common to all Linux network drivers.
414 ******************************************************************************
415 *****************************************************************************/
421 /***************************************************************
429 * Goes through the TLanDevices list and frees the device
430 * structs and memory associated with each device (lists
431 * and buffers). It also ureserves the IO port regions
432 * associated with this device.
434 **************************************************************/
437 static void __devexit tlan_remove_one( struct pci_dev *pdev)
439 struct net_device *dev = pci_get_drvdata( pdev );
440 TLanPrivateInfo *priv = netdev_priv(dev);
442 unregister_netdev( dev );
444 if ( priv->dmaStorage ) {
445 pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
449 pci_release_regions(pdev);
454 pci_set_drvdata( pdev, NULL );
457 static struct pci_driver tlan_driver = {
459 .id_table = tlan_pci_tbl,
460 .probe = tlan_init_one,
461 .remove = __devexit_p(tlan_remove_one),
464 static int __init tlan_probe(void)
468 printk(KERN_INFO "%s", tlan_banner);
470 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....\n");
472 /* Use new style PCI probing. Now the kernel will
473 do most of this for us */
474 rc = pci_register_driver(&tlan_driver);
477 printk(KERN_ERR "TLAN: Could not register pci driver.\n");
478 goto err_out_pci_free;
481 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n");
484 printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d EISA: %d\n",
485 TLanDevicesInstalled, TLanDevicesInstalled == 1 ? "" : "s",
486 tlan_have_pci, tlan_have_eisa);
488 if (TLanDevicesInstalled == 0) {
490 goto err_out_pci_unreg;
495 pci_unregister_driver(&tlan_driver);
501 static int __devinit tlan_init_one( struct pci_dev *pdev,
502 const struct pci_device_id *ent)
504 return TLan_probe1( pdev, -1, -1, 0, ent);
509 ***************************************************************
513 * 0 on success, error code on error
517 * The name is lower case to fit in with all the rest of
518 * the netcard_probe names. This function looks for
519 * another TLan based adapter, setting it up with the
520 * allocated device struct if one is found.
521 * tlan_probe has been ported to the new net API and
522 * now allocates its own device structure. This function
523 * is also used by modules.
525 **************************************************************/
527 static int __devinit TLan_probe1(struct pci_dev *pdev,
528 long ioaddr, int irq, int rev, const struct pci_device_id *ent )
531 struct net_device *dev;
532 TLanPrivateInfo *priv;
534 int reg, rc = -ENODEV;
538 rc = pci_enable_device(pdev);
542 rc = pci_request_regions(pdev, TLanSignature);
544 printk(KERN_ERR "TLAN: Could not reserve IO regions\n");
548 #endif /* CONFIG_PCI */
550 dev = alloc_etherdev(sizeof(TLanPrivateInfo));
552 printk(KERN_ERR "TLAN: Could not allocate memory for device.\n");
554 goto err_out_regions;
556 SET_NETDEV_DEV(dev, &pdev->dev);
558 priv = netdev_priv(dev);
563 /* Is this a PCI device? */
567 priv->adapter = &board_info[ent->driver_data];
569 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
571 printk(KERN_ERR "TLAN: No suitable PCI mapping available.\n");
572 goto err_out_free_dev;
575 for ( reg= 0; reg <= 5; reg ++ ) {
576 if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
577 pci_io_base = pci_resource_start(pdev, reg);
578 TLAN_DBG( TLAN_DEBUG_GNRL, "IO mapping is available at %x.\n",
584 printk(KERN_ERR "TLAN: No IO mappings available\n");
586 goto err_out_free_dev;
589 dev->base_addr = pci_io_base;
590 dev->irq = pdev->irq;
591 priv->adapterRev = pdev->revision;
592 pci_set_master(pdev);
593 pci_set_drvdata(pdev, dev);
595 } else { /* EISA card */
596 /* This is a hack. We need to know which board structure
597 * is suited for this adapter */
598 device_id = inw(ioaddr + EISA_ID2);
600 if (device_id == 0x20F1) {
601 priv->adapter = &board_info[13]; /* NetFlex-3/E */
602 priv->adapterRev = 23; /* TLAN 2.3 */
604 priv->adapter = &board_info[14];
605 priv->adapterRev = 10; /* TLAN 1.0 */
607 dev->base_addr = ioaddr;
611 /* Kernel parameters */
612 if (dev->mem_start) {
613 priv->aui = dev->mem_start & 0x01;
614 priv->duplex = ((dev->mem_start & 0x06) == 0x06) ? 0 : (dev->mem_start & 0x06) >> 1;
615 priv->speed = ((dev->mem_start & 0x18) == 0x18) ? 0 : (dev->mem_start & 0x18) >> 3;
617 if (priv->speed == 0x1) {
618 priv->speed = TLAN_SPEED_10;
619 } else if (priv->speed == 0x2) {
620 priv->speed = TLAN_SPEED_100;
622 debug = priv->debug = dev->mem_end;
624 priv->aui = aui[boards_found];
625 priv->speed = speed[boards_found];
626 priv->duplex = duplex[boards_found];
630 /* This will be used when we get an adapter error from
631 * within our irq handler */
632 INIT_WORK(&priv->tlan_tqueue, TLan_tx_timeout_work);
634 spin_lock_init(&priv->lock);
638 printk(KERN_ERR "TLAN: Could not set up device.\n");
639 goto err_out_free_dev;
642 rc = register_netdev(dev);
644 printk(KERN_ERR "TLAN: Could not register device.\n");
649 TLanDevicesInstalled++;
652 /* pdev is NULL if this is an EISA device */
656 priv->nextDevice = TLan_Eisa_Devices;
657 TLan_Eisa_Devices = dev;
661 printk(KERN_INFO "TLAN: %s irq=%2d, io=%04x, %s, Rev. %d\n",
664 (int) dev->base_addr,
665 priv->adapter->deviceLabel,
670 pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage,
671 priv->dmaStorageDMA );
677 pci_release_regions(pdev);
681 pci_disable_device(pdev);
686 static void TLan_Eisa_Cleanup(void)
688 struct net_device *dev;
689 TLanPrivateInfo *priv;
691 while( tlan_have_eisa ) {
692 dev = TLan_Eisa_Devices;
693 priv = netdev_priv(dev);
694 if (priv->dmaStorage) {
695 pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
697 release_region( dev->base_addr, 0x10);
698 unregister_netdev( dev );
699 TLan_Eisa_Devices = priv->nextDevice;
706 static void __exit tlan_exit(void)
708 pci_unregister_driver(&tlan_driver);
716 /* Module loading/unloading */
717 module_init(tlan_probe);
718 module_exit(tlan_exit);
722 /**************************************************************
725 * Returns: 0 on success, 1 otherwise
730 * This functions probes for EISA devices and calls
731 * TLan_probe1 when one is found.
733 *************************************************************/
735 static void __init TLan_EisaProbe (void)
743 TLAN_DBG(TLAN_DEBUG_PROBE, "No EISA bus present\n");
747 /* Loop through all slots of the EISA bus */
748 for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
750 TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID));
751 TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2));
754 TLAN_DBG(TLAN_DEBUG_PROBE, "Probing for EISA adapter at IO: 0x%4x : ",
756 if (request_region(ioaddr, 0x10, TLanSignature) == NULL)
759 if (inw(ioaddr + EISA_ID) != 0x110E) {
760 release_region(ioaddr, 0x10);
764 device_id = inw(ioaddr + EISA_ID2);
765 if (device_id != 0x20F1 && device_id != 0x40F1) {
766 release_region (ioaddr, 0x10);
770 if (inb(ioaddr + EISA_CR) != 0x1) { /* Check if adapter is enabled */
771 release_region (ioaddr, 0x10);
776 printk("Found one\n");
779 /* Get irq from board */
780 switch (inb(ioaddr + 0xCC0)) {
798 /* Setup the newly found eisa adapter */
799 rc = TLan_probe1( NULL, ioaddr, irq,
805 printk("None found\n");
808 out2: if (debug == 0x10)
809 printk("Card found but it is not enabled, skipping\n");
814 } /* TLan_EisaProbe */
816 #ifdef CONFIG_NET_POLL_CONTROLLER
817 static void TLan_Poll(struct net_device *dev)
819 disable_irq(dev->irq);
820 TLan_HandleInterrupt(dev->irq, dev);
821 enable_irq(dev->irq);
828 /***************************************************************
832 * 0 on success, error code otherwise.
834 * dev The structure of the device to be
837 * This function completes the initialization of the
838 * device structure and driver. It reserves the IO
839 * addresses, allocates memory for the lists and bounce
840 * buffers, retrieves the MAC address from the eeprom
841 * and assignes the device's methods.
843 **************************************************************/
845 static int TLan_Init( struct net_device *dev )
850 TLanPrivateInfo *priv;
852 priv = netdev_priv(dev);
855 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
856 * ( sizeof(TLanList) + TLAN_MAX_FRAME_SIZE );
858 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
859 * ( sizeof(TLanList) );
861 priv->dmaStorage = pci_alloc_consistent(priv->pciDev, dma_size, &priv->dmaStorageDMA);
862 priv->dmaSize = dma_size;
864 if ( priv->dmaStorage == NULL ) {
865 printk(KERN_ERR "TLAN: Could not allocate lists and buffers for %s.\n",
869 memset( priv->dmaStorage, 0, dma_size );
870 priv->rxList = (TLanList *)
871 ( ( ( (u32) priv->dmaStorage ) + 7 ) & 0xFFFFFFF8 );
872 priv->rxListDMA = ( ( ( (u32) priv->dmaStorageDMA ) + 7 ) & 0xFFFFFFF8 );
873 priv->txList = priv->rxList + TLAN_NUM_RX_LISTS;
874 priv->txListDMA = priv->rxListDMA + sizeof(TLanList) * TLAN_NUM_RX_LISTS;
876 priv->rxBuffer = (u8 *) ( priv->txList + TLAN_NUM_TX_LISTS );
877 priv->rxBufferDMA =priv->txListDMA + sizeof(TLanList) * TLAN_NUM_TX_LISTS;
878 priv->txBuffer = priv->rxBuffer + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
879 priv->txBufferDMA = priv->rxBufferDMA + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
883 for ( i = 0; i < 6 ; i++ )
884 err |= TLan_EeReadByte( dev,
885 (u8) priv->adapter->addrOfs + i,
886 (u8 *) &dev->dev_addr[i] );
888 printk(KERN_ERR "TLAN: %s: Error reading MAC from eeprom: %d\n",
894 netif_carrier_off(dev);
897 dev->open = &TLan_Open;
898 dev->hard_start_xmit = &TLan_StartTx;
899 dev->stop = &TLan_Close;
900 dev->get_stats = &TLan_GetStats;
901 dev->set_multicast_list = &TLan_SetMulticastList;
902 dev->do_ioctl = &TLan_ioctl;
903 #ifdef CONFIG_NET_POLL_CONTROLLER
904 dev->poll_controller = &TLan_Poll;
906 dev->tx_timeout = &TLan_tx_timeout;
907 dev->watchdog_timeo = TX_TIMEOUT;
916 /***************************************************************
920 * 0 on success, error code otherwise.
922 * dev Structure of device to be opened.
924 * This routine puts the driver and TLAN adapter in a
925 * state where it is ready to send and receive packets.
926 * It allocates the IRQ, resets and brings the adapter
927 * out of reset, and allows interrupts. It also delays
928 * the startup for autonegotiation or sends a Rx GO
929 * command to the adapter, as appropriate.
931 **************************************************************/
933 static int TLan_Open( struct net_device *dev )
935 TLanPrivateInfo *priv = netdev_priv(dev);
938 priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
939 err = request_irq( dev->irq, TLan_HandleInterrupt, IRQF_SHARED, TLanSignature, dev );
942 printk(KERN_ERR "TLAN: Cannot open %s because IRQ %d is already in use.\n", dev->name, dev->irq );
946 init_timer(&priv->timer);
947 netif_start_queue(dev);
949 /* NOTE: It might not be necessary to read the stats before a
950 reset if you don't care what the values are.
952 TLan_ResetLists( dev );
953 TLan_ReadAndClearStats( dev, TLAN_IGNORE );
954 TLan_ResetAdapter( dev );
956 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened. TLAN Chip Rev: %x\n", dev->name, priv->tlanRev );
964 /**************************************************************
968 * 0 on success, error code otherwise
970 * dev structure of device to receive ioctl.
972 * rq ifreq structure to hold userspace data.
977 *************************************************************/
979 static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
981 TLanPrivateInfo *priv = netdev_priv(dev);
982 struct mii_ioctl_data *data = if_mii(rq);
983 u32 phy = priv->phy[priv->phyNum];
985 if (!priv->phyOnline)
989 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
993 case SIOCGMIIREG: /* Read MII PHY register. */
994 TLan_MiiReadReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, &data->val_out);
998 case SIOCSMIIREG: /* Write MII PHY register. */
999 if (!capable(CAP_NET_ADMIN))
1001 TLan_MiiWriteReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1009 /***************************************************************
1015 * dev structure of device which timed out
1018 **************************************************************/
1020 static void TLan_tx_timeout(struct net_device *dev)
1023 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Transmit timed out.\n", dev->name);
1025 /* Ok so we timed out, lets see what we can do about it...*/
1026 TLan_FreeLists( dev );
1027 TLan_ResetLists( dev );
1028 TLan_ReadAndClearStats( dev, TLAN_IGNORE );
1029 TLan_ResetAdapter( dev );
1030 dev->trans_start = jiffies;
1031 netif_wake_queue( dev );
1036 /***************************************************************
1037 * TLan_tx_timeout_work
1042 * work work item of device which timed out
1044 **************************************************************/
1046 static void TLan_tx_timeout_work(struct work_struct *work)
1048 TLanPrivateInfo *priv =
1049 container_of(work, TLanPrivateInfo, tlan_tqueue);
1051 TLan_tx_timeout(priv->dev);
1056 /***************************************************************
1060 * 0 on success, non-zero on failure.
1062 * skb A pointer to the sk_buff containing the
1064 * dev The device to send the data on.
1066 * This function adds a frame to the Tx list to be sent
1067 * ASAP. First it verifies that the adapter is ready and
1068 * there is room in the queue. Then it sets up the next
1069 * available list, copies the frame to the corresponding
1070 * buffer. If the adapter Tx channel is idle, it gives
1071 * the adapter a Tx Go command on the list, otherwise it
1072 * sets the forward address of the previous list to point
1073 * to this one. Then it frees the sk_buff.
1075 **************************************************************/
1077 static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
1079 TLanPrivateInfo *priv = netdev_priv(dev);
1080 TLanList *tail_list;
1081 dma_addr_t tail_list_phys;
1083 unsigned long flags;
1085 if ( ! priv->phyOnline ) {
1086 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: %s PHY is not ready\n", dev->name );
1087 dev_kfree_skb_any(skb);
1091 if (skb_padto(skb, TLAN_MIN_FRAME_SIZE))
1094 tail_list = priv->txList + priv->txTail;
1095 tail_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txTail;
1097 if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) {
1098 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: %s is busy (Head=%d Tail=%d)\n", dev->name, priv->txHead, priv->txTail );
1099 netif_stop_queue(dev);
1100 priv->txBusyCount++;
1104 tail_list->forward = 0;
1107 tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
1108 skb_copy_from_linear_data(skb, tail_buffer, skb->len);
1110 tail_list->buffer[0].address = pci_map_single(priv->pciDev, skb->data, skb->len, PCI_DMA_TODEVICE);
1111 TLan_StoreSKB(tail_list, skb);
1114 tail_list->frameSize = (u16) skb->len;
1115 tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len;
1116 tail_list->buffer[1].count = 0;
1117 tail_list->buffer[1].address = 0;
1119 spin_lock_irqsave(&priv->lock, flags);
1120 tail_list->cStat = TLAN_CSTAT_READY;
1121 if ( ! priv->txInProgress ) {
1122 priv->txInProgress = 1;
1123 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Starting TX on buffer %d\n", priv->txTail );
1124 outl( tail_list_phys, dev->base_addr + TLAN_CH_PARM );
1125 outl( TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD );
1127 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Adding buffer %d to TX channel\n", priv->txTail );
1128 if ( priv->txTail == 0 ) {
1129 ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward = tail_list_phys;
1131 ( priv->txList + ( priv->txTail - 1 ) )->forward = tail_list_phys;
1134 spin_unlock_irqrestore(&priv->lock, flags);
1136 CIRC_INC( priv->txTail, TLAN_NUM_TX_LISTS );
1139 dev_kfree_skb_any(skb);
1141 dev->trans_start = jiffies;
1144 } /* TLan_StartTx */
1149 /***************************************************************
1150 * TLan_HandleInterrupt
1155 * irq The line on which the interrupt
1157 * dev_id A pointer to the device assigned to
1160 * This function handles an interrupt generated by its
1161 * assigned TLAN adapter. The function deactivates
1162 * interrupts on its adapter, records the type of
1163 * interrupt, executes the appropriate subhandler, and
1164 * acknowdges the interrupt to the adapter (thus
1165 * re-enabling adapter interrupts.
1167 **************************************************************/
1169 static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id)
1172 struct net_device *dev;
1176 TLanPrivateInfo *priv;
1179 priv = netdev_priv(dev);
1181 spin_lock(&priv->lock);
1183 host_int = inw( dev->base_addr + TLAN_HOST_INT );
1184 outw( host_int, dev->base_addr + TLAN_HOST_INT );
1186 type = ( host_int & TLAN_HI_IT_MASK ) >> 2;
1188 ack = TLanIntVector[type]( dev, host_int );
1191 host_cmd = TLAN_HC_ACK | ack | ( type << 18 );
1192 outl( host_cmd, dev->base_addr + TLAN_HOST_CMD );
1195 spin_unlock(&priv->lock);
1198 } /* TLan_HandleInterrupts */
1203 /***************************************************************
1209 * dev The device structure of the device to
1212 * This function shuts down the adapter. It records any
1213 * stats, puts the adapter into reset state, deactivates
1214 * its time as needed, and frees the irq it is using.
1216 **************************************************************/
1218 static int TLan_Close(struct net_device *dev)
1220 TLanPrivateInfo *priv = netdev_priv(dev);
1222 netif_stop_queue(dev);
1223 priv->neg_be_verbose = 0;
1225 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1226 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1227 if ( priv->timer.function != NULL ) {
1228 del_timer_sync( &priv->timer );
1229 priv->timer.function = NULL;
1232 free_irq( dev->irq, dev );
1233 TLan_FreeLists( dev );
1234 TLAN_DBG( TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name );
1243 /***************************************************************
1247 * A pointer to the device's statistics structure.
1249 * dev The device structure to return the
1252 * This function updates the devices statistics by reading
1253 * the TLAN chip's onboard registers. Then it returns the
1254 * address of the statistics structure.
1256 **************************************************************/
1258 static struct net_device_stats *TLan_GetStats( struct net_device *dev )
1260 TLanPrivateInfo *priv = netdev_priv(dev);
1263 /* Should only read stats if open ? */
1264 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1266 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: %s EOC count = %d\n", dev->name, priv->rxEocCount );
1267 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: %s Busy count = %d\n", dev->name, priv->txBusyCount );
1268 if ( debug & TLAN_DEBUG_GNRL ) {
1269 TLan_PrintDio( dev->base_addr );
1270 TLan_PhyPrint( dev );
1272 if ( debug & TLAN_DEBUG_LIST ) {
1273 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ )
1274 TLan_PrintList( priv->rxList + i, "RX", i );
1275 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ )
1276 TLan_PrintList( priv->txList + i, "TX", i );
1279 return ( &( (TLanPrivateInfo *) netdev_priv(dev) )->stats );
1281 } /* TLan_GetStats */
1286 /***************************************************************
1287 * TLan_SetMulticastList
1292 * dev The device structure to set the
1293 * multicast list for.
1295 * This function sets the TLAN adaptor to various receive
1296 * modes. If the IFF_PROMISC flag is set, promiscuous
1297 * mode is acitviated. Otherwise, promiscuous mode is
1298 * turned off. If the IFF_ALLMULTI flag is set, then
1299 * the hash table is set to receive all group addresses.
1300 * Otherwise, the first three multicast addresses are
1301 * stored in AREG_1-3, and the rest are selected via the
1302 * hash table, as necessary.
1304 **************************************************************/
1306 static void TLan_SetMulticastList( struct net_device *dev )
1308 struct dev_mc_list *dmi = dev->mc_list;
1315 if ( dev->flags & IFF_PROMISC ) {
1316 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1317 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF );
1319 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1320 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF );
1321 if ( dev->flags & IFF_ALLMULTI ) {
1322 for ( i = 0; i < 3; i++ )
1323 TLan_SetMac( dev, i + 1, NULL );
1324 TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF );
1325 TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF );
1327 for ( i = 0; i < dev->mc_count; i++ ) {
1329 TLan_SetMac( dev, i + 1, (char *) &dmi->dmi_addr );
1331 offset = TLan_HashFunc( (u8 *) &dmi->dmi_addr );
1333 hash1 |= ( 1 << offset );
1335 hash2 |= ( 1 << ( offset - 32 ) );
1339 for ( ; i < 3; i++ )
1340 TLan_SetMac( dev, i + 1, NULL );
1341 TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 );
1342 TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 );
1346 } /* TLan_SetMulticastList */
1350 /*****************************************************************************
1351 ******************************************************************************
1353 ThunderLAN Driver Interrupt Vectors and Table
1355 Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN
1356 Programmer's Guide" for more informations on handling interrupts
1357 generated by TLAN based adapters.
1359 ******************************************************************************
1360 *****************************************************************************/
1363 /***************************************************************
1364 * TLan_HandleInvalid
1369 * dev Device assigned the IRQ that was
1371 * host_int The contents of the HOST_INT
1374 * This function handles invalid interrupts. This should
1375 * never happen unless some other adapter is trying to use
1376 * the IRQ line assigned to the device.
1378 **************************************************************/
1380 static u32 TLan_HandleInvalid( struct net_device *dev, u16 host_int )
1382 /* printk( "TLAN: Invalid interrupt on %s.\n", dev->name ); */
1385 } /* TLan_HandleInvalid */
1390 /***************************************************************
1396 * dev Device assigned the IRQ that was
1398 * host_int The contents of the HOST_INT
1401 * This function handles Tx EOF interrupts which are raised
1402 * by the adapter when it has completed sending the
1403 * contents of a buffer. If detemines which list/buffer
1404 * was completed and resets it. If the buffer was the last
1405 * in the channel (EOC), then the function checks to see if
1406 * another buffer is ready to send, and if so, sends a Tx
1407 * Go command. Finally, the driver activates/continues the
1410 **************************************************************/
1412 static u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
1414 TLanPrivateInfo *priv = netdev_priv(dev);
1416 TLanList *head_list;
1417 dma_addr_t head_list_phys;
1421 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Handling TX EOF (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
1422 head_list = priv->txList + priv->txHead;
1424 while (((tmpCStat = head_list->cStat ) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1427 struct sk_buff *skb = TLan_GetSKB(head_list);
1428 pci_unmap_single(priv->pciDev, head_list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
1429 dev_kfree_skb_any(skb);
1430 head_list->buffer[8].address = 0;
1431 head_list->buffer[9].address = 0;
1434 if ( tmpCStat & TLAN_CSTAT_EOC )
1437 priv->stats.tx_bytes += head_list->frameSize;
1439 head_list->cStat = TLAN_CSTAT_UNUSED;
1440 netif_start_queue(dev);
1441 CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS );
1442 head_list = priv->txList + priv->txHead;
1446 printk(KERN_INFO "TLAN: Received interrupt for uncompleted TX frame.\n");
1449 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Handling TX EOC (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
1450 head_list = priv->txList + priv->txHead;
1451 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1452 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1453 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1456 priv->txInProgress = 0;
1460 if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1461 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1462 if ( priv->timer.function == NULL ) {
1463 priv->timer.function = &TLan_Timer;
1464 priv->timer.data = (unsigned long) dev;
1465 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1466 priv->timerSetAt = jiffies;
1467 priv->timerType = TLAN_TIMER_ACTIVITY;
1468 add_timer(&priv->timer);
1469 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1470 priv->timerSetAt = jiffies;
1476 } /* TLan_HandleTxEOF */
1481 /***************************************************************
1482 * TLan_HandleStatOverflow
1487 * dev Device assigned the IRQ that was
1489 * host_int The contents of the HOST_INT
1492 * This function handles the Statistics Overflow interrupt
1493 * which means that one or more of the TLAN statistics
1494 * registers has reached 1/2 capacity and needs to be read.
1496 **************************************************************/
1498 static u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
1500 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1504 } /* TLan_HandleStatOverflow */
1509 /***************************************************************
1515 * dev Device assigned the IRQ that was
1517 * host_int The contents of the HOST_INT
1520 * This function handles the Rx EOF interrupt which
1521 * indicates a frame has been received by the adapter from
1522 * the net and the frame has been transferred to memory.
1523 * The function determines the bounce buffer the frame has
1524 * been loaded into, creates a new sk_buff big enough to
1525 * hold the frame, and sends it to protocol stack. It
1526 * then resets the used buffer and appends it to the end
1527 * of the list. If the frame was the last in the Rx
1528 * channel (EOC), the function restarts the receive channel
1529 * by sending an Rx Go command to the adapter. Then it
1530 * activates/continues the activity LED.
1532 **************************************************************/
1534 static u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
1536 TLanPrivateInfo *priv = netdev_priv(dev);
1540 TLanList *head_list;
1541 struct sk_buff *skb;
1542 TLanList *tail_list;
1546 dma_addr_t head_list_phys;
1548 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: Handling RX EOF (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
1549 head_list = priv->rxList + priv->rxHead;
1550 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1552 while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1553 frameSize = head_list->frameSize;
1555 if (tmpCStat & TLAN_CSTAT_EOC)
1559 skb = dev_alloc_skb(frameSize + 7);
1561 printk(KERN_INFO "TLAN: Couldn't allocate memory for received data.\n");
1563 head_buffer = priv->rxBuffer + (priv->rxHead * TLAN_MAX_FRAME_SIZE);
1564 skb_reserve(skb, 2);
1565 t = (void *) skb_put(skb, frameSize);
1567 priv->stats.rx_bytes += head_list->frameSize;
1569 memcpy( t, head_buffer, frameSize );
1570 skb->protocol = eth_type_trans( skb, dev );
1574 struct sk_buff *new_skb;
1577 * I changed the algorithm here. What we now do
1578 * is allocate the new frame. If this fails we
1579 * simply recycle the frame.
1582 new_skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
1584 if ( new_skb != NULL ) {
1585 skb = TLan_GetSKB(head_list);
1586 pci_unmap_single(priv->pciDev, head_list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1587 skb_trim( skb, frameSize );
1589 priv->stats.rx_bytes += frameSize;
1591 skb->protocol = eth_type_trans( skb, dev );
1594 skb_reserve( new_skb, 2 );
1595 t = (void *) skb_put( new_skb, TLAN_MAX_FRAME_SIZE );
1596 head_list->buffer[0].address = pci_map_single(priv->pciDev, new_skb->data, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1597 head_list->buffer[8].address = (u32) t;
1598 TLan_StoreSKB(head_list, new_skb);
1600 printk(KERN_WARNING "TLAN: Couldn't allocate memory for received data.\n" );
1603 head_list->forward = 0;
1604 head_list->cStat = 0;
1605 tail_list = priv->rxList + priv->rxTail;
1606 tail_list->forward = head_list_phys;
1608 CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS );
1609 CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS );
1610 head_list = priv->rxList + priv->rxHead;
1611 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1615 printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.\n");
1621 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: Handling RX EOC (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
1622 head_list = priv->rxList + priv->rxHead;
1623 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1624 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1625 ack |= TLAN_HC_GO | TLAN_HC_RT;
1629 if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1630 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1631 if ( priv->timer.function == NULL ) {
1632 priv->timer.function = &TLan_Timer;
1633 priv->timer.data = (unsigned long) dev;
1634 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1635 priv->timerSetAt = jiffies;
1636 priv->timerType = TLAN_TIMER_ACTIVITY;
1637 add_timer(&priv->timer);
1638 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1639 priv->timerSetAt = jiffies;
1643 dev->last_rx = jiffies;
1647 } /* TLan_HandleRxEOF */
1652 /***************************************************************
1658 * dev Device assigned the IRQ that was
1660 * host_int The contents of the HOST_INT
1663 * This function handles the Dummy interrupt, which is
1664 * raised whenever a test interrupt is generated by setting
1665 * the Req_Int bit of HOST_CMD to 1.
1667 **************************************************************/
1669 static u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
1671 printk( "TLAN: Test interrupt on %s.\n", dev->name );
1674 } /* TLan_HandleDummy */
1679 /***************************************************************
1685 * dev Device assigned the IRQ that was
1687 * host_int The contents of the HOST_INT
1690 * This driver is structured to determine EOC occurrences by
1691 * reading the CSTAT member of the list structure. Tx EOC
1692 * interrupts are disabled via the DIO INTDIS register.
1693 * However, TLAN chips before revision 3.0 didn't have this
1694 * functionality, so process EOC events if this is the
1697 **************************************************************/
1699 static u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
1701 TLanPrivateInfo *priv = netdev_priv(dev);
1702 TLanList *head_list;
1703 dma_addr_t head_list_phys;
1707 if ( priv->tlanRev < 0x30 ) {
1708 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Handling TX EOC (Head=%d Tail=%d) -- IRQ\n", priv->txHead, priv->txTail );
1709 head_list = priv->txList + priv->txHead;
1710 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1711 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1712 netif_stop_queue(dev);
1713 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1716 priv->txInProgress = 0;
1722 } /* TLan_HandleTxEOC */
1727 /***************************************************************
1728 * TLan_HandleStatusCheck
1731 * 0 if Adapter check, 1 if Network Status check.
1733 * dev Device assigned the IRQ that was
1735 * host_int The contents of the HOST_INT
1738 * This function handles Adapter Check/Network Status
1739 * interrupts generated by the adapter. It checks the
1740 * vector in the HOST_INT register to determine if it is
1741 * an Adapter Check interrupt. If so, it resets the
1742 * adapter. Otherwise it clears the status registers
1743 * and services the PHY.
1745 **************************************************************/
1747 static u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
1749 TLanPrivateInfo *priv = netdev_priv(dev);
1758 if ( host_int & TLAN_HI_IV_MASK ) {
1759 netif_stop_queue( dev );
1760 error = inl( dev->base_addr + TLAN_CH_PARM );
1761 printk( "TLAN: %s: Adaptor Error = 0x%x\n", dev->name, error );
1762 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1763 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1765 schedule_work(&priv->tlan_tqueue);
1767 netif_wake_queue(dev);
1770 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name );
1771 phy = priv->phy[priv->phyNum];
1773 net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS );
1775 TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts );
1776 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Net_Sts = %x\n", dev->name, (unsigned) net_sts );
1778 if ( ( net_sts & TLAN_NET_STS_MIRQ ) && ( priv->phyNum == 0 ) ) {
1779 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts );
1780 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
1781 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 } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1785 tlphy_ctl &= ~TLAN_TC_SWAPOL;
1786 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1790 TLan_PhyPrint( dev );
1797 } /* TLan_HandleStatusCheck */
1802 /***************************************************************
1808 * dev Device assigned the IRQ that was
1810 * host_int The contents of the HOST_INT
1813 * This driver is structured to determine EOC occurrences by
1814 * reading the CSTAT member of the list structure. Rx EOC
1815 * interrupts are disabled via the DIO INTDIS register.
1816 * However, TLAN chips before revision 3.0 didn't have this
1817 * CSTAT member or a INTDIS register, so if this chip is
1818 * pre-3.0, process EOC interrupts normally.
1820 **************************************************************/
1822 static u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
1824 TLanPrivateInfo *priv = netdev_priv(dev);
1825 dma_addr_t head_list_phys;
1828 if ( priv->tlanRev < 0x30 ) {
1829 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: Handling RX EOC (Head=%d Tail=%d) -- IRQ\n", priv->rxHead, priv->rxTail );
1830 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1831 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1832 ack |= TLAN_HC_GO | TLAN_HC_RT;
1838 } /* TLan_HandleRxEOC */
1843 /*****************************************************************************
1844 ******************************************************************************
1846 ThunderLAN Driver Timer Function
1848 ******************************************************************************
1849 *****************************************************************************/
1852 /***************************************************************
1858 * data A value given to add timer when
1859 * add_timer was called.
1861 * This function handles timed functionality for the
1862 * TLAN driver. The two current timer uses are for
1863 * delaying for autonegotionation and driving the ACT LED.
1864 * - Autonegotiation requires being allowed about
1865 * 2 1/2 seconds before attempting to transmit a
1866 * packet. It would be a very bad thing to hang
1867 * the kernel this long, so the driver doesn't
1868 * allow transmission 'til after this time, for
1869 * certain PHYs. It would be much nicer if all
1870 * PHYs were interrupt-capable like the internal
1872 * - The ACT LED, which shows adapter activity, is
1873 * driven by the driver, and so must be left on
1874 * for a short period to power up the LED so it
1875 * can be seen. This delay can be changed by
1876 * changing the TLAN_TIMER_ACT_DELAY in tlan.h,
1877 * if desired. 100 ms produces a slightly
1878 * sluggish response.
1880 **************************************************************/
1882 static void TLan_Timer( unsigned long data )
1884 struct net_device *dev = (struct net_device *) data;
1885 TLanPrivateInfo *priv = netdev_priv(dev);
1887 unsigned long flags = 0;
1889 priv->timer.function = NULL;
1891 switch ( priv->timerType ) {
1893 case TLAN_TIMER_LINK_BEAT:
1894 TLan_PhyMonitor( dev );
1897 case TLAN_TIMER_PHY_PDOWN:
1898 TLan_PhyPowerDown( dev );
1900 case TLAN_TIMER_PHY_PUP:
1901 TLan_PhyPowerUp( dev );
1903 case TLAN_TIMER_PHY_RESET:
1904 TLan_PhyReset( dev );
1906 case TLAN_TIMER_PHY_START_LINK:
1907 TLan_PhyStartLink( dev );
1909 case TLAN_TIMER_PHY_FINISH_AN:
1910 TLan_PhyFinishAutoNeg( dev );
1912 case TLAN_TIMER_FINISH_RESET:
1913 TLan_FinishReset( dev );
1915 case TLAN_TIMER_ACTIVITY:
1916 spin_lock_irqsave(&priv->lock, flags);
1917 if ( priv->timer.function == NULL ) {
1918 elapsed = jiffies - priv->timerSetAt;
1919 if ( elapsed >= TLAN_TIMER_ACT_DELAY ) {
1920 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
1922 priv->timer.function = &TLan_Timer;
1923 priv->timer.expires = priv->timerSetAt + TLAN_TIMER_ACT_DELAY;
1924 spin_unlock_irqrestore(&priv->lock, flags);
1925 add_timer( &priv->timer );
1929 spin_unlock_irqrestore(&priv->lock, flags);
1940 /*****************************************************************************
1941 ******************************************************************************
1943 ThunderLAN Driver Adapter Related Routines
1945 ******************************************************************************
1946 *****************************************************************************/
1949 /***************************************************************
1955 * dev The device structure with the list
1956 * stuctures to be reset.
1958 * This routine sets the variables associated with managing
1959 * the TLAN lists to their initial values.
1961 **************************************************************/
1963 static void TLan_ResetLists( struct net_device *dev )
1965 TLanPrivateInfo *priv = netdev_priv(dev);
1968 dma_addr_t list_phys;
1969 struct sk_buff *skb;
1974 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
1975 list = priv->txList + i;
1976 list->cStat = TLAN_CSTAT_UNUSED;
1978 list->buffer[0].address = priv->txBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
1980 list->buffer[0].address = 0;
1982 list->buffer[2].count = 0;
1983 list->buffer[2].address = 0;
1984 list->buffer[8].address = 0;
1985 list->buffer[9].address = 0;
1989 priv->rxTail = TLAN_NUM_RX_LISTS - 1;
1990 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
1991 list = priv->rxList + i;
1992 list_phys = priv->rxListDMA + sizeof(TLanList) * i;
1993 list->cStat = TLAN_CSTAT_READY;
1994 list->frameSize = TLAN_MAX_FRAME_SIZE;
1995 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
1997 list->buffer[0].address = priv->rxBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
1999 skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
2000 if ( skb == NULL ) {
2001 printk( "TLAN: Couldn't allocate memory for received data.\n" );
2002 /* If this ever happened it would be a problem */
2005 skb_reserve( skb, 2 );
2006 t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE );
2008 list->buffer[0].address = pci_map_single(priv->pciDev, t, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
2009 list->buffer[8].address = (u32) t;
2010 TLan_StoreSKB(list, skb);
2012 list->buffer[1].count = 0;
2013 list->buffer[1].address = 0;
2014 if ( i < TLAN_NUM_RX_LISTS - 1 )
2015 list->forward = list_phys + sizeof(TLanList);
2020 } /* TLan_ResetLists */
2023 static void TLan_FreeLists( struct net_device *dev )
2025 TLanPrivateInfo *priv = netdev_priv(dev);
2028 struct sk_buff *skb;
2031 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
2032 list = priv->txList + i;
2033 skb = TLan_GetSKB(list);
2035 pci_unmap_single(priv->pciDev, list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
2036 dev_kfree_skb_any( skb );
2037 list->buffer[8].address = 0;
2038 list->buffer[9].address = 0;
2042 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
2043 list = priv->rxList + i;
2044 skb = TLan_GetSKB(list);
2046 pci_unmap_single(priv->pciDev, list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
2047 dev_kfree_skb_any( skb );
2048 list->buffer[8].address = 0;
2049 list->buffer[9].address = 0;
2053 } /* TLan_FreeLists */
2058 /***************************************************************
2064 * io_base Base IO port of the device of
2065 * which to print DIO registers.
2067 * This function prints out all the internal (DIO)
2068 * registers of a TLAN chip.
2070 **************************************************************/
2072 static void TLan_PrintDio( u16 io_base )
2077 printk( "TLAN: Contents of internal registers for io base 0x%04hx.\n", io_base );
2078 printk( "TLAN: Off. +0 +4\n" );
2079 for ( i = 0; i < 0x4C; i+= 8 ) {
2080 data0 = TLan_DioRead32( io_base, i );
2081 data1 = TLan_DioRead32( io_base, i + 0x4 );
2082 printk( "TLAN: 0x%02x 0x%08x 0x%08x\n", i, data0, data1 );
2085 } /* TLan_PrintDio */
2090 /***************************************************************
2096 * list A pointer to the TLanList structure to
2098 * type A string to designate type of list,
2100 * num The index of the list.
2102 * This function prints out the contents of the list
2103 * pointed to by the list parameter.
2105 **************************************************************/
2107 static void TLan_PrintList( TLanList *list, char *type, int num)
2111 printk( "TLAN: %s List %d at 0x%08x\n", type, num, (u32) list );
2112 printk( "TLAN: Forward = 0x%08x\n", list->forward );
2113 printk( "TLAN: CSTAT = 0x%04hx\n", list->cStat );
2114 printk( "TLAN: Frame Size = 0x%04hx\n", list->frameSize );
2115 /* for ( i = 0; i < 10; i++ ) { */
2116 for ( i = 0; i < 2; i++ ) {
2117 printk( "TLAN: Buffer[%d].count, addr = 0x%08x, 0x%08x\n", i, list->buffer[i].count, list->buffer[i].address );
2120 } /* TLan_PrintList */
2125 /***************************************************************
2126 * TLan_ReadAndClearStats
2131 * dev Pointer to device structure of adapter
2132 * to which to read stats.
2133 * record Flag indicating whether to add
2135 * This functions reads all the internal status registers
2136 * of the TLAN chip, which clears them as a side effect.
2137 * It then either adds the values to the device's status
2138 * struct, or discards them, depending on whether record
2139 * is TLAN_RECORD (!=0) or TLAN_IGNORE (==0).
2141 **************************************************************/
2143 static void TLan_ReadAndClearStats( struct net_device *dev, int record )
2145 TLanPrivateInfo *priv = netdev_priv(dev);
2146 u32 tx_good, tx_under;
2147 u32 rx_good, rx_over;
2148 u32 def_tx, crc, code;
2149 u32 multi_col, single_col;
2150 u32 excess_col, late_col, loss;
2152 outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2153 tx_good = inb( dev->base_addr + TLAN_DIO_DATA );
2154 tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2155 tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2156 tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2158 outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2159 rx_good = inb( dev->base_addr + TLAN_DIO_DATA );
2160 rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2161 rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2162 rx_over = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2164 outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
2165 def_tx = inb( dev->base_addr + TLAN_DIO_DATA );
2166 def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2167 crc = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2168 code = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2170 outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2171 multi_col = inb( dev->base_addr + TLAN_DIO_DATA );
2172 multi_col += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2173 single_col = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2174 single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8;
2176 outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2177 excess_col = inb( dev->base_addr + TLAN_DIO_DATA );
2178 late_col = inb( dev->base_addr + TLAN_DIO_DATA + 1 );
2179 loss = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2182 priv->stats.rx_packets += rx_good;
2183 priv->stats.rx_errors += rx_over + crc + code;
2184 priv->stats.tx_packets += tx_good;
2185 priv->stats.tx_errors += tx_under + loss;
2186 priv->stats.collisions += multi_col + single_col + excess_col + late_col;
2188 priv->stats.rx_over_errors += rx_over;
2189 priv->stats.rx_crc_errors += crc;
2190 priv->stats.rx_frame_errors += code;
2192 priv->stats.tx_aborted_errors += tx_under;
2193 priv->stats.tx_carrier_errors += loss;
2196 } /* TLan_ReadAndClearStats */
2201 /***************************************************************
2207 * dev Pointer to device structure of adapter
2210 * This function resets the adapter and it's physical
2211 * device. See Chap. 3, pp. 9-10 of the "ThunderLAN
2212 * Programmer's Guide" for details. The routine tries to
2213 * implement what is detailed there, though adjustments
2216 **************************************************************/
2219 TLan_ResetAdapter( struct net_device *dev )
2221 TLanPrivateInfo *priv = netdev_priv(dev);
2227 priv->tlanFullDuplex = FALSE;
2229 netif_carrier_off(dev);
2231 /* 1. Assert reset bit. */
2233 data = inl(dev->base_addr + TLAN_HOST_CMD);
2234 data |= TLAN_HC_AD_RST;
2235 outl(data, dev->base_addr + TLAN_HOST_CMD);
2239 /* 2. Turn off interrupts. ( Probably isn't necessary ) */
2241 data = inl(dev->base_addr + TLAN_HOST_CMD);
2242 data |= TLAN_HC_INT_OFF;
2243 outl(data, dev->base_addr + TLAN_HOST_CMD);
2245 /* 3. Clear AREGs and HASHs. */
2247 for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) {
2248 TLan_DioWrite32( dev->base_addr, (u16) i, 0 );
2251 /* 4. Setup NetConfig register. */
2253 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2254 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2256 /* 5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2258 outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD );
2259 outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD );
2261 /* 6. Unreset the MII by setting NMRST (in NetSio) to 1. */
2263 outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR );
2264 addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2265 TLan_SetBit( TLAN_NET_SIO_NMRST, addr );
2267 /* 7. Setup the remaining registers. */
2269 if ( priv->tlanRev >= 0x30 ) {
2270 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
2271 TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 );
2273 TLan_PhyDetect( dev );
2274 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
2276 if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
2277 data |= TLAN_NET_CFG_BIT;
2278 if ( priv->aui == 1 ) {
2279 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a );
2280 } else if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2281 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 );
2282 priv->tlanFullDuplex = TRUE;
2284 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 );
2288 if ( priv->phyNum == 0 ) {
2289 data |= TLAN_NET_CFG_PHY_EN;
2291 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2293 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2294 TLan_FinishReset( dev );
2296 TLan_PhyPowerDown( dev );
2299 } /* TLan_ResetAdapter */
2305 TLan_FinishReset( struct net_device *dev )
2307 TLanPrivateInfo *priv = netdev_priv(dev);
2315 u16 tlphy_id1, tlphy_id2;
2318 phy = priv->phy[priv->phyNum];
2320 data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
2321 if ( priv->tlanFullDuplex ) {
2322 data |= TLAN_NET_CMD_DUPLEX;
2324 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
2325 data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
2326 if ( priv->phyNum == 0 ) {
2327 data |= TLAN_NET_MASK_MASK7;
2329 TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
2330 TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
2331 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
2332 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
2334 if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) {
2335 status = MII_GS_LINK;
2336 printk( "TLAN: %s: Link forced.\n", dev->name );
2338 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2340 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2341 if ( (status & MII_GS_LINK) && /* We only support link info on Nat.Sem. PHY's */
2342 (tlphy_id1 == NAT_SEM_ID1) &&
2343 (tlphy_id2 == NAT_SEM_ID2) ) {
2344 TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
2345 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
2347 printk( "TLAN: %s: Link active with ", dev->name );
2348 if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
2349 printk( "forced 10%sMbps %s-Duplex\n",
2350 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2351 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2353 printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
2354 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2355 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2356 printk("TLAN: Partner capability: ");
2357 for (i = 5; i <= 10; i++)
2358 if (partner & (1<<i))
2359 printk("%s",media[i-5]);
2363 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2365 /* We have link beat..for now anyway */
2367 /*Enabling link beat monitoring */
2368 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
2370 } else if (status & MII_GS_LINK) {
2371 printk( "TLAN: %s: Link active\n", dev->name );
2372 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2376 if ( priv->phyNum == 0 ) {
2377 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
2378 tlphy_ctl |= TLAN_TC_INTEN;
2379 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl );
2380 sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO );
2381 sio |= TLAN_NET_SIO_MINTEN;
2382 TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio );
2385 if ( status & MII_GS_LINK ) {
2386 TLan_SetMac( dev, 0, dev->dev_addr );
2387 priv->phyOnline = 1;
2388 outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2389 if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
2390 outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2392 outl( priv->rxListDMA, dev->base_addr + TLAN_CH_PARM );
2393 outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
2394 netif_carrier_on(dev);
2396 printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", dev->name );
2397 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
2400 TLan_SetMulticastList(dev);
2402 } /* TLan_FinishReset */
2407 /***************************************************************
2413 * dev Pointer to device structure of adapter
2414 * on which to change the AREG.
2415 * areg The AREG to set the address in (0 - 3).
2416 * mac A pointer to an array of chars. Each
2417 * element stores one byte of the address.
2418 * IE, it isn't in ascii.
2420 * This function transfers a MAC address to one of the
2421 * TLAN AREGs (address registers). The TLAN chip locks
2422 * the register on writing to offset 0 and unlocks the
2423 * register after writing to offset 5. If NULL is passed
2424 * in mac, then the AREG is filled with 0's.
2426 **************************************************************/
2428 static void TLan_SetMac( struct net_device *dev, int areg, char *mac )
2434 if ( mac != NULL ) {
2435 for ( i = 0; i < 6; i++ )
2436 TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] );
2438 for ( i = 0; i < 6; i++ )
2439 TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 );
2447 /*****************************************************************************
2448 ******************************************************************************
2450 ThunderLAN Driver PHY Layer Routines
2452 ******************************************************************************
2453 *****************************************************************************/
2457 /*********************************************************************
2463 * dev A pointer to the device structure of the
2464 * TLAN device having the PHYs to be detailed.
2466 * This function prints the registers a PHY (aka transceiver).
2468 ********************************************************************/
2470 static void TLan_PhyPrint( struct net_device *dev )
2472 TLanPrivateInfo *priv = netdev_priv(dev);
2473 u16 i, data0, data1, data2, data3, phy;
2475 phy = priv->phy[priv->phyNum];
2477 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2478 printk( "TLAN: Device %s, Unmanaged PHY.\n", dev->name );
2479 } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
2480 printk( "TLAN: Device %s, PHY 0x%02x.\n", dev->name, phy );
2481 printk( "TLAN: Off. +0 +1 +2 +3 \n" );
2482 for ( i = 0; i < 0x20; i+= 4 ) {
2483 printk( "TLAN: 0x%02x", i );
2484 TLan_MiiReadReg( dev, phy, i, &data0 );
2485 printk( " 0x%04hx", data0 );
2486 TLan_MiiReadReg( dev, phy, i + 1, &data1 );
2487 printk( " 0x%04hx", data1 );
2488 TLan_MiiReadReg( dev, phy, i + 2, &data2 );
2489 printk( " 0x%04hx", data2 );
2490 TLan_MiiReadReg( dev, phy, i + 3, &data3 );
2491 printk( " 0x%04hx\n", data3 );
2494 printk( "TLAN: Device %s, Invalid PHY.\n", dev->name );
2497 } /* TLan_PhyPrint */
2502 /*********************************************************************
2508 * dev A pointer to the device structure of the adapter
2509 * for which the PHY needs determined.
2511 * So far I've found that adapters which have external PHYs
2512 * may also use the internal PHY for part of the functionality.
2513 * (eg, AUI/Thinnet). This function finds out if this TLAN
2514 * chip has an internal PHY, and then finds the first external
2515 * PHY (starting from address 0) if it exists).
2517 ********************************************************************/
2519 static void TLan_PhyDetect( struct net_device *dev )
2521 TLanPrivateInfo *priv = netdev_priv(dev);
2527 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2528 priv->phyNum = 0xFFFF;
2532 TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
2534 if ( hi != 0xFFFF ) {
2535 priv->phy[0] = TLAN_PHY_MAX_ADDR;
2537 priv->phy[0] = TLAN_PHY_NONE;
2540 priv->phy[1] = TLAN_PHY_NONE;
2541 for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) {
2542 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
2543 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
2544 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
2545 if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
2546 TLAN_DBG( TLAN_DEBUG_GNRL, "PHY found at %02x %04x %04x %04x\n", phy, control, hi, lo );
2547 if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) {
2553 if ( priv->phy[1] != TLAN_PHY_NONE ) {
2555 } else if ( priv->phy[0] != TLAN_PHY_NONE ) {
2558 printk( "TLAN: Cannot initialize device, no PHY was found!\n" );
2561 } /* TLan_PhyDetect */
2566 static void TLan_PhyPowerDown( struct net_device *dev )
2568 TLanPrivateInfo *priv = netdev_priv(dev);
2571 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name );
2572 value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
2573 TLan_MiiSync( dev->base_addr );
2574 TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2575 if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
2576 TLan_MiiSync( dev->base_addr );
2577 TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
2580 /* Wait for 50 ms and powerup
2581 * This is abitrary. It is intended to make sure the
2582 * transceiver settles.
2584 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP );
2586 } /* TLan_PhyPowerDown */
2591 static void TLan_PhyPowerUp( struct net_device *dev )
2593 TLanPrivateInfo *priv = netdev_priv(dev);
2596 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name );
2597 TLan_MiiSync( dev->base_addr );
2598 value = MII_GC_LOOPBK;
2599 TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2600 TLan_MiiSync(dev->base_addr);
2601 /* Wait for 500 ms and reset the
2602 * transceiver. The TLAN docs say both 50 ms and
2603 * 500 ms, so do the longer, just in case.
2605 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET );
2607 } /* TLan_PhyPowerUp */
2612 static void TLan_PhyReset( struct net_device *dev )
2614 TLanPrivateInfo *priv = netdev_priv(dev);
2618 phy = priv->phy[priv->phyNum];
2620 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name );
2621 TLan_MiiSync( dev->base_addr );
2622 value = MII_GC_LOOPBK | MII_GC_RESET;
2623 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value );
2624 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2625 while ( value & MII_GC_RESET ) {
2626 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2629 /* Wait for 500 ms and initialize.
2630 * I don't remember why I wait this long.
2631 * I've changed this to 50ms, as it seems long enough.
2633 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK );
2635 } /* TLan_PhyReset */
2640 static void TLan_PhyStartLink( struct net_device *dev )
2642 TLanPrivateInfo *priv = netdev_priv(dev);
2650 phy = priv->phy[priv->phyNum];
2651 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name );
2652 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2653 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
2655 if ( ( status & MII_GS_AUTONEG ) &&
2657 ability = status >> 11;
2658 if ( priv->speed == TLAN_SPEED_10 &&
2659 priv->duplex == TLAN_DUPLEX_HALF) {
2660 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
2661 } else if ( priv->speed == TLAN_SPEED_10 &&
2662 priv->duplex == TLAN_DUPLEX_FULL) {
2663 priv->tlanFullDuplex = TRUE;
2664 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100);
2665 } else if ( priv->speed == TLAN_SPEED_100 &&
2666 priv->duplex == TLAN_DUPLEX_HALF) {
2667 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000);
2668 } else if ( priv->speed == TLAN_SPEED_100 &&
2669 priv->duplex == TLAN_DUPLEX_FULL) {
2670 priv->tlanFullDuplex = TRUE;
2671 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
2674 /* Set Auto-Neg advertisement */
2675 TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
2676 /* Enablee Auto-Neg */
2677 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 );
2678 /* Restart Auto-Neg */
2679 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 );
2680 /* Wait for 4 sec for autonegotiation
2681 * to complete. The max spec time is less than this
2682 * but the card need additional time to start AN.
2683 * .5 sec should be plenty extra.
2685 printk( "TLAN: %s: Starting autonegotiation.\n", dev->name );
2686 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
2692 if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
2694 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2695 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2696 TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2698 } else if ( priv->phyNum == 0 ) {
2700 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
2702 tctl |= TLAN_TC_AUISEL;
2704 tctl &= ~TLAN_TC_AUISEL;
2705 if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2706 control |= MII_GC_DUPLEX;
2707 priv->tlanFullDuplex = TRUE;
2709 if ( priv->speed == TLAN_SPEED_100 ) {
2710 control |= MII_GC_SPEEDSEL;
2713 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control );
2714 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl );
2717 /* Wait for 2 sec to give the transceiver time
2718 * to establish link.
2720 TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET );
2722 } /* TLan_PhyStartLink */
2727 static void TLan_PhyFinishAutoNeg( struct net_device *dev )
2729 TLanPrivateInfo *priv = netdev_priv(dev);
2737 phy = priv->phy[priv->phyNum];
2739 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2741 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2743 if ( ! ( status & MII_GS_AUTOCMPLT ) ) {
2744 /* Wait for 8 sec to give the process
2745 * more time. Perhaps we should fail after a while.
2747 if (!priv->neg_be_verbose++) {
2748 printk(KERN_INFO "TLAN: Giving autonegotiation more time.\n");
2749 printk(KERN_INFO "TLAN: Please check that your adapter has\n");
2750 printk(KERN_INFO "TLAN: been properly connected to a HUB or Switch.\n");
2751 printk(KERN_INFO "TLAN: Trying to establish link in the background...\n");
2753 TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
2757 printk( "TLAN: %s: Autonegotiation complete.\n", dev->name );
2758 TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv );
2759 TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa );
2760 mode = an_adv & an_lpa & 0x03E0;
2761 if ( mode & 0x0100 ) {
2762 priv->tlanFullDuplex = TRUE;
2763 } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) {
2764 priv->tlanFullDuplex = TRUE;
2767 if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) {
2769 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2770 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2771 TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2775 if ( priv->phyNum == 0 ) {
2776 if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) {
2777 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX );
2778 printk( "TLAN: Starting internal PHY with FULL-DUPLEX\n" );
2780 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
2781 printk( "TLAN: Starting internal PHY with HALF-DUPLEX\n" );
2785 /* Wait for 100 ms. No reason in partiticular.
2787 TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
2789 } /* TLan_PhyFinishAutoNeg */
2793 /*********************************************************************
2801 * dev The device structure of this device.
2804 * This function monitors PHY condition by reading the status
2805 * register via the MII bus. This can be used to give info
2806 * about link changes (up/down), and possible switch to alternate
2809 * ******************************************************************/
2811 void TLan_PhyMonitor( struct net_device *dev )
2813 TLanPrivateInfo *priv = netdev_priv(dev);
2817 phy = priv->phy[priv->phyNum];
2819 /* Get PHY status register */
2820 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
2822 /* Check if link has been lost */
2823 if (!(phy_status & MII_GS_LINK)) {
2826 printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name);
2827 netif_carrier_off(dev);
2828 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2833 /* Link restablished? */
2834 if ((phy_status & MII_GS_LINK) && !priv->link) {
2836 printk(KERN_DEBUG "TLAN: %s has reestablished link\n", dev->name);
2837 netif_carrier_on(dev);
2840 /* Setup a new monitor */
2841 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2844 #endif /* MONITOR */
2847 /*****************************************************************************
2848 ******************************************************************************
2850 ThunderLAN Driver MII Routines
2852 These routines are based on the information in Chap. 2 of the
2853 "ThunderLAN Programmer's Guide", pp. 15-24.
2855 ******************************************************************************
2856 *****************************************************************************/
2859 /***************************************************************
2863 * 0 if ack received ok
2867 * dev The device structure containing
2868 * The io address and interrupt count
2870 * phy The address of the PHY to be queried.
2871 * reg The register whose contents are to be
2873 * val A pointer to a variable to store the
2876 * This function uses the TLAN's MII bus to retrieve the contents
2877 * of a given register on a PHY. It sends the appropriate info
2878 * and then reads the 16-bit register value from the MII bus via
2879 * the TLAN SIO register.
2881 **************************************************************/
2883 static int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
2890 TLanPrivateInfo *priv = netdev_priv(dev);
2891 unsigned long flags = 0;
2894 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2895 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2898 spin_lock_irqsave(&priv->lock, flags);
2900 TLan_MiiSync(dev->base_addr);
2902 minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
2904 TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);
2906 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */
2907 TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Read ( 10b ) */
2908 TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */
2909 TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */
2912 TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio); /* Change direction */
2914 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Clock Idle bit */
2915 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2916 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Wait 300ns */
2918 nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio); /* Check for ACK */
2919 TLan_SetBit(TLAN_NET_SIO_MCLK, sio); /* Finish ACK */
2920 if (nack) { /* No ACK, so fake it */
2921 for (i = 0; i < 16; i++) {
2922 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2923 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2927 } else { /* ACK, so read data */
2928 for (tmp = 0, i = 0x8000; i; i >>= 1) {
2929 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2930 if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
2932 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2937 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Idle cycle */
2938 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2941 TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
2946 spin_unlock_irqrestore(&priv->lock, flags);
2950 } /* TLan_MiiReadReg */
2955 /***************************************************************
2961 * base_port The base IO port of the adapter in
2963 * dev The address of the PHY to be queried.
2964 * data The value to be placed on the MII bus.
2965 * num_bits The number of bits in data that are to
2966 * be placed on the MII bus.
2968 * This function sends on sequence of bits on the MII
2969 * configuration bus.
2971 **************************************************************/
2973 static void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
2978 if ( num_bits == 0 )
2981 outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
2982 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
2983 TLan_SetBit( TLAN_NET_SIO_MTXEN, sio );
2985 for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) {
2986 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
2987 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2989 TLan_SetBit( TLAN_NET_SIO_MDATA, sio );
2991 TLan_ClearBit( TLAN_NET_SIO_MDATA, sio );
2992 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
2993 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2996 } /* TLan_MiiSendData */
3001 /***************************************************************
3007 * base_port The base IO port of the adapter in
3010 * This functions syncs all PHYs in terms of the MII configuration
3013 **************************************************************/
3015 static void TLan_MiiSync( u16 base_port )
3020 outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
3021 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3023 TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio );
3024 for ( i = 0; i < 32; i++ ) {
3025 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3026 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3029 } /* TLan_MiiSync */
3034 /***************************************************************
3040 * dev The device structure for the device
3042 * phy The address of the PHY to be written to.
3043 * reg The register whose contents are to be
3045 * val The value to be written to the register.
3047 * This function uses the TLAN's MII bus to write the contents of a
3048 * given register on a PHY. It sends the appropriate info and then
3049 * writes the 16-bit register value from the MII configuration bus
3050 * via the TLAN SIO register.
3052 **************************************************************/
3054 static void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
3058 unsigned long flags = 0;
3059 TLanPrivateInfo *priv = netdev_priv(dev);
3061 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3062 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
3065 spin_lock_irqsave(&priv->lock, flags);
3067 TLan_MiiSync( dev->base_addr );
3069 minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
3071 TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio );
3073 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */
3074 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Write ( 01b ) */
3075 TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */
3076 TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */
3078 TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Send ACK */
3079 TLan_MiiSendData( dev->base_addr, val, 16 ); /* Send Data */
3081 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); /* Idle cycle */
3082 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3085 TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
3088 spin_unlock_irqrestore(&priv->lock, flags);
3090 } /* TLan_MiiWriteReg */
3095 /*****************************************************************************
3096 ******************************************************************************
3098 ThunderLAN Driver Eeprom routines
3100 The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A
3101 EEPROM. These functions are based on information in Microchip's
3102 data sheet. I don't know how well this functions will work with
3105 ******************************************************************************
3106 *****************************************************************************/
3109 /***************************************************************
3115 * io_base The IO port base address for the
3116 * TLAN device with the EEPROM to
3119 * This function sends a start cycle to an EEPROM attached
3122 **************************************************************/
3124 static void TLan_EeSendStart( u16 io_base )
3128 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3129 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3131 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3132 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3133 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3134 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3135 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3137 } /* TLan_EeSendStart */
3142 /***************************************************************
3146 * If the correct ack was received, 0, otherwise 1
3147 * Parms: io_base The IO port base address for the
3148 * TLAN device with the EEPROM to
3150 * data The 8 bits of information to
3151 * send to the EEPROM.
3152 * stop If TLAN_EEPROM_STOP is passed, a
3153 * stop cycle is sent after the
3154 * byte is sent after the ack is
3157 * This function sends a byte on the serial EEPROM line,
3158 * driving the clock to send each bit. The function then
3159 * reverses transmission direction and reads an acknowledge
3162 **************************************************************/
3164 static int TLan_EeSendByte( u16 io_base, u8 data, int stop )
3170 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3171 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3173 /* Assume clock is low, tx is enabled; */
3174 for ( place = 0x80; place != 0; place >>= 1 ) {
3176 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3178 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3179 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3180 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3182 TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3183 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3184 err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio );
3185 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3186 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3188 if ( ( ! err ) && stop ) {
3189 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* STOP, raise data while clock is high */
3190 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3191 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3196 } /* TLan_EeSendByte */
3201 /***************************************************************
3202 * TLan_EeReceiveByte
3207 * io_base The IO port base address for the
3208 * TLAN device with the EEPROM to
3210 * data An address to a char to hold the
3211 * data sent from the EEPROM.
3212 * stop If TLAN_EEPROM_STOP is passed, a
3213 * stop cycle is sent after the
3214 * byte is received, and no ack is
3217 * This function receives 8 bits of data from the EEPROM
3218 * over the serial link. It then sends and ack bit, or no
3219 * ack and a stop bit. This function is used to retrieve
3220 * data after the address of a byte in the EEPROM has been
3223 **************************************************************/
3225 static void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
3230 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3231 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3234 /* Assume clock is low, tx is enabled; */
3235 TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3236 for ( place = 0x80; place; place >>= 1 ) {
3237 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3238 if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) )
3240 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3243 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3245 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* Ack = 0 */
3246 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3247 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3249 TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); /* No ack = 1 (?) */
3250 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3251 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3252 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* STOP, raise data while clock is high */
3253 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3254 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3257 } /* TLan_EeReceiveByte */
3262 /***************************************************************
3266 * No error = 0, else, the stage at which the error
3269 * io_base The IO port base address for the
3270 * TLAN device with the EEPROM to
3272 * ee_addr The address of the byte in the
3273 * EEPROM whose contents are to be
3275 * data An address to a char to hold the
3276 * data obtained from the EEPROM.
3278 * This function reads a byte of information from an byte
3279 * cell in the EEPROM.
3281 **************************************************************/
3283 static int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
3286 TLanPrivateInfo *priv = netdev_priv(dev);
3287 unsigned long flags = 0;
3290 spin_lock_irqsave(&priv->lock, flags);
3292 TLan_EeSendStart( dev->base_addr );
3293 err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK );
3299 err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK );
3305 TLan_EeSendStart( dev->base_addr );
3306 err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK );
3312 TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP );
3314 spin_unlock_irqrestore(&priv->lock, flags);
3318 } /* TLan_EeReadByte */