New ldisc for WiLink7.0
Subsystems (2)
PATCH v3 1/1 New ldisc for WiLink7.0
Greg / Alan,
Moved to staging directory as suggested.
All the patches have been modified to now go into drivers/staging/
Quoted 12 lines
Texas Instruments has introduced it's new series of WiLink chipsets which has Bluetooth, WLAN, FM-Rx and FM-Tx and GPS on 1 single chip. This series of chipsets allow apps processor to interface with the chip over a single UART mux-ed for all 3 (BT,FM and GPS) cores on chip and SDIO for WLAN.
The following list of patches introduces a new line discipline which allows such muxing to happen, and 3 different BT, FM and GPS drivers would sit on top of this driver (registering/unregistering) and glue this to relevant s/w stacks.
This has been verified to work on TI's OMAP
platforms(34xx,36xx and 44xx).
PATCH 1/7 serial: TTY: new ldisc for TI BT/FM/GPS chips
From: Pavan Savoy <[email protected]>
A new N_TI_WL line discipline added for TI BT/FM/GPS combo chips which make use of same TTY to communicate with chip. This is to be made use of individual protocol BT/FM/GPS drivers.
--- include/linux/tty.h | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-)
include/linux/tty.h +2 -1
@@ -23,7 +23,7 @@*/ #define NR_UNIX98_PTY_DEFAULT 4096/* Default maximum for Unix98 ptys */ #define NR_UNIX98_PTY_MAX (1 << MINORBITS)/* Absolute limit */ -#define NR_LDISCS 20 +#define NR_LDISCS 21/* line disciplines */ #define N_TTY 0
@@ -48,6 +48,7 @@#define N_PPS 18/* Pulse per Second */ #define N_V253 19/* Codec control over voice modem */ +#define N_TI_WL 20/* for TI's WL connectivity chips */ /* * This character is the same as _POSIX_VDISABLE: it cannot be used as
Signature · 1 line
1.5.4.3
PATCH 2/7 drivers:staging: Kconfig, Makefile for TI's ST ldisc
From: Pavan Savoy <[email protected]>
This change adds the Kconfig and Make file for TI's ST line discipline driver and the BlueZ driver for BT core of the TI BT/FM/GPS combo chip.
--- drivers/staging/Kconfig | 2 ++ drivers/staging/Makefile | 1 + drivers/staging/ti-st/Kconfig | 24 ++++++++++++++++++++++++ drivers/staging/ti-st/Makefile | 7 +++++++ 4 files changed, 34 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/ti-st/Kconfig create mode 100644 drivers/staging/ti-st/Makefile
drivers/staging/Kconfig +2 -0
@@ -141,5 +141,7 @@ source "drivers/staging/dt3155/Kconfig" source "drivers/staging/crystalhd/Kconfig" +source "drivers/staging/ti-st/Kconfig" + endif # !STAGING_EXCLUDE_BUILD endif # STAGING
drivers/staging/Makefile +1 -0
@@ -52,3 +52,4 @@ obj-$(CONFIG_PCMCIA_NETWAVE) += netwave/ obj-$(CONFIG_FB_SM7XX) += sm7xx/ obj-$(CONFIG_DT3155) += dt3155/ obj-$(CONFIG_CRYSTALHD) += crystalhd/ +obj-$(CONFIG_TI_ST) += ti-st/
drivers/staging/ti-st/Kconfig new file +24 -0
@@ -0,0 +1,24 @@ +# +# TI's shared transport line discipline and the protocol +# drivers (BT, FM and GPS) +# +menu "Texas Instruments shared transport line discipline" +config TI_ST + tristate "shared transport core driver" + select FW_LOADER + help + This enables the shared transport core driver for TI + BT / FM and GPS combo chips. This enables protocol drivers + to register themselves with core and send data, the responses + are returned to relevant protocol drivers based on their + packet types. + +config ST_BT + tristate "BlueZ bluetooth driver for ST" + depends on BT + select TI_ST + help + This enables the Bluetooth driver for TI BT/FM/GPS combo devices. + This makes use of shared transport line discipline core driver to + communicate with the BT core of the combo chip. +endmenu
drivers/staging/ti-st/Makefile new file +7 -0
@@ -0,0 +1,7 @@ +# +# Makefile for TI's shared transport line discipline +# and its protocol drivers (BT, FM, GPS) +# +obj-$(CONFIG_TI_ST) += st_drv.o +st_drv-objs := st_core.o st_kim.o st_ll.o +obj-$(CONFIG_ST_BT) += bt_drv.o
Signature · 1 line
1.5.4.3
PATCH 3/7 drivers:staging: sources for ST core
From: Pavan Savoy <[email protected]>
Texas Instruments BT, FM and GPS combo chips/drivers make use of a single TTY to communicate with the chip. This module constitutes the core logic, TTY ldisc driver and the exported symbols for registering/unregistering of the protocol drivers such as BT/FM/GPS.
--- drivers/staging/ti-st/st_core.c | 1057 +++++++++++++++++++++++++++++++++++++++ drivers/staging/ti-st/st_core.h | 92 ++++ 2 files changed, 1149 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/ti-st/st_core.c create mode 100644 drivers/staging/ti-st/st_core.h
drivers/staging/ti-st/st_core.c new file +1057 -0
@@ -0,0 +1,1057 @@ +/* +* Shared Transport Line discipline driver Core +* This hooks up ST KIM driver and ST LL driver +* Copyright (C) 2009 Texas Instruments +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +*/ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/tty.h> + +/* understand BT, FM and GPS for now */ +#include <net/bluetooth/bluetooth.h> +#include <net/bluetooth/hci_core.h> +#include <net/bluetooth/hci.h> +#include "fm.h" +/* +* packet formats for fm and gps +* #include "gps.h" +*/ +#include "st_core.h" +#include "st_kim.h" +#include "st_ll.h" +#include "st.h" + +/* all debug macros go in here */ +#define ST_DRV_ERR(fmt, arg...) printk(KERN_ERR "(stc):"fmt"\n" , ## arg) +#if defined(DEBUG )/* limited debug messages */ +#define ST_DRV_DBG(fmt, arg...) printk(KERN_INFO "(stc):"fmt"\n" , ## arg) +#define ST_DRV_VER(fmt, arg...) +#elif defined(VERBOSE )/* very verbose */ +#define ST_DRV_DBG(fmt, arg...) printk(KERN_INFO "(stc):"fmt"\n" , ## arg) +#define ST_DRV_VER(fmt, arg...) printk(KERN_INFO "(stc):"fmt"\n" , ## arg) +#else /* error msgs only */ +#define ST_DRV_DBG(fmt, arg...) +#define ST_DRV_VER(fmt, arg...) +#endif + +#ifdef DEBUG +/* strings to be used for rfkill entries and by +* ST Core to be used for sysfs debug entry +*/ +#define PROTO_ENTRY (type, name) name +const unsigned char *protocol_strngs[] = { +PROTO_ENTRY (ST_BT ,"Bluetooth" ), +PROTO_ENTRY (ST_FM ,"FM" ), +PROTO_ENTRY (ST_GPS ,"GPS" ), +}; +#endif +/* +* local data instances +*/ +static struct st_data_s *st_gdata; +/* function pointer pointing to either, +* st_kim_recv during registration to receive fw download responses +* st_int_recv after registration to receive proto stack responses +*/ +void (*st_recv) (const unsigned char *data,long count); + +/********************************************************************/ +/* internal misc functions */ +bool is_protocol_list_empty (void ) +{ +unsigned char i =0 ; +ST_DRV_DBG (" %s " , __func__); +for (i =0 ; i <ST_MAX ; i++) { +if (st_gdata->list[i] !=NULL ) +return ST_NOTEMPTY ; +/* not empty */ + } +/* list empty */ +return ST_EMPTY ; +} + +/* can be called in from +* -- KIM (during fw download) +* -- ST Core (during st_write) +* +* This is the internal write function - a wrapper +* to tty->ops->write +*/ +int st_int_write (const unsigned char *data,int count) +{ +#ifdef VERBOSE /* for debug */ +int i; +#endif +struct tty_struct *tty; +if (unlikely (st_gdata ==NULL || st_gdata->tty ==NULL )) { +ST_DRV_ERR ("tty unavailable to perform write" ); +return ST_ERR_FAILURE ; + } + tty = st_gdata->tty; +#ifdef VERBOSE +printk (KERN_ERR "start data..\n" ); +for (i =0 ; i < count; i++)/* no newlines for each datum */ +printk (" %x" , data[i]); +printk (KERN_ERR "\n ..end data\n" ); +#endif + +return tty->ops->write (tty, data, count); + +} + +/* +* push the skb received to relevant +* protocol stacks +*/ +void st_send_frame (enum proto_type protoid,struct sk_buff *skb) +{ +ST_DRV_DBG (" %s(prot:%d) " , __func__, protoid); + +if (unlikely + (st_gdata ==NULL || skb ==NULL + || st_gdata->list[protoid] ==NULL )) { +ST_DRV_ERR ("protocol %d not registered, no data to send?" , + protoid); +kfree_skb (skb); +return ; + } +/* this cannot fail +* this shouldn't take long +* - should be just skb_queue_tail for the +* protocol stack driver +*/ +if (likely (st_gdata->list[protoid]->recv !=NULL )) { +if (unlikely (st_gdata->list[protoid]->recv (skb) + !=ST_SUCCESS )) { +ST_DRV_ERR (" proto stack %d's ->recv failed" , protoid); +kfree_skb (skb); +return ; + } + }else { +ST_DRV_ERR (" proto stack %d's ->recv null" , protoid); +kfree_skb (skb); + } +ST_DRV_DBG (" done %s" , __func__); +return ; +} + +/* +* to call registration complete callbacks +* of all protocol stack drivers +*/ +void st_reg_complete (char err) +{ +unsigned char i =0 ; +ST_DRV_DBG (" %s " , __func__); +for (i =0 ; i <ST_MAX ; i++) { +if (likely (st_gdata !=NULL && st_gdata->list[i] !=NULL && + st_gdata->list[i]->reg_complete_cb !=NULL )) + st_gdata->list[i]->reg_complete_cb (err); + } +} + +static inline int st_check_data_len (int protoid,int len) +{ + registerint room =skb_tailroom (st_gdata->rx_skb); + +ST_DRV_DBG ("len %d room %d" , len, room); + +if (!len) { +/* Received packet has only packet header and +* has zero length payload. So, ask ST CORE to +* forward the packet to protocol driver (BT/FM/GPS) +*/ +st_send_frame (protoid, st_gdata->rx_skb); + + }else if (len > room) { +/* Received packet's payload length is larger. +* We can't accommodate it in created skb. +*/ +ST_DRV_ERR ("Data length is too large len %d room %d" , len, + room); +kfree_skb (st_gdata->rx_skb); + }else { +/* Packet header has non-zero payload length and +* we have enough space in created skb. Lets read +* payload data */ + st_gdata->rx_state =ST_BT_W4_DATA ; + st_gdata->rx_count = len; +return len; + } + +/* Change ST state to continue to process next +* packet */ + st_gdata->rx_state =ST_W4_PACKET_TYPE ; + st_gdata->rx_skb =NULL ; + st_gdata->rx_count =0 ; + +return 0 ; +} + +/* internal function for action when wake-up ack +* received +*/ +static inline void st_wakeup_ack (unsigned char cmd) +{ + registerstruct sk_buff *waiting_skb; +unsigned long flags =0 ; + +spin_lock_irqsave (&st_gdata->lock, flags); +/* de-Q from waitQ and Q in txQ now that the +* chip is awake +*/ +while ((waiting_skb =skb_dequeue (&st_gdata->tx_waitq))) +skb_queue_tail (&st_gdata->txq, waiting_skb); + +/* state forwarded to ST LL */ +st_ll_sleep_state ((unsigned long )cmd); +spin_unlock_irqrestore (&st_gdata->lock, flags); + +/* wake up to send the recently copied skbs from waitQ */ +st_tx_wakeup (st_gdata); +} + +/* Decodes received RAW data and forwards to corresponding +* client drivers (Bluetooth,FM,GPS..etc). +* +*/ +void st_int_recv (const unsigned char *data,long count) +{ + registerchar *ptr; +struct hci_event_hdr *eh; +struct hci_acl_hdr *ah; +struct hci_sco_hdr *sh; +struct fm_event_hdr *fm; +struct gps_event_hdr *gps; + registerint len =0 , type =0 , dlen =0 ; +static enum proto_type protoid =ST_MAX ; + +ST_DRV_DBG ("count %ld rx_state %ld" +"rx_count %ld" , count, st_gdata->rx_state, + st_gdata->rx_count); + + ptr = (char *)data; +/* tty_receive sent null ? */ +if (unlikely (ptr ==NULL )) { +ST_DRV_ERR (" received null from TTY " ); +return ; + } + +/* Decode received bytes here */ +while (count) { +if (st_gdata->rx_count) { + len = min_t(unsigned int, st_gdata->rx_count, count); +memcpy (skb_put (st_gdata->rx_skb, len), ptr, len); + st_gdata->rx_count -= len; + count -= len; + ptr += len; + +if (st_gdata->rx_count) +continue ; + +/* Check ST RX state machine , where are we? */ +switch (st_gdata->rx_state) { + +/* Waiting for complete packet ? */ +case ST_BT_W4_DATA : +ST_DRV_DBG ("Complete pkt received" ); + +/* Ask ST CORE to forward +* the packet to protocol driver */ +st_send_frame (protoid, st_gdata->rx_skb); + + st_gdata->rx_state =ST_W4_PACKET_TYPE ; + st_gdata->rx_skb =NULL ; + protoid =ST_MAX ;/* is this required ? */ +continue ; + +/* Waiting for Bluetooth event header ? */ +case ST_BT_W4_EVENT_HDR : + eh = (struct hci_event_hdr *)st_gdata->rx_skb-> + data; + +ST_DRV_DBG ("Event header: evt 0x%2.2x" +"plen %d" , eh->evt, eh->plen); + +st_check_data_len (protoid, eh->plen); +continue ; + +/* Waiting for Bluetooth acl header ? */ +case ST_BT_W4_ACL_HDR : + ah = (struct hci_acl_hdr *)st_gdata->rx_skb-> + data; + dlen =__le16_to_cpu (ah->dlen); + +ST_DRV_DBG ("ACL header: dlen %d" , dlen); + +st_check_data_len (protoid, dlen); +continue ; + +/* Waiting for Bluetooth sco header ? */ +case ST_BT_W4_SCO_HDR : + sh = (struct hci_sco_hdr *)st_gdata->rx_skb-> + data; + +ST_DRV_DBG ("SCO header: dlen %d" , sh->dlen); + +st_check_data_len (protoid, sh->dlen); +continue ; +case ST_FM_W4_EVENT_HDR : + fm = (struct fm_event_hdr *)st_gdata->rx_skb-> + data; +ST_DRV_DBG ("FM Header: " ); +st_check_data_len (ST_FM , fm->plen); +continue ; +/* TODO : Add GPS packet machine logic here */ +case ST_GPS_W4_EVENT_HDR : +/* [0x09 pkt hdr][R/W byte][2 byte len] */ + gps = (struct gps_event_hdr *)st_gdata->rx_skb-> + data; +ST_DRV_DBG ("GPS Header: " ); +st_check_data_len (ST_GPS , gps->plen); +continue ; + }/* end of switch rx_state */ + } + +/* end of if rx_count */ +/* Check first byte of packet and identify module +* owner (BT/FM/GPS) */ +switch (*ptr) { + +/* Bluetooth event packet? */ +case HCI_EVENT_PKT : +ST_DRV_DBG ("Event packet" ); + st_gdata->rx_state =ST_BT_W4_EVENT_HDR ; + st_gdata->rx_count =HCI_EVENT_HDR_SIZE ; + type =HCI_EVENT_PKT ; + protoid =ST_BT ; +break ; + +/* Bluetooth acl packet? */ +case HCI_ACLDATA_PKT : +ST_DRV_DBG ("ACL packet" ); + st_gdata->rx_state =ST_BT_W4_ACL_HDR ; + st_gdata->rx_count =HCI_ACL_HDR_SIZE ; + type =HCI_ACLDATA_PKT ; + protoid =ST_BT ; +break ; + +/* Bluetooth sco packet? */ +case HCI_SCODATA_PKT : +ST_DRV_DBG ("SCO packet" ); + st_gdata->rx_state =ST_BT_W4_SCO_HDR ; + st_gdata->rx_count =HCI_SCO_HDR_SIZE ; + type =HCI_SCODATA_PKT ; + protoid =ST_BT ; +break ; + +/* Channel 8(FM) packet? */ +case ST_FM_CH8_PKT : +ST_DRV_DBG ("FM CH8 packet" ); + type =ST_FM_CH8_PKT ; + st_gdata->rx_state =ST_FM_W4_EVENT_HDR ; + st_gdata->rx_count =FM_EVENT_HDR_SIZE ; + protoid =ST_FM ; +break ; + +/* Channel 9(GPS) packet? */ +case 0x9 :/*ST_LL_GPS_CH9_PKT */ +ST_DRV_DBG ("GPS CH9 packet" ); + type =0x9 ;/* ST_LL_GPS_CH9_PKT; */ + protoid =ST_GPS ; + st_gdata->rx_state =ST_GPS_W4_EVENT_HDR ; + st_gdata->rx_count =3 ;/* GPS_EVENT_HDR_SIZE -1*/ +break ; +case LL_SLEEP_IND : +case LL_SLEEP_ACK : +case LL_WAKE_UP_IND : +/* this takes appropriate action based on +* sleep state received -- +*/ +st_ll_sleep_state (*ptr); + ptr++; + count--; +continue ; +case LL_WAKE_UP_ACK : +/* wake up ack received */ +st_wakeup_ack (*ptr); + ptr++; + count--; +continue ; +/* Unknow packet? */ +default : +ST_DRV_ERR ("Unknown packet type %2.2x" , (__u8) *ptr); + ptr++; + count--; +continue ; + }; + ptr++; + count--; + +switch (protoid) { +case ST_BT : +/* Allocate new packet to hold received data */ + st_gdata->rx_skb = +bt_skb_alloc (HCI_MAX_FRAME_SIZE ,GFP_ATOMIC ); +if (!st_gdata->rx_skb) { +ST_DRV_ERR ("Can't allocate mem for new packet" ); + st_gdata->rx_state =ST_W4_PACKET_TYPE ; + st_gdata->rx_count =0 ; +return ; + } +bt_cb (st_gdata->rx_skb)->pkt_type = type; +break ; +case ST_FM :/* for FM */ + st_gdata->rx_skb = +alloc_skb (FM_MAX_FRAME_SIZE ,GFP_ATOMIC ); +if (!st_gdata->rx_skb) { +ST_DRV_ERR ("Can't allocate mem for new packet" ); + st_gdata->rx_state =ST_W4_PACKET_TYPE ; + st_gdata->rx_count =0 ; +return ; + } +/* place holder 0x08 */ +skb_reserve (st_gdata->rx_skb,1 ); + st_gdata->rx_skb->cb[0 ] =ST_FM_CH8_PKT ; +break ; +case ST_GPS : +/* for GPS */ + st_gdata->rx_skb = +alloc_skb (100 /*GPS_MAX_FRAME_SIZE */ ,GFP_ATOMIC ); +if (!st_gdata->rx_skb) { +ST_DRV_ERR ("Can't allocate mem for new packet" ); + st_gdata->rx_state =ST_W4_PACKET_TYPE ; + st_gdata->rx_count =0 ; +return ; + } +/* place holder 0x09 */ +skb_reserve (st_gdata->rx_skb,1 ); + st_gdata->rx_skb->cb[0 ] =0x09 ;/*ST_GPS_CH9_PKT; */ +break ; +case ST_MAX : +break ; + } + } +ST_DRV_DBG ("done %s" , __func__); +return ; +} + +/* internal de-Q function +* -- return previous in-completely written skb +* or return the skb in the txQ +*/ +struct sk_buff *st_int_dequeue (struct st_data_s *st_data) +{ +struct sk_buff *returning_skb; + +ST_DRV_VER ("%s" , __func__); +/* if the previous skb wasn't written completely +*/ +if (st_gdata->tx_skb !=NULL ) { + returning_skb = st_gdata->tx_skb; + st_gdata->tx_skb =NULL ; +return returning_skb; + } + +/* de-Q from the txQ always if previous write is complete */ +return skb_dequeue (&st_gdata->txq); +} + +/* internal Q-ing function +* will either Q the skb to txq or the tx_waitq +* depending on the ST LL state +* +* lock the whole func - since ll_getstate and Q-ing should happen +* in one-shot +*/ +void st_int_enqueue (struct sk_buff *skb) +{ +unsigned long flags =0 ; + +ST_DRV_VER ("%s" , __func__); +/* this function can be invoked in more then one context. +* so have a lock */ +spin_lock_irqsave (&st_gdata->lock, flags); + +switch (st_ll_getstate ()) { +case ST_LL_AWAKE : +ST_DRV_DBG ("ST LL is AWAKE, sending normally" ); +skb_queue_tail (&st_gdata->txq, skb); +break ; +case ST_LL_ASLEEP_TO_AWAKE : +skb_queue_tail (&st_gdata->tx_waitq, skb); +break ; +case ST_LL_AWAKE_TO_ASLEEP :/* host cannot be in this state */ +ST_DRV_ERR ("ST LL is illegal state(%ld)," +"purging received skb." ,st_ll_getstate ()); +kfree_skb (skb); +break ; + +case ST_LL_ASLEEP : +/* call a function of ST LL to put data +* in tx_waitQ and wake_ind in txQ +*/ +skb_queue_tail (&st_gdata->tx_waitq, skb); +st_ll_wakeup (); +break ; +default : +ST_DRV_ERR ("ST LL is illegal state(%ld)," +"purging received skb." ,st_ll_getstate ()); +kfree_skb (skb); +break ; + } +spin_unlock_irqrestore (&st_gdata->lock, flags); +ST_DRV_VER ("done %s" , __func__); +return ; +} + +/* +* internal wakeup function +* called from either +* - TTY layer when write's finished +* - st_write (in context of the protocol stack) +*/ +void st_tx_wakeup (struct st_data_s *st_data) +{ +struct sk_buff *skb; +unsigned long flags;/* for irq save flags */ +ST_DRV_VER ("%s" , __func__); +/* check for sending & set flag sending here */ +if (test_and_set_bit (ST_TX_SENDING , &st_data->tx_state)) { +ST_DRV_DBG ("ST already sending" ); +/* keep sending */ +set_bit (ST_TX_WAKEUP , &st_data->tx_state); +return ; +/* TX_WAKEUP will be checked in another +* context +*/ + } +do {/* come back if st_tx_wakeup is set */ +/* woke-up to write */ +clear_bit (ST_TX_WAKEUP , &st_data->tx_state); +while ((skb =st_int_dequeue (st_data))) { +int len; +spin_lock_irqsave (&st_data->lock, flags); +/* enable wake-up from TTY */ +set_bit (TTY_DO_WRITE_WAKEUP , &st_data->tty->flags); + len =st_int_write (skb->data, skb->len); +skb_pull (skb, len); +/* if skb->len = len as expected, skb->len=0 */ +if (skb->len) { +/* would be the next skb to be sent */ + st_data->tx_skb = skb; +spin_unlock_irqrestore (&st_gdata->lock, flags); +break ; + } +kfree_skb (skb); +spin_unlock_irqrestore (&st_gdata->lock, flags); + } +/* if wake-up is set in another context- restart sending */ + }while (test_bit (ST_TX_WAKEUP , &st_data->tx_state)); + +/* clear flag sending */ +clear_bit (ST_TX_SENDING , &st_data->tx_state); +} + +/********************************************************************/ +/* functions called from ST KIM +*/ +void kim_st_list_protocols (char *buf) +{ +unsigned long flags =0 ; +#ifdef DEBUG +unsigned char i =ST_MAX ; +#endif +spin_lock_irqsave (&st_gdata->lock, flags); +#ifdef DEBUG /* more detailed log */ +for (i =0 ; i <ST_MAX ; i++) { +if (i ==0 ) { +sprintf (buf,"%s is %s" , protocol_strngs[i], + st_gdata->list[i] != +NULL ?"Registered" :"Unregistered" ); + }else { +sprintf (buf,"%s\n%s is %s" , buf, protocol_strngs[i], + st_gdata->list[i] != +NULL ?"Registered" :"Unregistered" ); + } + } +sprintf (buf,"%s\n" , buf); +#else /* limited info */ +sprintf (buf,"BT=%c\nFM=%c\nGPS=%c\n" , + st_gdata->list[ST_BT ] !=NULL ?'R' :'U' , + st_gdata->list[ST_FM ] !=NULL ?'R' :'U' , + st_gdata->list[ST_GPS ] !=NULL ?'R' :'U' ); +#endif +spin_unlock_irqrestore (&st_gdata->lock, flags); +} + +/********************************************************************/ +/* +* functions called from protocol stack drivers +* to be EXPORT-ed +*/ +long st_register (struct st_proto_s *new_proto) +{ +long err =ST_SUCCESS ; +unsigned long flags =0 ; + +ST_DRV_DBG ("%s(%d) " , __func__, new_proto->type); +if (st_gdata ==NULL || new_proto ==NULL || new_proto->recv ==NULL + || new_proto->reg_complete_cb ==NULL ) { +ST_DRV_ERR ("gdata/new_proto/recv or reg_complete_cb not ready" ); +return ST_ERR_FAILURE ; + } + +if (new_proto->type <ST_BT || new_proto->type >=ST_MAX ) { +ST_DRV_ERR ("protocol %d not supported" , new_proto->type); +return ST_ERR_NOPROTO ; + } + +if (st_gdata->list[new_proto->type] !=NULL ) { +ST_DRV_ERR ("protocol %d already registered" , new_proto->type); +return ST_ERR_ALREADY ; + } + +/* can be from process context only */ +spin_lock_irqsave (&st_gdata->lock, flags); + +if (test_bit (ST_REG_IN_PROGRESS , &st_gdata->st_state)) { +ST_DRV_DBG (" ST_REG_IN_PROGRESS:%d " , new_proto->type); +/* fw download in progress */ +st_kim_chip_toggle (new_proto->type,KIM_GPIO_ACTIVE ); + + st_gdata->list[new_proto->type] = new_proto; + new_proto->write = st_write; + +set_bit (ST_REG_PENDING , &st_gdata->st_state); +spin_unlock_irqrestore (&st_gdata->lock, flags); +return ST_ERR_PENDING ; + }else if (is_protocol_list_empty () ==ST_EMPTY ) { +ST_DRV_DBG (" protocol list empty :%d " , new_proto->type); +set_bit (ST_REG_IN_PROGRESS , &st_gdata->st_state); + st_recv = st_kim_recv; + +/* release lock previously held - re-locked below */ +spin_unlock_irqrestore (&st_gdata->lock, flags); + +/* enable the ST LL - to set default chip state */ +st_ll_enable (); +/* this may take a while to complete +* since it involves BT fw download +*/ + err =st_kim_start (); +if (err !=ST_SUCCESS ) { +clear_bit (ST_REG_IN_PROGRESS , &st_gdata->st_state); +if ((is_protocol_list_empty () !=ST_EMPTY ) && + (test_bit (ST_REG_PENDING , &st_gdata->st_state))) { +ST_DRV_ERR (" KIM failure complete callback " ); +st_reg_complete (ST_ERR_FAILURE ); + } + +return ST_ERR_FAILURE ; + } + +/* the protocol might require other gpios to be toggled +*/ +st_kim_chip_toggle (new_proto->type,KIM_GPIO_ACTIVE ); + +clear_bit (ST_REG_IN_PROGRESS , &st_gdata->st_state); + st_recv = st_int_recv; + +/* this is where all pending registration +* are signalled to be complete by calling callback functions +*/ +if ((is_protocol_list_empty () !=ST_EMPTY ) && + (test_bit (ST_REG_PENDING , &st_gdata->st_state))) { +ST_DRV_VER (" call reg complete callback " ); +st_reg_complete (ST_SUCCESS ); + } +clear_bit (ST_REG_PENDING , &st_gdata->st_state); + +/* check for already registered once more, +* since the above check is old +*/ +if (st_gdata->list[new_proto->type] !=NULL ) { +ST_DRV_ERR (" proto %d already registered " , + new_proto->type); +return ST_ERR_ALREADY ; + } + +spin_lock_irqsave (&st_gdata->lock, flags); + st_gdata->list[new_proto->type] = new_proto; + new_proto->write = st_write; +spin_unlock_irqrestore (&st_gdata->lock, flags); +return err; + } +/* if fw is already downloaded & new stack registers protocol */ +else { +switch (new_proto->type) { +case ST_BT : +/* do nothing */ +break ; +case ST_FM : +case ST_GPS : +st_kim_chip_toggle (new_proto->type,KIM_GPIO_ACTIVE ); +break ; +case ST_MAX : +default : +ST_DRV_ERR ("%d protocol not supported" , + new_proto->type); + err =ST_ERR_NOPROTO ; +/* something wrong */ +break ; + } + st_gdata->list[new_proto->type] = new_proto; + new_proto->write = st_write; + +/* lock already held before entering else */ +spin_unlock_irqrestore (&st_gdata->lock, flags); +return err; + } +ST_DRV_DBG ("done %s(%d) " , __func__, new_proto->type); +} +EXPORT_SYMBOL_GPL (st_register); + +/* to unregister a protocol - +* to be called from protocol stack driver +*/ +long st_unregister (enum proto_type type) +{ +long err =ST_SUCCESS ; +unsigned long flags =0 ; + +ST_DRV_DBG ("%s: %d " , __func__, type); + +if (type <ST_BT || type >=ST_MAX ) { +ST_DRV_ERR (" protocol %d not supported" , type); +return ST_ERR_NOPROTO ; + } + +spin_lock_irqsave (&st_gdata->lock, flags); + +if (st_gdata->list[type] ==NULL ) { +ST_DRV_ERR (" protocol %d not registered" , type); +spin_unlock_irqrestore (&st_gdata->lock, flags); +return ST_ERR_NOPROTO ; + } + + st_gdata->list[type] =NULL ; + +/* kim ignores BT in the below function +* and handles the rest, BT is toggled +* only in kim_start and kim_stop +*/ +st_kim_chip_toggle (type,KIM_GPIO_INACTIVE ); +spin_unlock_irqrestore (&st_gdata->lock, flags); + +if ((is_protocol_list_empty () ==ST_EMPTY ) && + (!test_bit (ST_REG_PENDING , &st_gdata->st_state))) { +ST_DRV_DBG (" all protocols unregistered " ); + +/* stop traffic on tty */ +if (st_gdata->tty) { +tty_ldisc_flush (st_gdata->tty); +stop_tty (st_gdata->tty); + } + +/* all protocols now unregistered */ +st_kim_stop (); +/* disable ST LL */ +st_ll_disable (); + } +return err; +} + +/* +* called in protocol stack drivers +* via the write function pointer +*/ +long st_write (struct sk_buff *skb) +{ +#ifdef DEBUG +enum proto_type protoid =ST_MAX ; +#endif +long len; +struct st_data_s *st_data = st_gdata; + +if (unlikely (skb ==NULL || st_gdata ==NULL + || st_gdata->tty ==NULL )) { +ST_DRV_ERR ("data/tty unavailable to perform write" ); +return ST_ERR_FAILURE ; + } +#ifdef DEBUG /* open-up skb to read the 1st byte */ +switch (skb->data[0 ]) { +case HCI_COMMAND_PKT : +case HCI_ACLDATA_PKT : +case HCI_SCODATA_PKT : + protoid =ST_BT ; +break ; +case ST_FM_CH8_PKT : + protoid =ST_FM ; +break ; +case 0x09 : + protoid =ST_GPS ; +break ; + } +if (unlikely (st_gdata->list[protoid] ==NULL )) { +ST_DRV_ERR (" protocol %d not registered, and writing? " , + protoid); +return ST_ERR_FAILURE ; + } +#endif +ST_DRV_DBG ("%d to be written" , skb->len); + len = skb->len; + +/* st_ll to decide where to enqueue the skb */ +st_int_enqueue (skb); +/* wake up */ +st_tx_wakeup (st_data); + +/* return number of bytes written */ +return len; +} + +/* for protocols making use of shared transport */ +EXPORT_SYMBOL_GPL (st_unregister); + +/********************************************************************/ +/* +* functions called from TTY layer +*/ +static int st_tty_open (struct tty_struct *tty) +{ +int err =ST_SUCCESS ; +ST_DRV_DBG ("%s " , __func__); + + st_gdata->tty = tty; + +/* don't do an wakeup for now */ +clear_bit (TTY_DO_WRITE_WAKEUP , &tty->flags); + +/* mem already allocated +*/ + tty->receive_room =65536 ; +/* Flush any pending characters in the driver and discipline. */ +tty_ldisc_flush (tty); +tty_driver_flush_buffer (tty); +/* +* signal to UIM via KIM that - +* installation of N_TI_WL ldisc is complete +*/ +st_kim_complete (); +ST_DRV_DBG ("done %s" , __func__); +return err; +} + +static void st_tty_close (struct tty_struct *tty) +{ +unsigned char i =ST_MAX ; +unsigned long flags =0 ; + +ST_DRV_DBG ("%s " , __func__); + +/* TODO: +* if a protocol has been registered & line discipline +* un-installed for some reason - what should be done ? +*/ +spin_lock_irqsave (&st_gdata->lock, flags); +for (i =ST_BT ; i <ST_MAX ; i++) { +if (st_gdata->list[i] !=NULL ) +ST_DRV_ERR ("%d not un-registered" , i); + st_gdata->list[i] =NULL ; + } +spin_unlock_irqrestore (&st_gdata->lock, flags); +/* +* signal to UIM via KIM that - +* N_TI_WL ldisc is un-installed +*/ +st_kim_complete (); + st_gdata->tty =NULL ; +/* Flush any pending characters in the driver and discipline. */ +tty_ldisc_flush (tty); +tty_driver_flush_buffer (tty); + +spin_lock_irqsave (&st_gdata->lock, flags); +/* empty out txq and tx_waitq */ +skb_queue_purge (&st_gdata->txq); +skb_queue_purge (&st_gdata->tx_waitq); +/* reset the TTY Rx states of ST */ + st_gdata->rx_count =0 ; + st_gdata->rx_state =ST_W4_PACKET_TYPE ; +kfree_skb (st_gdata->rx_skb); + st_gdata->rx_skb =NULL ; +spin_unlock_irqrestore (&st_gdata->lock, flags); + +ST_DRV_DBG ("%s: done " , __func__); +} + +static void st_tty_receive (struct tty_struct *tty,const unsigned char *data, +char *tty_flags,int count) +{ +#ifdef VERBOSE +long i; +printk (KERN_ERR "incoming data...\n" ); +for (i =0 ; i < count; i++) +printk (" %x" , data[i]); +printk (KERN_ERR "\n.. data end\n" ); +#endif + +/* +* if fw download is in progress then route incoming data +* to KIM for validation +*/ +st_recv (data, count); +ST_DRV_VER ("done %s" , __func__); +} + +/* wake-up function called in from the TTY layer +* inside the internal wakeup function will be called +*/ +static void st_tty_wakeup (struct tty_struct *tty) +{ +ST_DRV_DBG ("%s " , __func__); +/* don't do an wakeup for now */ +clear_bit (TTY_DO_WRITE_WAKEUP , &tty->flags); + +/* call our internal wakeup */ +st_tx_wakeup ((void *)st_gdata); +} + +static void st_tty_flush_buffer (struct tty_struct *tty) +{ +ST_DRV_DBG ("%s " , __func__); + +kfree_skb (st_gdata->tx_skb); + st_gdata->tx_skb =NULL ; + + tty->ops->flush_buffer (tty); +return ; +} + +/********************************************************************/ +static int __init st_core_init (void ) +{ +long err; +static struct tty_ldisc_ops *st_ldisc_ops; + +/* populate and register to TTY line discipline */ + st_ldisc_ops =kzalloc (sizeof (*st_ldisc_ops),GFP_KERNEL ); +if (!st_ldisc_ops) { +ST_DRV_ERR ("no mem to allocate" ); +return -ENOMEM ; + } + + st_ldisc_ops->magic =TTY_LDISC_MAGIC ; + st_ldisc_ops->name ="n_st" ;/*"n_hci"; */ + st_ldisc_ops->open = st_tty_open; + st_ldisc_ops->close = st_tty_close; + st_ldisc_ops->receive_buf = st_tty_receive; + st_ldisc_ops->write_wakeup = st_tty_wakeup; + st_ldisc_ops->flush_buffer = st_tty_flush_buffer; + st_ldisc_ops->owner =THIS_MODULE ; + + err =tty_register_ldisc (N_TI_WL , st_ldisc_ops); +if (err) { +ST_DRV_ERR ("error registering %d line discipline %ld" , +N_TI_WL , err); +kfree (st_ldisc_ops); +return err; + } +ST_DRV_DBG ("registered n_shared line discipline" ); + + st_gdata =kzalloc (sizeof (struct st_data_s ),GFP_KERNEL ); +if (!st_gdata) { +ST_DRV_ERR ("memory allocation failed" ); + err =tty_unregister_ldisc (N_TI_WL ); +if (err) +ST_DRV_ERR ("unable to un-register ldisc %ld" , err); +kfree (st_ldisc_ops); + err = -ENOMEM ; +return err; + } + +/* Initialize ST TxQ and Tx waitQ queue head. All BT/FM/GPS module skb's +* will be pushed in this queue for actual transmission. +*/ +skb_queue_head_init (&st_gdata->txq); +skb_queue_head_init (&st_gdata->tx_waitq); + +/* Locking used in st_int_enqueue() to avoid multiple execution */ +spin_lock_init (&st_gdata->lock); + +/* ldisc_ops ref to be only used in __exit of module */ + st_gdata->ldisc_ops = st_ldisc_ops; + + err =st_kim_init (); +if (err) { +ST_DRV_ERR ("error during kim initialization(%ld)" , err); +kfree (st_gdata); + err =tty_unregister_ldisc (N_TI_WL ); +if (err) +ST_DRV_ERR ("unable to un-register ldisc" ); +kfree (st_ldisc_ops); +return -1 ; + } + + err =st_ll_init (); +if (err) { +ST_DRV_ERR ("error during st_ll initialization(%ld)" , err); + err =st_kim_deinit (); +kfree (st_gdata); + err =tty_unregister_ldisc (N_TI_WL ); +if (err) +ST_DRV_ERR ("unable to un-register ldisc" ); +kfree (st_ldisc_ops); +return -1 ; + } +return 0 ; +} + +static void __exit st_core_exit(void) +{ +long err; +/* internal module cleanup */ + err =st_ll_deinit (); +if (err) +ST_DRV_ERR ("error during deinit of ST LL %ld" , err); + err =st_kim_deinit (); +if (err) +ST_DRV_ERR ("error during deinit of ST KIM %ld" , err); + +if (st_gdata !=NULL ) { +/* Free ST Tx Qs and skbs */ +skb_queue_purge (&st_gdata->txq); +skb_queue_purge (&st_gdata->tx_waitq); +kfree_skb (st_gdata->rx_skb); +kfree_skb (st_gdata->tx_skb); +/* TTY ldisc cleanup */ + err =tty_unregister_ldisc (N_TI_WL ); +if (err) +ST_DRV_ERR ("unable to un-register ldisc %ld" , err); +kfree (st_gdata->ldisc_ops); +/* free the global data pointer */ +kfree (st_gdata); + } +} + +module_init (st_core_init); +module_exit (st_core_exit); +MODULE_AUTHOR ("Pavan Savoy <[email protected]>" ); +MODULE_DESCRIPTION ("Shared Transport Driver for TI BT/FM/GPS combo chips " ); +MODULE_LICENSE ("GPL" );
drivers/staging/ti-st/st_core.h new file +92 -0
92 lines not on this page · raw message
Signature · 1 line
1.5.4.3
PATCH 4/7 drivers:staging: sources for Init manager module
From: Pavan Savoy <[email protected]>
Kernel Space Init-Manager works along with User-Mode Init Manager daemon running to maintain the UART state. It also is a platform driver with a relevant platform device in the board-*.c along with the list of BT/FM/GPS chip enable gpio configuration
--- drivers/staging/ti-st/st_kim.c | 717 ++++++++++++++++++++++++++++++++++++++++ drivers/staging/ti-st/st_kim.h | 151 +++++++++ 2 files changed, 868 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/ti-st/st_kim.c create mode 100644 drivers/staging/ti-st/st_kim.h
drivers/staging/ti-st/st_kim.c new file +717 -0
@@ -0,0 +1,717 @@ +/* +* Shared Transport Line discipline driver Core +* Init Manager module responsible for GPIO control +* and firmware download +* Copyright (C) 2009 Texas Instruments +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +*/ + +#include <linux/platform_device.h> +#include <linux/jiffies.h> +#include <linux/firmware.h> +#include <linux/delay.h> +#include <linux/wait.h> +#include <linux/gpio.h> + +#include <linux/sched.h> + +#include "st_kim.h" +/* understand BT events for fw response */ +#include <net/bluetooth/bluetooth.h> +#include <net/bluetooth/hci_core.h> +#include <net/bluetooth/hci.h> + +/* all debug macros go in here */ +#define ST_KIM_ERR(fmt, arg...) printk(KERN_ERR "(stk):"fmt"\n" , ## arg) +#if defined(DEBUG )/* limited debug messages */ +#define ST_KIM_DBG(fmt, arg...) printk(KERN_INFO "(stk):"fmt"\n" , ## arg) +#define ST_KIM_VER(fmt, arg...) +#elif defined(VERBOSE )/* very verbose */ +#define ST_KIM_DBG(fmt, arg...) printk(KERN_INFO "(stk):"fmt"\n" , ## arg) +#define ST_KIM_VER(fmt, arg...) printk(KERN_INFO "(stk):"fmt"\n" , ## arg) +#else /* error msgs only */ +#define ST_KIM_DBG(fmt, arg...) +#define ST_KIM_VER(fmt, arg...) +#endif + +static int kim_probe (struct platform_device *pdev); +static int kim_remove (struct platform_device *pdev); +static ssize_t show_pid (struct device *dev,struct device_attribute + *attr,char *buf); +static ssize_t store_pid (struct device *dev,struct device_attribute + *devattr,char *buf,size_t count); +static ssize_t show_list (struct device *dev,struct device_attribute + *attr,char *buf); +/* KIM platform device driver structure */ +static struct platform_driver kim_platform_driver = { + .probe = kim_probe, + .remove = kim_remove, +/* TODO: ST driver power management during suspend/resume ? +*/ +#if 0 + .suspend = kim_suspend, + .resume = kim_resume, +#endif + .driver = { + .name ="kim" , + .owner =THIS_MODULE , + }, +}; + +/* structures specific for sysfs entries */ +static struct kobj_attribute pid_attr = +__ATTR (pid,0644 , (void *)show_pid, (void *)store_pid); + +static struct kobj_attribute list_protocols = +__ATTR (protocols,0444 , (void *)show_list,NULL ); + +static struct attribute *uim_attrs[] = { + &pid_attr.attr, +/* add more debug sysfs entries */ + &list_protocols.attr, +NULL , +}; + +static struct attribute_group uim_attr_grp = { + .attrs = uim_attrs, +}; + +/* strings to be used for rfkill entries and by +* ST Core to be used for sysfs debug entry +*/ +#define PROTO_ENTRY (type, name) name +const unsigned char *protocol_names[] = { +PROTO_ENTRY (ST_BT ,"Bluetooth" ), +PROTO_ENTRY (ST_FM ,"FM" ), +PROTO_ENTRY (ST_GPS ,"GPS" ), +}; +static int kim_toggle_radio (void *,bool ); +static const struct rfkill_ops kim_rfkill_ops = { + .set_block = kim_toggle_radio, +}; + +static struct kim_data_s *kim_gdata; + +/**********************************************************************/ +/* internal functions */ + +/* +* function to return whether the firmware response was proper +* in case of error don't complete so that waiting for proper +* response times out +*/ +void validate_firmware_response (struct sk_buff *skb) +{ +if (unlikely (skb->data[5 ] !=0 )) { +ST_KIM_ERR ("no proper response during fw download" ); +ST_KIM_ERR ("data6 %x" , skb->data[5 ]); +return ;/* keep waiting for the proper response */ + } +/* becos of all the script being downloaded */ +complete_all (&kim_gdata->kim_rcvd); +kfree_skb (skb); +} + +/* check for data len received inside kim_int_recv +* most often hit the last case to update state to waiting for data +*/ +static inline int kim_check_data_len (int len) +{ + registerint room =skb_tailroom (kim_gdata->rx_skb); + +ST_KIM_DBG ("len %d room %d" , len, room); + +if (!len) { +validate_firmware_response (kim_gdata->rx_skb); + }else if (len > room) { +/* Received packet's payload length is larger. +* We can't accommodate it in created skb. +*/ +ST_KIM_ERR ("Data length is too large len %d room %d" , len, + room); +kfree_skb (kim_gdata->rx_skb); + }else { +/* Packet header has non-zero payload length and +* we have enough space in created skb. Lets read +* payload data */ + kim_gdata->rx_state =ST_BT_W4_DATA ; + kim_gdata->rx_count = len; +return len; + } + +/* Change ST LL state to continue to process next +* packet */ + kim_gdata->rx_state =ST_W4_PACKET_TYPE ; + kim_gdata->rx_skb =NULL ; + kim_gdata->rx_count =0 ; + +return 0 ; +} + +/* receive function called during firmware download +* - firmware download responses on different UART drivers +* have been observed to come in bursts of different +* tty_receive and hence the logic +*/ +void kim_int_recv (const unsigned char *data,long count) +{ + registerchar *ptr; +struct hci_event_hdr *eh; + registerint len =0 , type =0 ; + +ST_KIM_DBG ("%s" , __func__); +/* Decode received bytes here */ + ptr = (char *)data; +if (unlikely (ptr ==NULL )) { +ST_KIM_ERR (" received null from TTY " ); +return ; + } +while (count) { +if (kim_gdata->rx_count) { + len = min_t(unsigned int, kim_gdata->rx_count, count); +memcpy (skb_put (kim_gdata->rx_skb, len), ptr, len); + kim_gdata->rx_count -= len; + count -= len; + ptr += len; + +if (kim_gdata->rx_count) +continue ; + +/* Check ST RX state machine , where are we? */ +switch (kim_gdata->rx_state) { +/* Waiting for complete packet ? */ +case ST_BT_W4_DATA : +ST_KIM_DBG ("Complete pkt received" ); +validate_firmware_response (kim_gdata->rx_skb); + kim_gdata->rx_state =ST_W4_PACKET_TYPE ; + kim_gdata->rx_skb =NULL ; +continue ; +/* Waiting for Bluetooth event header ? */ +case ST_BT_W4_EVENT_HDR : + eh = (struct hci_event_hdr *)kim_gdata-> + rx_skb->data; +ST_KIM_DBG ("Event header: evt 0x%2.2x" +"plen %d" , eh->evt, eh->plen); +kim_check_data_len (eh->plen); +continue ; + }/* end of switch */ + }/* end of if rx_state */ +switch (*ptr) { +/* Bluetooth event packet? */ +case HCI_EVENT_PKT : +ST_KIM_DBG ("Event packet" ); + kim_gdata->rx_state =ST_BT_W4_EVENT_HDR ; + kim_gdata->rx_count =HCI_EVENT_HDR_SIZE ; + type =HCI_EVENT_PKT ; +break ; +default : +ST_KIM_DBG ("unknown packet" ); + ptr++; + count--; +continue ; + }/* end of switch *ptr */ + ptr++; + count--; + kim_gdata->rx_skb = +bt_skb_alloc (HCI_MAX_FRAME_SIZE ,GFP_ATOMIC ); +if (!kim_gdata->rx_skb) { +ST_KIM_ERR ("can't allocate mem for new packet" ); + kim_gdata->rx_state =ST_W4_PACKET_TYPE ; + kim_gdata->rx_count =0 ; +return ; + }/* not necessary in this case */ +bt_cb (kim_gdata->rx_skb)->pkt_type = type; + }/* end of while count */ +ST_KIM_DBG ("done %s" , __func__); +return ; +} + +static long read_local_version (char *bts_scr_name) +{ +unsigned short version =0 , chip =0 , min_ver =0 , maj_ver =0 ; +char read_ver_cmd[] = {0x01 ,0x01 ,0x10 ,0x00 }; + +ST_KIM_DBG ("%s" , __func__); + +INIT_COMPLETION (kim_gdata->kim_rcvd); +if (4 !=st_int_write (read_ver_cmd,4 )) { +ST_KIM_ERR ("kim: couldn't write 4 bytes" ); +return ST_ERR_FAILURE ; + } + +if (!wait_for_completion_timeout + (&kim_gdata->kim_rcvd,msecs_to_jiffies (CMD_RESP_TIME ))) { +ST_KIM_ERR (" waiting for ver info- timed out " ); +return ST_ERR_FAILURE ; + } + + version = +MAKEWORD (kim_gdata->resp_buffer[13 ], kim_gdata->resp_buffer[14 ]); + chip = (version &0x7C00 ) >>10 ; + min_ver = (version &0x007F ); + maj_ver = (version &0x0380 ) >>7 ; + +if (version &0x8000 ) + maj_ver |=0x0008 ; + +sprintf (bts_scr_name,"TIInit_%d.%d.%d.bts" , chip, maj_ver, min_ver); +ST_KIM_DBG ("%s" , bts_scr_name); +return ST_SUCCESS ; +} + +/* internal function which parses through the .bts firmware script file +* intreprets SEND, DELAY actions only as of now +*/ +static long download_firmware (void ) +{ +long err =ST_SUCCESS ; +long len =0 ; + registerunsigned char *ptr =NULL ; + registerunsigned char *action_ptr =NULL ; +unsigned char bts_scr_name[30 ] = {0 };/* 30 char long bts scr name? */ + +ST_KIM_VER ("%s" , __func__); + + err =read_local_version (bts_scr_name); +if (err !=ST_SUCCESS ) { +ST_KIM_ERR ("kim: failed to read local ver" ); +return err; + } + err = +request_firmware (&kim_gdata->fw_entry, bts_scr_name, + &kim_gdata->kim_pdev->dev); +if (unlikely ((err !=0 ) || (kim_gdata->fw_entry->data ==NULL ) || + (kim_gdata->fw_entry->size ==0 ))) { +ST_KIM_ERR (" request_firmware failed(errno %ld) for %s" , err, + bts_scr_name); +return ST_ERR_FAILURE ; + } + ptr = (void *)kim_gdata->fw_entry->data; + len = kim_gdata->fw_entry->size; +/* bts_header to remove out magic number and +* version +*/ + ptr +=sizeof (struct bts_header ); + len -=sizeof (struct bts_header ); + +while (len >0 && ptr) { +ST_KIM_VER (" action size %d, type %d " , + ((struct bts_action *)ptr)->size, + ((struct bts_action *)ptr)->type); + +switch (((struct bts_action *)ptr)->type) { +case ACTION_SEND_COMMAND :/* action send */ + action_ptr = &(((struct bts_action *)ptr)->data[0 ]); +if (unlikely + (((struct hci_command *)action_ptr)->opcode == +0xFF36 )) { +/* ignore remote change +* baud rate HCI VS command */ +ST_KIM_ERR + (" change remote baud\ +rate command in firmware" ); +break ; + } + +INIT_COMPLETION (kim_gdata->kim_rcvd); + err =st_int_write (((struct bts_action_send *) + action_ptr)->data, + ((struct bts_action *)ptr)->size); +if (unlikely (err <0 )) { +release_firmware (kim_gdata->fw_entry); +return ST_ERR_FAILURE ; + } +if (!wait_for_completion_timeout + (&kim_gdata->kim_rcvd, +msecs_to_jiffies (CMD_RESP_TIME ))) { +ST_KIM_ERR + (" response timeout during fw download " ); +/* timed out */ +release_firmware (kim_gdata->fw_entry); +return ST_ERR_FAILURE ; + } +break ; +case ACTION_DELAY :/* sleep */ +ST_KIM_DBG ("sleep command in scr" ); + action_ptr = &(((struct bts_action *)ptr)->data[0 ]); +mdelay (((struct bts_action_delay *)action_ptr)->msec); +break ; + } + len = + len - (sizeof (struct bts_action ) + + ((struct bts_action *)ptr)->size); + ptr = + ptr +sizeof (struct bts_action ) + + ((struct bts_action *)ptr)->size; + } +/* fw download complete */ +release_firmware (kim_gdata->fw_entry); +return ST_SUCCESS ; +} + +/**********************************************************************/ +/* functions called from ST core */ + +/* function to toggle the GPIO +* needs to know whether the GPIO is active high or active low +*/ +void st_kim_chip_toggle (enum proto_type type,enum kim_gpio_state state) +{ +ST_KIM_DBG (" %s " , __func__); + +if (kim_gdata->gpios[type] ==-1 ) { +ST_KIM_DBG (" gpio not requested for protocol %s" , + protocol_names[type]); +return ; + } +switch (type) { +case ST_BT : +/*Do Nothing */ +break ; + +case ST_FM : +if (state ==KIM_GPIO_ACTIVE ) +gpio_set_value (kim_gdata->gpios[ST_FM ],GPIO_LOW ); +else +gpio_set_value (kim_gdata->gpios[ST_FM ],GPIO_HIGH ); +break ; + +case ST_GPS : +if (state ==KIM_GPIO_ACTIVE ) +gpio_set_value (kim_gdata->gpios[ST_GPS ],GPIO_HIGH ); +else +gpio_set_value (kim_gdata->gpios[ST_GPS ],GPIO_LOW ); +break ; + +case ST_MAX : +default : +break ; + } + +return ; +} + +/* called from ST Core, when REG_IN_PROGRESS (registration in progress) +* can be because of +* 1. response to read local version +* 2. during send/recv's of firmware download +*/ +void st_kim_recv (const unsigned char *data,long count) +{ +ST_KIM_DBG (" %s " , __func__); +/* copy to local buffer */ +if (unlikely (data[4 ] ==0x01 && data[5 ] ==0x10 && data[0 ] ==0x04 )) { +/* must be the read_ver_cmd */ +memcpy (kim_gdata->resp_buffer, data, count); +complete_all (&kim_gdata->kim_rcvd); +return ; + }else { +kim_int_recv (data, count); +/* either completes or times out */ + } +return ; +} + +/* to signal completion of line discipline installation +* called from ST Core, upon tty_open +*/ +void st_kim_complete (void ) +{ +complete (&kim_gdata->ldisc_installed); +} + +/* called from ST Core upon 1st registration +*/ +long st_kim_start (void ) +{ +long err =ST_SUCCESS ; +long retry =POR_RETRY_COUNT ; +ST_KIM_DBG (" %s" , __func__); + +do { +/* Configure BT nShutdown to HIGH state */ +gpio_set_value (kim_gdata->gpios[ST_BT ],GPIO_LOW ); +mdelay (5 );/* FIXME: a proper toggle */ +gpio_set_value (kim_gdata->gpios[ST_BT ],GPIO_HIGH ); +mdelay (100 ); + +/* re-initialize the completion */ +INIT_COMPLETION (kim_gdata->ldisc_installed); +/* send signal to UIM */ + err =kill_pid (find_get_pid (kim_gdata->uim_pid),SIGUSR2 ,0 ); +if (err !=0 ) { +ST_KIM_VER (" sending SIGUSR2 to uim failed %ld" , err); + err =ST_ERR_FAILURE ; +continue ; + } +/* wait for ldisc to be installed */ + err =wait_for_completion_timeout (&kim_gdata->ldisc_installed, +msecs_to_jiffies (LDISC_TIME )); +if (!err) {/* timeout */ +ST_KIM_ERR ("line disc installation timed out " ); + err =ST_ERR_FAILURE ; +continue ; + }else { +/* ldisc installed now */ +ST_KIM_DBG (" line discipline installed " ); + err =download_firmware (); +if (err !=ST_SUCCESS ) { +ST_KIM_ERR ("download firmware failed" ); +continue ; + }else {/* on success don't retry */ +break ; + } + } + }while (retry--); +return err; +} + +/* called from ST Core, on the last un-registration +*/ +long st_kim_stop (void ) +{ +long err =ST_SUCCESS ; + +INIT_COMPLETION (kim_gdata->ldisc_installed); +/* send signal to UIM */ + err =kill_pid (find_get_pid (kim_gdata->uim_pid),SIGUSR2 ,1 ); +if (err !=0 ) { +ST_KIM_ERR ("sending SIGUSR2 to uim failed %ld" , err); +return ST_ERR_FAILURE ; + } + +/* wait for ldisc to be un-installed */ + err =wait_for_completion_timeout (&kim_gdata->ldisc_installed, +msecs_to_jiffies (LDISC_TIME )); +if (!err) {/* timeout */ +ST_KIM_ERR (" timed out waiting for ldisc to be un-installed" ); +return ST_ERR_FAILURE ; + } + +/* By default configure BT nShutdown to LOW state */ +gpio_set_value (kim_gdata->gpios[ST_BT ],GPIO_LOW ); +mdelay (1 ); +gpio_set_value (kim_gdata->gpios[ST_BT ],GPIO_HIGH ); +mdelay (1 ); +gpio_set_value (kim_gdata->gpios[ST_BT ],GPIO_LOW ); +return err; +} + +/**********************************************************************/ +/* functions called from subsystems */ + +/* called when sysfs entry is written to */ +static ssize_t store_pid (struct device *dev,struct device_attribute + *devattr,char *buf,size_t count) +{ +ST_KIM_DBG ("%s: pid %s " , __func__, buf); +sscanf (buf,"%ld" , &kim_gdata->uim_pid); +/* to be made use by kim_start to signal SIGUSR2 +*/ +return strlen (buf); +} + +/* called when sysfs entry is read from */ +static ssize_t show_pid (struct device *dev,struct device_attribute + *attr,char *buf) +{ +sprintf (buf,"%ld" , kim_gdata->uim_pid); +return strlen (buf); +} + +/* called when sysfs entry is read from */ +static ssize_t show_list (struct device *dev,struct device_attribute + *attr,char *buf) +{ +kim_st_list_protocols (buf); +return strlen (buf); +} + +#ifdef LEGACY_RFKILL_SUPPORT +/* function called from rfkill subsystem, when someone from +* user space would write 0/1 on the sysfs entry +* /sys/class/rfkill/rfkill0,1,3/state +*/ +static int kim_toggle_radio (void *data,bool blocked) +{ +enum proto_type type = *((enum proto_type *)data); +ST_KIM_DBG (" %s: %d " , __func__, type); + +switch (type) { +case ST_BT : +/* do nothing */ +break ; +case ST_FM : +case ST_GPS : +if (blocked) +st_kim_chip_toggle (type,KIM_GPIO_INACTIVE ); +else +st_kim_chip_toggle (type,KIM_GPIO_ACTIVE ); +break ; +case ST_MAX : +ST_KIM_ERR (" wrong proto type " ); +break ; + } +return ST_SUCCESS ; +} +#endif + +/**********************************************************************/ +/* functions called from platform device driver subsystem +* need to have a relevant platform device entry in the platform's +* board-*.c file +*/ + +static int kim_probe (struct platform_device *pdev) +{ +long status; +long proto; +long *gpios = pdev->dev.platform_data; + +for (proto =0 ; proto <ST_MAX ; proto++) { + kim_gdata->gpios[proto] = gpios[proto]; +ST_KIM_VER (" %ld gpio to be requested" , gpios[proto]); + } + +for (proto =0 ; (proto <ST_MAX ) && (gpios[proto] !=-1 ); proto++) { +/* Claim the Bluetooth/FM/GPIO +* nShutdown gpio from the system +*/ + status =gpio_request (gpios[proto],"kim" ); +if (unlikely (status)) { +ST_KIM_ERR (" gpio %ld request failed " , gpios[proto]); + proto -=1 ; +while (proto >=0 ) { +if (gpios[proto] !=-1 ) +gpio_free (gpios[proto]); + } +return status; + } + +/* Configure nShutdown GPIO as output=0 */ + status = +gpio_direction_output (gpios[proto],0 ); +if (unlikely (status)) { +ST_KIM_ERR (" unable to configure gpio %ld" , + gpios[proto]); + proto -=1 ; +while (proto >=0 ) { +if (gpios[proto] !=-1 ) +gpio_free (gpios[proto]); + } +return status; + } + } +/* pdev to contain BT, FM and GPS enable/N-Shutdown GPIOs +* execute request_gpio, set output direction +*/ + kim_gdata->kim_kobj =kobject_create_and_add ("uim" ,NULL ); +/* create the sysfs entry for UIM to put in pid */ +if (sysfs_create_group (kim_gdata->kim_kobj, &uim_attr_grp)) { +ST_KIM_ERR (" sysfs entry creation failed" ); +kobject_put (kim_gdata->kim_kobj); +/* free requested GPIOs and fail probe */ +for (proto =ST_BT ; proto <ST_MAX ; proto++) { +if (gpios[proto] !=-1 ) +gpio_free (gpios[proto]); + } +return -1 ;/* fail insmod */ + } + +ST_KIM_DBG (" sysfs entry created " ); + +/* get reference of pdev for request_firmware +*/ + kim_gdata->kim_pdev = pdev; +init_completion (&kim_gdata->kim_rcvd); +init_completion (&kim_gdata->ldisc_installed); +#ifdef LEGACY_RFKILL_SUPPORT +for (proto =0 ; (proto <ST_MAX ) && (gpios[proto] !=-1 ); proto++) { +/* TODO: should all types be rfkill_type_bt ? */ + kim_gdata->rfkill[proto] =rfkill_alloc (protocol_names[proto], + &pdev->dev,RFKILL_TYPE_BLUETOOTH , + &kim_rfkill_ops, &proto); +if (kim_gdata->rfkill[proto] ==NULL ) { +ST_KIM_ERR ("cannot create rfkill entry for gpio %ld" , + gpios[proto]); +continue ; + } + status =rfkill_register (kim_gdata->rfkill[proto]); +if (unlikely (status)) { +ST_KIM_ERR ("rfkill registration failed for gpio %ld" , + gpios[proto]); +rfkill_unregister (kim_gdata->rfkill[proto]); +continue ; + } +ST_KIM_DBG ("rfkill entry created for %ld" , gpios[proto]); + } +#endif +return ST_SUCCESS ; +} + +static int kim_remove (struct platform_device *pdev) +{ +/* free the GPIOs requested +*/ +long *gpios = pdev->dev.platform_data; +long proto; + +for (proto =0 ; (proto <ST_MAX ) && (gpios[proto] !=-1 ); proto++) { +/* Claim the Bluetooth/FM/GPIO +* nShutdown gpio from the system +*/ +gpio_free (gpios[proto]); +#ifdef LEGACY_RFKILL_SUPPORT +rfkill_unregister (kim_gdata->rfkill[proto]); +rfkill_destroy (kim_gdata->rfkill[proto]); + kim_gdata->rfkill[proto] =NULL ; +#endif + } +ST_KIM_DBG ("kim: GPIO Freed" ); +/* delete the sysfs entries */ +sysfs_remove_group (kim_gdata->kim_kobj, &uim_attr_grp); +kobject_put (kim_gdata->kim_kobj); + kim_gdata->kim_pdev =NULL ; +return ST_SUCCESS ; +} + +/**********************************************************************/ +/* entry point for ST KIM module, called in from ST Core */ + +long st_kim_init (void ) +{ +long ret =ST_SUCCESS ; + kim_gdata =kzalloc (sizeof (struct kim_data_s ),GFP_ATOMIC ); +if (!kim_gdata) { +ST_KIM_ERR ("no mem to allocate" ); +return -ENOMEM ; + } + ret =platform_driver_register (&kim_platform_driver); +if (ret !=0 ) { +ST_KIM_ERR ("platform drv registration failed" ); +return ST_ERR_FAILURE ; + } +return ST_SUCCESS ; +} + +long st_kim_deinit (void ) +{ +/* the following returns void */ +platform_driver_unregister (&kim_platform_driver); +kfree (kim_gdata); + kim_gdata =NULL ; +return ST_SUCCESS ; +}
drivers/staging/ti-st/st_kim.h new file +151 -0
151 lines not on this page · raw message
Signature · 1 line
1.5.4.3
PATCH 5/7 drivers:staging: sources for HCI LL PM protocol
From: Pavan Savoy <[email protected]>
Texas Instruments BT, FM and GPS combo chips/drivers make use of a single TTY to communicate with the chip. This module constitutes the proprietary power management protocol from TI for the BT/FM/GPS combo chips
--- drivers/staging/ti-st/st_ll.c | 169 +++++++++++++++++++++++++++++++++++++++++ drivers/staging/ti-st/st_ll.h | 67 ++++++++++++++++ 2 files changed, 236 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/ti-st/st_ll.c create mode 100644 drivers/staging/ti-st/st_ll.h
drivers/staging/ti-st/st_ll.c new file +169 -0
@@ -0,0 +1,169 @@ +/* +* Shared Transport driver +* HCI-LL module responsible for TI proprietary HCI_LL protocol +* Copyright (C) 2009 Texas Instruments +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +*/ + +#include "st_ll.h" + +/* all debug macros go in here */ +#define ST_LL_ERR(fmt, arg...) printk(KERN_ERR "(stll):"fmt"\n" , ## arg) +#if defined(DEBUG )/* limited debug messages */ +#define ST_LL_DBG(fmt, arg...) printk(KERN_INFO "(stll):"fmt"\n" , ## arg) +#define ST_LL_VER(fmt, arg...) +#elif defined(VERBOSE )/* very verbose */ +#define ST_LL_DBG(fmt, arg...) printk(KERN_INFO "(stll):"fmt"\n" , ## arg) +#define ST_LL_VER(fmt, arg...) printk(KERN_INFO "(stll):"fmt"\n" , ## arg) +#else /* error msgs only */ +#define ST_LL_DBG(fmt, arg...) +#define ST_LL_VER(fmt, arg...) +#endif + +static struct ll_struct_s *ll; + +/**********************************************************************/ +/* internal functions */ +static void send_ll_cmd (unsigned char cmd) +{ + +ST_LL_DBG ("%s: writing %x" , __func__, cmd); +st_int_write (&cmd,1 ); +return ; +} + +static void ll_device_want_to_sleep (void ) +{ +ST_LL_DBG ("%s" , __func__); +/* sanity check */ +if (ll->ll_state !=ST_LL_AWAKE ) +ST_LL_ERR ("ERR hcill: ST_LL_GO_TO_SLEEP_IND" +"in state %ld" , ll->ll_state); + +send_ll_cmd (LL_SLEEP_ACK ); +/* update state */ + ll->ll_state =ST_LL_ASLEEP ; +} + +static void ll_device_want_to_wakeup (void ) +{ +/* diff actions in diff states */ +switch (ll->ll_state) { +case ST_LL_ASLEEP : +send_ll_cmd (LL_WAKE_UP_ACK );/* send wake_ack */ +break ; +case ST_LL_ASLEEP_TO_AWAKE : +/* duplicate wake_ind */ +ST_LL_ERR ("duplicate wake_ind while waiting for Wake ack" ); +break ; +case ST_LL_AWAKE : +/* duplicate wake_ind */ +ST_LL_ERR ("duplicate wake_ind already AWAKE" ); +break ; +case ST_LL_AWAKE_TO_ASLEEP : +/* duplicate wake_ind */ +ST_LL_ERR ("duplicate wake_ind" ); +break ; + } +/* update state */ + ll->ll_state =ST_LL_AWAKE ; +} + +/**********************************************************************/ +/* functions invoked by ST Core */ + +/* called when ST Core wants to +* enable ST LL */ +void st_ll_enable (void ) +{ + ll->ll_state =ST_LL_AWAKE ; +} + +/* called when ST Core /local module wants to +* disable ST LL */ +void st_ll_disable (void ) +{ + ll->ll_state =ST_LL_INVALID ; +} + +/* called when ST Core wants to update the state */ +void st_ll_wakeup (void ) +{ +if (likely (ll->ll_state !=ST_LL_AWAKE )) { +send_ll_cmd (LL_WAKE_UP_IND );/* WAKE_IND */ + ll->ll_state =ST_LL_ASLEEP_TO_AWAKE ; + }else { +/* don't send the duplicate wake_indication */ +ST_LL_ERR (" Chip already AWAKE " ); + } +} + +/* called when ST Core wants the state */ +unsigned long st_ll_getstate (void ) +{ +ST_LL_DBG (" returning state %ld" , ll->ll_state); +return ll->ll_state; +} + +/* called from ST Core, when a PM related packet arrives */ +unsigned long st_ll_sleep_state (unsigned char cmd) +{ +switch (cmd) { +case LL_SLEEP_IND :/* sleep ind */ +ST_LL_DBG ("sleep indication recvd" ); +ll_device_want_to_sleep (); +break ; +case LL_SLEEP_ACK :/* sleep ack */ +ST_LL_ERR ("sleep ack rcvd: host shouldn't" ); +break ; +case LL_WAKE_UP_IND :/* wake ind */ +ST_LL_DBG ("wake indication recvd" ); +ll_device_want_to_wakeup (); +break ; +case LL_WAKE_UP_ACK :/* wake ack */ +ST_LL_DBG ("wake ack rcvd" ); + ll->ll_state =ST_LL_AWAKE ; +break ; +default : +ST_LL_ERR (" unknown input/state " ); +return ST_ERR_FAILURE ; + } +return ST_SUCCESS ; +} + +/* Called from ST CORE to initialize ST LL */ +long st_ll_init (void ) +{ +long err =ST_SUCCESS ; + +/* Allocate memory for ST LL private structure */ + ll =kzalloc (sizeof (*ll),GFP_ATOMIC ); +if (!ll) { +ST_LL_ERR ("kzalloc failed to alloc memory for ST LL" ); + err = -ENOMEM ; +return err; + } +/* set state to invalid */ + ll->ll_state =ST_LL_INVALID ; +return err; +} + +/* Called from ST CORE to de-initialize ST LL */ +long st_ll_deinit (void ) +{ +kfree (ll); +return 0 ; +}
drivers/staging/ti-st/st_ll.h new file +67 -0
67 lines not on this page · raw message
Signature · 1 line
1.5.4.3
PATCH 6/7 drivers:staging: sources for ST header file
From: Pavan Savoy <[email protected]>
Texas Instruments BT, FM and GPS combo chips/drivers make use of a single TTY to communicate with the chip. This is the common header file for both the ST driver and the protocol drivers which intend to use ST as their mode of transport.
--- drivers/staging/ti-st/fm.h | 13 +++++++ drivers/staging/ti-st/st.h | 85 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 98 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/ti-st/fm.h create mode 100644 drivers/staging/ti-st/st.h
drivers/staging/ti-st/fm.h new file +13 -0
@@ -0,0 +1,13 @@ +struct fm_event_hdr { +unsigned char plen; +} __attribute__ ((packed)); + +#define FM_MAX_FRAME_SIZE 0xFF/* TODO: */ +#define FM_EVENT_HDR_SIZE 1/* size of fm_event_hdr */ +#define ST_FM_CH8_PKT 0x8 + +/* gps stuff */ +struct gps_event_hdr { +unsigned char opcode; +unsigned short plen; +} __attribute__ ((packed));
drivers/staging/ti-st/st.h new file +85 -0
85 lines not on this page · raw message
Signature · 1 line
1.5.4.3
PATCH 7/7 Documentation/ABI: for N_TI_SHARED ldisc
From: Pavan Savoy <[email protected]>
N_TI_SHARED creates a sysfs entry to communicate with the application/daemon which would want to install/ un-install the line discipline, it's documentation now exists in testing/ subdirectory.
--- Documentation/ABI/testing/sysfs-uim | 24 ++++++++++++++++++++++++ 1 files changed, 24 insertions(+), 0 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-uim
Documentation/ABI/testing/sysfs-uim new file +24 -0
@@ -0,0 +1,24 @@ +What: /sys/uim +Date: March 22 +Contact: Pavan Savoy <[email protected]> +Description: + Create a new kobject to pass information about the + N_TI_SHARED line discipline created to application/daemon + which would install/un-install line discipline. + +What: /sys/uim/pid +Date: March 22 +Contact: Pavan Savoy <[email protected]> +Description: + The daemon/application wanting to use the line discipline + N_TI_SHARED will write in it's process Id, for the LDISC + driver to send SIGUSR2 signal to the process whenever a + upper layer protocol driver wants to make use of the LDISC + driver. + +What: /sys/uim/protocols +Date: March 22 +Contact: Pavan Savoy <[email protected]> +Description: + List the protocols currently making use of the LDISC to ensure + LDISC is not un-installed when BT/FM or GPS is making use of it.
Signature · 1 line
1.5.4.3
Re: [PATCH 7/7] Documentation/ABI: for N_TI_SHARED ldisc
Quoted 10 lines · On Tue, Mar 23, 2010 at 03:41:15PM -0500, [email protected] wrote:
From: Pavan Savoy <[email protected]>
N_TI_SHAREDcreates a sysfs entry to communicate with the application/daemon which would want to install/ un-install the line discipline, it's documentation now exists in testing/ subdirectory.Signed-off-by Pavan Savoy <[email protected]>--- Documentation/ABI/testing/sysfs-uim | 24 ++++++++++++++++++++++++
Again, staging drivers need to be self-contained. Please keep this in the staging driver directory for now.
thanks,
greg k-h
Re: [PATCH 2/7] drivers:staging: Kconfig, Makefile for TI's ST ldisc
In reply to [email protected]Quoted 6 lines · On Tue, Mar 23, 2010 at 03:41:10PM -0500, [email protected] wrote:
From: Pavan Savoy <[email protected]>
This change adds the
Kconfigand Make file for TI's ST line discipline driver and the BlueZ driver for BT core of the TI BT/FM/GPS combo chip.
Quoted 6 lines
Signed-off-by Pavan Savoy <[email protected]>--- drivers/staging/Kconfig | 2 ++ drivers/staging/Makefile | 1 + drivers/staging/ti-st/Kconfig | 24 ++++++++++++++++++++++++ drivers/staging/ti-st/Makefile | 7 +++++++
Again, you just broke the build.
Please fix the ordering of your patches.
thanks,
greg k-h
Re: [PATCH 2/7] drivers:staging: Kconfig, Makefile for TI's ST ldisc
In reply to [email protected]Quoted 10 lines · On Tue, Mar 23, 2010 at 03:41:10PM -0500, [email protected] wrote:
From: Pavan Savoy <[email protected]>
This change adds the
Kconfigand Make file for TI's ST line discipline driver and the BlueZ driver for BT core of the TI BT/FM/GPS combo chip.Signed-off-by Pavan Savoy <[email protected]>--- drivers/staging/Kconfig | 2 ++ drivers/staging/Makefile | 1 +
To add a new staging driver, I need a TODO file that lists what needs to be done to the code in order to get it merged into the main portion of the kernel, and who is responsible for it. Look at the other drivers/staging/*/TODO files for examples of what to do.
thanks,
greg k-h
Re: [PATCH 1/7] serial: TTY: new ldisc for TI BT/FM/GPS chips
In reply to [email protected]Hi guys,
Quoted 24 lines
A new
N_TI_WLline discipline added for TI BT/FM/GPS combo chips which make use of same TTY to communicate with chip. This is to be made use of individual protocol BT/FM/GPS drivers.Signed-off-by Pavan Savoy <[email protected]>--- include/linux/tty.h | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-)include/linux/tty.h +1
-1@@ -23,7 +23,7 @@*/ #define NR_UNIX98_PTY_DEFAULT 4096/* Default maximum for Unix98 ptys */ #define NR_UNIX98_PTY_MAX (1 << MINORBITS)/* Absolute limit */ -#define NR_LDISCS 20 +#define NR_LDISCS 21/* line disciplines */ #define N_TTY 0
include/linux/tty.h line 54
Quoted 7 lines
include/linux/tty.h +1
-0@@ -48,6 +48,7 @@#define N_PPS 18/* Pulse per Second */ #define N_V253 19/* Codec control over voice modem */ +#define N_TI_WL 20/* for TI's WL connectivity chips */ /* * This character is the same as _POSIX_VDISABLE: it cannot be used as
why is this even targeting staging. I prefer if we have proper review cycles and get this reviewed this way. This looks like more a shortcut to get things into the kernel than actually spending the effort to clean things up.
If this would be just a driver, I wouldn't care, but it tries to assign official numbers for a line discipline and clearly collides with other peoples work that are going the proper upstream review cycles.
Greg, I would like to see the rule that if it touches files outside of drivers/staging/ then it is not eligible for staging.
Regards
Marcel
Re: [PATCH 1/7] serial: TTY: new ldisc for TI BT/FM/GPS chips
Quoted 10 lines · Marcel Holtmann
Quoted 4 lines
+#define
N_TI_WL20 /* for TI's WL connectivity chips *//*
* This character is the same as_POSIX_VDISABLE: it cannot be used aswhy is this even targeting staging. I prefer if we have proper review cycles and get this reviewed this way. This looks like more a shortcut to get things into the kernel than actually spending the effort to clean things up.
Quoted 6 lines
If this would be just a driver, I wouldn't care, but it tries to assign official numbers for a line discipline and clearly collides with other peoples work that are going the proper upstream review cycles.
Greg, I would like to see the rule that if it touches files outside of
drivers/staging/then it is not eligible for staging.
That is a rule already :)
See my complaint about this a few minutes ago.
thanks,
greg k-h
Re: [PATCH 1/7] serial: TTY: new ldisc for TI BT/FM/GPS chips
In reply to [email protected]Quoted 10 lines · On Tue, Mar 23, 2010 at 03:41:09PM -0500, [email protected] wrote:
From: Pavan Savoy <[email protected]>
A new
N_TI_WLline discipline added for TI BT/FM/GPS combo chips which make use of same TTY to communicate with chip. This is to be made use of individual protocol BT/FM/GPS drivers.Signed-off-by Pavan Savoy <[email protected]>--- include/linux/tty.h | 3 ++-
Staging code needs to be completly self-contained in the drivers/staging directory. Is there any way to do this without touching this file?
thanks,
greg k-h
Re: [PATCH 1/7] serial: TTY: new ldisc for TI BT/FM/GPS chips
Quoted 8 lines · On Tue, 23 Mar 2010 19:28:03 -0700 Greg KH <[email protected]> wrote:
Quoted 7 lines · On Tue, Mar 23, 2010 at 03:41:09PM -0500, [email protected] wrote:
From: Pavan Savoy <[email protected]>
A new
N_TI_WLline discipline added for TI BT/FM/GPS combo chips which make use of same TTY to communicate with chip. This is to be made use of individual protocol BT/FM/GPS drivers.
Quoted 6 lines
Quoted 3 lines
Signed-off-by Pavan Savoy <[email protected]>--- include/linux/tty.h | 3 ++-Staging code needs to be completly self-contained in the
drivers/stagingdirectory. Is there any way to do this without touching this file?
Put the N_TI_WL into a staging header, and bump the number of ldiscs as a separate non staging patch - we should probably simply bump it a bit anyway to leave room for experimental work using a built kernel image. There is no requirement that the number of ldiscs matches up to the last ldisc assigned.
Alan
Re: [PATCH 1/7] serial: TTY: new ldisc for TI BT/FM/GPS chips
Quoted 15 lines · Alan Cox
Quoted 12 lines · On Tue, 23 Mar 2010 19:28:03 -0700 Greg KH <[email protected]> wrote:
Quoted 10 lines · On Tue, Mar 23, 2010 at 03:41:09PM -0500, [email protected] wrote:
From: Pavan Savoy <[email protected]>
A new
N_TI_WLline discipline added for TI BT/FM/GPS combo chips which make use of same TTY to communicate with chip. This is to be made use of individual protocol BT/FM/GPS drivers.Signed-off-by Pavan Savoy <[email protected]>--- include/linux/tty.h | 3 ++-
Quoted 8 lines
Quoted 2 lines
Staging code needs to be completly self-contained in the
drivers/stagingdirectory. Is there any way to do this without touching this file?Put the
N_TI_WLinto a staging header, and bump the number of ldiscs as a separate non staging patch - we should probably simply bump it a bit anyway to leave room for experimental work using a built kernel image. There is no requirement that the number of ldiscs matches up to the last ldisc assigned.
That sounds good to me.
thanks,
greg k-h