eexpress.c 45 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734
  1. /* Intel EtherExpress 16 device driver for Linux
  2. *
  3. * Written by John Sullivan, 1995
  4. * based on original code by Donald Becker, with changes by
  5. * Alan Cox and Pauline Middelink.
  6. *
  7. * Support for 8-bit mode by Zoltan Szilagyi <zoltans@cs.arizona.edu>
  8. *
  9. * Many modifications, and currently maintained, by
  10. * Philip Blundell <philb@gnu.org>
  11. * Added the Compaq LTE Alan Cox <alan@redhat.com>
  12. * Added MCA support Adam Fritzler <mid@auk.cx>
  13. *
  14. * Note - this driver is experimental still - it has problems on faster
  15. * machines. Someone needs to sit down and go through it line by line with
  16. * a databook...
  17. */
  18. /* The EtherExpress 16 is a fairly simple card, based on a shared-memory
  19. * design using the i82586 Ethernet coprocessor. It bears no relationship,
  20. * as far as I know, to the similarly-named "EtherExpress Pro" range.
  21. *
  22. * Historically, Linux support for these cards has been very bad. However,
  23. * things seem to be getting better slowly.
  24. */
  25. /* If your card is confused about what sort of interface it has (eg it
  26. * persistently reports "10baseT" when none is fitted), running 'SOFTSET /BART'
  27. * or 'SOFTSET /LISA' from DOS seems to help.
  28. */
  29. /* Here's the scoop on memory mapping.
  30. *
  31. * There are three ways to access EtherExpress card memory: either using the
  32. * shared-memory mapping, or using PIO through the dataport, or using PIO
  33. * through the "shadow memory" ports.
  34. *
  35. * The shadow memory system works by having the card map some of its memory
  36. * as follows:
  37. *
  38. * (the low five bits of the SMPTR are ignored)
  39. *
  40. * base+0x4000..400f memory at SMPTR+0..15
  41. * base+0x8000..800f memory at SMPTR+16..31
  42. * base+0xc000..c007 dubious stuff (memory at SMPTR+16..23 apparently)
  43. * base+0xc008..c00f memory at 0x0008..0x000f
  44. *
  45. * This last set (the one at c008) is particularly handy because the SCB
  46. * lives at 0x0008. So that set of ports gives us easy random access to data
  47. * in the SCB without having to mess around setting up pointers and the like.
  48. * We always use this method to access the SCB (via the scb_xx() functions).
  49. *
  50. * Dataport access works by aiming the appropriate (read or write) pointer
  51. * at the first address you're interested in, and then reading or writing from
  52. * the dataport. The pointers auto-increment after each transfer. We use
  53. * this for data transfer.
  54. *
  55. * We don't use the shared-memory system because it allegedly doesn't work on
  56. * all cards, and because it's a bit more prone to go wrong (it's one more
  57. * thing to configure...).
  58. */
  59. /* Known bugs:
  60. *
  61. * - The card seems to want to give us two interrupts every time something
  62. * happens, where just one would be better.
  63. */
  64. /*
  65. *
  66. * Note by Zoltan Szilagyi 10-12-96:
  67. *
  68. * I've succeeded in eliminating the "CU wedged" messages, and hence the
  69. * lockups, which were only occurring with cards running in 8-bit mode ("force
  70. * 8-bit operation" in Intel's SoftSet utility). This version of the driver
  71. * sets the 82586 and the ASIC to 8-bit mode at startup; it also stops the
  72. * CU before submitting a packet for transmission, and then restarts it as soon
  73. * as the process of handing the packet is complete. This is definitely an
  74. * unnecessary slowdown if the card is running in 16-bit mode; therefore one
  75. * should detect 16-bit vs 8-bit mode from the EEPROM settings and act
  76. * accordingly. In 8-bit mode with this bugfix I'm getting about 150 K/s for
  77. * ftp's, which is significantly better than I get in DOS, so the overhead of
  78. * stopping and restarting the CU with each transmit is not prohibitive in
  79. * practice.
  80. *
  81. * Update by David Woodhouse 11/5/99:
  82. *
  83. * I've seen "CU wedged" messages in 16-bit mode, on the Alpha architecture.
  84. * I assume that this is because 16-bit accesses are actually handled as two
  85. * 8-bit accesses.
  86. */
  87. #ifdef __alpha__
  88. #define LOCKUP16 1
  89. #endif
  90. #ifndef LOCKUP16
  91. #define LOCKUP16 0
  92. #endif
  93. #include <linux/module.h>
  94. #include <linux/kernel.h>
  95. #include <linux/types.h>
  96. #include <linux/fcntl.h>
  97. #include <linux/interrupt.h>
  98. #include <linux/ioport.h>
  99. #include <linux/string.h>
  100. #include <linux/in.h>
  101. #include <linux/delay.h>
  102. #include <linux/errno.h>
  103. #include <linux/init.h>
  104. #include <linux/netdevice.h>
  105. #include <linux/etherdevice.h>
  106. #include <linux/skbuff.h>
  107. #include <linux/slab.h>
  108. #include <linux/mca-legacy.h>
  109. #include <linux/spinlock.h>
  110. #include <linux/bitops.h>
  111. #include <asm/system.h>
  112. #include <asm/io.h>
  113. #include <asm/irq.h>
  114. #ifndef NET_DEBUG
  115. #define NET_DEBUG 4
  116. #endif
  117. #include "eexpress.h"
  118. #define EEXP_IO_EXTENT 16
  119. /*
  120. * Private data declarations
  121. */
  122. struct net_local
  123. {
  124. struct net_device_stats stats;
  125. unsigned long last_tx; /* jiffies when last transmit started */
  126. unsigned long init_time; /* jiffies when eexp_hw_init586 called */
  127. unsigned short rx_first; /* first rx buf, same as RX_BUF_START */
  128. unsigned short rx_last; /* last rx buf */
  129. unsigned short rx_ptr; /* first rx buf to look at */
  130. unsigned short tx_head; /* next free tx buf */
  131. unsigned short tx_reap; /* first in-use tx buf */
  132. unsigned short tx_tail; /* previous tx buf to tx_head */
  133. unsigned short tx_link; /* last known-executing tx buf */
  134. unsigned short last_tx_restart; /* set to tx_link when we
  135. restart the CU */
  136. unsigned char started;
  137. unsigned short rx_buf_start;
  138. unsigned short rx_buf_end;
  139. unsigned short num_tx_bufs;
  140. unsigned short num_rx_bufs;
  141. unsigned char width; /* 0 for 16bit, 1 for 8bit */
  142. unsigned char was_promisc;
  143. unsigned char old_mc_count;
  144. spinlock_t lock;
  145. };
  146. /* This is the code and data that is downloaded to the EtherExpress card's
  147. * memory at boot time.
  148. */
  149. static unsigned short start_code[] = {
  150. /* 0x0000 */
  151. 0x0001, /* ISCP: busy - cleared after reset */
  152. 0x0008,0x0000,0x0000, /* offset,address (lo,hi) of SCB */
  153. 0x0000,0x0000, /* SCB: status, commands */
  154. 0x0000,0x0000, /* links to first command block,
  155. first receive descriptor */
  156. 0x0000,0x0000, /* CRC error, alignment error counts */
  157. 0x0000,0x0000, /* out of resources, overrun error counts */
  158. 0x0000,0x0000, /* pad */
  159. 0x0000,0x0000,
  160. /* 0x20 -- start of 82586 CU program */
  161. #define CONF_LINK 0x20
  162. 0x0000,Cmd_Config,
  163. 0x0032, /* link to next command */
  164. 0x080c, /* 12 bytes follow : fifo threshold=8 */
  165. 0x2e40, /* don't rx bad frames
  166. * SRDY/ARDY => ext. sync. : preamble len=8
  167. * take addresses from data buffers
  168. * 6 bytes/address
  169. */
  170. 0x6000, /* default backoff method & priority
  171. * interframe spacing = 0x60 */
  172. 0xf200, /* slot time=0x200
  173. * max collision retry = 0xf */
  174. #define CONF_PROMISC 0x2e
  175. 0x0000, /* no HDLC : normal CRC : enable broadcast
  176. * disable promiscuous/multicast modes */
  177. 0x003c, /* minimum frame length = 60 octets) */
  178. 0x0000,Cmd_SetAddr,
  179. 0x003e, /* link to next command */
  180. #define CONF_HWADDR 0x38
  181. 0x0000,0x0000,0x0000, /* hardware address placed here */
  182. 0x0000,Cmd_MCast,
  183. 0x0076, /* link to next command */
  184. #define CONF_NR_MULTICAST 0x44
  185. 0x0000, /* number of multicast addresses */
  186. #define CONF_MULTICAST 0x46
  187. 0x0000, 0x0000, 0x0000, /* some addresses */
  188. 0x0000, 0x0000, 0x0000,
  189. 0x0000, 0x0000, 0x0000,
  190. 0x0000, 0x0000, 0x0000,
  191. 0x0000, 0x0000, 0x0000,
  192. 0x0000, 0x0000, 0x0000,
  193. 0x0000, 0x0000, 0x0000,
  194. 0x0000, 0x0000, 0x0000,
  195. #define CONF_DIAG_RESULT 0x76
  196. 0x0000, Cmd_Diag,
  197. 0x007c, /* link to next command */
  198. 0x0000,Cmd_TDR|Cmd_INT,
  199. 0x0084,
  200. #define CONF_TDR_RESULT 0x82
  201. 0x0000,
  202. 0x0000,Cmd_END|Cmd_Nop, /* end of configure sequence */
  203. 0x0084 /* dummy link */
  204. };
  205. /* maps irq number to EtherExpress magic value */
  206. static char irqrmap[] = { 0,0,1,2,3,4,0,0,0,1,5,6,0,0,0,0 };
  207. #ifdef CONFIG_MCA_LEGACY
  208. /* mapping of the first four bits of the second POS register */
  209. static unsigned short mca_iomap[] = {
  210. 0x270, 0x260, 0x250, 0x240, 0x230, 0x220, 0x210, 0x200,
  211. 0x370, 0x360, 0x350, 0x340, 0x330, 0x320, 0x310, 0x300
  212. };
  213. /* bits 5-7 of the second POS register */
  214. static char mca_irqmap[] = { 12, 9, 3, 4, 5, 10, 11, 15 };
  215. #endif
  216. /*
  217. * Prototypes for Linux interface
  218. */
  219. static int eexp_open(struct net_device *dev);
  220. static int eexp_close(struct net_device *dev);
  221. static void eexp_timeout(struct net_device *dev);
  222. static struct net_device_stats *eexp_stats(struct net_device *dev);
  223. static int eexp_xmit(struct sk_buff *buf, struct net_device *dev);
  224. static irqreturn_t eexp_irq(int irq, void *dev_addr);
  225. static void eexp_set_multicast(struct net_device *dev);
  226. /*
  227. * Prototypes for hardware access functions
  228. */
  229. static void eexp_hw_rx_pio(struct net_device *dev);
  230. static void eexp_hw_tx_pio(struct net_device *dev, unsigned short *buf,
  231. unsigned short len);
  232. static int eexp_hw_probe(struct net_device *dev,unsigned short ioaddr);
  233. static unsigned short eexp_hw_readeeprom(unsigned short ioaddr,
  234. unsigned char location);
  235. static unsigned short eexp_hw_lasttxstat(struct net_device *dev);
  236. static void eexp_hw_txrestart(struct net_device *dev);
  237. static void eexp_hw_txinit (struct net_device *dev);
  238. static void eexp_hw_rxinit (struct net_device *dev);
  239. static void eexp_hw_init586 (struct net_device *dev);
  240. static void eexp_setup_filter (struct net_device *dev);
  241. static char *eexp_ifmap[]={"AUI", "BNC", "RJ45"};
  242. enum eexp_iftype {AUI=0, BNC=1, TPE=2};
  243. #define STARTED_RU 2
  244. #define STARTED_CU 1
  245. /*
  246. * Primitive hardware access functions.
  247. */
  248. static inline unsigned short scb_status(struct net_device *dev)
  249. {
  250. return inw(dev->base_addr + 0xc008);
  251. }
  252. static inline unsigned short scb_rdcmd(struct net_device *dev)
  253. {
  254. return inw(dev->base_addr + 0xc00a);
  255. }
  256. static inline void scb_command(struct net_device *dev, unsigned short cmd)
  257. {
  258. outw(cmd, dev->base_addr + 0xc00a);
  259. }
  260. static inline void scb_wrcbl(struct net_device *dev, unsigned short val)
  261. {
  262. outw(val, dev->base_addr + 0xc00c);
  263. }
  264. static inline void scb_wrrfa(struct net_device *dev, unsigned short val)
  265. {
  266. outw(val, dev->base_addr + 0xc00e);
  267. }
  268. static inline void set_loopback(struct net_device *dev)
  269. {
  270. outb(inb(dev->base_addr + Config) | 2, dev->base_addr + Config);
  271. }
  272. static inline void clear_loopback(struct net_device *dev)
  273. {
  274. outb(inb(dev->base_addr + Config) & ~2, dev->base_addr + Config);
  275. }
  276. static inline unsigned short int SHADOW(short int addr)
  277. {
  278. addr &= 0x1f;
  279. if (addr > 0xf) addr += 0x3ff0;
  280. return addr + 0x4000;
  281. }
  282. /*
  283. * Linux interface
  284. */
  285. /*
  286. * checks for presence of EtherExpress card
  287. */
  288. static int __init do_express_probe(struct net_device *dev)
  289. {
  290. unsigned short *port;
  291. static unsigned short ports[] = { 0x240,0x300,0x310,0x270,0x320,0x340,0 };
  292. unsigned short ioaddr = dev->base_addr;
  293. int dev_irq = dev->irq;
  294. int err;
  295. SET_MODULE_OWNER(dev);
  296. dev->if_port = 0xff; /* not set */
  297. #ifdef CONFIG_MCA_LEGACY
  298. if (MCA_bus) {
  299. int slot = 0;
  300. /*
  301. * Only find one card at a time. Subsequent calls
  302. * will find others, however, proper multicard MCA
  303. * probing and setup can't be done with the
  304. * old-style Space.c init routines. -- ASF
  305. */
  306. while (slot != MCA_NOTFOUND) {
  307. int pos0, pos1;
  308. slot = mca_find_unused_adapter(0x628B, slot);
  309. if (slot == MCA_NOTFOUND)
  310. break;
  311. pos0 = mca_read_stored_pos(slot, 2);
  312. pos1 = mca_read_stored_pos(slot, 3);
  313. ioaddr = mca_iomap[pos1&0xf];
  314. dev->irq = mca_irqmap[(pos1>>4)&0x7];
  315. /*
  316. * XXX: Transciever selection is done
  317. * differently on the MCA version.
  318. * How to get it to select something
  319. * other than external/AUI is currently
  320. * unknown. This code is just for looks. -- ASF
  321. */
  322. if ((pos0 & 0x7) == 0x1)
  323. dev->if_port = AUI;
  324. else if ((pos0 & 0x7) == 0x5) {
  325. if (pos1 & 0x80)
  326. dev->if_port = BNC;
  327. else
  328. dev->if_port = TPE;
  329. }
  330. mca_set_adapter_name(slot, "Intel EtherExpress 16 MCA");
  331. mca_set_adapter_procfn(slot, NULL, dev);
  332. mca_mark_as_used(slot);
  333. break;
  334. }
  335. }
  336. #endif
  337. if (ioaddr&0xfe00) {
  338. if (!request_region(ioaddr, EEXP_IO_EXTENT, "EtherExpress"))
  339. return -EBUSY;
  340. err = eexp_hw_probe(dev,ioaddr);
  341. release_region(ioaddr, EEXP_IO_EXTENT);
  342. return err;
  343. } else if (ioaddr)
  344. return -ENXIO;
  345. for (port=&ports[0] ; *port ; port++ )
  346. {
  347. unsigned short sum = 0;
  348. int i;
  349. if (!request_region(*port, EEXP_IO_EXTENT, "EtherExpress"))
  350. continue;
  351. for ( i=0 ; i<4 ; i++ )
  352. {
  353. unsigned short t;
  354. t = inb(*port + ID_PORT);
  355. sum |= (t>>4) << ((t & 0x03)<<2);
  356. }
  357. if (sum==0xbaba && !eexp_hw_probe(dev,*port)) {
  358. release_region(*port, EEXP_IO_EXTENT);
  359. return 0;
  360. }
  361. release_region(*port, EEXP_IO_EXTENT);
  362. dev->irq = dev_irq;
  363. }
  364. return -ENODEV;
  365. }
  366. #ifndef MODULE
  367. struct net_device * __init express_probe(int unit)
  368. {
  369. struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
  370. int err;
  371. if (!dev)
  372. return ERR_PTR(-ENOMEM);
  373. sprintf(dev->name, "eth%d", unit);
  374. netdev_boot_setup_check(dev);
  375. err = do_express_probe(dev);
  376. if (!err)
  377. return dev;
  378. free_netdev(dev);
  379. return ERR_PTR(err);
  380. }
  381. #endif
  382. /*
  383. * open and initialize the adapter, ready for use
  384. */
  385. static int eexp_open(struct net_device *dev)
  386. {
  387. int ret;
  388. unsigned short ioaddr = dev->base_addr;
  389. struct net_local *lp = netdev_priv(dev);
  390. #if NET_DEBUG > 6
  391. printk(KERN_DEBUG "%s: eexp_open()\n", dev->name);
  392. #endif
  393. if (!dev->irq || !irqrmap[dev->irq])
  394. return -ENXIO;
  395. ret = request_irq(dev->irq,&eexp_irq,0,dev->name,dev);
  396. if (ret) return ret;
  397. if (!request_region(ioaddr, EEXP_IO_EXTENT, "EtherExpress")) {
  398. printk(KERN_WARNING "EtherExpress io port %x, is busy.\n"
  399. , ioaddr);
  400. goto err_out1;
  401. }
  402. if (!request_region(ioaddr+0x4000, EEXP_IO_EXTENT, "EtherExpress shadow")) {
  403. printk(KERN_WARNING "EtherExpress io port %x, is busy.\n"
  404. , ioaddr+0x4000);
  405. goto err_out2;
  406. }
  407. if (!request_region(ioaddr+0x8000, EEXP_IO_EXTENT, "EtherExpress shadow")) {
  408. printk(KERN_WARNING "EtherExpress io port %x, is busy.\n"
  409. , ioaddr+0x8000);
  410. goto err_out3;
  411. }
  412. if (!request_region(ioaddr+0xc000, EEXP_IO_EXTENT, "EtherExpress shadow")) {
  413. printk(KERN_WARNING "EtherExpress io port %x, is busy.\n"
  414. , ioaddr+0xc000);
  415. goto err_out4;
  416. }
  417. if (lp->width) {
  418. printk("%s: forcing ASIC to 8-bit mode\n", dev->name);
  419. outb(inb(dev->base_addr+Config)&~4, dev->base_addr+Config);
  420. }
  421. eexp_hw_init586(dev);
  422. netif_start_queue(dev);
  423. #if NET_DEBUG > 6
  424. printk(KERN_DEBUG "%s: leaving eexp_open()\n", dev->name);
  425. #endif
  426. return 0;
  427. err_out4:
  428. release_region(ioaddr+0x8000, EEXP_IO_EXTENT);
  429. err_out3:
  430. release_region(ioaddr+0x4000, EEXP_IO_EXTENT);
  431. err_out2:
  432. release_region(ioaddr, EEXP_IO_EXTENT);
  433. err_out1:
  434. free_irq(dev->irq, dev);
  435. return -EBUSY;
  436. }
  437. /*
  438. * close and disable the interface, leaving the 586 in reset.
  439. */
  440. static int eexp_close(struct net_device *dev)
  441. {
  442. unsigned short ioaddr = dev->base_addr;
  443. struct net_local *lp = netdev_priv(dev);
  444. int irq = dev->irq;
  445. netif_stop_queue(dev);
  446. outb(SIRQ_dis|irqrmap[irq],ioaddr+SET_IRQ);
  447. lp->started = 0;
  448. scb_command(dev, SCB_CUsuspend|SCB_RUsuspend);
  449. outb(0,ioaddr+SIGNAL_CA);
  450. free_irq(irq,dev);
  451. outb(i586_RST,ioaddr+EEPROM_Ctrl);
  452. release_region(ioaddr, EEXP_IO_EXTENT);
  453. release_region(ioaddr+0x4000, 16);
  454. release_region(ioaddr+0x8000, 16);
  455. release_region(ioaddr+0xc000, 16);
  456. return 0;
  457. }
  458. /*
  459. * Return interface stats
  460. */
  461. static struct net_device_stats *eexp_stats(struct net_device *dev)
  462. {
  463. struct net_local *lp = netdev_priv(dev);
  464. return &lp->stats;
  465. }
  466. /*
  467. * This gets called when a higher level thinks we are broken. Check that
  468. * nothing has become jammed in the CU.
  469. */
  470. static void unstick_cu(struct net_device *dev)
  471. {
  472. struct net_local *lp = netdev_priv(dev);
  473. unsigned short ioaddr = dev->base_addr;
  474. if (lp->started)
  475. {
  476. if ((jiffies - dev->trans_start)>50)
  477. {
  478. if (lp->tx_link==lp->last_tx_restart)
  479. {
  480. unsigned short boguscount=200,rsst;
  481. printk(KERN_WARNING "%s: Retransmit timed out, status %04x, resetting...\n",
  482. dev->name, scb_status(dev));
  483. eexp_hw_txinit(dev);
  484. lp->last_tx_restart = 0;
  485. scb_wrcbl(dev, lp->tx_link);
  486. scb_command(dev, SCB_CUstart);
  487. outb(0,ioaddr+SIGNAL_CA);
  488. while (!SCB_complete(rsst=scb_status(dev)))
  489. {
  490. if (!--boguscount)
  491. {
  492. boguscount=200;
  493. printk(KERN_WARNING "%s: Reset timed out status %04x, retrying...\n",
  494. dev->name,rsst);
  495. scb_wrcbl(dev, lp->tx_link);
  496. scb_command(dev, SCB_CUstart);
  497. outb(0,ioaddr+SIGNAL_CA);
  498. }
  499. }
  500. netif_wake_queue(dev);
  501. }
  502. else
  503. {
  504. unsigned short status = scb_status(dev);
  505. if (SCB_CUdead(status))
  506. {
  507. unsigned short txstatus = eexp_hw_lasttxstat(dev);
  508. printk(KERN_WARNING "%s: Transmit timed out, CU not active status %04x %04x, restarting...\n",
  509. dev->name, status, txstatus);
  510. eexp_hw_txrestart(dev);
  511. }
  512. else
  513. {
  514. unsigned short txstatus = eexp_hw_lasttxstat(dev);
  515. if (netif_queue_stopped(dev) && !txstatus)
  516. {
  517. printk(KERN_WARNING "%s: CU wedged, status %04x %04x, resetting...\n",
  518. dev->name,status,txstatus);
  519. eexp_hw_init586(dev);
  520. netif_wake_queue(dev);
  521. }
  522. else
  523. {
  524. printk(KERN_WARNING "%s: transmit timed out\n", dev->name);
  525. }
  526. }
  527. }
  528. }
  529. }
  530. else
  531. {
  532. if ((jiffies-lp->init_time)>10)
  533. {
  534. unsigned short status = scb_status(dev);
  535. printk(KERN_WARNING "%s: i82586 startup timed out, status %04x, resetting...\n",
  536. dev->name, status);
  537. eexp_hw_init586(dev);
  538. netif_wake_queue(dev);
  539. }
  540. }
  541. }
  542. static void eexp_timeout(struct net_device *dev)
  543. {
  544. struct net_local *lp = netdev_priv(dev);
  545. #ifdef CONFIG_SMP
  546. unsigned long flags;
  547. #endif
  548. int status;
  549. disable_irq(dev->irq);
  550. /*
  551. * Best would be to use synchronize_irq(); spin_lock() here
  552. * lets make it work first..
  553. */
  554. #ifdef CONFIG_SMP
  555. spin_lock_irqsave(&lp->lock, flags);
  556. #endif
  557. status = scb_status(dev);
  558. unstick_cu(dev);
  559. printk(KERN_INFO "%s: transmit timed out, %s?\n", dev->name,
  560. (SCB_complete(status)?"lost interrupt":
  561. "board on fire"));
  562. lp->stats.tx_errors++;
  563. lp->last_tx = jiffies;
  564. if (!SCB_complete(status)) {
  565. scb_command(dev, SCB_CUabort);
  566. outb(0,dev->base_addr+SIGNAL_CA);
  567. }
  568. netif_wake_queue(dev);
  569. #ifdef CONFIG_SMP
  570. spin_unlock_irqrestore(&lp->lock, flags);
  571. #endif
  572. }
  573. /*
  574. * Called to transmit a packet, or to allow us to right ourselves
  575. * if the kernel thinks we've died.
  576. */
  577. static int eexp_xmit(struct sk_buff *buf, struct net_device *dev)
  578. {
  579. struct net_local *lp = netdev_priv(dev);
  580. short length = buf->len;
  581. #ifdef CONFIG_SMP
  582. unsigned long flags;
  583. #endif
  584. #if NET_DEBUG > 6
  585. printk(KERN_DEBUG "%s: eexp_xmit()\n", dev->name);
  586. #endif
  587. if (buf->len < ETH_ZLEN) {
  588. if (skb_padto(buf, ETH_ZLEN))
  589. return 0;
  590. length = ETH_ZLEN;
  591. }
  592. disable_irq(dev->irq);
  593. /*
  594. * Best would be to use synchronize_irq(); spin_lock() here
  595. * lets make it work first..
  596. */
  597. #ifdef CONFIG_SMP
  598. spin_lock_irqsave(&lp->lock, flags);
  599. #endif
  600. {
  601. unsigned short *data = (unsigned short *)buf->data;
  602. lp->stats.tx_bytes += length;
  603. eexp_hw_tx_pio(dev,data,length);
  604. }
  605. dev_kfree_skb(buf);
  606. #ifdef CONFIG_SMP
  607. spin_unlock_irqrestore(&lp->lock, flags);
  608. #endif
  609. enable_irq(dev->irq);
  610. return 0;
  611. }
  612. /*
  613. * Handle an EtherExpress interrupt
  614. * If we've finished initializing, start the RU and CU up.
  615. * If we've already started, reap tx buffers, handle any received packets,
  616. * check to make sure we've not become wedged.
  617. */
  618. static unsigned short eexp_start_irq(struct net_device *dev,
  619. unsigned short status)
  620. {
  621. unsigned short ack_cmd = SCB_ack(status);
  622. struct net_local *lp = netdev_priv(dev);
  623. unsigned short ioaddr = dev->base_addr;
  624. if ((dev->flags & IFF_UP) && !(lp->started & STARTED_CU)) {
  625. short diag_status, tdr_status;
  626. while (SCB_CUstat(status)==2)
  627. status = scb_status(dev);
  628. #if NET_DEBUG > 4
  629. printk("%s: CU went non-active (status %04x)\n",
  630. dev->name, status);
  631. #endif
  632. outw(CONF_DIAG_RESULT & ~31, ioaddr + SM_PTR);
  633. diag_status = inw(ioaddr + SHADOW(CONF_DIAG_RESULT));
  634. if (diag_status & 1<<11) {
  635. printk(KERN_WARNING "%s: 82586 failed self-test\n",
  636. dev->name);
  637. } else if (!(diag_status & 1<<13)) {
  638. printk(KERN_WARNING "%s: 82586 self-test failed to complete\n", dev->name);
  639. }
  640. outw(CONF_TDR_RESULT & ~31, ioaddr + SM_PTR);
  641. tdr_status = inw(ioaddr + SHADOW(CONF_TDR_RESULT));
  642. if (tdr_status & (TDR_SHORT|TDR_OPEN)) {
  643. printk(KERN_WARNING "%s: TDR reports cable %s at %d tick%s\n", dev->name, (tdr_status & TDR_SHORT)?"short":"broken", tdr_status & TDR_TIME, ((tdr_status & TDR_TIME) != 1) ? "s" : "");
  644. }
  645. else if (tdr_status & TDR_XCVRPROBLEM) {
  646. printk(KERN_WARNING "%s: TDR reports transceiver problem\n", dev->name);
  647. }
  648. else if (tdr_status & TDR_LINKOK) {
  649. #if NET_DEBUG > 4
  650. printk(KERN_DEBUG "%s: TDR reports link OK\n", dev->name);
  651. #endif
  652. } else {
  653. printk("%s: TDR is ga-ga (status %04x)\n", dev->name,
  654. tdr_status);
  655. }
  656. lp->started |= STARTED_CU;
  657. scb_wrcbl(dev, lp->tx_link);
  658. /* if the RU isn't running, start it now */
  659. if (!(lp->started & STARTED_RU)) {
  660. ack_cmd |= SCB_RUstart;
  661. scb_wrrfa(dev, lp->rx_buf_start);
  662. lp->rx_ptr = lp->rx_buf_start;
  663. lp->started |= STARTED_RU;
  664. }
  665. ack_cmd |= SCB_CUstart | 0x2000;
  666. }
  667. if ((dev->flags & IFF_UP) && !(lp->started & STARTED_RU) && SCB_RUstat(status)==4)
  668. lp->started|=STARTED_RU;
  669. return ack_cmd;
  670. }
  671. static void eexp_cmd_clear(struct net_device *dev)
  672. {
  673. unsigned long int oldtime = jiffies;
  674. while (scb_rdcmd(dev) && ((jiffies-oldtime)<10));
  675. if (scb_rdcmd(dev)) {
  676. printk("%s: command didn't clear\n", dev->name);
  677. }
  678. }
  679. static irqreturn_t eexp_irq(int irq, void *dev_info)
  680. {
  681. struct net_device *dev = dev_info;
  682. struct net_local *lp;
  683. unsigned short ioaddr,status,ack_cmd;
  684. unsigned short old_read_ptr, old_write_ptr;
  685. lp = netdev_priv(dev);
  686. ioaddr = dev->base_addr;
  687. spin_lock(&lp->lock);
  688. old_read_ptr = inw(ioaddr+READ_PTR);
  689. old_write_ptr = inw(ioaddr+WRITE_PTR);
  690. outb(SIRQ_dis|irqrmap[irq],ioaddr+SET_IRQ);
  691. status = scb_status(dev);
  692. #if NET_DEBUG > 4
  693. printk(KERN_DEBUG "%s: interrupt (status %x)\n", dev->name, status);
  694. #endif
  695. if (lp->started == (STARTED_CU | STARTED_RU)) {
  696. do {
  697. eexp_cmd_clear(dev);
  698. ack_cmd = SCB_ack(status);
  699. scb_command(dev, ack_cmd);
  700. outb(0,ioaddr+SIGNAL_CA);
  701. eexp_cmd_clear(dev);
  702. if (SCB_complete(status)) {
  703. if (!eexp_hw_lasttxstat(dev)) {
  704. printk("%s: tx interrupt but no status\n", dev->name);
  705. }
  706. }
  707. if (SCB_rxdframe(status))
  708. eexp_hw_rx_pio(dev);
  709. status = scb_status(dev);
  710. } while (status & 0xc000);
  711. if (SCB_RUdead(status))
  712. {
  713. printk(KERN_WARNING "%s: RU stopped: status %04x\n",
  714. dev->name,status);
  715. #if 0
  716. printk(KERN_WARNING "%s: cur_rfd=%04x, cur_rbd=%04x\n", dev->name, lp->cur_rfd, lp->cur_rbd);
  717. outw(lp->cur_rfd, ioaddr+READ_PTR);
  718. printk(KERN_WARNING "%s: [%04x]\n", dev->name, inw(ioaddr+DATAPORT));
  719. outw(lp->cur_rfd+6, ioaddr+READ_PTR);
  720. printk(KERN_WARNING "%s: rbd is %04x\n", dev->name, rbd= inw(ioaddr+DATAPORT));
  721. outw(rbd, ioaddr+READ_PTR);
  722. printk(KERN_WARNING "%s: [%04x %04x] ", dev->name, inw(ioaddr+DATAPORT), inw(ioaddr+DATAPORT));
  723. outw(rbd+8, ioaddr+READ_PTR);
  724. printk("[%04x]\n", inw(ioaddr+DATAPORT));
  725. #endif
  726. lp->stats.rx_errors++;
  727. #if 1
  728. eexp_hw_rxinit(dev);
  729. #else
  730. lp->cur_rfd = lp->first_rfd;
  731. #endif
  732. scb_wrrfa(dev, lp->rx_buf_start);
  733. scb_command(dev, SCB_RUstart);
  734. outb(0,ioaddr+SIGNAL_CA);
  735. }
  736. } else {
  737. if (status & 0x8000)
  738. ack_cmd = eexp_start_irq(dev, status);
  739. else
  740. ack_cmd = SCB_ack(status);
  741. scb_command(dev, ack_cmd);
  742. outb(0,ioaddr+SIGNAL_CA);
  743. }
  744. eexp_cmd_clear(dev);
  745. outb(SIRQ_en|irqrmap[irq],ioaddr+SET_IRQ);
  746. #if NET_DEBUG > 6
  747. printk("%s: leaving eexp_irq()\n", dev->name);
  748. #endif
  749. outw(old_read_ptr, ioaddr+READ_PTR);
  750. outw(old_write_ptr, ioaddr+WRITE_PTR);
  751. spin_unlock(&lp->lock);
  752. return IRQ_HANDLED;
  753. }
  754. /*
  755. * Hardware access functions
  756. */
  757. /*
  758. * Set the cable type to use.
  759. */
  760. static void eexp_hw_set_interface(struct net_device *dev)
  761. {
  762. unsigned char oldval = inb(dev->base_addr + 0x300e);
  763. oldval &= ~0x82;
  764. switch (dev->if_port) {
  765. case TPE:
  766. oldval |= 0x2;
  767. case BNC:
  768. oldval |= 0x80;
  769. break;
  770. }
  771. outb(oldval, dev->base_addr+0x300e);
  772. mdelay(20);
  773. }
  774. /*
  775. * Check all the receive buffers, and hand any received packets
  776. * to the upper levels. Basic sanity check on each frame
  777. * descriptor, though we don't bother trying to fix broken ones.
  778. */
  779. static void eexp_hw_rx_pio(struct net_device *dev)
  780. {
  781. struct net_local *lp = netdev_priv(dev);
  782. unsigned short rx_block = lp->rx_ptr;
  783. unsigned short boguscount = lp->num_rx_bufs;
  784. unsigned short ioaddr = dev->base_addr;
  785. unsigned short status;
  786. #if NET_DEBUG > 6
  787. printk(KERN_DEBUG "%s: eexp_hw_rx()\n", dev->name);
  788. #endif
  789. do {
  790. unsigned short rfd_cmd, rx_next, pbuf, pkt_len;
  791. outw(rx_block, ioaddr + READ_PTR);
  792. status = inw(ioaddr + DATAPORT);
  793. if (FD_Done(status))
  794. {
  795. rfd_cmd = inw(ioaddr + DATAPORT);
  796. rx_next = inw(ioaddr + DATAPORT);
  797. pbuf = inw(ioaddr + DATAPORT);
  798. outw(pbuf, ioaddr + READ_PTR);
  799. pkt_len = inw(ioaddr + DATAPORT);
  800. if (rfd_cmd!=0x0000)
  801. {
  802. printk(KERN_WARNING "%s: rfd_cmd not zero:0x%04x\n",
  803. dev->name, rfd_cmd);
  804. continue;
  805. }
  806. else if (pbuf!=rx_block+0x16)
  807. {
  808. printk(KERN_WARNING "%s: rfd and rbd out of sync 0x%04x 0x%04x\n",
  809. dev->name, rx_block+0x16, pbuf);
  810. continue;
  811. }
  812. else if ((pkt_len & 0xc000)!=0xc000)
  813. {
  814. printk(KERN_WARNING "%s: EOF or F not set on received buffer (%04x)\n",
  815. dev->name, pkt_len & 0xc000);
  816. continue;
  817. }
  818. else if (!FD_OK(status))
  819. {
  820. lp->stats.rx_errors++;
  821. if (FD_CRC(status))
  822. lp->stats.rx_crc_errors++;
  823. if (FD_Align(status))
  824. lp->stats.rx_frame_errors++;
  825. if (FD_Resrc(status))
  826. lp->stats.rx_fifo_errors++;
  827. if (FD_DMA(status))
  828. lp->stats.rx_over_errors++;
  829. if (FD_Short(status))
  830. lp->stats.rx_length_errors++;
  831. }
  832. else
  833. {
  834. struct sk_buff *skb;
  835. pkt_len &= 0x3fff;
  836. skb = dev_alloc_skb(pkt_len+16);
  837. if (skb == NULL)
  838. {
  839. printk(KERN_WARNING "%s: Memory squeeze, dropping packet\n",dev->name);
  840. lp->stats.rx_dropped++;
  841. break;
  842. }
  843. skb->dev = dev;
  844. skb_reserve(skb, 2);
  845. outw(pbuf+10, ioaddr+READ_PTR);
  846. insw(ioaddr+DATAPORT, skb_put(skb,pkt_len),(pkt_len+1)>>1);
  847. skb->protocol = eth_type_trans(skb,dev);
  848. netif_rx(skb);
  849. dev->last_rx = jiffies;
  850. lp->stats.rx_packets++;
  851. lp->stats.rx_bytes += pkt_len;
  852. }
  853. outw(rx_block, ioaddr+WRITE_PTR);
  854. outw(0, ioaddr+DATAPORT);
  855. outw(0, ioaddr+DATAPORT);
  856. rx_block = rx_next;
  857. }
  858. } while (FD_Done(status) && boguscount--);
  859. lp->rx_ptr = rx_block;
  860. }
  861. /*
  862. * Hand a packet to the card for transmission
  863. * If we get here, we MUST have already checked
  864. * to make sure there is room in the transmit
  865. * buffer region.
  866. */
  867. static void eexp_hw_tx_pio(struct net_device *dev, unsigned short *buf,
  868. unsigned short len)
  869. {
  870. struct net_local *lp = netdev_priv(dev);
  871. unsigned short ioaddr = dev->base_addr;
  872. if (LOCKUP16 || lp->width) {
  873. /* Stop the CU so that there is no chance that it
  874. jumps off to a bogus address while we are writing the
  875. pointer to the next transmit packet in 8-bit mode --
  876. this eliminates the "CU wedged" errors in 8-bit mode.
  877. (Zoltan Szilagyi 10-12-96) */
  878. scb_command(dev, SCB_CUsuspend);
  879. outw(0xFFFF, ioaddr+SIGNAL_CA);
  880. }
  881. outw(lp->tx_head, ioaddr + WRITE_PTR);
  882. outw(0x0000, ioaddr + DATAPORT);
  883. outw(Cmd_INT|Cmd_Xmit, ioaddr + DATAPORT);
  884. outw(lp->tx_head+0x08, ioaddr + DATAPORT);
  885. outw(lp->tx_head+0x0e, ioaddr + DATAPORT);
  886. outw(0x0000, ioaddr + DATAPORT);
  887. outw(0x0000, ioaddr + DATAPORT);
  888. outw(lp->tx_head+0x08, ioaddr + DATAPORT);
  889. outw(0x8000|len, ioaddr + DATAPORT);
  890. outw(-1, ioaddr + DATAPORT);
  891. outw(lp->tx_head+0x16, ioaddr + DATAPORT);
  892. outw(0, ioaddr + DATAPORT);
  893. outsw(ioaddr + DATAPORT, buf, (len+1)>>1);
  894. outw(lp->tx_tail+0xc, ioaddr + WRITE_PTR);
  895. outw(lp->tx_head, ioaddr + DATAPORT);
  896. dev->trans_start = jiffies;
  897. lp->tx_tail = lp->tx_head;
  898. if (lp->tx_head==TX_BUF_START+((lp->num_tx_bufs-1)*TX_BUF_SIZE))
  899. lp->tx_head = TX_BUF_START;
  900. else
  901. lp->tx_head += TX_BUF_SIZE;
  902. if (lp->tx_head != lp->tx_reap)
  903. netif_wake_queue(dev);
  904. if (LOCKUP16 || lp->width) {
  905. /* Restart the CU so that the packet can actually
  906. be transmitted. (Zoltan Szilagyi 10-12-96) */
  907. scb_command(dev, SCB_CUresume);
  908. outw(0xFFFF, ioaddr+SIGNAL_CA);
  909. }
  910. lp->stats.tx_packets++;
  911. lp->last_tx = jiffies;
  912. }
  913. /*
  914. * Sanity check the suspected EtherExpress card
  915. * Read hardware address, reset card, size memory and initialize buffer
  916. * memory pointers. These are held in dev->priv, in case someone has more
  917. * than one card in a machine.
  918. */
  919. static int __init eexp_hw_probe(struct net_device *dev, unsigned short ioaddr)
  920. {
  921. unsigned short hw_addr[3];
  922. unsigned char buswidth;
  923. unsigned int memory_size;
  924. int i;
  925. unsigned short xsum = 0;
  926. struct net_local *lp = netdev_priv(dev);
  927. printk("%s: EtherExpress 16 at %#x ",dev->name,ioaddr);
  928. outb(ASIC_RST, ioaddr+EEPROM_Ctrl);
  929. outb(0, ioaddr+EEPROM_Ctrl);
  930. udelay(500);
  931. outb(i586_RST, ioaddr+EEPROM_Ctrl);
  932. hw_addr[0] = eexp_hw_readeeprom(ioaddr,2);
  933. hw_addr[1] = eexp_hw_readeeprom(ioaddr,3);
  934. hw_addr[2] = eexp_hw_readeeprom(ioaddr,4);
  935. /* Standard Address or Compaq LTE Address */
  936. if (!((hw_addr[2]==0x00aa && ((hw_addr[1] & 0xff00)==0x0000)) ||
  937. (hw_addr[2]==0x0080 && ((hw_addr[1] & 0xff00)==0x5F00))))
  938. {
  939. printk(" rejected: invalid address %04x%04x%04x\n",
  940. hw_addr[2],hw_addr[1],hw_addr[0]);
  941. return -ENODEV;
  942. }
  943. /* Calculate the EEPROM checksum. Carry on anyway if it's bad,
  944. * though.
  945. */
  946. for (i = 0; i < 64; i++)
  947. xsum += eexp_hw_readeeprom(ioaddr, i);
  948. if (xsum != 0xbaba)
  949. printk(" (bad EEPROM xsum 0x%02x)", xsum);
  950. dev->base_addr = ioaddr;
  951. for ( i=0 ; i<6 ; i++ )
  952. dev->dev_addr[i] = ((unsigned char *)hw_addr)[5-i];
  953. {
  954. static char irqmap[]={0, 9, 3, 4, 5, 10, 11, 0};
  955. unsigned short setupval = eexp_hw_readeeprom(ioaddr,0);
  956. /* Use the IRQ from EEPROM if none was given */
  957. if (!dev->irq)
  958. dev->irq = irqmap[setupval>>13];
  959. if (dev->if_port == 0xff) {
  960. dev->if_port = !(setupval & 0x1000) ? AUI :
  961. eexp_hw_readeeprom(ioaddr,5) & 0x1 ? TPE : BNC;
  962. }
  963. buswidth = !((setupval & 0x400) >> 10);
  964. }
  965. memset(lp, 0, sizeof(struct net_local));
  966. spin_lock_init(&lp->lock);
  967. printk("(IRQ %d, %s connector, %d-bit bus", dev->irq,
  968. eexp_ifmap[dev->if_port], buswidth?8:16);
  969. if (!request_region(dev->base_addr + 0x300e, 1, "EtherExpress"))
  970. return -EBUSY;
  971. eexp_hw_set_interface(dev);
  972. release_region(dev->base_addr + 0x300e, 1);
  973. /* Find out how much RAM we have on the card */
  974. outw(0, dev->base_addr + WRITE_PTR);
  975. for (i = 0; i < 32768; i++)
  976. outw(0, dev->base_addr + DATAPORT);
  977. for (memory_size = 0; memory_size < 64; memory_size++)
  978. {
  979. outw(memory_size<<10, dev->base_addr + READ_PTR);
  980. if (inw(dev->base_addr+DATAPORT))
  981. break;
  982. outw(memory_size<<10, dev->base_addr + WRITE_PTR);
  983. outw(memory_size | 0x5000, dev->base_addr+DATAPORT);
  984. outw(memory_size<<10, dev->base_addr + READ_PTR);
  985. if (inw(dev->base_addr+DATAPORT) != (memory_size | 0x5000))
  986. break;
  987. }
  988. /* Sort out the number of buffers. We may have 16, 32, 48 or 64k
  989. * of RAM to play with.
  990. */
  991. lp->num_tx_bufs = 4;
  992. lp->rx_buf_end = 0x3ff6;
  993. switch (memory_size)
  994. {
  995. case 64:
  996. lp->rx_buf_end += 0x4000;
  997. case 48:
  998. lp->num_tx_bufs += 4;
  999. lp->rx_buf_end += 0x4000;
  1000. case 32:
  1001. lp->rx_buf_end += 0x4000;
  1002. case 16:
  1003. printk(", %dk RAM)\n", memory_size);
  1004. break;
  1005. default:
  1006. printk(") bad memory size (%dk).\n", memory_size);
  1007. return -ENODEV;
  1008. break;
  1009. }
  1010. lp->rx_buf_start = TX_BUF_START + (lp->num_tx_bufs*TX_BUF_SIZE);
  1011. lp->width = buswidth;
  1012. dev->open = eexp_open;
  1013. dev->stop = eexp_close;
  1014. dev->hard_start_xmit = eexp_xmit;
  1015. dev->get_stats = eexp_stats;
  1016. dev->set_multicast_list = &eexp_set_multicast;
  1017. dev->tx_timeout = eexp_timeout;
  1018. dev->watchdog_timeo = 2*HZ;
  1019. return register_netdev(dev);
  1020. }
  1021. /*
  1022. * Read a word from the EtherExpress on-board serial EEPROM.
  1023. * The EEPROM contains 64 words of 16 bits.
  1024. */
  1025. static unsigned short __init eexp_hw_readeeprom(unsigned short ioaddr,
  1026. unsigned char location)
  1027. {
  1028. unsigned short cmd = 0x180|(location&0x7f);
  1029. unsigned short rval = 0,wval = EC_CS|i586_RST;
  1030. int i;
  1031. outb(EC_CS|i586_RST,ioaddr+EEPROM_Ctrl);
  1032. for (i=0x100 ; i ; i>>=1 )
  1033. {
  1034. if (cmd&i)
  1035. wval |= EC_Wr;
  1036. else
  1037. wval &= ~EC_Wr;
  1038. outb(wval,ioaddr+EEPROM_Ctrl);
  1039. outb(wval|EC_Clk,ioaddr+EEPROM_Ctrl);
  1040. eeprom_delay();
  1041. outb(wval,ioaddr+EEPROM_Ctrl);
  1042. eeprom_delay();
  1043. }
  1044. wval &= ~EC_Wr;
  1045. outb(wval,ioaddr+EEPROM_Ctrl);
  1046. for (i=0x8000 ; i ; i>>=1 )
  1047. {
  1048. outb(wval|EC_Clk,ioaddr+EEPROM_Ctrl);
  1049. eeprom_delay();
  1050. if (inb(ioaddr+EEPROM_Ctrl)&EC_Rd)
  1051. rval |= i;
  1052. outb(wval,ioaddr+EEPROM_Ctrl);
  1053. eeprom_delay();
  1054. }
  1055. wval &= ~EC_CS;
  1056. outb(wval|EC_Clk,ioaddr+EEPROM_Ctrl);
  1057. eeprom_delay();
  1058. outb(wval,ioaddr+EEPROM_Ctrl);
  1059. eeprom_delay();
  1060. return rval;
  1061. }
  1062. /*
  1063. * Reap tx buffers and return last transmit status.
  1064. * if ==0 then either:
  1065. * a) we're not transmitting anything, so why are we here?
  1066. * b) we've died.
  1067. * otherwise, Stat_Busy(return) means we've still got some packets
  1068. * to transmit, Stat_Done(return) means our buffers should be empty
  1069. * again
  1070. */
  1071. static unsigned short eexp_hw_lasttxstat(struct net_device *dev)
  1072. {
  1073. struct net_local *lp = netdev_priv(dev);
  1074. unsigned short tx_block = lp->tx_reap;
  1075. unsigned short status;
  1076. if (!netif_queue_stopped(dev) && lp->tx_head==lp->tx_reap)
  1077. return 0x0000;
  1078. do
  1079. {
  1080. outw(tx_block & ~31, dev->base_addr + SM_PTR);
  1081. status = inw(dev->base_addr + SHADOW(tx_block));
  1082. if (!Stat_Done(status))
  1083. {
  1084. lp->tx_link = tx_block;
  1085. return status;
  1086. }
  1087. else
  1088. {
  1089. lp->last_tx_restart = 0;
  1090. lp->stats.collisions += Stat_NoColl(status);
  1091. if (!Stat_OK(status))
  1092. {
  1093. char *whatsup = NULL;
  1094. lp->stats.tx_errors++;
  1095. if (Stat_Abort(status))
  1096. lp->stats.tx_aborted_errors++;
  1097. if (Stat_TNoCar(status)) {
  1098. whatsup = "aborted, no carrier";
  1099. lp->stats.tx_carrier_errors++;
  1100. }
  1101. if (Stat_TNoCTS(status)) {
  1102. whatsup = "aborted, lost CTS";
  1103. lp->stats.tx_carrier_errors++;
  1104. }
  1105. if (Stat_TNoDMA(status)) {
  1106. whatsup = "FIFO underran";
  1107. lp->stats.tx_fifo_errors++;
  1108. }
  1109. if (Stat_TXColl(status)) {
  1110. whatsup = "aborted, too many collisions";
  1111. lp->stats.tx_aborted_errors++;
  1112. }
  1113. if (whatsup)
  1114. printk(KERN_INFO "%s: transmit %s\n",
  1115. dev->name, whatsup);
  1116. }
  1117. else
  1118. lp->stats.tx_packets++;
  1119. }
  1120. if (tx_block == TX_BUF_START+((lp->num_tx_bufs-1)*TX_BUF_SIZE))
  1121. lp->tx_reap = tx_block = TX_BUF_START;
  1122. else
  1123. lp->tx_reap = tx_block += TX_BUF_SIZE;
  1124. netif_wake_queue(dev);
  1125. }
  1126. while (lp->tx_reap != lp->tx_head);
  1127. lp->tx_link = lp->tx_tail + 0x08;
  1128. return status;
  1129. }
  1130. /*
  1131. * This should never happen. It is called when some higher routine detects
  1132. * that the CU has stopped, to try to restart it from the last packet we knew
  1133. * we were working on, or the idle loop if we had finished for the time.
  1134. */
  1135. static void eexp_hw_txrestart(struct net_device *dev)
  1136. {
  1137. struct net_local *lp = netdev_priv(dev);
  1138. unsigned short ioaddr = dev->base_addr;
  1139. lp->last_tx_restart = lp->tx_link;
  1140. scb_wrcbl(dev, lp->tx_link);
  1141. scb_command(dev, SCB_CUstart);
  1142. outb(0,ioaddr+SIGNAL_CA);
  1143. {
  1144. unsigned short boguscount=50,failcount=5;
  1145. while (!scb_status(dev))
  1146. {
  1147. if (!--boguscount)
  1148. {
  1149. if (--failcount)
  1150. {
  1151. printk(KERN_WARNING "%s: CU start timed out, status %04x, cmd %04x\n", dev->name, scb_status(dev), scb_rdcmd(dev));
  1152. scb_wrcbl(dev, lp->tx_link);
  1153. scb_command(dev, SCB_CUstart);
  1154. outb(0,ioaddr+SIGNAL_CA);
  1155. boguscount = 100;
  1156. }
  1157. else
  1158. {
  1159. printk(KERN_WARNING "%s: Failed to restart CU, resetting board...\n",dev->name);
  1160. eexp_hw_init586(dev);
  1161. netif_wake_queue(dev);
  1162. return;
  1163. }
  1164. }
  1165. }
  1166. }
  1167. }
  1168. /*
  1169. * Writes down the list of transmit buffers into card memory. Each
  1170. * entry consists of an 82586 transmit command, followed by a jump
  1171. * pointing to itself. When we want to transmit a packet, we write
  1172. * the data into the appropriate transmit buffer and then modify the
  1173. * preceding jump to point at the new transmit command. This means that
  1174. * the 586 command unit is continuously active.
  1175. */
  1176. static void eexp_hw_txinit(struct net_device *dev)
  1177. {
  1178. struct net_local *lp = netdev_priv(dev);
  1179. unsigned short tx_block = TX_BUF_START;
  1180. unsigned short curtbuf;
  1181. unsigned short ioaddr = dev->base_addr;
  1182. for ( curtbuf=0 ; curtbuf<lp->num_tx_bufs ; curtbuf++ )
  1183. {
  1184. outw(tx_block, ioaddr + WRITE_PTR);
  1185. outw(0x0000, ioaddr + DATAPORT);
  1186. outw(Cmd_INT|Cmd_Xmit, ioaddr + DATAPORT);
  1187. outw(tx_block+0x08, ioaddr + DATAPORT);
  1188. outw(tx_block+0x0e, ioaddr + DATAPORT);
  1189. outw(0x0000, ioaddr + DATAPORT);
  1190. outw(0x0000, ioaddr + DATAPORT);
  1191. outw(tx_block+0x08, ioaddr + DATAPORT);
  1192. outw(0x8000, ioaddr + DATAPORT);
  1193. outw(-1, ioaddr + DATAPORT);
  1194. outw(tx_block+0x16, ioaddr + DATAPORT);
  1195. outw(0x0000, ioaddr + DATAPORT);
  1196. tx_block += TX_BUF_SIZE;
  1197. }
  1198. lp->tx_head = TX_BUF_START;
  1199. lp->tx_reap = TX_BUF_START;
  1200. lp->tx_tail = tx_block - TX_BUF_SIZE;
  1201. lp->tx_link = lp->tx_tail + 0x08;
  1202. lp->rx_buf_start = tx_block;
  1203. }
  1204. /*
  1205. * Write the circular list of receive buffer descriptors to card memory.
  1206. * The end of the list isn't marked, which means that the 82586 receive
  1207. * unit will loop until buffers become available (this avoids it giving us
  1208. * "out of resources" messages).
  1209. */
  1210. static void eexp_hw_rxinit(struct net_device *dev)
  1211. {
  1212. struct net_local *lp = netdev_priv(dev);
  1213. unsigned short rx_block = lp->rx_buf_start;
  1214. unsigned short ioaddr = dev->base_addr;
  1215. lp->num_rx_bufs = 0;
  1216. lp->rx_first = lp->rx_ptr = rx_block;
  1217. do
  1218. {
  1219. lp->num_rx_bufs++;
  1220. outw(rx_block, ioaddr + WRITE_PTR);
  1221. outw(0, ioaddr + DATAPORT); outw(0, ioaddr+DATAPORT);
  1222. outw(rx_block + RX_BUF_SIZE, ioaddr+DATAPORT);
  1223. outw(0xffff, ioaddr+DATAPORT);
  1224. outw(0x0000, ioaddr+DATAPORT);
  1225. outw(0xdead, ioaddr+DATAPORT);
  1226. outw(0xdead, ioaddr+DATAPORT);
  1227. outw(0xdead, ioaddr+DATAPORT);
  1228. outw(0xdead, ioaddr+DATAPORT);
  1229. outw(0xdead, ioaddr+DATAPORT);
  1230. outw(0xdead, ioaddr+DATAPORT);
  1231. outw(0x0000, ioaddr+DATAPORT);
  1232. outw(rx_block + RX_BUF_SIZE + 0x16, ioaddr+DATAPORT);
  1233. outw(rx_block + 0x20, ioaddr+DATAPORT);
  1234. outw(0, ioaddr+DATAPORT);
  1235. outw(RX_BUF_SIZE-0x20, ioaddr+DATAPORT);
  1236. lp->rx_last = rx_block;
  1237. rx_block += RX_BUF_SIZE;
  1238. } while (rx_block <= lp->rx_buf_end-RX_BUF_SIZE);
  1239. /* Make first Rx frame descriptor point to first Rx buffer
  1240. descriptor */
  1241. outw(lp->rx_first + 6, ioaddr+WRITE_PTR);
  1242. outw(lp->rx_first + 0x16, ioaddr+DATAPORT);
  1243. /* Close Rx frame descriptor ring */
  1244. outw(lp->rx_last + 4, ioaddr+WRITE_PTR);
  1245. outw(lp->rx_first, ioaddr+DATAPORT);
  1246. /* Close Rx buffer descriptor ring */
  1247. outw(lp->rx_last + 0x16 + 2, ioaddr+WRITE_PTR);
  1248. outw(lp->rx_first + 0x16, ioaddr+DATAPORT);
  1249. }
  1250. /*
  1251. * Un-reset the 586, and start the configuration sequence. We don't wait for
  1252. * this to finish, but allow the interrupt handler to start the CU and RU for
  1253. * us. We can't start the receive/transmission system up before we know that
  1254. * the hardware is configured correctly.
  1255. */
  1256. static void eexp_hw_init586(struct net_device *dev)
  1257. {
  1258. struct net_local *lp = netdev_priv(dev);
  1259. unsigned short ioaddr = dev->base_addr;
  1260. int i;
  1261. #if NET_DEBUG > 6
  1262. printk("%s: eexp_hw_init586()\n", dev->name);
  1263. #endif
  1264. lp->started = 0;
  1265. set_loopback(dev);
  1266. outb(SIRQ_dis|irqrmap[dev->irq],ioaddr+SET_IRQ);
  1267. /* Download the startup code */
  1268. outw(lp->rx_buf_end & ~31, ioaddr + SM_PTR);
  1269. outw(lp->width?0x0001:0x0000, ioaddr + 0x8006);
  1270. outw(0x0000, ioaddr + 0x8008);
  1271. outw(0x0000, ioaddr + 0x800a);
  1272. outw(0x0000, ioaddr + 0x800c);
  1273. outw(0x0000, ioaddr + 0x800e);
  1274. for (i = 0; i < (sizeof(start_code)); i+=32) {
  1275. int j;
  1276. outw(i, ioaddr + SM_PTR);
  1277. for (j = 0; j < 16; j+=2)
  1278. outw(start_code[(i+j)/2],
  1279. ioaddr+0x4000+j);
  1280. for (j = 0; j < 16; j+=2)
  1281. outw(start_code[(i+j+16)/2],
  1282. ioaddr+0x8000+j);
  1283. }
  1284. /* Do we want promiscuous mode or multicast? */
  1285. outw(CONF_PROMISC & ~31, ioaddr+SM_PTR);
  1286. i = inw(ioaddr+SHADOW(CONF_PROMISC));
  1287. outw((dev->flags & IFF_PROMISC)?(i|1):(i & ~1),
  1288. ioaddr+SHADOW(CONF_PROMISC));
  1289. lp->was_promisc = dev->flags & IFF_PROMISC;
  1290. #if 0
  1291. eexp_setup_filter(dev);
  1292. #endif
  1293. /* Write our hardware address */
  1294. outw(CONF_HWADDR & ~31, ioaddr+SM_PTR);
  1295. outw(((unsigned short *)dev->dev_addr)[0], ioaddr+SHADOW(CONF_HWADDR));
  1296. outw(((unsigned short *)dev->dev_addr)[1],
  1297. ioaddr+SHADOW(CONF_HWADDR+2));
  1298. outw(((unsigned short *)dev->dev_addr)[2],
  1299. ioaddr+SHADOW(CONF_HWADDR+4));
  1300. eexp_hw_txinit(dev);
  1301. eexp_hw_rxinit(dev);
  1302. outb(0,ioaddr+EEPROM_Ctrl);
  1303. mdelay(5);
  1304. scb_command(dev, 0xf000);
  1305. outb(0,ioaddr+SIGNAL_CA);
  1306. outw(0, ioaddr+SM_PTR);
  1307. {
  1308. unsigned short rboguscount=50,rfailcount=5;
  1309. while (inw(ioaddr+0x4000))
  1310. {
  1311. if (!--rboguscount)
  1312. {
  1313. printk(KERN_WARNING "%s: i82586 reset timed out, kicking...\n",
  1314. dev->name);
  1315. scb_command(dev, 0);
  1316. outb(0,ioaddr+SIGNAL_CA);
  1317. rboguscount = 100;
  1318. if (!--rfailcount)
  1319. {
  1320. printk(KERN_WARNING "%s: i82586 not responding, giving up.\n",
  1321. dev->name);
  1322. return;
  1323. }
  1324. }
  1325. }
  1326. }
  1327. scb_wrcbl(dev, CONF_LINK);
  1328. scb_command(dev, 0xf000|SCB_CUstart);
  1329. outb(0,ioaddr+SIGNAL_CA);
  1330. {
  1331. unsigned short iboguscount=50,ifailcount=5;
  1332. while (!scb_status(dev))
  1333. {
  1334. if (!--iboguscount)
  1335. {
  1336. if (--ifailcount)
  1337. {
  1338. printk(KERN_WARNING "%s: i82586 initialization timed out, status %04x, cmd %04x\n",
  1339. dev->name, scb_status(dev), scb_rdcmd(dev));
  1340. scb_wrcbl(dev, CONF_LINK);
  1341. scb_command(dev, 0xf000|SCB_CUstart);
  1342. outb(0,ioaddr+SIGNAL_CA);
  1343. iboguscount = 100;
  1344. }
  1345. else
  1346. {
  1347. printk(KERN_WARNING "%s: Failed to initialize i82586, giving up.\n",dev->name);
  1348. return;
  1349. }
  1350. }
  1351. }
  1352. }
  1353. clear_loopback(dev);
  1354. outb(SIRQ_en|irqrmap[dev->irq],ioaddr+SET_IRQ);
  1355. lp->init_time = jiffies;
  1356. #if NET_DEBUG > 6
  1357. printk("%s: leaving eexp_hw_init586()\n", dev->name);
  1358. #endif
  1359. return;
  1360. }
  1361. static void eexp_setup_filter(struct net_device *dev)
  1362. {
  1363. struct dev_mc_list *dmi = dev->mc_list;
  1364. unsigned short ioaddr = dev->base_addr;
  1365. int count = dev->mc_count;
  1366. int i;
  1367. if (count > 8) {
  1368. printk(KERN_INFO "%s: too many multicast addresses (%d)\n",
  1369. dev->name, count);
  1370. count = 8;
  1371. }
  1372. outw(CONF_NR_MULTICAST & ~31, ioaddr+SM_PTR);
  1373. outw(count, ioaddr+SHADOW(CONF_NR_MULTICAST));
  1374. for (i = 0; i < count; i++) {
  1375. unsigned short *data = (unsigned short *)dmi->dmi_addr;
  1376. if (!dmi) {
  1377. printk(KERN_INFO "%s: too few multicast addresses\n", dev->name);
  1378. break;
  1379. }
  1380. if (dmi->dmi_addrlen != ETH_ALEN) {
  1381. printk(KERN_INFO "%s: invalid multicast address length given.\n", dev->name);
  1382. continue;
  1383. }
  1384. outw((CONF_MULTICAST+(6*i)) & ~31, ioaddr+SM_PTR);
  1385. outw(data[0], ioaddr+SHADOW(CONF_MULTICAST+(6*i)));
  1386. outw((CONF_MULTICAST+(6*i)+2) & ~31, ioaddr+SM_PTR);
  1387. outw(data[1], ioaddr+SHADOW(CONF_MULTICAST+(6*i)+2));
  1388. outw((CONF_MULTICAST+(6*i)+4) & ~31, ioaddr+SM_PTR);
  1389. outw(data[2], ioaddr+SHADOW(CONF_MULTICAST+(6*i)+4));
  1390. }
  1391. }
  1392. /*
  1393. * Set or clear the multicast filter for this adaptor.
  1394. */
  1395. static void
  1396. eexp_set_multicast(struct net_device *dev)
  1397. {
  1398. unsigned short ioaddr = dev->base_addr;
  1399. struct net_local *lp = netdev_priv(dev);
  1400. int kick = 0, i;
  1401. if ((dev->flags & IFF_PROMISC) != lp->was_promisc) {
  1402. outw(CONF_PROMISC & ~31, ioaddr+SM_PTR);
  1403. i = inw(ioaddr+SHADOW(CONF_PROMISC));
  1404. outw((dev->flags & IFF_PROMISC)?(i|1):(i & ~1),
  1405. ioaddr+SHADOW(CONF_PROMISC));
  1406. lp->was_promisc = dev->flags & IFF_PROMISC;
  1407. kick = 1;
  1408. }
  1409. if (!(dev->flags & IFF_PROMISC)) {
  1410. eexp_setup_filter(dev);
  1411. if (lp->old_mc_count != dev->mc_count) {
  1412. kick = 1;
  1413. lp->old_mc_count = dev->mc_count;
  1414. }
  1415. }
  1416. if (kick) {
  1417. unsigned long oj;
  1418. scb_command(dev, SCB_CUsuspend);
  1419. outb(0, ioaddr+SIGNAL_CA);
  1420. outb(0, ioaddr+SIGNAL_CA);
  1421. #if 0
  1422. printk("%s: waiting for CU to go suspended\n", dev->name);
  1423. #endif
  1424. oj = jiffies;
  1425. while ((SCB_CUstat(scb_status(dev)) == 2) &&
  1426. ((jiffies-oj) < 2000));
  1427. if (SCB_CUstat(scb_status(dev)) == 2)
  1428. printk("%s: warning, CU didn't stop\n", dev->name);
  1429. lp->started &= ~(STARTED_CU);
  1430. scb_wrcbl(dev, CONF_LINK);
  1431. scb_command(dev, SCB_CUstart);
  1432. outb(0, ioaddr+SIGNAL_CA);
  1433. }
  1434. }
  1435. /*
  1436. * MODULE stuff
  1437. */
  1438. #ifdef MODULE
  1439. #define EEXP_MAX_CARDS 4 /* max number of cards to support */
  1440. static struct net_device *dev_eexp[EEXP_MAX_CARDS];
  1441. static int irq[EEXP_MAX_CARDS];
  1442. static int io[EEXP_MAX_CARDS];
  1443. module_param_array(io, int, NULL, 0);
  1444. module_param_array(irq, int, NULL, 0);
  1445. MODULE_PARM_DESC(io, "EtherExpress 16 I/O base address(es)");
  1446. MODULE_PARM_DESC(irq, "EtherExpress 16 IRQ number(s)");
  1447. MODULE_LICENSE("GPL");
  1448. /* Ideally the user would give us io=, irq= for every card. If any parameters
  1449. * are specified, we verify and then use them. If no parameters are given, we
  1450. * autoprobe for one card only.
  1451. */
  1452. int __init init_module(void)
  1453. {
  1454. struct net_device *dev;
  1455. int this_dev, found = 0;
  1456. for (this_dev = 0; this_dev < EEXP_MAX_CARDS; this_dev++) {
  1457. dev = alloc_etherdev(sizeof(struct net_local));
  1458. dev->irq = irq[this_dev];
  1459. dev->base_addr = io[this_dev];
  1460. if (io[this_dev] == 0) {
  1461. if (this_dev)
  1462. break;
  1463. printk(KERN_NOTICE "eexpress.c: Module autoprobe not recommended, give io=xx.\n");
  1464. }
  1465. if (do_express_probe(dev) == 0) {
  1466. dev_eexp[this_dev] = dev;
  1467. found++;
  1468. continue;
  1469. }
  1470. printk(KERN_WARNING "eexpress.c: Failed to register card at 0x%x.\n", io[this_dev]);
  1471. free_netdev(dev);
  1472. break;
  1473. }
  1474. if (found)
  1475. return 0;
  1476. return -ENXIO;
  1477. }
  1478. void __exit cleanup_module(void)
  1479. {
  1480. int this_dev;
  1481. for (this_dev = 0; this_dev < EEXP_MAX_CARDS; this_dev++) {
  1482. struct net_device *dev = dev_eexp[this_dev];
  1483. if (dev) {
  1484. unregister_netdev(dev);
  1485. free_netdev(dev);
  1486. }
  1487. }
  1488. }
  1489. #endif
  1490. /*
  1491. * Local Variables:
  1492. * c-file-style: "linux"
  1493. * tab-width: 8
  1494. * End:
  1495. */