summaryrefslogtreecommitdiffstats
path: root/extras/recipes-kernel/linux/linux-omap/wl1271
diff options
context:
space:
mode:
Diffstat (limited to 'extras/recipes-kernel/linux/linux-omap/wl1271')
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0001-wl12xx-Read-MAC-address-from-NVS-file-on-HW-startup.patch41
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0002-wl1271-11n-Support-Add-Definitions.patch165
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0003-wl1271-11n-Support-ACX-Commands.patch128
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0004-wl1271-11n-Support-functionality-and-configuration-a.patch249
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0005-wl1271-set-wl-vif-only-if-add_interface-succeeded.patch86
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0006-wl12xx-Unset-bssid-filter-ssid-and-bssid-from-firmwa.patch44
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0007-drivers-media-radio-wl128x-FM-Driver-common-header-f.patch268
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0008-drivers-media-radio-wl128x-FM-Driver-V4L2-sources.patch645
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch2114
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0010-drivers-media-radio-wl128x-FM-driver-RX-sources.patch938
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0011-drivers-media-radio-wl128x-FM-driver-TX-sources.patch494
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0012-drivers-media-radio-wl128x-Kconfig-Makefile-for-wl12.patch52
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0013-drivers-media-radio-Update-Kconfig-and-Makefile-for-.patch38
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0014-drivers-misc-ti-st-change-protocol-parse-logic.patch900
-rw-r--r--extras/recipes-kernel/linux/linux-omap/wl1271/0015-Bluetooth-btwilink-driver.patch463
15 files changed, 6625 insertions, 0 deletions
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0001-wl12xx-Read-MAC-address-from-NVS-file-on-HW-startup.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0001-wl12xx-Read-MAC-address-from-NVS-file-on-HW-startup.patch
new file mode 100644
index 00000000..a4f08736
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0001-wl12xx-Read-MAC-address-from-NVS-file-on-HW-startup.patch
@@ -0,0 +1,41 @@
1From 5d302917bbdb377538f6c848243a6265878abcee Mon Sep 17 00:00:00 2001
2From: Arik Nemtsov <arik@wizery.com>
3Date: Sat, 16 Oct 2010 21:49:52 +0200
4Subject: [PATCH 01/15] wl12xx: Read MAC address from NVS file on HW startup
5
6Try to read the MAC address from the on-disk NVS file.
7A non-zero MAC address is required to add an AP interface.
8
9Signed-off-by: Arik Nemtsov <arik@wizery.com>
10Reviewed-by: Luciano Coelho <coelho@ti.com>
11Signed-off-by: Luciano Coelho <coelho@ti.com>
12---
13 drivers/net/wireless/wl12xx/wl1271_main.c | 12 ++++++++++++
14 1 files changed, 12 insertions(+), 0 deletions(-)
15
16diff --git a/drivers/net/wireless/wl12xx/wl1271_main.c b/drivers/net/wireless/wl12xx/wl1271_main.c
17index 48a4b99..591de0e 100644
18--- a/drivers/net/wireless/wl12xx/wl1271_main.c
19+++ b/drivers/net/wireless/wl12xx/wl1271_main.c
20@@ -2391,6 +2391,18 @@ int wl1271_register_hw(struct wl1271 *wl)
21 if (wl->mac80211_registered)
22 return 0;
23
24+ ret = wl1271_fetch_nvs(wl);
25+ if (ret == 0) {
26+ u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
27+
28+ wl->mac_addr[0] = nvs_ptr[11];
29+ wl->mac_addr[1] = nvs_ptr[10];
30+ wl->mac_addr[2] = nvs_ptr[6];
31+ wl->mac_addr[3] = nvs_ptr[5];
32+ wl->mac_addr[4] = nvs_ptr[4];
33+ wl->mac_addr[5] = nvs_ptr[3];
34+ }
35+
36 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
37
38 ret = ieee80211_register_hw(wl->hw);
39--
401.6.6.1
41
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0002-wl1271-11n-Support-Add-Definitions.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0002-wl1271-11n-Support-Add-Definitions.patch
new file mode 100644
index 00000000..1da7be6c
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0002-wl1271-11n-Support-Add-Definitions.patch
@@ -0,0 +1,165 @@
1From 99d1c6c23faa446ec0ebdf056d8aa8f4d983d518 Mon Sep 17 00:00:00 2001
2From: Shahar Levi <shahar_levi@ti.com>
3Date: Wed, 13 Oct 2010 16:09:39 +0200
4Subject: [PATCH 02/15] wl1271: 11n Support, Add Definitions
5
6Two acx commands: ht_capabilities & ht_information, 11n sta capabilities
7macro.
8
9Signed-off-by: Shahar Levi <shahar_levi@ti.com>
10Reviewed-by: Luciano Coelho <luciano.coelho@nokia.com>
11Signed-off-by: Luciano Coelho <luciano.coelho@nokia.com>
12---
13 drivers/net/wireless/wl12xx/wl1271.h | 11 ++++-
14 drivers/net/wireless/wl12xx/wl1271_acx.h | 81 +++++++++++++++++++++++++++++
15 drivers/net/wireless/wl12xx/wl1271_main.c | 15 +++++
16 3 files changed, 106 insertions(+), 1 deletions(-)
17
18diff --git a/drivers/net/wireless/wl12xx/wl1271.h b/drivers/net/wireless/wl12xx/wl1271.h
19index 8a4cd76..45a2583 100644
20--- a/drivers/net/wireless/wl12xx/wl1271.h
21+++ b/drivers/net/wireless/wl12xx/wl1271.h
22@@ -432,7 +432,12 @@ struct wl1271 {
23 /* Our association ID */
24 u16 aid;
25
26- /* currently configured rate set */
27+ /*
28+ * currently configured rate set:
29+ * bits 0-15 - 802.11abg rates
30+ * bits 16-23 - 802.11n MCS index mask
31+ * support only 1 stream, thus only 8 bits for the MCS rates (0-7).
32+ */
33 u32 sta_rate_set;
34 u32 basic_rate_set;
35 u32 basic_rate;
36@@ -509,4 +514,8 @@ int wl1271_plt_stop(struct wl1271 *wl);
37 #define WL1271_PRE_POWER_ON_SLEEP 20 /* in miliseconds */
38 #define WL1271_POWER_ON_SLEEP 200 /* in miliseconds */
39
40+/* Macros to handle wl1271.sta_rate_set */
41+#define HW_BG_RATES_MASK 0xffff
42+#define HW_HT_RATES_OFFSET 16
43+
44 #endif
45diff --git a/drivers/net/wireless/wl12xx/wl1271_acx.h b/drivers/net/wireless/wl12xx/wl1271_acx.h
46index ebb341d..f090a04 100644
47--- a/drivers/net/wireless/wl12xx/wl1271_acx.h
48+++ b/drivers/net/wireless/wl12xx/wl1271_acx.h
49@@ -964,6 +964,87 @@ struct wl1271_acx_rssi_snr_avg_weights {
50 u8 snr_data;
51 };
52
53+/*
54+ * ACX_PEER_HT_CAP
55+ * Configure HT capabilities - declare the capabilities of the peer
56+ * we are connected to.
57+ */
58+struct wl1271_acx_ht_capabilities {
59+ struct acx_header header;
60+
61+ /*
62+ * bit 0 - Allow HT Operation
63+ * bit 1 - Allow Greenfield format in TX
64+ * bit 2 - Allow Short GI in TX
65+ * bit 3 - Allow L-SIG TXOP Protection in TX
66+ * bit 4 - Allow HT Control fields in TX.
67+ * Note, driver will still leave space for HT control in packets
68+ * regardless of the value of this field. FW will be responsible
69+ * to drop the HT field from any frame when this Bit set to 0.
70+ * bit 5 - Allow RD initiation in TXOP. FW is allowed to initate RD.
71+ * Exact policy setting for this feature is TBD.
72+ * Note, this bit can only be set to 1 if bit 3 is set to 1.
73+ */
74+ __le32 ht_capabilites;
75+
76+ /*
77+ * Indicates to which peer these capabilities apply.
78+ * For infrastructure use ff:ff:ff:ff:ff:ff that indicates relevance
79+ * for all peers.
80+ * Only valid for IBSS/DLS operation.
81+ */
82+ u8 mac_address[ETH_ALEN];
83+
84+ /*
85+ * This the maximum A-MPDU length supported by the AP. The FW may not
86+ * exceed this length when sending A-MPDUs
87+ */
88+ u8 ampdu_max_length;
89+
90+ /* This is the minimal spacing required when sending A-MPDUs to the AP*/
91+ u8 ampdu_min_spacing;
92+} __packed;
93+
94+/* HT Capabilites Fw Bit Mask Mapping */
95+#define WL1271_ACX_FW_CAP_HT_OPERATION BIT(0)
96+#define WL1271_ACX_FW_CAP_GREENFIELD_FRAME_FORMAT BIT(1)
97+#define WL1271_ACX_FW_CAP_SHORT_GI_FOR_20MHZ_PACKETS BIT(2)
98+#define WL1271_ACX_FW_CAP_LSIG_TXOP_PROTECTION BIT(3)
99+#define WL1271_ACX_FW_CAP_HT_CONTROL_FIELDS BIT(4)
100+#define WL1271_ACX_FW_CAP_RD_INITIATION BIT(5)
101+
102+
103+/*
104+ * ACX_HT_BSS_OPERATION
105+ * Configure HT capabilities - AP rules for behavior in the BSS.
106+ */
107+struct wl1271_acx_ht_information {
108+ struct acx_header header;
109+
110+ /* Values: 0 - RIFS not allowed, 1 - RIFS allowed */
111+ u8 rifs_mode;
112+
113+ /* Values: 0 - 3 like in spec */
114+ u8 ht_protection;
115+
116+ /* Values: 0 - GF protection not required, 1 - GF protection required */
117+ u8 gf_protection;
118+
119+ /*Values: 0 - TX Burst limit not required, 1 - TX Burst Limit required*/
120+ u8 ht_tx_burst_limit;
121+
122+ /*
123+ * Values: 0 - Dual CTS protection not required,
124+ * 1 - Dual CTS Protection required
125+ * Note: When this value is set to 1 FW will protect all TXOP with RTS
126+ * frame and will not use CTS-to-self regardless of the value of the
127+ * ACX_CTS_PROTECTION information element
128+ */
129+ u8 dual_cts_protection;
130+
131+ u8 padding[3];
132+} __packed;
133+
134 struct wl1271_acx_fw_tsf_information {
135 struct acx_header header;
136
137diff --git a/drivers/net/wireless/wl12xx/wl1271_main.c b/drivers/net/wireless/wl12xx/wl1271_main.c
138index 591de0e..785b73c 100644
139--- a/drivers/net/wireless/wl12xx/wl1271_main.c
140+++ b/drivers/net/wireless/wl12xx/wl1271_main.c
141@@ -2134,6 +2134,21 @@ static const u8 wl1271_rate_to_idx_2ghz[] = {
142 0 /* CONF_HW_RXTX_RATE_1 */
143 };
144
145+/* 11n STA capabilities */
146+#define HW_RX_HIGHEST_RATE 72
147+
148+#define WL1271_HT_CAP { \
149+ .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
150+ .ht_supported = true, \
151+ .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
152+ .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
153+ .mcs = { \
154+ .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
155+ .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
156+ .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
157+ }, \
158+}
159+
160 /* can't be const, mac80211 writes to this */
161 static struct ieee80211_supported_band wl1271_band_2ghz = {
162 .channels = wl1271_channels,
163--
1641.6.6.1
165
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0003-wl1271-11n-Support-ACX-Commands.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0003-wl1271-11n-Support-ACX-Commands.patch
new file mode 100644
index 00000000..8d2412b1
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0003-wl1271-11n-Support-ACX-Commands.patch
@@ -0,0 +1,128 @@
1From 160169e1e717020b8456278950c30d2b1f15c314 Mon Sep 17 00:00:00 2001
2From: Shahar Levi <shahar_levi@ti.com>
3Date: Wed, 13 Oct 2010 16:09:40 +0200
4Subject: [PATCH 03/15] wl1271: 11n Support, ACX Commands
5
6Added ACX command to the FW for 11n support.
7
8Signed-off-by: Shahar Levi <shahar_levi@ti.com>
9Reviewed-by: Luciano Coelho <luciano.coelho@nokia.com>
10Signed-off-by: Luciano Coelho <luciano.coelho@nokia.com>
11---
12 drivers/net/wireless/wl12xx/wl1271_acx.c | 83 ++++++++++++++++++++++++++++++
13 drivers/net/wireless/wl12xx/wl1271_acx.h | 5 ++
14 2 files changed, 88 insertions(+), 0 deletions(-)
15
16diff --git a/drivers/net/wireless/wl12xx/wl1271_acx.c b/drivers/net/wireless/wl12xx/wl1271_acx.c
17index 6189934..bd7f95f 100644
18--- a/drivers/net/wireless/wl12xx/wl1271_acx.c
19+++ b/drivers/net/wireless/wl12xx/wl1271_acx.c
20@@ -1226,6 +1226,89 @@ out:
21 return ret;
22 }
23
24+int wl1271_acx_set_ht_capabilities(struct wl1271 *wl,
25+ struct ieee80211_sta_ht_cap *ht_cap,
26+ bool allow_ht_operation)
27+{
28+ struct wl1271_acx_ht_capabilities *acx;
29+ u8 mac_address[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
30+ int ret = 0;
31+
32+ wl1271_debug(DEBUG_ACX, "acx ht capabilities setting");
33+
34+ acx = kzalloc(sizeof(*acx), GFP_KERNEL);
35+ if (!acx) {
36+ ret = -ENOMEM;
37+ goto out;
38+ }
39+
40+ /* Allow HT Operation ? */
41+ if (allow_ht_operation) {
42+ acx->ht_capabilites =
43+ WL1271_ACX_FW_CAP_HT_OPERATION;
44+ if (ht_cap->cap & IEEE80211_HT_CAP_GRN_FLD)
45+ acx->ht_capabilites |=
46+ WL1271_ACX_FW_CAP_GREENFIELD_FRAME_FORMAT;
47+ if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
48+ acx->ht_capabilites |=
49+ WL1271_ACX_FW_CAP_SHORT_GI_FOR_20MHZ_PACKETS;
50+ if (ht_cap->cap & IEEE80211_HT_CAP_LSIG_TXOP_PROT)
51+ acx->ht_capabilites |=
52+ WL1271_ACX_FW_CAP_LSIG_TXOP_PROTECTION;
53+
54+ /* get data from A-MPDU parameters field */
55+ acx->ampdu_max_length = ht_cap->ampdu_factor;
56+ acx->ampdu_min_spacing = ht_cap->ampdu_density;
57+
58+ memcpy(acx->mac_address, mac_address, ETH_ALEN);
59+ } else { /* HT operations are not allowed */
60+ acx->ht_capabilites = 0;
61+ }
62+
63+ ret = wl1271_cmd_configure(wl, ACX_PEER_HT_CAP, acx, sizeof(*acx));
64+ if (ret < 0) {
65+ wl1271_warning("acx ht capabilities setting failed: %d", ret);
66+ goto out;
67+ }
68+
69+out:
70+ kfree(acx);
71+ return ret;
72+}
73+
74+int wl1271_acx_set_ht_information(struct wl1271 *wl,
75+ u16 ht_operation_mode)
76+{
77+ struct wl1271_acx_ht_information *acx;
78+ int ret = 0;
79+
80+ wl1271_debug(DEBUG_ACX, "acx ht information setting");
81+
82+ acx = kzalloc(sizeof(*acx), GFP_KERNEL);
83+ if (!acx) {
84+ ret = -ENOMEM;
85+ goto out;
86+ }
87+
88+ acx->ht_protection =
89+ (u8)(ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION);
90+ acx->rifs_mode = 0;
91+ acx->gf_protection = 0;
92+ acx->ht_tx_burst_limit = 0;
93+ acx->dual_cts_protection = 0;
94+
95+ ret = wl1271_cmd_configure(wl, ACX_HT_BSS_OPERATION, acx, sizeof(*acx));
96+
97+ if (ret < 0) {
98+ wl1271_warning("acx ht information setting failed: %d", ret);
99+ goto out;
100+ }
101+
102+out:
103+ kfree(acx);
104+ return ret;
105+}
106+
107 int wl1271_acx_tsf_info(struct wl1271 *wl, u64 *mactime)
108 {
109 struct wl1271_acx_fw_tsf_information *tsf_info;
110diff --git a/drivers/net/wireless/wl12xx/wl1271_acx.h b/drivers/net/wireless/wl12xx/wl1271_acx.h
111index f090a04..7589167 100644
112--- a/drivers/net/wireless/wl12xx/wl1271_acx.h
113+++ b/drivers/net/wireless/wl12xx/wl1271_acx.h
114@@ -1174,6 +1174,11 @@ int wl1271_acx_keep_alive_config(struct wl1271 *wl, u8 index, u8 tpl_valid);
115 int wl1271_acx_rssi_snr_trigger(struct wl1271 *wl, bool enable,
116 s16 thold, u8 hyst);
117 int wl1271_acx_rssi_snr_avg_weights(struct wl1271 *wl);
118+int wl1271_acx_set_ht_capabilities(struct wl1271 *wl,
119+ struct ieee80211_sta_ht_cap *ht_cap,
120+ bool allow_ht_operation);
121+int wl1271_acx_set_ht_information(struct wl1271 *wl,
122+ u16 ht_operation_mode);
123 int wl1271_acx_tsf_info(struct wl1271 *wl, u64 *mactime);
124
125 #endif /* __WL1271_ACX_H__ */
126--
1271.6.6.1
128
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0004-wl1271-11n-Support-functionality-and-configuration-a.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0004-wl1271-11n-Support-functionality-and-configuration-a.patch
new file mode 100644
index 00000000..17ed6e63
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0004-wl1271-11n-Support-functionality-and-configuration-a.patch
@@ -0,0 +1,249 @@
1From 9685ab91494ae35d2cb7e0033c5ee1bf3cdf0c64 Mon Sep 17 00:00:00 2001
2From: Shahar Levi <shahar_levi@ti.com>
3Date: Wed, 13 Oct 2010 16:09:41 +0200
4Subject: [PATCH 04/15] wl1271: 11n Support, functionality and configuration ability
5
6Add 11n ability in scan, connection and using MCS rates.
7The configuration is temporary due to the code incomplete and
8still in testing process. That plans to be remove in the future.
9
10Signed-off-by: Shahar Levi <shahar_levi@ti.com>
11Reviewed-by: Luciano Coelho <luciano.coelho@nokia.com>
12Signed-off-by: Luciano Coelho <luciano.coelho@nokia.com>
13---
14 drivers/net/wireless/wl12xx/Kconfig | 10 +++
15 drivers/net/wireless/wl12xx/wl1271_main.c | 96 +++++++++++++++++++++++------
16 drivers/net/wireless/wl12xx/wl1271_rx.c | 6 ++
17 drivers/net/wireless/wl12xx/wl1271_tx.c | 11 +++
18 4 files changed, 105 insertions(+), 18 deletions(-)
19
20diff --git a/drivers/net/wireless/wl12xx/Kconfig b/drivers/net/wireless/wl12xx/Kconfig
21index b447559..1b3b7bd 100644
22--- a/drivers/net/wireless/wl12xx/Kconfig
23+++ b/drivers/net/wireless/wl12xx/Kconfig
24@@ -18,6 +18,16 @@ config WL1271
25 If you choose to build a module, it'll be called wl1271. Say N if
26 unsure.
27
28+config WL1271_HT
29+ bool "TI wl1271 802.11 HT support (EXPERIMENTAL)"
30+ depends on WL1271 && EXPERIMENTAL
31+ default n
32+ ---help---
33+ This will enable 802.11 HT support for TI wl1271 chipset.
34+
35+ That configuration is temporary due to the code incomplete and
36+ still in testing process.
37+
38 config WL1271_SPI
39 tristate "TI wl1271 SPI support"
40 depends on WL1271 && SPI_MASTER
41diff --git a/drivers/net/wireless/wl12xx/wl1271_main.c b/drivers/net/wireless/wl12xx/wl1271_main.c
42index 785b73c..49ec0ef 100644
43--- a/drivers/net/wireless/wl12xx/wl1271_main.c
44+++ b/drivers/net/wireless/wl12xx/wl1271_main.c
45@@ -851,12 +851,32 @@ static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
46 struct ieee80211_sta *sta = txinfo->control.sta;
47 unsigned long flags;
48
49- /* peek into the rates configured in the STA entry */
50+ /*
51+ * peek into the rates configured in the STA entry.
52+ * The rates set after connection stage, The first block only BG sets:
53+ * the compare is for bit 0-16 of sta_rate_set. The second block add
54+ * HT rates in case of HT supported.
55+ */
56 spin_lock_irqsave(&wl->wl_lock, flags);
57- if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
58+ if (sta &&
59+ (sta->supp_rates[conf->channel->band] !=
60+ (wl->sta_rate_set & HW_BG_RATES_MASK))) {
61 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
62 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
63 }
64+
65+#ifdef CONFIG_WL1271_HT
66+ if (sta &&
67+ sta->ht_cap.ht_supported &&
68+ ((wl->sta_rate_set >> HW_HT_RATES_OFFSET) !=
69+ sta->ht_cap.mcs.rx_mask[0])) {
70+ /* Clean MCS bits before setting them */
71+ wl->sta_rate_set &= HW_BG_RATES_MASK;
72+ wl->sta_rate_set |=
73+ (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
74+ set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
75+ }
76+#endif
77 spin_unlock_irqrestore(&wl->wl_lock, flags);
78
79 /* queue the packet */
80@@ -1709,6 +1729,7 @@ static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
81 {
82 enum wl1271_cmd_ps_mode mode;
83 struct wl1271 *wl = hw->priv;
84+ struct ieee80211_sta *sta = ieee80211_find_sta(vif, bss_conf->bssid);
85 bool do_join = false;
86 bool set_assoc = false;
87 int ret;
88@@ -1927,6 +1948,37 @@ static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
89 }
90 }
91
92+ /*
93+ * Takes care of: New association with HT enable,
94+ * HT information change in beacon.
95+ */
96+ if (sta &&
97+ (changed & BSS_CHANGED_HT) &&
98+ (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
99+ ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true);
100+ if (ret < 0) {
101+ wl1271_warning("Set ht cap true failed %d", ret);
102+ goto out_sleep;
103+ }
104+ ret = wl1271_acx_set_ht_information(wl,
105+ bss_conf->ht_operation_mode);
106+ if (ret < 0) {
107+ wl1271_warning("Set ht information failed %d", ret);
108+ goto out_sleep;
109+ }
110+ }
111+ /*
112+ * Takes care of: New association without HT,
113+ * Disassociation.
114+ */
115+ else if (sta && (changed & BSS_CHANGED_ASSOC)) {
116+ ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, false);
117+ if (ret < 0) {
118+ wl1271_warning("Set ht cap false failed %d", ret);
119+ goto out_sleep;
120+ }
121+ }
122+
123 if (changed & BSS_CHANGED_ARP_FILTER) {
124 __be32 addr = bss_conf->arp_addr_list[0];
125 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
126@@ -2107,14 +2159,14 @@ static struct ieee80211_channel wl1271_channels[] = {
127 /* mapping to indexes for wl1271_rates */
128 static const u8 wl1271_rate_to_idx_2ghz[] = {
129 /* MCS rates are used only with 11n */
130- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
131- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
132- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
133- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
134- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
135- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
136- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
137- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
138+ 7, /* CONF_HW_RXTX_RATE_MCS7 */
139+ 6, /* CONF_HW_RXTX_RATE_MCS6 */
140+ 5, /* CONF_HW_RXTX_RATE_MCS5 */
141+ 4, /* CONF_HW_RXTX_RATE_MCS4 */
142+ 3, /* CONF_HW_RXTX_RATE_MCS3 */
143+ 2, /* CONF_HW_RXTX_RATE_MCS2 */
144+ 1, /* CONF_HW_RXTX_RATE_MCS1 */
145+ 0, /* CONF_HW_RXTX_RATE_MCS0 */
146
147 11, /* CONF_HW_RXTX_RATE_54 */
148 10, /* CONF_HW_RXTX_RATE_48 */
149@@ -2137,6 +2189,7 @@ static const u8 wl1271_rate_to_idx_2ghz[] = {
150 /* 11n STA capabilities */
151 #define HW_RX_HIGHEST_RATE 72
152
153+#ifdef CONFIG_WL1271_HT
154 #define WL1271_HT_CAP { \
155 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
156 .ht_supported = true, \
157@@ -2148,6 +2201,11 @@ static const u8 wl1271_rate_to_idx_2ghz[] = {
158 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
159 }, \
160 }
161+#else
162+#define WL1271_HT_CAP { \
163+ .ht_supported = false, \
164+}
165+#endif
166
167 /* can't be const, mac80211 writes to this */
168 static struct ieee80211_supported_band wl1271_band_2ghz = {
169@@ -2155,6 +2213,7 @@ static struct ieee80211_supported_band wl1271_band_2ghz = {
170 .n_channels = ARRAY_SIZE(wl1271_channels),
171 .bitrates = wl1271_rates,
172 .n_bitrates = ARRAY_SIZE(wl1271_rates),
173+ .ht_cap = WL1271_HT_CAP,
174 };
175
176 /* 5 GHz data rates for WL1273 */
177@@ -2237,14 +2296,14 @@ static struct ieee80211_channel wl1271_channels_5ghz[] = {
178 /* mapping to indexes for wl1271_rates_5ghz */
179 static const u8 wl1271_rate_to_idx_5ghz[] = {
180 /* MCS rates are used only with 11n */
181- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
182- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
183- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
184- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
185- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
186- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
187- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
188- CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
189+ 7, /* CONF_HW_RXTX_RATE_MCS7 */
190+ 6, /* CONF_HW_RXTX_RATE_MCS6 */
191+ 5, /* CONF_HW_RXTX_RATE_MCS5 */
192+ 4, /* CONF_HW_RXTX_RATE_MCS4 */
193+ 3, /* CONF_HW_RXTX_RATE_MCS3 */
194+ 2, /* CONF_HW_RXTX_RATE_MCS2 */
195+ 1, /* CONF_HW_RXTX_RATE_MCS1 */
196+ 0, /* CONF_HW_RXTX_RATE_MCS0 */
197
198 7, /* CONF_HW_RXTX_RATE_54 */
199 6, /* CONF_HW_RXTX_RATE_48 */
200@@ -2269,6 +2328,7 @@ static struct ieee80211_supported_band wl1271_band_5ghz = {
201 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
202 .bitrates = wl1271_rates_5ghz,
203 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
204+ .ht_cap = WL1271_HT_CAP,
205 };
206
207 static const u8 *wl1271_band_rate_to_idx[] = {
208diff --git a/drivers/net/wireless/wl12xx/wl1271_rx.c b/drivers/net/wireless/wl12xx/wl1271_rx.c
209index bea133b..ac13f7d 100644
210--- a/drivers/net/wireless/wl12xx/wl1271_rx.c
211+++ b/drivers/net/wireless/wl12xx/wl1271_rx.c
212@@ -53,6 +53,12 @@ static void wl1271_rx_status(struct wl1271 *wl,
213 status->band = wl->band;
214 status->rate_idx = wl1271_rate_to_idx(wl, desc->rate);
215
216+#ifdef CONFIG_WL1271_HT
217+ /* 11n support */
218+ if (desc->rate <= CONF_HW_RXTX_RATE_MCS0)
219+ status->flag |= RX_FLAG_HT;
220+#endif
221+
222 status->signal = desc->rssi;
223
224 /*
225diff --git a/drivers/net/wireless/wl12xx/wl1271_tx.c b/drivers/net/wireless/wl12xx/wl1271_tx.c
226index e3dc13c..6a87633 100644
227--- a/drivers/net/wireless/wl12xx/wl1271_tx.c
228+++ b/drivers/net/wireless/wl12xx/wl1271_tx.c
229@@ -201,6 +201,17 @@ u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set)
230 rate_set >>= 1;
231 }
232
233+#ifdef CONFIG_WL1271_HT
234+ /* MCS rates indication are on bits 16 - 23 */
235+ rate_set >>= HW_HT_RATES_OFFSET - band->n_bitrates;
236+
237+ for (bit = 0; bit < 8; bit++) {
238+ if (rate_set & 0x1)
239+ enabled_rates |= (CONF_HW_BIT_RATE_MCS_0 << bit);
240+ rate_set >>= 1;
241+ }
242+#endif
243+
244 return enabled_rates;
245 }
246
247--
2481.6.6.1
249
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0005-wl1271-set-wl-vif-only-if-add_interface-succeeded.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0005-wl1271-set-wl-vif-only-if-add_interface-succeeded.patch
new file mode 100644
index 00000000..3707b7c3
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0005-wl1271-set-wl-vif-only-if-add_interface-succeeded.patch
@@ -0,0 +1,86 @@
1From dd812452fb91de492a8fd8d838d16cfc67cbfcf4 Mon Sep 17 00:00:00 2001
2From: Eliad Peller <eliad@wizery.com>
3Date: Thu, 28 Oct 2010 21:46:43 +0200
4Subject: [PATCH 05/15] wl1271: set wl->vif only if add_interface succeeded.
5
6set wl->vif to the newly created interface only after the firmware booted
7successfully. on the way - make the function flow more clear.
8
9Signed-off-by: Eliad Peller <eliad@wizery.com>
10Reviewed-by: Luciano Coelho <luciano.coelho@nokia.com>
11Signed-off-by: Luciano Coelho <luciano.coelho@nokia.com>
12---
13 drivers/net/wireless/wl12xx/wl1271_main.c | 33 +++++++++++++++++-----------
14 1 files changed, 20 insertions(+), 13 deletions(-)
15
16diff --git a/drivers/net/wireless/wl12xx/wl1271_main.c b/drivers/net/wireless/wl12xx/wl1271_main.c
17index 49ec0ef..78273c9 100644
18--- a/drivers/net/wireless/wl12xx/wl1271_main.c
19+++ b/drivers/net/wireless/wl12xx/wl1271_main.c
20@@ -939,18 +939,19 @@ static int wl1271_op_add_interface(struct ieee80211_hw *hw,
21 struct wiphy *wiphy = hw->wiphy;
22 int retries = WL1271_BOOT_RETRIES;
23 int ret = 0;
24+ bool booted = false;
25
26 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
27 vif->type, vif->addr);
28
29 mutex_lock(&wl->mutex);
30 if (wl->vif) {
31+ wl1271_debug(DEBUG_MAC80211,
32+ "multiple vifs are not supported yet");
33 ret = -EBUSY;
34 goto out;
35 }
36
37- wl->vif = vif;
38-
39 switch (vif->type) {
40 case NL80211_IFTYPE_STATION:
41 wl->bss_type = BSS_TYPE_STA_BSS;
42@@ -988,15 +989,8 @@ static int wl1271_op_add_interface(struct ieee80211_hw *hw,
43 if (ret < 0)
44 goto irq_disable;
45
46- wl->state = WL1271_STATE_ON;
47- wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
48-
49- /* update hw/fw version info in wiphy struct */
50- wiphy->hw_version = wl->chip.id;
51- strncpy(wiphy->fw_version, wl->chip.fw_ver,
52- sizeof(wiphy->fw_version));
53-
54- goto out;
55+ booted = true;
56+ break;
57
58 irq_disable:
59 wl1271_disable_interrupts(wl);
60@@ -1014,8 +1008,21 @@ power_off:
61 wl1271_power_off(wl);
62 }
63
64- wl1271_error("firmware boot failed despite %d retries",
65- WL1271_BOOT_RETRIES);
66+ if (!booted) {
67+ wl1271_error("firmware boot failed despite %d retries",
68+ WL1271_BOOT_RETRIES);
69+ goto out;
70+ }
71+
72+ wl->vif = vif;
73+ wl->state = WL1271_STATE_ON;
74+ wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
75+
76+ /* update hw/fw version info in wiphy struct */
77+ wiphy->hw_version = wl->chip.id;
78+ strncpy(wiphy->fw_version, wl->chip.fw_ver,
79+ sizeof(wiphy->fw_version));
80+
81 out:
82 mutex_unlock(&wl->mutex);
83
84--
851.6.6.1
86
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0006-wl12xx-Unset-bssid-filter-ssid-and-bssid-from-firmwa.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0006-wl12xx-Unset-bssid-filter-ssid-and-bssid-from-firmwa.patch
new file mode 100644
index 00000000..5b83bc96
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0006-wl12xx-Unset-bssid-filter-ssid-and-bssid-from-firmwa.patch
@@ -0,0 +1,44 @@
1From 54b32b60bed66ac4ecf00279466496d9d4e80afa Mon Sep 17 00:00:00 2001
2From: Juuso Oikarinen <juuso.oikarinen@nokia.com>
3Date: Mon, 22 Nov 2010 12:59:08 +0200
4Subject: [PATCH 06/15] wl12xx: Unset bssid filter, ssid and bssid from firmware on disassoc
5
6On the disassociation event from the mac80211, the wl12xx driver does not
7clear the chipset configuration related to the AP - i.e. it does not perform
8a DISCONNECT and then a JOIN with zero SSID and dummy BSSID. Also, it does not
9unset the BSSID filter.
10
11Often this is not a problem, as the above is performed upon entering idle
12state. But if a scenario arises where a new association is attempted without
13cycling through idle state, the new association will fail.
14
15Fix this by resetting the firmware state on disassociation.
16
17Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
18Reviewed-by: Luciano Coelho <luciano.coelho@nokia.com>
19Signed-off-by: Luciano Coelho <luciano.coelho@nokia.com>
20---
21 drivers/net/wireless/wl12xx/wl1271_main.c | 5 ++++-
22 1 files changed, 4 insertions(+), 1 deletions(-)
23
24diff --git a/drivers/net/wireless/wl12xx/wl1271_main.c b/drivers/net/wireless/wl12xx/wl1271_main.c
25index 78273c9..db97648 100644
26--- a/drivers/net/wireless/wl12xx/wl1271_main.c
27+++ b/drivers/net/wireless/wl12xx/wl1271_main.c
28@@ -1919,9 +1919,12 @@ static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
29
30 /* Disable the keep-alive feature */
31 ret = wl1271_acx_keep_alive_mode(wl, false);
32-
33 if (ret < 0)
34 goto out_sleep;
35+
36+ /* restore the bssid filter and go to dummy bssid */
37+ wl1271_unjoin(wl);
38+ wl1271_dummy_join(wl);
39 }
40
41 }
42--
431.6.6.1
44
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0007-drivers-media-radio-wl128x-FM-Driver-common-header-f.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0007-drivers-media-radio-wl128x-FM-Driver-common-header-f.patch
new file mode 100644
index 00000000..d104a727
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0007-drivers-media-radio-wl128x-FM-Driver-common-header-f.patch
@@ -0,0 +1,268 @@
1From f568ec9bb6ccd1e17278dcab3fbc810cf2e071ac Mon Sep 17 00:00:00 2001
2From: Manjunatha Halli <manjunatha_halli@ti.com>
3Date: Tue, 11 Jan 2011 11:31:21 +0000
4Subject: [PATCH 07/15] drivers:media:radio: wl128x: FM Driver common header file
5
6These are common headers used in FM submodules (FM V4L2,
7FM common, FM Rx,and FM TX).
8
9Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com>
10Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl>
11---
12 drivers/media/radio/wl128x/fmdrv.h | 244 ++++++++++++++++++++++++++++++++++++
13 1 files changed, 244 insertions(+), 0 deletions(-)
14 create mode 100644 drivers/media/radio/wl128x/fmdrv.h
15
16diff --git a/drivers/media/radio/wl128x/fmdrv.h b/drivers/media/radio/wl128x/fmdrv.h
17new file mode 100644
18index 0000000..392b62d
19--- /dev/null
20+++ b/drivers/media/radio/wl128x/fmdrv.h
21@@ -0,0 +1,244 @@
22+/*
23+ * FM Driver for Connectivity chip of Texas Instruments.
24+ *
25+ * Common header for all FM driver sub-modules.
26+ *
27+ * Copyright (C) 2011 Texas Instruments
28+ *
29+ * This program is free software; you can redistribute it and/or modify
30+ * it under the terms of the GNU General Public License version 2 as
31+ * published by the Free Software Foundation.
32+ *
33+ * This program is distributed in the hope that it will be useful,
34+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
35+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36+ * GNU General Public License for more details.
37+ *
38+ * You should have received a copy of the GNU General Public License
39+ * along with this program; if not, write to the Free Software
40+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
41+ *
42+ */
43+
44+#ifndef _FM_DRV_H
45+#define _FM_DRV_H
46+
47+#include <linux/skbuff.h>
48+#include <linux/interrupt.h>
49+#include <sound/core.h>
50+#include <sound/initval.h>
51+#include <linux/timer.h>
52+#include <linux/version.h>
53+#include <media/v4l2-ioctl.h>
54+#include <media/v4l2-common.h>
55+#include <media/v4l2-ctrls.h>
56+
57+#define FM_DRV_VERSION "0.09"
58+/* Should match with FM_DRV_VERSION */
59+#define FM_DRV_RADIO_VERSION KERNEL_VERSION(0, 0, 1)
60+#define FM_DRV_NAME "ti_fmdrv"
61+#define FM_DRV_CARD_SHORT_NAME "TI FM Radio"
62+#define FM_DRV_CARD_LONG_NAME "Texas Instruments FM Radio"
63+
64+/* Flag info */
65+#define FM_INTTASK_RUNNING 0
66+#define FM_INTTASK_SCHEDULE_PENDING 1
67+#define FM_FW_DW_INPROGRESS 2
68+#define FM_CORE_READY 3
69+#define FM_CORE_TRANSPORT_READY 4
70+#define FM_AF_SWITCH_INPROGRESS 5
71+#define FM_CORE_TX_XMITING 6
72+
73+#define FM_TUNE_COMPLETE 0x1
74+#define FM_BAND_LIMIT 0x2
75+
76+#define FM_DRV_TX_TIMEOUT (5*HZ) /* 5 seconds */
77+#define FM_DRV_RX_SEEK_TIMEOUT (20*HZ) /* 20 seconds */
78+
79+#define NO_OF_ENTRIES_IN_ARRAY(array) (sizeof(array) / sizeof(array[0]))
80+
81+#define fmerr(format, ...) \
82+ printk(KERN_ERR "fmdrv: " format, ## __VA_ARGS__)
83+#define fmwarn(format, ...) \
84+ printk(KERN_WARNING "fmdrv: " format, ##__VA_ARGS__)
85+#ifdef DEBUG
86+#define fmdbg(format, ...) \
87+ printk(KERN_DEBUG "fmdrv: " format, ## __VA_ARGS__)
88+#else /* DEBUG */
89+#define fmdbg(format, ...)
90+#endif
91+enum {
92+ FM_MODE_OFF,
93+ FM_MODE_TX,
94+ FM_MODE_RX,
95+ FM_MODE_ENTRY_MAX
96+};
97+
98+#define FM_RX_RDS_INFO_FIELD_MAX 8 /* 4 Group * 2 Bytes */
99+
100+/* RX RDS data format */
101+struct fm_rdsdata_format {
102+ union {
103+ struct {
104+ u8 buff[FM_RX_RDS_INFO_FIELD_MAX];
105+ } groupdatabuff;
106+ struct {
107+ u16 pidata;
108+ u8 blk_b[2];
109+ u8 blk_c[2];
110+ u8 blk_d[2];
111+ } groupgeneral;
112+ struct {
113+ u16 pidata;
114+ u8 blk_b[2];
115+ u8 af[2];
116+ u8 ps[2];
117+ } group0A;
118+ struct {
119+ u16 pi[2];
120+ u8 blk_b[2];
121+ u8 ps[2];
122+ } group0B;
123+ } data;
124+};
125+
126+/* FM region (Europe/US, Japan) info */
127+struct region_info {
128+ u32 chanl_space;
129+ u32 bot_freq;
130+ u32 top_freq;
131+ u8 fm_band;
132+};
133+struct fmdev;
134+typedef void (*int_handler_prototype) (struct fmdev *);
135+
136+/* FM Interrupt processing related info */
137+struct fm_irq {
138+ u8 stage;
139+ u16 flag; /* FM interrupt flag */
140+ u16 mask; /* FM interrupt mask */
141+ /* Interrupt process timeout handler */
142+ struct timer_list timer;
143+ u8 retry;
144+ int_handler_prototype *handlers;
145+};
146+
147+/* RDS info */
148+struct fm_rds {
149+ u8 flag; /* RX RDS on/off status */
150+ u8 last_blk_idx; /* Last received RDS block */
151+
152+ /* RDS buffer */
153+ wait_queue_head_t read_queue;
154+ u32 buf_size; /* Size is always multiple of 3 */
155+ u32 wr_idx;
156+ u32 rd_idx;
157+ u8 *buff;
158+};
159+
160+#define FM_RDS_MAX_AF_LIST 25
161+
162+/*
163+ * Current RX channel Alternate Frequency cache.
164+ * This info is used to switch to other freq (AF)
165+ * when current channel signal strengh is below RSSI threshold.
166+ */
167+struct tuned_station_info {
168+ u16 picode;
169+ u32 af_cache[FM_RDS_MAX_AF_LIST];
170+ u8 afcache_size;
171+ u8 af_list_max;
172+};
173+
174+/* FM RX mode info */
175+struct fm_rx {
176+ struct region_info region; /* Current selected band */
177+ u32 freq; /* Current RX frquency */
178+ u8 mute_mode; /* Current mute mode */
179+ u8 deemphasis_mode; /* Current deemphasis mode */
180+ /* RF dependent soft mute mode */
181+ u8 rf_depend_mute;
182+ u16 volume; /* Current volume level */
183+ u16 rssi_threshold; /* Current RSSI threshold level */
184+ /* Holds the index of the current AF jump */
185+ u8 afjump_idx;
186+ /* Will hold the frequency before the jump */
187+ u32 freq_before_jump;
188+ u8 rds_mode; /* RDS operation mode (RDS/RDBS) */
189+ u8 af_mode; /* Alternate frequency on/off */
190+ struct tuned_station_info stat_info;
191+ struct fm_rds rds;
192+};
193+
194+#define FMTX_RDS_TXT_STR_SIZE 25
195+/*
196+ * FM TX RDS data
197+ *
198+ * @ text_type: is the text following PS or RT
199+ * @ text: radio text string which could either be PS or RT
200+ * @ af_freq: alternate frequency for Tx
201+ * TODO: to be declared in application
202+ */
203+struct tx_rds {
204+ u8 text_type;
205+ u8 text[FMTX_RDS_TXT_STR_SIZE];
206+ u8 flag;
207+ u32 af_freq;
208+};
209+/*
210+ * FM TX global data
211+ *
212+ * @ pwr_lvl: Power Level of the Transmission from mixer control
213+ * @ xmit_state: Transmission state = Updated locally upon Start/Stop
214+ * @ audio_io: i2S/Analog
215+ * @ tx_frq: Transmission frequency
216+ */
217+struct fmtx_data {
218+ u8 pwr_lvl;
219+ u8 xmit_state;
220+ u8 audio_io;
221+ u8 region;
222+ u16 aud_mode;
223+ u32 preemph;
224+ u32 tx_frq;
225+ struct tx_rds rds;
226+};
227+
228+/* FM driver operation structure */
229+struct fmdev {
230+ struct video_device *radio_dev; /* V4L2 video device pointer */
231+ struct snd_card *card; /* Card which holds FM mixer controls */
232+ u16 asci_id;
233+ spinlock_t rds_buff_lock; /* To protect access to RDS buffer */
234+ spinlock_t resp_skb_lock; /* To protect access to received SKB */
235+
236+ long flag; /* FM driver state machine info */
237+ u8 streg_cbdata; /* status of ST registration */
238+
239+ struct sk_buff_head rx_q; /* RX queue */
240+ struct tasklet_struct rx_task; /* RX Tasklet */
241+
242+ struct sk_buff_head tx_q; /* TX queue */
243+ struct tasklet_struct tx_task; /* TX Tasklet */
244+ unsigned long last_tx_jiffies; /* Timestamp of last pkt sent */
245+ atomic_t tx_cnt; /* Number of packets can send at a time */
246+
247+ struct sk_buff *resp_skb; /* Response from the chip */
248+ /* Main task completion handler */
249+ struct completion maintask_comp;
250+ /* Opcode of last command sent to the chip */
251+ u8 pre_op;
252+ /* Handler used for wakeup when response packet is received */
253+ struct completion *resp_comp;
254+ struct fm_irq irq_info;
255+ u8 curr_fmmode; /* Current FM chip mode (TX, RX, OFF) */
256+ struct fm_rx rx; /* FM receiver info */
257+ struct fmtx_data tx_data;
258+
259+ /* V4L2 ctrl framwork handler*/
260+ struct v4l2_ctrl_handler ctrl_handler;
261+
262+ /* For core assisted locking */
263+ struct mutex mutex;
264+};
265+#endif
266--
2671.6.6.1
268
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0008-drivers-media-radio-wl128x-FM-Driver-V4L2-sources.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0008-drivers-media-radio-wl128x-FM-Driver-V4L2-sources.patch
new file mode 100644
index 00000000..c3eae97f
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0008-drivers-media-radio-wl128x-FM-Driver-V4L2-sources.patch
@@ -0,0 +1,645 @@
1From d532e33a286ec2275b441c05675de52cd5b069d2 Mon Sep 17 00:00:00 2001
2From: Manjunatha Halli <manjunatha_halli@ti.com>
3Date: Tue, 11 Jan 2011 11:31:22 +0000
4Subject: [PATCH 08/15] drivers:media:radio: wl128x: FM Driver V4L2 sources
5
6This module interfaces V4L2 subsystem and FM common module.
7It registers itself with V4L2 as Radio module.
8
9Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com>
10Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl>
11---
12 drivers/media/radio/wl128x/fmdrv_v4l2.c | 580 +++++++++++++++++++++++++++++++
13 drivers/media/radio/wl128x/fmdrv_v4l2.h | 33 ++
14 2 files changed, 613 insertions(+), 0 deletions(-)
15 create mode 100644 drivers/media/radio/wl128x/fmdrv_v4l2.c
16 create mode 100644 drivers/media/radio/wl128x/fmdrv_v4l2.h
17
18diff --git a/drivers/media/radio/wl128x/fmdrv_v4l2.c b/drivers/media/radio/wl128x/fmdrv_v4l2.c
19new file mode 100644
20index 0000000..d50e5ac
21--- /dev/null
22+++ b/drivers/media/radio/wl128x/fmdrv_v4l2.c
23@@ -0,0 +1,580 @@
24+/*
25+ * FM Driver for Connectivity chip of Texas Instruments.
26+ * This file provides interfaces to V4L2 subsystem.
27+ *
28+ * This module registers with V4L2 subsystem as Radio
29+ * data system interface (/dev/radio). During the registration,
30+ * it will expose two set of function pointers.
31+ *
32+ * 1) File operation related API (open, close, read, write, poll...etc).
33+ * 2) Set of V4L2 IOCTL complaint API.
34+ *
35+ * Copyright (C) 2011 Texas Instruments
36+ * Author: Raja Mani <raja_mani@ti.com>
37+ * Author: Manjunatha Halli <manjunatha_halli@ti.com>
38+ *
39+ * This program is free software; you can redistribute it and/or modify
40+ * it under the terms of the GNU General Public License version 2 as
41+ * published by the Free Software Foundation.
42+ *
43+ * This program is distributed in the hope that it will be useful,
44+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
45+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
46+ * GNU General Public License for more details.
47+ *
48+ * You should have received a copy of the GNU General Public License
49+ * along with this program; if not, write to the Free Software
50+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
51+ *
52+ */
53+
54+#include "fmdrv.h"
55+#include "fmdrv_v4l2.h"
56+#include "fmdrv_common.h"
57+#include "fmdrv_rx.h"
58+#include "fmdrv_tx.h"
59+
60+static struct video_device *gradio_dev;
61+static u8 radio_disconnected;
62+
63+/* -- V4L2 RADIO (/dev/radioX) device file operation interfaces --- */
64+
65+/* Read RX RDS data */
66+static ssize_t fm_v4l2_fops_read(struct file *file, char __user * buf,
67+ size_t count, loff_t *ppos)
68+{
69+ u8 rds_mode;
70+ int ret;
71+ struct fmdev *fmdev;
72+
73+ fmdev = video_drvdata(file);
74+
75+ if (!radio_disconnected) {
76+ fmerr("FM device is already disconnected\n");
77+ return -EIO;
78+ }
79+
80+ /* Turn on RDS mode , if it is disabled */
81+ ret = fm_rx_get_rds_mode(fmdev, &rds_mode);
82+ if (ret < 0) {
83+ fmerr("Unable to read current rds mode\n");
84+ return ret;
85+ }
86+
87+ if (rds_mode == FM_RDS_DISABLE) {
88+ ret = fmc_set_rds_mode(fmdev, FM_RDS_ENABLE);
89+ if (ret < 0) {
90+ fmerr("Failed to enable rds mode\n");
91+ return ret;
92+ }
93+ }
94+
95+ /* Copy RDS data from internal buffer to user buffer */
96+ return fmc_transfer_rds_from_internal_buff(fmdev, file, buf, count);
97+}
98+
99+/* Write TX RDS data */
100+static ssize_t fm_v4l2_fops_write(struct file *file, const char __user * buf,
101+ size_t count, loff_t *ppos)
102+{
103+ struct tx_rds rds;
104+ int ret;
105+ struct fmdev *fmdev;
106+
107+ ret = copy_from_user(&rds, buf, sizeof(rds));
108+ fmdbg("(%d)type: %d, text %s, af %d\n",
109+ ret, rds.text_type, rds.text, rds.af_freq);
110+
111+ fmdev = video_drvdata(file);
112+ fm_tx_set_radio_text(fmdev, rds.text, rds.text_type);
113+ fm_tx_set_af(fmdev, rds.af_freq);
114+
115+ return 0;
116+}
117+
118+static u32 fm_v4l2_fops_poll(struct file *file, struct poll_table_struct *pts)
119+{
120+ int ret;
121+ struct fmdev *fmdev;
122+
123+ fmdev = video_drvdata(file);
124+ ret = fmc_is_rds_data_available(fmdev, file, pts);
125+ if (ret < 0)
126+ return POLLIN | POLLRDNORM;
127+
128+ return 0;
129+}
130+
131+/*
132+ * Handle open request for "/dev/radioX" device.
133+ * Start with FM RX mode as default.
134+ */
135+static int fm_v4l2_fops_open(struct file *file)
136+{
137+ int ret;
138+ struct fmdev *fmdev = NULL;
139+
140+ /* Don't allow multiple open */
141+ if (radio_disconnected) {
142+ fmerr("FM device is already opened\n");
143+ return -EBUSY;
144+ }
145+
146+ fmdev = video_drvdata(file);
147+
148+ ret = fmc_prepare(fmdev);
149+ if (ret < 0) {
150+ fmerr("Unable to prepare FM CORE\n");
151+ return ret;
152+ }
153+
154+ fmdbg("Load FM RX firmware..\n");
155+
156+ ret = fmc_set_mode(fmdev, FM_MODE_RX);
157+ if (ret < 0) {
158+ fmerr("Unable to load FM RX firmware\n");
159+ return ret;
160+ }
161+ radio_disconnected = 1;
162+
163+ return ret;
164+}
165+
166+static int fm_v4l2_fops_release(struct file *file)
167+{
168+ int ret;
169+ struct fmdev *fmdev;
170+
171+ fmdev = video_drvdata(file);
172+ if (!radio_disconnected) {
173+ fmdbg("FM device is already closed\n");
174+ return 0;
175+ }
176+
177+ ret = fmc_set_mode(fmdev, FM_MODE_OFF);
178+ if (ret < 0) {
179+ fmerr("Unable to turn off the chip\n");
180+ return ret;
181+ }
182+
183+ ret = fmc_release(fmdev);
184+ if (ret < 0) {
185+ fmerr("FM CORE release failed\n");
186+ return ret;
187+ }
188+ radio_disconnected = 0;
189+
190+ return ret;
191+}
192+
193+/* V4L2 RADIO (/dev/radioX) device IOCTL interfaces */
194+static int fm_v4l2_vidioc_querycap(struct file *file, void *priv,
195+ struct v4l2_capability *capability)
196+{
197+ strlcpy(capability->driver, FM_DRV_NAME, sizeof(capability->driver));
198+ strlcpy(capability->card, FM_DRV_CARD_SHORT_NAME,
199+ sizeof(capability->card));
200+ sprintf(capability->bus_info, "UART");
201+ capability->version = FM_DRV_RADIO_VERSION;
202+ capability->capabilities = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
203+ V4L2_CAP_RADIO | V4L2_CAP_MODULATOR |
204+ V4L2_CAP_AUDIO | V4L2_CAP_READWRITE |
205+ V4L2_CAP_RDS_CAPTURE;
206+
207+ return 0;
208+}
209+
210+static int fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
211+{
212+ struct fmdev *fmdev = container_of(ctrl->handler,
213+ struct fmdev, ctrl_handler);
214+
215+ switch (ctrl->id) {
216+ case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
217+ ctrl->val = fm_tx_get_tune_cap_val(fmdev);
218+ break;
219+ default:
220+ fmwarn("%s: Unknown IOCTL: %d\n", __func__, ctrl->id);
221+ break;
222+ }
223+
224+ return 0;
225+}
226+
227+static int fm_v4l2_s_ctrl(struct v4l2_ctrl *ctrl)
228+{
229+ struct fmdev *fmdev = container_of(ctrl->handler,
230+ struct fmdev, ctrl_handler);
231+
232+ switch (ctrl->id) {
233+ case V4L2_CID_AUDIO_VOLUME: /* set volume */
234+ return fm_rx_set_volume(fmdev, (u16)ctrl->val);
235+
236+ case V4L2_CID_AUDIO_MUTE: /* set mute */
237+ return fmc_set_mute_mode(fmdev, (u8)ctrl->val);
238+
239+ case V4L2_CID_TUNE_POWER_LEVEL:
240+ /* set TX power level - ext control */
241+ return fm_tx_set_pwr_lvl(fmdev, (u8)ctrl->val);
242+
243+ case V4L2_CID_TUNE_PREEMPHASIS:
244+ return fm_tx_set_preemph_filter(fmdev, (u8) ctrl->val);
245+
246+ default:
247+ return -EINVAL;
248+ }
249+}
250+
251+static int fm_v4l2_vidioc_g_audio(struct file *file, void *priv,
252+ struct v4l2_audio *audio)
253+{
254+ memset(audio, 0, sizeof(*audio));
255+ strcpy(audio->name, "Radio");
256+ audio->capability = V4L2_AUDCAP_STEREO;
257+
258+ return 0;
259+}
260+
261+static int fm_v4l2_vidioc_s_audio(struct file *file, void *priv,
262+ struct v4l2_audio *audio)
263+{
264+ if (audio->index != 0)
265+ return -EINVAL;
266+
267+ return 0;
268+}
269+
270+/* Get tuner attributes. If current mode is NOT RX, return error */
271+static int fm_v4l2_vidioc_g_tuner(struct file *file, void *priv,
272+ struct v4l2_tuner *tuner)
273+{
274+ struct fmdev *fmdev = video_drvdata(file);
275+ u32 bottom_freq;
276+ u32 top_freq;
277+ u16 stereo_mono_mode;
278+ u16 rssilvl;
279+ int ret;
280+
281+ if (tuner->index != 0)
282+ return -EINVAL;
283+
284+ if (fmdev->curr_fmmode != FM_MODE_RX)
285+ return -EPERM;
286+
287+ ret = fm_rx_get_band_freq_range(fmdev, &bottom_freq, &top_freq);
288+ if (ret != 0)
289+ return ret;
290+
291+ ret = fm_rx_get_stereo_mono(fmdev, &stereo_mono_mode);
292+ if (ret != 0)
293+ return ret;
294+
295+ ret = fm_rx_get_rssi_level(fmdev, &rssilvl);
296+ if (ret != 0)
297+ return ret;
298+
299+ strcpy(tuner->name, "FM");
300+ tuner->type = V4L2_TUNER_RADIO;
301+ /* Store rangelow and rangehigh freq in unit of 62.5 Hz */
302+ tuner->rangelow = bottom_freq * 16;
303+ tuner->rangehigh = top_freq * 16;
304+ tuner->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO |
305+ ((fmdev->rx.rds.flag == FM_RDS_ENABLE) ? V4L2_TUNER_SUB_RDS : 0);
306+ tuner->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS |
307+ V4L2_TUNER_CAP_LOW;
308+ tuner->audmode = (stereo_mono_mode ?
309+ V4L2_TUNER_MODE_MONO : V4L2_TUNER_MODE_STEREO);
310+
311+ /*
312+ * Actual rssi value lies in between -128 to +127.
313+ * Convert this range from 0 to 255 by adding +128
314+ */
315+ rssilvl += 128;
316+
317+ /*
318+ * Return signal strength value should be within 0 to 65535.
319+ * Find out correct signal radio by multiplying (65535/255) = 257
320+ */
321+ tuner->signal = rssilvl * 257;
322+ tuner->afc = 0;
323+
324+ return ret;
325+}
326+
327+/*
328+ * Set tuner attributes. If current mode is NOT RX, set to RX.
329+ * Currently, we set only audio mode (mono/stereo) and RDS state (on/off).
330+ * Should we set other tuner attributes, too?
331+ */
332+static int fm_v4l2_vidioc_s_tuner(struct file *file, void *priv,
333+ struct v4l2_tuner *tuner)
334+{
335+ struct fmdev *fmdev = video_drvdata(file);
336+ u16 aud_mode;
337+ u8 rds_mode;
338+ int ret;
339+
340+ if (tuner->index != 0)
341+ return -EINVAL;
342+
343+ aud_mode = (tuner->audmode == V4L2_TUNER_MODE_STEREO) ?
344+ FM_STEREO_MODE : FM_MONO_MODE;
345+ rds_mode = (tuner->rxsubchans & V4L2_TUNER_SUB_RDS) ?
346+ FM_RDS_ENABLE : FM_RDS_DISABLE;
347+
348+ if (fmdev->curr_fmmode != FM_MODE_RX) {
349+ ret = fmc_set_mode(fmdev, FM_MODE_RX);
350+ if (ret < 0) {
351+ fmerr("Failed to set RX mode\n");
352+ return ret;
353+ }
354+ }
355+
356+ ret = fmc_set_stereo_mono(fmdev, aud_mode);
357+ if (ret < 0) {
358+ fmerr("Failed to set RX stereo/mono mode\n");
359+ return ret;
360+ }
361+
362+ ret = fmc_set_rds_mode(fmdev, rds_mode);
363+ if (ret < 0)
364+ fmerr("Failed to set RX RDS mode\n");
365+
366+ return ret;
367+}
368+
369+/* Get tuner or modulator radio frequency */
370+static int fm_v4l2_vidioc_g_freq(struct file *file, void *priv,
371+ struct v4l2_frequency *freq)
372+{
373+ struct fmdev *fmdev = video_drvdata(file);
374+ int ret;
375+
376+ ret = fmc_get_freq(fmdev, &freq->frequency);
377+ if (ret < 0) {
378+ fmerr("Failed to get frequency\n");
379+ return ret;
380+ }
381+
382+ /* Frequency unit of 62.5 Hz*/
383+ freq->frequency = (u32) freq->frequency * 16;
384+
385+ return 0;
386+}
387+
388+/* Set tuner or modulator radio frequency */
389+static int fm_v4l2_vidioc_s_freq(struct file *file, void *priv,
390+ struct v4l2_frequency *freq)
391+{
392+ struct fmdev *fmdev = video_drvdata(file);
393+
394+ /*
395+ * As V4L2_TUNER_CAP_LOW is set 1 user sends the frequency
396+ * in units of 62.5 Hz.
397+ */
398+ freq->frequency = (u32)(freq->frequency / 16);
399+
400+ return fmc_set_freq(fmdev, freq->frequency);
401+}
402+
403+/* Set hardware frequency seek. If current mode is NOT RX, set it RX. */
404+static int fm_v4l2_vidioc_s_hw_freq_seek(struct file *file, void *priv,
405+ struct v4l2_hw_freq_seek *seek)
406+{
407+ struct fmdev *fmdev = video_drvdata(file);
408+ int ret;
409+
410+ if (fmdev->curr_fmmode != FM_MODE_RX) {
411+ ret = fmc_set_mode(fmdev, FM_MODE_RX);
412+ if (ret != 0) {
413+ fmerr("Failed to set RX mode\n");
414+ return ret;
415+ }
416+ }
417+
418+ ret = fm_rx_seek(fmdev, seek->seek_upward, seek->wrap_around,
419+ seek->spacing);
420+ if (ret < 0)
421+ fmerr("RX seek failed - %d\n", ret);
422+
423+ return ret;
424+}
425+/* Get modulator attributes. If mode is not TX, return no attributes. */
426+static int fm_v4l2_vidioc_g_modulator(struct file *file, void *priv,
427+ struct v4l2_modulator *mod)
428+{
429+ struct fmdev *fmdev = video_drvdata(file);;
430+
431+ if (mod->index != 0)
432+ return -EINVAL;
433+
434+ if (fmdev->curr_fmmode != FM_MODE_TX)
435+ return -EPERM;
436+
437+ mod->txsubchans = ((fmdev->tx_data.aud_mode == FM_STEREO_MODE) ?
438+ V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO) |
439+ ((fmdev->tx_data.rds.flag == FM_RDS_ENABLE) ?
440+ V4L2_TUNER_SUB_RDS : 0);
441+
442+ mod->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS |
443+ V4L2_TUNER_CAP_LOW;
444+
445+ return 0;
446+}
447+
448+/* Set modulator attributes. If mode is not TX, set to TX. */
449+static int fm_v4l2_vidioc_s_modulator(struct file *file, void *priv,
450+ struct v4l2_modulator *mod)
451+{
452+ struct fmdev *fmdev = video_drvdata(file);
453+ u8 rds_mode;
454+ u16 aud_mode;
455+ int ret;
456+
457+ if (mod->index != 0)
458+ return -EINVAL;
459+
460+ if (fmdev->curr_fmmode != FM_MODE_TX) {
461+ ret = fmc_set_mode(fmdev, FM_MODE_TX);
462+ if (ret != 0) {
463+ fmerr("Failed to set TX mode\n");
464+ return ret;
465+ }
466+ }
467+
468+ aud_mode = (mod->txsubchans & V4L2_TUNER_SUB_STEREO) ?
469+ FM_STEREO_MODE : FM_MONO_MODE;
470+ rds_mode = (mod->txsubchans & V4L2_TUNER_SUB_RDS) ?
471+ FM_RDS_ENABLE : FM_RDS_DISABLE;
472+ ret = fm_tx_set_stereo_mono(fmdev, aud_mode);
473+ if (ret < 0) {
474+ fmerr("Failed to set mono/stereo mode for TX\n");
475+ return ret;
476+ }
477+ ret = fm_tx_set_rds_mode(fmdev, rds_mode);
478+ if (ret < 0)
479+ fmerr("Failed to set rds mode for TX\n");
480+
481+ return ret;
482+}
483+
484+static const struct v4l2_file_operations fm_drv_fops = {
485+ .owner = THIS_MODULE,
486+ .read = fm_v4l2_fops_read,
487+ .write = fm_v4l2_fops_write,
488+ .poll = fm_v4l2_fops_poll,
489+ .unlocked_ioctl = video_ioctl2,
490+ .open = fm_v4l2_fops_open,
491+ .release = fm_v4l2_fops_release,
492+};
493+
494+static const struct v4l2_ctrl_ops fm_ctrl_ops = {
495+ .s_ctrl = fm_v4l2_s_ctrl,
496+ .g_volatile_ctrl = fm_g_volatile_ctrl,
497+};
498+static const struct v4l2_ioctl_ops fm_drv_ioctl_ops = {
499+ .vidioc_querycap = fm_v4l2_vidioc_querycap,
500+ .vidioc_g_audio = fm_v4l2_vidioc_g_audio,
501+ .vidioc_s_audio = fm_v4l2_vidioc_s_audio,
502+ .vidioc_g_tuner = fm_v4l2_vidioc_g_tuner,
503+ .vidioc_s_tuner = fm_v4l2_vidioc_s_tuner,
504+ .vidioc_g_frequency = fm_v4l2_vidioc_g_freq,
505+ .vidioc_s_frequency = fm_v4l2_vidioc_s_freq,
506+ .vidioc_s_hw_freq_seek = fm_v4l2_vidioc_s_hw_freq_seek,
507+ .vidioc_g_modulator = fm_v4l2_vidioc_g_modulator,
508+ .vidioc_s_modulator = fm_v4l2_vidioc_s_modulator
509+};
510+
511+/* V4L2 RADIO device parent structure */
512+static struct video_device fm_viddev_template = {
513+ .fops = &fm_drv_fops,
514+ .ioctl_ops = &fm_drv_ioctl_ops,
515+ .name = FM_DRV_NAME,
516+ .release = video_device_release,
517+};
518+
519+int fm_v4l2_init_video_device(struct fmdev *fmdev, int radio_nr)
520+{
521+ struct v4l2_ctrl *ctrl;
522+ int ret;
523+
524+ /* Init mutex for core locking */
525+ mutex_init(&fmdev->mutex);
526+
527+ /* Allocate new video device */
528+ gradio_dev = video_device_alloc();
529+ if (NULL == gradio_dev) {
530+ fmerr("Can't allocate video device\n");
531+ return -ENOMEM;
532+ }
533+
534+ /* Setup FM driver's V4L2 properties */
535+ memcpy(gradio_dev, &fm_viddev_template, sizeof(fm_viddev_template));
536+
537+ video_set_drvdata(gradio_dev, fmdev);
538+
539+ gradio_dev->lock = &fmdev->mutex;
540+
541+ /* Register with V4L2 subsystem as RADIO device */
542+ if (video_register_device(gradio_dev, VFL_TYPE_RADIO, radio_nr)) {
543+ video_device_release(gradio_dev);
544+ fmerr("Could not register video device\n");
545+ return -ENOMEM;
546+ }
547+
548+ fmdev->radio_dev = gradio_dev;
549+
550+ /* Register to v4l2 ctrl handler framework */
551+ fmdev->radio_dev->ctrl_handler = &fmdev->ctrl_handler;
552+
553+ ret = v4l2_ctrl_handler_init(&fmdev->ctrl_handler, 5);
554+ if (ret < 0) {
555+ fmerr("(fmdev): Can't init ctrl handler\n");
556+ v4l2_ctrl_handler_free(&fmdev->ctrl_handler);
557+ return -EBUSY;
558+ }
559+
560+ /*
561+ * Following controls are handled by V4L2 control framework.
562+ * Added in ascending ID order.
563+ */
564+ v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
565+ V4L2_CID_AUDIO_VOLUME, FM_RX_VOLUME_MIN,
566+ FM_RX_VOLUME_MAX, 1, FM_RX_VOLUME_MAX);
567+
568+ v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
569+ V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
570+
571+ v4l2_ctrl_new_std_menu(&fmdev->ctrl_handler, &fm_ctrl_ops,
572+ V4L2_CID_TUNE_PREEMPHASIS, V4L2_PREEMPHASIS_75_uS,
573+ 0, V4L2_PREEMPHASIS_75_uS);
574+
575+ v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
576+ V4L2_CID_TUNE_POWER_LEVEL, FM_PWR_LVL_LOW,
577+ FM_PWR_LVL_HIGH, 1, FM_PWR_LVL_HIGH);
578+
579+ ctrl = v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
580+ V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0,
581+ 255, 1, 255);
582+
583+ if (ctrl)
584+ ctrl->is_volatile = 1;
585+
586+ return 0;
587+}
588+
589+void *fm_v4l2_deinit_video_device(void)
590+{
591+ struct fmdev *fmdev;
592+
593+
594+ fmdev = video_get_drvdata(gradio_dev);
595+
596+ /* Unregister to v4l2 ctrl handler framework*/
597+ v4l2_ctrl_handler_free(&fmdev->ctrl_handler);
598+
599+ /* Unregister RADIO device from V4L2 subsystem */
600+ video_unregister_device(gradio_dev);
601+
602+ return fmdev;
603+}
604diff --git a/drivers/media/radio/wl128x/fmdrv_v4l2.h b/drivers/media/radio/wl128x/fmdrv_v4l2.h
605new file mode 100644
606index 0000000..0ba79d7
607--- /dev/null
608+++ b/drivers/media/radio/wl128x/fmdrv_v4l2.h
609@@ -0,0 +1,33 @@
610+/*
611+ * FM Driver for Connectivity chip of Texas Instruments.
612+ *
613+ * FM V4L2 module header.
614+ *
615+ * Copyright (C) 2011 Texas Instruments
616+ *
617+ * This program is free software; you can redistribute it and/or modify
618+ * it under the terms of the GNU General Public License version 2 as
619+ * published by the Free Software Foundation.
620+ *
621+ * This program is distributed in the hope that it will be useful,
622+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
623+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
624+ * GNU General Public License for more details.
625+ *
626+ * You should have received a copy of the GNU General Public License
627+ * along with this program; if not, write to the Free Software
628+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
629+ *
630+ */
631+
632+#ifndef _FMDRV_V4L2_H
633+#define _FMDRV_V4L2_H
634+
635+#include <media/v4l2-ioctl.h>
636+#include <media/v4l2-common.h>
637+#include <media/v4l2-ctrls.h>
638+
639+int fm_v4l2_init_video_device(struct fmdev *, int);
640+void *fm_v4l2_deinit_video_device(void);
641+
642+#endif
643--
6441.6.6.1
645
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch
new file mode 100644
index 00000000..61dc164b
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch
@@ -0,0 +1,2114 @@
1From 1c32040233847f9c7998e7c557fa80dfd953e236 Mon Sep 17 00:00:00 2001
2From: Manjunatha Halli <manjunatha_halli@ti.com>
3Date: Tue, 11 Jan 2011 11:31:23 +0000
4Subject: [PATCH 09/15] drivers:media:radio: wl128x: FM Driver Common sources
5
6These are the sources for the common interfaces required by the
7FM V4L2 driver for TI WL127x and WL128x chips.
8
9These implement the FM channel-8 protocol communication with the
10chip. This makes use of the Shared Transport as its transport.
11
12Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com>
13Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl>
14---
15 drivers/media/radio/wl128x/fmdrv_common.c | 1677 +++++++++++++++++++++++++++++
16 drivers/media/radio/wl128x/fmdrv_common.h | 402 +++++++
17 2 files changed, 2079 insertions(+), 0 deletions(-)
18 create mode 100644 drivers/media/radio/wl128x/fmdrv_common.c
19 create mode 100644 drivers/media/radio/wl128x/fmdrv_common.h
20
21diff --git a/drivers/media/radio/wl128x/fmdrv_common.c b/drivers/media/radio/wl128x/fmdrv_common.c
22new file mode 100644
23index 0000000..12f4c65
24--- /dev/null
25+++ b/drivers/media/radio/wl128x/fmdrv_common.c
26@@ -0,0 +1,1677 @@
27+/*
28+ * FM Driver for Connectivity chip of Texas Instruments.
29+ *
30+ * This sub-module of FM driver is common for FM RX and TX
31+ * functionality. This module is responsible for:
32+ * 1) Forming group of Channel-8 commands to perform particular
33+ * functionality (eg., frequency set require more than
34+ * one Channel-8 command to be sent to the chip).
35+ * 2) Sending each Channel-8 command to the chip and reading
36+ * response back over Shared Transport.
37+ * 3) Managing TX and RX Queues and Tasklets.
38+ * 4) Handling FM Interrupt packet and taking appropriate action.
39+ * 5) Loading FM firmware to the chip (common, FM TX, and FM RX
40+ * firmware files based on mode selection)
41+ *
42+ * Copyright (C) 2011 Texas Instruments
43+ * Author: Raja Mani <raja_mani@ti.com>
44+ * Author: Manjunatha Halli <manjunatha_halli@ti.com>
45+ *
46+ * This program is free software; you can redistribute it and/or modify
47+ * it under the terms of the GNU General Public License version 2 as
48+ * published by the Free Software Foundation.
49+ *
50+ * This program is distributed in the hope that it will be useful,
51+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
52+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
53+ * GNU General Public License for more details.
54+ *
55+ * You should have received a copy of the GNU General Public License
56+ * along with this program; if not, write to the Free Software
57+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
58+ *
59+ */
60+
61+#include <linux/module.h>
62+#include <linux/firmware.h>
63+#include <linux/delay.h>
64+#include "fmdrv.h"
65+#include "fmdrv_v4l2.h"
66+#include "fmdrv_common.h"
67+#include <linux/ti_wilink_st.h>
68+#include "fmdrv_rx.h"
69+#include "fmdrv_tx.h"
70+
71+/* Region info */
72+static struct region_info region_configs[] = {
73+ /* Europe/US */
74+ {
75+ .chanl_space = FM_CHANNEL_SPACING_200KHZ * FM_FREQ_MUL,
76+ .bot_freq = 87500, /* 87.5 MHz */
77+ .top_freq = 108000, /* 108 MHz */
78+ .fm_band = 0,
79+ },
80+ /* Japan */
81+ {
82+ .chanl_space = FM_CHANNEL_SPACING_200KHZ * FM_FREQ_MUL,
83+ .bot_freq = 76000, /* 76 MHz */
84+ .top_freq = 90000, /* 90 MHz */
85+ .fm_band = 1,
86+ },
87+};
88+
89+/* Band selection */
90+static u8 default_radio_region; /* Europe/US */
91+module_param(default_radio_region, byte, 0);
92+MODULE_PARM_DESC(default_radio_region, "Region: 0=Europe/US, 1=Japan");
93+
94+/* RDS buffer blocks */
95+static u32 default_rds_buf = 300;
96+module_param(default_rds_buf, uint, 0444);
97+MODULE_PARM_DESC(rds_buf, "RDS buffer entries");
98+
99+/* Radio Nr */
100+static u32 radio_nr = -1;
101+module_param(radio_nr, int, 0444);
102+MODULE_PARM_DESC(radio_nr, "Radio Nr");
103+
104+/* FM irq handlers forward declaration */
105+static void fm_irq_send_flag_getcmd(struct fmdev *);
106+static void fm_irq_handle_flag_getcmd_resp(struct fmdev *);
107+static void fm_irq_handle_hw_malfunction(struct fmdev *);
108+static void fm_irq_handle_rds_start(struct fmdev *);
109+static void fm_irq_send_rdsdata_getcmd(struct fmdev *);
110+static void fm_irq_handle_rdsdata_getcmd_resp(struct fmdev *);
111+static void fm_irq_handle_rds_finish(struct fmdev *);
112+static void fm_irq_handle_tune_op_ended(struct fmdev *);
113+static void fm_irq_handle_power_enb(struct fmdev *);
114+static void fm_irq_handle_low_rssi_start(struct fmdev *);
115+static void fm_irq_afjump_set_pi(struct fmdev *);
116+static void fm_irq_handle_set_pi_resp(struct fmdev *);
117+static void fm_irq_afjump_set_pimask(struct fmdev *);
118+static void fm_irq_handle_set_pimask_resp(struct fmdev *);
119+static void fm_irq_afjump_setfreq(struct fmdev *);
120+static void fm_irq_handle_setfreq_resp(struct fmdev *);
121+static void fm_irq_afjump_enableint(struct fmdev *);
122+static void fm_irq_afjump_enableint_resp(struct fmdev *);
123+static void fm_irq_start_afjump(struct fmdev *);
124+static void fm_irq_handle_start_afjump_resp(struct fmdev *);
125+static void fm_irq_afjump_rd_freq(struct fmdev *);
126+static void fm_irq_afjump_rd_freq_resp(struct fmdev *);
127+static void fm_irq_handle_low_rssi_finish(struct fmdev *);
128+static void fm_irq_send_intmsk_cmd(struct fmdev *);
129+static void fm_irq_handle_intmsk_cmd_resp(struct fmdev *);
130+
131+/*
132+ * When FM common module receives interrupt packet, following handlers
133+ * will be executed one after another to service the interrupt(s)
134+ */
135+enum fmc_irq_handler_index {
136+ FM_SEND_FLAG_GETCMD_IDX,
137+ FM_HANDLE_FLAG_GETCMD_RESP_IDX,
138+
139+ /* HW malfunction irq handler */
140+ FM_HW_MAL_FUNC_IDX,
141+
142+ /* RDS threshold reached irq handler */
143+ FM_RDS_START_IDX,
144+ FM_RDS_SEND_RDS_GETCMD_IDX,
145+ FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX,
146+ FM_RDS_FINISH_IDX,
147+
148+ /* Tune operation ended irq handler */
149+ FM_HW_TUNE_OP_ENDED_IDX,
150+
151+ /* TX power enable irq handler */
152+ FM_HW_POWER_ENB_IDX,
153+
154+ /* Low RSSI irq handler */
155+ FM_LOW_RSSI_START_IDX,
156+ FM_AF_JUMP_SETPI_IDX,
157+ FM_AF_JUMP_HANDLE_SETPI_RESP_IDX,
158+ FM_AF_JUMP_SETPI_MASK_IDX,
159+ FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX,
160+ FM_AF_JUMP_SET_AF_FREQ_IDX,
161+ FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX,
162+ FM_AF_JUMP_ENABLE_INT_IDX,
163+ FM_AF_JUMP_ENABLE_INT_RESP_IDX,
164+ FM_AF_JUMP_START_AFJUMP_IDX,
165+ FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX,
166+ FM_AF_JUMP_RD_FREQ_IDX,
167+ FM_AF_JUMP_RD_FREQ_RESP_IDX,
168+ FM_LOW_RSSI_FINISH_IDX,
169+
170+ /* Interrupt process post action */
171+ FM_SEND_INTMSK_CMD_IDX,
172+ FM_HANDLE_INTMSK_CMD_RESP_IDX,
173+};
174+
175+/* FM interrupt handler table */
176+static int_handler_prototype int_handler_table[] = {
177+ fm_irq_send_flag_getcmd,
178+ fm_irq_handle_flag_getcmd_resp,
179+ fm_irq_handle_hw_malfunction,
180+ fm_irq_handle_rds_start, /* RDS threshold reached irq handler */
181+ fm_irq_send_rdsdata_getcmd,
182+ fm_irq_handle_rdsdata_getcmd_resp,
183+ fm_irq_handle_rds_finish,
184+ fm_irq_handle_tune_op_ended,
185+ fm_irq_handle_power_enb, /* TX power enable irq handler */
186+ fm_irq_handle_low_rssi_start,
187+ fm_irq_afjump_set_pi,
188+ fm_irq_handle_set_pi_resp,
189+ fm_irq_afjump_set_pimask,
190+ fm_irq_handle_set_pimask_resp,
191+ fm_irq_afjump_setfreq,
192+ fm_irq_handle_setfreq_resp,
193+ fm_irq_afjump_enableint,
194+ fm_irq_afjump_enableint_resp,
195+ fm_irq_start_afjump,
196+ fm_irq_handle_start_afjump_resp,
197+ fm_irq_afjump_rd_freq,
198+ fm_irq_afjump_rd_freq_resp,
199+ fm_irq_handle_low_rssi_finish,
200+ fm_irq_send_intmsk_cmd, /* Interrupt process post action */
201+ fm_irq_handle_intmsk_cmd_resp
202+};
203+
204+long (*g_st_write) (struct sk_buff *skb);
205+static struct completion wait_for_fmdrv_reg_comp;
206+
207+static inline void fm_irq_call(struct fmdev *fmdev)
208+{
209+ fmdev->irq_info.handlers[fmdev->irq_info.stage](fmdev);
210+}
211+
212+/* Continue next function in interrupt handler table */
213+static inline void fm_irq_call_stage(struct fmdev *fmdev, u8 stage)
214+{
215+ fmdev->irq_info.stage = stage;
216+ fm_irq_call(fmdev);
217+}
218+
219+static inline void fm_irq_timeout_stage(struct fmdev *fmdev, u8 stage)
220+{
221+ fmdev->irq_info.stage = stage;
222+ mod_timer(&fmdev->irq_info.timer, jiffies + FM_DRV_TX_TIMEOUT);
223+}
224+
225+#ifdef FM_DUMP_TXRX_PKT
226+ /* To dump outgoing FM Channel-8 packets */
227+inline void dump_tx_skb_data(struct sk_buff *skb)
228+{
229+ int len, len_org;
230+ u8 index;
231+ struct fm_cmd_msg_hdr *cmd_hdr;
232+
233+ cmd_hdr = (struct fm_cmd_msg_hdr *)skb->data;
234+ printk(KERN_INFO "<<%shdr:%02x len:%02x opcode:%02x type:%s dlen:%02x",
235+ fm_cb(skb)->completion ? " " : "*", cmd_hdr->hdr,
236+ cmd_hdr->len, cmd_hdr->op,
237+ cmd_hdr->rd_wr ? "RD" : "WR", cmd_hdr->dlen);
238+
239+ len_org = skb->len - FM_CMD_MSG_HDR_SIZE;
240+ if (len_org > 0) {
241+ printk("\n data(%d): ", cmd_hdr->dlen);
242+ len = min(len_org, 14);
243+ for (index = 0; index < len; index++)
244+ printk("%x ",
245+ skb->data[FM_CMD_MSG_HDR_SIZE + index]);
246+ printk("%s", (len_org > 14) ? ".." : "");
247+ }
248+ printk("\n");
249+}
250+
251+ /* To dump incoming FM Channel-8 packets */
252+inline void dump_rx_skb_data(struct sk_buff *skb)
253+{
254+ int len, len_org;
255+ u8 index;
256+ struct fm_event_msg_hdr *evt_hdr;
257+
258+ evt_hdr = (struct fm_event_msg_hdr *)skb->data;
259+ printk(KERN_INFO ">> hdr:%02x len:%02x sts:%02x numhci:%02x "
260+ "opcode:%02x type:%s dlen:%02x", evt_hdr->hdr, evt_hdr->len,
261+ evt_hdr->status, evt_hdr->num_fm_hci_cmds, evt_hdr->op,
262+ (evt_hdr->rd_wr) ? "RD" : "WR", evt_hdr->dlen);
263+
264+ len_org = skb->len - FM_EVT_MSG_HDR_SIZE;
265+ if (len_org > 0) {
266+ printk("\n data(%d): ", evt_hdr->dlen);
267+ len = min(len_org, 14);
268+ for (index = 0; index < len; index++)
269+ printk("%x ",
270+ skb->data[FM_EVT_MSG_HDR_SIZE + index]);
271+ printk("%s", (len_org > 14) ? ".." : "");
272+ }
273+ printk("\n");
274+}
275+#endif
276+
277+void fmc_update_region_info(struct fmdev *fmdev, u8 region_to_set)
278+{
279+ fmdev->rx.region = region_configs[region_to_set];
280+}
281+
282+/*
283+ * FM common sub-module will schedule this tasklet whenever it receives
284+ * FM packet from ST driver.
285+ */
286+static void recv_tasklet(unsigned long arg)
287+{
288+ struct fmdev *fmdev;
289+ struct fm_irq *irq_info;
290+ struct fm_event_msg_hdr *evt_hdr;
291+ struct sk_buff *skb;
292+ u8 num_fm_hci_cmds;
293+ unsigned long flags;
294+
295+ fmdev = (struct fmdev *)arg;
296+ irq_info = &fmdev->irq_info;
297+ /* Process all packets in the RX queue */
298+ while ((skb = skb_dequeue(&fmdev->rx_q))) {
299+ if (skb->len < sizeof(struct fm_event_msg_hdr)) {
300+ fmerr("skb(%p) has only %d bytes"
301+ "atleast need %d bytes to decode\n", skb,
302+ skb->len, sizeof(struct fm_event_msg_hdr));
303+ kfree_skb(skb);
304+ continue;
305+ }
306+
307+ evt_hdr = (void *)skb->data;
308+ num_fm_hci_cmds = evt_hdr->num_fm_hci_cmds;
309+
310+ /* FM interrupt packet? */
311+ if (evt_hdr->op == FM_INTERRUPT) {
312+ /* FM interrupt handler started already? */
313+ if (!test_bit(FM_INTTASK_RUNNING, &fmdev->flag)) {
314+ set_bit(FM_INTTASK_RUNNING, &fmdev->flag);
315+ if (irq_info->stage != 0) {
316+ fmerr("Inval stage resetting to zero\n");
317+ irq_info->stage = 0;
318+ }
319+
320+ /*
321+ * Execute first function in interrupt handler
322+ * table.
323+ */
324+ irq_info->handlers[irq_info->stage](fmdev);
325+ } else {
326+ set_bit(FM_INTTASK_SCHEDULE_PENDING, &fmdev->flag);
327+ }
328+ kfree_skb(skb);
329+ }
330+ /* Anyone waiting for this with completion handler? */
331+ else if (evt_hdr->op == fmdev->pre_op && fmdev->resp_comp != NULL) {
332+
333+ spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
334+ fmdev->resp_skb = skb;
335+ spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
336+ complete(fmdev->resp_comp);
337+
338+ fmdev->resp_comp = NULL;
339+ atomic_set(&fmdev->tx_cnt, 1);
340+ }
341+ /* Is this for interrupt handler? */
342+ else if (evt_hdr->op == fmdev->pre_op && fmdev->resp_comp == NULL) {
343+ if (fmdev->resp_skb != NULL)
344+ fmerr("Response SKB ptr not NULL\n");
345+
346+ spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
347+ fmdev->resp_skb = skb;
348+ spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
349+
350+ /* Execute interrupt handler where state index points */
351+ irq_info->handlers[irq_info->stage](fmdev);
352+
353+ kfree_skb(skb);
354+ atomic_set(&fmdev->tx_cnt, 1);
355+ } else {
356+ fmerr("Nobody claimed SKB(%p),purging\n", skb);
357+ }
358+
359+ /*
360+ * Check flow control field. If Num_FM_HCI_Commands field is
361+ * not zero, schedule FM TX tasklet.
362+ */
363+ if (num_fm_hci_cmds && atomic_read(&fmdev->tx_cnt))
364+ if (!skb_queue_empty(&fmdev->tx_q))
365+ tasklet_schedule(&fmdev->tx_task);
366+ }
367+}
368+
369+/* FM send tasklet: is scheduled when FM packet has to be sent to chip */
370+static void send_tasklet(unsigned long arg)
371+{
372+ struct fmdev *fmdev;
373+ struct sk_buff *skb;
374+ int len;
375+
376+ fmdev = (struct fmdev *)arg;
377+
378+ if (!atomic_read(&fmdev->tx_cnt))
379+ return;
380+
381+ /* Check, is there any timeout happenned to last transmitted packet */
382+ if ((jiffies - fmdev->last_tx_jiffies) > FM_DRV_TX_TIMEOUT) {
383+ fmerr("TX timeout occurred\n");
384+ atomic_set(&fmdev->tx_cnt, 1);
385+ }
386+
387+ /* Send queued FM TX packets */
388+ skb = skb_dequeue(&fmdev->tx_q);
389+ if (!skb)
390+ return;
391+
392+ atomic_dec(&fmdev->tx_cnt);
393+ fmdev->pre_op = fm_cb(skb)->fm_op;
394+
395+ if (fmdev->resp_comp != NULL)
396+ fmerr("Response completion handler is not NULL\n");
397+
398+ fmdev->resp_comp = fm_cb(skb)->completion;
399+
400+ /* Write FM packet to ST driver */
401+ len = g_st_write(skb);
402+ if (len < 0) {
403+ kfree_skb(skb);
404+ fmdev->resp_comp = NULL;
405+ fmerr("TX tasklet failed to send skb(%p)\n", skb);
406+ atomic_set(&fmdev->tx_cnt, 1);
407+ } else {
408+ fmdev->last_tx_jiffies = jiffies;
409+ }
410+}
411+
412+/*
413+ * Queues FM Channel-8 packet to FM TX queue and schedules FM TX tasklet for
414+ * transmission
415+ */
416+static u32 fm_send_cmd(struct fmdev *fmdev, u8 fm_op, u16 type, void *payload,
417+ int payload_len, struct completion *wait_completion)
418+{
419+ struct sk_buff *skb;
420+ struct fm_cmd_msg_hdr *hdr;
421+ int size;
422+
423+ if (fm_op >= FM_INTERRUPT) {
424+ fmerr("Invalid fm opcode - %d\n", fm_op);
425+ return -EINVAL;
426+ }
427+ if (test_bit(FM_FW_DW_INPROGRESS, &fmdev->flag) && payload == NULL) {
428+ fmerr("Payload data is NULL during fw download\n");
429+ return -EINVAL;
430+ }
431+ if (!test_bit(FM_FW_DW_INPROGRESS, &fmdev->flag))
432+ size =
433+ FM_CMD_MSG_HDR_SIZE + ((payload == NULL) ? 0 : payload_len);
434+ else
435+ size = payload_len;
436+
437+ skb = alloc_skb(size, GFP_ATOMIC);
438+ if (!skb) {
439+ fmerr("No memory to create new SKB\n");
440+ return -ENOMEM;
441+ }
442+ /*
443+ * Don't fill FM header info for the commands which come from
444+ * FM firmware file.
445+ */
446+ if (!test_bit(FM_FW_DW_INPROGRESS, &fmdev->flag) ||
447+ test_bit(FM_INTTASK_RUNNING, &fmdev->flag)) {
448+ /* Fill command header info */
449+ hdr = (struct fm_cmd_msg_hdr *)skb_put(skb, FM_CMD_MSG_HDR_SIZE);
450+ hdr->hdr = FM_PKT_LOGICAL_CHAN_NUMBER; /* 0x08 */
451+
452+ /* 3 (fm_opcode,rd_wr,dlen) + payload len) */
453+ hdr->len = ((payload == NULL) ? 0 : payload_len) + 3;
454+
455+ /* FM opcode */
456+ hdr->op = fm_op;
457+
458+ /* read/write type */
459+ hdr->rd_wr = type;
460+ hdr->dlen = payload_len;
461+ fm_cb(skb)->fm_op = fm_op;
462+
463+ /*
464+ * If firmware download has finished and the command is
465+ * not a read command then payload is != NULL - a write
466+ * command with u16 payload - convert to be16
467+ */
468+ if (payload != NULL)
469+ *(u16 *)payload = cpu_to_be16(*(u16 *)payload);
470+
471+ } else if (payload != NULL) {
472+ fm_cb(skb)->fm_op = *((u8 *)payload + 2);
473+ }
474+ if (payload != NULL)
475+ memcpy(skb_put(skb, payload_len), payload, payload_len);
476+
477+ fm_cb(skb)->completion = wait_completion;
478+ skb_queue_tail(&fmdev->tx_q, skb);
479+ tasklet_schedule(&fmdev->tx_task);
480+
481+ return 0;
482+}
483+
484+/* Sends FM Channel-8 command to the chip and waits for the response */
485+u32 fmc_send_cmd(struct fmdev *fmdev, u8 fm_op, u16 type, void *payload,
486+ unsigned int payload_len, void *response, int *response_len)
487+{
488+ struct sk_buff *skb;
489+ struct fm_event_msg_hdr *evt_hdr;
490+ unsigned long flags;
491+ u32 ret;
492+
493+ init_completion(&fmdev->maintask_comp);
494+ ret = fm_send_cmd(fmdev, fm_op, type, payload, payload_len,
495+ &fmdev->maintask_comp);
496+ if (ret)
497+ return ret;
498+
499+ ret = wait_for_completion_timeout(&fmdev->maintask_comp, FM_DRV_TX_TIMEOUT);
500+ if (!ret) {
501+ fmerr("Timeout(%d sec),didn't get reg"
502+ "completion signal from RX tasklet\n",
503+ jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000);
504+ return -ETIMEDOUT;
505+ }
506+ if (!fmdev->resp_skb) {
507+ fmerr("Reponse SKB is missing\n");
508+ return -EFAULT;
509+ }
510+ spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
511+ skb = fmdev->resp_skb;
512+ fmdev->resp_skb = NULL;
513+ spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
514+
515+ evt_hdr = (void *)skb->data;
516+ if (evt_hdr->status != 0) {
517+ fmerr("Received event pkt status(%d) is not zero\n",
518+ evt_hdr->status);
519+ kfree_skb(skb);
520+ return -EIO;
521+ }
522+ /* Send response data to caller */
523+ if (response != NULL && response_len != NULL && evt_hdr->dlen) {
524+ /* Skip header info and copy only response data */
525+ skb_pull(skb, sizeof(struct fm_event_msg_hdr));
526+ memcpy(response, skb->data, evt_hdr->dlen);
527+ *response_len = evt_hdr->dlen;
528+ } else if (response_len != NULL && evt_hdr->dlen == 0) {
529+ *response_len = 0;
530+ }
531+ kfree_skb(skb);
532+
533+ return 0;
534+}
535+
536+/* --- Helper functions used in FM interrupt handlers ---*/
537+static inline u32 check_cmdresp_status(struct fmdev *fmdev,
538+ struct sk_buff **skb)
539+{
540+ struct fm_event_msg_hdr *fm_evt_hdr;
541+ unsigned long flags;
542+
543+ del_timer(&fmdev->irq_info.timer);
544+
545+ spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
546+ *skb = fmdev->resp_skb;
547+ fmdev->resp_skb = NULL;
548+ spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
549+
550+ fm_evt_hdr = (void *)(*skb)->data;
551+ if (fm_evt_hdr->status != 0) {
552+ fmerr("irq: opcode %x response status is not zero "
553+ "Initiating irq recovery process\n",
554+ fm_evt_hdr->op);
555+
556+ mod_timer(&fmdev->irq_info.timer, jiffies + FM_DRV_TX_TIMEOUT);
557+ return -1;
558+ }
559+
560+ return 0;
561+}
562+
563+static inline void fm_irq_common_cmd_resp_helper(struct fmdev *fmdev, u8 stage)
564+{
565+ struct sk_buff *skb;
566+
567+ if (!check_cmdresp_status(fmdev, &skb))
568+ fm_irq_call_stage(fmdev, stage);
569+}
570+
571+/*
572+ * Interrupt process timeout handler.
573+ * One of the irq handler did not get proper response from the chip. So take
574+ * recovery action here. FM interrupts are disabled in the beginning of
575+ * interrupt process. Therefore reset stage index to re-enable default
576+ * interrupts. So that next interrupt will be processed as usual.
577+ */
578+static void int_timeout_handler(unsigned long data)
579+{
580+ struct fmdev *fmdev;
581+ struct fm_irq *fmirq;
582+
583+ fmdbg("irq: timeout,trying to re-enable fm interrupts\n");
584+ fmdev = (struct fmdev *)data;
585+ fmirq = &fmdev->irq_info;
586+ fmirq->retry++;
587+
588+ if (fmirq->retry > FM_IRQ_TIMEOUT_RETRY_MAX) {
589+ /* Stop recovery action (interrupt reenable process) and
590+ * reset stage index & retry count values */
591+ fmirq->stage = 0;
592+ fmirq->retry = 0;
593+ fmerr("Recovery action failed during"
594+ "irq processing, max retry reached\n");
595+ return;
596+ }
597+ fm_irq_call_stage(fmdev, FM_SEND_INTMSK_CMD_IDX);
598+}
599+
600+/* --------- FM interrupt handlers ------------*/
601+static void fm_irq_send_flag_getcmd(struct fmdev *fmdev)
602+{
603+ u16 flag;
604+
605+ /* Send FLAG_GET command , to know the source of interrupt */
606+ if (!fm_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, sizeof(flag), NULL))
607+ fm_irq_timeout_stage(fmdev, FM_HANDLE_FLAG_GETCMD_RESP_IDX);
608+}
609+
610+static void fm_irq_handle_flag_getcmd_resp(struct fmdev *fmdev)
611+{
612+ struct sk_buff *skb;
613+ struct fm_event_msg_hdr *fm_evt_hdr;
614+
615+ if (check_cmdresp_status(fmdev, &skb))
616+ return;
617+
618+ fm_evt_hdr = (void *)skb->data;
619+
620+ /* Skip header info and copy only response data */
621+ skb_pull(skb, sizeof(struct fm_event_msg_hdr));
622+ memcpy(&fmdev->irq_info.flag, skb->data, fm_evt_hdr->dlen);
623+
624+ fmdev->irq_info.flag = be16_to_cpu(fmdev->irq_info.flag);
625+ fmdbg("irq: flag register(0x%x)\n", fmdev->irq_info.flag);
626+
627+ /* Continue next function in interrupt handler table */
628+ fm_irq_call_stage(fmdev, FM_HW_MAL_FUNC_IDX);
629+}
630+
631+static void fm_irq_handle_hw_malfunction(struct fmdev *fmdev)
632+{
633+ if (fmdev->irq_info.flag & FM_MAL_EVENT & fmdev->irq_info.mask)
634+ fmerr("irq: HW MAL int received - do nothing\n");
635+
636+ /* Continue next function in interrupt handler table */
637+ fm_irq_call_stage(fmdev, FM_RDS_START_IDX);
638+}
639+
640+static void fm_irq_handle_rds_start(struct fmdev *fmdev)
641+{
642+ if (fmdev->irq_info.flag & FM_RDS_EVENT & fmdev->irq_info.mask) {
643+ fmdbg("irq: rds threshold reached\n");
644+ fmdev->irq_info.stage = FM_RDS_SEND_RDS_GETCMD_IDX;
645+ } else {
646+ /* Continue next function in interrupt handler table */
647+ fmdev->irq_info.stage = FM_HW_TUNE_OP_ENDED_IDX;
648+ }
649+
650+ fm_irq_call(fmdev);
651+}
652+
653+static void fm_irq_send_rdsdata_getcmd(struct fmdev *fmdev)
654+{
655+ /* Send the command to read RDS data from the chip */
656+ if (!fm_send_cmd(fmdev, RDS_DATA_GET, REG_RD, NULL,
657+ (FM_RX_RDS_FIFO_THRESHOLD * 3), NULL))
658+ fm_irq_timeout_stage(fmdev, FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX);
659+}
660+
661+/* Keeps track of current RX channel AF (Alternate Frequency) */
662+static void fm_rx_update_af_cache(struct fmdev *fmdev, u8 af)
663+{
664+ struct tuned_station_info *stat_info = &fmdev->rx.stat_info;
665+ u8 reg_idx = fmdev->rx.region.fm_band;
666+ u8 index;
667+ u32 freq;
668+
669+ /* First AF indicates the number of AF follows. Reset the list */
670+ if ((af >= FM_RDS_1_AF_FOLLOWS) && (af <= FM_RDS_25_AF_FOLLOWS)) {
671+ fmdev->rx.stat_info.af_list_max = (af - FM_RDS_1_AF_FOLLOWS + 1);
672+ fmdev->rx.stat_info.afcache_size = 0;
673+ fmdbg("No of expected AF : %d\n", fmdev->rx.stat_info.af_list_max);
674+ return;
675+ }
676+
677+ if (af < FM_RDS_MIN_AF)
678+ return;
679+ if (reg_idx == FM_BAND_EUROPE_US && af > FM_RDS_MAX_AF)
680+ return;
681+ if (reg_idx == FM_BAND_JAPAN && af > FM_RDS_MAX_AF_JAPAN)
682+ return;
683+
684+ freq = fmdev->rx.region.bot_freq + (af * 100);
685+ if (freq == fmdev->rx.freq) {
686+ fmdbg("Current freq(%d) is matching with received AF(%d)\n",
687+ fmdev->rx.freq, freq);
688+ return;
689+ }
690+ /* Do check in AF cache */
691+ for (index = 0; index < stat_info->afcache_size; index++) {
692+ if (stat_info->af_cache[index] == freq)
693+ break;
694+ }
695+ /* Reached the limit of the list - ignore the next AF */
696+ if (index == stat_info->af_list_max) {
697+ fmdbg("AF cache is full\n");
698+ return;
699+ }
700+ /*
701+ * If we reached the end of the list then this AF is not
702+ * in the list - add it.
703+ */
704+ if (index == stat_info->afcache_size) {
705+ fmdbg("Storing AF %d to cache index %d\n", freq, index);
706+ stat_info->af_cache[index] = freq;
707+ stat_info->afcache_size++;
708+ }
709+}
710+
711+/*
712+ * Converts RDS buffer data from big endian format
713+ * to little endian format.
714+ */
715+static void fm_rdsparse_swapbytes(struct fmdev *fmdev,
716+ struct fm_rdsdata_format *rds_format)
717+{
718+ u8 byte1;
719+ u8 index = 0;
720+ u8 *rds_buff;
721+
722+ /*
723+ * Since in Orca the 2 RDS Data bytes are in little endian and
724+ * in Dolphin they are in big endian, the parsing of the RDS data
725+ * is chip dependent
726+ */
727+ if (fmdev->asci_id != 0x6350) {
728+ rds_buff = &rds_format->data.groupdatabuff.buff[0];
729+ while (index + 1 < FM_RX_RDS_INFO_FIELD_MAX) {
730+ byte1 = rds_buff[index];
731+ rds_buff[index] = rds_buff[index + 1];
732+ rds_buff[index + 1] = byte1;
733+ index += 2;
734+ }
735+ }
736+}
737+
738+static void fm_irq_handle_rdsdata_getcmd_resp(struct fmdev *fmdev)
739+{
740+ struct sk_buff *skb;
741+ struct fm_rdsdata_format rds_fmt;
742+ struct fm_rds *rds = &fmdev->rx.rds;
743+ unsigned long group_idx, flags;
744+ u8 *rds_data, meta_data, tmpbuf[3];
745+ u8 type, blk_idx;
746+ u16 cur_picode;
747+ u32 rds_len;
748+
749+ if (check_cmdresp_status(fmdev, &skb))
750+ return;
751+
752+ /* Skip header info */
753+ skb_pull(skb, sizeof(struct fm_event_msg_hdr));
754+ rds_data = skb->data;
755+ rds_len = skb->len;
756+
757+ /* Parse the RDS data */
758+ while (rds_len >= FM_RDS_BLK_SIZE) {
759+ meta_data = rds_data[2];
760+ /* Get the type: 0=A, 1=B, 2=C, 3=C', 4=D, 5=E */
761+ type = (meta_data & 0x07);
762+
763+ /* Transform the blk type into index sequence (0, 1, 2, 3, 4) */
764+ blk_idx = (type <= FM_RDS_BLOCK_C ? type : (type - 1));
765+ fmdbg("Block index:%d(%s)\n", blk_idx,
766+ (meta_data & FM_RDS_STATUS_ERR_MASK) ? "Bad" : "Ok");
767+
768+ if ((meta_data & FM_RDS_STATUS_ERR_MASK) != 0)
769+ break;
770+
771+ if (blk_idx < FM_RDS_BLK_IDX_A || blk_idx > FM_RDS_BLK_IDX_D) {
772+ fmdbg("Block sequence mismatch\n");
773+ rds->last_blk_idx = -1;
774+ break;
775+ }
776+
777+ /* Skip checkword (control) byte and copy only data byte */
778+ memcpy(&rds_fmt.data.groupdatabuff.
779+ buff[blk_idx * (FM_RDS_BLK_SIZE - 1)],
780+ rds_data, (FM_RDS_BLK_SIZE - 1));
781+
782+ rds->last_blk_idx = blk_idx;
783+
784+ /* If completed a whole group then handle it */
785+ if (blk_idx == FM_RDS_BLK_IDX_D) {
786+ fmdbg("Good block received\n");
787+ fm_rdsparse_swapbytes(fmdev, &rds_fmt);
788+
789+ /*
790+ * Extract PI code and store in local cache.
791+ * We need this during AF switch processing.
792+ */
793+ cur_picode = be16_to_cpu(rds_fmt.data.groupgeneral.pidata);
794+ if (fmdev->rx.stat_info.picode != cur_picode)
795+ fmdev->rx.stat_info.picode = cur_picode;
796+
797+ fmdbg("picode:%d\n", cur_picode);
798+
799+ group_idx = (rds_fmt.data.groupgeneral.blk_b[0] >> 3);
800+ fmdbg("(fmdrv):Group:%ld%s\n", group_idx/2,
801+ (group_idx % 2) ? "B" : "A");
802+
803+ group_idx = 1 << (rds_fmt.data.groupgeneral.blk_b[0] >> 3);
804+ if (group_idx == FM_RDS_GROUP_TYPE_MASK_0A) {
805+ fm_rx_update_af_cache(fmdev, rds_fmt.data.group0A.af[0]);
806+ fm_rx_update_af_cache(fmdev, rds_fmt.data.group0A.af[1]);
807+ }
808+ }
809+ rds_len -= FM_RDS_BLK_SIZE;
810+ rds_data += FM_RDS_BLK_SIZE;
811+ }
812+
813+ /* Copy raw rds data to internal rds buffer */
814+ rds_data = skb->data;
815+ rds_len = skb->len;
816+
817+ spin_lock_irqsave(&fmdev->rds_buff_lock, flags);
818+ while (rds_len > 0) {
819+ /*
820+ * Fill RDS buffer as per V4L2 specification.
821+ * Store control byte
822+ */
823+ type = (rds_data[2] & 0x07);
824+ blk_idx = (type <= FM_RDS_BLOCK_C ? type : (type - 1));
825+ tmpbuf[2] = blk_idx; /* Offset name */
826+ tmpbuf[2] |= blk_idx << 3; /* Received offset */
827+
828+ /* Store data byte */
829+ tmpbuf[0] = rds_data[0];
830+ tmpbuf[1] = rds_data[1];
831+
832+ memcpy(&rds->buff[rds->wr_idx], &tmpbuf, FM_RDS_BLK_SIZE);
833+ rds->wr_idx = (rds->wr_idx + FM_RDS_BLK_SIZE) % rds->buf_size;
834+
835+ /* Check for overflow & start over */
836+ if (rds->wr_idx == rds->rd_idx) {
837+ fmdbg("RDS buffer overflow\n");
838+ rds->wr_idx = 0;
839+ rds->rd_idx = 0;
840+ break;
841+ }
842+ rds_len -= FM_RDS_BLK_SIZE;
843+ rds_data += FM_RDS_BLK_SIZE;
844+ }
845+ spin_unlock_irqrestore(&fmdev->rds_buff_lock, flags);
846+
847+ /* Wakeup read queue */
848+ if (rds->wr_idx != rds->rd_idx)
849+ wake_up_interruptible(&rds->read_queue);
850+
851+ fm_irq_call_stage(fmdev, FM_RDS_FINISH_IDX);
852+}
853+
854+static void fm_irq_handle_rds_finish(struct fmdev *fmdev)
855+{
856+ fm_irq_call_stage(fmdev, FM_HW_TUNE_OP_ENDED_IDX);
857+}
858+
859+static void fm_irq_handle_tune_op_ended(struct fmdev *fmdev)
860+{
861+ if (fmdev->irq_info.flag & (FM_FR_EVENT | FM_BL_EVENT) & fmdev->
862+ irq_info.mask) {
863+ fmdbg("irq: tune ended/bandlimit reached\n");
864+ if (test_and_clear_bit(FM_AF_SWITCH_INPROGRESS, &fmdev->flag)) {
865+ fmdev->irq_info.stage = FM_AF_JUMP_RD_FREQ_IDX;
866+ } else {
867+ complete(&fmdev->maintask_comp);
868+ fmdev->irq_info.stage = FM_HW_POWER_ENB_IDX;
869+ }
870+ } else
871+ fmdev->irq_info.stage = FM_HW_POWER_ENB_IDX;
872+
873+ fm_irq_call(fmdev);
874+}
875+
876+static void fm_irq_handle_power_enb(struct fmdev *fmdev)
877+{
878+ if (fmdev->irq_info.flag & FM_POW_ENB_EVENT) {
879+ fmdbg("irq: Power Enabled/Disabled\n");
880+ complete(&fmdev->maintask_comp);
881+ }
882+
883+ fm_irq_call_stage(fmdev, FM_LOW_RSSI_START_IDX);
884+}
885+
886+static void fm_irq_handle_low_rssi_start(struct fmdev *fmdev)
887+{
888+ if ((fmdev->rx.af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON) &&
889+ (fmdev->irq_info.flag & FM_LEV_EVENT & fmdev->irq_info.mask) &&
890+ (fmdev->rx.freq != FM_UNDEFINED_FREQ) &&
891+ (fmdev->rx.stat_info.afcache_size != 0)) {
892+ fmdbg("irq: rssi level has fallen below threshold level\n");
893+
894+ /* Disable further low RSSI interrupts */
895+ fmdev->irq_info.mask &= ~FM_LEV_EVENT;
896+
897+ fmdev->rx.afjump_idx = 0;
898+ fmdev->rx.freq_before_jump = fmdev->rx.freq;
899+ fmdev->irq_info.stage = FM_AF_JUMP_SETPI_IDX;
900+ } else {
901+ /* Continue next function in interrupt handler table */
902+ fmdev->irq_info.stage = FM_SEND_INTMSK_CMD_IDX;
903+ }
904+
905+ fm_irq_call(fmdev);
906+}
907+
908+static void fm_irq_afjump_set_pi(struct fmdev *fmdev)
909+{
910+ u16 payload;
911+
912+ /* Set PI code - must be updated if the AF list is not empty */
913+ payload = fmdev->rx.stat_info.picode;
914+ if (!fm_send_cmd(fmdev, RDS_PI_SET, REG_WR, &payload, sizeof(payload), NULL))
915+ fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_SETPI_RESP_IDX);
916+}
917+
918+static void fm_irq_handle_set_pi_resp(struct fmdev *fmdev)
919+{
920+ fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_SETPI_MASK_IDX);
921+}
922+
923+/*
924+ * Set PI mask.
925+ * 0xFFFF = Enable PI code matching
926+ * 0x0000 = Disable PI code matching
927+ */
928+static void fm_irq_afjump_set_pimask(struct fmdev *fmdev)
929+{
930+ u16 payload;
931+
932+ payload = 0x0000;
933+ if (!fm_send_cmd(fmdev, RDS_PI_MASK_SET, REG_WR, &payload, sizeof(payload), NULL))
934+ fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX);
935+}
936+
937+static void fm_irq_handle_set_pimask_resp(struct fmdev *fmdev)
938+{
939+ fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_SET_AF_FREQ_IDX);
940+}
941+
942+static void fm_irq_afjump_setfreq(struct fmdev *fmdev)
943+{
944+ u16 frq_index;
945+ u16 payload;
946+
947+ fmdbg("Swtich to %d KHz\n", fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx]);
948+ frq_index = (fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx] -
949+ fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
950+
951+ payload = frq_index;
952+ if (!fm_send_cmd(fmdev, AF_FREQ_SET, REG_WR, &payload, sizeof(payload), NULL))
953+ fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX);
954+}
955+
956+static void fm_irq_handle_setfreq_resp(struct fmdev *fmdev)
957+{
958+ fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_ENABLE_INT_IDX);
959+}
960+
961+static void fm_irq_afjump_enableint(struct fmdev *fmdev)
962+{
963+ u16 payload;
964+
965+ /* Enable FR (tuning operation ended) interrupt */
966+ payload = FM_FR_EVENT;
967+ if (!fm_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload, sizeof(payload), NULL))
968+ fm_irq_timeout_stage(fmdev, FM_AF_JUMP_ENABLE_INT_RESP_IDX);
969+}
970+
971+static void fm_irq_afjump_enableint_resp(struct fmdev *fmdev)
972+{
973+ fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_START_AFJUMP_IDX);
974+}
975+
976+static void fm_irq_start_afjump(struct fmdev *fmdev)
977+{
978+ u16 payload;
979+
980+ payload = FM_TUNER_AF_JUMP_MODE;
981+ if (!fm_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload,
982+ sizeof(payload), NULL))
983+ fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX);
984+}
985+
986+static void fm_irq_handle_start_afjump_resp(struct fmdev *fmdev)
987+{
988+ struct sk_buff *skb;
989+
990+ if (check_cmdresp_status(fmdev, &skb))
991+ return;
992+
993+ fmdev->irq_info.stage = FM_SEND_FLAG_GETCMD_IDX;
994+ set_bit(FM_AF_SWITCH_INPROGRESS, &fmdev->flag);
995+ clear_bit(FM_INTTASK_RUNNING, &fmdev->flag);
996+}
997+
998+static void fm_irq_afjump_rd_freq(struct fmdev *fmdev)
999+{
1000+ u16 payload;
1001+
1002+ if (!fm_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, sizeof(payload), NULL))
1003+ fm_irq_timeout_stage(fmdev, FM_AF_JUMP_RD_FREQ_RESP_IDX);
1004+}
1005+
1006+static void fm_irq_afjump_rd_freq_resp(struct fmdev *fmdev)
1007+{
1008+ struct sk_buff *skb;
1009+ u16 read_freq;
1010+ u32 curr_freq, jumped_freq;
1011+
1012+ if (check_cmdresp_status(fmdev, &skb))
1013+ return;
1014+
1015+ /* Skip header info and copy only response data */
1016+ skb_pull(skb, sizeof(struct fm_event_msg_hdr));
1017+ memcpy(&read_freq, skb->data, sizeof(read_freq));
1018+ read_freq = be16_to_cpu(read_freq);
1019+ curr_freq = fmdev->rx.region.bot_freq + ((u32)read_freq * FM_FREQ_MUL);
1020+
1021+ jumped_freq = fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx];
1022+
1023+ /* If the frequency was changed the jump succeeded */
1024+ if ((curr_freq != fmdev->rx.freq_before_jump) && (curr_freq == jumped_freq)) {
1025+ fmdbg("Successfully switched to alternate freq %d\n", curr_freq);
1026+ fmdev->rx.freq = curr_freq;
1027+ fm_rx_reset_rds_cache(fmdev);
1028+
1029+ /* AF feature is on, enable low level RSSI interrupt */
1030+ if (fmdev->rx.af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
1031+ fmdev->irq_info.mask |= FM_LEV_EVENT;
1032+
1033+ fmdev->irq_info.stage = FM_LOW_RSSI_FINISH_IDX;
1034+ } else { /* jump to the next freq in the AF list */
1035+ fmdev->rx.afjump_idx++;
1036+
1037+ /* If we reached the end of the list - stop searching */
1038+ if (fmdev->rx.afjump_idx >= fmdev->rx.stat_info.afcache_size) {
1039+ fmdbg("AF switch processing failed\n");
1040+ fmdev->irq_info.stage = FM_LOW_RSSI_FINISH_IDX;
1041+ } else { /* AF List is not over - try next one */
1042+
1043+ fmdbg("Trying next freq in AF cache\n");
1044+ fmdev->irq_info.stage = FM_AF_JUMP_SETPI_IDX;
1045+ }
1046+ }
1047+ fm_irq_call(fmdev);
1048+}
1049+
1050+static void fm_irq_handle_low_rssi_finish(struct fmdev *fmdev)
1051+{
1052+ fm_irq_call_stage(fmdev, FM_SEND_INTMSK_CMD_IDX);
1053+}
1054+
1055+static void fm_irq_send_intmsk_cmd(struct fmdev *fmdev)
1056+{
1057+ u16 payload;
1058+
1059+ /* Re-enable FM interrupts */
1060+ payload = fmdev->irq_info.mask;
1061+
1062+ if (!fm_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
1063+ sizeof(payload), NULL))
1064+ fm_irq_timeout_stage(fmdev, FM_HANDLE_INTMSK_CMD_RESP_IDX);
1065+}
1066+
1067+static void fm_irq_handle_intmsk_cmd_resp(struct fmdev *fmdev)
1068+{
1069+ struct sk_buff *skb;
1070+
1071+ if (check_cmdresp_status(fmdev, &skb))
1072+ return;
1073+ /*
1074+ * This is last function in interrupt table to be executed.
1075+ * So, reset stage index to 0.
1076+ */
1077+ fmdev->irq_info.stage = FM_SEND_FLAG_GETCMD_IDX;
1078+
1079+ /* Start processing any pending interrupt */
1080+ if (test_and_clear_bit(FM_INTTASK_SCHEDULE_PENDING, &fmdev->flag))
1081+ fmdev->irq_info.handlers[fmdev->irq_info.stage](fmdev);
1082+ else
1083+ clear_bit(FM_INTTASK_RUNNING, &fmdev->flag);
1084+}
1085+
1086+/* Returns availability of RDS data in internel buffer */
1087+u32 fmc_is_rds_data_available(struct fmdev *fmdev, struct file *file,
1088+ struct poll_table_struct *pts)
1089+{
1090+ poll_wait(file, &fmdev->rx.rds.read_queue, pts);
1091+ if (fmdev->rx.rds.rd_idx != fmdev->rx.rds.wr_idx)
1092+ return 0;
1093+
1094+ return -EAGAIN;
1095+}
1096+
1097+/* Copies RDS data from internal buffer to user buffer */
1098+u32 fmc_transfer_rds_from_internal_buff(struct fmdev *fmdev, struct file *file,
1099+ u8 __user *buf, size_t count)
1100+{
1101+ u32 block_count;
1102+ unsigned long flags;
1103+ int ret;
1104+
1105+ if (fmdev->rx.rds.wr_idx == fmdev->rx.rds.rd_idx) {
1106+ if (file->f_flags & O_NONBLOCK)
1107+ return -EWOULDBLOCK;
1108+
1109+ ret = wait_event_interruptible(fmdev->rx.rds.read_queue,
1110+ (fmdev->rx.rds.wr_idx != fmdev->rx.rds.rd_idx));
1111+ if (ret)
1112+ return -EINTR;
1113+ }
1114+
1115+ /* Calculate block count from byte count */
1116+ count /= 3;
1117+ block_count = 0;
1118+ ret = 0;
1119+
1120+ spin_lock_irqsave(&fmdev->rds_buff_lock, flags);
1121+
1122+ while (block_count < count) {
1123+ if (fmdev->rx.rds.wr_idx == fmdev->rx.rds.rd_idx)
1124+ break;
1125+
1126+ if (copy_to_user(buf, &fmdev->rx.rds.buff[fmdev->rx.rds.rd_idx],
1127+ FM_RDS_BLK_SIZE))
1128+ break;
1129+
1130+ fmdev->rx.rds.rd_idx += FM_RDS_BLK_SIZE;
1131+ if (fmdev->rx.rds.rd_idx >= fmdev->rx.rds.buf_size)
1132+ fmdev->rx.rds.rd_idx = 0;
1133+
1134+ block_count++;
1135+ buf += FM_RDS_BLK_SIZE;
1136+ ret += FM_RDS_BLK_SIZE;
1137+ }
1138+ spin_unlock_irqrestore(&fmdev->rds_buff_lock, flags);
1139+ return ret;
1140+}
1141+
1142+u32 fmc_set_freq(struct fmdev *fmdev, u32 freq_to_set)
1143+{
1144+ switch (fmdev->curr_fmmode) {
1145+ case FM_MODE_RX:
1146+ return fm_rx_set_freq(fmdev, freq_to_set);
1147+
1148+ case FM_MODE_TX:
1149+ return fm_tx_set_freq(fmdev, freq_to_set);
1150+
1151+ default:
1152+ return -EINVAL;
1153+ }
1154+}
1155+
1156+u32 fmc_get_freq(struct fmdev *fmdev, u32 *cur_tuned_frq)
1157+{
1158+ if (fmdev->rx.freq == FM_UNDEFINED_FREQ) {
1159+ fmerr("RX frequency is not set\n");
1160+ return -EPERM;
1161+ }
1162+ if (cur_tuned_frq == NULL) {
1163+ fmerr("Invalid memory\n");
1164+ return -ENOMEM;
1165+ }
1166+
1167+ switch (fmdev->curr_fmmode) {
1168+ case FM_MODE_RX:
1169+ *cur_tuned_frq = fmdev->rx.freq;
1170+ return 0;
1171+
1172+ case FM_MODE_TX:
1173+ *cur_tuned_frq = 0; /* TODO : Change this later */
1174+ return 0;
1175+
1176+ default:
1177+ return -EINVAL;
1178+ }
1179+
1180+}
1181+
1182+u32 fmc_set_region(struct fmdev *fmdev, u8 region_to_set)
1183+{
1184+ switch (fmdev->curr_fmmode) {
1185+ case FM_MODE_RX:
1186+ return fm_rx_set_region(fmdev, region_to_set);
1187+
1188+ case FM_MODE_TX:
1189+ return fm_tx_set_region(fmdev, region_to_set);
1190+
1191+ default:
1192+ return -EINVAL;
1193+ }
1194+}
1195+
1196+u32 fmc_set_mute_mode(struct fmdev *fmdev, u8 mute_mode_toset)
1197+{
1198+ switch (fmdev->curr_fmmode) {
1199+ case FM_MODE_RX:
1200+ return fm_rx_set_mute_mode(fmdev, mute_mode_toset);
1201+
1202+ case FM_MODE_TX:
1203+ return fm_tx_set_mute_mode(fmdev, mute_mode_toset);
1204+
1205+ default:
1206+ return -EINVAL;
1207+ }
1208+}
1209+
1210+u32 fmc_set_stereo_mono(struct fmdev *fmdev, u16 mode)
1211+{
1212+ switch (fmdev->curr_fmmode) {
1213+ case FM_MODE_RX:
1214+ return fm_rx_set_stereo_mono(fmdev, mode);
1215+
1216+ case FM_MODE_TX:
1217+ return fm_tx_set_stereo_mono(fmdev, mode);
1218+
1219+ default:
1220+ return -EINVAL;
1221+ }
1222+}
1223+
1224+u32 fmc_set_rds_mode(struct fmdev *fmdev, u8 rds_en_dis)
1225+{
1226+ switch (fmdev->curr_fmmode) {
1227+ case FM_MODE_RX:
1228+ return fm_rx_set_rds_mode(fmdev, rds_en_dis);
1229+
1230+ case FM_MODE_TX:
1231+ return fm_tx_set_rds_mode(fmdev, rds_en_dis);
1232+
1233+ default:
1234+ return -EINVAL;
1235+ }
1236+}
1237+
1238+/* Sends power off command to the chip */
1239+static u32 fm_power_down(struct fmdev *fmdev)
1240+{
1241+ u16 payload;
1242+ u32 ret;
1243+
1244+ if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
1245+ fmerr("FM core is not ready\n");
1246+ return -EPERM;
1247+ }
1248+ if (fmdev->curr_fmmode == FM_MODE_OFF) {
1249+ fmdbg("FM chip is already in OFF state\n");
1250+ return 0;
1251+ }
1252+
1253+ payload = 0x0;
1254+ ret = fmc_send_cmd(fmdev, FM_POWER_MODE, REG_WR, &payload,
1255+ sizeof(payload), NULL, NULL);
1256+ if (ret < 0)
1257+ return ret;
1258+
1259+ return fmc_release(fmdev);
1260+}
1261+
1262+/* Reads init command from FM firmware file and loads to the chip */
1263+static u32 fm_download_firmware(struct fmdev *fmdev, const u8 *fw_name)
1264+{
1265+ const struct firmware *fw_entry;
1266+ struct bts_header *fw_header;
1267+ struct bts_action *action;
1268+ struct bts_action_delay *delay;
1269+ u8 *fw_data;
1270+ int ret, fw_len, cmd_cnt;
1271+
1272+ cmd_cnt = 0;
1273+ set_bit(FM_FW_DW_INPROGRESS, &fmdev->flag);
1274+
1275+ ret = request_firmware(&fw_entry, fw_name,
1276+ &fmdev->radio_dev->dev);
1277+ if (ret < 0) {
1278+ fmerr("Unable to read firmware(%s) content\n", fw_name);
1279+ return ret;
1280+ }
1281+ fmdbg("Firmware(%s) length : %d bytes\n", fw_name, fw_entry->size);
1282+
1283+ fw_data = (void *)fw_entry->data;
1284+ fw_len = fw_entry->size;
1285+
1286+ fw_header = (struct bts_header *)fw_data;
1287+ if (fw_header->magic != FM_FW_FILE_HEADER_MAGIC) {
1288+ fmerr("%s not a legal TI firmware file\n", fw_name);
1289+ ret = -EINVAL;
1290+ goto rel_fw;
1291+ }
1292+ fmdbg("FW(%s) magic number : 0x%x\n", fw_name, fw_header->magic);
1293+
1294+ /* Skip file header info , we already verified it */
1295+ fw_data += sizeof(struct bts_header);
1296+ fw_len -= sizeof(struct bts_header);
1297+
1298+ while (fw_data && fw_len > 0) {
1299+ action = (struct bts_action *)fw_data;
1300+
1301+ switch (action->type) {
1302+ case ACTION_SEND_COMMAND: /* Send */
1303+ if (fmc_send_cmd(fmdev, 0, 0, action->data,
1304+ action->size, NULL, NULL))
1305+ goto rel_fw;
1306+
1307+ cmd_cnt++;
1308+ break;
1309+
1310+ case ACTION_DELAY: /* Delay */
1311+ delay = (struct bts_action_delay *)action->data;
1312+ mdelay(delay->msec);
1313+ break;
1314+ }
1315+
1316+ fw_data += (sizeof(struct bts_action) + (action->size));
1317+ fw_len -= (sizeof(struct bts_action) + (action->size));
1318+ }
1319+ fmdbg("Firmware commands(%d) loaded to chip\n", cmd_cnt);
1320+rel_fw:
1321+ release_firmware(fw_entry);
1322+ clear_bit(FM_FW_DW_INPROGRESS, &fmdev->flag);
1323+
1324+ return ret;
1325+}
1326+
1327+/* Loads default RX configuration to the chip */
1328+static u32 load_default_rx_configuration(struct fmdev *fmdev)
1329+{
1330+ int ret;
1331+
1332+ ret = fm_rx_set_volume(fmdev, FM_DEFAULT_RX_VOLUME);
1333+ if (ret < 0)
1334+ return ret;
1335+
1336+ return fm_rx_set_rssi_threshold(fmdev, FM_DEFAULT_RSSI_THRESHOLD);
1337+}
1338+
1339+/* Does FM power on sequence */
1340+static u32 fm_power_up(struct fmdev *fmdev, u8 mode)
1341+{
1342+ u16 payload, asic_id, asic_ver;
1343+ int resp_len, ret;
1344+ u8 fw_name[50];
1345+
1346+ if (mode >= FM_MODE_ENTRY_MAX) {
1347+ fmerr("Invalid firmware download option\n");
1348+ return -EINVAL;
1349+ }
1350+
1351+ /*
1352+ * Initialize FM common module. FM GPIO toggling is
1353+ * taken care in Shared Transport driver.
1354+ */
1355+ ret = fmc_prepare(fmdev);
1356+ if (ret < 0) {
1357+ fmerr("Unable to prepare FM Common\n");
1358+ return ret;
1359+ }
1360+
1361+ payload = FM_ENABLE;
1362+ if (fmc_send_cmd(fmdev, FM_POWER_MODE, REG_WR, &payload,
1363+ sizeof(payload), NULL, NULL))
1364+ goto rel;
1365+
1366+ /* Allow the chip to settle down in Channel-8 mode */
1367+ msleep(20);
1368+
1369+ if (fmc_send_cmd(fmdev, ASIC_ID_GET, REG_RD, NULL,
1370+ sizeof(asic_id), &asic_id, &resp_len))
1371+ goto rel;
1372+
1373+ if (fmc_send_cmd(fmdev, ASIC_VER_GET, REG_RD, NULL,
1374+ sizeof(asic_ver), &asic_ver, &resp_len))
1375+ goto rel;
1376+
1377+ fmdbg("ASIC ID: 0x%x , ASIC Version: %d\n",
1378+ be16_to_cpu(asic_id), be16_to_cpu(asic_ver));
1379+
1380+ sprintf(fw_name, "%s_%x.%d.bts", FM_FMC_FW_FILE_START,
1381+ be16_to_cpu(asic_id), be16_to_cpu(asic_ver));
1382+
1383+ ret = fm_download_firmware(fmdev, fw_name);
1384+ if (ret < 0) {
1385+ fmdbg("Failed to download firmware file %s\n", fw_name);
1386+ goto rel;
1387+ }
1388+ sprintf(fw_name, "%s_%x.%d.bts", (mode == FM_MODE_RX) ?
1389+ FM_RX_FW_FILE_START : FM_TX_FW_FILE_START,
1390+ be16_to_cpu(asic_id), be16_to_cpu(asic_ver));
1391+
1392+ ret = fm_download_firmware(fmdev, fw_name);
1393+ if (ret < 0) {
1394+ fmdbg("Failed to download firmware file %s\n", fw_name);
1395+ goto rel;
1396+ } else
1397+ return ret;
1398+rel:
1399+ return fmc_release(fmdev);
1400+}
1401+
1402+/* Set FM Modes(TX, RX, OFF) */
1403+u32 fmc_set_mode(struct fmdev *fmdev, u8 fm_mode)
1404+{
1405+ int ret = 0;
1406+
1407+ if (fm_mode >= FM_MODE_ENTRY_MAX) {
1408+ fmerr("Invalid FM mode\n");
1409+ return -EINVAL;
1410+ }
1411+ if (fmdev->curr_fmmode == fm_mode) {
1412+ fmdbg("Already fm is in mode(%d)\n", fm_mode);
1413+ return ret;
1414+ }
1415+
1416+ switch (fm_mode) {
1417+ case FM_MODE_OFF: /* OFF Mode */
1418+ ret = fm_power_down(fmdev);
1419+ if (ret < 0) {
1420+ fmerr("Failed to set OFF mode\n");
1421+ return ret;
1422+ }
1423+ break;
1424+
1425+ case FM_MODE_TX: /* TX Mode */
1426+ case FM_MODE_RX: /* RX Mode */
1427+ /* Power down before switching to TX or RX mode */
1428+ if (fmdev->curr_fmmode != FM_MODE_OFF) {
1429+ ret = fm_power_down(fmdev);
1430+ if (ret < 0) {
1431+ fmerr("Failed to set OFF mode\n");
1432+ return ret;
1433+ }
1434+ msleep(30);
1435+ }
1436+ ret = fm_power_up(fmdev, fm_mode);
1437+ if (ret < 0) {
1438+ fmerr("Failed to load firmware\n");
1439+ return ret;
1440+ }
1441+ }
1442+ fmdev->curr_fmmode = fm_mode;
1443+
1444+ /* Set default configuration */
1445+ if (fmdev->curr_fmmode == FM_MODE_RX) {
1446+ fmdbg("Loading default rx configuration..\n");
1447+ ret = load_default_rx_configuration(fmdev);
1448+ if (ret < 0)
1449+ fmerr("Failed to load default values\n");
1450+ }
1451+
1452+ return ret;
1453+}
1454+
1455+/* Returns current FM mode (TX, RX, OFF) */
1456+u32 fmc_get_mode(struct fmdev *fmdev, u8 *fmmode)
1457+{
1458+ if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
1459+ fmerr("FM core is not ready\n");
1460+ return -EPERM;
1461+ }
1462+ if (fmmode == NULL) {
1463+ fmerr("Invalid memory\n");
1464+ return -ENOMEM;
1465+ }
1466+
1467+ *fmmode = fmdev->curr_fmmode;
1468+ return 0;
1469+}
1470+
1471+/* Called by ST layer when FM packet is available */
1472+static long fm_st_receive(void *arg, struct sk_buff *skb)
1473+{
1474+ struct fmdev *fmdev;
1475+
1476+ fmdev = (struct fmdev *)arg;
1477+
1478+ if (skb == NULL) {
1479+ fmerr("Invalid SKB received from ST\n");
1480+ return -EFAULT;
1481+ }
1482+
1483+ if (skb->cb[0] != FM_PKT_LOGICAL_CHAN_NUMBER) {
1484+ fmerr("Received SKB (%p) is not FM Channel 8 pkt\n", skb);
1485+ return -EINVAL;
1486+ }
1487+
1488+ memcpy(skb_push(skb, 1), &skb->cb[0], 1);
1489+ skb_queue_tail(&fmdev->rx_q, skb);
1490+ tasklet_schedule(&fmdev->rx_task);
1491+
1492+ return 0;
1493+}
1494+
1495+/*
1496+ * Called by ST layer to indicate protocol registration completion
1497+ * status.
1498+ */
1499+static void fm_st_reg_comp_cb(void *arg, char data)
1500+{
1501+ struct fmdev *fmdev;
1502+
1503+ fmdev = (struct fmdev *)arg;
1504+ fmdev->streg_cbdata = data;
1505+ complete(&wait_for_fmdrv_reg_comp);
1506+}
1507+
1508+/*
1509+ * This function will be called from FM V4L2 open function.
1510+ * Register with ST driver and initialize driver data.
1511+ */
1512+u32 fmc_prepare(struct fmdev *fmdev)
1513+{
1514+ static struct st_proto_s fm_st_proto;
1515+ u32 ret;
1516+
1517+ if (test_bit(FM_CORE_READY, &fmdev->flag)) {
1518+ fmdbg("FM Core is already up\n");
1519+ return 0;
1520+ }
1521+
1522+ memset(&fm_st_proto, 0, sizeof(fm_st_proto));
1523+ fm_st_proto.type = ST_FM;
1524+ fm_st_proto.recv = fm_st_receive;
1525+ fm_st_proto.match_packet = NULL;
1526+ fm_st_proto.reg_complete_cb = fm_st_reg_comp_cb;
1527+ fm_st_proto.write = NULL; /* TI ST driver will fill write pointer */
1528+ fm_st_proto.priv_data = fmdev;
1529+
1530+ ret = st_register(&fm_st_proto);
1531+ if (ret == -EINPROGRESS) {
1532+ init_completion(&wait_for_fmdrv_reg_comp);
1533+ fmdev->streg_cbdata = -EINPROGRESS;
1534+ fmdbg("%s waiting for ST reg completion signal\n", __func__);
1535+
1536+ ret = wait_for_completion_timeout(&wait_for_fmdrv_reg_comp,
1537+ FM_ST_REG_TIMEOUT);
1538+
1539+ if (!ret) {
1540+ fmerr("Timeout(%d sec), didn't get reg "
1541+ "completion signal from ST\n",
1542+ jiffies_to_msecs(FM_ST_REG_TIMEOUT) / 1000);
1543+ return -ETIMEDOUT;
1544+ }
1545+ if (fmdev->streg_cbdata != 0) {
1546+ fmerr("ST reg comp CB called with error "
1547+ "status %d\n", fmdev->streg_cbdata);
1548+ return -EAGAIN;
1549+ }
1550+
1551+ ret = 0;
1552+ } else if (ret == -1) {
1553+ fmerr("st_register failed %d\n", ret);
1554+ return -EAGAIN;
1555+ }
1556+
1557+ if (fm_st_proto.write != NULL) {
1558+ g_st_write = fm_st_proto.write;
1559+ } else {
1560+ fmerr("Failed to get ST write func pointer\n");
1561+ ret = st_unregister(ST_FM);
1562+ if (ret < 0)
1563+ fmerr("st_unregister failed %d\n", ret);
1564+ return -EAGAIN;
1565+ }
1566+
1567+ spin_lock_init(&fmdev->rds_buff_lock);
1568+ spin_lock_init(&fmdev->resp_skb_lock);
1569+
1570+ /* Initialize TX queue and TX tasklet */
1571+ skb_queue_head_init(&fmdev->tx_q);
1572+ tasklet_init(&fmdev->tx_task, send_tasklet, (unsigned long)fmdev);
1573+
1574+ /* Initialize RX Queue and RX tasklet */
1575+ skb_queue_head_init(&fmdev->rx_q);
1576+ tasklet_init(&fmdev->rx_task, recv_tasklet, (unsigned long)fmdev);
1577+
1578+ fmdev->irq_info.stage = 0;
1579+ atomic_set(&fmdev->tx_cnt, 1);
1580+ fmdev->resp_comp = NULL;
1581+
1582+ init_timer(&fmdev->irq_info.timer);
1583+ fmdev->irq_info.timer.function = &int_timeout_handler;
1584+ fmdev->irq_info.timer.data = (unsigned long)fmdev;
1585+ /*TODO: add FM_STIC_EVENT later */
1586+ fmdev->irq_info.mask = FM_MAL_EVENT;
1587+
1588+ /* Region info */
1589+ memcpy(&fmdev->rx.region, &region_configs[default_radio_region],
1590+ sizeof(struct region_info));
1591+
1592+ fmdev->rx.mute_mode = FM_MUTE_OFF;
1593+ fmdev->rx.rf_depend_mute = FM_RX_RF_DEPENDENT_MUTE_OFF;
1594+ fmdev->rx.rds.flag = FM_RDS_DISABLE;
1595+ fmdev->rx.freq = FM_UNDEFINED_FREQ;
1596+ fmdev->rx.rds_mode = FM_RDS_SYSTEM_RDS;
1597+ fmdev->rx.af_mode = FM_RX_RDS_AF_SWITCH_MODE_OFF;
1598+ fmdev->irq_info.retry = 0;
1599+
1600+ fm_rx_reset_rds_cache(fmdev);
1601+ init_waitqueue_head(&fmdev->rx.rds.read_queue);
1602+
1603+ fm_rx_reset_station_info(fmdev);
1604+ set_bit(FM_CORE_READY, &fmdev->flag);
1605+
1606+ return ret;
1607+}
1608+
1609+/*
1610+ * This function will be called from FM V4L2 release function.
1611+ * Unregister from ST driver.
1612+ */
1613+u32 fmc_release(struct fmdev *fmdev)
1614+{
1615+ u32 ret;
1616+
1617+ if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
1618+ fmdbg("FM Core is already down\n");
1619+ return 0;
1620+ }
1621+ /* Sevice pending read */
1622+ wake_up_interruptible(&fmdev->rx.rds.read_queue);
1623+
1624+ tasklet_kill(&fmdev->tx_task);
1625+ tasklet_kill(&fmdev->rx_task);
1626+
1627+ skb_queue_purge(&fmdev->tx_q);
1628+ skb_queue_purge(&fmdev->rx_q);
1629+
1630+ fmdev->resp_comp = NULL;
1631+ fmdev->rx.freq = 0;
1632+
1633+ ret = st_unregister(ST_FM);
1634+ if (ret < 0)
1635+ fmerr("Failed to de-register FM from ST %d\n", ret);
1636+ else
1637+ fmdbg("Successfully unregistered from ST\n");
1638+
1639+ clear_bit(FM_CORE_READY, &fmdev->flag);
1640+ return ret;
1641+}
1642+
1643+/*
1644+ * Module init function. Ask FM V4L module to register video device.
1645+ * Allocate memory for FM driver context and RX RDS buffer.
1646+ */
1647+static int __init fm_drv_init(void)
1648+{
1649+ struct fmdev *fmdev = NULL;
1650+ u32 ret = -ENOMEM;
1651+
1652+ fmdbg("FM driver version %s\n", FM_DRV_VERSION);
1653+
1654+ fmdev = kzalloc(sizeof(struct fmdev), GFP_KERNEL);
1655+ if (NULL == fmdev) {
1656+ fmerr("Can't allocate operation structure memory\n");
1657+ return ret;
1658+ }
1659+ fmdev->rx.rds.buf_size = default_rds_buf * FM_RDS_BLK_SIZE;
1660+ fmdev->rx.rds.buff = kzalloc(fmdev->rx.rds.buf_size, GFP_KERNEL);
1661+ if (NULL == fmdev->rx.rds.buff) {
1662+ fmerr("Can't allocate rds ring buffer\n");
1663+ goto rel_dev;
1664+ }
1665+
1666+ ret = fm_v4l2_init_video_device(fmdev, radio_nr);
1667+ if (ret < 0)
1668+ goto rel_rdsbuf;
1669+
1670+ fmdev->irq_info.handlers = int_handler_table;
1671+ fmdev->curr_fmmode = FM_MODE_OFF;
1672+ fmdev->tx_data.pwr_lvl = FM_PWR_LVL_DEF;
1673+ fmdev->tx_data.preemph = FM_TX_PREEMPH_50US;
1674+ return ret;
1675+
1676+rel_rdsbuf:
1677+ kfree(fmdev->rx.rds.buff);
1678+rel_dev:
1679+ kfree(fmdev);
1680+
1681+ return ret;
1682+}
1683+
1684+/* Module exit function. Ask FM V4L module to unregister video device */
1685+static void __exit fm_drv_exit(void)
1686+{
1687+ struct fmdev *fmdev = NULL;
1688+
1689+ fmdev = fm_v4l2_deinit_video_device();
1690+ if (fmdev != NULL) {
1691+ kfree(fmdev->rx.rds.buff);
1692+ kfree(fmdev);
1693+ }
1694+}
1695+
1696+module_init(fm_drv_init);
1697+module_exit(fm_drv_exit);
1698+
1699+/* ------------- Module Info ------------- */
1700+MODULE_AUTHOR("Manjunatha Halli <manjunatha_halli@ti.com>");
1701+MODULE_DESCRIPTION("FM Driver for TI's Connectivity chip. " FM_DRV_VERSION);
1702+MODULE_VERSION(FM_DRV_VERSION);
1703+MODULE_LICENSE("GPL");
1704diff --git a/drivers/media/radio/wl128x/fmdrv_common.h b/drivers/media/radio/wl128x/fmdrv_common.h
1705new file mode 100644
1706index 0000000..e5091f4
1707--- /dev/null
1708+++ b/drivers/media/radio/wl128x/fmdrv_common.h
1709@@ -0,0 +1,402 @@
1710+/*
1711+ * FM Driver for Connectivity chip of Texas Instruments.
1712+ * FM Common module header file
1713+ *
1714+ * Copyright (C) 2011 Texas Instruments
1715+ *
1716+ * This program is free software; you can redistribute it and/or modify
1717+ * it under the terms of the GNU General Public License version 2 as
1718+ * published by the Free Software Foundation.
1719+ *
1720+ * This program is distributed in the hope that it will be useful,
1721+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
1722+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1723+ * GNU General Public License for more details.
1724+ *
1725+ * You should have received a copy of the GNU General Public License
1726+ * along with this program; if not, write to the Free Software
1727+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1728+ *
1729+ */
1730+
1731+#ifndef _FMDRV_COMMON_H
1732+#define _FMDRV_COMMON_H
1733+
1734+#define FM_ST_REG_TIMEOUT msecs_to_jiffies(6000) /* 6 sec */
1735+#define FM_PKT_LOGICAL_CHAN_NUMBER 0x08 /* Logical channel 8 */
1736+
1737+#define REG_RD 0x1
1738+#define REG_WR 0x0
1739+
1740+struct fm_reg_table {
1741+ u8 opcode;
1742+ u8 type;
1743+ u8 *name;
1744+};
1745+
1746+#define STEREO_GET 0
1747+#define RSSI_LVL_GET 1
1748+#define IF_COUNT_GET 2
1749+#define FLAG_GET 3
1750+#define RDS_SYNC_GET 4
1751+#define RDS_DATA_GET 5
1752+#define FREQ_SET 10
1753+#define AF_FREQ_SET 11
1754+#define MOST_MODE_SET 12
1755+#define MOST_BLEND_SET 13
1756+#define DEMPH_MODE_SET 14
1757+#define SEARCH_LVL_SET 15
1758+#define BAND_SET 16
1759+#define MUTE_STATUS_SET 17
1760+#define RDS_PAUSE_LVL_SET 18
1761+#define RDS_PAUSE_DUR_SET 19
1762+#define RDS_MEM_SET 20
1763+#define RDS_BLK_B_SET 21
1764+#define RDS_MSK_B_SET 22
1765+#define RDS_PI_MASK_SET 23
1766+#define RDS_PI_SET 24
1767+#define RDS_SYSTEM_SET 25
1768+#define INT_MASK_SET 26
1769+#define SEARCH_DIR_SET 27
1770+#define VOLUME_SET 28
1771+#define AUDIO_ENABLE_SET 29
1772+#define PCM_MODE_SET 30
1773+#define I2S_MODE_CONFIG_SET 31
1774+#define POWER_SET 32
1775+#define INTX_CONFIG_SET 33
1776+#define PULL_EN_SET 34
1777+#define HILO_SET 35
1778+#define SWITCH2FREF 36
1779+#define FREQ_DRIFT_REPORT 37
1780+
1781+#define PCE_GET 40
1782+#define FIRM_VER_GET 41
1783+#define ASIC_VER_GET 42
1784+#define ASIC_ID_GET 43
1785+#define MAN_ID_GET 44
1786+#define TUNER_MODE_SET 45
1787+#define STOP_SEARCH 46
1788+#define RDS_CNTRL_SET 47
1789+
1790+#define WRITE_HARDWARE_REG 100
1791+#define CODE_DOWNLOAD 101
1792+#define RESET 102
1793+
1794+#define FM_POWER_MODE 254
1795+#define FM_INTERRUPT 255
1796+
1797+/* Transmitter API */
1798+
1799+#define CHANL_SET 55
1800+#define CHANL_BW_SET 56
1801+#define REF_SET 57
1802+#define POWER_ENB_SET 90
1803+#define POWER_ATT_SET 58
1804+#define POWER_LEV_SET 59
1805+#define AUDIO_DEV_SET 60
1806+#define PILOT_DEV_SET 61
1807+#define RDS_DEV_SET 62
1808+#define TX_BAND_SET 65
1809+#define PUPD_SET 91
1810+#define AUDIO_IO_SET 63
1811+#define PREMPH_SET 64
1812+#define MONO_SET 66
1813+#define MUTE 92
1814+#define MPX_LMT_ENABLE 67
1815+#define PI_SET 93
1816+#define ECC_SET 69
1817+#define PTY 70
1818+#define AF 71
1819+#define DISPLAY_MODE 74
1820+#define RDS_REP_SET 77
1821+#define RDS_CONFIG_DATA_SET 98
1822+#define RDS_DATA_SET 99
1823+#define RDS_DATA_ENB 94
1824+#define TA_SET 78
1825+#define TP_SET 79
1826+#define DI_SET 80
1827+#define MS_SET 81
1828+#define PS_SCROLL_SPEED 82
1829+#define TX_AUDIO_LEVEL_TEST 96
1830+#define TX_AUDIO_LEVEL_TEST_THRESHOLD 73
1831+#define TX_AUDIO_INPUT_LEVEL_RANGE_SET 54
1832+#define RX_ANTENNA_SELECT 87
1833+#define I2C_DEV_ADDR_SET 86
1834+#define REF_ERR_CALIB_PARAM_SET 88
1835+#define REF_ERR_CALIB_PERIODICITY_SET 89
1836+#define SOC_INT_TRIGGER 52
1837+#define SOC_AUDIO_PATH_SET 83
1838+#define SOC_PCMI_OVERRIDE 84
1839+#define SOC_I2S_OVERRIDE 85
1840+#define RSSI_BLOCK_SCAN_FREQ_SET 95
1841+#define RSSI_BLOCK_SCAN_START 97
1842+#define RSSI_BLOCK_SCAN_DATA_GET 5
1843+#define READ_FMANT_TUNE_VALUE 104
1844+
1845+/* SKB helpers */
1846+struct fm_skb_cb {
1847+ __u8 fm_op;
1848+ struct completion *completion;
1849+};
1850+
1851+#define fm_cb(skb) ((struct fm_skb_cb *)(skb->cb))
1852+
1853+/* FM Channel-8 command message format */
1854+struct fm_cmd_msg_hdr {
1855+ __u8 hdr; /* Logical Channel-8 */
1856+ __u8 len; /* Number of bytes follows */
1857+ __u8 op; /* FM Opcode */
1858+ __u8 rd_wr; /* Read/Write command */
1859+ __u8 dlen; /* Length of payload */
1860+} __attribute__ ((packed));
1861+
1862+#define FM_CMD_MSG_HDR_SIZE 5 /* sizeof(struct fm_cmd_msg_hdr) */
1863+
1864+/* FM Channel-8 event messgage format */
1865+struct fm_event_msg_hdr {
1866+ __u8 header; /* Logical Channel-8 */
1867+ __u8 len; /* Number of bytes follows */
1868+ __u8 status; /* Event status */
1869+ __u8 num_fm_hci_cmds; /* Number of pkts the host allowed to send */
1870+ __u8 op; /* FM Opcode */
1871+ __u8 rd_wr; /* Read/Write command */
1872+ __u8 dlen; /* Length of payload */
1873+} __attribute__ ((packed));
1874+
1875+#define FM_EVT_MSG_HDR_SIZE 7 /* sizeof(struct fm_event_msg_hdr) */
1876+
1877+/* TI's magic number in firmware file */
1878+#define FM_FW_FILE_HEADER_MAGIC 0x42535442
1879+
1880+#define FM_ENABLE 1
1881+#define FM_DISABLE 0
1882+
1883+/* FLAG_GET register bits */
1884+#define FM_FR_EVENT (1 << 0)
1885+#define FM_BL_EVENT (1 << 1)
1886+#define FM_RDS_EVENT (1 << 2)
1887+#define FM_BBLK_EVENT (1 << 3)
1888+#define FM_LSYNC_EVENT (1 << 4)
1889+#define FM_LEV_EVENT (1 << 5)
1890+#define FM_IFFR_EVENT (1 << 6)
1891+#define FM_PI_EVENT (1 << 7)
1892+#define FM_PD_EVENT (1 << 8)
1893+#define FM_STIC_EVENT (1 << 9)
1894+#define FM_MAL_EVENT (1 << 10)
1895+#define FM_POW_ENB_EVENT (1 << 11)
1896+
1897+/*
1898+ * Firmware files of FM. ASIC ID and ASIC version will be appened to this,
1899+ * later.
1900+ */
1901+#define FM_FMC_FW_FILE_START ("fmc_ch8")
1902+#define FM_RX_FW_FILE_START ("fm_rx_ch8")
1903+#define FM_TX_FW_FILE_START ("fm_tx_ch8")
1904+
1905+#define FM_UNDEFINED_FREQ 0xFFFFFFFF
1906+
1907+/* Band types */
1908+#define FM_BAND_EUROPE_US 0
1909+#define FM_BAND_JAPAN 1
1910+
1911+/* Seek directions */
1912+#define FM_SEARCH_DIRECTION_DOWN 0
1913+#define FM_SEARCH_DIRECTION_UP 1
1914+
1915+/* Tunner modes */
1916+#define FM_TUNER_STOP_SEARCH_MODE 0
1917+#define FM_TUNER_PRESET_MODE 1
1918+#define FM_TUNER_AUTONOMOUS_SEARCH_MODE 2
1919+#define FM_TUNER_AF_JUMP_MODE 3
1920+
1921+/* Min and Max volume */
1922+#define FM_RX_VOLUME_MIN 0
1923+#define FM_RX_VOLUME_MAX 70
1924+
1925+/* Volume gain step */
1926+#define FM_RX_VOLUME_GAIN_STEP 0x370
1927+
1928+/* Mute modes */
1929+#define FM_MUTE_OFF 0
1930+#define FM_MUTE_ON 1
1931+#define FM_MUTE_ATTENUATE 2
1932+
1933+#define FM_RX_UNMUTE_MODE 0x00
1934+#define FM_RX_RF_DEP_MODE 0x01
1935+#define FM_RX_AC_MUTE_MODE 0x02
1936+#define FM_RX_HARD_MUTE_LEFT_MODE 0x04
1937+#define FM_RX_HARD_MUTE_RIGHT_MODE 0x08
1938+#define FM_RX_SOFT_MUTE_FORCE_MODE 0x10
1939+
1940+/* RF dependent mute mode */
1941+#define FM_RX_RF_DEPENDENT_MUTE_ON 1
1942+#define FM_RX_RF_DEPENDENT_MUTE_OFF 0
1943+
1944+/* RSSI threshold min and max */
1945+#define FM_RX_RSSI_THRESHOLD_MIN -128
1946+#define FM_RX_RSSI_THRESHOLD_MAX 127
1947+
1948+/* Stereo/Mono mode */
1949+#define FM_STEREO_MODE 0
1950+#define FM_MONO_MODE 1
1951+#define FM_STEREO_SOFT_BLEND 1
1952+
1953+/* FM RX De-emphasis filter modes */
1954+#define FM_RX_EMPHASIS_FILTER_50_USEC 0
1955+#define FM_RX_EMPHASIS_FILTER_75_USEC 1
1956+
1957+/* FM RDS modes */
1958+#define FM_RDS_DISABLE 0
1959+#define FM_RDS_ENABLE 1
1960+
1961+#define FM_NO_PI_CODE 0
1962+
1963+/* FM and RX RDS block enable/disable */
1964+#define FM_RX_PWR_SET_FM_ON_RDS_OFF 0x1
1965+#define FM_RX_PWR_SET_FM_AND_RDS_BLK_ON 0x3
1966+#define FM_RX_PWR_SET_FM_AND_RDS_BLK_OFF 0x0
1967+
1968+/* RX RDS */
1969+#define FM_RX_RDS_FLUSH_FIFO 0x1
1970+#define FM_RX_RDS_FIFO_THRESHOLD 64 /* tuples */
1971+#define FM_RDS_BLK_SIZE 3 /* 3 bytes */
1972+
1973+/* RDS block types */
1974+#define FM_RDS_BLOCK_A 0
1975+#define FM_RDS_BLOCK_B 1
1976+#define FM_RDS_BLOCK_C 2
1977+#define FM_RDS_BLOCK_Ctag 3
1978+#define FM_RDS_BLOCK_D 4
1979+#define FM_RDS_BLOCK_E 5
1980+
1981+#define FM_RDS_BLK_IDX_A 0
1982+#define FM_RDS_BLK_IDX_B 1
1983+#define FM_RDS_BLK_IDX_C 2
1984+#define FM_RDS_BLK_IDX_D 3
1985+#define FM_RDS_BLK_IDX_UNKNOWN 0xF0
1986+
1987+#define FM_RDS_STATUS_ERR_MASK 0x18
1988+
1989+/*
1990+ * Represents an RDS group type & version.
1991+ * There are 15 groups, each group has 2 versions: A and B.
1992+ */
1993+#define FM_RDS_GROUP_TYPE_MASK_0A ((unsigned long)1<<0)
1994+#define FM_RDS_GROUP_TYPE_MASK_0B ((unsigned long)1<<1)
1995+#define FM_RDS_GROUP_TYPE_MASK_1A ((unsigned long)1<<2)
1996+#define FM_RDS_GROUP_TYPE_MASK_1B ((unsigned long)1<<3)
1997+#define FM_RDS_GROUP_TYPE_MASK_2A ((unsigned long)1<<4)
1998+#define FM_RDS_GROUP_TYPE_MASK_2B ((unsigned long)1<<5)
1999+#define FM_RDS_GROUP_TYPE_MASK_3A ((unsigned long)1<<6)
2000+#define FM_RDS_GROUP_TYPE_MASK_3B ((unsigned long)1<<7)
2001+#define FM_RDS_GROUP_TYPE_MASK_4A ((unsigned long)1<<8)
2002+#define FM_RDS_GROUP_TYPE_MASK_4B ((unsigned long)1<<9)
2003+#define FM_RDS_GROUP_TYPE_MASK_5A ((unsigned long)1<<10)
2004+#define FM_RDS_GROUP_TYPE_MASK_5B ((unsigned long)1<<11)
2005+#define FM_RDS_GROUP_TYPE_MASK_6A ((unsigned long)1<<12)
2006+#define FM_RDS_GROUP_TYPE_MASK_6B ((unsigned long)1<<13)
2007+#define FM_RDS_GROUP_TYPE_MASK_7A ((unsigned long)1<<14)
2008+#define FM_RDS_GROUP_TYPE_MASK_7B ((unsigned long)1<<15)
2009+#define FM_RDS_GROUP_TYPE_MASK_8A ((unsigned long)1<<16)
2010+#define FM_RDS_GROUP_TYPE_MASK_8B ((unsigned long)1<<17)
2011+#define FM_RDS_GROUP_TYPE_MASK_9A ((unsigned long)1<<18)
2012+#define FM_RDS_GROUP_TYPE_MASK_9B ((unsigned long)1<<19)
2013+#define FM_RDS_GROUP_TYPE_MASK_10A ((unsigned long)1<<20)
2014+#define FM_RDS_GROUP_TYPE_MASK_10B ((unsigned long)1<<21)
2015+#define FM_RDS_GROUP_TYPE_MASK_11A ((unsigned long)1<<22)
2016+#define FM_RDS_GROUP_TYPE_MASK_11B ((unsigned long)1<<23)
2017+#define FM_RDS_GROUP_TYPE_MASK_12A ((unsigned long)1<<24)
2018+#define FM_RDS_GROUP_TYPE_MASK_12B ((unsigned long)1<<25)
2019+#define FM_RDS_GROUP_TYPE_MASK_13A ((unsigned long)1<<26)
2020+#define FM_RDS_GROUP_TYPE_MASK_13B ((unsigned long)1<<27)
2021+#define FM_RDS_GROUP_TYPE_MASK_14A ((unsigned long)1<<28)
2022+#define FM_RDS_GROUP_TYPE_MASK_14B ((unsigned long)1<<29)
2023+#define FM_RDS_GROUP_TYPE_MASK_15A ((unsigned long)1<<30)
2024+#define FM_RDS_GROUP_TYPE_MASK_15B ((unsigned long)1<<31)
2025+
2026+/* RX Alternate Frequency info */
2027+#define FM_RDS_MIN_AF 1
2028+#define FM_RDS_MAX_AF 204
2029+#define FM_RDS_MAX_AF_JAPAN 140
2030+#define FM_RDS_1_AF_FOLLOWS 225
2031+#define FM_RDS_25_AF_FOLLOWS 249
2032+
2033+/* RDS system type (RDS/RBDS) */
2034+#define FM_RDS_SYSTEM_RDS 0
2035+#define FM_RDS_SYSTEM_RBDS 1
2036+
2037+/* AF on/off */
2038+#define FM_RX_RDS_AF_SWITCH_MODE_ON 1
2039+#define FM_RX_RDS_AF_SWITCH_MODE_OFF 0
2040+
2041+/* Retry count when interrupt process goes wrong */
2042+#define FM_IRQ_TIMEOUT_RETRY_MAX 5 /* 5 times */
2043+
2044+/* Audio IO set values */
2045+#define FM_RX_AUDIO_ENABLE_I2S 0x01
2046+#define FM_RX_AUDIO_ENABLE_ANALOG 0x02
2047+#define FM_RX_AUDIO_ENABLE_I2S_AND_ANALOG 0x03
2048+#define FM_RX_AUDIO_ENABLE_DISABLE 0x00
2049+
2050+/* HI/LO set values */
2051+#define FM_RX_IFFREQ_TO_HI_SIDE 0x0
2052+#define FM_RX_IFFREQ_TO_LO_SIDE 0x1
2053+#define FM_RX_IFFREQ_HILO_AUTOMATIC 0x2
2054+
2055+/*
2056+ * Default RX mode configuration. Chip will be configured
2057+ * with this default values after loading RX firmware.
2058+ */
2059+#define FM_DEFAULT_RX_VOLUME 10
2060+#define FM_DEFAULT_RSSI_THRESHOLD 3
2061+
2062+/* Range for TX power level in units for dB/uV */
2063+#define FM_PWR_LVL_LOW 91
2064+#define FM_PWR_LVL_HIGH 122
2065+
2066+/* Chip specific default TX power level value */
2067+#define FM_PWR_LVL_DEF 4
2068+
2069+/* FM TX Pre-emphasis filter values */
2070+#define FM_TX_PREEMPH_OFF 1
2071+#define FM_TX_PREEMPH_50US 0
2072+#define FM_TX_PREEMPH_75US 2
2073+
2074+/* FM TX antenna impedence values */
2075+#define FM_TX_ANT_IMP_50 0
2076+#define FM_TX_ANT_IMP_200 1
2077+#define FM_TX_ANT_IMP_500 2
2078+
2079+/* Functions exported by FM common sub-module */
2080+u32 fmc_prepare(struct fmdev *);
2081+u32 fmc_release(struct fmdev *);
2082+
2083+void fmc_update_region_info(struct fmdev *, u8);
2084+u32 fmc_send_cmd(struct fmdev *, u8, u16,
2085+ void *, unsigned int, void *, int *);
2086+u32 fmc_is_rds_data_available(struct fmdev *, struct file *,
2087+ struct poll_table_struct *);
2088+u32 fmc_transfer_rds_from_internal_buff(struct fmdev *, struct file *,
2089+ u8 __user *, size_t);
2090+
2091+u32 fmc_set_freq(struct fmdev *, u32);
2092+u32 fmc_set_mode(struct fmdev *, u8);
2093+u32 fmc_set_region(struct fmdev *, u8);
2094+u32 fmc_set_mute_mode(struct fmdev *, u8);
2095+u32 fmc_set_stereo_mono(struct fmdev *, u16);
2096+u32 fmc_set_rds_mode(struct fmdev *, u8);
2097+
2098+u32 fmc_get_freq(struct fmdev *, u32 *);
2099+u32 fmc_get_region(struct fmdev *, u8 *);
2100+u32 fmc_get_mode(struct fmdev *, u8 *);
2101+
2102+/*
2103+ * channel spacing
2104+ */
2105+#define FM_CHANNEL_SPACING_50KHZ 1
2106+#define FM_CHANNEL_SPACING_100KHZ 2
2107+#define FM_CHANNEL_SPACING_200KHZ 4
2108+#define FM_FREQ_MUL 50
2109+
2110+#endif
2111+
2112--
21131.6.6.1
2114
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0010-drivers-media-radio-wl128x-FM-driver-RX-sources.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0010-drivers-media-radio-wl128x-FM-driver-RX-sources.patch
new file mode 100644
index 00000000..8899a318
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0010-drivers-media-radio-wl128x-FM-driver-RX-sources.patch
@@ -0,0 +1,938 @@
1From ba32e1ae2a43f33dcfd459c1456d4e612da885db Mon Sep 17 00:00:00 2001
2From: Manjunatha Halli <manjunatha_halli@ti.com>
3Date: Tue, 11 Jan 2011 11:31:24 +0000
4Subject: [PATCH 10/15] drivers:media:radio: wl128x: FM driver RX sources
5
6This has implementation for FM RX functionality.
7It communicates with FM V4l2 module and FM common module
8
9Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com>
10Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl>
11---
12 drivers/media/radio/wl128x/fmdrv_rx.c | 847 +++++++++++++++++++++++++++++++++
13 drivers/media/radio/wl128x/fmdrv_rx.h | 59 +++
14 2 files changed, 906 insertions(+), 0 deletions(-)
15 create mode 100644 drivers/media/radio/wl128x/fmdrv_rx.c
16 create mode 100644 drivers/media/radio/wl128x/fmdrv_rx.h
17
18diff --git a/drivers/media/radio/wl128x/fmdrv_rx.c b/drivers/media/radio/wl128x/fmdrv_rx.c
19new file mode 100644
20index 0000000..ec529b5
21--- /dev/null
22+++ b/drivers/media/radio/wl128x/fmdrv_rx.c
23@@ -0,0 +1,847 @@
24+/*
25+ * FM Driver for Connectivity chip of Texas Instruments.
26+ * This sub-module of FM driver implements FM RX functionality.
27+ *
28+ * Copyright (C) 2011 Texas Instruments
29+ * Author: Raja Mani <raja_mani@ti.com>
30+ * Author: Manjunatha Halli <manjunatha_halli@ti.com>
31+ *
32+ * This program is free software; you can redistribute it and/or modify
33+ * it under the terms of the GNU General Public License version 2 as
34+ * published by the Free Software Foundation.
35+ *
36+ * This program is distributed in the hope that it will be useful,
37+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
38+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
39+ * GNU General Public License for more details.
40+ *
41+ * You should have received a copy of the GNU General Public License
42+ * along with this program; if not, write to the Free Software
43+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
44+ *
45+ */
46+
47+#include "fmdrv.h"
48+#include "fmdrv_common.h"
49+#include "fmdrv_rx.h"
50+
51+void fm_rx_reset_rds_cache(struct fmdev *fmdev)
52+{
53+ fmdev->rx.rds.flag = FM_RDS_DISABLE;
54+ fmdev->rx.rds.last_blk_idx = 0;
55+ fmdev->rx.rds.wr_idx = 0;
56+ fmdev->rx.rds.rd_idx = 0;
57+
58+ if (fmdev->rx.af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
59+ fmdev->irq_info.mask |= FM_LEV_EVENT;
60+}
61+
62+void fm_rx_reset_station_info(struct fmdev *fmdev)
63+{
64+ fmdev->rx.stat_info.picode = FM_NO_PI_CODE;
65+ fmdev->rx.stat_info.afcache_size = 0;
66+ fmdev->rx.stat_info.af_list_max = 0;
67+}
68+
69+u32 fm_rx_set_freq(struct fmdev *fmdev, u32 freq)
70+{
71+ unsigned long timeleft;
72+ u16 payload, curr_frq, intr_flag;
73+ u32 curr_frq_in_khz;
74+ u32 ret, resp_len;
75+
76+ if (freq < fmdev->rx.region.bot_freq || freq > fmdev->rx.region.top_freq) {
77+ fmerr("Invalid frequency %d\n", freq);
78+ return -EINVAL;
79+ }
80+
81+ /* Set audio enable */
82+ payload = FM_RX_AUDIO_ENABLE_I2S_AND_ANALOG;
83+
84+ ret = fmc_send_cmd(fmdev, AUDIO_ENABLE_SET, REG_WR, &payload,
85+ sizeof(payload), NULL, NULL);
86+ if (ret < 0)
87+ return ret;
88+
89+ /* Set hilo to automatic selection */
90+ payload = FM_RX_IFFREQ_HILO_AUTOMATIC;
91+ ret = fmc_send_cmd(fmdev, HILO_SET, REG_WR, &payload,
92+ sizeof(payload), NULL, NULL);
93+ if (ret < 0)
94+ return ret;
95+
96+ /* Calculate frequency index and set*/
97+ payload = (freq - fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
98+
99+ ret = fmc_send_cmd(fmdev, FREQ_SET, REG_WR, &payload,
100+ sizeof(payload), NULL, NULL);
101+ if (ret < 0)
102+ return ret;
103+
104+ /* Read flags - just to clear any pending interrupts if we had */
105+ ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2, NULL, NULL);
106+ if (ret < 0)
107+ return ret;
108+
109+ /* Enable FR, BL interrupts */
110+ intr_flag = fmdev->irq_info.mask;
111+ fmdev->irq_info.mask = (FM_FR_EVENT | FM_BL_EVENT);
112+ payload = fmdev->irq_info.mask;
113+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
114+ sizeof(payload), NULL, NULL);
115+ if (ret < 0)
116+ return ret;
117+
118+ /* Start tune */
119+ payload = FM_TUNER_PRESET_MODE;
120+ ret = fmc_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload,
121+ sizeof(payload), NULL, NULL);
122+ if (ret < 0)
123+ goto exit;
124+
125+ /* Wait for tune ended interrupt */
126+ init_completion(&fmdev->maintask_comp);
127+ timeleft = wait_for_completion_timeout(&fmdev->maintask_comp,
128+ FM_DRV_TX_TIMEOUT);
129+ if (!timeleft) {
130+ fmerr("Timeout(%d sec),didn't get tune ended int\n",
131+ jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000);
132+ ret = -ETIMEDOUT;
133+ goto exit;
134+ }
135+
136+ /* Read freq back to confirm */
137+ ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, 2, &curr_frq, &resp_len);
138+ if (ret < 0)
139+ goto exit;
140+
141+ curr_frq = be16_to_cpu(curr_frq);
142+ curr_frq_in_khz = (fmdev->rx.region.bot_freq + ((u32)curr_frq * FM_FREQ_MUL));
143+
144+ if (curr_frq_in_khz != freq) {
145+ pr_info("Frequency is set to (%d) but "
146+ "requested freq is (%d)\n", curr_frq_in_khz, freq);
147+ }
148+
149+ /* Update local cache */
150+ fmdev->rx.freq = curr_frq_in_khz;
151+exit:
152+ /* Re-enable default FM interrupts */
153+ fmdev->irq_info.mask = intr_flag;
154+ payload = fmdev->irq_info.mask;
155+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
156+ sizeof(payload), NULL, NULL);
157+ if (ret < 0)
158+ return ret;
159+
160+ /* Reset RDS cache and current station pointers */
161+ fm_rx_reset_rds_cache(fmdev);
162+ fm_rx_reset_station_info(fmdev);
163+
164+ return ret;
165+}
166+
167+static u32 fm_rx_set_channel_spacing(struct fmdev *fmdev, u32 spacing)
168+{
169+ u16 payload;
170+ u32 ret;
171+
172+ if (spacing > 0 && spacing <= 50000)
173+ spacing = FM_CHANNEL_SPACING_50KHZ;
174+ else if (spacing > 50000 && spacing <= 100000)
175+ spacing = FM_CHANNEL_SPACING_100KHZ;
176+ else
177+ spacing = FM_CHANNEL_SPACING_200KHZ;
178+
179+ /* set channel spacing */
180+ payload = spacing;
181+ ret = fmc_send_cmd(fmdev, CHANL_BW_SET, REG_WR, &payload,
182+ sizeof(payload), NULL, NULL);
183+ if (ret < 0)
184+ return ret;
185+
186+ fmdev->rx.region.chanl_space = spacing * FM_FREQ_MUL;
187+
188+ return ret;
189+}
190+
191+u32 fm_rx_seek(struct fmdev *fmdev, u32 seek_upward,
192+ u32 wrap_around, u32 spacing)
193+{
194+ u32 resp_len;
195+ u16 curr_frq, next_frq, last_frq;
196+ u16 payload, int_reason, intr_flag;
197+ u16 offset, space_idx;
198+ unsigned long timeleft;
199+ u32 ret;
200+
201+ /* Set channel spacing */
202+ ret = fm_rx_set_channel_spacing(fmdev, spacing);
203+ if (ret < 0) {
204+ fmerr("Failed to set channel spacing\n");
205+ return ret;
206+ }
207+
208+ /* Read the current frequency from chip */
209+ ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL,
210+ sizeof(curr_frq), &curr_frq, &resp_len);
211+ if (ret < 0)
212+ return ret;
213+
214+ curr_frq = be16_to_cpu(curr_frq);
215+ last_frq = (fmdev->rx.region.top_freq - fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
216+
217+ /* Check the offset in order to be aligned to the channel spacing*/
218+ space_idx = fmdev->rx.region.chanl_space / FM_FREQ_MUL;
219+ offset = curr_frq % space_idx;
220+
221+ next_frq = seek_upward ? curr_frq + space_idx /* Seek Up */ :
222+ curr_frq - space_idx /* Seek Down */ ;
223+
224+ /*
225+ * Add or subtract offset in order to stay aligned to the channel
226+ * spacing.
227+ */
228+ if ((short)next_frq < 0)
229+ next_frq = last_frq - offset;
230+ else if (next_frq > last_frq)
231+ next_frq = 0 + offset;
232+
233+again:
234+ /* Set calculated next frequency to perform seek */
235+ payload = next_frq;
236+ ret = fmc_send_cmd(fmdev, FREQ_SET, REG_WR, &payload,
237+ sizeof(payload), NULL, NULL);
238+ if (ret < 0)
239+ return ret;
240+
241+ /* Set search direction (0:Seek Down, 1:Seek Up) */
242+ payload = (seek_upward ? FM_SEARCH_DIRECTION_UP : FM_SEARCH_DIRECTION_DOWN);
243+ ret = fmc_send_cmd(fmdev, SEARCH_DIR_SET, REG_WR, &payload,
244+ sizeof(payload), NULL, NULL);
245+ if (ret < 0)
246+ return ret;
247+
248+ /* Read flags - just to clear any pending interrupts if we had */
249+ ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2, NULL, NULL);
250+ if (ret < 0)
251+ return ret;
252+
253+ /* Enable FR, BL interrupts */
254+ intr_flag = fmdev->irq_info.mask;
255+ fmdev->irq_info.mask = (FM_FR_EVENT | FM_BL_EVENT);
256+ payload = fmdev->irq_info.mask;
257+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
258+ sizeof(payload), NULL, NULL);
259+ if (ret < 0)
260+ return ret;
261+
262+ /* Start seek */
263+ payload = FM_TUNER_AUTONOMOUS_SEARCH_MODE;
264+ ret = fmc_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload,
265+ sizeof(payload), NULL, NULL);
266+ if (ret < 0)
267+ return ret;
268+
269+ /* Wait for tune ended/band limit reached interrupt */
270+ init_completion(&fmdev->maintask_comp);
271+ timeleft = wait_for_completion_timeout(&fmdev->maintask_comp,
272+ FM_DRV_RX_SEEK_TIMEOUT);
273+ if (!timeleft) {
274+ fmerr("Timeout(%d sec),didn't get tune ended int\n",
275+ jiffies_to_msecs(FM_DRV_RX_SEEK_TIMEOUT) / 1000);
276+ return -ETIMEDOUT;
277+ }
278+
279+ int_reason = fmdev->irq_info.flag & (FM_TUNE_COMPLETE | FM_BAND_LIMIT);
280+
281+ /* Re-enable default FM interrupts */
282+ fmdev->irq_info.mask = intr_flag;
283+ payload = fmdev->irq_info.mask;
284+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
285+ sizeof(payload), NULL, NULL);
286+ if (ret < 0)
287+ return ret;
288+
289+ if (int_reason & FM_BL_EVENT) {
290+ if (wrap_around == 0) {
291+ fmdev->rx.freq = seek_upward ?
292+ fmdev->rx.region.top_freq :
293+ fmdev->rx.region.bot_freq;
294+ } else {
295+ fmdev->rx.freq = seek_upward ?
296+ fmdev->rx.region.bot_freq :
297+ fmdev->rx.region.top_freq;
298+ /* Calculate frequency index to write */
299+ next_frq = (fmdev->rx.freq -
300+ fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
301+ goto again;
302+ }
303+ } else {
304+ /* Read freq to know where operation tune operation stopped */
305+ ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, 2,
306+ &curr_frq, &resp_len);
307+ if (ret < 0)
308+ return ret;
309+
310+ curr_frq = be16_to_cpu(curr_frq);
311+ fmdev->rx.freq = (fmdev->rx.region.bot_freq +
312+ ((u32)curr_frq * FM_FREQ_MUL));
313+
314+ }
315+ /* Reset RDS cache and current station pointers */
316+ fm_rx_reset_rds_cache(fmdev);
317+ fm_rx_reset_station_info(fmdev);
318+
319+ return ret;
320+}
321+
322+u32 fm_rx_set_volume(struct fmdev *fmdev, u16 vol_to_set)
323+{
324+ u16 payload;
325+ u32 ret;
326+
327+ if (fmdev->curr_fmmode != FM_MODE_RX)
328+ return -EPERM;
329+
330+ if (vol_to_set < FM_RX_VOLUME_MIN || vol_to_set > FM_RX_VOLUME_MAX) {
331+ fmerr("Volume is not within(%d-%d) range\n",
332+ FM_RX_VOLUME_MIN, FM_RX_VOLUME_MAX);
333+ return -EINVAL;
334+ }
335+ vol_to_set *= FM_RX_VOLUME_GAIN_STEP;
336+
337+ payload = vol_to_set;
338+ ret = fmc_send_cmd(fmdev, VOLUME_SET, REG_WR, &payload,
339+ sizeof(payload), NULL, NULL);
340+ if (ret < 0)
341+ return ret;
342+
343+ fmdev->rx.volume = vol_to_set;
344+ return ret;
345+}
346+
347+/* Get volume */
348+u32 fm_rx_get_volume(struct fmdev *fmdev, u16 *curr_vol)
349+{
350+ if (fmdev->curr_fmmode != FM_MODE_RX)
351+ return -EPERM;
352+
353+ if (curr_vol == NULL) {
354+ fmerr("Invalid memory\n");
355+ return -ENOMEM;
356+ }
357+
358+ *curr_vol = fmdev->rx.volume / FM_RX_VOLUME_GAIN_STEP;
359+
360+ return 0;
361+}
362+
363+/* To get current band's bottom and top frequency */
364+u32 fm_rx_get_band_freq_range(struct fmdev *fmdev, u32 *bot_freq, u32 *top_freq)
365+{
366+ if (bot_freq != NULL)
367+ *bot_freq = fmdev->rx.region.bot_freq;
368+
369+ if (top_freq != NULL)
370+ *top_freq = fmdev->rx.region.top_freq;
371+
372+ return 0;
373+}
374+
375+/* Returns current band index (0-Europe/US; 1-Japan) */
376+void fm_rx_get_region(struct fmdev *fmdev, u8 *region)
377+{
378+ *region = fmdev->rx.region.fm_band;
379+}
380+
381+/* Sets band (0-Europe/US; 1-Japan) */
382+u32 fm_rx_set_region(struct fmdev *fmdev, u8 region_to_set)
383+{
384+ u16 payload;
385+ u32 new_frq = 0;
386+ u32 ret;
387+
388+ if (region_to_set != FM_BAND_EUROPE_US &&
389+ region_to_set != FM_BAND_JAPAN) {
390+ fmerr("Invalid band\n");
391+ return -EINVAL;
392+ }
393+
394+ if (fmdev->rx.region.fm_band == region_to_set) {
395+ fmerr("Requested band is already configured\n");
396+ return 0;
397+ }
398+
399+ /* Send cmd to set the band */
400+ payload = (u16)region_to_set;
401+ ret = fmc_send_cmd(fmdev, BAND_SET, REG_WR, &payload,
402+ sizeof(payload), NULL, NULL);
403+ if (ret < 0)
404+ return ret;
405+
406+ fmc_update_region_info(fmdev, region_to_set);
407+
408+ /* Check whether current RX frequency is within band boundary */
409+ if (fmdev->rx.freq < fmdev->rx.region.bot_freq)
410+ new_frq = fmdev->rx.region.bot_freq;
411+ else if (fmdev->rx.freq > fmdev->rx.region.top_freq)
412+ new_frq = fmdev->rx.region.top_freq;
413+
414+ if (new_frq) {
415+ fmdbg("Current freq is not within band limit boundary,"
416+ "switching to %d KHz\n", new_frq);
417+ /* Current RX frequency is not in range. So, update it */
418+ ret = fm_rx_set_freq(fmdev, new_frq);
419+ }
420+
421+ return ret;
422+}
423+
424+/* Reads current mute mode (Mute Off/On/Attenuate)*/
425+u32 fm_rx_get_mute_mode(struct fmdev *fmdev, u8 *curr_mute_mode)
426+{
427+ if (fmdev->curr_fmmode != FM_MODE_RX)
428+ return -EPERM;
429+
430+ if (curr_mute_mode == NULL) {
431+ fmerr("Invalid memory\n");
432+ return -ENOMEM;
433+ }
434+
435+ *curr_mute_mode = fmdev->rx.mute_mode;
436+
437+ return 0;
438+}
439+
440+static u32 fm_config_rx_mute_reg(struct fmdev *fmdev)
441+{
442+ u16 payload, muteval;
443+ u32 ret;
444+
445+ muteval = 0;
446+ switch (fmdev->rx.mute_mode) {
447+ case FM_MUTE_ON:
448+ muteval = FM_RX_AC_MUTE_MODE;
449+ break;
450+
451+ case FM_MUTE_OFF:
452+ muteval = FM_RX_UNMUTE_MODE;
453+ break;
454+
455+ case FM_MUTE_ATTENUATE:
456+ muteval = FM_RX_SOFT_MUTE_FORCE_MODE;
457+ break;
458+ }
459+ if (fmdev->rx.rf_depend_mute == FM_RX_RF_DEPENDENT_MUTE_ON)
460+ muteval |= FM_RX_RF_DEP_MODE;
461+ else
462+ muteval &= ~FM_RX_RF_DEP_MODE;
463+
464+ payload = muteval;
465+ ret = fmc_send_cmd(fmdev, MUTE_STATUS_SET, REG_WR, &payload,
466+ sizeof(payload), NULL, NULL);
467+ if (ret < 0)
468+ return ret;
469+
470+ return 0;
471+}
472+
473+/* Configures mute mode (Mute Off/On/Attenuate) */
474+u32 fm_rx_set_mute_mode(struct fmdev *fmdev, u8 mute_mode_toset)
475+{
476+ u8 org_state;
477+ u32 ret;
478+
479+ if (fmdev->rx.mute_mode == mute_mode_toset)
480+ return 0;
481+
482+ org_state = fmdev->rx.mute_mode;
483+ fmdev->rx.mute_mode = mute_mode_toset;
484+
485+ ret = fm_config_rx_mute_reg(fmdev);
486+ if (ret < 0) {
487+ fmdev->rx.mute_mode = org_state;
488+ return ret;
489+ }
490+
491+ return 0;
492+}
493+
494+/* Gets RF dependent soft mute mode enable/disable status */
495+u32 fm_rx_get_rfdepend_softmute(struct fmdev *fmdev, u8 *curr_mute_mode)
496+{
497+ if (fmdev->curr_fmmode != FM_MODE_RX)
498+ return -EPERM;
499+
500+ if (curr_mute_mode == NULL) {
501+ fmerr("Invalid memory\n");
502+ return -ENOMEM;
503+ }
504+
505+ *curr_mute_mode = fmdev->rx.rf_depend_mute;
506+
507+ return 0;
508+}
509+
510+/* Sets RF dependent soft mute mode */
511+u32 fm_rx_set_rfdepend_softmute(struct fmdev *fmdev, u8 rfdepend_mute)
512+{
513+ u8 org_state;
514+ u32 ret;
515+
516+ if (fmdev->curr_fmmode != FM_MODE_RX)
517+ return -EPERM;
518+
519+ if (rfdepend_mute != FM_RX_RF_DEPENDENT_MUTE_ON &&
520+ rfdepend_mute != FM_RX_RF_DEPENDENT_MUTE_OFF) {
521+ fmerr("Invalid RF dependent soft mute\n");
522+ return -EINVAL;
523+ }
524+ if (fmdev->rx.rf_depend_mute == rfdepend_mute)
525+ return 0;
526+
527+ org_state = fmdev->rx.rf_depend_mute;
528+ fmdev->rx.rf_depend_mute = rfdepend_mute;
529+
530+ ret = fm_config_rx_mute_reg(fmdev);
531+ if (ret < 0) {
532+ fmdev->rx.rf_depend_mute = org_state;
533+ return ret;
534+ }
535+
536+ return 0;
537+}
538+
539+/* Returns the signal strength level of current channel */
540+u32 fm_rx_get_rssi_level(struct fmdev *fmdev, u16 *rssilvl)
541+{
542+ u16 curr_rssi_lel;
543+ u32 resp_len;
544+ u32 ret;
545+
546+ if (rssilvl == NULL) {
547+ fmerr("Invalid memory\n");
548+ return -ENOMEM;
549+ }
550+ /* Read current RSSI level */
551+ ret = fmc_send_cmd(fmdev, RSSI_LVL_GET, REG_RD, NULL, 2,
552+ &curr_rssi_lel, &resp_len);
553+ if (ret < 0)
554+ return ret;
555+
556+ *rssilvl = be16_to_cpu(curr_rssi_lel);
557+
558+ return 0;
559+}
560+
561+/*
562+ * Sets the signal strength level that once reached
563+ * will stop the auto search process
564+ */
565+u32 fm_rx_set_rssi_threshold(struct fmdev *fmdev, short rssi_lvl_toset)
566+{
567+ u16 payload;
568+ u32 ret;
569+
570+ if (rssi_lvl_toset < FM_RX_RSSI_THRESHOLD_MIN ||
571+ rssi_lvl_toset > FM_RX_RSSI_THRESHOLD_MAX) {
572+ fmerr("Invalid RSSI threshold level\n");
573+ return -EINVAL;
574+ }
575+ payload = (u16)rssi_lvl_toset;
576+ ret = fmc_send_cmd(fmdev, SEARCH_LVL_SET, REG_WR, &payload,
577+ sizeof(payload), NULL, NULL);
578+ if (ret < 0)
579+ return ret;
580+
581+ fmdev->rx.rssi_threshold = rssi_lvl_toset;
582+
583+ return 0;
584+}
585+
586+/* Returns current RX RSSI threshold value */
587+u32 fm_rx_get_rssi_threshold(struct fmdev *fmdev, short *curr_rssi_lvl)
588+{
589+ if (fmdev->curr_fmmode != FM_MODE_RX)
590+ return -EPERM;
591+
592+ if (curr_rssi_lvl == NULL) {
593+ fmerr("Invalid memory\n");
594+ return -ENOMEM;
595+ }
596+
597+ *curr_rssi_lvl = fmdev->rx.rssi_threshold;
598+
599+ return 0;
600+}
601+
602+/* Sets RX stereo/mono modes */
603+u32 fm_rx_set_stereo_mono(struct fmdev *fmdev, u16 mode)
604+{
605+ u16 payload;
606+ u32 ret;
607+
608+ if (mode != FM_STEREO_MODE && mode != FM_MONO_MODE) {
609+ fmerr("Invalid mode\n");
610+ return -EINVAL;
611+ }
612+
613+ /* Set stereo/mono mode */
614+ payload = (u16)mode;
615+ ret = fmc_send_cmd(fmdev, MOST_MODE_SET, REG_WR, &payload,
616+ sizeof(payload), NULL, NULL);
617+ if (ret < 0)
618+ return ret;
619+
620+ /* Set stereo blending mode */
621+ payload = FM_STEREO_SOFT_BLEND;
622+ ret = fmc_send_cmd(fmdev, MOST_BLEND_SET, REG_WR, &payload,
623+ sizeof(payload), NULL, NULL);
624+ if (ret < 0)
625+ return ret;
626+
627+ return 0;
628+}
629+
630+/* Gets current RX stereo/mono mode */
631+u32 fm_rx_get_stereo_mono(struct fmdev *fmdev, u16 *mode)
632+{
633+ u16 curr_mode;
634+ u32 ret, resp_len;
635+
636+ if (mode == NULL) {
637+ fmerr("Invalid memory\n");
638+ return -ENOMEM;
639+ }
640+
641+ ret = fmc_send_cmd(fmdev, MOST_MODE_SET, REG_RD, NULL, 2,
642+ &curr_mode, &resp_len);
643+ if (ret < 0)
644+ return ret;
645+
646+ *mode = be16_to_cpu(curr_mode);
647+
648+ return 0;
649+}
650+
651+/* Choose RX de-emphasis filter mode (50us/75us) */
652+u32 fm_rx_set_deemphasis_mode(struct fmdev *fmdev, u16 mode)
653+{
654+ u16 payload;
655+ u32 ret;
656+
657+ if (fmdev->curr_fmmode != FM_MODE_RX)
658+ return -EPERM;
659+
660+ if (mode != FM_RX_EMPHASIS_FILTER_50_USEC &&
661+ mode != FM_RX_EMPHASIS_FILTER_75_USEC) {
662+ fmerr("Invalid rx de-emphasis mode (%d)\n", mode);
663+ return -EINVAL;
664+ }
665+
666+ payload = mode;
667+ ret = fmc_send_cmd(fmdev, DEMPH_MODE_SET, REG_WR, &payload,
668+ sizeof(payload), NULL, NULL);
669+ if (ret < 0)
670+ return ret;
671+
672+ fmdev->rx.deemphasis_mode = mode;
673+
674+ return 0;
675+}
676+
677+/* Gets current RX de-emphasis filter mode */
678+u32 fm_rx_get_deemph_mode(struct fmdev *fmdev, u16 *curr_deemphasis_mode)
679+{
680+ if (fmdev->curr_fmmode != FM_MODE_RX)
681+ return -EPERM;
682+
683+ if (curr_deemphasis_mode == NULL) {
684+ fmerr("Invalid memory\n");
685+ return -ENOMEM;
686+ }
687+
688+ *curr_deemphasis_mode = fmdev->rx.deemphasis_mode;
689+
690+ return 0;
691+}
692+
693+/* Enable/Disable RX RDS */
694+u32 fm_rx_set_rds_mode(struct fmdev *fmdev, u8 rds_en_dis)
695+{
696+ u16 payload;
697+ u32 ret;
698+
699+ if (rds_en_dis != FM_RDS_ENABLE && rds_en_dis != FM_RDS_DISABLE) {
700+ fmerr("Invalid rds option\n");
701+ return -EINVAL;
702+ }
703+
704+ if (rds_en_dis == FM_RDS_ENABLE
705+ && fmdev->rx.rds.flag == FM_RDS_DISABLE) {
706+ /* Turn on RX RDS and RDS circuit */
707+ payload = FM_RX_PWR_SET_FM_AND_RDS_BLK_ON;
708+ ret = fmc_send_cmd(fmdev, POWER_SET, REG_WR, &payload,
709+ sizeof(payload), NULL, NULL);
710+ if (ret < 0)
711+ return ret;
712+
713+ /* Clear and reset RDS FIFO */
714+ payload = FM_RX_RDS_FLUSH_FIFO;
715+ ret = fmc_send_cmd(fmdev, RDS_CNTRL_SET, REG_WR, &payload,
716+ sizeof(payload), NULL, NULL);
717+ if (ret < 0)
718+ return ret;
719+
720+ /* Read flags - just to clear any pending interrupts. */
721+ ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2,
722+ NULL, NULL);
723+ if (ret < 0)
724+ return ret;
725+
726+ /* Set RDS FIFO threshold value */
727+ payload = FM_RX_RDS_FIFO_THRESHOLD;
728+ ret = fmc_send_cmd(fmdev, RDS_MEM_SET, REG_WR, &payload,
729+ sizeof(payload), NULL, NULL);
730+ if (ret < 0)
731+ return ret;
732+
733+ /* Enable RDS interrupt */
734+ fmdev->irq_info.mask |= FM_RDS_EVENT;
735+ payload = fmdev->irq_info.mask;
736+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
737+ sizeof(payload), NULL, NULL);
738+ if (ret < 0) {
739+ fmdev->irq_info.mask &= ~FM_RDS_EVENT;
740+ return ret;
741+ }
742+
743+ /* Update our local flag */
744+ fmdev->rx.rds.flag = FM_RDS_ENABLE;
745+ } else if (rds_en_dis == FM_RDS_DISABLE
746+ && fmdev->rx.rds.flag == FM_RDS_ENABLE) {
747+ /* Turn off RX RDS */
748+ payload = FM_RX_PWR_SET_FM_ON_RDS_OFF;
749+ ret = fmc_send_cmd(fmdev, POWER_SET, REG_WR, &payload,
750+ sizeof(payload), NULL, NULL);
751+ if (ret < 0)
752+ return ret;
753+
754+ /* Reset RDS pointers */
755+ fmdev->rx.rds.last_blk_idx = 0;
756+ fmdev->rx.rds.wr_idx = 0;
757+ fmdev->rx.rds.rd_idx = 0;
758+ fm_rx_reset_station_info(fmdev);
759+
760+ /* Update RDS local cache */
761+ fmdev->irq_info.mask &= ~(FM_RDS_EVENT);
762+ fmdev->rx.rds.flag = FM_RDS_DISABLE;
763+ }
764+
765+ return 0;
766+}
767+
768+/* Returns current RX RDS enable/disable status */
769+u32 fm_rx_get_rds_mode(struct fmdev *fmdev, u8 *curr_rds_en_dis)
770+{
771+ if (fmdev->curr_fmmode != FM_MODE_RX)
772+ return -EPERM;
773+
774+ if (curr_rds_en_dis == NULL) {
775+ fmerr("Invalid memory\n");
776+ return -ENOMEM;
777+ }
778+
779+ *curr_rds_en_dis = fmdev->rx.rds.flag;
780+
781+ return 0;
782+}
783+
784+/* Sets RDS operation mode (RDS/RDBS) */
785+u32 fm_rx_set_rds_system(struct fmdev *fmdev, u8 rds_mode)
786+{
787+ u16 payload;
788+ u32 ret;
789+
790+ if (fmdev->curr_fmmode != FM_MODE_RX)
791+ return -EPERM;
792+
793+ if (rds_mode != FM_RDS_SYSTEM_RDS && rds_mode != FM_RDS_SYSTEM_RBDS) {
794+ fmerr("Invalid rds mode\n");
795+ return -EINVAL;
796+ }
797+ /* Set RDS operation mode */
798+ payload = (u16)rds_mode;
799+ ret = fmc_send_cmd(fmdev, RDS_SYSTEM_SET, REG_WR, &payload,
800+ sizeof(payload), NULL, NULL);
801+ if (ret < 0)
802+ return ret;
803+
804+ fmdev->rx.rds_mode = rds_mode;
805+
806+ return 0;
807+}
808+
809+/* Returns current RDS operation mode */
810+u32 fm_rx_get_rds_system(struct fmdev *fmdev, u8 *rds_mode)
811+{
812+ if (fmdev->curr_fmmode != FM_MODE_RX)
813+ return -EPERM;
814+
815+ if (rds_mode == NULL) {
816+ fmerr("Invalid memory\n");
817+ return -ENOMEM;
818+ }
819+
820+ *rds_mode = fmdev->rx.rds_mode;
821+
822+ return 0;
823+}
824+
825+/* Configures Alternate Frequency switch mode */
826+u32 fm_rx_set_af_switch(struct fmdev *fmdev, u8 af_mode)
827+{
828+ u16 payload;
829+ u32 ret;
830+
831+ if (fmdev->curr_fmmode != FM_MODE_RX)
832+ return -EPERM;
833+
834+ if (af_mode != FM_RX_RDS_AF_SWITCH_MODE_ON &&
835+ af_mode != FM_RX_RDS_AF_SWITCH_MODE_OFF) {
836+ fmerr("Invalid af mode\n");
837+ return -EINVAL;
838+ }
839+ /* Enable/disable low RSSI interrupt based on af_mode */
840+ if (af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
841+ fmdev->irq_info.mask |= FM_LEV_EVENT;
842+ else
843+ fmdev->irq_info.mask &= ~FM_LEV_EVENT;
844+
845+ payload = fmdev->irq_info.mask;
846+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
847+ sizeof(payload), NULL, NULL);
848+ if (ret < 0)
849+ return ret;
850+
851+ fmdev->rx.af_mode = af_mode;
852+
853+ return 0;
854+}
855+
856+/* Returns Alternate Frequency switch status */
857+u32 fm_rx_get_af_switch(struct fmdev *fmdev, u8 *af_mode)
858+{
859+ if (fmdev->curr_fmmode != FM_MODE_RX)
860+ return -EPERM;
861+
862+ if (af_mode == NULL) {
863+ fmerr("Invalid memory\n");
864+ return -ENOMEM;
865+ }
866+
867+ *af_mode = fmdev->rx.af_mode;
868+
869+ return 0;
870+}
871diff --git a/drivers/media/radio/wl128x/fmdrv_rx.h b/drivers/media/radio/wl128x/fmdrv_rx.h
872new file mode 100644
873index 0000000..329e62f
874--- /dev/null
875+++ b/drivers/media/radio/wl128x/fmdrv_rx.h
876@@ -0,0 +1,59 @@
877+/*
878+ * FM Driver for Connectivity chip of Texas Instruments.
879+ * FM RX module header.
880+ *
881+ * Copyright (C) 2011 Texas Instruments
882+ *
883+ * This program is free software; you can redistribute it and/or modify
884+ * it under the terms of the GNU General Public License version 2 as
885+ * published by the Free Software Foundation.
886+ *
887+ * This program is distributed in the hope that it will be useful,
888+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
889+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
890+ * GNU General Public License for more details.
891+ *
892+ * You should have received a copy of the GNU General Public License
893+ * along with this program; if not, write to the Free Software
894+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
895+ *
896+ */
897+
898+#ifndef _FMDRV_RX_H
899+#define _FMDRV_RX_H
900+
901+u32 fm_rx_set_freq(struct fmdev *, u32);
902+u32 fm_rx_set_mute_mode(struct fmdev *, u8);
903+u32 fm_rx_set_stereo_mono(struct fmdev *, u16);
904+u32 fm_rx_set_rds_mode(struct fmdev *, u8);
905+u32 fm_rx_set_rds_system(struct fmdev *, u8);
906+u32 fm_rx_set_volume(struct fmdev *, u16);
907+u32 fm_rx_set_rssi_threshold(struct fmdev *, short);
908+u32 fm_rx_set_region(struct fmdev *, u8);
909+u32 fm_rx_set_rfdepend_softmute(struct fmdev *, u8);
910+u32 fm_rx_set_deemphasis_mode(struct fmdev *, u16);
911+u32 fm_rx_set_af_switch(struct fmdev *, u8);
912+
913+void fm_rx_reset_rds_cache(struct fmdev *);
914+void fm_rx_reset_station_info(struct fmdev *);
915+
916+u32 fm_rx_seek(struct fmdev *, u32, u32, u32);
917+
918+u32 fm_rx_get_rds_mode(struct fmdev *, u8 *);
919+u32 fm_rx_get_rds_system(struct fmdev *, u8 *);
920+u32 fm_rx_get_mute_mode(struct fmdev *, u8 *);
921+u32 fm_rx_get_volume(struct fmdev *, u16 *);
922+u32 fm_rx_get_band_freq_range(struct fmdev *,
923+ u32 *, u32 *);
924+u32 fm_rx_get_stereo_mono(struct fmdev *, u16 *);
925+u32 fm_rx_get_rssi_level(struct fmdev *, u16 *);
926+u32 fm_rx_get_rssi_threshold(struct fmdev *, short *);
927+u32 fm_rx_get_rfdepend_softmute(struct fmdev *, u8 *);
928+u32 fm_rx_get_deemph_mode(struct fmdev *, u16 *);
929+u32 fm_rx_get_af_switch(struct fmdev *, u8 *);
930+void fm_rx_get_region(struct fmdev *, u8 *);
931+
932+u32 fm_rx_set_chanl_spacing(struct fmdev *, u8);
933+u32 fm_rx_get_chanl_spacing(struct fmdev *, u8 *);
934+#endif
935+
936--
9371.6.6.1
938
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0011-drivers-media-radio-wl128x-FM-driver-TX-sources.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0011-drivers-media-radio-wl128x-FM-driver-TX-sources.patch
new file mode 100644
index 00000000..52b409f8
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0011-drivers-media-radio-wl128x-FM-driver-TX-sources.patch
@@ -0,0 +1,494 @@
1From 87d399bad67bdff67c1601fbb8e54deb5e0cf7e0 Mon Sep 17 00:00:00 2001
2From: Manjunatha Halli <manjunatha_halli@ti.com>
3Date: Tue, 11 Jan 2011 11:31:25 +0000
4Subject: [PATCH 11/15] drivers:media:radio: wl128x: FM driver TX sources
5
6This has implementation for FM TX functionality.
7It communicates with FM V4l2 module and FM common module.
8
9Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com>
10Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl>
11---
12 drivers/media/radio/wl128x/fmdrv_tx.c | 425 +++++++++++++++++++++++++++++++++
13 drivers/media/radio/wl128x/fmdrv_tx.h | 37 +++
14 2 files changed, 462 insertions(+), 0 deletions(-)
15 create mode 100644 drivers/media/radio/wl128x/fmdrv_tx.c
16 create mode 100644 drivers/media/radio/wl128x/fmdrv_tx.h
17
18diff --git a/drivers/media/radio/wl128x/fmdrv_tx.c b/drivers/media/radio/wl128x/fmdrv_tx.c
19new file mode 100644
20index 0000000..be54068
21--- /dev/null
22+++ b/drivers/media/radio/wl128x/fmdrv_tx.c
23@@ -0,0 +1,425 @@
24+/*
25+ * FM Driver for Connectivity chip of Texas Instruments.
26+ * This sub-module of FM driver implements FM TX functionality.
27+ *
28+ * Copyright (C) 2011 Texas Instruments
29+ *
30+ * This program is free software; you can redistribute it and/or modify
31+ * it under the terms of the GNU General Public License version 2 as
32+ * published by the Free Software Foundation.
33+ *
34+ * This program is distributed in the hope that it will be useful,
35+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
36+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37+ * GNU General Public License for more details.
38+ *
39+ * You should have received a copy of the GNU General Public License
40+ * along with this program; if not, write to the Free Software
41+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
42+ *
43+ */
44+
45+#include <linux/delay.h>
46+#include "fmdrv.h"
47+#include "fmdrv_common.h"
48+#include "fmdrv_tx.h"
49+
50+u32 fm_tx_set_stereo_mono(struct fmdev *fmdev, u16 mode)
51+{
52+ u16 payload;
53+ u32 ret;
54+
55+ if (fmdev->tx_data.aud_mode == mode)
56+ return 0;
57+
58+ fmdbg("stereo mode: %d\n", mode);
59+
60+ /* Set Stereo/Mono mode */
61+ payload = (1 - mode);
62+ ret = fmc_send_cmd(fmdev, MONO_SET, REG_WR, &payload,
63+ sizeof(payload), NULL, NULL);
64+ if (ret < 0)
65+ return ret;
66+
67+ fmdev->tx_data.aud_mode = mode;
68+
69+ return ret;
70+}
71+
72+static u32 set_rds_text(struct fmdev *fmdev, u8 *rds_text)
73+{
74+ u16 payload;
75+ u32 ret;
76+
77+ ret = fmc_send_cmd(fmdev, RDS_DATA_SET, REG_WR, rds_text,
78+ strlen(rds_text), NULL, NULL);
79+ if (ret < 0)
80+ return ret;
81+
82+ /* Scroll mode */
83+ payload = (u16)0x1;
84+ ret = fmc_send_cmd(fmdev, DISPLAY_MODE, REG_WR, &payload,
85+ sizeof(payload), NULL, NULL);
86+ if (ret < 0)
87+ return ret;
88+
89+ return 0;
90+}
91+
92+static u32 set_rds_data_mode(struct fmdev *fmdev, u8 mode)
93+{
94+ u16 payload;
95+ u32 ret;
96+
97+ /* Setting unique PI TODO: how unique? */
98+ payload = (u16)0xcafe;
99+ ret = fmc_send_cmd(fmdev, PI_SET, REG_WR, &payload,
100+ sizeof(payload), NULL, NULL);
101+ if (ret < 0)
102+ return ret;
103+
104+ /* Set decoder id */
105+ payload = (u16)0xa;
106+ ret = fmc_send_cmd(fmdev, DI_SET, REG_WR, &payload,
107+ sizeof(payload), NULL, NULL);
108+ if (ret < 0)
109+ return ret;
110+
111+ /* TODO: RDS_MODE_GET? */
112+ return 0;
113+}
114+
115+static u32 set_rds_len(struct fmdev *fmdev, u8 type, u16 len)
116+{
117+ u16 payload;
118+ u32 ret;
119+
120+ len |= type << 8;
121+ payload = len;
122+ ret = fmc_send_cmd(fmdev, RDS_CONFIG_DATA_SET, REG_WR, &payload,
123+ sizeof(payload), NULL, NULL);
124+ if (ret < 0)
125+ return ret;
126+
127+ /* TODO: LENGTH_GET? */
128+ return 0;
129+}
130+
131+u32 fm_tx_set_rds_mode(struct fmdev *fmdev, u8 rds_en_dis)
132+{
133+ u16 payload;
134+ u32 ret;
135+ u8 rds_text[] = "Zoom2\n";
136+
137+ fmdbg("rds_en_dis:%d(E:%d, D:%d)\n", rds_en_dis,
138+ FM_RDS_ENABLE, FM_RDS_DISABLE);
139+
140+ if (rds_en_dis == FM_RDS_ENABLE) {
141+ /* Set RDS length */
142+ set_rds_len(fmdev, 0, strlen(rds_text));
143+
144+ /* Set RDS text */
145+ set_rds_text(fmdev, rds_text);
146+
147+ /* Set RDS mode */
148+ set_rds_data_mode(fmdev, 0x0);
149+ }
150+
151+ /* Send command to enable RDS */
152+ if (rds_en_dis == FM_RDS_ENABLE)
153+ payload = 0x01;
154+ else
155+ payload = 0x00;
156+
157+ ret = fmc_send_cmd(fmdev, RDS_DATA_ENB, REG_WR, &payload,
158+ sizeof(payload), NULL, NULL);
159+ if (ret < 0)
160+ return ret;
161+
162+ if (rds_en_dis == FM_RDS_ENABLE) {
163+ /* Set RDS length */
164+ set_rds_len(fmdev, 0, strlen(rds_text));
165+
166+ /* Set RDS text */
167+ set_rds_text(fmdev, rds_text);
168+ }
169+ fmdev->tx_data.rds.flag = rds_en_dis;
170+
171+ return 0;
172+}
173+
174+u32 fm_tx_set_radio_text(struct fmdev *fmdev, u8 *rds_text, u8 rds_type)
175+{
176+ u16 payload;
177+ u32 ret;
178+
179+ if (fmdev->curr_fmmode != FM_MODE_TX)
180+ return -EPERM;
181+
182+ fm_tx_set_rds_mode(fmdev, 0);
183+
184+ /* Set RDS length */
185+ set_rds_len(fmdev, rds_type, strlen(rds_text));
186+
187+ /* Set RDS text */
188+ set_rds_text(fmdev, rds_text);
189+
190+ /* Set RDS mode */
191+ set_rds_data_mode(fmdev, 0x0);
192+
193+ payload = 1;
194+ ret = fmc_send_cmd(fmdev, RDS_DATA_ENB, REG_WR, &payload,
195+ sizeof(payload), NULL, NULL);
196+ if (ret < 0)
197+ return ret;
198+
199+ return 0;
200+}
201+
202+u32 fm_tx_set_af(struct fmdev *fmdev, u32 af)
203+{
204+ u16 payload;
205+ u32 ret;
206+
207+ if (fmdev->curr_fmmode != FM_MODE_TX)
208+ return -EPERM;
209+
210+ fmdbg("AF: %d\n", af);
211+
212+ af = (af - 87500) / 100;
213+ payload = (u16)af;
214+ ret = fmc_send_cmd(fmdev, TA_SET, REG_WR, &payload,
215+ sizeof(payload), NULL, NULL);
216+ if (ret < 0)
217+ return ret;
218+
219+ return 0;
220+}
221+
222+u32 fm_tx_set_region(struct fmdev *fmdev, u8 region)
223+{
224+ u16 payload;
225+ u32 ret;
226+
227+ if (region != FM_BAND_EUROPE_US && region != FM_BAND_JAPAN) {
228+ fmerr("Invalid band\n");
229+ return -EINVAL;
230+ }
231+
232+ /* Send command to set the band */
233+ payload = (u16)region;
234+ ret = fmc_send_cmd(fmdev, TX_BAND_SET, REG_WR, &payload,
235+ sizeof(payload), NULL, NULL);
236+ if (ret < 0)
237+ return ret;
238+
239+ return 0;
240+}
241+
242+u32 fm_tx_set_mute_mode(struct fmdev *fmdev, u8 mute_mode_toset)
243+{
244+ u16 payload;
245+ u32 ret;
246+
247+ fmdbg("tx: mute mode %d\n", mute_mode_toset);
248+
249+ payload = mute_mode_toset;
250+ ret = fmc_send_cmd(fmdev, MUTE, REG_WR, &payload,
251+ sizeof(payload), NULL, NULL);
252+ if (ret < 0)
253+ return ret;
254+
255+ return 0;
256+}
257+
258+/* Set TX Audio I/O */
259+static u32 set_audio_io(struct fmdev *fmdev)
260+{
261+ struct fmtx_data *tx = &fmdev->tx_data;
262+ u16 payload;
263+ u32 ret;
264+
265+ /* Set Audio I/O Enable */
266+ payload = tx->audio_io;
267+ ret = fmc_send_cmd(fmdev, AUDIO_IO_SET, REG_WR, &payload,
268+ sizeof(payload), NULL, NULL);
269+ if (ret < 0)
270+ return ret;
271+
272+ /* TODO: is audio set? */
273+ return 0;
274+}
275+
276+/* Start TX Transmission */
277+static u32 enable_xmit(struct fmdev *fmdev, u8 new_xmit_state)
278+{
279+ struct fmtx_data *tx = &fmdev->tx_data;
280+ unsigned long timeleft;
281+ u16 payload;
282+ u32 ret;
283+
284+ /* Enable POWER_ENB interrupts */
285+ payload = FM_POW_ENB_EVENT;
286+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
287+ sizeof(payload), NULL, NULL);
288+ if (ret < 0)
289+ return ret;
290+
291+ /* Set Power Enable */
292+ payload = new_xmit_state;
293+ ret = fmc_send_cmd(fmdev, POWER_ENB_SET, REG_WR, &payload,
294+ sizeof(payload), NULL, NULL);
295+ if (ret < 0)
296+ return ret;
297+
298+ /* Wait for Power Enabled */
299+ init_completion(&fmdev->maintask_comp);
300+ timeleft = wait_for_completion_timeout(&fmdev->maintask_comp,
301+ FM_DRV_TX_TIMEOUT);
302+ if (!timeleft) {
303+ fmerr("Timeout(%d sec),didn't get tune ended interrupt\n",
304+ jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000);
305+ return -ETIMEDOUT;
306+ }
307+
308+ set_bit(FM_CORE_TX_XMITING, &fmdev->flag);
309+ tx->xmit_state = new_xmit_state;
310+
311+ return 0;
312+}
313+
314+/* Set TX power level */
315+u32 fm_tx_set_pwr_lvl(struct fmdev *fmdev, u8 new_pwr_lvl)
316+{
317+ u16 payload;
318+ struct fmtx_data *tx = &fmdev->tx_data;
319+ u32 ret;
320+
321+ if (fmdev->curr_fmmode != FM_MODE_TX)
322+ return -EPERM;
323+ fmdbg("tx: pwr_level_to_set %ld\n", (long int)new_pwr_lvl);
324+
325+ /* If the core isn't ready update global variable */
326+ if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
327+ tx->pwr_lvl = new_pwr_lvl;
328+ return 0;
329+ }
330+
331+ /* Set power level: Application will specify power level value in
332+ * units of dB/uV, whereas range and step are specific to FM chip.
333+ * For TI's WL chips, convert application specified power level value
334+ * to chip specific value by subtracting 122 from it. Refer to TI FM
335+ * data sheet for details.
336+ * */
337+
338+ payload = (FM_PWR_LVL_HIGH - new_pwr_lvl);
339+ ret = fmc_send_cmd(fmdev, POWER_LEV_SET, REG_WR, &payload,
340+ sizeof(payload), NULL, NULL);
341+ if (ret < 0)
342+ return ret;
343+
344+ /* TODO: is the power level set? */
345+ tx->pwr_lvl = new_pwr_lvl;
346+
347+ return 0;
348+}
349+
350+/*
351+ * Sets FM TX pre-emphasis filter value (OFF, 50us, or 75us)
352+ * Convert V4L2 specified filter values to chip specific filter values.
353+ */
354+u32 fm_tx_set_preemph_filter(struct fmdev *fmdev, u32 preemphasis)
355+{
356+ struct fmtx_data *tx = &fmdev->tx_data;
357+ u16 payload;
358+ u32 ret;
359+
360+ if (fmdev->curr_fmmode != FM_MODE_TX)
361+ return -EPERM;
362+
363+ switch (preemphasis) {
364+ case V4L2_PREEMPHASIS_DISABLED:
365+ payload = FM_TX_PREEMPH_OFF;
366+ break;
367+ case V4L2_PREEMPHASIS_50_uS:
368+ payload = FM_TX_PREEMPH_50US;
369+ break;
370+ case V4L2_PREEMPHASIS_75_uS:
371+ payload = FM_TX_PREEMPH_75US;
372+ break;
373+ }
374+
375+ ret = fmc_send_cmd(fmdev, PREMPH_SET, REG_WR, &payload,
376+ sizeof(payload), NULL, NULL);
377+ if (ret < 0)
378+ return ret;
379+
380+ tx->preemph = payload;
381+
382+ return ret;
383+}
384+
385+/* Get the TX tuning capacitor value.*/
386+u32 fm_tx_get_tune_cap_val(struct fmdev *fmdev)
387+{
388+ u16 curr_val;
389+ u32 ret, resp_len;
390+
391+ if (fmdev->curr_fmmode != FM_MODE_TX)
392+ return -EPERM;
393+
394+ ret = fmc_send_cmd(fmdev, READ_FMANT_TUNE_VALUE, REG_RD,
395+ NULL, sizeof(curr_val), &curr_val, &resp_len);
396+ if (ret < 0)
397+ return ret;
398+
399+ curr_val = be16_to_cpu(curr_val);
400+
401+ return curr_val;
402+}
403+
404+/* Set TX Frequency */
405+u32 fm_tx_set_freq(struct fmdev *fmdev, u32 freq_to_set)
406+{
407+ struct fmtx_data *tx = &fmdev->tx_data;
408+ u16 payload, chanl_index;
409+ u32 ret;
410+
411+ if (test_bit(FM_CORE_TX_XMITING, &fmdev->flag)) {
412+ enable_xmit(fmdev, 0);
413+ clear_bit(FM_CORE_TX_XMITING, &fmdev->flag);
414+ }
415+
416+ /* Enable FR, BL interrupts */
417+ payload = (FM_FR_EVENT | FM_BL_EVENT);
418+ ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
419+ sizeof(payload), NULL, NULL);
420+ if (ret < 0)
421+ return ret;
422+
423+ tx->tx_frq = (unsigned long)freq_to_set;
424+ fmdbg("tx: freq_to_set %ld\n", (long int)tx->tx_frq);
425+
426+ chanl_index = freq_to_set / 10;
427+
428+ /* Set current tuner channel */
429+ payload = chanl_index;
430+ ret = fmc_send_cmd(fmdev, CHANL_SET, REG_WR, &payload,
431+ sizeof(payload), NULL, NULL);
432+ if (ret < 0)
433+ return ret;
434+
435+ fm_tx_set_pwr_lvl(fmdev, tx->pwr_lvl);
436+ fm_tx_set_preemph_filter(fmdev, tx->preemph);
437+
438+ tx->audio_io = 0x01; /* I2S */
439+ set_audio_io(fmdev);
440+
441+ enable_xmit(fmdev, 0x01); /* Enable transmission */
442+
443+ tx->aud_mode = FM_STEREO_MODE;
444+ tx->rds.flag = FM_RDS_DISABLE;
445+
446+ return 0;
447+}
448+
449diff --git a/drivers/media/radio/wl128x/fmdrv_tx.h b/drivers/media/radio/wl128x/fmdrv_tx.h
450new file mode 100644
451index 0000000..e393a2b
452--- /dev/null
453+++ b/drivers/media/radio/wl128x/fmdrv_tx.h
454@@ -0,0 +1,37 @@
455+/*
456+ * FM Driver for Connectivity chip of Texas Instruments.
457+ * FM TX module header.
458+ *
459+ * Copyright (C) 2011 Texas Instruments
460+ *
461+ * This program is free software; you can redistribute it and/or modify
462+ * it under the terms of the GNU General Public License version 2 as
463+ * published by the Free Software Foundation.
464+ *
465+ * This program is distributed in the hope that it will be useful,
466+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
467+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
468+ * GNU General Public License for more details.
469+ *
470+ * You should have received a copy of the GNU General Public License
471+ * along with this program; if not, write to the Free Software
472+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
473+ *
474+ */
475+
476+#ifndef _FMDRV_TX_H
477+#define _FMDRV_TX_H
478+
479+u32 fm_tx_set_freq(struct fmdev *, u32);
480+u32 fm_tx_set_pwr_lvl(struct fmdev *, u8);
481+u32 fm_tx_set_region(struct fmdev *, u8);
482+u32 fm_tx_set_mute_mode(struct fmdev *, u8);
483+u32 fm_tx_set_stereo_mono(struct fmdev *, u16);
484+u32 fm_tx_set_rds_mode(struct fmdev *, u8);
485+u32 fm_tx_set_radio_text(struct fmdev *, u8 *, u8);
486+u32 fm_tx_set_af(struct fmdev *, u32);
487+u32 fm_tx_set_preemph_filter(struct fmdev *, u32);
488+u32 fm_tx_get_tune_cap_val(struct fmdev *);
489+
490+#endif
491+
492--
4931.6.6.1
494
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0012-drivers-media-radio-wl128x-Kconfig-Makefile-for-wl12.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0012-drivers-media-radio-wl128x-Kconfig-Makefile-for-wl12.patch
new file mode 100644
index 00000000..2e5fda86
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0012-drivers-media-radio-wl128x-Kconfig-Makefile-for-wl12.patch
@@ -0,0 +1,52 @@
1From 949d2c98bb76cc321e5ef5a96a632d831e5953bf Mon Sep 17 00:00:00 2001
2From: Manjunatha Halli <manjunatha_halli@ti.com>
3Date: Tue, 11 Jan 2011 11:31:26 +0000
4Subject: [PATCH 12/15] drivers:media:radio: wl128x: Kconfig & Makefile for wl128x driver
5
6Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com>
7Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl>
8---
9 drivers/media/radio/wl128x/Kconfig | 17 +++++++++++++++++
10 drivers/media/radio/wl128x/Makefile | 6 ++++++
11 2 files changed, 23 insertions(+), 0 deletions(-)
12 create mode 100644 drivers/media/radio/wl128x/Kconfig
13 create mode 100644 drivers/media/radio/wl128x/Makefile
14
15diff --git a/drivers/media/radio/wl128x/Kconfig b/drivers/media/radio/wl128x/Kconfig
16new file mode 100644
17index 0000000..749f67b
18--- /dev/null
19+++ b/drivers/media/radio/wl128x/Kconfig
20@@ -0,0 +1,17 @@
21+#
22+# TI's wl128x FM driver based on TI's ST driver.
23+#
24+menu "Texas Instruments WL128x FM driver (ST based)"
25+config RADIO_WL128X
26+ tristate "Texas Instruments WL128x FM Radio"
27+ depends on VIDEO_V4L2 && RFKILL
28+ select TI_ST
29+ help
30+ Choose Y here if you have this FM radio chip.
31+
32+ In order to control your radio card, you will need to use programs
33+ that are compatible with the Video For Linux 2 API. Information on
34+ this API and pointers to "v4l2" programs may be found at
35+ <file:Documentation/video4linux/API.html>.
36+
37+endmenu
38diff --git a/drivers/media/radio/wl128x/Makefile b/drivers/media/radio/wl128x/Makefile
39new file mode 100644
40index 0000000..32a0ead
41--- /dev/null
42+++ b/drivers/media/radio/wl128x/Makefile
43@@ -0,0 +1,6 @@
44+#
45+# Makefile for TI's shared transport driver based wl128x
46+# FM radio.
47+#
48+obj-$(CONFIG_RADIO_WL128X) += fm_drv.o
49+fm_drv-objs := fmdrv_common.o fmdrv_rx.o fmdrv_tx.o fmdrv_v4l2.o
50--
511.6.6.1
52
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0013-drivers-media-radio-Update-Kconfig-and-Makefile-for-.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0013-drivers-media-radio-Update-Kconfig-and-Makefile-for-.patch
new file mode 100644
index 00000000..ea257a43
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0013-drivers-media-radio-Update-Kconfig-and-Makefile-for-.patch
@@ -0,0 +1,38 @@
1From 340d2fa4ff21c43309e70cc6b4a88f9ee6c23d95 Mon Sep 17 00:00:00 2001
2From: Manjunatha Halli <manjunatha_halli@ti.com>
3Date: Tue, 11 Jan 2011 11:31:27 +0000
4Subject: [PATCH 13/15] drivers:media:radio: Update Kconfig and Makefile for wl128x FM driver.
5
6Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com>
7Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl>
8---
9 drivers/media/radio/Kconfig | 3 +++
10 drivers/media/radio/Makefile | 1 +
11 2 files changed, 4 insertions(+), 0 deletions(-)
12
13diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig
14index 83567b8..4529bc7 100644
15--- a/drivers/media/radio/Kconfig
16+++ b/drivers/media/radio/Kconfig
17@@ -452,4 +452,7 @@ config RADIO_TIMBERDALE
18 found behind the Timberdale FPGA on the Russellville board.
19 Enabling this driver will automatically select the DSP and tuner.
20
21+# TI's ST based wl128x FM radio
22+source "drivers/media/radio/wl128x/Kconfig"
23+
24 endif # RADIO_ADAPTERS
25diff --git a/drivers/media/radio/Makefile b/drivers/media/radio/Makefile
26index f615583..b71f448 100644
27--- a/drivers/media/radio/Makefile
28+++ b/drivers/media/radio/Makefile
29@@ -26,5 +26,6 @@ obj-$(CONFIG_RADIO_TEA5764) += radio-tea5764.o
30 obj-$(CONFIG_RADIO_SAA7706H) += saa7706h.o
31 obj-$(CONFIG_RADIO_TEF6862) += tef6862.o
32 obj-$(CONFIG_RADIO_TIMBERDALE) += radio-timb.o
33+obj-$(CONFIG_RADIO_WL128X) += wl128x/
34
35 EXTRA_CFLAGS += -Isound
36--
371.6.6.1
38
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0014-drivers-misc-ti-st-change-protocol-parse-logic.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0014-drivers-misc-ti-st-change-protocol-parse-logic.patch
new file mode 100644
index 00000000..c16dc453
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0014-drivers-misc-ti-st-change-protocol-parse-logic.patch
@@ -0,0 +1,900 @@
1From 46b2c4077bedb96a38cdceff88f2c9b0a9923a8c Mon Sep 17 00:00:00 2001
2From: Pavan Savoy <pavan_savoy@ti.com>
3Date: Tue, 4 Jan 2011 10:59:47 +0000
4Subject: [PATCH 14/15] drivers:misc:ti-st: change protocol parse logic
5
6TI shared transport driver had to specifically know the
7protocol headers for each type of data it can receive to
8properly re-assemble data if its fragmented during UART
9transaction or fragment if the data is an assembly of
10
11different protocol data.
12
13Now the individual protocol drivers provide enough header
14information for shared transport driver to do this in a
15generic way applicable for all protocols.
16
17Signed-off-by: Pavan Savoy <pavan_savoy@ti.com>
18---
19 drivers/misc/ti-st/st_core.c | 355 +++++++++++++-----------------------------
20 drivers/misc/ti-st/st_kim.c | 56 ++++----
21 include/linux/ti_wilink_st.h | 40 ++++--
22 3 files changed, 167 insertions(+), 284 deletions(-)
23
24diff --git a/drivers/misc/ti-st/st_core.c b/drivers/misc/ti-st/st_core.c
25index f9aad06..84d73c5 100644
26--- a/drivers/misc/ti-st/st_core.c
27+++ b/drivers/misc/ti-st/st_core.c
28@@ -25,10 +25,9 @@
29 #include <linux/init.h>
30 #include <linux/tty.h>
31
32-/* understand BT, FM and GPS for now */
33-#include <net/bluetooth/bluetooth.h>
34-#include <net/bluetooth/hci_core.h>
35-#include <net/bluetooth/hci.h>
36+#include <linux/seq_file.h>
37+#include <linux/skbuff.h>
38+
39 #include <linux/ti_wilink_st.h>
40
41 /* function pointer pointing to either,
42@@ -38,21 +37,20 @@
43 void (*st_recv) (void*, const unsigned char*, long);
44
45 /********************************************************************/
46-#if 0
47-/* internal misc functions */
48-bool is_protocol_list_empty(void)
49+static void add_channel_to_table(struct st_data_s *st_gdata,
50+ struct st_proto_s *new_proto)
51 {
52- unsigned char i = 0;
53- pr_debug(" %s ", __func__);
54- for (i = 0; i < ST_MAX; i++) {
55- if (st_gdata->list[i] != NULL)
56- return ST_NOTEMPTY;
57- /* not empty */
58- }
59- /* list empty */
60- return ST_EMPTY;
61+ pr_info("%s: id %d\n", __func__, new_proto->chnl_id);
62+ /* list now has the channel id as index itself */
63+ st_gdata->list[new_proto->chnl_id] = new_proto;
64+}
65+
66+static void remove_channel_from_table(struct st_data_s *st_gdata,
67+ struct st_proto_s *proto)
68+{
69+ pr_info("%s: id %d\n", __func__, proto->chnl_id);
70+ st_gdata->list[proto->chnl_id] = NULL;
71 }
72-#endif
73
74 /* can be called in from
75 * -- KIM (during fw download)
76@@ -82,15 +80,15 @@ int st_int_write(struct st_data_s *st_gdata,
77 * push the skb received to relevant
78 * protocol stacks
79 */
80-void st_send_frame(enum proto_type protoid, struct st_data_s *st_gdata)
81+void st_send_frame(unsigned char chnl_id, struct st_data_s *st_gdata)
82 {
83- pr_info(" %s(prot:%d) ", __func__, protoid);
84+ pr_info(" %s(prot:%d) ", __func__, chnl_id);
85
86 if (unlikely
87 (st_gdata == NULL || st_gdata->rx_skb == NULL
88- || st_gdata->list[protoid] == NULL)) {
89- pr_err("protocol %d not registered, no data to send?",
90- protoid);
91+ || st_gdata->list[chnl_id] == NULL)) {
92+ pr_err("chnl_id %d not registered, no data to send?",
93+ chnl_id);
94 kfree_skb(st_gdata->rx_skb);
95 return;
96 }
97@@ -99,17 +97,17 @@ void st_send_frame(enum proto_type protoid, struct st_data_s *st_gdata)
98 * - should be just skb_queue_tail for the
99 * protocol stack driver
100 */
101- if (likely(st_gdata->list[protoid]->recv != NULL)) {
102+ if (likely(st_gdata->list[chnl_id]->recv != NULL)) {
103 if (unlikely
104- (st_gdata->list[protoid]->recv
105- (st_gdata->list[protoid]->priv_data, st_gdata->rx_skb)
106+ (st_gdata->list[chnl_id]->recv
107+ (st_gdata->list[chnl_id]->priv_data, st_gdata->rx_skb)
108 != 0)) {
109- pr_err(" proto stack %d's ->recv failed", protoid);
110+ pr_err(" proto stack %d's ->recv failed", chnl_id);
111 kfree_skb(st_gdata->rx_skb);
112 return;
113 }
114 } else {
115- pr_err(" proto stack %d's ->recv null", protoid);
116+ pr_err(" proto stack %d's ->recv null", chnl_id);
117 kfree_skb(st_gdata->rx_skb);
118 }
119 return;
120@@ -124,7 +122,7 @@ void st_reg_complete(struct st_data_s *st_gdata, char err)
121 {
122 unsigned char i = 0;
123 pr_info(" %s ", __func__);
124- for (i = 0; i < ST_MAX; i++) {
125+ for (i = 0; i < ST_MAX_CHANNELS; i++) {
126 if (likely(st_gdata != NULL && st_gdata->list[i] != NULL &&
127 st_gdata->list[i]->reg_complete_cb != NULL))
128 st_gdata->list[i]->reg_complete_cb
129@@ -133,7 +131,7 @@ void st_reg_complete(struct st_data_s *st_gdata, char err)
130 }
131
132 static inline int st_check_data_len(struct st_data_s *st_gdata,
133- int protoid, int len)
134+ unsigned char chnl_id, int len)
135 {
136 int room = skb_tailroom(st_gdata->rx_skb);
137
138@@ -144,7 +142,7 @@ static inline int st_check_data_len(struct st_data_s *st_gdata,
139 * has zero length payload. So, ask ST CORE to
140 * forward the packet to protocol driver (BT/FM/GPS)
141 */
142- st_send_frame(protoid, st_gdata);
143+ st_send_frame(chnl_id, st_gdata);
144
145 } else if (len > room) {
146 /* Received packet's payload length is larger.
147@@ -157,7 +155,7 @@ static inline int st_check_data_len(struct st_data_s *st_gdata,
148 /* Packet header has non-zero payload length and
149 * we have enough space in created skb. Lets read
150 * payload data */
151- st_gdata->rx_state = ST_BT_W4_DATA;
152+ st_gdata->rx_state = ST_W4_DATA;
153 st_gdata->rx_count = len;
154 return len;
155 }
156@@ -167,6 +165,7 @@ static inline int st_check_data_len(struct st_data_s *st_gdata,
157 st_gdata->rx_state = ST_W4_PACKET_TYPE;
158 st_gdata->rx_skb = NULL;
159 st_gdata->rx_count = 0;
160+ st_gdata->rx_chnl = 0;
161
162 return 0;
163 }
164@@ -208,13 +207,10 @@ void st_int_recv(void *disc_data,
165 const unsigned char *data, long count)
166 {
167 char *ptr;
168- struct hci_event_hdr *eh;
169- struct hci_acl_hdr *ah;
170- struct hci_sco_hdr *sh;
171- struct fm_event_hdr *fm;
172- struct gps_event_hdr *gps;
173- int len = 0, type = 0, dlen = 0;
174- static enum proto_type protoid = ST_MAX;
175+ struct st_proto_s *proto;
176+ unsigned short payload_len = 0;
177+ int len = 0, type = 0;
178+ unsigned char *plen;
179 struct st_data_s *st_gdata = (struct st_data_s *)disc_data;
180
181 ptr = (char *)data;
182@@ -242,64 +238,36 @@ void st_int_recv(void *disc_data,
183
184 /* Check ST RX state machine , where are we? */
185 switch (st_gdata->rx_state) {
186-
187- /* Waiting for complete packet ? */
188- case ST_BT_W4_DATA:
189+ /* Waiting for complete packet ? */
190+ case ST_W4_DATA:
191 pr_debug("Complete pkt received");
192-
193 /* Ask ST CORE to forward
194 * the packet to protocol driver */
195- st_send_frame(protoid, st_gdata);
196+ st_send_frame(st_gdata->rx_chnl, st_gdata);
197
198 st_gdata->rx_state = ST_W4_PACKET_TYPE;
199 st_gdata->rx_skb = NULL;
200- protoid = ST_MAX; /* is this required ? */
201- continue;
202-
203- /* Waiting for Bluetooth event header ? */
204- case ST_BT_W4_EVENT_HDR:
205- eh = (struct hci_event_hdr *)st_gdata->rx_skb->
206- data;
207-
208- pr_debug("Event header: evt 0x%2.2x"
209- "plen %d", eh->evt, eh->plen);
210-
211- st_check_data_len(st_gdata, protoid, eh->plen);
212- continue;
213-
214- /* Waiting for Bluetooth acl header ? */
215- case ST_BT_W4_ACL_HDR:
216- ah = (struct hci_acl_hdr *)st_gdata->rx_skb->
217- data;
218- dlen = __le16_to_cpu(ah->dlen);
219-
220- pr_info("ACL header: dlen %d", dlen);
221-
222- st_check_data_len(st_gdata, protoid, dlen);
223- continue;
224-
225- /* Waiting for Bluetooth sco header ? */
226- case ST_BT_W4_SCO_HDR:
227- sh = (struct hci_sco_hdr *)st_gdata->rx_skb->
228- data;
229-
230- pr_info("SCO header: dlen %d", sh->dlen);
231-
232- st_check_data_len(st_gdata, protoid, sh->dlen);
233- continue;
234- case ST_FM_W4_EVENT_HDR:
235- fm = (struct fm_event_hdr *)st_gdata->rx_skb->
236- data;
237- pr_info("FM Header: ");
238- st_check_data_len(st_gdata, ST_FM, fm->plen);
239 continue;
240- /* TODO : Add GPS packet machine logic here */
241- case ST_GPS_W4_EVENT_HDR:
242- /* [0x09 pkt hdr][R/W byte][2 byte len] */
243- gps = (struct gps_event_hdr *)st_gdata->rx_skb->
244- data;
245- pr_info("GPS Header: ");
246- st_check_data_len(st_gdata, ST_GPS, gps->plen);
247+ /* parse the header to know details */
248+ case ST_W4_HEADER:
249+ proto = st_gdata->list[st_gdata->rx_chnl];
250+ plen =
251+ &st_gdata->rx_skb->data
252+ [proto->offset_len_in_hdr];
253+ pr_info("plen pointing to %x\n", *plen);
254+ if (proto->len_size == 1)/* 1 byte len field */
255+ payload_len = *(unsigned char *)plen;
256+ else if (proto->len_size == 2)
257+ payload_len =
258+ __le16_to_cpu(*(unsigned short *)plen);
259+ else
260+ pr_info("%s: invalid length "
261+ "for id %d\n",
262+ __func__, proto->chnl_id);
263+ st_check_data_len(st_gdata, proto->chnl_id,
264+ payload_len);
265+ pr_info("off %d, pay len %d\n",
266+ proto->offset_len_in_hdr, payload_len);
267 continue;
268 } /* end of switch rx_state */
269 }
270@@ -308,51 +276,6 @@ void st_int_recv(void *disc_data,
271 /* Check first byte of packet and identify module
272 * owner (BT/FM/GPS) */
273 switch (*ptr) {
274-
275- /* Bluetooth event packet? */
276- case HCI_EVENT_PKT:
277- pr_info("Event packet");
278- st_gdata->rx_state = ST_BT_W4_EVENT_HDR;
279- st_gdata->rx_count = HCI_EVENT_HDR_SIZE;
280- type = HCI_EVENT_PKT;
281- protoid = ST_BT;
282- break;
283-
284- /* Bluetooth acl packet? */
285- case HCI_ACLDATA_PKT:
286- pr_info("ACL packet");
287- st_gdata->rx_state = ST_BT_W4_ACL_HDR;
288- st_gdata->rx_count = HCI_ACL_HDR_SIZE;
289- type = HCI_ACLDATA_PKT;
290- protoid = ST_BT;
291- break;
292-
293- /* Bluetooth sco packet? */
294- case HCI_SCODATA_PKT:
295- pr_info("SCO packet");
296- st_gdata->rx_state = ST_BT_W4_SCO_HDR;
297- st_gdata->rx_count = HCI_SCO_HDR_SIZE;
298- type = HCI_SCODATA_PKT;
299- protoid = ST_BT;
300- break;
301-
302- /* Channel 8(FM) packet? */
303- case ST_FM_CH8_PKT:
304- pr_info("FM CH8 packet");
305- type = ST_FM_CH8_PKT;
306- st_gdata->rx_state = ST_FM_W4_EVENT_HDR;
307- st_gdata->rx_count = FM_EVENT_HDR_SIZE;
308- protoid = ST_FM;
309- break;
310-
311- /* Channel 9(GPS) packet? */
312- case 0x9: /*ST_LL_GPS_CH9_PKT */
313- pr_info("GPS CH9 packet");
314- type = 0x9; /* ST_LL_GPS_CH9_PKT; */
315- protoid = ST_GPS;
316- st_gdata->rx_state = ST_GPS_W4_EVENT_HDR;
317- st_gdata->rx_count = 3; /* GPS_EVENT_HDR_SIZE -1*/
318- break;
319 case LL_SLEEP_IND:
320 case LL_SLEEP_ACK:
321 case LL_WAKE_UP_IND:
322@@ -373,57 +296,22 @@ void st_int_recv(void *disc_data,
323 continue;
324 /* Unknow packet? */
325 default:
326- pr_err("Unknown packet type %2.2x", (__u8) *ptr);
327- ptr++;
328- count--;
329- continue;
330+ type = *ptr;
331+ st_gdata->rx_skb = alloc_skb(
332+ st_gdata->list[type]->max_frame_size,
333+ GFP_ATOMIC);
334+ skb_reserve(st_gdata->rx_skb,
335+ st_gdata->list[type]->reserve);
336+ /* next 2 required for BT only */
337+ st_gdata->rx_skb->cb[0] = type; /*pkt_type*/
338+ st_gdata->rx_skb->cb[1] = 0; /*incoming*/
339+ st_gdata->rx_chnl = *ptr;
340+ st_gdata->rx_state = ST_W4_HEADER;
341+ st_gdata->rx_count = st_gdata->list[type]->hdr_len;
342+ pr_info("rx_count %ld\n", st_gdata->rx_count);
343 };
344 ptr++;
345 count--;
346-
347- switch (protoid) {
348- case ST_BT:
349- /* Allocate new packet to hold received data */
350- st_gdata->rx_skb =
351- bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
352- if (!st_gdata->rx_skb) {
353- pr_err("Can't allocate mem for new packet");
354- st_gdata->rx_state = ST_W4_PACKET_TYPE;
355- st_gdata->rx_count = 0;
356- return;
357- }
358- bt_cb(st_gdata->rx_skb)->pkt_type = type;
359- break;
360- case ST_FM: /* for FM */
361- st_gdata->rx_skb =
362- alloc_skb(FM_MAX_FRAME_SIZE, GFP_ATOMIC);
363- if (!st_gdata->rx_skb) {
364- pr_err("Can't allocate mem for new packet");
365- st_gdata->rx_state = ST_W4_PACKET_TYPE;
366- st_gdata->rx_count = 0;
367- return;
368- }
369- /* place holder 0x08 */
370- skb_reserve(st_gdata->rx_skb, 1);
371- st_gdata->rx_skb->cb[0] = ST_FM_CH8_PKT;
372- break;
373- case ST_GPS:
374- /* for GPS */
375- st_gdata->rx_skb =
376- alloc_skb(100 /*GPS_MAX_FRAME_SIZE */ , GFP_ATOMIC);
377- if (!st_gdata->rx_skb) {
378- pr_err("Can't allocate mem for new packet");
379- st_gdata->rx_state = ST_W4_PACKET_TYPE;
380- st_gdata->rx_count = 0;
381- return;
382- }
383- /* place holder 0x09 */
384- skb_reserve(st_gdata->rx_skb, 1);
385- st_gdata->rx_skb->cb[0] = 0x09; /*ST_GPS_CH9_PKT; */
386- break;
387- case ST_MAX:
388- break;
389- }
390 }
391 pr_debug("done %s", __func__);
392 return;
393@@ -565,20 +453,28 @@ long st_register(struct st_proto_s *new_proto)
394 unsigned long flags = 0;
395
396 st_kim_ref(&st_gdata, 0);
397- pr_info("%s(%d) ", __func__, new_proto->type);
398+ pr_info("%s(%d) ", __func__, new_proto->chnl_id);
399 if (st_gdata == NULL || new_proto == NULL || new_proto->recv == NULL
400 || new_proto->reg_complete_cb == NULL) {
401 pr_err("gdata/new_proto/recv or reg_complete_cb not ready");
402+ if (st_gdata == NULL)
403+ pr_err("error 1\n");
404+ if (new_proto == NULL)
405+ pr_err("error 2\n");
406+ if (new_proto->recv == NULL)
407+ pr_err("error 3\n");
408+ if (new_proto->reg_complete_cb == NULL)
409+ pr_err("erro 4\n");
410 return -1;
411 }
412
413- if (new_proto->type < ST_BT || new_proto->type >= ST_MAX) {
414- pr_err("protocol %d not supported", new_proto->type);
415+ if (new_proto->chnl_id >= ST_MAX_CHANNELS) {
416+ pr_err("chnl_id %d not supported", new_proto->chnl_id);
417 return -EPROTONOSUPPORT;
418 }
419
420- if (st_gdata->list[new_proto->type] != NULL) {
421- pr_err("protocol %d already registered", new_proto->type);
422+ if (st_gdata->list[new_proto->chnl_id] != NULL) {
423+ pr_err("chnl_id %d already registered", new_proto->chnl_id);
424 return -EALREADY;
425 }
426
427@@ -586,11 +482,11 @@ long st_register(struct st_proto_s *new_proto)
428 spin_lock_irqsave(&st_gdata->lock, flags);
429
430 if (test_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state)) {
431- pr_info(" ST_REG_IN_PROGRESS:%d ", new_proto->type);
432+ pr_info(" ST_REG_IN_PROGRESS:%d ", new_proto->chnl_id);
433 /* fw download in progress */
434- st_kim_chip_toggle(new_proto->type, KIM_GPIO_ACTIVE);
435+ st_kim_chip_toggle(new_proto->chnl_id, KIM_GPIO_ACTIVE);
436
437- st_gdata->list[new_proto->type] = new_proto;
438+ add_channel_to_table(st_gdata, new_proto);
439 st_gdata->protos_registered++;
440 new_proto->write = st_write;
441
442@@ -598,7 +494,7 @@ long st_register(struct st_proto_s *new_proto)
443 spin_unlock_irqrestore(&st_gdata->lock, flags);
444 return -EINPROGRESS;
445 } else if (st_gdata->protos_registered == ST_EMPTY) {
446- pr_info(" protocol list empty :%d ", new_proto->type);
447+ pr_info(" chnl_id list empty :%d ", new_proto->chnl_id);
448 set_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state);
449 st_recv = st_kim_recv;
450
451@@ -622,9 +518,9 @@ long st_register(struct st_proto_s *new_proto)
452 return -1;
453 }
454
455- /* the protocol might require other gpios to be toggled
456+ /* the chnl_id might require other gpios to be toggled
457 */
458- st_kim_chip_toggle(new_proto->type, KIM_GPIO_ACTIVE);
459+ st_kim_chip_toggle(new_proto->chnl_id, KIM_GPIO_ACTIVE);
460
461 clear_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state);
462 st_recv = st_int_recv;
463@@ -642,14 +538,14 @@ long st_register(struct st_proto_s *new_proto)
464 /* check for already registered once more,
465 * since the above check is old
466 */
467- if (st_gdata->list[new_proto->type] != NULL) {
468+ if (st_gdata->list[new_proto->chnl_id] != NULL) {
469 pr_err(" proto %d already registered ",
470- new_proto->type);
471+ new_proto->chnl_id);
472 return -EALREADY;
473 }
474
475 spin_lock_irqsave(&st_gdata->lock, flags);
476- st_gdata->list[new_proto->type] = new_proto;
477+ add_channel_to_table(st_gdata, new_proto);
478 st_gdata->protos_registered++;
479 new_proto->write = st_write;
480 spin_unlock_irqrestore(&st_gdata->lock, flags);
481@@ -657,22 +553,7 @@ long st_register(struct st_proto_s *new_proto)
482 }
483 /* if fw is already downloaded & new stack registers protocol */
484 else {
485- switch (new_proto->type) {
486- case ST_BT:
487- /* do nothing */
488- break;
489- case ST_FM:
490- case ST_GPS:
491- st_kim_chip_toggle(new_proto->type, KIM_GPIO_ACTIVE);
492- break;
493- case ST_MAX:
494- default:
495- pr_err("%d protocol not supported",
496- new_proto->type);
497- spin_unlock_irqrestore(&st_gdata->lock, flags);
498- return -EPROTONOSUPPORT;
499- }
500- st_gdata->list[new_proto->type] = new_proto;
501+ add_channel_to_table(st_gdata, new_proto);
502 st_gdata->protos_registered++;
503 new_proto->write = st_write;
504
505@@ -680,48 +561,48 @@ long st_register(struct st_proto_s *new_proto)
506 spin_unlock_irqrestore(&st_gdata->lock, flags);
507 return err;
508 }
509- pr_debug("done %s(%d) ", __func__, new_proto->type);
510+ pr_debug("done %s(%d) ", __func__, new_proto->chnl_id);
511 }
512 EXPORT_SYMBOL_GPL(st_register);
513
514 /* to unregister a protocol -
515 * to be called from protocol stack driver
516 */
517-long st_unregister(enum proto_type type)
518+long st_unregister(struct st_proto_s *proto)
519 {
520 long err = 0;
521 unsigned long flags = 0;
522 struct st_data_s *st_gdata;
523
524- pr_debug("%s: %d ", __func__, type);
525+ pr_debug("%s: %d ", __func__, proto->chnl_id);
526
527 st_kim_ref(&st_gdata, 0);
528- if (type < ST_BT || type >= ST_MAX) {
529- pr_err(" protocol %d not supported", type);
530+ if (proto->chnl_id >= ST_MAX_CHANNELS) {
531+ pr_err(" chnl_id %d not supported", proto->chnl_id);
532 return -EPROTONOSUPPORT;
533 }
534
535 spin_lock_irqsave(&st_gdata->lock, flags);
536
537- if (st_gdata->list[type] == NULL) {
538- pr_err(" protocol %d not registered", type);
539+ if (st_gdata->list[proto->chnl_id] == NULL) {
540+ pr_err(" chnl_id %d not registered", proto->chnl_id);
541 spin_unlock_irqrestore(&st_gdata->lock, flags);
542 return -EPROTONOSUPPORT;
543 }
544
545 st_gdata->protos_registered--;
546- st_gdata->list[type] = NULL;
547+ remove_channel_from_table(st_gdata, proto);
548
549 /* kim ignores BT in the below function
550 * and handles the rest, BT is toggled
551 * only in kim_start and kim_stop
552 */
553- st_kim_chip_toggle(type, KIM_GPIO_INACTIVE);
554+ st_kim_chip_toggle(proto->chnl_id, KIM_GPIO_INACTIVE);
555 spin_unlock_irqrestore(&st_gdata->lock, flags);
556
557 if ((st_gdata->protos_registered == ST_EMPTY) &&
558 (!test_bit(ST_REG_PENDING, &st_gdata->st_state))) {
559- pr_info(" all protocols unregistered ");
560+ pr_info(" all chnl_ids unregistered ");
561
562 /* stop traffic on tty */
563 if (st_gdata->tty) {
564@@ -729,7 +610,7 @@ long st_unregister(enum proto_type type)
565 stop_tty(st_gdata->tty);
566 }
567
568- /* all protocols now unregistered */
569+ /* all chnl_ids now unregistered */
570 st_kim_stop(st_gdata->kim_data);
571 /* disable ST LL */
572 st_ll_disable(st_gdata);
573@@ -745,7 +626,7 @@ long st_write(struct sk_buff *skb)
574 {
575 struct st_data_s *st_gdata;
576 #ifdef DEBUG
577- enum proto_type protoid = ST_MAX;
578+ unsigned char chnl_id = ST_MAX_CHANNELS;
579 #endif
580 long len;
581
582@@ -756,22 +637,10 @@ long st_write(struct sk_buff *skb)
583 return -1;
584 }
585 #ifdef DEBUG /* open-up skb to read the 1st byte */
586- switch (skb->data[0]) {
587- case HCI_COMMAND_PKT:
588- case HCI_ACLDATA_PKT:
589- case HCI_SCODATA_PKT:
590- protoid = ST_BT;
591- break;
592- case ST_FM_CH8_PKT:
593- protoid = ST_FM;
594- break;
595- case 0x09:
596- protoid = ST_GPS;
597- break;
598- }
599- if (unlikely(st_gdata->list[protoid] == NULL)) {
600- pr_err(" protocol %d not registered, and writing? ",
601- protoid);
602+ chnl_id = skb->data[0];
603+ if (unlikely(st_gdata->list[chnl_id] == NULL)) {
604+ pr_err(" chnl_id %d not registered, and writing? ",
605+ chnl_id);
606 return -1;
607 }
608 #endif
609@@ -824,7 +693,7 @@ static int st_tty_open(struct tty_struct *tty)
610
611 static void st_tty_close(struct tty_struct *tty)
612 {
613- unsigned char i = ST_MAX;
614+ unsigned char i = ST_MAX_CHANNELS;
615 unsigned long flags = 0;
616 struct st_data_s *st_gdata = tty->disc_data;
617
618@@ -835,7 +704,7 @@ static void st_tty_close(struct tty_struct *tty)
619 * un-installed for some reason - what should be done ?
620 */
621 spin_lock_irqsave(&st_gdata->lock, flags);
622- for (i = ST_BT; i < ST_MAX; i++) {
623+ for (i = ST_BT; i < ST_MAX_CHANNELS; i++) {
624 if (st_gdata->list[i] != NULL)
625 pr_err("%d not un-registered", i);
626 st_gdata->list[i] = NULL;
627@@ -869,7 +738,7 @@ static void st_tty_close(struct tty_struct *tty)
628 static void st_tty_receive(struct tty_struct *tty, const unsigned char *data,
629 char *tty_flags, int count)
630 {
631-
632+#define VERBOSE
633 #ifdef VERBOSE
634 print_hex_dump(KERN_DEBUG, ">in>", DUMP_PREFIX_NONE,
635 16, 1, data, count, 0);
636diff --git a/drivers/misc/ti-st/st_kim.c b/drivers/misc/ti-st/st_kim.c
637index 73b6c8b..707c858 100644
638--- a/drivers/misc/ti-st/st_kim.c
639+++ b/drivers/misc/ti-st/st_kim.c
640@@ -32,11 +32,7 @@
641 #include <linux/sched.h>
642 #include <linux/rfkill.h>
643
644-/* understand BT events for fw response */
645-#include <net/bluetooth/bluetooth.h>
646-#include <net/bluetooth/hci_core.h>
647-#include <net/bluetooth/hci.h>
648-
649+#include <linux/skbuff.h>
650 #include <linux/ti_wilink_st.h>
651
652
653@@ -134,7 +130,7 @@ static inline int kim_check_data_len(struct kim_data_s *kim_gdata, int len)
654 /* Packet header has non-zero payload length and
655 * we have enough space in created skb. Lets read
656 * payload data */
657- kim_gdata->rx_state = ST_BT_W4_DATA;
658+ kim_gdata->rx_state = ST_W4_DATA;
659 kim_gdata->rx_count = len;
660 return len;
661 }
662@@ -158,8 +154,8 @@ void kim_int_recv(struct kim_data_s *kim_gdata,
663 const unsigned char *data, long count)
664 {
665 const unsigned char *ptr;
666- struct hci_event_hdr *eh;
667 int len = 0, type = 0;
668+ unsigned char *plen;
669
670 pr_debug("%s", __func__);
671 /* Decode received bytes here */
672@@ -183,29 +179,27 @@ void kim_int_recv(struct kim_data_s *kim_gdata,
673 /* Check ST RX state machine , where are we? */
674 switch (kim_gdata->rx_state) {
675 /* Waiting for complete packet ? */
676- case ST_BT_W4_DATA:
677+ case ST_W4_DATA:
678 pr_debug("Complete pkt received");
679 validate_firmware_response(kim_gdata);
680 kim_gdata->rx_state = ST_W4_PACKET_TYPE;
681 kim_gdata->rx_skb = NULL;
682 continue;
683 /* Waiting for Bluetooth event header ? */
684- case ST_BT_W4_EVENT_HDR:
685- eh = (struct hci_event_hdr *)kim_gdata->
686- rx_skb->data;
687- pr_debug("Event header: evt 0x%2.2x"
688- "plen %d", eh->evt, eh->plen);
689- kim_check_data_len(kim_gdata, eh->plen);
690+ case ST_W4_HEADER:
691+ plen =
692+ (unsigned char *)&kim_gdata->rx_skb->data[1];
693+ pr_debug("event hdr: plen 0x%02x\n", *plen);
694+ kim_check_data_len(kim_gdata, *plen);
695 continue;
696 } /* end of switch */
697 } /* end of if rx_state */
698 switch (*ptr) {
699 /* Bluetooth event packet? */
700- case HCI_EVENT_PKT:
701- pr_info("Event packet");
702- kim_gdata->rx_state = ST_BT_W4_EVENT_HDR;
703- kim_gdata->rx_count = HCI_EVENT_HDR_SIZE;
704- type = HCI_EVENT_PKT;
705+ case 0x04:
706+ kim_gdata->rx_state = ST_W4_HEADER;
707+ kim_gdata->rx_count = 2;
708+ type = *ptr;
709 break;
710 default:
711 pr_info("unknown packet");
712@@ -216,16 +210,18 @@ void kim_int_recv(struct kim_data_s *kim_gdata,
713 ptr++;
714 count--;
715 kim_gdata->rx_skb =
716- bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
717+ alloc_skb(1024+8, GFP_ATOMIC);
718 if (!kim_gdata->rx_skb) {
719 pr_err("can't allocate mem for new packet");
720 kim_gdata->rx_state = ST_W4_PACKET_TYPE;
721 kim_gdata->rx_count = 0;
722 return;
723 }
724- bt_cb(kim_gdata->rx_skb)->pkt_type = type;
725+ skb_reserve(kim_gdata->rx_skb, 8);
726+ kim_gdata->rx_skb->cb[0] = 4;
727+ kim_gdata->rx_skb->cb[1] = 0;
728+
729 }
730- pr_info("done %s", __func__);
731 return;
732 }
733
734@@ -398,7 +394,7 @@ void st_kim_chip_toggle(enum proto_type type, enum kim_gpio_state state)
735 gpio_set_value(kim_gdata->gpios[ST_GPS], GPIO_LOW);
736 break;
737
738- case ST_MAX:
739+ case ST_MAX_CHANNELS:
740 default:
741 break;
742 }
743@@ -416,7 +412,6 @@ void st_kim_recv(void *disc_data, const unsigned char *data, long count)
744 struct st_data_s *st_gdata = (struct st_data_s *)disc_data;
745 struct kim_data_s *kim_gdata = st_gdata->kim_data;
746
747- pr_info(" %s ", __func__);
748 /* copy to local buffer */
749 if (unlikely(data[4] == 0x01 && data[5] == 0x10 && data[0] == 0x04)) {
750 /* must be the read_ver_cmd */
751@@ -578,7 +573,7 @@ static int kim_toggle_radio(void *data, bool blocked)
752 else
753 st_kim_chip_toggle(type, KIM_GPIO_ACTIVE);
754 break;
755- case ST_MAX:
756+ case ST_MAX_CHANNELS:
757 pr_err(" wrong proto type ");
758 break;
759 }
760@@ -664,12 +659,13 @@ static int kim_probe(struct platform_device *pdev)
761 /* refer to itself */
762 kim_gdata->core_data->kim_data = kim_gdata;
763
764- for (proto = 0; proto < ST_MAX; proto++) {
765+ for (proto = 0; proto < ST_MAX_CHANNELS; proto++) {
766 kim_gdata->gpios[proto] = gpios[proto];
767 pr_info(" %ld gpio to be requested", gpios[proto]);
768 }
769
770- for (proto = 0; (proto < ST_MAX) && (gpios[proto] != -1); proto++) {
771+ for (proto = 0; (proto < ST_MAX_CHANNELS)
772+ && (gpios[proto] != -1); proto++) {
773 /* Claim the Bluetooth/FM/GPIO
774 * nShutdown gpio from the system
775 */
776@@ -704,7 +700,8 @@ static int kim_probe(struct platform_device *pdev)
777 init_completion(&kim_gdata->kim_rcvd);
778 init_completion(&kim_gdata->ldisc_installed);
779
780- for (proto = 0; (proto < ST_MAX) && (gpios[proto] != -1); proto++) {
781+ for (proto = 0; (proto < ST_MAX_CHANNELS)
782+ && (gpios[proto] != -1); proto++) {
783 /* TODO: should all types be rfkill_type_bt ? */
784 kim_gdata->rf_protos[proto] = proto;
785 kim_gdata->rfkill[proto] = rfkill_alloc(protocol_names[proto],
786@@ -752,7 +749,8 @@ static int kim_remove(struct platform_device *pdev)
787
788 kim_gdata = dev_get_drvdata(&pdev->dev);
789
790- for (proto = 0; (proto < ST_MAX) && (gpios[proto] != -1); proto++) {
791+ for (proto = 0; (proto < ST_MAX_CHANNELS)
792+ && (gpios[proto] != -1); proto++) {
793 /* Claim the Bluetooth/FM/GPIO
794 * nShutdown gpio from the system
795 */
796diff --git a/include/linux/ti_wilink_st.h b/include/linux/ti_wilink_st.h
797index 4c7be22..1674ca7 100644
798--- a/include/linux/ti_wilink_st.h
799+++ b/include/linux/ti_wilink_st.h
800@@ -42,7 +42,7 @@ enum proto_type {
801 ST_BT,
802 ST_FM,
803 ST_GPS,
804- ST_MAX,
805+ ST_MAX_CHANNELS = 16,
806 };
807
808 /**
809@@ -62,6 +62,17 @@ enum proto_type {
810 * @priv_data: privdate data holder for the protocol drivers, sent
811 * from the protocol drivers during registration, and sent back on
812 * reg_complete_cb and recv.
813+ * @chnl_id: channel id the protocol driver is interested in, the channel
814+ * id is nothing but the 1st byte of the packet in UART frame.
815+ * @max_frame_size: size of the largest frame the protocol can receive.
816+ * @hdr_len: length of the header structure of the protocol.
817+ * @offset_len_in_hdr: this provides the offset of the length field in the
818+ * header structure of the protocol header, to assist ST to know
819+ * how much to receive, if the data is split across UART frames.
820+ * @len_size: whether the length field inside the header is 2 bytes
821+ * or 1 byte.
822+ * @reserve: the number of bytes ST needs to reserve in the skb being
823+ * prepared for the protocol driver.
824 */
825 struct st_proto_s {
826 enum proto_type type;
827@@ -70,10 +81,17 @@ struct st_proto_s {
828 void (*reg_complete_cb) (void *, char data);
829 long (*write) (struct sk_buff *skb);
830 void *priv_data;
831+
832+ unsigned char chnl_id;
833+ unsigned short max_frame_size;
834+ unsigned char hdr_len;
835+ unsigned char offset_len_in_hdr;
836+ unsigned char len_size;
837+ unsigned char reserve;
838 };
839
840 extern long st_register(struct st_proto_s *);
841-extern long st_unregister(enum proto_type);
842+extern long st_unregister(struct st_proto_s *);
843
844
845 /*
846@@ -114,6 +132,7 @@ extern long st_unregister(enum proto_type);
847 * @rx_skb: the skb where all data for a protocol gets accumulated,
848 * since tty might not call receive when a complete event packet
849 * is received, the states, count and the skb needs to be maintained.
850+ * @rx_chnl: the channel ID for which the data is getting accumalated for.
851 * @txq: the list of skbs which needs to be sent onto the TTY.
852 * @tx_waitq: if the chip is not in AWAKE state, the skbs needs to be queued
853 * up in here, PM(WAKEUP_IND) data needs to be sent and then the skbs
854@@ -135,10 +154,11 @@ struct st_data_s {
855 #define ST_TX_SENDING 1
856 #define ST_TX_WAKEUP 2
857 unsigned long tx_state;
858- struct st_proto_s *list[ST_MAX];
859+ struct st_proto_s *list[ST_MAX_CHANNELS];
860 unsigned long rx_state;
861 unsigned long rx_count;
862 struct sk_buff *rx_skb;
863+ unsigned char rx_chnl;
864 struct sk_buff_head txq, tx_waitq;
865 spinlock_t lock;
866 unsigned char protos_registered;
867@@ -243,12 +263,12 @@ struct kim_data_s {
868 struct completion kim_rcvd, ldisc_installed;
869 char resp_buffer[30];
870 const struct firmware *fw_entry;
871- long gpios[ST_MAX];
872+ long gpios[ST_MAX_CHANNELS];
873 unsigned long rx_state;
874 unsigned long rx_count;
875 struct sk_buff *rx_skb;
876- struct rfkill *rfkill[ST_MAX];
877- enum proto_type rf_protos[ST_MAX];
878+ struct rfkill *rfkill[ST_MAX_CHANNELS];
879+ enum proto_type rf_protos[ST_MAX_CHANNELS];
880 struct st_data_s *core_data;
881 struct chip_version version;
882 };
883@@ -338,12 +358,8 @@ struct hci_command {
884
885 /* ST LL receiver states */
886 #define ST_W4_PACKET_TYPE 0
887-#define ST_BT_W4_EVENT_HDR 1
888-#define ST_BT_W4_ACL_HDR 2
889-#define ST_BT_W4_SCO_HDR 3
890-#define ST_BT_W4_DATA 4
891-#define ST_FM_W4_EVENT_HDR 5
892-#define ST_GPS_W4_EVENT_HDR 6
893+#define ST_W4_HEADER 1
894+#define ST_W4_DATA 2
895
896 /* ST LL state machines */
897 #define ST_LL_ASLEEP 0
898--
8991.6.6.1
900
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0015-Bluetooth-btwilink-driver.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0015-Bluetooth-btwilink-driver.patch
new file mode 100644
index 00000000..f45149f3
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0015-Bluetooth-btwilink-driver.patch
@@ -0,0 +1,463 @@
1From e3948bda11a3a0d938500ffbc7ef43603909cc15 Mon Sep 17 00:00:00 2001
2From: Pavan Savoy <pavan_savoy@ti.com>
3Date: Tue, 4 Jan 2011 10:59:48 +0000
4Subject: [PATCH 15/15] Bluetooth: btwilink driver
5
6-- patch description --
7
8This is the bluetooth protocol driver for the TI WiLink7 chipsets.
9Texas Instrument's WiLink chipsets combine wireless technologies
10like BT, FM, GPS and WLAN onto a single chip.
11
12This Bluetooth driver works on top of the TI_ST shared transport
13line discipline driver which also allows other drivers like
14FM V4L2 and GPS character driver to make use of the same UART interface.
15
16Kconfig and Makefile modifications to enable the Bluetooth
17driver for Texas Instrument's WiLink 7 chipset.
18
19Signed-off-by: Pavan Savoy <pavan_savoy@ti.com>
20---
21 drivers/bluetooth/Kconfig | 10 +
22 drivers/bluetooth/Makefile | 1 +
23 drivers/bluetooth/btwilink.c | 397 ++++++++++++++++++++++++++++++++++++++++++
24 3 files changed, 408 insertions(+), 0 deletions(-)
25 create mode 100644 drivers/bluetooth/btwilink.c
26
27diff --git a/drivers/bluetooth/Kconfig b/drivers/bluetooth/Kconfig
28index 02deef4..8e0de9a 100644
29--- a/drivers/bluetooth/Kconfig
30+++ b/drivers/bluetooth/Kconfig
31@@ -219,4 +219,14 @@ config BT_ATH3K
32 Say Y here to compile support for "Atheros firmware download driver"
33 into the kernel or say M to compile it as module (ath3k).
34
35+config BT_WILINK
36+ tristate "Texas Instruments WiLink7 driver"
37+ depends on TI_ST
38+ help
39+ This enables the Bluetooth driver for Texas Instrument's BT/FM/GPS
40+ combo devices. This makes use of shared transport line discipline
41+ core driver to communicate with the BT core of the combo chip.
42+
43+ Say Y here to compile support for Texas Instrument's WiLink7 driver
44+ into the kernel or say M to compile it as module.
45 endmenu
46diff --git a/drivers/bluetooth/Makefile b/drivers/bluetooth/Makefile
47index 71bdf13..f4460f4 100644
48--- a/drivers/bluetooth/Makefile
49+++ b/drivers/bluetooth/Makefile
50@@ -18,6 +18,7 @@ obj-$(CONFIG_BT_HCIBTSDIO) += btsdio.o
51 obj-$(CONFIG_BT_ATH3K) += ath3k.o
52 obj-$(CONFIG_BT_MRVL) += btmrvl.o
53 obj-$(CONFIG_BT_MRVL_SDIO) += btmrvl_sdio.o
54+obj-$(CONFIG_BT_WILINK) += btwilink.o
55
56 btmrvl-y := btmrvl_main.o
57 btmrvl-$(CONFIG_DEBUG_FS) += btmrvl_debugfs.o
58diff --git a/drivers/bluetooth/btwilink.c b/drivers/bluetooth/btwilink.c
59new file mode 100644
60index 0000000..0201aca
61--- /dev/null
62+++ b/drivers/bluetooth/btwilink.c
63@@ -0,0 +1,397 @@
64+/*
65+ * Texas Instrument's Bluetooth Driver For Shared Transport.
66+ *
67+ * Bluetooth Driver acts as interface between HCI core and
68+ * TI Shared Transport Layer.
69+ *
70+ * Copyright (C) 2009-2010 Texas Instruments
71+ * Author: Raja Mani <raja_mani@ti.com>
72+ * Pavan Savoy <pavan_savoy@ti.com>
73+ *
74+ * This program is free software; you can redistribute it and/or modify
75+ * it under the terms of the GNU General Public License version 2 as
76+ * published by the Free Software Foundation.
77+ *
78+ * This program is distributed in the hope that it will be useful,
79+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
80+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
81+ * GNU General Public License for more details.
82+ *
83+ * You should have received a copy of the GNU General Public License
84+ * along with this program; if not, write to the Free Software
85+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
86+ *
87+ */
88+
89+#include <linux/platform_device.h>
90+#include <net/bluetooth/bluetooth.h>
91+#include <net/bluetooth/hci_core.h>
92+
93+#include <linux/ti_wilink_st.h>
94+
95+/* Bluetooth Driver Version */
96+#define VERSION "1.0"
97+
98+/* Number of seconds to wait for registration completion
99+ * when ST returns PENDING status.
100+ */
101+#define BT_REGISTER_TIMEOUT 6000 /* 6 sec */
102+
103+/**
104+ * struct ti_st - driver operation structure
105+ * @hdev: hci device pointer which binds to bt driver
106+ * @reg_status: ST registration callback status
107+ * @st_write: write function provided by the ST driver
108+ * to be used by the driver during send_frame.
109+ * @wait_reg_completion - completion sync between ti_st_open
110+ * and ti_st_registration_completion_cb.
111+ */
112+struct ti_st {
113+ struct hci_dev *hdev;
114+ char reg_status;
115+ long (*st_write) (struct sk_buff *);
116+ struct completion wait_reg_completion;
117+};
118+
119+/* Increments HCI counters based on pocket ID (cmd,acl,sco) */
120+static inline void ti_st_tx_complete(struct ti_st *hst, int pkt_type)
121+{
122+ struct hci_dev *hdev = hst->hdev;
123+
124+ /* Update HCI stat counters */
125+ switch (pkt_type) {
126+ case HCI_COMMAND_PKT:
127+ hdev->stat.cmd_tx++;
128+ break;
129+
130+ case HCI_ACLDATA_PKT:
131+ hdev->stat.acl_tx++;
132+ break;
133+
134+ case HCI_SCODATA_PKT:
135+ hdev->stat.sco_tx++;
136+ break;
137+ }
138+}
139+
140+/* ------- Interfaces to Shared Transport ------ */
141+
142+/* Called by ST layer to indicate protocol registration completion
143+ * status.ti_st_open() function will wait for signal from this
144+ * API when st_register() function returns ST_PENDING.
145+ */
146+static void st_registration_completion_cb(void *priv_data, char data)
147+{
148+ struct ti_st *lhst = priv_data;
149+
150+ /* Save registration status for use in ti_st_open() */
151+ lhst->reg_status = data;
152+ /* complete the wait in ti_st_open() */
153+ complete(&lhst->wait_reg_completion);
154+}
155+
156+/* Called by Shared Transport layer when receive data is
157+ * available */
158+static long st_receive(void *priv_data, struct sk_buff *skb)
159+{
160+ struct ti_st *lhst = priv_data;
161+ int err;
162+
163+ if (!skb)
164+ return -EFAULT;
165+
166+ if (!lhst) {
167+ kfree_skb(skb);
168+ return -EFAULT;
169+ }
170+
171+ skb->dev = (void *) lhst->hdev;
172+
173+ /* Forward skb to HCI core layer */
174+ err = hci_recv_frame(skb);
175+ if (err < 0) {
176+ BT_ERR("Unable to push skb to HCI core(%d)", err);
177+ return err;
178+ }
179+
180+ lhst->hdev->stat.byte_rx += skb->len;
181+
182+ return 0;
183+}
184+
185+/* ------- Interfaces to HCI layer ------ */
186+/* protocol structure registered with shared transport */
187+static struct st_proto_s ti_st_proto[3] = {
188+ {
189+ .chnl_id = 0x02, /* ACL */
190+ .recv = st_receive,
191+ .reg_complete_cb = st_registration_completion_cb,
192+ .hdr_len = 4,
193+ .offset_len_in_hdr = 2,
194+ .len_size = 2,
195+ .reserve = 8,
196+ },
197+ {
198+ .chnl_id = 0x03, /* SCO */
199+ .recv = st_receive,
200+ .reg_complete_cb = st_registration_completion_cb,
201+ .hdr_len = 3,
202+ .offset_len_in_hdr = 2,
203+ .len_size = 1,
204+ .reserve = 8,
205+ },
206+ {
207+ .chnl_id = 0x04, /* HCI Events */
208+ .recv = st_receive,
209+ .reg_complete_cb = st_registration_completion_cb,
210+ .hdr_len = 2,
211+ .offset_len_in_hdr = 1,
212+ .len_size = 1,
213+ .reserve = 8,
214+ },
215+};
216+
217+/* Called from HCI core to initialize the device */
218+static int ti_st_open(struct hci_dev *hdev)
219+{
220+ unsigned long timeleft;
221+ struct ti_st *hst;
222+ int err, i;
223+
224+ BT_DBG("%s %p", hdev->name, hdev);
225+ if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) {
226+ BT_ERR("btwilink already opened");
227+ return -EBUSY;
228+ }
229+
230+ /* provide contexts for callbacks from ST */
231+ hst = hdev->driver_data;
232+
233+ for (i = 0; i < 3; i++) {
234+ ti_st_proto[i].priv_data = hst;
235+ ti_st_proto[i].max_frame_size = HCI_MAX_FRAME_SIZE;
236+
237+ err = st_register(&ti_st_proto[i]);
238+ if (err == -EINPROGRESS) {
239+ /* ST is busy with either protocol
240+ * registration or firmware download.
241+ */
242+ /* Prepare wait-for-completion handler data structures.
243+ */
244+ init_completion(&hst->wait_reg_completion);
245+
246+ /* Reset ST registration callback status flag,
247+ * this value will be updated in
248+ * ti_st_registration_completion_cb()
249+ * function whenever it called from ST driver.
250+ */
251+ hst->reg_status = -EINPROGRESS;
252+
253+ BT_DBG("waiting for registration "
254+ "completion signal from ST");
255+ timeleft = wait_for_completion_timeout
256+ (&hst->wait_reg_completion,
257+ msecs_to_jiffies(BT_REGISTER_TIMEOUT));
258+ if (!timeleft) {
259+ clear_bit(HCI_RUNNING, &hdev->flags);
260+ BT_ERR("Timeout(%d sec),didn't get reg "
261+ "completion signal from ST",
262+ BT_REGISTER_TIMEOUT / 1000);
263+ return -ETIMEDOUT;
264+ }
265+
266+ /* Is ST registration callback
267+ * called with ERROR status? */
268+ if (hst->reg_status != 0) {
269+ clear_bit(HCI_RUNNING, &hdev->flags);
270+ BT_ERR("ST registration completed with invalid "
271+ "status %d", hst->reg_status);
272+ return -EAGAIN;
273+ }
274+ err = 0;
275+ } else if (err != 0) {
276+ clear_bit(HCI_RUNNING, &hdev->flags);
277+ BT_ERR("st_register failed %d", err);
278+ return err;
279+ }
280+ hst->st_write = ti_st_proto[i].write;
281+ if (!hst->st_write) {
282+ BT_ERR("undefined ST write function");
283+ clear_bit(HCI_RUNNING, &hdev->flags);
284+
285+ /* Undo registration with ST */
286+ err = st_unregister(&ti_st_proto[i]);
287+ if (err)
288+ BT_ERR("st_unregister() failed with "
289+ "error %d", err);
290+
291+ hst->st_write = NULL;
292+ /* ti_st_proto.write is filled up by the
293+ * underlying shared transport driver
294+ * upon registration
295+ */
296+ return err;
297+ }
298+ }
299+
300+ return err;
301+}
302+
303+/* Close device */
304+static int ti_st_close(struct hci_dev *hdev)
305+{
306+ int err, i;
307+ struct ti_st *hst = hdev->driver_data;
308+
309+ if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
310+ return 0;
311+
312+ for (i = 0; i < 3; i++) {
313+ /* continue to unregister from transport */
314+ err = st_unregister(&ti_st_proto[i]);
315+ if (err)
316+ BT_ERR("st_unregister() failed with error %d", err);
317+ }
318+
319+ hst->st_write = NULL;
320+
321+ return err;
322+}
323+
324+static int ti_st_send_frame(struct sk_buff *skb)
325+{
326+ struct hci_dev *hdev;
327+ struct ti_st *hst;
328+ long len;
329+
330+ hdev = (struct hci_dev *)skb->dev;
331+
332+ if (!test_bit(HCI_RUNNING, &hdev->flags))
333+ return -EBUSY;
334+
335+ hst = hdev->driver_data;
336+
337+ /* Prepend skb with frame type */
338+ memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
339+
340+ BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type,
341+ skb->len);
342+
343+ /* Insert skb to shared transport layer's transmit queue.
344+ * Freeing skb memory is taken care in shared transport layer,
345+ * so don't free skb memory here.
346+ */
347+ len = hst->st_write(skb);
348+ if (len < 0) {
349+ kfree_skb(skb);
350+ BT_ERR("ST write failed (%ld)", len);
351+ /* Try Again, would only fail if UART has gone bad */
352+ return -EAGAIN;
353+ }
354+
355+ /* ST accepted our skb. So, Go ahead and do rest */
356+ hdev->stat.byte_tx += len;
357+ ti_st_tx_complete(hst, bt_cb(skb)->pkt_type);
358+
359+ return 0;
360+}
361+
362+static void ti_st_destruct(struct hci_dev *hdev)
363+{
364+ BT_DBG("%s", hdev->name);
365+ kfree(hdev->driver_data);
366+}
367+
368+static int bt_ti_probe(struct platform_device *pdev)
369+{
370+ static struct ti_st *hst;
371+ struct hci_dev *hdev;
372+ int err;
373+
374+ hst = kzalloc(sizeof(struct ti_st), GFP_KERNEL);
375+ if (!hst)
376+ return -ENOMEM;
377+
378+ /* Expose "hciX" device to user space */
379+ hdev = hci_alloc_dev();
380+ if (!hdev) {
381+ kfree(hst);
382+ return -ENOMEM;
383+ }
384+
385+ BT_DBG("hdev %p", hdev);
386+
387+ hst->hdev = hdev;
388+ hdev->bus = HCI_UART;
389+ hdev->driver_data = hst;
390+ hdev->open = ti_st_open;
391+ hdev->close = ti_st_close;
392+ hdev->flush = NULL;
393+ hdev->send = ti_st_send_frame;
394+ hdev->destruct = ti_st_destruct;
395+ hdev->owner = THIS_MODULE;
396+
397+ err = hci_register_dev(hdev);
398+ if (err < 0) {
399+ BT_ERR("Can't register HCI device error %d", err);
400+ kfree(hst);
401+ hci_free_dev(hdev);
402+ return err;
403+ }
404+
405+ BT_DBG("HCI device registered (hdev %p)", hdev);
406+
407+ dev_set_drvdata(&pdev->dev, hst);
408+ return err;
409+}
410+
411+static int bt_ti_remove(struct platform_device *pdev)
412+{
413+ struct hci_dev *hdev;
414+ struct ti_st *hst = dev_get_drvdata(&pdev->dev);
415+
416+ if (!hst)
417+ return -EFAULT;
418+
419+ hdev = hst->hdev;
420+ ti_st_close(hdev);
421+ hci_unregister_dev(hdev);
422+
423+ hci_free_dev(hdev);
424+ kfree(hst);
425+
426+ dev_set_drvdata(&pdev->dev, NULL);
427+ return 0;
428+}
429+
430+static struct platform_driver btwilink_driver = {
431+ .probe = bt_ti_probe,
432+ .remove = bt_ti_remove,
433+ .driver = {
434+ .name = "btwilink",
435+ .owner = THIS_MODULE,
436+ },
437+};
438+
439+/* ------- Module Init/Exit interfaces ------ */
440+static int __init btwilink_init(void)
441+{
442+ BT_INFO("Bluetooth Driver for TI WiLink - Version %s", VERSION);
443+
444+ return platform_driver_register(&btwilink_driver);
445+}
446+
447+static void __exit btwilink_exit(void)
448+{
449+ platform_driver_unregister(&btwilink_driver);
450+}
451+
452+module_init(btwilink_init);
453+module_exit(btwilink_exit);
454+
455+/* ------ Module Info ------ */
456+
457+MODULE_AUTHOR("Raja Mani <raja_mani@ti.com>");
458+MODULE_DESCRIPTION("Bluetooth Driver for TI Shared Transport" VERSION);
459+MODULE_VERSION(VERSION);
460+MODULE_LICENSE("GPL");
461--
4621.6.6.1
463
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-06-27 07:56:18 +0000