summaryrefslogtreecommitdiffstats
path: root/c/src/lib/libbsp/i386/pc386/network/network.c
blob: a37b9cf88c8bb0526f247e379f3c6fcfa5ee45a4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
/*
 * RTEMS/KA9Q driver for WD8003 Ethernet Controller
 *
 *
 *  $Id$
 */
#include <bsp.h>
#include <wd80x3.h>
#include <rtems/error.h>
#include <ka9q/rtems_ka9q.h>
#include <ka9q/global.h>
#include <ka9q/enet.h>
#include <ka9q/iface.h>
#include <ka9q/netuser.h>
#include <ka9q/trace.h>
#include <ka9q/commands.h>
#include <ka9q/domain.h>
#include "irq.h"

#define	ET_MINLEN 60		/* minimum message length */

/*
 * Number of SCCs supported by this driver
 */
#define NSCCDRIVER	1

/*
 * Default number of buffer descriptors set aside for this driver.
 * The number of transmit buffer descriptors has to be quite large
 * since a single frame often uses four or more buffer descriptors.
 */

#define RX_BUF_COUNT     15
#define TX_BUF_COUNT     4
#define TX_BD_PER_BUF    4

/*
 * RTEMS event used by interrupt handler to signal daemons.
 * This must *not* be the same event used by the KA9Q task synchronization.
 */
#define INTERRUPT_EVENT	RTEMS_EVENT_1

/*
 * Receive buffer size -- Allow for a full ethernet packet plus a pointer
 */
#define RBUF_SIZE	(1520 + sizeof (struct iface *))

/*
 * Hardware-specific storage
 */
typedef struct  {
  struct mbuf		**rxMbuf;
  struct mbuf		**txMbuf;
  unsigned int 		port;
  char 			*base;
  unsigned long		bpar;
  unsigned int		irno;
  int			rxBdCount;
  int			txBdCount;
  int			txBdHead;
  int			txBdTail;
  int			txBdActiveCount;
  struct iface		*iface;
  rtems_id		txWaitTid;
  
  /*
   * Statistics
   */
  unsigned long	rxInterrupts;
  unsigned long	rxNotFirst;
  unsigned long	rxNotLast;
  unsigned long	rxGiant;
  unsigned long	rxNonOctet;
  unsigned long	rxRunt;
  unsigned long	rxBadCRC;
  unsigned long	rxOverrun;
  unsigned long	rxCollision;
  
  unsigned long	txInterrupts;
  unsigned long	txDeferred;
  unsigned long	txHeartbeat;
  unsigned long	txLateCollision;
  unsigned long	txRetryLimit;
  unsigned long	txUnderrun;
  unsigned long	txLostCarrier;
  unsigned long	txRawWait;
}wd80x3EnetDriver;

#define RO 0x10

#define SHATOT (8*1024)		/* size of shared memory */
#define SHAPAGE 256		/* shared memory information */
#define MAXSIZ 	1536		/*(MAXBUF - MESSH_SZ)*/
#define OUTPAGE ((SHATOT-(MAXSIZ+SHAPAGE-1))/SHAPAGE)

static unsigned long loopc;

static wd80x3EnetDriver wd8003EnetDriver[NSCCDRIVER];

/*
 * WD8003 interrupt handler
 */
