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