1 /* $NetBSD: oboe.c,v 1.51 2021/09/26 14:56:36 thorpej Exp $ */
2
3 /* XXXXFVDL THIS DRIVER IS BROKEN FOR NON-i386 -- vtophys() usage */
4
5 /*-
6 * Copyright (c) 2001 The NetBSD Foundation, Inc.
7 * All rights reserved.
8 *
9 * This code is derived from software contributed to The NetBSD Foundation
10 * by Jan Sparud.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 /*
35 * Toshiba OBOE IrDA SIR/FIR driver.
36 *
37 * Based on information from the Linux driver, thus the magic hex numbers.
38 */
39
40 #include <sys/cdefs.h>
41 __KERNEL_RCSID(0, "$NetBSD: oboe.c,v 1.51 2021/09/26 14:56:36 thorpej Exp $");
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/kernel.h>
46 #include <sys/device.h>
47 #include <sys/malloc.h>
48 #include <sys/tty.h>
49 #include <sys/vnode.h>
50 #include <sys/poll.h>
51 #include <sys/proc.h>
52
53 #include <dev/ir/ir.h>
54 #include <dev/ir/irdaio.h>
55 #include <dev/ir/irframevar.h>
56 #include <dev/ir/sir.h>
57
58 #include <dev/pci/pcidevs.h>
59 #include <dev/pci/pcivar.h>
60
61 #include <sys/bus.h>
62 #include <sys/intr.h>
63
64 #include <dev/pci/oboereg.h>
65
66 static int oboe_match(device_t parent, cfdata_t match, void *aux);
67 static void oboe_attach(device_t parent, device_t self, void *aux);
68 static int oboe_detach(device_t self, int flags);
69
70 static int oboe_open(void *h, int flag, int mode, struct lwp *l);
71 static int oboe_close(void *h, int flag, int mode, struct lwp *l);
72 static int oboe_read(void *h, struct uio *uio, int flag);
73 static int oboe_write(void *h, struct uio *uio, int flag);
74 static int oboe_set_params(void *h, struct irda_params *params);
75 static int oboe_get_speeds(void *h, int *speeds);
76 static int oboe_get_turnarounds(void *h, int *times);
77 static int oboe_poll(void *h, int events, struct lwp *l);
78 static int oboe_kqfilter(void *h, struct knote *kn);
79
80 #ifdef OBOE_DEBUG
81 #define DPRINTF(x) if (oboedebug) printf x
82 int oboedebug = 1;
83 #else
84 #define DPRINTF(x)
85 #endif
86
87 struct oboe_dma;
88
89 struct oboe_softc {
90 device_t sc_child;
91 struct pci_attach_args sc_pa;
92 pci_intr_handle_t * sc_ih;
93 unsigned int sc_revision; /* PCI Revision ID */
94 /* I/O Base device */
95 bus_space_tag_t sc_iot;
96 bus_space_handle_t sc_ioh;
97 bus_dma_tag_t sc_dmatag;
98 struct selinfo sc_rsel;
99
100 int sc_state;
101 #define OBOE_RSLP 0x01 /* waiting for data (read) */
102 #define OBOE_WSLP 0x02 /* waiting for data (write) */
103 #define OBOE_CLOSING 0x04 /* waiting for output to drain */
104
105 int sc_speeds;
106 int sc_flags;
107 int sc_speed;
108 int sc_ebofs;
109
110 struct oboe_dma *sc_dmas;
111 struct OboeTaskFile *sc_taskfile; /* The taskfile */
112 u_char * sc_xmit_bufs[TX_SLOTS];
113 u_char * sc_recv_bufs[RX_SLOTS];
114 void * sc_xmit_stores[TX_SLOTS];
115 void * sc_recv_stores[RX_SLOTS];
116 int sc_txs; /* Current transmit slot number */
117 int sc_rxs; /* Current receive slot number */
118 int sc_saved; /* number of saved frames */
119 int sc_lens[RX_SLOTS];
120
121 int sc_txpending;
122
123 /* Statistics */
124 int sc_txpackets;
125 int sc_rxpackets;
126 int sc_txerrors;
127 int sc_rxerrors;
128 };
129
130 static int oboe_intr(void *handle);
131 static int oboe_reset(struct oboe_softc *);
132
133 struct oboe_dma {
134 bus_dmamap_t map;
135 void *addr;
136 bus_dma_segment_t segs[1];
137 int nsegs;
138 size_t size;
139 struct oboe_dma *next;
140 };
141
142 #define DMAADDR(p) ((p)->map->dm_segs[0].ds_addr)
143 #define KERNADDR(p) ((void *)((p)->addr))
144
145 static int oboe_alloc_taskfile(struct oboe_softc *);
146 static void oboe_init_taskfile(struct oboe_softc *);
147 static void oboe_startchip(struct oboe_softc *);
148 static void oboe_stopchip(struct oboe_softc *);
149 static int oboe_setbaud(struct oboe_softc *, int);
150
151 CFATTACH_DECL_NEW(oboe, sizeof(struct oboe_softc),
152 oboe_match, oboe_attach, oboe_detach, NULL);
153
154 static struct irframe_methods oboe_methods = {
155 oboe_open, oboe_close, oboe_read, oboe_write, oboe_poll,
156 oboe_kqfilter, oboe_set_params, oboe_get_speeds, oboe_get_turnarounds
157 };
158
159 static int
oboe_match(device_t parent,cfdata_t match,void * aux)160 oboe_match(device_t parent, cfdata_t match, void *aux)
161 {
162 struct pci_attach_args *pa = aux;
163
164 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_TOSHIBA2 &&
165 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_TOSHIBA2_OBOE ||
166 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_TOSHIBA2_DONAUOBOE))
167 return (1);
168 return 0;
169 }
170
171 static void
oboe_attach(device_t parent,device_t self,void * aux)172 oboe_attach(device_t parent, device_t self, void *aux)
173 {
174 struct oboe_softc *sc = device_private(self);
175 struct pci_attach_args *pa = aux;
176 pci_intr_handle_t ih;
177 struct ir_attach_args ia;
178 const char *intrstring;
179 char intrbuf[PCI_INTRSTR_LEN];
180
181 sc->sc_revision = PCI_REVISION(pa->pa_class);
182 printf(": Toshiba Fast Infrared Type O, revision %d\n",
183 sc->sc_revision);
184
185 /* Map I/O registers. */
186 if (pci_mapreg_map(pa, IO_BAR, PCI_MAPREG_TYPE_IO, 0,
187 &sc->sc_iot, &sc->sc_ioh, NULL, NULL)) {
188 aprint_error_dev(self, "can't map I/O space\n");
189 return;
190 }
191
192 sc->sc_dmatag = pa->pa_dmat;
193
194 ia.ia_type = IR_TYPE_IRFRAME;
195 ia.ia_methods = &oboe_methods;
196 ia.ia_handle = sc;
197
198 sc->sc_state = 0;
199 sc->sc_speed = IRDA_SPEED_9600;
200
201 /* Enable the device */
202 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
203 pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG) |
204 PCI_COMMAND_MASTER_ENABLE);
205
206 /* Reset the device; bail out upon failure. */
207 if (oboe_reset(sc) != 0) {
208 aprint_error_dev(self, "can't reset\n");
209 return;
210 }
211 /* Map and establish the interrupt. */
212 if (pci_intr_map(pa, &ih)) {
213 aprint_error_dev(self, "couldn't map interrupt\n");
214 return;
215 }
216 intrstring = pci_intr_string(pa->pa_pc, ih, intrbuf, sizeof(intrbuf));
217 sc->sc_ih = pci_intr_establish_xname(pa->pa_pc, ih, IPL_IR, oboe_intr,
218 sc, device_xname(self));
219 if (sc->sc_ih == NULL) {
220 aprint_error_dev(self, "couldn't establish interrupt");
221 if (intrstring != NULL)
222 aprint_error(" at %s", intrstring);
223 aprint_error("\n");
224 return;
225 }
226 aprint_normal_dev(self, "interrupting at %s\n", intrstring);
227
228 selinit(&sc->sc_rsel);
229
230 sc->sc_txs = 0;
231 sc->sc_rxs = 0;
232
233 sc->sc_speeds =
234 IRDA_SPEED_2400 | IRDA_SPEED_9600 | IRDA_SPEED_19200 |
235 IRDA_SPEED_38400 | IRDA_SPEED_57600 | IRDA_SPEED_115200 |
236 IRDA_SPEED_576000 | IRDA_SPEED_1152000 | IRDA_SPEED_4000000;
237
238 oboe_alloc_taskfile(sc);
239
240 sc->sc_child = config_found(self, &ia, ir_print, CFARGS_NONE);
241 }
242
243 static int
oboe_detach(device_t self,int flags)244 oboe_detach(device_t self, int flags)
245 {
246 struct oboe_softc *sc = device_private(self);
247
248 #ifdef OBOE_DEBUG
249 /* XXX needs reference counting for proper detach. */
250 DPRINTF(("%s: sc=%p\n", __func__, sc));
251 #endif
252 seldestroy(&sc->sc_rsel);
253 return (0);
254 }
255
256 static int
oboe_open(void * h,int flag,int mode,struct lwp * l)257 oboe_open(void *h, int flag, int mode, struct lwp *l)
258 {
259 struct oboe_softc *sc = h;
260
261 DPRINTF(("%s: sc=%p\n", __func__, sc));
262
263 sc->sc_state = 0;
264 sc->sc_saved = 0;
265 oboe_init_taskfile(sc);
266 oboe_startchip(sc);
267
268 return (0);
269 }
270
271 static int
oboe_close(void * h,int flag,int mode,struct lwp * l)272 oboe_close(void *h, int flag, int mode,
273 struct lwp *l)
274 {
275 struct oboe_softc *sc = h;
276 int error = 0;
277 int s = splir();
278
279 DPRINTF(("%s: sc=%p\n", __func__, sc));
280 /* Wait for output to drain */
281
282 if (sc->sc_txpending > 0) {
283 sc->sc_state |= OBOE_CLOSING;
284 error = tsleep(&sc->sc_state, PZERO | PCATCH, "oboecl", hz/10);
285 }
286 splx(s);
287
288 oboe_stopchip(sc);
289 return (error);
290 }
291
292 static int
oboe_read(void * h,struct uio * uio,int flag)293 oboe_read(void *h, struct uio *uio, int flag)
294 {
295 struct oboe_softc *sc = h;
296 int error = 0;
297 int s;
298 int slot;
299
300 DPRINTF(("%s: resid=%zu, iovcnt=%d, offset=%jd\n",
301 __func__, uio->uio_resid, uio->uio_iovcnt,
302 (intmax_t)uio->uio_offset));
303
304 s = splir();
305 while (sc->sc_saved == 0) {
306 if (flag & IO_NDELAY) {
307 splx(s);
308 return (EWOULDBLOCK);
309 }
310 sc->sc_state |= OBOE_RSLP;
311 DPRINTF(("oboe_read: sleep\n"));
312 error = tsleep(&sc->sc_rxs, PZERO | PCATCH, "oboerd", 0);
313 DPRINTF(("oboe_read: woke, error=%d\n", error));
314 if (error) {
315 sc->sc_state &= ~OBOE_RSLP;
316 break;
317 }
318 }
319
320 /* Do just one frame transfer per read */
321
322 if (!error) {
323 slot = (sc->sc_rxs - sc->sc_saved + RX_SLOTS) % RX_SLOTS;
324 if (uio->uio_resid < sc->sc_lens[slot]) {
325 DPRINTF(("oboe_read: uio buffer smaller than frame size"
326 "(%zu < %d)\n", uio->uio_resid, sc->sc_lens[slot]));
327 error = EINVAL;
328 } else {
329 DPRINTF(("oboe_read: moving %d bytes from %p\n",
330 sc->sc_lens[slot],
331 sc->sc_recv_stores[slot]));
332 error = uiomove(sc->sc_recv_stores[slot],
333 sc->sc_lens[slot], uio);
334 }
335 }
336 sc->sc_saved--;
337 splx(s);
338
339 return (error);
340 }
341
342 static int
oboe_write(void * h,struct uio * uio,int flag)343 oboe_write(void *h, struct uio *uio, int flag)
344 {
345 struct oboe_softc *sc = h;
346 int error = 0;
347 int n;
348 int s = splir();
349
350 DPRINTF(("%s: sc=%p\n", __func__, sc));
351 while (sc->sc_txpending == TX_SLOTS) {
352 if (flag & IO_NDELAY) {
353 splx(s);
354 return (EWOULDBLOCK);
355 }
356 sc->sc_state |= OBOE_WSLP;
357 DPRINTF(("oboe_write: sleep\n"));
358 error = tsleep(&sc->sc_txs, PZERO | PCATCH, "oboewr", 0);
359 DPRINTF(("oboe_write: woke up, error=%d\n", error));
360 if (error) {
361 sc->sc_state &= ~OBOE_WSLP;
362 break;
363 }
364 }
365 if (error)
366 goto err;
367 if (sc->sc_taskfile->xmit[sc->sc_txs].control) {
368 DPRINTF(("oboe_write: slot overrun\n"));
369 }
370
371 n = irda_sir_frame(sc->sc_xmit_bufs[sc->sc_txs], TX_BUF_SZ, uio,
372 sc->sc_ebofs);
373 if (n < 0) {
374 error = -n;
375 goto err;
376 }
377 sc->sc_taskfile->xmit[sc->sc_txs].len = n;
378
379 OUTB(sc, 0, OBOE_RST);
380 OUTB(sc, 0x1e, OBOE_REG_11);
381
382 sc->sc_taskfile->xmit[sc->sc_txs].control = 0x84;
383
384 /* XXX Need delay here??? */
385 delay(1000);
386
387 sc->sc_txpending++;
388 OUTB(sc, 0x80, OBOE_RST);
389 OUTB(sc, 1, OBOE_REG_9);
390 sc->sc_txs++;
391 sc->sc_txs %= TX_SLOTS;
392
393 err:
394 splx(s);
395 return (error);
396 }
397
398 static int
oboe_set_params(void * h,struct irda_params * p)399 oboe_set_params(void *h, struct irda_params *p)
400 {
401 struct oboe_softc *sc = h;
402 int error;
403
404 if (p->speed > 0) {
405 error = oboe_setbaud(sc, p->speed);
406 if (error)
407 return (error);
408 }
409 sc->sc_ebofs = p->ebofs;
410
411 /* XXX ignore ebofs and maxsize for now */
412 return (0);
413 }
414
415 static int
oboe_get_speeds(void * h,int * speeds)416 oboe_get_speeds(void *h, int *speeds)
417 {
418 struct oboe_softc *sc = h;
419 *speeds = sc->sc_speeds;
420 return (0);
421 }
422
423 static int
oboe_get_turnarounds(void * h,int * turnarounds)424 oboe_get_turnarounds(void *h, int *turnarounds)
425 {
426 #ifdef OBOE_DEBUG
427 struct oboe_softc *sc = h;
428 DPRINTF(("%s: sc=%p\n", __func__, sc));
429 #endif
430
431 /* XXX Linux driver sets all bits */
432 *turnarounds = IRDA_TURNT_10000; /* 10ms */
433
434 return (0);
435 }
436
437 static int
oboe_poll(void * h,int events,struct lwp * l)438 oboe_poll(void *h, int events, struct lwp *l)
439 {
440 struct oboe_softc *sc = h;
441 int revents = 0;
442 int s;
443
444 DPRINTF(("%s: sc=%p\n", __func__, sc));
445
446 s = splir();
447 if (events & (POLLOUT | POLLWRNORM))
448 revents |= events & (POLLOUT | POLLWRNORM);
449 if (events & (POLLIN | POLLRDNORM)) {
450 if (sc->sc_saved > 0) {
451 DPRINTF(("%s: have data\n", __func__));
452 revents |= events & (POLLIN | POLLRDNORM);
453 } else {
454 DPRINTF(("%s: recording select\n", __func__));
455 selrecord(l, &sc->sc_rsel);
456 }
457 }
458 splx(s);
459
460 return (revents);
461 }
462
463 static void
filt_oboerdetach(struct knote * kn)464 filt_oboerdetach(struct knote *kn)
465 {
466 struct oboe_softc *sc = kn->kn_hook;
467 int s;
468
469 s = splir();
470 selremove_knote(&sc->sc_rsel, kn);
471 splx(s);
472 }
473
474 static int
filt_oboeread(struct knote * kn,long hint)475 filt_oboeread(struct knote *kn, long hint)
476 {
477 struct oboe_softc *sc = kn->kn_hook;
478
479 kn->kn_data = sc->sc_saved;
480 return (kn->kn_data > 0);
481 }
482
483 static const struct filterops oboeread_filtops = {
484 .f_flags = FILTEROP_ISFD,
485 .f_attach = NULL,
486 .f_detach = filt_oboerdetach,
487 .f_event = filt_oboeread,
488 };
489
490 static int
oboe_kqfilter(void * h,struct knote * kn)491 oboe_kqfilter(void *h, struct knote *kn)
492 {
493 struct oboe_softc *sc = h;
494 int s;
495
496 switch (kn->kn_filter) {
497 case EVFILT_READ:
498 kn->kn_fop = &oboeread_filtops;
499 kn->kn_hook = sc;
500 s = splir();
501 selrecord_knote(&sc->sc_rsel, kn);
502 splx(s);
503 break;
504
505 case EVFILT_WRITE:
506 kn->kn_fop = &seltrue_filtops;
507 break;
508 default:
509 return (EINVAL);
510 }
511
512 return (0);
513 }
514
515 static int
oboe_reset(struct oboe_softc * sc)516 oboe_reset(struct oboe_softc *sc)
517 {
518 #if 0
519 OUTB(sc, 0x00, OBOE_RST);
520 OUTB(sc, 0x80, OBOE_RST);
521 #endif
522 return 0;
523 }
524
525 static int
oboe_intr(void * p)526 oboe_intr(void *p)
527 {
528 struct oboe_softc *sc = p;
529 uint8_t irqstat = INB(sc, OBOE_ISR);
530
531 if (!(irqstat & 0xf8))
532 return (0); /* Not for me? */
533
534 DPRINTF(("oboe_intr stat=0x%x\n", irqstat));
535
536 OUTB(sc, irqstat, OBOE_ISR);
537
538 if (irqstat & OBOE_ISR_RXDONE) {
539 while (sc->sc_taskfile->recv[sc->sc_rxs].control == 0) {
540 int len = sc->sc_taskfile->recv[sc->sc_rxs].len;
541 if (sc->sc_saved == RX_SLOTS) {
542 DPRINTF(("oboe_intr: all buffers filled\n"));
543 return 0;
544 }
545
546 if (len > 2)
547 len -= 2; /* JSP: skip check sum? */
548
549 DPRINTF(("oboe_intr: moving %d bytes to %p\n", len,
550 sc->sc_recv_stores[sc->sc_rxs]));
551 memcpy(sc->sc_recv_stores[sc->sc_rxs],
552 sc->sc_recv_bufs[sc->sc_rxs],
553 len);
554 sc->sc_lens[sc->sc_rxs] = len;
555 sc->sc_saved++;
556 #if 0
557 (void)b_to_q(sc->sc_recv_bufs[sc->sc_rxs],
558 len, &sc->sc_q);
559 #endif
560 sc->sc_taskfile->recv[sc->sc_rxs].control = 0x83;
561 sc->sc_taskfile->recv[sc->sc_rxs].len = 0x0;
562 sc->sc_rxs = (sc->sc_rxs + 1) % RX_SLOTS;
563 DPRINTF(("oboe_intr new rxs=%d\n", sc->sc_rxs));
564 }
565 DPRINTF(("oboe_intr no more frames available\n"));
566 if (sc->sc_state & OBOE_RSLP) {
567 DPRINTF(("oboe_intr changing state to ~OBOE_RSLP\n"));
568 sc->sc_state &= ~OBOE_RSLP;
569 DPRINTF(("oboe_intr: waking up reader\n"));
570 wakeup(&sc->sc_rxs);
571 }
572 selnotify(&sc->sc_rsel, 0, 0);
573 DPRINTF(("oboe_intr returning\n"));
574 }
575 if (irqstat & OBOE_ISR_TXDONE) {
576 DPRINTF(("oboe_intr: write done\n"));
577 sc->sc_txpending--;
578 sc->sc_txpackets++;
579
580 if ((sc->sc_state & OBOE_CLOSING) && sc->sc_txpending == 0) {
581 wakeup(&sc->sc_state);
582 return 1;
583 }
584
585 if (sc->sc_state & OBOE_WSLP) {
586 DPRINTF(("oboe_intr changing state to ~OBOE_WSLP\n"));
587 sc->sc_state &= ~OBOE_WSLP;
588 DPRINTF(("oboe_intr: waking up writer\n"));
589 wakeup(&sc->sc_txs);
590 }
591 }
592 return (1);
593 }
594
595 /* XXX vtophys must go! */
596 static void
oboe_init_taskfile(struct oboe_softc * sc)597 oboe_init_taskfile(struct oboe_softc *sc)
598 {
599 int i;
600 int s = splir();
601
602 for (i = 0; i < TX_SLOTS; ++i) {
603 sc->sc_taskfile->xmit[i].len = 0;
604 sc->sc_taskfile->xmit[i].control = 0x00;
605 sc->sc_taskfile->xmit[i].buffer =
606 vtophys((uintptr_t)sc->sc_xmit_bufs[i]);
607 }
608
609 for (i = 0; i < RX_SLOTS; ++i) {
610 sc->sc_taskfile->recv[i].len = 0;
611 sc->sc_taskfile->recv[i].control = 0x83;
612 sc->sc_taskfile->recv[i].buffer =
613 vtophys((uintptr_t)sc->sc_recv_bufs[i]);
614 }
615
616 sc->sc_txpending = 0;
617
618 splx(s);
619 }
620
621 static int
oboe_alloc_taskfile(struct oboe_softc * sc)622 oboe_alloc_taskfile(struct oboe_softc *sc)
623 {
624 int i;
625 /* XXX */
626 uintptr_t addr =
627 (uintptr_t)malloc(OBOE_TASK_BUF_LEN, M_DEVBUF, M_WAITOK);
628
629 addr &= ~(sizeof (struct OboeTaskFile) - 1);
630 addr += sizeof (struct OboeTaskFile);
631 sc->sc_taskfile = (struct OboeTaskFile *) addr;
632
633 for (i = 0; i < TX_SLOTS; ++i) {
634 sc->sc_xmit_bufs[i] =
635 malloc(TX_BUF_SZ, M_DEVBUF, M_WAITOK);
636 sc->sc_xmit_stores[i] =
637 malloc(TX_BUF_SZ, M_DEVBUF, M_WAITOK);
638 }
639 for (i = 0; i < RX_SLOTS; ++i) {
640 sc->sc_recv_bufs[i] =
641 malloc(RX_BUF_SZ, M_DEVBUF, M_WAITOK);
642 sc->sc_recv_stores[i] =
643 malloc(RX_BUF_SZ, M_DEVBUF, M_WAITOK);
644 }
645
646 return 0;
647 }
648
649 static void
oboe_startchip(struct oboe_softc * sc)650 oboe_startchip (struct oboe_softc *sc)
651 {
652 uint32_t physaddr;
653
654 OUTB(sc, 0, OBOE_LOCK);
655 OUTB(sc, 0, OBOE_RST);
656 OUTB(sc, OBOE_NTR_VAL, OBOE_NTR);
657 OUTB(sc, 0xf0, OBOE_REG_D);
658 OUTB(sc, 0xff, OBOE_ISR);
659 OUTB(sc, 0x0f, OBOE_REG_1A);
660 OUTB(sc, 0xff, OBOE_REG_1B);
661
662 physaddr = vtophys((uintptr_t)sc->sc_taskfile);
663
664 OUTB(sc, (physaddr >> 0x0a) & 0xff, OBOE_TFP0);
665 OUTB(sc, (physaddr >> 0x12) & 0xff, OBOE_TFP1);
666 OUTB(sc, (physaddr >> 0x1a) & 0x3f, OBOE_TFP2);
667
668 OUTB(sc, 0x0e, OBOE_REG_11);
669 OUTB(sc, 0x80, OBOE_RST);
670
671 (void)oboe_setbaud(sc, 9600);
672
673 sc->sc_rxs = INB(sc, OBOE_RCVT);
674 if (sc->sc_rxs < 0 || sc->sc_rxs >= RX_SLOTS)
675 sc->sc_rxs = 0;
676 sc->sc_txs = INB(sc, OBOE_XMTT) - OBOE_XMTT_OFFSET;
677 if (sc->sc_txs < 0 || sc->sc_txs >= TX_SLOTS)
678 sc->sc_txs = 0;
679 }
680
681 static void
oboe_stopchip(struct oboe_softc * sc)682 oboe_stopchip (struct oboe_softc *sc)
683 {
684 OUTB(sc, 0x0e, OBOE_REG_11);
685 OUTB(sc, 0x00, OBOE_RST);
686 OUTB(sc, 0x3f, OBOE_TFP2); /* Write the taskfile address */
687 OUTB(sc, 0xff, OBOE_TFP1);
688 OUTB(sc, 0xff, OBOE_TFP0);
689 OUTB(sc, 0x0f, OBOE_REG_1B);
690 OUTB(sc, 0xff, OBOE_REG_1A);
691 OUTB(sc, 0x00, OBOE_ISR); /* XXX: should i do this to disable ints? */
692 OUTB(sc, 0x80, OBOE_RST);
693 OUTB(sc, 0x0e, OBOE_LOCK);
694 }
695
696 #define SPEEDCASE(speed, type, divisor) \
697 case speed: \
698 OUTB(sc, OBOE_PMDL_##type, OBOE_PMDL); \
699 OUTB(sc, OBOE_SMDL_##type, OBOE_SMDL); \
700 OUTB(sc, divisor, OBOE_UDIV); \
701 break
702
703 static int
oboe_setbaud(struct oboe_softc * sc,int baud)704 oboe_setbaud(struct oboe_softc *sc, int baud)
705 {
706 int s;
707
708 DPRINTF(("oboe: setting baud to %d\n", baud));
709
710 s = splir();
711
712 switch (baud) {
713 SPEEDCASE( 2400, SIR, 0xbf);
714 SPEEDCASE( 9600, SIR, 0x2f);
715 SPEEDCASE( 19200, SIR, 0x17);
716 SPEEDCASE( 38400, SIR, 0x0b);
717 SPEEDCASE( 57600, SIR, 0x07);
718 SPEEDCASE( 115200, SIR, 0x03);
719 SPEEDCASE(1152000, MIR, 0x01);
720 SPEEDCASE(4000000, FIR, 0x00);
721 default:
722 DPRINTF(("oboe: cannot set speed to %d\n", baud));
723 splx(s);
724 return (EINVAL);
725 }
726
727 OUTB(sc, 0x00, OBOE_RST);
728 OUTB(sc, 0x80, OBOE_RST);
729 OUTB(sc, 0x01, OBOE_REG_9);
730
731 sc->sc_speed = baud;
732
733 splx(s);
734
735 return (0);
736 }
737