?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / dev / pcmcia / bt3c.c
blob5478577325a25f72a757fb66ff92f3e849d5ac0e
1 /* $NetBSD: bt3c.c,v 1.19 2009/05/12 13:18:04 cegger Exp $ */
2
3 /*-
4 * Copyright (c) 2005 Iain D. Hibbert,
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /*
31 * Driver for the 3Com Bluetooth PC Card 3CRWB6096, written with reference to
32 * FreeBSD and BlueZ drivers for same, with credit for those going to:
33 *
34 * Maksim Yevmenkin <m_evmenkin@yahoo.com> (FreeBSD)
35 * Marcel Holtmann <marcel@holtmann.org> (BlueZ)
36 * Jose Orlando Pereira <jop@di.uminho.pt> (BlueZ)
37 * David Hinds <dahinds@users.sourceforge.net> (Original Code)
38 */
39
40 /*
41 * The CIS info from my card:
42 *
43 * pcmcia1: CIS tuple chain:
44 * CISTPL_DEVICE type=null speed=null
45 * 01 03 00 00 ff
46 * CISTPL_VERS_1
47 * 15 24 05 00 33 43 4f 4d 00 33 43 52 57 42 36 30
48 * 2d 41 00 42 6c 75 65 74 6f 6f 74 68 20 50 43 20
49 * 43 61 72 64 00 ff
50 * CISTPL_MANFID
51 * 20 04 01 01 40 00
52 * CISTPL_FUNCID
53 * 21 02 02 01
54 * CISTPL_CONFIG
55 * 1a 06 05 30 20 03 17 00
56 * CISTPL_CFTABLE_ENTRY
57 * 1b 09 f0 41 18 a0 40 07 30 ff ff
58 * unhandled CISTPL 80
59 * 80 0a 02 01 40 00 2d 00 00 00 00 ff
60 * CISTPL_NO_LINK
61 * 14 00
62 * CISTPL_END
63 * ff
64 * pcmcia1: CIS version PC Card Standard 5.0
65 * pcmcia1: CIS info: 3COM, 3CRWB60-A, Bluetooth PC Card
66 * pcmcia1: Manufacturer code 0x101, product 0x40
67 * pcmcia1: function 0: serial port, ccr addr 320 mask 17
68 * pcmcia1: function 0, config table entry 48: I/O card; irq mask ffff; iomask 0, iospace 0-7; rdybsy_active io8 irqlevel
69 */
70
71 #include <sys/cdefs.h>
72 __KERNEL_RCSID(0, "$NetBSD: bt3c.c,v 1.19 2009/05/12 13:18:04 cegger Exp $");
73
74 #include <sys/param.h>
75 #include <sys/device.h>
76 #include <sys/mbuf.h>
77 #include <sys/systm.h>
78
79 #include <sys/cpu.h>
80 #include <sys/bus.h>
81 #include <sys/intr.h>
82
83 #include <dev/pcmcia/pcmciareg.h>
84 #include <dev/pcmcia/pcmciavar.h>
85 #include <dev/pcmcia/pcmciadevs.h>
86
87 #include <netbt/bluetooth.h>
88 #include <netbt/hci.h>
89
90 #include <dev/firmload.h>
91 #define BT3C_FIRMWARE_FILE "BT3CPCC.bin"
92
93 /**************************************************************************
94 *
95 * bt3c autoconfig glue
96 */
97
98 struct bt3c_softc {
99 device_t sc_dev;
100
101 struct pcmcia_function *sc_pf; /* our PCMCIA function */
102 struct pcmcia_io_handle sc_pcioh; /* PCMCIA i/o space info */
103 int sc_iow; /* our i/o window */
104 int sc_flags; /* flags */
105
106 struct hci_unit *sc_unit; /* Bluetooth HCI Unit */
107 struct bt_stats sc_stats; /* HCI stats */
108
109 /* hardware interrupt */
110 void *sc_intr; /* cookie */
111 int sc_state; /* receive state */
112 int sc_want; /* how much we want */
113 struct mbuf *sc_rxp; /* incoming packet */
114 struct mbuf *sc_txp; /* outgoing packet */
115
116 /* transmit queues */
117 MBUFQ_HEAD() sc_cmdq; /* commands */
118 MBUFQ_HEAD() sc_aclq; /* ACL data */
119 MBUFQ_HEAD() sc_scoq; /* SCO data */
120 };
121
122 /* sc_state */ /* receiving */
123 #define BT3C_RECV_PKT_TYPE 0 /* packet type */
124 #define BT3C_RECV_ACL_HDR 1 /* acl header */
125 #define BT3C_RECV_SCO_HDR 2 /* sco header */
126 #define BT3C_RECV_EVENT_HDR 3 /* event header */
127 #define BT3C_RECV_ACL_DATA 4 /* acl packet data */
128 #define BT3C_RECV_SCO_DATA 5 /* sco packet data */
129 #define BT3C_RECV_EVENT_DATA 6 /* event packet data */
130
131 /* sc_flags */
132 #define BT3C_XMIT (1 << 1) /* transmit active */
133 #define BT3C_ENABLED (1 << 2) /* enabled */
134
135 static int bt3c_match(device_t, cfdata_t, void *);
136 static void bt3c_attach(device_t, device_t, void *);
137 static int bt3c_detach(device_t, int);
138 static bool bt3c_suspend(device_t, pmf_qual_t);
139 static bool bt3c_resume(device_t, pmf_qual_t);
140
141 CFATTACH_DECL_NEW(bt3c, sizeof(struct bt3c_softc),
142 bt3c_match, bt3c_attach, bt3c_detach, NULL);
143
144 static int bt3c_enable(device_t);
145 static void bt3c_disable(device_t);
146 static void bt3c_output_cmd(device_t, struct mbuf *);
147 static void bt3c_output_acl(device_t, struct mbuf *);
148 static void bt3c_output_sco(device_t, struct mbuf *);
149 static void bt3c_stats(device_t, struct bt_stats *, int);
150
151 static const struct hci_if bt3c_hci = {
152 .enable = bt3c_enable,
153 .disable = bt3c_disable,
154 .output_cmd = bt3c_output_cmd,
155 .output_acl = bt3c_output_acl,
156 .output_sco = bt3c_output_sco,
157 .get_stats = bt3c_stats,
158 .ipl = IPL_TTY,
159 };
160
161 static void bt3c_start(struct bt3c_softc *);
162
163 /**************************************************************************
164 *
165 * Hardware Definitions & IO routines
166 *
167 * I made up the names for most of these defs since we dont have
168 * manufacturers recommendations, but I dont like raw numbers..
169 *
170 * all hardware routines are running at IPL_TTY
171 *
172 */
173 #define BT3C_ISR 0x7001 /* Interrupt Status Register */
174 #define BT3C_ISR_RXRDY (1<<0) /* Device has data */
175 #define BT3C_ISR_TXRDY (1<<1) /* Finished sending data */
176 #define BT3C_ISR_ANTENNA (1<<5) /* Antenna position changed */
177
178 #define BT3C_CSR 0x7002 /* Card Status Register */
179 #define BT3C_CSR_ANTENNA (1<<4) /* Antenna position */
180
181 #define BT3C_TX_COUNT 0x7005 /* Tx fifo contents */
182 #define BT3C_TX_FIFO 0x7080 /* Transmit Fifo */
183 #define BT3C_RX_COUNT 0x7006 /* Rx fifo contents */
184 #define BT3C_RX_FIFO 0x7480 /* Receive Fifo */
185 #define BT3C_FIFO_SIZE 256
186
187 /* IO Registers */
188 #define BT3C_IOR_DATA_L 0x00 /* data low byte */
189 #define BT3C_IOR_DATA_H 0x01 /* data high byte */
190 #define BT3C_IOR_ADDR_L 0x02 /* address low byte */
191 #define BT3C_IOR_ADDR_H 0x03 /* address high byte */
192 #define BT3C_IOR_CNTL 0x04 /* control byte */
193 #define BT3C_IOR_CNTL_BOOT (1<<6) /* Boot Card */
194 #define BT3C_IOR_CNTL_INTR (1<<7) /* Interrupt Requested */
195 #define BT3C_IOR_LEN 0x05
196
197 static inline uint16_t
198 bt3c_get(struct bt3c_softc *sc)
199 {
200 uint16_t data;
201
202 bus_space_barrier(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
203 0, BT3C_IOR_LEN, BUS_SPACE_BARRIER_READ);
204 data = bus_space_read_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
205 BT3C_IOR_DATA_L);
206 data |= bus_space_read_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
207 BT3C_IOR_DATA_H) << 8;
208
209 return data;
210 }
211
212 static inline void
213 bt3c_put(struct bt3c_softc *sc, uint16_t data)
214 {
215
216 bus_space_barrier(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
217 0, BT3C_IOR_LEN, BUS_SPACE_BARRIER_WRITE);
218 bus_space_write_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
219 BT3C_IOR_DATA_L, data & 0xff);
220 bus_space_write_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
221 BT3C_IOR_DATA_H, (data >> 8) & 0xff);
222 }
223
224 static inline uint8_t
225 bt3c_read_control(struct bt3c_softc *sc)
226 {
227
228 bus_space_barrier(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
229 0, BT3C_IOR_LEN, BUS_SPACE_BARRIER_READ);
230 return bus_space_read_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
231 BT3C_IOR_CNTL);
232 }
233
234 static inline void
235 bt3c_write_control(struct bt3c_softc *sc, uint8_t data)
236 {
237
238 bus_space_barrier(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
239 0, BT3C_IOR_LEN, BUS_SPACE_BARRIER_WRITE);
240 bus_space_write_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
241 BT3C_IOR_CNTL, data);
242 }
243
244 static inline void
245 bt3c_set_address(struct bt3c_softc *sc, uint16_t addr)
246 {
247
248 bus_space_barrier(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
249 0, BT3C_IOR_LEN, BUS_SPACE_BARRIER_WRITE);
250 bus_space_write_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
251 BT3C_IOR_ADDR_L, addr & 0xff);
252 bus_space_write_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
253 BT3C_IOR_ADDR_H, (addr >> 8) & 0xff);
254 }
255
256 static inline uint16_t
257 bt3c_read(struct bt3c_softc *sc, uint16_t addr)
258 {
259
260 bt3c_set_address(sc, addr);
261 return bt3c_get(sc);
262 }
263
264 static inline void
265 bt3c_write(struct bt3c_softc *sc, uint16_t addr, uint16_t data)
266 {
267
268 bt3c_set_address(sc, addr);
269 bt3c_put(sc, data);
270 }
271
272 /*
273 * receive incoming data from device, store in mbuf chain and
274 * pass on complete packets to bt device
275 */
276 static void
277 bt3c_receive(struct bt3c_softc *sc)
278 {
279 struct mbuf *m = sc->sc_rxp;
280 int space = 0;
281 uint16_t count;
282 uint8_t b;
283
284 /*
285 * If we already started a packet, find the
286 * trailing end of it.
287 */
288 if (m) {
289 while (m->m_next)
290 m = m->m_next;
291
292 space = M_TRAILINGSPACE(m);
293 }
294
295 count = bt3c_read(sc, BT3C_RX_COUNT);
296 bt3c_set_address(sc, BT3C_RX_FIFO);
297
298 while (count > 0) {
299 if (space == 0) {
300 if (m == NULL) {
301 /* new packet */
302 MGETHDR(m, M_DONTWAIT, MT_DATA);
303 if (m == NULL) {
304 aprint_error_dev(sc->sc_dev,
305 "out of memory\n");
306 sc->sc_stats.err_rx++;
307 goto out; /* (lost sync) */
308 }
309
310 sc->sc_rxp = m;
311 m->m_pkthdr.len = m->m_len = 0;
312 space = MHLEN;
313
314 sc->sc_state = BT3C_RECV_PKT_TYPE;
315 sc->sc_want = 1;
316 } else {
317 /* extend mbuf */
318 MGET(m->m_next, M_DONTWAIT, MT_DATA);
319 if (m->m_next == NULL) {
320 aprint_error_dev(sc->sc_dev,
321 "out of memory\n");
322 sc->sc_stats.err_rx++;
323 goto out; /* (lost sync) */
324 }
325
326 m = m->m_next;
327 m->m_len = 0;
328 space = MLEN;
329
330 if (sc->sc_want > MINCLSIZE) {
331 MCLGET(m, M_DONTWAIT);
332 if (m->m_flags & M_EXT)
333 space = MCLBYTES;
334 }
335 }
336 }
337
338 b = bt3c_get(sc);
339 mtod(m, uint8_t *)[m->m_len++] = b;
340 count--;
341 space--;
342 sc->sc_rxp->m_pkthdr.len++;
343 sc->sc_stats.byte_rx++;
344
345 sc->sc_want--;
346 if (sc->sc_want > 0)
347 continue; /* want more */
348
349 switch (sc->sc_state) {
350 case BT3C_RECV_PKT_TYPE: /* Got packet type */
351
352 switch (b) {
353 case HCI_ACL_DATA_PKT:
354 sc->sc_state = BT3C_RECV_ACL_HDR;
355 sc->sc_want = sizeof(hci_acldata_hdr_t) - 1;
356 break;
357
358 case HCI_SCO_DATA_PKT:
359 sc->sc_state = BT3C_RECV_SCO_HDR;
360 sc->sc_want = sizeof(hci_scodata_hdr_t) - 1;
361 break;
362
363 case HCI_EVENT_PKT:
364 sc->sc_state = BT3C_RECV_EVENT_HDR;
365 sc->sc_want = sizeof(hci_event_hdr_t) - 1;
366 break;
367
368 default:
369 aprint_error_dev(sc->sc_dev,
370 "Unknown packet type=%#x!\n", b);
371 sc->sc_stats.err_rx++;
372 m_freem(sc->sc_rxp);
373 sc->sc_rxp = NULL;
374 goto out; /* (lost sync) */
375 }
376
377 break;
378
379 /*
380 * we assume (correctly of course :) that the packet headers
381 * all fit into a single pkthdr mbuf
382 */
383 case BT3C_RECV_ACL_HDR: /* Got ACL Header */
384 sc->sc_state = BT3C_RECV_ACL_DATA;
385 sc->sc_want = mtod(m, hci_acldata_hdr_t *)->length;
386 sc->sc_want = le16toh(sc->sc_want);
387 break;
388
389 case BT3C_RECV_SCO_HDR: /* Got SCO Header */
390 sc->sc_state = BT3C_RECV_SCO_DATA;
391 sc->sc_want = mtod(m, hci_scodata_hdr_t *)->length;
392 break;
393
394 case BT3C_RECV_EVENT_HDR: /* Got Event Header */
395 sc->sc_state = BT3C_RECV_EVENT_DATA;
396 sc->sc_want = mtod(m, hci_event_hdr_t *)->length;
397 break;
398
399 case BT3C_RECV_ACL_DATA: /* ACL Packet Complete */
400 if (!hci_input_acl(sc->sc_unit, sc->sc_rxp))
401 sc->sc_stats.err_rx++;
402
403 sc->sc_stats.acl_rx++;
404 sc->sc_rxp = m = NULL;
405 space = 0;
406 break;
407
408 case BT3C_RECV_SCO_DATA: /* SCO Packet Complete */
409 if (!hci_input_sco(sc->sc_unit, sc->sc_rxp))
410 sc->sc_stats.err_rx++;
411
412 sc->sc_stats.sco_rx++;
413 sc->sc_rxp = m = NULL;
414 space = 0;
415 break;
416
417 case BT3C_RECV_EVENT_DATA: /* Event Packet Complete */
418 if (!hci_input_event(sc->sc_unit, sc->sc_rxp))
419 sc->sc_stats.err_rx++;
420
421 sc->sc_stats.evt_rx++;
422 sc->sc_rxp = m = NULL;
423 space = 0;
424 break;
425
426 default:
427 panic("%s: invalid state %d!\n",
428 device_xname(sc->sc_dev), sc->sc_state);
429 }
430 }
431
432 out:
433 bt3c_write(sc, BT3C_RX_COUNT, 0x0000);
434 }
435
436 /*
437 * write data from current packet to Transmit FIFO.
438 * restart when done.
439 */
440 static void
441 bt3c_transmit(struct bt3c_softc *sc)
442 {
443 struct mbuf *m;
444 int count, rlen;
445 uint8_t *rptr;
446
447 m = sc->sc_txp;
448 if (m == NULL) {
449 sc->sc_flags &= ~BT3C_XMIT;
450 bt3c_start(sc);
451 return;
452 }
453
454 count = 0;
455 rlen = 0;
456 rptr = mtod(m, uint8_t *);
457
458 bt3c_set_address(sc, BT3C_TX_FIFO);
459
460 for(;;) {
461 if (rlen >= m->m_len) {
462 m = m->m_next;
463 if (m == NULL) {
464 m = sc->sc_txp;
465 sc->sc_txp = NULL;
466
467 if (M_GETCTX(m, void *) == NULL)
468 m_freem(m);
469 else if (!hci_complete_sco(sc->sc_unit, m))
470 sc->sc_stats.err_tx++;
471
472 break;
473 }
474
475 rlen = 0;
476 rptr = mtod(m, uint8_t *);
477 continue;
478 }
479
480 if (count >= BT3C_FIFO_SIZE) {
481 m_adj(m, rlen);
482 break;
483 }
484
485 bt3c_put(sc, *rptr++);
486 rlen++;
487 count++;
488 }
489
490 bt3c_write(sc, BT3C_TX_COUNT, count);
491 sc->sc_stats.byte_tx += count;
492 }
493
494 /*
495 * interrupt routine
496 */
497 static int
498 bt3c_intr(void *arg)
499 {
500 struct bt3c_softc *sc = arg;
501 uint16_t control, isr;
502
503 control = bt3c_read_control(sc);
504 if (control & BT3C_IOR_CNTL_INTR) {
505 isr = bt3c_read(sc, BT3C_ISR);
506 if ((isr & 0xff) == 0x7f) {
507 aprint_error_dev(sc->sc_dev, "strange ISR=%04x\n", isr);
508 } else if ((isr & 0xff) != 0xff) {
509
510 if (isr & BT3C_ISR_RXRDY)
511 bt3c_receive(sc);
512
513 if (isr & BT3C_ISR_TXRDY)
514 bt3c_transmit(sc);
515
516 #ifdef DIAGNOSTIC
517 if (isr & BT3C_ISR_ANTENNA) {
518 if (bt3c_read(sc, BT3C_CSR) & BT3C_CSR_ANTENNA)
519 aprint_verbose_dev(sc->sc_dev,
520 "Antenna Out\n");
521 else
522 aprint_verbose_dev(sc->sc_dev,
523 "Antenna In\n");
524 }
525 #endif
526
527 bt3c_write(sc, BT3C_ISR, 0x0000);
528 bt3c_write_control(sc, control);
529
530 return 1; /* handled */
531 }
532 }
533
534 return 0; /* not handled */
535 }
536
537 /*
538 * load firmware for the device
539 *
540 * The firmware file is a plain ASCII file in the Motorola S-Record format,
541 * with lines in the format:
542 *
543 * S<Digit><Len><Address><Data1><Data2>...<DataN><Checksum>
544 *
545 * <Digit>: 0 header
546 * 3 data record (4 byte address)
547 * 7 boot record (4 byte address)
548 *
549 * <Len>: 1 byte, and is the number of bytes in the rest of the line
550 * <Address>: 4 byte address (only 2 bytes are valid for bt3c I think)
551 * <Data>: 2 byte data word to be written to the address
552 * <Checksum>: checksum of all bytes in the line including <Len>
553 *
554 * all bytes are in hexadecimal
555 */
556 static inline int32_t
557 hex(const uint8_t *p, int n)
558 {
559 uint32_t val = 0;
560
561 while (n > 0) {
562 val <<= 4;
563
564 if ('0' <= *p && *p <= '9')
565 val += (*p - '0');
566 else if ('a' <= *p && *p <= 'f')
567 val += (*p - 'a' + 0xa);
568 else if ('A' <= *p && *p <= 'F')
569 val += (*p - 'A' + 0xa);
570 else
571 return -1;
572
573 p++;
574 n--;
575 }
576
577 return val;
578 }
579
580 static int
581 bt3c_load_firmware(struct bt3c_softc *sc)
582 {
583 uint8_t *buf, *line, *next, *p;
584 int32_t addr, data;
585 int err, sum, len;
586 firmware_handle_t fh;
587 cfdata_t cf = device_cfdata(sc->sc_dev);
588 size_t size;
589
590 err = firmware_open(cf->cf_name,
591 BT3C_FIRMWARE_FILE, &fh);
592 if (err) {
593 aprint_error_dev(sc->sc_dev, "Cannot open firmware %s/%s\n",
594 cf->cf_name, BT3C_FIRMWARE_FILE);
595 return err;
596 }
597
598 size = (size_t)firmware_get_size(fh);
599 #ifdef DIAGNOSTIC
600 if (size > 10 * 1024) { /* sanity check */
601 aprint_error_dev(sc->sc_dev, "insane firmware file size!\n");
602 firmware_close(fh);
603 return EFBIG;
604 }
605 #endif
606
607 buf = firmware_malloc(size);
608 KASSERT(buf != NULL);
609
610 err = firmware_read(fh, 0, buf, size);
611 if (err) {
612 aprint_error_dev(sc->sc_dev, "Firmware read failed (%d)\n", err);
613 goto out;
614 }
615
616 /* Reset */
617 bt3c_write(sc, 0x8040, 0x0404);
618 bt3c_write(sc, 0x8040, 0x0400);
619 DELAY(1);
620 bt3c_write(sc, 0x8040, 0x0404);
621 DELAY(17);
622
623 next = buf;
624 err = EFTYPE;
625
626 while (next < buf + size) {
627 line = next;
628
629 while (*next != '\r' && *next != '\n') {
630 if (next >= buf + size)
631 goto out;
632
633 next++;
634 }
635
636 /* 14 covers address and checksum minimum */
637 if (next - line < 14)
638 goto out;
639
640 if (line[0] != 'S')
641 goto out;
642
643 /* verify line length */
644 len = hex(line + 2, 2);
645 if (len < 0 || next - line != len * 2 + 4)
646 goto out;
647
648 /* checksum the line */
649 sum = 0;
650 for (p = line + 2 ; p < next ; p += 2)
651 sum += hex(p, 2);
652
653 if ((sum & 0xff) != 0xff)
654 goto out;
655
656 /* extract relevant data */
657 switch (line[1]) {
658 case '0':
659 /* we ignore the header */
660 break;
661
662 case '3':
663 /* find number of data words */
664 len = (len - 5) / 2;
665 if (len > 15)
666 goto out;
667
668 addr = hex(line + 8, 4);
669 if (addr < 0)
670 goto out;
671
672 bt3c_set_address(sc, addr);
673
674 for (p = line + 12 ; p + 4 < next ; p += 4) {
675 data = hex(p, 4);
676 if (data < 0)
677 goto out;
678
679 bt3c_put(sc, data);
680 }
681 break;
682
683 case '7':
684 /*
685 * for some reason we ignore this record
686 * and boot from 0x3000 which happens to
687 * be the first record in the file.
688 */
689 break;
690
691 default:
692 goto out;
693 }
694
695 /* skip to start of next line */
696 while (next < buf + size && (*next == '\r' || *next == '\n'))
697 next++;
698 }
699
700 err = 0;
701 DELAY(17);
702
703 /* Boot */
704 bt3c_set_address(sc, 0x3000);
705 bt3c_write_control(sc, (bt3c_read_control(sc) | BT3C_IOR_CNTL_BOOT));
706 DELAY(17);
707
708 /* Clear Registers */
709 bt3c_write(sc, BT3C_RX_COUNT, 0x0000);
710 bt3c_write(sc, BT3C_TX_COUNT, 0x0000);
711 bt3c_write(sc, BT3C_ISR, 0x0000);
712 DELAY(1000);
713
714 out:
715 firmware_free(buf, size);
716 firmware_close(fh);
717 return err;
718 }
719
720 /**************************************************************************
721 *
722 * bt device callbacks
723 */
724
725 /*
726 * start sending on bt3c
727 * should be called at spltty() when BT3C_XMIT is not set
728 */
729 static void
730 bt3c_start(struct bt3c_softc *sc)
731 {
732 struct mbuf *m;
733
734 KASSERT((sc->sc_flags & BT3C_XMIT) == 0);
735 KASSERT(sc->sc_txp == NULL);
736
737 if (MBUFQ_FIRST(&sc->sc_cmdq)) {
738 MBUFQ_DEQUEUE(&sc->sc_cmdq, m);
739 sc->sc_stats.cmd_tx++;
740 goto start;
741 }
742
743 if (MBUFQ_FIRST(&sc->sc_scoq)) {
744 MBUFQ_DEQUEUE(&sc->sc_scoq, m);
745 sc->sc_stats.sco_tx++;
746 goto start;
747 }
748
749 if (MBUFQ_FIRST(&sc->sc_aclq)) {
750 MBUFQ_DEQUEUE(&sc->sc_aclq, m);
751 sc->sc_stats.acl_tx++;
752 goto start;
753 }
754
755 /* Nothing to send */
756 return;
757
758 start:
759 sc->sc_txp = m;
760 sc->sc_flags |= BT3C_XMIT;
761 bt3c_transmit(sc);
762 }
763
764 static void
765 bt3c_output_cmd(device_t self, struct mbuf *m)
766 {
767 struct bt3c_softc *sc = device_private(self);
768 int s;
769
770 KASSERT(sc->sc_flags & BT3C_ENABLED);
771
772 M_SETCTX(m, NULL);
773
774 s = spltty();
775 MBUFQ_ENQUEUE(&sc->sc_cmdq, m);
776 if ((sc->sc_flags & BT3C_XMIT) == 0)
777 bt3c_start(sc);
778
779 splx(s);
780 }
781
782 static void
783 bt3c_output_acl(device_t self, struct mbuf *m)
784 {
785 struct bt3c_softc *sc = device_private(self);
786 int s;
787
788 KASSERT(sc->sc_flags & BT3C_ENABLED);
789
790 M_SETCTX(m, NULL);
791
792 s = spltty();
793 MBUFQ_ENQUEUE(&sc->sc_aclq, m);
794 if ((sc->sc_flags & BT3C_XMIT) == 0)
795 bt3c_start(sc);
796
797 splx(s);
798 }
799
800 static void
801 bt3c_output_sco(device_t self, struct mbuf *m)
802 {
803 struct bt3c_softc *sc = device_private(self);
804 int s;
805
806 KASSERT(sc->sc_flags & BT3C_ENABLED);
807
808 s = spltty();
809 MBUFQ_ENQUEUE(&sc->sc_scoq, m);
810 if ((sc->sc_flags & BT3C_XMIT) == 0)
811 bt3c_start(sc);
812
813 splx(s);
814 }
815
816 /*
817 * enable device
818 * turn on card
819 * load firmware
820 * establish interrupts
821 */
822 static int
823 bt3c_enable(device_t self)
824 {
825 struct bt3c_softc *sc = device_private(self);
826 int err, s;
827
828 if (sc->sc_flags & BT3C_ENABLED)
829 return 0;
830
831 s = spltty();
832
833 sc->sc_intr = pcmcia_intr_establish(sc->sc_pf, IPL_TTY, bt3c_intr, sc);
834 if (sc->sc_intr == NULL) {
835 err = EIO;
836 goto bad;
837 }
838
839 err = pcmcia_function_enable(sc->sc_pf);
840 if (err)
841 goto bad1;
842
843 err = bt3c_load_firmware(sc);
844 if (err)
845 goto bad2;
846
847 sc->sc_flags |= BT3C_ENABLED;
848 sc->sc_flags &= ~BT3C_XMIT;
849
850 splx(s);
851
852 return 0;
853
854 bad2:
855 pcmcia_function_disable(sc->sc_pf);
856 bad1:
857 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_intr);
858 sc->sc_intr = NULL;
859 bad:
860 splx(s);
861 return err;
862 }
863
864 /*
865 * disable device
866 * shut down card
867 * disestablish interrupts
868 * free held packets
869 */
870 static void
871 bt3c_disable(device_t self)
872 {
873 struct bt3c_softc *sc = device_private(self);
874 int s;
875
876 if ((sc->sc_flags & BT3C_ENABLED) == 0)
877 return;
878
879 s = spltty();
880
881 pcmcia_function_disable(sc->sc_pf);
882
883 if (sc->sc_intr) {
884 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_intr);
885 sc->sc_intr = NULL;
886 }
887
888 if (sc->sc_rxp) {
889 m_freem(sc->sc_rxp);
890 sc->sc_rxp = NULL;
891 }
892
893 if (sc->sc_txp) {
894 m_freem(sc->sc_txp);
895 sc->sc_txp = NULL;
896 }
897
898 MBUFQ_DRAIN(&sc->sc_cmdq);
899 MBUFQ_DRAIN(&sc->sc_aclq);
900 MBUFQ_DRAIN(&sc->sc_scoq);
901
902 sc->sc_flags &= ~BT3C_ENABLED;
903 splx(s);
904 }
905
906 void
907 bt3c_stats(device_t self, struct bt_stats *dest, int flush)
908 {
909 struct bt3c_softc *sc = device_private(self);
910 int s;
911
912 s = spltty();
913 memcpy(dest, &sc->sc_stats, sizeof(struct bt_stats));
914
915 if (flush)
916 memset(&sc->sc_stats, 0, sizeof(struct bt_stats));
917
918 splx(s);
919 }
920
921 /**************************************************************************
922 *
923 * bt3c PCMCIA autoconfig glue
924 */
925
926 static int
927 bt3c_match(device_t parent, cfdata_t match, void *aux)
928 {
929 struct pcmcia_attach_args *pa = aux;
930
931 if (pa->manufacturer == PCMCIA_VENDOR_3COM &&
932 pa->product == PCMCIA_PRODUCT_3COM_3CRWB6096)
933 return 10; /* 'com' also claims this, so trump them */
934
935 return 0;
936 }
937
938 static void
939 bt3c_attach(device_t parent, device_t self, void *aux)
940 {
941 struct bt3c_softc *sc = device_private(self);
942 struct pcmcia_attach_args *pa = aux;
943 struct pcmcia_config_entry *cfe;
944
945 sc->sc_dev = self;
946 sc->sc_pf = pa->pf;
947
948 MBUFQ_INIT(&sc->sc_cmdq);
949 MBUFQ_INIT(&sc->sc_aclq);
950 MBUFQ_INIT(&sc->sc_scoq);
951
952 /* Find a PCMCIA config entry we can use */
953 SIMPLEQ_FOREACH(cfe, &pa->pf->cfe_head, cfe_list) {
954 if (cfe->num_memspace != 0)
955 continue;
956
957 if (cfe->num_iospace != 1)
958 continue;
959
960 if (pcmcia_io_alloc(pa->pf, cfe->iospace[0].start,
961 cfe->iospace[0].length, 0, &sc->sc_pcioh) == 0)
962 break;
963 }
964
965 if (cfe == 0) {
966 aprint_error_dev(self, "cannot allocate io space\n");
967 goto no_config_entry;
968 }
969
970 /* Initialise it */
971 pcmcia_function_init(pa->pf, cfe);
972
973 /* Map in the io space */
974 if (pcmcia_io_map(pa->pf, PCMCIA_WIDTH_AUTO,
975 &sc->sc_pcioh, &sc->sc_iow)) {
976 aprint_error_dev(self, "cannot map io space\n");
977 goto iomap_failed;
978 }
979
980 /* Attach Bluetooth unit */
981 sc->sc_unit = hci_attach(&bt3c_hci, self, BTF_POWER_UP_NOOP);
982 if (sc->sc_unit == NULL)
983 aprint_error_dev(self, "HCI attach failed\n");
984
985 if (!pmf_device_register(self, bt3c_suspend, bt3c_resume))
986 aprint_error_dev(self, "couldn't establish power handler\n");
987
988 return;
989
990 iomap_failed:
991 /* unmap io space */
992 pcmcia_io_free(pa->pf, &sc->sc_pcioh);
993
994 no_config_entry:
995 sc->sc_iow = -1;
996 }
997
998 static int
999 bt3c_detach(device_t self, int flags)
1000 {
1001 struct bt3c_softc *sc = device_private(self);
1002 int err = 0;
1003
1004 pmf_device_deregister(self);
1005 bt3c_disable(self);
1006
1007 if (sc->sc_unit) {
1008 hci_detach(sc->sc_unit);
1009 sc->sc_unit = NULL;
1010 }
1011
1012 if (sc->sc_iow != -1) {
1013 pcmcia_io_unmap(sc->sc_pf, sc->sc_iow);
1014 pcmcia_io_free(sc->sc_pf, &sc->sc_pcioh);
1015 sc->sc_iow = -1;
1016 }
1017
1018 return err;
1019 }
1020
1021 static bool
1022 bt3c_suspend(device_t self, pmf_qual_t qual)
1023 {
1024 struct bt3c_softc *sc = device_private(self);
1025
1026 if (sc->sc_unit) {
1027 hci_detach(sc->sc_unit);
1028 sc->sc_unit = NULL;
1029 }
1030
1031 return true;
1032 }
1033
1034 static bool
1035 bt3c_resume(device_t self, pmf_qual_t qual)
1036 {
1037 struct bt3c_softc *sc = device_private(self);
1038
1039 KASSERT(sc->sc_unit == NULL);
1040
1041 sc->sc_unit = hci_attach(&bt3c_hci, self, BTF_POWER_UP_NOOP);
1042 if (sc->sc_unit == NULL)
1043 return false;
1044
1045 return true;
1046 }
NetBSD on the FriendlyARM MINI2440