2 * Shared Transport Line discipline driver Core
3 * This hooks up ST KIM driver and ST LL driver
4 * Copyright (C) 2009 Texas Instruments
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #define pr_fmt(fmt) "(stc): " fmt
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/init.h>
25 #include <linux/tty.h>
27 /* understand BT, FM and GPS for now */
28 #include <net/bluetooth/bluetooth.h>
29 #include <net/bluetooth/hci_core.h>
30 #include <net/bluetooth/hci.h>
33 * packet formats for fm and gps
43 /* strings to be used for rfkill entries and by
44 * ST Core to be used for sysfs debug entry
46 #define PROTO_ENTRY(type, name) name
47 const unsigned char *protocol_strngs
[] = {
48 PROTO_ENTRY(ST_BT
, "Bluetooth"),
49 PROTO_ENTRY(ST_FM
, "FM"),
50 PROTO_ENTRY(ST_GPS
, "GPS"),
53 /* function pointer pointing to either,
54 * st_kim_recv during registration to receive fw download responses
55 * st_int_recv after registration to receive proto stack responses
57 void (*st_recv
) (void*, const unsigned char*, long);
59 /********************************************************************/
61 /* internal misc functions */
62 bool is_protocol_list_empty(void)
65 pr_debug(" %s ", __func__
);
66 for (i
= 0; i
< ST_MAX
; i
++) {
67 if (st_gdata
->list
[i
] != NULL
)
76 /* can be called in from
77 * -- KIM (during fw download)
78 * -- ST Core (during st_write)
80 * This is the internal write function - a wrapper
83 int st_int_write(struct st_data_s
*st_gdata
,
84 const unsigned char *data
, int count
)
86 struct tty_struct
*tty
;
87 if (unlikely(st_gdata
== NULL
|| st_gdata
->tty
== NULL
)) {
88 pr_err("tty unavailable to perform write");
93 print_hex_dump(KERN_DEBUG
, "<out<", DUMP_PREFIX_NONE
,
94 16, 1, data
, count
, 0);
96 return tty
->ops
->write(tty
, data
, count
);
101 * push the skb received to relevant
104 void st_send_frame(enum proto_type protoid
, struct st_data_s
*st_gdata
)
106 pr_info(" %s(prot:%d) ", __func__
, protoid
);
109 (st_gdata
== NULL
|| st_gdata
->rx_skb
== NULL
110 || st_gdata
->list
[protoid
] == NULL
)) {
111 pr_err("protocol %d not registered, no data to send?",
113 kfree_skb(st_gdata
->rx_skb
);
117 * this shouldn't take long
118 * - should be just skb_queue_tail for the
119 * protocol stack driver
121 if (likely(st_gdata
->list
[protoid
]->recv
!= NULL
)) {
123 (st_gdata
->list
[protoid
]->recv
124 (st_gdata
->list
[protoid
]->priv_data
, st_gdata
->rx_skb
)
126 pr_err(" proto stack %d's ->recv failed", protoid
);
127 kfree_skb(st_gdata
->rx_skb
);
131 pr_err(" proto stack %d's ->recv null", protoid
);
132 kfree_skb(st_gdata
->rx_skb
);
139 * to call registration complete callbacks
140 * of all protocol stack drivers
142 void st_reg_complete(struct st_data_s
*st_gdata
, char err
)
145 pr_info(" %s ", __func__
);
146 for (i
= 0; i
< ST_MAX
; i
++) {
147 if (likely(st_gdata
!= NULL
&& st_gdata
->list
[i
] != NULL
&&
148 st_gdata
->list
[i
]->reg_complete_cb
!= NULL
))
149 st_gdata
->list
[i
]->reg_complete_cb
150 (st_gdata
->list
[i
]->priv_data
, err
);
154 static inline int st_check_data_len(struct st_data_s
*st_gdata
,
155 int protoid
, int len
)
157 register int room
= skb_tailroom(st_gdata
->rx_skb
);
159 pr_debug("len %d room %d", len
, room
);
162 /* Received packet has only packet header and
163 * has zero length payload. So, ask ST CORE to
164 * forward the packet to protocol driver (BT/FM/GPS)
166 st_send_frame(protoid
, st_gdata
);
168 } else if (len
> room
) {
169 /* Received packet's payload length is larger.
170 * We can't accommodate it in created skb.
172 pr_err("Data length is too large len %d room %d", len
,
174 kfree_skb(st_gdata
->rx_skb
);
176 /* Packet header has non-zero payload length and
177 * we have enough space in created skb. Lets read
179 st_gdata
->rx_state
= ST_BT_W4_DATA
;
180 st_gdata
->rx_count
= len
;
184 /* Change ST state to continue to process next
186 st_gdata
->rx_state
= ST_W4_PACKET_TYPE
;
187 st_gdata
->rx_skb
= NULL
;
188 st_gdata
->rx_count
= 0;
194 * st_wakeup_ack - internal function for action when wake-up ack
197 static inline void st_wakeup_ack(struct st_data_s
*st_gdata
,
200 register struct sk_buff
*waiting_skb
;
201 unsigned long flags
= 0;
203 spin_lock_irqsave(&st_gdata
->lock
, flags
);
204 /* de-Q from waitQ and Q in txQ now that the
207 while ((waiting_skb
= skb_dequeue(&st_gdata
->tx_waitq
)))
208 skb_queue_tail(&st_gdata
->txq
, waiting_skb
);
210 /* state forwarded to ST LL */
211 st_ll_sleep_state(st_gdata
, (unsigned long)cmd
);
212 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
214 /* wake up to send the recently copied skbs from waitQ */
215 st_tx_wakeup(st_gdata
);
219 * st_int_recv - ST's internal receive function.
220 * Decodes received RAW data and forwards to corresponding
221 * client drivers (Bluetooth,FM,GPS..etc).
222 * This can receive various types of packets,
223 * HCI-Events, ACL, SCO, 4 types of HCI-LL PM packets
224 * CH-8 packets from FM, CH-9 packets from GPS cores.
226 void st_int_recv(void *disc_data
,
227 const unsigned char *data
, long count
)
230 struct hci_event_hdr
*eh
;
231 struct hci_acl_hdr
*ah
;
232 struct hci_sco_hdr
*sh
;
233 struct fm_event_hdr
*fm
;
234 struct gps_event_hdr
*gps
;
235 register int len
= 0, type
= 0, dlen
= 0;
236 static enum proto_type protoid
= ST_MAX
;
237 struct st_data_s
*st_gdata
= (struct st_data_s
*)disc_data
;
240 /* tty_receive sent null ? */
241 if (unlikely(ptr
== NULL
) || (st_gdata
== NULL
)) {
242 pr_err(" received null from TTY ");
246 pr_info("count %ld rx_state %ld"
247 "rx_count %ld", count
, st_gdata
->rx_state
,
250 /* Decode received bytes here */
252 if (st_gdata
->rx_count
) {
253 len
= min_t(unsigned int, st_gdata
->rx_count
, count
);
254 memcpy(skb_put(st_gdata
->rx_skb
, len
), ptr
, len
);
255 st_gdata
->rx_count
-= len
;
259 if (st_gdata
->rx_count
)
262 /* Check ST RX state machine , where are we? */
263 switch (st_gdata
->rx_state
) {
265 /* Waiting for complete packet ? */
267 pr_debug("Complete pkt received");
269 /* Ask ST CORE to forward
270 * the packet to protocol driver */
271 st_send_frame(protoid
, st_gdata
);
273 st_gdata
->rx_state
= ST_W4_PACKET_TYPE
;
274 st_gdata
->rx_skb
= NULL
;
275 protoid
= ST_MAX
; /* is this required ? */
278 /* Waiting for Bluetooth event header ? */
279 case ST_BT_W4_EVENT_HDR
:
280 eh
= (struct hci_event_hdr
*)st_gdata
->rx_skb
->
283 pr_debug("Event header: evt 0x%2.2x"
284 "plen %d", eh
->evt
, eh
->plen
);
286 st_check_data_len(st_gdata
, protoid
, eh
->plen
);
289 /* Waiting for Bluetooth acl header ? */
290 case ST_BT_W4_ACL_HDR
:
291 ah
= (struct hci_acl_hdr
*)st_gdata
->rx_skb
->
293 dlen
= __le16_to_cpu(ah
->dlen
);
295 pr_info("ACL header: dlen %d", dlen
);
297 st_check_data_len(st_gdata
, protoid
, dlen
);
300 /* Waiting for Bluetooth sco header ? */
301 case ST_BT_W4_SCO_HDR
:
302 sh
= (struct hci_sco_hdr
*)st_gdata
->rx_skb
->
305 pr_info("SCO header: dlen %d", sh
->dlen
);
307 st_check_data_len(st_gdata
, protoid
, sh
->dlen
);
309 case ST_FM_W4_EVENT_HDR
:
310 fm
= (struct fm_event_hdr
*)st_gdata
->rx_skb
->
312 pr_info("FM Header: ");
313 st_check_data_len(st_gdata
, ST_FM
, fm
->plen
);
315 /* TODO : Add GPS packet machine logic here */
316 case ST_GPS_W4_EVENT_HDR
:
317 /* [0x09 pkt hdr][R/W byte][2 byte len] */
318 gps
= (struct gps_event_hdr
*)st_gdata
->rx_skb
->
320 pr_info("GPS Header: ");
321 st_check_data_len(st_gdata
, ST_GPS
, gps
->plen
);
323 } /* end of switch rx_state */
326 /* end of if rx_count */
327 /* Check first byte of packet and identify module
328 * owner (BT/FM/GPS) */
331 /* Bluetooth event packet? */
333 pr_info("Event packet");
334 st_gdata
->rx_state
= ST_BT_W4_EVENT_HDR
;
335 st_gdata
->rx_count
= HCI_EVENT_HDR_SIZE
;
336 type
= HCI_EVENT_PKT
;
340 /* Bluetooth acl packet? */
341 case HCI_ACLDATA_PKT
:
342 pr_info("ACL packet");
343 st_gdata
->rx_state
= ST_BT_W4_ACL_HDR
;
344 st_gdata
->rx_count
= HCI_ACL_HDR_SIZE
;
345 type
= HCI_ACLDATA_PKT
;
349 /* Bluetooth sco packet? */
350 case HCI_SCODATA_PKT
:
351 pr_info("SCO packet");
352 st_gdata
->rx_state
= ST_BT_W4_SCO_HDR
;
353 st_gdata
->rx_count
= HCI_SCO_HDR_SIZE
;
354 type
= HCI_SCODATA_PKT
;
358 /* Channel 8(FM) packet? */
360 pr_info("FM CH8 packet");
361 type
= ST_FM_CH8_PKT
;
362 st_gdata
->rx_state
= ST_FM_W4_EVENT_HDR
;
363 st_gdata
->rx_count
= FM_EVENT_HDR_SIZE
;
367 /* Channel 9(GPS) packet? */
368 case 0x9: /*ST_LL_GPS_CH9_PKT */
369 pr_info("GPS CH9 packet");
370 type
= 0x9; /* ST_LL_GPS_CH9_PKT; */
372 st_gdata
->rx_state
= ST_GPS_W4_EVENT_HDR
;
373 st_gdata
->rx_count
= 3; /* GPS_EVENT_HDR_SIZE -1*/
378 pr_info("PM packet");
379 /* this takes appropriate action based on
380 * sleep state received --
382 st_ll_sleep_state(st_gdata
, *ptr
);
387 pr_info("PM packet");
388 /* wake up ack received */
389 st_wakeup_ack(st_gdata
, *ptr
);
395 pr_err("Unknown packet type %2.2x", (__u8
) *ptr
);
405 /* Allocate new packet to hold received data */
407 bt_skb_alloc(HCI_MAX_FRAME_SIZE
, GFP_ATOMIC
);
408 if (!st_gdata
->rx_skb
) {
409 pr_err("Can't allocate mem for new packet");
410 st_gdata
->rx_state
= ST_W4_PACKET_TYPE
;
411 st_gdata
->rx_count
= 0;
414 bt_cb(st_gdata
->rx_skb
)->pkt_type
= type
;
416 case ST_FM
: /* for FM */
418 alloc_skb(FM_MAX_FRAME_SIZE
, GFP_ATOMIC
);
419 if (!st_gdata
->rx_skb
) {
420 pr_err("Can't allocate mem for new packet");
421 st_gdata
->rx_state
= ST_W4_PACKET_TYPE
;
422 st_gdata
->rx_count
= 0;
425 /* place holder 0x08 */
426 skb_reserve(st_gdata
->rx_skb
, 1);
427 st_gdata
->rx_skb
->cb
[0] = ST_FM_CH8_PKT
;
432 alloc_skb(100 /*GPS_MAX_FRAME_SIZE */ , GFP_ATOMIC
);
433 if (!st_gdata
->rx_skb
) {
434 pr_err("Can't allocate mem for new packet");
435 st_gdata
->rx_state
= ST_W4_PACKET_TYPE
;
436 st_gdata
->rx_count
= 0;
439 /* place holder 0x09 */
440 skb_reserve(st_gdata
->rx_skb
, 1);
441 st_gdata
->rx_skb
->cb
[0] = 0x09; /*ST_GPS_CH9_PKT; */
447 pr_debug("done %s", __func__
);
452 * st_int_dequeue - internal de-Q function.
453 * If the previous data set was not written
454 * completely, return that skb which has the pending data.
455 * In normal cases, return top of txq.
457 struct sk_buff
*st_int_dequeue(struct st_data_s
*st_gdata
)
459 struct sk_buff
*returning_skb
;
461 pr_debug("%s", __func__
);
462 if (st_gdata
->tx_skb
!= NULL
) {
463 returning_skb
= st_gdata
->tx_skb
;
464 st_gdata
->tx_skb
= NULL
;
465 return returning_skb
;
467 return skb_dequeue(&st_gdata
->txq
);
471 * st_int_enqueue - internal Q-ing function.
472 * Will either Q the skb to txq or the tx_waitq
473 * depending on the ST LL state.
474 * If the chip is asleep, then Q it onto waitq and
476 * txq and waitq needs protection since the other contexts
477 * may be sending data, waking up chip.
479 void st_int_enqueue(struct st_data_s
*st_gdata
, struct sk_buff
*skb
)
481 unsigned long flags
= 0;
483 pr_debug("%s", __func__
);
484 spin_lock_irqsave(&st_gdata
->lock
, flags
);
486 switch (st_ll_getstate(st_gdata
)) {
488 pr_info("ST LL is AWAKE, sending normally");
489 skb_queue_tail(&st_gdata
->txq
, skb
);
491 case ST_LL_ASLEEP_TO_AWAKE
:
492 skb_queue_tail(&st_gdata
->tx_waitq
, skb
);
494 case ST_LL_AWAKE_TO_ASLEEP
:
495 pr_err("ST LL is illegal state(%ld),"
496 "purging received skb.", st_ll_getstate(st_gdata
));
500 skb_queue_tail(&st_gdata
->tx_waitq
, skb
);
501 st_ll_wakeup(st_gdata
);
504 pr_err("ST LL is illegal state(%ld),"
505 "purging received skb.", st_ll_getstate(st_gdata
));
510 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
511 pr_debug("done %s", __func__
);
516 * internal wakeup function
518 * - TTY layer when write's finished
519 * - st_write (in context of the protocol stack)
521 void st_tx_wakeup(struct st_data_s
*st_data
)
524 unsigned long flags
; /* for irq save flags */
525 pr_debug("%s", __func__
);
526 /* check for sending & set flag sending here */
527 if (test_and_set_bit(ST_TX_SENDING
, &st_data
->tx_state
)) {
528 pr_info("ST already sending");
530 set_bit(ST_TX_WAKEUP
, &st_data
->tx_state
);
532 /* TX_WAKEUP will be checked in another
536 do { /* come back if st_tx_wakeup is set */
537 /* woke-up to write */
538 clear_bit(ST_TX_WAKEUP
, &st_data
->tx_state
);
539 while ((skb
= st_int_dequeue(st_data
))) {
541 spin_lock_irqsave(&st_data
->lock
, flags
);
542 /* enable wake-up from TTY */
543 set_bit(TTY_DO_WRITE_WAKEUP
, &st_data
->tty
->flags
);
544 len
= st_int_write(st_data
, skb
->data
, skb
->len
);
546 /* if skb->len = len as expected, skb->len=0 */
548 /* would be the next skb to be sent */
549 st_data
->tx_skb
= skb
;
550 spin_unlock_irqrestore(&st_data
->lock
, flags
);
554 spin_unlock_irqrestore(&st_data
->lock
, flags
);
556 /* if wake-up is set in another context- restart sending */
557 } while (test_bit(ST_TX_WAKEUP
, &st_data
->tx_state
));
559 /* clear flag sending */
560 clear_bit(ST_TX_SENDING
, &st_data
->tx_state
);
563 /********************************************************************/
564 /* functions called from ST KIM
566 void kim_st_list_protocols(struct st_data_s
*st_gdata
, char *buf
)
568 unsigned long flags
= 0;
570 unsigned char i
= ST_MAX
;
572 spin_lock_irqsave(&st_gdata
->lock
, flags
);
573 #ifdef DEBUG /* more detailed log */
574 for (i
= 0; i
< ST_MAX
; i
++) {
576 sprintf(buf
, "%s is %s", protocol_strngs
[i
],
578 NULL
? "Registered" : "Unregistered");
580 sprintf(buf
, "%s\n%s is %s", buf
, protocol_strngs
[i
],
582 NULL
? "Registered" : "Unregistered");
585 sprintf(buf
, "%s\n", buf
);
586 #else /* limited info */
587 sprintf(buf
, "[%d]\nBT=%c\nFM=%c\nGPS=%c\n",
588 st_gdata
->protos_registered
,
589 st_gdata
->list
[ST_BT
] != NULL
? 'R' : 'U',
590 st_gdata
->list
[ST_FM
] != NULL
? 'R' : 'U',
591 st_gdata
->list
[ST_GPS
] != NULL
? 'R' : 'U');
593 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
596 /********************************************************************/
598 * functions called from protocol stack drivers
601 long st_register(struct st_proto_s
*new_proto
)
603 struct st_data_s
*st_gdata
;
605 unsigned long flags
= 0;
607 st_kim_ref(&st_gdata
);
608 pr_info("%s(%d) ", __func__
, new_proto
->type
);
609 if (st_gdata
== NULL
|| new_proto
== NULL
|| new_proto
->recv
== NULL
610 || new_proto
->reg_complete_cb
== NULL
) {
611 pr_err("gdata/new_proto/recv or reg_complete_cb not ready");
615 if (new_proto
->type
< ST_BT
|| new_proto
->type
>= ST_MAX
) {
616 pr_err("protocol %d not supported", new_proto
->type
);
617 return -EPROTONOSUPPORT
;
620 if (st_gdata
->list
[new_proto
->type
] != NULL
) {
621 pr_err("protocol %d already registered", new_proto
->type
);
625 /* can be from process context only */
626 spin_lock_irqsave(&st_gdata
->lock
, flags
);
628 if (test_bit(ST_REG_IN_PROGRESS
, &st_gdata
->st_state
)) {
629 pr_info(" ST_REG_IN_PROGRESS:%d ", new_proto
->type
);
630 /* fw download in progress */
631 st_kim_chip_toggle(new_proto
->type
, KIM_GPIO_ACTIVE
);
633 st_gdata
->list
[new_proto
->type
] = new_proto
;
634 st_gdata
->protos_registered
++;
635 new_proto
->write
= st_write
;
637 set_bit(ST_REG_PENDING
, &st_gdata
->st_state
);
638 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
640 } else if (st_gdata
->protos_registered
== ST_EMPTY
) {
641 pr_info(" protocol list empty :%d ", new_proto
->type
);
642 set_bit(ST_REG_IN_PROGRESS
, &st_gdata
->st_state
);
643 st_recv
= st_kim_recv
;
645 /* release lock previously held - re-locked below */
646 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
648 /* enable the ST LL - to set default chip state */
649 st_ll_enable(st_gdata
);
650 /* this may take a while to complete
651 * since it involves BT fw download
653 err
= st_kim_start(st_gdata
->kim_data
);
655 clear_bit(ST_REG_IN_PROGRESS
, &st_gdata
->st_state
);
656 if ((st_gdata
->protos_registered
!= ST_EMPTY
) &&
657 (test_bit(ST_REG_PENDING
, &st_gdata
->st_state
))) {
658 pr_err(" KIM failure complete callback ");
659 st_reg_complete(st_gdata
, -1);
665 /* the protocol might require other gpios to be toggled
667 st_kim_chip_toggle(new_proto
->type
, KIM_GPIO_ACTIVE
);
669 clear_bit(ST_REG_IN_PROGRESS
, &st_gdata
->st_state
);
670 st_recv
= st_int_recv
;
672 /* this is where all pending registration
673 * are signalled to be complete by calling callback functions
675 if ((st_gdata
->protos_registered
!= ST_EMPTY
) &&
676 (test_bit(ST_REG_PENDING
, &st_gdata
->st_state
))) {
677 pr_debug(" call reg complete callback ");
678 st_reg_complete(st_gdata
, 0);
680 clear_bit(ST_REG_PENDING
, &st_gdata
->st_state
);
682 /* check for already registered once more,
683 * since the above check is old
685 if (st_gdata
->list
[new_proto
->type
] != NULL
) {
686 pr_err(" proto %d already registered ",
691 spin_lock_irqsave(&st_gdata
->lock
, flags
);
692 st_gdata
->list
[new_proto
->type
] = new_proto
;
693 st_gdata
->protos_registered
++;
694 new_proto
->write
= st_write
;
695 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
698 /* if fw is already downloaded & new stack registers protocol */
700 switch (new_proto
->type
) {
706 st_kim_chip_toggle(new_proto
->type
, KIM_GPIO_ACTIVE
);
710 pr_err("%d protocol not supported",
712 err
= -EPROTONOSUPPORT
;
713 /* something wrong */
716 st_gdata
->list
[new_proto
->type
] = new_proto
;
717 st_gdata
->protos_registered
++;
718 new_proto
->write
= st_write
;
720 /* lock already held before entering else */
721 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
724 pr_debug("done %s(%d) ", __func__
, new_proto
->type
);
726 EXPORT_SYMBOL_GPL(st_register
);
728 /* to unregister a protocol -
729 * to be called from protocol stack driver
731 long st_unregister(enum proto_type type
)
734 unsigned long flags
= 0;
735 struct st_data_s
*st_gdata
;
737 pr_debug("%s: %d ", __func__
, type
);
739 st_kim_ref(&st_gdata
);
740 if (type
< ST_BT
|| type
>= ST_MAX
) {
741 pr_err(" protocol %d not supported", type
);
742 return -EPROTONOSUPPORT
;
745 spin_lock_irqsave(&st_gdata
->lock
, flags
);
747 if (st_gdata
->list
[type
] == NULL
) {
748 pr_err(" protocol %d not registered", type
);
749 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
750 return -EPROTONOSUPPORT
;
753 st_gdata
->protos_registered
--;
754 st_gdata
->list
[type
] = NULL
;
756 /* kim ignores BT in the below function
757 * and handles the rest, BT is toggled
758 * only in kim_start and kim_stop
760 st_kim_chip_toggle(type
, KIM_GPIO_INACTIVE
);
761 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
763 if ((st_gdata
->protos_registered
== ST_EMPTY
) &&
764 (!test_bit(ST_REG_PENDING
, &st_gdata
->st_state
))) {
765 pr_info(" all protocols unregistered ");
767 /* stop traffic on tty */
769 tty_ldisc_flush(st_gdata
->tty
);
770 stop_tty(st_gdata
->tty
);
773 /* all protocols now unregistered */
774 st_kim_stop(st_gdata
->kim_data
);
776 st_ll_disable(st_gdata
);
782 * called in protocol stack drivers
783 * via the write function pointer
785 long st_write(struct sk_buff
*skb
)
787 struct st_data_s
*st_gdata
;
789 enum proto_type protoid
= ST_MAX
;
793 st_kim_ref(&st_gdata
);
794 if (unlikely(skb
== NULL
|| st_gdata
== NULL
795 || st_gdata
->tty
== NULL
)) {
796 pr_err("data/tty unavailable to perform write");
799 #ifdef DEBUG /* open-up skb to read the 1st byte */
800 switch (skb
->data
[0]) {
801 case HCI_COMMAND_PKT
:
802 case HCI_ACLDATA_PKT
:
803 case HCI_SCODATA_PKT
:
813 if (unlikely(st_gdata
->list
[protoid
] == NULL
)) {
814 pr_err(" protocol %d not registered, and writing? ",
819 pr_debug("%d to be written", skb
->len
);
822 /* st_ll to decide where to enqueue the skb */
823 st_int_enqueue(st_gdata
, skb
);
825 st_tx_wakeup(st_gdata
);
827 /* return number of bytes written */
831 /* for protocols making use of shared transport */
832 EXPORT_SYMBOL_GPL(st_unregister
);
834 /********************************************************************/
836 * functions called from TTY layer
838 static int st_tty_open(struct tty_struct
*tty
)
841 struct st_data_s
*st_gdata
;
842 pr_info("%s ", __func__
);
844 st_kim_ref(&st_gdata
);
846 tty
->disc_data
= st_gdata
;
848 /* don't do an wakeup for now */
849 clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
851 /* mem already allocated
853 tty
->receive_room
= 65536;
854 /* Flush any pending characters in the driver and discipline. */
855 tty_ldisc_flush(tty
);
856 tty_driver_flush_buffer(tty
);
858 * signal to UIM via KIM that -
859 * installation of N_TI_WL ldisc is complete
861 st_kim_complete(st_gdata
->kim_data
);
862 pr_debug("done %s", __func__
);
866 static void st_tty_close(struct tty_struct
*tty
)
868 unsigned char i
= ST_MAX
;
869 unsigned long flags
= 0;
870 struct st_data_s
*st_gdata
= tty
->disc_data
;
872 pr_info("%s ", __func__
);
875 * if a protocol has been registered & line discipline
876 * un-installed for some reason - what should be done ?
878 spin_lock_irqsave(&st_gdata
->lock
, flags
);
879 for (i
= ST_BT
; i
< ST_MAX
; i
++) {
880 if (st_gdata
->list
[i
] != NULL
)
881 pr_err("%d not un-registered", i
);
882 st_gdata
->list
[i
] = NULL
;
884 st_gdata
->protos_registered
= 0;
885 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
887 * signal to UIM via KIM that -
888 * N_TI_WL ldisc is un-installed
890 st_kim_complete(st_gdata
->kim_data
);
891 st_gdata
->tty
= NULL
;
892 /* Flush any pending characters in the driver and discipline. */
893 tty_ldisc_flush(tty
);
894 tty_driver_flush_buffer(tty
);
896 spin_lock_irqsave(&st_gdata
->lock
, flags
);
897 /* empty out txq and tx_waitq */
898 skb_queue_purge(&st_gdata
->txq
);
899 skb_queue_purge(&st_gdata
->tx_waitq
);
900 /* reset the TTY Rx states of ST */
901 st_gdata
->rx_count
= 0;
902 st_gdata
->rx_state
= ST_W4_PACKET_TYPE
;
903 kfree_skb(st_gdata
->rx_skb
);
904 st_gdata
->rx_skb
= NULL
;
905 spin_unlock_irqrestore(&st_gdata
->lock
, flags
);
907 pr_debug("%s: done ", __func__
);
910 static void st_tty_receive(struct tty_struct
*tty
, const unsigned char *data
,
911 char *tty_flags
, int count
)
915 print_hex_dump(KERN_DEBUG
, ">in>", DUMP_PREFIX_NONE
,
916 16, 1, data
, count
, 0);
920 * if fw download is in progress then route incoming data
921 * to KIM for validation
923 st_recv(tty
->disc_data
, data
, count
);
924 pr_debug("done %s", __func__
);
927 /* wake-up function called in from the TTY layer
928 * inside the internal wakeup function will be called
930 static void st_tty_wakeup(struct tty_struct
*tty
)
932 struct st_data_s
*st_gdata
= tty
->disc_data
;
933 pr_debug("%s ", __func__
);
934 /* don't do an wakeup for now */
935 clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
937 /* call our internal wakeup */
938 st_tx_wakeup((void *)st_gdata
);
941 static void st_tty_flush_buffer(struct tty_struct
*tty
)
943 struct st_data_s
*st_gdata
= tty
->disc_data
;
944 pr_debug("%s ", __func__
);
946 kfree_skb(st_gdata
->tx_skb
);
947 st_gdata
->tx_skb
= NULL
;
949 tty
->ops
->flush_buffer(tty
);
953 /********************************************************************/
954 int st_core_init(struct st_data_s
**core_data
)
956 struct st_data_s
*st_gdata
;
958 static struct tty_ldisc_ops
*st_ldisc_ops
;
960 /* populate and register to TTY line discipline */
961 st_ldisc_ops
= kzalloc(sizeof(*st_ldisc_ops
), GFP_KERNEL
);
963 pr_err("no mem to allocate");
967 st_ldisc_ops
->magic
= TTY_LDISC_MAGIC
;
968 st_ldisc_ops
->name
= "n_st"; /*"n_hci"; */
969 st_ldisc_ops
->open
= st_tty_open
;
970 st_ldisc_ops
->close
= st_tty_close
;
971 st_ldisc_ops
->receive_buf
= st_tty_receive
;
972 st_ldisc_ops
->write_wakeup
= st_tty_wakeup
;
973 st_ldisc_ops
->flush_buffer
= st_tty_flush_buffer
;
974 st_ldisc_ops
->owner
= THIS_MODULE
;
976 err
= tty_register_ldisc(N_TI_WL
, st_ldisc_ops
);
978 pr_err("error registering %d line discipline %ld",
983 pr_debug("registered n_shared line discipline");
985 st_gdata
= kzalloc(sizeof(struct st_data_s
), GFP_KERNEL
);
987 pr_err("memory allocation failed");
988 err
= tty_unregister_ldisc(N_TI_WL
);
990 pr_err("unable to un-register ldisc %ld", err
);
996 /* Initialize ST TxQ and Tx waitQ queue head. All BT/FM/GPS module skb's
997 * will be pushed in this queue for actual transmission.
999 skb_queue_head_init(&st_gdata
->txq
);
1000 skb_queue_head_init(&st_gdata
->tx_waitq
);
1002 /* Locking used in st_int_enqueue() to avoid multiple execution */
1003 spin_lock_init(&st_gdata
->lock
);
1005 /* ldisc_ops ref to be only used in __exit of module */
1006 st_gdata
->ldisc_ops
= st_ldisc_ops
;
1009 err
= st_kim_init();
1011 pr_err("error during kim initialization(%ld)", err
);
1013 err
= tty_unregister_ldisc(N_TI_WL
);
1015 pr_err("unable to un-register ldisc");
1016 kfree(st_ldisc_ops
);
1021 err
= st_ll_init(st_gdata
);
1023 pr_err("error during st_ll initialization(%ld)", err
);
1025 err
= tty_unregister_ldisc(N_TI_WL
);
1027 pr_err("unable to un-register ldisc");
1028 kfree(st_ldisc_ops
);
1031 *core_data
= st_gdata
;
1035 void st_core_exit(struct st_data_s
*st_gdata
)
1038 /* internal module cleanup */
1039 err
= st_ll_deinit(st_gdata
);
1041 pr_err("error during deinit of ST LL %ld", err
);
1043 err
= st_kim_deinit();
1045 pr_err("error during deinit of ST KIM %ld", err
);
1047 if (st_gdata
!= NULL
) {
1048 /* Free ST Tx Qs and skbs */
1049 skb_queue_purge(&st_gdata
->txq
);
1050 skb_queue_purge(&st_gdata
->tx_waitq
);
1051 kfree_skb(st_gdata
->rx_skb
);
1052 kfree_skb(st_gdata
->tx_skb
);
1053 /* TTY ldisc cleanup */
1054 err
= tty_unregister_ldisc(N_TI_WL
);
1056 pr_err("unable to un-register ldisc %ld", err
);
1057 kfree(st_gdata
->ldisc_ops
);
1058 /* free the global data pointer */