static rtems_isr
wd8003Enet_interrupt_handler (rtems_vector_number v)
{
  unsigned int tport, nowTicks, bootTicks;
  unsigned char status, status2;

  struct iface *iface = (struct iface *)(wd8003EnetDriver[0].iface);
  wd80x3EnetDriver *dp = (wd80x3EnetDriver *)&wd8003EnetDriver[0];
  struct mbuf *bp;
  unsigned int i2;
  unsigned int len;
  unsigned char start, next, current;
  char *shp, *temp;

  tport = wd8003EnetDriver[0].port ;

  PC386_disableIrq(wd8003EnetDriver[0].irno);
  PC386_ackIrq(wd8003EnetDriver[0].irno);
  asm volatile("sti");
  
  /*
   * Drop chips interrupt
   */
  outport_byte(tport+IMR, 0x00);

  /*
   * Read status
   */
  inport_byte(tport+ISR, status);

  /*
   * Ring overwrite
   */

  if (status & MSK_OVW){
    outport_byte(tport+CMDR, MSK_STP + MSK_RD2);	/* stop 8390 */
    rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &bootTicks );
    while(nowTicks < bootTicks+loopc)               /* 2ms delay */
      rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &nowTicks );
    outport_byte(tport+RBCR0, 0);			/* clear byte count */
    outport_byte(tport+RBCR1, 0);
    inport_byte(tport+ISR, status2);
    status |= (status2 & (MSK_PTX+MSK_TXE)) ;	/* TX status */
    outport_byte(tport+TCR, MSK_LOOP);		/* loopback mode */
    outport_byte(tport+CMDR, MSK_STA + MSK_RD2);	/* start */
  }
  
  /*
   * Frame received?
   */       
  while (status & (MSK_PRX+MSK_RXE)) {
    outport_byte(tport+ISR, status & (MSK_PRX+MSK_RXE));
    inport_byte(tport+BNRY, start);
    start += 1;
    shp = dp->base + 1 + (SHAPAGE * start);
    next = *shp++;
    len = *((short *)shp)++ - 4;
    if (start >= OUTPAGE || next >= OUTPAGE)
      break;
    bp = ambufw (RBUF_SIZE);
    bp->data += sizeof (struct iface *);
    temp = bp->data;
    bp->cnt = len;

    if ((i2 = (OUTPAGE - start) * SHAPAGE - 4) < len){
      memcpy(temp, shp, i2);
      len -= i2;
      temp += i2;
      shp = dp->base;
    }
    memcpy(temp, shp, len);

    net_route (iface, &bp);
    outport_byte(tport+BNRY, next-1);
    outport_byte(tport+CMDR, MSK_PG1 + MSK_RD2);
    inport_byte(tport+CURR, current);
    outport_byte(tport+CMDR, MSK_PG0 + MSK_RD2); 
    if (current == next)
      break;
  }

  /*
   * Ring overwrite
   */
  if (status & MSK_OVW)	{     
    outport_byte(tport+ISR, MSK_OVW);	/* reset IR */
    outport_byte(tport+TCR, 0);		/* out of loopback */
    if ((status & (MSK_PTX+MSK_TXE)) == 0)
      outport_byte(tport+CMDR, MSK_TXP + MSK_RD2);	/* resend */
  }

  /*
   * Enable chip interrupts
   */
  outport_byte(tport+IMR, 0x15);
  asm volatile("cli");
  PC386_enableIrq(wd8003EnetDriver[0].irno);
  
}

/*
 * Initialize the ethernet hardware
 */
