drm/linux: Port kfifo.h to DragonFly BSD
[dragonfly.git] / sys / dev / misc / efirt / efidev.c
1 /*-
2  * Copyright (c) 2016 Netflix, Inc.
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  *    in this position and unchanged.
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.
14  *
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.
25  *
26  * $FreeBSD: head/sys/dev/efidev/efidev.c 307391 2016-10-16 06:07:43Z kib $
27  */
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/kernel.h>
32 #include <sys/bus.h>
33 #include <sys/conf.h>
34 #include <sys/lock.h>
35 #include <sys/malloc.h>
36 #include <sys/module.h>
37 #include <sys/device.h>
38
39 #include <machine/efi.h>
40 #include <sys/efiio.h>
41
42 static struct lock efidev_lock = LOCK_INITIALIZER("efidev", 0, 0);
43
44 static d_ioctl_t efidev_ioctl;
45 static d_open_t efidev_open;
46 static d_close_t efidev_close;
47
48 static struct dev_ops efi_ops = {
49         { "efi", 0, D_MPSAFE },
50         .d_open = efidev_open,
51         .d_close = efidev_close,
52         .d_ioctl = efidev_ioctl,
53 };
54
55 static int
56 efidev_open(struct dev_open_args *ap)
57 {
58         return 0;
59 }
60
61 static int
62 efidev_close(struct dev_close_args *ap)
63 {
64         return 0;
65 }
66
67 static int
68 efidev_ioctl(struct dev_ioctl_args *ap)
69 {
70         u_long cmd = ap->a_cmd;
71         caddr_t addr = ap->a_data;
72         int error;
73
74         lockmgr(&efidev_lock, LK_EXCLUSIVE);
75
76         switch (cmd) {
77         case EFIIOC_GET_TABLE:
78         {
79                 struct efi_get_table_ioc *egtioc =
80                     (struct efi_get_table_ioc *)addr;
81
82                 error = efi_get_table(&egtioc->uuid, &egtioc->ptr);
83                 break;
84         }
85         case EFIIOC_GET_TIME:
86         {
87                 struct efi_tm *tm = (struct efi_tm *)addr;
88
89                 error = efi_get_time(tm);
90                 break;
91         }
92         case EFIIOC_SET_TIME:
93         {
94                 struct efi_tm *tm = (struct efi_tm *)addr;
95
96                 error = efi_set_time(tm);
97                 break;
98         }
99         case EFIIOC_VAR_GET:
100         {
101                 struct efi_var_ioc *ev = (struct efi_var_ioc *)addr;
102                 void *data;
103                 efi_char *name;
104
105                 data = kmalloc(ev->datasize, M_TEMP, M_WAITOK);
106                 name = kmalloc(ev->namesize, M_TEMP, M_WAITOK);
107                 error = copyin(ev->name, name, ev->namesize);
108                 if (error)
109                         goto vg_out;
110                 if (name[ev->namesize / sizeof(efi_char) - 1] != 0) {
111                         error = EINVAL;
112                         goto vg_out;
113                 }
114
115                 error = efi_var_get(name, &ev->vendor, &ev->attrib,
116                     &ev->datasize, data);
117
118                 if (error == 0) {
119                         error = copyout(data, ev->data, ev->datasize);
120                 } else if (error == EOVERFLOW) {
121                         /*
122                          * Pass back the size we really need, but
123                          * convert the error to 0 so the copyout
124                          * happens. datasize was updated in the
125                          * efi_var_get call.
126                          */
127                         ev->data = NULL;
128                         error = 0;
129                 }
130 vg_out:
131                 kfree(data, M_TEMP);
132                 kfree(name, M_TEMP);
133                 break;
134         }
135         case EFIIOC_VAR_NEXT:
136         {
137                 struct efi_var_ioc *ev = (struct efi_var_ioc *)addr;
138                 efi_char *name;
139
140                 name = kmalloc(ev->namesize, M_TEMP, M_WAITOK);
141                 error = copyin(ev->name, name, ev->namesize);
142                 if (error)
143                         goto vn_out;
144                 /* Note: namesize is the buffer size, not the string lenght */
145
146                 error = efi_var_nextname(&ev->namesize, name, &ev->vendor);
147                 if (error == 0) {
148                         error = copyout(name, ev->name, ev->namesize);
149                 } else if (error == EOVERFLOW) {
150                         ev->name = NULL;
151                         error = 0;
152                 }
153         vn_out:
154                 kfree(name, M_TEMP);
155                 break;
156         }
157         case EFIIOC_VAR_SET:
158         {
159                 struct efi_var_ioc *ev = (struct efi_var_ioc *)addr;
160                 void *data = NULL;
161                 efi_char *name;
162
163                 /* datasize == 0 -> delete (more or less) */
164                 if (ev->datasize > 0)
165                         data = kmalloc(ev->datasize, M_TEMP, M_WAITOK);
166                 name = kmalloc(ev->namesize, M_TEMP, M_WAITOK);
167                 if (ev->datasize) {
168                         error = copyin(ev->data, data, ev->datasize);
169                         if (error)
170                                 goto vs_out;
171                 }
172                 error = copyin(ev->name, name, ev->namesize);
173                 if (error)
174                         goto vs_out;
175                 if (name[ev->namesize / sizeof(efi_char) - 1] != 0) {
176                         error = EINVAL;
177                         goto vs_out;
178                 }
179
180                 error = efi_var_set(name, &ev->vendor, ev->attrib, ev->datasize,
181                     data);
182 vs_out:
183                 kfree(data, M_TEMP);
184                 kfree(name, M_TEMP);
185                 break;
186         }
187         default:
188                 error = ENOTTY;
189                 break;
190         }
191
192         lockmgr(&efidev_lock, LK_RELEASE);
193
194         return (error);
195 }
196
197 static struct cdev *efidev;
198
199 static int
200 efidev_modevents(module_t m, int event, void *arg __unused)
201 {
202         switch (event) {
203         case MOD_LOAD:
204                 efidev = make_dev(&efi_ops, 0, UID_ROOT, GID_WHEEL,
205                                   0700, "efi");
206                 return (0);
207
208         case MOD_UNLOAD:
209                 if (efidev != NULL)
210                         destroy_dev(efidev);
211                 efidev = NULL;
212                 return (0);
213
214         case MOD_SHUTDOWN:
215                 return (0);
216
217         default:
218                 return (EOPNOTSUPP);
219         }
220 }
221
222 static moduledata_t efidev_moddata = {
223         .name = "efidev",
224         .evhand = efidev_modevents,
225         .priv = NULL,
226 };
227
228 DECLARE_MODULE(efidev, efidev_moddata, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY);
229 MODULE_VERSION(efidev, 1);
230 MODULE_DEPEND(efidev, efirt, 1, 1, 1);