/drivers/net/ethernet/hp/hp100.c

http://github.com/mirrors/linux · C · 3051 lines · 2052 code · 449 blank · 550 comment · 439 complexity · b901a00119206b4fadfbd29636fa37ae MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. ** hp100.c
  3. ** HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters
  4. **
  5. ** $Id: hp100.c,v 1.58 2001/09/24 18:03:01 perex Exp perex $
  6. **
  7. ** Based on the HP100 driver written by Jaroslav Kysela <perex@jcu.cz>
  8. ** Extended for new busmaster capable chipsets by
  9. ** Siegfried "Frieder" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>
  10. **
  11. ** Maintained by: Jaroslav Kysela <perex@perex.cz>
  12. **
  13. ** This driver has only been tested with
  14. ** -- HP J2585B 10/100 Mbit/s PCI Busmaster
  15. ** -- HP J2585A 10/100 Mbit/s PCI
  16. ** -- HP J2970A 10 Mbit/s PCI Combo 10base-T/BNC
  17. ** -- HP J2973A 10 Mbit/s PCI 10base-T
  18. ** -- HP J2573 10/100 ISA
  19. ** -- Compex ReadyLink ENET100-VG4 10/100 Mbit/s PCI / EISA
  20. ** -- Compex FreedomLine 100/VG 10/100 Mbit/s ISA / EISA / PCI
  21. **
  22. ** but it should also work with the other CASCADE based adapters.
  23. **
  24. ** TODO:
  25. ** - J2573 seems to hang sometimes when in shared memory mode.
  26. ** - Mode for Priority TX
  27. ** - Check PCI registers, performance might be improved?
  28. ** - To reduce interrupt load in busmaster, one could switch off
  29. ** the interrupts that are used to refill the queues whenever the
  30. ** queues are filled up to more than a certain threshold.
  31. ** - some updates for EISA version of card
  32. **
  33. **
  34. ** This code is free software; you can redistribute it and/or modify
  35. ** it under the terms of the GNU General Public License as published by
  36. ** the Free Software Foundation; either version 2 of the License, or
  37. ** (at your option) any later version.
  38. **
  39. ** This code is distributed in the hope that it will be useful,
  40. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  41. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  42. ** GNU General Public License for more details.
  43. **
  44. ** You should have received a copy of the GNU General Public License
  45. ** along with this program; if not, write to the Free Software
  46. ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  47. **
  48. ** 1.57c -> 1.58
  49. ** - used indent to change coding-style
  50. ** - added KTI DP-200 EISA ID
  51. ** - ioremap is also used for low (<1MB) memory (multi-architecture support)
  52. **
  53. ** 1.57b -> 1.57c - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  54. ** - release resources on failure in init_module
  55. **
  56. ** 1.57 -> 1.57b - Jean II
  57. ** - fix spinlocks, SMP is now working !
  58. **
  59. ** 1.56 -> 1.57
  60. ** - updates for new PCI interface for 2.1 kernels
  61. **
  62. ** 1.55 -> 1.56
  63. ** - removed printk in misc. interrupt and update statistics to allow
  64. ** monitoring of card status
  65. ** - timing changes in xmit routines, relogin to 100VG hub added when
  66. ** driver does reset
  67. ** - included fix for Compex FreedomLine PCI adapter
  68. **
  69. ** 1.54 -> 1.55
  70. ** - fixed bad initialization in init_module
  71. ** - added Compex FreedomLine adapter
  72. ** - some fixes in card initialization
  73. **
  74. ** 1.53 -> 1.54
  75. ** - added hardware multicast filter support (doesn't work)
  76. ** - little changes in hp100_sense_lan routine
  77. ** - added support for Coax and AUI (J2970)
  78. ** - fix for multiple cards and hp100_mode parameter (insmod)
  79. ** - fix for shared IRQ
  80. **
  81. ** 1.52 -> 1.53
  82. ** - fixed bug in multicast support
  83. **
  84. */
  85. #define HP100_DEFAULT_PRIORITY_TX 0
  86. #undef HP100_DEBUG
  87. #undef HP100_DEBUG_B /* Trace */
  88. #undef HP100_DEBUG_BM /* Debug busmaster code (PDL stuff) */
  89. #undef HP100_DEBUG_TRAINING /* Debug login-to-hub procedure */
  90. #undef HP100_DEBUG_TX
  91. #undef HP100_DEBUG_IRQ
  92. #undef HP100_DEBUG_RX
  93. #undef HP100_MULTICAST_FILTER /* Need to be debugged... */
  94. #include <linux/module.h>
  95. #include <linux/kernel.h>
  96. #include <linux/sched.h>
  97. #include <linux/string.h>
  98. #include <linux/errno.h>
  99. #include <linux/ioport.h>
  100. #include <linux/interrupt.h>
  101. #include <linux/eisa.h>
  102. #include <linux/pci.h>
  103. #include <linux/dma-mapping.h>
  104. #include <linux/spinlock.h>
  105. #include <linux/netdevice.h>
  106. #include <linux/etherdevice.h>
  107. #include <linux/skbuff.h>
  108. #include <linux/types.h>
  109. #include <linux/delay.h>
  110. #include <linux/init.h>
  111. #include <linux/bitops.h>
  112. #include <linux/jiffies.h>
  113. #include <asm/io.h>
  114. #include "hp100.h"
  115. /*
  116. * defines
  117. */
  118. #define HP100_BUS_ISA 0
  119. #define HP100_BUS_EISA 1
  120. #define HP100_BUS_PCI 2
  121. #define HP100_REGION_SIZE 0x20 /* for ioports */
  122. #define HP100_SIG_LEN 8 /* same as EISA_SIG_LEN */
  123. #define HP100_MAX_PACKET_SIZE (1536+4)
  124. #define HP100_MIN_PACKET_SIZE 60
  125. #ifndef HP100_DEFAULT_RX_RATIO
  126. /* default - 75% onboard memory on the card are used for RX packets */
  127. #define HP100_DEFAULT_RX_RATIO 75
  128. #endif
  129. #ifndef HP100_DEFAULT_PRIORITY_TX
  130. /* default - don't enable transmit outgoing packets as priority */
  131. #define HP100_DEFAULT_PRIORITY_TX 0
  132. #endif
  133. /*
  134. * structures
  135. */
  136. struct hp100_private {
  137. spinlock_t lock;
  138. char id[HP100_SIG_LEN];
  139. u_short chip;
  140. u_short soft_model;
  141. u_int memory_size;
  142. u_int virt_memory_size;
  143. u_short rx_ratio; /* 1 - 99 */
  144. u_short priority_tx; /* != 0 - priority tx */
  145. u_short mode; /* PIO, Shared Mem or Busmaster */
  146. u_char bus;
  147. struct pci_dev *pci_dev;
  148. short mem_mapped; /* memory mapped access */
  149. void __iomem *mem_ptr_virt; /* virtual memory mapped area, maybe NULL */
  150. unsigned long mem_ptr_phys; /* physical memory mapped area */
  151. short lan_type; /* 10Mb/s, 100Mb/s or -1 (error) */
  152. int hub_status; /* was login to hub successful? */
  153. u_char mac1_mode;
  154. u_char mac2_mode;
  155. u_char hash_bytes[8];
  156. /* Rings for busmaster mode: */
  157. hp100_ring_t *rxrhead; /* Head (oldest) index into rxring */
  158. hp100_ring_t *rxrtail; /* Tail (newest) index into rxring */
  159. hp100_ring_t *txrhead; /* Head (oldest) index into txring */
  160. hp100_ring_t *txrtail; /* Tail (newest) index into txring */
  161. hp100_ring_t rxring[MAX_RX_PDL];
  162. hp100_ring_t txring[MAX_TX_PDL];
  163. u_int *page_vaddr_algn; /* Aligned virtual address of allocated page */
  164. u_long whatever_offset; /* Offset to bus/phys/dma address */
  165. int rxrcommit; /* # Rx PDLs committed to adapter */
  166. int txrcommit; /* # Tx PDLs committed to adapter */
  167. };
  168. /*
  169. * variables
  170. */
  171. #ifdef CONFIG_ISA
  172. static const char *hp100_isa_tbl[] = {
  173. "HWPF150", /* HP J2573 rev A */
  174. "HWP1950", /* HP J2573 */
  175. };
  176. #endif
  177. static struct eisa_device_id hp100_eisa_tbl[] = {
  178. { "HWPF180" }, /* HP J2577 rev A */
  179. { "HWP1920" }, /* HP 27248B */
  180. { "HWP1940" }, /* HP J2577 */
  181. { "HWP1990" }, /* HP J2577 */
  182. { "CPX0301" }, /* ReadyLink ENET100-VG4 */
  183. { "CPX0401" }, /* FreedomLine 100/VG */
  184. { "" } /* Mandatory final entry ! */
  185. };
  186. MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
  187. static const struct pci_device_id hp100_pci_tbl[] = {
  188. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,},
  189. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,},
  190. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2970A, PCI_ANY_ID, PCI_ANY_ID,},
  191. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2973A, PCI_ANY_ID, PCI_ANY_ID,},
  192. {PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_ENET100VG4, PCI_ANY_ID, PCI_ANY_ID,},
  193. {PCI_VENDOR_ID_COMPEX2, PCI_DEVICE_ID_COMPEX2_100VG, PCI_ANY_ID, PCI_ANY_ID,},
  194. /* {PCI_VENDOR_ID_KTI, PCI_DEVICE_ID_KTI_DP200, PCI_ANY_ID, PCI_ANY_ID }, */
  195. {} /* Terminating entry */
  196. };
  197. MODULE_DEVICE_TABLE(pci, hp100_pci_tbl);
  198. static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
  199. static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
  200. static int hp100_mode = 1;
  201. module_param(hp100_rx_ratio, int, 0);
  202. module_param(hp100_priority_tx, int, 0);
  203. module_param(hp100_mode, int, 0);
  204. /*
  205. * prototypes
  206. */
  207. static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
  208. struct pci_dev *pci_dev);
  209. static int hp100_open(struct net_device *dev);
  210. static int hp100_close(struct net_device *dev);
  211. static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
  212. struct net_device *dev);
  213. static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb,
  214. struct net_device *dev);
  215. static void hp100_rx(struct net_device *dev);
  216. static struct net_device_stats *hp100_get_stats(struct net_device *dev);
  217. static void hp100_misc_interrupt(struct net_device *dev);
  218. static void hp100_update_stats(struct net_device *dev);
  219. static void hp100_clear_stats(struct hp100_private *lp, int ioaddr);
  220. static void hp100_set_multicast_list(struct net_device *dev);
  221. static irqreturn_t hp100_interrupt(int irq, void *dev_id);
  222. static void hp100_start_interface(struct net_device *dev);
  223. static void hp100_stop_interface(struct net_device *dev);
  224. static void hp100_load_eeprom(struct net_device *dev, u_short ioaddr);
  225. static int hp100_sense_lan(struct net_device *dev);
  226. static int hp100_login_to_vg_hub(struct net_device *dev,
  227. u_short force_relogin);
  228. static int hp100_down_vg_link(struct net_device *dev);
  229. static void hp100_cascade_reset(struct net_device *dev, u_short enable);
  230. static void hp100_BM_shutdown(struct net_device *dev);
  231. static void hp100_mmuinit(struct net_device *dev);
  232. static void hp100_init_pdls(struct net_device *dev);
  233. static int hp100_init_rxpdl(struct net_device *dev,
  234. register hp100_ring_t * ringptr,
  235. register u_int * pdlptr);
  236. static int hp100_init_txpdl(struct net_device *dev,
  237. register hp100_ring_t * ringptr,
  238. register u_int * pdlptr);
  239. static void hp100_rxfill(struct net_device *dev);
  240. static void hp100_hwinit(struct net_device *dev);
  241. static void hp100_clean_txring(struct net_device *dev);
  242. #ifdef HP100_DEBUG
  243. static void hp100_RegisterDump(struct net_device *dev);
  244. #endif
  245. /* Conversion to new PCI API :
  246. * Convert an address in a kernel buffer to a bus/phys/dma address.
  247. * This work *only* for memory fragments part of lp->page_vaddr,
  248. * because it was properly DMA allocated via pci_alloc_consistent(),
  249. * so we just need to "retrieve" the original mapping to bus/phys/dma
  250. * address - Jean II */
  251. static inline dma_addr_t virt_to_whatever(struct net_device *dev, u32 * ptr)
  252. {
  253. struct hp100_private *lp = netdev_priv(dev);
  254. return ((u_long) ptr) + lp->whatever_offset;
  255. }
  256. static inline u_int pdl_map_data(struct hp100_private *lp, void *data)
  257. {
  258. return pci_map_single(lp->pci_dev, data,
  259. MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
  260. }
  261. /* TODO: This function should not really be needed in a good design... */
  262. static void wait(void)
  263. {
  264. mdelay(1);
  265. }
  266. /*
  267. * probe functions
  268. * These functions should - if possible - avoid doing write operations
  269. * since this could cause problems when the card is not installed.
  270. */
  271. /*
  272. * Read board id and convert to string.
  273. * Effectively same code as decode_eisa_sig
  274. */
  275. static const char *hp100_read_id(int ioaddr)
  276. {
  277. int i;
  278. static char str[HP100_SIG_LEN];
  279. unsigned char sig[4], sum;
  280. unsigned short rev;
  281. hp100_page(ID_MAC_ADDR);
  282. sum = 0;
  283. for (i = 0; i < 4; i++) {
  284. sig[i] = hp100_inb(BOARD_ID + i);
  285. sum += sig[i];
  286. }
  287. sum += hp100_inb(BOARD_ID + i);
  288. if (sum != 0xff)
  289. return NULL; /* bad checksum */
  290. str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1);
  291. str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1);
  292. str[2] = (sig[1] & 0x1f) + ('A' - 1);
  293. rev = (sig[2] << 8) | sig[3];
  294. sprintf(str + 3, "%04X", rev);
  295. return str;
  296. }
  297. #ifdef CONFIG_ISA
  298. static __init int hp100_isa_probe1(struct net_device *dev, int ioaddr)
  299. {
  300. const char *sig;
  301. int i;
  302. if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
  303. goto err;
  304. if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE) {
  305. release_region(ioaddr, HP100_REGION_SIZE);
  306. goto err;
  307. }
  308. sig = hp100_read_id(ioaddr);
  309. release_region(ioaddr, HP100_REGION_SIZE);
  310. if (sig == NULL)
  311. goto err;
  312. for (i = 0; i < ARRAY_SIZE(hp100_isa_tbl); i++) {
  313. if (!strcmp(hp100_isa_tbl[i], sig))
  314. break;
  315. }
  316. if (i < ARRAY_SIZE(hp100_isa_tbl))
  317. return hp100_probe1(dev, ioaddr, HP100_BUS_ISA, NULL);
  318. err:
  319. return -ENODEV;
  320. }
  321. /*
  322. * Probe for ISA board.
  323. * EISA and PCI are handled by device infrastructure.
  324. */
  325. static int __init hp100_isa_probe(struct net_device *dev, int addr)
  326. {
  327. int err = -ENODEV;
  328. /* Probe for a specific ISA address */
  329. if (addr > 0xff && addr < 0x400)
  330. err = hp100_isa_probe1(dev, addr);
  331. else if (addr != 0)
  332. err = -ENXIO;
  333. else {
  334. /* Probe all ISA possible port regions */
  335. for (addr = 0x100; addr < 0x400; addr += 0x20) {
  336. err = hp100_isa_probe1(dev, addr);
  337. if (!err)
  338. break;
  339. }
  340. }
  341. return err;
  342. }
  343. #endif /* CONFIG_ISA */
  344. #if !defined(MODULE) && defined(CONFIG_ISA)
  345. struct net_device * __init hp100_probe(int unit)
  346. {
  347. struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
  348. int err;
  349. if (!dev)
  350. return ERR_PTR(-ENODEV);
  351. #ifdef HP100_DEBUG_B
  352. hp100_outw(0x4200, TRACE);
  353. printk("hp100: %s: probe\n", dev->name);
  354. #endif
  355. if (unit >= 0) {
  356. sprintf(dev->name, "eth%d", unit);
  357. netdev_boot_setup_check(dev);
  358. }
  359. err = hp100_isa_probe(dev, dev->base_addr);
  360. if (err)
  361. goto out;
  362. return dev;
  363. out:
  364. free_netdev(dev);
  365. return ERR_PTR(err);
  366. }
  367. #endif /* !MODULE && CONFIG_ISA */
  368. static const struct net_device_ops hp100_bm_netdev_ops = {
  369. .ndo_open = hp100_open,
  370. .ndo_stop = hp100_close,
  371. .ndo_start_xmit = hp100_start_xmit_bm,
  372. .ndo_get_stats = hp100_get_stats,
  373. .ndo_set_rx_mode = hp100_set_multicast_list,
  374. .ndo_change_mtu = eth_change_mtu,
  375. .ndo_set_mac_address = eth_mac_addr,
  376. .ndo_validate_addr = eth_validate_addr,
  377. };
  378. static const struct net_device_ops hp100_netdev_ops = {
  379. .ndo_open = hp100_open,
  380. .ndo_stop = hp100_close,
  381. .ndo_start_xmit = hp100_start_xmit,
  382. .ndo_get_stats = hp100_get_stats,
  383. .ndo_set_rx_mode = hp100_set_multicast_list,
  384. .ndo_change_mtu = eth_change_mtu,
  385. .ndo_set_mac_address = eth_mac_addr,
  386. .ndo_validate_addr = eth_validate_addr,
  387. };
  388. static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
  389. struct pci_dev *pci_dev)
  390. {
  391. int i;
  392. int err = -ENODEV;
  393. const char *eid;
  394. u_int chip;
  395. u_char uc;
  396. u_int memory_size = 0, virt_memory_size = 0;
  397. u_short local_mode, lsw;
  398. short mem_mapped;
  399. unsigned long mem_ptr_phys;
  400. void __iomem *mem_ptr_virt;
  401. struct hp100_private *lp;
  402. #ifdef HP100_DEBUG_B
  403. hp100_outw(0x4201, TRACE);
  404. printk("hp100: %s: probe1\n", dev->name);
  405. #endif
  406. /* memory region for programmed i/o */
  407. if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
  408. goto out1;
  409. if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE)
  410. goto out2;
  411. chip = hp100_inw(PAGING) & HP100_CHIPID_MASK;
  412. #ifdef HP100_DEBUG
  413. if (chip == HP100_CHIPID_SHASTA)
  414. printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name);
  415. else if (chip == HP100_CHIPID_RAINIER)
  416. printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name);
  417. else if (chip == HP100_CHIPID_LASSEN)
  418. printk("hp100: %s: Lassen Chip detected.\n", dev->name);
  419. else
  420. printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n", dev->name, chip);
  421. #endif
  422. dev->base_addr = ioaddr;
  423. eid = hp100_read_id(ioaddr);
  424. if (eid == NULL) { /* bad checksum? */
  425. printk(KERN_WARNING "%s: bad ID checksum at base port 0x%x\n",
  426. __func__, ioaddr);
  427. goto out2;
  428. }
  429. hp100_page(ID_MAC_ADDR);
  430. for (i = uc = 0; i < 7; i++)
  431. uc += hp100_inb(LAN_ADDR + i);
  432. if (uc != 0xff) {
  433. printk(KERN_WARNING
  434. "%s: bad lan address checksum at port 0x%x)\n",
  435. __func__, ioaddr);
  436. err = -EIO;
  437. goto out2;
  438. }
  439. /* Make sure, that all registers are correctly updated... */
  440. hp100_load_eeprom(dev, ioaddr);
  441. wait();
  442. /*
  443. * Determine driver operation mode
  444. *
  445. * Use the variable "hp100_mode" upon insmod or as kernel parameter to
  446. * force driver modes:
  447. * hp100_mode=1 -> default, use busmaster mode if configured.
  448. * hp100_mode=2 -> enable shared memory mode
  449. * hp100_mode=3 -> force use of i/o mapped mode.
  450. * hp100_mode=4 -> same as 1, but re-set the enable bit on the card.
  451. */
  452. /*
  453. * LSW values:
  454. * 0x2278 -> J2585B, PnP shared memory mode
  455. * 0x2270 -> J2585B, shared memory mode, 0xdc000
  456. * 0xa23c -> J2585B, I/O mapped mode
  457. * 0x2240 -> EISA COMPEX, BusMaster (Shasta Chip)
  458. * 0x2220 -> EISA HP, I/O (Shasta Chip)
  459. * 0x2260 -> EISA HP, BusMaster (Shasta Chip)
  460. */
  461. #if 0
  462. local_mode = 0x2270;
  463. hp100_outw(0xfefe, OPTION_LSW);
  464. hp100_outw(local_mode | HP100_SET_LB | HP100_SET_HB, OPTION_LSW);
  465. #endif
  466. /* hp100_mode value maybe used in future by another card */
  467. local_mode = hp100_mode;
  468. if (local_mode < 1 || local_mode > 4)
  469. local_mode = 1; /* default */
  470. #ifdef HP100_DEBUG
  471. printk("hp100: %s: original LSW = 0x%x\n", dev->name,
  472. hp100_inw(OPTION_LSW));
  473. #endif
  474. if (local_mode == 3) {
  475. hp100_outw(HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
  476. hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  477. hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
  478. printk("hp100: IO mapped mode forced.\n");
  479. } else if (local_mode == 2) {
  480. hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
  481. hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  482. hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
  483. printk("hp100: Shared memory mode requested.\n");
  484. } else if (local_mode == 4) {
  485. if (chip == HP100_CHIPID_LASSEN) {
  486. hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_SET_HB, OPTION_LSW);
  487. hp100_outw(HP100_IO_EN | HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
  488. printk("hp100: Busmaster mode requested.\n");
  489. }
  490. local_mode = 1;
  491. }
  492. if (local_mode == 1) { /* default behaviour */
  493. lsw = hp100_inw(OPTION_LSW);
  494. if ((lsw & HP100_IO_EN) && (~lsw & HP100_MEM_EN) &&
  495. (~lsw & (HP100_BM_WRITE | HP100_BM_READ))) {
  496. #ifdef HP100_DEBUG
  497. printk("hp100: %s: IO_EN bit is set on card.\n", dev->name);
  498. #endif
  499. local_mode = 3;
  500. } else if (chip == HP100_CHIPID_LASSEN &&
  501. (lsw & (HP100_BM_WRITE | HP100_BM_READ)) == (HP100_BM_WRITE | HP100_BM_READ)) {
  502. /* Conversion to new PCI API :
  503. * I don't have the doc, but I assume that the card
  504. * can map the full 32bit address space.
  505. * Also, we can have EISA Busmaster cards (not tested),
  506. * so beware !!! - Jean II */
  507. if((bus == HP100_BUS_PCI) &&
  508. (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)))) {
  509. /* Gracefully fallback to shared memory */
  510. goto busmasterfail;
  511. }
  512. printk("hp100: Busmaster mode enabled.\n");
  513. hp100_outw(HP100_MEM_EN | HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
  514. } else {
  515. busmasterfail:
  516. #ifdef HP100_DEBUG
  517. printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name);
  518. printk("hp100: %s: Trying shared memory mode.\n", dev->name);
  519. #endif
  520. /* In this case, try shared memory mode */
  521. local_mode = 2;
  522. hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
  523. /* hp100_outw(HP100_IO_EN|HP100_RESET_LB, OPTION_LSW); */
  524. }
  525. }
  526. #ifdef HP100_DEBUG
  527. printk("hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW));
  528. #endif
  529. /* Check for shared memory on the card, eventually remap it */
  530. hp100_page(HW_MAP);
  531. mem_mapped = ((hp100_inw(OPTION_LSW) & (HP100_MEM_EN)) != 0);
  532. mem_ptr_phys = 0UL;
  533. mem_ptr_virt = NULL;
  534. memory_size = (8192 << ((hp100_inb(SRAM) >> 5) & 0x07));
  535. virt_memory_size = 0;
  536. /* For memory mapped or busmaster mode, we want the memory address */
  537. if (mem_mapped || (local_mode == 1)) {
  538. mem_ptr_phys = (hp100_inw(MEM_MAP_LSW) | (hp100_inw(MEM_MAP_MSW) << 16));
  539. mem_ptr_phys &= ~0x1fff; /* 8k alignment */
  540. if (bus == HP100_BUS_ISA && (mem_ptr_phys & ~0xfffff) != 0) {
  541. printk("hp100: Can only use programmed i/o mode.\n");
  542. mem_ptr_phys = 0;
  543. mem_mapped = 0;
  544. local_mode = 3; /* Use programmed i/o */
  545. }
  546. /* We do not need access to shared memory in busmaster mode */
  547. /* However in slave mode we need to remap high (>1GB) card memory */
  548. if (local_mode != 1) { /* = not busmaster */
  549. /* We try with smaller memory sizes, if ioremap fails */
  550. for (virt_memory_size = memory_size; virt_memory_size > 16383; virt_memory_size >>= 1) {
  551. if ((mem_ptr_virt = ioremap((u_long) mem_ptr_phys, virt_memory_size)) == NULL) {
  552. #ifdef HP100_DEBUG
  553. printk("hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, mem_ptr_phys);
  554. #endif
  555. } else {
  556. #ifdef HP100_DEBUG
  557. printk("hp100: %s: remapped 0x%x bytes high PCI memory at 0x%lx to %p.\n", dev->name, virt_memory_size, mem_ptr_phys, mem_ptr_virt);
  558. #endif
  559. break;
  560. }
  561. }
  562. if (mem_ptr_virt == NULL) { /* all ioremap tries failed */
  563. printk("hp100: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n");
  564. local_mode = 3;
  565. virt_memory_size = 0;
  566. }
  567. }
  568. }
  569. if (local_mode == 3) { /* io mapped forced */
  570. mem_mapped = 0;
  571. mem_ptr_phys = 0;
  572. mem_ptr_virt = NULL;
  573. printk("hp100: Using (slow) programmed i/o mode.\n");
  574. }
  575. /* Initialise the "private" data structure for this card. */
  576. lp = netdev_priv(dev);
  577. spin_lock_init(&lp->lock);
  578. strlcpy(lp->id, eid, HP100_SIG_LEN);
  579. lp->chip = chip;
  580. lp->mode = local_mode;
  581. lp->bus = bus;
  582. lp->pci_dev = pci_dev;
  583. lp->priority_tx = hp100_priority_tx;
  584. lp->rx_ratio = hp100_rx_ratio;
  585. lp->mem_ptr_phys = mem_ptr_phys;
  586. lp->mem_ptr_virt = mem_ptr_virt;
  587. hp100_page(ID_MAC_ADDR);
  588. lp->soft_model = hp100_inb(SOFT_MODEL);
  589. lp->mac1_mode = HP100_MAC1MODE3;
  590. lp->mac2_mode = HP100_MAC2MODE3;
  591. memset(&lp->hash_bytes, 0x00, 8);
  592. dev->base_addr = ioaddr;
  593. lp->memory_size = memory_size;
  594. lp->virt_memory_size = virt_memory_size;
  595. lp->rx_ratio = hp100_rx_ratio; /* can be conf'd with insmod */
  596. if (lp->mode == 1) /* busmaster */
  597. dev->netdev_ops = &hp100_bm_netdev_ops;
  598. else
  599. dev->netdev_ops = &hp100_netdev_ops;
  600. /* Ask the card for which IRQ line it is configured */
  601. if (bus == HP100_BUS_PCI) {
  602. dev->irq = pci_dev->irq;
  603. } else {
  604. hp100_page(HW_MAP);
  605. dev->irq = hp100_inb(IRQ_CHANNEL) & HP100_IRQMASK;
  606. if (dev->irq == 2)
  607. dev->irq = 9;
  608. }
  609. if (lp->mode == 1) /* busmaster */
  610. dev->dma = 4;
  611. /* Ask the card for its MAC address and store it for later use. */
  612. hp100_page(ID_MAC_ADDR);
  613. for (i = uc = 0; i < 6; i++)
  614. dev->dev_addr[i] = hp100_inb(LAN_ADDR + i);
  615. /* Reset statistics (counters) */
  616. hp100_clear_stats(lp, ioaddr);
  617. /* If busmaster mode is wanted, a dma-capable memory area is needed for
  618. * the rx and tx PDLs
  619. * PCI cards can access the whole PC memory. Therefore GFP_DMA is not
  620. * needed for the allocation of the memory area.
  621. */
  622. /* TODO: We do not need this with old cards, where PDLs are stored
  623. * in the cards shared memory area. But currently, busmaster has been
  624. * implemented/tested only with the lassen chip anyway... */
  625. if (lp->mode == 1) { /* busmaster */
  626. dma_addr_t page_baddr;
  627. /* Get physically continuous memory for TX & RX PDLs */
  628. /* Conversion to new PCI API :
  629. * Pages are always aligned and zeroed, no need to it ourself.
  630. * Doc says should be OK for EISA bus as well - Jean II */
  631. lp->page_vaddr_algn = pci_alloc_consistent(lp->pci_dev, MAX_RINGSIZE, &page_baddr);
  632. if (!lp->page_vaddr_algn) {
  633. err = -ENOMEM;
  634. goto out_mem_ptr;
  635. }
  636. lp->whatever_offset = ((u_long) page_baddr) - ((u_long) lp->page_vaddr_algn);
  637. #ifdef HP100_DEBUG_BM
  638. printk("hp100: %s: Reserved DMA memory from 0x%x to 0x%x\n", dev->name, (u_int) lp->page_vaddr_algn, (u_int) lp->page_vaddr_algn + MAX_RINGSIZE);
  639. #endif
  640. lp->rxrcommit = lp->txrcommit = 0;
  641. lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
  642. lp->txrhead = lp->txrtail = &(lp->txring[0]);
  643. }
  644. /* Initialise the card. */
  645. /* (I'm not really sure if it's a good idea to do this during probing, but
  646. * like this it's assured that the lan connection type can be sensed
  647. * correctly)
  648. */
  649. hp100_hwinit(dev);
  650. /* Try to find out which kind of LAN the card is connected to. */
  651. lp->lan_type = hp100_sense_lan(dev);
  652. /* Print out a message what about what we think we have probed. */
  653. printk("hp100: at 0x%x, IRQ %d, ", ioaddr, dev->irq);
  654. switch (bus) {
  655. case HP100_BUS_EISA:
  656. printk("EISA");
  657. break;
  658. case HP100_BUS_PCI:
  659. printk("PCI");
  660. break;
  661. default:
  662. printk("ISA");
  663. break;
  664. }
  665. printk(" bus, %dk SRAM (rx/tx %d%%).\n", lp->memory_size >> 10, lp->rx_ratio);
  666. if (lp->mode == 2) { /* memory mapped */
  667. printk("hp100: Memory area at 0x%lx-0x%lx", mem_ptr_phys,
  668. (mem_ptr_phys + (mem_ptr_phys > 0x100000 ? (u_long) lp->memory_size : 16 * 1024)) - 1);
  669. if (mem_ptr_virt)
  670. printk(" (virtual base %p)", mem_ptr_virt);
  671. printk(".\n");
  672. /* Set for info when doing ifconfig */
  673. dev->mem_start = mem_ptr_phys;
  674. dev->mem_end = mem_ptr_phys + lp->memory_size;
  675. }
  676. printk("hp100: ");
  677. if (lp->lan_type != HP100_LAN_ERR)
  678. printk("Adapter is attached to ");
  679. switch (lp->lan_type) {
  680. case HP100_LAN_100:
  681. printk("100Mb/s Voice Grade AnyLAN network.\n");
  682. break;
  683. case HP100_LAN_10:
  684. printk("10Mb/s network (10baseT).\n");
  685. break;
  686. case HP100_LAN_COAX:
  687. printk("10Mb/s network (coax).\n");
  688. break;
  689. default:
  690. printk("Warning! Link down.\n");
  691. }
  692. err = register_netdev(dev);
  693. if (err)
  694. goto out3;
  695. return 0;
  696. out3:
  697. if (local_mode == 1)
  698. pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f,
  699. lp->page_vaddr_algn,
  700. virt_to_whatever(dev, lp->page_vaddr_algn));
  701. out_mem_ptr:
  702. if (mem_ptr_virt)
  703. iounmap(mem_ptr_virt);
  704. out2:
  705. release_region(ioaddr, HP100_REGION_SIZE);
  706. out1:
  707. return err;
  708. }
  709. /* This procedure puts the card into a stable init state */
  710. static void hp100_hwinit(struct net_device *dev)
  711. {
  712. int ioaddr = dev->base_addr;
  713. struct hp100_private *lp = netdev_priv(dev);
  714. #ifdef HP100_DEBUG_B
  715. hp100_outw(0x4202, TRACE);
  716. printk("hp100: %s: hwinit\n", dev->name);
  717. #endif
  718. /* Initialise the card. -------------------------------------------- */
  719. /* Clear all pending Ints and disable Ints */
  720. hp100_page(PERFORMANCE);
  721. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  722. hp100_outw(0xffff, IRQ_STATUS); /* clear all pending ints */
  723. hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  724. hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
  725. if (lp->mode == 1) {
  726. hp100_BM_shutdown(dev); /* disables BM, puts cascade in reset */
  727. wait();
  728. } else {
  729. hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  730. hp100_cascade_reset(dev, 1);
  731. hp100_page(MAC_CTRL);
  732. hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
  733. }
  734. /* Initiate EEPROM reload */
  735. hp100_load_eeprom(dev, 0);
  736. wait();
  737. /* Go into reset again. */
  738. hp100_cascade_reset(dev, 1);
  739. /* Set Option Registers to a safe state */
  740. hp100_outw(HP100_DEBUG_EN |
  741. HP100_RX_HDR |
  742. HP100_EE_EN |
  743. HP100_BM_WRITE |
  744. HP100_BM_READ | HP100_RESET_HB |
  745. HP100_FAKE_INT |
  746. HP100_INT_EN |
  747. HP100_MEM_EN |
  748. HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
  749. hp100_outw(HP100_TRI_INT |
  750. HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
  751. hp100_outb(HP100_PRIORITY_TX |
  752. HP100_ADV_NXT_PKT |
  753. HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
  754. /* TODO: Configure MMU for Ram Test. */
  755. /* TODO: Ram Test. */
  756. /* Re-check if adapter is still at same i/o location */
  757. /* (If the base i/o in eeprom has been changed but the */
  758. /* registers had not been changed, a reload of the eeprom */
  759. /* would move the adapter to the address stored in eeprom */
  760. /* TODO: Code to implement. */
  761. /* Until here it was code from HWdiscover procedure. */
  762. /* Next comes code from mmuinit procedure of SCO BM driver which is
  763. * called from HWconfigure in the SCO driver. */
  764. /* Initialise MMU, eventually switch on Busmaster Mode, initialise
  765. * multicast filter...
  766. */
  767. hp100_mmuinit(dev);
  768. /* We don't turn the interrupts on here - this is done by start_interface. */
  769. wait(); /* TODO: Do we really need this? */
  770. /* Enable Hardware (e.g. unreset) */
  771. hp100_cascade_reset(dev, 0);
  772. /* ------- initialisation complete ----------- */
  773. /* Finally try to log in the Hub if there may be a VG connection. */
  774. if ((lp->lan_type == HP100_LAN_100) || (lp->lan_type == HP100_LAN_ERR))
  775. hp100_login_to_vg_hub(dev, 0); /* relogin */
  776. }
  777. /*
  778. * mmuinit - Reinitialise Cascade MMU and MAC settings.
  779. * Note: Must already be in reset and leaves card in reset.
  780. */
  781. static void hp100_mmuinit(struct net_device *dev)
  782. {
  783. int ioaddr = dev->base_addr;
  784. struct hp100_private *lp = netdev_priv(dev);
  785. int i;
  786. #ifdef HP100_DEBUG_B
  787. hp100_outw(0x4203, TRACE);
  788. printk("hp100: %s: mmuinit\n", dev->name);
  789. #endif
  790. #ifdef HP100_DEBUG
  791. if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
  792. printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n", dev->name);
  793. return;
  794. }
  795. #endif
  796. /* Make sure IRQs are masked off and ack'ed. */
  797. hp100_page(PERFORMANCE);
  798. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  799. hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
  800. /*
  801. * Enable Hardware
  802. * - Clear Debug En, Rx Hdr Pipe, EE En, I/O En, Fake Int and Intr En
  803. * - Set Tri-State Int, Bus Master Rd/Wr, and Mem Map Disable
  804. * - Clear Priority, Advance Pkt and Xmit Cmd
  805. */
  806. hp100_outw(HP100_DEBUG_EN |
  807. HP100_RX_HDR |
  808. HP100_EE_EN | HP100_RESET_HB |
  809. HP100_IO_EN |
  810. HP100_FAKE_INT |
  811. HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  812. hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
  813. if (lp->mode == 1) { /* busmaster */
  814. hp100_outw(HP100_BM_WRITE |
  815. HP100_BM_READ |
  816. HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
  817. } else if (lp->mode == 2) { /* memory mapped */
  818. hp100_outw(HP100_BM_WRITE |
  819. HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
  820. hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
  821. hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
  822. hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  823. } else if (lp->mode == 3) { /* i/o mapped mode */
  824. hp100_outw(HP100_MMAP_DIS | HP100_SET_HB |
  825. HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
  826. }
  827. hp100_page(HW_MAP);
  828. hp100_outb(0, EARLYRXCFG);
  829. hp100_outw(0, EARLYTXCFG);
  830. /*
  831. * Enable Bus Master mode
  832. */
  833. if (lp->mode == 1) { /* busmaster */
  834. /* Experimental: Set some PCI configuration bits */
  835. hp100_page(HW_MAP);
  836. hp100_andb(~HP100_PDL_USE3, MODECTRL1); /* BM engine read maximum */
  837. hp100_andb(~HP100_TX_DUALQ, MODECTRL1); /* No Queue for Priority TX */
  838. /* PCI Bus failures should result in a Misc. Interrupt */
  839. hp100_orb(HP100_EN_BUS_FAIL, MODECTRL2);
  840. hp100_outw(HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW);
  841. hp100_page(HW_MAP);
  842. /* Use Burst Mode and switch on PAGE_CK */
  843. hp100_orb(HP100_BM_BURST_RD | HP100_BM_BURST_WR, BM);
  844. if ((lp->chip == HP100_CHIPID_RAINIER) || (lp->chip == HP100_CHIPID_SHASTA))
  845. hp100_orb(HP100_BM_PAGE_CK, BM);
  846. hp100_orb(HP100_BM_MASTER, BM);
  847. } else { /* not busmaster */
  848. hp100_page(HW_MAP);
  849. hp100_andb(~HP100_BM_MASTER, BM);
  850. }
  851. /*
  852. * Divide card memory into regions for Rx, Tx and, if non-ETR chip, PDLs
  853. */
  854. hp100_page(MMU_CFG);
  855. if (lp->mode == 1) { /* only needed for Busmaster */
  856. int xmit_stop, recv_stop;
  857. if ((lp->chip == HP100_CHIPID_RAINIER) ||
  858. (lp->chip == HP100_CHIPID_SHASTA)) {
  859. int pdl_stop;
  860. /*
  861. * Each pdl is 508 bytes long. (63 frags * 4 bytes for address and
  862. * 4 bytes for header). We will leave NUM_RXPDLS * 508 (rounded
  863. * to the next higher 1k boundary) bytes for the rx-pdl's
  864. * Note: For non-etr chips the transmit stop register must be
  865. * programmed on a 1k boundary, i.e. bits 9:0 must be zero.
  866. */
  867. pdl_stop = lp->memory_size;
  868. xmit_stop = (pdl_stop - 508 * (MAX_RX_PDL) - 16) & ~(0x03ff);
  869. recv_stop = (xmit_stop * (lp->rx_ratio) / 100) & ~(0x03ff);
  870. hp100_outw((pdl_stop >> 4) - 1, PDL_MEM_STOP);
  871. #ifdef HP100_DEBUG_BM
  872. printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop);
  873. #endif
  874. } else {
  875. /* ETR chip (Lassen) in busmaster mode */
  876. xmit_stop = (lp->memory_size) - 1;
  877. recv_stop = ((lp->memory_size * lp->rx_ratio) / 100) & ~(0x03ff);
  878. }
  879. hp100_outw(xmit_stop >> 4, TX_MEM_STOP);
  880. hp100_outw(recv_stop >> 4, RX_MEM_STOP);
  881. #ifdef HP100_DEBUG_BM
  882. printk("hp100: %s: TX_STOP = 0x%x\n", dev->name, xmit_stop >> 4);
  883. printk("hp100: %s: RX_STOP = 0x%x\n", dev->name, recv_stop >> 4);
  884. #endif
  885. } else {
  886. /* Slave modes (memory mapped and programmed io) */
  887. hp100_outw((((lp->memory_size * lp->rx_ratio) / 100) >> 4), RX_MEM_STOP);
  888. hp100_outw(((lp->memory_size - 1) >> 4), TX_MEM_STOP);
  889. #ifdef HP100_DEBUG
  890. printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(TX_MEM_STOP));
  891. printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(RX_MEM_STOP));
  892. #endif
  893. }
  894. /* Write MAC address into page 1 */
  895. hp100_page(MAC_ADDRESS);
  896. for (i = 0; i < 6; i++)
  897. hp100_outb(dev->dev_addr[i], MAC_ADDR + i);
  898. /* Zero the multicast hash registers */
  899. for (i = 0; i < 8; i++)
  900. hp100_outb(0x0, HASH_BYTE0 + i);
  901. /* Set up MAC defaults */
  902. hp100_page(MAC_CTRL);
  903. /* Go to LAN Page and zero all filter bits */
  904. /* Zero accept error, accept multicast, accept broadcast and accept */
  905. /* all directed packet bits */
  906. hp100_andb(~(HP100_RX_EN |
  907. HP100_TX_EN |
  908. HP100_ACC_ERRORED |
  909. HP100_ACC_MC |
  910. HP100_ACC_BC | HP100_ACC_PHY), MAC_CFG_1);
  911. hp100_outb(0x00, MAC_CFG_2);
  912. /* Zero the frame format bit. This works around a training bug in the */
  913. /* new hubs. */
  914. hp100_outb(0x00, VG_LAN_CFG_2); /* (use 802.3) */
  915. if (lp->priority_tx)
  916. hp100_outb(HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW);
  917. else
  918. hp100_outb(HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW);
  919. hp100_outb(HP100_ADV_NXT_PKT |
  920. HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
  921. /* If busmaster, initialize the PDLs */
  922. if (lp->mode == 1)
  923. hp100_init_pdls(dev);
  924. /* Go to performance page and initialize isr and imr registers */
  925. hp100_page(PERFORMANCE);
  926. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  927. hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
  928. }
  929. /*
  930. * open/close functions
  931. */
  932. static int hp100_open(struct net_device *dev)
  933. {
  934. struct hp100_private *lp = netdev_priv(dev);
  935. #ifdef HP100_DEBUG_B
  936. int ioaddr = dev->base_addr;
  937. #endif
  938. #ifdef HP100_DEBUG_B
  939. hp100_outw(0x4204, TRACE);
  940. printk("hp100: %s: open\n", dev->name);
  941. #endif
  942. /* New: if bus is PCI or EISA, interrupts might be shared interrupts */
  943. if (request_irq(dev->irq, hp100_interrupt,
  944. lp->bus == HP100_BUS_PCI || lp->bus ==
  945. HP100_BUS_EISA ? IRQF_SHARED : 0,
  946. dev->name, dev)) {
  947. printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq);
  948. return -EAGAIN;
  949. }
  950. netif_trans_update(dev); /* prevent tx timeout */
  951. netif_start_queue(dev);
  952. lp->lan_type = hp100_sense_lan(dev);
  953. lp->mac1_mode = HP100_MAC1MODE3;
  954. lp->mac2_mode = HP100_MAC2MODE3;
  955. memset(&lp->hash_bytes, 0x00, 8);
  956. hp100_stop_interface(dev);
  957. hp100_hwinit(dev);
  958. hp100_start_interface(dev); /* sets mac modes, enables interrupts */
  959. return 0;
  960. }
  961. /* The close function is called when the interface is to be brought down */
  962. static int hp100_close(struct net_device *dev)
  963. {
  964. int ioaddr = dev->base_addr;
  965. struct hp100_private *lp = netdev_priv(dev);
  966. #ifdef HP100_DEBUG_B
  967. hp100_outw(0x4205, TRACE);
  968. printk("hp100: %s: close\n", dev->name);
  969. #endif
  970. hp100_page(PERFORMANCE);
  971. hp100_outw(0xfefe, IRQ_MASK); /* mask off all IRQs */
  972. hp100_stop_interface(dev);
  973. if (lp->lan_type == HP100_LAN_100)
  974. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  975. netif_stop_queue(dev);
  976. free_irq(dev->irq, dev);
  977. #ifdef HP100_DEBUG
  978. printk("hp100: %s: close LSW = 0x%x\n", dev->name,
  979. hp100_inw(OPTION_LSW));
  980. #endif
  981. return 0;
  982. }
  983. /*
  984. * Configure the PDL Rx rings and LAN
  985. */
  986. static void hp100_init_pdls(struct net_device *dev)
  987. {
  988. struct hp100_private *lp = netdev_priv(dev);
  989. hp100_ring_t *ringptr;
  990. u_int *pageptr; /* Warning : increment by 4 - Jean II */
  991. int i;
  992. #ifdef HP100_DEBUG_B
  993. int ioaddr = dev->base_addr;
  994. #endif
  995. #ifdef HP100_DEBUG_B
  996. hp100_outw(0x4206, TRACE);
  997. printk("hp100: %s: init pdls\n", dev->name);
  998. #endif
  999. if (!lp->page_vaddr_algn)
  1000. printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n", dev->name);
  1001. else {
  1002. /* pageptr shall point into the DMA accessible memory region */
  1003. /* we use this pointer to status the upper limit of allocated */
  1004. /* memory in the allocated page. */
  1005. /* note: align the pointers to the pci cache line size */
  1006. memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE); /* Zero Rx/Tx ring page */
  1007. pageptr = lp->page_vaddr_algn;
  1008. lp->rxrcommit = 0;
  1009. ringptr = lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
  1010. /* Initialise Rx Ring */
  1011. for (i = MAX_RX_PDL - 1; i >= 0; i--) {
  1012. lp->rxring[i].next = ringptr;
  1013. ringptr = &(lp->rxring[i]);
  1014. pageptr += hp100_init_rxpdl(dev, ringptr, pageptr);
  1015. }
  1016. /* Initialise Tx Ring */
  1017. lp->txrcommit = 0;
  1018. ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]);
  1019. for (i = MAX_TX_PDL - 1; i >= 0; i--) {
  1020. lp->txring[i].next = ringptr;
  1021. ringptr = &(lp->txring[i]);
  1022. pageptr += hp100_init_txpdl(dev, ringptr, pageptr);
  1023. }
  1024. }
  1025. }
  1026. /* These functions "format" the entries in the pdl structure */
  1027. /* They return how much memory the fragments need. */
  1028. static int hp100_init_rxpdl(struct net_device *dev,
  1029. register hp100_ring_t * ringptr,
  1030. register u32 * pdlptr)
  1031. {
  1032. /* pdlptr is starting address for this pdl */
  1033. if (0 != (((unsigned long) pdlptr) & 0xf))
  1034. printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%lx.\n",
  1035. dev->name, (unsigned long) pdlptr);
  1036. ringptr->pdl = pdlptr + 1;
  1037. ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr + 1);
  1038. ringptr->skb = NULL;
  1039. /*
  1040. * Write address and length of first PDL Fragment (which is used for
  1041. * storing the RX-Header
  1042. * We use the 4 bytes _before_ the PDH in the pdl memory area to
  1043. * store this information. (PDH is at offset 0x04)
  1044. */
  1045. /* Note that pdlptr+1 and not pdlptr is the pointer to the PDH */
  1046. *(pdlptr + 2) = (u_int) virt_to_whatever(dev, pdlptr); /* Address Frag 1 */
  1047. *(pdlptr + 3) = 4; /* Length Frag 1 */
  1048. return roundup(MAX_RX_FRAG * 2 + 2, 4);
  1049. }
  1050. static int hp100_init_txpdl(struct net_device *dev,
  1051. register hp100_ring_t * ringptr,
  1052. register u32 * pdlptr)
  1053. {
  1054. if (0 != (((unsigned long) pdlptr) & 0xf))
  1055. printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%lx.\n", dev->name, (unsigned long) pdlptr);
  1056. ringptr->pdl = pdlptr; /* +1; */
  1057. ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr); /* +1 */
  1058. ringptr->skb = NULL;
  1059. return roundup(MAX_TX_FRAG * 2 + 2, 4);
  1060. }
  1061. /*
  1062. * hp100_build_rx_pdl allocates an skb_buff of maximum size plus two bytes
  1063. * for possible odd word alignment rounding up to next dword and set PDL
  1064. * address for fragment#2
  1065. * Returns: 0 if unable to allocate skb_buff
  1066. * 1 if successful
  1067. */
  1068. static int hp100_build_rx_pdl(hp100_ring_t * ringptr,
  1069. struct net_device *dev)
  1070. {
  1071. #ifdef HP100_DEBUG_B
  1072. int ioaddr = dev->base_addr;
  1073. #endif
  1074. #ifdef HP100_DEBUG_BM
  1075. u_int *p;
  1076. #endif
  1077. #ifdef HP100_DEBUG_B
  1078. hp100_outw(0x4207, TRACE);
  1079. printk("hp100: %s: build rx pdl\n", dev->name);
  1080. #endif
  1081. /* Allocate skb buffer of maximum size */
  1082. /* Note: This depends on the alloc_skb functions allocating more
  1083. * space than requested, i.e. aligning to 16bytes */
  1084. ringptr->skb = netdev_alloc_skb(dev, roundup(MAX_ETHER_SIZE + 2, 4));
  1085. if (NULL != ringptr->skb) {
  1086. /*
  1087. * Reserve 2 bytes at the head of the buffer to land the IP header
  1088. * on a long word boundary (According to the Network Driver section
  1089. * in the Linux KHG, this should help to increase performance.)
  1090. */
  1091. skb_reserve(ringptr->skb, 2);
  1092. ringptr->skb->data = (u_char *) skb_put(ringptr->skb, MAX_ETHER_SIZE);
  1093. /* ringptr->pdl points to the beginning of the PDL, i.e. the PDH */
  1094. /* Note: 1st Fragment is used for the 4 byte packet status
  1095. * (receive header). Its PDL entries are set up by init_rxpdl. So
  1096. * here we only have to set up the PDL fragment entries for the data
  1097. * part. Those 4 bytes will be stored in the DMA memory region
  1098. * directly before the PDL.
  1099. */
  1100. #ifdef HP100_DEBUG_BM
  1101. printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n",
  1102. dev->name, (u_int) ringptr->pdl,
  1103. roundup(MAX_ETHER_SIZE + 2, 4),
  1104. (unsigned int) ringptr->skb->data);
  1105. #endif
  1106. /* Conversion to new PCI API : map skbuf data to PCI bus.
  1107. * Doc says it's OK for EISA as well - Jean II */
  1108. ringptr->pdl[0] = 0x00020000; /* Write PDH */
  1109. ringptr->pdl[3] = pdl_map_data(netdev_priv(dev),
  1110. ringptr->skb->data);
  1111. ringptr->pdl[4] = MAX_ETHER_SIZE; /* Length of Data */
  1112. #ifdef HP100_DEBUG_BM
  1113. for (p = (ringptr->pdl); p < (ringptr->pdl + 5); p++)
  1114. printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n", dev->name, (u_int) p, (u_int) * p);
  1115. #endif
  1116. return 1;
  1117. }
  1118. /* else: */
  1119. /* alloc_skb failed (no memory) -> still can receive the header
  1120. * fragment into PDL memory. make PDL safe by clearing msgptr and
  1121. * making the PDL only 1 fragment (i.e. the 4 byte packet status)
  1122. */
  1123. #ifdef HP100_DEBUG_BM
  1124. printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n", dev->name, (u_int) ringptr->pdl);
  1125. #endif
  1126. ringptr->pdl[0] = 0x00010000; /* PDH: Count=1 Fragment */
  1127. return 0;
  1128. }
  1129. /*
  1130. * hp100_rxfill - attempt to fill the Rx Ring will empty skb's
  1131. *
  1132. * Makes assumption that skb's are always contiguous memory areas and
  1133. * therefore PDLs contain only 2 physical fragments.
  1134. * - While the number of Rx PDLs with buffers is less than maximum
  1135. * a. Get a maximum packet size skb
  1136. * b. Put the physical address of the buffer into the PDL.
  1137. * c. Output physical address of PDL to adapter.
  1138. */
  1139. static void hp100_rxfill(struct net_device *dev)
  1140. {
  1141. int ioaddr = dev->base_addr;
  1142. struct hp100_private *lp = netdev_priv(dev);
  1143. hp100_ring_t *ringptr;
  1144. #ifdef HP100_DEBUG_B
  1145. hp100_outw(0x4208, TRACE);
  1146. printk("hp100: %s: rxfill\n", dev->name);
  1147. #endif
  1148. hp100_page(PERFORMANCE);
  1149. while (lp->rxrcommit < MAX_RX_PDL) {
  1150. /*
  1151. ** Attempt to get a buffer and build a Rx PDL.
  1152. */
  1153. ringptr = lp->rxrtail;
  1154. if (0 == hp100_build_rx_pdl(ringptr, dev)) {
  1155. return; /* None available, return */
  1156. }
  1157. /* Hand this PDL over to the card */
  1158. /* Note: This needs performance page selected! */
  1159. #ifdef HP100_DEBUG_BM
  1160. printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n",
  1161. dev->name, lp->rxrcommit, (u_int) ringptr->pdl,
  1162. (u_int) ringptr->pdl_paddr, (u_int) ringptr->pdl[3]);
  1163. #endif
  1164. hp100_outl((u32) ringptr->pdl_paddr, RX_PDA);
  1165. lp->rxrcommit += 1;
  1166. lp->rxrtail = ringptr->next;
  1167. }
  1168. }
  1169. /*
  1170. * BM_shutdown - shutdown bus mastering and leave chip in reset state
  1171. */
  1172. static void hp100_BM_shutdown(struct net_device *dev)
  1173. {
  1174. int ioaddr = dev->base_addr;
  1175. struct hp100_private *lp = netdev_priv(dev);
  1176. unsigned long time;
  1177. #ifdef HP100_DEBUG_B
  1178. hp100_outw(0x4209, TRACE);
  1179. printk("hp100: %s: bm shutdown\n", dev->name);
  1180. #endif
  1181. hp100_page(PERFORMANCE);
  1182. hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
  1183. hp100_outw(0xffff, IRQ_STATUS); /* Ack all ints */
  1184. /* Ensure Interrupts are off */
  1185. hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
  1186. /* Disable all MAC activity */
  1187. hp100_page(MAC_CTRL);
  1188. hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */
  1189. /* If cascade MMU is not already in reset */
  1190. if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
  1191. /* Wait 1.3ms (10Mb max packet time) to ensure MAC is idle so
  1192. * MMU pointers will not be reset out from underneath
  1193. */
  1194. hp100_page(MAC_CTRL);
  1195. for (time = 0; time < 5000; time++) {
  1196. if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE))
  1197. break;
  1198. }
  1199. /* Shutdown algorithm depends on the generation of Cascade */
  1200. if (lp->chip == HP100_CHIPID_LASSEN) { /* ETR shutdown/reset */
  1201. /* Disable Busmaster mode and wait for bit to go to zero. */
  1202. hp100_page(HW_MAP);
  1203. hp100_andb(~HP100_BM_MASTER, BM);
  1204. /* 100 ms timeout */
  1205. for (time = 0; time < 32000; time++) {
  1206. if (0 == (hp100_inb(BM) & HP100_BM_MASTER))
  1207. break;
  1208. }
  1209. } else { /* Shasta or Rainier Shutdown/Reset */
  1210. /* To ensure all bus master inloading activity has ceased,
  1211. * wait for no Rx PDAs or no Rx packets on card.
  1212. */
  1213. hp100_page(PERFORMANCE);
  1214. /* 100 ms timeout */
  1215. for (time = 0; time < 10000; time++) {
  1216. /* RX_PDL: PDLs not executed. */
  1217. /* RX_PKT_CNT: RX'd packets on card. */
  1218. if ((hp100_inb(RX_PDL) == 0) && (hp100_inb(RX_PKT_CNT) == 0))
  1219. break;
  1220. }
  1221. if (time >= 10000)
  1222. printk("hp100: %s: BM shutdown error.\n", dev->name);
  1223. /* To ensure all bus master outloading activity has ceased,
  1224. * wait until the Tx PDA count goes to zero or no more Tx space
  1225. * available in the Tx region of the card.
  1226. */
  1227. /* 100 ms timeout */
  1228. for (time = 0; time < 10000; time++) {
  1229. if ((0 == hp100_inb(TX_PKT_CNT)) &&
  1230. (0 != (hp100_inb(TX_MEM_FREE) & HP100_AUTO_COMPARE)))
  1231. break;
  1232. }
  1233. /* Disable Busmaster mode */
  1234. hp100_page(HW_MAP);
  1235. hp100_andb(~HP100_BM_MASTER, BM);
  1236. } /* end of shutdown procedure for non-etr parts */
  1237. hp100_cascade_reset(dev, 1);
  1238. }
  1239. hp100_page(PERFORMANCE);
  1240. /* hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_RESET_HB, OPTION_LSW ); */
  1241. /* Busmaster mode should be shut down now. */
  1242. }
  1243. static int hp100_check_lan(struct net_device *dev)
  1244. {
  1245. struct hp100_private *lp = netdev_priv(dev);
  1246. if (lp->lan_type < 0) { /* no LAN type detected yet? */
  1247. hp100_stop_interface(dev);
  1248. if ((lp->lan_type = hp100_sense_lan(dev)) < 0) {
  1249. printk("hp100: %s: no connection found - check wire\n", dev->name);
  1250. hp100_start_interface(dev); /* 10Mb/s RX packets maybe handled */
  1251. return -EIO;
  1252. }
  1253. if (lp->lan_type == HP100_LAN_100)
  1254. lp->hub_status = hp100_login_to_vg_hub(dev, 0); /* relogin */
  1255. hp100_start_interface(dev);
  1256. }
  1257. return 0;
  1258. }
  1259. /*
  1260. * transmit functions
  1261. */
  1262. /* tx function for busmaster mode */
  1263. static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb,
  1264. struct net_device *dev)
  1265. {
  1266. unsigned long flags;
  1267. int i, ok_flag;
  1268. int ioaddr = dev->base_addr;
  1269. struct hp100_private *lp = netdev_priv(dev);
  1270. hp100_ring_t *ringptr;
  1271. #ifdef HP100_DEBUG_B
  1272. hp100_outw(0x4210, TRACE);
  1273. printk("hp100: %s: start_xmit_bm\n", dev->name);
  1274. #endif
  1275. if (skb->len <= 0)
  1276. goto drop;
  1277. if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN))
  1278. return NETDEV_TX_OK;
  1279. /* Get Tx ring tail pointer */
  1280. if (lp->txrtail->next == lp->txrhead) {
  1281. /* No memory. */
  1282. #ifdef HP100_DEBUG
  1283. printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name);
  1284. #endif
  1285. /* not waited long enough since last tx? */
  1286. if (time_before(jiffies, dev_trans_start(dev) + HZ))
  1287. goto drop;
  1288. if (hp100_check_lan(dev))
  1289. goto drop;
  1290. if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
  1291. /* we have a 100Mb/s adapter but it isn't connected to hub */
  1292. printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
  1293. hp100_stop_interface(dev);
  1294. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1295. hp100_start_interface(dev);
  1296. } else {
  1297. spin_lock_irqsave(&lp->lock, flags);
  1298. hp100_ints_off(); /* Useful ? Jean II */
  1299. i = hp100_sense_lan(dev);
  1300. hp100_ints_on();
  1301. spin_unlock_irqrestore(&lp->lock, flags);
  1302. if (i == HP100_LAN_ERR)
  1303. printk("hp100: %s: link down detected\n", dev->name);
  1304. else if (lp->lan_type != i) { /* cable change! */
  1305. /* it's very hard - all network settings must be changed!!! */
  1306. printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
  1307. lp->lan_type = i;
  1308. hp100_stop_interface(dev);
  1309. if (lp->lan_type == HP100_LAN_100)
  1310. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1311. hp100_start_interface(dev);
  1312. } else {
  1313. printk("hp100: %s: interface reset\n", dev->name);
  1314. hp100_stop_interface(dev);
  1315. if (lp->lan_type == HP100_LAN_100)
  1316. lp->hub_status = hp100_login_to_vg_hub(dev, 0);
  1317. hp100_start_interface(dev);
  1318. }
  1319. }
  1320. goto drop;
  1321. }
  1322. /*
  1323. * we have to turn int's off before modifying this, otherwise
  1324. * a tx_pdl_cleanup could occur at the same time
  1325. */
  1326. spin_lock_irqsave(&lp->lock, flags);
  1327. ringptr = lp->txrtail;
  1328. lp->txrtail = ringptr->next;
  1329. /* Check whether packet has minimal packet size */
  1330. ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
  1331. i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
  1332. ringptr->skb = skb;
  1333. ringptr->pdl[0] = ((1 << 16) | i); /* PDH: 1 Fragment & length */
  1334. if (lp->chip == HP100_CHIPID_SHASTA) {
  1335. /* TODO:Could someone who has the EISA card please check if this works? */
  1336. ringptr->pdl[2] = i;
  1337. } else { /* Lassen */
  1338. /* In the PDL, don't use the padded size but the real packet size: */
  1339. ringptr->pdl[2] = skb->len; /* 1st Frag: Length of frag */
  1340. }
  1341. /* Conversion to new PCI API : map skbuf data to PCI bus.
  1342. * Doc says it's OK for EISA as well - Jean II */
  1343. ringptr->pdl[1] = ((u32) pci_map_single(lp->pci_dev, skb->data, ringptr->pdl[2], PCI_DMA_TODEVICE)); /* 1st Frag: Adr. of data */
  1344. /* Hand this PDL to the card. */
  1345. hp100_outl(ringptr->pdl_paddr, TX_PDA_L); /* Low Prio. Queue */
  1346. lp->txrcommit++;
  1347. dev->stats.tx_packets++;
  1348. dev->stats.tx_bytes += skb->len;
  1349. spin_unlock_irqrestore(&lp->lock, flags);
  1350. return NETDEV_TX_OK;
  1351. drop:
  1352. dev_kfree_skb(skb);
  1353. return NETDEV_TX_OK;
  1354. }
  1355. /* clean_txring checks if packets have been sent by the card by reading
  1356. * the TX_PDL register from the performance page and comparing it to the
  1357. * number of committed packets. It then frees the skb's of the packets that
  1358. * obviously have been sent to the network.
  1359. *
  1360. * Needs the PERFORMANCE page selected.
  1361. */
  1362. static void hp100_clean_txring(struct net_device *dev)
  1363. {
  1364. struct hp100_private *lp = netdev_priv(dev);
  1365. int ioaddr = dev->base_addr;
  1366. int donecount;
  1367. #ifdef HP100_DEBUG_B
  1368. hp100_outw(0x4211, TRACE);
  1369. printk("hp100: %s: clean txring\n", dev->name);
  1370. #endif
  1371. /* How many PDLs have been transmitted? */
  1372. donecount = (lp->txrcommit) - hp100_inb(TX_PDL);
  1373. #ifdef HP100_DEBUG
  1374. if (donecount > MAX_TX_PDL)
  1375. printk("hp100: %s: Warning: More PDLs transmitted than committed to card???\n", dev->name);
  1376. #endif
  1377. for (; 0 != donecount; donecount--) {
  1378. #ifdef HP100_DEBUG_BM
  1379. printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n",
  1380. dev->name, (u_int) lp->txrhead->skb->data,
  1381. lp->txrcommit, hp100_inb(TX_PDL), donecount);
  1382. #endif
  1383. /* Conversion to new PCI API : NOP */
  1384. pci_unmap_single(lp->pci_dev, (dma_addr_t) lp->txrhead->pdl[1], lp->txrhead->pdl[2], PCI_DMA_TODEVICE);
  1385. dev_consume_skb_any(lp->txrhead->skb);
  1386. lp->txrhead->skb = NULL;
  1387. lp->txrhead = lp->txrhead->next;
  1388. lp->txrcommit--;
  1389. }
  1390. }
  1391. /* tx function for slave modes */
  1392. static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
  1393. struct net_device *dev)
  1394. {
  1395. unsigned long flags;
  1396. int i, ok_flag;
  1397. int ioaddr = dev->base_addr;
  1398. u_short val;
  1399. struct hp100_private *lp = netdev_priv(dev);
  1400. #ifdef HP100_DEBUG_B
  1401. hp100_outw(0x4212, TRACE);
  1402. printk("hp100: %s: start_xmit\n", dev->name);
  1403. #endif
  1404. if (skb->len <= 0)
  1405. goto drop;
  1406. if (hp100_check_lan(dev))
  1407. goto drop;
  1408. /* If there is not enough free memory on the card... */
  1409. i = hp100_i