Annotation of sys/dev/sdmmc/sbt.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: sbt.c,v 1.9 2007/06/19 07:59:57 uwe Exp $ */
2:
3: /*
4: * Copyright (c) 2007 Uwe Stuehler <uwe@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: /* Driver for Type-A/B SDIO Bluetooth cards */
20:
21: #include <sys/param.h>
22: #include <sys/device.h>
23: #include <sys/malloc.h>
24: #include <sys/mbuf.h>
25: #include <sys/proc.h>
26: #include <sys/queue.h>
27: #include <sys/socket.h>
28: #include <sys/systm.h>
29:
30: #include <netbt/hci.h>
31:
32: #include <dev/sdmmc/sdmmcdevs.h>
33: #include <dev/sdmmc/sdmmcvar.h>
34:
35: #define CSR_READ_1(sc, reg) sdmmc_io_read_1((sc)->sc_sf, (reg))
36: #define CSR_WRITE_1(sc, reg, val) sdmmc_io_write_1((sc)->sc_sf, (reg), (val))
37:
38: #define SBT_REG_DAT 0x00 /* receiver/transmitter data */
39: #define SBT_REG_RPC 0x10 /* read packet control */
40: #define RPC_PCRRT (1<<0) /* packet read retry */
41: #define SBT_REG_WPC 0x11 /* write packet control */
42: #define WPC_PCWRT (1<<0) /* packet write retry */
43: #define SBT_REG_RC 0x12 /* retry control status/set */
44: #define SBT_REG_ISTAT 0x13 /* interrupt status */
45: #define ISTAT_INTRD (1<<0) /* packet available for read */
46: #define SBT_REG_ICLR 0x13 /* interrupt clear */
47: #define SBT_REG_IENA 0x14 /* interrupt enable */
48: #define SBT_REG_BTMODE 0x20 /* SDIO Bluetooth card mode */
49: #define BTMODE_TYPEB (1<<0) /* 1=Type-B, 0=Type-A */
50:
51: #define SBT_PKT_BUFSIZ 65540
52: #define SBT_RXTRY_MAX 5
53:
54: struct sbt_softc {
55: struct device sc_dev; /* base device */
56: struct hci_unit sc_unit; /* MI host controller */
57: struct sdmmc_function *sc_sf; /* SDIO function */
58: struct proc *sc_thread; /* inquiry thread */
59: int sc_dying; /* shutdown in progress */
60: void *sc_ih;
61: u_char *sc_buf;
62: int sc_rxtry;
63: };
64:
65: int sbt_match(struct device *, void *, void *);
66: void sbt_attach(struct device *, struct device *, void *);
67: int sbt_detach(struct device *, int);
68:
69: int sbt_write_packet(struct sbt_softc *, u_char *, size_t);
70: int sbt_read_packet(struct sbt_softc *, u_char *, size_t *);
71:
72: int sbt_intr(void *);
73:
74: int sbt_enable(struct hci_unit *);
75: void sbt_disable(struct hci_unit *);
76: void sbt_start(struct hci_unit *, struct ifqueue *, int);
77: void sbt_start_cmd(struct hci_unit *);
78: void sbt_start_acl(struct hci_unit *);
79: void sbt_start_sco(struct hci_unit *);
80:
81: #undef DPRINTF
82: #define SBT_DEBUG
83: #ifdef SBT_DEBUG
84: int sbt_debug = 1;
85: #define DPRINTF(s) printf s
86: #define DNPRINTF(n, s) do { if ((n) <= sbt_debug) printf s; } while (0)
87: #else
88: #define DPRINTF(s) do {} while (0)
89: #define DNPRINTF(n, s) do {} while (0)
90: #endif
91:
92: #define DEVNAME(sc) ((sc)->sc_dev.dv_xname)
93:
94: struct cfattach sbt_ca = {
95: sizeof(struct sbt_softc), sbt_match, sbt_attach, sbt_detach
96: };
97:
98: struct cfdriver sbt_cd = {
99: NULL, "sbt", DV_DULL
100: };
101:
102:
103: /*
104: * Autoconf glue
105: */
106:
107: static const struct sbt_product {
108: u_int16_t sp_vendor;
109: u_int16_t sp_product;
110: const char *sp_cisinfo[4];
111: } sbt_products[] = {
112: { SDMMC_VENDOR_SOCKETCOM,
113: SDMMC_PRODUCT_SOCKETCOM_BTCARD,
114: SDMMC_CIS_SOCKETCOM_BTCARD }
115: };
116:
117: int
118: sbt_match(struct device *parent, void *match, void *aux)
119: {
120: struct sdmmc_attach_args *sa = aux;
121: const struct sbt_product *sp;
122: struct sdmmc_function *sf;
123: int i;
124:
125: if (sa->sf == NULL)
126: return 0; /* not SDIO */
127:
128: sf = sa->sf->sc->sc_fn0;
129: sp = &sbt_products[0];
130:
131: for (i = 0; i < sizeof(sbt_products) / sizeof(sbt_products[0]);
132: i++, sp = &sbt_products[i])
133: if (sp->sp_vendor == sf->cis.manufacturer &&
134: sp->sp_product == sf->cis.product)
135: return 1;
136: return 0;
137: }
138:
139: void
140: sbt_attach(struct device *parent, struct device *self, void *aux)
141: {
142: struct sbt_softc *sc = (struct sbt_softc *)self;
143: struct sdmmc_attach_args *sa = aux;
144:
145: printf("\n");
146:
147: sc->sc_sf = sa->sf;
148:
149: (void)sdmmc_io_function_disable(sc->sc_sf);
150: if (sdmmc_io_function_enable(sc->sc_sf)) {
151: printf("%s: function not ready\n", DEVNAME(sc));
152: return;
153: }
154:
155: /* It may be Type-B, but we use it only in Type-A mode. */
156: printf("%s: SDIO Bluetooth Type-A\n", DEVNAME(sc));
157:
158: sc->sc_buf = malloc(SBT_PKT_BUFSIZ, M_DEVBUF,
159: M_NOWAIT | M_CANFAIL);
160: if (sc->sc_buf == NULL) {
161: printf("%s: can't allocate cmd buffer\n", DEVNAME(sc));
162: return;
163: }
164:
165: /* Enable the HCI packet transport read interrupt. */
166: CSR_WRITE_1(sc, SBT_REG_IENA, ISTAT_INTRD);
167:
168: /* Enable the card interrupt for this function. */
169: sc->sc_ih = sdmmc_intr_establish(parent, sbt_intr, sc, DEVNAME(sc));
170: if (sc->sc_ih == NULL) {
171: printf("%s: can't establish interrupt\n", DEVNAME(sc));
172: return;
173: }
174: sdmmc_intr_enable(sc->sc_sf);
175:
176: /*
177: * Attach Bluetooth unit (machine-independent HCI).
178: */
179: sc->sc_unit.hci_softc = self;
180: sc->sc_unit.hci_devname = DEVNAME(sc);
181: sc->sc_unit.hci_enable = sbt_enable;
182: sc->sc_unit.hci_disable = sbt_disable;
183: sc->sc_unit.hci_start_cmd = sbt_start_cmd;
184: sc->sc_unit.hci_start_acl = sbt_start_acl;
185: sc->sc_unit.hci_start_sco = sbt_start_sco;
186: sc->sc_unit.hci_ipl = IPL_TTY; /* XXX */
187: hci_attach(&sc->sc_unit);
188: }
189:
190: int
191: sbt_detach(struct device *self, int flags)
192: {
193: struct sbt_softc *sc = (struct sbt_softc *)self;
194:
195: sc->sc_dying = 1;
196: while (sc->sc_thread != NULL)
197: tsleep(sc, PWAIT, "dying", 0);
198:
199: hci_detach(&sc->sc_unit);
200:
201: if (sc->sc_ih != NULL)
202: sdmmc_intr_disestablish(sc->sc_ih);
203:
204: return 0;
205: }
206:
207:
208: /*
209: * Bluetooth HCI packet transport
210: */
211:
212: int
213: sbt_write_packet(struct sbt_softc *sc, u_char *buf, size_t len)
214: {
215: u_char hdr[3];
216: size_t pktlen;
217: int error = EIO;
218: int retry = 3;
219:
220: again:
221: if (retry-- == 0) {
222: DPRINTF(("%s: sbt_write_cmd: giving up\n", DEVNAME(sc)));
223: return error;
224: }
225:
226: /* Restart the current packet. */
227: sdmmc_io_write_1(sc->sc_sf, SBT_REG_WPC, WPC_PCWRT);
228:
229: /* Write the packet length. */
230: pktlen = len + 3;
231: hdr[0] = pktlen & 0xff;
232: hdr[1] = (pktlen >> 8) & 0xff;
233: hdr[2] = (pktlen >> 16) & 0xff;
234: error = sdmmc_io_write_multi_1(sc->sc_sf, SBT_REG_DAT, hdr, 3);
235: if (error) {
236: DPRINTF(("%s: sbt_write_packet: failed to send length\n",
237: DEVNAME(sc)));
238: goto again;
239: }
240:
241: error = sdmmc_io_write_multi_1(sc->sc_sf, SBT_REG_DAT, buf, len);
242: if (error) {
243: DPRINTF(("%s: sbt_write_packet: failed to send packet data\n",
244: DEVNAME(sc)));
245: goto again;
246: }
247: return 0;
248: }
249:
250: int
251: sbt_read_packet(struct sbt_softc *sc, u_char *buf, size_t *lenp)
252: {
253: u_char hdr[3];
254: size_t len;
255: int error;
256:
257: error = sdmmc_io_read_multi_1(sc->sc_sf, SBT_REG_DAT, hdr, 3);
258: if (error) {
259: DPRINTF(("%s: sbt_read_packet: failed to read length\n",
260: DEVNAME(sc)));
261: goto out;
262: }
263: len = (hdr[0] | (hdr[1] << 8) | (hdr[2] << 16)) - 3;
264: if (len > *lenp) {
265: DPRINTF(("%s: sbt_read_packet: len %u > %u\n",
266: DEVNAME(sc), len, *lenp));
267: error = ENOBUFS;
268: goto out;
269: }
270:
271: DNPRINTF(2,("%s: sbt_read_packet: reading len %u bytes\n",
272: DEVNAME(sc), len));
273: error = sdmmc_io_read_multi_1(sc->sc_sf, SBT_REG_DAT, buf, len);
274: if (error) {
275: DPRINTF(("%s: sbt_read_packet: failed to read packet data\n",
276: DEVNAME(sc)));
277: goto out;
278: }
279:
280: out:
281: if (error) {
282: if (sc->sc_rxtry >= SBT_RXTRY_MAX) {
283: /* Drop and request the next packet. */
284: sc->sc_rxtry = 0;
285: CSR_WRITE_1(sc, SBT_REG_RPC, 0);
286: } else {
287: /* Request the current packet again. */
288: sc->sc_rxtry++;
289: CSR_WRITE_1(sc, SBT_REG_RPC, RPC_PCRRT);
290: }
291: return error;
292: }
293:
294: /* acknowledge read packet */
295: CSR_WRITE_1(sc, SBT_REG_RPC, 0);
296:
297: *lenp = len;
298: return 0;
299: }
300:
301: /*
302: * Interrupt handling
303: */
304:
305: int
306: sbt_intr(void *arg)
307: {
308: struct sbt_softc *sc = arg;
309: struct mbuf *m = NULL;
310: u_int8_t status;
311: size_t len;
312: int s;
313:
314: s = splsdmmc();
315:
316: status = CSR_READ_1(sc, SBT_REG_ISTAT);
317: CSR_WRITE_1(sc, SBT_REG_ICLR, status);
318:
319: if ((status & ISTAT_INTRD) == 0)
320: return 0; /* shared SDIO card interrupt? */
321:
322: len = SBT_PKT_BUFSIZ;
323: if (sbt_read_packet(sc, sc->sc_buf, &len) != 0 || len == 0) {
324: DPRINTF(("%s: sbt_intr: read failed\n", DEVNAME(sc)));
325: goto eoi;
326: }
327:
328: MGETHDR(m, M_DONTWAIT, MT_DATA);
329: if (m == NULL) {
330: DPRINTF(("%s: sbt_intr: MGETHDR failed\n", DEVNAME(sc)));
331: goto eoi;
332: }
333:
334: m->m_pkthdr.len = m->m_len = MHLEN;
335: m_copyback(m, 0, len, sc->sc_buf);
336: if (m->m_pkthdr.len == MAX(MHLEN, len)) {
337: m->m_pkthdr.len = len;
338: m->m_len = MIN(MHLEN, m->m_pkthdr.len);
339: } else {
340: DPRINTF(("%s: sbt_intr: m_copyback failed\n", DEVNAME(sc)));
341: m_free(m);
342: m = NULL;
343: }
344:
345: eoi:
346: if (m != NULL) {
347: switch (sc->sc_buf[0]) {
348: case HCI_ACL_DATA_PKT:
349: DNPRINTF(1,("%s: recv ACL packet (%d bytes)\n",
350: DEVNAME(sc), m->m_pkthdr.len));
351: hci_input_acl(&sc->sc_unit, m);
352: break;
353: case HCI_SCO_DATA_PKT:
354: DNPRINTF(1,("%s: recv SCO packet (%d bytes)\n",
355: DEVNAME(sc), m->m_pkthdr.len));
356: hci_input_sco(&sc->sc_unit, m);
357: break;
358: case HCI_EVENT_PKT:
359: DNPRINTF(1,("%s: recv EVENT packet (%d bytes)\n",
360: DEVNAME(sc), m->m_pkthdr.len));
361: hci_input_event(&sc->sc_unit, m);
362: break;
363: default:
364: DPRINTF(("%s: recv 0x%x packet (%d bytes)\n",
365: DEVNAME(sc), sc->sc_buf[0], m->m_pkthdr.len));
366: sc->sc_unit.hci_stats.err_rx++;
367: m_free(m);
368: break;
369: }
370: } else
371: sc->sc_unit.hci_stats.err_rx++;
372:
373: splx(s);
374:
375: /* Claim this interrupt. */
376: return 1;
377: }
378:
379:
380: /*
381: * Bluetooth HCI unit functions
382: */
383:
384: int
385: sbt_enable(struct hci_unit *unit)
386: {
387: if (unit->hci_flags & BTF_RUNNING)
388: return 0;
389:
390: unit->hci_flags |= BTF_RUNNING;
391: unit->hci_flags &= ~BTF_XMIT;
392: return 0;
393: }
394:
395: void
396: sbt_disable(struct hci_unit *unit)
397: {
398: if (!(unit->hci_flags & BTF_RUNNING))
399: return;
400:
401: #ifdef notyet /* XXX */
402: if (sc->sc_rxp) {
403: m_freem(sc->sc_rxp);
404: sc->sc_rxp = NULL;
405: }
406:
407: if (sc->sc_txp) {
408: m_freem(sc->sc_txp);
409: sc->sc_txp = NULL;
410: }
411: #endif
412:
413: unit->hci_flags &= ~BTF_RUNNING;
414: }
415:
416: void
417: sbt_start(struct hci_unit *unit, struct ifqueue *q, int xmit)
418: {
419: struct sbt_softc *sc = (struct sbt_softc *)unit->hci_softc;
420: struct mbuf *m;
421: int len;
422: #ifdef SBT_DEBUG
423: const char *what;
424: #endif
425:
426: if (sc->sc_dying || IF_IS_EMPTY(q))
427: return;
428:
429: IF_DEQUEUE(q, m);
430:
431: #ifdef SBT_DEBUG
432: switch (xmit) {
433: case BTF_XMIT_CMD:
434: what = "CMD";
435: break;
436: case BTF_XMIT_ACL:
437: what = "ACL";
438: break;
439: case BTF_XMIT_SCO:
440: what = "SCO";
441: break;
442: }
443: DNPRINTF(1,("%s: xmit %s packet (%d bytes)\n", DEVNAME(sc),
444: what, m->m_pkthdr.len));
445: #endif
446:
447: unit->hci_flags |= xmit;
448:
449: len = m->m_pkthdr.len;
450: m_copydata(m, 0, len, sc->sc_buf);
451: m_freem(m);
452:
453: if (sbt_write_packet(sc, sc->sc_buf, len))
454: DPRINTF(("%s: sbt_write_packet failed\n", DEVNAME(sc)));
455:
456: unit->hci_flags &= ~xmit;
457: }
458:
459: void
460: sbt_start_cmd(struct hci_unit *unit)
461: {
462: sbt_start(unit, &unit->hci_cmdq, BTF_XMIT_CMD);
463: }
464:
465: void
466: sbt_start_acl(struct hci_unit *unit)
467: {
468: sbt_start(unit, &unit->hci_acltxq, BTF_XMIT_ACL);
469: }
470:
471: void
472: sbt_start_sco(struct hci_unit *unit)
473: {
474: sbt_start(unit, &unit->hci_scotxq, BTF_XMIT_SCO);
475: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sbt.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / sdmmc