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