1 /*- 2 * Copyright (c) 2003 Matthew N. Dodd <winter@jurai.net> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/kernel.h> 33 34 #include <sys/module.h> 35 #include <sys/bus.h> 36 #include <sys/conf.h> 37 38 #include <machine/bus.h> 39 #include <machine/resource.h> 40 #include <sys/rman.h> 41 42 /* And all this for BIOS_PADDRTOVADDR() */ 43 #include <vm/vm.h> 44 #include <vm/pmap.h> 45 #include <machine/md_var.h> 46 #include <machine/pc/bios.h> 47 48 #include <machine/smapi.h> 49 50 #define SMAPI_START 0xf0000 51 #define SMAPI_STEP 0x10 52 #define SMAPI_OFF 0 53 #define SMAPI_LEN 4 54 #define SMAPI_SIG "$SMB" 55 56 #define RES2HDR(res) ((struct smapi_bios_header *)rman_get_virtual(res)) 57 #define ADDR2HDR(addr) ((struct smapi_bios_header *)BIOS_PADDRTOVADDR(addr)) 58 59 struct smapi_softc { 60 dev_t cdev; 61 device_t dev; 62 struct resource * res; 63 int rid; 64 65 u_int32_t smapi32_entry; 66 67 struct smapi_bios_header *header; 68 }; 69 70 u_long smapi32_offset; 71 u_short smapi32_segment; 72 #define SMAPI32_SEGMENT 0x18 73 74 devclass_t smapi_devclass; 75 76 static d_ioctl_t smapi_ioctl; 77 78 static struct cdevsw smapi_cdevsw = { 79 .d_open = nullopen, 80 .d_close = nullclose, 81 .d_ioctl = smapi_ioctl, 82 .d_name = "smapi", 83 .d_maj = MAJOR_AUTO, 84 .d_flags = D_MEM, 85 }; 86 87 static void smapi_identify (driver_t *, device_t); 88 static int smapi_probe (device_t); 89 static int smapi_attach (device_t); 90 static int smapi_detach (device_t); 91 static int smapi_modevent (module_t, int, void *); 92 93 static int smapi_header_cksum (struct smapi_bios_header *); 94 95 extern int smapi32 (struct smapi_bios_parameter *, 96 struct smapi_bios_parameter *); 97 extern int smapi32_new (u_long, u_short, 98 struct smapi_bios_parameter *, 99 struct smapi_bios_parameter *); 100 101 static int 102 smapi_ioctl (dev, cmd, data, fflag, td) 103 dev_t dev; 104 u_long cmd; 105 caddr_t data; 106 int fflag; 107 d_thread_t * td; 108 { 109 struct smapi_softc *sc; 110 int error; 111 112 error = 0; 113 sc = devclass_get_softc(smapi_devclass, minor(dev)); 114 if (sc == NULL) { 115 error = ENXIO; 116 goto fail; 117 } 118 119 switch (cmd) { 120 case SMAPIOGHEADER: 121 bcopy((caddr_t)sc->header, data, 122 sizeof(struct smapi_bios_header)); 123 error = 0; 124 break; 125 case SMAPIOCGFUNCTION: 126 #if 1 127 smapi32_segment = SMAPI32_SEGMENT; 128 smapi32_offset = sc->smapi32_entry; 129 error = smapi32( 130 #else 131 error = smapi32_new(sc->smapi32_entry, SMAPI32_SEGMENT, 132 #endif 133 (struct smapi_bios_parameter *)data, 134 (struct smapi_bios_parameter *)data); 135 break; 136 default: 137 error = ENOTTY; 138 } 139 140 fail: 141 return (error); 142 } 143 144 static int 145 smapi_header_cksum (struct smapi_bios_header *header) 146 { 147 u_int8_t *ptr; 148 u_int8_t cksum; 149 int i; 150 151 ptr = (u_int8_t *)header; 152 cksum = 0; 153 for (i = 0; i < header->length; i++) { 154 cksum += ptr[i]; 155 } 156 157 return (cksum); 158 } 159 160 static void 161 smapi_identify (driver_t *driver, device_t parent) 162 { 163 device_t child; 164 u_int32_t addr; 165 int length; 166 int rid; 167 168 if (!device_is_alive(parent)) 169 return; 170 171 addr = bios_sigsearch(SMAPI_START, SMAPI_SIG, SMAPI_LEN, 172 SMAPI_STEP, SMAPI_OFF); 173 if (addr != 0) { 174 rid = 0; 175 length = ADDR2HDR(addr)->length; 176 177 child = BUS_ADD_CHILD(parent, 0, "smapi", -1); 178 device_set_driver(child, driver); 179 bus_set_resource(child, SYS_RES_MEMORY, rid, addr, length); 180 device_set_desc(child, "SMAPI BIOS"); 181 } 182 183 return; 184 } 185 186 static int 187 smapi_probe (device_t dev) 188 { 189 struct resource *res; 190 int rid; 191 int error; 192 193 error = 0; 194 rid = 0; 195 res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 196 0ul, ~0ul, 1, RF_ACTIVE); 197 if (res == NULL) { 198 device_printf(dev, "Unable to allocate memory resource.\n"); 199 error = ENOMEM; 200 goto bad; 201 } 202 203 if (smapi_header_cksum(RES2HDR(res))) { 204 device_printf(dev, "SMAPI header checksum failed.\n"); 205 error = ENXIO; 206 goto bad; 207 } 208 209 bad: 210 if (res) 211 bus_release_resource(dev, SYS_RES_MEMORY, rid, res); 212 return (error); 213 } 214 215 static int 216 smapi_attach (device_t dev) 217 { 218 struct smapi_softc *sc; 219 int error; 220 221 sc = device_get_softc(dev); 222 error = 0; 223 224 sc->dev = dev; 225 sc->rid = 0; 226 sc->res = bus_alloc_resource(dev, SYS_RES_MEMORY, &sc->rid, 227 0ul, ~0ul, 1, RF_ACTIVE); 228 if (sc->res == NULL) { 229 device_printf(dev, "Unable to allocate memory resource.\n"); 230 error = ENOMEM; 231 goto bad; 232 } 233 sc->header = (struct smapi_bios_header *)rman_get_virtual(sc->res); 234 sc->smapi32_entry = (u_int32_t)BIOS_PADDRTOVADDR( 235 sc->header->prot32_segment + 236 sc->header->prot32_offset); 237 238 sc->cdev = make_dev(&smapi_cdevsw, 239 device_get_unit(sc->dev), 240 UID_ROOT, GID_WHEEL, 0600, 241 "%s%d", 242 smapi_cdevsw.d_name, 243 device_get_unit(sc->dev)); 244 245 device_printf(dev, "Version: %d.%02d, Length: %d, Checksum: 0x%02x\n", 246 bcd2bin(sc->header->version_major), 247 bcd2bin(sc->header->version_minor), 248 sc->header->length, 249 sc->header->checksum); 250 device_printf(dev, "Information=0x%b\n", 251 sc->header->information, 252 "\020" 253 "\001REAL_VM86" 254 "\002PROTECTED_16" 255 "\003PROTECTED_32"); 256 257 if (bootverbose) { 258 if (sc->header->information & SMAPI_REAL_VM86) 259 device_printf(dev, "Real/VM86 mode: Segment 0x%04x, Offset 0x%04x\n", 260 sc->header->real16_segment, 261 sc->header->real16_offset); 262 if (sc->header->information & SMAPI_PROT_16BIT) 263 device_printf(dev, "16-bit Protected mode: Segment 0x%08x, Offset 0x%04x\n", 264 sc->header->prot16_segment, 265 sc->header->prot16_offset); 266 if (sc->header->information & SMAPI_PROT_32BIT) 267 device_printf(dev, "32-bit Protected mode: Segment 0x%08x, Offset 0x%08x\n", 268 sc->header->prot32_segment, 269 sc->header->prot32_offset); 270 } 271 272 return (0); 273 bad: 274 if (sc->res) 275 bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res); 276 return (error); 277 } 278 279 static int 280 smapi_detach (device_t dev) 281 { 282 struct smapi_softc *sc; 283 284 sc = device_get_softc(dev); 285 286 destroy_dev(sc->cdev); 287 288 if (sc->res) 289 bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res); 290 291 return (0); 292 } 293 294 static int 295 smapi_modevent (mod, what, arg) 296 module_t mod; 297 int what; 298 void * arg; 299 { 300 device_t * devs; 301 int count; 302 int i; 303 304 switch (what) { 305 case MOD_LOAD: 306 break; 307 case MOD_UNLOAD: 308 devclass_get_devices(smapi_devclass, &devs, &count); 309 for (i = 0; i < count; i++) { 310 device_delete_child(device_get_parent(devs[i]), devs[i]); 311 } 312 break; 313 default: 314 break; 315 } 316 317 return (0); 318 } 319 320 static device_method_t smapi_methods[] = { 321 /* Device interface */ 322 DEVMETHOD(device_identify, smapi_identify), 323 DEVMETHOD(device_probe, smapi_probe), 324 DEVMETHOD(device_attach, smapi_attach), 325 DEVMETHOD(device_detach, smapi_detach), 326 { 0, 0 } 327 }; 328 329 static driver_t smapi_driver = { 330 "smapi", 331 smapi_methods, 332 sizeof(struct smapi_softc), 333 }; 334 335 DRIVER_MODULE(smapi, nexus, smapi_driver, smapi_devclass, smapi_modevent, 0); 336 MODULE_VERSION(smapi, 1); 337