Loading...
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/export.h>
24#include <linux/proc_fs.h>
25#include <linux/seq_file.h>
26#include <linux/types.h>
27#include <linux/errno.h>
28#include <linux/kernel.h>
29#include <linux/sched.h>
30#include <linux/slab.h>
31#include <linux/poll.h>
32#include <linux/fcntl.h>
33#include <linux/skbuff.h>
34#include <linux/socket.h>
35#include <linux/ioctl.h>
36#include <linux/file.h>
37#include <linux/wait.h>
38#include <linux/kthread.h>
39#include <net/sock.h>
40
41#include <linux/isdn/capilli.h>
42#include <linux/isdn/capicmd.h>
43#include <linux/isdn/capiutil.h>
44
45#include "cmtp.h"
46
47#define CAPI_INTEROPERABILITY 0x20
48
49#define CAPI_INTEROPERABILITY_REQ CAPICMD(CAPI_INTEROPERABILITY, CAPI_REQ)
50#define CAPI_INTEROPERABILITY_CONF CAPICMD(CAPI_INTEROPERABILITY, CAPI_CONF)
51#define CAPI_INTEROPERABILITY_IND CAPICMD(CAPI_INTEROPERABILITY, CAPI_IND)
52#define CAPI_INTEROPERABILITY_RESP CAPICMD(CAPI_INTEROPERABILITY, CAPI_RESP)
53
54#define CAPI_INTEROPERABILITY_REQ_LEN (CAPI_MSG_BASELEN + 2)
55#define CAPI_INTEROPERABILITY_CONF_LEN (CAPI_MSG_BASELEN + 4)
56#define CAPI_INTEROPERABILITY_IND_LEN (CAPI_MSG_BASELEN + 2)
57#define CAPI_INTEROPERABILITY_RESP_LEN (CAPI_MSG_BASELEN + 2)
58
59#define CAPI_FUNCTION_REGISTER 0
60#define CAPI_FUNCTION_RELEASE 1
61#define CAPI_FUNCTION_GET_PROFILE 2
62#define CAPI_FUNCTION_GET_MANUFACTURER 3
63#define CAPI_FUNCTION_GET_VERSION 4
64#define CAPI_FUNCTION_GET_SERIAL_NUMBER 5
65#define CAPI_FUNCTION_MANUFACTURER 6
66#define CAPI_FUNCTION_LOOPBACK 7
67
68
69#define CMTP_MSGNUM 1
70#define CMTP_APPLID 2
71#define CMTP_MAPPING 3
72
73static struct cmtp_application *cmtp_application_add(struct cmtp_session *session, __u16 appl)
74{
75 struct cmtp_application *app = kzalloc(sizeof(*app), GFP_KERNEL);
76
77 BT_DBG("session %p application %p appl %d", session, app, appl);
78
79 if (!app)
80 return NULL;
81
82 app->state = BT_OPEN;
83 app->appl = appl;
84
85 list_add_tail(&app->list, &session->applications);
86
87 return app;
88}
89
90static void cmtp_application_del(struct cmtp_session *session, struct cmtp_application *app)
91{
92 BT_DBG("session %p application %p", session, app);
93
94 if (app) {
95 list_del(&app->list);
96 kfree(app);
97 }
98}
99
100static struct cmtp_application *cmtp_application_get(struct cmtp_session *session, int pattern, __u16 value)
101{
102 struct cmtp_application *app;
103
104 list_for_each_entry(app, &session->applications, 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
124static 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
134static 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 wake_up_interruptible(sk_sleep(session->sock->sk));
146}
147
148static 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 skb = alloc_skb(CAPI_MSG_BASELEN + 6 + len, GFP_ATOMIC);
158 if (!skb) {
159 BT_ERR("Can't allocate memory for interoperability packet");
160 return;
161 }
162
163 s = skb_put(skb, CAPI_MSG_BASELEN + 6 + len);
164
165 capimsg_setu16(s, 0, CAPI_MSG_BASELEN + 6 + len);
166 capimsg_setu16(s, 2, appl);
167 capimsg_setu8 (s, 4, CAPI_INTEROPERABILITY);
168 capimsg_setu8 (s, 5, subcmd);
169 capimsg_setu16(s, 6, msgnum);
170
171 /* Interoperability selector (Bluetooth Device Management) */
172 capimsg_setu16(s, 8, 0x0001);
173
174 capimsg_setu8 (s, 10, 3 + len);
175 capimsg_setu16(s, 11, function);
176 capimsg_setu8 (s, 13, len);
177
178 if (len > 0)
179 memcpy(s + 14, buf, len);
180
181 cmtp_send_capimsg(session, skb);
182}
183
184static void cmtp_recv_interopmsg(struct cmtp_session *session, struct sk_buff *skb)
185{
186 struct capi_ctr *ctrl = &session->ctrl;
187 struct cmtp_application *application;
188 __u16 appl, msgnum, func, info;
189 __u32 controller;
190
191 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
192
193 switch (CAPIMSG_SUBCOMMAND(skb->data)) {
194 case CAPI_CONF:
195 if (skb->len < CAPI_MSG_BASELEN + 10)
196 break;
197
198 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 5);
199 info = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 8);
200
201 switch (func) {
202 case CAPI_FUNCTION_REGISTER:
203 msgnum = CAPIMSG_MSGID(skb->data);
204
205 application = cmtp_application_get(session, CMTP_MSGNUM, msgnum);
206 if (application) {
207 application->state = BT_CONNECTED;
208 application->msgnum = 0;
209 application->mapping = CAPIMSG_APPID(skb->data);
210 wake_up_interruptible(&session->wait);
211 }
212
213 break;
214
215 case CAPI_FUNCTION_RELEASE:
216 appl = CAPIMSG_APPID(skb->data);
217
218 application = cmtp_application_get(session, CMTP_MAPPING, appl);
219 if (application) {
220 application->state = BT_CLOSED;
221 application->msgnum = 0;
222 wake_up_interruptible(&session->wait);
223 }
224
225 break;
226
227 case CAPI_FUNCTION_GET_PROFILE:
228 if (skb->len < CAPI_MSG_BASELEN + 11 + sizeof(capi_profile))
229 break;
230
231 controller = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 11);
232 msgnum = CAPIMSG_MSGID(skb->data);
233
234 if (!info && (msgnum == CMTP_INITIAL_MSGNUM)) {
235 session->ncontroller = controller;
236 wake_up_interruptible(&session->wait);
237 break;
238 }
239
240 if (!info && ctrl) {
241 memcpy(&ctrl->profile,
242 skb->data + CAPI_MSG_BASELEN + 11,
243 sizeof(capi_profile));
244 session->state = BT_CONNECTED;
245 capi_ctr_ready(ctrl);
246 }
247
248 break;
249
250 case CAPI_FUNCTION_GET_MANUFACTURER:
251 if (skb->len < CAPI_MSG_BASELEN + 15)
252 break;
253
254 if (!info && ctrl) {
255 int len = min_t(uint, CAPI_MANUFACTURER_LEN,
256 skb->data[CAPI_MSG_BASELEN + 14]);
257
258 memset(ctrl->manu, 0, CAPI_MANUFACTURER_LEN);
259 strncpy(ctrl->manu,
260 skb->data + CAPI_MSG_BASELEN + 15, len);
261 }
262
263 break;
264
265 case CAPI_FUNCTION_GET_VERSION:
266 if (skb->len < CAPI_MSG_BASELEN + 32)
267 break;
268
269 if (!info && ctrl) {
270 ctrl->version.majorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 16);
271 ctrl->version.minorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 20);
272 ctrl->version.majormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 24);
273 ctrl->version.minormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 28);
274 }
275
276 break;
277
278 case CAPI_FUNCTION_GET_SERIAL_NUMBER:
279 if (skb->len < CAPI_MSG_BASELEN + 17)
280 break;
281
282 if (!info && ctrl) {
283 int len = min_t(uint, CAPI_SERIAL_LEN,
284 skb->data[CAPI_MSG_BASELEN + 16]);
285
286 memset(ctrl->serial, 0, CAPI_SERIAL_LEN);
287 strncpy(ctrl->serial,
288 skb->data + CAPI_MSG_BASELEN + 17, len);
289 }
290
291 break;
292 }
293
294 break;
295
296 case CAPI_IND:
297 if (skb->len < CAPI_MSG_BASELEN + 6)
298 break;
299
300 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 3);
301
302 if (func == CAPI_FUNCTION_LOOPBACK) {
303 int len = min_t(uint, skb->len - CAPI_MSG_BASELEN - 6,
304 skb->data[CAPI_MSG_BASELEN + 5]);
305 appl = CAPIMSG_APPID(skb->data);
306 msgnum = CAPIMSG_MSGID(skb->data);
307 cmtp_send_interopmsg(session, CAPI_RESP, appl, msgnum, func,
308 skb->data + CAPI_MSG_BASELEN + 6, len);
309 }
310
311 break;
312 }
313
314 kfree_skb(skb);
315}
316
317void cmtp_recv_capimsg(struct cmtp_session *session, struct sk_buff *skb)
318{
319 struct capi_ctr *ctrl = &session->ctrl;
320 struct cmtp_application *application;
321 __u16 appl;
322 __u32 contr;
323
324 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
325
326 if (skb->len < CAPI_MSG_BASELEN)
327 return;
328
329 if (CAPIMSG_COMMAND(skb->data) == CAPI_INTEROPERABILITY) {
330 cmtp_recv_interopmsg(session, skb);
331 return;
332 }
333
334 if (session->flags & BIT(CMTP_LOOPBACK)) {
335 kfree_skb(skb);
336 return;
337 }
338
339 appl = CAPIMSG_APPID(skb->data);
340 contr = CAPIMSG_CONTROL(skb->data);
341
342 application = cmtp_application_get(session, CMTP_MAPPING, appl);
343 if (application) {
344 appl = application->appl;
345 CAPIMSG_SETAPPID(skb->data, appl);
346 } else {
347 BT_ERR("Can't find application with id %d", appl);
348 kfree_skb(skb);
349 return;
350 }
351
352 if ((contr & 0x7f) == 0x01) {
353 contr = (contr & 0xffffff80) | session->num;
354 CAPIMSG_SETCONTROL(skb->data, contr);
355 }
356
357 capi_ctr_handle_message(ctrl, appl, skb);
358}
359
360static int cmtp_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
361{
362 BT_DBG("ctrl %p data %p", ctrl, data);
363
364 return 0;
365}
366
367static void cmtp_reset_ctr(struct capi_ctr *ctrl)
368{
369 struct cmtp_session *session = ctrl->driverdata;
370
371 BT_DBG("ctrl %p", ctrl);
372
373 capi_ctr_down(ctrl);
374
375 atomic_inc(&session->terminate);
376 wake_up_process(session->task);
377}
378
379static void cmtp_register_appl(struct capi_ctr *ctrl, __u16 appl, capi_register_params *rp)
380{
381 DECLARE_WAITQUEUE(wait, current);
382 struct cmtp_session *session = ctrl->driverdata;
383 struct cmtp_application *application;
384 unsigned long timeo = CMTP_INTEROP_TIMEOUT;
385 unsigned char buf[8];
386 int err = 0, nconn, want = rp->level3cnt;
387
388 BT_DBG("ctrl %p appl %d level3cnt %d datablkcnt %d datablklen %d",
389 ctrl, appl, rp->level3cnt, rp->datablkcnt, rp->datablklen);
390
391 application = cmtp_application_add(session, appl);
392 if (!application) {
393 BT_ERR("Can't allocate memory for new application");
394 return;
395 }
396
397 if (want < 0)
398 nconn = ctrl->profile.nbchannel * -want;
399 else
400 nconn = want;
401
402 if (nconn == 0)
403 nconn = ctrl->profile.nbchannel;
404
405 capimsg_setu16(buf, 0, nconn);
406 capimsg_setu16(buf, 2, rp->datablkcnt);
407 capimsg_setu16(buf, 4, rp->datablklen);
408
409 application->state = BT_CONFIG;
410 application->msgnum = cmtp_msgnum_get(session);
411
412 cmtp_send_interopmsg(session, CAPI_REQ, 0x0000, application->msgnum,
413 CAPI_FUNCTION_REGISTER, buf, 6);
414
415 add_wait_queue(&session->wait, &wait);
416 while (1) {
417 set_current_state(TASK_INTERRUPTIBLE);
418
419 if (!timeo) {
420 err = -EAGAIN;
421 break;
422 }
423
424 if (application->state == BT_CLOSED) {
425 err = -application->err;
426 break;
427 }
428
429 if (application->state == BT_CONNECTED)
430 break;
431
432 if (signal_pending(current)) {
433 err = -EINTR;
434 break;
435 }
436
437 timeo = schedule_timeout(timeo);
438 }
439 set_current_state(TASK_RUNNING);
440 remove_wait_queue(&session->wait, &wait);
441
442 if (err) {
443 cmtp_application_del(session, application);
444 return;
445 }
446}
447
448static void cmtp_release_appl(struct capi_ctr *ctrl, __u16 appl)
449{
450 struct cmtp_session *session = ctrl->driverdata;
451 struct cmtp_application *application;
452
453 BT_DBG("ctrl %p appl %d", ctrl, appl);
454
455 application = cmtp_application_get(session, CMTP_APPLID, appl);
456 if (!application) {
457 BT_ERR("Can't find application");
458 return;
459 }
460
461 application->msgnum = cmtp_msgnum_get(session);
462
463 cmtp_send_interopmsg(session, CAPI_REQ, application->mapping, application->msgnum,
464 CAPI_FUNCTION_RELEASE, NULL, 0);
465
466 wait_event_interruptible_timeout(session->wait,
467 (application->state == BT_CLOSED), CMTP_INTEROP_TIMEOUT);
468
469 cmtp_application_del(session, application);
470}
471
472static u16 cmtp_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
473{
474 struct cmtp_session *session = ctrl->driverdata;
475 struct cmtp_application *application;
476 __u16 appl;
477 __u32 contr;
478
479 BT_DBG("ctrl %p skb %p", ctrl, skb);
480
481 appl = CAPIMSG_APPID(skb->data);
482 contr = CAPIMSG_CONTROL(skb->data);
483
484 application = cmtp_application_get(session, CMTP_APPLID, appl);
485 if ((!application) || (application->state != BT_CONNECTED)) {
486 BT_ERR("Can't find application with id %d", appl);
487 return CAPI_ILLAPPNR;
488 }
489
490 CAPIMSG_SETAPPID(skb->data, application->mapping);
491
492 if ((contr & 0x7f) == session->num) {
493 contr = (contr & 0xffffff80) | 0x01;
494 CAPIMSG_SETCONTROL(skb->data, contr);
495 }
496
497 cmtp_send_capimsg(session, skb);
498
499 return CAPI_NOERROR;
500}
501
502static char *cmtp_procinfo(struct capi_ctr *ctrl)
503{
504 return "CAPI Message Transport Protocol";
505}
506
507static int cmtp_proc_show(struct seq_file *m, void *v)
508{
509 struct capi_ctr *ctrl = m->private;
510 struct cmtp_session *session = ctrl->driverdata;
511 struct cmtp_application *app;
512
513 seq_printf(m, "%s\n\n", cmtp_procinfo(ctrl));
514 seq_printf(m, "addr %s\n", session->name);
515 seq_printf(m, "ctrl %d\n", session->num);
516
517 list_for_each_entry(app, &session->applications, list) {
518 seq_printf(m, "appl %d -> %d\n", app->appl, app->mapping);
519 }
520
521 return 0;
522}
523
524static int cmtp_proc_open(struct inode *inode, struct file *file)
525{
526 return single_open(file, cmtp_proc_show, PDE_DATA(inode));
527}
528
529static const struct file_operations cmtp_proc_fops = {
530 .owner = THIS_MODULE,
531 .open = cmtp_proc_open,
532 .read = seq_read,
533 .llseek = seq_lseek,
534 .release = single_release,
535};
536
537int cmtp_attach_device(struct cmtp_session *session)
538{
539 unsigned char buf[4];
540 long ret;
541
542 BT_DBG("session %p", session);
543
544 capimsg_setu32(buf, 0, 0);
545
546 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, CMTP_INITIAL_MSGNUM,
547 CAPI_FUNCTION_GET_PROFILE, buf, 4);
548
549 ret = wait_event_interruptible_timeout(session->wait,
550 session->ncontroller, CMTP_INTEROP_TIMEOUT);
551
552 BT_INFO("Found %d CAPI controller(s) on device %s", session->ncontroller, session->name);
553
554 if (!ret)
555 return -ETIMEDOUT;
556
557 if (!session->ncontroller)
558 return -ENODEV;
559
560 if (session->ncontroller > 1)
561 BT_INFO("Setting up only CAPI controller 1");
562
563 session->ctrl.owner = THIS_MODULE;
564 session->ctrl.driverdata = session;
565 strcpy(session->ctrl.name, session->name);
566
567 session->ctrl.driver_name = "cmtp";
568 session->ctrl.load_firmware = cmtp_load_firmware;
569 session->ctrl.reset_ctr = cmtp_reset_ctr;
570 session->ctrl.register_appl = cmtp_register_appl;
571 session->ctrl.release_appl = cmtp_release_appl;
572 session->ctrl.send_message = cmtp_send_message;
573
574 session->ctrl.procinfo = cmtp_procinfo;
575 session->ctrl.proc_fops = &cmtp_proc_fops;
576
577 if (attach_capi_ctr(&session->ctrl) < 0) {
578 BT_ERR("Can't attach new controller");
579 return -EBUSY;
580 }
581
582 session->num = session->ctrl.cnr;
583
584 BT_DBG("session %p num %d", session, session->num);
585
586 capimsg_setu32(buf, 0, 1);
587
588 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
589 CAPI_FUNCTION_GET_MANUFACTURER, buf, 4);
590
591 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
592 CAPI_FUNCTION_GET_VERSION, buf, 4);
593
594 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
595 CAPI_FUNCTION_GET_SERIAL_NUMBER, buf, 4);
596
597 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
598 CAPI_FUNCTION_GET_PROFILE, buf, 4);
599
600 return 0;
601}
602
603void cmtp_detach_device(struct cmtp_session *session)
604{
605 BT_DBG("session %p", session);
606
607 detach_capi_ctr(&session->ctrl);
608}
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/export.h>
24#include <linux/proc_fs.h>
25#include <linux/seq_file.h>
26#include <linux/types.h>
27#include <linux/errno.h>
28#include <linux/kernel.h>
29#include <linux/sched/signal.h>
30#include <linux/slab.h>
31#include <linux/poll.h>
32#include <linux/fcntl.h>
33#include <linux/skbuff.h>
34#include <linux/socket.h>
35#include <linux/ioctl.h>
36#include <linux/file.h>
37#include <linux/wait.h>
38#include <linux/kthread.h>
39#include <net/sock.h>
40
41#include <linux/isdn/capilli.h>
42#include <linux/isdn/capicmd.h>
43#include <linux/isdn/capiutil.h>
44
45#include "cmtp.h"
46
47#define CAPI_INTEROPERABILITY 0x20
48
49#define CAPI_INTEROPERABILITY_REQ CAPICMD(CAPI_INTEROPERABILITY, CAPI_REQ)
50#define CAPI_INTEROPERABILITY_CONF CAPICMD(CAPI_INTEROPERABILITY, CAPI_CONF)
51#define CAPI_INTEROPERABILITY_IND CAPICMD(CAPI_INTEROPERABILITY, CAPI_IND)
52#define CAPI_INTEROPERABILITY_RESP CAPICMD(CAPI_INTEROPERABILITY, CAPI_RESP)
53
54#define CAPI_INTEROPERABILITY_REQ_LEN (CAPI_MSG_BASELEN + 2)
55#define CAPI_INTEROPERABILITY_CONF_LEN (CAPI_MSG_BASELEN + 4)
56#define CAPI_INTEROPERABILITY_IND_LEN (CAPI_MSG_BASELEN + 2)
57#define CAPI_INTEROPERABILITY_RESP_LEN (CAPI_MSG_BASELEN + 2)
58
59#define CAPI_FUNCTION_REGISTER 0
60#define CAPI_FUNCTION_RELEASE 1
61#define CAPI_FUNCTION_GET_PROFILE 2
62#define CAPI_FUNCTION_GET_MANUFACTURER 3
63#define CAPI_FUNCTION_GET_VERSION 4
64#define CAPI_FUNCTION_GET_SERIAL_NUMBER 5
65#define CAPI_FUNCTION_MANUFACTURER 6
66#define CAPI_FUNCTION_LOOPBACK 7
67
68
69#define CMTP_MSGNUM 1
70#define CMTP_APPLID 2
71#define CMTP_MAPPING 3
72
73static struct cmtp_application *cmtp_application_add(struct cmtp_session *session, __u16 appl)
74{
75 struct cmtp_application *app = kzalloc(sizeof(*app), GFP_KERNEL);
76
77 BT_DBG("session %p application %p appl %u", session, app, appl);
78
79 if (!app)
80 return NULL;
81
82 app->state = BT_OPEN;
83 app->appl = appl;
84
85 list_add_tail(&app->list, &session->applications);
86
87 return app;
88}
89
90static void cmtp_application_del(struct cmtp_session *session, struct cmtp_application *app)
91{
92 BT_DBG("session %p application %p", session, app);
93
94 if (app) {
95 list_del(&app->list);
96 kfree(app);
97 }
98}
99
100static struct cmtp_application *cmtp_application_get(struct cmtp_session *session, int pattern, __u16 value)
101{
102 struct cmtp_application *app;
103
104 list_for_each_entry(app, &session->applications, 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
124static 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
134static 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 %u", 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 wake_up_interruptible(sk_sleep(session->sock->sk));
146}
147
148static 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 %u msgnum %u", session, subcmd, appl, msgnum);
156
157 skb = alloc_skb(CAPI_MSG_BASELEN + 6 + len, GFP_ATOMIC);
158 if (!skb) {
159 BT_ERR("Can't allocate memory for interoperability packet");
160 return;
161 }
162
163 s = skb_put(skb, CAPI_MSG_BASELEN + 6 + len);
164
165 capimsg_setu16(s, 0, CAPI_MSG_BASELEN + 6 + len);
166 capimsg_setu16(s, 2, appl);
167 capimsg_setu8 (s, 4, CAPI_INTEROPERABILITY);
168 capimsg_setu8 (s, 5, subcmd);
169 capimsg_setu16(s, 6, msgnum);
170
171 /* Interoperability selector (Bluetooth Device Management) */
172 capimsg_setu16(s, 8, 0x0001);
173
174 capimsg_setu8 (s, 10, 3 + len);
175 capimsg_setu16(s, 11, function);
176 capimsg_setu8 (s, 13, len);
177
178 if (len > 0)
179 memcpy(s + 14, buf, len);
180
181 cmtp_send_capimsg(session, skb);
182}
183
184static void cmtp_recv_interopmsg(struct cmtp_session *session, struct sk_buff *skb)
185{
186 struct capi_ctr *ctrl = &session->ctrl;
187 struct cmtp_application *application;
188 __u16 appl, msgnum, func, info;
189 __u32 controller;
190
191 BT_DBG("session %p skb %p len %u", session, skb, skb->len);
192
193 switch (CAPIMSG_SUBCOMMAND(skb->data)) {
194 case CAPI_CONF:
195 if (skb->len < CAPI_MSG_BASELEN + 10)
196 break;
197
198 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 5);
199 info = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 8);
200
201 switch (func) {
202 case CAPI_FUNCTION_REGISTER:
203 msgnum = CAPIMSG_MSGID(skb->data);
204
205 application = cmtp_application_get(session, CMTP_MSGNUM, msgnum);
206 if (application) {
207 application->state = BT_CONNECTED;
208 application->msgnum = 0;
209 application->mapping = CAPIMSG_APPID(skb->data);
210 wake_up_interruptible(&session->wait);
211 }
212
213 break;
214
215 case CAPI_FUNCTION_RELEASE:
216 appl = CAPIMSG_APPID(skb->data);
217
218 application = cmtp_application_get(session, CMTP_MAPPING, appl);
219 if (application) {
220 application->state = BT_CLOSED;
221 application->msgnum = 0;
222 wake_up_interruptible(&session->wait);
223 }
224
225 break;
226
227 case CAPI_FUNCTION_GET_PROFILE:
228 if (skb->len < CAPI_MSG_BASELEN + 11 + sizeof(capi_profile))
229 break;
230
231 controller = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 11);
232 msgnum = CAPIMSG_MSGID(skb->data);
233
234 if (!info && (msgnum == CMTP_INITIAL_MSGNUM)) {
235 session->ncontroller = controller;
236 wake_up_interruptible(&session->wait);
237 break;
238 }
239
240 if (!info && ctrl) {
241 memcpy(&ctrl->profile,
242 skb->data + CAPI_MSG_BASELEN + 11,
243 sizeof(capi_profile));
244 session->state = BT_CONNECTED;
245 capi_ctr_ready(ctrl);
246 }
247
248 break;
249
250 case CAPI_FUNCTION_GET_MANUFACTURER:
251 if (!info && ctrl && skb->len > CAPI_MSG_BASELEN + 14)
252 strscpy_pad(ctrl->manu,
253 skb->data + CAPI_MSG_BASELEN + 15,
254 skb->data[CAPI_MSG_BASELEN + 14]);
255 break;
256
257 case CAPI_FUNCTION_GET_VERSION:
258 if (skb->len < CAPI_MSG_BASELEN + 32)
259 break;
260
261 if (!info && ctrl) {
262 ctrl->version.majorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 16);
263 ctrl->version.minorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 20);
264 ctrl->version.majormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 24);
265 ctrl->version.minormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 28);
266 }
267
268 break;
269
270 case CAPI_FUNCTION_GET_SERIAL_NUMBER:
271 if (!info && ctrl && skb->len > CAPI_MSG_BASELEN + 16)
272 strscpy_pad(ctrl->serial,
273 skb->data + CAPI_MSG_BASELEN + 17,
274 skb->data[CAPI_MSG_BASELEN + 16]);
275 break;
276 }
277
278 break;
279
280 case CAPI_IND:
281 if (skb->len < CAPI_MSG_BASELEN + 6)
282 break;
283
284 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 3);
285
286 if (func == CAPI_FUNCTION_LOOPBACK) {
287 int len = min_t(uint, skb->len - CAPI_MSG_BASELEN - 6,
288 skb->data[CAPI_MSG_BASELEN + 5]);
289 appl = CAPIMSG_APPID(skb->data);
290 msgnum = CAPIMSG_MSGID(skb->data);
291 cmtp_send_interopmsg(session, CAPI_RESP, appl, msgnum, func,
292 skb->data + CAPI_MSG_BASELEN + 6, len);
293 }
294
295 break;
296 }
297
298 kfree_skb(skb);
299}
300
301void cmtp_recv_capimsg(struct cmtp_session *session, struct sk_buff *skb)
302{
303 struct capi_ctr *ctrl = &session->ctrl;
304 struct cmtp_application *application;
305 __u16 appl;
306 __u32 contr;
307
308 BT_DBG("session %p skb %p len %u", session, skb, skb->len);
309
310 if (skb->len < CAPI_MSG_BASELEN)
311 return;
312
313 if (CAPIMSG_COMMAND(skb->data) == CAPI_INTEROPERABILITY) {
314 cmtp_recv_interopmsg(session, skb);
315 return;
316 }
317
318 if (session->flags & BIT(CMTP_LOOPBACK)) {
319 kfree_skb(skb);
320 return;
321 }
322
323 appl = CAPIMSG_APPID(skb->data);
324 contr = CAPIMSG_CONTROL(skb->data);
325
326 application = cmtp_application_get(session, CMTP_MAPPING, appl);
327 if (application) {
328 appl = application->appl;
329 CAPIMSG_SETAPPID(skb->data, appl);
330 } else {
331 BT_ERR("Can't find application with id %u", appl);
332 kfree_skb(skb);
333 return;
334 }
335
336 if ((contr & 0x7f) == 0x01) {
337 contr = (contr & 0xffffff80) | session->num;
338 CAPIMSG_SETCONTROL(skb->data, contr);
339 }
340
341 capi_ctr_handle_message(ctrl, appl, skb);
342}
343
344static int cmtp_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
345{
346 BT_DBG("ctrl %p data %p", ctrl, data);
347
348 return 0;
349}
350
351static void cmtp_reset_ctr(struct capi_ctr *ctrl)
352{
353 struct cmtp_session *session = ctrl->driverdata;
354
355 BT_DBG("ctrl %p", ctrl);
356
357 capi_ctr_down(ctrl);
358
359 atomic_inc(&session->terminate);
360 wake_up_process(session->task);
361}
362
363static void cmtp_register_appl(struct capi_ctr *ctrl, __u16 appl, capi_register_params *rp)
364{
365 DECLARE_WAITQUEUE(wait, current);
366 struct cmtp_session *session = ctrl->driverdata;
367 struct cmtp_application *application;
368 unsigned long timeo = CMTP_INTEROP_TIMEOUT;
369 unsigned char buf[8];
370 int err = 0, nconn, want = rp->level3cnt;
371
372 BT_DBG("ctrl %p appl %u level3cnt %u datablkcnt %u datablklen %u",
373 ctrl, appl, rp->level3cnt, rp->datablkcnt, rp->datablklen);
374
375 application = cmtp_application_add(session, appl);
376 if (!application) {
377 BT_ERR("Can't allocate memory for new application");
378 return;
379 }
380
381 if (want < 0)
382 nconn = ctrl->profile.nbchannel * -want;
383 else
384 nconn = want;
385
386 if (nconn == 0)
387 nconn = ctrl->profile.nbchannel;
388
389 capimsg_setu16(buf, 0, nconn);
390 capimsg_setu16(buf, 2, rp->datablkcnt);
391 capimsg_setu16(buf, 4, rp->datablklen);
392
393 application->state = BT_CONFIG;
394 application->msgnum = cmtp_msgnum_get(session);
395
396 cmtp_send_interopmsg(session, CAPI_REQ, 0x0000, application->msgnum,
397 CAPI_FUNCTION_REGISTER, buf, 6);
398
399 add_wait_queue(&session->wait, &wait);
400 while (1) {
401 set_current_state(TASK_INTERRUPTIBLE);
402
403 if (!timeo) {
404 err = -EAGAIN;
405 break;
406 }
407
408 if (application->state == BT_CLOSED) {
409 err = -application->err;
410 break;
411 }
412
413 if (application->state == BT_CONNECTED)
414 break;
415
416 if (signal_pending(current)) {
417 err = -EINTR;
418 break;
419 }
420
421 timeo = schedule_timeout(timeo);
422 }
423 set_current_state(TASK_RUNNING);
424 remove_wait_queue(&session->wait, &wait);
425
426 if (err) {
427 cmtp_application_del(session, application);
428 return;
429 }
430}
431
432static void cmtp_release_appl(struct capi_ctr *ctrl, __u16 appl)
433{
434 struct cmtp_session *session = ctrl->driverdata;
435 struct cmtp_application *application;
436
437 BT_DBG("ctrl %p appl %u", ctrl, appl);
438
439 application = cmtp_application_get(session, CMTP_APPLID, appl);
440 if (!application) {
441 BT_ERR("Can't find application");
442 return;
443 }
444
445 application->msgnum = cmtp_msgnum_get(session);
446
447 cmtp_send_interopmsg(session, CAPI_REQ, application->mapping, application->msgnum,
448 CAPI_FUNCTION_RELEASE, NULL, 0);
449
450 wait_event_interruptible_timeout(session->wait,
451 (application->state == BT_CLOSED), CMTP_INTEROP_TIMEOUT);
452
453 cmtp_application_del(session, application);
454}
455
456static u16 cmtp_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
457{
458 struct cmtp_session *session = ctrl->driverdata;
459 struct cmtp_application *application;
460 __u16 appl;
461 __u32 contr;
462
463 BT_DBG("ctrl %p skb %p", ctrl, skb);
464
465 appl = CAPIMSG_APPID(skb->data);
466 contr = CAPIMSG_CONTROL(skb->data);
467
468 application = cmtp_application_get(session, CMTP_APPLID, appl);
469 if ((!application) || (application->state != BT_CONNECTED)) {
470 BT_ERR("Can't find application with id %u", appl);
471 return CAPI_ILLAPPNR;
472 }
473
474 CAPIMSG_SETAPPID(skb->data, application->mapping);
475
476 if ((contr & 0x7f) == session->num) {
477 contr = (contr & 0xffffff80) | 0x01;
478 CAPIMSG_SETCONTROL(skb->data, contr);
479 }
480
481 cmtp_send_capimsg(session, skb);
482
483 return CAPI_NOERROR;
484}
485
486static char *cmtp_procinfo(struct capi_ctr *ctrl)
487{
488 return "CAPI Message Transport Protocol";
489}
490
491static int cmtp_proc_show(struct seq_file *m, void *v)
492{
493 struct capi_ctr *ctrl = m->private;
494 struct cmtp_session *session = ctrl->driverdata;
495 struct cmtp_application *app;
496
497 seq_printf(m, "%s\n\n", cmtp_procinfo(ctrl));
498 seq_printf(m, "addr %s\n", session->name);
499 seq_printf(m, "ctrl %d\n", session->num);
500
501 list_for_each_entry(app, &session->applications, list) {
502 seq_printf(m, "appl %u -> %u\n", app->appl, app->mapping);
503 }
504
505 return 0;
506}
507
508int cmtp_attach_device(struct cmtp_session *session)
509{
510 unsigned char buf[4];
511 long ret;
512
513 BT_DBG("session %p", session);
514
515 capimsg_setu32(buf, 0, 0);
516
517 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, CMTP_INITIAL_MSGNUM,
518 CAPI_FUNCTION_GET_PROFILE, buf, 4);
519
520 ret = wait_event_interruptible_timeout(session->wait,
521 session->ncontroller, CMTP_INTEROP_TIMEOUT);
522
523 BT_INFO("Found %d CAPI controller(s) on device %s", session->ncontroller, session->name);
524
525 if (!ret)
526 return -ETIMEDOUT;
527
528 if (!session->ncontroller)
529 return -ENODEV;
530
531 if (session->ncontroller > 1)
532 BT_INFO("Setting up only CAPI controller 1");
533
534 session->ctrl.owner = THIS_MODULE;
535 session->ctrl.driverdata = session;
536 strcpy(session->ctrl.name, session->name);
537
538 session->ctrl.driver_name = "cmtp";
539 session->ctrl.load_firmware = cmtp_load_firmware;
540 session->ctrl.reset_ctr = cmtp_reset_ctr;
541 session->ctrl.register_appl = cmtp_register_appl;
542 session->ctrl.release_appl = cmtp_release_appl;
543 session->ctrl.send_message = cmtp_send_message;
544
545 session->ctrl.procinfo = cmtp_procinfo;
546 session->ctrl.proc_show = cmtp_proc_show;
547
548 if (attach_capi_ctr(&session->ctrl) < 0) {
549 BT_ERR("Can't attach new controller");
550 return -EBUSY;
551 }
552
553 session->num = session->ctrl.cnr;
554
555 BT_DBG("session %p num %d", session, session->num);
556
557 capimsg_setu32(buf, 0, 1);
558
559 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
560 CAPI_FUNCTION_GET_MANUFACTURER, buf, 4);
561
562 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
563 CAPI_FUNCTION_GET_VERSION, buf, 4);
564
565 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
566 CAPI_FUNCTION_GET_SERIAL_NUMBER, buf, 4);
567
568 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
569 CAPI_FUNCTION_GET_PROFILE, buf, 4);
570
571 return 0;
572}
573
574void cmtp_detach_device(struct cmtp_session *session)
575{
576 BT_DBG("session %p", session);
577
578 detach_capi_ctr(&session->ctrl);
579}