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