1/* 2 * Shared Transport Line discipline driver Core 3 * This hooks up ST KIM driver and ST LL driver 4 * Copyright (C) 2009-2010 Texas Instruments 5 * Author: Pavan Savoy <pavan_savoy@ti.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 */ 21 22#define pr_fmt(fmt) "(stc): " fmt 23#include <linux/module.h> 24#include <linux/kernel.h> 25#include <linux/tty.h> 26 27#include <linux/seq_file.h> 28#include <linux/skbuff.h> 29 30#include <linux/ti_wilink_st.h> 31 32extern void st_kim_recv(void *, const unsigned char *, long); 33void st_int_recv(void *, const unsigned char *, long); 34/* function pointer pointing to either, 35 * st_kim_recv during registration to receive fw download responses 36 * st_int_recv after registration to receive proto stack responses 37 */ 38static void (*st_recv) (void *, const unsigned char *, long); 39 40/********************************************************************/ 41static void add_channel_to_table(struct st_data_s *st_gdata, 42 struct st_proto_s *new_proto) 43{ 44 pr_info("%s: id %d\n", __func__, new_proto->chnl_id); 45 /* list now has the channel id as index itself */ 46 st_gdata->list[new_proto->chnl_id] = new_proto; 47 st_gdata->is_registered[new_proto->chnl_id] = true; 48} 49 50static void remove_channel_from_table(struct st_data_s *st_gdata, 51 struct st_proto_s *proto) 52{ 53 pr_info("%s: id %d\n", __func__, proto->chnl_id); 54/* st_gdata->list[proto->chnl_id] = NULL; */ 55 st_gdata->is_registered[proto->chnl_id] = false; 56} 57 58/* 59 * called from KIM during firmware download. 60 * 61 * This is a wrapper function to tty->ops->write_room. 62 * It returns number of free space available in 63 * uart tx buffer. 64 */ 65int st_get_uart_wr_room(struct st_data_s *st_gdata) 66{ 67 struct tty_struct *tty; 68 if (unlikely(st_gdata == NULL || st_gdata->tty == NULL)) { 69 pr_err("tty unavailable to perform write"); 70 return -1; 71 } 72 tty = st_gdata->tty; 73 return tty->ops->write_room(tty); 74} 75 76/* can be called in from 77 * -- KIM (during fw download) 78 * -- ST Core (during st_write) 79 * 80 * This is the internal write function - a wrapper 81 * to tty->ops->write 82 */ 83int st_int_write(struct st_data_s *st_gdata, 84 const unsigned char *data, int count) 85{ 86 struct tty_struct *tty; 87 if (unlikely(st_gdata == NULL || st_gdata->tty == NULL)) { 88 pr_err("tty unavailable to perform write"); 89 return -EINVAL; 90 } 91 tty = st_gdata->tty; 92#ifdef VERBOSE 93 print_hex_dump(KERN_DEBUG, "<out<", DUMP_PREFIX_NONE, 94 16, 1, data, count, 0); 95#endif 96 return tty->ops->write(tty, data, count); 97 98} 99 100/* 101 * push the skb received to relevant 102 * protocol stacks 103 */ 104static void st_send_frame(unsigned char chnl_id, struct st_data_s *st_gdata) 105{ 106 pr_debug(" %s(prot:%d) ", __func__, chnl_id); 107 108 if (unlikely 109 (st_gdata == NULL || st_gdata->rx_skb == NULL 110 || st_gdata->is_registered[chnl_id] == false)) { 111 pr_err("chnl_id %d not registered, no data to send?", 112 chnl_id); 113 kfree_skb(st_gdata->rx_skb); 114 return; 115 } 116 /* this cannot fail 117 * this shouldn't take long 118 * - should be just skb_queue_tail for the 119 * protocol stack driver 120 */ 121 if (likely(st_gdata->list[chnl_id]->recv != NULL)) { 122 if (unlikely 123 (st_gdata->list[chnl_id]->recv 124 (st_gdata->list[chnl_id]->priv_data, st_gdata->rx_skb) 125 != 0)) { 126 pr_err(" proto stack %d's ->recv failed", chnl_id); 127 kfree_skb(st_gdata->rx_skb); 128 return; 129 } 130 } else { 131 pr_err(" proto stack %d's ->recv null", chnl_id); 132 kfree_skb(st_gdata->rx_skb); 133 } 134 return; 135} 136 137/** 138 * st_reg_complete - 139 * to call registration complete callbacks 140 * of all protocol stack drivers 141 * This function is being called with spin lock held, protocol drivers are 142 * only expected to complete their waits and do nothing more than that. 143 */ 144static void st_reg_complete(struct st_data_s *st_gdata, char err) 145{ 146 unsigned char i = 0; 147 pr_info(" %s ", __func__); 148 for (i = 0; i < ST_MAX_CHANNELS; i++) { 149 if (likely(st_gdata != NULL && 150 st_gdata->is_registered[i] == true && 151 st_gdata->list[i]->reg_complete_cb != NULL)) { 152 st_gdata->list[i]->reg_complete_cb 153 (st_gdata->list[i]->priv_data, err); 154 pr_info("protocol %d's cb sent %d\n", i, err); 155 if (err) { /* cleanup registered protocol */ 156 st_gdata->is_registered[i] = false; 157 if (st_gdata->protos_registered) 158 st_gdata->protos_registered--; 159 } 160 } 161 } 162} 163 164static inline int st_check_data_len(struct st_data_s *st_gdata, 165 unsigned char chnl_id, int len) 166{ 167 int room = skb_tailroom(st_gdata->rx_skb); 168 169 pr_debug("len %d room %d", len, room); 170 171 if (!len) { 172 /* Received packet has only packet header and 173 * has zero length payload. So, ask ST CORE to 174 * forward the packet to protocol driver (BT/FM/GPS) 175 */ 176 st_send_frame(chnl_id, st_gdata); 177 178 } else if (len > room) { 179 /* Received packet's payload length is larger. 180 * We can't accommodate it in created skb. 181 */ 182 pr_err("Data length is too large len %d room %d", len, 183 room); 184 kfree_skb(st_gdata->rx_skb); 185 } else { 186 /* Packet header has non-zero payload length and 187 * we have enough space in created skb. Lets read 188 * payload data */ 189 st_gdata->rx_state = ST_W4_DATA; 190 st_gdata->rx_count = len; 191 return len; 192 } 193 194 /* Change ST state to continue to process next 195 * packet */ 196 st_gdata->rx_state = ST_W4_PACKET_TYPE; 197 st_gdata->rx_skb = NULL; 198 st_gdata->rx_count = 0; 199 st_gdata->rx_chnl = 0; 200 201 return 0; 202} 203 204/** 205 * st_wakeup_ack - internal function for action when wake-up ack 206 * received 207 */ 208static inline void st_wakeup_ack(struct st_data_s *st_gdata, 209 unsigned char cmd) 210{ 211 struct sk_buff *waiting_skb; 212 unsigned long flags = 0; 213 214 spin_lock_irqsave(&st_gdata->lock, flags); 215 /* de-Q from waitQ and Q in txQ now that the 216 * chip is awake 217 */ 218 while ((waiting_skb = skb_dequeue(&st_gdata->tx_waitq))) 219 skb_queue_tail(&st_gdata->txq, waiting_skb); 220 221 /* state forwarded to ST LL */ 222 st_ll_sleep_state(st_gdata, (unsigned long)cmd); 223 spin_unlock_irqrestore(&st_gdata->lock, flags); 224 225 /* wake up to send the recently copied skbs from waitQ */ 226 st_tx_wakeup(st_gdata); 227} 228 229/** 230 * st_int_recv - ST's internal receive function. 231 * Decodes received RAW data and forwards to corresponding 232 * client drivers (Bluetooth,FM,GPS..etc). 233 * This can receive various types of packets, 234 * HCI-Events, ACL, SCO, 4 types of HCI-LL PM packets 235 * CH-8 packets from FM, CH-9 packets from GPS cores. 236 */ 237void st_int_recv(void *disc_data, 238 const unsigned char *data, long count) 239{ 240 char *ptr; 241 struct st_proto_s *proto; 242 unsigned short payload_len = 0; 243 int len = 0; 244 unsigned char type = 0; 245 unsigned char *plen; 246 struct st_data_s *st_gdata = (struct st_data_s *)disc_data; 247 unsigned long flags; 248 249 ptr = (char *)data; 250 /* tty_receive sent null ? */ 251 if (unlikely(ptr == NULL) || (st_gdata == NULL)) { 252 pr_err(" received null from TTY "); 253 return; 254 } 255 256 pr_debug("count %ld rx_state %ld" 257 "rx_count %ld", count, st_gdata->rx_state, 258 st_gdata->rx_count); 259 260 spin_lock_irqsave(&st_gdata->lock, flags); 261 /* Decode received bytes here */ 262 while (count) { 263 if (st_gdata->rx_count) { 264 len = min_t(unsigned int, st_gdata->rx_count, count); 265 memcpy(skb_put(st_gdata->rx_skb, len), ptr, len); 266 st_gdata->rx_count -= len; 267 count -= len; 268 ptr += len; 269 270 if (st_gdata->rx_count) 271 continue; 272 273 /* Check ST RX state machine , where are we? */ 274 switch (st_gdata->rx_state) { 275 /* Waiting for complete packet ? */ 276 case ST_W4_DATA: 277 pr_debug("Complete pkt received"); 278 /* Ask ST CORE to forward 279 * the packet to protocol driver */ 280 st_send_frame(st_gdata->rx_chnl, st_gdata); 281 282 st_gdata->rx_state = ST_W4_PACKET_TYPE; 283 st_gdata->rx_skb = NULL; 284 continue; 285 /* parse the header to know details */ 286 case ST_W4_HEADER: 287 proto = st_gdata->list[st_gdata->rx_chnl]; 288 plen = 289 &st_gdata->rx_skb->data 290 [proto->offset_len_in_hdr]; 291 pr_debug("plen pointing to %x\n", *plen); 292 if (proto->len_size == 1)/* 1 byte len field */ 293 payload_len = *(unsigned char *)plen; 294 else if (proto->len_size == 2) 295 payload_len = 296 __le16_to_cpu(*(unsigned short *)plen); 297 else 298 pr_info("%s: invalid length " 299 "for id %d\n", 300 __func__, proto->chnl_id); 301 st_check_data_len(st_gdata, proto->chnl_id, 302 payload_len); 303 pr_debug("off %d, pay len %d\n", 304 proto->offset_len_in_hdr, payload_len); 305 continue; 306 } /* end of switch rx_state */ 307 } 308 309 /* end of if rx_count */ 310 /* Check first byte of packet and identify module 311 * owner (BT/FM/GPS) */ 312 switch (*ptr) { 313 case LL_SLEEP_IND: 314 case LL_SLEEP_ACK: 315 case LL_WAKE_UP_IND: 316 pr_debug("PM packet"); 317 /* this takes appropriate action based on 318 * sleep state received -- 319 */ 320 st_ll_sleep_state(st_gdata, *ptr); 321 /* if WAKEUP_IND collides copy from waitq to txq 322 * and assume chip awake 323 */ 324 spin_unlock_irqrestore(&st_gdata->lock, flags); 325 if (st_ll_getstate(st_gdata) == ST_LL_AWAKE) 326 st_wakeup_ack(st_gdata, LL_WAKE_UP_ACK); 327 spin_lock_irqsave(&st_gdata->lock, flags); 328 329 ptr++; 330 count--; 331 continue; 332 case LL_WAKE_UP_ACK: 333 pr_debug("PM packet"); 334 335 spin_unlock_irqrestore(&st_gdata->lock, flags); 336 /* wake up ack received */ 337 st_wakeup_ack(st_gdata, *ptr); 338 spin_lock_irqsave(&st_gdata->lock, flags); 339 340 ptr++; 341 count--; 342 continue; 343 /* Unknow packet? */ 344 default: 345 type = *ptr; 346 347 /* Default case means non-HCILL packets, 348 * possibilities are packets for: 349 * (a) valid protocol - Supported Protocols within 350 * the ST_MAX_CHANNELS. 351 * (b) registered protocol - Checked by 352 * "st_gdata->list[type] == NULL)" are supported 353 * protocols only. 354 * Rules out any invalid protocol and 355 * unregistered protocols with channel ID < 16. 356 */ 357 358 if ((type >= ST_MAX_CHANNELS) || 359 (st_gdata->list[type] == NULL)) { 360 pr_err("chip/interface misbehavior: " 361 "dropping frame starting " 362 "with 0x%02x\n", type); 363 goto done; 364 } 365 366 st_gdata->rx_skb = alloc_skb( 367 st_gdata->list[type]->max_frame_size, 368 GFP_ATOMIC); 369 if (st_gdata->rx_skb == NULL) { 370 pr_err("out of memory: dropping\n"); 371 goto done; 372 } 373 374 skb_reserve(st_gdata->rx_skb, 375 st_gdata->list[type]->reserve); 376 /* next 2 required for BT only */ 377 st_gdata->rx_skb->cb[0] = type; /*pkt_type*/ 378 st_gdata->rx_skb->cb[1] = 0; /*incoming*/ 379 st_gdata->rx_chnl = *ptr; 380 st_gdata->rx_state = ST_W4_HEADER; 381 st_gdata->rx_count = st_gdata->list[type]->hdr_len; 382 pr_debug("rx_count %ld\n", st_gdata->rx_count); 383 }; 384 ptr++; 385 count--; 386 } 387done: 388 spin_unlock_irqrestore(&st_gdata->lock, flags); 389 pr_debug("done %s", __func__); 390 return; 391} 392 393/** 394 * st_int_dequeue - internal de-Q function. 395 * If the previous data set was not written 396 * completely, return that skb which has the pending data. 397 * In normal cases, return top of txq. 398 */ 399static struct sk_buff *st_int_dequeue(struct st_data_s *st_gdata) 400{ 401 struct sk_buff *returning_skb; 402 403 pr_debug("%s", __func__); 404 if (st_gdata->tx_skb != NULL) { 405 returning_skb = st_gdata->tx_skb; 406 st_gdata->tx_skb = NULL; 407 return returning_skb; 408 } 409 return skb_dequeue(&st_gdata->txq); 410} 411 412/** 413 * st_int_enqueue - internal Q-ing function. 414 * Will either Q the skb to txq or the tx_waitq 415 * depending on the ST LL state. 416 * If the chip is asleep, then Q it onto waitq and 417 * wakeup the chip. 418 * txq and waitq needs protection since the other contexts 419 * may be sending data, waking up chip. 420 */ 421static void st_int_enqueue(struct st_data_s *st_gdata, struct sk_buff *skb) 422{ 423 unsigned long flags = 0; 424 425 pr_debug("%s", __func__); 426 spin_lock_irqsave(&st_gdata->lock, flags); 427 428 switch (st_ll_getstate(st_gdata)) { 429 case ST_LL_AWAKE: 430 pr_debug("ST LL is AWAKE, sending normally"); 431 skb_queue_tail(&st_gdata->txq, skb); 432 break; 433 case ST_LL_ASLEEP_TO_AWAKE: 434 skb_queue_tail(&st_gdata->tx_waitq, skb); 435 break; 436 case ST_LL_AWAKE_TO_ASLEEP: 437 pr_err("ST LL is illegal state(%ld)," 438 "purging received skb.", st_ll_getstate(st_gdata)); 439 kfree_skb(skb); 440 break; 441 case ST_LL_ASLEEP: 442 skb_queue_tail(&st_gdata->tx_waitq, skb); 443 st_ll_wakeup(st_gdata); 444 break; 445 default: 446 pr_err("ST LL is illegal state(%ld)," 447 "purging received skb.", st_ll_getstate(st_gdata)); 448 kfree_skb(skb); 449 break; 450 } 451 452 spin_unlock_irqrestore(&st_gdata->lock, flags); 453 pr_debug("done %s", __func__); 454 return; 455} 456 457/* 458 * internal wakeup function 459 * called from either 460 * - TTY layer when write's finished 461 * - st_write (in context of the protocol stack) 462 */ 463static void work_fn_write_wakeup(struct work_struct *work) 464{ 465 struct st_data_s *st_gdata = container_of(work, struct st_data_s, 466 work_write_wakeup); 467 468 st_tx_wakeup((void *)st_gdata); 469} 470void st_tx_wakeup(struct st_data_s *st_data) 471{ 472 struct sk_buff *skb; 473 unsigned long flags; /* for irq save flags */ 474 pr_debug("%s", __func__); 475 /* check for sending & set flag sending here */ 476 if (test_and_set_bit(ST_TX_SENDING, &st_data->tx_state)) { 477 pr_debug("ST already sending"); 478 /* keep sending */ 479 set_bit(ST_TX_WAKEUP, &st_data->tx_state); 480 return; 481 /* TX_WAKEUP will be checked in another 482 * context 483 */ 484 } 485 do { /* come back if st_tx_wakeup is set */ 486 /* woke-up to write */ 487 clear_bit(ST_TX_WAKEUP, &st_data->tx_state); 488 while ((skb = st_int_dequeue(st_data))) { 489 int len; 490 spin_lock_irqsave(&st_data->lock, flags); 491 /* enable wake-up from TTY */ 492 set_bit(TTY_DO_WRITE_WAKEUP, &st_data->tty->flags); 493 len = st_int_write(st_data, skb->data, skb->len); 494 skb_pull(skb, len); 495 /* if skb->len = len as expected, skb->len=0 */ 496 if (skb->len) { 497 /* would be the next skb to be sent */ 498 st_data->tx_skb = skb; 499 spin_unlock_irqrestore(&st_data->lock, flags); 500 break; 501 } 502 kfree_skb(skb); 503 spin_unlock_irqrestore(&st_data->lock, flags); 504 } 505 /* if wake-up is set in another context- restart sending */ 506 } while (test_bit(ST_TX_WAKEUP, &st_data->tx_state)); 507 508 /* clear flag sending */ 509 clear_bit(ST_TX_SENDING, &st_data->tx_state); 510} 511 512/********************************************************************/ 513/* functions called from ST KIM 514*/ 515void kim_st_list_protocols(struct st_data_s *st_gdata, void *buf) 516{ 517 seq_printf(buf, "[%d]\nBT=%c\nFM=%c\nGPS=%c\n", 518 st_gdata->protos_registered, 519 st_gdata->is_registered[0x04] == true ? 'R' : 'U', 520 st_gdata->is_registered[0x08] == true ? 'R' : 'U', 521 st_gdata->is_registered[0x09] == true ? 'R' : 'U'); 522} 523 524/********************************************************************/ 525/* 526 * functions called from protocol stack drivers 527 * to be EXPORT-ed 528 */ 529long st_register(struct st_proto_s *new_proto) 530{ 531 struct st_data_s *st_gdata; 532 long err = 0; 533 unsigned long flags = 0; 534 535 st_kim_ref(&st_gdata, 0); 536 if (st_gdata == NULL || new_proto == NULL || new_proto->recv == NULL 537 || new_proto->reg_complete_cb == NULL) { 538 pr_err("gdata/new_proto/recv or reg_complete_cb not ready"); 539 return -EINVAL; 540 } 541 542 if (new_proto->chnl_id >= ST_MAX_CHANNELS) { 543 pr_err("chnl_id %d not supported", new_proto->chnl_id); 544 return -EPROTONOSUPPORT; 545 } 546 547 if (st_gdata->is_registered[new_proto->chnl_id] == true) { 548 pr_err("chnl_id %d already registered", new_proto->chnl_id); 549 return -EALREADY; 550 } 551 552 /* can be from process context only */ 553 spin_lock_irqsave(&st_gdata->lock, flags); 554 555 if (test_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state)) { 556 pr_info(" ST_REG_IN_PROGRESS:%d ", new_proto->chnl_id); 557 /* fw download in progress */ 558 559 add_channel_to_table(st_gdata, new_proto); 560 st_gdata->protos_registered++; 561 new_proto->write = st_write; 562 563 set_bit(ST_REG_PENDING, &st_gdata->st_state); 564 spin_unlock_irqrestore(&st_gdata->lock, flags); 565 return -EINPROGRESS; 566 } else if (st_gdata->protos_registered == ST_EMPTY) { 567 pr_info(" chnl_id list empty :%d ", new_proto->chnl_id); 568 set_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state); 569 st_recv = st_kim_recv; 570 571 /* enable the ST LL - to set default chip state */ 572 st_ll_enable(st_gdata); 573 574 /* release lock previously held - re-locked below */ 575 spin_unlock_irqrestore(&st_gdata->lock, flags); 576 577 /* this may take a while to complete 578 * since it involves BT fw download 579 */ 580 err = st_kim_start(st_gdata->kim_data); 581 if (err != 0) { 582 clear_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state); 583 if ((st_gdata->protos_registered != ST_EMPTY) && 584 (test_bit(ST_REG_PENDING, &st_gdata->st_state))) { 585 pr_err(" KIM failure complete callback "); 586 spin_lock_irqsave(&st_gdata->lock, flags); 587 st_reg_complete(st_gdata, err); 588 spin_unlock_irqrestore(&st_gdata->lock, flags); 589 clear_bit(ST_REG_PENDING, &st_gdata->st_state); 590 } 591 return -EINVAL; 592 } 593 594 spin_lock_irqsave(&st_gdata->lock, flags); 595 596 clear_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state); 597 st_recv = st_int_recv; 598 599 /* this is where all pending registration 600 * are signalled to be complete by calling callback functions 601 */ 602 if ((st_gdata->protos_registered != ST_EMPTY) && 603 (test_bit(ST_REG_PENDING, &st_gdata->st_state))) { 604 pr_debug(" call reg complete callback "); 605 st_reg_complete(st_gdata, 0); 606 } 607 clear_bit(ST_REG_PENDING, &st_gdata->st_state); 608 609 /* check for already registered once more, 610 * since the above check is old 611 */ 612 if (st_gdata->is_registered[new_proto->chnl_id] == true) { 613 pr_err(" proto %d already registered ", 614 new_proto->chnl_id); 615 spin_unlock_irqrestore(&st_gdata->lock, flags); 616 return -EALREADY; 617 } 618 619 add_channel_to_table(st_gdata, new_proto); 620 st_gdata->protos_registered++; 621 new_proto->write = st_write; 622 spin_unlock_irqrestore(&st_gdata->lock, flags); 623 return err; 624 } 625 /* if fw is already downloaded & new stack registers protocol */ 626 else { 627 add_channel_to_table(st_gdata, new_proto); 628 st_gdata->protos_registered++; 629 new_proto->write = st_write; 630 631 /* lock already held before entering else */ 632 spin_unlock_irqrestore(&st_gdata->lock, flags); 633 return err; 634 } 635 pr_debug("done %s(%d) ", __func__, new_proto->chnl_id); 636} 637EXPORT_SYMBOL_GPL(st_register); 638 639/* to unregister a protocol - 640 * to be called from protocol stack driver 641 */ 642long st_unregister(struct st_proto_s *proto) 643{ 644 long err = 0; 645 unsigned long flags = 0; 646 struct st_data_s *st_gdata; 647 648 pr_debug("%s: %d ", __func__, proto->chnl_id); 649 650 st_kim_ref(&st_gdata, 0); 651 if (!st_gdata || proto->chnl_id >= ST_MAX_CHANNELS) { 652 pr_err(" chnl_id %d not supported", proto->chnl_id); 653 return -EPROTONOSUPPORT; 654 } 655 656 spin_lock_irqsave(&st_gdata->lock, flags); 657 658 if (st_gdata->is_registered[proto->chnl_id] == false) { 659 pr_err(" chnl_id %d not registered", proto->chnl_id); 660 spin_unlock_irqrestore(&st_gdata->lock, flags); 661 return -EPROTONOSUPPORT; 662 } 663 664 if (st_gdata->protos_registered) 665 st_gdata->protos_registered--; 666 667 remove_channel_from_table(st_gdata, proto); 668 spin_unlock_irqrestore(&st_gdata->lock, flags); 669 670 if ((st_gdata->protos_registered == ST_EMPTY) && 671 (!test_bit(ST_REG_PENDING, &st_gdata->st_state))) { 672 pr_info(" all chnl_ids unregistered "); 673 674 /* stop traffic on tty */ 675 if (st_gdata->tty) { 676 tty_ldisc_flush(st_gdata->tty); 677 stop_tty(st_gdata->tty); 678 } 679 680 /* all chnl_ids now unregistered */ 681 st_kim_stop(st_gdata->kim_data); 682 /* disable ST LL */ 683 st_ll_disable(st_gdata); 684 } 685 return err; 686} 687 688/* 689 * called in protocol stack drivers 690 * via the write function pointer 691 */ 692long st_write(struct sk_buff *skb) 693{ 694 struct st_data_s *st_gdata; 695 long len; 696 697 st_kim_ref(&st_gdata, 0); 698 if (unlikely(skb == NULL || st_gdata == NULL 699 || st_gdata->tty == NULL)) { 700 pr_err("data/tty unavailable to perform write"); 701 return -EINVAL; 702 } 703 704 pr_debug("%d to be written", skb->len); 705 len = skb->len; 706 707 /* st_ll to decide where to enqueue the skb */ 708 st_int_enqueue(st_gdata, skb); 709 /* wake up */ 710 st_tx_wakeup(st_gdata); 711 712 /* return number of bytes written */ 713 return len; 714} 715 716/* for protocols making use of shared transport */ 717EXPORT_SYMBOL_GPL(st_unregister); 718 719/********************************************************************/ 720/* 721 * functions called from TTY layer 722 */ 723static int st_tty_open(struct tty_struct *tty) 724{ 725 int err = 0; 726 struct st_data_s *st_gdata; 727 pr_info("%s ", __func__); 728 729 st_kim_ref(&st_gdata, 0); 730 st_gdata->tty = tty; 731 tty->disc_data = st_gdata; 732 733 /* don't do an wakeup for now */ 734 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 735 736 /* mem already allocated 737 */ 738 tty->receive_room = 65536; 739 /* Flush any pending characters in the driver and discipline. */ 740 tty_ldisc_flush(tty); 741 tty_driver_flush_buffer(tty); 742 /* 743 * signal to UIM via KIM that - 744 * installation of N_TI_WL ldisc is complete 745 */ 746 st_kim_complete(st_gdata->kim_data); 747 pr_debug("done %s", __func__); 748 return err; 749} 750 751static void st_tty_close(struct tty_struct *tty) 752{ 753 unsigned char i = ST_MAX_CHANNELS; 754 unsigned long flags = 0; 755 struct st_data_s *st_gdata = tty->disc_data; 756 757 pr_info("%s ", __func__); 758 759 /* TODO: 760 * if a protocol has been registered & line discipline 761 * un-installed for some reason - what should be done ? 762 */ 763 spin_lock_irqsave(&st_gdata->lock, flags); 764 for (i = ST_BT; i < ST_MAX_CHANNELS; i++) { 765 if (st_gdata->is_registered[i] == true) 766 pr_err("%d not un-registered", i); 767 st_gdata->list[i] = NULL; 768 st_gdata->is_registered[i] = false; 769 } 770 st_gdata->protos_registered = 0; 771 spin_unlock_irqrestore(&st_gdata->lock, flags); 772 /* 773 * signal to UIM via KIM that - 774 * N_TI_WL ldisc is un-installed 775 */ 776 st_kim_complete(st_gdata->kim_data); 777 st_gdata->tty = NULL; 778 /* Flush any pending characters in the driver and discipline. */ 779 tty_ldisc_flush(tty); 780 tty_driver_flush_buffer(tty); 781 782 spin_lock_irqsave(&st_gdata->lock, flags); 783 /* empty out txq and tx_waitq */ 784 skb_queue_purge(&st_gdata->txq); 785 skb_queue_purge(&st_gdata->tx_waitq); 786 /* reset the TTY Rx states of ST */ 787 st_gdata->rx_count = 0; 788 st_gdata->rx_state = ST_W4_PACKET_TYPE; 789 kfree_skb(st_gdata->rx_skb); 790 st_gdata->rx_skb = NULL; 791 spin_unlock_irqrestore(&st_gdata->lock, flags); 792 793 pr_debug("%s: done ", __func__); 794} 795 796static void st_tty_receive(struct tty_struct *tty, const unsigned char *data, 797 char *tty_flags, int count) 798{ 799#ifdef VERBOSE 800 print_hex_dump(KERN_DEBUG, ">in>", DUMP_PREFIX_NONE, 801 16, 1, data, count, 0); 802#endif 803 804 /* 805 * if fw download is in progress then route incoming data 806 * to KIM for validation 807 */ 808 st_recv(tty->disc_data, data, count); 809 pr_debug("done %s", __func__); 810} 811 812/* wake-up function called in from the TTY layer 813 * inside the internal wakeup function will be called 814 */ 815static void st_tty_wakeup(struct tty_struct *tty) 816{ 817 struct st_data_s *st_gdata = tty->disc_data; 818 pr_debug("%s ", __func__); 819 /* don't do an wakeup for now */ 820 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 821 822 /* 823 * schedule the internal wakeup instead of calling directly to 824 * avoid lockup (port->lock needed in tty->ops->write is 825 * already taken here 826 */ 827 schedule_work(&st_gdata->work_write_wakeup); 828} 829 830static void st_tty_flush_buffer(struct tty_struct *tty) 831{ 832 struct st_data_s *st_gdata = tty->disc_data; 833 pr_debug("%s ", __func__); 834 835 kfree_skb(st_gdata->tx_skb); 836 st_gdata->tx_skb = NULL; 837 838 tty_driver_flush_buffer(tty); 839 return; 840} 841 842static struct tty_ldisc_ops st_ldisc_ops = { 843 .magic = TTY_LDISC_MAGIC, 844 .name = "n_st", 845 .open = st_tty_open, 846 .close = st_tty_close, 847 .receive_buf = st_tty_receive, 848 .write_wakeup = st_tty_wakeup, 849 .flush_buffer = st_tty_flush_buffer, 850 .owner = THIS_MODULE 851}; 852 853/********************************************************************/ 854int st_core_init(struct st_data_s **core_data) 855{ 856 struct st_data_s *st_gdata; 857 long err; 858 859 err = tty_register_ldisc(N_TI_WL, &st_ldisc_ops); 860 if (err) { 861 pr_err("error registering %d line discipline %ld", 862 N_TI_WL, err); 863 return err; 864 } 865 pr_debug("registered n_shared line discipline"); 866 867 st_gdata = kzalloc(sizeof(struct st_data_s), GFP_KERNEL); 868 if (!st_gdata) { 869 pr_err("memory allocation failed"); 870 err = tty_unregister_ldisc(N_TI_WL); 871 if (err) 872 pr_err("unable to un-register ldisc %ld", err); 873 err = -ENOMEM; 874 return err; 875 } 876 877 /* Initialize ST TxQ and Tx waitQ queue head. All BT/FM/GPS module skb's 878 * will be pushed in this queue for actual transmission. 879 */ 880 skb_queue_head_init(&st_gdata->txq); 881 skb_queue_head_init(&st_gdata->tx_waitq); 882 883 /* Locking used in st_int_enqueue() to avoid multiple execution */ 884 spin_lock_init(&st_gdata->lock); 885 886 err = st_ll_init(st_gdata); 887 if (err) { 888 pr_err("error during st_ll initialization(%ld)", err); 889 kfree(st_gdata); 890 err = tty_unregister_ldisc(N_TI_WL); 891 if (err) 892 pr_err("unable to un-register ldisc"); 893 return err; 894 } 895 896 INIT_WORK(&st_gdata->work_write_wakeup, work_fn_write_wakeup); 897 898 *core_data = st_gdata; 899 return 0; 900} 901 902void st_core_exit(struct st_data_s *st_gdata) 903{ 904 long err; 905 /* internal module cleanup */ 906 err = st_ll_deinit(st_gdata); 907 if (err) 908 pr_err("error during deinit of ST LL %ld", err); 909 910 if (st_gdata != NULL) { 911 /* Free ST Tx Qs and skbs */ 912 skb_queue_purge(&st_gdata->txq); 913 skb_queue_purge(&st_gdata->tx_waitq); 914 kfree_skb(st_gdata->rx_skb); 915 kfree_skb(st_gdata->tx_skb); 916 /* TTY ldisc cleanup */ 917 err = tty_unregister_ldisc(N_TI_WL); 918 if (err) 919 pr_err("unable to un-register ldisc %ld", err); 920 /* free the global data pointer */ 921 kfree(st_gdata); 922 } 923} 924