2 * Copyright (c) 2005, Sam Leffler <sam@errno.com>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/malloc.h>
33 #include <sys/queue.h>
34 #include <sys/taskqueue.h>
35 #include <sys/systm.h>
37 #include <sys/mutex.h>
38 #include <sys/errno.h>
39 #include <sys/linker.h>
40 #include <sys/firmware.h>
43 #include <sys/module.h>
45 #define FIRMWARE_MAX 30
46 static struct firmware firmware_table[FIRMWARE_MAX];
47 struct task firmware_task;
48 struct mtx firmware_mtx;
49 MTX_SYSINIT(firmware, &firmware_mtx, "firmware table", MTX_DEF);
52 * Register a firmware image with the specified name. The
53 * image name must not already be registered. If this is a
54 * subimage then parent refers to a previously registered
55 * image that this should be associated with.
58 firmware_register(const char *imagename, const void *data, size_t datasize,
59 unsigned int version, struct firmware *parent)
61 struct firmware *frp = NULL;
64 mtx_lock(&firmware_mtx);
65 for (i = 0; i < FIRMWARE_MAX; i++) {
66 struct firmware *fp = &firmware_table[i];
68 if (fp->name == NULL) {
73 if (strcasecmp(imagename, fp->name) == 0) {
74 mtx_unlock(&firmware_mtx);
75 printf("%s: image %s already registered!\n",
81 mtx_unlock(&firmware_mtx);
82 printf("%s: cannot register image %s, firmware table full!\n",
86 frp->name = imagename;
88 frp->datasize = datasize;
89 frp->version = version;
96 mtx_unlock(&firmware_mtx);
99 printf("firmware: '%s' version %u: %zu bytes loaded at %p\n",
100 imagename, version, datasize, data);
106 clearentry(struct firmware *fp)
108 KASSERT(fp->refcnt == 0, ("image %s refcnt %u", fp->name, fp->refcnt));
115 if (fp->parent != NULL) { /* release parent reference */
116 fp->parent->refcnt--;
121 static struct firmware *
122 lookup(const char *name)
127 for (i = 0; i < FIRMWARE_MAX; i++) {
128 fp = &firmware_table[i];
129 if (fp->name != NULL && strcasecmp(name, fp->name) == 0)
136 * Unregister/remove a firmware image. If there are outstanding
137 * references an error is returned and the image is not removed
141 firmware_unregister(const char *imagename)
146 mtx_lock(&firmware_mtx);
148 * NB: it is ok for the lookup to fail; this can happen
149 * when a module is unloaded on last reference and the
150 * module unload handler unregister's each of it's
153 fp = lookup(imagename);
159 mtx_unlock(&firmware_mtx);
160 return (refcnt != 0 ? EBUSY : 0);
164 * Lookup and potentially load the specified firmware image.
165 * If the firmware is not found in the registry attempt to
166 * load a kernel module with the image name. If the firmware
167 * is located a reference is returned. The caller must release
168 * this reference for the image to be eligible for removal/unload.
171 firmware_get(const char *imagename)
175 linker_file_t result;
176 int requested_load = 0;
179 mtx_lock(&firmware_mtx);
180 fp = lookup(imagename);
185 mtx_unlock(&firmware_mtx);
189 * Image not present, try to load the module holding it
190 * or if we already tried give up.
192 mtx_unlock(&firmware_mtx);
193 if (requested_load) {
194 printf("%s: failed to load firmware image %s\n",
195 __func__, imagename);
196 (void) linker_release_module(imagename, NULL, NULL);
200 if (priv_check(td, PRIV_FIRMWARE_LOAD) != 0 ||
201 securelevel_gt(td->td_ucred, 0) != 0) {
202 printf("%s: insufficient privileges to "
203 "load firmware image %s\n", __func__, imagename);
206 (void) linker_reference_module(imagename, NULL, &result);
208 goto again; /* sort of an Algol-style for loop */
212 unloadentry(void *unused1, int unused2)
218 mtx_lock(&firmware_mtx);
220 /* Look for an unwanted entry that we explicitly loaded. */
221 for (i = 0; i < FIRMWARE_MAX; i++) {
222 fp = &firmware_table[i];
223 if (fp->name != NULL && fp->file != NULL &&
225 (fp->flags & FIRMWAREFLAG_KEEPKLDREF) == 0)
232 /* No longer explicitly loaded. */
234 mtx_unlock(&firmware_mtx);
236 err = linker_release_module(NULL, NULL, file);
238 mtx_lock(&firmware_mtx);
241 * If linker_release_module() failed then we still
242 * hold a reference on the module so it should not be
243 * possible for it to go away or be re-registered.
245 KASSERT(fp->file == NULL,
246 ("firmware entry reused while referenced!"));
250 mtx_unlock(&firmware_mtx);
254 * Release a reference to a firmware image returned by
255 * firmware_get. The reference is released and if this is
256 * the last reference to the firmware image the associated
257 * module may be released/unloaded.
260 firmware_put(struct firmware *fp, int flags)
262 mtx_lock(&firmware_mtx);
264 if (fp->refcnt == 0) {
265 if ((flags & FIRMWARE_UNLOAD) == 0)
266 fp->flags |= FIRMWAREFLAG_KEEPKLDREF;
269 taskqueue_enqueue(taskqueue_thread, &firmware_task);
270 mtx_unlock(&firmware_mtx);
277 firmware_modevent(module_t mod, int type, void *unused)
284 TASK_INIT(&firmware_task, 0, unloadentry, NULL);
287 for (i = 0; i < FIRMWARE_MAX; i++) {
288 fp = &firmware_table[i];
289 fp->flags &= ~FIRMWAREFLAG_KEEPKLDREF;
291 taskqueue_enqueue(taskqueue_thread, &firmware_task);
292 taskqueue_drain(taskqueue_thread, &firmware_task);
298 static moduledata_t firmware_mod = {
303 DECLARE_MODULE(firmware, firmware_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
304 MODULE_VERSION(firmware, 1);