static void
wd8003Enet_initialize_hardware (wd80x3EnetDriver *dp, int broadcastFlag)
{
  int  i1, ultra;
  char cc1, cc2;
  unsigned char  temp;
  rtems_status_code sc;
  unsigned int tport;

  tport = dp->port;

  /* address from board ROM */
  inport_byte(tport+0x04, temp);
  outport_byte(tport+0x04, temp & 0x7f);

  for (i1=cc2=0; i1<8; i1++) {
    inport_byte(tport + ADDROM + i1, cc1);
    cc2 += cc1;
    if (i1 < 6)
      dp->iface->hwaddr[i1] = cc1;
  }
  
  inport_byte(tport+0x04, temp); 
  outport_byte(tport+0x04, temp | 0x80);	/* alternate registers */
  outport_byte(tport+W83CREG, MSK_RESET);	/* reset board, set buffer */
  outport_byte(tport+W83CREG, 0);
  outport_byte(tport+W83CREG, MSK_ENASH + (int)((dp->bpar>>13)&0x3f));

  outport_byte(tport+CMDR, MSK_PG0 + MSK_RD2);
  cc1 = MSK_BMS + MSK_FT10; /* configure 8 or 16 bits */

  inport_byte(tport+0x07, temp) ; 

  ultra = ((temp & 0xf0) == 0x20 || (temp & 0xf0) == 0x40);
  if (ultra)
    cc1 = MSK_WTS + MSK_BMS + MSK_FT10;
  outport_byte(tport+DCR, cc1);
  outport_byte(tport+RBCR0, 0);
  outport_byte(tport+RBCR1, 0);
  outport_byte(tport+RCR, MSK_MON);	       	/* disable the rxer */
  outport_byte(tport+TCR, 0);			/* normal operation */
  outport_byte(tport+PSTOP, OUTPAGE);		/* init PSTOP */
  outport_byte(tport+PSTART, 0);	       	/* init PSTART */
  outport_byte(tport+BNRY, -1);			/* init BNRY */
  outport_byte(tport+ISR, -1);			/* clear IR's */
  outport_byte(tport+IMR, 0x15);	       	/* 0x17 enable interrupt */

  outport_byte(tport+CMDR, MSK_PG1 + MSK_RD2);

  for (i1=0; i1<6; i1++)			/* initial physical addr */
    outport_byte(tport+PAR+i1, dp->iface->hwaddr[i1]);

  for (i1=0; i1<MARsize; i1++)			/* clear multicast */
    outport_byte(tport+MAR+i1, 0);
  outport_byte(tport+CURR, 0);			/* init current packet */

  outport_byte(tport+CMDR, MSK_PG0 + MSK_RD2);
  outport_byte(tport+CMDR, MSK_STA + MSK_RD2);	/* put 8390 on line */
  outport_byte(tport+RCR, MSK_AB);		/* MSK_AB accept broadcast */
  
  if (ultra) {
    inport_byte(tport+0x0c, temp);
    outport_byte(tport+0x0c, temp | 0x80);
    outport_byte(tport+0x05, 0x80);
    outport_byte(tport+0x06, 0x01);
  }
  
  /*
   * Set up interrupts
   */
  sc = PC386_installRtemsIrqHandler(dp->irno, wd8003Enet_interrupt_handler);
  if (sc != RTEMS_SUCCESSFUL)
    rtems_panic ("Can't attach interrupt handler: %s\n",
		 rtems_status_text (sc));
}


/*
 * Send raw packet (caller provides header).
 * This code runs in the context of the interface transmit
 * task or in the context of the network task.
 */
static int
wd8003Enet_raw (struct iface *iface, struct mbuf **bpp)
{
  wd80x3EnetDriver *dp = &wd8003EnetDriver[iface->dev];
  struct mbuf *bp;
  unsigned int len, tport;
  char *shp;

  tport = dp->port;
  
  /*
   * Fill in some logging data
   */
  iface->rawsndcnt++;
  iface->lastsent = secclock ();
  dump (iface, IF_TRACE_OUT, *bpp);
  
  /*
   * It would not do to have two tasks active in the transmit
   * loop at the same time.
   * The blocking is simple-minded since the odds of two tasks
   * simultaneously attempting to use this code are low.  The only
   * way that two tasks can try to run here is:
   *	1) Task A enters this code and ends up having to
   *	   wait for a transmit buffer descriptor.
   *	2) Task B  gains control and tries to transmit a packet.
   * The RTEMS/KA9Q scheduling semaphore ensures that there
   * are no race conditions associated with manipulating the
   * txWaitTid variable.
   */

  if (dp->txWaitTid) {
    dp->txRawWait++;
    while (dp->txWaitTid)
      rtems_ka9q_ppause (10);
  }
  
  if (dp->txWaitTid == 0)		
    rtems_task_ident (0, 0, &dp->txWaitTid);

  bp = *bpp;
  len = 0;
  shp = dp->base + (SHAPAGE * OUTPAGE);

  /*rtems_interrupt_disable(level);*/
  
  for (;;){
    len += bp->cnt;
    memcpy(shp, (char *)bp->data, bp->cnt);
    shp += bp->cnt ;
    if ((bp = bp->next) == NULL)
      break;
  }

  free_p(bpp);

  if (len < ET_MINLEN) len = ET_MINLEN;
  outport_byte(tport+TBCR0, len);
  outport_byte(tport+TBCR1, (len >> 8) );
  outport_byte(tport+TPSR, OUTPAGE);
  outport_byte(tport+CMDR, MSK_TXP + MSK_RD2);

  /*
   * Show that we've finished with the packet
   */
  dp->txWaitTid = 0;
  return 0;
  
}


