?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Vendor import of netgraph from FreeBSD-current 20080626
[dragonfly.git] / sys / netgraph7 / bluetooth / drivers / bt3c / ng_bt3c_pccard.c
bloba9b971661feda16db8a98757c5f33ff861b033e6
1 /*
2 * ng_bt3c_pccard.c
3 */
4
5 /*-
6 * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com>
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 * $Id: ng_bt3c_pccard.c,v 1.5 2003/04/01 18:15:21 max Exp $
31 * $FreeBSD: src/sys/netgraph/bluetooth/drivers/bt3c/ng_bt3c_pccard.c,v 1.20 2007/02/23 12:19:02 piso Exp $
32 *
33 * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
34 *
35 * Based on information obrained from: Jose Orlando Pereira <jop@di.uminho.pt>
36 * and disassembled w2k driver.
37 *
38 * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
39 *
40 */
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44
45 #include <sys/bus.h>
46 #include <machine/bus.h>
47
48 #include <sys/conf.h>
49 #include <sys/endian.h>
50 #include <sys/interrupt.h>
51 #include <sys/kernel.h>
52 #include <sys/mbuf.h>
53 #include <sys/module.h>
54
55 #include <machine/resource.h>
56 #include <sys/rman.h>
57
58 #include <sys/socket.h>
59 #include <net/if.h>
60 #include <net/if_var.h>
61
62 #include <dev/pccard/pccardreg.h>
63 #include <dev/pccard/pccardvar.h>
64 #include "pccarddevs.h"
65
66 #include <netgraph/ng_message.h>
67 #include <netgraph/netgraph.h>
68 #include <netgraph/ng_parse.h>
69 #include <netgraph/bluetooth/include/ng_bluetooth.h>
70 #include <netgraph/bluetooth/include/ng_hci.h>
71 #include <netgraph/bluetooth/include/ng_bt3c.h>
72 #include <netgraph/bluetooth/drivers/bt3c/ng_bt3c_var.h>
73
74 /* Netgraph methods */
75 static ng_constructor_t ng_bt3c_constructor;
76 static ng_shutdown_t ng_bt3c_shutdown;
77 static ng_newhook_t ng_bt3c_newhook;
78 static ng_connect_t ng_bt3c_connect;
79 static ng_disconnect_t ng_bt3c_disconnect;
80 static ng_rcvmsg_t ng_bt3c_rcvmsg;
81 static ng_rcvdata_t ng_bt3c_rcvdata;
82
83 /* PCMCIA driver methods */
84 static int bt3c_pccard_probe (device_t);
85 static int bt3c_pccard_attach (device_t);
86 static int bt3c_pccard_detach (device_t);
87
88 static void bt3c_intr (void *);
89 static void bt3c_receive (bt3c_softc_p);
90
91 static void bt3c_swi_intr (void *);
92 static void bt3c_forward (node_p, hook_p, void *, int);
93 static void bt3c_send (node_p, hook_p, void *, int);
94
95 static void bt3c_download_firmware (bt3c_softc_p, char const *, int);
96
97 #define bt3c_set_address(sc, address) \
98 do { \
99 bus_space_write_1((sc)->iot, (sc)->ioh, BT3C_ADDR_L, ((address) & 0xff)); \
100 bus_space_write_1((sc)->iot, (sc)->ioh, BT3C_ADDR_H, (((address) >> 8) & 0xff)); \
101 } while (0)
102
103 #define bt3c_read_data(sc, data) \
104 do { \
105 (data) = bus_space_read_1((sc)->iot, (sc)->ioh, BT3C_DATA_L); \
106 (data) |= ((bus_space_read_1((sc)->iot, (sc)->ioh, BT3C_DATA_H) & 0xff) << 8); \
107 } while (0)
108
109 #define bt3c_write_data(sc, data) \
110 do { \
111 bus_space_write_1((sc)->iot, (sc)->ioh, BT3C_DATA_L, ((data) & 0xff)); \
112 bus_space_write_1((sc)->iot, (sc)->ioh, BT3C_DATA_H, (((data) >> 8) & 0xff)); \
113 } while (0)
114
115 #define bt3c_read_control(sc, data) \
116 do { \
117 (data) = bus_space_read_1((sc)->iot, (sc)->ioh, BT3C_CONTROL); \
118 } while (0)
119
120 #define bt3c_write_control(sc, data) \
121 do { \
122 bus_space_write_1((sc)->iot, (sc)->ioh, BT3C_CONTROL, (data)); \
123 } while (0)
124
125 #define bt3c_read(sc, address, data) \
126 do { \
127 bt3c_set_address((sc), (address)); \
128 bt3c_read_data((sc), (data)); \
129 } while(0)
130
131 #define bt3c_write(sc, address, data) \
132 do { \
133 bt3c_set_address((sc), (address)); \
134 bt3c_write_data((sc), (data)); \
135 } while(0)
136
137 static MALLOC_DEFINE(M_BT3C, "bt3c", "bt3c data structures");
138
139 /****************************************************************************
140 ****************************************************************************
141 ** Netgraph specific
142 ****************************************************************************
143 ****************************************************************************/
144
145 /*
146 * Netgraph node type
147 */
148
149 /* Queue length */
150 static const struct ng_parse_struct_field ng_bt3c_node_qlen_type_fields[] =
151 {
152 { "queue", &ng_parse_int32_type, },
153 { "qlen", &ng_parse_int32_type, },
154 { NULL, }
155 };
156 static const struct ng_parse_type ng_bt3c_node_qlen_type = {
157 &ng_parse_struct_type,
158 &ng_bt3c_node_qlen_type_fields
159 };
160
161 /* Stat info */
162 static const struct ng_parse_struct_field ng_bt3c_node_stat_type_fields[] =
163 {
164 { "pckts_recv", &ng_parse_uint32_type, },
165 { "bytes_recv", &ng_parse_uint32_type, },
166 { "pckts_sent", &ng_parse_uint32_type, },
167 { "bytes_sent", &ng_parse_uint32_type, },
168 { "oerrors", &ng_parse_uint32_type, },
169 { "ierrors", &ng_parse_uint32_type, },
170 { NULL, }
171 };
172 static const struct ng_parse_type ng_bt3c_node_stat_type = {
173 &ng_parse_struct_type,
174 &ng_bt3c_node_stat_type_fields
175 };
176
177 static const struct ng_cmdlist ng_bt3c_cmdlist[] = {
178 {
179 NGM_BT3C_COOKIE,
180 NGM_BT3C_NODE_GET_STATE,
181 "get_state",
182 NULL,
183 &ng_parse_uint16_type
184 },
185 {
186 NGM_BT3C_COOKIE,
187 NGM_BT3C_NODE_SET_DEBUG,
188 "set_debug",
189 &ng_parse_uint16_type,
190 NULL
191 },
192 {
193 NGM_BT3C_COOKIE,
194 NGM_BT3C_NODE_GET_DEBUG,
195 "get_debug",
196 NULL,
197 &ng_parse_uint16_type
198 },
199 {
200 NGM_BT3C_COOKIE,
201 NGM_BT3C_NODE_GET_QLEN,
202 "get_qlen",
203 NULL,
204 &ng_bt3c_node_qlen_type
205 },
206 {
207 NGM_BT3C_COOKIE,
208 NGM_BT3C_NODE_SET_QLEN,
209 "set_qlen",
210 &ng_bt3c_node_qlen_type,
211 NULL
212 },
213 {
214 NGM_BT3C_COOKIE,
215 NGM_BT3C_NODE_GET_STAT,
216 "get_stat",
217 NULL,
218 &ng_bt3c_node_stat_type
219 },
220 {
221 NGM_BT3C_COOKIE,
222 NGM_BT3C_NODE_RESET_STAT,
223 "reset_stat",
224 NULL,
225 NULL
226 },
227 { 0, }
228 };
229
230 static struct ng_type typestruct = {
231 .version = NG_ABI_VERSION,
232 .name = NG_BT3C_NODE_TYPE,
233 .constructor = ng_bt3c_constructor,
234 .rcvmsg = ng_bt3c_rcvmsg,
235 .shutdown = ng_bt3c_shutdown,
236 .newhook = ng_bt3c_newhook,
237 .connect = ng_bt3c_connect,
238 .rcvdata = ng_bt3c_rcvdata,
239 .disconnect = ng_bt3c_disconnect,
240 .cmdlist = ng_bt3c_cmdlist
241 };
242
243 /*
244 * Netgraph node constructor. Do not allow to create node of this type.
245 */
246
247 static int
248 ng_bt3c_constructor(node_p node)
249 {
250 return (EINVAL);
251 } /* ng_bt3c_constructor */
252
253 /*
254 * Netgraph node destructor. Destroy node only when device has been detached
255 */
256
257 static int
258 ng_bt3c_shutdown(node_p node)
259 {
260 bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node);
261
262 /* Let old node go */
263 NG_NODE_SET_PRIVATE(node, NULL);
264 NG_NODE_UNREF(node);
265
266 /* Create new fresh one if we are not going down */
267 if (sc == NULL)
268 goto out;
269
270 /* Create new Netgraph node */
271 if (ng_make_node_common(&typestruct, &sc->node) != 0) {
272 device_printf(sc->dev, "Could not create Netgraph node\n");
273 sc->node = NULL;
274 goto out;
275 }
276
277 /* Name new Netgraph node */
278 if (ng_name_node(sc->node, device_get_nameunit(sc->dev)) != 0) {
279 device_printf(sc->dev, "Could not name Netgraph node\n");
280 NG_NODE_UNREF(sc->node);
281 sc->node = NULL;
282 goto out;
283 }
284
285 NG_NODE_SET_PRIVATE(sc->node, sc);
286 out:
287 return (0);
288 } /* ng_bt3c_shutdown */
289
290 /*
291 * Create new hook. There can only be one.
292 */
293
294 static int
295 ng_bt3c_newhook(node_p node, hook_p hook, char const *name)
296 {
297 bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node);
298
299 if (strcmp(name, NG_BT3C_HOOK) != 0)
300 return (EINVAL);
301
302 if (sc->hook != NULL)
303 return (EISCONN);
304
305 sc->hook = hook;
306
307 return (0);
308 } /* ng_bt3c_newhook */
309
310 /*
311 * Connect hook. Say YEP, that's OK with me.
312 */
313
314 static int
315 ng_bt3c_connect(hook_p hook)
316 {
317 bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
318
319 if (hook != sc->hook) {
320 sc->hook = NULL;
321 return (EINVAL);
322 }
323
324 /* set the hook into queueing mode (for incoming (from wire) packets) */
325 NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook));
326
327 return (0);
328 } /* ng_bt3c_connect */
329
330 /*
331 * Disconnect hook
332 */
333
334 static int
335 ng_bt3c_disconnect(hook_p hook)
336 {
337 bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
338
339 /*
340 * We need to check for sc != NULL because we can be called from
341 * bt3c_pccard_detach() via ng_rmnode_self()
342 */
343
344 if (sc != NULL) {
345 if (hook != sc->hook)
346 return (EINVAL);
347
348 IF_DRAIN(&sc->inq);
349 IF_DRAIN(&sc->outq);
350
351 sc->hook = NULL;
352 }
353
354 return (0);
355 } /* ng_bt3c_disconnect */
356
357 /*
358 * Process control message
359 */
360
361 static int
362 ng_bt3c_rcvmsg(node_p node, item_p item, hook_p lasthook)
363 {
364 bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node);
365 struct ng_mesg *msg = NULL, *rsp = NULL;
366 int error = 0;
367
368 if (sc == NULL) {
369 NG_FREE_ITEM(item);
370 return (EHOSTDOWN);
371 }
372
373 NGI_GET_MSG(item, msg);
374
375 switch (msg->header.typecookie) {
376 case NGM_GENERIC_COOKIE:
377 switch (msg->header.cmd) {
378 case NGM_TEXT_STATUS:
379 NG_MKRESPONSE(rsp, msg, NG_TEXTRESPONSE, M_NOWAIT);
380 if (rsp == NULL)
381 error = ENOMEM;
382 else
383 snprintf(rsp->data, NG_TEXTRESPONSE,
384 "Hook: %s\n" \
385 "Flags: %#x\n" \
386 "Debug: %d\n" \
387 "State: %d\n" \
388 "IncmQ: [len:%d,max:%d]\n" \
389 "OutgQ: [len:%d,max:%d]\n",
390 (sc->hook != NULL)? NG_BT3C_HOOK : "",
391 sc->flags,
392 sc->debug,
393 sc->state,
394 _IF_QLEN(&sc->inq), /* XXX */
395 sc->inq.ifq_maxlen, /* XXX */
396 _IF_QLEN(&sc->outq), /* XXX */
397 sc->outq.ifq_maxlen /* XXX */
398 );
399 break;
400
401 default:
402 error = EINVAL;
403 break;
404 }
405 break;
406
407 case NGM_BT3C_COOKIE:
408 switch (msg->header.cmd) {
409 case NGM_BT3C_NODE_GET_STATE:
410 NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_state_ep),
411 M_NOWAIT);
412 if (rsp == NULL)
413 error = ENOMEM;
414 else
415 *((ng_bt3c_node_state_ep *)(rsp->data)) =
416 sc->state;
417 break;
418
419 case NGM_BT3C_NODE_SET_DEBUG:
420 if (msg->header.arglen != sizeof(ng_bt3c_node_debug_ep))
421 error = EMSGSIZE;
422 else
423 sc->debug =
424 *((ng_bt3c_node_debug_ep *)(msg->data));
425 break;
426
427 case NGM_BT3C_NODE_GET_DEBUG:
428 NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_debug_ep),
429 M_NOWAIT);
430 if (rsp == NULL)
431 error = ENOMEM;
432 else
433 *((ng_bt3c_node_debug_ep *)(rsp->data)) =
434 sc->debug;
435 break;
436
437 case NGM_BT3C_NODE_GET_QLEN:
438 NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_qlen_ep),
439 M_NOWAIT);
440 if (rsp == NULL) {
441 error = ENOMEM;
442 break;
443 }
444
445 switch (((ng_bt3c_node_qlen_ep *)(msg->data))->queue) {
446 case NGM_BT3C_NODE_IN_QUEUE:
447 ((ng_bt3c_node_qlen_ep *)(rsp->data))->queue =
448 NGM_BT3C_NODE_IN_QUEUE;
449 ((ng_bt3c_node_qlen_ep *)(rsp->data))->qlen =
450 sc->inq.ifq_maxlen;
451 break;
452
453 case NGM_BT3C_NODE_OUT_QUEUE:
454 ((ng_bt3c_node_qlen_ep *)(rsp->data))->queue =
455 NGM_BT3C_NODE_OUT_QUEUE;
456 ((ng_bt3c_node_qlen_ep *)(rsp->data))->qlen =
457 sc->outq.ifq_maxlen;
458 break;
459
460 default:
461 NG_FREE_MSG(rsp);
462 error = EINVAL;
463 break;
464 }
465 break;
466
467 case NGM_BT3C_NODE_SET_QLEN:
468 if (msg->header.arglen != sizeof(ng_bt3c_node_qlen_ep)){
469 error = EMSGSIZE;
470 break;
471 }
472
473 if (((ng_bt3c_node_qlen_ep *)(msg->data))->qlen <= 0) {
474 error = EINVAL;
475 break;
476 }
477
478 switch (((ng_bt3c_node_qlen_ep *)(msg->data))->queue) {
479 case NGM_BT3C_NODE_IN_QUEUE:
480 sc->inq.ifq_maxlen = ((ng_bt3c_node_qlen_ep *)
481 (msg->data))->qlen; /* XXX */
482 break;
483
484 case NGM_BT3C_NODE_OUT_QUEUE:
485 sc->outq.ifq_maxlen = ((ng_bt3c_node_qlen_ep *)
486 (msg->data))->qlen; /* XXX */
487 break;
488
489 default:
490 error = EINVAL;
491 break;
492 }
493 break;
494
495 case NGM_BT3C_NODE_GET_STAT:
496 NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_stat_ep),
497 M_NOWAIT);
498 if (rsp == NULL)
499 error = ENOMEM;
500 else
501 bcopy(&sc->stat, rsp->data,
502 sizeof(ng_bt3c_node_stat_ep));
503 break;
504
505 case NGM_BT3C_NODE_RESET_STAT:
506 NG_BT3C_STAT_RESET(sc->stat);
507 break;
508
509 case NGM_BT3C_NODE_DOWNLOAD_FIRMWARE:
510 if (msg->header.arglen <
511 sizeof(ng_bt3c_firmware_block_ep))
512 error = EMSGSIZE;
513 else
514 bt3c_download_firmware(sc, msg->data,
515 msg->header.arglen);
516 break;
517
518 default:
519 error = EINVAL;
520 break;
521 }
522 break;
523
524 default:
525 error = EINVAL;
526 break;
527 }
528
529 NG_RESPOND_MSG(error, node, item, rsp);
530 NG_FREE_MSG(msg);
531
532 return (error);
533 } /* ng_bt3c_rcvmsg */
534
535 /*
536 * Process data
537 */
538
539 static int
540 ng_bt3c_rcvdata(hook_p hook, item_p item)
541 {
542 bt3c_softc_p sc = (bt3c_softc_p)NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
543 struct mbuf *m = NULL;
544 int error = 0;
545
546 if (sc == NULL) {
547 error = EHOSTDOWN;
548 goto out;
549 }
550
551 if (hook != sc->hook) {
552 error = EINVAL;
553 goto out;
554 }
555
556 NGI_GET_M(item, m);
557
558 IF_LOCK(&sc->outq);
559 if (_IF_QFULL(&sc->outq)) {
560 NG_BT3C_ERR(sc->dev,
561 "Outgoing queue is full. Dropping mbuf, len=%d\n", m->m_pkthdr.len);
562
563 _IF_DROP(&sc->outq);
564 NG_BT3C_STAT_OERROR(sc->stat);
565
566 NG_FREE_M(m);
567 } else
568 _IF_ENQUEUE(&sc->outq, m);
569 IF_UNLOCK(&sc->outq);
570
571 error = ng_send_fn(sc->node, NULL, bt3c_send, NULL, 0 /* new send */);
572 out:
573 NG_FREE_ITEM(item);
574
575 return (error);
576 } /* ng_bt3c_rcvdata */
577
578 /****************************************************************************
579 ****************************************************************************
580 ** PCMCIA driver specific
581 ****************************************************************************
582 ****************************************************************************/
583
584 /*
585 * PC Card (PCMCIA) probe routine
586 */
587
588 static int
589 bt3c_pccard_probe(device_t dev)
590 {
591 static struct pccard_product const bt3c_pccard_products[] = {
592 PCMCIA_CARD(3COM, 3CRWB609),
593 { NULL, }
594 };
595
596 struct pccard_product const *pp = NULL;
597
598 pp = pccard_product_lookup(dev, bt3c_pccard_products,
599 sizeof(bt3c_pccard_products[0]), NULL);
600 if (pp == NULL)
601 return (ENXIO);
602
603 device_set_desc(dev, pp->pp_name);
604
605 return (0);
606 } /* bt3c_pccard_probe */
607
608 /*
609 * PC Card (PCMCIA) attach routine
610 */
611
612 static int
613 bt3c_pccard_attach(device_t dev)
614 {
615 bt3c_softc_p sc = (bt3c_softc_p) device_get_softc(dev);
616
617 /* Allocate I/O ports */
618 sc->iobase_rid = 0;
619 sc->iobase = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->iobase_rid,
620 0, ~0, 8, RF_ACTIVE);
621 if (sc->iobase == NULL) {
622 device_printf(dev, "Could not allocate I/O ports\n");
623 goto bad;
624 }
625 sc->iot = rman_get_bustag(sc->iobase);
626 sc->ioh = rman_get_bushandle(sc->iobase);
627
628 /* Allocate IRQ */
629 sc->irq_rid = 0;
630 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irq_rid,
631 RF_ACTIVE);
632 if (sc->irq == NULL) {
633 device_printf(dev, "Could not allocate IRQ\n");
634 goto bad;
635 }
636
637 sc->irq_cookie = NULL;
638 if (bus_setup_intr(dev, sc->irq, INTR_TYPE_TTY, NULL, bt3c_intr, sc,
639 &sc->irq_cookie) != 0) {
640 device_printf(dev, "Could not setup ISR\n");
641 goto bad;
642 }
643
644 /* Attach handler to TTY SWI thread */
645 sc->ith = NULL;
646 if (swi_add(&tty_intr_event, device_get_nameunit(dev),
647 bt3c_swi_intr, sc, SWI_TTY, 0, &sc->ith) < 0) {
648 device_printf(dev, "Could not setup SWI ISR\n");
649 goto bad;
650 }
651
652 /* Create Netgraph node */
653 if (ng_make_node_common(&typestruct, &sc->node) != 0) {
654 device_printf(dev, "Could not create Netgraph node\n");
655 sc->node = NULL;
656 goto bad;
657 }
658
659 /* Name Netgraph node */
660 if (ng_name_node(sc->node, device_get_nameunit(dev)) != 0) {
661 device_printf(dev, "Could not name Netgraph node\n");
662 NG_NODE_UNREF(sc->node);
663 sc->node = NULL;
664 goto bad;
665 }
666
667 sc->dev = dev;
668 sc->debug = NG_BT3C_WARN_LEVEL;
669
670 sc->inq.ifq_maxlen = sc->outq.ifq_maxlen = BT3C_DEFAULTQLEN;
671 mtx_init(&sc->inq.ifq_mtx, "BT3C inq", NULL, MTX_DEF);
672 mtx_init(&sc->outq.ifq_mtx, "BT3C outq", NULL, MTX_DEF);
673
674 sc->state = NG_BT3C_W4_PKT_IND;
675 sc->want = 1;
676
677 NG_NODE_SET_PRIVATE(sc->node, sc);
678
679 return (0);
680 bad:
681 if (sc->ith != NULL) {
682 swi_remove(sc->ith);
683 sc->ith = NULL;
684 }
685
686 if (sc->irq != NULL) {
687 if (sc->irq_cookie != NULL)
688 bus_teardown_intr(dev, sc->irq, sc->irq_cookie);
689
690 bus_release_resource(dev, SYS_RES_IRQ,
691 sc->irq_rid, sc->irq);
692
693 sc->irq = NULL;
694 sc->irq_rid = 0;
695 }
696
697 if (sc->iobase != NULL) {
698 bus_release_resource(dev, SYS_RES_IOPORT,
699 sc->iobase_rid, sc->iobase);
700
701 sc->iobase = NULL;
702 sc->iobase_rid = 0;
703 }
704
705 return (ENXIO);
706 } /* bt3c_pccacd_attach */
707
708 /*
709 * PC Card (PCMCIA) detach routine
710 */
711
712 static int
713 bt3c_pccard_detach(device_t dev)
714 {
715 bt3c_softc_p sc = (bt3c_softc_p) device_get_softc(dev);
716
717 if (sc == NULL)
718 return (0);
719
720 swi_remove(sc->ith);
721 sc->ith = NULL;
722
723 bus_teardown_intr(dev, sc->irq, sc->irq_cookie);
724 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq);
725 sc->irq_cookie = NULL;
726 sc->irq = NULL;
727 sc->irq_rid = 0;
728
729 bus_release_resource(dev, SYS_RES_IOPORT, sc->iobase_rid, sc->iobase);
730 sc->iobase = NULL;
731 sc->iobase_rid = 0;
732
733 if (sc->node != NULL) {
734 NG_NODE_SET_PRIVATE(sc->node, NULL);
735 ng_rmnode_self(sc->node);
736 sc->node = NULL;
737 }
738
739 NG_FREE_M(sc->m);
740 IF_DRAIN(&sc->inq);
741 IF_DRAIN(&sc->outq);
742
743 mtx_destroy(&sc->inq.ifq_mtx);
744 mtx_destroy(&sc->outq.ifq_mtx);
745
746 return (0);
747 } /* bt3c_pccacd_detach */
748
749 /*
750 * Interrupt service routine's
751 */
752
753 static void
754 bt3c_intr(void *context)
755 {
756 bt3c_softc_p sc = (bt3c_softc_p) context;
757 u_int16_t control, status;
758
759 if (sc == NULL || sc->ith == NULL) {
760 printf("%s: bogus interrupt\n", NG_BT3C_NODE_TYPE);
761 return;
762 }
763
764 bt3c_read_control(sc, control);
765 if ((control & 0x80) == 0)
766 return;
767
768 bt3c_read(sc, 0x7001, status);
769 NG_BT3C_INFO(sc->dev, "control=%#x, status=%#x\n", control, status);
770
771 if ((status & 0xff) == 0x7f || (status & 0xff) == 0xff) {
772 NG_BT3C_WARN(sc->dev, "Strange status=%#x\n", status);
773 return;
774 }
775
776 /* Receive complete */
777 if (status & 0x0001)
778 bt3c_receive(sc);
779
780 /* Record status and schedule SWI */
781 sc->status |= status;
782 swi_sched(sc->ith, 0);
783
784 /* Complete interrupt */
785 bt3c_write(sc, 0x7001, 0x0000);
786 bt3c_write_control(sc, control);
787 } /* bt3c_intr */
788
789 /*
790 * Receive data
791 */
792
793 static void
794 bt3c_receive(bt3c_softc_p sc)
795 {
796 u_int16_t i, count, c;
797
798 /* Receive data from the card */
799 bt3c_read(sc, 0x7006, count);
800 NG_BT3C_INFO(sc->dev, "The card has %d characters\n", count);
801
802 bt3c_set_address(sc, 0x7480);
803
804 for (i = 0; i < count; i++) {
805 /* Allocate new mbuf if needed */
806 if (sc->m == NULL) {
807 sc->state = NG_BT3C_W4_PKT_IND;
808 sc->want = 1;
809
810 MGETHDR(sc->m, M_DONTWAIT, MT_DATA);
811 if (sc->m == NULL) {
812 NG_BT3C_ERR(sc->dev, "Could not get mbuf\n");
813 NG_BT3C_STAT_IERROR(sc->stat);
814
815 break; /* XXX lost of sync */
816 }
817
818 MCLGET(sc->m, M_DONTWAIT);
819 if (!(sc->m->m_flags & M_EXT)) {
820 NG_FREE_M(sc->m);
821
822 NG_BT3C_ERR(sc->dev, "Could not get cluster\n");
823 NG_BT3C_STAT_IERROR(sc->stat);
824
825 break; /* XXX lost of sync */
826 }
827
828 sc->m->m_len = sc->m->m_pkthdr.len = 0;
829 }
830
831 /* Read and append character to mbuf */
832 bt3c_read_data(sc, c);
833 if (sc->m->m_pkthdr.len >= MCLBYTES) {
834 NG_BT3C_ERR(sc->dev, "Oversized frame\n");
835
836 NG_FREE_M(sc->m);
837 sc->state = NG_BT3C_W4_PKT_IND;
838 sc->want = 1;
839
840 break; /* XXX lost of sync */
841 }
842
843 mtod(sc->m, u_int8_t *)[sc->m->m_len ++] = (u_int8_t) c;
844 sc->m->m_pkthdr.len ++;
845
846 NG_BT3C_INFO(sc->dev,
847 "Got char %#x, want=%d, got=%d\n", c, sc->want, sc->m->m_pkthdr.len);
848
849 if (sc->m->m_pkthdr.len < sc->want)
850 continue; /* wait for more */
851
852 switch (sc->state) {
853 /* Got packet indicator */
854 case NG_BT3C_W4_PKT_IND:
855 NG_BT3C_INFO(sc->dev,
856 "Got packet indicator %#x\n", *mtod(sc->m, u_int8_t *));
857
858 sc->state = NG_BT3C_W4_PKT_HDR;
859
860 /*
861 * Since packet indicator included in the packet
862 * header just set sc->want to sizeof(packet header).
863 */
864
865 switch (*mtod(sc->m, u_int8_t *)) {
866 case NG_HCI_ACL_DATA_PKT:
867 sc->want = sizeof(ng_hci_acldata_pkt_t);
868 break;
869
870 case NG_HCI_SCO_DATA_PKT:
871 sc->want = sizeof(ng_hci_scodata_pkt_t);
872 break;
873
874 case NG_HCI_EVENT_PKT:
875 sc->want = sizeof(ng_hci_event_pkt_t);
876 break;
877
878 default:
879 NG_BT3C_ERR(sc->dev,
880 "Ignoring unknown packet type=%#x\n", *mtod(sc->m, u_int8_t *));
881
882 NG_BT3C_STAT_IERROR(sc->stat);
883
884 NG_FREE_M(sc->m);
885 sc->state = NG_BT3C_W4_PKT_IND;
886 sc->want = 1;
887 break;
888 }
889 break;
890
891 /* Got packet header */
892 case NG_BT3C_W4_PKT_HDR:
893 sc->state = NG_BT3C_W4_PKT_DATA;
894
895 switch (*mtod(sc->m, u_int8_t *)) {
896 case NG_HCI_ACL_DATA_PKT:
897 c = le16toh(mtod(sc->m,
898 ng_hci_acldata_pkt_t *)->length);
899 break;
900
901 case NG_HCI_SCO_DATA_PKT:
902 c = mtod(sc->m, ng_hci_scodata_pkt_t*)->length;
903 break;
904
905 case NG_HCI_EVENT_PKT:
906 c = mtod(sc->m, ng_hci_event_pkt_t *)->length;
907 break;
908
909 default:
910 KASSERT(0,
911 ("Invalid packet type=%#x\n", *mtod(sc->m, u_int8_t *)));
912 break;
913 }
914
915 NG_BT3C_INFO(sc->dev,
916 "Got packet header, packet type=%#x, got so far %d, payload size=%d\n",
917 *mtod(sc->m, u_int8_t *), sc->m->m_pkthdr.len,
918 c);
919
920 if (c > 0) {
921 sc->want += c;
922 break;
923 }
924
925 /* else FALLTHROUGH and deliver frame */
926 /* XXX is this true? should we deliver empty frame? */
927
928 /* Got packet data */
929 case NG_BT3C_W4_PKT_DATA:
930 NG_BT3C_INFO(sc->dev,
931 "Got full packet, packet type=%#x, packet size=%d\n",
932 *mtod(sc->m, u_int8_t *), sc->m->m_pkthdr.len);
933
934 NG_BT3C_STAT_BYTES_RECV(sc->stat, sc->m->m_pkthdr.len);
935 NG_BT3C_STAT_PCKTS_RECV(sc->stat);
936
937 IF_LOCK(&sc->inq);
938 if (_IF_QFULL(&sc->inq)) {
939 NG_BT3C_ERR(sc->dev,
940 "Incoming queue is full. Dropping mbuf, len=%d\n", sc->m->m_pkthdr.len);
941
942 _IF_DROP(&sc->inq);
943 NG_BT3C_STAT_IERROR(sc->stat);
944
945 NG_FREE_M(sc->m);
946 } else {
947 _IF_ENQUEUE(&sc->inq, sc->m);
948 sc->m = NULL;
949 }
950 IF_UNLOCK(&sc->inq);
951
952 sc->state = NG_BT3C_W4_PKT_IND;
953 sc->want = 1;
954 break;
955
956 default:
957 KASSERT(0,
958 ("Invalid node state=%d", sc->state));
959 break;
960 }
961 }
962
963 bt3c_write(sc, 0x7006, 0x0000);
964 } /* bt3c_receive */
965
966 /*
967 * SWI interrupt handler
968 * Netgraph part is handled via ng_send_fn() to avoid race with hook
969 * connection/disconnection
970 */
971
972 static void
973 bt3c_swi_intr(void *context)
974 {
975 bt3c_softc_p sc = (bt3c_softc_p) context;
976 u_int16_t data;
977
978 /* Receive complete */
979 if (sc->status & 0x0001) {
980 sc->status &= ~0x0001; /* XXX is it safe? */
981
982 if (ng_send_fn(sc->node, NULL, &bt3c_forward, NULL, 0) != 0)
983 NG_BT3C_ALERT(sc->dev, "Could not forward frames!\n");
984 }
985
986 /* Send complete */
987 if (sc->status & 0x0002) {
988 sc->status &= ~0x0002; /* XXX is it safe */
989
990 if (ng_send_fn(sc->node, NULL, &bt3c_send, NULL, 1) != 0)
991 NG_BT3C_ALERT(sc->dev, "Could not send frames!\n");
992 }
993
994 /* Antenna position */
995 if (sc->status & 0x0020) {
996 sc->status &= ~0x0020; /* XXX is it safe */
997
998 bt3c_read(sc, 0x7002, data);
999 data &= 0x10;
1000
1001 if (data)
1002 sc->flags |= BT3C_ANTENNA_OUT;
1003 else
1004 sc->flags &= ~BT3C_ANTENNA_OUT;
1005
1006 NG_BT3C_INFO(sc->dev, "Antenna %s\n", data? "OUT" : "IN");
1007 }
1008 } /* bt3c_swi_intr */
1009
1010 /*
1011 * Send all incoming frames to the upper layer
1012 */
1013
1014 static void
1015 bt3c_forward(node_p node, hook_p hook, void *arg1, int arg2)
1016 {
1017 bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node);
1018 struct mbuf *m = NULL;
1019 int error;
1020
1021 if (sc == NULL)
1022 return;
1023
1024 if (sc->hook != NULL && NG_HOOK_IS_VALID(sc->hook)) {
1025 for (;;) {
1026 IF_DEQUEUE(&sc->inq, m);
1027 if (m == NULL)
1028 break;
1029
1030 NG_SEND_DATA_ONLY(error, sc->hook, m);
1031 if (error != 0)
1032 NG_BT3C_STAT_IERROR(sc->stat);
1033 }
1034 } else {
1035 IF_LOCK(&sc->inq);
1036 for (;;) {
1037 _IF_DEQUEUE(&sc->inq, m);
1038 if (m == NULL)
1039 break;
1040
1041 NG_BT3C_STAT_IERROR(sc->stat);
1042 NG_FREE_M(m);
1043 }
1044 IF_UNLOCK(&sc->inq);
1045 }
1046 } /* bt3c_forward */
1047
1048 /*
1049 * Send more data to the device. Must be called when node is locked
1050 */
1051
1052 static void
1053 bt3c_send(node_p node, hook_p hook, void *arg, int completed)
1054 {
1055 bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node);
1056 struct mbuf *m = NULL;
1057 int i, wrote, len;
1058
1059 if (sc == NULL)
1060 return;
1061
1062 if (completed)
1063 sc->flags &= ~BT3C_XMIT;
1064
1065 if (sc->flags & BT3C_XMIT)
1066 return;
1067
1068 bt3c_set_address(sc, 0x7080);
1069
1070 for (wrote = 0; wrote < BT3C_FIFO_SIZE; ) {
1071 IF_DEQUEUE(&sc->outq, m);
1072 if (m == NULL)
1073 break;
1074
1075 while (m != NULL) {
1076 len = min((BT3C_FIFO_SIZE - wrote), m->m_len);
1077
1078 for (i = 0; i < len; i++)
1079 bt3c_write_data(sc, m->m_data[i]);
1080
1081 wrote += len;
1082 m->m_data += len;
1083 m->m_len -= len;
1084
1085 if (m->m_len > 0)
1086 break;
1087
1088 m = m_free(m);
1089 }
1090
1091 if (m != NULL) {
1092 IF_PREPEND(&sc->outq, m);
1093 break;
1094 }
1095
1096 NG_BT3C_STAT_PCKTS_SENT(sc->stat);
1097 }
1098
1099 if (wrote > 0) {
1100 NG_BT3C_INFO(sc->dev, "Wrote %d bytes\n", wrote);
1101 NG_BT3C_STAT_BYTES_SENT(sc->stat, wrote);
1102
1103 bt3c_write(sc, 0x7005, wrote);
1104 sc->flags |= BT3C_XMIT;
1105 }
1106 } /* bt3c_send */
1107
1108 /*
1109 * Download chip firmware
1110 */
1111
1112 static void
1113 bt3c_download_firmware(bt3c_softc_p sc, char const *firmware, int firmware_size)
1114 {
1115 ng_bt3c_firmware_block_ep const *block = NULL;
1116 u_int16_t const *data = NULL;
1117 int i, size;
1118 u_int8_t c;
1119
1120 /* Reset */
1121 device_printf(sc->dev, "Reseting the card...\n");
1122 bt3c_write(sc, 0x8040, 0x0404);
1123 bt3c_write(sc, 0x8040, 0x0400);
1124 DELAY(1);
1125
1126 bt3c_write(sc, 0x8040, 0x0404);
1127 DELAY(17);
1128
1129 /* Download firmware */
1130 device_printf(sc->dev, "Starting firmware download process...\n");
1131
1132 for (size = 0; size < firmware_size; ) {
1133 block = (ng_bt3c_firmware_block_ep const *)(firmware + size);
1134 data = (u_int16_t const *)(block + 1);
1135
1136 if (bootverbose)
1137 device_printf(sc->dev, "Download firmware block, " \
1138 "address=%#08x, size=%d words, aligment=%d\n",
1139 block->block_address, block->block_size,
1140 block->block_alignment);
1141
1142 bt3c_set_address(sc, block->block_address);
1143 for (i = 0; i < block->block_size; i++)
1144 bt3c_write_data(sc, data[i]);
1145
1146 size += (sizeof(*block) + (block->block_size * 2) +
1147 block->block_alignment);
1148 }
1149
1150 DELAY(17);
1151 device_printf(sc->dev, "Firmware download process complete\n");
1152
1153 /* Boot */
1154 device_printf(sc->dev, "Starting the card...\n");
1155 bt3c_set_address(sc, 0x3000);
1156 bt3c_read_control(sc, c);
1157 bt3c_write_control(sc, (c | 0x40));
1158 DELAY(17);
1159
1160 /* Clear registers */
1161 device_printf(sc->dev, "Clearing card registers...\n");
1162 bt3c_write(sc, 0x7006, 0x0000);
1163 bt3c_write(sc, 0x7005, 0x0000);
1164 bt3c_write(sc, 0x7001, 0x0000);
1165 DELAY(1000);
1166 } /* bt3c_download_firmware */
1167
1168 /****************************************************************************
1169 ****************************************************************************
1170 ** Driver module
1171 ****************************************************************************
1172 ****************************************************************************/
1173
1174 /*
1175 * PC Card (PCMCIA) driver
1176 */
1177
1178 static device_method_t bt3c_pccard_methods[] = {
1179 /* Device interface */
1180 DEVMETHOD(device_probe, bt3c_pccard_probe),
1181 DEVMETHOD(device_attach, bt3c_pccard_attach),
1182 DEVMETHOD(device_detach, bt3c_pccard_detach),
1183
1184 { 0, 0 }
1185 };
1186
1187 static driver_t bt3c_pccard_driver = {
1188 NG_BT3C_NODE_TYPE,
1189 bt3c_pccard_methods,
1190 sizeof(bt3c_softc_t)
1191 };
1192
1193 static devclass_t bt3c_devclass;
1194
1195
1196 /*
1197 * Load/Unload the driver module
1198 */
1199
1200 static int
1201 bt3c_modevent(module_t mod, int event, void *data)
1202 {
1203 int error;
1204
1205 switch (event) {
1206 case MOD_LOAD:
1207 error = ng_newtype(&typestruct);
1208 if (error != 0)
1209 printf("%s: Could not register Netgraph node type, " \
1210 "error=%d\n", NG_BT3C_NODE_TYPE, error);
1211 break;
1212
1213 case MOD_UNLOAD:
1214 error = ng_rmtype(&typestruct);
1215 break;
1216
1217 default:
1218 error = EOPNOTSUPP;
1219 break;
1220 }
1221
1222 return (error);
1223 } /* bt3c_modevent */
1224
1225 DRIVER_MODULE(bt3c, pccard, bt3c_pccard_driver, bt3c_devclass, bt3c_modevent,0);
1226 MODULE_VERSION(ng_bt3c, NG_BLUETOOTH_VERSION);
1227 MODULE_DEPEND(ng_bt3c, netgraph, NG_ABI_VERSION, NG_ABI_VERSION,NG_ABI_VERSION);
1228
DragonFly BSD