projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://neil.brown.name/md
[deliverable/linux.git] / net / bluetooth / cmtp / capi.c
1 /*
2 CMTP implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License version 2 as
7 published by the Free Software Foundation;
8
9 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
10 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
11 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
12 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
13 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17
18 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
19 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
20 SOFTWARE IS DISCLAIMED.
21 */
22
23 #include <linux/module.h>
24
25 #include <linux/types.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/poll.h>
31 #include <linux/fcntl.h>
32 #include <linux/skbuff.h>
33 #include <linux/socket.h>
34 #include <linux/ioctl.h>
35 #include <linux/file.h>
36 #include <linux/wait.h>
37 #include <net/sock.h>
38
39 #include <linux/isdn/capilli.h>
40 #include <linux/isdn/capicmd.h>
41 #include <linux/isdn/capiutil.h>
42
43 #include "cmtp.h"
44
45 #define CAPI_INTEROPERABILITY 0x20
46
47 #define CAPI_INTEROPERABILITY_REQ CAPICMD(CAPI_INTEROPERABILITY, CAPI_REQ)
48 #define CAPI_INTEROPERABILITY_CONF CAPICMD(CAPI_INTEROPERABILITY, CAPI_CONF)
49 #define CAPI_INTEROPERABILITY_IND CAPICMD(CAPI_INTEROPERABILITY, CAPI_IND)
50 #define CAPI_INTEROPERABILITY_RESP CAPICMD(CAPI_INTEROPERABILITY, CAPI_RESP)
51
52 #define CAPI_INTEROPERABILITY_REQ_LEN (CAPI_MSG_BASELEN + 2)
53 #define CAPI_INTEROPERABILITY_CONF_LEN (CAPI_MSG_BASELEN + 4)
54 #define CAPI_INTEROPERABILITY_IND_LEN (CAPI_MSG_BASELEN + 2)
55 #define CAPI_INTEROPERABILITY_RESP_LEN (CAPI_MSG_BASELEN + 2)
56
57 #define CAPI_FUNCTION_REGISTER 0
58 #define CAPI_FUNCTION_RELEASE 1
59 #define CAPI_FUNCTION_GET_PROFILE 2
60 #define CAPI_FUNCTION_GET_MANUFACTURER 3
61 #define CAPI_FUNCTION_GET_VERSION 4
62 #define CAPI_FUNCTION_GET_SERIAL_NUMBER 5
63 #define CAPI_FUNCTION_MANUFACTURER 6
64 #define CAPI_FUNCTION_LOOPBACK 7
65
66
67 #define CMTP_MSGNUM 1
68 #define CMTP_APPLID 2
69 #define CMTP_MAPPING 3
70
71 static struct cmtp_application *cmtp_application_add(struct cmtp_session *session, __u16 appl)
72 {
73 struct cmtp_application *app = kzalloc(sizeof(*app), GFP_KERNEL);
74
75 BT_DBG("session %p application %p appl %d", session, app, appl);
76
77 if (!app)
78 return NULL;
79
80 app->state = BT_OPEN;
81 app->appl = appl;
82
83 list_add_tail(&app->list, &session->applications);
84
85 return app;
86 }
87
88 static void cmtp_application_del(struct cmtp_session *session, struct cmtp_application *app)
89 {
90 BT_DBG("session %p application %p", session, app);
91
92 if (app) {
93 list_del(&app->list);
94 kfree(app);
95 }
96 }
97
98 static struct cmtp_application *cmtp_application_get(struct cmtp_session *session, int pattern, __u16 value)
99 {
100 struct cmtp_application *app;
101 struct list_head *p, *n;
102
103 list_for_each_safe(p, n, &session->applications) {
104 app = list_entry(p, struct cmtp_application, list);
105 switch (pattern) {
106 case CMTP_MSGNUM:
107 if (app->msgnum == value)
108 return app;
109 break;
110 case CMTP_APPLID:
111 if (app->appl == value)
112 return app;
113 break;
114 case CMTP_MAPPING:
115 if (app->mapping == value)
116 return app;
117 break;
118 }
119 }
120
121 return NULL;
122 }
123
124 static int cmtp_msgnum_get(struct cmtp_session *session)
125 {
126 session->msgnum++;
127
128 if ((session->msgnum & 0xff) > 200)
129 session->msgnum = CMTP_INITIAL_MSGNUM + 1;
130
131 return session->msgnum;
132 }
133
134 static void cmtp_send_capimsg(struct cmtp_session *session, struct sk_buff *skb)
135 {
136 struct cmtp_scb *scb = (void *) skb->cb;
137
138 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
139
140 scb->id = -1;
141 scb->data = (CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3);
142
143 skb_queue_tail(&session->transmit, skb);
144
145 cmtp_schedule(session);
146 }
147
148 static void cmtp_send_interopmsg(struct cmtp_session *session,
149 __u8 subcmd, __u16 appl, __u16 msgnum,
150 __u16 function, unsigned char *buf, int len)
151 {
152 struct sk_buff *skb;
153 unsigned char *s;
154
155 BT_DBG("session %p subcmd 0x%02x appl %d msgnum %d", session, subcmd, appl, msgnum);
156
157 if (!(skb = alloc_skb(CAPI_MSG_BASELEN + 6 + len, GFP_ATOMIC))) {
158 BT_ERR("Can't allocate memory for interoperability packet");
159 return;
160 }
161
162 s = skb_put(skb, CAPI_MSG_BASELEN + 6 + len);
163
164 capimsg_setu16(s, 0, CAPI_MSG_BASELEN + 6 + len);
165 capimsg_setu16(s, 2, appl);
166 capimsg_setu8 (s, 4, CAPI_INTEROPERABILITY);
167 capimsg_setu8 (s, 5, subcmd);
168 capimsg_setu16(s, 6, msgnum);
169
170 /* Interoperability selector (Bluetooth Device Management) */
171 capimsg_setu16(s, 8, 0x0001);
172
173 capimsg_setu8 (s, 10, 3 + len);
174 capimsg_setu16(s, 11, function);
175 capimsg_setu8 (s, 13, len);
176
177 if (len > 0)
178 memcpy(s + 14, buf, len);
179
180 cmtp_send_capimsg(session, skb);
181 }
182
183 static void cmtp_recv_interopmsg(struct cmtp_session *session, struct sk_buff *skb)
184 {
185 struct capi_ctr *ctrl = &session->ctrl;
186 struct cmtp_application *application;
187 __u16 appl, msgnum, func, info;
188 __u32 controller;
189
190 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
191
192 switch (CAPIMSG_SUBCOMMAND(skb->data)) {
193 case CAPI_CONF:
194 if (skb->len < CAPI_MSG_BASELEN + 10)
195 break;
196
197 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 5);
198 info = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 8);
199
200 switch (func) {
201 case CAPI_FUNCTION_REGISTER:
202 msgnum = CAPIMSG_MSGID(skb->data);
203
204 application = cmtp_application_get(session, CMTP_MSGNUM, msgnum);
205 if (application) {
206 application->state = BT_CONNECTED;
207 application->msgnum = 0;
208 application->mapping = CAPIMSG_APPID(skb->data);
209 wake_up_interruptible(&session->wait);
210 }
211
212 break;
213
214 case CAPI_FUNCTION_RELEASE:
215 appl = CAPIMSG_APPID(skb->data);
216
217 application = cmtp_application_get(session, CMTP_MAPPING, appl);
218 if (application) {
219 application->state = BT_CLOSED;
220 application->msgnum = 0;
221 wake_up_interruptible(&session->wait);
222 }
223
224 break;
225
226 case CAPI_FUNCTION_GET_PROFILE:
227 if (skb->len < CAPI_MSG_BASELEN + 11 + sizeof(capi_profile))
228 break;
229
230 controller = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 11);
231 msgnum = CAPIMSG_MSGID(skb->data);
232
233 if (!info && (msgnum == CMTP_INITIAL_MSGNUM)) {
234 session->ncontroller = controller;
235 wake_up_interruptible(&session->wait);
236 break;
237 }
238
239 if (!info && ctrl) {
240 memcpy(&ctrl->profile,
241 skb->data + CAPI_MSG_BASELEN + 11,
242 sizeof(capi_profile));
243 session->state = BT_CONNECTED;
244 capi_ctr_ready(ctrl);
245 }
246
247 break;
248
249 case CAPI_FUNCTION_GET_MANUFACTURER:
250 if (skb->len < CAPI_MSG_BASELEN + 15)
251 break;
252
253 controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 10);
254
255 if (!info && ctrl) {
256 int len = min_t(uint, CAPI_MANUFACTURER_LEN,
257 skb->data[CAPI_MSG_BASELEN + 14]);
258
259 memset(ctrl->manu, 0, CAPI_MANUFACTURER_LEN);
260 strncpy(ctrl->manu,
261 skb->data + CAPI_MSG_BASELEN + 15, len);
262 }
263
264 break;
265
266 case CAPI_FUNCTION_GET_VERSION:
267 if (skb->len < CAPI_MSG_BASELEN + 32)
268 break;
269
270 controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);
271
272 if (!info && ctrl) {
273 ctrl->version.majorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 16);
274 ctrl->version.minorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 20);
275 ctrl->version.majormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 24);
276 ctrl->version.minormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 28);
277 }
278
279 break;
280
281 case CAPI_FUNCTION_GET_SERIAL_NUMBER:
282 if (skb->len < CAPI_MSG_BASELEN + 17)
283 break;
284
285 controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);
286
287 if (!info && ctrl) {
288 int len = min_t(uint, CAPI_SERIAL_LEN,
289 skb->data[CAPI_MSG_BASELEN + 16]);
290
291 memset(ctrl->serial, 0, CAPI_SERIAL_LEN);
292 strncpy(ctrl->serial,
293 skb->data + CAPI_MSG_BASELEN + 17, len);
294 }
295
296 break;
297 }
298
299 break;
300
301 case CAPI_IND:
302 if (skb->len < CAPI_MSG_BASELEN + 6)
303 break;
304
305 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 3);
306
307 if (func == CAPI_FUNCTION_LOOPBACK) {
308 int len = min_t(uint, skb->len - CAPI_MSG_BASELEN - 6,
309 skb->data[CAPI_MSG_BASELEN + 5]);
310 appl = CAPIMSG_APPID(skb->data);
311 msgnum = CAPIMSG_MSGID(skb->data);
312 cmtp_send_interopmsg(session, CAPI_RESP, appl, msgnum, func,
313 skb->data + CAPI_MSG_BASELEN + 6, len);
314 }
315
316 break;
317 }
318
319 kfree_skb(skb);
320 }
321
322 void cmtp_recv_capimsg(struct cmtp_session *session, struct sk_buff *skb)
323 {
324 struct capi_ctr *ctrl = &session->ctrl;
325 struct cmtp_application *application;
326 __u16 cmd, appl;
327 __u32 contr;
328
329 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
330
331 if (skb->len < CAPI_MSG_BASELEN)
332 return;
333
334 if (CAPIMSG_COMMAND(skb->data) == CAPI_INTEROPERABILITY) {
335 cmtp_recv_interopmsg(session, skb);
336 return;
337 }
338
339 if (session->flags & (1 << CMTP_LOOPBACK)) {
340 kfree_skb(skb);
341 return;
342 }
343
344 cmd = CAPICMD(CAPIMSG_COMMAND(skb->data), CAPIMSG_SUBCOMMAND(skb->data));
345 appl = CAPIMSG_APPID(skb->data);
346 contr = CAPIMSG_CONTROL(skb->data);
347
348 application = cmtp_application_get(session, CMTP_MAPPING, appl);
349 if (application) {
350 appl = application->appl;
351 CAPIMSG_SETAPPID(skb->data, appl);
352 } else {
353 BT_ERR("Can't find application with id %d", appl);
354 kfree_skb(skb);
355 return;
356 }
357
358 if ((contr & 0x7f) == 0x01) {
359 contr = (contr & 0xffffff80) | session->num;
360 CAPIMSG_SETCONTROL(skb->data, contr);
361 }
362
363 if (!ctrl) {
364 BT_ERR("Can't find controller %d for message", session->num);
365 kfree_skb(skb);
366 return;
367 }
368
369 capi_ctr_handle_message(ctrl, appl, skb);
370 }
371
372 static int cmtp_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
373 {
374 BT_DBG("ctrl %p data %p", ctrl, data);
375
376 return 0;
377 }
378
379 static void cmtp_reset_ctr(struct capi_ctr *ctrl)
380 {
381 struct cmtp_session *session = ctrl->driverdata;
382
383 BT_DBG("ctrl %p", ctrl);
384
385 capi_ctr_down(ctrl);
386
387 atomic_inc(&session->terminate);
388 cmtp_schedule(session);
389 }
390
391 static void cmtp_register_appl(struct capi_ctr *ctrl, __u16 appl, capi_register_params *rp)
392 {
393 DECLARE_WAITQUEUE(wait, current);
394 struct cmtp_session *session = ctrl->driverdata;
395 struct cmtp_application *application;
396 unsigned long timeo = CMTP_INTEROP_TIMEOUT;
397 unsigned char buf[8];
398 int err = 0, nconn, want = rp->level3cnt;
399
400 BT_DBG("ctrl %p appl %d level3cnt %d datablkcnt %d datablklen %d",
401 ctrl, appl, rp->level3cnt, rp->datablkcnt, rp->datablklen);
402
403 application = cmtp_application_add(session, appl);
404 if (!application) {
405 BT_ERR("Can't allocate memory for new application");
406 return;
407 }
408
409 if (want < 0)
410 nconn = ctrl->profile.nbchannel * -want;
411 else
412 nconn = want;
413
414 if (nconn == 0)
415 nconn = ctrl->profile.nbchannel;
416
417 capimsg_setu16(buf, 0, nconn);
418 capimsg_setu16(buf, 2, rp->datablkcnt);
419 capimsg_setu16(buf, 4, rp->datablklen);
420
421 application->state = BT_CONFIG;
422 application->msgnum = cmtp_msgnum_get(session);
423
424 cmtp_send_interopmsg(session, CAPI_REQ, 0x0000, application->msgnum,
425 CAPI_FUNCTION_REGISTER, buf, 6);
426
427 add_wait_queue(&session->wait, &wait);
428 while (1) {
429 set_current_state(TASK_INTERRUPTIBLE);
430
431 if (!timeo) {
432 err = -EAGAIN;
433 break;
434 }
435
436 if (application->state == BT_CLOSED) {
437 err = -application->err;
438 break;
439 }
440
441 if (application->state == BT_CONNECTED)
442 break;
443
444 if (signal_pending(current)) {
445 err = -EINTR;
446 break;
447 }
448
449 timeo = schedule_timeout(timeo);
450 }
451 set_current_state(TASK_RUNNING);
452 remove_wait_queue(&session->wait, &wait);
453
454 if (err) {
455 cmtp_application_del(session, application);
456 return;
457 }
458 }
459
460 static void cmtp_release_appl(struct capi_ctr *ctrl, __u16 appl)
461 {
462 struct cmtp_session *session = ctrl->driverdata;
463 struct cmtp_application *application;
464
465 BT_DBG("ctrl %p appl %d", ctrl, appl);
466
467 application = cmtp_application_get(session, CMTP_APPLID, appl);
468 if (!application) {
469 BT_ERR("Can't find application");
470 return;
471 }
472
473 application->msgnum = cmtp_msgnum_get(session);
474
475 cmtp_send_interopmsg(session, CAPI_REQ, application->mapping, application->msgnum,
476 CAPI_FUNCTION_RELEASE, NULL, 0);
477
478 wait_event_interruptible_timeout(session->wait,
479 (application->state == BT_CLOSED), CMTP_INTEROP_TIMEOUT);
480
481 cmtp_application_del(session, application);
482 }
483
484 static u16 cmtp_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
485 {
486 struct cmtp_session *session = ctrl->driverdata;
487 struct cmtp_application *application;
488 __u16 appl;
489 __u32 contr;
490
491 BT_DBG("ctrl %p skb %p", ctrl, skb);
492
493 appl = CAPIMSG_APPID(skb->data);
494 contr = CAPIMSG_CONTROL(skb->data);
495
496 application = cmtp_application_get(session, CMTP_APPLID, appl);
497 if ((!application) || (application->state != BT_CONNECTED)) {
498 BT_ERR("Can't find application with id %d", appl);
499 return CAPI_ILLAPPNR;
500 }
501
502 CAPIMSG_SETAPPID(skb->data, application->mapping);
503
504 if ((contr & 0x7f) == session->num) {
505 contr = (contr & 0xffffff80) | 0x01;
506 CAPIMSG_SETCONTROL(skb->data, contr);
507 }
508
509 cmtp_send_capimsg(session, skb);
510
511 return CAPI_NOERROR;
512 }
513
514 static char *cmtp_procinfo(struct capi_ctr *ctrl)
515 {
516 return "CAPI Message Transport Protocol";
517 }
518
519 static int cmtp_ctr_read_proc(char *page, char **start, off_t off, int count, int *eof, struct capi_ctr *ctrl)
520 {
521 struct cmtp_session *session = ctrl->driverdata;
522 struct cmtp_application *app;
523 struct list_head *p, *n;
524 int len = 0;
525
526 len += sprintf(page + len, "%s\n\n", cmtp_procinfo(ctrl));
527 len += sprintf(page + len, "addr %s\n", session->name);
528 len += sprintf(page + len, "ctrl %d\n", session->num);
529
530 list_for_each_safe(p, n, &session->applications) {
531 app = list_entry(p, struct cmtp_application, list);
532 len += sprintf(page + len, "appl %d -> %d\n", app->appl, app->mapping);
533 }
534
535 if (off + count >= len)
536 *eof = 1;
537
538 if (len < off)
539 return 0;
540
541 *start = page + off;
542
543 return ((count < len - off) ? count : len - off);
544 }
545
546
547 int cmtp_attach_device(struct cmtp_session *session)
548 {
549 unsigned char buf[4];
550 long ret;
551
552 BT_DBG("session %p", session);
553
554 capimsg_setu32(buf, 0, 0);
555
556 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, CMTP_INITIAL_MSGNUM,
557 CAPI_FUNCTION_GET_PROFILE, buf, 4);
558
559 ret = wait_event_interruptible_timeout(session->wait,
560 session->ncontroller, CMTP_INTEROP_TIMEOUT);
561
562 BT_INFO("Found %d CAPI controller(s) on device %s", session->ncontroller, session->name);
563
564 if (!ret)
565 return -ETIMEDOUT;
566
567 if (!session->ncontroller)
568 return -ENODEV;
569
570 if (session->ncontroller > 1)
571 BT_INFO("Setting up only CAPI controller 1");
572
573 session->ctrl.owner = THIS_MODULE;
574 session->ctrl.driverdata = session;
575 strcpy(session->ctrl.name, session->name);
576
577 session->ctrl.driver_name = "cmtp";
578 session->ctrl.load_firmware = cmtp_load_firmware;
579 session->ctrl.reset_ctr = cmtp_reset_ctr;
580 session->ctrl.register_appl = cmtp_register_appl;
581 session->ctrl.release_appl = cmtp_release_appl;
582 session->ctrl.send_message = cmtp_send_message;
583
584 session->ctrl.procinfo = cmtp_procinfo;
585 session->ctrl.ctr_read_proc = cmtp_ctr_read_proc;
586
587 if (attach_capi_ctr(&session->ctrl) < 0) {
588 BT_ERR("Can't attach new controller");
589 return -EBUSY;
590 }
591
592 session->num = session->ctrl.cnr;
593
594 BT_DBG("session %p num %d", session, session->num);
595
596 capimsg_setu32(buf, 0, 1);
597
598 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
599 CAPI_FUNCTION_GET_MANUFACTURER, buf, 4);
600
601 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
602 CAPI_FUNCTION_GET_VERSION, buf, 4);
603
604 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
605 CAPI_FUNCTION_GET_SERIAL_NUMBER, buf, 4);
606
607 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
608 CAPI_FUNCTION_GET_PROFILE, buf, 4);
609
610 return 0;
611 }
612
613 void cmtp_detach_device(struct cmtp_session *session)
614 {
615 BT_DBG("session %p", session);
616
617 detach_capi_ctr(&session->ctrl);
618 }
Linux kernel - Deliverables
This page took 0.181942 seconds and 5 git commands to generate.