1 /**************************************************************************
2 Etherboot - BOOTP/TFTP Bootstrap Program
3 UNDI NIC driver for Etherboot
4
5 This file Copyright (C) 2003 Michael Brown <mbrown@fensystems.co.uk>
6 of Fen Systems Ltd. (http://www.fensystems.co.uk/). All rights
7 reserved.
8
9 $Id: undi.c,v 1.8 2003/10/25 13:54:53 mcb30 Exp $
10 ***************************************************************************/
11
12 /*
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License as
15 * published by the Free Software Foundation; either version 2, or (at
16 * your option) any later version.
17 */
18
19 /* to get some global routines like printf */
20 #include "etherboot.h"
21 /* to get the interface to the body of the program */
22 #include "nic.h"
23 /* to get the PCI support functions, if this is a PCI NIC */
24 #include "pci.h"
25 /* UNDI and PXE defines. Includes pxe.h. */
26 #include "undi.h"
27 /* 8259 PIC defines */
28 #include "pic8259.h"
29 #include "bootp.h"
30 #include "tftp.h"
31 #include "shared.h"
32
33 /* NIC specific static variables go here */
34 static undi_t undi = { NULL, NULL, NULL, NULL, NULL, NULL, NULL,
35 NULL, NULL, 0, NULL, 0, NULL,
36 0, 0, 0, 0,
37 { 0, 0, 0, NULL, 0, 0, 0, 0, 0, 0, 0, NULL },
38 IRQ_NONE };
39 static undi_base_mem_data_t undi_base_mem_data;
40
41 #define UNDI_HEAP (void *)(512 << 10)
42
43 /* Function prototypes */
44 int allocate_base_mem_data ( void );
45 int free_base_mem_data ( void );
46 int eb_pxenv_undi_shutdown ( void );
47 int eb_pxenv_stop_undi ( void );
48 int undi_unload_base_code ( void );
49 int undi_full_shutdown ( void );
50 int eb_pxenv_get_cached_info (uint8_t, void **info);
51
52 /**************************************************************************
53 * Utility functions
54 **************************************************************************/
55
56 /* Checksum a block.
57 */
58
checksum(void * block,size_t size)59 uint8_t checksum ( void *block, size_t size ) {
60 uint8_t sum = 0;
61 uint16_t i = 0;
62 for ( i = 0; i < size; i++ ) {
63 sum += ( ( uint8_t * ) block )[i];
64 }
65 return sum;
66 }
67
68 /* Print the status of a !PXE structure
69 */
70
pxe_dump(void)71 void pxe_dump ( void ) {
72 #ifdef TRACE_UNDI
73 printf ( "API %hx:%hx St %hx:%hx UD %hx:%hx UC %hx:%hx "
74 "BD %hx:%hx BC %hx:%hx\n",
75 undi.pxe->EntryPointSP.segment, undi.pxe->EntryPointSP.offset,
76 undi.pxe->Stack.Seg_Addr, undi.pxe->Stack.Seg_Size,
77 undi.pxe->UNDIData.Seg_Addr, undi.pxe->UNDIData.Seg_Size,
78 undi.pxe->UNDICode.Seg_Addr, undi.pxe->UNDICode.Seg_Size,
79 undi.pxe->BC_Data.Seg_Addr, undi.pxe->BC_Data.Seg_Size,
80 undi.pxe->BC_Code.Seg_Addr, undi.pxe->BC_Code.Seg_Size );
81 #endif
82 }
83
84 /* Allocate/free space for structures that must reside in base memory
85 */
86
allocate_base_mem_data(void)87 int allocate_base_mem_data ( void ) {
88 /* In GRUB, anything is in base address, so we do not need
89 * allocate anything */
90 undi.base_mem_data = &undi_base_mem_data;
91 memset ( undi.base_mem_data, 0, sizeof(undi_base_mem_data_t) );
92 undi.undi_call_info = &undi.base_mem_data->undi_call_info;
93 undi.pxs = &undi.base_mem_data->pxs;
94 undi.xmit_data = &undi.base_mem_data->xmit_data;
95 undi.xmit_buffer = undi.base_mem_data->xmit_buffer;
96 #if 0 /* Etherboot Code */
97 /* Allocate space in base memory.
98 * Initialise pointers to base memory structures.
99 */
100 if ( undi.base_mem_data == NULL ) {
101 undi.base_mem_data =
102 allot_base_memory ( sizeof(undi_base_mem_data_t) +
103 TRIVIAL_IRQ_HANDLER_SIZE );
104 if ( undi.base_mem_data == NULL ) {
105 printf ( "Failed to allocate base memory\n" );
106 free_base_mem_data();
107 return 0;
108 }
109 memset ( undi.base_mem_data, 0, sizeof(undi_base_mem_data_t) );
110 undi.undi_call_info = &undi.base_mem_data->undi_call_info;
111 undi.pxs = &undi.base_mem_data->pxs;
112 undi.xmit_data = &undi.base_mem_data->xmit_data;
113 undi.xmit_buffer = undi.base_mem_data->xmit_buffer;
114 copy_trivial_irq_handler ( undi.base_mem_data->irq_handler,
115 TRIVIAL_IRQ_HANDLER_SIZE );
116 }
117 #endif /* Etherboot Code */
118 return 1;
119 }
120
free_base_mem_data(void)121 int free_base_mem_data ( void ) {
122 /* Just pretend to free something :-) */
123 undi.base_mem_data = NULL;
124 undi.undi_call_info = NULL;
125 undi.pxs = NULL;
126 undi.xmit_data = NULL;
127 undi.xmit_buffer = NULL;
128 #if 0 /* Etherboot Code */
129 if ( undi.base_mem_data != NULL ) {
130 forget_base_memory ( undi.base_mem_data,
131 sizeof(undi_base_mem_data_t) +
132 TRIVIAL_IRQ_HANDLER_SIZE );
133 undi.base_mem_data = NULL;
134 undi.undi_call_info = NULL;
135 undi.pxs = NULL;
136 undi.xmit_data = NULL;
137 undi.xmit_buffer = NULL;
138 copy_trivial_irq_handler ( NULL, 0 );
139 }
140 #endif /* Etherboot Code */
141 return 1;
142 }
143
assemble_firing_squad(firing_squad_lineup_t * lineup,void * start,size_t size,firing_squad_shoot_t shoot)144 void assemble_firing_squad ( firing_squad_lineup_t *lineup,
145 void *start, size_t size,
146 firing_squad_shoot_t shoot ) {
147 int target;
148 int index;
149 int bit;
150 int start_kb = virt_to_phys(start) >> 10;
151 int end_kb = ( virt_to_phys(start+size) + (1<<10) - 1 ) >> 10;
152
153 for ( target = start_kb; target <= end_kb; target++ ) {
154 index = FIRING_SQUAD_TARGET_INDEX ( target );
155 bit = FIRING_SQUAD_TARGET_BIT ( target );
156 lineup->targets[index] = ( shoot << bit ) |
157 ( lineup->targets[index] & ~( 1 << bit ) );
158 }
159 }
160
shoot_targets(firing_squad_lineup_t * lineup)161 void shoot_targets ( firing_squad_lineup_t *lineup ) {
162 int shoot_this_target = 0;
163 int shoot_last_target = 0;
164 int start_target = 0;
165 int target;
166
167 for ( target = 0; target <= 640; target++ ) {
168 shoot_this_target = ( target == 640 ? 0 :
169 ( 1 << FIRING_SQUAD_TARGET_BIT(target) ) &
170 lineup->targets[FIRING_SQUAD_TARGET_INDEX(target)] );
171 if ( shoot_this_target && !shoot_last_target ) {
172 start_target = target;
173 } else if ( shoot_last_target && !shoot_this_target ) {
174 size_t range_size = ( target - start_target ) << 10;
175 forget_base_memory ( phys_to_virt( start_target<<10 ),
176 range_size );
177 }
178 shoot_last_target = shoot_this_target;
179 }
180 }
181
182 /* Debug macros
183 */
184
185 #ifdef TRACE_UNDI
186 #define DBG(...) printf ( __VA_ARGS__ )
187 #else
188 #define DBG(...)
189 #endif
190
191 #define UNDI_STATUS(pxs) ( (pxs)->Status == PXENV_EXIT_SUCCESS ? \
192 "SUCCESS" : \
193 ( (pxs)->Status == PXENV_EXIT_FAILURE ? \
194 "FAILURE" : "UNKNOWN" ) )
195
196 /**************************************************************************
197 * Base memory scanning functions
198 **************************************************************************/
199
200 /* Locate the $PnP structure indicating a PnP BIOS.
201 */
202
hunt_pnp_bios(void)203 int hunt_pnp_bios ( void ) {
204 uint32_t off = 0x10000;
205
206 DBG ( "Hunting for PnP BIOS..." );
207 while ( off > 0 ) {
208 off -= 16;
209 undi.pnp_bios = (pnp_bios_t *) phys_to_virt ( 0xf0000 + off );
210 if ( undi.pnp_bios->signature == PNP_BIOS_SIGNATURE ) {
211 DBG ( "found $PnP at f000:%hx...", off );
212 if ( checksum(undi.pnp_bios,sizeof(pnp_bios_t)) !=0) {
213 DBG ( "invalid checksum\n..." );
214 continue;
215 }
216 DBG ( "ok\n" );
217 return 1;
218 }
219 }
220 DBG ( "none found\n" );
221 undi.pnp_bios = NULL;
222 return 0;
223 }
224
225 /* Locate the !PXE structure indicating a loaded UNDI driver.
226 */
227
hunt_pixie(void)228 int hunt_pixie ( void ) {
229 static uint32_t ptr = 0;
230 pxe_t *pxe = NULL;
231
232 DBG ( "Hunting for pixies..." );
233 if ( ptr == 0 ) ptr = 0xa0000;
234 while ( ptr > 0x10000 ) {
235 ptr -= 16;
236 pxe = (pxe_t *) phys_to_virt ( ptr );
237 if ( memcmp ( pxe->Signature, "!PXE", 4 ) == 0 ) {
238 DBG ( "found !PXE at %x...", ptr );
239 if ( checksum ( pxe, sizeof(pxe_t) ) != 0 ) {
240 DBG ( "invalid checksum\n..." );
241 continue;
242 }
243 if ( ptr < get_free_base_memory() ) {
244 DBG ( "in free base memory!\n\n"
245 "WARNING: a valid !PXE structure was "
246 "found in an area of memory marked "
247 "as free!\n\n" );
248 undi.pxe = pxe;
249 pxe_dump();
250 undi.pxe = NULL;
251 DBG ( "\nIgnoring and continuing, but this "
252 "may cause problems later!\n\n" );
253 continue;
254 }
255 DBG ( "ok\n" );
256 undi.pxe = pxe;
257 pxe_dump();
258 DBG ( "Resetting pixie...\n" );
259 undi_unload_base_code();
260 eb_pxenv_stop_undi();
261 pxe_dump();
262 return 1;
263 }
264 }
265 DBG ( "none found\n" );
266 ptr = 0;
267 return 0;
268 }
269
270 /* Locate PCI PnP ROMs.
271 */
272
hunt_rom(void)273 int hunt_rom ( void ) {
274 static uint32_t ptr = 0;
275
276 DBG ( "Hunting for ROMs..." );
277 if ( ptr == 0 ) ptr = 0x100000;
278 while ( ptr > 0x0c0000 ) {
279 ptr -= 0x800;
280 undi.rom = ( rom_t * ) phys_to_virt ( ptr );
281 if ( undi.rom->signature == ROM_SIGNATURE ) {
282 pcir_header_t *pcir_header = NULL;
283 pnp_header_t *pnp_header = NULL;
284
285 DBG ( "found 55AA at %x...", ptr );
286 if ( undi.rom->pcir_off == 0 ) {
287 DBG ( "not a PCI ROM\n..." );
288 continue;
289 }
290 pcir_header = (pcir_header_t*)( ( void * ) undi.rom +
291 undi.rom->pcir_off );
292 if ( pcir_header->signature != PCIR_SIGNATURE ) {
293 DBG ( "invalid PCI signature\n..." );
294 continue;
295 }
296 DBG ( "PCI:%hx:%hx...", pcir_header->vendor_id,
297 pcir_header->device_id );
298 if ( ( pcir_header->vendor_id != undi.pci.vendor ) ||
299 ( pcir_header->device_id != undi.pci.dev_id ) ) {
300 DBG ( "not me (%hx:%hx)\n...",
301 undi.pci.vendor,
302 undi.pci.dev_id );
303 continue;
304 }
305 if ( undi.rom->pnp_off == 0 ) {
306 DBG ( "not a PnP ROM\n..." );
307 continue;
308 }
309 pnp_header = (pnp_header_t*)( ( void * ) undi.rom +
310 undi.rom->pnp_off );
311 if ( pnp_header->signature != PNP_SIGNATURE ) {
312 DBG ( "invalid $PnP signature\n..." );
313 continue;
314 }
315 if ( checksum(pnp_header,sizeof(pnp_header_t)) != 0 ) {
316 DBG ( "invalid PnP checksum\n..." );
317 continue;
318 }
319 DBG ( "ok\n");
320 printf ("ROM %s by %s\n",
321 pnp_header->product_str_off==0 ? "(unknown)" :
322 (void*)undi.rom+pnp_header->product_str_off,
323 pnp_header->manuf_str_off==0 ? "(unknown)" :
324 (void*)undi.rom+pnp_header->manuf_str_off );
325 return 1;
326 }
327 }
328 DBG ( "none found\n" );
329 ptr = 0;
330 undi.rom = NULL;
331 return 0;
332 }
333
334 /* Locate ROMs containing UNDI drivers.
335 */
336
hunt_undi_rom(void)337 int hunt_undi_rom ( void ) {
338 while ( hunt_rom() ) {
339 if ( undi.rom->undi_rom_id_off == 0 ) {
340 DBG ( "Not a PXE ROM\n" );
341 continue;
342 }
343 undi.undi_rom_id = (undi_rom_id_t *)
344 ( (void *)undi.rom + undi.rom->undi_rom_id_off );
345 if ( undi.undi_rom_id->signature != UNDI_SIGNATURE ) {
346 DBG ( "Invalid UNDI signature\n" );
347 continue;
348 }
349 printf ( "Revision %d.%d.%d",
350 undi.undi_rom_id->undi_rev[2],
351 undi.undi_rom_id->undi_rev[1],
352 undi.undi_rom_id->undi_rev[0] );
353 return 1;
354 }
355 return 0;
356 }
357
358 /**************************************************************************
359 * Low-level UNDI API call wrappers
360 **************************************************************************/
361
362 /* Make a real-mode UNDI API call to the UNDI routine at
363 * routine_seg:routine_off, passing in three uint16 parameters on the
364 * real-mode stack.
365 * Calls the assembler wrapper routine __undi_call.
366 */
367
_undi_call(uint16_t routine_seg,uint16_t routine_off,uint16_t st0,uint16_t st1,uint16_t st2)368 static inline PXENV_EXIT_t _undi_call ( uint16_t routine_seg,
369 uint16_t routine_off, uint16_t st0,
370 uint16_t st1, uint16_t st2 ) {
371 PXENV_EXIT_t ret = PXENV_EXIT_FAILURE;
372
373 undi.undi_call_info->routine.segment = routine_seg;
374 undi.undi_call_info->routine.offset = routine_off;
375 undi.undi_call_info->stack[0] = st0;
376 undi.undi_call_info->stack[1] = st1;
377 undi.undi_call_info->stack[2] = st2;
378 ret = __undi_call ( SEGMENT( undi.undi_call_info ),
379 OFFSET( undi.undi_call_info ) );
380
381 /* UNDI API calls may rudely change the status of A20 and not
382 * bother to restore it afterwards. Intel is known to be
383 * guilty of this.
384 *
385 * Note that we will return to this point even if A20 gets
386 * screwed up by the UNDI driver, because Etherboot always
387 * resides in an even megabyte of RAM.
388 */
389 gateA20_set();
390
391 return ret;
392 }
393
394 /* Make a real-mode call to the UNDI loader routine at
395 * routine_seg:routine_off, passing in the seg:off address of a
396 * pxenv_structure on the real-mode stack.
397 */
398
undi_call_loader(void)399 int undi_call_loader ( void ) {
400 PXENV_EXIT_t pxenv_exit = PXENV_EXIT_FAILURE;
401
402 pxenv_exit = _undi_call ( SEGMENT( undi.rom ),
403 undi.undi_rom_id->undi_loader_off,
404 OFFSET( undi.pxs ),
405 SEGMENT( undi.pxs ),
406 0 /* Unused for UNDI loader API */ );
407 /* Return 1 for success, to be consistent with other routines */
408 if ( pxenv_exit == PXENV_EXIT_SUCCESS ) return 1;
409 DBG ( "UNDI loader call failed with status %#hx\n",
410 undi.pxs->Status );
411 return 0;
412 }
413
414 /* Make a real-mode UNDI API call, passing in the opcode and the
415 * seg:off address of a pxenv_structure on the real-mode stack.
416 *
417 * Two versions: undi_call() will automatically report any failure
418 * codes, undi_call_silent() will not.
419 */
420
undi_call_silent(uint16_t opcode)421 int undi_call_silent ( uint16_t opcode ) {
422 PXENV_EXIT_t pxenv_exit = PXENV_EXIT_FAILURE;
423
424 pxenv_exit = _undi_call ( undi.pxe->EntryPointSP.segment,
425 undi.pxe->EntryPointSP.offset,
426 opcode,
427 OFFSET( undi.pxs ),
428 SEGMENT( undi.pxs ) );
429 /* Return 1 for success, to be consistent with other routines */
430 return pxenv_exit == PXENV_EXIT_SUCCESS ? 1 : 0;
431 }
432
undi_call(uint16_t opcode)433 int undi_call ( uint16_t opcode ) {
434 if ( undi_call_silent ( opcode ) ) return 1;
435 DBG ( "UNDI API call %#hx failed with status %#hx\n",
436 opcode, undi.pxs->Status );
437 return 0;
438 }
439
440 /**************************************************************************
441 * High-level UNDI API call wrappers
442 **************************************************************************/
443
444 /* Install the UNDI driver from a located UNDI ROM.
445 */
446
undi_loader(void)447 int undi_loader ( void ) {
448 pxe_t *pxe = NULL;
449
450 /* AX contains PCI bus:devfn (PCI specification) */
451 undi.pxs->loader.ax = ( undi.pci.bus << 8 ) | undi.pci.devfn;
452 /* BX and DX set to 0xffff for non-ISAPnP devices
453 * (BIOS boot specification)
454 */
455 undi.pxs->loader.bx = 0xffff;
456 undi.pxs->loader.dx = 0xffff;
457 /* ES:DI points to PnP BIOS' $PnP structure
458 * (BIOS boot specification)
459 */
460 undi.pxs->loader.es = 0xf000;
461 undi.pxs->loader.di = virt_to_phys ( undi.pnp_bios ) - 0xf0000;
462
463 /* Allocate space for UNDI driver's code and data segments */
464 undi.driver_code_size = undi.undi_rom_id->code_size;
465 undi.driver_code = UNDI_HEAP;
466 if ( undi.driver_code == NULL ) {
467 printf ( "Could not allocate %d bytes for UNDI code segment\n",
468 undi.driver_code_size );
469 return 0;
470 }
471 undi.pxs->loader.undi_cs = SEGMENT( undi.driver_code );
472
473 undi.driver_data_size = undi.undi_rom_id->data_size;
474 undi.driver_data = (void *)((((unsigned long)UNDI_HEAP + undi.undi_rom_id->code_size) | (1024 -1)) + 1);
475 if ( undi.driver_data == NULL ) {
476 printf ( "Could not allocate %d bytes for UNDI code segment\n",
477 undi.driver_data_size );
478 return 0;
479 }
480 undi.pxs->loader.undi_ds = SEGMENT( undi.driver_data );
481
482 DBG ( "Installing UNDI driver code to %hx:0000, data at %hx:0000\n",
483 undi.pxs->loader.undi_cs, undi.pxs->loader.undi_ds );
484
485 /* Do the API call to install the loader */
486 if ( ! undi_call_loader () ) return 0;
487
488 pxe = VIRTUAL( undi.pxs->loader.undi_cs, undi.pxs->loader.pxe_off );
489 DBG ( "UNDI driver created a pixie at %hx:%hx...",
490 undi.pxs->loader.undi_cs, undi.pxs->loader.pxe_off );
491 if ( memcmp ( pxe->Signature, "!PXE", 4 ) != 0 ) {
492 DBG ( "invalid signature\n" );
493 return 0;
494 }
495 if ( checksum ( pxe, sizeof(pxe_t) ) != 0 ) {
496 DBG ( "invalid checksum\n" );
497 return 0;
498 }
499 DBG ( "ok\n" );
500 undi.pxe = pxe;
501 pxe_dump();
502 return 1;
503 }
504
505 /* Start the UNDI driver.
506 */
507
eb_pxenv_start_undi(void)508 int eb_pxenv_start_undi ( void ) {
509 int success = 0;
510
511 /* AX contains PCI bus:devfn (PCI specification) */
512 undi.pxs->start_undi.ax = ( undi.pci.bus << 8 ) | undi.pci.devfn;
513 /* BX and DX set to 0xffff for non-ISAPnP devices
514 * (BIOS boot specification)
515 */
516 undi.pxs->start_undi.bx = 0xffff;
517 undi.pxs->start_undi.dx = 0xffff;
518 /* ES:DI points to PnP BIOS' $PnP structure
519 * (BIOS boot specification)
520 */
521 undi.pxs->start_undi.es = 0xf000;
522 undi.pxs->start_undi.di = virt_to_phys ( undi.pnp_bios ) - 0xf0000;
523
524 DBG ( "PXENV_START_UNDI => AX=%hx BX=%hx DX=%hx ES:DI=%hx:%hx\n",
525 undi.pxs->start_undi.ax,
526 undi.pxs->start_undi.bx, undi.pxs->start_undi.dx,
527 undi.pxs->start_undi.es, undi.pxs->start_undi.di );
528 success = undi_call ( PXENV_START_UNDI );
529 DBG ( "PXENV_START_UNDI <= Status=%s\n", UNDI_STATUS(undi.pxs) );
530 if ( success ) undi.prestarted = 1;
531 return success;
532 }
533
eb_pxenv_undi_startup(void)534 int eb_pxenv_undi_startup ( void ) {
535 int success = 0;
536
537 DBG ( "PXENV_UNDI_STARTUP => (void)\n" );
538 success = undi_call ( PXENV_UNDI_STARTUP );
539 DBG ( "PXENV_UNDI_STARTUP <= Status=%s\n", UNDI_STATUS(undi.pxs) );
540 if ( success ) undi.started = 1;
541 return success;
542 }
543
eb_pxenv_undi_cleanup(void)544 int eb_pxenv_undi_cleanup ( void ) {
545 int success = 0;
546
547 DBG ( "PXENV_UNDI_CLEANUP => (void)\n" );
548 success = undi_call ( PXENV_UNDI_CLEANUP );
549 DBG ( "PXENV_UNDI_CLEANUP <= Status=%s\n", UNDI_STATUS(undi.pxs) );
550 return success;
551 }
552
eb_pxenv_undi_initialize(void)553 int eb_pxenv_undi_initialize ( void ) {
554 int success = 0;
555
556 undi.pxs->undi_initialize.ProtocolIni = 0;
557 memset ( &undi.pxs->undi_initialize.reserved, 0,
558 sizeof ( undi.pxs->undi_initialize.reserved ) );
559 DBG ( "PXENV_UNDI_INITIALIZE => ProtocolIni=%x\n" );
560 success = undi_call ( PXENV_UNDI_INITIALIZE );
561 DBG ( "PXENV_UNDI_INITIALIZE <= Status=%s\n", UNDI_STATUS(undi.pxs) );
562 if ( success ) undi.initialized = 1;
563 return success;
564 }
565
eb_pxenv_undi_shutdown(void)566 int eb_pxenv_undi_shutdown ( void ) {
567 int success = 0;
568
569 DBG ( "PXENV_UNDI_SHUTDOWN => (void)\n" );
570 success = undi_call ( PXENV_UNDI_SHUTDOWN );
571 DBG ( "PXENV_UNDI_SHUTDOWN <= Status=%s\n", UNDI_STATUS(undi.pxs) );
572 if ( success ) {
573 undi.initialized = 0;
574 undi.started = 0;
575 }
576 return success;
577 }
578
eb_pxenv_undi_open(void)579 int eb_pxenv_undi_open ( void ) {
580 int success = 0;
581
582 undi.pxs->undi_open.OpenFlag = 0;
583 undi.pxs->undi_open.PktFilter = FLTR_DIRECTED | FLTR_BRDCST;
584
585 /* Multicast support not yet implemented */
586 undi.pxs->undi_open.R_Mcast_Buf.MCastAddrCount = 0;
587 DBG ( "PXENV_UNDI_OPEN => OpenFlag=%hx PktFilter=%hx "
588 "MCastAddrCount=%hx\n",
589 undi.pxs->undi_open.OpenFlag, undi.pxs->undi_open.PktFilter,
590 undi.pxs->undi_open.R_Mcast_Buf.MCastAddrCount );
591 success = undi_call ( PXENV_UNDI_OPEN );
592 DBG ( "PXENV_UNDI_OPEN <= Status=%s\n", UNDI_STATUS(undi.pxs) );
593 if ( success ) undi.opened = 1;
594 return success;
595 }
596
eb_pxenv_undi_close(void)597 int eb_pxenv_undi_close ( void ) {
598 int success = 0;
599
600 DBG ( "PXENV_UNDI_CLOSE => (void)\n" );
601 success = undi_call ( PXENV_UNDI_CLOSE );
602 DBG ( "PXENV_UNDI_CLOSE <= Status=%s\n", UNDI_STATUS(undi.pxs) );
603 if ( success ) undi.opened = 0;
604 return success;
605 }
606
eb_pxenv_undi_transmit_packet(void)607 int eb_pxenv_undi_transmit_packet ( void ) {
608 int success = 0;
609 static const uint8_t broadcast[] = { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF };
610
611 /* XMitFlag selects unicast / broadcast */
612 if ( memcmp ( undi.xmit_data->destaddr, broadcast,
613 sizeof(broadcast) ) == 0 ) {
614 undi.pxs->undi_transmit.XmitFlag = XMT_BROADCAST;
615 } else {
616 undi.pxs->undi_transmit.XmitFlag = XMT_DESTADDR;
617 }
618
619 /* Zero reserved dwords */
620 undi.pxs->undi_transmit.Reserved[0] = 0;
621 undi.pxs->undi_transmit.Reserved[1] = 0;
622
623 /* Segment:offset pointer to DestAddr in base memory */
624 undi.pxs->undi_transmit.DestAddr.segment =
625 SEGMENT( undi.xmit_data->destaddr );
626 undi.pxs->undi_transmit.DestAddr.offset =
627 OFFSET( undi.xmit_data->destaddr );
628
629 /* Segment:offset pointer to TBD in base memory */
630 undi.pxs->undi_transmit.TBD.segment = SEGMENT( &undi.xmit_data->tbd );
631 undi.pxs->undi_transmit.TBD.offset = OFFSET( &undi.xmit_data->tbd );
632
633 /* Use only the "immediate" part of the TBD */
634 undi.xmit_data->tbd.DataBlkCount = 0;
635
636 DBG ( "PXENV_UNDI_TRANSMIT_PACKET => Protocol=%hx XmitFlag=%hx ...\n"
637 "... DestAddr=%hx:%hx TBD=%hx:%hx ...\n",
638 undi.pxs->undi_transmit.Protocol,
639 undi.pxs->undi_transmit.XmitFlag,
640 undi.pxs->undi_transmit.DestAddr.segment,
641 undi.pxs->undi_transmit.DestAddr.offset,
642 undi.pxs->undi_transmit.TBD.segment,
643 undi.pxs->undi_transmit.TBD.offset );
644 DBG ( "... TBD { ImmedLength=%hx Xmit=%hx:%hx DataBlkCount=%hx }\n",
645 undi.xmit_data->tbd.ImmedLength,
646 undi.xmit_data->tbd.Xmit.segment,
647 undi.xmit_data->tbd.Xmit.offset,
648 undi.xmit_data->tbd.DataBlkCount );
649 success = undi_call ( PXENV_UNDI_TRANSMIT );
650 DBG ( "PXENV_UNDI_TRANSMIT_PACKET <= Status=%s\n",
651 UNDI_STATUS(undi.pxs) );
652 return success;
653 }
654
eb_pxenv_undi_set_station_address(void)655 int eb_pxenv_undi_set_station_address ( void ) {
656 /* This will spuriously fail on some cards. Ignore failures.
657 * We only ever use it to set the MAC address to the card's
658 * permanent value anyway, so it's a useless call (although we
659 * make it because PXE spec says we should).
660 */
661 DBG ( "PXENV_UNDI_SET_STATION_ADDRESS => "
662 "StationAddress=%!\n",
663 undi.pxs->undi_set_station_address.StationAddress );
664 undi_call_silent ( PXENV_UNDI_SET_STATION_ADDRESS );
665 DBG ( "PXENV_UNDI_SET_STATION_ADDRESS <= Status=%s\n",
666 UNDI_STATUS(undi.pxs) );
667 return 1;
668 }
669
eb_pxenv_undi_get_information(void)670 int eb_pxenv_undi_get_information ( void ) {
671 int success = 0;
672 memset ( undi.pxs, 0, sizeof ( undi.pxs ) );
673 DBG ( "PXENV_UNDI_GET_INFORMATION => (void)\n" );
674 success = undi_call ( PXENV_UNDI_GET_INFORMATION );
675 DBG ( "PXENV_UNDI_GET_INFORMATION <= Status=%s "
676 "BaseIO=%hx IntNumber=%hx ...\n"
677 "... MaxTranUnit=%hx HwType=%hx HwAddrlen=%hx ...\n"
678 "... CurrentNodeAddress=%! PermNodeAddress=%! ...\n"
679 "... ROMAddress=%hx RxBufCt=%hx TxBufCt=%hx\n",
680 UNDI_STATUS(undi.pxs),
681 undi.pxs->undi_get_information.BaseIo,
682 undi.pxs->undi_get_information.IntNumber,
683 undi.pxs->undi_get_information.MaxTranUnit,
684 undi.pxs->undi_get_information.HwType,
685 undi.pxs->undi_get_information.HwAddrLen,
686 undi.pxs->undi_get_information.CurrentNodeAddress,
687 undi.pxs->undi_get_information.PermNodeAddress,
688 undi.pxs->undi_get_information.ROMAddress,
689 undi.pxs->undi_get_information.RxBufCt,
690 undi.pxs->undi_get_information.TxBufCt );
691 return success;
692 }
693
eb_pxenv_undi_get_iface_info(void)694 int eb_pxenv_undi_get_iface_info ( void ) {
695 int success = 0;
696
697 DBG ( "PXENV_UNDI_GET_IFACE_INFO => (void)\n" );
698 success = undi_call ( PXENV_UNDI_GET_IFACE_INFO );
699 DBG ( "PXENV_UNDI_GET_IFACE_INFO <= Status=%s IfaceType=%s ...\n"
700 "... LinkSpeed=%x ServiceFlags=%x\n",
701 UNDI_STATUS(undi.pxs),
702 undi.pxs->undi_get_iface_info.IfaceType,
703 undi.pxs->undi_get_iface_info.LinkSpeed,
704 undi.pxs->undi_get_iface_info.ServiceFlags );
705 return success;
706 }
707
eb_pxenv_undi_isr(void)708 int eb_pxenv_undi_isr ( void ) {
709 int success = 0;
710
711 DBG ( "PXENV_UNDI_ISR => FuncFlag=%hx\n",
712 undi.pxs->undi_isr.FuncFlag );
713 success = undi_call ( PXENV_UNDI_ISR );
714 DBG ( "PXENV_UNDI_ISR <= Status=%s FuncFlag=%hx BufferLength=%hx ...\n"
715 "... FrameLength=%hx FrameHeaderLength=%hx Frame=%hx:%hx "
716 "ProtType=%hhx ...\n... PktType=%hhx\n",
717 UNDI_STATUS(undi.pxs), undi.pxs->undi_isr.FuncFlag,
718 undi.pxs->undi_isr.BufferLength,
719 undi.pxs->undi_isr.FrameLength,
720 undi.pxs->undi_isr.FrameHeaderLength,
721 undi.pxs->undi_isr.Frame.segment,
722 undi.pxs->undi_isr.Frame.offset,
723 undi.pxs->undi_isr.ProtType,
724 undi.pxs->undi_isr.PktType );
725 return success;
726 }
727
eb_pxenv_stop_undi(void)728 int eb_pxenv_stop_undi ( void ) {
729 int success = 0;
730
731 DBG ( "PXENV_STOP_UNDI => (void)\n" );
732 success = undi_call ( PXENV_STOP_UNDI );
733 DBG ( "PXENV_STOP_UNDI <= Status=%s\n", UNDI_STATUS(undi.pxs) );
734 if ( success ) undi.prestarted = 0;
735 return success;
736 }
737
eb_pxenv_unload_stack(void)738 int eb_pxenv_unload_stack ( void ) {
739 int success = 0;
740
741 memset ( undi.pxs, 0, sizeof ( undi.pxs ) );
742 DBG ( "PXENV_UNLOAD_STACK => (void)\n" );
743 success = undi_call_silent ( PXENV_UNLOAD_STACK );
744 DBG ( "PXENV_UNLOAD_STACK <= Status=%s ...\n... (%s)\n",
745 UNDI_STATUS(undi.pxs),
746 ( undi.pxs->Status == PXENV_STATUS_SUCCESS ?
747 "base-code is ready to be removed" :
748 ( undi.pxs->Status == PXENV_STATUS_FAILURE ?
749 "the size of free base memory has been changed" :
750 ( undi.pxs->Status == PXENV_STATUS_KEEP_ALL ?
751 "the NIC interrupt vector has been changed" :
752 "UNEXPECTED STATUS CODE" ) ) ) );
753 return success;
754 }
755
eb_pxenv_stop_base(void)756 int eb_pxenv_stop_base ( void ) {
757 int success = 0;
758
759 DBG ( "PXENV_STOP_BASE => (void)\n" );
760 success = undi_call ( PXENV_STOP_BASE );
761 DBG ( "PXENV_STOP_BASE <= Status=%s\n", UNDI_STATUS(undi.pxs) );
762 return success;
763 }
764
765 /* Unload UNDI base code (if any present) and free memory.
766 */
undi_unload_base_code(void)767 int undi_unload_base_code ( void ) {
768 /* In GRUB, we do not allocate anything, but we still can call
769 * to free the base space */
770 void *bc_code = VIRTUAL( undi.pxe->BC_Code.Seg_Addr, 0 );
771 size_t bc_code_size = undi.pxe->BC_Code.Seg_Size;
772 void *bc_data = VIRTUAL( undi.pxe->BC_Data.Seg_Addr, 0 );
773 size_t bc_data_size = undi.pxe->BC_Data.Seg_Size;
774 void *bc_stck = VIRTUAL( undi.pxe->Stack.Seg_Addr, 0 );
775 size_t bc_stck_size = undi.pxe->Stack.Seg_Size;
776 firing_squad_lineup_t lineup;
777
778 /* Don't unload if there is no base code present */
779 if ( undi.pxe->BC_Code.Seg_Addr == 0 ) return 1;
780
781 /* Since we never start the base code, the only time we should
782 * reach this is if we were loaded via PXE. There are many
783 * different and conflicting versions of the "correct" way to
784 * unload the PXE base code, several of which appear within
785 * the PXE specification itself. This one seems to work for
786 * our purposes.
787 */
788 eb_pxenv_stop_base();
789 //eb_pxenv_unload_stack();
790 /* if ( ( undi.pxs->unload_stack.Status != PXENV_STATUS_SUCCESS ) &&
791 ( undi.pxs->unload_stack.Status != PXENV_STATUS_FAILURE ) ) {
792 printf ( "Could not free memory allocated to PXE base code: "
793 "possible memory leak\n" );
794 return 0;
795 }*/
796 /* Free data structures. Forget what the PXE specification
797 * says about how to calculate the new size of base memory;
798 * basemem.c takes care of all that for us. Note that we also
799 * have to free the stack (even though PXE spec doesn't say
800 * anything about it) because nothing else is going to do so.
801 *
802 * Structures will almost certainly not be kB-aligned and
803 * there's a reasonable chance that the UNDI code or data
804 * portions will lie in the same kB as the base code. Since
805 * forget_base_memory works only in 1kB increments, this means
806 * we have to do some arcane trickery.
807 */
808 memset ( &lineup, 0, sizeof(lineup) );
809 if ( SEGMENT(bc_code) != 0 )
810 assemble_firing_squad( &lineup, bc_code, bc_code_size, SHOOT );
811 if ( SEGMENT(bc_data) != 0 )
812 assemble_firing_squad( &lineup, bc_data, bc_data_size, SHOOT );
813 if ( SEGMENT(bc_stck) != 0 )
814 assemble_firing_squad( &lineup, bc_stck, bc_stck_size, SHOOT );
815 /* Don't shoot any bits of the UNDI driver code or data */
816 assemble_firing_squad ( &lineup,
817 VIRTUAL(undi.pxe->UNDICode.Seg_Addr, 0),
818 undi.pxe->UNDICode.Seg_Size, DONTSHOOT );
819 assemble_firing_squad ( &lineup,
820 VIRTUAL(undi.pxe->UNDIData.Seg_Addr, 0),
821 undi.pxe->UNDIData.Seg_Size, DONTSHOOT );
822 //shoot_targets ( &lineup );
823 //undi.pxe->BC_Code.Seg_Addr = 0;
824 //undi.pxe->BC_Data.Seg_Addr = 0;
825 //undi.pxe->Stack.Seg_Addr = 0;
826
827 /* Free and reallocate our own base memory data structures, to
828 * allow the freed base-code blocks to be fully released.
829 */
830 free_base_mem_data();
831 if ( ! allocate_base_mem_data() ) {
832 printf ( "FATAL: memory unaccountably lost\n" );
833 while ( 1 ) {};
834 }
835
836 return 1;
837 }
838
839 /* UNDI full initialization
840 *
841 * This calls all the various UNDI initialization routines in sequence.
842 */
843
undi_full_startup(void)844 int undi_full_startup ( void ) {
845 if ( ! eb_pxenv_start_undi() ) return 0;
846 if ( ! eb_pxenv_undi_startup() ) return 0;
847 if ( ! eb_pxenv_undi_initialize() ) return 0;
848 if ( ! eb_pxenv_undi_get_information() ) return 0;
849 undi.irq = undi.pxs->undi_get_information.IntNumber;
850 if ( ! install_undi_irq_handler ( undi.irq, undi.pxe->EntryPointSP ) ) {
851 undi.irq = IRQ_NONE;
852 return 0;
853 }
854 memmove ( &undi.pxs->undi_set_station_address.StationAddress,
855 &undi.pxs->undi_get_information.PermNodeAddress,
856 sizeof (undi.pxs->undi_set_station_address.StationAddress) );
857 if ( ! eb_pxenv_undi_set_station_address() ) return 0;
858 if ( ! eb_pxenv_undi_open() ) return 0;
859 /* install_undi_irq_handler leaves irq disabled */
860 enable_irq ( undi.irq );
861 return 1;
862 }
863
864 /* UNDI full shutdown
865 *
866 * This calls all the various UNDI shutdown routines in sequence and
867 * also frees any memory that it can.
868 */
869
undi_full_shutdown(void)870 int undi_full_shutdown ( void ) {
871 if ( undi.pxe != NULL ) {
872 /* In case we didn't allocate the driver's memory in the first
873 * place, try to grab the code and data segments and sizes
874 * from the !PXE structure.
875 */
876 if ( undi.driver_code == NULL ) {
877 undi.driver_code = VIRTUAL(undi.pxe->UNDICode.Seg_Addr,
878 0 );
879 undi.driver_code_size = undi.pxe->UNDICode.Seg_Size;
880 }
881 if ( undi.driver_data == NULL ) {
882 undi.driver_data = VIRTUAL(undi.pxe->UNDIData.Seg_Addr,
883 0 );
884 undi.driver_data_size = undi.pxe->UNDIData.Seg_Size;
885 }
886
887 /* Ignore errors and continue in the hope of shutting
888 * down anyway
889 */
890 if ( undi.opened ) eb_pxenv_undi_close();
891 if ( undi.started ) {
892 eb_pxenv_undi_cleanup();
893 /* We may get spurious UNDI API errors at this
894 * point. If startup() succeeded but
895 * initialize() failed then according to the
896 * spec, we should call shutdown(). However,
897 * some NICS will fail with a status code
898 * 0x006a (INVALID_STATE).
899 */
900 eb_pxenv_undi_shutdown();
901 }
902 if ( undi.irq != IRQ_NONE ) {
903 remove_undi_irq_handler ( undi.irq );
904 undi.irq = IRQ_NONE;
905 }
906 undi_unload_base_code();
907 if ( undi.prestarted ) {
908 eb_pxenv_stop_undi();
909 /* Success OR Failure indicates that memory
910 * can be freed. Any other status code means
911 * that it can't.
912 */
913 if (( undi.pxs->Status == PXENV_STATUS_KEEP_UNDI ) ||
914 ( undi.pxs->Status == PXENV_STATUS_KEEP_ALL ) ) {
915 printf ("Could not free memory allocated to "
916 "UNDI driver: possible memory leak\n");
917 return 0;
918 }
919 }
920 }
921 /* Free memory allocated to UNDI driver */
922 if ( undi.driver_code != NULL ) {
923 /* Clear contents in order to eliminate !PXE and PXENV
924 * signatures to prevent spurious detection via base
925 * memory scan.
926 */
927 memset ( undi.driver_code, 0, undi.driver_code_size );
928 /* forget_base_memory ( undi.driver_code, undi.driver_code_size ); */
929 undi.driver_code = NULL;
930 undi.driver_code_size = 0;
931 }
932 if ( undi.driver_data != NULL ) {
933 /* forget_base_memory ( undi.driver_data, undi.driver_data_size ); */
934 undi.driver_data = NULL;
935 undi.driver_data_size = 0;
936 }
937 /* !PXE structure now gone; memory freed */
938 undi.pxe = NULL;
939 return 1;
940 }
941
942 /**************************************************************************
943 POLL - Wait for a frame
944 ***************************************************************************/
undi_poll(struct nic * nic,int retrieve)945 static int undi_poll(struct nic *nic, int retrieve)
946 {
947 /* Fun, fun, fun. UNDI drivers don't use polling; they use
948 * interrupts. We therefore cheat and pretend that an
949 * interrupt has occurred every time undi_poll() is called.
950 * This isn't too much of a hack; PCI devices share IRQs and
951 * so the first thing that a proper ISR should do is call
952 * PXENV_UNDI_ISR to determine whether or not the UNDI NIC
953 * generated the interrupt; there is no harm done by spurious
954 * calls to PXENV_UNDI_ISR. Similarly, we wouldn't be
955 * handling them any more rapidly than the usual rate of
956 * undi_poll() being called even if we did implement a full
957 * ISR. So it should work. Ha!
958 *
959 * Addendum (21/10/03). Some cards don't play nicely with
960 * this trick, so instead of doing it the easy way we have to
961 * go to all the hassle of installing a genuine interrupt
962 * service routine and dealing with the wonderful 8259
963 * Programmable Interrupt Controller. Joy.
964 *
965 * (02/01/2005). A real UNDI ISR is now implemented in,
966 * following Figure 3-4 in PXE spec 2.0. The interrupt
967 * handler, undi_irq_handler, issues PXENV_UNDI_ISR_IN_START.
968 * If the interrupt is ours, the handler sends EOI and bumps the
969 * undi_irq_trigger_count. This polled routine is equivalent
970 * to the "driver strategy routine".
971 *
972 * Another issue is that upper layer await_*() does not handle
973 * coalesced packets. The UNDI implementation on broadcom chips
974 * appear to combine interrupts. If we loop through GET_NEXT,
975 * we may hand up coalesced packets, resulting in drops, and
976 * severe time delay. As a temperary hack, we return as soon as
977 * we get something, remembering where we were (IN_PROCESS
978 * or GET_NEXT). This assume packets are never broken up.
979 * XXX Need to fix upper layer to handle coalesced data.
980 */
981
982 static int undi_opcode = PXENV_UNDI_ISR_IN_PROCESS;
983
984 /* See if a hardware interrupt has occurred since the last poll().
985 */
986 switch ( undi_opcode ) {
987 case PXENV_UNDI_ISR_IN_PROCESS:
988 if ( ! undi_irq_triggered ( undi.irq ) )
989 return 0;
990 default:
991 break;
992 }
993
994 /* We have an interrupt or there is something left from
995 * last poll. Either way, we need to call UNDI ISR.
996 */
997 nic->packetlen = 0;
998 undi.pxs->undi_isr.FuncFlag = undi_opcode;
999 /* there is no good way to handle this error */
1000 if ( ! eb_pxenv_undi_isr() ) {
1001 printf ("undi isr call failed: opcode = %d\n", undi_opcode);
1002 return 0;
1003 }
1004 switch ( undi.pxs->undi_isr.FuncFlag ) {
1005 case PXENV_UNDI_ISR_OUT_DONE:
1006 /* Set opcode back to IN_PROCESS and wait for next intr */
1007 undi_opcode = PXENV_UNDI_ISR_IN_PROCESS;
1008 return 0;
1009 case PXENV_UNDI_ISR_OUT_TRANSMIT:
1010 /* We really don't care about transmission complete
1011 * interrupts. Move on to next frame.
1012 */
1013 undi_opcode = PXENV_UNDI_ISR_IN_GET_NEXT;
1014 return 0;
1015 case PXENV_UNDI_ISR_OUT_BUSY:
1016 /* This should never happen.
1017 */
1018 undi_opcode = PXENV_UNDI_ISR_IN_GET_NEXT;
1019 printf ( "UNDI ISR thinks it's being re-entered!\n"
1020 "Aborting receive\n" );
1021 return 0;
1022 case PXENV_UNDI_ISR_OUT_RECEIVE:
1023 /* Copy data to receive buffer and move on to next frame */
1024 undi_opcode = PXENV_UNDI_ISR_IN_GET_NEXT;
1025 memcpy ( nic->packet + nic->packetlen,
1026 VIRTUAL( undi.pxs->undi_isr.Frame.segment,
1027 undi.pxs->undi_isr.Frame.offset ),
1028 undi.pxs->undi_isr.BufferLength );
1029 nic->packetlen += undi.pxs->undi_isr.BufferLength;
1030 break;
1031 default:
1032 undi_opcode = PXENV_UNDI_ISR_IN_PROCESS;
1033 printf ( "UNDI ISR returned bizzare status code %d\n",
1034 undi.pxs->undi_isr.FuncFlag );
1035 }
1036
1037 return nic->packetlen > 0 ? 1 : 0;
1038 }
1039
1040 /**************************************************************************
1041 TRANSMIT - Transmit a frame
1042 ***************************************************************************/
undi_transmit(struct nic * nic,const char * d,unsigned int t,unsigned int s,const char * p)1043 static void undi_transmit(
1044 struct nic *nic,
1045 const char *d, /* Destination */
1046 unsigned int t, /* Type */
1047 unsigned int s, /* size */
1048 const char *p) /* Packet */
1049 {
1050 /* Inhibit compiler warning about unused parameter nic */
1051 if ( nic == NULL ) {};
1052
1053 /* Copy destination to buffer in base memory */
1054 memcpy ( undi.xmit_data->destaddr, d, sizeof(MAC_ADDR) );
1055
1056 /* Translate packet type to UNDI packet type */
1057 switch ( t ) {
1058 case IP : undi.pxs->undi_transmit.Protocol = P_IP; break;
1059 case ARP: undi.pxs->undi_transmit.Protocol = P_ARP; break;
1060 case RARP: undi.pxs->undi_transmit.Protocol = P_RARP; break;
1061 default: undi.pxs->undi_transmit.Protocol = P_UNKNOWN; break;
1062 }
1063
1064 /* Store packet length in TBD */
1065 undi.xmit_data->tbd.ImmedLength = s;
1066
1067 /* Check to see if data to be transmitted is currently in base
1068 * memory. If not, allocate temporary storage in base memory
1069 * and copy it there.
1070 */
1071 if ( SEGMENT( p ) <= 0xffff ) {
1072 undi.xmit_data->tbd.Xmit.segment = SEGMENT( p );
1073 undi.xmit_data->tbd.Xmit.offset = OFFSET( p );
1074 } else {
1075 memcpy ( undi.xmit_buffer, p, s );
1076 undi.xmit_data->tbd.Xmit.segment = SEGMENT( undi.xmit_buffer );
1077 undi.xmit_data->tbd.Xmit.offset = OFFSET( undi.xmit_buffer );
1078 }
1079
1080 eb_pxenv_undi_transmit_packet();
1081 }
1082
1083 /**************************************************************************
1084 DISABLE - Turn off ethernet interface
1085 ***************************************************************************/
undi_disable(struct dev * dev)1086 static void undi_disable(struct dev *dev)
1087 {
1088 /* Inhibit compiler warning about unused parameter dev */
1089 if ( dev == NULL ) {};
1090 undi_full_shutdown();
1091 free_base_mem_data();
1092 }
1093
1094 /**************************************************************************
1095 PROBE - Look for an adapter, this routine's visible to the outside
1096 ***************************************************************************/
1097
1098 /* Locate an UNDI driver by first scanning through base memory for an
1099 * installed driver and then by scanning for UNDI ROMs and attempting
1100 * to install their drivers.
1101 */
1102
hunt_pixies_and_undi_roms(void)1103 int hunt_pixies_and_undi_roms ( void ) {
1104 static uint8_t hunt_type = HUNT_FOR_PIXIES;
1105
1106 if ( hunt_type == HUNT_FOR_PIXIES ) {
1107 if ( hunt_pixie() ) {
1108 return 1;
1109 }
1110 }
1111 hunt_type = HUNT_FOR_UNDI_ROMS;
1112 while ( hunt_undi_rom() ) {
1113 if ( undi_loader() ) {
1114 return 1;
1115 }
1116 undi_full_shutdown(); /* Free any allocated memory */
1117 }
1118 hunt_type = HUNT_FOR_PIXIES;
1119 return 0;
1120 }
1121
1122 /* The actual Etherboot probe routine.
1123 */
1124
undi_probe(struct dev * dev,struct pci_device * pci)1125 static int undi_probe(struct dev *dev, struct pci_device *pci)
1126 {
1127 struct nic *nic = (struct nic *)dev;
1128
1129 /* Zero out global undi structure */
1130 memset ( &undi, 0, sizeof(undi) );
1131
1132 /* Store PCI parameters; we will need them to initialize the UNDI
1133 * driver later.
1134 */
1135 memcpy ( &undi.pci, pci, sizeof(undi.pci) );
1136
1137 /* Find the BIOS' $PnP structure */
1138 if ( ! hunt_pnp_bios() ) {
1139 printf ( "No PnP BIOS found; aborting\n" );
1140 return 0;
1141 }
1142
1143 /* Allocate base memory data structures */
1144 if ( ! allocate_base_mem_data() ) return 0;
1145
1146 /* Search thoroughly for UNDI drivers */
1147 for ( ; hunt_pixies_and_undi_roms(); undi_full_shutdown() ) {
1148 /* Try to initialise UNDI driver */
1149 DBG ( "Initializing UNDI driver. Please wait...\n" );
1150 if ( ! undi_full_startup() ) {
1151 if ( undi.pxs->Status ==
1152 PXENV_STATUS_UNDI_MEDIATEST_FAILED ) {
1153 DBG ( "Cable not connected (code %#hx)\n",
1154 PXENV_STATUS_UNDI_MEDIATEST_FAILED );
1155 }
1156 continue;
1157 }
1158 /* Basic information: MAC, IO addr, IRQ */
1159 if ( ! eb_pxenv_undi_get_information() ) continue;
1160 DBG ( "Initialized UNDI NIC with IO %#hx, IRQ %d, MAC %!\n",
1161 undi.pxs->undi_get_information.BaseIo,
1162 undi.pxs->undi_get_information.IntNumber,
1163 undi.pxs->undi_get_information.CurrentNodeAddress );
1164 /* Fill out MAC address in nic structure */
1165 memcpy ( nic->node_addr,
1166 undi.pxs->undi_get_information.CurrentNodeAddress,
1167 ETH_ALEN );
1168 /* More diagnostic information including link speed */
1169 if ( ! eb_pxenv_undi_get_iface_info() ) continue;
1170 printf ( " NDIS type %s interface at %d Mbps\n",
1171 undi.pxs->undi_get_iface_info.IfaceType,
1172 undi.pxs->undi_get_iface_info.LinkSpeed / 1000000 );
1173 DBG ("UNDI Stack at %#hx:%#hx",UNDI_STACK_SEG, UNDI_STACK_OFF);
1174 dev->disable = undi_disable;
1175 nic->poll = undi_poll;
1176 nic->transmit = undi_transmit;
1177 return 1;
1178 }
1179 undi_disable ( dev ); /* To free base memory structures */
1180 return 0;
1181 }
1182
1183 /* UNDI driver states that it is suitable for any PCI NIC (i.e. any
1184 * PCI device of class PCI_CLASS_NETWORK_ETHERNET). If there are any
1185 * obscure UNDI NICs that have the incorrect PCI class, add them to
1186 * this list.
1187 */
1188 static struct pci_id undi_nics[] = {
1189 PCI_ROM(0x10de, 0x0057, "ck804", "nVidia Corporation CK804 Ethernet"),
1190 PCI_ROM(0x10de, 0x0373, "mcp55", "nVidia Corporation MCP55 Ethernet")
1191 };
1192
1193 struct pci_driver undi_driver = {
1194 .type = NIC_DRIVER,
1195 .name = "UNDI",
1196 .probe = undi_probe,
1197 .ids = undi_nics,
1198 .id_count = sizeof(undi_nics)/sizeof(undi_nics[0]),
1199 .class = PCI_CLASS_NETWORK_ETHERNET,
1200 };
1201
1202 /************************************************
1203 * Code for reusing the BIOS provided pxe stack
1204 */
1205
1206 /* Verify !PXE structure saved by pxeloader. */
undi_bios_pxe(void ** dhcpreply)1207 int undi_bios_pxe(void **dhcpreply)
1208 {
1209 pxe_t *pxe;
1210 uint16_t *ptr = (uint16_t *)0x7C80;
1211
1212 pxe = (pxe_t *) VIRTUAL(ptr[0], ptr[1]);
1213 if (memcmp(pxe->Signature, "!PXE", 4) != 0) {
1214 DBG ("invalid !PXE signature at %x:%x\n", ptr[0], ptr[1]);
1215 return 0;
1216 }
1217
1218 if (checksum(pxe, sizeof(pxe_t)) != 0) {
1219 DBG ("invalid checksum\n");
1220 return 0;
1221 }
1222
1223 /* Zero out global undi structure */
1224 memset (&undi, 0, sizeof(undi));
1225
1226 /* Allocate base memory data structures */
1227 if (! allocate_base_mem_data()) return 0;
1228
1229 undi.pxe = pxe;
1230 pxe_dump();
1231
1232 if (!eb_pxenv_get_cached_info(PXENV_PACKET_TYPE_DHCP_ACK, dhcpreply)) {
1233 DBG ("failed to get cached DHCP reply\n");
1234 return 0;
1235 }
1236 return 1;
1237 }
1238
undi_pxe_disable(void)1239 void undi_pxe_disable(void)
1240 {
1241 /* full shutdown is problematic for some machines */
1242 (void) eb_pxenv_undi_shutdown();
1243 }
1244
1245 /*
1246 * Various helper functions for dhcp and tftp
1247 */
eb_pxenv_get_cached_info(uint8_t type,void ** info)1248 int eb_pxenv_get_cached_info (uint8_t type, void **info)
1249 {
1250 int success;
1251
1252 memset(undi.pxs, 0, sizeof (undi.pxs));
1253 /* Segment:offset pointer to DestAddr in base memory */
1254 undi.pxs->get_cached_info.PacketType = type;
1255 undi.pxs->get_cached_info.BufferSize = 0;
1256 undi.pxs->get_cached_info.Buffer.segment = 0;
1257 undi.pxs->get_cached_info.Buffer.offset = 0;
1258
1259 success = undi_call(PXENV_GET_CACHED_INFO);
1260 DBG ("PXENV_GET_CACHED_INFO <= Status=%s\n", UNDI_STATUS(undi.pxs));
1261
1262 *info = (void *)VIRTUAL(undi.pxs->get_cached_info.Buffer.segment,
1263 undi.pxs->get_cached_info.Buffer.offset);
1264 return success;
1265 }
1266
1267 /* tftp help routines */
eb_pxenv_tftp_open(char * file,IP4_t serverip,IP4_t gatewayip,uint16_t * pktlen)1268 int eb_pxenv_tftp_open(char *file, IP4_t serverip, IP4_t gatewayip,
1269 uint16_t *pktlen)
1270 {
1271 int success;
1272 memset(undi.pxs, 0, sizeof (undi.pxs));
1273 undi.pxs->tftp_open.ServerIPAddress = serverip;
1274 undi.pxs->tftp_open.GatewayIPAddress = gatewayip;
1275 undi.pxs->tftp_open.TFTPPort = htons(TFTP_PORT);
1276 undi.pxs->tftp_open.PacketSize = TFTP_MAX_PACKET;
1277 (void) sprintf(undi.pxs->tftp_open.FileName, "%s", file);
1278 success = undi_call(PXENV_TFTP_OPEN);
1279 DBG ("PXENV_TFTP_OPEN <= Status=%s\n", UNDI_STATUS(undi.pxs));
1280 *pktlen = undi.pxs->tftp_open.PacketSize;
1281 return success;
1282 }
1283
eb_pxenv_tftp_read(uint8_t * buf,uint16_t * len)1284 int eb_pxenv_tftp_read(uint8_t *buf, uint16_t *len)
1285 {
1286 static int tftp_count = 0;
1287
1288 int success;
1289 memset(undi.pxs, 0, sizeof (undi.pxs));
1290 undi.pxs->tftp_read.Buffer.segment = SEGMENT(buf);
1291 undi.pxs->tftp_read.Buffer.offset = OFFSET(buf);
1292 success = undi_call(PXENV_TFTP_READ);
1293 DBG ("PXENV_TFTP_READ <= Status=%s\n", UNDI_STATUS(undi.pxs));
1294 *len = undi.pxs->tftp_read.BufferSize;
1295 tftp_count++;
1296 if ((tftp_count % 1000) == 0)
1297 noisy_printf(".");
1298 return success;
1299 }
1300
eb_pxenv_tftp_close(void)1301 int eb_pxenv_tftp_close(void)
1302 {
1303 int success;
1304 memset(undi.pxs, 0, sizeof (undi.pxs));
1305 success = undi_call(PXENV_TFTP_CLOSE);
1306 DBG ("PXENV_TFTP_CLOSE <= Status=%s\n", UNDI_STATUS(undi.pxs));
1307 return success;
1308 }
1309
eb_pxenv_tftp_get_fsize(char * file,IP4_t serverip,IP4_t gatewayip,uint32_t * fsize)1310 int eb_pxenv_tftp_get_fsize(char *file, IP4_t serverip, IP4_t gatewayip,
1311 uint32_t *fsize)
1312 {
1313 int success;
1314 memset(undi.pxs, 0, sizeof (undi.pxs));
1315 undi.pxs->tftp_open.ServerIPAddress = serverip;
1316 undi.pxs->tftp_open.GatewayIPAddress = gatewayip;
1317 (void) sprintf(undi.pxs->tftp_open.FileName, "%s", file);
1318 success = undi_call(PXENV_TFTP_GET_FSIZE);
1319 DBG ("PXENV_TFTP_GET_FSIZE <= Status=%s\n", UNDI_STATUS(undi.pxs));
1320 *fsize = undi.pxs->tftp_get_fsize.FileSize;
1321 return success;
1322 }
1323