FreeBSD/Linux Kernel Cross Reference
sys/dev/pci/hifn7751.c
1 /* $NetBSD: hifn7751.c,v 1.20.2.1 2004/05/05 15:23:59 tron Exp $ */
2 /* $FreeBSD: hifn7751.c,v 1.5.2.7 2003/10/08 23:52:00 sam Exp $ */
3 /* $OpenBSD: hifn7751.c,v 1.140 2003/08/01 17:55:54 deraadt Exp $ */
4
5 /*
6 * Invertex AEON / Hifn 7751 driver
7 * Copyright (c) 1999 Invertex Inc. All rights reserved.
8 * Copyright (c) 1999 Theo de Raadt
9 * Copyright (c) 2000-2001 Network Security Technologies, Inc.
10 * http://www.netsec.net
11 * Copyright (c) 2003 Hifn Inc.
12 *
13 * This driver is based on a previous driver by Invertex, for which they
14 * requested: Please send any comments, feedback, bug-fixes, or feature
15 * requests to software@invertex.com.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
19 * are met:
20 *
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * 3. The name of the author may not be used to endorse or promote products
27 * derived from this software without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
30 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
31 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
32 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
33 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
34 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
38 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Effort sponsored in part by the Defense Advanced Research Projects
41 * Agency (DARPA) and Air Force Research Laboratory, Air Force
42 * Materiel Command, USAF, under agreement number F30602-01-2-0537.
43 *
44 */
45
46 /*
47 * Driver for various Hifn pre-HIPP encryption processors.
48 */
49
50 #include <sys/cdefs.h>
51 __KERNEL_RCSID(0, "$NetBSD: hifn7751.c,v 1.20.2.1 2004/05/05 15:23:59 tron Exp $");
52
53 #include "rnd.h"
54 #include "opencrypto.h"
55
56 #if NRND == 0 || NOPENCRYPTO == 0
57 #error hifn7751 requires rnd and opencrypto pseudo-devices
58 #endif
59
60
61 #include <sys/param.h>
62 #include <sys/systm.h>
63 #include <sys/proc.h>
64 #include <sys/errno.h>
65 #include <sys/malloc.h>
66 #include <sys/kernel.h>
67 #include <sys/mbuf.h>
68 #include <sys/device.h>
69
70 #include <uvm/uvm_extern.h>
71
72
73 #ifdef __OpenBSD__
74 #include <crypto/crypto.h>
75 #include <dev/rndvar.h>
76 #else
77 #include <opencrypto/cryptodev.h>
78 #include <sys/rnd.h>
79 #endif
80
81 #include <dev/pci/pcireg.h>
82 #include <dev/pci/pcivar.h>
83 #include <dev/pci/pcidevs.h>
84
85 #include <dev/pci/hifn7751reg.h>
86 #include <dev/pci/hifn7751var.h>
87
88 #undef HIFN_DEBUG
89
90 #ifdef __NetBSD__
91 #define HIFN_NO_RNG /* until statistically tested */
92 #define M_DUP_PKTHDR M_COPY_PKTHDR /* XXX */
93 #endif
94
95 #ifdef HIFN_DEBUG
96 extern int hifn_debug; /* patchable */
97 int hifn_debug = 1;
98 #endif
99
100 #ifdef __OpenBSD__
101 #define HAVE_CRYPTO_LZS /* OpenBSD OCF supports CRYPTO_COMP_LZS */
102 #endif
103
104 /*
105 * Prototypes and count for the pci_device structure
106 */
107 #ifdef __OpenBSD__
108 int hifn_probe((struct device *, void *, void *);
109 #else
110 int hifn_probe(struct device *, struct cfdata *, void *);
111 #endif
112 void hifn_attach(struct device *, struct device *, void *);
113
114 CFATTACH_DECL(hifn, sizeof(struct hifn_softc),
115 hifn_probe, hifn_attach, NULL, NULL);
116
117 #ifdef __OpenBSD__
118 struct cfdriver hifn_cd = {
119 0, "hifn", DV_DULL
120 };
121 #endif
122
123 void hifn_reset_board(struct hifn_softc *, int);
124 void hifn_reset_puc(struct hifn_softc *);
125 void hifn_puc_wait(struct hifn_softc *);
126 const char *hifn_enable_crypto(struct hifn_softc *, pcireg_t);
127 void hifn_set_retry(struct hifn_softc *);
128 void hifn_init_dma(struct hifn_softc *);
129 void hifn_init_pci_registers(struct hifn_softc *);
130 int hifn_sramsize(struct hifn_softc *);
131 int hifn_dramsize(struct hifn_softc *);
132 int hifn_ramtype(struct hifn_softc *);
133 void hifn_sessions(struct hifn_softc *);
134 int hifn_intr(void *);
135 u_int hifn_write_command(struct hifn_command *, u_int8_t *);
136 u_int32_t hifn_next_signature(u_int32_t a, u_int cnt);
137 int hifn_newsession(void*, u_int32_t *, struct cryptoini *);
138 int hifn_freesession(void*, u_int64_t);
139 int hifn_process(void*, struct cryptop *, int);
140 void hifn_callback(struct hifn_softc *, struct hifn_command *, u_int8_t *);
141 int hifn_crypto(struct hifn_softc *, struct hifn_command *,
142 struct cryptop*, int);
143 int hifn_readramaddr(struct hifn_softc *, int, u_int8_t *);
144 int hifn_writeramaddr(struct hifn_softc *, int, u_int8_t *);
145 int hifn_dmamap_aligned(bus_dmamap_t);
146 int hifn_dmamap_load_src(struct hifn_softc *, struct hifn_command *);
147 int hifn_dmamap_load_dst(struct hifn_softc *, struct hifn_command *);
148 int hifn_init_pubrng(struct hifn_softc *);
149 #ifndef HIFN_NO_RNG
150 static void hifn_rng(void *);
151 #endif
152 void hifn_tick(void *);
153 void hifn_abort(struct hifn_softc *);
154 void hifn_alloc_slot(struct hifn_softc *, int *, int *, int *, int *);
155 void hifn_write_4(struct hifn_softc *, int, bus_size_t, u_int32_t);
156 u_int32_t hifn_read_4(struct hifn_softc *, int, bus_size_t);
157 #ifdef HAVE_CRYPTO_LZS
158 int hifn_compression(struct hifn_softc *, struct cryptop *,
159 struct hifn_command *);
160 struct mbuf *hifn_mkmbuf_chain(int, struct mbuf *);
161 int hifn_compress_enter(struct hifn_softc *, struct hifn_command *);
162 void hifn_callback_comp(struct hifn_softc *, struct hifn_command *,
163 u_int8_t *);
164 #endif /* HAVE_CRYPTO_LZS */
165
166
167 #ifdef notyet
168 int hifn_compression(struct hifn_softc *, struct cryptop *,
169 struct hifn_command *);
170 struct mbuf *hifn_mkmbuf_chain(int, struct mbuf *);
171 int hifn_compress_enter(struct hifn_softc *, struct hifn_command *);
172 void hifn_callback_comp(struct hifn_softc *, struct hifn_command *,
173 u_int8_t *);
174 #endif
175
176 struct hifn_stats hifnstats;
177
178 static const struct hifn_product {
179 pci_vendor_id_t hifn_vendor;
180 pci_product_id_t hifn_product;
181 int hifn_flags;
182 const char *hifn_name;
183 } hifn_products[] = {
184 { PCI_VENDOR_INVERTEX, PCI_PRODUCT_INVERTEX_AEON,
185 0,
186 "Invertex AEON",
187 },
188
189 { PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7751,
190 0,
191 "Hifn 7751",
192 },
193 { PCI_VENDOR_NETSEC, PCI_PRODUCT_NETSEC_7751,
194 0,
195 "Hifn 7751 (NetSec)"
196 },
197
198 { PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7811,
199 HIFN_IS_7811 | HIFN_HAS_RNG | HIFN_HAS_LEDS | HIFN_NO_BURSTWRITE,
200 "Hifn 7811",
201 },
202
203 { PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7951,
204 HIFN_HAS_RNG | HIFN_HAS_PUBLIC,
205 "Hifn 7951",
206 },
207
208 { PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7955,
209 HIFN_HAS_RNG | HIFN_HAS_PUBLIC | HIFN_IS_7956 | HIFN_HAS_AES,
210 "Hifn 7955",
211 },
212
213 { PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7956,
214 HIFN_HAS_RNG | HIFN_HAS_PUBLIC | HIFN_IS_7956 | HIFN_HAS_AES,
215 "Hifn 7956",
216 },
217
218
219 { 0, 0,
220 0,
221 NULL
222 }
223 };
224
225 static const struct hifn_product *
226 hifn_lookup(const struct pci_attach_args *pa)
227 {
228 const struct hifn_product *hp;
229
230 for (hp = hifn_products; hp->hifn_name != NULL; hp++) {
231 if (PCI_VENDOR(pa->pa_id) == hp->hifn_vendor &&
232 PCI_PRODUCT(pa->pa_id) == hp->hifn_product)
233 return (hp);
234 }
235 return (NULL);
236 }
237
238 int
239 hifn_probe(struct device *parent, struct cfdata *match, void *aux)
240 {
241 struct pci_attach_args *pa = (struct pci_attach_args *) aux;
242
243 if (hifn_lookup(pa) != NULL)
244 return (1);
245
246 return (0);
247 }
248
249 void
250 hifn_attach(struct device *parent, struct device *self, void *aux)
251 {
252 struct hifn_softc *sc = (struct hifn_softc *)self;
253 struct pci_attach_args *pa = aux;
254 const struct hifn_product *hp;
255 pci_chipset_tag_t pc = pa->pa_pc;
256 pci_intr_handle_t ih;
257 const char *intrstr = NULL;
258 const char *hifncap;
259 char rbase;
260 bus_size_t iosize0, iosize1;
261 u_int32_t cmd;
262 u_int16_t ena;
263 bus_dma_segment_t seg;
264 bus_dmamap_t dmamap;
265 int rseg;
266 caddr_t kva;
267
268 hp = hifn_lookup(pa);
269 if (hp == NULL) {
270 printf("\n");
271 panic("hifn_attach: impossible");
272 }
273
274 aprint_naive(": Crypto processor\n");
275 aprint_normal(": %s, rev. %d\n", hp->hifn_name,
276 PCI_REVISION(pa->pa_class));
277
278 sc->sc_pci_pc = pa->pa_pc;
279 sc->sc_pci_tag = pa->pa_tag;
280
281 sc->sc_flags = hp->hifn_flags;
282
283 cmd = pci_conf_read(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
284 cmd |= PCI_COMMAND_MASTER_ENABLE;
285 pci_conf_write(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, cmd);
286
287 if (pci_mapreg_map(pa, HIFN_BAR0, PCI_MAPREG_TYPE_MEM, 0,
288 &sc->sc_st0, &sc->sc_sh0, NULL, &iosize0)) {
289 aprint_error("%s: can't map mem space %d\n",
290 sc->sc_dv.dv_xname, 0);
291 return;
292 }
293
294 if (pci_mapreg_map(pa, HIFN_BAR1, PCI_MAPREG_TYPE_MEM, 0,
295 &sc->sc_st1, &sc->sc_sh1, NULL, &iosize1)) {
296 aprint_error("%s: can't find mem space %d\n",
297 sc->sc_dv.dv_xname, 1);
298 goto fail_io0;
299 }
300
301 hifn_set_retry(sc);
302
303 if (sc->sc_flags & HIFN_NO_BURSTWRITE) {
304 sc->sc_waw_lastgroup = -1;
305 sc->sc_waw_lastreg = 1;
306 }
307
308 sc->sc_dmat = pa->pa_dmat;
309 if (bus_dmamem_alloc(sc->sc_dmat, sizeof(*sc->sc_dma), PAGE_SIZE, 0,
310 &seg, 1, &rseg, BUS_DMA_NOWAIT)) {
311 aprint_error("%s: can't alloc DMA buffer\n",
312 sc->sc_dv.dv_xname);
313 goto fail_io1;
314 }
315 if (bus_dmamem_map(sc->sc_dmat, &seg, rseg, sizeof(*sc->sc_dma), &kva,
316 BUS_DMA_NOWAIT)) {
317 aprint_error("%s: can't map DMA buffers (%lu bytes)\n",
318 sc->sc_dv.dv_xname, (u_long)sizeof(*sc->sc_dma));
319 bus_dmamem_free(sc->sc_dmat, &seg, rseg);
320 goto fail_io1;
321 }
322 if (bus_dmamap_create(sc->sc_dmat, sizeof(*sc->sc_dma), 1,
323 sizeof(*sc->sc_dma), 0, BUS_DMA_NOWAIT, &dmamap)) {
324 aprint_error("%s: can't create DMA map\n",
325 sc->sc_dv.dv_xname);
326 bus_dmamem_unmap(sc->sc_dmat, kva, sizeof(*sc->sc_dma));
327 bus_dmamem_free(sc->sc_dmat, &seg, rseg);
328 goto fail_io1;
329 }
330 if (bus_dmamap_load(sc->sc_dmat, dmamap, kva, sizeof(*sc->sc_dma),
331 NULL, BUS_DMA_NOWAIT)) {
332 aprint_error("%s: can't load DMA map\n",
333 sc->sc_dv.dv_xname);
334 bus_dmamap_destroy(sc->sc_dmat, dmamap);
335 bus_dmamem_unmap(sc->sc_dmat, kva, sizeof(*sc->sc_dma));
336 bus_dmamem_free(sc->sc_dmat, &seg, rseg);
337 goto fail_io1;
338 }
339 sc->sc_dmamap = dmamap;
340 sc->sc_dma = (struct hifn_dma *)kva;
341 bzero(sc->sc_dma, sizeof(*sc->sc_dma));
342
343 hifn_reset_board(sc, 0);
344
345 if ((hifncap = hifn_enable_crypto(sc, pa->pa_id)) == NULL) {
346 aprint_error("%s: crypto enabling failed\n",
347 sc->sc_dv.dv_xname);
348 goto fail_mem;
349 }
350 hifn_reset_puc(sc);
351
352 hifn_init_dma(sc);
353 hifn_init_pci_registers(sc);
354
355 /* XXX can't dynamically determine ram type for 795x; force dram */
356 if (sc->sc_flags & HIFN_IS_7956)
357 sc->sc_drammodel = 1;
358 else if (hifn_ramtype(sc))
359 goto fail_mem;
360
361 if (sc->sc_drammodel == 0)
362 hifn_sramsize(sc);
363 else
364 hifn_dramsize(sc);
365
366 /*
367 * Workaround for NetSec 7751 rev A: half ram size because two
368 * of the address lines were left floating
369 */
370 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_NETSEC &&
371 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_NETSEC_7751 &&
372 PCI_REVISION(pa->pa_class) == 0x61)
373 sc->sc_ramsize >>= 1;
374
375 if (pci_intr_map(pa, &ih)) {
376 aprint_error("%s: couldn't map interrupt\n",
377 sc->sc_dv.dv_xname);
378 goto fail_mem;
379 }
380 intrstr = pci_intr_string(pc, ih);
381 #ifdef __OpenBSD__
382 sc->sc_ih = pci_intr_establish(pc, ih, IPL_NET, hifn_intr, sc,
383 self->dv_xname);
384 #else
385 sc->sc_ih = pci_intr_establish(pc, ih, IPL_NET, hifn_intr, sc);
386 #endif
387 if (sc->sc_ih == NULL) {
388 aprint_error("%s: couldn't establish interrupt\n",
389 sc->sc_dv.dv_xname);
390 if (intrstr != NULL)
391 aprint_normal(" at %s", intrstr);
392 aprint_normal("\n");
393 goto fail_mem;
394 }
395
396 hifn_sessions(sc);
397
398 rseg = sc->sc_ramsize / 1024;
399 rbase = 'K';
400 if (sc->sc_ramsize >= (1024 * 1024)) {
401 rbase = 'M';
402 rseg /= 1024;
403 }
404 aprint_normal("%s: %s, %d%cB %cram, interrupting at %s\n",
405 sc->sc_dv.dv_xname, hifncap, rseg, rbase,
406 sc->sc_drammodel ? 'd' : 's', intrstr);
407
408 sc->sc_cid = crypto_get_driverid(0);
409 if (sc->sc_cid < 0) {
410 aprint_error("%s: couldn't get crypto driver id\n",
411 sc->sc_dv.dv_xname);
412 goto fail_intr;
413 }
414
415 WRITE_REG_0(sc, HIFN_0_PUCNFG,
416 READ_REG_0(sc, HIFN_0_PUCNFG) | HIFN_PUCNFG_CHIPID);
417 ena = READ_REG_0(sc, HIFN_0_PUSTAT) & HIFN_PUSTAT_CHIPENA;
418
419 switch (ena) {
420 case HIFN_PUSTAT_ENA_2:
421 crypto_register(sc->sc_cid, CRYPTO_3DES_CBC, 0, 0,
422 hifn_newsession, hifn_freesession, hifn_process, sc);
423 crypto_register(sc->sc_cid, CRYPTO_ARC4, 0, 0,
424 hifn_newsession, hifn_freesession, hifn_process, sc);
425 if (sc->sc_flags & HIFN_HAS_AES)
426 crypto_register(sc->sc_cid, CRYPTO_AES_CBC, 0, 0,
427 hifn_newsession, hifn_freesession,
428 hifn_process, sc);
429 /*FALLTHROUGH*/
430 case HIFN_PUSTAT_ENA_1:
431 crypto_register(sc->sc_cid, CRYPTO_MD5, 0, 0,
432 hifn_newsession, hifn_freesession, hifn_process, sc);
433 crypto_register(sc->sc_cid, CRYPTO_SHA1, 0, 0,
434 hifn_newsession, hifn_freesession, hifn_process, sc);
435 crypto_register(sc->sc_cid, CRYPTO_MD5_HMAC, 0, 0,
436 hifn_newsession, hifn_freesession, hifn_process, sc);
437 crypto_register(sc->sc_cid, CRYPTO_SHA1_HMAC, 0, 0,
438 hifn_newsession, hifn_freesession, hifn_process, sc);
439 crypto_register(sc->sc_cid, CRYPTO_DES_CBC, 0, 0,
440 hifn_newsession, hifn_freesession, hifn_process, sc);
441 break;
442 }
443
444 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, 0,
445 sc->sc_dmamap->dm_mapsize,
446 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
447
448 if (sc->sc_flags & (HIFN_HAS_PUBLIC | HIFN_HAS_RNG))
449 hifn_init_pubrng(sc);
450
451 #ifdef __OpenBSD__
452 timeout_set(&sc->sc_tickto, hifn_tick, sc);
453 timeout_add(&sc->sc_tickto, hz);
454 #else
455 callout_init(&sc->sc_tickto);
456 callout_reset(&sc->sc_tickto, hz, hifn_tick, sc);
457 #endif
458 return;
459
460 fail_intr:
461 pci_intr_disestablish(pc, sc->sc_ih);
462 fail_mem:
463 bus_dmamap_unload(sc->sc_dmat, dmamap);
464 bus_dmamap_destroy(sc->sc_dmat, dmamap);
465 bus_dmamem_unmap(sc->sc_dmat, kva, sizeof(*sc->sc_dma));
466 bus_dmamem_free(sc->sc_dmat, &seg, rseg);
467
468 /* Turn off DMA polling */
469 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
470 HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE);
471
472 fail_io1:
473 bus_space_unmap(sc->sc_st1, sc->sc_sh1, iosize1);
474 fail_io0:
475 bus_space_unmap(sc->sc_st0, sc->sc_sh0, iosize0);
476 }
477
478 int
479 hifn_init_pubrng(struct hifn_softc *sc)
480 {
481 u_int32_t r;
482 int i;
483
484 if ((sc->sc_flags & HIFN_IS_7811) == 0) {
485 /* Reset 7951 public key/rng engine */
486 WRITE_REG_1(sc, HIFN_1_PUB_RESET,
487 READ_REG_1(sc, HIFN_1_PUB_RESET) | HIFN_PUBRST_RESET);
488
489 for (i = 0; i < 100; i++) {
490 DELAY(1000);
491 if ((READ_REG_1(sc, HIFN_1_PUB_RESET) &
492 HIFN_PUBRST_RESET) == 0)
493 break;
494 }
495
496 if (i == 100) {
497 printf("%s: public key init failed\n",
498 sc->sc_dv.dv_xname);
499 return (1);
500 }
501 }
502
503 /* Enable the rng, if available */
504 if (sc->sc_flags & HIFN_HAS_RNG) {
505 if (sc->sc_flags & HIFN_IS_7811) {
506 r = READ_REG_1(sc, HIFN_1_7811_RNGENA);
507 if (r & HIFN_7811_RNGENA_ENA) {
508 r &= ~HIFN_7811_RNGENA_ENA;
509 WRITE_REG_1(sc, HIFN_1_7811_RNGENA, r);
510 }
511 WRITE_REG_1(sc, HIFN_1_7811_RNGCFG,
512 HIFN_7811_RNGCFG_DEFL);
513 r |= HIFN_7811_RNGENA_ENA;
514 WRITE_REG_1(sc, HIFN_1_7811_RNGENA, r);
515 } else
516 WRITE_REG_1(sc, HIFN_1_RNG_CONFIG,
517 READ_REG_1(sc, HIFN_1_RNG_CONFIG) |
518 HIFN_RNGCFG_ENA);
519
520 sc->sc_rngfirst = 1;
521 if (hz >= 100)
522 sc->sc_rnghz = hz / 100;
523 else
524 sc->sc_rnghz = 1;
525 #ifndef HIFN_NO_RNG
526 #ifdef __OpenBSD__
527 timeout_set(&sc->sc_rngto, hifn_rng, sc);
528 timeout_add(&sc->sc_rngto, sc->sc_rnghz);
529 #else /* !__OpenBSD__ */
530 callout_init(&sc->sc_rngto);
531 callout_reset(&sc->sc_rngto, sc->sc_rnghz, hifn_rng, sc);
532 #endif /* !__OpenBSD__ */
533 #endif /* HIFN_NO_RNG */
534 }
535
536 /* Enable public key engine, if available */
537 if (sc->sc_flags & HIFN_HAS_PUBLIC) {
538 WRITE_REG_1(sc, HIFN_1_PUB_IEN, HIFN_PUBIEN_DONE);
539 sc->sc_dmaier |= HIFN_DMAIER_PUBDONE;
540 WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
541 }
542
543 return (0);
544 }
545
546 #ifndef HIFN_NO_RNG
547 static void
548 hifn_rng(void *vsc)
549 {
550 #ifndef __NetBSD__
551 struct hifn_softc *sc = vsc;
552 u_int32_t num1, sts, num2;
553 int i;
554
555 if (sc->sc_flags & HIFN_IS_7811) {
556 for (i = 0; i < 5; i++) {
557 sts = READ_REG_1(sc, HIFN_1_7811_RNGSTS);
558 if (sts & HIFN_7811_RNGSTS_UFL) {
559 printf("%s: RNG underflow: disabling\n",
560 sc->sc_dv.dv_xname);
561 return;
562 }
563 if ((sts & HIFN_7811_RNGSTS_RDY) == 0)
564 break;
565
566 /*
567 * There are at least two words in the RNG FIFO
568 * at this point.
569 */
570 num1 = READ_REG_1(sc, HIFN_1_7811_RNGDAT);
571 num2 = READ_REG_1(sc, HIFN_1_7811_RNGDAT);
572 if (sc->sc_rngfirst)
573 sc->sc_rngfirst = 0;
574 else {
575 add_true_randomness(num1);
576 add_true_randomness(num2);
577 }
578 }
579 } else {
580 num1 = READ_REG_1(sc, HIFN_1_RNG_DATA);
581
582 if (sc->sc_rngfirst)
583 sc->sc_rngfirst = 0;
584 else
585 add_true_randomness(num1);
586 }
587
588 #ifdef __OpenBSD__
589 timeout_add(&sc->sc_rngto, sc->sc_rnghz);
590 #else
591 callout_reset(&sc->sc_rngto, sc->sc_rnghz, hifn_rng, sc);
592 #endif
593 #endif /*!__NetBSD__*/
594 }
595 #endif
596
597 void
598 hifn_puc_wait(struct hifn_softc *sc)
599 {
600 int i;
601
602 for (i = 5000; i > 0; i--) {
603 DELAY(1);
604 if (!(READ_REG_0(sc, HIFN_0_PUCTRL) & HIFN_PUCTRL_RESET))
605 break;
606 }
607 if (!i)
608 printf("%s: proc unit did not reset\n", sc->sc_dv.dv_xname);
609 }
610
611 /*
612 * Reset the processing unit.
613 */
614 void
615 hifn_reset_puc(struct hifn_softc *sc)
616 {
617 /* Reset processing unit */
618 WRITE_REG_0(sc, HIFN_0_PUCTRL, HIFN_PUCTRL_DMAENA);
619 hifn_puc_wait(sc);
620 }
621
622 void
623 hifn_set_retry(struct hifn_softc *sc)
624 {
625 u_int32_t r;
626
627 r = pci_conf_read(sc->sc_pci_pc, sc->sc_pci_tag, HIFN_TRDY_TIMEOUT);
628 r &= 0xffff0000;
629 pci_conf_write(sc->sc_pci_pc, sc->sc_pci_tag, HIFN_TRDY_TIMEOUT, r);
630 }
631
632 /*
633 * Resets the board. Values in the regesters are left as is
634 * from the reset (i.e. initial values are assigned elsewhere).
635 */
636 void
637 hifn_reset_board(struct hifn_softc *sc, int full)
638 {
639 u_int32_t reg;
640
641 /*
642 * Set polling in the DMA configuration register to zero. 0x7 avoids
643 * resetting the board and zeros out the other fields.
644 */
645 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
646 HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE);
647
648 /*
649 * Now that polling has been disabled, we have to wait 1 ms
650 * before resetting the board.
651 */
652 DELAY(1000);
653
654 /* Reset the DMA unit */
655 if (full) {
656 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MODE);
657 DELAY(1000);
658 } else {
659 WRITE_REG_1(sc, HIFN_1_DMA_CNFG,
660 HIFN_DMACNFG_MODE | HIFN_DMACNFG_MSTRESET);
661 hifn_reset_puc(sc);
662 }
663
664 bzero(sc->sc_dma, sizeof(*sc->sc_dma));
665
666 /* Bring dma unit out of reset */
667 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
668 HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE);
669
670 hifn_puc_wait(sc);
671
672 hifn_set_retry(sc);
673
674 if (sc->sc_flags & HIFN_IS_7811) {
675 for (reg = 0; reg < 1000; reg++) {
676 if (READ_REG_1(sc, HIFN_1_7811_MIPSRST) &
677 HIFN_MIPSRST_CRAMINIT)
678 break;
679 DELAY(1000);
680 }
681 if (reg == 1000)
682 printf(": cram init timeout\n");
683 }
684 }
685
686 u_int32_t
687 hifn_next_signature(u_int32_t a, u_int cnt)
688 {
689 int i;
690 u_int32_t v;
691
692 for (i = 0; i < cnt; i++) {
693
694 /* get the parity */
695 v = a & 0x80080125;
696 v ^= v >> 16;
697 v ^= v >> 8;
698 v ^= v >> 4;
699 v ^= v >> 2;
700 v ^= v >> 1;
701
702 a = (v & 1) ^ (a << 1);
703 }
704
705 return a;
706 }
707
708 struct pci2id {
709 u_short pci_vendor;
710 u_short pci_prod;
711 char card_id[13];
712 } pci2id[] = {
713 {
714 PCI_VENDOR_HIFN,
715 PCI_PRODUCT_HIFN_7951,
716 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
717 0x00, 0x00, 0x00, 0x00, 0x00 }
718 }, {
719 PCI_VENDOR_HIFN,
720 PCI_PRODUCT_HIFN_7955,
721 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
722 0x00, 0x00, 0x00, 0x00, 0x00 }
723 }, {
724 PCI_VENDOR_HIFN,
725 PCI_PRODUCT_HIFN_7956,
726 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
727 0x00, 0x00, 0x00, 0x00, 0x00 }
728 }, {
729 PCI_VENDOR_NETSEC,
730 PCI_PRODUCT_NETSEC_7751,
731 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
732 0x00, 0x00, 0x00, 0x00, 0x00 }
733 }, {
734 PCI_VENDOR_INVERTEX,
735 PCI_PRODUCT_INVERTEX_AEON,
736 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
737 0x00, 0x00, 0x00, 0x00, 0x00 }
738 }, {
739 PCI_VENDOR_HIFN,
740 PCI_PRODUCT_HIFN_7811,
741 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
742 0x00, 0x00, 0x00, 0x00, 0x00 }
743 }, {
744 /*
745 * Other vendors share this PCI ID as well, such as
746 * http://www.powercrypt.com, and obviously they also
747 * use the same key.
748 */
749 PCI_VENDOR_HIFN,
750 PCI_PRODUCT_HIFN_7751,
751 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
752 0x00, 0x00, 0x00, 0x00, 0x00 }
753 },
754 };
755
756 /*
757 * Checks to see if crypto is already enabled. If crypto isn't enable,
758 * "hifn_enable_crypto" is called to enable it. The check is important,
759 * as enabling crypto twice will lock the board.
760 */
761 const char *
762 hifn_enable_crypto(struct hifn_softc *sc, pcireg_t pciid)
763 {
764 u_int32_t dmacfg, ramcfg, encl, addr, i;
765 char *offtbl = NULL;
766
767 for (i = 0; i < sizeof(pci2id)/sizeof(pci2id[0]); i++) {
768 if (pci2id[i].pci_vendor == PCI_VENDOR(pciid) &&
769 pci2id[i].pci_prod == PCI_PRODUCT(pciid)) {
770 offtbl = pci2id[i].card_id;
771 break;
772 }
773 }
774
775 if (offtbl == NULL) {
776 #ifdef HIFN_DEBUG
777 aprint_debug("%s: Unknown card!\n", sc->sc_dv.dv_xname);
778 #endif
779 return (NULL);
780 }
781
782 ramcfg = READ_REG_0(sc, HIFN_0_PUCNFG);
783 dmacfg = READ_REG_1(sc, HIFN_1_DMA_CNFG);
784
785 /*
786 * The RAM config register's encrypt level bit needs to be set before
787 * every read performed on the encryption level register.
788 */
789 WRITE_REG_0(sc, HIFN_0_PUCNFG, ramcfg | HIFN_PUCNFG_CHIPID);
790
791 encl = READ_REG_0(sc, HIFN_0_PUSTAT) & HIFN_PUSTAT_CHIPENA;
792
793 /*
794 * Make sure we don't re-unlock. Two unlocks kills chip until the
795 * next reboot.
796 */
797 if (encl == HIFN_PUSTAT_ENA_1 || encl == HIFN_PUSTAT_ENA_2) {
798 #ifdef HIFN_DEBUG
799 aprint_debug("%s: Strong Crypto already enabled!\n",
800 sc->sc_dv.dv_xname);
801 #endif
802 goto report;
803 }
804
805 if (encl != 0 && encl != HIFN_PUSTAT_ENA_0) {
806 #ifdef HIFN_DEBUG
807 aprint_debug("%s: Unknown encryption level\n",
808 sc->sc_dv.dv_xname);
809 #endif
810 return (NULL);
811 }
812
813 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_UNLOCK |
814 HIFN_DMACNFG_MSTRESET | HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE);
815 DELAY(1000);
816 addr = READ_REG_1(sc, HIFN_1_UNLOCK_SECRET1);
817 DELAY(1000);
818 WRITE_REG_1(sc, HIFN_1_UNLOCK_SECRET2, 0);
819 DELAY(1000);
820
821 for (i = 0; i <= 12; i++) {
822 addr = hifn_next_signature(addr, offtbl[i] + 0x101);
823 WRITE_REG_1(sc, HIFN_1_UNLOCK_SECRET2, addr);
824
825 DELAY(1000);
826 }
827
828 WRITE_REG_0(sc, HIFN_0_PUCNFG, ramcfg | HIFN_PUCNFG_CHIPID);
829 encl = READ_REG_0(sc, HIFN_0_PUSTAT) & HIFN_PUSTAT_CHIPENA;
830
831 #ifdef HIFN_DEBUG
832 if (encl != HIFN_PUSTAT_ENA_1 && encl != HIFN_PUSTAT_ENA_2)
833 aprint_debug("Encryption engine is permanently locked until next system reset.");
834 else
835 aprint_debug("Encryption engine enabled successfully!");
836 #endif
837
838 report:
839 WRITE_REG_0(sc, HIFN_0_PUCNFG, ramcfg);
840 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, dmacfg);
841
842 switch (encl) {
843 case HIFN_PUSTAT_ENA_0:
844 return ("LZS-only (no encr/auth)");
845
846 case HIFN_PUSTAT_ENA_1:
847 return ("DES");
848
849 case HIFN_PUSTAT_ENA_2:
850 if (sc->sc_flags & HIFN_HAS_AES)
851 return ("3DES/AES");
852 else
853 return ("3DES");
854
855 default:
856 return ("disabled");
857 }
858 /* NOTREACHED */
859 }
860
861 /*
862 * Give initial values to the registers listed in the "Register Space"
863 * section of the HIFN Software Development reference manual.
864 */
865 void
866 hifn_init_pci_registers(struct hifn_softc *sc)
867 {
868 /* write fixed values needed by the Initialization registers */
869 WRITE_REG_0(sc, HIFN_0_PUCTRL, HIFN_PUCTRL_DMAENA);
870 WRITE_REG_0(sc, HIFN_0_FIFOCNFG, HIFN_FIFOCNFG_THRESHOLD);
871 WRITE_REG_0(sc, HIFN_0_PUIER, HIFN_PUIER_DSTOVER);
872
873 /* write all 4 ring address registers */
874 WRITE_REG_1(sc, HIFN_1_DMA_CRAR, sc->sc_dmamap->dm_segs[0].ds_addr +
875 offsetof(struct hifn_dma, cmdr[0]));
876 WRITE_REG_1(sc, HIFN_1_DMA_SRAR, sc->sc_dmamap->dm_segs[0].ds_addr +
877 offsetof(struct hifn_dma, srcr[0]));
878 WRITE_REG_1(sc, HIFN_1_DMA_DRAR, sc->sc_dmamap->dm_segs[0].ds_addr +
879 offsetof(struct hifn_dma, dstr[0]));
880 WRITE_REG_1(sc, HIFN_1_DMA_RRAR, sc->sc_dmamap->dm_segs[0].ds_addr +
881 offsetof(struct hifn_dma, resr[0]));
882
883 DELAY(2000);
884
885 /* write status register */
886 WRITE_REG_1(sc, HIFN_1_DMA_CSR,
887 HIFN_DMACSR_D_CTRL_DIS | HIFN_DMACSR_R_CTRL_DIS |
888 HIFN_DMACSR_S_CTRL_DIS | HIFN_DMACSR_C_CTRL_DIS |
889 HIFN_DMACSR_D_ABORT | HIFN_DMACSR_D_DONE | HIFN_DMACSR_D_LAST |
890 HIFN_DMACSR_D_WAIT | HIFN_DMACSR_D_OVER |
891 HIFN_DMACSR_R_ABORT | HIFN_DMACSR_R_DONE | HIFN_DMACSR_R_LAST |
892 HIFN_DMACSR_R_WAIT | HIFN_DMACSR_R_OVER |
893 HIFN_DMACSR_S_ABORT | HIFN_DMACSR_S_DONE | HIFN_DMACSR_S_LAST |
894 HIFN_DMACSR_S_WAIT |
895 HIFN_DMACSR_C_ABORT | HIFN_DMACSR_C_DONE | HIFN_DMACSR_C_LAST |
896 HIFN_DMACSR_C_WAIT |
897 HIFN_DMACSR_ENGINE |
898 ((sc->sc_flags & HIFN_HAS_PUBLIC) ?
899 HIFN_DMACSR_PUBDONE : 0) |
900 ((sc->sc_flags & HIFN_IS_7811) ?
901 HIFN_DMACSR_ILLW | HIFN_DMACSR_ILLR : 0));
902
903 sc->sc_d_busy = sc->sc_r_busy = sc->sc_s_busy = sc->sc_c_busy = 0;
904 sc->sc_dmaier |= HIFN_DMAIER_R_DONE | HIFN_DMAIER_C_ABORT |
905 HIFN_DMAIER_D_OVER | HIFN_DMAIER_R_OVER |
906 HIFN_DMAIER_S_ABORT | HIFN_DMAIER_D_ABORT | HIFN_DMAIER_R_ABORT |
907 HIFN_DMAIER_ENGINE |
908 ((sc->sc_flags & HIFN_IS_7811) ?
909 HIFN_DMAIER_ILLW | HIFN_DMAIER_ILLR : 0);
910 sc->sc_dmaier &= ~HIFN_DMAIER_C_WAIT;
911 WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
912 CLR_LED(sc, HIFN_MIPSRST_LED0 | HIFN_MIPSRST_LED1 | HIFN_MIPSRST_LED2);
913
914 if (sc->sc_flags & HIFN_IS_7956) {
915 WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING |
916 HIFN_PUCNFG_TCALLPHASES |
917 HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32);
918 WRITE_REG_1(sc, HIFN_1_PLL, HIFN_PLL_7956);
919 } else {
920 WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING |
921 HIFN_PUCNFG_DRFR_128 | HIFN_PUCNFG_TCALLPHASES |
922 HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32 |
923 (sc->sc_drammodel ? HIFN_PUCNFG_DRAM : HIFN_PUCNFG_SRAM));
924 }
925
926 WRITE_REG_0(sc, HIFN_0_PUISR, HIFN_PUISR_DSTOVER);
927 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
928 HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE | HIFN_DMACNFG_LAST |
929 ((HIFN_POLL_FREQUENCY << 16 ) & HIFN_DMACNFG_POLLFREQ) |
930 ((HIFN_POLL_SCALAR << 8) & HIFN_DMACNFG_POLLINVAL));
931 }
932
933 /*
934 * The maximum number of sessions supported by the card
935 * is dependent on the amount of context ram, which
936 * encryption algorithms are enabled, and how compression
937 * is configured. This should be configured before this
938 * routine is called.
939 */
940 void
941 hifn_sessions(struct hifn_softc *sc)
942 {
943 u_int32_t pucnfg;
944 int ctxsize;
945
946 pucnfg = READ_REG_0(sc, HIFN_0_PUCNFG);
947
948 if (pucnfg & HIFN_PUCNFG_COMPSING) {
949 if (pucnfg & HIFN_PUCNFG_ENCCNFG)
950 ctxsize = 128;
951 else
952 ctxsize = 512;
953 /*
954 * 7955/7956 has internal context memory of 32K
955 */
956 if (sc->sc_flags & HIFN_IS_7956)
957 sc->sc_maxses = 32768 / ctxsize;
958 else
959 sc->sc_maxses = 1 +
960 ((sc->sc_ramsize - 32768) / ctxsize);
961 }
962 else
963 sc->sc_maxses = sc->sc_ramsize / 16384;
964
965 if (sc->sc_maxses > 2048)
966 sc->sc_maxses = 2048;
967 }
968
969 /*
970 * Determine ram type (sram or dram). Board should be just out of a reset
971 * state when this is called.
972 */
973 int
974 hifn_ramtype(struct hifn_softc *sc)
975 {
976 u_int8_t data[8], dataexpect[8];
977 int i;
978
979 for (i = 0; i < sizeof(data); i++)
980 data[i] = dataexpect[i] = 0x55;
981 if (hifn_writeramaddr(sc, 0, data))
982 return (-1);
983 if (hifn_readramaddr(sc, 0, data))
984 return (-1);
985 if (bcmp(data, dataexpect, sizeof(data)) != 0) {
986 sc->sc_drammodel = 1;
987 return (0);
988 }
989
990 for (i = 0; i < sizeof(data); i++)
991 data[i] = dataexpect[i] = 0xaa;
992 if (hifn_writeramaddr(sc, 0, data))
993 return (-1);
994 if (hifn_readramaddr(sc, 0, data))
995 return (-1);
996 if (bcmp(data, dataexpect, sizeof(data)) != 0) {
997 sc->sc_drammodel = 1;
998 return (0);
999 }
1000
1001 return (0);
1002 }
1003
1004 #define HIFN_SRAM_MAX (32 << 20)
1005 #define HIFN_SRAM_STEP_SIZE 16384
1006 #define HIFN_SRAM_GRANULARITY (HIFN_SRAM_MAX / HIFN_SRAM_STEP_SIZE)
1007
1008 int
1009 hifn_sramsize(struct hifn_softc *sc)
1010 {
1011 u_int32_t a;
1012 u_int8_t data[8];
1013 u_int8_t dataexpect[sizeof(data)];
1014 int32_t i;
1015
1016 for (i = 0; i < sizeof(data); i++)
1017 data[i] = dataexpect[i] = i ^ 0x5a;
1018
1019 for (i = HIFN_SRAM_GRANULARITY - 1; i >= 0; i--) {
1020 a = i * HIFN_SRAM_STEP_SIZE;
1021 bcopy(&i, data, sizeof(i));
1022 hifn_writeramaddr(sc, a, data);
1023 }
1024
1025 for (i = 0; i < HIFN_SRAM_GRANULARITY; i++) {
1026 a = i * HIFN_SRAM_STEP_SIZE;
1027 bcopy(&i, dataexpect, sizeof(i));
1028 if (hifn_readramaddr(sc, a, data) < 0)
1029 return (0);
1030 if (bcmp(data, dataexpect, sizeof(data)) != 0)
1031 return (0);
1032 sc->sc_ramsize = a + HIFN_SRAM_STEP_SIZE;
1033 }
1034
1035 return (0);
1036 }
1037
1038 /*
1039 * XXX For dram boards, one should really try all of the
1040 * HIFN_PUCNFG_DSZ_*'s. This just assumes that PUCNFG
1041 * is already set up correctly.
1042 */
1043 int
1044 hifn_dramsize(struct hifn_softc *sc)
1045 {
1046 u_int32_t cnfg;
1047
1048 if (sc->sc_flags & HIFN_IS_7956) {
1049 /*
1050 * 7955/7956 have a fixed internal ram of only 32K.
1051 */
1052 sc->sc_ramsize = 32768;
1053 } else {
1054 cnfg = READ_REG_0(sc, HIFN_0_PUCNFG) &
1055 HIFN_PUCNFG_DRAMMASK;
1056 sc->sc_ramsize = 1 << ((cnfg >> 13) + 18);
1057 }
1058 return (0);
1059 }
1060
1061 void
1062 hifn_alloc_slot(struct hifn_softc *sc, int *cmdp, int *srcp, int *dstp,
1063 int *resp)
1064 {
1065 struct hifn_dma *dma = sc->sc_dma;
1066
1067 if (dma->cmdi == HIFN_D_CMD_RSIZE) {
1068 dma->cmdi = 0;
1069 dma->cmdr[HIFN_D_CMD_RSIZE].l = htole32(HIFN_D_VALID |
1070 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1071 HIFN_CMDR_SYNC(sc, HIFN_D_CMD_RSIZE,
1072 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1073 }
1074 *cmdp = dma->cmdi++;
1075 dma->cmdk = dma->cmdi;
1076
1077 if (dma->srci == HIFN_D_SRC_RSIZE) {
1078 dma->srci = 0;
1079 dma->srcr[HIFN_D_SRC_RSIZE].l = htole32(HIFN_D_VALID |
1080 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1081 HIFN_SRCR_SYNC(sc, HIFN_D_SRC_RSIZE,
1082 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1083 }
1084 *srcp = dma->srci++;
1085 dma->srck = dma->srci;
1086
1087 if (dma->dsti == HIFN_D_DST_RSIZE) {
1088 dma->dsti = 0;
1089 dma->dstr[HIFN_D_DST_RSIZE].l = htole32(HIFN_D_VALID |
1090 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1091 HIFN_DSTR_SYNC(sc, HIFN_D_DST_RSIZE,
1092 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1093 }
1094 *dstp = dma->dsti++;
1095 dma->dstk = dma->dsti;
1096
1097 if (dma->resi == HIFN_D_RES_RSIZE) {
1098 dma->resi = 0;
1099 dma->resr[HIFN_D_RES_RSIZE].l = htole32(HIFN_D_VALID |
1100 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1101 HIFN_RESR_SYNC(sc, HIFN_D_RES_RSIZE,
1102 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1103 }
1104 *resp = dma->resi++;
1105 dma->resk = dma->resi;
1106 }
1107
1108 int
1109 hifn_writeramaddr(struct hifn_softc *sc, int addr, u_int8_t *data)
1110 {
1111 struct hifn_dma *dma = sc->sc_dma;
1112 struct hifn_base_command wc;
1113 const u_int32_t masks = HIFN_D_VALID | HIFN_D_LAST | HIFN_D_MASKDONEIRQ;
1114 int r, cmdi, resi, srci, dsti;
1115
1116 wc.masks = htole16(3 << 13);
1117 wc.session_num = htole16(addr >> 14);
1118 wc.total_source_count = htole16(8);
1119 wc.total_dest_count = htole16(addr & 0x3fff);
1120
1121 hifn_alloc_slot(sc, &cmdi, &srci, &dsti, &resi);
1122
1123 WRITE_REG_1(sc, HIFN_1_DMA_CSR,
1124 HIFN_DMACSR_C_CTRL_ENA | HIFN_DMACSR_S_CTRL_ENA |
1125 HIFN_DMACSR_D_CTRL_ENA | HIFN_DMACSR_R_CTRL_ENA);
1126
1127 /* build write command */
1128 bzero(dma->command_bufs[cmdi], HIFN_MAX_COMMAND);
1129 *(struct hifn_base_command *)dma->command_bufs[cmdi] = wc;
1130 bcopy(data, &dma->test_src, sizeof(dma->test_src));
1131
1132 dma->srcr[srci].p = htole32(sc->sc_dmamap->dm_segs[0].ds_addr
1133 + offsetof(struct hifn_dma, test_src));
1134 dma->dstr[dsti].p = htole32(sc->sc_dmamap->dm_segs[0].ds_addr
1135 + offsetof(struct hifn_dma, test_dst));
1136
1137 dma->cmdr[cmdi].l = htole32(16 | masks);
1138 dma->srcr[srci].l = htole32(8 | masks);
1139 dma->dstr[dsti].l = htole32(4 | masks);
1140 dma->resr[resi].l = htole32(4 | masks);
1141
1142 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
1143 0, sc->sc_dmamap->dm_mapsize,
1144 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1145
1146 for (r = 10000; r >= 0; r--) {
1147 DELAY(10);
1148 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
1149 0, sc->sc_dmamap->dm_mapsize,
1150 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1151 if ((dma->resr[resi].l & htole32(HIFN_D_VALID)) == 0)
1152 break;
1153 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
1154 0, sc->sc_dmamap->dm_mapsize,
1155 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1156 }
1157 if (r == 0) {
1158 printf("%s: writeramaddr -- "
1159 "result[%d](addr %d) still valid\n",
1160 sc->sc_dv.dv_xname, resi, addr);
1161 r = -1;
1162 return (-1);
1163 } else
1164 r = 0;
1165
1166 WRITE_REG_1(sc, HIFN_1_DMA_CSR,
1167 HIFN_DMACSR_C_CTRL_DIS | HIFN_DMACSR_S_CTRL_DIS |
1168 HIFN_DMACSR_D_CTRL_DIS | HIFN_DMACSR_R_CTRL_DIS);
1169
1170 return (r);
1171 }
1172
1173 int
1174 hifn_readramaddr(struct hifn_softc *sc, int addr, u_int8_t *data)
1175 {
1176 struct hifn_dma *dma = sc->sc_dma;
1177 struct hifn_base_command rc;
1178 const u_int32_t masks = HIFN_D_VALID | HIFN_D_LAST | HIFN_D_MASKDONEIRQ;
1179 int r, cmdi, srci, dsti, resi;
1180
1181 rc.masks = htole16(2 << 13);
1182 rc.session_num = htole16(addr >> 14);
1183 rc.total_source_count = htole16(addr & 0x3fff);
1184 rc.total_dest_count = htole16(8);
1185
1186 hifn_alloc_slot(sc, &cmdi, &srci, &dsti, &resi);
1187
1188 WRITE_REG_1(sc, HIFN_1_DMA_CSR,
1189 HIFN_DMACSR_C_CTRL_ENA | HIFN_DMACSR_S_CTRL_ENA |
1190 HIFN_DMACSR_D_CTRL_ENA | HIFN_DMACSR_R_CTRL_ENA);
1191
1192 bzero(dma->command_bufs[cmdi], HIFN_MAX_COMMAND);
1193 *(struct hifn_base_command *)dma->command_bufs[cmdi] = rc;
1194
1195 dma->srcr[srci].p = htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1196 offsetof(struct hifn_dma, test_src));
1197 dma->test_src = 0;
1198 dma->dstr[dsti].p = htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1199 offsetof(struct hifn_dma, test_dst));
1200 dma->test_dst = 0;
1201 dma->cmdr[cmdi].l = htole32(8 | masks);
1202 dma->srcr[srci].l = htole32(8 | masks);
1203 dma->dstr[dsti].l = htole32(8 | masks);
1204 dma->resr[resi].l = htole32(HIFN_MAX_RESULT | masks);
1205
1206 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
1207 0, sc->sc_dmamap->dm_mapsize,
1208 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1209
1210 for (r = 10000; r >= 0; r--) {
1211 DELAY(10);
1212 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
1213 0, sc->sc_dmamap->dm_mapsize,
1214 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1215 if ((dma->resr[resi].l & htole32(HIFN_D_VALID)) == 0)
1216 break;
1217 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
1218 0, sc->sc_dmamap->dm_mapsize,
1219 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1220 }
1221 if (r == 0) {
1222 printf("%s: readramaddr -- "
1223 "result[%d](addr %d) still valid\n",
1224 sc->sc_dv.dv_xname, resi, addr);
1225 r = -1;
1226 } else {
1227 r = 0;
1228 bcopy(&dma->test_dst, data, sizeof(dma->test_dst));
1229 }
1230
1231 WRITE_REG_1(sc, HIFN_1_DMA_CSR,
1232 HIFN_DMACSR_C_CTRL_DIS | HIFN_DMACSR_S_CTRL_DIS |
1233 HIFN_DMACSR_D_CTRL_DIS | HIFN_DMACSR_R_CTRL_DIS);
1234
1235 return (r);
1236 }
1237
1238 /*
1239 * Initialize the descriptor rings.
1240 */
1241 void
1242 hifn_init_dma(struct hifn_softc *sc)
1243 {
1244 struct hifn_dma *dma = sc->sc_dma;
1245 int i;
1246
1247 hifn_set_retry(sc);
1248
1249 /* initialize static pointer values */
1250 for (i = 0; i < HIFN_D_CMD_RSIZE; i++)
1251 dma->cmdr[i].p = htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1252 offsetof(struct hifn_dma, command_bufs[i][0]));
1253 for (i = 0; i < HIFN_D_RES_RSIZE; i++)
1254 dma->resr[i].p = htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1255 offsetof(struct hifn_dma, result_bufs[i][0]));
1256
1257 dma->cmdr[HIFN_D_CMD_RSIZE].p =
1258 htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1259 offsetof(struct hifn_dma, cmdr[0]));
1260 dma->srcr[HIFN_D_SRC_RSIZE].p =
1261 htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1262 offsetof(struct hifn_dma, srcr[0]));
1263 dma->dstr[HIFN_D_DST_RSIZE].p =
1264 htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1265 offsetof(struct hifn_dma, dstr[0]));
1266 dma->resr[HIFN_D_RES_RSIZE].p =
1267 htole32(sc->sc_dmamap->dm_segs[0].ds_addr +
1268 offsetof(struct hifn_dma, resr[0]));
1269
1270 dma->cmdu = dma->srcu = dma->dstu = dma->resu = 0;
1271 dma->cmdi = dma->srci = dma->dsti = dma->resi = 0;
1272 dma->cmdk = dma->srck = dma->dstk = dma->resk = 0;
1273 }
1274
1275 /*
1276 * Writes out the raw command buffer space. Returns the
1277 * command buffer size.
1278 */
1279 u_int
1280 hifn_write_command(struct hifn_command *cmd, u_int8_t *buf)
1281 {
1282 u_int8_t *buf_pos;
1283 struct hifn_base_command *base_cmd;
1284 struct hifn_mac_command *mac_cmd;
1285 struct hifn_crypt_command *cry_cmd;
1286 struct hifn_comp_command *comp_cmd;
1287 int using_mac, using_crypt, using_comp, len, ivlen;
1288 u_int32_t dlen, slen;
1289
1290 buf_pos = buf;
1291 using_mac = cmd->base_masks & HIFN_BASE_CMD_MAC;
1292 using_crypt = cmd->base_masks & HIFN_BASE_CMD_CRYPT;
1293 using_comp = cmd->base_masks & HIFN_BASE_CMD_COMP;
1294
1295 base_cmd = (struct hifn_base_command *)buf_pos;
1296 base_cmd->masks = htole16(cmd->base_masks);
1297 slen = cmd->src_map->dm_mapsize;
1298 if (cmd->sloplen)
1299 dlen = cmd->dst_map->dm_mapsize - cmd->sloplen +
1300 sizeof(u_int32_t);
1301 else
1302 dlen = cmd->dst_map->dm_mapsize;
1303 base_cmd->total_source_count = htole16(slen & HIFN_BASE_CMD_LENMASK_LO);
1304 base_cmd->total_dest_count = htole16(dlen & HIFN_BASE_CMD_LENMASK_LO);
1305 dlen >>= 16;
1306 slen >>= 16;
1307 base_cmd->session_num = htole16(cmd->session_num |
1308 ((slen << HIFN_BASE_CMD_SRCLEN_S) & HIFN_BASE_CMD_SRCLEN_M) |
1309 ((dlen << HIFN_BASE_CMD_DSTLEN_S) & HIFN_BASE_CMD_DSTLEN_M));
1310 buf_pos += sizeof(struct hifn_base_command);
1311
1312 if (using_comp) {
1313 comp_cmd = (struct hifn_comp_command *)buf_pos;
1314 dlen = cmd->compcrd->crd_len;
1315 comp_cmd->source_count = htole16(dlen & 0xffff);
1316 dlen >>= 16;
1317 comp_cmd->masks = htole16(cmd->comp_masks |
1318 ((dlen << HIFN_COMP_CMD_SRCLEN_S) & HIFN_COMP_CMD_SRCLEN_M));
1319 comp_cmd->header_skip = htole16(cmd->compcrd->crd_skip);
1320 comp_cmd->reserved = 0;
1321 buf_pos += sizeof(struct hifn_comp_command);
1322 }
1323
1324 if (using_mac) {
1325 mac_cmd = (struct hifn_mac_command *)buf_pos;
1326 dlen = cmd->maccrd->crd_len;
1327 mac_cmd->source_count = htole16(dlen & 0xffff);
1328 dlen >>= 16;
1329 mac_cmd->masks = htole16(cmd->mac_masks |
1330 ((dlen << HIFN_MAC_CMD_SRCLEN_S) & HIFN_MAC_CMD_SRCLEN_M));
1331 mac_cmd->header_skip = htole16(cmd->maccrd->crd_skip);
1332 mac_cmd->reserved = 0;
1333 buf_pos += sizeof(struct hifn_mac_command);
1334 }
1335
1336 if (using_crypt) {
1337 cry_cmd = (struct hifn_crypt_command *)buf_pos;
1338 dlen = cmd->enccrd->crd_len;
1339 cry_cmd->source_count = htole16(dlen & 0xffff);
1340 dlen >>= 16;
1341 cry_cmd->masks = htole16(cmd->cry_masks |
1342 ((dlen << HIFN_CRYPT_CMD_SRCLEN_S) & HIFN_CRYPT_CMD_SRCLEN_M));
1343 cry_cmd->header_skip = htole16(cmd->enccrd->crd_skip);
1344 cry_cmd->reserved = 0;
1345 buf_pos += sizeof(struct hifn_crypt_command);
1346 }
1347
1348 if (using_mac && cmd->mac_masks & HIFN_MAC_CMD_NEW_KEY) {
1349 bcopy(cmd->mac, buf_pos, HIFN_MAC_KEY_LENGTH);
1350 buf_pos += HIFN_MAC_KEY_LENGTH;
1351 }
1352
1353 if (using_crypt && cmd->cry_masks & HIFN_CRYPT_CMD_NEW_KEY) {
1354 switch (cmd->cry_masks & HIFN_CRYPT_CMD_ALG_MASK) {
1355 case HIFN_CRYPT_CMD_ALG_3DES:
1356 bcopy(cmd->ck, buf_pos, HIFN_3DES_KEY_LENGTH);
1357 buf_pos += HIFN_3DES_KEY_LENGTH;
1358 break;
1359 case HIFN_CRYPT_CMD_ALG_DES:
1360 bcopy(cmd->ck, buf_pos, HIFN_DES_KEY_LENGTH);
1361 buf_pos += HIFN_DES_KEY_LENGTH;
1362 break;
1363 case HIFN_CRYPT_CMD_ALG_RC4:
1364 len = 256;
1365 do {
1366 int clen;
1367
1368 clen = MIN(cmd->cklen, len);
1369 bcopy(cmd->ck, buf_pos, clen);
1370 len -= clen;
1371 buf_pos += clen;
1372 } while (len > 0);
1373 bzero(buf_pos, 4);
1374 buf_pos += 4;
1375 break;
1376 case HIFN_CRYPT_CMD_ALG_AES:
1377 /*
1378 * AES keys are variable 128, 192 and
1379 * 256 bits (16, 24 and 32 bytes).
1380 */
1381 bcopy(cmd->ck, buf_pos, cmd->cklen);
1382 buf_pos += cmd->cklen;
1383 break;
1384 }
1385 }
1386
1387 if (using_crypt && cmd->cry_masks & HIFN_CRYPT_CMD_NEW_IV) {
1388 switch (cmd->cry_masks & HIFN_CRYPT_CMD_ALG_MASK) {
1389 case HIFN_CRYPT_CMD_ALG_AES:
1390 ivlen = HIFN_AES_IV_LENGTH;
1391 break;
1392 default:
1393 ivlen = HIFN_IV_LENGTH;
1394 break;
1395 }
1396 bcopy(cmd->iv, buf_pos, ivlen);
1397 buf_pos += ivlen;
1398 }
1399
1400 if ((cmd->base_masks & (HIFN_BASE_CMD_MAC | HIFN_BASE_CMD_CRYPT |
1401 HIFN_BASE_CMD_COMP)) == 0) {
1402 bzero(buf_pos, 8);
1403 buf_pos += 8;
1404 }
1405
1406 return (buf_pos - buf);
1407 }
1408
1409 int
1410 hifn_dmamap_aligned(bus_dmamap_t map)
1411 {
1412 int i;
1413
1414 for (i = 0; i < map->dm_nsegs; i++) {
1415 if (map->dm_segs[i].ds_addr & 3)
1416 return (0);
1417 if ((i != (map->dm_nsegs - 1)) &&
1418 (map->dm_segs[i].ds_len & 3))
1419 return (0);
1420 }
1421 return (1);
1422 }
1423
1424 int
1425 hifn_dmamap_load_dst(struct hifn_softc *sc, struct hifn_command *cmd)
1426 {
1427 struct hifn_dma *dma = sc->sc_dma;
1428 bus_dmamap_t map = cmd->dst_map;
1429 u_int32_t p, l;
1430 int idx, used = 0, i;
1431
1432 idx = dma->dsti;
1433 for (i = 0; i < map->dm_nsegs - 1; i++) {
1434 dma->dstr[idx].p = htole32(map->dm_segs[i].ds_addr);
1435 dma->dstr[idx].l = htole32(HIFN_D_VALID |
1436 HIFN_D_MASKDONEIRQ | map->dm_segs[i].ds_len);
1437 HIFN_DSTR_SYNC(sc, idx,
1438 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1439 used++;
1440
1441 if (++idx == HIFN_D_DST_RSIZE) {
1442 dma->dstr[idx].l = htole32(HIFN_D_VALID |
1443 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1444 HIFN_DSTR_SYNC(sc, idx,
1445 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1446 idx = 0;
1447 }
1448 }
1449
1450 if (cmd->sloplen == 0) {
1451 p = map->dm_segs[i].ds_addr;
1452 l = HIFN_D_VALID | HIFN_D_MASKDONEIRQ | HIFN_D_LAST |
1453 map->dm_segs[i].ds_len;
1454 } else {
1455 p = sc->sc_dmamap->dm_segs[0].ds_addr +
1456 offsetof(struct hifn_dma, slop[cmd->slopidx]);
1457 l = HIFN_D_VALID | HIFN_D_MASKDONEIRQ | HIFN_D_LAST |
1458 sizeof(u_int32_t);
1459
1460 if ((map->dm_segs[i].ds_len - cmd->sloplen) != 0) {
1461 dma->dstr[idx].p = htole32(map->dm_segs[i].ds_addr);
1462 dma->dstr[idx].l = htole32(HIFN_D_VALID |
1463 HIFN_D_MASKDONEIRQ |
1464 (map->dm_segs[i].ds_len - cmd->sloplen));
1465 HIFN_DSTR_SYNC(sc, idx,
1466 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1467 used++;
1468
1469 if (++idx == HIFN_D_DST_RSIZE) {
1470 dma->dstr[idx].l = htole32(HIFN_D_VALID |
1471 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1472 HIFN_DSTR_SYNC(sc, idx,
1473 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1474 idx = 0;
1475 }
1476 }
1477 }
1478 dma->dstr[idx].p = htole32(p);
1479 dma->dstr[idx].l = htole32(l);
1480 HIFN_DSTR_SYNC(sc, idx, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1481 used++;
1482
1483 if (++idx == HIFN_D_DST_RSIZE) {
1484 dma->dstr[idx].l = htole32(HIFN_D_VALID | HIFN_D_JUMP |
1485 HIFN_D_MASKDONEIRQ);
1486 HIFN_DSTR_SYNC(sc, idx,
1487 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1488 idx = 0;
1489 }
1490
1491 dma->dsti = idx;
1492 dma->dstu += used;
1493 return (idx);
1494 }
1495
1496 int
1497 hifn_dmamap_load_src(struct hifn_softc *sc, struct hifn_command *cmd)
1498 {
1499 struct hifn_dma *dma = sc->sc_dma;
1500 bus_dmamap_t map = cmd->src_map;
1501 int idx, i;
1502 u_int32_t last = 0;
1503
1504 idx = dma->srci;
1505 for (i = 0; i < map->dm_nsegs; i++) {
1506 if (i == map->dm_nsegs - 1)
1507 last = HIFN_D_LAST;
1508
1509 dma->srcr[idx].p = htole32(map->dm_segs[i].ds_addr);
1510 dma->srcr[idx].l = htole32(map->dm_segs[i].ds_len |
1511 HIFN_D_VALID | HIFN_D_MASKDONEIRQ | last);
1512 HIFN_SRCR_SYNC(sc, idx,
1513 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1514
1515 if (++idx == HIFN_D_SRC_RSIZE) {
1516 dma->srcr[idx].l = htole32(HIFN_D_VALID |
1517 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1518 HIFN_SRCR_SYNC(sc, HIFN_D_SRC_RSIZE,
1519 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1520 idx = 0;
1521 }
1522 }
1523 dma->srci = idx;
1524 dma->srcu += map->dm_nsegs;
1525 return (idx);
1526 }
1527
1528 int
1529 hifn_crypto(struct hifn_softc *sc, struct hifn_command *cmd,
1530 struct cryptop *crp, int hint)
1531 {
1532 struct hifn_dma *dma = sc->sc_dma;
1533 u_int32_t cmdlen;
1534 int cmdi, resi, s, err = 0;
1535
1536 if (bus_dmamap_create(sc->sc_dmat, HIFN_MAX_DMALEN, MAX_SCATTER,
1537 HIFN_MAX_SEGLEN, 0, BUS_DMA_NOWAIT, &cmd->src_map))
1538 return (ENOMEM);
1539
1540 if (crp->crp_flags & CRYPTO_F_IMBUF) {
1541 if (bus_dmamap_load_mbuf(sc->sc_dmat, cmd->src_map,
1542 cmd->srcu.src_m, BUS_DMA_NOWAIT)) {
1543 err = ENOMEM;
1544 goto err_srcmap1;
1545 }
1546 } else if (crp->crp_flags & CRYPTO_F_IOV) {
1547 if (bus_dmamap_load_uio(sc->sc_dmat, cmd->src_map,
1548 cmd->srcu.src_io, BUS_DMA_NOWAIT)) {
1549 err = ENOMEM;
1550 goto err_srcmap1;
1551 }
1552 } else {
1553 err = EINVAL;
1554 goto err_srcmap1;
1555 }
1556
1557 if (hifn_dmamap_aligned(cmd->src_map)) {
1558 cmd->sloplen = cmd->src_map->dm_mapsize & 3;
1559 if (crp->crp_flags & CRYPTO_F_IOV)
1560 cmd->dstu.dst_io = cmd->srcu.src_io;
1561 else if (crp->crp_flags & CRYPTO_F_IMBUF)
1562 cmd->dstu.dst_m = cmd->srcu.src_m;
1563 cmd->dst_map = cmd->src_map;
1564 } else {
1565 if (crp->crp_flags & CRYPTO_F_IOV) {
1566 err = EINVAL;
1567 goto err_srcmap;
1568 } else if (crp->crp_flags & CRYPTO_F_IMBUF) {
1569 int totlen, len;
1570 struct mbuf *m, *m0, *mlast;
1571
1572 totlen = cmd->src_map->dm_mapsize;
1573 if (cmd->srcu.src_m->m_flags & M_PKTHDR) {
1574 len = MHLEN;
1575 MGETHDR(m0, M_DONTWAIT, MT_DATA);
1576 } else {
1577 len = MLEN;
1578 MGET(m0, M_DONTWAIT, MT_DATA);
1579 }
1580 if (m0 == NULL) {
1581 err = ENOMEM;
1582 goto err_srcmap;
1583 }
1584 if (len == MHLEN)
1585 M_DUP_PKTHDR(m0, cmd->srcu.src_m);
1586 if (totlen >= MINCLSIZE) {
1587 MCLGET(m0, M_DONTWAIT);
1588 if (m0->m_flags & M_EXT)
1589 len = MCLBYTES;
1590 }
1591 totlen -= len;
1592 m0->m_pkthdr.len = m0->m_len = len;
1593 mlast = m0;
1594
1595 while (totlen > 0) {
1596 MGET(m, M_DONTWAIT, MT_DATA);
1597 if (m == NULL) {
1598 err = ENOMEM;
1599 m_freem(m0);
1600 goto err_srcmap;
1601 }
1602 len = MLEN;
1603 if (totlen >= MINCLSIZE) {
1604 MCLGET(m, M_DONTWAIT);
1605 if (m->m_flags & M_EXT)
1606 len = MCLBYTES;
1607 }
1608
1609 m->m_len = len;
1610 if (m0->m_flags & M_PKTHDR)
1611 m0->m_pkthdr.len += len;
1612 totlen -= len;
1613
1614 mlast->m_next = m;
1615 mlast = m;
1616 }
1617 cmd->dstu.dst_m = m0;
1618 }
1619 }
1620
1621 if (cmd->dst_map == NULL) {
1622 if (bus_dmamap_create(sc->sc_dmat,
1623 HIFN_MAX_SEGLEN * MAX_SCATTER, MAX_SCATTER,
1624 HIFN_MAX_SEGLEN, 0, BUS_DMA_NOWAIT, &cmd->dst_map)) {
1625 err = ENOMEM;
1626 goto err_srcmap;
1627 }
1628 if (crp->crp_flags & CRYPTO_F_IMBUF) {
1629 if (bus_dmamap_load_mbuf(sc->sc_dmat, cmd->dst_map,
1630 cmd->dstu.dst_m, BUS_DMA_NOWAIT)) {
1631 err = ENOMEM;
1632 goto err_dstmap1;
1633 }
1634 } else if (crp->crp_flags & CRYPTO_F_IOV) {
1635 if (bus_dmamap_load_uio(sc->sc_dmat, cmd->dst_map,
1636 cmd->dstu.dst_io, BUS_DMA_NOWAIT)) {
1637 err = ENOMEM;
1638 goto err_dstmap1;
1639 }
1640 }
1641 }
1642
1643 #ifdef HIFN_DEBUG
1644 if (hifn_debug)
1645 printf("%s: Entering cmd: stat %8x ien %8x u %d/%d/%d/%d n %d/%d\n",
1646 sc->sc_dv.dv_xname,
1647 READ_REG_1(sc, HIFN_1_DMA_CSR),
1648 READ_REG_1(sc, HIFN_1_DMA_IER),
1649 dma->cmdu, dma->srcu, dma->dstu, dma->resu,
1650 cmd->src_map->dm_nsegs, cmd->dst_map->dm_nsegs);
1651 #endif
1652
1653 if (cmd->src_map == cmd->dst_map)
1654 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
1655 0, cmd->src_map->dm_mapsize,
1656 BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
1657 else {
1658 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
1659 0, cmd->src_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
1660 bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
1661 0, cmd->dst_map->dm_mapsize, BUS_DMASYNC_PREREAD);
1662 }
1663
1664 s = splnet();
1665
1666 /*
1667 * need 1 cmd, and 1 res
1668 * need N src, and N dst
1669 */
1670 if ((dma->cmdu + 1) > HIFN_D_CMD_RSIZE ||
1671 (dma->resu + 1) > HIFN_D_RES_RSIZE) {
1672 splx(s);
1673 err = ENOMEM;
1674 goto err_dstmap;
1675 }
1676 if ((dma->srcu + cmd->src_map->dm_nsegs) > HIFN_D_SRC_RSIZE ||
1677 (dma->dstu + cmd->dst_map->dm_nsegs + 1) > HIFN_D_DST_RSIZE) {
1678 splx(s);
1679 err = ENOMEM;
1680 goto err_dstmap;
1681 }
1682
1683 if (dma->cmdi == HIFN_D_CMD_RSIZE) {
1684 dma->cmdi = 0;
1685 dma->cmdr[HIFN_D_CMD_RSIZE].l = htole32(HIFN_D_VALID |
1686 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1687 HIFN_CMDR_SYNC(sc, HIFN_D_CMD_RSIZE,
1688 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1689 }
1690 cmdi = dma->cmdi++;
1691 cmdlen = hifn_write_command(cmd, dma->command_bufs[cmdi]);
1692 HIFN_CMD_SYNC(sc, cmdi, BUS_DMASYNC_PREWRITE);
1693
1694 /* .p for command/result already set */
1695 dma->cmdr[cmdi].l = htole32(cmdlen | HIFN_D_VALID | HIFN_D_LAST |
1696 HIFN_D_MASKDONEIRQ);
1697 HIFN_CMDR_SYNC(sc, cmdi,
1698 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1699 dma->cmdu++;
1700 if (sc->sc_c_busy == 0) {
1701 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_C_CTRL_ENA);
1702 sc->sc_c_busy = 1;
1703 SET_LED(sc, HIFN_MIPSRST_LED0);
1704 }
1705
1706 /*
1707 * We don't worry about missing an interrupt (which a "command wait"
1708 * interrupt salvages us from), unless there is more than one command
1709 * in the queue.
1710 */
1711 if (dma->cmdu > 1) {
1712 sc->sc_dmaier |= HIFN_DMAIER_C_WAIT;
1713 WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
1714 }
1715
1716 hifnstats.hst_ipackets++;
1717 hifnstats.hst_ibytes += cmd->src_map->dm_mapsize;
1718
1719 hifn_dmamap_load_src(sc, cmd);
1720 if (sc->sc_s_busy == 0) {
1721 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_S_CTRL_ENA);
1722 sc->sc_s_busy = 1;
1723 SET_LED(sc, HIFN_MIPSRST_LED1);
1724 }
1725
1726 /*
1727 * Unlike other descriptors, we don't mask done interrupt from
1728 * result descriptor.
1729 */
1730 #ifdef HIFN_DEBUG
1731 if (hifn_debug)
1732 printf("load res\n");
1733 #endif
1734 if (dma->resi == HIFN_D_RES_RSIZE) {
1735 dma->resi = 0;
1736 dma->resr[HIFN_D_RES_RSIZE].l = htole32(HIFN_D_VALID |
1737 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
1738 HIFN_RESR_SYNC(sc, HIFN_D_RES_RSIZE,
1739 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1740 }
1741 resi = dma->resi++;
1742 dma->hifn_commands[resi] = cmd;
1743 HIFN_RES_SYNC(sc, resi, BUS_DMASYNC_PREREAD);
1744 dma->resr[resi].l = htole32(HIFN_MAX_RESULT |
1745 HIFN_D_VALID | HIFN_D_LAST);
1746 HIFN_RESR_SYNC(sc, resi,
1747 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1748 dma->resu++;
1749 if (sc->sc_r_busy == 0) {
1750 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_R_CTRL_ENA);
1751 sc->sc_r_busy = 1;
1752 SET_LED(sc, HIFN_MIPSRST_LED2);
1753 }
1754
1755 if (cmd->sloplen)
1756 cmd->slopidx = resi;
1757
1758 hifn_dmamap_load_dst(sc, cmd);
1759
1760 if (sc->sc_d_busy == 0) {
1761 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_D_CTRL_ENA);
1762 sc->sc_d_busy = 1;
1763 }
1764
1765 #ifdef HIFN_DEBUG
1766 if (hifn_debug)
1767 printf("%s: command: stat %8x ier %8x\n",
1768 sc->sc_dv.dv_xname,
1769 READ_REG_1(sc, HIFN_1_DMA_CSR), READ_REG_1(sc, HIFN_1_DMA_IER));
1770 #endif
1771
1772 sc->sc_active = 5;
1773 splx(s);
1774 return (err); /* success */
1775
1776 err_dstmap:
1777 if (cmd->src_map != cmd->dst_map)
1778 bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
1779 err_dstmap1:
1780 if (cmd->src_map != cmd->dst_map)
1781 bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
1782 err_srcmap:
1783 if (crp->crp_flags & CRYPTO_F_IMBUF &&
1784 cmd->srcu.src_m != cmd->dstu.dst_m)
1785 m_freem(cmd->dstu.dst_m);
1786 bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
1787 err_srcmap1:
1788 bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
1789 return (err);
1790 }
1791
1792 void
1793 hifn_tick(void *vsc)
1794 {
1795 struct hifn_softc *sc = vsc;
1796 int s;
1797
1798 s = splnet();
1799 if (sc->sc_active == 0) {
1800 struct hifn_dma *dma = sc->sc_dma;
1801 u_int32_t r = 0;
1802
1803 if (dma->cmdu == 0 && sc->sc_c_busy) {
1804 sc->sc_c_busy = 0;
1805 r |= HIFN_DMACSR_C_CTRL_DIS;
1806 CLR_LED(sc, HIFN_MIPSRST_LED0);
1807 }
1808 if (dma->srcu == 0 && sc->sc_s_busy) {
1809 sc->sc_s_busy = 0;
1810 r |= HIFN_DMACSR_S_CTRL_DIS;
1811 CLR_LED(sc, HIFN_MIPSRST_LED1);
1812 }
1813 if (dma->dstu == 0 && sc->sc_d_busy) {
1814 sc->sc_d_busy = 0;
1815 r |= HIFN_DMACSR_D_CTRL_DIS;
1816 }
1817 if (dma->resu == 0 && sc->sc_r_busy) {
1818 sc->sc_r_busy = 0;
1819 r |= HIFN_DMACSR_R_CTRL_DIS;
1820 CLR_LED(sc, HIFN_MIPSRST_LED2);
1821 }
1822 if (r)
1823 WRITE_REG_1(sc, HIFN_1_DMA_CSR, r);
1824 }
1825 else
1826 sc->sc_active--;
1827 splx(s);
1828 #ifdef __OpenBSD__
1829 timeout_add(&sc->sc_tickto, hz);
1830 #else
1831 callout_reset(&sc->sc_tickto, hz, hifn_tick, sc);
1832 #endif
1833 }
1834
1835 int
1836 hifn_intr(void *arg)
1837 {
1838 struct hifn_softc *sc = arg;
1839 struct hifn_dma *dma = sc->sc_dma;
1840 u_int32_t dmacsr, restart;
1841 int i, u;
1842
1843 dmacsr = READ_REG_1(sc, HIFN_1_DMA_CSR);
1844
1845 #ifdef HIFN_DEBUG
1846 if (hifn_debug)
1847 printf("%s: irq: stat %08x ien %08x u %d/%d/%d/%d\n",
1848 sc->sc_dv.dv_xname,
1849 dmacsr, READ_REG_1(sc, HIFN_1_DMA_IER),
1850 dma->cmdu, dma->srcu, dma->dstu, dma->resu);
1851 #endif
1852
1853 /* Nothing in the DMA unit interrupted */
1854 if ((dmacsr & sc->sc_dmaier) == 0)
1855 return (0);
1856
1857 WRITE_REG_1(sc, HIFN_1_DMA_CSR, dmacsr & sc->sc_dmaier);
1858
1859 if (dmacsr & HIFN_DMACSR_ENGINE)
1860 WRITE_REG_0(sc, HIFN_0_PUISR, READ_REG_0(sc, HIFN_0_PUISR));
1861
1862 if ((sc->sc_flags & HIFN_HAS_PUBLIC) &&
1863 (dmacsr & HIFN_DMACSR_PUBDONE))
1864 WRITE_REG_1(sc, HIFN_1_PUB_STATUS,
1865 READ_REG_1(sc, HIFN_1_PUB_STATUS) | HIFN_PUBSTS_DONE);
1866
1867 restart = dmacsr & (HIFN_DMACSR_R_OVER | HIFN_DMACSR_D_OVER);
1868 if (restart)
1869 printf("%s: overrun %x\n", sc->sc_dv.dv_xname, dmacsr);
1870
1871 if (sc->sc_flags & HIFN_IS_7811) {
1872 if (dmacsr & HIFN_DMACSR_ILLR)
1873 printf("%s: illegal read\n", sc->sc_dv.dv_xname);
1874 if (dmacsr & HIFN_DMACSR_ILLW)
1875 printf("%s: illegal write\n", sc->sc_dv.dv_xname);
1876 }
1877
1878 restart = dmacsr & (HIFN_DMACSR_C_ABORT | HIFN_DMACSR_S_ABORT |
1879 HIFN_DMACSR_D_ABORT | HIFN_DMACSR_R_ABORT);
1880 if (restart) {
1881 printf("%s: abort, resetting.\n", sc->sc_dv.dv_xname);
1882 hifnstats.hst_abort++;
1883 hifn_abort(sc);
1884 return (1);
1885 }
1886
1887 if ((dmacsr & HIFN_DMACSR_C_WAIT) && (dma->resu == 0)) {
1888 /*
1889 * If no slots to process and we receive a "waiting on
1890 * command" interrupt, we disable the "waiting on command"
1891 * (by clearing it).
1892 */
1893 sc->sc_dmaier &= ~HIFN_DMAIER_C_WAIT;
1894 WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
1895 }
1896
1897 /* clear the rings */
1898 i = dma->resk;
1899 while (dma->resu != 0) {
1900 HIFN_RESR_SYNC(sc, i,
1901 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1902 if (dma->resr[i].l & htole32(HIFN_D_VALID)) {
1903 HIFN_RESR_SYNC(sc, i,
1904 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1905 break;
1906 }
1907
1908 if (i != HIFN_D_RES_RSIZE) {
1909 struct hifn_command *cmd;
1910 u_int8_t *macbuf = NULL;
1911
1912 HIFN_RES_SYNC(sc, i, BUS_DMASYNC_POSTREAD);
1913 cmd = dma->hifn_commands[i];
1914 KASSERT(cmd != NULL
1915 /*("hifn_intr: null command slot %u", i)*/);
1916 dma->hifn_commands[i] = NULL;
1917
1918 if (cmd->base_masks & HIFN_BASE_CMD_MAC) {
1919 macbuf = dma->result_bufs[i];
1920 macbuf += 12;
1921 }
1922
1923 hifn_callback(sc, cmd, macbuf);
1924 hifnstats.hst_opackets++;
1925 }
1926
1927 if (++i == (HIFN_D_RES_RSIZE + 1))
1928 i = 0;
1929 else
1930 dma->resu--;
1931 }
1932 dma->resk = i;
1933
1934 i = dma->srck; u = dma->srcu;
1935 while (u != 0) {
1936 HIFN_SRCR_SYNC(sc, i,
1937 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1938 if (dma->srcr[i].l & htole32(HIFN_D_VALID)) {
1939 HIFN_SRCR_SYNC(sc, i,
1940 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1941 break;
1942 }
1943 if (++i == (HIFN_D_SRC_RSIZE + 1))
1944 i = 0;
1945 else
1946 u--;
1947 }
1948 dma->srck = i; dma->srcu = u;
1949
1950 i = dma->cmdk; u = dma->cmdu;
1951 while (u != 0) {
1952 HIFN_CMDR_SYNC(sc, i,
1953 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1954 if (dma->cmdr[i].l & htole32(HIFN_D_VALID)) {
1955 HIFN_CMDR_SYNC(sc, i,
1956 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1957 break;
1958 }
1959 if (i != HIFN_D_CMD_RSIZE) {
1960 u--;
1961 HIFN_CMD_SYNC(sc, i, BUS_DMASYNC_POSTWRITE);
1962 }
1963 if (++i == (HIFN_D_CMD_RSIZE + 1))
1964 i = 0;
1965 }
1966 dma->cmdk = i; dma->cmdu = u;
1967
1968 return (1);
1969 }
1970
1971 /*
1972 * Allocate a new 'session' and return an encoded session id. 'sidp'
1973 * contains our registration id, and should contain an encoded session
1974 * id on successful allocation.
1975 */
1976 int
1977 hifn_newsession(void *arg, u_int32_t *sidp, struct cryptoini *cri)
1978 {
1979 struct cryptoini *c;
1980 struct hifn_softc *sc = arg;
1981 int i, mac = 0, cry = 0, comp = 0;
1982
1983 KASSERT(sc != NULL /*, ("hifn_newsession: null softc")*/);
1984 if (sidp == NULL || cri == NULL || sc == NULL)
1985 return (EINVAL);
1986
1987 for (i = 0; i < sc->sc_maxses; i++)
1988 if (sc->sc_sessions[i].hs_state == HS_STATE_FREE)
1989 break;
1990 if (i == sc->sc_maxses)
1991 return (ENOMEM);
1992
1993 for (c = cri; c != NULL; c = c->cri_next) {
1994 switch (c->cri_alg) {
1995 case CRYPTO_MD5:
1996 case CRYPTO_SHA1:
1997 case CRYPTO_MD5_HMAC:
1998 case CRYPTO_SHA1_HMAC:
1999 if (mac)
2000 return (EINVAL);
2001 mac = 1;
2002 break;
2003 case CRYPTO_DES_CBC:
2004 case CRYPTO_3DES_CBC:
2005 case CRYPTO_AES_CBC:
2006 #ifdef __NetBSD__
2007 rnd_extract_data(sc->sc_sessions[i].hs_iv,
2008 c->cri_alg == CRYPTO_AES_CBC ?
2009 HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH,
2010 RND_EXTRACT_ANY);
2011 #else /* FreeBSD and OpenBSD have get_random_bytes */
2012 /* XXX this may read fewer, does it matter? */
2013 get_random_bytes(sc->sc_sessions[i].hs_iv,
2014 c->cri_alg == CRYPTO_AES_CBC ?
2015 HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
2016 #endif
2017 /*FALLTHROUGH*/
2018 case CRYPTO_ARC4:
2019 if (cry)
2020 return (EINVAL);
2021 cry = 1;
2022 break;
2023 #ifdef HAVE_CRYPTO_LSZ
2024 case CRYPTO_LZS_COMP:
2025 if (comp)
2026 return (EINVAL);
2027 comp = 1;
2028 break;
2029 #endif
2030 default:
2031 return (EINVAL);
2032 }
2033 }
2034 if (mac == 0 && cry == 0 && comp == 0)
2035 return (EINVAL);
2036
2037 /*
2038 * XXX only want to support compression without chaining to
2039 * MAC/crypt engine right now
2040 */
2041 if ((comp && mac) || (comp && cry))
2042 return (EINVAL);
2043
2044 *sidp = HIFN_SID(sc->sc_dv.dv_unit, i);
2045 sc->sc_sessions[i].hs_state = HS_STATE_USED;
2046
2047 return (0);
2048 }
2049
2050 /*
2051 * Deallocate a session.
2052 * XXX this routine should run a zero'd mac/encrypt key into context ram.
2053 * XXX to blow away any keys already stored there.
2054 */
2055 int
2056 hifn_freesession(void *arg, u_int64_t tid)
2057 {
2058 struct hifn_softc *sc = arg;
2059 int session;
2060 u_int32_t sid = ((u_int32_t) tid) & 0xffffffff;
2061
2062 KASSERT(sc != NULL /*, ("hifn_freesession: null softc")*/);
2063 if (sc == NULL)
2064 return (EINVAL);
2065
2066 session = HIFN_SESSION(sid);
2067 if (session >= sc->sc_maxses)
2068 return (EINVAL);
2069
2070 bzero(&sc->sc_sessions[session], sizeof(sc->sc_sessions[session]));
2071 return (0);
2072 }
2073
2074 int
2075 hifn_process(void *arg, struct cryptop *crp, int hint)
2076 {
2077 struct hifn_softc *sc = arg;
2078 struct hifn_command *cmd = NULL;
2079 int session, err, ivlen;
2080 struct cryptodesc *crd1, *crd2, *maccrd, *enccrd;
2081
2082 if (crp == NULL || crp->crp_callback == NULL) {
2083 hifnstats.hst_invalid++;
2084 return (EINVAL);
2085 }
2086 session = HIFN_SESSION(crp->crp_sid);
2087
2088 if (sc == NULL || session >= sc->sc_maxses) {
2089 err = EINVAL;
2090 goto errout;
2091 }
2092
2093 cmd = (struct hifn_command *)malloc(sizeof(struct hifn_command),
2094 M_DEVBUF, M_NOWAIT|M_ZERO);
2095 if (cmd == NULL) {
2096 hifnstats.hst_nomem++;
2097 err = ENOMEM;
2098 goto errout;
2099 }
2100
2101 if (crp->crp_flags & CRYPTO_F_IMBUF) {
2102 cmd->srcu.src_m = (struct mbuf *)crp->crp_buf;
2103 cmd->dstu.dst_m = (struct mbuf *)crp->crp_buf;
2104 } else if (crp->crp_flags & CRYPTO_F_IOV) {
2105 cmd->srcu.src_io = (struct uio *)crp->crp_buf;
2106 cmd->dstu.dst_io = (struct uio *)crp->crp_buf;
2107 } else {
2108 err = EINVAL;
2109 goto errout; /* XXX we don't handle contiguous buffers! */
2110 }
2111
2112 crd1 = crp->crp_desc;
2113 if (crd1 == NULL) {
2114 err = EINVAL;
2115 goto errout;
2116 }
2117 crd2 = crd1->crd_next;
2118
2119 if (crd2 == NULL) {
2120 if (crd1->crd_alg == CRYPTO_MD5_HMAC ||
2121 crd1->crd_alg == CRYPTO_SHA1_HMAC ||
2122 crd1->crd_alg == CRYPTO_SHA1 ||
2123 crd1->crd_alg == CRYPTO_MD5) {
2124 maccrd = crd1;
2125 enccrd = NULL;
2126 } else if (crd1->crd_alg == CRYPTO_DES_CBC ||
2127 crd1->crd_alg == CRYPTO_3DES_CBC ||
2128 crd1->crd_alg == CRYPTO_AES_CBC ||
2129 crd1->crd_alg == CRYPTO_ARC4) {
2130 if ((crd1->crd_flags & CRD_F_ENCRYPT) == 0)
2131 cmd->base_masks |= HIFN_BASE_CMD_DECODE;
2132 maccrd = NULL;
2133 enccrd = crd1;
2134 #ifdef HAVE_CRYPTO_LSZ
2135 } else if (crd1->crd_alg == CRYPTO_LZS_COMP) {
2136 return (hifn_compression(sc, crp, cmd));
2137 #endif
2138 } else {
2139 err = EINVAL;
2140 goto errout;
2141 }
2142 } else {
2143 if ((crd1->crd_alg == CRYPTO_MD5_HMAC ||
2144 crd1->crd_alg == CRYPTO_SHA1_HMAC ||
2145 crd1->crd_alg == CRYPTO_MD5 ||
2146 crd1->crd_alg == CRYPTO_SHA1) &&
2147 (crd2->crd_alg == CRYPTO_DES_CBC ||
2148 crd2->crd_alg == CRYPTO_3DES_CBC ||
2149 crd2->crd_alg == CRYPTO_AES_CBC ||
2150 crd2->crd_alg == CRYPTO_ARC4) &&
2151 ((crd2->crd_flags & CRD_F_ENCRYPT) == 0)) {
2152 cmd->base_masks = HIFN_BASE_CMD_DECODE;
2153 maccrd = crd1;
2154 enccrd = crd2;
2155 } else if ((crd1->crd_alg == CRYPTO_DES_CBC ||
2156 crd1->crd_alg == CRYPTO_ARC4 ||
2157 crd1->crd_alg == CRYPTO_3DES_CBC ||
2158 crd1->crd_alg == CRYPTO_AES_CBC) &&
2159 (crd2->crd_alg == CRYPTO_MD5_HMAC ||
2160 crd2->crd_alg == CRYPTO_SHA1_HMAC ||
2161 crd2->crd_alg == CRYPTO_MD5 ||
2162 crd2->crd_alg == CRYPTO_SHA1) &&
2163 (crd1->crd_flags & CRD_F_ENCRYPT)) {
2164 enccrd = crd1;
2165 maccrd = crd2;
2166 } else {
2167 /*
2168 * We cannot order the 7751 as requested
2169 */
2170 err = EINVAL;
2171 goto errout;
2172 }
2173 }
2174
2175 if (enccrd) {
2176 cmd->enccrd = enccrd;
2177 cmd->base_masks |= HIFN_BASE_CMD_CRYPT;
2178 switch (enccrd->crd_alg) {
2179 case CRYPTO_ARC4:
2180 cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_RC4;
2181 if ((enccrd->crd_flags & CRD_F_ENCRYPT)
2182 != sc->sc_sessions[session].hs_prev_op)
2183 sc->sc_sessions[session].hs_state =
2184 HS_STATE_USED;
2185 break;
2186 case CRYPTO_DES_CBC:
2187 cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_DES |
2188 HIFN_CRYPT_CMD_MODE_CBC |
2189 HIFN_CRYPT_CMD_NEW_IV;
2190 break;
2191 case CRYPTO_3DES_CBC:
2192 cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_3DES |
2193 HIFN_CRYPT_CMD_MODE_CBC |
2194 HIFN_CRYPT_CMD_NEW_IV;
2195 break;
2196 case CRYPTO_AES_CBC:
2197 cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_AES |
2198 HIFN_CRYPT_CMD_MODE_CBC |
2199 HIFN_CRYPT_CMD_NEW_IV;
2200 break;
2201 default:
2202 err = EINVAL;
2203 goto errout;
2204 }
2205 if (enccrd->crd_alg != CRYPTO_ARC4) {
2206 ivlen = ((enccrd->crd_alg == CRYPTO_AES_CBC) ?
2207 HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
2208 if (enccrd->crd_flags & CRD_F_ENCRYPT) {
2209 if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)
2210 bcopy(enccrd->crd_iv, cmd->iv, ivlen);
2211 else
2212 bcopy(sc->sc_sessions[session].hs_iv,
2213 cmd->iv, ivlen);
2214
2215 if ((enccrd->crd_flags & CRD_F_IV_PRESENT)
2216 == 0) {
2217 if (crp->crp_flags & CRYPTO_F_IMBUF)
2218 m_copyback(cmd->srcu.src_m,
2219 enccrd->crd_inject,
2220 ivlen, cmd->iv);
2221 else if (crp->crp_flags & CRYPTO_F_IOV)
2222 cuio_copyback(cmd->srcu.src_io,
2223 enccrd->crd_inject,
2224 ivlen, cmd->iv);
2225 }
2226 } else {
2227 if (enccrd->crd_flags & CRD_F_IV_EXPLICIT)
2228 bcopy(enccrd->crd_iv, cmd->iv, ivlen);
2229 else if (crp->crp_flags & CRYPTO_F_IMBUF)
2230 m_copydata(cmd->srcu.src_m,
2231 enccrd->crd_inject, ivlen, cmd->iv);
2232 else if (crp->crp_flags & CRYPTO_F_IOV)
2233 cuio_copydata(cmd->srcu.src_io,
2234 enccrd->crd_inject, ivlen, cmd->iv);
2235 }
2236 }
2237
2238 cmd->ck = enccrd->crd_key;
2239 cmd->cklen = enccrd->crd_klen >> 3;
2240
2241 /*
2242 * Need to specify the size for the AES key in the masks.
2243 */
2244 if ((cmd->cry_masks & HIFN_CRYPT_CMD_ALG_MASK) ==
2245 HIFN_CRYPT_CMD_ALG_AES) {
2246 switch (cmd->cklen) {
2247 case 16:
2248 cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_128;
2249 break;
2250 case 24:
2251 cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_192;
2252 break;
2253 case 32:
2254 cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_256;
2255 break;
2256 default:
2257 err = EINVAL;
2258 goto errout;
2259 }
2260 }
2261
2262 if (sc->sc_sessions[session].hs_state == HS_STATE_USED)
2263 cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY;
2264 }
2265
2266 if (maccrd) {
2267 cmd->maccrd = maccrd;
2268 cmd->base_masks |= HIFN_BASE_CMD_MAC;
2269
2270 switch (maccrd->crd_alg) {
2271 case CRYPTO_MD5:
2272 cmd->mac_masks |= HIFN_MAC_CMD_ALG_MD5 |
2273 HIFN_MAC_CMD_RESULT | HIFN_MAC_CMD_MODE_HASH |
2274 HIFN_MAC_CMD_POS_IPSEC;
2275 break;
2276 case CRYPTO_MD5_HMAC:
2277 cmd->mac_masks |= HIFN_MAC_CMD_ALG_MD5 |
2278 HIFN_MAC_CMD_RESULT | HIFN_MAC_CMD_MODE_HMAC |
2279 HIFN_MAC_CMD_POS_IPSEC | HIFN_MAC_CMD_TRUNC;
2280 break;
2281 case CRYPTO_SHA1:
2282 cmd->mac_masks |= HIFN_MAC_CMD_ALG_SHA1 |
2283 HIFN_MAC_CMD_RESULT | HIFN_MAC_CMD_MODE_HASH |
2284 HIFN_MAC_CMD_POS_IPSEC;
2285 break;
2286 case CRYPTO_SHA1_HMAC:
2287 cmd->mac_masks |= HIFN_MAC_CMD_ALG_SHA1 |
2288 HIFN_MAC_CMD_RESULT | HIFN_MAC_CMD_MODE_HMAC |
2289 HIFN_MAC_CMD_POS_IPSEC | HIFN_MAC_CMD_TRUNC;
2290 break;
2291 }
2292
2293 if ((maccrd->crd_alg == CRYPTO_SHA1_HMAC ||
2294 maccrd->crd_alg == CRYPTO_MD5_HMAC) &&
2295 sc->sc_sessions[session].hs_state == HS_STATE_USED) {
2296 cmd->mac_masks |= HIFN_MAC_CMD_NEW_KEY;
2297 bcopy(maccrd->crd_key, cmd->mac, maccrd->crd_klen >> 3);
2298 bzero(cmd->mac + (maccrd->crd_klen >> 3),
2299 HIFN_MAC_KEY_LENGTH - (maccrd->crd_klen >> 3));
2300 }
2301 }
2302
2303 cmd->crp = crp;
2304 cmd->session_num = session;
2305 cmd->softc = sc;
2306
2307 err = hifn_crypto(sc, cmd, crp, hint);
2308 if (err == 0) {
2309 if (enccrd)
2310 sc->sc_sessions[session].hs_prev_op =
2311 enccrd->crd_flags & CRD_F_ENCRYPT;
2312 if (sc->sc_sessions[session].hs_state == HS_STATE_USED)
2313 sc->sc_sessions[session].hs_state = HS_STATE_KEY;
2314 return 0;
2315 } else if (err == ERESTART) {
2316 /*
2317 * There weren't enough resources to dispatch the request
2318 * to the part. Notify the caller so they'll requeue this
2319 * request and resubmit it again soon.
2320 */
2321 #ifdef HIFN_DEBUG
2322 if (hifn_debug)
2323 printf(sc->sc_dv.dv_xname, "requeue request\n");
2324 #endif
2325 free(cmd, M_DEVBUF);
2326 sc->sc_needwakeup |= CRYPTO_SYMQ;
2327 return (err);
2328 }
2329
2330 errout:
2331 if (cmd != NULL)
2332 free(cmd, M_DEVBUF);
2333 if (err == EINVAL)
2334 hifnstats.hst_invalid++;
2335 else
2336 hifnstats.hst_nomem++;
2337 crp->crp_etype = err;
2338 crypto_done(crp);
2339 return (0);
2340 }
2341
2342 void
2343 hifn_abort(struct hifn_softc *sc)
2344 {
2345 struct hifn_dma *dma = sc->sc_dma;
2346 struct hifn_command *cmd;
2347 struct cryptop *crp;
2348 int i, u;
2349
2350 i = dma->resk; u = dma->resu;
2351 while (u != 0) {
2352 cmd = dma->hifn_commands[i];
2353 KASSERT(cmd != NULL /*, ("hifn_abort: null cmd slot %u", i)*/);
2354 dma->hifn_commands[i] = NULL;
2355 crp = cmd->crp;
2356
2357 if ((dma->resr[i].l & htole32(HIFN_D_VALID)) == 0) {
2358 /* Salvage what we can. */
2359 u_int8_t *macbuf;
2360
2361 if (cmd->base_masks & HIFN_BASE_CMD_MAC) {
2362 macbuf = dma->result_bufs[i];
2363 macbuf += 12;
2364 } else
2365 macbuf = NULL;
2366 hifnstats.hst_opackets++;
2367 hifn_callback(sc, cmd, macbuf);
2368 } else {
2369 if (cmd->src_map == cmd->dst_map) {
2370 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2371 0, cmd->src_map->dm_mapsize,
2372 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
2373 } else {
2374 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2375 0, cmd->src_map->dm_mapsize,
2376 BUS_DMASYNC_POSTWRITE);
2377 bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
2378 0, cmd->dst_map->dm_mapsize,
2379 BUS_DMASYNC_POSTREAD);
2380 }
2381
2382 if (cmd->srcu.src_m != cmd->dstu.dst_m) {
2383 m_freem(cmd->srcu.src_m);
2384 crp->crp_buf = (caddr_t)cmd->dstu.dst_m;
2385 }
2386
2387 /* non-shared buffers cannot be restarted */
2388 if (cmd->src_map != cmd->dst_map) {
2389 /*
2390 * XXX should be EAGAIN, delayed until
2391 * after the reset.
2392 */
2393 crp->crp_etype = ENOMEM;
2394 bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
2395 bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
2396 } else
2397 crp->crp_etype = ENOMEM;
2398
2399 bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
2400 bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
2401
2402 free(cmd, M_DEVBUF);
2403 if (crp->crp_etype != EAGAIN)
2404 crypto_done(crp);
2405 }
2406
2407 if (++i == HIFN_D_RES_RSIZE)
2408 i = 0;
2409 u--;
2410 }
2411 dma->resk = i; dma->resu = u;
2412
2413 /* Force upload of key next time */
2414 for (i = 0; i < sc->sc_maxses; i++)
2415 if (sc->sc_sessions[i].hs_state == HS_STATE_KEY)
2416 sc->sc_sessions[i].hs_state = HS_STATE_USED;
2417
2418 hifn_reset_board(sc, 1);
2419 hifn_init_dma(sc);
2420 hifn_init_pci_registers(sc);
2421 }
2422
2423 void
2424 hifn_callback(struct hifn_softc *sc, struct hifn_command *cmd, u_int8_t *resbuf)
2425 {
2426 struct hifn_dma *dma = sc->sc_dma;
2427 struct cryptop *crp = cmd->crp;
2428 struct cryptodesc *crd;
2429 struct mbuf *m;
2430 int totlen, i, u, ivlen;
2431
2432 if (cmd->src_map == cmd->dst_map)
2433 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2434 0, cmd->src_map->dm_mapsize,
2435 BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
2436 else {
2437 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2438 0, cmd->src_map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
2439 bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
2440 0, cmd->dst_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
2441 }
2442
2443 if (crp->crp_flags & CRYPTO_F_IMBUF) {
2444 if (cmd->srcu.src_m != cmd->dstu.dst_m) {
2445 crp->crp_buf = (caddr_t)cmd->dstu.dst_m;
2446 totlen = cmd->src_map->dm_mapsize;
2447 for (m = cmd->dstu.dst_m; m != NULL; m = m->m_next) {
2448 if (totlen < m->m_len) {
2449 m->m_len = totlen;
2450 totlen = 0;
2451 } else
2452 totlen -= m->m_len;
2453 }
2454 cmd->dstu.dst_m->m_pkthdr.len =
2455 cmd->srcu.src_m->m_pkthdr.len;
2456 m_freem(cmd->srcu.src_m);
2457 }
2458 }
2459
2460 if (cmd->sloplen != 0) {
2461 if (crp->crp_flags & CRYPTO_F_IMBUF)
2462 m_copyback((struct mbuf *)crp->crp_buf,
2463 cmd->src_map->dm_mapsize - cmd->sloplen,
2464 cmd->sloplen, (caddr_t)&dma->slop[cmd->slopidx]);
2465 else if (crp->crp_flags & CRYPTO_F_IOV)
2466 cuio_copyback((struct uio *)crp->crp_buf,
2467 cmd->src_map->dm_mapsize - cmd->sloplen,
2468 cmd->sloplen, (caddr_t)&dma->slop[cmd->slopidx]);
2469 }
2470
2471 i = dma->dstk; u = dma->dstu;
2472 while (u != 0) {
2473 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
2474 offsetof(struct hifn_dma, dstr[i]), sizeof(struct hifn_desc),
2475 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
2476 if (dma->dstr[i].l & htole32(HIFN_D_VALID)) {
2477 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
2478 offsetof(struct hifn_dma, dstr[i]),
2479 sizeof(struct hifn_desc),
2480 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2481 break;
2482 }
2483 if (++i == (HIFN_D_DST_RSIZE + 1))
2484 i = 0;
2485 else
2486 u--;
2487 }
2488 dma->dstk = i; dma->dstu = u;
2489
2490 hifnstats.hst_obytes += cmd->dst_map->dm_mapsize;
2491
2492 if ((cmd->base_masks & (HIFN_BASE_CMD_CRYPT | HIFN_BASE_CMD_DECODE)) ==
2493 HIFN_BASE_CMD_CRYPT) {
2494 for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
2495 if (crd->crd_alg != CRYPTO_DES_CBC &&
2496 crd->crd_alg != CRYPTO_3DES_CBC &&
2497 crd->crd_alg != CRYPTO_AES_CBC)
2498 continue;
2499 ivlen = ((crd->crd_alg == CRYPTO_AES_CBC) ?
2500 HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
2501 if (crp->crp_flags & CRYPTO_F_IMBUF)
2502 m_copydata((struct mbuf *)crp->crp_buf,
2503 crd->crd_skip + crd->crd_len - ivlen,
2504 ivlen,
2505 cmd->softc->sc_sessions[cmd->session_num].hs_iv);
2506 else if (crp->crp_flags & CRYPTO_F_IOV) {
2507 cuio_copydata((struct uio *)crp->crp_buf,
2508 crd->crd_skip + crd->crd_len - ivlen,
2509 ivlen,
2510 cmd->softc->sc_sessions[cmd->session_num].hs_iv);
2511 }
2512 /* XXX We do not handle contig data */
2513 break;
2514 }
2515 }
2516
2517 if (cmd->base_masks & HIFN_BASE_CMD_MAC) {
2518 u_int8_t *macbuf;
2519
2520 macbuf = resbuf + sizeof(struct hifn_base_result);
2521 if (cmd->base_masks & HIFN_BASE_CMD_COMP)
2522 macbuf += sizeof(struct hifn_comp_result);
2523 macbuf += sizeof(struct hifn_mac_result);
2524
2525 for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
2526 int len;
2527
2528 if (crd->crd_alg == CRYPTO_MD5)
2529 len = 16;
2530 else if (crd->crd_alg == CRYPTO_SHA1)
2531 len = 20;
2532 else if (crd->crd_alg == CRYPTO_MD5_HMAC ||
2533 crd->crd_alg == CRYPTO_SHA1_HMAC)
2534 len = 12;
2535 else
2536 continue;
2537
2538 if (crp->crp_flags & CRYPTO_F_IMBUF)
2539 m_copyback((struct mbuf *)crp->crp_buf,
2540 crd->crd_inject, len, macbuf);
2541 else if ((crp->crp_flags & CRYPTO_F_IOV) && crp->crp_mac)
2542 bcopy((caddr_t)macbuf, crp->crp_mac, len);
2543 break;
2544 }
2545 }
2546
2547 if (cmd->src_map != cmd->dst_map) {
2548 bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
2549 bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
2550 }
2551 bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
2552 bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
2553 free(cmd, M_DEVBUF);
2554 crypto_done(crp);
2555 }
2556
2557 #ifdef HAVE_CRYPTO_LSZ
2558
2559 int
2560 hifn_compression(struct hifn_softc *sc, struct cryptop *crp,
2561 struct hifn_command *cmd)
2562 {
2563 struct cryptodesc *crd = crp->crp_desc;
2564 int s, err = 0;
2565
2566 cmd->compcrd = crd;
2567 cmd->base_masks |= HIFN_BASE_CMD_COMP;
2568
2569 if ((crp->crp_flags & CRYPTO_F_IMBUF) == 0) {
2570 /*
2571 * XXX can only handle mbufs right now since we can
2572 * XXX dynamically resize them.
2573 */
2574 err = EINVAL;
2575 return (ENOMEM);
2576 }
2577
2578 if ((crd->crd_flags & CRD_F_COMP) == 0)
2579 cmd->base_masks |= HIFN_BASE_CMD_DECODE;
2580 if (crd->crd_alg == CRYPTO_LZS_COMP)
2581 cmd->comp_masks |= HIFN_COMP_CMD_ALG_LZS |
2582 HIFN_COMP_CMD_CLEARHIST;
2583
2584 if (bus_dmamap_create(sc->sc_dmat, HIFN_MAX_DMALEN, MAX_SCATTER,
2585 HIFN_MAX_SEGLEN, 0, BUS_DMA_NOWAIT, &cmd->src_map)) {
2586 err = ENOMEM;
2587 goto fail;
2588 }
2589
2590 if (bus_dmamap_create(sc->sc_dmat, HIFN_MAX_DMALEN, MAX_SCATTER,
2591 HIFN_MAX_SEGLEN, 0, BUS_DMA_NOWAIT, &cmd->dst_map)) {
2592 err = ENOMEM;
2593 goto fail;
2594 }
2595
2596 if (crp->crp_flags & CRYPTO_F_IMBUF) {
2597 int len;
2598
2599 if (bus_dmamap_load_mbuf(sc->sc_dmat, cmd->src_map,
2600 cmd->srcu.src_m, BUS_DMA_NOWAIT)) {
2601 err = ENOMEM;
2602 goto fail;
2603 }
2604
2605 len = cmd->src_map->dm_mapsize / MCLBYTES;
2606 if ((cmd->src_map->dm_mapsize % MCLBYTES) != 0)
2607 len++;
2608 len *= MCLBYTES;
2609
2610 if ((crd->crd_flags & CRD_F_COMP) == 0)
2611 len *= 4;
2612
2613 if (len > HIFN_MAX_DMALEN)
2614 len = HIFN_MAX_DMALEN;
2615
2616 cmd->dstu.dst_m = hifn_mkmbuf_chain(len, cmd->srcu.src_m);
2617 if (cmd->dstu.dst_m == NULL) {
2618 err = ENOMEM;
2619 goto fail;
2620 }
2621
2622 if (bus_dmamap_load_mbuf(sc->sc_dmat, cmd->dst_map,
2623 cmd->dstu.dst_m, BUS_DMA_NOWAIT)) {
2624 err = ENOMEM;
2625 goto fail;
2626 }
2627 } else if (crp->crp_flags & CRYPTO_F_IOV) {
2628 if (bus_dmamap_load_uio(sc->sc_dmat, cmd->src_map,
2629 cmd->srcu.src_io, BUS_DMA_NOWAIT)) {
2630 err = ENOMEM;
2631 goto fail;
2632 }
2633 if (bus_dmamap_load_uio(sc->sc_dmat, cmd->dst_map,
2634 cmd->dstu.dst_io, BUS_DMA_NOWAIT)) {
2635 err = ENOMEM;
2636 goto fail;
2637 }
2638 }
2639
2640 if (cmd->src_map == cmd->dst_map)
2641 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2642 0, cmd->src_map->dm_mapsize,
2643 BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
2644 else {
2645 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2646 0, cmd->src_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
2647 bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
2648 0, cmd->dst_map->dm_mapsize, BUS_DMASYNC_PREREAD);
2649 }
2650
2651 cmd->crp = crp;
2652 /*
2653 * Always use session 0. The modes of compression we use are
2654 * stateless and there is always at least one compression
2655 * context, zero.
2656 */
2657 cmd->session_num = 0;
2658 cmd->softc = sc;
2659
2660 s = splnet();
2661 err = hifn_compress_enter(sc, cmd);
2662 splx(s);
2663
2664 if (err != 0)
2665 goto fail;
2666 return (0);
2667
2668 fail:
2669 if (cmd->dst_map != NULL) {
2670 if (cmd->dst_map->dm_nsegs > 0)
2671 bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
2672 bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
2673 }
2674 if (cmd->src_map != NULL) {
2675 if (cmd->src_map->dm_nsegs > 0)
2676 bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
2677 bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
2678 }
2679 free(cmd, M_DEVBUF);
2680 if (err == EINVAL)
2681 hifnstats.hst_invalid++;
2682 else
2683 hifnstats.hst_nomem++;
2684 crp->crp_etype = err;
2685 crypto_done(crp);
2686 return (0);
2687 }
2688
2689 /*
2690 * must be called at splnet()
2691 */
2692 int
2693 hifn_compress_enter(struct hifn_softc *sc, struct hifn_command *cmd)
2694 {
2695 struct hifn_dma *dma = sc->sc_dma;
2696 int cmdi, resi;
2697 u_int32_t cmdlen;
2698
2699 if ((dma->cmdu + 1) > HIFN_D_CMD_RSIZE ||
2700 (dma->resu + 1) > HIFN_D_CMD_RSIZE)
2701 return (ENOMEM);
2702
2703 if ((dma->srcu + cmd->src_map->dm_nsegs) > HIFN_D_SRC_RSIZE ||
2704 (dma->dstu + cmd->dst_map->dm_nsegs) > HIFN_D_DST_RSIZE)
2705 return (ENOMEM);
2706
2707 if (dma->cmdi == HIFN_D_CMD_RSIZE) {
2708 dma->cmdi = 0;
2709 dma->cmdr[HIFN_D_CMD_RSIZE].l = htole32(HIFN_D_VALID |
2710 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
2711 HIFN_CMDR_SYNC(sc, HIFN_D_CMD_RSIZE,
2712 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
2713 }
2714 cmdi = dma->cmdi++;
2715 cmdlen = hifn_write_command(cmd, dma->command_bufs[cmdi]);
2716 HIFN_CMD_SYNC(sc, cmdi, BUS_DMASYNC_PREWRITE);
2717
2718 /* .p for command/result already set */
2719 dma->cmdr[cmdi].l = htole32(cmdlen | HIFN_D_VALID | HIFN_D_LAST |
2720 HIFN_D_MASKDONEIRQ);
2721 HIFN_CMDR_SYNC(sc, cmdi,
2722 BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
2723 dma->cmdu++;
2724 if (sc->sc_c_busy == 0) {
2725 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_C_CTRL_ENA);
2726 sc->sc_c_busy = 1;
2727 SET_LED(sc, HIFN_MIPSRST_LED0);
2728 }
2729
2730 /*
2731 * We don't worry about missing an interrupt (which a "command wait"
2732 * interrupt salvages us from), unless there is more than one command
2733 * in the queue.
2734 */
2735 if (dma->cmdu > 1) {
2736 sc->sc_dmaier |= HIFN_DMAIER_C_WAIT;
2737 WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
2738 }
2739
2740 hifnstats.hst_ipackets++;
2741 hifnstats.hst_ibytes += cmd->src_map->dm_mapsize;
2742
2743 hifn_dmamap_load_src(sc, cmd);
2744 if (sc->sc_s_busy == 0) {
2745 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_S_CTRL_ENA);
2746 sc->sc_s_busy = 1;
2747 SET_LED(sc, HIFN_MIPSRST_LED1);
2748 }
2749
2750 /*
2751 * Unlike other descriptors, we don't mask done interrupt from
2752 * result descriptor.
2753 */
2754 if (dma->resi == HIFN_D_RES_RSIZE) {
2755 dma->resi = 0;
2756 dma->resr[HIFN_D_RES_RSIZE].l = htole32(HIFN_D_VALID |
2757 HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
2758 HIFN_RESR_SYNC(sc, HIFN_D_RES_RSIZE,
2759 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2760 }
2761 resi = dma->resi++;
2762 dma->hifn_commands[resi] = cmd;
2763 HIFN_RES_SYNC(sc, resi, BUS_DMASYNC_PREREAD);
2764 dma->resr[resi].l = htole32(HIFN_MAX_RESULT |
2765 HIFN_D_VALID | HIFN_D_LAST);
2766 HIFN_RESR_SYNC(sc, resi,
2767 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2768 dma->resu++;
2769 if (sc->sc_r_busy == 0) {
2770 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_R_CTRL_ENA);
2771 sc->sc_r_busy = 1;
2772 SET_LED(sc, HIFN_MIPSRST_LED2);
2773 }
2774
2775 if (cmd->sloplen)
2776 cmd->slopidx = resi;
2777
2778 hifn_dmamap_load_dst(sc, cmd);
2779
2780 if (sc->sc_d_busy == 0) {
2781 WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_D_CTRL_ENA);
2782 sc->sc_d_busy = 1;
2783 }
2784 sc->sc_active = 5;
2785 cmd->cmd_callback = hifn_callback_comp;
2786 return (0);
2787 }
2788
2789 void
2790 hifn_callback_comp(struct hifn_softc *sc, struct hifn_command *cmd,
2791 u_int8_t *resbuf)
2792 {
2793 struct hifn_base_result baseres;
2794 struct cryptop *crp = cmd->crp;
2795 struct hifn_dma *dma = sc->sc_dma;
2796 struct mbuf *m;
2797 int err = 0, i, u;
2798 u_int32_t olen;
2799 bus_size_t dstsize;
2800
2801 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2802 0, cmd->src_map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
2803 bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
2804 0, cmd->dst_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
2805
2806 dstsize = cmd->dst_map->dm_mapsize;
2807 bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
2808
2809 bcopy(resbuf, &baseres, sizeof(struct hifn_base_result));
2810
2811 i = dma->dstk; u = dma->dstu;
2812 while (u != 0) {
2813 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
2814 offsetof(struct hifn_dma, dstr[i]), sizeof(struct hifn_desc),
2815 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
2816 if (dma->dstr[i].l & htole32(HIFN_D_VALID)) {
2817 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap,
2818 offsetof(struct hifn_dma, dstr[i]),
2819 sizeof(struct hifn_desc),
2820 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2821 break;
2822 }
2823 if (++i == (HIFN_D_DST_RSIZE + 1))
2824 i = 0;
2825 else
2826 u--;
2827 }
2828 dma->dstk = i; dma->dstu = u;
2829
2830 if (baseres.flags & htole16(HIFN_BASE_RES_DSTOVERRUN)) {
2831 bus_size_t xlen;
2832
2833 xlen = dstsize;
2834
2835 m_freem(cmd->dstu.dst_m);
2836
2837 if (xlen == HIFN_MAX_DMALEN) {
2838 /* We've done all we can. */
2839 err = E2BIG;
2840 goto out;
2841 }
2842
2843 xlen += MCLBYTES;
2844
2845 if (xlen > HIFN_MAX_DMALEN)
2846 xlen = HIFN_MAX_DMALEN;
2847
2848 cmd->dstu.dst_m = hifn_mkmbuf_chain(xlen,
2849 cmd->srcu.src_m);
2850 if (cmd->dstu.dst_m == NULL) {
2851 err = ENOMEM;
2852 goto out;
2853 }
2854 if (bus_dmamap_load_mbuf(sc->sc_dmat, cmd->dst_map,
2855 cmd->dstu.dst_m, BUS_DMA_NOWAIT)) {
2856 err = ENOMEM;
2857 goto out;
2858 }
2859
2860 bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
2861 0, cmd->src_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
2862 bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
2863 0, cmd->dst_map->dm_mapsize, BUS_DMASYNC_PREREAD);
2864
2865 /* already at splnet... */
2866 err = hifn_compress_enter(sc, cmd);
2867 if (err != 0)
2868 goto out;
2869 return;
2870 }
2871
2872 olen = dstsize - (letoh16(baseres.dst_cnt) |
2873 (((letoh16(baseres.session) & HIFN_BASE_RES_DSTLEN_M) >>
2874 HIFN_BASE_RES_DSTLEN_S) << 16));
2875
2876 crp->crp_olen = olen - cmd->compcrd->crd_skip;
2877
2878 bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
2879 bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
2880 bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
2881
2882 m = cmd->dstu.dst_m;
2883 if (m->m_flags & M_PKTHDR)
2884 m->m_pkthdr.len = olen;
2885 crp->crp_buf = (caddr_t)m;
2886 for (; m != NULL; m = m->m_next) {
2887 if (olen >= m->m_len)
2888 olen -= m->m_len;
2889 else {
2890 m->m_len = olen;
2891 olen = 0;
2892 }
2893 }
2894
2895 m_freem(cmd->srcu.src_m);
2896 free(cmd, M_DEVBUF);
2897 crp->crp_etype = 0;
2898 crypto_done(crp);
2899 return;
2900
2901 out:
2902 if (cmd->dst_map != NULL) {
2903 if (cmd->src_map->dm_nsegs != 0)
2904 bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
2905 bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
2906 }
2907 if (cmd->src_map != NULL) {
2908 if (cmd->src_map->dm_nsegs != 0)
2909 bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
2910 bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
2911 }
2912 if (cmd->dstu.dst_m != NULL)
2913 m_freem(cmd->dstu.dst_m);
2914 free(cmd, M_DEVBUF);
2915 crp->crp_etype = err;
2916 crypto_done(crp);
2917 }
2918
2919 struct mbuf *
2920 hifn_mkmbuf_chain(int totlen, struct mbuf *mtemplate)
2921 {
2922 int len;
2923 struct mbuf *m, *m0, *mlast;
2924
2925 if (mtemplate->m_flags & M_PKTHDR) {
2926 len = MHLEN;
2927 MGETHDR(m0, M_DONTWAIT, MT_DATA);
2928 } else {
2929 len = MLEN;
2930 MGET(m0, M_DONTWAIT, MT_DATA);
2931 }
2932 if (m0 == NULL)
2933 return (NULL);
2934 if (len == MHLEN)
2935 M_DUP_PKTHDR(m0, mtemplate);
2936 MCLGET(m0, M_DONTWAIT);
2937 if (!(m0->m_flags & M_EXT))
2938 m_freem(m0);
2939 len = MCLBYTES;
2940
2941 totlen -= len;
2942 m0->m_pkthdr.len = m0->m_len = len;
2943 mlast = m0;
2944
2945 while (totlen > 0) {
2946 MGET(m, M_DONTWAIT, MT_DATA);
2947 if (m == NULL) {
2948 m_freem(m0);
2949 return (NULL);
2950 }
2951 MCLGET(m, M_DONTWAIT);
2952 if (!(m->m_flags & M_EXT)) {
2953 m_freem(m0);
2954 return (NULL);
2955 }
2956 len = MCLBYTES;
2957 m->m_len = len;
2958 if (m0->m_flags & M_PKTHDR)
2959 m0->m_pkthdr.len += len;
2960 totlen -= len;
2961
2962 mlast->m_next = m;
2963 mlast = m;
2964 }
2965
2966 return (m0);
2967 }
2968 #endif /* HAVE_CRYPTO_LSZ */
2969
2970 void
2971 hifn_write_4(struct hifn_softc *sc, int reggrp, bus_size_t reg, u_int32_t val)
2972 {
2973 /*
2974 * 7811 PB3 rev/2 parts lock-up on burst writes to Group 0
2975 * and Group 1 registers; avoid conditions that could create
2976 * burst writes by doing a read in between the writes.
2977 */
2978 if (sc->sc_flags & HIFN_NO_BURSTWRITE) {
2979 if (sc->sc_waw_lastgroup == reggrp &&
2980 sc->sc_waw_lastreg == reg - 4) {
2981 bus_space_read_4(sc->sc_st1, sc->sc_sh1, HIFN_1_REVID);
2982 }
2983 sc->sc_waw_lastgroup = reggrp;
2984 sc->sc_waw_lastreg = reg;
2985 }
2986 if (reggrp == 0)
2987 bus_space_write_4(sc->sc_st0, sc->sc_sh0, reg, val);
2988 else
2989 bus_space_write_4(sc->sc_st1, sc->sc_sh1, reg, val);
2990
2991 }
2992
2993 u_int32_t
2994 hifn_read_4(struct hifn_softc *sc, int reggrp, bus_size_t reg)
2995 {
2996 if (sc->sc_flags & HIFN_NO_BURSTWRITE) {
2997 sc->sc_waw_lastgroup = -1;
2998 sc->sc_waw_lastreg = 1;
2999 }
3000 if (reggrp == 0)
3001 return (bus_space_read_4(sc->sc_st0, sc->sc_sh0, reg));
3002 return (bus_space_read_4(sc->sc_st1, sc->sc_sh1, reg));
3003 }
Cache object: 6e7a85267ea17ad3179f5855a31cee5c
|