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