source: rtems/bsps/shared/net/dec21140.c @ 762fa62

5
Last change on this file since 762fa62 was 27de4e1f, checked in by Sebastian Huber <sebastian.huber@…>, on Apr 3, 2018 at 5:20:11 AM

bsps: Move libchip to bsps

This patch is a part of the BSP source reorganization.

Update #3285.

  • Property mode set to 100644
File size: 29.5 KB
Line 
1/*
2 *  RTEMS driver for TULIP based Ethernet Controller
3 *
4 *  Copyright (C) 1999 Emmanuel Raguet. raguet@crf.canon.fr
5 *
6 *  The license and distribution terms for this file may be
7 *  found in the file LICENSE in this distribution or at
8 *  http://www.rtems.org/license/LICENSE.
9 *
10 * ------------------------------------------------------------------------
11 * [22.05.2000,StWi/CWA] added support for the DEC/Intel 21143 chip
12 *
13 * Thanks go to Andrew Klossner who provided the vital information about the
14 * Intel 21143 chip.  FWIW: The 21143 additions to this driver were initially
15 * tested with a PC386 BSP using a Kingston KNE100TX with 21143PD chip.
16 *
17 * The driver will automatically detect whether there is a 21140 or 21143
18 * network card in the system and activate support accordingly. It will
19 * look for the 21140 first. If the 21140 is not found the driver will
20 * look for the 21143.
21 *
22 * 2004-11-10, Joel/Richard - 21143 support works on MVME2100.
23 * ------------------------------------------------------------------------
24 *
25 * 2003-03-13, Greg Menke, gregory.menke@gsfc.nasa.gov
26 *
27 * Added support for up to 8 units (which is an arbitrary limit now),
28 * consolidating their support into a single pair of rx/tx daemons and a
29 * single ISR for all vectors servicing the DEC units.  The driver now
30 * simply uses whatever INTERRUPT_LINE the card supplies, requiring it
31 * be configured either by the boot monitor or bspstart() hackery.
32 * Tested on a MCP750 PPC based system with 2 DEC21140 boards.
33 *
34 * Also fixed a few bugs related to board configuration, start and stop.
35 *
36 */
37
38#define __INSIDE_RTEMS_BSD_TCPIP_STACK__
39
40#include <rtems.h>
41#include <inttypes.h>
42
43/*
44 *  This driver only supports architectures with the new style
45 *  exception processing.  The following checks try to keep this
46 *  from being compiled on systems which can't support this driver.
47 */
48
49#if defined(__i386__)
50  #define DEC21140_SUPPORTED
51  #define PCI_DRAM_OFFSET 0
52#endif
53#if defined(__PPC__)
54  #define DEC21140_SUPPORTED
55#endif
56
57#include <bsp.h>
58
59#if !defined(PCI_DRAM_OFFSET)
60  #undef DEC21140_SUPPORTED
61#endif
62
63#if defined(DEC21140_SUPPORTED)
64#include <rtems/pci.h>
65
66#if defined(__PPC__)
67#include <libcpu/byteorder.h>
68#include <libcpu/io.h>
69#endif
70
71#if defined(__i386__)
72#include <libcpu/byteorder.h>
73#include <libcpu/page.h>
74#endif
75
76#include <stdlib.h>
77#include <stdio.h>
78#include <stdarg.h>
79#include <string.h>
80#include <errno.h>
81#include <rtems/error.h>
82#include <rtems/bspIo.h>
83#include <rtems/rtems_bsdnet.h>
84
85#include <sys/param.h>
86#include <sys/mbuf.h>
87
88#include <sys/socket.h>
89#include <sys/sockio.h>
90#include <net/if.h>
91#include <netinet/in.h>
92#include <netinet/if_ether.h>
93
94#include <bsp/irq.h>
95
96#ifdef malloc
97#undef malloc
98#endif
99#ifdef free
100#undef free
101#endif
102
103#define DEC_DEBUG
104
105/* note: the 21143 isn't really a DEC, it's an Intel chip */
106#define PCI_VENDOR_ID_DEC               0x1011
107#define PCI_DEVICE_ID_DEC_21140         0x0009
108#define PCI_DEVICE_ID_DEC_21143         0x0019
109
110#define DRIVER_PREFIX   "dc"
111
112#define IO_MASK   0x3
113#define MEM_MASK  0xF
114
115/* command and status registers, 32-bit access, only if IO-ACCESS */
116#define ioCSR0  0x00    /* bus mode register */
117#define ioCSR1  0x08    /* transmit poll demand */
118#define ioCSR2  0x10    /* receive poll demand */
119#define ioCSR3  0x18    /* receive list base address */
120#define ioCSR4  0x20    /* transmit list base address */
121#define ioCSR5  0x28    /* status register */
122#define ioCSR6  0x30    /* operation mode register */
123#define ioCSR7  0x38    /* interrupt mask register */
124#define ioCSR8  0x40    /* missed frame counter */
125#define ioCSR9  0x48    /* Ethernet ROM register */
126#define ioCSR10 0x50    /* reserved */
127#define ioCSR11 0x58    /* full-duplex register */
128#define ioCSR12 0x60    /* SIA status register */
129#define ioCSR13 0x68
130#define ioCSR14 0x70
131#define ioCSR15 0x78    /* SIA general register */
132
133/* command and status registers, 32-bit access, only if MEMORY-ACCESS */
134#define memCSR0  0x00    /* bus mode register */
135#define memCSR1  0x02    /* transmit poll demand */
136#define memCSR2  0x04    /* receive poll demand */
137#define memCSR3  0x06    /* receive list base address */
138#define memCSR4  0x08    /* transmit list base address */
139#define memCSR5  0x0A    /* status register */
140#define memCSR6  0x0C    /* operation mode register */
141#define memCSR7  0x0E    /* interrupt mask register */
142#define memCSR8  0x10    /* missed frame counter */
143#define memCSR9  0x12    /* Ethernet ROM register */
144#define memCSR10 0x14    /* reserved */
145#define memCSR11 0x16    /* full-duplex register */
146#define memCSR12 0x18    /* SIA status register */
147#define memCSR13 0x1A
148#define memCSR14 0x1C
149#define memCSR15 0x1E    /* SIA general register */
150
151#define DEC_REGISTER_SIZE    0x100   /* to reserve virtual memory */
152
153
154
155
156#define RESET_CHIP   0x00000001
157#if defined(__PPC__)
158#define CSR0_MODE    0x0030e002   /* 01b08000 */
159#else
160#define CSR0_MODE    0x0020e002   /* 01b08000 */
161#endif
162#define ROM_ADDRESS  0x00004800
163#define CSR6_INIT    0x022cc000   /* 022c0000 020c0000 */
164#define CSR6_TX      0x00002000
165#define CSR6_TXRX    0x00002002
166#define IT_SETUP     0x000100c0   /* 000100e0 */
167#define CLEAR_IT     0xFFFFFFFF
168#define NO_IT        0x00000000
169
170/* message descriptor entry */
171struct MD {
172    /* used by hardware */
173    volatile uint32_t   status;
174    volatile uint32_t   counts;
175    volatile uint32_t   buf1, buf2;
176    /* used by software */
177    volatile struct mbuf *m;
178    volatile struct MD *next;
179} __attribute__ ((packed));
180
181/*
182** These buffers allocated for each unit, so ensure
183**
184**   rtems_bsdnet_config.mbuf_bytecount
185**   rtems_bsdnet_config.mbuf_cluster_bytecount
186**
187** are adequately sized to provide enough clusters and mbufs for all the
188** units.  The default bsdnet configuration is sufficient for one dec
189** unit, but will be nearing exhaustion with 2 or more.  Although a
190** little expensive in memory, the following configuration should
191** eliminate all mbuf/cluster issues;
192**
193**   rtems_bsdnet_config.mbuf_bytecount           = 128*1024;
194**   rtems_bsdnet_config.mbuf_cluster_bytecount   = 256*1024;
195*/
196
197#define NRXBUFS 16    /* number of receive buffers */
198#define NTXBUFS 16    /* number of transmit buffers */
199
200/*
201 * Number of DEC boards supported by this driver
202 */
203#define NDECDRIVER    8
204
205/*
206 * Receive buffer size -- Allow for a full ethernet packet including CRC
207 */
208#define RBUF_SIZE    1536
209
210#define ET_MINLEN       60    /* minimum message length */
211
212/*
213** Events, one per unit.  The event is sent to the rx task from the isr
214** or from the stack to the tx task whenever a unit needs service.  The
215** rx/tx tasks identify the requesting unit(s) by their particular
216** events so only requesting units are serviced.
217*/
218
219static rtems_event_set unit_signals[NDECDRIVER]= { RTEMS_EVENT_1,
220                                                   RTEMS_EVENT_2,
221                                                   RTEMS_EVENT_3,
222                                                   RTEMS_EVENT_4,
223                                                   RTEMS_EVENT_5,
224                                                   RTEMS_EVENT_6,
225                                                   RTEMS_EVENT_7,
226                                                   RTEMS_EVENT_8 };
227
228#if defined(__PPC__)
229#define phys_to_bus(address) ((unsigned int)((address)) + PCI_DRAM_OFFSET)
230#define bus_to_phys(address) ((unsigned int)((address)) - PCI_DRAM_OFFSET)
231#define CPU_CACHE_ALIGNMENT_FOR_BUFFER PPC_CACHE_ALIGNMENT
232#else
233extern void Wait_X_ms( unsigned int timeToWait );
234#define phys_to_bus(address) ((unsigned int) ((address)))
235#define bus_to_phys(address) ((unsigned int) ((address)))
236#define rtems_bsp_delay_in_bus_cycles(cycle) Wait_X_ms( cycle/100 )
237#define CPU_CACHE_ALIGNMENT_FOR_BUFFER PG_SIZE
238#endif
239
240#if (MCLBYTES < RBUF_SIZE)
241# error "Driver must have MCLBYTES > RBUF_SIZE"
242#endif
243
244/*
245 * Per-device data
246 */
247struct dec21140_softc {
248
249      struct arpcom             arpcom;
250
251      rtems_irq_connect_data    irqInfo;
252      rtems_event_set           ioevent;
253
254      int                       numRxbuffers, numTxbuffers;
255
256      volatile struct MD        *MDbase;
257      volatile struct MD        *nextRxMD;
258      volatile unsigned char   *bufferBase;
259      int                       acceptBroadcast;
260
261      volatile struct MD       *TxMD;
262      volatile struct MD       *SentTxMD;
263      int                       PendingTxCount;
264      int                       TxSuspended;
265
266      unsigned int              port;
267      volatile uint32_t        *base;
268
269      /*
270       * Statistics
271       */
272      unsigned long     rxInterrupts;
273      unsigned long     rxNotFirst;
274      unsigned long     rxNotLast;
275      unsigned long     rxGiant;
276      unsigned long     rxNonOctet;
277      unsigned long     rxRunt;
278      unsigned long     rxBadCRC;
279      unsigned long     rxOverrun;
280      unsigned long     rxCollision;
281
282      unsigned long     txInterrupts;
283      unsigned long     txDeferred;
284      unsigned long     txHeartbeat;
285      unsigned long     txLateCollision;
286      unsigned long     txRetryLimit;
287      unsigned long     txUnderrun;
288      unsigned long     txLostCarrier;
289      unsigned long     txRawWait;
290};
291
292static struct dec21140_softc dec21140_softc[NDECDRIVER];
293static rtems_id rxDaemonTid;
294static rtems_id txDaemonTid;
295
296void dec21140_txDaemon (void *arg);
297
298/*
299 * This routine reads a word (16 bits) from the serial EEPROM.
300 */
301/*  EEPROM_Ctrl bits. */
302#define EE_SHIFT_CLK    0x02    /* EEPROM shift clock. */
303#define EE_CS           0x01    /* EEPROM chip select. */
304#define EE_DATA_WRITE   0x04    /* EEPROM chip data in. */
305#define EE_WRITE_0      0x01
306#define EE_WRITE_1      0x05
307#define EE_DATA_READ    0x08    /* EEPROM chip data out. */
308#define EE_ENB          (0x4800 | EE_CS)
309
310/* The EEPROM commands include the alway-set leading bit. */
311#define EE_WRITE_CMD    (5 << 6)
312#define EE_READ_CMD     (6 << 6)
313#define EE_ERASE_CMD    (7 << 6)
314
315static int eeget16(volatile uint32_t *ioaddr, int location)
316{
317   int i;
318   unsigned short retval = 0;
319   int read_cmd = location | EE_READ_CMD;
320
321   st_le32(ioaddr, EE_ENB & ~EE_CS);
322   st_le32(ioaddr, EE_ENB);
323
324   /* Shift the read command bits out. */
325   for (i = 10; i >= 0; i--) {
326      short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
327      st_le32(ioaddr, EE_ENB | dataval);
328      rtems_bsp_delay_in_bus_cycles(200);
329      st_le32(ioaddr, EE_ENB | dataval | EE_SHIFT_CLK);
330      rtems_bsp_delay_in_bus_cycles(200);
331      st_le32(ioaddr, EE_ENB | dataval); /* Finish EEPROM a clock tick. */
332      rtems_bsp_delay_in_bus_cycles(200);
333   }
334   st_le32(ioaddr, EE_ENB);
335
336   for (i = 16; i > 0; i--) {
337      st_le32(ioaddr, EE_ENB | EE_SHIFT_CLK);
338      rtems_bsp_delay_in_bus_cycles(200);
339      retval = (retval << 1) | ((ld_le32(ioaddr) & EE_DATA_READ) ? 1 : 0);
340      st_le32(ioaddr, EE_ENB);
341      rtems_bsp_delay_in_bus_cycles(200);
342   }
343
344   /* Terminate the EEPROM access. */
345   st_le32(ioaddr, EE_ENB & ~EE_CS);
346   return ( ((retval<<8)&0xff00) | ((retval>>8)&0xff) );
347}
348
349static void no_op(const rtems_irq_connect_data* irq)
350{
351   return;
352}
353
354/*
355 * DEC21140 interrupt handler
356 */
357static rtems_isr
358dec21140Enet_interrupt_handler ( struct dec21140_softc *sc )
359{
360   volatile uint32_t      *tbase;
361   uint32_t               status;
362
363   tbase = (uint32_t*)(sc->base);
364
365   /*
366    * Read status
367    */
368   status = ld_le32(tbase+memCSR5);
369   st_le32((tbase+memCSR5), status);
370
371   /*
372    * Frame received?
373    */
374   if( status & 0x000000c0 )
375   {
376      sc->rxInterrupts++;
377      rtems_bsdnet_event_send(rxDaemonTid, sc->ioevent);
378   }
379}
380
381static rtems_isr
382dec21140Enet_interrupt_handler_entry(void)
383{
384   int i;
385
386   /*
387   ** Check all the initialized dec units for interrupt service
388   */
389
390   for(i=0; i< NDECDRIVER; i++ )
391   {
392      if( dec21140_softc[i].base )
393         dec21140Enet_interrupt_handler( &dec21140_softc[i] );
394   }
395}
396
397/*
398 * Initialize the ethernet hardware
399 */
400static void
401dec21140Enet_initialize_hardware (struct dec21140_softc *sc)
402{
403   int i,st;
404   volatile uint32_t      *tbase;
405   volatile unsigned char *cp, *setup_frm, *eaddrs;
406   volatile unsigned char *buffer;
407   volatile struct MD     *rmd;
408
409
410#ifdef DEC_DEBUG
411   printk("dec2114x : %02x:%02x:%02x:%02x:%02x:%02x   name '%s%d', io %x, mem %x, int %d\n",
412          sc->arpcom.ac_enaddr[0], sc->arpcom.ac_enaddr[1],
413          sc->arpcom.ac_enaddr[2], sc->arpcom.ac_enaddr[3],
414          sc->arpcom.ac_enaddr[4], sc->arpcom.ac_enaddr[5],
415          sc->arpcom.ac_if.if_name, sc->arpcom.ac_if.if_unit,
416          sc->port, (unsigned) sc->base, sc->irqInfo.name );
417#endif
418
419   tbase = sc->base;
420
421   /*
422    * WARNING : First write in CSR6
423    *           Then Reset the chip ( 1 in CSR0)
424    */
425   st_le32( (tbase+memCSR6), CSR6_INIT);
426   st_le32( (tbase+memCSR0), RESET_CHIP);
427   rtems_bsp_delay_in_bus_cycles(200);
428
429   st_le32( (tbase+memCSR7), NO_IT);
430
431   /*
432    * Init CSR0
433    */
434   st_le32( (tbase+memCSR0), CSR0_MODE);
435
436   /*
437    * Init RX ring
438    */
439   cp = (volatile unsigned char *)malloc(((sc->numRxbuffers+sc->numTxbuffers)*sizeof(struct MD))
440                                         + (sc->numTxbuffers*RBUF_SIZE)
441                                         + CPU_CACHE_ALIGNMENT_FOR_BUFFER);
442   sc->bufferBase = cp;
443   cp += (CPU_CACHE_ALIGNMENT_FOR_BUFFER - (int)cp) & (CPU_CACHE_ALIGNMENT_FOR_BUFFER - 1);
444#if defined(__i386__)
445#ifdef PCI_BRIDGE_DOES_NOT_ENSURE_CACHE_COHERENCY_FOR_DMA
446   if (_CPU_is_paging_enabled())
447      _CPU_change_memory_mapping_attribute
448         (NULL, cp,
449          ((sc->numRxbuffers+sc->numTxbuffers)*sizeof(struct MD))
450          + (sc->numTxbuffers*RBUF_SIZE),
451          PTE_CACHE_DISABLE | PTE_WRITABLE);
452#endif
453#endif
454   rmd = (volatile struct MD*)cp;
455   sc->MDbase = rmd;
456   sc->nextRxMD = sc->MDbase;
457
458   buffer = cp + ((sc->numRxbuffers+sc->numTxbuffers)*sizeof(struct MD));
459   st_le32( (tbase+memCSR3), (long)(phys_to_bus((long)(sc->MDbase))));
460
461   for (i=0 ; i<sc->numRxbuffers; i++)
462   {
463      struct mbuf *m;
464
465      /* allocate an mbuf for each receive descriptor */
466      MGETHDR (m, M_WAIT, MT_DATA);
467      MCLGET (m, M_WAIT);
468      m->m_pkthdr.rcvif = &sc->arpcom.ac_if;
469      rmd->m = m;
470
471      rmd->buf2   = phys_to_bus(rmd+1);
472      rmd->buf1   = phys_to_bus(mtod(m, void *));
473      rmd->status = 0x80000000;
474      rmd->counts = 0xfdc00000 | (RBUF_SIZE);
475      rmd->next   = rmd+1;
476      rmd++;
477   }
478   /*
479    * mark last RX buffer.
480    */
481   sc->MDbase [sc->numRxbuffers-1].buf2   = 0;
482   sc->MDbase [sc->numRxbuffers-1].counts = 0xfec00000 | (RBUF_SIZE);
483   sc->MDbase [sc->numRxbuffers-1].next   = sc->MDbase;
484
485
486
487   /*
488    * Init TX ring
489    */
490   st_le32( (tbase+memCSR4), (long)(phys_to_bus((long)(rmd))) );
491   for (i=0 ; i<sc->numTxbuffers; i++){
492      (rmd+i)->buf2   = phys_to_bus(rmd+i+1);
493      (rmd+i)->buf1   = phys_to_bus(buffer + (i*RBUF_SIZE));
494      (rmd+i)->counts = 0x01000000;
495      (rmd+i)->status = 0x0;
496      (rmd+i)->next   = rmd+i+1;
497      (rmd+i)->m      = 0;
498   }
499
500   /*
501    * mark last TX buffer.
502    */
503   (rmd+sc->numTxbuffers-1)->buf2   = phys_to_bus(rmd);
504   (rmd+sc->numTxbuffers-1)->next   = rmd;
505
506
507   /*
508    * Build setup frame
509    */
510   setup_frm = (volatile unsigned char *)(bus_to_phys(rmd->buf1));
511   eaddrs = (unsigned char *)(sc->arpcom.ac_enaddr);
512   /* Fill the buffer with our physical address. */
513   for (i = 1; i < 16; i++) {
514      *setup_frm++ = eaddrs[0];
515      *setup_frm++ = eaddrs[1];
516      *setup_frm++ = eaddrs[0];
517      *setup_frm++ = eaddrs[1];
518      *setup_frm++ = eaddrs[2];
519      *setup_frm++ = eaddrs[3];
520      *setup_frm++ = eaddrs[2];
521      *setup_frm++ = eaddrs[3];
522      *setup_frm++ = eaddrs[4];
523      *setup_frm++ = eaddrs[5];
524      *setup_frm++ = eaddrs[4];
525      *setup_frm++ = eaddrs[5];
526   }
527
528   /* Add the broadcast address when doing perfect filtering */
529   memset((void*) setup_frm, 0xff, 12);
530   rmd->counts = 0x09000000 | 192 ;
531   rmd->status = 0x80000000;
532   st_le32( (tbase+memCSR6), CSR6_INIT | CSR6_TX);
533   st_le32( (tbase+memCSR1), 1);
534
535   while (rmd->status != 0x7fffffff);
536   rmd->counts = 0x01000000;
537
538   sc->TxMD = rmd+1;
539
540   sc->irqInfo.hdl  = (rtems_irq_hdl)dec21140Enet_interrupt_handler_entry;
541   sc->irqInfo.on   = no_op;
542   sc->irqInfo.off  = no_op;
543   sc->irqInfo.isOn = NULL;
544
545#ifdef DEC_DEBUG
546   printk( "dec2114x: Installing IRQ %d\n", sc->irqInfo.name );
547#endif
548#ifdef BSP_SHARED_HANDLER_SUPPORT
549   st = BSP_install_rtems_shared_irq_handler( &sc->irqInfo );
550#else
551   st = BSP_install_rtems_irq_handler( &sc->irqInfo );
552#endif
553
554   if (!st)
555      rtems_panic ("dec2114x : Interrupt name %d already in use\n", sc->irqInfo.name );
556}
557
558static void
559dec21140_rxDaemon (void *arg)
560{
561   volatile struct MD    *rmd;
562   struct dec21140_softc *sc;
563   struct ifnet          *ifp;
564   struct ether_header   *eh;
565   struct mbuf           *m;
566   unsigned int          i,len;
567   rtems_event_set       events;
568
569   for (;;)
570   {
571
572      rtems_bsdnet_event_receive( RTEMS_ALL_EVENTS,
573                                  RTEMS_WAIT|RTEMS_EVENT_ANY,
574                                  RTEMS_NO_TIMEOUT,
575                                  &events);
576
577      for(i=0; i< NDECDRIVER; i++ )
578      {
579         sc = &dec21140_softc[i];
580         if( sc->base )
581         {
582            if( events & sc->ioevent )
583            {
584               ifp   = &sc->arpcom.ac_if;
585               rmd   = sc->nextRxMD;
586
587               /*
588               ** Read off all the packets we've received on this unit
589               */
590               while((rmd->status & 0x80000000) == 0)
591               {
592                  /* printk("unit %i rx\n", ifp->if_unit ); */
593
594                  /* pass on the packet in the mbuf */
595                  len = (rmd->status >> 16) & 0x7ff;
596                  m = (struct mbuf *)(rmd->m);
597                  m->m_len = m->m_pkthdr.len = len - sizeof(struct ether_header);
598                  eh = mtod (m, struct ether_header *);
599                  m->m_data += sizeof(struct ether_header);
600                  ether_input (ifp, eh, m);
601
602                  /* get a new mbuf for the 21140 */
603                  MGETHDR (m, M_WAIT, MT_DATA);
604                  MCLGET (m, M_WAIT);
605                  m->m_pkthdr.rcvif = ifp;
606                  rmd->m = m;
607                  rmd->buf1 = phys_to_bus(mtod(m, void *));
608
609                  /* mark the descriptor as ready to receive */
610                  rmd->status = 0x80000000;
611
612                  rmd=rmd->next;
613               }
614
615               sc->nextRxMD = rmd;
616            }
617         }
618      }
619
620   }
621}
622
623static void
624sendpacket (struct ifnet *ifp, struct mbuf *m)
625{
626   struct dec21140_softc   *dp = ifp->if_softc;
627   volatile struct MD      *tmd;
628   volatile unsigned char  *temp;
629   struct mbuf             *n;
630   unsigned int            len;
631   volatile uint32_t      *tbase;
632
633   tbase = dp->base;
634   /*
635    * Waiting for Transmitter ready
636    */
637
638   tmd = dp->TxMD;
639   n = m;
640
641   while ((tmd->status & 0x80000000) != 0)
642   {
643      tmd=tmd->next;
644   }
645
646   len = 0;
647   temp = (volatile unsigned char *)(bus_to_phys(tmd->buf1));
648
649   for (;;)
650   {
651      len += m->m_len;
652      memcpy((void*) temp, (char *)m->m_data, m->m_len);
653      temp += m->m_len ;
654      if ((m = m->m_next) == NULL)
655         break;
656   }
657
658   if (len < ET_MINLEN) len = ET_MINLEN;
659   tmd->counts =  0xe1000000 | (len & 0x7ff);
660   tmd->status = 0x80000000;
661
662   st_le32( (tbase+memCSR1), 0x1);
663
664   m_freem(n);
665
666   dp->TxMD = tmd->next;
667}
668
669/*
670 * Driver transmit daemon
671 */
672void
673dec21140_txDaemon (void *arg)
674{
675   struct dec21140_softc *sc;
676   struct ifnet          *ifp;
677   struct mbuf           *m;
678   int i;
679   rtems_event_set       events;
680
681   for (;;)
682   {
683      /*
684       * Wait for packets bound for any of the dec units
685       */
686      rtems_bsdnet_event_receive( RTEMS_ALL_EVENTS,
687                                  RTEMS_EVENT_ANY | RTEMS_WAIT,
688                                  RTEMS_NO_TIMEOUT, &events);
689
690      for(i=0; i< NDECDRIVER; i++ )
691      {
692         sc  = &dec21140_softc[i];
693         if( sc->base )
694         {
695            if( events & sc->ioevent )
696            {
697               ifp = &sc->arpcom.ac_if;
698
699               /*
700                * Send packets till queue is empty
701                */
702               for(;;)
703               {
704                  IF_DEQUEUE(&ifp->if_snd, m);
705                  if( !m ) break;
706                  /* printk("unit %i tx\n", ifp->if_unit ); */
707                  sendpacket (ifp, m);
708               }
709
710               ifp->if_flags &= ~IFF_OACTIVE;
711            }
712         }
713      }
714
715   }
716}
717
718static void
719dec21140_start (struct ifnet *ifp)
720{
721   struct dec21140_softc *sc = ifp->if_softc;
722   rtems_bsdnet_event_send( txDaemonTid, sc->ioevent );
723   ifp->if_flags |= IFF_OACTIVE;
724}
725
726/*
727 * Initialize and start the device
728 */
729static void
730dec21140_init (void *arg)
731{
732   struct dec21140_softc *sc = arg;
733   struct ifnet *ifp = &sc->arpcom.ac_if;
734   volatile uint32_t *tbase;
735
736   /*
737    * Set up DEC21140 hardware if its not already been done
738    */
739   if( !sc->irqInfo.hdl )
740   {
741      dec21140Enet_initialize_hardware (sc);
742   }
743
744   /*
745    * Enable RX and TX
746    */
747   tbase = sc->base;
748   st_le32( (tbase+memCSR5), IT_SETUP);
749   st_le32( (tbase+memCSR7), IT_SETUP);
750   st_le32( (tbase+memCSR6), CSR6_INIT | CSR6_TXRX);
751
752   /*
753    * Tell the world that we're running.
754    */
755   ifp->if_flags |= IFF_RUNNING;
756}
757
758/*
759 * Stop the device
760 */
761static void
762dec21140_stop (struct dec21140_softc *sc)
763{
764  volatile uint32_t *tbase;
765  struct ifnet *ifp = &sc->arpcom.ac_if;
766
767  ifp->if_flags &= ~IFF_RUNNING;
768
769  /*
770   * Stop the transmitter
771   */
772  tbase = sc->base;
773  st_le32( (tbase+memCSR7), NO_IT);
774  st_le32( (tbase+memCSR6), CSR6_INIT);
775
776  /*  free((void*)sc->bufferBase); */
777}
778
779/*
780 * Show interface statistics
781 */
782static void
783dec21140_stats (struct dec21140_softc *sc)
784{
785  printf ("      Rx Interrupts:%-8lu", sc->rxInterrupts);
786  printf ("       Not First:%-8lu", sc->rxNotFirst);
787  printf ("        Not Last:%-8lu\n", sc->rxNotLast);
788  printf ("              Giant:%-8lu", sc->rxGiant);
789  printf ("            Runt:%-8lu", sc->rxRunt);
790  printf ("       Non-octet:%-8lu\n", sc->rxNonOctet);
791  printf ("            Bad CRC:%-8lu", sc->rxBadCRC);
792  printf ("         Overrun:%-8lu", sc->rxOverrun);
793  printf ("       Collision:%-8lu\n", sc->rxCollision);
794
795  printf ("      Tx Interrupts:%-8lu", sc->txInterrupts);
796  printf ("        Deferred:%-8lu", sc->txDeferred);
797  printf (" Missed Hearbeat:%-8lu\n", sc->txHeartbeat);
798  printf ("         No Carrier:%-8lu", sc->txLostCarrier);
799  printf ("Retransmit Limit:%-8lu", sc->txRetryLimit);
800  printf ("  Late Collision:%-8lu\n", sc->txLateCollision);
801  printf ("           Underrun:%-8lu", sc->txUnderrun);
802  printf (" Raw output wait:%-8lu\n", sc->txRawWait);
803}
804
805/*
806 * Driver ioctl handler
807 */
808static int
809dec21140_ioctl (struct ifnet *ifp, ioctl_command_t command, caddr_t data)
810{
811   struct dec21140_softc *sc = ifp->if_softc;
812   int error = 0;
813
814   switch (command) {
815      case SIOCGIFADDR:
816      case SIOCSIFADDR:
817         ether_ioctl (ifp, command, data);
818         break;
819
820      case SIOCSIFFLAGS:
821         switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
822            case IFF_RUNNING:
823               dec21140_stop (sc);
824               break;
825
826            case IFF_UP:
827               dec21140_init (sc);
828               break;
829
830            case IFF_UP | IFF_RUNNING:
831               dec21140_stop (sc);
832               dec21140_init (sc);
833               break;
834
835            default:
836               break;
837         }
838         break;
839
840      case SIO_RTEMS_SHOW_STATS:
841         dec21140_stats (sc);
842         break;
843
844         /*
845          * FIXME: All sorts of multicast commands need to be added here!
846          */
847      default:
848         error = EINVAL;
849         break;
850   }
851
852   return error;
853}
854
855
856/*
857int iftap(struct ifnet *ifp, struct ether_header *eh, struct mbuf *m )
858{
859   int i;
860
861   if(  ifp->if_unit == 1 ) return 0;
862
863   printf("unit %i, src ", ifp->if_unit );
864   for(i=0; i< ETHER_ADDR_LEN; i++) printf("%02x", (char) eh->ether_shost[i] );
865   printf(" dest ");
866   for(i=0; i< ETHER_ADDR_LEN; i++) printf("%02x", (char) eh->ether_dhost[i] );
867   printf("\n");
868
869   return -1;
870}
871*/
872
873/*
874 * Attach an DEC21140 driver to the system
875 */
876int
877rtems_dec21140_driver_attach (struct rtems_bsdnet_ifconfig *config, int attach)
878{
879   struct dec21140_softc *sc;
880   struct ifnet *ifp;
881   char         *unitName;
882   int          unitNumber;
883   int          mtu;
884   unsigned char cvalue;
885#if defined(__i386__)
886   uint32_t     value;
887   uint8_t      interrupt;
888#endif
889   int          pbus, pdev, pfun;
890#if defined(__PPC__)
891   int          tmp;
892   uint32_t     lvalue;
893#endif
894
895   /*
896    * Get the instance number for the board we're going to configure
897    * from the user.
898    */
899   if( (unitNumber = rtems_bsdnet_parse_driver_name(config, &unitName)) == -1 )
900   {
901      return 0;
902   }
903   if( strcmp(unitName, DRIVER_PREFIX) )
904   {
905      printk("dec2114x : unit name '%s' not %s\n", unitName, DRIVER_PREFIX );
906      return 0;
907   }
908
909   /*
910    * Find the board
911    */
912   if ( pci_find_device(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21140,
913                          unitNumber-1, &pbus, &pdev, &pfun) == -1 ) {
914      if ( pci_find_device(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21143,
915                             unitNumber-1, &pbus, &pdev, &pfun) != -1 ) {
916
917        /* the 21143 chip must be enabled before it can be accessed */
918#if defined(__i386__)
919        pci_write_config_dword(pbus, pdev, pfun, 0x40, 0 );
920#else
921        pci_write_config_dword(pbus, pdev, pfun, 0x40, PCI_DEVICE_ID_DEC_21143);
922#endif
923
924      } else {
925         printk("dec2114x : device '%s' not found on PCI bus\n", config->name );
926         return 0;
927      }
928   }
929
930#ifdef DEC_DEBUG
931   else {
932      printk("dec21140 : found device '%s', bus 0x%02x, dev 0x%02x, func 0x%02x\n",
933             config->name, pbus, pdev, pfun);
934   }
935#endif
936
937   if ((unitNumber < 1) || (unitNumber > NDECDRIVER))
938   {
939      printk("dec2114x : unit %i is invalid, must be (1 <= n <= %d)\n",
940              unitNumber, NDECDRIVER);
941      return 0;
942   }
943
944   sc = &dec21140_softc[unitNumber - 1];
945   ifp = &sc->arpcom.ac_if;
946   if (ifp->if_softc != NULL)
947   {
948      printk("dec2114x : unit %i already in use.\n", unitNumber );
949      return 0;
950   }
951
952
953   /*
954   ** Get this unit's rx/tx event
955   */
956   sc->ioevent = unit_signals[unitNumber-1];
957
958   /*
959   ** Save the buffer counts
960   */
961   sc->numRxbuffers = (config->rbuf_count) ? config->rbuf_count : NRXBUFS;
962   sc->numTxbuffers = (config->xbuf_count) ? config->xbuf_count : NTXBUFS;
963
964
965   /*
966    * Get card address spaces & retrieve its isr vector
967    */
968#if defined(__i386__)
969
970   pci_read_config_dword(pbus, pdev, pfun, 16, &value);
971   sc->port = value & ~IO_MASK;
972
973   pci_read_config_dword(pbus, pdev, pfun, 20, &value);
974   if (_CPU_is_paging_enabled())
975      _CPU_map_phys_address((void **) &(sc->base),
976                            (void *)(value & ~MEM_MASK),
977                            DEC_REGISTER_SIZE ,
978                            PTE_CACHE_DISABLE | PTE_WRITABLE);
979   else
980      sc->base = (uint32_t *)(value & ~MEM_MASK);
981
982   pci_read_config_byte(pbus, pdev, pfun, 60, &interrupt);
983   cvalue = interrupt;
984#endif
985#if defined(__PPC__)
986   (void)pci_read_config_dword(pbus,
987                               pdev,
988                               pfun,
989                               PCI_BASE_ADDRESS_0,
990                               &lvalue);
991
992   sc->port = lvalue & (unsigned int)(~IO_MASK);
993
994   (void)pci_read_config_dword(pbus,
995                               pdev,
996                               pfun,
997                               PCI_BASE_ADDRESS_1,
998                               &lvalue);
999
1000   tmp = (unsigned int)(lvalue & (unsigned int)(~MEM_MASK))
1001      + (unsigned int)PCI_MEM_BASE;
1002
1003   sc->base = (uint32_t*)(tmp);
1004
1005   pci_read_config_byte(pbus,
1006                        pdev,
1007                        pfun,
1008                        PCI_INTERRUPT_LINE,
1009                        &cvalue);
1010
1011#endif
1012
1013   /*
1014   ** Prep the board
1015   */
1016
1017   pci_write_config_word(pbus, pdev, pfun,
1018      PCI_COMMAND,
1019      (uint16_t) ( PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER ) );
1020
1021   /*
1022   ** Store the interrupt name, we'll use it later when we initialize
1023   ** the board.
1024   */
1025   memset(&sc->irqInfo,0,sizeof(rtems_irq_connect_data));
1026   sc->irqInfo.name = cvalue;
1027
1028
1029#ifdef DEC_DEBUG
1030   printk("dec2114x : unit %d base address %p.\n", unitNumber, sc->base);
1031#endif
1032
1033
1034   /*
1035   ** Setup ethernet address
1036   */
1037   if (config->hardware_address) {
1038      memcpy (sc->arpcom.ac_enaddr, config->hardware_address,
1039              ETHER_ADDR_LEN);
1040   }
1041   else {
1042      union {char c[64]; unsigned short s[32];} rombuf;
1043      int i;
1044
1045      for (i=0; i<32; i++){
1046         rombuf.s[i] = eeget16( sc->base + memCSR9, i);
1047      }
1048#if defined(__i386__)
1049      for (i=0 ; i<(ETHER_ADDR_LEN/2); i++){
1050         sc->arpcom.ac_enaddr[2*i]   = rombuf.c[20+2*i+1];
1051         sc->arpcom.ac_enaddr[2*i+1] = rombuf.c[20+2*i];
1052      }
1053#endif
1054#if defined(__PPC__)
1055      memcpy (sc->arpcom.ac_enaddr, rombuf.c+20, ETHER_ADDR_LEN);
1056#endif
1057   }
1058
1059   if (config->mtu)
1060      mtu = config->mtu;
1061   else
1062      mtu = ETHERMTU;
1063
1064   sc->acceptBroadcast = !config->ignore_broadcast;
1065
1066   /*
1067    * Set up network interface values
1068    */
1069
1070/*   ifp->if_tap = iftap; */
1071
1072   ifp->if_softc = sc;
1073   ifp->if_unit = unitNumber;
1074   ifp->if_name = unitName;
1075   ifp->if_mtu = mtu;
1076   ifp->if_init = dec21140_init;
1077   ifp->if_ioctl = dec21140_ioctl;
1078   ifp->if_start = dec21140_start;
1079   ifp->if_output = ether_output;
1080   ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
1081   if (ifp->if_snd.ifq_maxlen == 0)
1082      ifp->if_snd.ifq_maxlen = ifqmaxlen;
1083
1084   /*
1085    * Attach the interface
1086    */
1087   if_attach (ifp);
1088   ether_ifattach (ifp);
1089
1090#ifdef DEC_DEBUG
1091   printk( "dec2114x : driver attached\n" );
1092#endif
1093
1094   /*
1095    * Start driver tasks if this is the first dec unit initialized
1096    */
1097   if (txDaemonTid == 0)
1098   {
1099      rxDaemonTid = rtems_bsdnet_newproc( "DCrx", 4096,
1100                                          dec21140_rxDaemon, NULL);
1101
1102      txDaemonTid = rtems_bsdnet_newproc( "DCtx", 4096,
1103                                          dec21140_txDaemon, NULL);
1104#ifdef DEC_DEBUG
1105      printk( "dec2114x : driver tasks created\n" );
1106#endif
1107   }
1108
1109   return 1;
1110};
1111
1112#endif /* DEC21140_SUPPORTED */
Note: See TracBrowser for help on using the repository browser.