aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/ath/ath9k/htc_hst.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/ath/ath9k/htc_hst.c')
-rw-r--r--drivers/net/wireless/ath/ath9k/htc_hst.c480
1 files changed, 480 insertions, 0 deletions
diff --git a/drivers/net/wireless/ath/ath9k/htc_hst.c b/drivers/net/wireless/ath/ath9k/htc_hst.c
new file mode 100644
index 000000000000..064397fd738e
--- /dev/null
+++ b/drivers/net/wireless/ath/ath9k/htc_hst.c
@@ -0,0 +1,480 @@
1/*
2 * Copyright (c) 2010 Atheros Communications 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
17#include "htc.h"
18
19static int htc_issue_send(struct htc_target *target, struct sk_buff* skb,
20 u16 len, u8 flags, u8 epid,
21 struct ath9k_htc_tx_ctl *tx_ctl)
22{
23 struct htc_frame_hdr *hdr;
24 struct htc_endpoint *endpoint = &target->endpoint[epid];
25 int status;
26
27 hdr = (struct htc_frame_hdr *)
28 skb_push(skb, sizeof(struct htc_frame_hdr));
29 hdr->endpoint_id = epid;
30 hdr->flags = flags;
31 hdr->payload_len = cpu_to_be16(len);
32
33 status = target->hif->send(target->hif_dev, endpoint->ul_pipeid, skb,
34 tx_ctl);
35 return status;
36}
37
38static struct htc_endpoint *get_next_avail_ep(struct htc_endpoint *endpoint)
39{
40 enum htc_endpoint_id avail_epid;
41
42 for (avail_epid = (ENDPOINT_MAX - 1); avail_epid > ENDPOINT0; avail_epid--)
43 if (endpoint[avail_epid].service_id == 0)
44 return &endpoint[avail_epid];
45 return NULL;
46}
47
48static u8 service_to_ulpipe(u16 service_id)
49{
50 switch (service_id) {
51 case WMI_CONTROL_SVC:
52 return 4;
53 case WMI_BEACON_SVC:
54 case WMI_CAB_SVC:
55 case WMI_UAPSD_SVC:
56 case WMI_MGMT_SVC:
57 case WMI_DATA_VO_SVC:
58 case WMI_DATA_VI_SVC:
59 case WMI_DATA_BE_SVC:
60 case WMI_DATA_BK_SVC:
61 return 1;
62 default:
63 return 0;
64 }
65}
66
67static u8 service_to_dlpipe(u16 service_id)
68{
69 switch (service_id) {
70 case WMI_CONTROL_SVC:
71 return 3;
72 case WMI_BEACON_SVC:
73 case WMI_CAB_SVC:
74 case WMI_UAPSD_SVC:
75 case WMI_MGMT_SVC:
76 case WMI_DATA_VO_SVC:
77 case WMI_DATA_VI_SVC:
78 case WMI_DATA_BE_SVC:
79 case WMI_DATA_BK_SVC:
80 return 2;
81 default:
82 return 0;
83 }
84}
85
86static void htc_process_target_rdy(struct htc_target *target,
87 void *buf)
88{
89 struct htc_endpoint *endpoint;
90 struct htc_ready_msg *htc_ready_msg = (struct htc_ready_msg *) buf;
91
92 target->credits = be16_to_cpu(htc_ready_msg->credits);
93 target->credit_size = be16_to_cpu(htc_ready_msg->credit_size);
94
95 endpoint = &target->endpoint[ENDPOINT0];
96 endpoint->service_id = HTC_CTRL_RSVD_SVC;
97 endpoint->max_msglen = HTC_MAX_CONTROL_MESSAGE_LENGTH;
98 atomic_inc(&target->tgt_ready);
99 complete(&target->target_wait);
100}
101
102static void htc_process_conn_rsp(struct htc_target *target,
103 struct htc_frame_hdr *htc_hdr)
104{
105 struct htc_conn_svc_rspmsg *svc_rspmsg;
106 struct htc_endpoint *endpoint, *tmp_endpoint = NULL;
107 u16 service_id;
108 u16 max_msglen;
109 enum htc_endpoint_id epid, tepid;
110
111 svc_rspmsg = (struct htc_conn_svc_rspmsg *)
112 ((void *) htc_hdr + sizeof(struct htc_frame_hdr));
113
114 if (svc_rspmsg->status == HTC_SERVICE_SUCCESS) {
115 epid = svc_rspmsg->endpoint_id;
116 service_id = be16_to_cpu(svc_rspmsg->service_id);
117 max_msglen = be16_to_cpu(svc_rspmsg->max_msg_len);
118 endpoint = &target->endpoint[epid];
119
120 for (tepid = (ENDPOINT_MAX - 1); tepid > ENDPOINT0; tepid--) {
121 tmp_endpoint = &target->endpoint[tepid];
122 if (tmp_endpoint->service_id == service_id) {
123 tmp_endpoint->service_id = 0;
124 break;
125 }
126 }
127
128 if (tepid == ENDPOINT0)
129 return;
130
131 endpoint->service_id = service_id;
132 endpoint->max_txqdepth = tmp_endpoint->max_txqdepth;
133 endpoint->ep_callbacks = tmp_endpoint->ep_callbacks;
134 endpoint->ul_pipeid = tmp_endpoint->ul_pipeid;
135 endpoint->dl_pipeid = tmp_endpoint->dl_pipeid;
136 endpoint->max_msglen = max_msglen;
137 target->conn_rsp_epid = epid;
138 complete(&target->cmd_wait);
139 } else {
140 target->conn_rsp_epid = ENDPOINT_UNUSED;
141 }
142}
143
144static int htc_config_pipe_credits(struct htc_target *target)
145{
146 struct sk_buff *skb;
147 struct htc_config_pipe_msg *cp_msg;
148 int ret, time_left;
149
150 skb = alloc_skb(50 + sizeof(struct htc_frame_hdr), GFP_ATOMIC);
151 if (!skb) {
152 dev_err(target->dev, "failed to allocate send buffer\n");
153 return -ENOMEM;
154 }
155 skb_reserve(skb, sizeof(struct htc_frame_hdr));
156
157 cp_msg = (struct htc_config_pipe_msg *)
158 skb_put(skb, sizeof(struct htc_config_pipe_msg));
159
160 cp_msg->message_id = cpu_to_be16(HTC_MSG_CONFIG_PIPE_ID);
161 cp_msg->pipe_id = USB_WLAN_TX_PIPE;
162 cp_msg->credits = 28;
163
164 target->htc_flags |= HTC_OP_CONFIG_PIPE_CREDITS;
165
166 ret = htc_issue_send(target, skb, skb->len, 0, ENDPOINT0, NULL);
167 if (ret)
168 goto err;
169
170 time_left = wait_for_completion_timeout(&target->cmd_wait, HZ);
171 if (!time_left) {
172 dev_err(target->dev, "HTC credit config timeout\n");
173 return -ETIMEDOUT;
174 }
175
176 return 0;
177err:
178 kfree_skb(skb);
179 return -EINVAL;
180}
181
182static int htc_setup_complete(struct htc_target *target)
183{
184 struct sk_buff *skb;
185 struct htc_comp_msg *comp_msg;
186 int ret = 0, time_left;
187
188 skb = alloc_skb(50 + sizeof(struct htc_frame_hdr), GFP_ATOMIC);
189 if (!skb) {
190 dev_err(target->dev, "failed to allocate send buffer\n");
191 return -ENOMEM;
192 }
193 skb_reserve(skb, sizeof(struct htc_frame_hdr));
194
195 comp_msg = (struct htc_comp_msg *)
196 skb_put(skb, sizeof(struct htc_comp_msg));
197 comp_msg->msg_id = cpu_to_be16(HTC_MSG_SETUP_COMPLETE_ID);
198
199 target->htc_flags |= HTC_OP_START_WAIT;
200
201 ret = htc_issue_send(target, skb, skb->len, 0, ENDPOINT0, NULL);
202 if (ret)
203 goto err;
204
205 time_left = wait_for_completion_timeout(&target->cmd_wait, HZ);
206 if (!time_left) {
207 dev_err(target->dev, "HTC start timeout\n");
208 return -ETIMEDOUT;
209 }
210
211 return 0;
212
213err:
214 kfree_skb(skb);
215 return -EINVAL;
216}
217
218/* HTC APIs */
219
220int htc_init(struct htc_target *target)
221{
222 int ret;
223
224 ret = htc_config_pipe_credits(target);
225 if (ret)
226 return ret;
227
228 return htc_setup_complete(target);
229}
230
231int htc_connect_service(struct htc_target *target,
232 struct htc_service_connreq *service_connreq,
233 enum htc_endpoint_id *conn_rsp_epid)
234{
235 struct sk_buff *skb;
236 struct htc_endpoint *endpoint;
237 struct htc_conn_svc_msg *conn_msg;
238 int ret, time_left;
239
240 /* Find an available endpoint */
241 endpoint = get_next_avail_ep(target->endpoint);
242 if (!endpoint) {
243 dev_err(target->dev, "Endpoint is not available for"
244 "service %d\n", service_connreq->service_id);
245 return -EINVAL;
246 }
247
248 endpoint->service_id = service_connreq->service_id;
249 endpoint->max_txqdepth = service_connreq->max_send_qdepth;
250 endpoint->ul_pipeid = service_to_ulpipe(service_connreq->service_id);
251 endpoint->dl_pipeid = service_to_dlpipe(service_connreq->service_id);
252 endpoint->ep_callbacks = service_connreq->ep_callbacks;
253
254 skb = alloc_skb(sizeof(struct htc_conn_svc_msg) +
255 sizeof(struct htc_frame_hdr), GFP_ATOMIC);
256 if (!skb) {
257 dev_err(target->dev, "Failed to allocate buf to send"
258 "service connect req\n");
259 return -ENOMEM;
260 }
261
262 skb_reserve(skb, sizeof(struct htc_frame_hdr));
263
264 conn_msg = (struct htc_conn_svc_msg *)
265 skb_put(skb, sizeof(struct htc_conn_svc_msg));
266 conn_msg->service_id = cpu_to_be16(service_connreq->service_id);
267 conn_msg->msg_id = cpu_to_be16(HTC_MSG_CONNECT_SERVICE_ID);
268 conn_msg->con_flags = cpu_to_be16(service_connreq->con_flags);
269 conn_msg->dl_pipeid = endpoint->dl_pipeid;
270 conn_msg->ul_pipeid = endpoint->ul_pipeid;
271
272 ret = htc_issue_send(target, skb, skb->len, 0, ENDPOINT0, NULL);
273 if (ret)
274 goto err;
275
276 time_left = wait_for_completion_timeout(&target->cmd_wait, HZ);
277 if (!time_left) {
278 dev_err(target->dev, "Service connection timeout for: %d\n",
279 service_connreq->service_id);
280 return -ETIMEDOUT;
281 }
282
283 *conn_rsp_epid = target->conn_rsp_epid;
284 return 0;
285err:
286 kfree_skb(skb);
287 return ret;
288}
289
290int htc_send(struct htc_target *target, struct sk_buff *skb,
291 enum htc_endpoint_id epid, struct ath9k_htc_tx_ctl *tx_ctl)
292{
293 return htc_issue_send(target, skb, skb->len, 0, epid, tx_ctl);
294}
295
296void htc_stop(struct htc_target *target)
297{
298 enum htc_endpoint_id epid;
299 struct htc_endpoint *endpoint;
300
301 for (epid = ENDPOINT0; epid < ENDPOINT_MAX; epid++) {
302 endpoint = &target->endpoint[epid];
303 if (endpoint->service_id != 0)
304 target->hif->stop(target->hif_dev, endpoint->ul_pipeid);
305 }
306}
307
308void htc_start(struct htc_target *target)
309{
310 enum htc_endpoint_id epid;
311 struct htc_endpoint *endpoint;
312
313 for (epid = ENDPOINT0; epid < ENDPOINT_MAX; epid++) {
314 endpoint = &target->endpoint[epid];
315 if (endpoint->service_id != 0)
316 target->hif->start(target->hif_dev,
317 endpoint->ul_pipeid);
318 }
319}
320
321void ath9k_htc_txcompletion_cb(struct htc_target *htc_handle,
322 struct sk_buff *skb, bool txok)
323{
324 struct htc_endpoint *endpoint;
325 struct htc_frame_hdr *htc_hdr = NULL;
326
327 if (htc_handle->htc_flags & HTC_OP_CONFIG_PIPE_CREDITS) {
328 complete(&htc_handle->cmd_wait);
329 htc_handle->htc_flags &= ~HTC_OP_CONFIG_PIPE_CREDITS;
330 goto ret;
331 }
332
333 if (htc_handle->htc_flags & HTC_OP_START_WAIT) {
334 complete(&htc_handle->cmd_wait);
335 htc_handle->htc_flags &= ~HTC_OP_START_WAIT;
336 goto ret;
337 }
338
339 if (skb) {
340 htc_hdr = (struct htc_frame_hdr *) skb->data;
341 endpoint = &htc_handle->endpoint[htc_hdr->endpoint_id];
342 skb_pull(skb, sizeof(struct htc_frame_hdr));
343
344 if (endpoint->ep_callbacks.tx) {
345 endpoint->ep_callbacks.tx(endpoint->ep_callbacks.priv,
346 skb, htc_hdr->endpoint_id,
347 txok);
348 }
349 }
350
351 return;
352ret:
353 /* HTC-generated packets are freed here. */
354 if (htc_hdr && htc_hdr->endpoint_id != ENDPOINT0)
355 dev_kfree_skb_any(skb);
356 else
357 kfree_skb(skb);
358}
359
360/*
361 * HTC Messages are handled directly here and the obtained SKB
362 * is freed.
363 *
364 * Sevice messages (Data, WMI) passed to the corresponding
365 * endpoint RX handlers, which have to free the SKB.
366 */
367void ath9k_htc_rx_msg(struct htc_target *htc_handle,
368 struct sk_buff *skb, u32 len, u8 pipe_id)
369{
370 struct htc_frame_hdr *htc_hdr;
371 enum htc_endpoint_id epid;
372 struct htc_endpoint *endpoint;
373 __be16 *msg_id;
374
375 if (!htc_handle || !skb)
376 return;
377
378 htc_hdr = (struct htc_frame_hdr *) skb->data;
379 epid = htc_hdr->endpoint_id;
380
381 if (epid >= ENDPOINT_MAX) {
382 if (pipe_id != USB_REG_IN_PIPE)
383 dev_kfree_skb_any(skb);
384 else
385 kfree_skb(skb);
386 return;
387 }
388
389 if (epid == ENDPOINT0) {
390
391 /* Handle trailer */
392 if (htc_hdr->flags & HTC_FLAGS_RECV_TRAILER) {
393 if (be32_to_cpu(*(__be32 *) skb->data) == 0x00C60000)
394 /* Move past the Watchdog pattern */
395 htc_hdr = (struct htc_frame_hdr *)(skb->data + 4);
396 }
397
398 /* Get the message ID */
399 msg_id = (__be16 *) ((void *) htc_hdr +
400 sizeof(struct htc_frame_hdr));
401
402 /* Now process HTC messages */
403 switch (be16_to_cpu(*msg_id)) {
404 case HTC_MSG_READY_ID:
405 htc_process_target_rdy(htc_handle, htc_hdr);
406 break;
407 case HTC_MSG_CONNECT_SERVICE_RESPONSE_ID:
408 htc_process_conn_rsp(htc_handle, htc_hdr);
409 break;
410 default:
411 break;
412 }
413
414 kfree_skb(skb);
415
416 } else {
417 if (htc_hdr->flags & HTC_FLAGS_RECV_TRAILER)
418 skb_trim(skb, len - htc_hdr->control[0]);
419
420 skb_pull(skb, sizeof(struct htc_frame_hdr));
421
422 endpoint = &htc_handle->endpoint[epid];
423 if (endpoint->ep_callbacks.rx)
424 endpoint->ep_callbacks.rx(endpoint->ep_callbacks.priv,
425 skb, epid);
426 }
427}
428
429struct htc_target *ath9k_htc_hw_alloc(void *hif_handle,
430 struct ath9k_htc_hif *hif,
431 struct device *dev)
432{
433 struct htc_endpoint *endpoint;
434 struct htc_target *target;
435
436 target = kzalloc(sizeof(struct htc_target), GFP_KERNEL);
437 if (!target) {
438 printk(KERN_ERR "Unable to allocate memory for"
439 "target device\n");
440 return NULL;
441 }
442
443 init_completion(&target->target_wait);
444 init_completion(&target->cmd_wait);
445
446 target->hif = hif;
447 target->hif_dev = hif_handle;
448 target->dev = dev;
449
450 /* Assign control endpoint pipe IDs */
451 endpoint = &target->endpoint[ENDPOINT0];
452 endpoint->ul_pipeid = hif->control_ul_pipe;
453 endpoint->dl_pipeid = hif->control_dl_pipe;
454
455 atomic_set(&target->tgt_ready, 0);
456
457 return target;
458}
459
460void ath9k_htc_hw_free(struct htc_target *htc)
461{
462 kfree(htc);
463}
464
465int ath9k_htc_hw_init(struct htc_target *target,
466 struct device *dev, u16 devid)
467{
468 if (ath9k_htc_probe_device(target, dev, devid)) {
469 printk(KERN_ERR "Failed to initialize the device\n");
470 return -ENODEV;
471 }
472
473 return 0;
474}
475
476void ath9k_htc_hw_deinit(struct htc_target *target, bool hot_unplug)
477{
478 if (target)
479 ath9k_htc_disconnect_device(target, hot_unplug);
480}
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-20 20:50:21 -0400