xref: /freebsd/sys/i386/bios/smapi.c (revision 74bf4e164ba5851606a27d4feff27717452583e5)
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/vm_param.h>
45 #include <vm/pmap.h>
46 #include <machine/md_var.h>
47 #include <machine/pc/bios.h>
48 
49 #include <machine/smapi.h>
50 
51 #define	SMAPI_START	0xf0000
52 #define	SMAPI_STEP	0x10
53 #define	SMAPI_OFF	0
54 #define	SMAPI_LEN	4
55 #define	SMAPI_SIG	"$SMB"
56 
57 #define	RES2HDR(res)	((struct smapi_bios_header *)rman_get_virtual(res))
58 #define	ADDR2HDR(addr)	((struct smapi_bios_header *)BIOS_PADDRTOVADDR(addr))
59 
60 struct smapi_softc {
61 	struct cdev *cdev;
62 	device_t		dev;
63 	struct resource *	res;
64 	int			rid;
65 
66 	u_int32_t		smapi32_entry;
67 
68 	struct smapi_bios_header *header;
69 };
70 
71 extern u_long smapi32_offset;
72 extern u_short smapi32_segment;
73 
74 devclass_t smapi_devclass;
75 
76 static d_ioctl_t smapi_ioctl;
77 
78 static struct cdevsw smapi_cdevsw = {
79 	.d_version =	D_VERSION,
80 	.d_ioctl =	smapi_ioctl,
81 	.d_name =	"smapi",
82 	.d_flags =	D_MEM | D_NEEDGIANT,
83 };
84 
85 static void	smapi_identify		(driver_t *, device_t);
86 static int	smapi_probe		(device_t);
87 static int	smapi_attach		(device_t);
88 static int	smapi_detach            (device_t);
89 static int	smapi_modevent		(module_t, int, void *);
90 
91 static int	smapi_header_cksum	(struct smapi_bios_header *);
92 
93 extern int	smapi32			(struct smapi_bios_parameter *,
94 					 struct smapi_bios_parameter *);
95 extern int	smapi32_new		(u_long, u_short,
96 					 struct smapi_bios_parameter *,
97 					 struct smapi_bios_parameter *);
98 
99 static int
100 smapi_ioctl (dev, cmd, data, fflag, td)
101 	struct cdev *dev;
102 	u_long		cmd;
103 	caddr_t		data;
104 	int		fflag;
105 	d_thread_t *	td;
106 {
107 	struct smapi_softc *sc;
108 	int error;
109 
110 	error = 0;
111 	sc = devclass_get_softc(smapi_devclass, minor(dev));
112         if (sc == NULL) {
113                 error = ENXIO;
114                 goto fail;
115         }
116 
117 	switch (cmd) {
118 	case SMAPIOGHEADER:
119 		bcopy((caddr_t)sc->header, data,
120 				sizeof(struct smapi_bios_header));
121 		error = 0;
122 		break;
123 	case SMAPIOCGFUNCTION:
124 		smapi32_offset = sc->smapi32_entry;
125 		error = smapi32((struct smapi_bios_parameter *)data,
126 				(struct smapi_bios_parameter *)data);
127 		break;
128 	default:
129 		error = ENOTTY;
130 	}
131 
132 fail:
133 	return (error);
134 }
135 
136 static int
137 smapi_header_cksum (struct smapi_bios_header *header)
138 {
139 	u_int8_t *ptr;
140 	u_int8_t cksum;
141 	int i;
142 
143 	ptr = (u_int8_t *)header;
144 	cksum = 0;
145 	for (i = 0; i < header->length; i++) {
146 		cksum += ptr[i];
147 	}
148 
149 	return (cksum);
150 }
151 
152 static void
153 smapi_identify (driver_t *driver, device_t parent)
154 {
155 	device_t child;
156 	u_int32_t addr;
157 	int length;
158 	int rid;
159 
160 	if (!device_is_alive(parent))
161 		return;
162 
163 	addr = bios_sigsearch(SMAPI_START, SMAPI_SIG, SMAPI_LEN,
164                               SMAPI_STEP, SMAPI_OFF);
165 	if (addr != 0) {
166 		rid = 0;
167 		length = ADDR2HDR(addr)->length;
168 
169 		child = BUS_ADD_CHILD(parent, 0, "smapi", -1);
170 		device_set_driver(child, driver);
171 		bus_set_resource(child, SYS_RES_MEMORY, rid, addr, length);
172 		device_set_desc(child, "SMAPI BIOS");
173 	}
174 
175 	return;
176 }
177 
178 static int
179 smapi_probe (device_t dev)
180 {
181 	struct resource *res;
182 	int rid;
183 	int error;
184 
185 	error = 0;
186 	rid = 0;
187 	res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
188 	if (res == NULL) {
189 		device_printf(dev, "Unable to allocate memory resource.\n");
190 		error = ENOMEM;
191 		goto bad;
192 	}
193 
194 	if (smapi_header_cksum(RES2HDR(res))) {
195 		device_printf(dev, "SMAPI header checksum failed.\n");
196 		error = ENXIO;
197 		goto bad;
198 	}
199 
200 bad:
201 	if (res)
202 		bus_release_resource(dev, SYS_RES_MEMORY, rid, res);
203 	return (error);
204 }
205 
206 static int
207 smapi_attach (device_t dev)
208 {
209 	struct smapi_softc *sc;
210 	int error;
211 
212 	sc = device_get_softc(dev);
213 	error = 0;
214 
215 	sc->dev = dev;
216 	sc->rid = 0;
217 	sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->rid,
218 		 RF_ACTIVE);
219 	if (sc->res == NULL) {
220 		device_printf(dev, "Unable to allocate memory resource.\n");
221 		error = ENOMEM;
222 		goto bad;
223 	}
224 	sc->header = (struct smapi_bios_header *)rman_get_virtual(sc->res);
225 	sc->smapi32_entry = (u_int32_t)BIOS_PADDRTOVADDR(
226 					sc->header->prot32_segment +
227 					sc->header->prot32_offset);
228 
229         sc->cdev = make_dev(&smapi_cdevsw,
230 			device_get_unit(sc->dev),
231 			UID_ROOT, GID_WHEEL, 0600,
232 			"%s%d",
233 			smapi_cdevsw.d_name,
234 			device_get_unit(sc->dev));
235 
236 	device_printf(dev, "Version: %d.%02d, Length: %d, Checksum: 0x%02x\n",
237 		bcd2bin(sc->header->version_major),
238 		bcd2bin(sc->header->version_minor),
239 		sc->header->length,
240 		sc->header->checksum);
241 	device_printf(dev, "Information=0x%b\n",
242 		sc->header->information,
243 		"\020"
244 		"\001REAL_VM86"
245 		"\002PROTECTED_16"
246 		"\003PROTECTED_32");
247 
248 	if (bootverbose) {
249 		if (sc->header->information & SMAPI_REAL_VM86)
250 			device_printf(dev, "Real/VM86 mode: Segment 0x%04x, Offset 0x%04x\n",
251 				sc->header->real16_segment,
252 				sc->header->real16_offset);
253 		if (sc->header->information & SMAPI_PROT_16BIT)
254 			device_printf(dev, "16-bit Protected mode: Segment 0x%08x, Offset 0x%04x\n",
255 				sc->header->prot16_segment,
256 				sc->header->prot16_offset);
257 		if (sc->header->information & SMAPI_PROT_32BIT)
258 			device_printf(dev, "32-bit Protected mode: Segment 0x%08x, Offset 0x%08x\n",
259 				sc->header->prot32_segment,
260 				sc->header->prot32_offset);
261 	}
262 
263 	return (0);
264 bad:
265 	if (sc->res)
266 		bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res);
267 	return (error);
268 }
269 
270 static int
271 smapi_detach (device_t dev)
272 {
273 	struct smapi_softc *sc;
274 
275 	sc = device_get_softc(dev);
276 
277 	destroy_dev(sc->cdev);
278 
279 	if (sc->res)
280 		bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res);
281 
282 	return (0);
283 }
284 
285 static int
286 smapi_modevent (mod, what, arg)
287         module_t        mod;
288         int             what;
289         void *          arg;
290 {
291 	device_t *	devs;
292 	int		count;
293 	int		i;
294 
295 	switch (what) {
296 	case MOD_LOAD:
297 		break;
298 	case MOD_UNLOAD:
299 		devclass_get_devices(smapi_devclass, &devs, &count);
300 		for (i = 0; i < count; i++) {
301 			device_delete_child(device_get_parent(devs[i]), devs[i]);
302 		}
303 		break;
304 	default:
305 		break;
306 	}
307 
308 	return (0);
309 }
310 
311 static device_method_t smapi_methods[] = {
312 	/* Device interface */
313 	DEVMETHOD(device_identify,      smapi_identify),
314 	DEVMETHOD(device_probe,         smapi_probe),
315 	DEVMETHOD(device_attach,        smapi_attach),
316 	DEVMETHOD(device_detach,        smapi_detach),
317 	{ 0, 0 }
318 };
319 
320 static driver_t smapi_driver = {
321 	"smapi",
322 	smapi_methods,
323 	sizeof(struct smapi_softc),
324 };
325 
326 DRIVER_MODULE(smapi, nexus, smapi_driver, smapi_devclass, smapi_modevent, 0);
327 MODULE_VERSION(smapi, 1);
328