/*
 * Shut down the interface
 * FIXME: This is a pretty simple-minded routine.  It doesn't worry
 * about cleaning up mbufs, shutting down daemons, etc.
 */
static int
wd8003Enet_stop (struct iface *iface)
{
  unsigned int tport;
  unsigned char temp;
  /*
   * Stop the transmitter
   */
  tport=wd8003EnetDriver[0].port ;
  inport_byte(tport+0x04,temp);
  outport_byte(tport+0x04, temp & 0x7f);
  outport_byte(tport + CMDR, MSK_STP + MSK_RD2);
  return 0;
}

/*
 * Show interface statistics
 */
static void
wd8003Enet_show (struct iface *iface)
{
  printf ("      Rx Interrupts:%-8lu", wd8003EnetDriver[0].rxInterrupts);
  printf ("       Not First:%-8lu", wd8003EnetDriver[0].rxNotFirst);
  printf ("        Not Last:%-8lu\n", wd8003EnetDriver[0].rxNotLast);
  printf ("              Giant:%-8lu", wd8003EnetDriver[0].rxGiant);
  printf ("            Runt:%-8lu", wd8003EnetDriver[0].rxRunt);
  printf ("       Non-octet:%-8lu\n", wd8003EnetDriver[0].rxNonOctet);
  printf ("            Bad CRC:%-8lu", wd8003EnetDriver[0].rxBadCRC);
  printf ("         Overrun:%-8lu", wd8003EnetDriver[0].rxOverrun);
  printf ("       Collision:%-8lu\n", wd8003EnetDriver[0].rxCollision);
  printf ("      Tx Interrupts:%-8lu", wd8003EnetDriver[0].txInterrupts);
  printf ("        Deferred:%-8lu", wd8003EnetDriver[0].txDeferred);
  printf (" Missed Hearbeat:%-8lu\n", wd8003EnetDriver[0].txHeartbeat);
  printf ("         No Carrier:%-8lu", wd8003EnetDriver[0].txLostCarrier);
  printf ("Retransmit Limit:%-8lu", wd8003EnetDriver[0].txRetryLimit);
  printf ("  Late Collision:%-8lu\n", wd8003EnetDriver[0].txLateCollision);
  printf ("           Underrun:%-8lu", wd8003EnetDriver[0].txUnderrun);
  printf (" Raw output wait:%-8lu\n", wd8003EnetDriver[0].txRawWait);
}

/*
 * Attach an WD8003 driver to the system
 * This is the only `extern' function in the driver.
 *
 * argv[0]: interface label, e.g., "rtems"
 * The remainder of the arguemnts are key/value pairs:
 * mtu ##                  --  maximum transmission unit, default 1500
 * broadcast y/n           -- accept or ignore broadcast packets, default yes
 * rbuf ##                 -- Set number of receive buffer descriptors
 * rbuf ##                 -- Set number of transmit buffer descriptors
 * ip ###.###.###.###      -- IP address
 * ether ##:##:##:##:##:## -- Ethernet address
 * irno                    -- Set controller irq
 * port			   -- Set io port
 * bpar                    -- Set RAM address
 */
