← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to hw/bt-hci-csr.c

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/bt-hci-csr.c
 
1
/*
 
2
 * Bluetooth serial HCI transport.
 
3
 * CSR41814 HCI with H4p vendor extensions.
 
4
 *
 
5
 * Copyright (C) 2008 Andrzej Zaborowski  <balrog@zabor.org>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU General Public License as
 
9
 * published by the Free Software Foundation; either version 2 or
 
10
 * (at your option) version 3 of the License.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License along
 
18
 * with this program; if not, see <http://www.gnu.org/licenses/>.
 
19
 */
 
20
 
 
21
#include "qemu-common.h"
 
22
#include "qemu-char.h"
 
23
#include "qemu-timer.h"
 
24
#include "irq.h"
 
25
#include "net.h"
 
26
#include "bt.h"
 
27
 
 
28
struct csrhci_s {
 
29
    int enable;
 
30
    qemu_irq *pins;
 
31
    int pin_state;
 
32
    int modem_state;
 
33
    CharDriverState chr;
 
34
#define FIFO_LEN        4096
 
35
    int out_start;
 
36
    int out_len;
 
37
    int out_size;
 
38
    uint8_t outfifo[FIFO_LEN * 2];
 
39
    uint8_t inpkt[FIFO_LEN];
 
40
    int in_len;
 
41
    int in_hdr;
 
42
    int in_data;
 
43
    QEMUTimer *out_tm;
 
44
    int64_t baud_delay;
 
45
 
 
46
    bdaddr_t bd_addr;
 
47
    struct HCIInfo *hci;
 
48
};
 
49
 
 
50
/* H4+ packet types */
 
51
enum {
 
52
    H4_CMD_PKT   = 1,
 
53
    H4_ACL_PKT   = 2,
 
54
    H4_SCO_PKT   = 3,
 
55
    H4_EVT_PKT   = 4,
 
56
    H4_NEG_PKT   = 6,
 
57
    H4_ALIVE_PKT = 7,
 
58
};
 
59
 
 
60
/* CSR41814 negotiation start magic packet */
 
61
static const uint8_t csrhci_neg_packet[] = {
 
62
    H4_NEG_PKT, 10,
 
63
    0x00, 0xa0, 0x01, 0x00, 0x00,
 
64
    0x4c, 0x00, 0x96, 0x00, 0x00,
 
65
};
 
66
 
 
67
/* CSR41814 vendor-specific command OCFs */
 
68
enum {
 
69
    OCF_CSR_SEND_FIRMWARE = 0x000,
 
70
};
 
71
 
 
72
static inline void csrhci_fifo_wake(struct csrhci_s *s)
 
73
{
 
74
    if (!s->enable || !s->out_len)
 
75
        return;
 
76
 
 
77
    /* XXX: Should wait for s->modem_state & CHR_TIOCM_RTS? */
 
78
    if (s->chr.chr_can_read && s->chr.chr_can_read(s->chr.handler_opaque) &&
 
79
                    s->chr.chr_read) {
 
80
        s->chr.chr_read(s->chr.handler_opaque,
 
81
                        s->outfifo + s->out_start ++, 1);
 
82
        s->out_len --;
 
83
        if (s->out_start >= s->out_size) {
 
84
            s->out_start = 0;
 
85
            s->out_size = FIFO_LEN;
 
86
        }
 
87
    }
 
88
 
 
89
    if (s->out_len)
 
90
        qemu_mod_timer(s->out_tm, qemu_get_clock_ns(vm_clock) + s->baud_delay);
 
91
}
 
92
 
 
93
#define csrhci_out_packetz(s, len) memset(csrhci_out_packet(s, len), 0, len)
 
94
static uint8_t *csrhci_out_packet(struct csrhci_s *s, int len)
 
