?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
panic() cleanup.
[minix.git] / drivers / orinoco / orinoco.c
blobb230d8bcf725d65017198fc23e7603e095367054
1 /*
2 * orinoco.c
3 *
4 * This file contains a wireless device driver for Prism based wireless
5 * cards.
6 *
7 * Created by Stevens Le Blond <slblond@few.vu.nl>
8 * and Michael Valkering <mjvalker@cs.vu.nl>
9 *
10 * * The valid messages and their parameters are:
11 *
12 * m_type DL_PORT DL_PROC DL_COUNT DL_MODE DL_ADDR DL_GRANT
13 * |------------+----------+---------+----------+---------+---------+---------|
14 * | HARDINT | | | | | | |
15 * |------------|----------|---------|----------|---------|---------|---------|
16 * | DL_WRITE | port nr | proc nr | count | mode | address | |
17 * |------------|----------|---------|----------|---------|---------|---------|
18 * | DL_WRITEV | port nr | proc nr | count | mode | address | |
19 * |------------|----------|---------|----------|---------|---------|---------|
20 * | DL_WRITEV_S| port nr | proc nr | count | mode | | grant |
21 * |------------|----------|---------|----------|---------|---------|---------|
22 * | DL_READ | port nr | proc nr | count | | address | |
23 * |------------|----------|---------|----------|---------|---------|---------|
24 * | DL_READV | port nr | proc nr | count | | address | |
25 * |------------|----------|---------|----------|---------|---------|---------|
26 * | DL_READV_S | port nr | proc nr | count | | | grant |
27 * |------------|----------|---------|----------|---------|---------|---------|
28 * | DL_CONF | port nr | proc nr | | mode | address | |
29 * |------------|----------|---------|----------|---------|---------|---------|
30 * | DL_GETSTAT | port nr | proc nr | | | address | |
31 * |------------|----------|---------|----------|---------|---------|---------|
32 * |DL_GETSTAT_S| port nr | proc nr | | | | grant |
33 * |------------|----------|---------|----------|---------|---------|---------|
34 * | DL_STOP | port_nr | | | | | |
35 * |------------|----------|---------|----------|---------|---------|---------|
36 *
37 * The messages sent are:
38 *
39 * m_type DL_PORT DL_PROC DL_COUNT DL_STAT DL_CLCK
40 * |------------|----------|---------|----------|---------|---------|
41 * |DL_TASK_REPL| port nr | proc nr | rd-count | err|stat| clock |
42 * |------------|----------|---------|----------|---------|---------|
43 *
44 * m_type m3_i1 m3_i2 m3_ca1
45 * |------------|---------|-----------|---------------|
46 * |DL_CONF_REPL| port nr | last port | ethernet addr |
47 * |------------|---------|-----------|---------------|
48 *
49 * m_type DL_PORT DL_STAT
50 * |------------|---------|-----------|
51 * |DL_STAT_REPL| port nr | err |
52 * |------------|---------|-----------|
53 *
54 */
55
56 #include "../drivers.h"
57 #include <string.h>
58 #include <minix/syslib.h>
59 #include <minix/type.h>
60 #include <minix/sysutil.h>
61 #include <timers.h>
62 #include <ibm/pci.h>
63 #include <minix/ds.h>
64 #include <minix/endpoint.h>
65 #include "../../kernel/const.h"
66 #include "../../kernel/config.h"
67 #include "../../kernel/type.h"
68
69 #define VERBOSE 1 /* display message during init */
70
71 PRIVATE struct pcitab {
72 u16_t vid;
73 u16_t did;
74 int checkclass;
75 } pcitab[]=
76 {
77 { 0x1260, 0x3873, 0 },
78 { 0x1186, 0x1300, 0 },
79 { 0x0000, 0x0000, 0 }
80 };
81
82
83 static timer_t or_watchdog;
84
85 #include <stdio.h>
86 #include <stdlib.h>
87 #include <minix/com.h>
88 #include <minix/portio.h>
89 #include <net/hton.h>
90 #include <net/gen/ether.h>
91 #include <net/gen/eth_io.h>
92 #include <sys/vm_i386.h>
93 #include <sys/types.h>
94 #include <unistd.h>
95 #include <errno.h>
96
97 #include "assert.h"
98 #include "hermes.h"
99 #include "hermes_rid.h"
100 #include "orinoco.h"
101
102 #define ERR -1
103
104 #define debug 0
105
106 #define OR_M_ENABLED 1
107 #define OR_M_DISABLED 0
108 #define OR_F_EMPTY 0
109 #define OR_F_MULTI 1
110 #define OR_F_BROAD (1<<1)
111 #define OR_F_ENABLED (1<<2)
112 #define OR_F_PROMISC (1<<3)
113 #define OR_F_READING (1<<4)
114 #define OR_F_SEND_AVAIL (1<<5)
115 #define OR_F_PACK_SENT (1<<6)
116 #define OR_F_PACK_RECV (1<<7)
117 #define ORINOCO_INTEN ( HERMES_EV_RX | HERMES_EV_ALLOC |\
118 HERMES_EV_WTERR | HERMES_EV_TXEXC|\
119 HERMES_EV_INFO | HERMES_EV_INFDROP|\
120 HERMES_EV_TX)
121
122 #define NO_FID (-1)
123 #define ETH_ALEN 6
124 #define USER_BAP 0
125 #define IRQ_BAP 1
126 #define ETH_HLEN 14
127
128 PRIVATE t_or or_table[OR_PORT_NR];
129
130 struct ethhdr {
131 u8_t h_dest[ETH_ALEN];
132 u8_t h_src[ETH_ALEN];
133 u16_t h_proto;
134 };
135
136 struct header_struct {
137 /* 802.3 */
138 u8_t dest[ETH_ALEN];
139 u8_t src[ETH_ALEN];
140 u16_t len;
141 /* 802.2 */
142 u8_t dsap;
143 u8_t ssap;
144 u8_t ctrl;
145 /* SNAP */
146 u8_t oui[3];
147 u16_t ethertype;
148 };
149
150 #define RUP_EVEN(x) (((x) + 1) & (~1))
151
152 u8_t encaps_hdr[] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
153 #define ENCAPS_OVERHEAD (sizeof (encaps_hdr) + 2)
154
155 /********************************************************************
156 * Data tables *
157 ********************************************************************/
158
159 /* The frequency of each channel in MHz */
160 PRIVATE const long channel_frequency[] = {
161 2412, 2417, 2422, 2427, 2432, 2437, 2442,
162 2447, 2452, 2457, 2462, 2467, 2472, 2484
163 };
164
165 #define NUM_CHANNELS (sizeof(channel_frequency) / sizeof(channel_frequency[0]))
166
167 /* This tables gives the actual meanings of the bitrate IDs returned by the
168 * firmware. Not used yet */
169 struct {
170 int bitrate; /* in 100s of kilobits */
171 int automatic;
172 u16_t txratectrl;
173 } bitrate_table[] =
174 {
175 {110, 1, 15}, /* Entry 0 is the default */
176 {10, 0, 1},
177 {10, 1, 1},
178 {20, 0, 2},
179 {20, 1, 3},
180 {55, 0, 4},
181 {55, 1, 7},
182 {110, 0, 8},};
183
184 #define BITRATE_TABLE_SIZE (sizeof(bitrate_table) / sizeof(bitrate_table[0]))
185
186
187 _PROTOTYPE (static void or_writev, (message * mp, int from_int, int vectored));
188 _PROTOTYPE (static void or_readv, (message * mp, int from_int, int vectored));
189 _PROTOTYPE (static void or_writev_s, (message * mp, int from_int));
190 _PROTOTYPE (static void or_readv_s, (message * mp, int from_int));
191 _PROTOTYPE (static void reply, (t_or * orp, int err, int may_block));
192 _PROTOTYPE (static int or_probe, (t_or *));
193 _PROTOTYPE (static void or_ev_info, (t_or *));
194 _PROTOTYPE (static void or_init, (message *));
195 _PROTOTYPE (static void or_pci_conf, (void));
196 _PROTOTYPE (static void or_init_struct, (t_or *));
197 _PROTOTYPE (static void map_hw_buffer, (t_or *));
198 _PROTOTYPE (static void or_init_hw, (t_or *));
199 _PROTOTYPE (static void or_check_ints, (t_or *));
200 _PROTOTYPE (static void or_writerids, (hermes_t *, t_or *));
201 _PROTOTYPE (static void or_readrids, (hermes_t *, t_or *));
202 _PROTOTYPE (static void or_rec_mode, (t_or *));
203 _PROTOTYPE (static void mess_reply, (message *, message *));
204 _PROTOTYPE (static u32_t or_get_bar, (int devind, t_or * orp));
205 _PROTOTYPE (static void or_getstat, (message * mp));
206 _PROTOTYPE (static void or_getstat_s, (message * mp));
207 _PROTOTYPE (static void print_linkstatus, (t_or * orp, u16_t status));
208 _PROTOTYPE (static int or_get_recvd_packet, (t_or *orp, u16_t rxfid,
209 u8_t *databuf));
210 _PROTOTYPE (static void orinoco_stop, (void));
211 _PROTOTYPE (static void or_reset, (void));
212 _PROTOTYPE (static void or_watchdog_f, (timer_t *tp) );
213 _PROTOTYPE (static void setup_wepkey, (t_or *orp, char *wepkey0) );
214 _PROTOTYPE (static void or_getstat, (message *m));
215 _PROTOTYPE (static int do_hard_int, (void));
216 _PROTOTYPE (static void check_int_events, (void));
217 _PROTOTYPE (static void or_getname, (message *m));
218 _PROTOTYPE (static int or_handler, (t_or *orp));
219 _PROTOTYPE (static void or_dump, (message *m));
220
221 /* The message used in the main loop is made global, so that rl_watchdog_f()
222 * can change its message type to fake an interrupt message.
223 */
224 PRIVATE message m;
225 PRIVATE int int_event_check; /* set to TRUE if events arrived */
226
227 PRIVATE u32_t system_hz;
228
229 PRIVATE const char *progname;
230
231 /* SEF functions and variables. */
232 FORWARD _PROTOTYPE( void sef_local_startup, (void) );
233 FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
234 EXTERN char **env_argv;
235
236 /*****************************************************************************
237 * main *
238 * *
239 * *
240 * The main function of the driver, receiving and processing messages *
241 *****************************************************************************/
242 int main(int argc, char *argv[]) {
243 int r;
244
245 /* SEF local startup. */
246 env_setargs(argc, argv);
247 sef_local_startup();
248
249 while (TRUE) {
250 if ((r = sef_receive (ANY, &m)) != OK)
251 panic("orinoco: sef_receive failed");
252
253 if (is_notify(m.m_type)) {
254 switch (_ENDPOINT_P(m.m_source)) {
255 case CLOCK:
256 or_watchdog_f(NULL);
257 break;
258 case HARDWARE:
259 do_hard_int();
260 if (int_event_check)
261 check_int_events();
262 break ;
263 case TTY_PROC_NR:
264 or_dump(&m);
265 break;
266 case PM_PROC_NR:
267 {
268 sigset_t set;
269
270 if (getsigset(&set) != 0) break;
271
272 if (sigismember(&set, SIGTERM))
273 orinoco_stop();
274
275 break;
276 }
277 default:
278 panic("orinoco: illegal notify from: %d",
279 m.m_source);
280 }
281
282 /* done, get new message */
283 continue;
284 }
285
286 switch (m.m_type) {
287 case DL_WRITEV:
288 or_writev (&m, FALSE, TRUE);
289 break;
290 case DL_WRITEV_S:
291 or_writev_s (&m, FALSE);
292 break;
293 case DL_WRITE:
294 or_writev (&m, FALSE, FALSE);
295 break;
296 case DL_READ:
297 or_readv (&m, FALSE, FALSE);
298 break;
299 case DL_READV:
300 or_readv (&m, FALSE, TRUE);
301 break;
302 case DL_READV_S:
303 or_readv_s (&m, FALSE);
304 break;
305 case DL_CONF:
306 or_init (&m);
307 break;
308 case DL_GETSTAT:
309 or_getstat (&m);
310 break;
311 case DL_GETSTAT_S:
312 or_getstat_s (&m);
313 break;
314 case DL_GETNAME:
315 or_getname(&m);
316 break;
317 default:
318 panic("orinoco: illegal message: %d", m.m_type);
319 }
320 }
321 }
322
323 /*===========================================================================*
324 * sef_local_startup *
325 *===========================================================================*/
326 PRIVATE void sef_local_startup()
327 {
328 /* Register init callbacks. */
329 sef_setcb_init_fresh(sef_cb_init_fresh);
330 sef_setcb_init_restart(sef_cb_init_fresh);
331
332 /* No live update support for now. */
333
334 /* Let SEF perform startup. */
335 sef_startup();
336 }
337
338 /*===========================================================================*
339 * sef_cb_init_fresh *
340 *===========================================================================*/
341 PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *info)
342 {
343 /* Initialize the orinoco driver. */
344 int fkeys, sfkeys, r;
345 u32_t inet_proc_nr;
346
347 system_hz = sys_hz();
348
349 (progname=strrchr(env_argv[0],'/')) ? progname++
350 : (progname=env_argv[0]);
351
352 /* Observe some function key for debug dumps. */
353 fkeys = sfkeys = 0; bit_set(sfkeys, 11);
354 if ((r=fkey_map(&fkeys, &sfkeys)) != OK)
355 printf("Warning: orinoco couldn't observe F-key(s): %d\n",r);
356
357 /* Try to notify INET that we are present (again). If INET cannot
358 * be found, assume this is the first time we started and INET is
359 * not yet alive. */
360 r = ds_retrieve_label_num("inet", &inet_proc_nr);
361 if (r == OK)
362 notify(inet_proc_nr);
363 else if (r != ESRCH)
364 printf("orinoco: ds_retrieve_label_num failed for 'inet': %d\n", r);
365
366 return(OK);
367 }
368
369 /*****************************************************************************
370 * check_int_events *
371 * *
372 * If a hard interrupt message came in, call the or_check_ints for the right *
373 * card *
374 *****************************************************************************/
375 static void check_int_events(void) {
376 int i;
377 t_or *orp;
378
379 /* the interrupt message doesn't contain information about the port, try
380 * to find it */
381 for (orp = or_table;
382 orp < or_table + OR_PORT_NR; orp++) {
383 if (orp->or_mode != OR_M_ENABLED)
384 continue;
385 if (!orp->or_got_int)
386 continue;
387 orp->or_got_int = 0;
388 assert (orp->or_flags & OR_F_ENABLED);
389 or_check_ints (orp);
390 }
391
392 }
393
394 /****************************************************************************
395 * or_getname *
396 * *
397 * Gets the drivers name, orinoco *
398 ****************************************************************************/
399 static void or_getname(message *mp) {
400 int r;
401
402 strncpy(mp->DL_NAME, progname, sizeof(mp->DL_NAME));
403 mp->DL_NAME[sizeof(mp->DL_NAME) - 1] = '\0';
404 mp->m_type = DL_NAME_REPLY;
405
406 r = send(mp->m_source, mp);
407 if(r != OK) {
408 panic("or_getname: send failed: %d", r);
409 }
410 }
411
412 /*****************************************************************************
413 * do_hard_int *
414 * *
415 * Process the interrupts which the card generated *
416 *****************************************************************************/
417 static int do_hard_int(void) {
418 u16_t evstat;
419 hermes_t *hw;
420 int i,s;
421 t_or *orp;
422
423 for (i=0; i < OR_PORT_NR; i ++) {
424 /* Run interrupt handler at driver level. */
425 or_handler( &or_table[i]);
426
427 /* Reenable interrupts for this hook. */
428 if ((s=sys_irqenable(&or_table[i].or_hook_id)) != OK) {
429 printf("orinoco: error, couldn't enable");
430 printf(" interrupts: %d\n", s);
431 }
432 }
433 }
434
435
436
437 /*****************************************************************************
438 * orinoco_stop *
439 * *
440 * Stops the card. The signal to the card itself is not implemented yet. *
441 *****************************************************************************/
442 static void orinoco_stop () {
443 int i;
444 t_or *orp;
445
446 for (i= 0, orp= &or_table[0]; i<OR_PORT_NR; i++, orp++) {
447 if (orp->or_mode != OR_M_ENABLED)
448 continue;
449 /* TODO: send a signal to the card to shut it down */
450 }
451 exit(0);
452 }
453
454 /*****************************************************************************
455 * or_reset *
456 * *
457 * Sometime the card gets screwed, behaving erratically. Solution: reset the *
458 * card. This is actually largely redoing the initialization *
459 *****************************************************************************/
460 static void or_reset() {
461 static clock_t last_reset, now;
462 t_or *orp;
463 int i, j, r;
464 u16_t irqmask;
465
466 if (OK != (r = getuptime(&now)))
467 panic("orinoco: getuptime() failed: %d", r);
468
469 if(now - last_reset < system_hz * 10) {
470 printf("Resetting card too often. Going to reset driver\n");
471 exit(1);
472 }
473
474 for (i = 0, orp = or_table; orp < or_table + OR_PORT_NR; i++, orp++) {
475 if(orp->or_mode == OR_M_DISABLED)
476 printf("orinoco port %d is disabled\n", i);
477
478 if(orp->or_mode != OR_M_ENABLED) {
479 continue;
480 }
481
482 orp->or_need_reset = 0;
483 or_init_hw(orp);
484
485 orp->rx_last = orp->rx_first = 0;
486 for(j = 0; j < NR_RX_BUFS; j++) {
487 orp->rx_length[0] = 0;
488 }
489
490 if(orp->or_flags & OR_F_SEND_AVAIL) {
491 orp->or_tx.ret_busy = FALSE;
492 orp->or_send_int = TRUE;
493 }
494 }
495
496 last_reset = now;
497
498 }
499
500 /*****************************************************************************
501 * or_dump *
502 * *
503 * Dump interesting information about the card on F-key pressed. *
504 * Not implemented yet *
505 *****************************************************************************/
506 static void or_dump (message *m)
507 {
508 t_or *orp;
509 int err;
510 u16_t evstat =0, d;
511
512 for (orp = or_table; orp < or_table + OR_PORT_NR; orp++) {
513 if(orp->or_mode == OR_M_DISABLED) {
514 printf("%s is disabled\n", orp->or_name);
515 }
516
517 if(orp->or_mode != OR_M_ENABLED)
518 continue;
519
520 m->m_type = FKEY_CONTROL;
521 m->FKEY_REQUEST = FKEY_EVENTS;
522 if(OK!=(sendrec(TTY_PROC_NR,m)) )
523 printf("Contacting the TTY failed\n");
524
525 if(bit_isset(m->FKEY_SFKEYS, 11)) {
526 print_linkstatus(orp, orp->last_linkstatus);
527 }
528 }
529 }
530
531 /*****************************************************************************
532 * or_init *
533 * *
534 * The main initialization function, called when a DL_INIT message comes in. *
535 *****************************************************************************/
536 static void or_init (message * mp) {
537 int port, err, i;
538 t_or *orp;
539 message reply;
540 static int first_time = 1;
541 clock_t t0,t1;
542
543 if (first_time) {
544 first_time = 0;
545 or_pci_conf (); /* Configure PCI devices. */
546
547 tmr_inittimer(&or_watchdog);
548 /* Use a synchronous alarm instead of a watchdog timer. */
549 sys_setalarm(system_hz, 0);
550 }
551
552 port = mp->DL_PORT;
553 if (port < 0 || port >= OR_PORT_NR) {
554 /* illegal port in message */
555 reply.m_type = DL_CONF_REPLY;
556 reply.m3_i1 = ENXIO;
557 mess_reply (mp, &reply);
558 return;
559 }
560
561 /* the port resolves to the main orinoco structure */
562 orp = &or_table[port];
563 /* resolving to the main hardware structure */
564
565 if (orp->or_mode == OR_M_DISABLED) {
566 /* Initialize the orp structure */
567 or_init_struct (orp);
568 if (orp->or_mode == OR_M_DISABLED) {
569 reply.m_type = DL_CONF_REPLY;
570 reply.m3_i1 = ENXIO;
571 mess_reply (mp, &reply);
572 return;
573 }
574 if (orp->or_mode == OR_M_ENABLED) {
575 /* initialize card, hardware/firmware */
576 orp->or_flags |= OR_F_ENABLED;
577 or_init_hw (orp);
578 }
579 }
580
581 assert (orp->or_mode == OR_M_ENABLED);
582 assert (orp->or_flags & OR_F_ENABLED);
583
584 /* Not supported by the driver yet, but set a couple of options:
585 * multicasting, promiscuity, broadcasting, depending on the users
586 * needs */
587 orp->or_flags &= ~(OR_F_PROMISC | OR_F_MULTI | OR_F_BROAD);
588 if (mp->DL_MODE & DL_PROMISC_REQ)
589 orp->or_flags |= OR_F_PROMISC;
590 if (mp->DL_MODE & DL_MULTI_REQ)
591 orp->or_flags |= OR_F_MULTI;
592 if (mp->DL_MODE & DL_BROAD_REQ)
593 orp->or_flags |= OR_F_BROAD;
594
595 orp->or_client = mp->m_source;
596 or_rec_mode (orp);
597
598 /* reply the caller that the configuration succeeded */
599 reply.m_type = DL_CONF_REPLY;
600 reply.m3_i1 = mp->DL_PORT;
601 reply.m3_i2 = OR_PORT_NR;
602 *(ether_addr_t *) reply.m3_ca1 = orp->or_address;
603 mess_reply (mp, &reply);
604 }
605
606 /*****************************************************************************
607 * or_pci_conf *
608 * *
609 * Configure the pci related issues of the card, e.g. finding out where the *
610 * card is in the pci configuration, it's assigned irq, etc. This can be *
611 * done if the boot monitor is provided with information, or the pci bus *
612 * can be searched (at the end: or_probe function) *
613 *****************************************************************************/
614 static void or_pci_conf () {
615 long v;
616 t_or *orp;
617 int i, h;
618 static char envfmt[] = "*:d.d.d";
619 static char envvar[] = OR_ENVVAR "#";
620 static char val[128];
621
622 /* extract information from the boot monitor about the pci
623 * configuration if provided */
624 for (i = 0, orp = or_table; i < OR_PORT_NR; i++, orp++) {
625 strncpy (orp->or_name, OR_NAME, sizeof(OR_NAME));
626 orp->or_name[sizeof(OR_NAME) - 2] = i + '0';
627 orp->or_seen = FALSE;
628 /* whats this envvar; whats the definition;*/
629 /* i guess this whole loop could be removed*/
630 envvar[sizeof (OR_ENVVAR) - 1] = '0' + i;
631 if (0 == env_get_param(envvar, val, sizeof(val)) &&
632 ! env_prefix(envvar, "pci")) {
633 env_panic(envvar);
634 }
635 v = 0;
636 (void) env_parse (envvar, envfmt, 1, &v, 0, 255);
637 orp->or_pci_bus = v;
638 v = 0;
639 (void) env_parse (envvar, envfmt, 2, &v, 0, 255);
640 orp->or_pci_dev = v;
641 v = 0;
642 (void) env_parse (envvar, envfmt, 3, &v, 0, 255);
643 orp->or_pci_func = v;
644 }
645
646 /* Initialize the pci bus, bridges and cards, if not yet done */
647 pci_init ();
648
649 /* Try to find out where the card(s) are in the pci bus */
650 for (h = 1; h >= 0; h--)
651 for (i = 0, orp = or_table; i < OR_PORT_NR; i++, orp++) {
652 if (((orp->or_pci_bus | orp->or_pci_dev |
653 orp->or_pci_func) != 0) != h) {
654 continue;
655 }
656 if (or_probe (orp))
657 orp->or_seen = TRUE;
658 }
659 }
660
661 /*****************************************************************************
662 * or_probe *
663 * *
664 * Try to find the card based on information provided by pci and get irq and *
665 * bar *
666 *****************************************************************************/
667 static int or_probe (t_or * orp) {
668 u8_t ilr;
669 u32_t bar, reg, cpuspace_bar;
670 char *dname;
671 u16_t vid, did;
672 int i, r, devind, just_one;
673
674 if ((orp->or_pci_bus | orp->or_pci_dev | orp->or_pci_func) != 0) {
675 /* The monitor has provided us with clues about where the
676 * device is. Try to find it at that place */
677 r = pci_find_dev (orp->or_pci_bus, orp->or_pci_dev,
678 orp->or_pci_func, &devind);
679 if (r == 0) {
680 printf ("%s: no PCI found at %d.%d.%d\n",
681 orp->or_name, orp->or_pci_bus,
682 orp->or_pci_dev, orp->or_pci_func);
683 return (0);
684 }
685 /* get the information about the card, vendor id and device
686 * id */
687 pci_ids (devind, &vid, &did);
688 just_one = TRUE;
689 } else {
690 /* no clue where the card is. Start looking from the
691 * beginning */
692 r = pci_first_dev (&devind, &vid, &did);
693 if (r == 0)
694 return (0);
695 just_one = FALSE;
696 }
697
698 while (TRUE) {
699 /* loop through the pcitab to find a maching entry. The match
700 * being between one of the values in pcitab and the
701 * information provided by the pci bus */
702 for (i = 0; pcitab[i].vid != 0; i++) {
703 if (pcitab[i].vid != vid)
704 continue;
705 if (pcitab[i].did != did)
706 continue;
707 if (pcitab[i].checkclass) {
708 panic("or_probe:class check not implmnted");
709 }
710 /* we have found the card in the pci bus */
711 break;
712 }
713 if (pcitab[i].vid != 0)
714 break;
715
716 if (just_one) {
717 printf ("%s: wrong PCI device", orp->or_name);
718 printf (" (%04x/%04x) found at %d.%d.%d\n", vid, did,
719 orp->or_pci_bus, orp->or_pci_dev,
720 orp->or_pci_func);
721 return (0);
722 }
723
724 /* if the pci device which was under consideration was not
725 * of the desired brand or type, get the next device */
726 r = pci_next_dev (&devind, &vid, &did);
727 if (!r)
728 return (0);
729 }
730
731 /* Get the name as advertised by pci */
732 dname = pci_dev_name (vid, did);
733 if (!dname)
734 dname = "unknown device";
735 printf ("%s: %s (%04x/%04x) at %s\n",
736 orp->or_name, dname, vid, did, pci_slot_name (devind));
737
738 pci_reserve (devind);
739
740 orp->devind = devind;
741 /* Get the irq */
742 ilr = pci_attr_r8 (devind, PCI_ILR);
743 orp->or_irq = ilr;
744
745 /* Get the base address */
746 bar = or_get_bar (devind, orp);
747 orp->or_base_port = bar;
748
749 map_hw_buffer(orp);
750 return TRUE;
751 }
752
753 /*****************************************************************************
754 * map_hw_buffer *
755 * *
756 * Map the memory mapped registers into user space memory *
757 *****************************************************************************/
758 static void map_hw_buffer(t_or *orp) {
759 int r;
760 size_t o, size, reg_size;
761 char *buf, *abuf;
762 hermes_t *hw = &(orp->hw);
763
764 /* This way, the buffer will be at least I386_PAGE_SIZE big: see
765 * calculation with the offset */
766 size = 2 * I386_PAGE_SIZE;
767
768 buf = (char *)malloc(size);
769 if(buf == NULL)
770 panic("map_hw_buffer: cannot malloc size: %d", size);
771
772 /* Let the mapped memory by I386_PAGE_SIZE aligned */
773 o = I386_PAGE_SIZE - ((vir_bytes)buf % I386_PAGE_SIZE);
774 abuf = buf + o;
775
776 #if 0
777 r = sys_vm_map(SELF, 1, (vir_bytes)abuf,
778 1 * I386_PAGE_SIZE, (phys_bytes)orp->or_base_port);
779 #else
780 r = ENOSYS;
781 #endif
782
783 if(r!=OK)
784 panic("map_hw_buffer: sys_vm_map failed: %d", r);
785
786
787 hw->locmem = abuf;
788 }
789
790
791
792 /*****************************************************************************
793 * or_get_bar *
794 * *
795 * Get the base address from pci (from Base Address Register) and find out *
796 * whether the card is memory mapped or in I/O space. Currently, only *
797 * memmory mapped is supported. *
798 *****************************************************************************/
799 static u32_t or_get_bar (int devind, t_or * orp) {
800
801 u32_t bar, desired_bar;
802 int is_iospace, i;
803 u16_t check, check2;
804 hermes_t *hw = &(orp->hw);
805
806 /* bit 1 off the PCI_BAR register indicates whether the cards registers
807 * are mapped in io-space or shared memory */
808 is_iospace = pci_attr_r32 (devind, PCI_BAR) & 1;
809
810 if (is_iospace) {
811 /* read where the base address is in I/O space */
812 bar = pci_attr_r32 (devind, PCI_BAR) & 0xffffffe0;
813
814 if ((bar & 0x3ff) >= 0x100 - 32 || bar < 0x400)
815 panic("base address isn't properly configured");
816
817 /* In I/O space registers are 2 bytes wide, without any spacing
818 * in between */
819 hermes_struct_init (hw, bar, is_iospace,
820 HERMES_16BIT_REGSPACING);
821
822 if (debug) {
823 printf ("%s: using I/O space address 0x%lx, IRQ %d\n",
824 orp->or_name, bar, orp->or_irq);
825 }
826
827 panic("Not implemente yet");
828 /* Although we are able to find the desired bar and irq for an
829 * I/O spaced card, we haven't implemented the right register
830 * accessing functions. This wouldn't be difficult, but we were
831 * not able to test them. Therefore, give an alert here */
832
833 return bar;
834 } else {
835 /* read where the base address is in shared memory */
836 bar = pci_attr_r32 (devind, PCI_BAR) & 0xfffffff0;
837 /* maybe some checking whether the address is legal... */
838
839 /* Memory mapped registers are 2 bytes wide, aligned on 4
840 * bytes */
841 hermes_struct_init (hw, bar, is_iospace,
842 HERMES_32BIT_REGSPACING);
843
844 if (debug){
845 printf ("%s: using shared memory address",
846 orp->or_name);
847 printf (" 0x%lx, IRQ %d\n", bar, orp->or_irq);
848 }
849
850 return bar;
851
852 }
853 }
854
855 /*****************************************************************************
856 * or_init_struct *
857 * *
858 * Set the orinoco structure to default values *
859 *****************************************************************************/
860 static void or_init_struct (t_or * orp) {
861 int i = 0;
862 static eth_stat_t empty_stat = { 0, 0, 0, 0, 0, 0 };
863
864 orp->or_mode = OR_M_DISABLED;
865
866 if (orp->or_seen)
867 orp->or_mode = OR_M_ENABLED;
868
869 if (orp->or_mode != OR_M_ENABLED)
870 return;
871
872 orp->or_got_int = 0;
873 orp->or_link_up = -1;
874 orp->or_send_int = 0;
875 orp->or_clear_rx = 0;
876 orp->or_tx_alive = 0;
877 orp->or_need_reset = 0;
878
879 orp->or_read_s = 0;
880 orp->or_tx_head = 0;
881 orp->or_tx_tail = 0;
882 orp->connected = 0;
883
884 orp->or_tx.ret_busy = FALSE;
885 orp->or_tx.or_txfid = NO_FID;
886
887 for(i = 0; i < NR_RX_BUFS; i++) {
888 orp->rxfid[i] = NO_FID;
889 orp->rx_length[i] = 0;
890 }
891 orp->rx_current = 0;
892 orp->rx_first = 0;
893 orp->rx_last = 0;
894
895 orp->or_stat = empty_stat;
896 orp->or_flags = OR_F_EMPTY;
897
898 /* Keep an administration in the driver whether the internal
899 buffer is in use. That's what ret_busy is for */
900 orp->or_tx.ret_busy = FALSE;
901
902 orp->or_nicbuf_size = IEEE802_11_FRAME_LEN + ETH_HLEN;
903
904 }
905
906 /*****************************************************************************
907 * or_init_hw *
908 * *
909 * Initialize hardware and prepare for intercepting the interrupts. At the *
910 * end, the card is up and running *
911 *****************************************************************************/
912 static void or_init_hw (t_or * orp) {
913 int i, err, s;
914 hermes_t *hw = &(orp->hw);
915 static int first_time = TRUE;
916
917 /* first step in starting the card */
918 if (hermes_cor_reset(hw) != 0) {
919 printf ("%s: Failed to start the card\n", orp->or_name);
920 }
921
922 /* here begins the real things, yeah! ;) */
923 if (err = hermes_init (hw)) {
924 printf ("error value of hermes_init(): %d\n", err);
925 }
926
927 /* Get the MAC address (which is a data item in the card)*/
928 or_readrids (hw, orp);
929
930 /* Write a few rids to the card, e.g. WEP key*/
931 or_writerids (hw, orp);
932
933 if (debug) {
934 printf ("%s: Ethernet address ", orp->or_name);
935 for (i = 0; i < 6; i++) {
936 printf ("%x%c", orp->or_address.ea_addr[i],
937 i < 5 ? ':' : '\n');
938 }
939 }
940
941 /* Prepare internal TX buffer in the card */
942 err = hermes_allocate (hw,
943 orp->or_nicbuf_size,
944 &(orp->or_tx.or_txfid));
945
946 if (err)
947 printf ("%s:Error %d allocating Tx buffer\n",
948 orp->or_name, err);
949
950 /* Establish event handle */
951 if(first_time) {
952 orp->or_hook_id = orp->or_irq;
953 if ((s=sys_irqsetpolicy(orp->or_irq, 0,
954 &orp->or_hook_id)) != OK)
955 printf("orinoco: couldn't set IRQ policy: %d\n", s);
956
957 if ((s=sys_irqenable(&orp->or_hook_id)) != OK)
958 printf("orinoco: couldn't enable interrupts: %d\n", s);
959 first_time = FALSE;
960 }
961
962 /* Tell the card which events should raise an interrupt to the OS */
963 hermes_set_irqmask (hw, ORINOCO_INTEN);
964
965 /* Enable operation */
966 err = hermes_docmd_wait (hw, HERMES_CMD_ENABLE, 0, NULL);
967 if (err) {
968 printf ("%s: Error %d enabling MAC port\n", orp->or_name, err);
969 }
970 }
971
972
973 /*****************************************************************************
974 * or_readrids *
975 * *
976 * Read some default rids from the card. A rid (resource identifier) *
977 * is a data item in the firmware, some configuration variable. *
978 * In our case, we are mostly interested in the MAC address for now *
979 *****************************************************************************/
980
981 static void or_readrids (hermes_t * hw, t_or * orp) {
982 int err, len, i;
983 struct hermes_idstring nickbuf;
984 u16_t reclen, d;
985
986 /* Read the MAC address */
987 err = hermes_read_ltv (hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
988 ETH_ALEN, NULL, &orp->or_address);
989 if (err) {
990 printf ("%s: failed to read MAC address!\n", orp->or_name);
991 return;
992 }
993
994 }
995
996 /*****************************************************************************
997 * or_writerids *
998 * *
999 * Write some default rids to the card. A rid (resource identifier) *
1000 * is a data item in the firmware, some configuration variable, e.g. WEP key *
1001 *****************************************************************************/
1002 static void or_writerids (hermes_t * hw, t_or * orp) {
1003 int err;
1004 struct hermes_idstring idbuf;
1005 u16_t port_type, max_data_len, reclen;
1006 static char essid[IW_ESSID_MAX_SIZE + 1];
1007 static char wepkey0[LARGE_KEY_LENGTH + 1];
1008
1009 /* Set the MAC port */
1010 port_type = 1;
1011 err = hermes_write_wordrec (hw, USER_BAP, HERMES_RID_CNFPORTTYPE,
1012 port_type);
1013 if (err) {
1014 printf ("%s: Error %d setting port type\n", orp->or_name, err);
1015 return;
1016 }
1017
1018 if (OK != env_get_param("essid", essid, sizeof(essid))) {
1019 essid[0] = 0;
1020 }
1021
1022 if(strlen(essid) == 0) {
1023 printf("%s: no essid provided in boot monitor!\n",
1024 orp->or_name);
1025 printf("Hope you'll connect to the right network... \n");
1026 }
1027
1028 /* Set the desired ESSID */
1029 idbuf.len = strlen (essid);
1030 memcpy (&idbuf.val, essid, sizeof (idbuf.val));
1031
1032 err = hermes_write_ltv (hw, USER_BAP, HERMES_RID_CNFDESIREDSSID,
1033 HERMES_BYTES_TO_RECLEN (strlen (essid) + 2),
1034 &idbuf);
1035 if (err) {
1036 printf ("%s: Error %d setting DESIREDSSID\n",
1037 orp->or_name, err);
1038 return;
1039 }
1040
1041 if (OK != env_get_param("wep", wepkey0, sizeof(wepkey0))) {
1042 wepkey0[0] = 0;
1043 }
1044
1045 switch(strlen(wepkey0)) {
1046 case 0:
1047 /* No key found in monitor, using no encryption */
1048 break;
1049 case LARGE_KEY_LENGTH:
1050 setup_wepkey(orp, wepkey0);
1051 break;
1052 default:
1053 printf("Invalid key provided. Has to be 13 chars\n");
1054 break;
1055 }
1056 }
1057
1058 /*****************************************************************************
1059 * setup_wepkey *
1060 * *
1061 * If a wepkey is provided in the boot monitor, set the necessary rids so *
1062 * that the card will decrypt received data and encrypt data to send by *
1063 * by default with this key. *
1064 * It appears that there is a severe bug in setting up WEP. If the driver *
1065 * doesnt function properly, please turn WEP off. *
1066 *****************************************************************************/
1067 static void setup_wepkey(t_or *orp, char *wepkey0) {
1068 int default_key = 0, err = 0;
1069 hermes_t *hw = &(orp->hw);
1070
1071 err = hermes_write_wordrec (hw, USER_BAP,
1072 HERMES_RID_CNFWEPDEFAULTKEYID,
1073 default_key);
1074 if (err)
1075 printf ("%s: Error %d setting the default WEP-key entry\n",
1076 orp->or_name, err);
1077
1078 err = hermes_write_ltv (hw, USER_BAP,
1079 HERMES_RID_CNFDEFAULTKEY0,
1080 HERMES_BYTES_TO_RECLEN(LARGE_KEY_LENGTH),
1081 wepkey0);
1082 if (err)
1083 printf ("%s: Error %d setting the WEP-key0\n",
1084 orp->or_name, err);
1085
1086 err = hermes_write_wordrec (hw, USER_BAP,
1087 HERMES_RID_CNFAUTHENTICATION,
1088 HERMES_AUTH_OPEN);
1089 if (err)
1090 printf ("%s: Error %d setting the authentication flag\n",
1091 orp->or_name, err);
1092
1093 err = hermes_write_wordrec (hw, USER_BAP,
1094 HERMES_RID_CNFWEPFLAGS_INTERSIL,
1095 HERMES_WEP_PRIVACY_INVOKED);
1096 if (err)
1097 printf ("%s: Error %d setting the master wep setting flag\n",
1098 orp->or_name, err);
1099
1100 }
1101
1102
1103 /*****************************************************************************
1104 * or_rec_mode *
1105 * *
1106 * Set the desired receive mode, e.g. promiscuous mode. Not implemented yet *
1107 *****************************************************************************/
1108 static void or_rec_mode (t_or * orp) {
1109 /* TODO */
1110 }
1111
1112 /*****************************************************************************
1113 * or_handler *
1114 * *
1115 * The handler which is called when the card generated an interrupt. Events *
1116 * like EV_INFO and EV_RX have to be handled before an acknowledgement for *
1117 * the event is returned to the card. See also the documentation *
1118 *****************************************************************************/
1119 static int or_handler (t_or *orp) {
1120 int i, err, length, nr = 0;
1121 u16_t evstat, events, fid;
1122 hermes_t *hw;
1123 struct hermes_tx_descriptor desc;
1124
1125 hw = &(orp->hw);
1126
1127 beginning:
1128 /* Retrieve which kind of event happened */
1129 evstat = hermes_read_reg (hw, HERMES_EVSTAT);
1130 events = evstat;
1131
1132 /* There are plenty of events possible. The more interesting events
1133 are actually implemented. Whether the following events actually
1134 raise an interrupt depends on the value of ORINOCO_INTEN. For more
1135 information about the events, see the specification in pdf */
1136
1137 /* Occurs at each tick of the auxiliary time */
1138 if (events & HERMES_EV_TICK) {
1139 events &= ~HERMES_EV_TICK;
1140 }
1141 /* Occurs when a wait time-out error is detected */
1142 if (events & HERMES_EV_WTERR) {
1143 events &= ~HERMES_EV_WTERR;
1144 }
1145
1146 /* Occurs when an info frame is dropped because there is not enough
1147 buffer space available */
1148 if (events & HERMES_EV_INFDROP) {
1149 events &= ~(HERMES_EV_INFDROP);
1150 }
1151
1152 /* This AP-only event will be asserted at the beacon interval prior to
1153 the DTIM interval */
1154 if (events & HERMES_EV_DTIM) {
1155 events &= ~(HERMES_EV_DTIM);
1156 }
1157
1158 /* Occurs when a command execution is completed */
1159 if (events & HERMES_EV_CMD) {
1160 events &= ~(HERMES_EV_CMD);
1161 }
1162
1163 /* Occurs when the asynchronous transmission process is unsuccessfully
1164 completed */
1165 if (events & HERMES_EV_TXEXC) {
1166
1167 /* What buffer generated the event? Represented by an fid */
1168 fid = hermes_read_reg(hw, HERMES_TXCOMPLFID);
1169 if(fid == 0xFFFF) {
1170 /* Illegal fid found */
1171 printf("unexpected txexc_fid interrupted\n");
1172 }
1173
1174 orp->or_tx.ret_busy = FALSE;
1175
1176 if(orp->or_flags & OR_F_SEND_AVAIL) {
1177 orp->or_send_int = TRUE;
1178 if (!orp->or_got_int){
1179 orp->or_got_int = TRUE;
1180 int_event_check = TRUE;
1181 }
1182 }
1183
1184 /* To detect illegal fids */
1185 hermes_write_reg(hw, HERMES_TXCOMPLFID, 0xFFFF);
1186 events &= ~(HERMES_EV_TXEXC);
1187 /* We don't do anything else yet.
1188 * Could be used for statistics */
1189 }
1190
1191 /* Occurs when the asynchronous transmission process is successfully
1192 completed */
1193 if (events & HERMES_EV_TX) {
1194 events &= ~(HERMES_EV_TX);
1195 /* Which buffer was sent, represented by an fid */
1196 fid = hermes_read_reg (hw, HERMES_TXCOMPLFID);
1197 if(fid == 0xFFFF) {
1198 /* Illegal fid found */
1199 printf("unexpected tx_fid interrupted\n");
1200 }
1201
1202 orp->or_tx.ret_busy = FALSE;
1203
1204 if(orp->or_flags & OR_F_SEND_AVAIL) {
1205 orp->or_send_int = TRUE;
1206 if (!orp->or_got_int){
1207 orp->or_got_int = TRUE;
1208 int_event_check = TRUE;
1209 }
1210 }
1211
1212 /* To detect illegal fids */
1213 hermes_write_reg(hw, HERMES_TXCOMPLFID, 0xFFFF);
1214 /* We don't do anything else when such event happens */
1215 }
1216
1217 /* Occurs when an info frame is available in the card */
1218 if (events & HERMES_EV_INFO) {
1219 events &= ~(HERMES_EV_INFO);
1220 /* Process the information, inside the handler (!) */
1221 or_ev_info(orp);
1222 }
1223
1224 /* Occurs when a TX buffer is available again for usage */
1225 if (events & HERMES_EV_ALLOC) {
1226 /* Which frame is now marked as free? */
1227 fid = hermes_read_reg (hw, HERMES_ALLOCFID);
1228 if (fid == 0xFFFF){
1229 /* An illegal frame identifier is found. Ignore */
1230 printf("Allocate event on unexpected fid\n");
1231 return ;
1232 }
1233
1234 /* To be able to detect illegal fids */
1235 hermes_write_reg(hw, HERMES_ALLOCFID, 0xFFFF);
1236
1237 events &= ~(HERMES_EV_ALLOC);
1238 }
1239
1240
1241 /* Occurs when a frame is received by the asynchronous reception
1242 * process */
1243
1244 if (events & HERMES_EV_RX) {
1245 orp->or_ev_rx = TRUE;
1246 events &= ~(HERMES_EV_RX);
1247
1248 /* If the last buffer is still filled with data, then we don't
1249 * have any buffers available to store the data */
1250 if(orp->rx_length[orp->rx_last] != 0) {
1251 /* indeed, we are going to overwrite information
1252 * in a buffer */
1253 }
1254
1255 /* Which buffer is storing the data (represented by a fid) */
1256 orp->rxfid[orp->rx_last]
1257 = hermes_read_reg (hw, HERMES_RXFID);
1258
1259 /* Get the packet from the card and store it in
1260 * orp->rx_buf[orp->rx_last]. The length is returned by this
1261 * function */
1262 length = or_get_recvd_packet(orp, orp->rxfid[orp->rx_last],
1263 (orp->rx_buf[orp->rx_last]));
1264
1265 if(length < 0) {
1266 /* Error happened. */
1267 printf("length < 0\n");
1268 goto next;
1269 } else {
1270 orp->rx_length[orp->rx_last] = length;
1271 }
1272
1273 /* The next buffer will be used the next time, circularly */
1274 orp->rx_last++;
1275 orp->rx_last %= NR_RX_BUFS;
1276
1277 if (!orp->or_got_int){
1278 orp->or_got_int = TRUE;
1279 }
1280 int_event_check = TRUE;
1281 }
1282 next:
1283 if (events) {
1284 printf("Unknown event: 0x%x\n", events);
1285 }
1286
1287 /* Acknowledge to the card that the events have been processed. After
1288 * this the card will assume we have processed any buffer which were in
1289 * use for this event. */
1290 hermes_write_reg (hw, HERMES_EVACK, evstat);
1291
1292 evstat = hermes_read_reg (hw, HERMES_EVSTAT);
1293 if(evstat != 0 && !(evstat & HERMES_EV_TICK)) {
1294 goto beginning;
1295 }
1296
1297 return (1);
1298 }
1299
1300
1301 /*****************************************************************************
1302 * or_watchdog_f *
1303 * *
1304 * Will be called regularly to see whether the driver has crashed. If that *
1305 * condition is detected, reset the driver and card *
1306 *****************************************************************************/
1307 static void or_watchdog_f(timer_t *tp) {
1308 int i;
1309 t_or *orp;
1310
1311 /* Use a synchronous alarm instead of a watchdog timer. */
1312 sys_setalarm(system_hz, 0);
1313
1314 for (i= 0, orp = &or_table[0]; i<OR_PORT_NR; i++, orp++) {
1315 if (orp->or_mode != OR_M_ENABLED)
1316 continue;
1317
1318 if (!(orp->or_flags & OR_F_SEND_AVAIL)) {
1319 /* Assume that an idle system is alive */
1320 orp->or_tx_alive= TRUE;
1321 continue;
1322 }
1323
1324 if (orp->connected == 0) {
1325 orp->or_tx_alive= TRUE;
1326 continue;
1327 }
1328 if (orp->or_tx_alive) {
1329 orp->or_tx_alive= FALSE;
1330 continue;
1331 }
1332
1333 printf("or_watchdog_f: resetting port %d\n", i);
1334
1335 orp->or_need_reset= TRUE;
1336 orp->or_got_int= TRUE;
1337 check_int_events();
1338 }
1339 }
1340
1341 /*****************************************************************************
1342 * mess_reply *
1343 *****************************************************************************/
1344
1345 static void mess_reply (message * req, message * reply_mess) {
1346 if (send (req->m_source, reply_mess) != 0)
1347 panic("orinoco: unable to mess_reply");
1348
1349 }
1350
1351 /*****************************************************************************
1352 * or_writev *
1353 * *
1354 * As far as we can see, this function is never called from 3.1.3. However, *
1355 * it is still in rtl8139, so we'll keep it here as well. It's almost a copy *
1356 * of or_writev_s. We left out the comments. For an explanation, see *
1357 * or_writev_s *
1358 ******************************************************************************/
1359 static void or_writev (message * mp, int from_int, int vectored) {
1360 int port, or_client, count, size, err, data_len, data_off, tx_head;
1361 int o, j, n, i, s, p, cps ;
1362 struct ethhdr *eh;
1363 t_or *orp;
1364 clock_t timebefore, t0;
1365 phys_bytes phys_user;
1366 hermes_t *hw;
1367 struct hermes_tx_descriptor desc;
1368 struct header_struct hdr;
1369
1370 iovec_t *iovp;
1371 phys_bytes phys_databuf;
1372 u16_t txfid;
1373 static u8_t databuf[IEEE802_11_DATA_LEN + ETH_HLEN + 2 + 1];
1374 memset (databuf, 0, IEEE802_11_DATA_LEN + ETH_HLEN + 3);
1375
1376 port = mp->DL_PORT;
1377 count = mp->DL_COUNT;
1378 if (port < 0 || port >= OR_PORT_NR)
1379 panic("orinoco: illegal port");
1380
1381 or_client = mp->DL_PROC;
1382 orp = &or_table[port];
1383 orp->or_client = or_client;
1384 hw = &(orp->hw);
1385
1386 if (from_int) {
1387 assert (orp->or_flags & OR_F_SEND_AVAIL);
1388 orp->or_flags &= ~OR_F_SEND_AVAIL;
1389 orp->or_send_int = FALSE;
1390 orp->or_tx_alive = TRUE;
1391 }
1392
1393 if (orp->or_tx.ret_busy) {
1394 assert(!(orp->or_flags & OR_F_SEND_AVAIL));
1395 orp->or_flags |= OR_F_SEND_AVAIL;
1396 goto suspend_write;
1397 }
1398
1399 assert (orp->or_mode == OR_M_ENABLED);
1400 assert (orp->or_flags & OR_F_ENABLED);
1401
1402 /* CvR: copied from or_writev_s(), since txfid was not initialized. */
1403 txfid = orp->or_tx.or_txfid;
1404
1405 if (vectored) {
1406
1407 int iov_offset = 0;
1408 size = 0;
1409 o = 0;
1410
1411 for (i = 0; i < count; i += IOVEC_NR,
1412 iov_offset += IOVEC_NR * sizeof (orp->or_iovec[0])) {
1413
1414 n = IOVEC_NR;
1415 if (i + n > count)
1416 n = count - i;
1417 cps = sys_vircopy(or_client, D,
1418 ((vir_bytes) mp->DL_ADDR) + iov_offset,
1419 SELF, D, (vir_bytes) orp->or_iovec,
1420 n * sizeof(orp->or_iovec[0]));
1421 if (cps != OK) printf("sys_vircopy failed: %d\n", cps);
1422
1423 for (j = 0, iovp = orp->or_iovec; j < n; j++, iovp++) {
1424 s = iovp->iov_size;
1425 if (size + s > ETH_MAX_PACK_SIZE_TAGGED) {
1426 printf("invalid packet size\n");
1427 }
1428 cps = sys_vircopy(or_client, D, iovp->iov_addr,
1429 SELF, D, (vir_bytes) databuf + o, s);
1430 if (cps != OK)
1431 printf("sys_vircopy failed: %d\n",cps);
1432
1433 size += s;
1434 o += s;
1435 }
1436 }
1437 if (size < ETH_MIN_PACK_SIZE)
1438 printf("invalid packet size %d\n", size);
1439 } else {
1440 size = mp->DL_COUNT;
1441 if (size < ETH_MIN_PACK_SIZE
1442 || size > ETH_MAX_PACK_SIZE_TAGGED)
1443 printf("invalid packet size %d\n", size);
1444
1445 cps = sys_vircopy(or_client, D, (vir_bytes)mp->DL_ADDR,
1446 SELF, D, (vir_bytes) databuf, size);
1447 if (cps != OK) printf("sys_abscopy failed: %d\n", cps);
1448 }
1449
1450 memset (&desc, 0, sizeof (desc));
1451 desc.tx_control = HERMES_TXCTRL_TX_OK | HERMES_TXCTRL_TX_EX;
1452
1453 err = hermes_bap_pwrite (hw, USER_BAP, &desc, sizeof (desc), txfid,
1454 0);
1455 if (err) {
1456 or_reset();
1457 goto fail;
1458 }
1459
1460 eh = (struct ethhdr *) databuf;
1461 if (ntohs (eh->h_proto) > 1500) {
1462
1463 data_len = size - ETH_HLEN;
1464 data_off = HERMES_802_3_OFFSET + sizeof (hdr);
1465
1466 memcpy (hdr.dest, eh->h_dest, ETH_ALEN);
1467 memcpy (hdr.src, eh->h_src, ETH_ALEN);
1468 hdr.len = htons (data_len + ENCAPS_OVERHEAD);
1469
1470 memcpy (&hdr.dsap, &encaps_hdr, sizeof (encaps_hdr));
1471 hdr.ethertype = eh->h_proto;
1472
1473 err = hermes_bap_pwrite (hw, USER_BAP, &hdr, sizeof (hdr),
1474 txfid, HERMES_802_3_OFFSET);
1475 if (err) {
1476 printf ("%s: Error %d writing packet header to BAP\n",
1477 orp->or_name, err);
1478 goto fail;
1479 }
1480
1481 p = ETH_HLEN;
1482 } else {
1483 data_len = size + ETH_HLEN;
1484 data_off = HERMES_802_3_OFFSET;
1485 p = 0;
1486 }
1487
1488 err = hermes_bap_pwrite (hw, USER_BAP,
1489 (void *) &(databuf[p]), RUP_EVEN (data_len),
1490 txfid, data_off);
1491 if (err) {
1492 printf ("hermes_bap_pwrite(data): error %d\n", err);
1493 goto fail;
1494 }
1495
1496 orp->or_tx.ret_busy = TRUE;
1497
1498 err = hermes_docmd_wait (hw, HERMES_CMD_TX | HERMES_CMD_RECL,
1499 txfid, NULL);
1500 if (err) {
1501 orp->or_tx.ret_busy = FALSE;
1502 printf ("hermes_docmd_wait(TX|RECL): error %d\n", err);
1503 goto fail;
1504 }
1505
1506 fail:
1507 orp->or_flags |= OR_F_PACK_SENT;
1508
1509 if (from_int) {
1510 return;
1511 }
1512
1513 reply (orp, OK, FALSE);
1514 return;
1515
1516 suspend_write:
1517 orp->or_tx_mess = *mp;
1518 reply (orp, OK, FALSE);
1519 return;
1520 }
1521
1522
1523
1524 /*****************************************************************************
1525 * or_writev_s *
1526 * *
1527 * Write data which is denoted by the message to the card and send it. *
1528 *****************************************************************************/
1529 static void or_writev_s (message * mp, int from_int) {
1530 int port, or_client, count, size, err, data_len, data_off, tx_head;
1531 int o, j, n, i, s, p, cps ;
1532 struct ethhdr *eh;
1533 t_or *orp;
1534 clock_t timebefore, t0;
1535 phys_bytes phys_user;
1536 hermes_t *hw;
1537 struct hermes_tx_descriptor desc;
1538 int iov_offset = 0;
1539 struct header_struct hdr;
1540 iovec_s_t *iovp;
1541 phys_bytes phys_databuf;
1542 u16_t txfid;
1543
1544 /* We need space for the max packet size itself, plus an ethernet
1545 * header, plus 2 bytes so we can align the IP header on a
1546 * 32bit boundary, plus 1 byte so we can read in odd length
1547 * packets from the card, which has an IO granularity of 16
1548 * bits */
1549 static u8_t databuf[IEEE802_11_DATA_LEN + ETH_HLEN + 2 + 1];
1550 memset (databuf, 0, IEEE802_11_DATA_LEN + ETH_HLEN + 3);
1551
1552 port = mp->DL_PORT;
1553 count = mp->DL_COUNT;
1554 if (port < 0 || port >= OR_PORT_NR)
1555 panic("orinoco: illegal port");
1556
1557 or_client = mp->DL_PROC;
1558 orp = &or_table[port];
1559 orp->or_client = or_client;
1560 hw = &(orp->hw);
1561
1562 /* Switch off interrupts. The card is accessable via 2 BAPs, one for
1563 * reading and one for writing. In theory these BAPs should be
1564 * independent, but in practice, the are not. By switching off the
1565 * interrupts of the card, the chances of one interfering with the
1566 * other should be less */
1567 if (from_int){
1568 /* We were called with from_int, meaning that the last time we
1569 * were called, no tx buffers were available, and we had to
1570 * suspend. Now, we'll try again to find an empty buffer in the
1571 * card */
1572 assert (orp->or_flags & OR_F_SEND_AVAIL);
1573 orp->or_flags &= ~OR_F_SEND_AVAIL;
1574 orp->or_send_int = FALSE;
1575 orp->or_tx_alive = TRUE;
1576 }
1577
1578 txfid = orp->or_tx.or_txfid;
1579
1580 if (orp->or_tx.ret_busy || orp->connected == 0) {
1581 /* there is no buffer in the card available */
1582 assert(!(orp->or_flags & OR_F_SEND_AVAIL));
1583 /* Remember that there is a packet to be sent available */
1584 orp->or_flags |= OR_F_SEND_AVAIL;
1585 goto suspend_write_s;
1586 }
1587
1588 assert (orp->or_mode == OR_M_ENABLED);
1589 assert (orp->or_flags & OR_F_ENABLED);
1590
1591
1592 /* Copy the data to be send from the vector to the databuf */
1593 size = 0;
1594 o = 0;
1595 for (i = 0; i < count; i += IOVEC_NR,
1596 iov_offset += IOVEC_NR * sizeof (orp->or_iovec_s[0])) {
1597
1598 n = IOVEC_NR;
1599 if (i + n > count)
1600 n = count - i;
1601
1602 cps = sys_safecopyfrom(or_client, mp->DL_GRANT, iov_offset,
1603 (vir_bytes) orp->or_iovec_s,
1604 n * sizeof(orp->or_iovec_s[0]), D);
1605 if (cps != OK)
1606 printf("orinoco: sys_safecopyfrom failed: %d\n", cps);
1607
1608 for (j = 0, iovp = orp->or_iovec_s; j < n; j++, iovp++) {
1609 s = iovp->iov_size;
1610 if (size + s > ETH_MAX_PACK_SIZE_TAGGED) {
1611 printf("Orinoco: invalid pkt size\n");
1612 }
1613
1614 cps = sys_safecopyfrom(or_client, iovp->iov_grant, 0,
1615 (vir_bytes) databuf + o, s, D);
1616 if (cps != OK)
1617 printf("orinoco: sys_safecopyfrom failed:%d\n",
1618 cps);
1619
1620 size += s;
1621 o += s;
1622 }
1623 }
1624
1625 assert(size >= ETH_MIN_PACK_SIZE);
1626
1627 memset (&desc, 0, sizeof (desc));
1628 /* Reclaim the tx buffer once the data is sent (OK), or it is clear
1629 * that transmission failed (EX). Reclaiming means that we can reuse
1630 * the buffer again for transmission */
1631 desc.tx_control = HERMES_TXCTRL_TX_OK | HERMES_TXCTRL_TX_EX;
1632 /* Actually, this reclaim bit is the only thing which needs to be set
1633 * in the descriptor */
1634 err = hermes_bap_pwrite (hw, USER_BAP, &desc, sizeof (desc), txfid,
1635 0);
1636 if (err) {
1637 printf("hermes_bap_pwrite() descriptor error:resetting card\n");
1638 /* When this happens, the card is quite confused: it will not
1639 * recover. Reset it */
1640 or_reset();
1641 goto fail;
1642 }
1643
1644 eh = (struct ethhdr *) databuf;
1645 /* Encapsulate Ethernet-II frames */
1646 if (ntohs (eh->h_proto) > 1500) {
1647 /* Ethernet-II frame */
1648 data_len = size - ETH_HLEN;
1649 data_off = HERMES_802_3_OFFSET + sizeof (hdr);
1650
1651 /* 802.3 header */
1652 memcpy (hdr.dest, eh->h_dest, ETH_ALEN);
1653 memcpy (hdr.src, eh->h_src, ETH_ALEN);
1654 hdr.len = htons (data_len + ENCAPS_OVERHEAD);
1655
1656 /* 802.2 header */
1657 memcpy (&hdr.dsap, &encaps_hdr, sizeof (encaps_hdr));
1658 hdr.ethertype = eh->h_proto;
1659
1660 err = hermes_bap_pwrite (hw, USER_BAP, &hdr, sizeof (hdr),
1661 txfid, HERMES_802_3_OFFSET);
1662 if (err) {
1663 printf ("%s: Error %d writing packet header to BAP\n",
1664 orp->or_name, err);
1665 goto fail;
1666 }
1667
1668 p = ETH_HLEN;
1669 } else {
1670 /* IEEE 802.3 frame */
1671 data_len = size + ETH_HLEN;
1672 data_off = HERMES_802_3_OFFSET;
1673 p = 0;
1674 }
1675
1676 /* Round up for odd length packets */
1677 err = hermes_bap_pwrite (hw, USER_BAP,
1678 (void *) &(databuf[p]), RUP_EVEN (data_len),
1679 txfid, data_off);
1680 if (err) {
1681 printf ("hermes_bap_pwrite(data): error %d\n", err);
1682 goto fail;
1683 }
1684
1685 /* this should be before the docmd_wait. Cause otherwise the bit can
1686 be cleared in the handler (if irq's not off) before it is set
1687 and then 1 reset (ret_busy=false) is lost */
1688 orp->or_tx.ret_busy = TRUE;
1689
1690 /* Send the packet which was constructed in txfid */
1691 err = hermes_docmd_wait (hw, HERMES_CMD_TX | HERMES_CMD_RECL,
1692 txfid, NULL);
1693 if (err) {
1694 printf ("hermes_docmd_wait(TX|RECL): error %d\n", err);
1695 /* Mark the buffer as available again */
1696 orp->or_tx.ret_busy = FALSE;
1697 goto fail;
1698 }
1699
1700 fail:
1701 /* If the interrupt handler called, don't send a reply. The reply
1702 * will be sent after all interrupts are handled.
1703 */
1704 orp->or_flags |= OR_F_PACK_SENT;
1705
1706 if (from_int) {
1707 return;
1708 }
1709
1710 reply (orp, OK, FALSE);
1711 return;
1712
1713 suspend_write_s:
1714 orp->or_tx_mess = *mp;
1715
1716 reply (orp, OK, FALSE);
1717 return;
1718 }
1719
1720
1721 /*****************************************************************************
1722 * reply *
1723 * *
1724 * Send a message back to the caller, informing it about the data received *
1725 * or sent *
1726 *****************************************************************************/
1727 static void reply (t_or * orp, int err, int may_block) {
1728 message reply;
1729 int status = 0, r;
1730 clock_t now;
1731
1732 if (orp->or_flags & OR_F_PACK_SENT)
1733 status |= DL_PACK_SEND;
1734 if (orp->or_flags & OR_F_PACK_RECV)
1735 status |= DL_PACK_RECV;
1736
1737 reply.m_type = DL_TASK_REPLY;
1738 reply.DL_PORT = orp - or_table;
1739 assert(reply.DL_PORT == 0);
1740 reply.DL_PROC = orp->or_client;
1741 reply.DL_STAT = status | ((u32_t) err << 16);
1742 reply.DL_COUNT = orp->or_read_s;
1743
1744 if (OK != (r = getuptime(&now)))
1745 panic("orinoco: getuptime() failed: %d", r);
1746
1747 reply.DL_CLCK = now;
1748 r = send (orp->or_client, &reply);
1749
1750 if (r == ELOCKED && may_block) {
1751 return;
1752 }
1753
1754 if (r < 0)
1755 panic("orinoco: send failed: %d", r);
1756
1757 orp->or_read_s = 0;
1758 orp->or_flags &= ~(OR_F_PACK_SENT | OR_F_PACK_RECV);
1759 }
1760
1761
1762
1763 /*****************************************************************************
1764 * or_ev_info *
1765 * *
1766 * Process information which comes in from the card *
1767 *****************************************************************************/
1768 static void or_ev_info (t_or * orp) {
1769 u16_t infofid;
1770 int err, len, type, i;
1771 hermes_t *hw = &orp->hw;
1772
1773 struct {
1774 u16_t len;
1775 u16_t type;
1776 } info;
1777
1778 infofid = hermes_read_reg (hw, HERMES_INFOFID);
1779 err = hermes_bap_pread (hw, IRQ_BAP, &info, sizeof (info), infofid,
1780 0);
1781 if (err) {
1782 printf ("%s: error %d reading info frame.\n", orp->or_name,
1783 err);
1784 return;
1785 }
1786
1787 len = HERMES_RECLEN_TO_BYTES (info.len);
1788 type = info.type;
1789
1790 switch (type) {
1791 case HERMES_INQ_TALLIES:
1792 {
1793 struct hermes_tallies_frame tallies;
1794
1795 if (len > sizeof (tallies)) {
1796 printf ("%s: Tallies frame too long ",
1797 orp->or_name);
1798 printf ("(%d bytes)\n", len);
1799 len = sizeof (tallies);
1800 }
1801 hermes_read_words (hw, HERMES_DATA1,
1802 (void *) &tallies, len / 2);
1803 /* TODO: do something with the tallies structure */
1804 }
1805 break;
1806
1807 case HERMES_INQ_LINKSTATUS: {
1808 u16_t newstatus;
1809 struct hermes_linkstatus linkstatus;
1810
1811 if (len != sizeof (linkstatus)) {
1812 printf ("%s: Unexpected size for linkstatus ",
1813 orp->or_name);
1814 printf ("frame (%d bytes)\n", len);
1815 }
1816
1817 hermes_read_words (hw, HERMES_DATA1,
1818 (void *) &linkstatus, len / 2);
1819 newstatus = linkstatus.linkstatus;
1820
1821 if ((newstatus == HERMES_LINKSTATUS_CONNECTED)
1822 || (newstatus == HERMES_LINKSTATUS_AP_CHANGE)
1823 || (newstatus == HERMES_LINKSTATUS_AP_IN_RANGE)) {
1824 orp->connected = 1;
1825
1826 if(orp->or_flags & OR_F_SEND_AVAIL) {
1827 orp->or_send_int = TRUE;
1828 orp->or_got_int = TRUE;
1829 int_event_check = TRUE;
1830 }
1831
1832
1833 }
1834 else if ((newstatus ==
1835 HERMES_LINKSTATUS_NOT_CONNECTED)
1836 || (newstatus ==
1837 HERMES_LINKSTATUS_DISCONNECTED)
1838 || (newstatus ==
1839 HERMES_LINKSTATUS_AP_OUT_OF_RANGE)
1840 || (newstatus ==
1841 HERMES_LINKSTATUS_ASSOC_FAILED)) {
1842 orp->connected = 0;
1843 }
1844
1845 if (newstatus != orp->last_linkstatus)
1846 print_linkstatus(orp, newstatus);
1847
1848 orp->last_linkstatus = newstatus;
1849 }
1850 break;
1851 default:
1852 printf ("%s:Unknown information frame received(type %04x).\n",
1853 orp->or_name, type);
1854 break;
1855 }
1856 }
1857
1858 /*****************************************************************************
1859 * or_print_linkstatus *
1860 * *
1861 * Process information which comes in from the card *
1862 *****************************************************************************/
1863 static void print_linkstatus (t_or * orp, u16_t status) {
1864 int err;
1865 u16_t d;
1866 char *s;
1867 hermes_t *hw = &(orp->hw);
1868
1869 switch (status) {
1870 case HERMES_LINKSTATUS_NOT_CONNECTED:
1871 s = "Not Connected";
1872 break;
1873 case HERMES_LINKSTATUS_CONNECTED:
1874 s = "Connected";
1875 break;
1876 case HERMES_LINKSTATUS_DISCONNECTED:
1877 s = "Disconnected";
1878 break;
1879 case HERMES_LINKSTATUS_AP_CHANGE:
1880 s = "AP Changed";
1881 break;
1882 case HERMES_LINKSTATUS_AP_OUT_OF_RANGE:
1883 s = "AP Out of Range";
1884 break;
1885 case HERMES_LINKSTATUS_AP_IN_RANGE:
1886 s = "AP In Range";
1887 break;
1888 case HERMES_LINKSTATUS_ASSOC_FAILED:
1889 s = "Association Failed";
1890 break;
1891 default:
1892 s = "UNKNOWN";
1893 }
1894
1895 printf ("%s: link status: %s, ", orp->or_name, s);
1896
1897 err = hermes_read_wordrec (hw, USER_BAP,
1898 HERMES_RID_CURRENTCHANNEL, &d);
1899 if (err) {
1900 printf ("%s: Error %d \n", orp->or_name, err);
1901 return;
1902 }
1903 printf("channel: %d, freq: %d MHz ",
1904 d, (channel_frequency[d-1]));
1905
1906 }
1907
1908
1909 /*****************************************************************************
1910 * or_check_ints *
1911 * *
1912 * Process events which have been postponed in the interrupt handler *
1913 *****************************************************************************/
1914 static void or_check_ints (t_or * orp) {
1915 int or_flags;
1916 hermes_t *hw = &orp->hw;
1917
1918 if (orp->or_need_reset)
1919 or_reset();
1920 if ((orp->rx_first!=orp->rx_last) && (orp->or_flags & OR_F_READING)) {
1921 orp->or_ev_rx = 0;
1922 if (orp->or_rx_mess.m_type == DL_READV) {
1923 or_readv (&orp->or_rx_mess, TRUE, TRUE);
1924 } else if(orp->or_rx_mess.m_type == DL_READV_S) {
1925 or_readv_s (&orp->or_rx_mess, TRUE);
1926 } else {
1927 assert(orp->or_rx_mess.m_type == DL_READ);
1928 or_readv (&orp->or_rx_mess, TRUE, FALSE);
1929 }
1930 }
1931
1932 if (orp->or_send_int) {
1933 if (orp->or_tx_mess.m_type == DL_WRITEV) {
1934 or_writev (&orp->or_tx_mess, TRUE, TRUE);
1935 }
1936 else if(orp->or_tx_mess.m_type == DL_WRITEV_S) {
1937 or_writev_s (&orp->or_tx_mess, TRUE);
1938 } else {
1939 assert(orp->or_tx_mess.m_type == DL_WRITE);
1940 or_writev (&orp->or_tx_mess, TRUE, FALSE);
1941 }
1942 }
1943
1944 if (orp->or_flags & (OR_F_PACK_SENT | OR_F_PACK_RECV)) {
1945 reply (orp, OK, TRUE);
1946 }
1947 }
1948
1949
1950 /*****************************************************************************
1951 * is_ethersnap *
1952 * *
1953 * is there an LLC and SNAP header in the ethernet packet? The inet task *
1954 * isn't very interested in it... *
1955 *****************************************************************************/
1956 static int is_ethersnap(struct header_struct *hdr) {
1957
1958 /* We de-encapsulate all packets which, a) have SNAP headers
1959 * (i.e. SSAP=DSAP=0xaa and CTRL=0x3 in the 802.2 LLC header
1960 * and where b) the OUI of the SNAP header is 00:00:00 or
1961 * 00:00:f8 - we need both because different APs appear to use
1962 * different OUIs for some reason */
1963 return (memcmp(&hdr->dsap, &encaps_hdr, 5) == 0)
1964 && ( (hdr->oui[2] == 0x00) || (hdr->oui[2] == 0xf8) );
1965 }
1966
1967 /*****************************************************************************
1968 * or_readv *
1969 * *
1970 * As far as we can see, this function is never called from 3.1.3. However, *
1971 * it is still in rtl8139, so we'll keep it here as well. It's almost a copy *
1972 * of or_readv_s. We left out the comments. For an explanation, see *
1973 * or_readv_s *
1974 *****************************************************************************/
1975 static void or_readv (message * mp, int from_int, int vectored) {
1976 int i, j, n, o, s, s1, dl_port, or_client, count, size, err, yep, cps;
1977 port_t port;
1978 clock_t timebefore;
1979 unsigned amount, totlen, packlen;
1980 struct hermes_rx_descriptor desc;
1981 phys_bytes dst_phys;
1982 u16_t d_start, d_end, status;
1983 struct header_struct hdr;
1984 int length, offset;
1985 u32_t l, rxstat;
1986 struct ethhdr *eh;
1987 struct header_struct *h;
1988 t_or *orp;
1989 iovec_t *iovp;
1990 u8_t *databuf;
1991
1992 dl_port = mp->DL_PORT;
1993 count = mp->DL_COUNT;
1994 if (dl_port < 0 || dl_port >= OR_PORT_NR)
1995 panic("orinoco: illegal port: %d", dl_port);
1996
1997 orp = &or_table[dl_port];
1998 or_client = mp->DL_PROC;
1999 orp->or_client = or_client;
2000
2001 assert (orp->or_mode == OR_M_ENABLED);
2002 assert (orp->or_flags & OR_F_ENABLED);
2003
2004 if (!from_int && (orp->rx_first==orp->rx_last)) {
2005 goto suspend_readv;
2006 }
2007
2008 databuf = &(orp->rx_buf[orp->rx_first][0]);
2009 length = orp->rx_length[orp->rx_first];
2010
2011 orp->rxfid[orp->rx_first] = NO_FID;
2012 orp->rx_length[orp->rx_first] = 0;
2013
2014 orp->rx_first++;
2015 orp->rx_first %= NR_RX_BUFS;
2016
2017 o = 0;
2018
2019 if (vectored) {
2020 int iov_offset = 0;
2021 size = 0;
2022
2023 for (i = 0; i < count; i += IOVEC_NR,
2024 iov_offset += IOVEC_NR * sizeof(orp->or_iovec[0])) {
2025
2026 n = IOVEC_NR;
2027 if (i + n > count)
2028 n = count - i;
2029
2030 cps = sys_vircopy(or_client, D,
2031 (vir_bytes) mp->DL_ADDR + iov_offset,
2032 SELF, D, (vir_bytes) orp->or_iovec,
2033 n * sizeof(orp->or_iovec[0]));
2034 if (cps != OK) printf("sys_vircopy failed: %d (%d)\n",
2035 cps, __LINE__);
2036
2037 for (j = 0, iovp = orp->or_iovec; j < n; j++, iovp++) {
2038 s = iovp->iov_size;
2039 if (size + s > length) {
2040 assert (length > size);
2041 s = length - size;
2042 }
2043
2044 cps = sys_vircopy(SELF, D,
2045 (vir_bytes) databuf + o,
2046 or_client, D,
2047 iovp->iov_addr, s);
2048 if (cps != OK)
2049 printf("sys_vircopy failed:%d (%d)\n",
2050 cps, __LINE__);
2051
2052 size += s;
2053 if (size == length)
2054 break;
2055 o += s;
2056 }
2057 if (size == length)
2058 break;
2059 }
2060 assert (size >= length);
2061 }
2062
2063 orp->or_stat.ets_packetR++;
2064 orp->or_read_s = length;
2065 orp->or_flags &= ~OR_F_READING;
2066 orp->or_flags |= OR_F_PACK_RECV;
2067
2068 if (!from_int)
2069 reply (orp, OK, FALSE);
2070
2071 return;
2072
2073 suspend_readv :
2074 if (from_int) {
2075 assert (orp->or_flags & OR_F_READING);
2076 return;
2077 }
2078
2079 orp->or_rx_mess = *mp;
2080 assert (!(orp->or_flags & OR_F_READING));
2081 orp->or_flags |= OR_F_READING;
2082
2083 reply (orp, OK, FALSE);
2084 }
2085
2086
2087 /*****************************************************************************
2088 * or_readv_s *
2089 * *
2090 * Copy the data which is stored in orp->rx_buf[orp->rx_first] in the vector *
2091 * which was given with the message *mp *
2092 *****************************************************************************/
2093 static void or_readv_s (message * mp, int from_int) {
2094 int i, j, n, o, s, s1, dl_port, or_client, count, size, err, cps;
2095 int iov_offset = 0, length, offset;
2096 port_t port;
2097 clock_t timebefore;
2098 unsigned amount, totlen, packlen;
2099 struct hermes_rx_descriptor desc;
2100 phys_bytes dst_phys;
2101 u16_t d_start, d_end, status;
2102 struct header_struct hdr;
2103 u32_t l, rxstat;
2104 struct ethhdr *eh;
2105 struct header_struct *h;
2106 t_or *orp;
2107
2108 iovec_s_t *iovp;
2109 phys_bytes databuf_phys;
2110
2111 u8_t *databuf;
2112
2113 dl_port = mp->DL_PORT;
2114 count = mp->DL_COUNT;
2115 if (dl_port < 0 || dl_port >= OR_PORT_NR)
2116 panic("orinoco: illegal port: %d", dl_port);
2117
2118 orp = &or_table[dl_port];
2119 or_client = mp->DL_PROC;
2120 orp->or_client = or_client;
2121
2122 assert (orp->or_mode == OR_M_ENABLED);
2123 assert (orp->or_flags & OR_F_ENABLED);
2124
2125 if (!from_int && (orp->rx_first==orp->rx_last))
2126
2127 {
2128 /* if we are not called from a hard int (data is not yet available) and
2129 * there are no buffers (or->rx_buf[x]) which contain any data, we cant
2130 * copy any data to the inet server. Goto suspend, and wait for data
2131 * to arrive */
2132 goto suspend_readv_s;
2133 }
2134
2135
2136
2137 /* and store the pointer to this data in databuf */
2138 databuf = &(orp->rx_buf[orp->rx_first][0]);
2139 length = orp->rx_length[orp->rx_first];
2140
2141 orp->rxfid[orp->rx_first] = NO_FID;
2142 orp->rx_length[orp->rx_first] = 0;
2143
2144 /* Next time, the next buffer with data will be retrieved */
2145 orp->rx_first++;
2146 orp->rx_first %= NR_RX_BUFS;
2147
2148 o = 0;
2149 /* The data which we want to be copied to the vector starts at
2150 * *databuf and will be copied to the vecor below */
2151 size = 0;
2152 for (i = 0; i < count; i += IOVEC_NR,
2153 iov_offset += IOVEC_NR * sizeof(orp->or_iovec_s[0])) {
2154 n = IOVEC_NR;
2155 if (i + n > count)
2156 n = count - i;
2157
2158 cps = sys_safecopyfrom(or_client, mp->DL_GRANT, iov_offset,
2159 (vir_bytes)orp->or_iovec_s,
2160 n * sizeof(orp->or_iovec_s[0]), D);
2161 if (cps != OK)
2162 panic("orinoco: warning: sys_safecopytp failed: %d", cps);
2163
2164 for (j = 0, iovp = orp->or_iovec_s; j < n; j++, iovp++) {
2165 s = iovp->iov_size;
2166 if (size + s > length) {
2167 assert (length > size);
2168 s = length - size;
2169 }
2170 cps = sys_safecopyto(or_client, iovp->iov_grant, 0,
2171 (vir_bytes) databuf + o, s, D);
2172 if (cps != OK)
2173 panic("orinoco: warning: sys_safecopy failed: %d", cps);
2174
2175 size += s;
2176 if (size == length)
2177 break;
2178 o += s;
2179 }
2180 if (size == length)
2181 break;
2182 }
2183
2184 assert(size >= length);
2185
2186 orp->or_stat.ets_packetR++;
2187 drop:
2188 orp->or_read_s = length;
2189 orp->or_flags &= ~OR_F_READING;
2190 orp->or_flags |= OR_F_PACK_RECV;
2191
2192 if (!from_int) {
2193 /* There was data in the orp->rx_buf[x] which is now copied to
2194 * the inet sever. Tell the inet server */
2195 reply (orp, OK, FALSE);
2196 }
2197
2198 return;
2199 suspend_readv_s:
2200 if (from_int) {
2201 assert (orp->or_flags & OR_F_READING);
2202 /* No need to store any state */
2203 return;
2204 }
2205
2206 /* We want to store the message, so that next time when we are called
2207 * by hard int, we know where to copy the received data */
2208 orp->or_rx_mess = *mp;
2209 assert (!(orp->or_flags & OR_F_READING));
2210 orp->or_flags |= OR_F_READING;
2211
2212 reply (orp, OK, FALSE);
2213
2214 }
2215
2216
2217 /*****************************************************************************
2218 * or_get_recvd_packet *
2219 * *
2220 * The card has received data. Retrieve the data from the card and put it *
2221 * in a buffer in the driver (in the orp structure) *
2222 *****************************************************************************/
2223 static int or_get_recvd_packet(t_or *orp, u16_t rxfid, u8_t *databuf) {
2224 struct hermes_rx_descriptor desc;
2225 hermes_t *hw;
2226 struct header_struct hdr;
2227 int err, length, offset;
2228 u16_t status;
2229
2230 memset(databuf, 0, IEEE802_11_FRAME_LEN);
2231
2232 hw = &(orp->hw);
2233
2234 /* Read the data from the buffer in the card which holds the data.
2235 * First get the descriptor which will tell us whether the packet is
2236 * healthy*/
2237 err = hermes_bap_pread (hw, IRQ_BAP, &desc, sizeof (desc), rxfid, 0);
2238 if (err) {
2239 printf("Orinoco: error %d reading Rx descriptor. "
2240 "Frame dropped\n", err);
2241 orp->or_stat.ets_recvErr++;
2242 return -1;
2243 }
2244
2245 status = desc.status;
2246
2247 if (status & HERMES_RXSTAT_ERR) {
2248 if (status & HERMES_RXSTAT_UNDECRYPTABLE) {
2249 printf("Error reading Orinoco Rx descriptor.Dropped");
2250 } else {
2251 orp->or_stat.ets_CRCerr++;
2252 printf("Orinoco: Bad CRC on Rx. Frame dropped\n");
2253 }
2254 orp->or_stat.ets_recvErr++;
2255 return -1;
2256 }
2257
2258 /* For now we ignore the 802.11 header completely, assuming
2259 that the card's firmware has handled anything vital. The only
2260 thing we want to know is the length of the received data */
2261 err = hermes_bap_pread (hw, IRQ_BAP, &hdr, sizeof (hdr),
2262 rxfid, HERMES_802_3_OFFSET);
2263
2264 if (err) {
2265 printf("Orinoco: error %d reading frame header. "
2266 "Frame dropped\n", err);
2267 orp->or_stat.ets_recvErr++;
2268 return -1;
2269 }
2270
2271 length = ntohs (hdr.len);
2272
2273 /* Sanity checks */
2274 if (length < 3) {
2275 /* No for even an 802.2 LLC header */
2276 printf("Orinoco: error in frame length: length = %d\n",
2277 length);
2278 /* orp->or_stat.ets_recvErr++; */
2279 return -1;
2280 }
2281
2282 if (length > IEEE802_11_DATA_LEN) {
2283 printf("Orinoco: Oversized frame received (%d bytes)\n",
2284 length);
2285 orp->or_stat.ets_recvErr++;
2286 return -1;
2287 }
2288
2289 length += sizeof (struct ethhdr);
2290 offset = HERMES_802_3_OFFSET;
2291
2292 /* Read the interesting parts of the data to the drivers memory. This
2293 * would be everything from the 802.3 layer and up */
2294 err = hermes_bap_pread (hw,
2295 IRQ_BAP, (void *) databuf, RUP_EVEN (length),
2296 rxfid, offset);
2297
2298 if (err) {
2299 printf("Orinoco: error doing hermes_bap_pread()\n");
2300 orp->or_stat.ets_recvErr++;
2301 return -1;
2302 }
2303
2304 /* Some types of firmware give us the SNAP and OUI headers. Remove these.
2305 */
2306 if (is_ethersnap(&hdr)) {
2307 length -= 8;
2308
2309
2310 memcpy (databuf + ETH_ALEN * 2,
2311 databuf + sizeof(struct header_struct) - 2,
2312 length - ETH_ALEN * 2);
2313 }
2314
2315 if(length<60) length=60;
2316
2317 return length;
2318 }
2319
2320 /*****************************************************************************
2321 * or_getstat *
2322 * *
2323 * Return the statistics structure. The statistics aren't updated until now, *
2324 * so this won't return much interesting yet. *
2325 *****************************************************************************/
2326 static void or_getstat (message * mp) {
2327 int r, port;
2328 eth_stat_t stats;
2329 t_or *orp;
2330
2331 port = mp->DL_PORT;
2332 if (port < 0 || port >= OR_PORT_NR)
2333 panic("orinoco: illegal port: %d", port);
2334 orp = &or_table[port];
2335 orp->or_client = mp->DL_PROC;
2336
2337 assert (orp->or_mode == OR_M_ENABLED);
2338 assert (orp->or_flags & OR_F_ENABLED);
2339
2340 stats = orp->or_stat;
2341
2342 r = sys_datacopy(SELF, (vir_bytes)&stats, mp->DL_PROC,
2343 (vir_bytes) mp->DL_ADDR, sizeof(stats));
2344 if(r != OK) {
2345 panic("or_getstat: send failed: %d", r);
2346 }
2347
2348 mp->m_type = DL_STAT_REPLY;
2349 mp->DL_PORT = port;
2350 mp->DL_STAT = OK;
2351
2352 r = send(mp->m_source, mp);
2353 if(r != OK)
2354 panic("orinoco: getstat failed: %d", r);
2355
2356 /*reply (orp, OK, FALSE);*/
2357
2358 }
2359
2360 /*****************************************************************************
2361 * or_getstat_s *
2362 * *
2363 * Return the statistics structure. The statistics aren't updated until now, *
2364 * so this won't return much interesting yet. *
2365 *****************************************************************************/
2366 static void or_getstat_s (message * mp) {
2367 int r, port;
2368 eth_stat_t stats;
2369 t_or *orp;
2370
2371 port = mp->DL_PORT;
2372 if (port < 0 || port >= OR_PORT_NR)
2373 panic("orinoco: illegal port: %d", port);
2374 assert(port==0);
2375 orp = &or_table[port];
2376 orp->or_client = mp->DL_PROC;
2377
2378 assert (orp->or_mode == OR_M_ENABLED);
2379 assert (orp->or_flags & OR_F_ENABLED);
2380
2381 stats = orp->or_stat;
2382
2383 r = sys_safecopyto(mp->DL_PROC, mp->DL_GRANT, 0,
2384 (vir_bytes) &stats, sizeof(stats), D);
2385 if(r != OK) {
2386 panic("or_getstat_s: sys_safecopyto failed: %d", r);
2387 }
2388
2389 mp->m_type = DL_STAT_REPLY;
2390 mp->DL_PORT = port;
2391 mp->DL_STAT = OK;
2392
2393 r = send(mp->m_source, mp);
2394 if(r != OK)
2395 panic("orinoco: getstat_s failed: %d", r);
2396 }
2397
MINIX 3 (repo.or.cz mirror)