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 ** Useful (if not required) reading:
18 * Texas Instruments, ThunderLAN Programmer's Guide,
19 * TI Literature Number SPWU013A
20 * available in PDF format from www.ti.com
21 * Level One, LXT901 and LXT970 Data Sheets
22 * available in PDF format from www.level1.com
23 * National Semiconductor, DP83840A Data Sheet
24 * available in PDF format from www.national.com
25 * Microchip Technology, 24C01A/02A/04A Data Sheet
26 * available in PDF format from www.microchip.com
30 * Tigran Aivazian <tigran@sco.com>: TLan_PciProbe() now uses
31 * new PCI BIOS interface.
32 * Alan Cox <alan@lxorguk.ukuu.org.uk>:
33 * Fixed the out of memory
36 * Torben Mathiasen <torben.mathiasen@compaq.com> New Maintainer!
38 * v1.1 Dec 20, 1999 - Removed linux version checking
39 * Patch from Tigran Aivazian.
40 * - v1.1 includes Alan's SMP updates.
41 * - We still have problems on SMP though,
42 * but I'm looking into that.
44 * v1.2 Jan 02, 2000 - Hopefully fixed the SMP deadlock.
45 * - Removed dependency of HZ being 100.
46 * - We now allow higher priority timers to
47 * overwrite timers like TLAN_TIMER_ACTIVITY
48 * Patch from John Cagle <john.cagle@compaq.com>.
49 * - Fixed a few compiler warnings.
51 * v1.3 Feb 04, 2000 - Fixed the remaining HZ issues.
52 * - Removed call to pci_present().
53 * - Removed SA_INTERRUPT flag from irq handler.
54 * - Added __init and __initdata to reduce resisdent
56 * - Driver now uses module_init/module_exit.
57 * - Rewrote init_module and tlan_probe to
58 * share a lot more code. We now use tlan_probe
59 * with builtin and module driver.
60 * - Driver ported to new net API.
61 * - tlan.txt has been reworked to reflect current
65 * v1.4 Feb 10, 2000 - Updated with more changes required after Dave's
66 * network cleanup in 2.3.43pre7 (Tigran & myself)
69 * v1.5 March 22, 2000 - Fixed another timer bug that would hang the driver
70 * if no cable/link were present.
72 * - TODO: Port completely to new PCI/DMA API
75 * v1.6 April 04, 2000 - Fixed driver support for kernel-parameters. Haven't
76 * tested it though, as the kernel support is currently
77 * broken (2.3.99p4p3).
78 * - Updated tlan.txt accordingly.
79 * - Adjusted minimum/maximum frame length.
80 * - There is now a TLAN website up at
81 * http://tlan.kernel.dk
83 * v1.7 April 07, 2000 - Started to implement custom ioctls. Driver now
84 * reports PHY information when used with Donald
85 * Beckers userspace MII diagnostics utility.
87 * v1.8 April 23, 2000 - Fixed support for forced speed/duplex settings.
88 * - Added link information to Auto-Neg and forced
89 * modes. When NIC operates with auto-neg the driver
90 * will report Link speed & duplex modes as well as
91 * link partner abilities. When forced link is used,
92 * the driver will report status of the established
94 * Please read tlan.txt for additional information.
95 * - Removed call to check_region(), and used
96 * return value of request_region() instead.
98 * v1.8a May 28, 2000 - Minor updates.
100 * v1.9 July 25, 2000 - Fixed a few remaining Full-Duplex issues.
101 * - Updated with timer fixes from Andrew Morton.
102 * - Fixed module race in TLan_Open.
103 * - Added routine to monitor PHY status.
104 * - Added activity led support for Proliant devices.
106 * v1.10 Aug 30, 2000 - Added support for EISA based tlan controllers
107 * like the Compaq NetFlex3/E.
108 * - Rewrote tlan_probe to better handle multiple
109 * bus probes. Probing and device setup is now
110 * done through TLan_Probe and TLan_init_one. Actual
111 * hardware probe is done with kernel API and
113 * - Adjusted debug information for probing.
114 * - Fixed bug that would cause general debug information
115 * to be printed after driver removal.
116 * - Added transmit timeout handling.
117 * - Fixed OOM return values in tlan_probe.
118 * - Fixed possible mem leak in tlan_exit
119 * (now tlan_remove_one).
120 * - Fixed timer bug in TLan_phyMonitor.
121 * - This driver version is alpha quality, please
122 * send me any bug issues you may encounter.
124 * v1.11 Aug 31, 2000 - Do not try to register irq 0 if no irq line was
125 * set for EISA cards.
126 * - Added support for NetFlex3/E with nibble-rate
127 * 10Base-T PHY. This is untestet as I haven't got
128 * one of these cards.
129 * - Fixed timer being added twice.
130 * - Disabled PhyMonitoring by default as this is
131 * work in progress. Define MONITOR to enable it.
132 * - Now we don't display link info with PHYs that
133 * doesn't support it (level1).
134 * - Incresed tx_timeout beacuse of auto-neg.
135 * - Adjusted timers for forced speeds.
137 * v1.12 Oct 12, 2000 - Minor fixes (memleak, init, etc.)
139 * v1.13 Nov 28, 2000 - Stop flooding console with auto-neg issues
140 * when link can't be established.
141 * - Added the bbuf option as a kernel parameter.
142 * - Fixed ioaddr probe bug.
143 * - Fixed stupid deadlock with MII interrupts.
144 * - Added support for speed/duplex selection with
146 * - Added partly fix for TX Channel lockup with
147 * TLAN v1.0 silicon. This needs to be investigated
150 * v1.14 Dec 16, 2000 - Added support for servicing multiple frames per.
151 * interrupt. Thanks goes to
152 * Adam Keys <adam@ti.com>
153 * Denis Beaudoin <dbeaudoin@ti.com>
154 * for providing the patch.
155 * - Fixed auto-neg output when using multiple
157 * - Converted to use new taskq interface.
159 * v1.14a Jan 6, 2001 - Minor adjustments (spinlocks, etc.)
161 * Samuel Chessman <chessman@tux.org> New Maintainer!
163 * v1.15 Apr 4, 2002 - Correct operation when aui=1 to be
164 * 10T half duplex no loopback
165 * Thanks to Gunnar Eikman
166 *******************************************************************************/
168 #include <linux/module.h>
169 #include <linux/init.h>
170 #include <linux/ioport.h>
171 #include <linux/eisa.h>
172 #include <linux/pci.h>
173 #include <linux/dma-mapping.h>
174 #include <linux/netdevice.h>
175 #include <linux/etherdevice.h>
176 #include <linux/delay.h>
177 #include <linux/spinlock.h>
178 #include <linux/workqueue.h>
179 #include <linux/mii.h>
183 typedef u32 (TLanIntVectorFunc)( struct net_device *, u16 );
186 /* For removing EISA devices */
187 static struct net_device *TLan_Eisa_Devices;
189 static int TLanDevicesInstalled;
191 /* Set speed, duplex and aui settings */
192 static int aui[MAX_TLAN_BOARDS];
193 static int duplex[MAX_TLAN_BOARDS];
194 static int speed[MAX_TLAN_BOARDS];
195 static int boards_found;
196 module_param_array(aui, int, NULL, 0);
197 module_param_array(duplex, int, NULL, 0);
198 module_param_array(speed, int, NULL, 0);
199 MODULE_PARM_DESC(aui, "ThunderLAN use AUI port(s) (0-1)");
200 MODULE_PARM_DESC(duplex, "ThunderLAN duplex setting(s) (0-default, 1-half, 2-full)");
201 MODULE_PARM_DESC(speed, "ThunderLAN port speen setting(s) (0,10,100)");
203 MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>");
204 MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
205 MODULE_LICENSE("GPL");
208 /* Define this to enable Link beat monitoring */
211 /* Turn on debugging. See Documentation/networking/tlan.txt for details */
213 module_param(debug, int, 0);
214 MODULE_PARM_DESC(debug, "ThunderLAN debug mask");
217 module_param(bbuf, int, 0);
218 MODULE_PARM_DESC(bbuf, "ThunderLAN use big buffer (0-1)");
220 static const char TLanSignature[] = "TLAN";
221 static const char tlan_banner[] = "ThunderLAN driver v1.15\n";
222 static int tlan_have_pci;
223 static int tlan_have_eisa;
225 static const char *media[] = {
226 "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ",
227 "100baseTx-FD", "100baseT4", NULL
230 static struct board {
231 const char *deviceLabel;
235 { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
236 { "Compaq Netelligent 10/100 TX PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
237 { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
238 { "Compaq NetFlex-3/P",
239 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",
242 TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
243 { "Compaq Netelligent Dual 10/100 TX PCI UTP", TLAN_ADAPTER_NONE, 0x83 },
244 { "Compaq Netelligent 10/100 TX Embedded UTP", TLAN_ADAPTER_NONE, 0x83 },
245 { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 },
246 { "Olicom OC-2325", TLAN_ADAPTER_UNMANAGED_PHY, 0xF8 },
247 { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xF8 },
248 { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
249 { "Compaq Netelligent 10 T/2 PCI UTP/Coax", TLAN_ADAPTER_NONE, 0x83 },
250 { "Compaq NetFlex-3/E",
251 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 */
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 },
285 MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);
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,
298 int irq, int rev, const struct pci_device_id *ent);
299 static void TLan_tx_timeout( struct net_device *dev);
300 static void TLan_tx_timeout_work(struct work_struct *work);
301 static int tlan_init_one( struct pci_dev *pdev, const struct pci_device_id *ent);
303 static u32 TLan_HandleTxEOF( struct net_device *, u16 );
304 static u32 TLan_HandleStatOverflow( struct net_device *, u16 );
305 static u32 TLan_HandleRxEOF( struct net_device *, u16 );
306 static u32 TLan_HandleDummy( struct net_device *, u16 );
307 static u32 TLan_HandleTxEOC( struct net_device *, u16 );
308 static u32 TLan_HandleStatusCheck( struct net_device *, u16 );
309 static u32 TLan_HandleRxEOC( struct net_device *, u16 );
311 static void TLan_Timer( unsigned long );
313 static void TLan_ResetLists( struct net_device * );
314 static void TLan_FreeLists( struct net_device * );
315 static void TLan_PrintDio( u16 );
316 static void TLan_PrintList( TLanList *, char *, int );
317 static void TLan_ReadAndClearStats( struct net_device *, int );
318 static void TLan_ResetAdapter( struct net_device * );
319 static void TLan_FinishReset( struct net_device * );
320 static void TLan_SetMac( struct net_device *, int areg, char *mac );
322 static void TLan_PhyPrint( struct net_device * );
323 static void TLan_PhyDetect( struct net_device * );
324 static void TLan_PhyPowerDown( struct net_device * );
325 static void TLan_PhyPowerUp( struct net_device * );
326 static void TLan_PhyReset( struct net_device * );
327 static void TLan_PhyStartLink( struct net_device * );
328 static void TLan_PhyFinishAutoNeg( struct net_device * );
330 static void TLan_PhyMonitor( struct net_device * );
334 static int TLan_PhyNop( struct net_device * );
335 static int TLan_PhyInternalCheck( struct net_device * );
336 static int TLan_PhyInternalService( struct net_device * );
337 static int TLan_PhyDp83840aCheck( struct net_device * );
340 static int TLan_MiiReadReg( struct net_device *, u16, u16, u16 * );
341 static void TLan_MiiSendData( u16, u32, unsigned );
342 static void TLan_MiiSync( u16 );
343 static void TLan_MiiWriteReg( struct net_device *, u16, u16, u16 );
345 static void TLan_EeSendStart( u16 );
346 static int TLan_EeSendByte( u16, u8, int );
347 static void TLan_EeReceiveByte( u16, u8 *, int );
348 static int TLan_EeReadByte( struct net_device *, u8, u8 * );
352 TLan_StoreSKB( struct tlan_list_tag *tag, struct sk_buff *skb)
354 unsigned long addr = (unsigned long)skb;
355 tag->buffer[9].address = addr;
356 tag->buffer[8].address = upper_32_bits(addr);
359 static inline struct sk_buff *
360 TLan_GetSKB( const struct tlan_list_tag *tag)
364 addr = tag->buffer[9].address;
365 addr |= (tag->buffer[8].address << 16) << 16;
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,
446 priv->dmaSize, priv->dmaStorage,
447 priv->dmaStorageDMA );
451 pci_release_regions(pdev);
456 pci_set_drvdata( pdev, NULL );
459 static struct pci_driver tlan_driver = {
461 .id_table = tlan_pci_tbl,
462 .probe = tlan_init_one,
463 .remove = __devexit_p(tlan_remove_one),
466 static int __init tlan_probe(void)
470 printk(KERN_INFO "%s", tlan_banner);
472 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....\n");
474 /* Use new style PCI probing. Now the kernel will
475 do most of this for us */
476 rc = pci_register_driver(&tlan_driver);
479 printk(KERN_ERR "TLAN: Could not register pci driver.\n");
480 goto err_out_pci_free;
483 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n");
486 printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d EISA: %d\n",
487 TLanDevicesInstalled, TLanDevicesInstalled == 1 ? "" : "s",
488 tlan_have_pci, tlan_have_eisa);
490 if (TLanDevicesInstalled == 0) {
492 goto err_out_pci_unreg;
497 pci_unregister_driver(&tlan_driver);
503 static int __devinit tlan_init_one( struct pci_dev *pdev,
504 const struct pci_device_id *ent)
506 return TLan_probe1( pdev, -1, -1, 0, ent);
511 ***************************************************************
515 * 0 on success, error code on error
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.
527 **************************************************************/
529 static int __devinit TLan_probe1(struct pci_dev *pdev,
530 long ioaddr, int irq, int rev,
531 const struct pci_device_id *ent )
534 struct net_device *dev;
535 TLanPrivateInfo *priv;
537 int reg, rc = -ENODEV;
541 rc = pci_enable_device(pdev);
545 rc = pci_request_regions(pdev, TLanSignature);
547 printk(KERN_ERR "TLAN: Could not reserve IO regions\n");
551 #endif /* CONFIG_PCI */
553 dev = alloc_etherdev(sizeof(TLanPrivateInfo));
555 printk(KERN_ERR "TLAN: Could not allocate memory for device.\n");
557 goto err_out_regions;
559 SET_NETDEV_DEV(dev, &pdev->dev);
561 priv = netdev_priv(dev);
566 /* Is this a PCI device? */
570 priv->adapter = &board_info[ent->driver_data];
572 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
574 printk(KERN_ERR "TLAN: No suitable PCI mapping available.\n");
575 goto err_out_free_dev;
578 for ( reg= 0; reg <= 5; reg ++ ) {
579 if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
580 pci_io_base = pci_resource_start(pdev, reg);
581 TLAN_DBG( TLAN_DEBUG_GNRL, "IO mapping is available at %x.\n",
587 printk(KERN_ERR "TLAN: No IO mappings available\n");
589 goto err_out_free_dev;
592 dev->base_addr = pci_io_base;
593 dev->irq = pdev->irq;
594 priv->adapterRev = pdev->revision;
595 pci_set_master(pdev);
596 pci_set_drvdata(pdev, dev);
598 } else { /* EISA card */
599 /* This is a hack. We need to know which board structure
600 * is suited for this adapter */
601 device_id = inw(ioaddr + EISA_ID2);
603 if (device_id == 0x20F1) {
604 priv->adapter = &board_info[13]; /* NetFlex-3/E */
605 priv->adapterRev = 23; /* TLAN 2.3 */
607 priv->adapter = &board_info[14];
608 priv->adapterRev = 10; /* TLAN 1.0 */
610 dev->base_addr = ioaddr;
614 /* Kernel parameters */
615 if (dev->mem_start) {
616 priv->aui = dev->mem_start & 0x01;
617 priv->duplex = ((dev->mem_start & 0x06) == 0x06) ? 0
618 : (dev->mem_start & 0x06) >> 1;
619 priv->speed = ((dev->mem_start & 0x18) == 0x18) ? 0
620 : (dev->mem_start & 0x18) >> 3;
622 if (priv->speed == 0x1) {
623 priv->speed = TLAN_SPEED_10;
624 } else if (priv->speed == 0x2) {
625 priv->speed = TLAN_SPEED_100;
627 debug = priv->debug = dev->mem_end;
629 priv->aui = aui[boards_found];
630 priv->speed = speed[boards_found];
631 priv->duplex = duplex[boards_found];
635 /* This will be used when we get an adapter error from
636 * within our irq handler */
637 INIT_WORK(&priv->tlan_tqueue, TLan_tx_timeout_work);
639 spin_lock_init(&priv->lock);
643 printk(KERN_ERR "TLAN: Could not set up device.\n");
644 goto err_out_free_dev;
647 rc = register_netdev(dev);
649 printk(KERN_ERR "TLAN: Could not register device.\n");
654 TLanDevicesInstalled++;
657 /* pdev is NULL if this is an EISA device */
661 priv->nextDevice = TLan_Eisa_Devices;
662 TLan_Eisa_Devices = dev;
666 printk(KERN_INFO "TLAN: %s irq=%2d, io=%04x, %s, Rev. %d\n",
669 (int) dev->base_addr,
670 priv->adapter->deviceLabel,
675 pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage,
676 priv->dmaStorageDMA );
682 pci_release_regions(pdev);
686 pci_disable_device(pdev);
691 static void TLan_Eisa_Cleanup(void)
693 struct net_device *dev;
694 TLanPrivateInfo *priv;
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,
701 priv->dmaStorage, priv->dmaStorageDMA );
703 release_region( dev->base_addr, 0x10);
704 unregister_netdev( dev );
705 TLan_Eisa_Devices = priv->nextDevice;
712 static void __exit tlan_exit(void)
714 pci_unregister_driver(&tlan_driver);
722 /* Module loading/unloading */
723 module_init(tlan_probe);
724 module_exit(tlan_exit);
728 /**************************************************************
731 * Returns: 0 on success, 1 otherwise
736 * This functions probes for EISA devices and calls
737 * TLan_probe1 when one is found.
739 *************************************************************/
741 static void __init TLan_EisaProbe (void)
749 TLAN_DBG(TLAN_DEBUG_PROBE, "No EISA bus present\n");
753 /* Loop through all slots of the EISA bus */
754 for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
756 TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n",
757 (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID));
758 TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n",
759 (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2));
762 TLAN_DBG(TLAN_DEBUG_PROBE, "Probing for EISA adapter at IO: 0x%4x : ",
764 if (request_region(ioaddr, 0x10, TLanSignature) == NULL)
767 if (inw(ioaddr + EISA_ID) != 0x110E) {
768 release_region(ioaddr, 0x10);
772 device_id = inw(ioaddr + EISA_ID2);
773 if (device_id != 0x20F1 && device_id != 0x40F1) {
774 release_region (ioaddr, 0x10);
778 if (inb(ioaddr + EISA_CR) != 0x1) { /* Check if adapter is enabled */
779 release_region (ioaddr, 0x10);
784 printk("Found one\n");
787 /* Get irq from board */
788 switch (inb(ioaddr + 0xCC0)) {
806 /* Setup the newly found eisa adapter */
807 rc = TLan_probe1( NULL, ioaddr, irq,
813 printk("None found\n");
816 out2: if (debug == 0x10)
817 printk("Card found but it is not enabled, skipping\n");
822 } /* TLan_EisaProbe */
824 #ifdef CONFIG_NET_POLL_CONTROLLER
825 static void TLan_Poll(struct net_device *dev)
827 disable_irq(dev->irq);
828 TLan_HandleInterrupt(dev->irq, dev);
829 enable_irq(dev->irq);
836 /***************************************************************
840 * 0 on success, error code otherwise.
842 * dev The structure of the device to be
845 * This function completes the initialization of the
846 * device structure and driver. It reserves the IO
847 * addresses, allocates memory for the lists and bounce
848 * buffers, retrieves the MAC address from the eeprom
849 * and assignes the device's methods.
851 **************************************************************/
853 static int TLan_Init( struct net_device *dev )
858 TLanPrivateInfo *priv;
860 priv = netdev_priv(dev);
863 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
864 * ( sizeof(TLanList) + TLAN_MAX_FRAME_SIZE );
866 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
867 * ( sizeof(TLanList) );
869 priv->dmaStorage = pci_alloc_consistent(priv->pciDev,
870 dma_size, &priv->dmaStorageDMA);
871 priv->dmaSize = dma_size;
873 if ( priv->dmaStorage == NULL ) {
874 printk(KERN_ERR "TLAN: Could not allocate lists and buffers for %s.\n",
878 memset( priv->dmaStorage, 0, dma_size );
879 priv->rxList = (TLanList *) ALIGN((unsigned long)priv->dmaStorage, 8);
880 priv->rxListDMA = ALIGN(priv->dmaStorageDMA, 8);
881 priv->txList = priv->rxList + TLAN_NUM_RX_LISTS;
882 priv->txListDMA = priv->rxListDMA + sizeof(TLanList) * TLAN_NUM_RX_LISTS;
885 priv->rxBuffer = (u8 *) ( priv->txList + TLAN_NUM_TX_LISTS );
886 priv->rxBufferDMA =priv->txListDMA
887 + sizeof(TLanList) * TLAN_NUM_TX_LISTS;
888 priv->txBuffer = priv->rxBuffer
889 + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
890 priv->txBufferDMA = priv->rxBufferDMA
891 + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
895 for ( i = 0; i < 6 ; i++ )
896 err |= TLan_EeReadByte( dev,
897 (u8) priv->adapter->addrOfs + i,
898 (u8 *) &dev->dev_addr[i] );
900 printk(KERN_ERR "TLAN: %s: Error reading MAC from eeprom: %d\n",
906 netif_carrier_off(dev);
909 dev->open = &TLan_Open;
910 dev->hard_start_xmit = &TLan_StartTx;
911 dev->stop = &TLan_Close;
912 dev->get_stats = &TLan_GetStats;
913 dev->set_multicast_list = &TLan_SetMulticastList;
914 dev->do_ioctl = &TLan_ioctl;
915 #ifdef CONFIG_NET_POLL_CONTROLLER
916 dev->poll_controller = &TLan_Poll;
918 dev->tx_timeout = &TLan_tx_timeout;
919 dev->watchdog_timeo = TX_TIMEOUT;
928 /***************************************************************
932 * 0 on success, error code otherwise.
934 * dev Structure of device to be opened.
936 * This routine puts the driver and TLAN adapter in a
937 * state where it is ready to send and receive packets.
938 * It allocates the IRQ, resets and brings the adapter
939 * out of reset, and allows interrupts. It also delays
940 * the startup for autonegotiation or sends a Rx GO
941 * command to the adapter, as appropriate.
943 **************************************************************/
945 static int TLan_Open( struct net_device *dev )
947 TLanPrivateInfo *priv = netdev_priv(dev);
950 priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
951 err = request_irq( dev->irq, TLan_HandleInterrupt, IRQF_SHARED,
955 pr_err("TLAN: Cannot open %s because IRQ %d is already in use.\n",
956 dev->name, dev->irq );
960 init_timer(&priv->timer);
961 netif_start_queue(dev);
963 /* NOTE: It might not be necessary to read the stats before a
964 reset if you don't care what the values are.
966 TLan_ResetLists( dev );
967 TLan_ReadAndClearStats( dev, TLAN_IGNORE );
968 TLan_ResetAdapter( dev );
970 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened. TLAN Chip Rev: %x\n",
971 dev->name, priv->tlanRev );
979 /**************************************************************
983 * 0 on success, error code otherwise
985 * dev structure of device to receive ioctl.
987 * rq ifreq structure to hold userspace data.
992 *************************************************************/
994 static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
996 TLanPrivateInfo *priv = netdev_priv(dev);
997 struct mii_ioctl_data *data = if_mii(rq);
998 u32 phy = priv->phy[priv->phyNum];
1000 if (!priv->phyOnline)
1004 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
1008 case SIOCGMIIREG: /* Read MII PHY register. */
1009 TLan_MiiReadReg(dev, data->phy_id & 0x1f,
1010 data->reg_num & 0x1f, &data->val_out);
1014 case SIOCSMIIREG: /* Write MII PHY register. */
1015 if (!capable(CAP_NET_ADMIN))
1017 TLan_MiiWriteReg(dev, data->phy_id & 0x1f,
1018 data->reg_num & 0x1f, data->val_in);
1026 /***************************************************************
1032 * dev structure of device which timed out
1035 **************************************************************/
1037 static void TLan_tx_timeout(struct net_device *dev)
1040 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Transmit timed out.\n", dev->name);
1042 /* Ok so we timed out, lets see what we can do about it...*/
1043 TLan_FreeLists( dev );
1044 TLan_ResetLists( dev );
1045 TLan_ReadAndClearStats( dev, TLAN_IGNORE );
1046 TLan_ResetAdapter( dev );
1047 dev->trans_start = jiffies;
1048 netif_wake_queue( dev );
1053 /***************************************************************
1054 * TLan_tx_timeout_work
1059 * work work item of device which timed out
1061 **************************************************************/
1063 static void TLan_tx_timeout_work(struct work_struct *work)
1065 TLanPrivateInfo *priv =
1066 container_of(work, TLanPrivateInfo, tlan_tqueue);
1068 TLan_tx_timeout(priv->dev);
1073 /***************************************************************
1077 * 0 on success, non-zero on failure.
1079 * skb A pointer to the sk_buff containing the
1081 * dev The device to send the data on.
1083 * This function adds a frame to the Tx list to be sent
1084 * ASAP. First it verifies that the adapter is ready and
1085 * there is room in the queue. Then it sets up the next
1086 * available list, copies the frame to the corresponding
1087 * buffer. If the adapter Tx channel is idle, it gives
1088 * the adapter a Tx Go command on the list, otherwise it
1089 * sets the forward address of the previous list to point
1090 * to this one. Then it frees the sk_buff.
1092 **************************************************************/
1094 static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
1096 TLanPrivateInfo *priv = netdev_priv(dev);
1097 TLanList *tail_list;
1098 dma_addr_t tail_list_phys;
1100 unsigned long flags;
1103 if ( ! priv->phyOnline ) {
1104 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: %s PHY is not ready\n",
1106 dev_kfree_skb_any(skb);
1110 if (skb_padto(skb, TLAN_MIN_FRAME_SIZE))
1112 txlen = max(skb->len, (unsigned int)TLAN_MIN_FRAME_SIZE);
1114 tail_list = priv->txList + priv->txTail;
1115 tail_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txTail;
1117 if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) {
1118 TLAN_DBG( TLAN_DEBUG_TX,
1119 "TRANSMIT: %s is busy (Head=%d Tail=%d)\n",
1120 dev->name, priv->txHead, priv->txTail );
1121 netif_stop_queue(dev);
1122 priv->txBusyCount++;
1126 tail_list->forward = 0;
1129 tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
1130 skb_copy_from_linear_data(skb, tail_buffer, txlen);
1132 tail_list->buffer[0].address = pci_map_single(priv->pciDev,
1135 TLan_StoreSKB(tail_list, skb);
1138 tail_list->frameSize = (u16) txlen;
1139 tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) txlen;
1140 tail_list->buffer[1].count = 0;
1141 tail_list->buffer[1].address = 0;
1143 spin_lock_irqsave(&priv->lock, flags);
1144 tail_list->cStat = TLAN_CSTAT_READY;
1145 if ( ! priv->txInProgress ) {
1146 priv->txInProgress = 1;
1147 TLAN_DBG( TLAN_DEBUG_TX,
1148 "TRANSMIT: Starting TX on buffer %d\n", priv->txTail );
1149 outl( tail_list_phys, dev->base_addr + TLAN_CH_PARM );
1150 outl( TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD );
1152 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Adding buffer %d to TX channel\n",
1154 if ( priv->txTail == 0 ) {
1155 ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward
1158 ( priv->txList + ( priv->txTail - 1 ) )->forward
1162 spin_unlock_irqrestore(&priv->lock, flags);
1164 CIRC_INC( priv->txTail, TLAN_NUM_TX_LISTS );
1167 dev_kfree_skb_any(skb);
1169 dev->trans_start = jiffies;
1172 } /* TLan_StartTx */
1177 /***************************************************************
1178 * TLan_HandleInterrupt
1183 * irq The line on which the interrupt
1185 * dev_id A pointer to the device assigned to
1188 * This function handles an interrupt generated by its
1189 * assigned TLAN adapter. The function deactivates
1190 * interrupts on its adapter, records the type of
1191 * interrupt, executes the appropriate subhandler, and
1192 * acknowdges the interrupt to the adapter (thus
1193 * re-enabling adapter interrupts.
1195 **************************************************************/
1197 static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id)
1199 struct net_device *dev = dev_id;
1200 TLanPrivateInfo *priv = netdev_priv(dev);
1204 spin_lock(&priv->lock);
1206 host_int = inw( dev->base_addr + TLAN_HOST_INT );
1207 type = ( host_int & TLAN_HI_IT_MASK ) >> 2;
1212 outw( host_int, dev->base_addr + TLAN_HOST_INT );
1213 ack = TLanIntVector[type]( dev, host_int );
1216 host_cmd = TLAN_HC_ACK | ack | ( type << 18 );
1217 outl( host_cmd, dev->base_addr + TLAN_HOST_CMD );
1221 spin_unlock(&priv->lock);
1223 return IRQ_RETVAL(type);
1224 } /* TLan_HandleInterrupts */
1229 /***************************************************************
1235 * dev The device structure of the device to
1238 * This function shuts down the adapter. It records any
1239 * stats, puts the adapter into reset state, deactivates
1240 * its time as needed, and frees the irq it is using.
1242 **************************************************************/
1244 static int TLan_Close(struct net_device *dev)
1246 TLanPrivateInfo *priv = netdev_priv(dev);
1248 netif_stop_queue(dev);
1249 priv->neg_be_verbose = 0;
1251 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1252 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1253 if ( priv->timer.function != NULL ) {
1254 del_timer_sync( &priv->timer );
1255 priv->timer.function = NULL;
1258 free_irq( dev->irq, dev );
1259 TLan_FreeLists( dev );
1260 TLAN_DBG( TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name );
1269 /***************************************************************
1273 * A pointer to the device's statistics structure.
1275 * dev The device structure to return the
1278 * This function updates the devices statistics by reading
1279 * the TLAN chip's onboard registers. Then it returns the
1280 * address of the statistics structure.
1282 **************************************************************/
1284 static struct net_device_stats *TLan_GetStats( struct net_device *dev )
1286 TLanPrivateInfo *priv = netdev_priv(dev);
1289 /* Should only read stats if open ? */
1290 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1292 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: %s EOC count = %d\n", dev->name,
1294 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: %s Busy count = %d\n", dev->name,
1295 priv->txBusyCount );
1296 if ( debug & TLAN_DEBUG_GNRL ) {
1297 TLan_PrintDio( dev->base_addr );
1298 TLan_PhyPrint( dev );
1300 if ( debug & TLAN_DEBUG_LIST ) {
1301 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ )
1302 TLan_PrintList( priv->rxList + i, "RX", i );
1303 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ )
1304 TLan_PrintList( priv->txList + i, "TX", i );
1309 } /* TLan_GetStats */
1314 /***************************************************************
1315 * TLan_SetMulticastList
1320 * dev The device structure to set the
1321 * multicast list for.
1323 * This function sets the TLAN adaptor to various receive
1324 * modes. If the IFF_PROMISC flag is set, promiscuous
1325 * mode is acitviated. Otherwise, promiscuous mode is
1326 * turned off. If the IFF_ALLMULTI flag is set, then
1327 * the hash table is set to receive all group addresses.
1328 * Otherwise, the first three multicast addresses are
1329 * stored in AREG_1-3, and the rest are selected via the
1330 * hash table, as necessary.
1332 **************************************************************/
1334 static void TLan_SetMulticastList( struct net_device *dev )
1336 struct dev_mc_list *dmi = dev->mc_list;
1343 if ( dev->flags & IFF_PROMISC ) {
1344 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1345 TLan_DioWrite8( dev->base_addr,
1346 TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF );
1348 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1349 TLan_DioWrite8( dev->base_addr,
1350 TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF );
1351 if ( dev->flags & IFF_ALLMULTI ) {
1352 for ( i = 0; i < 3; i++ )
1353 TLan_SetMac( dev, i + 1, NULL );
1354 TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF );
1355 TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF );
1357 for ( i = 0; i < dev->mc_count; i++ ) {
1359 TLan_SetMac( dev, i + 1,
1360 (char *) &dmi->dmi_addr );
1362 offset = TLan_HashFunc( (u8 *) &dmi->dmi_addr );
1364 hash1 |= ( 1 << offset );
1366 hash2 |= ( 1 << ( offset - 32 ) );
1370 for ( ; i < 3; i++ )
1371 TLan_SetMac( dev, i + 1, NULL );
1372 TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 );
1373 TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 );
1377 } /* TLan_SetMulticastList */
1381 /*****************************************************************************
1382 ******************************************************************************
1384 ThunderLAN Driver Interrupt Vectors and Table
1386 Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN
1387 Programmer's Guide" for more informations on handling interrupts
1388 generated by TLAN based adapters.
1390 ******************************************************************************
1391 *****************************************************************************/
1396 /***************************************************************
1402 * dev Device assigned the IRQ that was
1404 * host_int The contents of the HOST_INT
1407 * This function handles Tx EOF interrupts which are raised
1408 * by the adapter when it has completed sending the
1409 * contents of a buffer. If detemines which list/buffer
1410 * was completed and resets it. If the buffer was the last
1411 * in the channel (EOC), then the function checks to see if
1412 * another buffer is ready to send, and if so, sends a Tx
1413 * Go command. Finally, the driver activates/continues the
1416 **************************************************************/
1418 static u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
1420 TLanPrivateInfo *priv = netdev_priv(dev);
1422 TLanList *head_list;
1423 dma_addr_t head_list_phys;
1427 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Handling TX EOF (Head=%d Tail=%d)\n",
1428 priv->txHead, priv->txTail );
1429 head_list = priv->txList + priv->txHead;
1431 while (((tmpCStat = head_list->cStat ) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1434 struct sk_buff *skb = TLan_GetSKB(head_list);
1435 pci_unmap_single(priv->pciDev, head_list->buffer[0].address,
1436 skb->len, PCI_DMA_TODEVICE);
1437 dev_kfree_skb_any(skb);
1438 head_list->buffer[8].address = 0;
1439 head_list->buffer[9].address = 0;
1442 if ( tmpCStat & TLAN_CSTAT_EOC )
1445 dev->stats.tx_bytes += head_list->frameSize;
1447 head_list->cStat = TLAN_CSTAT_UNUSED;
1448 netif_start_queue(dev);
1449 CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS );
1450 head_list = priv->txList + priv->txHead;
1454 printk(KERN_INFO "TLAN: Received interrupt for uncompleted TX frame.\n");
1457 TLAN_DBG( TLAN_DEBUG_TX,
1458 "TRANSMIT: Handling TX EOC (Head=%d Tail=%d)\n",
1459 priv->txHead, priv->txTail );
1460 head_list = priv->txList + priv->txHead;
1461 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1462 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1463 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1466 priv->txInProgress = 0;
1470 if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1471 TLan_DioWrite8( dev->base_addr,
1472 TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1473 if ( priv->timer.function == NULL ) {
1474 priv->timer.function = &TLan_Timer;
1475 priv->timer.data = (unsigned long) dev;
1476 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1477 priv->timerSetAt = jiffies;
1478 priv->timerType = TLAN_TIMER_ACTIVITY;
1479 add_timer(&priv->timer);
1480 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1481 priv->timerSetAt = jiffies;
1487 } /* TLan_HandleTxEOF */
1492 /***************************************************************
1493 * TLan_HandleStatOverflow
1498 * dev Device assigned the IRQ that was
1500 * host_int The contents of the HOST_INT
1503 * This function handles the Statistics Overflow interrupt
1504 * which means that one or more of the TLAN statistics
1505 * registers has reached 1/2 capacity and needs to be read.
1507 **************************************************************/
1509 static u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
1511 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1515 } /* TLan_HandleStatOverflow */
1520 /***************************************************************
1526 * dev Device assigned the IRQ that was
1528 * host_int The contents of the HOST_INT
1531 * This function handles the Rx EOF interrupt which
1532 * indicates a frame has been received by the adapter from
1533 * the net and the frame has been transferred to memory.
1534 * The function determines the bounce buffer the frame has
1535 * been loaded into, creates a new sk_buff big enough to
1536 * hold the frame, and sends it to protocol stack. It
1537 * then resets the used buffer and appends it to the end
1538 * of the list. If the frame was the last in the Rx
1539 * channel (EOC), the function restarts the receive channel
1540 * by sending an Rx Go command to the adapter. Then it
1541 * activates/continues the activity LED.
1543 **************************************************************/
1545 static u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
1547 TLanPrivateInfo *priv = netdev_priv(dev);
1551 TLanList *head_list;
1552 struct sk_buff *skb;
1553 TLanList *tail_list;
1555 dma_addr_t head_list_phys;
1557 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: Handling RX EOF (Head=%d Tail=%d)\n",
1558 priv->rxHead, priv->rxTail );
1559 head_list = priv->rxList + priv->rxHead;
1560 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1562 while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1563 dma_addr_t frameDma = head_list->buffer[0].address;
1564 u32 frameSize = head_list->frameSize;
1566 if (tmpCStat & TLAN_CSTAT_EOC)
1570 skb = netdev_alloc_skb(dev, frameSize + 7);
1572 goto drop_and_reuse;
1574 head_buffer = priv->rxBuffer
1575 + (priv->rxHead * TLAN_MAX_FRAME_SIZE);
1576 skb_reserve(skb, 2);
1577 pci_dma_sync_single_for_cpu(priv->pciDev,
1578 frameDma, frameSize,
1579 PCI_DMA_FROMDEVICE);
1580 skb_copy_from_linear_data(skb, head_buffer, frameSize);
1581 skb_put(skb, frameSize);
1582 dev->stats.rx_bytes += frameSize;
1584 skb->protocol = eth_type_trans( skb, dev );
1587 struct sk_buff *new_skb;
1589 new_skb = netdev_alloc_skb(dev, TLAN_MAX_FRAME_SIZE + 7 );
1591 goto drop_and_reuse;
1593 skb = TLan_GetSKB(head_list);
1594 pci_unmap_single(priv->pciDev, frameDma,
1595 TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1596 skb_put( skb, frameSize );
1598 dev->stats.rx_bytes += frameSize;
1600 skb->protocol = eth_type_trans( skb, dev );
1603 skb_reserve( new_skb, NET_IP_ALIGN );
1604 head_list->buffer[0].address = pci_map_single(priv->pciDev,
1606 TLAN_MAX_FRAME_SIZE,
1607 PCI_DMA_FROMDEVICE);
1609 TLan_StoreSKB(head_list, new_skb);
1613 head_list->forward = 0;
1614 head_list->cStat = 0;
1615 tail_list = priv->rxList + priv->rxTail;
1616 tail_list->forward = head_list_phys;
1618 CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS );
1619 CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS );
1620 head_list = priv->rxList + priv->rxHead;
1621 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1625 printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.\n");
1629 TLAN_DBG( TLAN_DEBUG_RX,
1630 "RECEIVE: Handling RX EOC (Head=%d Tail=%d)\n",
1631 priv->rxHead, priv->rxTail );
1632 head_list = priv->rxList + priv->rxHead;
1633 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1634 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1635 ack |= TLAN_HC_GO | TLAN_HC_RT;
1639 if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1640 TLan_DioWrite8( dev->base_addr,
1641 TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1642 if ( priv->timer.function == NULL ) {
1643 priv->timer.function = &TLan_Timer;
1644 priv->timer.data = (unsigned long) dev;
1645 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1646 priv->timerSetAt = jiffies;
1647 priv->timerType = TLAN_TIMER_ACTIVITY;
1648 add_timer(&priv->timer);
1649 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1650 priv->timerSetAt = jiffies;
1654 dev->last_rx = jiffies;
1658 } /* TLan_HandleRxEOF */
1663 /***************************************************************
1669 * dev Device assigned the IRQ that was
1671 * host_int The contents of the HOST_INT
1674 * This function handles the Dummy interrupt, which is
1675 * raised whenever a test interrupt is generated by setting
1676 * the Req_Int bit of HOST_CMD to 1.
1678 **************************************************************/
1680 static u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
1682 printk( "TLAN: Test interrupt on %s.\n", dev->name );
1685 } /* TLan_HandleDummy */
1690 /***************************************************************
1696 * dev Device assigned the IRQ that was
1698 * host_int The contents of the HOST_INT
1701 * This driver is structured to determine EOC occurrences by
1702 * reading the CSTAT member of the list structure. Tx EOC
1703 * interrupts are disabled via the DIO INTDIS register.
1704 * However, TLAN chips before revision 3.0 didn't have this
1705 * functionality, so process EOC events if this is the
1708 **************************************************************/
1710 static u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
1712 TLanPrivateInfo *priv = netdev_priv(dev);
1713 TLanList *head_list;
1714 dma_addr_t head_list_phys;
1718 if ( priv->tlanRev < 0x30 ) {
1719 TLAN_DBG( TLAN_DEBUG_TX,
1720 "TRANSMIT: Handling TX EOC (Head=%d Tail=%d) -- IRQ\n",
1721 priv->txHead, priv->txTail );
1722 head_list = priv->txList + priv->txHead;
1723 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1724 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1725 netif_stop_queue(dev);
1726 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1729 priv->txInProgress = 0;
1735 } /* TLan_HandleTxEOC */
1740 /***************************************************************
1741 * TLan_HandleStatusCheck
1744 * 0 if Adapter check, 1 if Network Status check.
1746 * dev Device assigned the IRQ that was
1748 * host_int The contents of the HOST_INT
1751 * This function handles Adapter Check/Network Status
1752 * interrupts generated by the adapter. It checks the
1753 * vector in the HOST_INT register to determine if it is
1754 * an Adapter Check interrupt. If so, it resets the
1755 * adapter. Otherwise it clears the status registers
1756 * and services the PHY.
1758 **************************************************************/
1760 static u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
1762 TLanPrivateInfo *priv = netdev_priv(dev);
1771 if ( host_int & TLAN_HI_IV_MASK ) {
1772 netif_stop_queue( dev );
1773 error = inl( dev->base_addr + TLAN_CH_PARM );
1774 printk( "TLAN: %s: Adaptor Error = 0x%x\n", dev->name, error );
1775 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1776 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1778 schedule_work(&priv->tlan_tqueue);
1780 netif_wake_queue(dev);
1783 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name );
1784 phy = priv->phy[priv->phyNum];
1786 net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS );
1788 TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts );
1789 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Net_Sts = %x\n",
1790 dev->name, (unsigned) net_sts );
1792 if ( ( net_sts & TLAN_NET_STS_MIRQ ) && ( priv->phyNum == 0 ) ) {
1793 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts );
1794 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
1795 if ( ! ( tlphy_sts & TLAN_TS_POLOK ) &&
1796 ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1797 tlphy_ctl |= TLAN_TC_SWAPOL;
1798 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1799 } else if ( ( tlphy_sts & TLAN_TS_POLOK )
1800 && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1801 tlphy_ctl &= ~TLAN_TC_SWAPOL;
1802 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1806 TLan_PhyPrint( dev );
1813 } /* TLan_HandleStatusCheck */
1818 /***************************************************************
1824 * dev Device assigned the IRQ that was
1826 * host_int The contents of the HOST_INT
1829 * This driver is structured to determine EOC occurrences by
1830 * reading the CSTAT member of the list structure. Rx EOC
1831 * interrupts are disabled via the DIO INTDIS register.
1832 * However, TLAN chips before revision 3.0 didn't have this
1833 * CSTAT member or a INTDIS register, so if this chip is
1834 * pre-3.0, process EOC interrupts normally.
1836 **************************************************************/
1838 static u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
1840 TLanPrivateInfo *priv = netdev_priv(dev);
1841 dma_addr_t head_list_phys;
1844 if ( priv->tlanRev < 0x30 ) {
1845 TLAN_DBG( TLAN_DEBUG_RX,
1846 "RECEIVE: Handling RX EOC (Head=%d Tail=%d) -- IRQ\n",
1847 priv->rxHead, priv->rxTail );
1848 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1849 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1850 ack |= TLAN_HC_GO | TLAN_HC_RT;
1856 } /* TLan_HandleRxEOC */
1861 /*****************************************************************************
1862 ******************************************************************************
1864 ThunderLAN Driver Timer Function
1866 ******************************************************************************
1867 *****************************************************************************/
1870 /***************************************************************
1876 * data A value given to add timer when
1877 * add_timer was called.
1879 * This function handles timed functionality for the
1880 * TLAN driver. The two current timer uses are for
1881 * delaying for autonegotionation and driving the ACT LED.
1882 * - Autonegotiation requires being allowed about
1883 * 2 1/2 seconds before attempting to transmit a
1884 * packet. It would be a very bad thing to hang
1885 * the kernel this long, so the driver doesn't
1886 * allow transmission 'til after this time, for
1887 * certain PHYs. It would be much nicer if all
1888 * PHYs were interrupt-capable like the internal
1890 * - The ACT LED, which shows adapter activity, is
1891 * driven by the driver, and so must be left on
1892 * for a short period to power up the LED so it
1893 * can be seen. This delay can be changed by
1894 * changing the TLAN_TIMER_ACT_DELAY in tlan.h,
1895 * if desired. 100 ms produces a slightly
1896 * sluggish response.
1898 **************************************************************/
1900 static void TLan_Timer( unsigned long data )
1902 struct net_device *dev = (struct net_device *) data;
1903 TLanPrivateInfo *priv = netdev_priv(dev);
1905 unsigned long flags = 0;
1907 priv->timer.function = NULL;
1909 switch ( priv->timerType ) {
1911 case TLAN_TIMER_LINK_BEAT:
1912 TLan_PhyMonitor( dev );
1915 case TLAN_TIMER_PHY_PDOWN:
1916 TLan_PhyPowerDown( dev );
1918 case TLAN_TIMER_PHY_PUP:
1919 TLan_PhyPowerUp( dev );
1921 case TLAN_TIMER_PHY_RESET:
1922 TLan_PhyReset( dev );
1924 case TLAN_TIMER_PHY_START_LINK:
1925 TLan_PhyStartLink( dev );
1927 case TLAN_TIMER_PHY_FINISH_AN:
1928 TLan_PhyFinishAutoNeg( dev );
1930 case TLAN_TIMER_FINISH_RESET:
1931 TLan_FinishReset( dev );
1933 case TLAN_TIMER_ACTIVITY:
1934 spin_lock_irqsave(&priv->lock, flags);
1935 if ( priv->timer.function == NULL ) {
1936 elapsed = jiffies - priv->timerSetAt;
1937 if ( elapsed >= TLAN_TIMER_ACT_DELAY ) {
1938 TLan_DioWrite8( dev->base_addr,
1939 TLAN_LED_REG, TLAN_LED_LINK );
1941 priv->timer.function = &TLan_Timer;
1942 priv->timer.expires = priv->timerSetAt
1943 + TLAN_TIMER_ACT_DELAY;
1944 spin_unlock_irqrestore(&priv->lock, flags);
1945 add_timer( &priv->timer );
1949 spin_unlock_irqrestore(&priv->lock, flags);
1960 /*****************************************************************************
1961 ******************************************************************************
1963 ThunderLAN Driver Adapter Related Routines
1965 ******************************************************************************
1966 *****************************************************************************/
1969 /***************************************************************
1975 * dev The device structure with the list
1976 * stuctures to be reset.
1978 * This routine sets the variables associated with managing
1979 * the TLAN lists to their initial values.
1981 **************************************************************/
1983 static void TLan_ResetLists( struct net_device *dev )
1985 TLanPrivateInfo *priv = netdev_priv(dev);
1988 dma_addr_t list_phys;
1989 struct sk_buff *skb;
1993 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
1994 list = priv->txList + i;
1995 list->cStat = TLAN_CSTAT_UNUSED;
1997 list->buffer[0].address = priv->txBufferDMA
1998 + ( i * TLAN_MAX_FRAME_SIZE );
2000 list->buffer[0].address = 0;
2002 list->buffer[2].count = 0;
2003 list->buffer[2].address = 0;
2004 list->buffer[8].address = 0;
2005 list->buffer[9].address = 0;
2009 priv->rxTail = TLAN_NUM_RX_LISTS - 1;
2010 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
2011 list = priv->rxList + i;
2012 list_phys = priv->rxListDMA + sizeof(TLanList) * i;
2013 list->cStat = TLAN_CSTAT_READY;
2014 list->frameSize = TLAN_MAX_FRAME_SIZE;
2015 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
2017 list->buffer[0].address = priv->rxBufferDMA
2018 + ( i * TLAN_MAX_FRAME_SIZE );
2020 skb = netdev_alloc_skb(dev, TLAN_MAX_FRAME_SIZE + 7 );
2022 pr_err("TLAN: out of memory for received data.\n" );
2026 skb_reserve( skb, NET_IP_ALIGN );
2027 list->buffer[0].address = pci_map_single(priv->pciDev,
2029 TLAN_MAX_FRAME_SIZE,
2030 PCI_DMA_FROMDEVICE);
2031 TLan_StoreSKB(list, skb);
2033 list->buffer[1].count = 0;
2034 list->buffer[1].address = 0;
2035 list->forward = list_phys + sizeof(TLanList);
2038 /* in case ran out of memory early, clear bits */
2039 while (i < TLAN_NUM_RX_LISTS) {
2040 TLan_StoreSKB(priv->rxList + i, NULL);
2045 } /* TLan_ResetLists */
2048 static void TLan_FreeLists( struct net_device *dev )
2050 TLanPrivateInfo *priv = netdev_priv(dev);
2053 struct sk_buff *skb;
2056 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
2057 list = priv->txList + i;
2058 skb = TLan_GetSKB(list);
2060 pci_unmap_single(priv->pciDev,
2061 list->buffer[0].address, skb->len,
2063 dev_kfree_skb_any( skb );
2064 list->buffer[8].address = 0;
2065 list->buffer[9].address = 0;
2069 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
2070 list = priv->rxList + i;
2071 skb = TLan_GetSKB(list);
2073 pci_unmap_single(priv->pciDev,
2074 list->buffer[0].address,
2075 TLAN_MAX_FRAME_SIZE,
2076 PCI_DMA_FROMDEVICE);
2077 dev_kfree_skb_any( skb );
2078 list->buffer[8].address = 0;
2079 list->buffer[9].address = 0;
2083 } /* TLan_FreeLists */
2088 /***************************************************************
2094 * io_base Base IO port of the device of
2095 * which to print DIO registers.
2097 * This function prints out all the internal (DIO)
2098 * registers of a TLAN chip.
2100 **************************************************************/
2102 static void TLan_PrintDio( u16 io_base )
2107 printk( "TLAN: Contents of internal registers for io base 0x%04hx.\n",
2109 printk( "TLAN: Off. +0 +4\n" );
2110 for ( i = 0; i < 0x4C; i+= 8 ) {
2111 data0 = TLan_DioRead32( io_base, i );
2112 data1 = TLan_DioRead32( io_base, i + 0x4 );
2113 printk( "TLAN: 0x%02x 0x%08x 0x%08x\n", i, data0, data1 );
2116 } /* TLan_PrintDio */
2121 /***************************************************************
2127 * list A pointer to the TLanList structure to
2129 * type A string to designate type of list,
2131 * num The index of the list.
2133 * This function prints out the contents of the list
2134 * pointed to by the list parameter.
2136 **************************************************************/
2138 static void TLan_PrintList( TLanList *list, char *type, int num)
2142 printk( "TLAN: %s List %d at %p\n", type, num, list );
2143 printk( "TLAN: Forward = 0x%08x\n", list->forward );
2144 printk( "TLAN: CSTAT = 0x%04hx\n", list->cStat );
2145 printk( "TLAN: Frame Size = 0x%04hx\n", list->frameSize );
2146 /* for ( i = 0; i < 10; i++ ) { */
2147 for ( i = 0; i < 2; i++ ) {
2148 printk( "TLAN: Buffer[%d].count, addr = 0x%08x, 0x%08x\n",
2149 i, list->buffer[i].count, list->buffer[i].address );
2152 } /* TLan_PrintList */
2157 /***************************************************************
2158 * TLan_ReadAndClearStats
2163 * dev Pointer to device structure of adapter
2164 * to which to read stats.
2165 * record Flag indicating whether to add
2167 * This functions reads all the internal status registers
2168 * of the TLAN chip, which clears them as a side effect.
2169 * It then either adds the values to the device's status
2170 * struct, or discards them, depending on whether record
2171 * is TLAN_RECORD (!=0) or TLAN_IGNORE (==0).
2173 **************************************************************/
2175 static void TLan_ReadAndClearStats( struct net_device *dev, int record )
2177 u32 tx_good, tx_under;
2178 u32 rx_good, rx_over;
2179 u32 def_tx, crc, code;
2180 u32 multi_col, single_col;
2181 u32 excess_col, late_col, loss;
2183 outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2184 tx_good = inb( dev->base_addr + TLAN_DIO_DATA );
2185 tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2186 tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2187 tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2189 outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2190 rx_good = inb( dev->base_addr + TLAN_DIO_DATA );
2191 rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2192 rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2193 rx_over = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2195 outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
2196 def_tx = inb( dev->base_addr + TLAN_DIO_DATA );
2197 def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2198 crc = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2199 code = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2201 outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2202 multi_col = inb( dev->base_addr + TLAN_DIO_DATA );
2203 multi_col += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2204 single_col = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2205 single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8;
2207 outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2208 excess_col = inb( dev->base_addr + TLAN_DIO_DATA );
2209 late_col = inb( dev->base_addr + TLAN_DIO_DATA + 1 );
2210 loss = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2213 dev->stats.rx_packets += rx_good;
2214 dev->stats.rx_errors += rx_over + crc + code;
2215 dev->stats.tx_packets += tx_good;
2216 dev->stats.tx_errors += tx_under + loss;
2217 dev->stats.collisions += multi_col + single_col + excess_col + late_col;
2219 dev->stats.rx_over_errors += rx_over;
2220 dev->stats.rx_crc_errors += crc;
2221 dev->stats.rx_frame_errors += code;
2223 dev->stats.tx_aborted_errors += tx_under;
2224 dev->stats.tx_carrier_errors += loss;
2227 } /* TLan_ReadAndClearStats */
2232 /***************************************************************
2238 * dev Pointer to device structure of adapter
2241 * This function resets the adapter and it's physical
2242 * device. See Chap. 3, pp. 9-10 of the "ThunderLAN
2243 * Programmer's Guide" for details. The routine tries to
2244 * implement what is detailed there, though adjustments
2247 **************************************************************/
2250 TLan_ResetAdapter( struct net_device *dev )
2252 TLanPrivateInfo *priv = netdev_priv(dev);
2258 priv->tlanFullDuplex = FALSE;
2260 netif_carrier_off(dev);
2262 /* 1. Assert reset bit. */
2264 data = inl(dev->base_addr + TLAN_HOST_CMD);
2265 data |= TLAN_HC_AD_RST;
2266 outl(data, dev->base_addr + TLAN_HOST_CMD);
2270 /* 2. Turn off interrupts. ( Probably isn't necessary ) */
2272 data = inl(dev->base_addr + TLAN_HOST_CMD);
2273 data |= TLAN_HC_INT_OFF;
2274 outl(data, dev->base_addr + TLAN_HOST_CMD);
2276 /* 3. Clear AREGs and HASHs. */
2278 for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) {
2279 TLan_DioWrite32( dev->base_addr, (u16) i, 0 );
2282 /* 4. Setup NetConfig register. */
2284 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2285 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2287 /* 5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2289 outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD );
2290 outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD );
2292 /* 6. Unreset the MII by setting NMRST (in NetSio) to 1. */
2294 outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR );
2295 addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2296 TLan_SetBit( TLAN_NET_SIO_NMRST, addr );
2298 /* 7. Setup the remaining registers. */
2300 if ( priv->tlanRev >= 0x30 ) {
2301 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
2302 TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 );
2304 TLan_PhyDetect( dev );
2305 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
2307 if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
2308 data |= TLAN_NET_CFG_BIT;
2309 if ( priv->aui == 1 ) {
2310 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a );
2311 } else if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2312 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 );
2313 priv->tlanFullDuplex = TRUE;
2315 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 );
2319 if ( priv->phyNum == 0 ) {
2320 data |= TLAN_NET_CFG_PHY_EN;
2322 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2324 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2325 TLan_FinishReset( dev );
2327 TLan_PhyPowerDown( dev );
2330 } /* TLan_ResetAdapter */
2336 TLan_FinishReset( struct net_device *dev )
2338 TLanPrivateInfo *priv = netdev_priv(dev);
2346 u16 tlphy_id1, tlphy_id2;
2349 phy = priv->phy[priv->phyNum];
2351 data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
2352 if ( priv->tlanFullDuplex ) {
2353 data |= TLAN_NET_CMD_DUPLEX;
2355 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
2356 data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
2357 if ( priv->phyNum == 0 ) {
2358 data |= TLAN_NET_MASK_MASK7;
2360 TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
2361 TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
2362 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
2363 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
2365 if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) ||
2367 status = MII_GS_LINK;
2368 printk( "TLAN: %s: Link forced.\n", dev->name );
2370 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2372 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2373 if ( (status & MII_GS_LINK) &&
2374 /* We only support link info on Nat.Sem. PHY's */
2375 (tlphy_id1 == NAT_SEM_ID1) &&
2376 (tlphy_id2 == NAT_SEM_ID2) ) {
2377 TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
2378 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
2380 printk( "TLAN: %s: Link active with ", dev->name );
2381 if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
2382 printk( "forced 10%sMbps %s-Duplex\n",
2383 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2384 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2386 printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
2387 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2388 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2389 printk("TLAN: Partner capability: ");
2390 for (i = 5; i <= 10; i++)
2391 if (partner & (1<<i))
2392 printk("%s",media[i-5]);
2396 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2398 /* We have link beat..for now anyway */
2400 /*Enabling link beat monitoring */
2401 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
2403 } else if (status & MII_GS_LINK) {
2404 printk( "TLAN: %s: Link active\n", dev->name );
2405 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2409 if ( priv->phyNum == 0 ) {
2410 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
2411 tlphy_ctl |= TLAN_TC_INTEN;
2412 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl );
2413 sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO );
2414 sio |= TLAN_NET_SIO_MINTEN;
2415 TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio );
2418 if ( status & MII_GS_LINK ) {
2419 TLan_SetMac( dev, 0, dev->dev_addr );
2420 priv->phyOnline = 1;
2421 outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2422 if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
2423 outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2425 outl( priv->rxListDMA, dev->base_addr + TLAN_CH_PARM );
2426 outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
2427 netif_carrier_on(dev);
2429 printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n",
2431 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
2434 TLan_SetMulticastList(dev);
2436 } /* TLan_FinishReset */
2441 /***************************************************************
2447 * dev Pointer to device structure of adapter
2448 * on which to change the AREG.
2449 * areg The AREG to set the address in (0 - 3).
2450 * mac A pointer to an array of chars. Each
2451 * element stores one byte of the address.
2452 * IE, it isn't in ascii.
2454 * This function transfers a MAC address to one of the
2455 * TLAN AREGs (address registers). The TLAN chip locks
2456 * the register on writing to offset 0 and unlocks the
2457 * register after writing to offset 5. If NULL is passed
2458 * in mac, then the AREG is filled with 0's.
2460 **************************************************************/
2462 static void TLan_SetMac( struct net_device *dev, int areg, char *mac )
2468 if ( mac != NULL ) {
2469 for ( i = 0; i < 6; i++ )
2470 TLan_DioWrite8( dev->base_addr,
2471 TLAN_AREG_0 + areg + i, mac[i] );
2473 for ( i = 0; i < 6; i++ )
2474 TLan_DioWrite8( dev->base_addr,
2475 TLAN_AREG_0 + areg + i, 0 );
2483 /*****************************************************************************
2484 ******************************************************************************
2486 ThunderLAN Driver PHY Layer Routines
2488 ******************************************************************************
2489 *****************************************************************************/
2493 /*********************************************************************
2499 * dev A pointer to the device structure of the
2500 * TLAN device having the PHYs to be detailed.
2502 * This function prints the registers a PHY (aka transceiver).
2504 ********************************************************************/
2506 static void TLan_PhyPrint( struct net_device *dev )
2508 TLanPrivateInfo *priv = netdev_priv(dev);
2509 u16 i, data0, data1, data2, data3, phy;
2511 phy = priv->phy[priv->phyNum];
2513 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2514 printk( "TLAN: Device %s, Unmanaged PHY.\n", dev->name );
2515 } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
2516 printk( "TLAN: Device %s, PHY 0x%02x.\n", dev->name, phy );
2517 printk( "TLAN: Off. +0 +1 +2 +3 \n" );
2518 for ( i = 0; i < 0x20; i+= 4 ) {
2519 printk( "TLAN: 0x%02x", i );
2520 TLan_MiiReadReg( dev, phy, i, &data0 );
2521 printk( " 0x%04hx", data0 );
2522 TLan_MiiReadReg( dev, phy, i + 1, &data1 );
2523 printk( " 0x%04hx", data1 );
2524 TLan_MiiReadReg( dev, phy, i + 2, &data2 );
2525 printk( " 0x%04hx", data2 );
2526 TLan_MiiReadReg( dev, phy, i + 3, &data3 );
2527 printk( " 0x%04hx\n", data3 );
2530 printk( "TLAN: Device %s, Invalid PHY.\n", dev->name );
2533 } /* TLan_PhyPrint */
2538 /*********************************************************************
2544 * dev A pointer to the device structure of the adapter
2545 * for which the PHY needs determined.
2547 * So far I've found that adapters which have external PHYs
2548 * may also use the internal PHY for part of the functionality.
2549 * (eg, AUI/Thinnet). This function finds out if this TLAN
2550 * chip has an internal PHY, and then finds the first external
2551 * PHY (starting from address 0) if it exists).
2553 ********************************************************************/
2555 static void TLan_PhyDetect( struct net_device *dev )
2557 TLanPrivateInfo *priv = netdev_priv(dev);
2563 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2564 priv->phyNum = 0xFFFF;
2568 TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
2570 if ( hi != 0xFFFF ) {
2571 priv->phy[0] = TLAN_PHY_MAX_ADDR;
2573 priv->phy[0] = TLAN_PHY_NONE;
2576 priv->phy[1] = TLAN_PHY_NONE;
2577 for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) {
2578 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
2579 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
2580 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
2581 if ( ( control != 0xFFFF ) ||
2582 ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
2583 TLAN_DBG( TLAN_DEBUG_GNRL,
2584 "PHY found at %02x %04x %04x %04x\n",
2585 phy, control, hi, lo );
2586 if ( ( priv->phy[1] == TLAN_PHY_NONE ) &&
2587 ( phy != TLAN_PHY_MAX_ADDR ) ) {
2593 if ( priv->phy[1] != TLAN_PHY_NONE ) {
2595 } else if ( priv->phy[0] != TLAN_PHY_NONE ) {
2598 printk( "TLAN: Cannot initialize device, no PHY was found!\n" );
2601 } /* TLan_PhyDetect */
2606 static void TLan_PhyPowerDown( struct net_device *dev )
2608 TLanPrivateInfo *priv = netdev_priv(dev);
2611 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name );
2612 value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
2613 TLan_MiiSync( dev->base_addr );
2614 TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2615 if ( ( priv->phyNum == 0 ) &&
2616 ( priv->phy[1] != TLAN_PHY_NONE ) &&
2617 ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
2618 TLan_MiiSync( dev->base_addr );
2619 TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
2622 /* Wait for 50 ms and powerup
2623 * This is abitrary. It is intended to make sure the
2624 * transceiver settles.
2626 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP );
2628 } /* TLan_PhyPowerDown */
2633 static void TLan_PhyPowerUp( struct net_device *dev )
2635 TLanPrivateInfo *priv = netdev_priv(dev);
2638 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name );
2639 TLan_MiiSync( dev->base_addr );
2640 value = MII_GC_LOOPBK;
2641 TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2642 TLan_MiiSync(dev->base_addr);
2643 /* Wait for 500 ms and reset the
2644 * transceiver. The TLAN docs say both 50 ms and
2645 * 500 ms, so do the longer, just in case.
2647 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET );
2649 } /* TLan_PhyPowerUp */
2654 static void TLan_PhyReset( struct net_device *dev )
2656 TLanPrivateInfo *priv = netdev_priv(dev);
2660 phy = priv->phy[priv->phyNum];
2662 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name );
2663 TLan_MiiSync( dev->base_addr );
2664 value = MII_GC_LOOPBK | MII_GC_RESET;
2665 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value );
2666 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2667 while ( value & MII_GC_RESET ) {
2668 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2671 /* Wait for 500 ms and initialize.
2672 * I don't remember why I wait this long.
2673 * I've changed this to 50ms, as it seems long enough.
2675 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK );
2677 } /* TLan_PhyReset */
2682 static void TLan_PhyStartLink( struct net_device *dev )
2684 TLanPrivateInfo *priv = netdev_priv(dev);
2692 phy = priv->phy[priv->phyNum];
2693 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name );
2694 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2695 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
2697 if ( ( status & MII_GS_AUTONEG ) &&
2699 ability = status >> 11;
2700 if ( priv->speed == TLAN_SPEED_10 &&
2701 priv->duplex == TLAN_DUPLEX_HALF) {
2702 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
2703 } else if ( priv->speed == TLAN_SPEED_10 &&
2704 priv->duplex == TLAN_DUPLEX_FULL) {
2705 priv->tlanFullDuplex = TRUE;
2706 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100);
2707 } else if ( priv->speed == TLAN_SPEED_100 &&
2708 priv->duplex == TLAN_DUPLEX_HALF) {
2709 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000);
2710 } else if ( priv->speed == TLAN_SPEED_100 &&
2711 priv->duplex == TLAN_DUPLEX_FULL) {
2712 priv->tlanFullDuplex = TRUE;
2713 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
2716 /* Set Auto-Neg advertisement */
2717 TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
2718 /* Enablee Auto-Neg */
2719 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 );
2720 /* Restart Auto-Neg */
2721 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 );
2722 /* Wait for 4 sec for autonegotiation
2723 * to complete. The max spec time is less than this
2724 * but the card need additional time to start AN.
2725 * .5 sec should be plenty extra.
2727 printk( "TLAN: %s: Starting autonegotiation.\n", dev->name );
2728 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
2734 if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
2736 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2737 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2738 TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2740 } else if ( priv->phyNum == 0 ) {
2742 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
2744 tctl |= TLAN_TC_AUISEL;
2746 tctl &= ~TLAN_TC_AUISEL;
2747 if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2748 control |= MII_GC_DUPLEX;
2749 priv->tlanFullDuplex = TRUE;
2751 if ( priv->speed == TLAN_SPEED_100 ) {
2752 control |= MII_GC_SPEEDSEL;
2755 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control );
2756 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl );
2759 /* Wait for 2 sec to give the transceiver time
2760 * to establish link.
2762 TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET );
2764 } /* TLan_PhyStartLink */
2769 static void TLan_PhyFinishAutoNeg( struct net_device *dev )
2771 TLanPrivateInfo *priv = netdev_priv(dev);
2779 phy = priv->phy[priv->phyNum];
2781 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2783 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2785 if ( ! ( status & MII_GS_AUTOCMPLT ) ) {
2786 /* Wait for 8 sec to give the process
2787 * more time. Perhaps we should fail after a while.
2789 if (!priv->neg_be_verbose++) {
2790 pr_info("TLAN: Giving autonegotiation more time.\n");
2791 pr_info("TLAN: Please check that your adapter has\n");
2792 pr_info("TLAN: been properly connected to a HUB or Switch.\n");
2793 pr_info("TLAN: Trying to establish link in the background...\n");
2795 TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
2799 printk( "TLAN: %s: Autonegotiation complete.\n", dev->name );
2800 TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv );
2801 TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa );
2802 mode = an_adv & an_lpa & 0x03E0;
2803 if ( mode & 0x0100 ) {
2804 priv->tlanFullDuplex = TRUE;
2805 } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) {
2806 priv->tlanFullDuplex = TRUE;
2809 if ( ( ! ( mode & 0x0180 ) ) &&
2810 ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) &&
2811 ( priv->phyNum != 0 ) ) {
2813 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2814 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2815 TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2819 if ( priv->phyNum == 0 ) {
2820 if ( ( priv->duplex == TLAN_DUPLEX_FULL ) ||
2821 ( an_adv & an_lpa & 0x0040 ) ) {
2822 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL,
2823 MII_GC_AUTOENB | MII_GC_DUPLEX );
2824 pr_info("TLAN: Starting internal PHY with FULL-DUPLEX\n" );
2826 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
2827 pr_info( "TLAN: Starting internal PHY with HALF-DUPLEX\n" );
2831 /* Wait for 100 ms. No reason in partiticular.
2833 TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
2835 } /* TLan_PhyFinishAutoNeg */
2839 /*********************************************************************
2847 * dev The device structure of this device.
2850 * This function monitors PHY condition by reading the status
2851 * register via the MII bus. This can be used to give info
2852 * about link changes (up/down), and possible switch to alternate
2855 * ******************************************************************/
2857 void TLan_PhyMonitor( struct net_device *dev )
2859 TLanPrivateInfo *priv = netdev_priv(dev);
2863 phy = priv->phy[priv->phyNum];
2865 /* Get PHY status register */
2866 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
2868 /* Check if link has been lost */
2869 if (!(phy_status & MII_GS_LINK)) {
2872 printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name);
2873 netif_carrier_off(dev);
2874 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2879 /* Link restablished? */
2880 if ((phy_status & MII_GS_LINK) && !priv->link) {
2882 printk(KERN_DEBUG "TLAN: %s has reestablished link\n", dev->name);
2883 netif_carrier_on(dev);
2886 /* Setup a new monitor */
2887 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2890 #endif /* MONITOR */
2893 /*****************************************************************************
2894 ******************************************************************************
2896 ThunderLAN Driver MII Routines
2898 These routines are based on the information in Chap. 2 of the
2899 "ThunderLAN Programmer's Guide", pp. 15-24.
2901 ******************************************************************************
2902 *****************************************************************************/
2905 /***************************************************************
2909 * 0 if ack received ok
2913 * dev The device structure containing
2914 * The io address and interrupt count
2916 * phy The address of the PHY to be queried.
2917 * reg The register whose contents are to be
2919 * val A pointer to a variable to store the
2922 * This function uses the TLAN's MII bus to retrieve the contents
2923 * of a given register on a PHY. It sends the appropriate info
2924 * and then reads the 16-bit register value from the MII bus via
2925 * the TLAN SIO register.
2927 **************************************************************/
2929 static int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
2936 TLanPrivateInfo *priv = netdev_priv(dev);
2937 unsigned long flags = 0;
2940 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2941 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2944 spin_lock_irqsave(&priv->lock, flags);
2946 TLan_MiiSync(dev->base_addr);
2948 minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
2950 TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);
2952 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */
2953 TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Read ( 10b ) */
2954 TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */
2955 TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */
2958 TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio); /* Change direction */
2960 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Clock Idle bit */
2961 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2962 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Wait 300ns */
2964 nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio); /* Check for ACK */
2965 TLan_SetBit(TLAN_NET_SIO_MCLK, sio); /* Finish ACK */
2966 if (nack) { /* No ACK, so fake it */
2967 for (i = 0; i < 16; i++) {
2968 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2969 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2973 } else { /* ACK, so read data */
2974 for (tmp = 0, i = 0x8000; i; i >>= 1) {
2975 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2976 if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
2978 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2983 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Idle cycle */
2984 TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2987 TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
2992 spin_unlock_irqrestore(&priv->lock, flags);
2996 } /* TLan_MiiReadReg */
3001 /***************************************************************
3007 * base_port The base IO port of the adapter in
3009 * dev The address of the PHY to be queried.
3010 * data The value to be placed on the MII bus.
3011 * num_bits The number of bits in data that are to
3012 * be placed on the MII bus.
3014 * This function sends on sequence of bits on the MII
3015 * configuration bus.
3017 **************************************************************/
3019 static void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
3024 if ( num_bits == 0 )
3027 outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
3028 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3029 TLan_SetBit( TLAN_NET_SIO_MTXEN, sio );
3031 for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) {
3032 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3033 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
3035 TLan_SetBit( TLAN_NET_SIO_MDATA, sio );
3037 TLan_ClearBit( TLAN_NET_SIO_MDATA, sio );
3038 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3039 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
3042 } /* TLan_MiiSendData */
3047 /***************************************************************
3053 * base_port The base IO port of the adapter in
3056 * This functions syncs all PHYs in terms of the MII configuration
3059 **************************************************************/
3061 static void TLan_MiiSync( u16 base_port )
3066 outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
3067 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3069 TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio );
3070 for ( i = 0; i < 32; i++ ) {
3071 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3072 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3075 } /* TLan_MiiSync */
3080 /***************************************************************
3086 * dev The device structure for the device
3088 * phy The address of the PHY to be written to.
3089 * reg The register whose contents are to be
3091 * val The value to be written to the register.
3093 * This function uses the TLAN's MII bus to write the contents of a
3094 * given register on a PHY. It sends the appropriate info and then
3095 * writes the 16-bit register value from the MII configuration bus
3096 * via the TLAN SIO register.
3098 **************************************************************/
3100 static void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
3104 unsigned long flags = 0;
3105 TLanPrivateInfo *priv = netdev_priv(dev);
3107 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3108 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
3111 spin_lock_irqsave(&priv->lock, flags);
3113 TLan_MiiSync( dev->base_addr );
3115 minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
3117 TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio );
3119 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */
3120 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Write ( 01b ) */
3121 TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */
3122 TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */
3124 TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Send ACK */
3125 TLan_MiiSendData( dev->base_addr, val, 16 ); /* Send Data */
3127 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); /* Idle cycle */
3128 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3131 TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
3134 spin_unlock_irqrestore(&priv->lock, flags);
3136 } /* TLan_MiiWriteReg */
3141 /*****************************************************************************
3142 ******************************************************************************
3144 ThunderLAN Driver Eeprom routines
3146 The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A
3147 EEPROM. These functions are based on information in Microchip's
3148 data sheet. I don't know how well this functions will work with
3151 ******************************************************************************
3152 *****************************************************************************/
3155 /***************************************************************
3161 * io_base The IO port base address for the
3162 * TLAN device with the EEPROM to
3165 * This function sends a start cycle to an EEPROM attached
3168 **************************************************************/
3170 static void TLan_EeSendStart( u16 io_base )
3174 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3175 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3177 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3178 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3179 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3180 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3181 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3183 } /* TLan_EeSendStart */
3188 /***************************************************************
3192 * If the correct ack was received, 0, otherwise 1
3193 * Parms: io_base The IO port base address for the
3194 * TLAN device with the EEPROM to
3196 * data The 8 bits of information to
3197 * send to the EEPROM.
3198 * stop If TLAN_EEPROM_STOP is passed, a
3199 * stop cycle is sent after the
3200 * byte is sent after the ack is
3203 * This function sends a byte on the serial EEPROM line,
3204 * driving the clock to send each bit. The function then
3205 * reverses transmission direction and reads an acknowledge
3208 **************************************************************/
3210 static int TLan_EeSendByte( u16 io_base, u8 data, int stop )
3216 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3217 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3219 /* Assume clock is low, tx is enabled; */
3220 for ( place = 0x80; place != 0; place >>= 1 ) {
3222 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3224 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3225 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3226 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3228 TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3229 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3230 err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio );
3231 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3232 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3234 if ( ( ! err ) && stop ) {
3235 /* STOP, raise data while clock is high */
3236 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3237 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3238 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3243 } /* TLan_EeSendByte */
3248 /***************************************************************
3249 * TLan_EeReceiveByte
3254 * io_base The IO port base address for the
3255 * TLAN device with the EEPROM to
3257 * data An address to a char to hold the
3258 * data sent from the EEPROM.
3259 * stop If TLAN_EEPROM_STOP is passed, a
3260 * stop cycle is sent after the
3261 * byte is received, and no ack is
3264 * This function receives 8 bits of data from the EEPROM
3265 * over the serial link. It then sends and ack bit, or no
3266 * ack and a stop bit. This function is used to retrieve
3267 * data after the address of a byte in the EEPROM has been
3270 **************************************************************/
3272 static void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
3277 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3278 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3281 /* Assume clock is low, tx is enabled; */
3282 TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3283 for ( place = 0x80; place; place >>= 1 ) {
3284 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3285 if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) )
3287 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3290 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3292 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* Ack = 0 */
3293 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3294 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3296 TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); /* No ack = 1 (?) */
3297 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3298 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3299 /* STOP, raise data while clock is high */
3300 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3301 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3302 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3305 } /* TLan_EeReceiveByte */
3310 /***************************************************************
3314 * No error = 0, else, the stage at which the error
3317 * io_base The IO port base address for the
3318 * TLAN device with the EEPROM to
3320 * ee_addr The address of the byte in the
3321 * EEPROM whose contents are to be
3323 * data An address to a char to hold the
3324 * data obtained from the EEPROM.
3326 * This function reads a byte of information from an byte
3327 * cell in the EEPROM.
3329 **************************************************************/
3331 static int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
3334 TLanPrivateInfo *priv = netdev_priv(dev);
3335 unsigned long flags = 0;
3338 spin_lock_irqsave(&priv->lock, flags);
3340 TLan_EeSendStart( dev->base_addr );
3341 err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK );
3347 err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK );
3353 TLan_EeSendStart( dev->base_addr );
3354 err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK );
3360 TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP );
3362 spin_unlock_irqrestore(&priv->lock, flags);
3366 } /* TLan_EeReadByte */