95
{
 
96
    int off = s->out_start + s->out_len;
 
97
 
 
98
    /* TODO: do the padding here, i.e. align len */
 
99
    s->out_len += len;
 
100
 
 
101
    if (off < FIFO_LEN) {
 
102
        if (off + len > FIFO_LEN && (s->out_size = off + len) > FIFO_LEN * 2) {
 
103
            fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
 
104
            exit(-1);
 
105
        }
 
106
        return s->outfifo + off;
 
107
    }
 
108
 
 
109
    if (s->out_len > s->out_size) {
 
110
        fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
 
111
        exit(-1);
 
112
    }
 
113
 
 
114
    return s->outfifo + off - s->out_size;
 
115
}
 
116
 
 
117
static inline uint8_t *csrhci_out_packet_csr(struct csrhci_s *s,
 
118
                int type, int len)
 
119
{
 
120
    uint8_t *ret = csrhci_out_packetz(s, len + 2);
 
121
 
 
122
    *ret ++ = type;
 
123
    *ret ++ = len;
 
124
 
 
125
    return ret;
 
126
}
 
127
 
 
128
static inline uint8_t *csrhci_out_packet_event(struct csrhci_s *s,
 
129
                int evt, int len)
 
130
{
 
131
    uint8_t *ret = csrhci_out_packetz(s,
 
132
                    len + 1 + sizeof(struct hci_event_hdr));
 
133
 
 
134
    *ret ++ = H4_EVT_PKT;
 
135
    ((struct hci_event_hdr *) ret)->evt = evt;
 
136
    ((struct hci_event_hdr *) ret)->plen = len;
 
137
 
 
138
    return ret + sizeof(struct hci_event_hdr);
 
139
}
 
140
 
 
141
static void csrhci_in_packet_vendor(struct csrhci_s *s, int ocf,
 
142
                uint8_t *data, int len)
 
143
{
 
144
    int offset;
 
145
    uint8_t *rpkt;
 
146
 
 
147
    switch (ocf) {
 
148
    case OCF_CSR_SEND_FIRMWARE:
 
149
        /* Check if this is the bd_address packet */
 
150
        if (len >= 18 + 8 && data[12] == 0x01 && data[13] == 0x00) {
 
151
            offset = 18;
 
152
            s->bd_addr.b[0] = data[offset + 7]; /* Beyond cmd packet end(!?) */
 
153
            s->bd_addr.b[1] = data[offset + 6];
 
154
            s->bd_addr.b[2] = data[offset + 4];
 
155
            s->bd_addr.b[3] = data[offset + 0];
 
156
            s->bd_addr.b[4] = data[offset + 3];
 
157
            s->bd_addr.b[5] = data[offset + 2];
 
158
 
 
159
            s->hci->bdaddr_set(s->hci, s->bd_addr.b);
 
160
            fprintf(stderr, "%s: bd_address loaded from firmware: "
 
161
                            "%02x:%02x:%02x:%02x:%02x:%02x\n", __FUNCTION__,
 
162
                            s->bd_addr.b[0], s->bd_addr.b[1], s->bd_addr.b[2],
 
163
                            s->bd_addr.b[3], s->bd_addr.b[4], s->bd_addr.b[5]);
 
164
        }
 
165
 
 
166
        rpkt = csrhci_out_packet_event(s, EVT_VENDOR, 11);
 
167
        /* Status bytes: no error */
 
168
        rpkt[9] = 0x00;
 
169
        rpkt[10] = 0x00;
 
170
        break;
 
171
 
 
172
    default:
 
173
        fprintf(stderr, "%s: got a bad CMD packet\n", __FUNCTION__);
 
174
        return;
 
175
    }
 
176
 
 
177
    csrhci_fifo_wake(s);
 
178
}
 
179
 
 
180
static void csrhci_in_packet(struct csrhci_s *s, uint8_t *pkt)
 
