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