Commit | Line | Data |
---|---|---|
dad0d04f FF |
1 | /** |
2 | * Copyright (c) 2014 Redpine Signals Inc. | |
3 | * | |
4 | * Permission to use, copy, modify, and/or distribute this software for any | |
5 | * purpose with or without fee is hereby granted, provided that the above | |
6 | * copyright notice and this permission notice appear in all copies. | |
7 | * | |
8 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
9 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
10 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
11 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
12 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
13 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
14 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
15 | */ | |
16 | ||
5fe1b76a JP |
17 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
18 | ||
dad0d04f FF |
19 | #include <linux/module.h> |
20 | #include <linux/firmware.h> | |
21 | #include "rsi_mgmt.h" | |
22 | #include "rsi_common.h" | |
23 | ||
24 | u32 rsi_zone_enabled = /* INFO_ZONE | | |
25 | INIT_ZONE | | |
26 | MGMT_TX_ZONE | | |
27 | MGMT_RX_ZONE | | |
28 | DATA_TX_ZONE | | |
29 | DATA_RX_ZONE | | |
30 | FSM_ZONE | | |
31 | ISR_ZONE | */ | |
32 | ERR_ZONE | | |
33 | 0; | |
34 | EXPORT_SYMBOL_GPL(rsi_zone_enabled); | |
35 | ||
2df3b0b7 JL |
36 | /** |
37 | * rsi_dbg() - This function outputs informational messages. | |
38 | * @zone: Zone of interest for output message. | |
39 | * @fmt: printf-style format for output message. | |
40 | * | |
41 | * Return: none | |
42 | */ | |
43 | void rsi_dbg(u32 zone, const char *fmt, ...) | |
44 | { | |
45 | struct va_format vaf; | |
46 | va_list args; | |
47 | ||
48 | va_start(args, fmt); | |
49 | ||
50 | vaf.fmt = fmt; | |
51 | vaf.va = &args; | |
52 | ||
53 | if (zone & rsi_zone_enabled) | |
54 | pr_info("%pV", &vaf); | |
55 | va_end(args); | |
56 | } | |
57 | EXPORT_SYMBOL_GPL(rsi_dbg); | |
58 | ||
dad0d04f FF |
59 | /** |
60 | * rsi_prepare_skb() - This function prepares the skb. | |
61 | * @common: Pointer to the driver private structure. | |
62 | * @buffer: Pointer to the packet data. | |
63 | * @pkt_len: Length of the packet. | |
64 | * @extended_desc: Extended descriptor. | |
65 | * | |
66 | * Return: Successfully skb. | |
67 | */ | |
68 | static struct sk_buff *rsi_prepare_skb(struct rsi_common *common, | |
69 | u8 *buffer, | |
70 | u32 pkt_len, | |
71 | u8 extended_desc) | |
72 | { | |
73 | struct ieee80211_tx_info *info; | |
74 | struct skb_info *rx_params; | |
75 | struct sk_buff *skb = NULL; | |
76 | u8 payload_offset; | |
77 | ||
78 | if (WARN(!pkt_len, "%s: Dummy pkt received", __func__)) | |
79 | return NULL; | |
80 | ||
81 | if (pkt_len > (RSI_RCV_BUFFER_LEN * 4)) { | |
82 | rsi_dbg(ERR_ZONE, "%s: Pkt size > max rx buf size %d\n", | |
83 | __func__, pkt_len); | |
84 | pkt_len = RSI_RCV_BUFFER_LEN * 4; | |
85 | } | |
86 | ||
87 | pkt_len -= extended_desc; | |
88 | skb = dev_alloc_skb(pkt_len + FRAME_DESC_SZ); | |
89 | if (skb == NULL) | |
90 | return NULL; | |
91 | ||
92 | payload_offset = (extended_desc + FRAME_DESC_SZ); | |
93 | skb_put(skb, pkt_len); | |
94 | memcpy((skb->data), (buffer + payload_offset), skb->len); | |
95 | ||
96 | info = IEEE80211_SKB_CB(skb); | |
97 | rx_params = (struct skb_info *)info->driver_data; | |
98 | rx_params->rssi = rsi_get_rssi(buffer); | |
99 | rx_params->channel = rsi_get_connected_channel(common->priv); | |
100 | ||
101 | return skb; | |
102 | } | |
103 | ||
104 | /** | |
105 | * rsi_read_pkt() - This function reads frames from the card. | |
106 | * @common: Pointer to the driver private structure. | |
107 | * @rcv_pkt_len: Received pkt length. In case of USB it is 0. | |
108 | * | |
109 | * Return: 0 on success, -1 on failure. | |
110 | */ | |
111 | int rsi_read_pkt(struct rsi_common *common, s32 rcv_pkt_len) | |
112 | { | |
113 | u8 *frame_desc = NULL, extended_desc = 0; | |
114 | u32 index, length = 0, queueno = 0; | |
115 | u16 actual_length = 0, offset; | |
116 | struct sk_buff *skb = NULL; | |
117 | ||
118 | index = 0; | |
119 | do { | |
120 | frame_desc = &common->rx_data_pkt[index]; | |
121 | actual_length = *(u16 *)&frame_desc[0]; | |
122 | offset = *(u16 *)&frame_desc[2]; | |
123 | ||
124 | queueno = rsi_get_queueno(frame_desc, offset); | |
125 | length = rsi_get_length(frame_desc, offset); | |
126 | extended_desc = rsi_get_extended_desc(frame_desc, offset); | |
127 | ||
128 | switch (queueno) { | |
129 | case RSI_WIFI_DATA_Q: | |
130 | skb = rsi_prepare_skb(common, | |
131 | (frame_desc + offset), | |
132 | length, | |
133 | extended_desc); | |
134 | if (skb == NULL) | |
135 | goto fail; | |
136 | ||
137 | rsi_indicate_pkt_to_os(common, skb); | |
138 | break; | |
139 | ||
140 | case RSI_WIFI_MGMT_Q: | |
141 | rsi_mgmt_pkt_recv(common, (frame_desc + offset)); | |
142 | break; | |
143 | ||
144 | default: | |
145 | rsi_dbg(ERR_ZONE, "%s: pkt from invalid queue: %d\n", | |
146 | __func__, queueno); | |
147 | goto fail; | |
148 | } | |
149 | ||
150 | index += actual_length; | |
151 | rcv_pkt_len -= actual_length; | |
152 | } while (rcv_pkt_len > 0); | |
153 | ||
154 | return 0; | |
155 | fail: | |
156 | return -EINVAL; | |
157 | } | |
158 | EXPORT_SYMBOL_GPL(rsi_read_pkt); | |
159 | ||
160 | /** | |
161 | * rsi_tx_scheduler_thread() - This function is a kernel thread to send the | |
162 | * packets to the device. | |
163 | * @common: Pointer to the driver private structure. | |
164 | * | |
165 | * Return: None. | |
166 | */ | |
167 | static void rsi_tx_scheduler_thread(struct rsi_common *common) | |
168 | { | |
169 | struct rsi_hw *adapter = common->priv; | |
170 | u32 timeout = EVENT_WAIT_FOREVER; | |
171 | ||
172 | do { | |
173 | if (adapter->determine_event_timeout) | |
174 | timeout = adapter->determine_event_timeout(adapter); | |
175 | rsi_wait_event(&common->tx_thread.event, timeout); | |
176 | rsi_reset_event(&common->tx_thread.event); | |
177 | ||
178 | if (common->init_done) | |
179 | rsi_core_qos_processor(common); | |
180 | } while (atomic_read(&common->tx_thread.thread_done) == 0); | |
181 | complete_and_exit(&common->tx_thread.completion, 0); | |
182 | } | |
183 | ||
184 | /** | |
185 | * rsi_91x_init() - This function initializes os interface operations. | |
186 | * @void: Void. | |
187 | * | |
188 | * Return: Pointer to the adapter structure on success, NULL on failure . | |
189 | */ | |
190 | struct rsi_hw *rsi_91x_init(void) | |
191 | { | |
192 | struct rsi_hw *adapter = NULL; | |
193 | struct rsi_common *common = NULL; | |
194 | u8 ii = 0; | |
195 | ||
196 | adapter = kzalloc(sizeof(*adapter), GFP_KERNEL); | |
197 | if (!adapter) | |
198 | return NULL; | |
199 | ||
200 | adapter->priv = kzalloc(sizeof(*common), GFP_KERNEL); | |
201 | if (adapter->priv == NULL) { | |
202 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of memory\n", | |
203 | __func__); | |
204 | kfree(adapter); | |
205 | return NULL; | |
206 | } else { | |
207 | common = adapter->priv; | |
208 | common->priv = adapter; | |
209 | } | |
210 | ||
211 | for (ii = 0; ii < NUM_SOFT_QUEUES; ii++) | |
212 | skb_queue_head_init(&common->tx_queue[ii]); | |
213 | ||
214 | rsi_init_event(&common->tx_thread.event); | |
215 | mutex_init(&common->mutex); | |
216 | mutex_init(&common->tx_rxlock); | |
217 | ||
218 | if (rsi_create_kthread(common, | |
219 | &common->tx_thread, | |
220 | rsi_tx_scheduler_thread, | |
221 | "Tx-Thread")) { | |
222 | rsi_dbg(ERR_ZONE, "%s: Unable to init tx thrd\n", __func__); | |
223 | goto err; | |
224 | } | |
225 | ||
226 | common->init_done = true; | |
227 | return adapter; | |
228 | ||
229 | err: | |
230 | kfree(common); | |
231 | kfree(adapter); | |
232 | return NULL; | |
233 | } | |
234 | EXPORT_SYMBOL_GPL(rsi_91x_init); | |
235 | ||
236 | /** | |
237 | * rsi_91x_deinit() - This function de-intializes os intf operations. | |
238 | * @adapter: Pointer to the adapter structure. | |
239 | * | |
240 | * Return: None. | |
241 | */ | |
242 | void rsi_91x_deinit(struct rsi_hw *adapter) | |
243 | { | |
244 | struct rsi_common *common = adapter->priv; | |
245 | u8 ii; | |
246 | ||
247 | rsi_dbg(INFO_ZONE, "%s: Performing deinit os ops\n", __func__); | |
248 | ||
249 | rsi_kill_thread(&common->tx_thread); | |
250 | ||
251 | for (ii = 0; ii < NUM_SOFT_QUEUES; ii++) | |
252 | skb_queue_purge(&common->tx_queue[ii]); | |
253 | ||
254 | common->init_done = false; | |
255 | ||
256 | kfree(common); | |
257 | kfree(adapter->rsi_dev); | |
258 | kfree(adapter); | |
259 | } | |
260 | EXPORT_SYMBOL_GPL(rsi_91x_deinit); | |
261 | ||
262 | /** | |
263 | * rsi_91x_hal_module_init() - This function is invoked when the module is | |
264 | * loaded into the kernel. | |
265 | * It registers the client driver. | |
266 | * @void: Void. | |
267 | * | |
268 | * Return: 0 on success, -1 on failure. | |
269 | */ | |
270 | static int rsi_91x_hal_module_init(void) | |
271 | { | |
272 | rsi_dbg(INIT_ZONE, "%s: Module init called\n", __func__); | |
273 | return 0; | |
274 | } | |
275 | ||
276 | /** | |
277 | * rsi_91x_hal_module_exit() - This function is called at the time of | |
278 | * removing/unloading the module. | |
279 | * It unregisters the client driver. | |
280 | * @void: Void. | |
281 | * | |
282 | * Return: None. | |
283 | */ | |
284 | static void rsi_91x_hal_module_exit(void) | |
285 | { | |
286 | rsi_dbg(INIT_ZONE, "%s: Module exit called\n", __func__); | |
287 | } | |
288 | ||
289 | module_init(rsi_91x_hal_module_init); | |
290 | module_exit(rsi_91x_hal_module_exit); | |
291 | MODULE_AUTHOR("Redpine Signals Inc"); | |
292 | MODULE_DESCRIPTION("Station driver for RSI 91x devices"); | |
293 | MODULE_SUPPORTED_DEVICE("RSI-91x"); | |
294 | MODULE_VERSION("0.1"); | |
295 | MODULE_LICENSE("Dual BSD/GPL"); |