181
{
 
182
    uint8_t *rpkt;
 
183
    int opc;
 
184
 
 
185
    switch (*pkt ++) {
 
186
    case H4_CMD_PKT:
 
187
        opc = le16_to_cpu(((struct hci_command_hdr *) pkt)->opcode);
 
188
        if (cmd_opcode_ogf(opc) == OGF_VENDOR_CMD) {
 
189
            csrhci_in_packet_vendor(s, cmd_opcode_ocf(opc),
 
190
                            pkt + sizeof(struct hci_command_hdr),
 
191
                            s->in_len - sizeof(struct hci_command_hdr) - 1);
 
192
            return;
 
193
        }
 
194
 
 
195
        /* TODO: if the command is OCF_READ_LOCAL_COMMANDS or the likes,
 
196
         * we need to send it to the HCI layer and then add our supported
 
197
         * commands to the returned mask (such as OGF_VENDOR_CMD).  With
 
198
         * bt-hci.c we could just have hooks for this kind of commands but
 
199
         * we can't with bt-host.c.  */
 
200
 
 
201
        s->hci->cmd_send(s->hci, pkt, s->in_len - 1);
 
202
        break;
 
203
 
 
204
    case H4_EVT_PKT:
 
205
        goto bad_pkt;
 
206
 
 
207
    case H4_ACL_PKT:
 
208
        s->hci->acl_send(s->hci, pkt, s->in_len - 1);
 
209
        break;
 
210
 
 
211
    case H4_SCO_PKT:
 
212
        s->hci->sco_send(s->hci, pkt, s->in_len - 1);
 
213
        break;
 
214
 
 
215
    case H4_NEG_PKT:
 
216
        if (s->in_hdr != sizeof(csrhci_neg_packet) ||
 
217
                        memcmp(pkt - 1, csrhci_neg_packet, s->in_hdr)) {
 
218
            fprintf(stderr, "%s: got a bad NEG packet\n", __FUNCTION__);
 
219
            return;
 
220
        }
 
221
        pkt += 2;
 
222
 
 
223
        rpkt = csrhci_out_packet_csr(s, H4_NEG_PKT, 10);
 
224
 
 
225
        *rpkt ++ = 0x20;        /* Operational settings negotation Ok */
 
226
        memcpy(rpkt, pkt, 7); rpkt += 7;
 
227
        *rpkt ++ = 0xff;
 
228
        *rpkt = 0xff;
 
229
        break;
 
230
 
 
231
    case H4_ALIVE_PKT:
 
232
        if (s->in_hdr != 4 || pkt[1] != 0x55 || pkt[2] != 0x00) {
 
233
            fprintf(stderr, "%s: got a bad ALIVE packet\n", __FUNCTION__);
 
234
            return;
 
235
        }
 
236
 
 
237
        rpkt = csrhci_out_packet_csr(s, H4_ALIVE_PKT, 2);
 
238
 
 
239
        *rpkt ++ = 0xcc;
 
240
        *rpkt = 0x00;
 
241
        break;
 
242
 
 
243
    default:
 
244
    bad_pkt:
 
245
        /* TODO: error out */
 
246
        fprintf(stderr, "%s: got a bad packet\n", __FUNCTION__);
 
247
        break;
 
248
    }
 
249
 
 
250
    csrhci_fifo_wake(s);
 
251
}
 
252
 
 
253
static int csrhci_header_len(const uint8_t *pkt)
 
254
{
 
255
    switch (pkt[0]) {
 
256
    case H4_CMD_PKT:
 
257
        return HCI_COMMAND_HDR_SIZE;
 
258
    case H4_EVT_PKT:
 
259
        return HCI_EVENT_HDR_SIZE;
 
260
    case H4_ACL_PKT:
 
261
        return HCI_ACL_HDR_SIZE;
 
262
    case H4_SCO_PKT:
 
263
        return HCI_SCO_HDR_SIZE;
 
264
    case H4_NEG_PKT:
 
265
        return pkt[1] + 1;
 
266
    case H4_ALIVE_PKT:
 
267
        return 3;
 
268
    }
 
269
 
 
270
    exit(-1);
 
271
}
 
272
 
 
273
static int csrhci_data_len(const uint8_t *pkt)
 