int
rtems_ka9q_driver_attach (int argc, char *argv[], void *p)
{
  struct iface *iface;
  wd80x3EnetDriver *dp;
  char *cp;
  int i;
  int argIndex;
  int broadcastFlag;
  char cbuf[30];
  
  /*
   * Find a free driver
   */
  for (i = 0 ; i < NSCCDRIVER ; i++) {
    if (wd8003EnetDriver[i].iface == NULL)
      break;
  }
  if (i >= NSCCDRIVER) {
    printf ("Too many SCC drivers.\n");
    return -1;
  }
  if (if_lookup (argv[0]) != NULL) {
    printf ("Interface %s already exists\n", argv[0]);
    return -1;
  }
  dp = &wd8003EnetDriver[i];
  
  /*
   * Create an inteface descriptor
   */
  iface = callocw (1, sizeof *iface);
  iface->name = strdup (argv[0]);
  
  /*
   * Set default values
   */
  broadcastFlag = 1;
  dp->txWaitTid = 0;
  dp->rxBdCount = RX_BUF_COUNT;
  dp->txBdCount = TX_BUF_COUNT * TX_BD_PER_BUF;
  dp->irno = 5;
  dp->port = 0x240;
  dp->base = 0xD0000;
  dp->bpar = 0xD0000;
  iface->mtu = 1500;
  iface->addr = Ip_addr;
  iface->hwaddr = mallocw (EADDR_LEN);
  memset (iface->hwaddr, 0x08, EADDR_LEN);
  
  /*
   * Parse arguments
   */
  for (argIndex = 1 ; argIndex < (argc - 1) ; argIndex++) {
    if (strcmp ("mtu", argv[argIndex]) == 0) {
      iface->mtu = atoi (argv[++argIndex]);
    }
    else if (strcmp ("broadcast", argv[argIndex]) == 0) {
      if (*argv[++argIndex] == 'n')
	broadcastFlag = 0;
    }
    else if (strcmp ("rbuf", argv[argIndex]) == 0) {
      dp->rxBdCount = atoi (argv[++argIndex]);
    }
    else if (strcmp ("tbuf", argv[argIndex]) == 0) {
      dp->txBdCount = atoi (argv[++argIndex]) * TX_BD_PER_BUF;
    }
    else if (strcmp ("ip", argv[argIndex]) == 0) {
      iface->addr = resolve (argv[++argIndex]);
    }
    else if (strcmp ("ether", argv[argIndex]) == 0) {
      argIndex++;
      gether (iface->hwaddr, argv[argIndex]);
    }
    else if (strcmp ("irno", argv[argIndex]) == 0) {
      dp->irno = atoi (argv[++argIndex]);
    }
    else if (strcmp ("port", argv[argIndex]) == 0) {
      sscanf(argv[++argIndex], "%x", &(dp->port));
    }
    else if (strcmp ("bpar", argv[argIndex]) == 0) {
      sscanf(argv[++argIndex], "%x", &(dp->bpar));
      dp->base = (char *)(dp->bpar);
    }
    else {
      printf ("Argument %d (%s) is invalid.\n", argIndex, argv[argIndex]);
      return -1;
    }
  }
  printf ("Ethernet address: %s\n", pether (cbuf, iface->hwaddr));
  printf ("Internet address: %s\n", inet_ntoa(iface->addr));
  printf ("Irno: %X, port: %X, bpar: %X, base: %X\n",dp->irno, dp->port,
	  dp->bpar, dp->base);
  fflush(stdout);
  /*	
   * Fill in remainder of interface configuration
   */	
  iface->dev = i;
  iface->raw = wd8003Enet_raw;
  iface->stop = wd8003Enet_stop;
  iface->show = wd8003Enet_show;
  dp->iface = iface;
  setencap (iface, "Ethernet");
  
  /*
   * Set up SCC hardware
   */
  wd8003Enet_initialize_hardware (dp, broadcastFlag);
  fflush(stdout);
  
  /*
   * Chain onto list of interfaces
   */
  iface->next = Ifaces;
  Ifaces = iface;
    
  /* calibrate a delay loop for 2 milliseconds */
  rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &loopc );
  loopc /= 500;
  
  /*
   * Start I/O daemons
   */
  cp = if_name (iface, " tx");
  iface->txproc = newproc (cp, 1024, if_tx, iface->dev, iface, NULL, 0);
  free (cp);
  return 0;
}