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 #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 73 static 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 90 static 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 100 static struct cmtp_application *cmtp_application_get(struct cmtp_session *session, int pattern, __u16 value) 101 { 102 struct cmtp_application *app; 103 struct list_head *p, *n; 104 105 list_for_each_safe(p, n, &session->applications) { 106 app = list_entry(p, struct cmtp_application, list); 107 switch (pattern) { 108 case CMTP_MSGNUM: 109 if (app->msgnum == value) 110 return app; 111 break; 112 case CMTP_APPLID: 113 if (app->appl == value) 114 return app; 115 break; 116 case CMTP_MAPPING: 117 if (app->mapping == value) 118 return app; 119 break; 120 } 121 } 122 123 return NULL; 124 } 125 126 static int cmtp_msgnum_get(struct cmtp_session *session) 127 { 128 session->msgnum++; 129 130 if ((session->msgnum & 0xff) > 200) 131 session->msgnum = CMTP_INITIAL_MSGNUM + 1; 132 133 return session->msgnum; 134 } 135 136 static void cmtp_send_capimsg(struct cmtp_session *session, struct sk_buff *skb) 137 { 138 struct cmtp_scb *scb = (void *) skb->cb; 139 140 BT_DBG("session %p skb %p len %d", session, skb, skb->len); 141 142 scb->id = -1; 143 scb->data = (CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3); 144 145 skb_queue_tail(&session->transmit, skb); 146 147 wake_up_interruptible(sk_sleep(session->sock->sk)); 148 } 149 150 static void cmtp_send_interopmsg(struct cmtp_session *session, 151 __u8 subcmd, __u16 appl, __u16 msgnum, 152 __u16 function, unsigned char *buf, int len) 153 { 154 struct sk_buff *skb; 155 unsigned char *s; 156 157 BT_DBG("session %p subcmd 0x%02x appl %d msgnum %d", session, subcmd, appl, msgnum); 158 159 skb = alloc_skb(CAPI_MSG_BASELEN + 6 + len, GFP_ATOMIC); 160 if (!skb) { 161 BT_ERR("Can't allocate memory for interoperability packet"); 162 return; 163 } 164 165 s = skb_put(skb, CAPI_MSG_BASELEN + 6 + len); 166 167 capimsg_setu16(s, 0, CAPI_MSG_BASELEN + 6 + len); 168 capimsg_setu16(s, 2, appl); 169 capimsg_setu8 (s, 4, CAPI_INTEROPERABILITY); 170 capimsg_setu8 (s, 5, subcmd); 171 capimsg_setu16(s, 6, msgnum); 172 173 /* Interoperability selector (Bluetooth Device Management) */ 174 capimsg_setu16(s, 8, 0x0001); 175 176 capimsg_setu8 (s, 10, 3 + len); 177 capimsg_setu16(s, 11, function); 178 capimsg_setu8 (s, 13, len); 179 180 if (len > 0) 181 memcpy(s + 14, buf, len); 182 183 cmtp_send_capimsg(session, skb); 184 } 185 186 static void cmtp_recv_interopmsg(struct cmtp_session *session, struct sk_buff *skb) 187 { 188 struct capi_ctr *ctrl = &session->ctrl; 189 struct cmtp_application *application; 190 __u16 appl, msgnum, func, info; 191 __u32 controller; 192 193 BT_DBG("session %p skb %p len %d", session, skb, skb->len); 194 195 switch (CAPIMSG_SUBCOMMAND(skb->data)) { 196 case CAPI_CONF: 197 if (skb->len < CAPI_MSG_BASELEN + 10) 198 break; 199 200 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 5); 201 info = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 8); 202 203 switch (func) { 204 case CAPI_FUNCTION_REGISTER: 205 msgnum = CAPIMSG_MSGID(skb->data); 206 207 application = cmtp_application_get(session, CMTP_MSGNUM, msgnum); 208 if (application) { 209 application->state = BT_CONNECTED; 210 application->msgnum = 0; 211 application->mapping = CAPIMSG_APPID(skb->data); 212 wake_up_interruptible(&session->wait); 213 } 214 215 break; 216 217 case CAPI_FUNCTION_RELEASE: 218 appl = CAPIMSG_APPID(skb->data); 219 220 application = cmtp_application_get(session, CMTP_MAPPING, appl); 221 if (application) { 222 application->state = BT_CLOSED; 223 application->msgnum = 0; 224 wake_up_interruptible(&session->wait); 225 } 226 227 break; 228 229 case CAPI_FUNCTION_GET_PROFILE: 230 if (skb->len < CAPI_MSG_BASELEN + 11 + sizeof(capi_profile)) 231 break; 232 233 controller = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 11); 234 msgnum = CAPIMSG_MSGID(skb->data); 235 236 if (!info && (msgnum == CMTP_INITIAL_MSGNUM)) { 237 session->ncontroller = controller; 238 wake_up_interruptible(&session->wait); 239 break; 240 } 241 242 if (!info && ctrl) { 243 memcpy(&ctrl->profile, 244 skb->data + CAPI_MSG_BASELEN + 11, 245 sizeof(capi_profile)); 246 session->state = BT_CONNECTED; 247 capi_ctr_ready(ctrl); 248 } 249 250 break; 251 252 case CAPI_FUNCTION_GET_MANUFACTURER: 253 if (skb->len < CAPI_MSG_BASELEN + 15) 254 break; 255 256 controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 10); 257 258 if (!info && ctrl) { 259 int len = min_t(uint, CAPI_MANUFACTURER_LEN, 260 skb->data[CAPI_MSG_BASELEN + 14]); 261 262 memset(ctrl->manu, 0, CAPI_MANUFACTURER_LEN); 263 strncpy(ctrl->manu, 264 skb->data + CAPI_MSG_BASELEN + 15, len); 265 } 266 267 break; 268 269 case CAPI_FUNCTION_GET_VERSION: 270 if (skb->len < CAPI_MSG_BASELEN + 32) 271 break; 272 273 controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12); 274 275 if (!info && ctrl) { 276 ctrl->version.majorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 16); 277 ctrl->version.minorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 20); 278 ctrl->version.majormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 24); 279 ctrl->version.minormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 28); 280 } 281 282 break; 283 284 case CAPI_FUNCTION_GET_SERIAL_NUMBER: 285 if (skb->len < CAPI_MSG_BASELEN + 17) 286 break; 287 288 controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12); 289 290 if (!info && ctrl) { 291 int len = min_t(uint, CAPI_SERIAL_LEN, 292 skb->data[CAPI_MSG_BASELEN + 16]); 293 294 memset(ctrl->serial, 0, CAPI_SERIAL_LEN); 295 strncpy(ctrl->serial, 296 skb->data + CAPI_MSG_BASELEN + 17, len); 297 } 298 299 break; 300 } 301 302 break; 303 304 case CAPI_IND: 305 if (skb->len < CAPI_MSG_BASELEN + 6) 306 break; 307 308 func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 3); 309 310 if (func == CAPI_FUNCTION_LOOPBACK) { 311 int len = min_t(uint, skb->len - CAPI_MSG_BASELEN - 6, 312 skb->data[CAPI_MSG_BASELEN + 5]); 313 appl = CAPIMSG_APPID(skb->data); 314 msgnum = CAPIMSG_MSGID(skb->data); 315 cmtp_send_interopmsg(session, CAPI_RESP, appl, msgnum, func, 316 skb->data + CAPI_MSG_BASELEN + 6, len); 317 } 318 319 break; 320 } 321 322 kfree_skb(skb); 323 } 324 325 void cmtp_recv_capimsg(struct cmtp_session *session, struct sk_buff *skb) 326 { 327 struct capi_ctr *ctrl = &session->ctrl; 328 struct cmtp_application *application; 329 __u16 appl; 330 __u32 contr; 331 332 BT_DBG("session %p skb %p len %d", session, skb, skb->len); 333 334 if (skb->len < CAPI_MSG_BASELEN) 335 return; 336 337 if (CAPIMSG_COMMAND(skb->data) == CAPI_INTEROPERABILITY) { 338 cmtp_recv_interopmsg(session, skb); 339 return; 340 } 341 342 if (session->flags & (1 << CMTP_LOOPBACK)) { 343 kfree_skb(skb); 344 return; 345 } 346 347 appl = CAPIMSG_APPID(skb->data); 348 contr = CAPIMSG_CONTROL(skb->data); 349 350 application = cmtp_application_get(session, CMTP_MAPPING, appl); 351 if (application) { 352 appl = application->appl; 353 CAPIMSG_SETAPPID(skb->data, appl); 354 } else { 355 BT_ERR("Can't find application with id %d", appl); 356 kfree_skb(skb); 357 return; 358 } 359 360 if ((contr & 0x7f) == 0x01) { 361 contr = (contr & 0xffffff80) | session->num; 362 CAPIMSG_SETCONTROL(skb->data, contr); 363 } 364 365 if (!ctrl) { 366 BT_ERR("Can't find controller %d for message", session->num); 367 kfree_skb(skb); 368 return; 369 } 370 371 capi_ctr_handle_message(ctrl, appl, skb); 372 } 373 374 static int cmtp_load_firmware(struct capi_ctr *ctrl, capiloaddata *data) 375 { 376 BT_DBG("ctrl %p data %p", ctrl, data); 377 378 return 0; 379 } 380 381 static void cmtp_reset_ctr(struct capi_ctr *ctrl) 382 { 383 struct cmtp_session *session = ctrl->driverdata; 384 385 BT_DBG("ctrl %p", ctrl); 386 387 capi_ctr_down(ctrl); 388 389 kthread_stop(session->task); 390 } 391 392 static void cmtp_register_appl(struct capi_ctr *ctrl, __u16 appl, capi_register_params *rp) 393 { 394 DECLARE_WAITQUEUE(wait, current); 395 struct cmtp_session *session = ctrl->driverdata; 396 struct cmtp_application *application; 397 unsigned long timeo = CMTP_INTEROP_TIMEOUT; 398 unsigned char buf[8]; 399 int err = 0, nconn, want = rp->level3cnt; 400 401 BT_DBG("ctrl %p appl %d level3cnt %d datablkcnt %d datablklen %d", 402 ctrl, appl, rp->level3cnt, rp->datablkcnt, rp->datablklen); 403 404 application = cmtp_application_add(session, appl); 405 if (!application) { 406 BT_ERR("Can't allocate memory for new application"); 407 return; 408 } 409 410 if (want < 0) 411 nconn = ctrl->profile.nbchannel * -want; 412 else 413 nconn = want; 414 415 if (nconn == 0) 416 nconn = ctrl->profile.nbchannel; 417 418 capimsg_setu16(buf, 0, nconn); 419 capimsg_setu16(buf, 2, rp->datablkcnt); 420 capimsg_setu16(buf, 4, rp->datablklen); 421 422 application->state = BT_CONFIG; 423 application->msgnum = cmtp_msgnum_get(session); 424 425 cmtp_send_interopmsg(session, CAPI_REQ, 0x0000, application->msgnum, 426 CAPI_FUNCTION_REGISTER, buf, 6); 427 428 add_wait_queue(&session->wait, &wait); 429 while (1) { 430 set_current_state(TASK_INTERRUPTIBLE); 431 432 if (!timeo) { 433 err = -EAGAIN; 434 break; 435 } 436 437 if (application->state == BT_CLOSED) { 438 err = -application->err; 439 break; 440 } 441 442 if (application->state == BT_CONNECTED) 443 break; 444 445 if (signal_pending(current)) { 446 err = -EINTR; 447 break; 448 } 449 450 timeo = schedule_timeout(timeo); 451 } 452 set_current_state(TASK_RUNNING); 453 remove_wait_queue(&session->wait, &wait); 454 455 if (err) { 456 cmtp_application_del(session, application); 457 return; 458 } 459 } 460 461 static void cmtp_release_appl(struct capi_ctr *ctrl, __u16 appl) 462 { 463 struct cmtp_session *session = ctrl->driverdata; 464 struct cmtp_application *application; 465 466 BT_DBG("ctrl %p appl %d", ctrl, appl); 467 468 application = cmtp_application_get(session, CMTP_APPLID, appl); 469 if (!application) { 470 BT_ERR("Can't find application"); 471 return; 472 } 473 474 application->msgnum = cmtp_msgnum_get(session); 475 476 cmtp_send_interopmsg(session, CAPI_REQ, application->mapping, application->msgnum, 477 CAPI_FUNCTION_RELEASE, NULL, 0); 478 479 wait_event_interruptible_timeout(session->wait, 480 (application->state == BT_CLOSED), CMTP_INTEROP_TIMEOUT); 481 482 cmtp_application_del(session, application); 483 } 484 485 static u16 cmtp_send_message(struct capi_ctr *ctrl, struct sk_buff *skb) 486 { 487 struct cmtp_session *session = ctrl->driverdata; 488 struct cmtp_application *application; 489 __u16 appl; 490 __u32 contr; 491 492 BT_DBG("ctrl %p skb %p", ctrl, skb); 493 494 appl = CAPIMSG_APPID(skb->data); 495 contr = CAPIMSG_CONTROL(skb->data); 496 497 application = cmtp_application_get(session, CMTP_APPLID, appl); 498 if ((!application) || (application->state != BT_CONNECTED)) { 499 BT_ERR("Can't find application with id %d", appl); 500 return CAPI_ILLAPPNR; 501 } 502 503 CAPIMSG_SETAPPID(skb->data, application->mapping); 504 505 if ((contr & 0x7f) == session->num) { 506 contr = (contr & 0xffffff80) | 0x01; 507 CAPIMSG_SETCONTROL(skb->data, contr); 508 } 509 510 cmtp_send_capimsg(session, skb); 511 512 return CAPI_NOERROR; 513 } 514 515 static char *cmtp_procinfo(struct capi_ctr *ctrl) 516 { 517 return "CAPI Message Transport Protocol"; 518 } 519 520 static int cmtp_proc_show(struct seq_file *m, void *v) 521 { 522 struct capi_ctr *ctrl = m->private; 523 struct cmtp_session *session = ctrl->driverdata; 524 struct cmtp_application *app; 525 struct list_head *p, *n; 526 527 seq_printf(m, "%s\n\n", cmtp_procinfo(ctrl)); 528 seq_printf(m, "addr %s\n", session->name); 529 seq_printf(m, "ctrl %d\n", session->num); 530 531 list_for_each_safe(p, n, &session->applications) { 532 app = list_entry(p, struct cmtp_application, list); 533 seq_printf(m, "appl %d -> %d\n", app->appl, app->mapping); 534 } 535 536 return 0; 537 } 538 539 static int cmtp_proc_open(struct inode *inode, struct file *file) 540 { 541 return single_open(file, cmtp_proc_show, PDE(inode)->data); 542 } 543 544 static const struct file_operations cmtp_proc_fops = { 545 .owner = THIS_MODULE, 546 .open = cmtp_proc_open, 547 .read = seq_read, 548 .llseek = seq_lseek, 549 .release = single_release, 550 }; 551 552 int cmtp_attach_device(struct cmtp_session *session) 553 { 554 unsigned char buf[4]; 555 long ret; 556 557 BT_DBG("session %p", session); 558 559 capimsg_setu32(buf, 0, 0); 560 561 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, CMTP_INITIAL_MSGNUM, 562 CAPI_FUNCTION_GET_PROFILE, buf, 4); 563 564 ret = wait_event_interruptible_timeout(session->wait, 565 session->ncontroller, CMTP_INTEROP_TIMEOUT); 566 567 BT_INFO("Found %d CAPI controller(s) on device %s", session->ncontroller, session->name); 568 569 if (!ret) 570 return -ETIMEDOUT; 571 572 if (!session->ncontroller) 573 return -ENODEV; 574 575 if (session->ncontroller > 1) 576 BT_INFO("Setting up only CAPI controller 1"); 577 578 session->ctrl.owner = THIS_MODULE; 579 session->ctrl.driverdata = session; 580 strcpy(session->ctrl.name, session->name); 581 582 session->ctrl.driver_name = "cmtp"; 583 session->ctrl.load_firmware = cmtp_load_firmware; 584 session->ctrl.reset_ctr = cmtp_reset_ctr; 585 session->ctrl.register_appl = cmtp_register_appl; 586 session->ctrl.release_appl = cmtp_release_appl; 587 session->ctrl.send_message = cmtp_send_message; 588 589 session->ctrl.procinfo = cmtp_procinfo; 590 session->ctrl.proc_fops = &cmtp_proc_fops; 591 592 if (attach_capi_ctr(&session->ctrl) < 0) { 593 BT_ERR("Can't attach new controller"); 594 return -EBUSY; 595 } 596 597 session->num = session->ctrl.cnr; 598 599 BT_DBG("session %p num %d", session, session->num); 600 601 capimsg_setu32(buf, 0, 1); 602 603 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session), 604 CAPI_FUNCTION_GET_MANUFACTURER, buf, 4); 605 606 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session), 607 CAPI_FUNCTION_GET_VERSION, buf, 4); 608 609 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session), 610 CAPI_FUNCTION_GET_SERIAL_NUMBER, buf, 4); 611 612 cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session), 613 CAPI_FUNCTION_GET_PROFILE, buf, 4); 614 615 return 0; 616 } 617 618 void cmtp_detach_device(struct cmtp_session *session) 619 { 620 BT_DBG("session %p", session); 621 622 detach_capi_ctr(&session->ctrl); 623 } 624