274
{
 
275
    switch (*pkt ++) {
 
276
    case H4_CMD_PKT:
 
277
        /* It seems that vendor-specific command packets for H4+ are all
 
278
         * one byte longer than indicated in the standard header.  */
 
279
        if (le16_to_cpu(((struct hci_command_hdr *) pkt)->opcode) == 0xfc00)
 
280
            return (((struct hci_command_hdr *) pkt)->plen + 1) & ~1;
 
281
 
 
282
        return ((struct hci_command_hdr *) pkt)->plen;
 
283
    case H4_EVT_PKT:
 
284
        return ((struct hci_event_hdr *) pkt)->plen;
 
285
    case H4_ACL_PKT:
 
286
        return le16_to_cpu(((struct hci_acl_hdr *) pkt)->dlen);
 
287
    case H4_SCO_PKT:
 
288
        return ((struct hci_sco_hdr *) pkt)->dlen;
 
289
    case H4_NEG_PKT:
 
290
    case H4_ALIVE_PKT:
 
291
        return 0;
 
292
    }
 
293
 
 
294
    exit(-1);
 
295
}
 
296
 
 
297
static int csrhci_write(struct CharDriverState *chr,
 
298
                const uint8_t *buf, int len)
 
299
{
 
300
    struct csrhci_s *s = (struct csrhci_s *) chr->opaque;
 
301
    int plen = s->in_len;
 
302
 
 
303
    if (!s->enable)
 
304
        return 0;
 
305
 
 
306
    s->in_len += len;
 
307
    memcpy(s->inpkt + plen, buf, len);
 
308
 
 
309
    while (1) {
 
310
        if (s->in_len >= 2 && plen < 2)
 
311
            s->in_hdr = csrhci_header_len(s->inpkt) + 1;
 
312
 
 
313
        if (s->in_len >= s->in_hdr && plen < s->in_hdr)
 
314
            s->in_data = csrhci_data_len(s->inpkt) + s->in_hdr;
 
315
 
 
316
        if (s->in_len >= s->in_data) {
 
317
            csrhci_in_packet(s, s->inpkt);
 
318
 
 
319
            memmove(s->inpkt, s->inpkt + s->in_len, s->in_len - s->in_data);
 
320
            s->in_len -= s->in_data;
 
321
            s->in_hdr = INT_MAX;
 
322
            s->in_data = INT_MAX;
 
323
            plen = 0;
 
324
        } else
 
325
            break;
 
326
    }
 
327
 
 
328
    return len;
 
329
}
 
330
 
 
331
static void csrhci_out_hci_packet_event(void *opaque,
 
332
                const uint8_t *data, int len)
 
333
{
 
334
    struct csrhci_s *s = (struct csrhci_s *) opaque;
 
335
    uint8_t *pkt = csrhci_out_packet(s, (len + 2) & ~1);        /* Align */
 
336
 
 
337
    *pkt ++ = H4_EVT_PKT;
 
338
    memcpy(pkt, data, len);
 
339
 
 
340
    csrhci_fifo_wake(s);
 
341
}
 
342
 
 
343
static void csrhci_out_hci_packet_acl(void *opaque,
 
344
                const uint8_t *data, int len)
 
345
{
 
346
    struct csrhci_s *s = (struct csrhci_s *) opaque;
 
347
    uint8_t *pkt = csrhci_out_packet(s, (len + 2) & ~1);        /* Align */
 
348
 
 
349
    *pkt ++ = H4_ACL_PKT;
 
350
    pkt[len & ~1] = 0;
 
351
    memcpy(pkt, data, len);
 
352
 
 
353
    csrhci_fifo_wake(s);
 
354
}
 
355
 
 
356
static int csrhci_ioctl(struct CharDriverState *chr, int cmd, void *arg)
 
