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 "ng_message.h" 67 #include "netgraph.h" 68 #include "ng_parse.h" 69 #include "bluetooth/include/ng_bluetooth.h" 70 #include "bluetooth/include/ng_hci.h" 71 #include "bluetooth/include/ng_bt3c.h" 72 #include "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_WAITOK | M_NULLOK); 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_WAITOK | M_NULLOK); 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_WAITOK | M_NULLOK); 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_WAITOK | M_NULLOK); 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_WAITOK | M_NULLOK); 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, MB_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, MB_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 DEVMETHOD_END 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,NULL); 1226 MODULE_VERSION(ng_bt3c, NG_BLUETOOTH_VERSION); 1227 MODULE_DEPEND(ng_bt3c, netgraph, NG_ABI_VERSION, NG_ABI_VERSION,NG_ABI_VERSION); 1228 1229