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