src/arch/i386/drivers/bus/pxedrv.c

   1 /*
   2  * Copyright (C) 2007 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 <stdint.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <pxe.h>
  23 #include <realmode.h>
  24 #include <bios.h>
  25
  26 /** @file
  27  *
  28  * PXE drivers
  29  *
  30  */
  31
  32 static LIST_HEAD ( pxe_drivers );
  33
  34 /**
  35  * Parse PXE ROM ID structure
  36  *
  37  * @v pxedrv            PXE driver
  38  * @v pxeromid          Offset within ROM to PXE ROM ID structure
  39  * @ret rc              Return status code
  40  */
  41 static int pxedrv_parse_pxeromid ( struct pxe_driver *pxedrv,
  42                                    unsigned int pxeromid ) {
  43         struct undi_rom_id undi_rom_id;
  44         unsigned int undiloader;
  45
  46         DBGC ( pxedrv, "PXEDRV %p has PXE ROM ID at %04x:%04x\n", pxedrv,
  47                pxedrv->rom_segment, pxeromid );
  48
  49         /* Read PXE ROM ID structure and verify */
  50         copy_from_real ( &undi_rom_id, pxedrv->rom_segment, pxeromid,
  51                          sizeof ( undi_rom_id ) );
  52         if ( undi_rom_id.Signature != UNDI_ROM_ID_SIGNATURE ) {
  53                 DBGC ( pxedrv, "PXEDRV %p has bad PXE ROM ID signature "
  54                        "%08lx\n", pxedrv, undi_rom_id.Signature );
  55                 return -EINVAL;
  56         }
  57
  58         /* Check for UNDI loader */
  59         undiloader = undi_rom_id.UNDILoader;
  60         if ( ! undiloader ) {
  61                 DBGC ( pxedrv, "PXEDRV %p has no UNDI loader\n", pxedrv );
  62                 return -EINVAL;
  63         }
  64
  65         /* Fill in PXE driver loader fields */
  66         pxedrv->loader_entry.segment = pxedrv->rom_segment;
  67         pxedrv->loader_entry.offset = undiloader;
  68         pxedrv->code_size = undi_rom_id.CodeSize;
  69         pxedrv->data_size = undi_rom_id.DataSize;
  70
  71         DBGC ( pxedrv, "PXEDRV %p has UNDI loader at %04x:%04x "
  72                "(code %04x data %04x)\n", pxedrv,
  73                pxedrv->loader_entry.segment, pxedrv->loader_entry.offset,
  74                pxedrv->code_size, pxedrv->data_size );
  75         return 0;
  76 }
  77
  78 /**
  79  * Parse PCI expansion header
  80  *
  81  * @v pxedrv            PXE driver
  82  * @v pcirheader        Offset within ROM to PCI expansion header
  83  */
  84 static int pxedrv_parse_pcirheader ( struct pxe_driver *pxedrv,
  85                                      unsigned int pcirheader ) {
  86         struct pcir_header pcir_header;
  87
  88         DBGC ( pxedrv, "PXEDRV %p has PCI expansion header at %04x:%04x\n",
  89                pxedrv, pxedrv->rom_segment, pcirheader );
  90
  91         /* Read PCI expansion header and verify */
  92         copy_from_real ( &pcir_header, pxedrv->rom_segment, pcirheader,
  93                          sizeof ( pcir_header ) );
  94         if ( pcir_header.signature != PCIR_SIGNATURE ) {
  95                 DBGC ( pxedrv, "PXEDRV %p has bad PCI expansion header "
  96                        "signature %08lx\n", pxedrv, pcir_header.signature );
  97                 return -EINVAL;
  98         }
  99         DBGC ( pxedrv, "PXEDRV %p is a PCI ROM\n", pxedrv );
 100
 101         /* Fill in PXE driver PCI device fields */
 102         pxedrv->bus_type = PCI_NIC;
 103         pxedrv->bus_id.pci.vendor_id = pcir_header.vendor_id;
 104         pxedrv->bus_id.pci.device_id = pcir_header.device_id;
 105
 106         DBGC ( pxedrv, "PXEDRV %p is for PCI devices %04x:%04x\n", pxedrv,
 107                pxedrv->bus_id.pci.vendor_id, pxedrv->bus_id.pci.device_id );
 108         return 0;
 109
 110 }
 111
 112 /**
 113  * Create PXE driver for expansion ROM
 114  *
 115  * @v rom_segment       ROM segment address
 116  * @ret rc              Return status code
 117  */
 118 static int pxedrv_probe_rom ( unsigned int rom_segment ) {
 119         struct pxe_driver *pxedrv = NULL;
 120         struct undi_rom rom;
 121         unsigned int pxeromid;
 122         unsigned int pcirheader;
 123         int rc;
 124
 125         /* Read expansion ROM header and verify */
 126         copy_from_real ( &rom, rom_segment, 0, sizeof ( rom ) );
 127         if ( rom.Signature != ROM_SIGNATURE ) {
 128                 rc = -EINVAL;
 129                 goto err;
 130         }
 131
 132         /* Allocate memory for PXE driver */
 133         pxedrv = malloc ( sizeof ( *pxedrv ) );
 134         if ( ! pxedrv ) {
 135                 DBG ( "Could not allocate PXE driver structure\n" );
 136                 rc = -ENOMEM;
 137                 goto err;
 138         }
 139         memset ( pxedrv, 0, sizeof ( *pxedrv ) );
 140         DBGC ( pxedrv, "PXEDRV %p using expansion ROM at %04x:0000 (%zdkB)\n",
 141                pxedrv, rom_segment, ( rom.ROMLength / 2 ) );
 142         pxedrv->rom_segment = rom_segment;
 143
 144         /* Check for and parse PXE ROM ID */
 145         pxeromid = rom.PXEROMID;
 146         if ( ! pxeromid ) {
 147                 DBGC ( pxedrv, "PXEDRV %p has no PXE ROM ID\n", pxedrv );
 148                 rc = -EINVAL;
 149                 goto err;
 150         }
 151         if ( ( rc = pxedrv_parse_pxeromid ( pxedrv, pxeromid ) ) != 0 )
 152                 goto err;
 153
 154         /* Parse PCIR header, if present */
 155         pcirheader = rom.PCIRHeader;
 156         if ( pcirheader )
 157                 pxedrv_parse_pcirheader ( pxedrv, pcirheader );
 158
 159         /* Add to PXE driver list and return */
 160         DBGC ( pxedrv, "PXEDRV %p registered\n", pxedrv );
 161         list_add ( &pxedrv->list, &pxe_drivers );
 162         return 0;
 163
 164  err:
 165         free ( pxedrv );
 166         return rc;
 167 }
 168
 169 /**
 170  * Create PXE drivers for all possible expansion ROMs
 171  *
 172  * @ret
 173  */
 174 static void pxedrv_probe_all_roms ( void ) {
 175         static int probed = 0;
 176         unsigned int rom_segment;
 177
 178         /* Perform probe only once */
 179         if ( probed )
 180                 return;
 181
 182         DBG ( "Scanning for PXE expansion ROMs\n" );
 183
 184         /* Scan through expansion ROM region at 2kB intervals */
 185         for ( rom_segment = 0xc000 ; rom_segment < 0x10000 ;
 186               rom_segment += 0x80 ) {
 187                 pxedrv_probe_rom ( rom_segment );
 188         }
 189
 190         probed = 1;
 191 }
 192
 193 /**
 194  * Find PXE driver for PCI device
 195  *
 196  * @v vendor_id         PCI vendor ID
 197  * @v device_id         PCI device ID
 198  * @v rombase           ROM base address, or 0 for any
 199  * @ret pxedrv          PXE driver, or NULL
 200  */
 201 struct pxe_driver * pxedrv_find_pci_driver ( unsigned int vendor_id,
 202                                              unsigned int device_id,
 203                                              unsigned int rombase ) {
 204         struct pxe_driver *pxedrv;
 205
 206         pxedrv_probe_all_roms();
 207
 208         list_for_each_entry ( pxedrv, &pxe_drivers, list ) {
 209                 if ( pxedrv->bus_type != PCI_NIC )
 210                         continue;
 211                 if ( pxedrv->bus_id.pci.vendor_id != vendor_id )
 212                         continue;
 213                 if ( pxedrv->bus_id.pci.device_id != device_id )
 214                         continue;
 215                 if ( rombase && ( ( pxedrv->rom_segment << 4 ) != rombase ) )
 216                         continue;
 217                 DBGC ( pxedrv, "PXEDRV %p matched PCI %04x:%04x (%08x)\n",
 218                        pxedrv, vendor_id, device_id, rombase );
 219                 return pxedrv;
 220         }
 221
 222         DBG ( "No PXE driver matched PCI %04x:%04x (%08x)\n",
 223               vendor_id, device_id, rombase );
 224         return NULL;
 225 }
 226
 227 /** Parameter block for calling UNDI loader */
 228 static struct s_UNDI_LOADER __data16 ( undi_loader );
 229 #define undi_loader __use_data16 ( undi_loader )
 230
 231 /** UNDI loader entry point */
 232 static SEGOFF16_t __data16 ( undi_loader_entry );
 233 #define undi_loader_entry __use_data16 ( undi_loader_entry )
 234
 235 /**
 236  * Call UNDI loader to create a pixie
 237  *
 238  * @v pxedrv            PXE driver
 239  * @v pxe               PXE device to be created
 240  * @v pci_busdevfn      PCI bus:dev.fn (PCI devices only), or 0
 241  * @v isapnp_csn        ISAPnP Card Select Number, or -1U
 242  * @v isapnp_read_port  ISAPnP read port, or -1U
 243  * @ret rc              Return status code
 244  */
 245 static int pxedrv_load ( struct pxe_driver *pxedrv, struct pxe_device *pxe,
 246                          unsigned int pci_busdevfn, unsigned int isapnp_csn,
 247                          unsigned int isapnp_read_port ) {
 248         int discard;
 249         uint16_t exit;
 250         uint16_t fbms;
 251         unsigned int fbms_seg;
 252         int rc;
 253
 254         memset ( &undi_loader, 0, sizeof ( undi_loader ) );
 255         undi_loader.AX = pci_busdevfn;
 256         undi_loader.BX = isapnp_csn;
 257         undi_loader.DX = isapnp_read_port;
 258
 259         /* Allocate base memory for PXE stack */
 260         get_real ( fbms, BDA_SEG, BDA_FBMS );
 261         fbms_seg = ( fbms << 6 );
 262         fbms_seg -= ( ( pxedrv->data_size + 0x0f ) >> 4 );
 263         undi_loader.UNDI_DS = fbms_seg;
 264         fbms_seg -= ( ( pxedrv->code_size + 0x0f ) >> 4 );
 265         undi_loader.UNDI_CS = fbms_seg;
 266         DBGC ( pxedrv, "PXEDRV %p loading to CS %04x and DS %04x\n", pxedrv,
 267                undi_loader.UNDI_CS, undi_loader.UNDI_DS );
 268
 269         /* Call loader */
 270         undi_loader_entry = pxedrv->loader_entry;
 271         __asm__ __volatile__ ( REAL_CODE ( "pushw %%ds\n\t"
 272                                            "pushw %w0\n\t"
 273                                            "lcall *%c3\n\t"
 274                                            "addw $4, %%sp\n\t" )
 275                                : "=a" ( exit ), "=r" ( discard )
 276                                : "0" ( & __from_data16 ( undi_loader ) ),
 277                                  "p" ( & __from_data16 ( undi_loader_entry )));
 278         if ( exit != PXENV_EXIT_SUCCESS ) {
 279                 rc = -undi_loader.Status;
 280                 if ( rc == 0 ) /* Paranoia */
 281                         rc = -EIO;
 282                 DBGC ( pxedrv, "PXEDRV %p loader failed: %s\n",
 283                        strerror ( rc ) );
 284                 return rc;
 285         }
 286
 287         /* Update free base memory counter */
 288         fbms = ( fbms_seg >> 6 );
 289         put_real ( fbms, BDA_SEG, BDA_FBMS );
 290
 291         /* Record location of pixie in PXE device structure */
 292         pxe->pxenv = undi_loader.PXENVptr;
 293         pxe->ppxe = undi_loader.PXEptr;
 294         return 0;
 295 }
 296
 297 /**
 298  * Call UNDI loader to create a pixie
 299  *
 300  * @v pxedrv            PXE driver
 301  * @v pxe               PXE device to be created
 302  * @v pci_busdevfn      PCI bus:dev.fn
 303  * @ret rc              Return status code
 304  */
 305 int pxedrv_load_pci ( struct pxe_driver *pxedrv, struct pxe_device *pxe,
 306                       unsigned int bus, unsigned int devfn ) {
 307         return pxedrv_load ( pxedrv, pxe, ( ( bus << 8 ) | devfn ), -1U, -1U );
 308 }