357
{
 
358
    QEMUSerialSetParams *ssp;
 
359
    struct csrhci_s *s = (struct csrhci_s *) chr->opaque;
 
360
    int prev_state = s->modem_state;
 
361
 
 
362
    switch (cmd) {
 
363
    case CHR_IOCTL_SERIAL_SET_PARAMS:
 
364
        ssp = (QEMUSerialSetParams *) arg;
 
365
        s->baud_delay = get_ticks_per_sec() / ssp->speed;
 
366
        /* Moments later... (but shorter than 100ms) */
 
367
        s->modem_state |= CHR_TIOCM_CTS;
 
368
        break;
 
369
 
 
370
    case CHR_IOCTL_SERIAL_GET_TIOCM:
 
371
        *(int *) arg = s->modem_state;
 
372
        break;
 
373
 
 
374
    case CHR_IOCTL_SERIAL_SET_TIOCM:
 
375
        s->modem_state = *(int *) arg;
 
376
        if (~s->modem_state & prev_state & CHR_TIOCM_RTS)
 
377
            s->modem_state &= ~CHR_TIOCM_CTS;
 
378
        break;
 
379
 
 
380
    default:
 
381
        return -ENOTSUP;
 
382
    }
 
383
    return 0;
 
384
}
 
385
 
 
386
static void csrhci_reset(struct csrhci_s *s)
 
387
{
 
388
    s->out_len = 0;
 
389
    s->out_size = FIFO_LEN;
 
390
    s->in_len = 0;
 
391
    s->baud_delay = get_ticks_per_sec();
 
392
    s->enable = 0;
 
393
    s->in_hdr = INT_MAX;
 
394
    s->in_data = INT_MAX;
 
395
 
 
396
    s->modem_state = 0;
 
397
    /* After a while... (but sooner than 10ms) */
 
398
    s->modem_state |= CHR_TIOCM_CTS;
 
399
 
 
400
    memset(&s->bd_addr, 0, sizeof(bdaddr_t));
 
401
}
 
402
 
 
403
static void csrhci_out_tick(void *opaque)
 
404
{
 
405
    csrhci_fifo_wake((struct csrhci_s *) opaque);
 
406
}
 
407
 
 
408
static void csrhci_pins(void *opaque, int line, int level)
 
409
{
 
410
    struct csrhci_s *s = (struct csrhci_s *) opaque;
 
411
    int state = s->pin_state;
 
412
 
 
413
    s->pin_state &= ~(1 << line);
 
414
    s->pin_state |= (!!level) << line;
 
415
 
 
416
    if ((state & ~s->pin_state) & (1 << csrhci_pin_reset)) {
 
417
        /* TODO: Disappear from lower layers */
 
418
        csrhci_reset(s);
 
419
    }
 
420
 
 
421
    if (s->pin_state == 3 && state != 3) {
 
422
        s->enable = 1;
 
423
        /* TODO: Wake lower layers up */
 
424
    }
 
425
}
 
426
 
 
427
qemu_irq *csrhci_pins_get(CharDriverState *chr)
 
428
{
 
429
    struct csrhci_s *s = (struct csrhci_s *) chr->opaque;
 
430
 
 
431
    return s->pins;
 
432
}
 
433
 
 
434
CharDriverState *uart_hci_init(qemu_irq wakeup)
 
435
{
 
436
    struct csrhci_s *s = (struct csrhci_s *)
 
437
            g_malloc0(sizeof(struct csrhci_s));
 
438
 
 
439
    s->chr.opaque = s;
 
440
    s->chr.chr_write = csrhci_write;
 
441
    s->chr.chr_ioctl = csrhci_ioctl;
 
442
 
 
443
    s->hci = qemu_next_hci();
 
444
    s->hci->opaque = s;
 
445
    s->hci->evt_recv = csrhci_out_hci_packet_event;
 
446
    s->hci->acl_recv = csrhci_out_hci_packet_acl;
 
447
 
 
448
    s->out_tm = qemu_new_timer_ns(vm_clock, csrhci_out_tick, s);
 
449
    s->pins = qemu_allocate_irqs(csrhci_pins, s, __csrhci_pins);
 
450
    csrhci_reset(s);
 
451
 
 
452
    return &s->chr;
 
453
}