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