开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
tlan.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：92k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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