![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eepro100.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / net|
Return to eepro100.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / net |
1.1 root 1: /*
2: * eepro100.c -- This is a driver for Intel Fast Ethernet Controllers
3: * (ifec).
4: *
5: * Originally written for Etherboot by:
6: *
7: * Copyright (C) AW Computer Systems.
8: * written by R.E.Wolff -- [email protected]
9: *
10: * AW Computer Systems is contributing to the free software community
11: * by paying for this driver and then putting the result under GPL.
12: *
13: * If you need a Linux device driver, please contact BitWizard for a
14: * quote.
15: *
16: * This program is free software; you can redistribute it and/or
17: * modify it under the terms of the GNU General Public License as
18: * published by the Free Software Foundation; either version 2, or (at
19: * your option) any later version.
20: *
21: * This program is distributed in the hope that it will be useful, but
22: * WITHOUT ANY WARRANTY; without even the implied warranty of
23: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24: * General Public License for more details.
25: *
26: * You should have received a copy of the GNU General Public License
27: * along with this program; if not, write to the Free Software
28: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29: *
30: *
31: * date version by what
32: * Written: May 29 1997 V0.10 REW Initial revision.
33: * changes: May 31 1997 V0.90 REW Works!
34: * Jun 1 1997 V0.91 REW Cleanup
35: * Jun 2 1997 V0.92 REW Add some code documentation
36: * Jul 25 1997 V1.00 REW Tested by AW to work in a PROM
37: * Cleanup for publication
38: * Dez 11 2004 V1.10 Kiszka Add RX ring buffer support
39: * Jun 2008 v2.0 mdeck Updated to iPXE. Changed much.
40: *
41: * Cleanups and fixes by Thomas Miletich<[email protected]>
42: *
43: * This is the etherboot intel etherexpress Pro/100B driver.
44: *
45: * It was written from scratch, with Donald Beckers eepro100.c kernel
46: * driver as a guideline. Mostly the 82557 related definitions and the
47: * lower level routines have been cut-and-pasted into this source.
48: *
49: * The driver was finished before Intel got the NDA out of the closet.
50: *
51: * Datasheet is now published and available from
52: * ftp://download.intel.com/design/network/manuals/8255X_OpenSDM.pdf
53: * - Michael Brown
54: * */
55:
56: FILE_LICENCE ( GPL2_OR_LATER );
57:
58: /*
59: * General Theory of Operation
60: *
61: * Initialization
62: *
63: * ifec_pci_probe() is called by iPXE during initialization. Typical NIC
64: * initialization is performed. EEPROM data is read.
65: *
66: * Network Boot
67: *
68: * ifec_net_open() is called by iPXE before attempting to network boot from the
69: * card. Here, the Command Unit & Receive Unit are initialized. The tx & rx
70: * rings are setup. The MAC address is programmed and the card is configured.
71: *
72: * Transmit
73: *
74: * ifec_net_transmit() enqueues a packet in the tx ring - active::tcbs[] The tx
75: * ring is composed of TCBs linked to each other into a ring. A tx request
76: * fills out the next available TCB with a pointer to the packet data.
77: * The last enqueued tx is always at active::tcb_head. Thus, a tx request fills
78: * out the TCB following tcb_head.
79: * active::tcb_tail points to the TCB we're awaiting completion of.
80: * ifec_tx_process() checks tcb_tail, and once complete,
81: * blindly increments tcb_tail to the next ring TCB.
82: *
83: * Receive
84: *
85: * priv::rfds[] is an array of Receive Frame Descriptors. The RFDs are linked
86: * together to form a ring.
87: * ifec_net_poll() calls ifec_rx_process(), which checks the next RFD for
88: * data. If we received a packet, we allocate a new io_buffer and copy the
89: * packet data into it. If alloc_iob() fails, we don't touch the RFD and try
90: * again on the next poll.
91: */
92:
93: /*
94: * Debugging levels:
95: * - DBG() is for any errors, i.e. failed alloc_iob(), malloc_dma(),
96: * TX overflow, corrupted packets, ...
97: * - DBG2() is for successful events, like packet received,
98: * packet transmitted, and other general notifications.
99: * - DBGP() prints the name of each called function on entry
100: */
101:
102: #include <stdint.h>
103: #include <byteswap.h>
104: #include <errno.h>
105: #include <stdio.h>
106: #include <unistd.h>
107: #include <ipxe/ethernet.h>
108: #include <ipxe/if_ether.h>
109: #include <ipxe/iobuf.h>
110: #include <ipxe/malloc.h>
111: #include <ipxe/pci.h>
112: #include <ipxe/spi_bit.h>
113: #include <ipxe/timer.h>
114: #include <ipxe/nvs.h>
115: #include <ipxe/threewire.h>
116: #include <ipxe/netdevice.h>
117: #include "eepro100.h"
118:
119: /****************************** Global data **********************************/
120:
121: /*
122: * This is the default configuration command data. The values were copied from
123: * the Linux kernel initialization for the eepro100.
124: */
125: static struct ifec_cfg ifec_cfg = {
126: .status = 0,
127: .command = CmdConfigure | CmdSuspend,
128: .link = 0, /* Filled in later */
129: .byte = { 22, /* How many bytes in this array */
130: ( TX_FIFO << 4 ) | RX_FIFO, /* Rx & Tx FIFO limits */
131: 0, 0, /* Adaptive Interframe Spacing */
132: RX_DMA_COUNT, /* Rx DMA max byte count */
133: TX_DMA_COUNT + 0x80, /* Tx DMA max byte count */
134: 0x32, /* Many bits. */
135: 0x03, /* Discard short receive & Underrun retries */
136: 1, /* 1=Use MII 0=Use AUI */
137: 0,
138: 0x2E, /* NSAI, Preamble length, & Loopback*/
139: 0, /* Linear priority */
140: 0x60, /* L PRI MODE & Interframe spacing */
141: 0, 0xf2,
142: 0x48, /* Promiscuous, Broadcast disable, CRS & CDT */
143: 0, 0x40,
144: 0xf2, /* Stripping, Padding, Receive CRC Transfer */
145: 0x80, /* 0x40=Force full-duplex, 0x80=Allowfull-duplex*/
146: 0x3f, /* Multiple IA */
147: 0x0D } /* Multicast all */
148: };
149:
150: static struct net_device_operations ifec_operations = {
151: .open = ifec_net_open,
152: .close = ifec_net_close,
153: .transmit = ifec_net_transmit,
154: .poll = ifec_net_poll,
155: .irq = ifec_net_irq
156: };
157:
158: /******************* iPXE PCI Device Driver API functions ********************/
159:
160: /*
161: * Initialize the PCI device.
162: *
163: * @v pci The device's associated pci_device structure.
164: * @v id The PCI device + vendor id.
165: * @ret rc Returns zero if successfully initialized.
166: *
167: * This function is called very early on, while iPXE is initializing.
168: * This is a iPXE PCI Device Driver API function.
169: */
170: static int ifec_pci_probe ( struct pci_device *pci )
171: {
172: struct net_device *netdev;
173: struct ifec_private *priv;
174: int rc;
175:
176: DBGP ( "ifec_pci_probe: " );
177:
178: if ( pci->ioaddr == 0 )
179: return -EINVAL;
180:
181: netdev = alloc_etherdev ( sizeof(*priv) );
182: if ( !netdev )
183: return -ENOMEM;
184:
185: netdev_init ( netdev, &ifec_operations );
186: priv = netdev->priv;
187:
188: pci_set_drvdata ( pci, netdev );
189: netdev->dev = &pci->dev;
190:
191: /* enable bus master, etc */
192: adjust_pci_device( pci );
193:
194: DBGP ( "pci " );
195:
196: memset ( priv, 0, sizeof(*priv) );
197: priv->ioaddr = pci->ioaddr;
198:
199: ifec_reset ( netdev );
200: DBGP ( "reset " );
201:
202: ifec_init_eeprom ( netdev );
203:
204: /* read MAC address */
205: nvs_read ( &priv->eeprom.nvs, EEPROM_ADDR_MAC_0, netdev->hw_addr,
206: ETH_ALEN );
207: /* read mdio_register */
208: nvs_read ( &priv->eeprom.nvs, EEPROM_ADDR_MDIO_REGISTER,
209: &priv->mdio_register, 2 );
210:
211: if ( ( rc = register_netdev ( netdev ) ) != 0 )
212: goto error;
213:
214: netdev_link_up ( netdev );
215:
216: DBGP ( "ints\n" );
217:
218: return 0;
219:
220: error:
221: ifec_reset ( netdev );
222: netdev_nullify ( netdev );
223: netdev_put ( netdev );
224:
225: return rc;
226: }
227:
228: /*
229: * Remove a device from the PCI device list.
230: *
231: * @v pci PCI device to remove.
232: *
233: * This is a PCI Device Driver API function.
234: */
235: static void ifec_pci_remove ( struct pci_device *pci )
236: {
237: struct net_device *netdev = pci_get_drvdata ( pci );
238:
239: DBGP ( "ifec_pci_remove\n" );
240:
241: unregister_netdev ( netdev );
242: ifec_reset ( netdev );
243: netdev_nullify ( netdev );
244: netdev_put ( netdev );
245: }
246:
247: /****************** iPXE Network Device Driver API functions *****************/
248:
249: /*
250: * Close a network device.
251: *
252: * @v netdev Device to close.
253: *
254: * This is a iPXE Network Device Driver API function.
255: */
256: static void ifec_net_close ( struct net_device *netdev )
257: {
258: struct ifec_private *priv = netdev->priv;
259: unsigned long ioaddr = priv->ioaddr;
260: unsigned short intr_status;
261:
262: DBGP ( "ifec_net_close\n" );
263:
264: /* disable interrupts */
265: ifec_net_irq ( netdev, 0 );
266:
267: /* Ack & clear ints */
268: intr_status = inw ( ioaddr + SCBStatus );
269: outw ( intr_status, ioaddr + SCBStatus );
270: inw ( ioaddr + SCBStatus );
271:
272: ifec_reset ( netdev );
273:
274: /* Free any resources */
275: ifec_free ( netdev );
276: }
277:
278: /* Interrupts to be masked */
279: #define INTERRUPT_MASK ( SCBMaskEarlyRx | SCBMaskFlowCtl )
280:
281: /*
282: * Enable or disable IRQ masking.
283: *
284: * @v netdev Device to control.
285: * @v enable Zero to mask off IRQ, non-zero to enable IRQ.
286: *
287: * This is a iPXE Network Driver API function.
288: */
289: static void ifec_net_irq ( struct net_device *netdev, int enable )
290: {
291: struct ifec_private *priv = netdev->priv;
292: unsigned long ioaddr = priv->ioaddr;
293:
294: DBGP ( "ifec_net_irq\n" );
295:
296: outw ( enable ? INTERRUPT_MASK : SCBMaskAll, ioaddr + SCBCmd );
297: }
298:
299: /*
300: * Opens a network device.
301: *
302: * @v netdev Device to be opened.
303: * @ret rc Non-zero if failed to open.
304: *
305: * This enables tx and rx on the device.
306: * This is a iPXE Network Device Driver API function.
307: */
308: static int ifec_net_open ( struct net_device *netdev )
309: {
310: struct ifec_private *priv = netdev->priv;
311: struct ifec_ias *ias = NULL;
312: struct ifec_cfg *cfg = NULL;
313: int i, options;
314: int rc = -ENOMEM;
315:
316: DBGP ( "ifec_net_open: " );
317:
318: /* Ensure interrupts are disabled. */
319: ifec_net_irq ( netdev, 0 );
320:
321: /* Initialize Command Unit and Receive Unit base addresses. */
322: ifec_scb_cmd ( netdev, 0, RUAddrLoad );
323: ifec_scb_cmd ( netdev, virt_to_bus ( &priv->stats ), CUStatsAddr );
324: ifec_scb_cmd ( netdev, 0, CUCmdBase );
325:
326: /* Initialize both rings */
327: if ( ( rc = ifec_rx_setup ( netdev ) ) != 0 )
328: goto error;
329: if ( ( rc = ifec_tx_setup ( netdev ) ) != 0 )
330: goto error;
331:
332: /* Initialize MDIO */
333: options = 0x00; /* 0x40 = 10mbps half duplex, 0x00 = Autosense */
334: ifec_mdio_setup ( netdev, options );
335:
336: /* Prepare MAC address w/ Individual Address Setup (ias) command.*/
337: ias = malloc_dma ( sizeof ( *ias ), CB_ALIGN );
338: if ( !ias ) {
339: rc = -ENOMEM;
340: goto error;
341: }
342: ias->command = CmdIASetup;
343: ias->status = 0;
344: memcpy ( ias->ia, netdev->ll_addr, ETH_ALEN );
345:
346: /* Prepare operating parameters w/ a configure command. */
347: cfg = malloc_dma ( sizeof ( *cfg ), CB_ALIGN );
348: if ( !cfg ) {
349: rc = -ENOMEM;
350: goto error;
351: }
352: memcpy ( cfg, &ifec_cfg, sizeof ( *cfg ) );
353: cfg->link = virt_to_bus ( priv->tcbs );
354: cfg->byte[19] = ( options & 0x10 ) ? 0xC0 : 0x80;
355: ias->link = virt_to_bus ( cfg );
356:
357: /* Issue the ias and configure commands. */
358: ifec_scb_cmd ( netdev, virt_to_bus ( ias ), CUStart );
359: ifec_scb_cmd_wait ( netdev );
360: priv->configured = 1;
361:
362: /* Wait up to 10 ms for configuration to initiate */
363: for ( i = 10; i && !cfg->status; i-- )
364: mdelay ( 1 );
365: if ( ! cfg->status ) {
366: DBG ( "Failed to initiate!\n" );
367: goto error;
368: }
369: free_dma ( ias, sizeof ( *ias ) );
370: free_dma ( cfg, sizeof ( *cfg ) );
371: DBG2 ( "cfg " );
372:
373: /* Enable rx by sending ring address to card */
374: if ( priv->rfds[0] != NULL ) {
375: ifec_scb_cmd ( netdev, virt_to_bus( priv->rfds[0] ), RUStart );
376: ifec_scb_cmd_wait ( netdev );
377: }
378: DBG2 ( "rx_start\n" );
379:
380: return 0;
381:
382: error:
383: free_dma ( cfg, sizeof ( *cfg ) );
384: free_dma ( ias, sizeof ( *ias ) );
385: ifec_free ( netdev );
386: ifec_reset ( netdev );
387: return rc;
388: }
389:
390: /*
391: * This function allows a driver to process events during operation.
392: *
393: * @v netdev Device being polled.
394: *
395: * This is called periodically by iPXE to let the driver check the status of
396: * transmitted packets and to allow the driver to check for received packets.
397: * This is a iPXE Network Device Driver API function.
398: */
399: static void ifec_net_poll ( struct net_device *netdev )
400: {
401: struct ifec_private *priv = netdev->priv;
402: unsigned short intr_status;
403:
404: DBGP ( "ifec_net_poll\n" );
405:
406: /* acknowledge interrupts ASAP */
407: intr_status = inw ( priv->ioaddr + SCBStatus );
408: outw ( intr_status, priv->ioaddr + SCBStatus );
409: inw ( priv->ioaddr + SCBStatus );
410:
411: DBG2 ( "poll - status: 0x%04X\n", intr_status );
412:
413: /* anything to do here? */
414: if ( ( intr_status & ( ~INTERRUPT_MASK ) ) == 0 )
415: return;
416:
417: /* process received and transmitted packets */
418: ifec_tx_process ( netdev );
419: ifec_rx_process ( netdev );
420:
421: ifec_check_ru_status ( netdev, intr_status );
422:
423: return;
424: }
425:
426: /*
427: * This transmits a packet.
428: *
429: * @v netdev Device to transmit from.
430: * @v iobuf Data to transmit.
431: * @ret rc Non-zero if failed to transmit.
432: *
433: * This is a iPXE Network Driver API function.
434: */
435: static int ifec_net_transmit ( struct net_device *netdev,
436: struct io_buffer *iobuf )
437: {
438: struct ifec_private *priv = netdev->priv;
439: struct ifec_tcb *tcb = priv->tcb_head->next;
440: unsigned long ioaddr = priv->ioaddr;
441:
442: DBGP ( "ifec_net_transmit\n" );
443:
444: /* Wait for TCB to become available. */
445: if ( tcb->status || tcb->iob ) {
446: DBG ( "TX overflow\n" );
447: return -ENOBUFS;
448: }
449:
450: DBG2 ( "transmitting packet (%zd bytes). status = %hX, cmd=%hX\n",
451: iob_len ( iobuf ), tcb->status, inw ( ioaddr + SCBCmd ) );
452:
453: tcb->command = CmdSuspend | CmdTx | CmdTxFlex;
454: tcb->count = 0x01208000;
455: tcb->tbd_addr0 = virt_to_bus ( iobuf->data );
456: tcb->tbd_size0 = 0x3FFF & iob_len ( iobuf );
457: tcb->iob = iobuf;
458:
459: ifec_tx_wake ( netdev );
460:
461: /* Append to end of ring. */
462: priv->tcb_head = tcb;
463:
464: return 0;
465: }
466:
467: /*************************** Local support functions *************************/
468:
469: /* Define what each GPIO Pin does */
470: static const uint16_t ifec_ee_bits[] = {
471: [SPI_BIT_SCLK] = EE_SHIFT_CLK,
472: [SPI_BIT_MOSI] = EE_DATA_WRITE,
473: [SPI_BIT_MISO] = EE_DATA_READ,
474: [SPI_BIT_SS(0)] = EE_ENB,
475: };
476:
477: /*
478: * Read a single bit from the GPIO pins used for SPI.
479: * should be called by SPI bitbash functions only
480: *
481: * @v basher Bitbash device
482: * @v bit_id Line to be read
483: */
484: static int ifec_spi_read_bit ( struct bit_basher *basher,
485: unsigned int bit_id )
486: {
487: struct ifec_private *priv =
488: container_of ( basher, struct ifec_private, spi.basher );
489: unsigned long ee_addr = priv->ioaddr + CSREeprom;
490: unsigned int ret = 0;
491: uint16_t mask;
492:
493: DBGP ( "ifec_spi_read_bit\n" );
494:
495: mask = ifec_ee_bits[bit_id];
496: ret = inw (ee_addr);
497:
498: return ( ret & mask ) ? 1 : 0;
499: }
500:
501: /*
502: * Write a single bit to the GPIO pins used for SPI.
503: * should be called by SPI bitbash functions only
504: *
505: * @v basher Bitbash device
506: * @v bit_id Line to write to
507: * @v data Value to write
508: */
509: static void ifec_spi_write_bit ( struct bit_basher *basher,
510: unsigned int bit_id,
511: unsigned long data )
512: {
513: struct ifec_private *priv =
514: container_of ( basher, struct ifec_private, spi.basher );
515: unsigned long ee_addr = priv->ioaddr + CSREeprom;
516: short val;
517: uint16_t mask = ifec_ee_bits[bit_id];
518:
519: DBGP ( "ifec_spi_write_bit\n" );
520:
521: val = inw ( ee_addr );
522: val &= ~mask;
523: val |= data & mask;
524:
525: outw ( val, ee_addr );
526: }
527:
528: /* set function pointer to SPI read- and write-bit functions */
529: static struct bit_basher_operations ifec_basher_ops = {
530: .read = ifec_spi_read_bit,
531: .write = ifec_spi_write_bit,
532: };
533:
534: /*
535: * Initialize the eeprom stuff
536: *
537: * @v netdev Network device
538: */
539: static void ifec_init_eeprom ( struct net_device *netdev )
540: {
541: struct ifec_private *priv = netdev->priv;
542:
543: DBGP ( "ifec_init_eeprom\n" );
544:
545: priv->spi.basher.op = &ifec_basher_ops;
546: priv->spi.bus.mode = SPI_MODE_THREEWIRE;
547: init_spi_bit_basher ( &priv->spi );
548:
549: priv->eeprom.bus = &priv->spi.bus;
550:
551: /* init as 93c46(93c14 compatible) first, to set the command len,
552: * block size and word len. Needs to be set for address len detection.
553: */
554: init_at93c46 ( &priv->eeprom, 16 );
555:
556: /* detect address length, */
557: threewire_detect_address_len ( &priv->eeprom );
558:
559: /* address len == 8 means 93c66 instead of 93c46 */
560: if ( priv->eeprom.address_len == 8 )
561: init_at93c66 ( &priv->eeprom, 16 );
562: }
563:
564: /*
565: * Support function: ifec_mdio_read
566: *
567: * This probably reads a register in the "physical media interface chip".
568: * -- REW
569: */
570: static int ifec_mdio_read ( struct net_device *netdev, int phy_id,
571: int location )
572: {
573: struct ifec_private *priv = netdev->priv;
574: unsigned long ioaddr = priv->ioaddr;
575: int val;
576: int boguscnt = 64*4; /* <64 usec. to complete, typ 27 ticks */
577:
578: DBGP ( "ifec_mdio_read\n" );
579:
580: outl ( 0x08000000 | ( location << 16 ) | ( phy_id << 21 ),
581: ioaddr + CSRCtrlMDI );
582: do {
583: udelay ( 16 );
584:
585: val = inl ( ioaddr + CSRCtrlMDI );
586:
587: if ( --boguscnt < 0 ) {
588: DBG ( " ifec_mdio_read() time out with val = %X.\n",
589: val );
590: break;
591: }
592: } while (! ( val & 0x10000000 ) );
593: return val & 0xffff;
594: }
595:
596: /*
597: * Initializes MDIO.
598: *
599: * @v netdev Network device
600: * @v options MDIO options
601: */
602: static void ifec_mdio_setup ( struct net_device *netdev, int options )
603: {
604: struct ifec_private *priv = netdev->priv;
605: unsigned short mdio_register = priv->mdio_register;
606:
607: DBGP ( "ifec_mdio_setup\n" );
608:
609: if ( ( (mdio_register>>8) & 0x3f ) == DP83840
610: || ( (mdio_register>>8) & 0x3f ) == DP83840A ) {
611: int mdi_reg23 = ifec_mdio_read ( netdev, mdio_register
612: & 0x1f, 23 ) | 0x0422;
613: if (CONGENB)
614: mdi_reg23 |= 0x0100;
615: DBG2 ( "DP83840 specific setup, setting register 23 to "
616: "%hX.\n", mdi_reg23 );
617: ifec_mdio_write ( netdev, mdio_register & 0x1f, 23, mdi_reg23 );
618: }
619: DBG2 ( "dp83840 " );
620: if ( options != 0 ) {
621: ifec_mdio_write ( netdev, mdio_register & 0x1f, 0,
622: ( (options & 0x20) ? 0x2000 : 0 ) |
623: ( (options & 0x10) ? 0x0100 : 0 ) );
624: DBG2 ( "set mdio_register. " );
625: }
626: }
627:
628: /*
629: * Support function: ifec_mdio_write
630: *
631: * This probably writes to the "physical media interface chip".
632: * -- REW
633: */
634: static int ifec_mdio_write ( struct net_device *netdev,
635: int phy_id, int location, int value )
636: {
637: struct ifec_private *priv = netdev->priv;
638: unsigned long ioaddr = priv->ioaddr;
639: int val;
640: int boguscnt = 64*4; /* <64 usec. to complete, typ 27 ticks */
641:
642: DBGP ( "ifec_mdio_write\n" );
643:
644: outl ( 0x04000000 | ( location << 16 ) | ( phy_id << 21 ) | value,
645: ioaddr + CSRCtrlMDI );
646: do {
647: udelay ( 16 );
648:
649: val = inl ( ioaddr + CSRCtrlMDI );
650: if ( --boguscnt < 0 ) {
651: DBG ( " ifec_mdio_write() time out with val = %X.\n",
652: val );
653: break;
654: }
655: } while (! ( val & 0x10000000 ) );
656: return val & 0xffff;
657: }
658:
659: /*
660: * Resets the hardware.
661: *
662: * @v netdev Network device
663: */
664: static void ifec_reset ( struct net_device *netdev )
665: {
666: struct ifec_private *priv = netdev->priv;
667: unsigned long ioaddr = priv->ioaddr;
668:
669: DBGP ( "ifec_reset\n" );
670:
671: /* do partial reset first */
672: outl ( PortPartialReset, ioaddr + CSRPort );
673: inw ( ioaddr + SCBStatus );
674: udelay ( 20 );
675:
676: /* full reset */
677: outl ( PortReset, ioaddr + CSRPort );
678: inw ( ioaddr + SCBStatus );
679: udelay ( 20 );
680:
681: /* disable interrupts again */
682: ifec_net_irq ( netdev, 0 );
683: }
684:
685: /*
686: * free()s the tx/rx rings.
687: *
688: * @v netdev Network device
689: */
690: static void ifec_free ( struct net_device *netdev )
691: {
692: struct ifec_private *priv = netdev_priv ( netdev );
693: int i;
694:
695: DBGP ( "ifec_free\n" );
696:
697: /* free all allocated receive io_buffers */
698: for ( i = 0; i < RFD_COUNT; i++ ) {
699: free_iob ( priv->rx_iobs[i] );
700: priv->rx_iobs[i] = NULL;
701: priv->rfds[i] = NULL;
702: }
703:
704: /* free TX ring buffer */
705: free_dma ( priv->tcbs, TX_RING_BYTES );
706:
707: priv->tcbs = NULL;
708: }
709:
710: /*
711: * Initializes an RFD.
712: *
713: * @v rfd RFD struct to initialize
714: * @v command Command word
715: * @v link Link value
716: */
717: static void ifec_rfd_init ( struct ifec_rfd *rfd, s16 command, u32 link )
718: {
719: DBGP ( "ifec_rfd_init\n" );
720:
721: rfd->status = 0;
722: rfd->command = command;
723: rfd->rx_buf_addr = 0xFFFFFFFF;
724: rfd->count = 0;
725: rfd->size = RFD_PACKET_LEN;
726: rfd->link = link;
727: }
728:
729: /*
730: * Send address of new RFD to card
731: *
732: * @v netdev Network device
733: */
734: static void ifec_reprime_ru ( struct net_device *netdev )
735: {
736: struct ifec_private *priv = netdev->priv;
737: int cur_rx = priv->cur_rx;
738:
739: DBGP ( "ifec_reprime_ru\n" );
740:
741: if ( priv->rfds[cur_rx] != NULL ) {
742: ifec_scb_cmd ( netdev, virt_to_bus ( priv->rfds[cur_rx] ),
743: RUStart );
744: ifec_scb_cmd_wait ( netdev );
745: }
746: }
747:
748: /*
749: * Check if reprime of RU needed
750: *
751: * @v netdev Network device
752: */
753: static void ifec_check_ru_status ( struct net_device *netdev,
754: unsigned short intr_status )
755: {
756: struct ifec_private *priv = netdev->priv;
757:
758: DBGP ( "ifec_check_ru_status\n" );
759:
760: /*
761: * The chip may have suspended reception for various reasons.
762: * Check for that, and re-prime it should this be the case.
763: */
764: switch ( ( intr_status >> 2 ) & 0xf ) {
765: case 0: /* Idle */
766: case 4: /* Ready */
767: break;
768: case 1: /* Suspended */
769: case 2: /* No resources (RFDs) */
770: case 9: /* Suspended with no more RBDs */
771: case 10: /* No resources due to no RBDs */
772: case 12: /* Ready with no RBDs */
773: DBG ( "ifec_net_poll: RU reprimed.\n" );
774: ifec_reprime_ru ( netdev );
775: break;
776: default:
777: /* reserved values */
778: DBG ( "ifec_net_poll: RU state anomaly: %i\n",
779: ( inw ( priv->ioaddr + SCBStatus ) >> 2 ) & 0xf );
780: break;
781: }
782: }
783:
784: #define RFD_STATUS ( RFD_OK | RFDRxCol | RFDRxErr | RFDShort | \
785: RFDDMAOverrun | RFDNoBufs | RFDCRCError )
786: /*
787: * Looks for received packets in the rx ring, reports success or error to
788: * the core accordingly. Starts reallocation of rx ring.
789: *
790: * @v netdev Network device
791: */
792: static void ifec_rx_process ( struct net_device *netdev )
793: {
794: struct ifec_private *priv = netdev->priv;
795: int cur_rx = priv->cur_rx;
796: struct io_buffer *iob = priv->rx_iobs[cur_rx];
797: struct ifec_rfd *rfd = priv->rfds[cur_rx];
798: unsigned int rx_len;
799: s16 status;
800:
801: DBGP ( "ifec_rx_process\n" );
802:
803: /* Process any received packets */
804: while ( iob && rfd && ( status = rfd->status ) ) {
805: rx_len = rfd->count & RFDMaskCount;
806:
807: DBG2 ( "Got a packet: Len = %d, cur_rx = %d.\n", rx_len,
808: cur_rx );
809: DBGIO_HD ( (void*)rfd->packet, 0x30 );
810:
811: if ( ( status & ( RFD_STATUS & ~RFDShort ) ) != RFD_OK ) {
812: DBG ( "Corrupted packet received. "
813: "Status = %#08hx\n", status );
814: netdev_rx_err ( netdev, iob, -EINVAL );
815: } else {
816: /* Hand off the packet to the network subsystem */
817: iob_put ( iob, rx_len );
818: DBG2 ( "Received packet: %p, len: %d\n", iob, rx_len );
819: netdev_rx ( netdev, iob );
820: }
821:
822: /* make sure we don't reuse this RFD */
823: priv->rx_iobs[cur_rx] = NULL;
824: priv->rfds[cur_rx] = NULL;
825:
826: /* Next RFD */
827: priv->cur_rx = ( cur_rx + 1 ) % RFD_COUNT;
828: cur_rx = priv->cur_rx;
829: iob = priv->rx_iobs[cur_rx];
830: rfd = priv->rfds[cur_rx];
831: }
832:
833: ifec_refill_rx_ring ( netdev );
834: }
835:
836: /*
837: * Allocates io_buffer, set pointers in ifec_private structure accordingly,
838: * reserves space for RFD header in io_buffer.
839: *
840: * @v netdev Network device
841: * @v cur Descriptor number to work on
842: * @v cmd Value to set cmd field in RFD to
843: * @v link Pointer to ned RFD
844: * @ret rc 0 on success, negative on failure
845: */
846: static int ifec_get_rx_desc ( struct net_device *netdev, int cur, int cmd,
847: int link )
848: {
849: struct ifec_private *priv = netdev->priv;
850: struct ifec_rfd *rfd = priv->rfds[cur];
851:
852: DBGP ( "ifec_get_rx_desc\n" );
853:
854: priv->rx_iobs[cur] = alloc_iob ( sizeof ( *rfd ) );
855: if ( ! priv->rx_iobs[cur] ) {
856: DBG ( "alloc_iob failed. desc. nr: %d\n", cur );
857: priv->rfds[cur] = NULL;
858: return -ENOMEM;
859: }
860:
861: /* Initialize new tail. */
862: priv->rfds[cur] = priv->rx_iobs[cur]->data;
863: ifec_rfd_init ( priv->rfds[cur], cmd, link );
864: iob_reserve ( priv->rx_iobs[cur], RFD_HEADER_LEN );
865:
866: return 0;
867: }
868:
869: /*
870: * Allocate new descriptor entries and initialize them if needed
871: *
872: * @v netdev Network device
873: */
874: static void ifec_refill_rx_ring ( struct net_device *netdev )
875: {
876: struct ifec_private *priv = netdev->priv;
877: int i, cur_rx;
878: unsigned short intr_status;
879:
880: DBGP ( "ifec_refill_rx_ring\n" );
881:
882: for ( i = 0; i < RFD_COUNT; i++ ) {
883: cur_rx = ( priv->cur_rx + i ) % RFD_COUNT;
884: /* only refill if empty */
885: if ( priv->rfds[cur_rx] != NULL ||
886: priv->rx_iobs[cur_rx] != NULL )
887: continue;
888:
889: DBG2 ( "refilling RFD %d\n", cur_rx );
890:
891: if ( ifec_get_rx_desc ( netdev, cur_rx,
892: CmdSuspend | CmdEndOfList, 0 ) == 0 ) {
893: if ( i > 0 ) {
894: int prev_rx = ( ( ( cur_rx + RFD_COUNT ) - 1 )
895: % RFD_COUNT );
896: struct ifec_rfd *rfd = priv->rfds[prev_rx];
897:
898: rfd->command = 0;
899: rfd->link = virt_to_bus ( priv->rfds[cur_rx] );
900: }
901: }
902: }
903:
904: intr_status = inw ( priv->ioaddr + SCBStatus );
905: ifec_check_ru_status ( netdev, intr_status );
906: }
907:
908: /*
909: * Initial allocation & initialization of the rx ring.
910: *
911: * @v netdev Device of rx ring.
912: * @ret rc Non-zero if error occured
913: */
914: static int ifec_rx_setup ( struct net_device *netdev )
915: {
916: struct ifec_private *priv = netdev->priv;
917: int i;
918:
919: DBGP ( "ifec_rx_setup\n" );
920:
921: priv->cur_rx = 0;
922:
923: /* init values for ifec_refill_rx_ring() */
924: for ( i = 0; i < RFD_COUNT; i++ ) {
925: priv->rfds[i] = NULL;
926: priv->rx_iobs[i] = NULL;
927: }
928: ifec_refill_rx_ring ( netdev );
929:
930: return 0;
931: }
932:
933: /*
934: * Initiates a SCB command.
935: *
936: * @v netdev Network device
937: * @v ptr General pointer value for command.
938: * @v cmd Command to issue.
939: * @ret rc Non-zero if command not issued.
940: */
941: static int ifec_scb_cmd ( struct net_device *netdev, u32 ptr, u8 cmd )
942: {
943: struct ifec_private *priv = netdev->priv;
944: unsigned long ioaddr = priv->ioaddr;
945: int rc;
946:
947: DBGP ( "ifec_scb_cmd\n" );
948:
949: rc = ifec_scb_cmd_wait ( netdev ); /* Wait until ready */
950: if ( !rc ) {
951: outl ( ptr, ioaddr + SCBPointer );
952: outb ( cmd, ioaddr + SCBCmd ); /* Issue command */
953: }
954: return rc;
955: }
956:
957: /*
958: * Wait for command unit to accept a command.
959: *
960: * @v cmd_ioaddr I/O address of command register.
961: * @ret rc Non-zero if command timed out.
962: */
963: static int ifec_scb_cmd_wait ( struct net_device *netdev )
964: {
965: struct ifec_private *priv = netdev->priv;
966: unsigned long cmd_ioaddr = priv->ioaddr + SCBCmd;
967: int rc, wait = CU_CMD_TIMEOUT;
968:
969: DBGP ( "ifec_scb_cmd_wait\n" );
970:
971: for ( ; wait && ( rc = inb ( cmd_ioaddr ) ); wait-- )
972: udelay ( 1 );
973:
974: if ( !wait )
975: DBG ( "ifec_scb_cmd_wait timeout!\n" );
976: return rc;
977: }
978:
979: /*
980: * Check status of transmitted packets & perform tx completions.
981: *
982: * @v netdev Network device.
983: */
984: static void ifec_tx_process ( struct net_device *netdev )
985: {
986: struct ifec_private *priv = netdev->priv;
987: struct ifec_tcb *tcb = priv->tcb_tail;
988: s16 status;
989:
990: DBGP ( "ifec_tx_process\n" );
991:
992: /* Check status of transmitted packets */
993: while ( ( status = tcb->status ) && tcb->iob ) {
994: if ( status & TCB_U ) {
995: /* report error to iPXE */
996: DBG ( "ifec_tx_process : tx error!\n " );
997: netdev_tx_complete_err ( netdev, tcb->iob, -EINVAL );
998: } else {
999: /* report successful transmit */
1000: netdev_tx_complete ( netdev, tcb->iob );
1001: }
1002: DBG2 ( "tx completion\n" );
1003:
1004: tcb->iob = NULL;
1005: tcb->status = 0;
1006:
1007: priv->tcb_tail = tcb->next; /* Next TCB */
1008: tcb = tcb->next;
1009: }
1010: }
1011:
1012: /*
1013: * Allocates & initialize tx resources.
1014: *
1015: * @v netdev Network device.
1016: * @ret rc Non-zero if error occurred.
1017: */
1018: static int ifec_tx_setup ( struct net_device *netdev )
1019: {
1020: struct ifec_private *priv = netdev->priv;
1021: struct ifec_tcb *tcb;
1022: int i;
1023:
1024: DBGP ( "ifec_tx_setup\n" );
1025:
1026: /* allocate tx ring */
1027: priv->tcbs = malloc_dma ( TX_RING_BYTES, CB_ALIGN );
1028: if ( !priv->tcbs ) {
1029: DBG ( "TX-ring allocation failed\n" );
1030: return -ENOMEM;
1031: }
1032:
1033: tcb = priv->tcb_tail = priv->tcbs;
1034: priv->tx_curr = priv->tx_tail = 0;
1035: priv->tx_cnt = 0;
1036:
1037: for ( i = 0; i < TCB_COUNT; i++, tcb++ ) {
1038: tcb->status = 0;
1039: tcb->count = 0x01208000;
1040: tcb->iob = NULL;
1041: tcb->tbda_addr = virt_to_bus ( &tcb->tbd_addr0 );
1042: tcb->link = virt_to_bus ( tcb + 1 );
1043: tcb->next = tcb + 1;
1044: }
1045: /* We point tcb_head at the last TCB, so the first ifec_net_transmit()
1046: * will use the first (head->next) TCB to transmit. */
1047: priv->tcb_head = --tcb;
1048: tcb->link = virt_to_bus ( priv->tcbs );
1049: tcb->next = priv->tcbs;
1050:
1051: return 0;
1052: }
1053:
1054: /*
1055: * Wake up the Command Unit and issue a Resume/Start.
1056: *
1057: * @v netdev Network device containing Command Unit
1058: *
1059: * The time between clearing the S bit and issuing Resume must be as short as
1060: * possible to prevent a race condition. As noted in linux eepro100.c :
1061: * Note: Watch out for the potential race condition here: imagine
1062: * erasing the previous suspend
1063: * the chip processes the previous command
1064: * the chip processes the final command, and suspends
1065: * doing the CU_RESUME
1066: * the chip processes the next-yet-valid post-final-command.
1067: * So blindly sending a CU_RESUME is only safe if we do it immediately after
1068: * erasing the previous CmdSuspend, without the possibility of an intervening
1069: * delay.
1070: */
1071: void ifec_tx_wake ( struct net_device *netdev )
1072: {
1073: struct ifec_private *priv = netdev->priv;
1074: unsigned long ioaddr = priv->ioaddr;
1075: struct ifec_tcb *tcb = priv->tcb_head->next;
1076:
1077: DBGP ( "ifec_tx_wake\n" );
1078:
1079: /* For the special case of the first transmit, we issue a START. The
1080: * card won't RESUME after the configure command. */
1081: if ( priv->configured ) {
1082: priv->configured = 0;
1083: ifec_scb_cmd ( netdev, virt_to_bus ( tcb ), CUStart );
1084: ifec_scb_cmd_wait ( netdev );
1085: return;
1086: }
1087:
1088: /* Resume if suspended. */
1089: switch ( ( inw ( ioaddr + SCBStatus ) >> 6 ) & 0x3 ) {
1090: case 0: /* Idle - We should not reach this state. */
1091: DBG2 ( "ifec_tx_wake: tx idle!\n" );
1092: ifec_scb_cmd ( netdev, virt_to_bus ( tcb ), CUStart );
1093: ifec_scb_cmd_wait ( netdev );
1094: return;
1095: case 1: /* Suspended */
1096: DBG2 ( "s" );
1097: break;
1098: default: /* Active */
1099: DBG2 ( "a" );
1100: }
1101: ifec_scb_cmd_wait ( netdev );
1102: outl ( 0, ioaddr + SCBPointer );
1103: priv->tcb_head->command &= ~CmdSuspend;
1104: /* Immediately issue Resume command */
1105: outb ( CUResume, ioaddr + SCBCmd );
1106: ifec_scb_cmd_wait ( netdev );
1107: }
1108:
1109: /*********************************************************************/
1110:
1111: static struct pci_device_id ifec_nics[] = {
1112: PCI_ROM(0x8086, 0x1029, "id1029", "Intel EtherExpressPro100 ID1029", 0),
1113: PCI_ROM(0x8086, 0x1030, "id1030", "Intel EtherExpressPro100 ID1030", 0),
1114: PCI_ROM(0x8086, 0x1031, "82801cam", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1115: PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection", 0),
1116: PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection", 0),
1117: PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection", 0),
1118: PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1119: PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1120: PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1121: PCI_ROM(0x8086, 0x1038, "id1038", "Intel PRO/100 VM Network Connection", 0),
1122: PCI_ROM(0x8086, 0x1039, "82562et", "Intel PRO100 VE 82562ET", 0),
1123: PCI_ROM(0x8086, 0x103a, "id103a", "Intel Corporation 82559 InBusiness 10/100", 0),
1124: PCI_ROM(0x8086, 0x103b, "82562etb", "Intel PRO100 VE 82562ETB", 0),
1125: PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection", 0),
1126: PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection", 0),
1127: PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection", 0),
1128: PCI_ROM(0x8086, 0x1051, "prove", "Intel PRO/100 VE Network Connection", 0),
1129: PCI_ROM(0x8086, 0x1059, "82551qm", "Intel PRO/100 M Mobile Connection", 0),
1130: PCI_ROM(0x8086, 0x1209, "82559er", "Intel EtherExpressPro100 82559ER", 0),
1131: PCI_ROM(0x8086, 0x1227, "82865", "Intel 82865 EtherExpress PRO/100A", 0),
1132: PCI_ROM(0x8086, 0x1228, "82556", "Intel 82556 EtherExpress PRO/100 Smart", 0),
1133: PCI_ROM(0x8086, 0x1229, "eepro100", "Intel EtherExpressPro100", 0),
1134: PCI_ROM(0x8086, 0x2449, "82562em", "Intel EtherExpressPro100 82562EM", 0),
1135: PCI_ROM(0x8086, 0x2459, "82562-1", "Intel 82562 based Fast Ethernet Connection", 0),
1136: PCI_ROM(0x8086, 0x245d, "82562-2", "Intel 82562 based Fast Ethernet Connection", 0),
1137: PCI_ROM(0x8086, 0x1050, "82562ez", "Intel 82562EZ Network Connection", 0),
1138: PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller", 0),
1139: PCI_ROM(0x8086, 0x1065, "82562-3", "Intel 82562 based Fast Ethernet Connection", 0),
1140: PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server", 0),
1141: PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server", 0),
1142: PCI_ROM(0x8086, 0x1092, "82562-3", "Intel Pro/100 VE Network", 0),
1143: PCI_ROM(0x8086, 0x27dc, "eepro100-27dc", "Intel 82801G (ICH7) Chipset Ethernet Controller", 0),
1144: };
1145:
1146: /* Cards with device ids 0x1030 to 0x103F, 0x2449, 0x2459 or 0x245D might need
1147: * a workaround for hardware bug on 10 mbit half duplex (see linux driver eepro100.c)
1148: * 2003/03/17 gbaum */
1149:
1150: struct pci_driver ifec_driver __pci_driver = {
1151: .ids = ifec_nics,
1152: .id_count = ( sizeof (ifec_nics) / sizeof (ifec_nics[0]) ),
1153: .probe = ifec_pci_probe,
1154: .remove = ifec_pci_remove
1155: };
1156:
1157: /*
1158: * Local variables:
1159: * c-basic-offset: 8
1160: * c-indent-level: 8
1161: * tab-width: 8
1162: * End:
1163: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.