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., 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 gPXE. Changed much.
40 *
41 * Cleanups and fixes by Thomas Miletich<thomas.miletich@gmail.com>
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 gPXE during initialization. Typical NIC
64 * initialization is performed. EEPROM data is read.
65 *
66 * Network Boot
67 *
68 * ifec_net_open() is called by gPXE 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 <gpxe/ethernet.h>
108 #include <gpxe/if_ether.h>
109 #include <gpxe/iobuf.h>
110 #include <gpxe/malloc.h>
111 #include <gpxe/pci.h>
112 #include <gpxe/spi_bit.h>
113 #include <gpxe/timer.h>
114 #include <gpxe/nvs.h>
115 #include <gpxe/threewire.h>
116 #include <gpxe/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 /******************* gPXE 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 gPXE is initializing.
168 * This is a gPXE PCI Device Driver API function.
169 */
ifec_pci_probe(struct pci_device * pci,const struct pci_device_id * id __unused)170 static int ifec_pci_probe ( struct pci_device *pci,
171 const struct pci_device_id *id __unused )
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
186 netdev_init ( netdev, &ifec_operations );
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
203 ifec_init_eeprom ( netdev );
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 ifec_link_update ( netdev ); /* Update link state */
213
214 if ( ( rc = register_netdev ( netdev ) ) != 0 )
215 goto error;
216
217 DBGP ( "ints\n" );
218
219 return 0;
220
221 error:
222 ifec_reset ( netdev );
223 netdev_nullify ( 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 */
ifec_pci_remove(struct pci_device * pci)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
242 unregister_netdev ( netdev );
243 ifec_reset ( netdev );
244 netdev_nullify ( netdev );
245 netdev_put ( netdev );
246 }
247
248 /****************** gPXE Network Device Driver API functions *****************/
249
250 /*
251 * Close a network device.
252 *
253 * @v netdev Device to close.
254 *
255 * This is a gPXE Network Device Driver API function.
256 */
ifec_net_close(struct net_device * netdev)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 gPXE Network Driver API function.
289 */
ifec_net_irq(struct net_device * netdev,int enable)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 gPXE Network Device Driver API function.
308 */
ifec_net_open(struct net_device * netdev)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. */
323 ifec_scb_cmd ( netdev, 0, RUAddrLoad );
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 */
335 ifec_mdio_setup ( netdev, options );
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 );
360 ifec_scb_cmd_wait ( netdev );
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 );
377 ifec_scb_cmd_wait ( netdev );
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 gPXE 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 gPXE Network Device Driver API function.
399 */
ifec_net_poll(struct net_device * netdev)400 static void ifec_net_poll ( struct net_device *netdev )
401 {
402 struct ifec_private *priv = netdev->priv;
403 static int linkpoll = 0;
404 unsigned short intr_status;
405
406 DBGP ( "ifec_net_poll\n" );
407
408 /* acknowledge interrupts ASAP */
409 intr_status = inw ( priv->ioaddr + SCBStatus );
410 outw ( intr_status, priv->ioaddr + SCBStatus );
411 inw ( priv->ioaddr + SCBStatus );
412
413 DBG2 ( "poll - status: 0x%04X\n", intr_status );
414
415 if ( ++linkpoll > LINK_CHECK_PERIOD ) {
416 linkpoll = 0;
417 ifec_link_update ( netdev ); /* Update link state */
418 }
419
420 /* anything to do here? */
421 if ( ( intr_status & ( ~INTERRUPT_MASK ) ) == 0 )
422 return;
423
424 /* process received and transmitted packets */
425 ifec_tx_process ( netdev );
426 ifec_rx_process ( netdev );
427
428 ifec_check_ru_status ( netdev, intr_status );
429
430 return;
431 }
432
433 /*
434 * This transmits a packet.
435 *
436 * @v netdev Device to transmit from.
437 * @v iobuf Data to transmit.
438 * @ret rc Non-zero if failed to transmit.
439 *
440 * This is a gPXE Network Driver API function.
441 */
ifec_net_transmit(struct net_device * netdev,struct io_buffer * iobuf)442 static int ifec_net_transmit ( struct net_device *netdev,
443 struct io_buffer *iobuf )
444 {
445 struct ifec_private *priv = netdev->priv;
446 struct ifec_tcb *tcb = priv->tcb_head->next;
447 unsigned long ioaddr = priv->ioaddr;
448
449 DBGP ( "ifec_net_transmit\n" );
450
451 /* Wait for TCB to become available. */
452 if ( tcb->status || tcb->iob ) {
453 DBG ( "TX overflow\n" );
454 return -ENOBUFS;
455 }
456
457 DBG2 ( "transmitting packet (%d bytes). status = %hX, cmd=%hX\n",
458 iob_len ( iobuf ), tcb->status, inw ( ioaddr + SCBCmd ) );
459
460 tcb->command = CmdSuspend | CmdTx | CmdTxFlex;
461 tcb->count = 0x01208000;
462 tcb->tbd_addr0 = virt_to_bus ( iobuf->data );
463 tcb->tbd_size0 = 0x3FFF & iob_len ( iobuf );
464 tcb->iob = iobuf;
465
466 ifec_tx_wake ( netdev );
467
468 /* Append to end of ring. */
469 priv->tcb_head = tcb;
470
471 return 0;
472 }
473
474 /*************************** Local support functions *************************/
475
476 /* Define what each GPIO Pin does */
477 static const uint16_t ifec_ee_bits[] = {
478 [SPI_BIT_SCLK] = EE_SHIFT_CLK,
479 [SPI_BIT_MOSI] = EE_DATA_WRITE,
480 [SPI_BIT_MISO] = EE_DATA_READ,
481 [SPI_BIT_SS(0)] = EE_ENB,
482 };
483
484 /*
485 * Read a single bit from the GPIO pins used for SPI.
486 * should be called by SPI bitbash functions only
487 *
488 * @v basher Bitbash device
489 * @v bit_id Line to be read
490 */
ifec_spi_read_bit(struct bit_basher * basher,unsigned int bit_id)491 static int ifec_spi_read_bit ( struct bit_basher *basher,
492 unsigned int bit_id )
493 {
494 struct ifec_private *priv =
495 container_of ( basher, struct ifec_private, spi.basher );
496 unsigned long ee_addr = priv->ioaddr + CSREeprom;
497 unsigned int ret = 0;
498 uint16_t mask;
499
500 DBGP ( "ifec_spi_read_bit\n" );
501
502 mask = ifec_ee_bits[bit_id];
503 ret = inw (ee_addr);
504
505 return ( ret & mask ) ? 1 : 0;
506 }
507
508 /*
509 * Write a single bit to the GPIO pins used for SPI.
510 * should be called by SPI bitbash functions only
511 *
512 * @v basher Bitbash device
513 * @v bit_id Line to write to
514 * @v data Value to write
515 */
ifec_spi_write_bit(struct bit_basher * basher,unsigned int bit_id,unsigned long data)516 static void ifec_spi_write_bit ( struct bit_basher *basher,
517 unsigned int bit_id,
518 unsigned long data )
519 {
520 struct ifec_private *priv =
521 container_of ( basher, struct ifec_private, spi.basher );
522 unsigned long ee_addr = priv->ioaddr + CSREeprom;
523 short val;
524 uint16_t mask = ifec_ee_bits[bit_id];
525
526 DBGP ( "ifec_spi_write_bit\n" );
527
528 val = inw ( ee_addr );
529 val &= ~mask;
530 val |= data & mask;
531
532 outw ( val, ee_addr );
533 }
534
535 /* set function pointer to SPI read- and write-bit functions */
536 static struct bit_basher_operations ifec_basher_ops = {
537 .read = ifec_spi_read_bit,
538 .write = ifec_spi_write_bit,
539 };
540
541 /*
542 * Initialize the eeprom stuff
543 *
544 * @v netdev Network device
545 */
ifec_init_eeprom(struct net_device * netdev)546 static void ifec_init_eeprom ( struct net_device *netdev )
547 {
548 struct ifec_private *priv = netdev->priv;
549
550 DBGP ( "ifec_init_eeprom\n" );
551
552 priv->spi.basher.op = &ifec_basher_ops;
553 priv->spi.bus.mode = SPI_MODE_THREEWIRE;
554 init_spi_bit_basher ( &priv->spi );
555
556 priv->eeprom.bus = &priv->spi.bus;
557
558 /* init as 93c46(93c14 compatible) first, to set the command len,
559 * block size and word len. Needs to be set for address len detection.
560 */
561 init_at93c46 ( &priv->eeprom, 16 );
562
563 /* detect address length, */
564 threewire_detect_address_len ( &priv->eeprom );
565
566 /* address len == 8 means 93c66 instead of 93c46 */
567 if ( priv->eeprom.address_len == 8 )
568 init_at93c66 ( &priv->eeprom, 16 );
569 }
570
571 /*
572 * Check if the network cable is plugged in.
573 *
574 * @v netdev Network device to check.
575 * @ret retval greater 0 if linkup.
576 */
ifec_link_check(struct net_device * netdev)577 static int ifec_link_check ( struct net_device *netdev )
578 {
579 struct ifec_private *priv = netdev->priv;
580 unsigned short mdio_register = priv->mdio_register;
581
582 DBGP ( "ifec_link_check\n" );
583
584 /* Read the status register once to discard stale data */
585 ifec_mdio_read ( netdev, mdio_register & 0x1f, 1 );
586 /* Check to see if network cable is plugged in. */
587 if ( ! ( ifec_mdio_read ( netdev, mdio_register & 0x1f, 1 )
588 & ( 1 << 2 ) ) ) {
589 return 0;
590 }
591 return 1;
592 }
593
594 /*
595 * Check network cable link, inform gPXE as appropriate.
596 *
597 * @v netdev Network device to check.
598 */
ifec_link_update(struct net_device * netdev)599 static void ifec_link_update ( struct net_device *netdev )
600 {
601 DBGP ( "ifec_link_update\n" );
602
603 /* Update link state */
604 if ( ifec_link_check ( netdev ) )
605 netdev_link_up ( netdev );
606 else
607 netdev_link_down ( netdev );
608 }
609
610 /*
611 * Support function: ifec_mdio_read
612 *
613 * This probably reads a register in the "physical media interface chip".
614 * -- REW
615 */
ifec_mdio_read(struct net_device * netdev,int phy_id,int location)616 static int ifec_mdio_read ( struct net_device *netdev, int phy_id,
617 int location )
618 {
619 struct ifec_private *priv = netdev->priv;
620 unsigned long ioaddr = priv->ioaddr;
621 int val;
622 int boguscnt = 64*4; /* <64 usec. to complete, typ 27 ticks */
623
624 DBGP ( "ifec_mdio_read\n" );
625
626 outl ( 0x08000000 | ( location << 16 ) | ( phy_id << 21 ),
627 ioaddr + CSRCtrlMDI );
628 do {
629 udelay ( 16 );
630
631 val = inl ( ioaddr + CSRCtrlMDI );
632
633 if ( --boguscnt < 0 ) {
634 DBG ( " ifec_mdio_read() time out with val = %X.\n",
635 val );
636 break;
637 }
638 } while (! ( val & 0x10000000 ) );
639 return val & 0xffff;
640 }
641
642 /*
643 * Initializes MDIO.
644 *
645 * @v netdev Network device
646 * @v options MDIO options
647 */
ifec_mdio_setup(struct net_device * netdev,int options)648 static void ifec_mdio_setup ( struct net_device *netdev, int options )
649 {
650 struct ifec_private *priv = netdev->priv;
651 unsigned short mdio_register = priv->mdio_register;
652
653 DBGP ( "ifec_mdio_setup\n" );
654
655 if ( ( (mdio_register>>8) & 0x3f ) == DP83840
656 || ( (mdio_register>>8) & 0x3f ) == DP83840A ) {
657 int mdi_reg23 = ifec_mdio_read ( netdev, mdio_register
658 & 0x1f, 23 ) | 0x0422;
659 if (CONGENB)
660 mdi_reg23 |= 0x0100;
661 DBG2 ( "DP83840 specific setup, setting register 23 to "
662 "%hX.\n", mdi_reg23 );
663 ifec_mdio_write ( netdev, mdio_register & 0x1f, 23, mdi_reg23 );
664 }
665 DBG2 ( "dp83840 " );
666 if ( options != 0 ) {
667 ifec_mdio_write ( netdev, mdio_register & 0x1f, 0,
668 ( (options & 0x20) ? 0x2000 : 0 ) |
669 ( (options & 0x10) ? 0x0100 : 0 ) );
670 DBG2 ( "set mdio_register. " );
671 }
672 }
673
674 /*
675 * Support function: ifec_mdio_write
676 *
677 * This probably writes to the "physical media interface chip".
678 * -- REW
679 */
ifec_mdio_write(struct net_device * netdev,int phy_id,int location,int value)680 static int ifec_mdio_write ( struct net_device *netdev,
681 int phy_id, int location, int value )
682 {
683 struct ifec_private *priv = netdev->priv;
684 unsigned long ioaddr = priv->ioaddr;
685 int val;
686 int boguscnt = 64*4; /* <64 usec. to complete, typ 27 ticks */
687
688 DBGP ( "ifec_mdio_write\n" );
689
690 outl ( 0x04000000 | ( location << 16 ) | ( phy_id << 21 ) | value,
691 ioaddr + CSRCtrlMDI );
692 do {
693 udelay ( 16 );
694
695 val = inl ( ioaddr + CSRCtrlMDI );
696 if ( --boguscnt < 0 ) {
697 DBG ( " ifec_mdio_write() time out with val = %X.\n",
698 val );
699 break;
700 }
701 } while (! ( val & 0x10000000 ) );
702 return val & 0xffff;
703 }
704
705 /*
706 * Resets the hardware.
707 *
708 * @v netdev Network device
709 */
ifec_reset(struct net_device * netdev)710 static void ifec_reset ( struct net_device *netdev )
711 {
712 struct ifec_private *priv = netdev->priv;
713 unsigned long ioaddr = priv->ioaddr;
714
715 DBGP ( "ifec_reset\n" );
716
717 /* do partial reset first */
718 outl ( PortPartialReset, ioaddr + CSRPort );
719 inw ( ioaddr + SCBStatus );
720 udelay ( 20 );
721
722 /* full reset */
723 outl ( PortReset, ioaddr + CSRPort );
724 inw ( ioaddr + SCBStatus );
725 udelay ( 20 );
726
727 /* disable interrupts again */
728 ifec_net_irq ( netdev, 0 );
729 }
730
731 /*
732 * free()s the tx/rx rings.
733 *
734 * @v netdev Network device
735 */
ifec_free(struct net_device * netdev)736 static void ifec_free ( struct net_device *netdev )
737 {
738 struct ifec_private *priv = netdev_priv ( netdev );
739 int i;
740
741 DBGP ( "ifec_free\n" );
742
743 /* free all allocated receive io_buffers */
744 for ( i = 0; i < RFD_COUNT; i++ ) {
745 free_iob ( priv->rx_iobs[i] );
746 priv->rx_iobs[i] = NULL;
747 priv->rfds[i] = NULL;
748 }
749
750 /* free TX ring buffer */
751 free_dma ( priv->tcbs, TX_RING_BYTES );
752
753 priv->tcbs = NULL;
754 }
755
756 /*
757 * Initializes an RFD.
758 *
759 * @v rfd RFD struct to initialize
760 * @v command Command word
761 * @v link Link value
762 */
ifec_rfd_init(struct ifec_rfd * rfd,s16 command,u32 link)763 static void ifec_rfd_init ( struct ifec_rfd *rfd, s16 command, u32 link )
764 {
765 DBGP ( "ifec_rfd_init\n" );
766
767 rfd->status = 0;
768 rfd->command = command;
769 rfd->rx_buf_addr = 0xFFFFFFFF;
770 rfd->count = 0;
771 rfd->size = RFD_PACKET_LEN;
772 rfd->link = link;
773 }
774
775 /*
776 * Send address of new RFD to card
777 *
778 * @v netdev Network device
779 */
ifec_reprime_ru(struct net_device * netdev)780 static void ifec_reprime_ru ( struct net_device *netdev )
781 {
782 struct ifec_private *priv = netdev->priv;
783 int cur_rx = priv->cur_rx;
784
785 DBGP ( "ifec_reprime_ru\n" );
786
787 if ( priv->rfds[cur_rx] != NULL ) {
788 ifec_scb_cmd ( netdev, virt_to_bus ( priv->rfds[cur_rx] ),
789 RUStart );
790 ifec_scb_cmd_wait ( netdev );
791 }
792 }
793
794 /*
795 * Check if reprime of RU needed
796 *
797 * @v netdev Network device
798 */
ifec_check_ru_status(struct net_device * netdev,unsigned short intr_status)799 static void ifec_check_ru_status ( struct net_device *netdev,
800 unsigned short intr_status )
801 {
802 struct ifec_private *priv = netdev->priv;
803
804 DBGP ( "ifec_check_ru_status\n" );
805
806 /*
807 * The chip may have suspended reception for various reasons.
808 * Check for that, and re-prime it should this be the case.
809 */
810 switch ( ( intr_status >> 2 ) & 0xf ) {
811 case 0: /* Idle */
812 case 4: /* Ready */
813 break;
814 case 1: /* Suspended */
815 case 2: /* No resources (RFDs) */
816 case 9: /* Suspended with no more RBDs */
817 case 10: /* No resources due to no RBDs */
818 case 12: /* Ready with no RBDs */
819 DBG ( "ifec_net_poll: RU reprimed.\n" );
820 ifec_reprime_ru ( netdev );
821 break;
822 default:
823 /* reserved values */
824 DBG ( "ifec_net_poll: RU state anomaly: %i\n",
825 ( inw ( priv->ioaddr + SCBStatus ) >> 2 ) & 0xf );
826 break;
827 }
828 }
829
830 #define RFD_STATUS ( RFD_OK | RFDRxCol | RFDRxErr | RFDShort | \
831 RFDDMAOverrun | RFDNoBufs | RFDCRCError )
832 /*
833 * Looks for received packets in the rx ring, reports success or error to
834 * the core accordingly. Starts reallocation of rx ring.
835 *
836 * @v netdev Network device
837 */
ifec_rx_process(struct net_device * netdev)838 static void ifec_rx_process ( struct net_device *netdev )
839 {
840 struct ifec_private *priv = netdev->priv;
841 int cur_rx = priv->cur_rx;
842 struct io_buffer *iob = priv->rx_iobs[cur_rx];
843 struct ifec_rfd *rfd = priv->rfds[cur_rx];
844 unsigned int rx_len;
845 s16 status;
846
847 DBGP ( "ifec_rx_process\n" );
848
849 /* Process any received packets */
850 while ( iob && rfd && ( status = rfd->status ) ) {
851 rx_len = rfd->count & RFDMaskCount;
852
853 DBG2 ( "Got a packet: Len = %d, cur_rx = %d.\n", rx_len,
854 cur_rx );
855 DBGIO_HD ( (void*)rfd->packet, 0x30 );
856
857 if ( ( status & RFD_STATUS ) != RFD_OK ) {
858 DBG ( "Corrupted packet received. "
859 "Status = %#08hx\n", status );
860 netdev_rx_err ( netdev, iob, -EINVAL );
861 } else {
862 /* Hand off the packet to the network subsystem */
863 iob_put ( iob, rx_len );
864 DBG2 ( "Received packet: %p, len: %d\n", iob, rx_len );
865 netdev_rx ( netdev, iob );
866 }
867
868 /* make sure we don't reuse this RFD */
869 priv->rx_iobs[cur_rx] = NULL;
870 priv->rfds[cur_rx] = NULL;
871
872 /* Next RFD */
873 priv->cur_rx = ( cur_rx + 1 ) % RFD_COUNT;
874 cur_rx = priv->cur_rx;
875 iob = priv->rx_iobs[cur_rx];
876 rfd = priv->rfds[cur_rx];
877 }
878
879 ifec_refill_rx_ring ( netdev );
880 }
881
882 /*
883 * Allocates io_buffer, set pointers in ifec_private structure accordingly,
884 * reserves space for RFD header in io_buffer.
885 *
886 * @v netdev Network device
887 * @v cur Descriptor number to work on
888 * @v cmd Value to set cmd field in RFD to
889 * @v link Pointer to ned RFD
890 * @ret rc 0 on success, negative on failure
891 */
ifec_get_rx_desc(struct net_device * netdev,int cur,int cmd,int link)892 static int ifec_get_rx_desc ( struct net_device *netdev, int cur, int cmd,
893 int link )
894 {
895 struct ifec_private *priv = netdev->priv;
896 struct ifec_rfd *rfd = priv->rfds[cur];
897
898 DBGP ( "ifec_get_rx_desc\n" );
899
900 priv->rx_iobs[cur] = alloc_iob ( sizeof ( *rfd ) );
901 if ( ! priv->rx_iobs[cur] ) {
902 DBG ( "alloc_iob failed. desc. nr: %d\n", cur );
903 priv->rfds[cur] = NULL;
904 return -ENOMEM;
905 }
906
907 /* Initialize new tail. */
908 priv->rfds[cur] = priv->rx_iobs[cur]->data;
909 ifec_rfd_init ( priv->rfds[cur], cmd, link );
910 iob_reserve ( priv->rx_iobs[cur], RFD_HEADER_LEN );
911
912 return 0;
913 }
914
915 /*
916 * Allocate new descriptor entries and initialize them if needed
917 *
918 * @v netdev Network device
919 */
ifec_refill_rx_ring(struct net_device * netdev)920 static void ifec_refill_rx_ring ( struct net_device *netdev )
921 {
922 struct ifec_private *priv = netdev->priv;
923 int i, cur_rx;
924 unsigned short intr_status;
925
926 DBGP ( "ifec_refill_rx_ring\n" );
927
928 for ( i = 0; i < RFD_COUNT; i++ ) {
929 cur_rx = ( priv->cur_rx + i ) % RFD_COUNT;
930 /* only refill if empty */
931 if ( priv->rfds[cur_rx] != NULL ||
932 priv->rx_iobs[cur_rx] != NULL )
933 continue;
934
935 DBG2 ( "refilling RFD %d\n", cur_rx );
936
937 if ( ifec_get_rx_desc ( netdev, cur_rx,
938 CmdSuspend | CmdEndOfList, 0 ) == 0 ) {
939 if ( i > 0 ) {
940 int prev_rx = ( ( ( cur_rx + RFD_COUNT ) - 1 )
941 % RFD_COUNT );
942 struct ifec_rfd *rfd = priv->rfds[prev_rx];
943
944 rfd->command = 0;
945 rfd->link = virt_to_bus ( priv->rfds[cur_rx] );
946 }
947 }
948 }
949
950 intr_status = inw ( priv->ioaddr + SCBStatus );
951 ifec_check_ru_status ( netdev, intr_status );
952 }
953
954 /*
955 * Initial allocation & initialization of the rx ring.
956 *
957 * @v netdev Device of rx ring.
958 * @ret rc Non-zero if error occured
959 */
ifec_rx_setup(struct net_device * netdev)960 static int ifec_rx_setup ( struct net_device *netdev )
961 {
962 struct ifec_private *priv = netdev->priv;
963 int i;
964
965 DBGP ( "ifec_rx_setup\n" );
966
967 priv->cur_rx = 0;
968
969 /* init values for ifec_refill_rx_ring() */
970 for ( i = 0; i < RFD_COUNT; i++ ) {
971 priv->rfds[i] = NULL;
972 priv->rx_iobs[i] = NULL;
973 }
974 ifec_refill_rx_ring ( netdev );
975
976 return 0;
977 }
978
979 /*
980 * Initiates a SCB command.
981 *
982 * @v netdev Network device
983 * @v ptr General pointer value for command.
984 * @v cmd Command to issue.
985 * @ret rc Non-zero if command not issued.
986 */
ifec_scb_cmd(struct net_device * netdev,u32 ptr,u8 cmd)987 static int ifec_scb_cmd ( struct net_device *netdev, u32 ptr, u8 cmd )
988 {
989 struct ifec_private *priv = netdev->priv;
990 unsigned long ioaddr = priv->ioaddr;
991 int rc;
992
993 DBGP ( "ifec_scb_cmd\n" );
994
995 rc = ifec_scb_cmd_wait ( netdev ); /* Wait until ready */
996 if ( !rc ) {
997 outl ( ptr, ioaddr + SCBPointer );
998 outb ( cmd, ioaddr + SCBCmd ); /* Issue command */
999 }
1000 return rc;
1001 }
1002
1003 /*
1004 * Wait for command unit to accept a command.
1005 *
1006 * @v cmd_ioaddr I/O address of command register.
1007 * @ret rc Non-zero if command timed out.
1008 */
ifec_scb_cmd_wait(struct net_device * netdev)1009 static int ifec_scb_cmd_wait ( struct net_device *netdev )
1010 {
1011 struct ifec_private *priv = netdev->priv;
1012 unsigned long cmd_ioaddr = priv->ioaddr + SCBCmd;
1013 int rc, wait = CU_CMD_TIMEOUT;
1014
1015 DBGP ( "ifec_scb_cmd_wait\n" );
1016
1017 for ( ; wait && ( rc = inb ( cmd_ioaddr ) ); wait-- )
1018 udelay ( 1 );
1019
1020 if ( !wait )
1021 DBG ( "ifec_scb_cmd_wait timeout!\n" );
1022 return rc;
1023 }
1024
1025 /*
1026 * Check status of transmitted packets & perform tx completions.
1027 *
1028 * @v netdev Network device.
1029 */
ifec_tx_process(struct net_device * netdev)1030 static void ifec_tx_process ( struct net_device *netdev )
1031 {
1032 struct ifec_private *priv = netdev->priv;
1033 struct ifec_tcb *tcb = priv->tcb_tail;
1034 s16 status;
1035
1036 DBGP ( "ifec_tx_process\n" );
1037
1038 /* Check status of transmitted packets */
1039 while ( ( status = tcb->status ) && tcb->iob ) {
1040 if ( status & TCB_U ) {
1041 /* report error to gPXE */
1042 DBG ( "ifec_tx_process : tx error!\n " );
1043 netdev_tx_complete_err ( netdev, tcb->iob, -EINVAL );
1044 } else {
1045 /* report successful transmit */
1046 netdev_tx_complete ( netdev, tcb->iob );
1047 }
1048 DBG2 ( "tx completion\n" );
1049
1050 tcb->iob = NULL;
1051 tcb->status = 0;
1052
1053 priv->tcb_tail = tcb->next; /* Next TCB */
1054 tcb = tcb->next;
1055 }
1056 }
1057
1058 /*
1059 * Allocates & initialize tx resources.
1060 *
1061 * @v netdev Network device.
1062 * @ret rc Non-zero if error occurred.
1063 */
ifec_tx_setup(struct net_device * netdev)1064 static int ifec_tx_setup ( struct net_device *netdev )
1065 {
1066 struct ifec_private *priv = netdev->priv;
1067 struct ifec_tcb *tcb;
1068 int i;
1069
1070 DBGP ( "ifec_tx_setup\n" );
1071
1072 /* allocate tx ring */
1073 priv->tcbs = malloc_dma ( TX_RING_BYTES, CB_ALIGN );
1074 if ( !priv->tcbs ) {
1075 DBG ( "TX-ring allocation failed\n" );
1076 return -ENOMEM;
1077 }
1078
1079 tcb = priv->tcb_tail = priv->tcbs;
1080 priv->tx_curr = priv->tx_tail = 0;
1081 priv->tx_cnt = 0;
1082
1083 for ( i = 0; i < TCB_COUNT; i++, tcb++ ) {
1084 tcb->status = 0;
1085 tcb->count = 0x01208000;
1086 tcb->iob = NULL;
1087 tcb->tbda_addr = virt_to_bus ( &tcb->tbd_addr0 );
1088 tcb->link = virt_to_bus ( tcb + 1 );
1089 tcb->next = tcb + 1;
1090 }
1091 /* We point tcb_head at the last TCB, so the first ifec_net_transmit()
1092 * will use the first (head->next) TCB to transmit. */
1093 priv->tcb_head = --tcb;
1094 tcb->link = virt_to_bus ( priv->tcbs );
1095 tcb->next = priv->tcbs;
1096
1097 return 0;
1098 }
1099
1100 /*
1101 * Wake up the Command Unit and issue a Resume/Start.
1102 *
1103 * @v netdev Network device containing Command Unit
1104 *
1105 * The time between clearing the S bit and issuing Resume must be as short as
1106 * possible to prevent a race condition. As noted in linux eepro100.c :
1107 * Note: Watch out for the potential race condition here: imagine
1108 * erasing the previous suspend
1109 * the chip processes the previous command
1110 * the chip processes the final command, and suspends
1111 * doing the CU_RESUME
1112 * the chip processes the next-yet-valid post-final-command.
1113 * So blindly sending a CU_RESUME is only safe if we do it immediately after
1114 * erasing the previous CmdSuspend, without the possibility of an intervening
1115 * delay.
1116 */
ifec_tx_wake(struct net_device * netdev)1117 void ifec_tx_wake ( struct net_device *netdev )
1118 {
1119 struct ifec_private *priv = netdev->priv;
1120 unsigned long ioaddr = priv->ioaddr;
1121 struct ifec_tcb *tcb = priv->tcb_head->next;
1122
1123 DBGP ( "ifec_tx_wake\n" );
1124
1125 /* For the special case of the first transmit, we issue a START. The
1126 * card won't RESUME after the configure command. */
1127 if ( priv->configured ) {
1128 priv->configured = 0;
1129 ifec_scb_cmd ( netdev, virt_to_bus ( tcb ), CUStart );
1130 ifec_scb_cmd_wait ( netdev );
1131 return;
1132 }
1133
1134 /* Resume if suspended. */
1135 switch ( ( inw ( ioaddr + SCBStatus ) >> 6 ) & 0x3 ) {
1136 case 0: /* Idle - We should not reach this state. */
1137 DBG2 ( "ifec_tx_wake: tx idle!\n" );
1138 ifec_scb_cmd ( netdev, virt_to_bus ( tcb ), CUStart );
1139 ifec_scb_cmd_wait ( netdev );
1140 return;
1141 case 1: /* Suspended */
1142 DBG2 ( "s" );
1143 break;
1144 default: /* Active */
1145 DBG2 ( "a" );
1146 }
1147 ifec_scb_cmd_wait ( netdev );
1148 outl ( 0, ioaddr + SCBPointer );
1149 priv->tcb_head->command &= ~CmdSuspend;
1150 /* Immediately issue Resume command */
1151 outb ( CUResume, ioaddr + SCBCmd );
1152 ifec_scb_cmd_wait ( netdev );
1153 }
1154
1155 /*********************************************************************/
1156
1157 static struct pci_device_id ifec_nics[] = {
1158 PCI_ROM(0x8086, 0x1029, "id1029", "Intel EtherExpressPro100 ID1029", 0),
1159 PCI_ROM(0x8086, 0x1030, "id1030", "Intel EtherExpressPro100 ID1030", 0),
1160 PCI_ROM(0x8086, 0x1031, "82801cam", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1161 PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection", 0),
1162 PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection", 0),
1163 PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection", 0),
1164 PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1165 PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1166 PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1167 PCI_ROM(0x8086, 0x1038, "id1038", "Intel PRO/100 VM Network Connection", 0),
1168 PCI_ROM(0x8086, 0x1039, "82562et", "Intel PRO100 VE 82562ET", 0),
1169 PCI_ROM(0x8086, 0x103a, "id103a", "Intel Corporation 82559 InBusiness 10/100", 0),
1170 PCI_ROM(0x8086, 0x103b, "82562etb", "Intel PRO100 VE 82562ETB", 0),
1171 PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection", 0),
1172 PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection", 0),
1173 PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection", 0),
1174 PCI_ROM(0x8086, 0x1051, "prove", "Intel PRO/100 VE Network Connection", 0),
1175 PCI_ROM(0x8086, 0x1059, "82551qm", "Intel PRO/100 M Mobile Connection", 0),
1176 PCI_ROM(0x8086, 0x1209, "82559er", "Intel EtherExpressPro100 82559ER", 0),
1177 PCI_ROM(0x8086, 0x1227, "82865", "Intel 82865 EtherExpress PRO/100A", 0),
1178 PCI_ROM(0x8086, 0x1228, "82556", "Intel 82556 EtherExpress PRO/100 Smart", 0),
1179 PCI_ROM(0x8086, 0x1229, "eepro100", "Intel EtherExpressPro100", 0),
1180 PCI_ROM(0x8086, 0x2449, "82562em", "Intel EtherExpressPro100 82562EM", 0),
1181 PCI_ROM(0x8086, 0x2459, "82562-1", "Intel 82562 based Fast Ethernet Connection", 0),
1182 PCI_ROM(0x8086, 0x245d, "82562-2", "Intel 82562 based Fast Ethernet Connection", 0),
1183 PCI_ROM(0x8086, 0x1050, "82562ez", "Intel 82562EZ Network Connection", 0),
1184 PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller", 0),
1185 PCI_ROM(0x8086, 0x1065, "82562-3", "Intel 82562 based Fast Ethernet Connection", 0),
1186 PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server", 0),
1187 PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server", 0),
1188 };
1189
1190 /* Cards with device ids 0x1030 to 0x103F, 0x2449, 0x2459 or 0x245D might need
1191 * a workaround for hardware bug on 10 mbit half duplex (see linux driver eepro100.c)
1192 * 2003/03/17 gbaum */
1193
1194 struct pci_driver ifec_driver __pci_driver = {
1195 .ids = ifec_nics,
1196 .id_count = ( sizeof (ifec_nics) / sizeof (ifec_nics[0]) ),
1197 .probe = ifec_pci_probe,
1198 .remove = ifec_pci_remove
1199 };
1200
1201 /*
1202 * Local variables:
1203 * c-basic-offset: 8
1204 * c-indent-level: 8
1205 * tab-width: 8
1206 * End:
1207 */
1208