1 /*-
2 * Copyright (c) 2005-2008 Pawel Jakub Dawidek <pjd@FreeBSD.org>
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 AUTHORS 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 AUTHORS 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/param.h>
28 #include <sys/systm.h>
29 #include <sys/kernel.h>
30 #include <sys/module.h>
31 #include <sys/lock.h>
32 #include <sys/rwlock.h>
33 #include <sys/malloc.h>
34 #include <sys/libkern.h>
35 #if defined(__amd64__) || defined(__i386__)
36 #include <machine/cpufunc.h>
37 #include <machine/cputypes.h>
38 #include <machine/fpu.h>
39 #include <machine/md_var.h>
40 #include <machine/specialreg.h>
41 #endif
42
43 #include <opencrypto/cryptodev.h>
44
45 #include <crypto/via/padlock.h>
46
47 #include <sys/kobj.h>
48 #include <sys/bus.h>
49 #include "cryptodev_if.h"
50
51 /*
52 * Technical documentation about the PadLock engine can be found here:
53 *
54 * http://www.via.com.tw/en/downloads/whitepapers/initiatives/padlock/programming_guide.pdf
55 */
56
57 struct padlock_softc {
58 int32_t sc_cid;
59 };
60
61 static int padlock_probesession(device_t, const struct crypto_session_params *);
62 static int padlock_newsession(device_t, crypto_session_t cses,
63 const struct crypto_session_params *);
64 static void padlock_freesession(device_t, crypto_session_t cses);
65 static void padlock_freesession_one(struct padlock_session *ses);
66 static int padlock_process(device_t, struct cryptop *crp, int hint __unused);
67
68 MALLOC_DEFINE(M_PADLOCK, "padlock_data", "PadLock Data");
69
70 static void
padlock_identify(driver_t * drv,device_t parent)71 padlock_identify(driver_t *drv, device_t parent)
72 {
73 /* NB: order 10 is so we get attached after h/w devices */
74 if (device_find_child(parent, "padlock", -1) == NULL &&
75 BUS_ADD_CHILD(parent, 10, "padlock", -1) == 0)
76 panic("padlock: could not attach");
77 }
78
79 static int
padlock_probe(device_t dev)80 padlock_probe(device_t dev)
81 {
82 char capp[256];
83
84 #if defined(__amd64__) || defined(__i386__)
85 /* If there is no AES support, we has nothing to do here. */
86 if (!(via_feature_xcrypt & VIA_HAS_AES)) {
87 device_printf(dev, "No ACE support.\n");
88 return (EINVAL);
89 }
90 strlcpy(capp, "AES-CBC", sizeof(capp));
91 #if 0
92 strlcat(capp, ",AES-EBC", sizeof(capp));
93 strlcat(capp, ",AES-CFB", sizeof(capp));
94 strlcat(capp, ",AES-OFB", sizeof(capp));
95 #endif
96 if (via_feature_xcrypt & VIA_HAS_SHA) {
97 strlcat(capp, ",SHA1", sizeof(capp));
98 strlcat(capp, ",SHA256", sizeof(capp));
99 }
100 #if 0
101 if (via_feature_xcrypt & VIA_HAS_AESCTR)
102 strlcat(capp, ",AES-CTR", sizeof(capp));
103 if (via_feature_xcrypt & VIA_HAS_MM)
104 strlcat(capp, ",RSA", sizeof(capp));
105 #endif
106 device_set_desc_copy(dev, capp);
107 return (0);
108 #else
109 return (EINVAL);
110 #endif
111 }
112
113 static int
padlock_attach(device_t dev)114 padlock_attach(device_t dev)
115 {
116 struct padlock_softc *sc = device_get_softc(dev);
117
118 sc->sc_cid = crypto_get_driverid(dev, sizeof(struct padlock_session),
119 CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_SYNC |
120 CRYPTOCAP_F_ACCEL_SOFTWARE);
121 if (sc->sc_cid < 0) {
122 device_printf(dev, "Could not get crypto driver id.\n");
123 return (ENOMEM);
124 }
125
126 return (0);
127 }
128
129 static int
padlock_detach(device_t dev)130 padlock_detach(device_t dev)
131 {
132 struct padlock_softc *sc = device_get_softc(dev);
133
134 crypto_unregister_all(sc->sc_cid);
135 return (0);
136 }
137
138 static int
padlock_probesession(device_t dev,const struct crypto_session_params * csp)139 padlock_probesession(device_t dev, const struct crypto_session_params *csp)
140 {
141
142 if (csp->csp_flags != 0)
143 return (EINVAL);
144
145 /*
146 * We only support HMAC algorithms to be able to work with
147 * ipsec(4), so if we are asked only for authentication without
148 * encryption, don't pretend we can accelerate it.
149 *
150 * XXX: For CPUs with SHA instructions we should probably
151 * permit CSP_MODE_DIGEST so that those can be tested.
152 */
153 switch (csp->csp_mode) {
154 case CSP_MODE_ETA:
155 if (!padlock_hash_check(csp))
156 return (EINVAL);
157 /* FALLTHROUGH */
158 case CSP_MODE_CIPHER:
159 switch (csp->csp_cipher_alg) {
160 case CRYPTO_AES_CBC:
161 if (csp->csp_ivlen != AES_BLOCK_LEN)
162 return (EINVAL);
163 break;
164 default:
165 return (EINVAL);
166 }
167 break;
168 default:
169 return (EINVAL);
170 }
171
172 return (CRYPTODEV_PROBE_ACCEL_SOFTWARE);
173 }
174
175 static int
padlock_newsession(device_t dev,crypto_session_t cses,const struct crypto_session_params * csp)176 padlock_newsession(device_t dev, crypto_session_t cses,
177 const struct crypto_session_params *csp)
178 {
179 struct padlock_session *ses;
180 struct thread *td;
181 int error;
182
183 ses = crypto_get_driver_session(cses);
184
185 error = padlock_cipher_setup(ses, csp);
186 if (error != 0) {
187 padlock_freesession_one(ses);
188 return (error);
189 }
190
191 if (csp->csp_mode == CSP_MODE_ETA) {
192 td = curthread;
193 fpu_kern_enter(td, NULL, FPU_KERN_NORMAL | FPU_KERN_NOCTX);
194 error = padlock_hash_setup(ses, csp);
195 fpu_kern_leave(td, NULL);
196 if (error != 0) {
197 padlock_freesession_one(ses);
198 return (error);
199 }
200 }
201
202 return (0);
203 }
204
205 static void
padlock_freesession_one(struct padlock_session * ses)206 padlock_freesession_one(struct padlock_session *ses)
207 {
208
209 padlock_hash_free(ses);
210 }
211
212 static void
padlock_freesession(device_t dev,crypto_session_t cses)213 padlock_freesession(device_t dev, crypto_session_t cses)
214 {
215 struct padlock_session *ses;
216
217 ses = crypto_get_driver_session(cses);
218 padlock_freesession_one(ses);
219 }
220
221 static int
padlock_process(device_t dev,struct cryptop * crp,int hint __unused)222 padlock_process(device_t dev, struct cryptop *crp, int hint __unused)
223 {
224 const struct crypto_session_params *csp;
225 struct padlock_session *ses;
226 int error;
227
228 if ((crp->crp_payload_length % AES_BLOCK_LEN) != 0) {
229 error = EINVAL;
230 goto out;
231 }
232
233 ses = crypto_get_driver_session(crp->crp_session);
234 csp = crypto_get_params(crp->crp_session);
235
236 /* Perform data authentication if requested before decryption. */
237 if (csp->csp_mode == CSP_MODE_ETA &&
238 !CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
239 error = padlock_hash_process(ses, crp, csp);
240 if (error != 0)
241 goto out;
242 }
243
244 error = padlock_cipher_process(ses, crp, csp);
245 if (error != 0)
246 goto out;
247
248 /* Perform data authentication if requested after encryption. */
249 if (csp->csp_mode == CSP_MODE_ETA &&
250 CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) {
251 error = padlock_hash_process(ses, crp, csp);
252 if (error != 0)
253 goto out;
254 }
255
256 out:
257 #if 0
258 /*
259 * This code is not necessary, because contexts will be freed on next
260 * padlock_setup_mackey() call or at padlock_freesession() call.
261 */
262 if (ses != NULL && maccrd != NULL &&
263 (maccrd->crd_flags & CRD_F_KEY_EXPLICIT) != 0) {
264 padlock_free_ctx(ses->ses_axf, ses->ses_ictx);
265 padlock_free_ctx(ses->ses_axf, ses->ses_octx);
266 }
267 #endif
268 crp->crp_etype = error;
269 crypto_done(crp);
270 return (0);
271 }
272
273 static device_method_t padlock_methods[] = {
274 DEVMETHOD(device_identify, padlock_identify),
275 DEVMETHOD(device_probe, padlock_probe),
276 DEVMETHOD(device_attach, padlock_attach),
277 DEVMETHOD(device_detach, padlock_detach),
278
279 DEVMETHOD(cryptodev_probesession, padlock_probesession),
280 DEVMETHOD(cryptodev_newsession, padlock_newsession),
281 DEVMETHOD(cryptodev_freesession,padlock_freesession),
282 DEVMETHOD(cryptodev_process, padlock_process),
283
284 {0, 0},
285 };
286
287 static driver_t padlock_driver = {
288 "padlock",
289 padlock_methods,
290 sizeof(struct padlock_softc),
291 };
292
293 /* XXX where to attach */
294 DRIVER_MODULE(padlock, nexus, padlock_driver, 0, 0);
295 MODULE_VERSION(padlock, 1);
296 MODULE_DEPEND(padlock, crypto, 1, 1, 1);
297