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