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 #include <gpxe/uaccess.h>
  20 #include <registers.h>
  21 #include <biosint.h>
  22 #include <pxe.h>
  23 #include <pxe_call.h>
  24
  25 /** @file
  26  *
  27  * PXE API entry point
  28  */
  29
  30 /** Vector for chaining INT 1A */
  31 extern struct segoff __text16 ( pxe_int_1a_vector );
  32 #define pxe_int_1a_vector __use_text16 ( pxe_int_1a_vector )
  33
  34 /** INT 1A handler */
  35 extern void pxe_int_1a ( void );
  36
  37 /** A function pointer to hold any PXE API call
  38  *
  39  * Used by pxe_api_call() to avoid large swathes of duplicated code.
  40  */
  41 union pxenv_call {
  42         PXENV_EXIT_t ( * any ) ( union u_PXENV_ANY * );
  43         PXENV_EXIT_t ( * unknown ) ( struct s_PXENV_UNKNOWN * );
  44         PXENV_EXIT_t ( * unload_stack ) ( struct s_PXENV_UNLOAD_STACK * );
  45         PXENV_EXIT_t ( * get_cached_info )
  46                         ( struct s_PXENV_GET_CACHED_INFO * );
  47         PXENV_EXIT_t ( * restart_tftp ) ( struct s_PXENV_TFTP_READ_FILE * );
  48         PXENV_EXIT_t ( * start_undi ) ( struct s_PXENV_START_UNDI * );
  49         PXENV_EXIT_t ( * stop_undi ) ( struct s_PXENV_STOP_UNDI * );
  50         PXENV_EXIT_t ( * start_base ) ( struct s_PXENV_START_BASE * );
  51         PXENV_EXIT_t ( * stop_base ) ( struct s_PXENV_STOP_BASE * );
  52         PXENV_EXIT_t ( * tftp_open ) ( struct s_PXENV_TFTP_OPEN * );
  53         PXENV_EXIT_t ( * tftp_close ) ( struct s_PXENV_TFTP_CLOSE * );
  54         PXENV_EXIT_t ( * tftp_read ) ( struct s_PXENV_TFTP_READ * );
  55         PXENV_EXIT_t ( * tftp_read_file ) ( struct s_PXENV_TFTP_READ_FILE * );
  56         PXENV_EXIT_t ( * tftp_get_fsize ) ( struct s_PXENV_TFTP_GET_FSIZE * );
  57         PXENV_EXIT_t ( * udp_open ) ( struct s_PXENV_UDP_OPEN * );
  58         PXENV_EXIT_t ( * udp_close ) ( struct s_PXENV_UDP_CLOSE * );
  59         PXENV_EXIT_t ( * udp_write ) ( struct s_PXENV_UDP_WRITE * );
  60         PXENV_EXIT_t ( * udp_read ) ( struct s_PXENV_UDP_READ * );
  61         PXENV_EXIT_t ( * undi_startup ) ( struct s_PXENV_UNDI_STARTUP * );
  62         PXENV_EXIT_t ( * undi_cleanup ) ( struct s_PXENV_UNDI_CLEANUP * );
  63         PXENV_EXIT_t ( * undi_initialize )
  64                         ( struct s_PXENV_UNDI_INITIALIZE * );
  65         PXENV_EXIT_t ( * undi_reset_adapter ) ( struct s_PXENV_UNDI_RESET * );
  66         PXENV_EXIT_t ( * undi_shutdown ) ( struct s_PXENV_UNDI_SHUTDOWN * );
  67         PXENV_EXIT_t ( * undi_open ) ( struct s_PXENV_UNDI_OPEN * );
  68         PXENV_EXIT_t ( * undi_close ) ( struct s_PXENV_UNDI_CLOSE * );
  69         PXENV_EXIT_t ( * undi_transmit ) ( struct s_PXENV_UNDI_TRANSMIT * );
  70         PXENV_EXIT_t ( * undi_set_mcast_address )
  71                         ( struct s_PXENV_UNDI_SET_MCAST_ADDRESS * );
  72         PXENV_EXIT_t ( * undi_set_station_address )
  73                         ( struct s_PXENV_UNDI_SET_STATION_ADDRESS * );
  74         PXENV_EXIT_t ( * undi_set_packet_filter )
  75                         ( struct s_PXENV_UNDI_SET_PACKET_FILTER * );
  76         PXENV_EXIT_t ( * undi_get_information )
  77                         ( struct s_PXENV_UNDI_GET_INFORMATION * );
  78         PXENV_EXIT_t ( * undi_get_statistics )
  79                         ( struct s_PXENV_UNDI_GET_STATISTICS * );
  80         PXENV_EXIT_t ( * undi_clear_statistics )
  81                         ( struct s_PXENV_UNDI_CLEAR_STATISTICS * );
  82         PXENV_EXIT_t ( * undi_initiate_diags )
  83                         ( struct s_PXENV_UNDI_INITIATE_DIAGS * );
  84         PXENV_EXIT_t ( * undi_force_interrupt )
  85                         ( struct s_PXENV_UNDI_FORCE_INTERRUPT * );
  86         PXENV_EXIT_t ( * undi_get_mcast_address )
  87                         ( struct s_PXENV_UNDI_GET_MCAST_ADDRESS * );
  88         PXENV_EXIT_t ( * undi_get_nic_type )
  89                         ( struct s_PXENV_UNDI_GET_NIC_TYPE * );
  90         PXENV_EXIT_t ( * undi_get_iface_info )
  91                         ( struct s_PXENV_UNDI_GET_IFACE_INFO * );
  92         PXENV_EXIT_t ( * undi_get_state ) ( struct s_PXENV_UNDI_GET_STATE * );
  93         PXENV_EXIT_t ( * undi_isr ) ( struct s_PXENV_UNDI_ISR * );
  94         PXENV_EXIT_t ( * file_open ) ( struct s_PXENV_FILE_OPEN * );
  95         PXENV_EXIT_t ( * file_close ) ( struct s_PXENV_FILE_CLOSE * );
  96         PXENV_EXIT_t ( * file_select ) ( struct s_PXENV_FILE_SELECT * );
  97         PXENV_EXIT_t ( * file_read ) ( struct s_PXENV_FILE_READ * );
  98         PXENV_EXIT_t ( * get_file_size ) ( struct s_PXENV_GET_FILE_SIZE * );
  99 };
 100
 101 /**
 102  * Handle an unknown PXE API call
 103  *
 104  * @v pxenv_unknown                     Pointer to a struct s_PXENV_UNKNOWN
 105  * @ret #PXENV_EXIT_FAILURE             Always
 106  * @err #PXENV_STATUS_UNSUPPORTED       Always
 107  */
 108 static PXENV_EXIT_t pxenv_unknown ( struct s_PXENV_UNKNOWN *pxenv_unknown ) {
 109         pxenv_unknown->Status = PXENV_STATUS_UNSUPPORTED;
 110         return PXENV_EXIT_FAILURE;
 111 }
 112
 113 /**
 114  * Dispatch PXE API call
 115  *
 116  * @v bx                PXE opcode
 117  * @v es:di             Address of PXE parameter block
 118  * @ret ax              PXE exit code
 119  */
 120 __cdecl void pxe_api_call ( struct i386_all_regs *ix86 ) {
 121         int opcode = ix86->regs.bx;
 122         userptr_t parameters = real_to_user ( ix86->segs.es, ix86->regs.di );
 123         size_t param_len;
 124         union u_PXENV_ANY pxenv_any;
 125         union pxenv_call pxenv_call;
 126         PXENV_EXIT_t ret;
 127
 128         switch ( opcode ) {
 129         case PXENV_UNLOAD_STACK:
 130                 pxenv_call.unload_stack = pxenv_unload_stack;
 131                 param_len = sizeof ( pxenv_any.unload_stack );
 132                 break;
 133         case PXENV_GET_CACHED_INFO:
 134                 pxenv_call.get_cached_info = pxenv_get_cached_info;
 135                 param_len = sizeof ( pxenv_any.get_cached_info );
 136                 break;
 137         case PXENV_RESTART_TFTP:
 138                 pxenv_call.restart_tftp = pxenv_restart_tftp;
 139                 param_len = sizeof ( pxenv_any.restart_tftp );
 140                 break;
 141         case PXENV_START_UNDI:
 142                 pxenv_call.start_undi = pxenv_start_undi;
 143                 param_len = sizeof ( pxenv_any.start_undi );
 144                 break;
 145         case PXENV_STOP_UNDI:
 146                 pxenv_call.stop_undi = pxenv_stop_undi;
 147                 param_len = sizeof ( pxenv_any.stop_undi );
 148                 break;
 149         case PXENV_START_BASE:
 150                 pxenv_call.start_base = pxenv_start_base;
 151                 param_len = sizeof ( pxenv_any.start_base );
 152                 break;
 153         case PXENV_STOP_BASE:
 154                 pxenv_call.stop_base = pxenv_stop_base;
 155                 param_len = sizeof ( pxenv_any.stop_base );
 156                 break;
 157         case PXENV_TFTP_OPEN:
 158                 pxenv_call.tftp_open = pxenv_tftp_open;
 159                 param_len = sizeof ( pxenv_any.tftp_open );
 160                 break;
 161         case PXENV_TFTP_CLOSE:
 162                 pxenv_call.tftp_close = pxenv_tftp_close;
 163                 param_len = sizeof ( pxenv_any.tftp_close );
 164                 break;
 165         case PXENV_TFTP_READ:
 166                 pxenv_call.tftp_read = pxenv_tftp_read;
 167                 param_len = sizeof ( pxenv_any.tftp_read );
 168                 break;
 169         case PXENV_TFTP_READ_FILE:
 170                 pxenv_call.tftp_read_file = pxenv_tftp_read_file;
 171                 param_len = sizeof ( pxenv_any.tftp_read_file );
 172                 break;
 173         case PXENV_TFTP_GET_FSIZE:
 174                 pxenv_call.tftp_get_fsize = pxenv_tftp_get_fsize;
 175                 param_len = sizeof ( pxenv_any.tftp_get_fsize );
 176                 break;
 177         case PXENV_UDP_OPEN:
 178                 pxenv_call.udp_open = pxenv_udp_open;
 179                 param_len = sizeof ( pxenv_any.udp_open );
 180                 break;
 181         case PXENV_UDP_CLOSE:
 182                 pxenv_call.udp_close = pxenv_udp_close;
 183                 param_len = sizeof ( pxenv_any.udp_close );
 184                 break;
 185         case PXENV_UDP_WRITE:
 186                 pxenv_call.udp_write = pxenv_udp_write;
 187                 param_len = sizeof ( pxenv_any.udp_write );
 188                 break;
 189         case PXENV_UDP_READ:
 190                 pxenv_call.udp_read = pxenv_udp_read;
 191                 param_len = sizeof ( pxenv_any.udp_read );
 192                 break;
 193         case PXENV_UNDI_STARTUP:
 194                 pxenv_call.undi_startup = pxenv_undi_startup;
 195                 param_len = sizeof ( pxenv_any.undi_startup );
 196                 break;
 197         case PXENV_UNDI_CLEANUP:
 198                 pxenv_call.undi_cleanup = pxenv_undi_cleanup;
 199                 param_len = sizeof ( pxenv_any.undi_cleanup );
 200                 break;
 201         case PXENV_UNDI_INITIALIZE:
 202                 pxenv_call.undi_initialize = pxenv_undi_initialize;
 203                 param_len = sizeof ( pxenv_any.undi_initialize );
 204                 break;
 205         case PXENV_UNDI_RESET_ADAPTER:
 206                 pxenv_call.undi_reset_adapter = pxenv_undi_reset_adapter;
 207                 param_len = sizeof ( pxenv_any.undi_reset_adapter );
 208                 break;
 209         case PXENV_UNDI_SHUTDOWN:
 210                 pxenv_call.undi_shutdown = pxenv_undi_shutdown;
 211                 param_len = sizeof ( pxenv_any.undi_shutdown );
 212                 break;
 213         case PXENV_UNDI_OPEN:
 214                 pxenv_call.undi_open = pxenv_undi_open;
 215                 param_len = sizeof ( pxenv_any.undi_open );
 216                 break;
 217         case PXENV_UNDI_CLOSE:
 218                 pxenv_call.undi_close = pxenv_undi_close;
 219                 param_len = sizeof ( pxenv_any.undi_close );
 220                 break;
 221         case PXENV_UNDI_TRANSMIT:
 222                 pxenv_call.undi_transmit = pxenv_undi_transmit;
 223                 param_len = sizeof ( pxenv_any.undi_transmit );
 224                 break;
 225         case PXENV_UNDI_SET_MCAST_ADDRESS:
 226                 pxenv_call.undi_set_mcast_address =
 227                         pxenv_undi_set_mcast_address;
 228                 param_len = sizeof ( pxenv_any.undi_set_mcast_address );
 229                 break;
 230         case PXENV_UNDI_SET_STATION_ADDRESS:
 231                 pxenv_call.undi_set_station_address =
 232                         pxenv_undi_set_station_address;
 233                 param_len = sizeof ( pxenv_any.undi_set_station_address );
 234                 break;
 235         case PXENV_UNDI_SET_PACKET_FILTER:
 236                 pxenv_call.undi_set_packet_filter =
 237                         pxenv_undi_set_packet_filter;
 238                 param_len = sizeof ( pxenv_any.undi_set_packet_filter );
 239                 break;
 240         case PXENV_UNDI_GET_INFORMATION:
 241                 pxenv_call.undi_get_information = pxenv_undi_get_information;
 242                 param_len = sizeof ( pxenv_any.undi_get_information );
 243                 break;
 244         case PXENV_UNDI_GET_STATISTICS:
 245                 pxenv_call.undi_get_statistics = pxenv_undi_get_statistics;
 246                 param_len = sizeof ( pxenv_any.undi_get_statistics );
 247                 break;
 248         case PXENV_UNDI_CLEAR_STATISTICS:
 249                 pxenv_call.undi_clear_statistics = pxenv_undi_clear_statistics;
 250                 param_len = sizeof ( pxenv_any.undi_clear_statistics );
 251                 break;
 252         case PXENV_UNDI_INITIATE_DIAGS:
 253                 pxenv_call.undi_initiate_diags = pxenv_undi_initiate_diags;
 254                 param_len = sizeof ( pxenv_any.undi_initiate_diags );
 255                 break;
 256         case PXENV_UNDI_FORCE_INTERRUPT:
 257                 pxenv_call.undi_force_interrupt = pxenv_undi_force_interrupt;
 258                 param_len = sizeof ( pxenv_any.undi_force_interrupt );
 259                 break;
 260         case PXENV_UNDI_GET_MCAST_ADDRESS:
 261                 pxenv_call.undi_get_mcast_address =
 262                         pxenv_undi_get_mcast_address;
 263                 param_len = sizeof ( pxenv_any.undi_get_mcast_address );
 264                 break;
 265         case PXENV_UNDI_GET_NIC_TYPE:
 266                 pxenv_call.undi_get_nic_type = pxenv_undi_get_nic_type;
 267                 param_len = sizeof ( pxenv_any.undi_get_nic_type );
 268                 break;
 269         case PXENV_UNDI_GET_IFACE_INFO:
 270                 pxenv_call.undi_get_iface_info = pxenv_undi_get_iface_info;
 271                 param_len = sizeof ( pxenv_any.undi_get_iface_info );
 272                 break;
 273         case PXENV_UNDI_ISR:
 274                 pxenv_call.undi_isr = pxenv_undi_isr;
 275                 param_len = sizeof ( pxenv_any.undi_isr );
 276                 break;
 277         case PXENV_FILE_OPEN:
 278                 pxenv_call.file_open = pxenv_file_open;
 279                 param_len = sizeof ( pxenv_any.file_open );
 280                 break;
 281         case PXENV_FILE_CLOSE:
 282                 pxenv_call.file_close = pxenv_file_close;
 283                 param_len = sizeof ( pxenv_any.file_close );
 284                 break;
 285         case PXENV_FILE_SELECT:
 286                 pxenv_call.file_select = pxenv_file_select;
 287                 param_len = sizeof ( pxenv_any.file_select );
 288                 break;
 289         case PXENV_FILE_READ:
 290                 pxenv_call.file_read = pxenv_file_read;
 291                 param_len = sizeof ( pxenv_any.file_read );
 292                 break;
 293         case PXENV_GET_FILE_SIZE:
 294                 pxenv_call.get_file_size = pxenv_get_file_size;
 295                 param_len = sizeof ( pxenv_any.get_file_size );
 296                 break;
 297         default:
 298                 DBG ( "PXENV_UNKNOWN_%hx", opcode );
 299                 pxenv_call.unknown = pxenv_unknown;
 300                 param_len = sizeof ( pxenv_any.unknown );
 301                 break;
 302         }
 303
 304         /* Copy parameter block from caller */
 305         copy_from_user ( &pxenv_any, parameters, 0, param_len );
 306
 307         /* Set default status in case child routine fails to do so */
 308         pxenv_any.Status = PXENV_STATUS_FAILURE;
 309
 310         /* Hand off to relevant API routine */
 311         DBG ( "[" );
 312         ret = pxenv_call.any ( &pxenv_any );
 313         if ( pxenv_any.Status != PXENV_STATUS_SUCCESS ) {
 314                 DBG ( " %02x", pxenv_any.Status );
 315         }
 316         if ( ret != PXENV_EXIT_SUCCESS ) {
 317                 DBG ( ret == PXENV_EXIT_FAILURE ? " err" : " ??" );
 318         }
 319         DBG ( "]" );
 320
 321         /* Copy modified parameter block back to caller and return */
 322         copy_to_user ( parameters, 0, &pxenv_any, param_len );
 323         ix86->regs.ax = ret;
 324 }
 325
 326 /**
 327  * Dispatch PXE loader call
 328  *
 329  * @v es:di             Address of PXE parameter block
 330  * @ret ax              PXE exit code
 331  */
 332 __cdecl void pxe_loader_call ( struct i386_all_regs *ix86 ) {
 333         userptr_t uparams = real_to_user ( ix86->segs.es, ix86->regs.di );
 334         struct s_UNDI_LOADER params;
 335         PXENV_EXIT_t ret;
 336
 337         /* Copy parameter block from caller */
 338         copy_from_user ( &params, uparams, 0, sizeof ( params ) );
 339
 340         /* Set default status in case child routine fails to do so */
 341         params.Status = PXENV_STATUS_FAILURE;
 342
 343         /* Call UNDI loader */
 344         ret = undi_loader ( &params );
 345
 346         /* Copy modified parameter block back to caller and return */
 347         copy_to_user ( uparams, 0, &params, sizeof ( params ) );
 348         ix86->regs.ax = ret;
 349 }
 350
 351 /**
 352  * Hook INT 1A for PXE
 353  *
 354  */
 355 void pxe_hook_int1a ( void ) {
 356         hook_bios_interrupt ( 0x1a, ( unsigned int ) pxe_int_1a,
 357                               &pxe_int_1a_vector );
 358 }
 359
 360 /**
 361  * Unhook INT 1A for PXE
 362  *
 363  * @ret rc              Return status code
 364  */
 365 int pxe_unhook_int1a ( void ) {
 366         return unhook_bios_interrupt ( 0x1a, ( unsigned int ) pxe_int_1a,
 367                                        &pxe_int_1a_vector );
 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 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 /**
 418  * Start PXE NBP at 0000:7c00
 419  *
 420  * @ret rc              Return status code
 421  */
 422 int pxe_start_nbp ( void ) {
 423         int discard_b, discard_c;
 424         uint16_t rc;
 425
 426         /* Far call to PXE NBP */
 427         __asm__ __volatile__ ( REAL_CODE ( "pushw %%cx\n\t"
 428                                            "pushw %%ax\n\t"
 429                                            "movw %%cx, %%es\n\t"
 430                                            "lcall $0, $0x7c00\n\t"
 431                                            "addw $4, %%sp\n\t" )
 432                                : "=a" ( rc ), "=b" ( discard_b ),
 433                                  "=c" ( discard_c )
 434                                :  "a" ( & __from_text16 ( ppxe ) ),
 435                                   "b" ( & __from_text16 ( pxenv ) ),
 436                                   "c" ( rm_cs )
 437                                : "edx", "esi", "edi", "ebp", "memory" );
 438
 439         return rc;
 440 }