705afcabb7bd969ae5cab4a83894deab09081379
[people/cooldavid/gpxe.git] / src / arch / i386 / interface / pxe / pxe_call.c
1 /*
2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 FILE_LICENCE ( GPL2_OR_LATER );
20
21 #include <gpxe/uaccess.h>
22 #include <gpxe/init.h>
23 #include <registers.h>
24 #include <biosint.h>
25 #include <pxe.h>
26 #include <pxe_call.h>
27
28 /** @file
29  *
30  * PXE API entry point
31  */
32
33 /** Vector for chaining INT 1A */
34 extern struct segoff __text16 ( pxe_int_1a_vector );
35 #define pxe_int_1a_vector __use_text16 ( pxe_int_1a_vector )
36
37 /** INT 1A handler */
38 extern void pxe_int_1a ( void );
39
40 /** INT 1A hooked flag */
41 static int int_1a_hooked = 0;
42
43 /** A function pointer to hold any PXE API call
44  *
45  * Used by pxe_api_call() to avoid large swathes of duplicated code.
46  */
47 union pxenv_call {
48         PXENV_EXIT_t ( * any ) ( union u_PXENV_ANY * );
49         PXENV_EXIT_t ( * unknown ) ( struct s_PXENV_UNKNOWN * );
50         PXENV_EXIT_t ( * unload_stack ) ( struct s_PXENV_UNLOAD_STACK * );
51         PXENV_EXIT_t ( * get_cached_info )
52                         ( struct s_PXENV_GET_CACHED_INFO * );
53         PXENV_EXIT_t ( * restart_tftp ) ( struct s_PXENV_TFTP_READ_FILE * );
54         PXENV_EXIT_t ( * start_undi ) ( struct s_PXENV_START_UNDI * );
55         PXENV_EXIT_t ( * stop_undi ) ( struct s_PXENV_STOP_UNDI * );
56         PXENV_EXIT_t ( * start_base ) ( struct s_PXENV_START_BASE * );
57         PXENV_EXIT_t ( * stop_base ) ( struct s_PXENV_STOP_BASE * );
58         PXENV_EXIT_t ( * tftp_open ) ( struct s_PXENV_TFTP_OPEN * );
59         PXENV_EXIT_t ( * tftp_close ) ( struct s_PXENV_TFTP_CLOSE * );
60         PXENV_EXIT_t ( * tftp_read ) ( struct s_PXENV_TFTP_READ * );
61         PXENV_EXIT_t ( * tftp_read_file ) ( struct s_PXENV_TFTP_READ_FILE * );
62         PXENV_EXIT_t ( * tftp_get_fsize ) ( struct s_PXENV_TFTP_GET_FSIZE * );
63         PXENV_EXIT_t ( * udp_open ) ( struct s_PXENV_UDP_OPEN * );
64         PXENV_EXIT_t ( * udp_close ) ( struct s_PXENV_UDP_CLOSE * );
65         PXENV_EXIT_t ( * udp_write ) ( struct s_PXENV_UDP_WRITE * );
66         PXENV_EXIT_t ( * udp_read ) ( struct s_PXENV_UDP_READ * );
67         PXENV_EXIT_t ( * undi_startup ) ( struct s_PXENV_UNDI_STARTUP * );
68         PXENV_EXIT_t ( * undi_cleanup ) ( struct s_PXENV_UNDI_CLEANUP * );
69         PXENV_EXIT_t ( * undi_initialize )
70                         ( struct s_PXENV_UNDI_INITIALIZE * );
71         PXENV_EXIT_t ( * undi_reset_adapter ) ( struct s_PXENV_UNDI_RESET * );
72         PXENV_EXIT_t ( * undi_shutdown ) ( struct s_PXENV_UNDI_SHUTDOWN * );
73         PXENV_EXIT_t ( * undi_open ) ( struct s_PXENV_UNDI_OPEN * );
74         PXENV_EXIT_t ( * undi_close ) ( struct s_PXENV_UNDI_CLOSE * );
75         PXENV_EXIT_t ( * undi_transmit ) ( struct s_PXENV_UNDI_TRANSMIT * );
76         PXENV_EXIT_t ( * undi_set_mcast_address )
77                         ( struct s_PXENV_UNDI_SET_MCAST_ADDRESS * );
78         PXENV_EXIT_t ( * undi_set_station_address )
79                         ( struct s_PXENV_UNDI_SET_STATION_ADDRESS * );
80         PXENV_EXIT_t ( * undi_set_packet_filter )
81                         ( struct s_PXENV_UNDI_SET_PACKET_FILTER * );
82         PXENV_EXIT_t ( * undi_get_information )
83                         ( struct s_PXENV_UNDI_GET_INFORMATION * );
84         PXENV_EXIT_t ( * undi_get_statistics )
85                         ( struct s_PXENV_UNDI_GET_STATISTICS * );
86         PXENV_EXIT_t ( * undi_clear_statistics )
87                         ( struct s_PXENV_UNDI_CLEAR_STATISTICS * );
88         PXENV_EXIT_t ( * undi_initiate_diags )
89                         ( struct s_PXENV_UNDI_INITIATE_DIAGS * );
90         PXENV_EXIT_t ( * undi_force_interrupt )
91                         ( struct s_PXENV_UNDI_FORCE_INTERRUPT * );
92         PXENV_EXIT_t ( * undi_get_mcast_address )
93                         ( struct s_PXENV_UNDI_GET_MCAST_ADDRESS * );
94         PXENV_EXIT_t ( * undi_get_nic_type )
95                         ( struct s_PXENV_UNDI_GET_NIC_TYPE * );
96         PXENV_EXIT_t ( * undi_get_iface_info )
97                         ( struct s_PXENV_UNDI_GET_IFACE_INFO * );
98         PXENV_EXIT_t ( * undi_get_state ) ( struct s_PXENV_UNDI_GET_STATE * );
99         PXENV_EXIT_t ( * undi_isr ) ( struct s_PXENV_UNDI_ISR * );
100         PXENV_EXIT_t ( * file_open ) ( struct s_PXENV_FILE_OPEN * );
101         PXENV_EXIT_t ( * file_close ) ( struct s_PXENV_FILE_CLOSE * );
102         PXENV_EXIT_t ( * file_select ) ( struct s_PXENV_FILE_SELECT * );
103         PXENV_EXIT_t ( * file_read ) ( struct s_PXENV_FILE_READ * );
104         PXENV_EXIT_t ( * get_file_size ) ( struct s_PXENV_GET_FILE_SIZE * );
105         PXENV_EXIT_t ( * file_exec ) ( struct s_PXENV_FILE_EXEC * );
106         PXENV_EXIT_t ( * file_api_check ) ( struct s_PXENV_FILE_API_CHECK * );
107 };
108
109 /**
110  * Handle an unknown PXE API call
111  *
112  * @v pxenv_unknown                     Pointer to a struct s_PXENV_UNKNOWN
113  * @ret #PXENV_EXIT_FAILURE             Always
114  * @err #PXENV_STATUS_UNSUPPORTED       Always
115  */
116 static PXENV_EXIT_t pxenv_unknown ( struct s_PXENV_UNKNOWN *pxenv_unknown ) {
117         pxenv_unknown->Status = PXENV_STATUS_UNSUPPORTED;
118         return PXENV_EXIT_FAILURE;
119 }
120
121 /**
122  * Dispatch PXE API call
123  *
124  * @v bx                PXE opcode
125  * @v es:di             Address of PXE parameter block
126  * @ret ax              PXE exit code
127  */
128 __asmcall void pxe_api_call ( struct i386_all_regs *ix86 ) {
129         int opcode = ix86->regs.bx;
130         userptr_t parameters = real_to_user ( ix86->segs.es, ix86->regs.di );
131         size_t param_len;
132         union u_PXENV_ANY pxenv_any;
133         union pxenv_call pxenv_call;
134         PXENV_EXIT_t ret;
135
136         switch ( opcode ) {
137         case PXENV_UNLOAD_STACK:
138                 pxenv_call.unload_stack = pxenv_unload_stack;
139                 param_len = sizeof ( pxenv_any.unload_stack );
140                 break;
141         case PXENV_GET_CACHED_INFO:
142                 pxenv_call.get_cached_info = pxenv_get_cached_info;
143                 param_len = sizeof ( pxenv_any.get_cached_info );
144                 break;
145         case PXENV_RESTART_TFTP:
146                 pxenv_call.restart_tftp = pxenv_restart_tftp;
147                 param_len = sizeof ( pxenv_any.restart_tftp );
148                 break;
149         case PXENV_START_UNDI:
150                 pxenv_call.start_undi = pxenv_start_undi;
151                 param_len = sizeof ( pxenv_any.start_undi );
152                 break;
153         case PXENV_STOP_UNDI:
154                 pxenv_call.stop_undi = pxenv_stop_undi;
155                 param_len = sizeof ( pxenv_any.stop_undi );
156                 break;
157         case PXENV_START_BASE:
158                 pxenv_call.start_base = pxenv_start_base;
159                 param_len = sizeof ( pxenv_any.start_base );
160                 break;
161         case PXENV_STOP_BASE:
162                 pxenv_call.stop_base = pxenv_stop_base;
163                 param_len = sizeof ( pxenv_any.stop_base );
164                 break;
165         case PXENV_TFTP_OPEN:
166                 pxenv_call.tftp_open = pxenv_tftp_open;
167                 param_len = sizeof ( pxenv_any.tftp_open );
168                 break;
169         case PXENV_TFTP_CLOSE:
170                 pxenv_call.tftp_close = pxenv_tftp_close;
171                 param_len = sizeof ( pxenv_any.tftp_close );
172                 break;
173         case PXENV_TFTP_READ:
174                 pxenv_call.tftp_read = pxenv_tftp_read;
175                 param_len = sizeof ( pxenv_any.tftp_read );
176                 break;
177         case PXENV_TFTP_READ_FILE:
178                 pxenv_call.tftp_read_file = pxenv_tftp_read_file;
179                 param_len = sizeof ( pxenv_any.tftp_read_file );
180                 break;
181         case PXENV_TFTP_GET_FSIZE:
182                 pxenv_call.tftp_get_fsize = pxenv_tftp_get_fsize;
183                 param_len = sizeof ( pxenv_any.tftp_get_fsize );
184                 break;
185         case PXENV_UDP_OPEN:
186                 pxenv_call.udp_open = pxenv_udp_open;
187                 param_len = sizeof ( pxenv_any.udp_open );
188                 break;
189         case PXENV_UDP_CLOSE:
190                 pxenv_call.udp_close = pxenv_udp_close;
191                 param_len = sizeof ( pxenv_any.udp_close );
192                 break;
193         case PXENV_UDP_WRITE:
194                 pxenv_call.udp_write = pxenv_udp_write;
195                 param_len = sizeof ( pxenv_any.udp_write );
196                 break;
197         case PXENV_UDP_READ:
198                 pxenv_call.udp_read = pxenv_udp_read;
199                 param_len = sizeof ( pxenv_any.udp_read );
200                 break;
201         case PXENV_UNDI_STARTUP:
202                 pxenv_call.undi_startup = pxenv_undi_startup;
203                 param_len = sizeof ( pxenv_any.undi_startup );
204                 break;
205         case PXENV_UNDI_CLEANUP:
206                 pxenv_call.undi_cleanup = pxenv_undi_cleanup;
207                 param_len = sizeof ( pxenv_any.undi_cleanup );
208                 break;
209         case PXENV_UNDI_INITIALIZE:
210                 pxenv_call.undi_initialize = pxenv_undi_initialize;
211                 param_len = sizeof ( pxenv_any.undi_initialize );
212                 break;
213         case PXENV_UNDI_RESET_ADAPTER:
214                 pxenv_call.undi_reset_adapter = pxenv_undi_reset_adapter;
215                 param_len = sizeof ( pxenv_any.undi_reset_adapter );
216                 break;
217         case PXENV_UNDI_SHUTDOWN:
218                 pxenv_call.undi_shutdown = pxenv_undi_shutdown;
219                 param_len = sizeof ( pxenv_any.undi_shutdown );
220                 break;
221         case PXENV_UNDI_OPEN:
222                 pxenv_call.undi_open = pxenv_undi_open;
223                 param_len = sizeof ( pxenv_any.undi_open );
224                 break;
225         case PXENV_UNDI_CLOSE:
226                 pxenv_call.undi_close = pxenv_undi_close;
227                 param_len = sizeof ( pxenv_any.undi_close );
228                 break;
229         case PXENV_UNDI_TRANSMIT:
230                 pxenv_call.undi_transmit = pxenv_undi_transmit;
231                 param_len = sizeof ( pxenv_any.undi_transmit );
232                 break;
233         case PXENV_UNDI_SET_MCAST_ADDRESS:
234                 pxenv_call.undi_set_mcast_address =
235                         pxenv_undi_set_mcast_address;
236                 param_len = sizeof ( pxenv_any.undi_set_mcast_address );
237                 break;
238         case PXENV_UNDI_SET_STATION_ADDRESS:
239                 pxenv_call.undi_set_station_address =
240                         pxenv_undi_set_station_address;
241                 param_len = sizeof ( pxenv_any.undi_set_station_address );
242                 break;
243         case PXENV_UNDI_SET_PACKET_FILTER:
244                 pxenv_call.undi_set_packet_filter =
245                         pxenv_undi_set_packet_filter;
246                 param_len = sizeof ( pxenv_any.undi_set_packet_filter );
247                 break;
248         case PXENV_UNDI_GET_INFORMATION:
249                 pxenv_call.undi_get_information = pxenv_undi_get_information;
250                 param_len = sizeof ( pxenv_any.undi_get_information );
251                 break;
252         case PXENV_UNDI_GET_STATISTICS:
253                 pxenv_call.undi_get_statistics = pxenv_undi_get_statistics;
254                 param_len = sizeof ( pxenv_any.undi_get_statistics );
255                 break;
256         case PXENV_UNDI_CLEAR_STATISTICS:
257                 pxenv_call.undi_clear_statistics = pxenv_undi_clear_statistics;
258                 param_len = sizeof ( pxenv_any.undi_clear_statistics );
259                 break;
260         case PXENV_UNDI_INITIATE_DIAGS:
261                 pxenv_call.undi_initiate_diags = pxenv_undi_initiate_diags;
262                 param_len = sizeof ( pxenv_any.undi_initiate_diags );
263                 break;
264         case PXENV_UNDI_FORCE_INTERRUPT:
265                 pxenv_call.undi_force_interrupt = pxenv_undi_force_interrupt;
266                 param_len = sizeof ( pxenv_any.undi_force_interrupt );
267                 break;
268         case PXENV_UNDI_GET_MCAST_ADDRESS:
269                 pxenv_call.undi_get_mcast_address =
270                         pxenv_undi_get_mcast_address;
271                 param_len = sizeof ( pxenv_any.undi_get_mcast_address );
272                 break;
273         case PXENV_UNDI_GET_NIC_TYPE:
274                 pxenv_call.undi_get_nic_type = pxenv_undi_get_nic_type;
275                 param_len = sizeof ( pxenv_any.undi_get_nic_type );
276                 break;
277         case PXENV_UNDI_GET_IFACE_INFO:
278                 pxenv_call.undi_get_iface_info = pxenv_undi_get_iface_info;
279                 param_len = sizeof ( pxenv_any.undi_get_iface_info );
280                 break;
281         case PXENV_UNDI_ISR:
282                 pxenv_call.undi_isr = pxenv_undi_isr;
283                 param_len = sizeof ( pxenv_any.undi_isr );
284                 break;
285         case PXENV_FILE_OPEN:
286                 pxenv_call.file_open = pxenv_file_open;
287                 param_len = sizeof ( pxenv_any.file_open );
288                 break;
289         case PXENV_FILE_CLOSE:
290                 pxenv_call.file_close = pxenv_file_close;
291                 param_len = sizeof ( pxenv_any.file_close );
292                 break;
293         case PXENV_FILE_SELECT:
294                 pxenv_call.file_select = pxenv_file_select;
295                 param_len = sizeof ( pxenv_any.file_select );
296                 break;
297         case PXENV_FILE_READ:
298                 pxenv_call.file_read = pxenv_file_read;
299                 param_len = sizeof ( pxenv_any.file_read );
300                 break;
301         case PXENV_GET_FILE_SIZE:
302                 pxenv_call.get_file_size = pxenv_get_file_size;
303                 param_len = sizeof ( pxenv_any.get_file_size );
304                 break;
305         case PXENV_FILE_EXEC:
306                 pxenv_call.file_exec = pxenv_file_exec;
307                 param_len = sizeof ( pxenv_any.file_exec );
308                 break;
309         case PXENV_FILE_API_CHECK:
310                 pxenv_call.file_api_check = pxenv_file_api_check;
311                 param_len = sizeof ( pxenv_any.file_api_check );
312                 break;
313         default:
314                 DBG ( "PXENV_UNKNOWN_%hx", opcode );
315                 pxenv_call.unknown = pxenv_unknown;
316                 param_len = sizeof ( pxenv_any.unknown );
317                 break;
318         }
319
320         /* Copy parameter block from caller */
321         copy_from_user ( &pxenv_any, parameters, 0, param_len );
322
323         /* Set default status in case child routine fails to do so */
324         pxenv_any.Status = PXENV_STATUS_FAILURE;
325
326         /* Hand off to relevant API routine */
327         DBG ( "[" );
328         ret = pxenv_call.any ( &pxenv_any );
329         if ( pxenv_any.Status != PXENV_STATUS_SUCCESS ) {
330                 DBG ( " %02x", pxenv_any.Status );
331         }
332         if ( ret != PXENV_EXIT_SUCCESS ) {
333                 DBG ( ret == PXENV_EXIT_FAILURE ? " err" : " ??" );
334         }
335         DBG ( "]" );
336         
337         /* Copy modified parameter block back to caller and return */
338         copy_to_user ( parameters, 0, &pxenv_any, param_len );
339         ix86->regs.ax = ret;
340 }
341
342 /**
343  * Dispatch PXE loader call
344  *
345  * @v es:di             Address of PXE parameter block
346  * @ret ax              PXE exit code
347  */
348 __asmcall void pxe_loader_call ( struct i386_all_regs *ix86 ) {
349         userptr_t uparams = real_to_user ( ix86->segs.es, ix86->regs.di );
350         struct s_UNDI_LOADER params;
351         PXENV_EXIT_t ret;
352
353         /* Copy parameter block from caller */
354         copy_from_user ( &params, uparams, 0, sizeof ( params ) );
355
356         /* Fill in ROM segment address */
357         ppxe.UNDIROMID.segment = ix86->segs.ds;
358
359         /* Set default status in case child routine fails to do so */
360         params.Status = PXENV_STATUS_FAILURE;
361
362         /* Call UNDI loader */
363         ret = undi_loader ( &params );
364
365         /* Copy modified parameter block back to caller and return */
366         copy_to_user ( uparams, 0, &params, sizeof ( params ) );
367         ix86->regs.ax = ret;
368 }
369
370 /**
371  * Calculate byte checksum as used by PXE
372  *
373  * @v data              Data
374  * @v size              Length of data
375  * @ret sum             Checksum
376  */
377 static uint8_t pxe_checksum ( void *data, size_t size ) {
378         uint8_t *bytes = data;
379         uint8_t sum = 0;
380
381         while ( size-- ) {
382                 sum += *bytes++;
383         }
384         return sum;
385 }
386
387 /**
388  * Initialise !PXE and PXENV+ structures
389  *
390  */
391 static void pxe_init_structures ( void ) {
392         uint32_t rm_cs_phys = ( rm_cs << 4 );
393         uint32_t rm_ds_phys = ( rm_ds << 4 );
394
395         /* Fill in missing segment fields */
396         ppxe.EntryPointSP.segment = rm_cs;
397         ppxe.EntryPointESP.segment = rm_cs;
398         ppxe.Stack.segment_address = rm_ds;
399         ppxe.Stack.Physical_address = rm_ds_phys;
400         ppxe.UNDIData.segment_address = rm_ds;
401         ppxe.UNDIData.Physical_address = rm_ds_phys;
402         ppxe.UNDICode.segment_address = rm_cs;
403         ppxe.UNDICode.Physical_address = rm_cs_phys;
404         ppxe.UNDICodeWrite.segment_address = rm_cs;
405         ppxe.UNDICodeWrite.Physical_address = rm_cs_phys;
406         pxenv.RMEntry.segment = rm_cs;
407         pxenv.StackSeg = rm_ds;
408         pxenv.UNDIDataSeg = rm_ds;
409         pxenv.UNDICodeSeg = rm_cs;
410         pxenv.PXEPtr.segment = rm_cs;
411
412         /* Update checksums */
413         ppxe.StructCksum -= pxe_checksum ( &ppxe, sizeof ( ppxe ) );
414         pxenv.Checksum -= pxe_checksum ( &pxenv, sizeof ( pxenv ) );
415 }
416
417 /** PXE structure initialiser */
418 struct init_fn pxe_init_fn __init_fn ( INIT_NORMAL ) = {
419         .initialise = pxe_init_structures,
420 };
421
422 /**
423  * Activate PXE stack
424  *
425  * @v netdev            Net device to use as PXE net device
426  */
427 void pxe_activate ( struct net_device *netdev ) {
428
429         /* Ensure INT 1A is hooked */
430         if ( ! int_1a_hooked ) {
431                 hook_bios_interrupt ( 0x1a, ( unsigned int ) pxe_int_1a,
432                                       &pxe_int_1a_vector );
433                 int_1a_hooked = 1;
434         }
435
436         /* Set PXE network device */
437         pxe_set_netdev ( netdev );
438 }
439
440 /**
441  * Deactivate PXE stack
442  *
443  * @ret rc              Return status code
444  */
445 int pxe_deactivate ( void ) {
446         int rc;
447
448         /* Clear PXE network device */
449         pxe_set_netdev ( NULL );
450
451         /* Ensure INT 1A is unhooked, if possible */
452         if ( int_1a_hooked ) {
453                 if ( ( rc = unhook_bios_interrupt ( 0x1a,
454                                                     (unsigned int) pxe_int_1a,
455                                                     &pxe_int_1a_vector ))!= 0){
456                         DBG ( "Could not unhook INT 1A: %s\n",
457                               strerror ( rc ) );
458                         return rc;
459                 }
460                 int_1a_hooked = 0;
461         }
462
463         return 0;
464 }
465
466 /**
467  * Start PXE NBP at 0000:7c00
468  *
469  * @ret rc              Return status code
470  */
471 int pxe_start_nbp ( void ) {
472         int discard_b, discard_c, discard_d, discard_D;
473         uint16_t rc;
474
475         /* Far call to PXE NBP */
476         __asm__ __volatile__ ( REAL_CODE ( "movw %%cx, %%es\n\t"
477                                            "pushw %%es\n\t"
478                                            "pushw %%di\n\t"
479                                            "sti\n\t"
480                                            "lcall $0, $0x7c00\n\t"
481                                            "addw $4, %%sp\n\t" )
482                                : "=a" ( rc ), "=b" ( discard_b ),
483                                  "=c" ( discard_c ), "=d" ( discard_d ),
484                                  "=D" ( discard_D )
485                                : "a" ( 0 ), "b" ( __from_text16 ( &pxenv ) ),
486                                  "c" ( rm_cs ),
487                                  "d" ( virt_to_phys ( &pxenv ) ),
488                                  "D" ( __from_text16 ( &ppxe ) )
489                                : "esi", "ebp", "memory" );
490
491         return rc;
492 }