forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1725 lines
43 KiB
1725 lines
43 KiB
/* |
|
* Copyright (c) 2007-2011 Atheros Communications Inc. |
|
* |
|
* Permission to use, copy, modify, and/or distribute this software for any |
|
* purpose with or without fee is hereby granted, provided that the above |
|
* copyright notice and this permission notice appear in all copies. |
|
* |
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
*/ |
|
|
|
#include "core.h" |
|
#include "debug.h" |
|
#include "hif-ops.h" |
|
|
|
#define HTC_PACKET_CONTAINER_ALLOCATION 32 |
|
#define HTC_CONTROL_BUFFER_SIZE (HTC_MAX_CTRL_MSG_LEN + HTC_HDR_LENGTH) |
|
|
|
static int ath6kl_htc_pipe_tx(struct htc_target *handle, |
|
struct htc_packet *packet); |
|
static void ath6kl_htc_pipe_cleanup(struct htc_target *handle); |
|
|
|
/* htc pipe tx path */ |
|
static inline void restore_tx_packet(struct htc_packet *packet) |
|
{ |
|
if (packet->info.tx.flags & HTC_FLAGS_TX_FIXUP_NETBUF) { |
|
skb_pull(packet->skb, sizeof(struct htc_frame_hdr)); |
|
packet->info.tx.flags &= ~HTC_FLAGS_TX_FIXUP_NETBUF; |
|
} |
|
} |
|
|
|
static void do_send_completion(struct htc_endpoint *ep, |
|
struct list_head *queue_to_indicate) |
|
{ |
|
struct htc_packet *packet; |
|
|
|
if (list_empty(queue_to_indicate)) { |
|
/* nothing to indicate */ |
|
return; |
|
} |
|
|
|
if (ep->ep_cb.tx_comp_multi != NULL) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: calling ep %d, send complete multiple callback (%d pkts)\n", |
|
__func__, ep->eid, |
|
get_queue_depth(queue_to_indicate)); |
|
/* |
|
* a multiple send complete handler is being used, |
|
* pass the queue to the handler |
|
*/ |
|
ep->ep_cb.tx_comp_multi(ep->target, queue_to_indicate); |
|
/* |
|
* all packets are now owned by the callback, |
|
* reset queue to be safe |
|
*/ |
|
INIT_LIST_HEAD(queue_to_indicate); |
|
} else { |
|
/* using legacy EpTxComplete */ |
|
do { |
|
packet = list_first_entry(queue_to_indicate, |
|
struct htc_packet, list); |
|
|
|
list_del(&packet->list); |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: calling ep %d send complete callback on packet 0x%p\n", |
|
__func__, ep->eid, packet); |
|
ep->ep_cb.tx_complete(ep->target, packet); |
|
} while (!list_empty(queue_to_indicate)); |
|
} |
|
} |
|
|
|
static void send_packet_completion(struct htc_target *target, |
|
struct htc_packet *packet) |
|
{ |
|
struct htc_endpoint *ep = &target->endpoint[packet->endpoint]; |
|
struct list_head container; |
|
|
|
restore_tx_packet(packet); |
|
INIT_LIST_HEAD(&container); |
|
list_add_tail(&packet->list, &container); |
|
|
|
/* do completion */ |
|
do_send_completion(ep, &container); |
|
} |
|
|
|
static void get_htc_packet_credit_based(struct htc_target *target, |
|
struct htc_endpoint *ep, |
|
struct list_head *queue) |
|
{ |
|
int credits_required; |
|
int remainder; |
|
u8 send_flags; |
|
struct htc_packet *packet; |
|
unsigned int transfer_len; |
|
|
|
/* NOTE : the TX lock is held when this function is called */ |
|
|
|
/* loop until we can grab as many packets out of the queue as we can */ |
|
while (true) { |
|
send_flags = 0; |
|
if (list_empty(&ep->txq)) |
|
break; |
|
|
|
/* get packet at head, but don't remove it */ |
|
packet = list_first_entry(&ep->txq, struct htc_packet, list); |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: got head packet:0x%p , queue depth: %d\n", |
|
__func__, packet, get_queue_depth(&ep->txq)); |
|
|
|
transfer_len = packet->act_len + HTC_HDR_LENGTH; |
|
|
|
if (transfer_len <= target->tgt_cred_sz) { |
|
credits_required = 1; |
|
} else { |
|
/* figure out how many credits this message requires */ |
|
credits_required = transfer_len / target->tgt_cred_sz; |
|
remainder = transfer_len % target->tgt_cred_sz; |
|
|
|
if (remainder) |
|
credits_required++; |
|
} |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, "%s: creds required:%d got:%d\n", |
|
__func__, credits_required, ep->cred_dist.credits); |
|
|
|
if (ep->eid == ENDPOINT_0) { |
|
/* |
|
* endpoint 0 is special, it always has a credit and |
|
* does not require credit based flow control |
|
*/ |
|
credits_required = 0; |
|
|
|
} else { |
|
if (ep->cred_dist.credits < credits_required) |
|
break; |
|
|
|
ep->cred_dist.credits -= credits_required; |
|
ep->ep_st.cred_cosumd += credits_required; |
|
|
|
/* check if we need credits back from the target */ |
|
if (ep->cred_dist.credits < |
|
ep->cred_dist.cred_per_msg) { |
|
/* tell the target we need credits ASAP! */ |
|
send_flags |= HTC_FLAGS_NEED_CREDIT_UPDATE; |
|
ep->ep_st.cred_low_indicate += 1; |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: host needs credits\n", |
|
__func__); |
|
} |
|
} |
|
|
|
/* now we can fully dequeue */ |
|
packet = list_first_entry(&ep->txq, struct htc_packet, list); |
|
|
|
list_del(&packet->list); |
|
/* save the number of credits this packet consumed */ |
|
packet->info.tx.cred_used = credits_required; |
|
/* save send flags */ |
|
packet->info.tx.flags = send_flags; |
|
packet->info.tx.seqno = ep->seqno; |
|
ep->seqno++; |
|
/* queue this packet into the caller's queue */ |
|
list_add_tail(&packet->list, queue); |
|
} |
|
} |
|
|
|
static void get_htc_packet(struct htc_target *target, |
|
struct htc_endpoint *ep, |
|
struct list_head *queue, int resources) |
|
{ |
|
struct htc_packet *packet; |
|
|
|
/* NOTE : the TX lock is held when this function is called */ |
|
|
|
/* loop until we can grab as many packets out of the queue as we can */ |
|
while (resources) { |
|
if (list_empty(&ep->txq)) |
|
break; |
|
|
|
packet = list_first_entry(&ep->txq, struct htc_packet, list); |
|
list_del(&packet->list); |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: got packet:0x%p , new queue depth: %d\n", |
|
__func__, packet, get_queue_depth(&ep->txq)); |
|
packet->info.tx.seqno = ep->seqno; |
|
packet->info.tx.flags = 0; |
|
packet->info.tx.cred_used = 0; |
|
ep->seqno++; |
|
|
|
/* queue this packet into the caller's queue */ |
|
list_add_tail(&packet->list, queue); |
|
resources--; |
|
} |
|
} |
|
|
|
static int htc_issue_packets(struct htc_target *target, |
|
struct htc_endpoint *ep, |
|
struct list_head *pkt_queue) |
|
{ |
|
int status = 0; |
|
u16 payload_len; |
|
struct sk_buff *skb; |
|
struct htc_frame_hdr *htc_hdr; |
|
struct htc_packet *packet; |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: queue: 0x%p, pkts %d\n", __func__, |
|
pkt_queue, get_queue_depth(pkt_queue)); |
|
|
|
while (!list_empty(pkt_queue)) { |
|
packet = list_first_entry(pkt_queue, struct htc_packet, list); |
|
list_del(&packet->list); |
|
|
|
skb = packet->skb; |
|
if (!skb) { |
|
WARN_ON_ONCE(1); |
|
status = -EINVAL; |
|
break; |
|
} |
|
|
|
payload_len = packet->act_len; |
|
|
|
/* setup HTC frame header */ |
|
htc_hdr = skb_push(skb, sizeof(*htc_hdr)); |
|
if (!htc_hdr) { |
|
WARN_ON_ONCE(1); |
|
status = -EINVAL; |
|
break; |
|
} |
|
|
|
packet->info.tx.flags |= HTC_FLAGS_TX_FIXUP_NETBUF; |
|
|
|
/* Endianess? */ |
|
put_unaligned((u16) payload_len, &htc_hdr->payld_len); |
|
htc_hdr->flags = packet->info.tx.flags; |
|
htc_hdr->eid = (u8) packet->endpoint; |
|
htc_hdr->ctrl[0] = 0; |
|
htc_hdr->ctrl[1] = (u8) packet->info.tx.seqno; |
|
|
|
spin_lock_bh(&target->tx_lock); |
|
|
|
/* store in look up queue to match completions */ |
|
list_add_tail(&packet->list, &ep->pipe.tx_lookup_queue); |
|
ep->ep_st.tx_issued += 1; |
|
spin_unlock_bh(&target->tx_lock); |
|
|
|
status = ath6kl_hif_pipe_send(target->dev->ar, |
|
ep->pipe.pipeid_ul, NULL, skb); |
|
|
|
if (status != 0) { |
|
if (status != -ENOMEM) { |
|
/* TODO: if more than 1 endpoint maps to the |
|
* same PipeID, it is possible to run out of |
|
* resources in the HIF layer. |
|
* Don't emit the error |
|
*/ |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: failed status:%d\n", |
|
__func__, status); |
|
} |
|
spin_lock_bh(&target->tx_lock); |
|
list_del(&packet->list); |
|
|
|
/* reclaim credits */ |
|
ep->cred_dist.credits += packet->info.tx.cred_used; |
|
spin_unlock_bh(&target->tx_lock); |
|
|
|
/* put it back into the callers queue */ |
|
list_add(&packet->list, pkt_queue); |
|
break; |
|
} |
|
} |
|
|
|
if (status != 0) { |
|
while (!list_empty(pkt_queue)) { |
|
if (status != -ENOMEM) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: failed pkt:0x%p status:%d\n", |
|
__func__, packet, status); |
|
} |
|
|
|
packet = list_first_entry(pkt_queue, |
|
struct htc_packet, list); |
|
list_del(&packet->list); |
|
packet->status = status; |
|
send_packet_completion(target, packet); |
|
} |
|
} |
|
|
|
return status; |
|
} |
|
|
|
static enum htc_send_queue_result htc_try_send(struct htc_target *target, |
|
struct htc_endpoint *ep, |
|
struct list_head *txq) |
|
{ |
|
struct list_head send_queue; /* temp queue to hold packets */ |
|
struct htc_packet *packet, *tmp_pkt; |
|
struct ath6kl *ar = target->dev->ar; |
|
enum htc_send_full_action action; |
|
int tx_resources, overflow, txqueue_depth, i, good_pkts; |
|
u8 pipeid; |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, "%s: (queue:0x%p depth:%d)\n", |
|
__func__, txq, |
|
(txq == NULL) ? 0 : get_queue_depth(txq)); |
|
|
|
/* init the local send queue */ |
|
INIT_LIST_HEAD(&send_queue); |
|
|
|
/* |
|
* txq equals to NULL means |
|
* caller didn't provide a queue, just wants us to |
|
* check queues and send |
|
*/ |
|
if (txq != NULL) { |
|
if (list_empty(txq)) { |
|
/* empty queue */ |
|
return HTC_SEND_QUEUE_DROP; |
|
} |
|
|
|
spin_lock_bh(&target->tx_lock); |
|
txqueue_depth = get_queue_depth(&ep->txq); |
|
spin_unlock_bh(&target->tx_lock); |
|
|
|
if (txqueue_depth >= ep->max_txq_depth) { |
|
/* we've already overflowed */ |
|
overflow = get_queue_depth(txq); |
|
} else { |
|
/* get how much we will overflow by */ |
|
overflow = txqueue_depth; |
|
overflow += get_queue_depth(txq); |
|
/* get how much we will overflow the TX queue by */ |
|
overflow -= ep->max_txq_depth; |
|
} |
|
|
|
/* if overflow is negative or zero, we are okay */ |
|
if (overflow > 0) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: Endpoint %d, TX queue will overflow :%d, Tx Depth:%d, Max:%d\n", |
|
__func__, ep->eid, overflow, txqueue_depth, |
|
ep->max_txq_depth); |
|
} |
|
if ((overflow <= 0) || |
|
(ep->ep_cb.tx_full == NULL)) { |
|
/* |
|
* all packets will fit or caller did not provide send |
|
* full indication handler -- just move all of them |
|
* to the local send_queue object |
|
*/ |
|
list_splice_tail_init(txq, &send_queue); |
|
} else { |
|
good_pkts = get_queue_depth(txq) - overflow; |
|
if (good_pkts < 0) { |
|
WARN_ON_ONCE(1); |
|
return HTC_SEND_QUEUE_DROP; |
|
} |
|
|
|
/* we have overflowed, and a callback is provided */ |
|
/* dequeue all non-overflow packets to the sendqueue */ |
|
for (i = 0; i < good_pkts; i++) { |
|
/* pop off caller's queue */ |
|
packet = list_first_entry(txq, |
|
struct htc_packet, |
|
list); |
|
/* move to local queue */ |
|
list_move_tail(&packet->list, &send_queue); |
|
} |
|
|
|
/* |
|
* the caller's queue has all the packets that won't fit |
|
* walk through the caller's queue and indicate each to |
|
* the send full handler |
|
*/ |
|
list_for_each_entry_safe(packet, tmp_pkt, |
|
txq, list) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: Indicate overflowed TX pkts: %p\n", |
|
__func__, packet); |
|
action = ep->ep_cb.tx_full(ep->target, packet); |
|
if (action == HTC_SEND_FULL_DROP) { |
|
/* callback wants the packet dropped */ |
|
ep->ep_st.tx_dropped += 1; |
|
|
|
/* leave this one in the caller's queue |
|
* for cleanup */ |
|
} else { |
|
/* callback wants to keep this packet, |
|
* move from caller's queue to the send |
|
* queue */ |
|
list_move_tail(&packet->list, |
|
&send_queue); |
|
} |
|
} |
|
|
|
if (list_empty(&send_queue)) { |
|
/* no packets made it in, caller will cleanup */ |
|
return HTC_SEND_QUEUE_DROP; |
|
} |
|
} |
|
} |
|
|
|
if (!ep->pipe.tx_credit_flow_enabled) { |
|
tx_resources = |
|
ath6kl_hif_pipe_get_free_queue_number(ar, |
|
ep->pipe.pipeid_ul); |
|
} else { |
|
tx_resources = 0; |
|
} |
|
|
|
spin_lock_bh(&target->tx_lock); |
|
if (!list_empty(&send_queue)) { |
|
/* transfer packets to tail */ |
|
list_splice_tail_init(&send_queue, &ep->txq); |
|
if (!list_empty(&send_queue)) { |
|
WARN_ON_ONCE(1); |
|
spin_unlock_bh(&target->tx_lock); |
|
return HTC_SEND_QUEUE_DROP; |
|
} |
|
INIT_LIST_HEAD(&send_queue); |
|
} |
|
|
|
/* increment tx processing count on entry */ |
|
ep->tx_proc_cnt++; |
|
|
|
if (ep->tx_proc_cnt > 1) { |
|
/* |
|
* Another thread or task is draining the TX queues on this |
|
* endpoint that thread will reset the tx processing count |
|
* when the queue is drained. |
|
*/ |
|
ep->tx_proc_cnt--; |
|
spin_unlock_bh(&target->tx_lock); |
|
return HTC_SEND_QUEUE_OK; |
|
} |
|
|
|
/***** beyond this point only 1 thread may enter ******/ |
|
|
|
/* |
|
* Now drain the endpoint TX queue for transmission as long as we have |
|
* enough transmit resources. |
|
*/ |
|
while (true) { |
|
if (get_queue_depth(&ep->txq) == 0) |
|
break; |
|
|
|
if (ep->pipe.tx_credit_flow_enabled) { |
|
/* |
|
* Credit based mechanism provides flow control |
|
* based on target transmit resource availability, |
|
* we assume that the HIF layer will always have |
|
* bus resources greater than target transmit |
|
* resources. |
|
*/ |
|
get_htc_packet_credit_based(target, ep, &send_queue); |
|
} else { |
|
/* |
|
* Get all packets for this endpoint that we can |
|
* for this pass. |
|
*/ |
|
get_htc_packet(target, ep, &send_queue, tx_resources); |
|
} |
|
|
|
if (get_queue_depth(&send_queue) == 0) { |
|
/* |
|
* Didn't get packets due to out of resources or TX |
|
* queue was drained. |
|
*/ |
|
break; |
|
} |
|
|
|
spin_unlock_bh(&target->tx_lock); |
|
|
|
/* send what we can */ |
|
htc_issue_packets(target, ep, &send_queue); |
|
|
|
if (!ep->pipe.tx_credit_flow_enabled) { |
|
pipeid = ep->pipe.pipeid_ul; |
|
tx_resources = |
|
ath6kl_hif_pipe_get_free_queue_number(ar, pipeid); |
|
} |
|
|
|
spin_lock_bh(&target->tx_lock); |
|
} |
|
|
|
/* done with this endpoint, we can clear the count */ |
|
ep->tx_proc_cnt = 0; |
|
spin_unlock_bh(&target->tx_lock); |
|
|
|
return HTC_SEND_QUEUE_OK; |
|
} |
|
|
|
/* htc control packet manipulation */ |
|
static void destroy_htc_txctrl_packet(struct htc_packet *packet) |
|
{ |
|
struct sk_buff *skb; |
|
skb = packet->skb; |
|
dev_kfree_skb(skb); |
|
kfree(packet); |
|
} |
|
|
|
static struct htc_packet *build_htc_txctrl_packet(void) |
|
{ |
|
struct htc_packet *packet = NULL; |
|
struct sk_buff *skb; |
|
|
|
packet = kzalloc(sizeof(struct htc_packet), GFP_KERNEL); |
|
if (packet == NULL) |
|
return NULL; |
|
|
|
skb = __dev_alloc_skb(HTC_CONTROL_BUFFER_SIZE, GFP_KERNEL); |
|
|
|
if (skb == NULL) { |
|
kfree(packet); |
|
return NULL; |
|
} |
|
packet->skb = skb; |
|
|
|
return packet; |
|
} |
|
|
|
static void htc_free_txctrl_packet(struct htc_target *target, |
|
struct htc_packet *packet) |
|
{ |
|
destroy_htc_txctrl_packet(packet); |
|
} |
|
|
|
static struct htc_packet *htc_alloc_txctrl_packet(struct htc_target *target) |
|
{ |
|
return build_htc_txctrl_packet(); |
|
} |
|
|
|
static void htc_txctrl_complete(struct htc_target *target, |
|
struct htc_packet *packet) |
|
{ |
|
htc_free_txctrl_packet(target, packet); |
|
} |
|
|
|
#define MAX_MESSAGE_SIZE 1536 |
|
|
|
static int htc_setup_target_buffer_assignments(struct htc_target *target) |
|
{ |
|
int status, credits, credit_per_maxmsg, i; |
|
struct htc_pipe_txcredit_alloc *entry; |
|
unsigned int hif_usbaudioclass = 0; |
|
|
|
credit_per_maxmsg = MAX_MESSAGE_SIZE / target->tgt_cred_sz; |
|
if (MAX_MESSAGE_SIZE % target->tgt_cred_sz) |
|
credit_per_maxmsg++; |
|
|
|
/* TODO, this should be configured by the caller! */ |
|
|
|
credits = target->tgt_creds; |
|
entry = &target->pipe.txcredit_alloc[0]; |
|
|
|
status = -ENOMEM; |
|
|
|
/* FIXME: hif_usbaudioclass is always zero */ |
|
if (hif_usbaudioclass) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: For USB Audio Class- Total:%d\n", |
|
__func__, credits); |
|
entry++; |
|
entry++; |
|
/* Setup VO Service To have Max Credits */ |
|
entry->service_id = WMI_DATA_VO_SVC; |
|
entry->credit_alloc = (credits - 6); |
|
if (entry->credit_alloc == 0) |
|
entry->credit_alloc++; |
|
|
|
credits -= (int) entry->credit_alloc; |
|
if (credits <= 0) |
|
return status; |
|
|
|
entry++; |
|
entry->service_id = WMI_CONTROL_SVC; |
|
entry->credit_alloc = credit_per_maxmsg; |
|
credits -= (int) entry->credit_alloc; |
|
if (credits <= 0) |
|
return status; |
|
|
|
/* leftovers go to best effort */ |
|
entry++; |
|
entry++; |
|
entry->service_id = WMI_DATA_BE_SVC; |
|
entry->credit_alloc = (u8) credits; |
|
status = 0; |
|
} else { |
|
entry++; |
|
entry->service_id = WMI_DATA_VI_SVC; |
|
entry->credit_alloc = credits / 4; |
|
if (entry->credit_alloc == 0) |
|
entry->credit_alloc++; |
|
|
|
credits -= (int) entry->credit_alloc; |
|
if (credits <= 0) |
|
return status; |
|
|
|
entry++; |
|
entry->service_id = WMI_DATA_VO_SVC; |
|
entry->credit_alloc = credits / 4; |
|
if (entry->credit_alloc == 0) |
|
entry->credit_alloc++; |
|
|
|
credits -= (int) entry->credit_alloc; |
|
if (credits <= 0) |
|
return status; |
|
|
|
entry++; |
|
entry->service_id = WMI_CONTROL_SVC; |
|
entry->credit_alloc = credit_per_maxmsg; |
|
credits -= (int) entry->credit_alloc; |
|
if (credits <= 0) |
|
return status; |
|
|
|
entry++; |
|
entry->service_id = WMI_DATA_BK_SVC; |
|
entry->credit_alloc = credit_per_maxmsg; |
|
credits -= (int) entry->credit_alloc; |
|
if (credits <= 0) |
|
return status; |
|
|
|
/* leftovers go to best effort */ |
|
entry++; |
|
entry->service_id = WMI_DATA_BE_SVC; |
|
entry->credit_alloc = (u8) credits; |
|
status = 0; |
|
} |
|
|
|
if (status == 0) { |
|
for (i = 0; i < ENDPOINT_MAX; i++) { |
|
if (target->pipe.txcredit_alloc[i].service_id != 0) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"HTC Service Index : %d TX : 0x%2.2X : alloc:%d\n", |
|
i, |
|
target->pipe.txcredit_alloc[i]. |
|
service_id, |
|
target->pipe.txcredit_alloc[i]. |
|
credit_alloc); |
|
} |
|
} |
|
} |
|
return status; |
|
} |
|
|
|
/* process credit reports and call distribution function */ |
|
static void htc_process_credit_report(struct htc_target *target, |
|
struct htc_credit_report *rpt, |
|
int num_entries, |
|
enum htc_endpoint_id from_ep) |
|
{ |
|
int total_credits = 0, i; |
|
struct htc_endpoint *ep; |
|
|
|
/* lock out TX while we update credits */ |
|
spin_lock_bh(&target->tx_lock); |
|
|
|
for (i = 0; i < num_entries; i++, rpt++) { |
|
if (rpt->eid >= ENDPOINT_MAX) { |
|
WARN_ON_ONCE(1); |
|
spin_unlock_bh(&target->tx_lock); |
|
return; |
|
} |
|
|
|
ep = &target->endpoint[rpt->eid]; |
|
ep->cred_dist.credits += rpt->credits; |
|
|
|
if (ep->cred_dist.credits && get_queue_depth(&ep->txq)) { |
|
spin_unlock_bh(&target->tx_lock); |
|
htc_try_send(target, ep, NULL); |
|
spin_lock_bh(&target->tx_lock); |
|
} |
|
|
|
total_credits += rpt->credits; |
|
} |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"Report indicated %d credits to distribute\n", |
|
total_credits); |
|
|
|
spin_unlock_bh(&target->tx_lock); |
|
} |
|
|
|
/* flush endpoint TX queue */ |
|
static void htc_flush_tx_endpoint(struct htc_target *target, |
|
struct htc_endpoint *ep, u16 tag) |
|
{ |
|
struct htc_packet *packet; |
|
|
|
spin_lock_bh(&target->tx_lock); |
|
while (get_queue_depth(&ep->txq)) { |
|
packet = list_first_entry(&ep->txq, struct htc_packet, list); |
|
list_del(&packet->list); |
|
packet->status = 0; |
|
send_packet_completion(target, packet); |
|
} |
|
spin_unlock_bh(&target->tx_lock); |
|
} |
|
|
|
/* |
|
* In the adapted HIF layer, struct sk_buff * are passed between HIF and HTC, |
|
* since upper layers expects struct htc_packet containers we use the completed |
|
* skb and lookup it's corresponding HTC packet buffer from a lookup list. |
|
* This is extra overhead that can be fixed by re-aligning HIF interfaces with |
|
* HTC. |
|
*/ |
|
static struct htc_packet *htc_lookup_tx_packet(struct htc_target *target, |
|
struct htc_endpoint *ep, |
|
struct sk_buff *skb) |
|
{ |
|
struct htc_packet *packet, *tmp_pkt, *found_packet = NULL; |
|
|
|
spin_lock_bh(&target->tx_lock); |
|
|
|
/* |
|
* interate from the front of tx lookup queue |
|
* this lookup should be fast since lower layers completes in-order and |
|
* so the completed packet should be at the head of the list generally |
|
*/ |
|
list_for_each_entry_safe(packet, tmp_pkt, &ep->pipe.tx_lookup_queue, |
|
list) { |
|
/* check for removal */ |
|
if (skb == packet->skb) { |
|
/* found it */ |
|
list_del(&packet->list); |
|
found_packet = packet; |
|
break; |
|
} |
|
} |
|
|
|
spin_unlock_bh(&target->tx_lock); |
|
|
|
return found_packet; |
|
} |
|
|
|
static int ath6kl_htc_pipe_tx_complete(struct ath6kl *ar, struct sk_buff *skb) |
|
{ |
|
struct htc_target *target = ar->htc_target; |
|
struct htc_frame_hdr *htc_hdr; |
|
struct htc_endpoint *ep; |
|
struct htc_packet *packet; |
|
u8 ep_id, *netdata; |
|
|
|
netdata = skb->data; |
|
|
|
htc_hdr = (struct htc_frame_hdr *) netdata; |
|
|
|
ep_id = htc_hdr->eid; |
|
ep = &target->endpoint[ep_id]; |
|
|
|
packet = htc_lookup_tx_packet(target, ep, skb); |
|
if (packet == NULL) { |
|
/* may have already been flushed and freed */ |
|
ath6kl_err("HTC TX lookup failed!\n"); |
|
} else { |
|
/* will be giving this buffer back to upper layers */ |
|
packet->status = 0; |
|
send_packet_completion(target, packet); |
|
} |
|
skb = NULL; |
|
|
|
if (!ep->pipe.tx_credit_flow_enabled) { |
|
/* |
|
* note: when using TX credit flow, the re-checking of queues |
|
* happens when credits flow back from the target. in the |
|
* non-TX credit case, we recheck after the packet completes |
|
*/ |
|
htc_try_send(target, ep, NULL); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int htc_send_packets_multiple(struct htc_target *target, |
|
struct list_head *pkt_queue) |
|
{ |
|
struct htc_endpoint *ep; |
|
struct htc_packet *packet, *tmp_pkt; |
|
|
|
if (list_empty(pkt_queue)) |
|
return -EINVAL; |
|
|
|
/* get first packet to find out which ep the packets will go into */ |
|
packet = list_first_entry(pkt_queue, struct htc_packet, list); |
|
|
|
if (packet->endpoint >= ENDPOINT_MAX) { |
|
WARN_ON_ONCE(1); |
|
return -EINVAL; |
|
} |
|
ep = &target->endpoint[packet->endpoint]; |
|
|
|
htc_try_send(target, ep, pkt_queue); |
|
|
|
/* do completion on any packets that couldn't get in */ |
|
if (!list_empty(pkt_queue)) { |
|
list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) { |
|
packet->status = -ENOMEM; |
|
} |
|
|
|
do_send_completion(ep, pkt_queue); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* htc pipe rx path */ |
|
static struct htc_packet *alloc_htc_packet_container(struct htc_target *target) |
|
{ |
|
struct htc_packet *packet; |
|
spin_lock_bh(&target->rx_lock); |
|
|
|
if (target->pipe.htc_packet_pool == NULL) { |
|
spin_unlock_bh(&target->rx_lock); |
|
return NULL; |
|
} |
|
|
|
packet = target->pipe.htc_packet_pool; |
|
target->pipe.htc_packet_pool = (struct htc_packet *) packet->list.next; |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
|
|
packet->list.next = NULL; |
|
return packet; |
|
} |
|
|
|
static void free_htc_packet_container(struct htc_target *target, |
|
struct htc_packet *packet) |
|
{ |
|
struct list_head *lh; |
|
|
|
spin_lock_bh(&target->rx_lock); |
|
|
|
if (target->pipe.htc_packet_pool == NULL) { |
|
target->pipe.htc_packet_pool = packet; |
|
packet->list.next = NULL; |
|
} else { |
|
lh = (struct list_head *) target->pipe.htc_packet_pool; |
|
packet->list.next = lh; |
|
target->pipe.htc_packet_pool = packet; |
|
} |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
} |
|
|
|
static int htc_process_trailer(struct htc_target *target, u8 *buffer, |
|
int len, enum htc_endpoint_id from_ep) |
|
{ |
|
struct htc_credit_report *report; |
|
struct htc_record_hdr *record; |
|
u8 *record_buf; |
|
int status = 0; |
|
|
|
while (len > 0) { |
|
if (len < sizeof(struct htc_record_hdr)) { |
|
status = -EINVAL; |
|
break; |
|
} |
|
|
|
/* these are byte aligned structs */ |
|
record = (struct htc_record_hdr *) buffer; |
|
len -= sizeof(struct htc_record_hdr); |
|
buffer += sizeof(struct htc_record_hdr); |
|
|
|
if (record->len > len) { |
|
/* no room left in buffer for record */ |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"invalid length: %d (id:%d) buffer has: %d bytes left\n", |
|
record->len, record->rec_id, len); |
|
status = -EINVAL; |
|
break; |
|
} |
|
|
|
/* start of record follows the header */ |
|
record_buf = buffer; |
|
|
|
switch (record->rec_id) { |
|
case HTC_RECORD_CREDITS: |
|
if (record->len < sizeof(struct htc_credit_report)) { |
|
WARN_ON_ONCE(1); |
|
return -EINVAL; |
|
} |
|
|
|
report = (struct htc_credit_report *) record_buf; |
|
htc_process_credit_report(target, report, |
|
record->len / sizeof(*report), |
|
from_ep); |
|
break; |
|
default: |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"unhandled record: id:%d length:%d\n", |
|
record->rec_id, record->len); |
|
break; |
|
} |
|
|
|
/* advance buffer past this record for next time around */ |
|
buffer += record->len; |
|
len -= record->len; |
|
} |
|
|
|
return status; |
|
} |
|
|
|
static void do_recv_completion(struct htc_endpoint *ep, |
|
struct list_head *queue_to_indicate) |
|
{ |
|
struct htc_packet *packet; |
|
|
|
if (list_empty(queue_to_indicate)) { |
|
/* nothing to indicate */ |
|
return; |
|
} |
|
|
|
/* using legacy EpRecv */ |
|
while (!list_empty(queue_to_indicate)) { |
|
packet = list_first_entry(queue_to_indicate, |
|
struct htc_packet, list); |
|
list_del(&packet->list); |
|
ep->ep_cb.rx(ep->target, packet); |
|
} |
|
|
|
return; |
|
} |
|
|
|
static void recv_packet_completion(struct htc_target *target, |
|
struct htc_endpoint *ep, |
|
struct htc_packet *packet) |
|
{ |
|
struct list_head container; |
|
INIT_LIST_HEAD(&container); |
|
list_add_tail(&packet->list, &container); |
|
|
|
/* do completion */ |
|
do_recv_completion(ep, &container); |
|
} |
|
|
|
static int ath6kl_htc_pipe_rx_complete(struct ath6kl *ar, struct sk_buff *skb, |
|
u8 pipeid) |
|
{ |
|
struct htc_target *target = ar->htc_target; |
|
u8 *netdata, *trailer, hdr_info; |
|
struct htc_frame_hdr *htc_hdr; |
|
u32 netlen, trailerlen = 0; |
|
struct htc_packet *packet; |
|
struct htc_endpoint *ep; |
|
u16 payload_len; |
|
int status = 0; |
|
|
|
/* |
|
* ar->htc_target can be NULL due to a race condition that can occur |
|
* during driver initialization(we do 'ath6kl_hif_power_on' before |
|
* initializing 'ar->htc_target' via 'ath6kl_htc_create'). |
|
* 'ath6kl_hif_power_on' assigns 'ath6kl_recv_complete' as |
|
* usb_complete_t/callback function for 'usb_fill_bulk_urb'. |
|
* Thus the possibility of ar->htc_target being NULL |
|
* via ath6kl_recv_complete -> ath6kl_usb_io_comp_work. |
|
*/ |
|
if (WARN_ON_ONCE(!target)) { |
|
ath6kl_err("Target not yet initialized\n"); |
|
status = -EINVAL; |
|
goto free_skb; |
|
} |
|
|
|
|
|
netdata = skb->data; |
|
netlen = skb->len; |
|
|
|
htc_hdr = (struct htc_frame_hdr *) netdata; |
|
|
|
if (htc_hdr->eid >= ENDPOINT_MAX) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"HTC Rx: invalid EndpointID=%d\n", |
|
htc_hdr->eid); |
|
status = -EINVAL; |
|
goto free_skb; |
|
} |
|
ep = &target->endpoint[htc_hdr->eid]; |
|
|
|
payload_len = le16_to_cpu(get_unaligned(&htc_hdr->payld_len)); |
|
|
|
if (netlen < (payload_len + HTC_HDR_LENGTH)) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"HTC Rx: insufficient length, got:%d expected =%zu\n", |
|
netlen, payload_len + HTC_HDR_LENGTH); |
|
status = -EINVAL; |
|
goto free_skb; |
|
} |
|
|
|
/* get flags to check for trailer */ |
|
hdr_info = htc_hdr->flags; |
|
if (hdr_info & HTC_FLG_RX_TRAILER) { |
|
/* extract the trailer length */ |
|
hdr_info = htc_hdr->ctrl[0]; |
|
if ((hdr_info < sizeof(struct htc_record_hdr)) || |
|
(hdr_info > payload_len)) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"invalid header: payloadlen should be %d, CB[0]: %d\n", |
|
payload_len, hdr_info); |
|
status = -EINVAL; |
|
goto free_skb; |
|
} |
|
|
|
trailerlen = hdr_info; |
|
/* process trailer after hdr/apps payload */ |
|
trailer = (u8 *) htc_hdr + HTC_HDR_LENGTH + |
|
payload_len - hdr_info; |
|
status = htc_process_trailer(target, trailer, hdr_info, |
|
htc_hdr->eid); |
|
if (status != 0) |
|
goto free_skb; |
|
} |
|
|
|
if (((int) payload_len - (int) trailerlen) <= 0) { |
|
/* zero length packet with trailer, just drop these */ |
|
goto free_skb; |
|
} |
|
|
|
if (htc_hdr->eid == ENDPOINT_0) { |
|
/* handle HTC control message */ |
|
if (target->htc_flags & HTC_OP_STATE_SETUP_COMPLETE) { |
|
/* |
|
* fatal: target should not send unsolicited |
|
* messageson the endpoint 0 |
|
*/ |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"HTC ignores Rx Ctrl after setup complete\n"); |
|
status = -EINVAL; |
|
goto free_skb; |
|
} |
|
|
|
/* remove HTC header */ |
|
skb_pull(skb, HTC_HDR_LENGTH); |
|
|
|
netdata = skb->data; |
|
netlen = skb->len; |
|
|
|
spin_lock_bh(&target->rx_lock); |
|
|
|
target->pipe.ctrl_response_valid = true; |
|
target->pipe.ctrl_response_len = min_t(int, netlen, |
|
HTC_MAX_CTRL_MSG_LEN); |
|
memcpy(target->pipe.ctrl_response_buf, netdata, |
|
target->pipe.ctrl_response_len); |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
|
|
dev_kfree_skb(skb); |
|
skb = NULL; |
|
|
|
goto free_skb; |
|
} |
|
|
|
/* |
|
* TODO: the message based HIF architecture allocates net bufs |
|
* for recv packets since it bridges that HIF to upper layers, |
|
* which expects HTC packets, we form the packets here |
|
*/ |
|
packet = alloc_htc_packet_container(target); |
|
if (packet == NULL) { |
|
status = -ENOMEM; |
|
goto free_skb; |
|
} |
|
|
|
packet->status = 0; |
|
packet->endpoint = htc_hdr->eid; |
|
packet->pkt_cntxt = skb; |
|
|
|
/* TODO: for backwards compatibility */ |
|
packet->buf = skb_push(skb, 0) + HTC_HDR_LENGTH; |
|
packet->act_len = netlen - HTC_HDR_LENGTH - trailerlen; |
|
|
|
/* |
|
* TODO: this is a hack because the driver layer will set the |
|
* actual len of the skb again which will just double the len |
|
*/ |
|
skb_trim(skb, 0); |
|
|
|
recv_packet_completion(target, ep, packet); |
|
|
|
/* recover the packet container */ |
|
free_htc_packet_container(target, packet); |
|
skb = NULL; |
|
|
|
free_skb: |
|
dev_kfree_skb(skb); |
|
|
|
return status; |
|
} |
|
|
|
static void htc_flush_rx_queue(struct htc_target *target, |
|
struct htc_endpoint *ep) |
|
{ |
|
struct list_head container; |
|
struct htc_packet *packet; |
|
|
|
spin_lock_bh(&target->rx_lock); |
|
|
|
while (1) { |
|
if (list_empty(&ep->rx_bufq)) |
|
break; |
|
|
|
packet = list_first_entry(&ep->rx_bufq, |
|
struct htc_packet, list); |
|
list_del(&packet->list); |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
packet->status = -ECANCELED; |
|
packet->act_len = 0; |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"Flushing RX packet:0x%p, length:%d, ep:%d\n", |
|
packet, packet->buf_len, |
|
packet->endpoint); |
|
|
|
INIT_LIST_HEAD(&container); |
|
list_add_tail(&packet->list, &container); |
|
|
|
/* give the packet back */ |
|
do_recv_completion(ep, &container); |
|
spin_lock_bh(&target->rx_lock); |
|
} |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
} |
|
|
|
/* polling routine to wait for a control packet to be received */ |
|
static int htc_wait_recv_ctrl_message(struct htc_target *target) |
|
{ |
|
int count = HTC_TARGET_RESPONSE_POLL_COUNT; |
|
|
|
while (count > 0) { |
|
spin_lock_bh(&target->rx_lock); |
|
|
|
if (target->pipe.ctrl_response_valid) { |
|
target->pipe.ctrl_response_valid = false; |
|
spin_unlock_bh(&target->rx_lock); |
|
break; |
|
} |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
|
|
count--; |
|
|
|
msleep_interruptible(HTC_TARGET_RESPONSE_POLL_WAIT); |
|
} |
|
|
|
if (count <= 0) { |
|
ath6kl_warn("htc pipe control receive timeout!\n"); |
|
return -ETIMEDOUT; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static void htc_rxctrl_complete(struct htc_target *context, |
|
struct htc_packet *packet) |
|
{ |
|
struct sk_buff *skb = packet->skb; |
|
|
|
if (packet->endpoint == ENDPOINT_0 && |
|
packet->status == -ECANCELED && |
|
skb != NULL) |
|
dev_kfree_skb(skb); |
|
} |
|
|
|
/* htc pipe initialization */ |
|
static void reset_endpoint_states(struct htc_target *target) |
|
{ |
|
struct htc_endpoint *ep; |
|
int i; |
|
|
|
for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) { |
|
ep = &target->endpoint[i]; |
|
ep->svc_id = 0; |
|
ep->len_max = 0; |
|
ep->max_txq_depth = 0; |
|
ep->eid = i; |
|
INIT_LIST_HEAD(&ep->txq); |
|
INIT_LIST_HEAD(&ep->pipe.tx_lookup_queue); |
|
INIT_LIST_HEAD(&ep->rx_bufq); |
|
ep->target = target; |
|
ep->pipe.tx_credit_flow_enabled = true; |
|
} |
|
} |
|
|
|
/* start HTC, this is called after all services are connected */ |
|
static int htc_config_target_hif_pipe(struct htc_target *target) |
|
{ |
|
return 0; |
|
} |
|
|
|
/* htc service functions */ |
|
static u8 htc_get_credit_alloc(struct htc_target *target, u16 service_id) |
|
{ |
|
u8 allocation = 0; |
|
int i; |
|
|
|
for (i = 0; i < ENDPOINT_MAX; i++) { |
|
if (target->pipe.txcredit_alloc[i].service_id == service_id) |
|
allocation = |
|
target->pipe.txcredit_alloc[i].credit_alloc; |
|
} |
|
|
|
if (allocation == 0) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"HTC Service TX : 0x%2.2X : allocation is zero!\n", |
|
service_id); |
|
} |
|
|
|
return allocation; |
|
} |
|
|
|
static int ath6kl_htc_pipe_conn_service(struct htc_target *target, |
|
struct htc_service_connect_req *conn_req, |
|
struct htc_service_connect_resp *conn_resp) |
|
{ |
|
struct ath6kl *ar = target->dev->ar; |
|
struct htc_packet *packet = NULL; |
|
struct htc_conn_service_resp *resp_msg; |
|
struct htc_conn_service_msg *conn_msg; |
|
enum htc_endpoint_id assigned_epid = ENDPOINT_MAX; |
|
bool disable_credit_flowctrl = false; |
|
unsigned int max_msg_size = 0; |
|
struct htc_endpoint *ep; |
|
int length, status = 0; |
|
struct sk_buff *skb; |
|
u8 tx_alloc; |
|
u16 flags; |
|
|
|
if (conn_req->svc_id == 0) { |
|
WARN_ON_ONCE(1); |
|
status = -EINVAL; |
|
goto free_packet; |
|
} |
|
|
|
if (conn_req->svc_id == HTC_CTRL_RSVD_SVC) { |
|
/* special case for pseudo control service */ |
|
assigned_epid = ENDPOINT_0; |
|
max_msg_size = HTC_MAX_CTRL_MSG_LEN; |
|
tx_alloc = 0; |
|
|
|
} else { |
|
tx_alloc = htc_get_credit_alloc(target, conn_req->svc_id); |
|
if (tx_alloc == 0) { |
|
status = -ENOMEM; |
|
goto free_packet; |
|
} |
|
|
|
/* allocate a packet to send to the target */ |
|
packet = htc_alloc_txctrl_packet(target); |
|
|
|
if (packet == NULL) { |
|
WARN_ON_ONCE(1); |
|
status = -ENOMEM; |
|
goto free_packet; |
|
} |
|
|
|
skb = packet->skb; |
|
length = sizeof(struct htc_conn_service_msg); |
|
|
|
/* assemble connect service message */ |
|
conn_msg = skb_put(skb, length); |
|
if (conn_msg == NULL) { |
|
WARN_ON_ONCE(1); |
|
status = -EINVAL; |
|
goto free_packet; |
|
} |
|
|
|
memset(conn_msg, 0, |
|
sizeof(struct htc_conn_service_msg)); |
|
conn_msg->msg_id = cpu_to_le16(HTC_MSG_CONN_SVC_ID); |
|
conn_msg->svc_id = cpu_to_le16(conn_req->svc_id); |
|
conn_msg->conn_flags = cpu_to_le16(conn_req->conn_flags & |
|
~HTC_CONN_FLGS_SET_RECV_ALLOC_MASK); |
|
|
|
/* tell target desired recv alloc for this ep */ |
|
flags = tx_alloc << HTC_CONN_FLGS_SET_RECV_ALLOC_SHIFT; |
|
conn_msg->conn_flags |= cpu_to_le16(flags); |
|
|
|
if (conn_req->conn_flags & |
|
HTC_CONN_FLGS_DISABLE_CRED_FLOW_CTRL) { |
|
disable_credit_flowctrl = true; |
|
} |
|
|
|
set_htc_pkt_info(packet, NULL, (u8 *) conn_msg, |
|
length, |
|
ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); |
|
|
|
status = ath6kl_htc_pipe_tx(target, packet); |
|
|
|
/* we don't own it anymore */ |
|
packet = NULL; |
|
if (status != 0) |
|
goto free_packet; |
|
|
|
/* wait for response */ |
|
status = htc_wait_recv_ctrl_message(target); |
|
if (status != 0) |
|
goto free_packet; |
|
|
|
/* we controlled the buffer creation so it has to be |
|
* properly aligned |
|
*/ |
|
resp_msg = (struct htc_conn_service_resp *) |
|
target->pipe.ctrl_response_buf; |
|
|
|
if (resp_msg->msg_id != cpu_to_le16(HTC_MSG_CONN_SVC_RESP_ID) || |
|
(target->pipe.ctrl_response_len < sizeof(*resp_msg))) { |
|
/* this message is not valid */ |
|
WARN_ON_ONCE(1); |
|
status = -EINVAL; |
|
goto free_packet; |
|
} |
|
|
|
ath6kl_dbg(ATH6KL_DBG_TRC, |
|
"%s: service 0x%X conn resp: status: %d ep: %d\n", |
|
__func__, resp_msg->svc_id, resp_msg->status, |
|
resp_msg->eid); |
|
|
|
conn_resp->resp_code = resp_msg->status; |
|
/* check response status */ |
|
if (resp_msg->status != HTC_SERVICE_SUCCESS) { |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"Target failed service 0x%X connect request (status:%d)\n", |
|
resp_msg->svc_id, resp_msg->status); |
|
status = -EINVAL; |
|
goto free_packet; |
|
} |
|
|
|
assigned_epid = (enum htc_endpoint_id) resp_msg->eid; |
|
max_msg_size = le16_to_cpu(resp_msg->max_msg_sz); |
|
} |
|
|
|
/* the rest are parameter checks so set the error status */ |
|
status = -EINVAL; |
|
|
|
if (assigned_epid >= ENDPOINT_MAX) { |
|
WARN_ON_ONCE(1); |
|
goto free_packet; |
|
} |
|
|
|
if (max_msg_size == 0) { |
|
WARN_ON_ONCE(1); |
|
goto free_packet; |
|
} |
|
|
|
ep = &target->endpoint[assigned_epid]; |
|
ep->eid = assigned_epid; |
|
if (ep->svc_id != 0) { |
|
/* endpoint already in use! */ |
|
WARN_ON_ONCE(1); |
|
goto free_packet; |
|
} |
|
|
|
/* return assigned endpoint to caller */ |
|
conn_resp->endpoint = assigned_epid; |
|
conn_resp->len_max = max_msg_size; |
|
|
|
/* setup the endpoint */ |
|
ep->svc_id = conn_req->svc_id; /* this marks ep in use */ |
|
ep->max_txq_depth = conn_req->max_txq_depth; |
|
ep->len_max = max_msg_size; |
|
ep->cred_dist.credits = tx_alloc; |
|
ep->cred_dist.cred_sz = target->tgt_cred_sz; |
|
ep->cred_dist.cred_per_msg = max_msg_size / target->tgt_cred_sz; |
|
if (max_msg_size % target->tgt_cred_sz) |
|
ep->cred_dist.cred_per_msg++; |
|
|
|
/* copy all the callbacks */ |
|
ep->ep_cb = conn_req->ep_cb; |
|
|
|
/* initialize tx_drop_packet_threshold */ |
|
ep->tx_drop_packet_threshold = MAX_HI_COOKIE_NUM; |
|
|
|
status = ath6kl_hif_pipe_map_service(ar, ep->svc_id, |
|
&ep->pipe.pipeid_ul, |
|
&ep->pipe.pipeid_dl); |
|
if (status != 0) |
|
goto free_packet; |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"SVC Ready: 0x%4.4X: ULpipe:%d DLpipe:%d id:%d\n", |
|
ep->svc_id, ep->pipe.pipeid_ul, |
|
ep->pipe.pipeid_dl, ep->eid); |
|
|
|
if (disable_credit_flowctrl && ep->pipe.tx_credit_flow_enabled) { |
|
ep->pipe.tx_credit_flow_enabled = false; |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"SVC: 0x%4.4X ep:%d TX flow control off\n", |
|
ep->svc_id, assigned_epid); |
|
} |
|
|
|
free_packet: |
|
if (packet != NULL) |
|
htc_free_txctrl_packet(target, packet); |
|
return status; |
|
} |
|
|
|
/* htc export functions */ |
|
static void *ath6kl_htc_pipe_create(struct ath6kl *ar) |
|
{ |
|
int status = 0; |
|
struct htc_endpoint *ep = NULL; |
|
struct htc_target *target = NULL; |
|
struct htc_packet *packet; |
|
int i; |
|
|
|
target = kzalloc(sizeof(struct htc_target), GFP_KERNEL); |
|
if (target == NULL) { |
|
ath6kl_err("htc create unable to allocate memory\n"); |
|
status = -ENOMEM; |
|
goto fail_htc_create; |
|
} |
|
|
|
spin_lock_init(&target->htc_lock); |
|
spin_lock_init(&target->rx_lock); |
|
spin_lock_init(&target->tx_lock); |
|
|
|
reset_endpoint_states(target); |
|
|
|
for (i = 0; i < HTC_PACKET_CONTAINER_ALLOCATION; i++) { |
|
packet = kzalloc(sizeof(struct htc_packet), GFP_KERNEL); |
|
|
|
if (packet != NULL) |
|
free_htc_packet_container(target, packet); |
|
} |
|
|
|
target->dev = kzalloc(sizeof(*target->dev), GFP_KERNEL); |
|
if (!target->dev) { |
|
ath6kl_err("unable to allocate memory\n"); |
|
status = -ENOMEM; |
|
goto fail_htc_create; |
|
} |
|
target->dev->ar = ar; |
|
target->dev->htc_cnxt = target; |
|
|
|
/* Get HIF default pipe for HTC message exchange */ |
|
ep = &target->endpoint[ENDPOINT_0]; |
|
|
|
ath6kl_hif_pipe_get_default(ar, &ep->pipe.pipeid_ul, |
|
&ep->pipe.pipeid_dl); |
|
|
|
return target; |
|
|
|
fail_htc_create: |
|
if (status != 0) { |
|
if (target != NULL) |
|
ath6kl_htc_pipe_cleanup(target); |
|
|
|
target = NULL; |
|
} |
|
return target; |
|
} |
|
|
|
/* cleanup the HTC instance */ |
|
static void ath6kl_htc_pipe_cleanup(struct htc_target *target) |
|
{ |
|
struct htc_packet *packet; |
|
|
|
while (true) { |
|
packet = alloc_htc_packet_container(target); |
|
if (packet == NULL) |
|
break; |
|
kfree(packet); |
|
} |
|
|
|
kfree(target->dev); |
|
|
|
/* kfree our instance */ |
|
kfree(target); |
|
} |
|
|
|
static int ath6kl_htc_pipe_start(struct htc_target *target) |
|
{ |
|
struct sk_buff *skb; |
|
struct htc_setup_comp_ext_msg *setup; |
|
struct htc_packet *packet; |
|
|
|
htc_config_target_hif_pipe(target); |
|
|
|
/* allocate a buffer to send */ |
|
packet = htc_alloc_txctrl_packet(target); |
|
if (packet == NULL) { |
|
WARN_ON_ONCE(1); |
|
return -ENOMEM; |
|
} |
|
|
|
skb = packet->skb; |
|
|
|
/* assemble setup complete message */ |
|
setup = skb_put(skb, sizeof(*setup)); |
|
memset(setup, 0, sizeof(struct htc_setup_comp_ext_msg)); |
|
setup->msg_id = cpu_to_le16(HTC_MSG_SETUP_COMPLETE_EX_ID); |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, "HTC using TX credit flow control\n"); |
|
|
|
set_htc_pkt_info(packet, NULL, (u8 *) setup, |
|
sizeof(struct htc_setup_comp_ext_msg), |
|
ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); |
|
|
|
target->htc_flags |= HTC_OP_STATE_SETUP_COMPLETE; |
|
|
|
return ath6kl_htc_pipe_tx(target, packet); |
|
} |
|
|
|
static void ath6kl_htc_pipe_stop(struct htc_target *target) |
|
{ |
|
int i; |
|
struct htc_endpoint *ep; |
|
|
|
/* cleanup endpoints */ |
|
for (i = 0; i < ENDPOINT_MAX; i++) { |
|
ep = &target->endpoint[i]; |
|
htc_flush_rx_queue(target, ep); |
|
htc_flush_tx_endpoint(target, ep, HTC_TX_PACKET_TAG_ALL); |
|
} |
|
|
|
reset_endpoint_states(target); |
|
target->htc_flags &= ~HTC_OP_STATE_SETUP_COMPLETE; |
|
} |
|
|
|
static int ath6kl_htc_pipe_get_rxbuf_num(struct htc_target *target, |
|
enum htc_endpoint_id endpoint) |
|
{ |
|
int num; |
|
|
|
spin_lock_bh(&target->rx_lock); |
|
num = get_queue_depth(&(target->endpoint[endpoint].rx_bufq)); |
|
spin_unlock_bh(&target->rx_lock); |
|
|
|
return num; |
|
} |
|
|
|
static int ath6kl_htc_pipe_tx(struct htc_target *target, |
|
struct htc_packet *packet) |
|
{ |
|
struct list_head queue; |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"%s: endPointId: %d, buffer: 0x%p, length: %d\n", |
|
__func__, packet->endpoint, packet->buf, |
|
packet->act_len); |
|
|
|
INIT_LIST_HEAD(&queue); |
|
list_add_tail(&packet->list, &queue); |
|
|
|
return htc_send_packets_multiple(target, &queue); |
|
} |
|
|
|
static int ath6kl_htc_pipe_wait_target(struct htc_target *target) |
|
{ |
|
struct htc_ready_ext_msg *ready_msg; |
|
struct htc_service_connect_req connect; |
|
struct htc_service_connect_resp resp; |
|
int status = 0; |
|
|
|
status = htc_wait_recv_ctrl_message(target); |
|
|
|
if (status != 0) |
|
return status; |
|
|
|
if (target->pipe.ctrl_response_len < sizeof(*ready_msg)) { |
|
ath6kl_warn("invalid htc pipe ready msg len: %d\n", |
|
target->pipe.ctrl_response_len); |
|
return -ECOMM; |
|
} |
|
|
|
ready_msg = (struct htc_ready_ext_msg *) target->pipe.ctrl_response_buf; |
|
|
|
if (ready_msg->ver2_0_info.msg_id != cpu_to_le16(HTC_MSG_READY_ID)) { |
|
ath6kl_warn("invalid htc pipe ready msg: 0x%x\n", |
|
ready_msg->ver2_0_info.msg_id); |
|
return -ECOMM; |
|
} |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"Target Ready! : transmit resources : %d size:%d\n", |
|
ready_msg->ver2_0_info.cred_cnt, |
|
ready_msg->ver2_0_info.cred_sz); |
|
|
|
target->tgt_creds = le16_to_cpu(ready_msg->ver2_0_info.cred_cnt); |
|
target->tgt_cred_sz = le16_to_cpu(ready_msg->ver2_0_info.cred_sz); |
|
|
|
if ((target->tgt_creds == 0) || (target->tgt_cred_sz == 0)) |
|
return -ECOMM; |
|
|
|
htc_setup_target_buffer_assignments(target); |
|
|
|
/* setup our pseudo HTC control endpoint connection */ |
|
memset(&connect, 0, sizeof(connect)); |
|
memset(&resp, 0, sizeof(resp)); |
|
connect.ep_cb.tx_complete = htc_txctrl_complete; |
|
connect.ep_cb.rx = htc_rxctrl_complete; |
|
connect.max_txq_depth = NUM_CONTROL_TX_BUFFERS; |
|
connect.svc_id = HTC_CTRL_RSVD_SVC; |
|
|
|
/* connect fake service */ |
|
status = ath6kl_htc_pipe_conn_service(target, &connect, &resp); |
|
|
|
return status; |
|
} |
|
|
|
static void ath6kl_htc_pipe_flush_txep(struct htc_target *target, |
|
enum htc_endpoint_id endpoint, u16 tag) |
|
{ |
|
struct htc_endpoint *ep = &target->endpoint[endpoint]; |
|
|
|
if (ep->svc_id == 0) { |
|
WARN_ON_ONCE(1); |
|
/* not in use.. */ |
|
return; |
|
} |
|
|
|
htc_flush_tx_endpoint(target, ep, tag); |
|
} |
|
|
|
static int ath6kl_htc_pipe_add_rxbuf_multiple(struct htc_target *target, |
|
struct list_head *pkt_queue) |
|
{ |
|
struct htc_packet *packet, *tmp_pkt, *first; |
|
struct htc_endpoint *ep; |
|
int status = 0; |
|
|
|
if (list_empty(pkt_queue)) |
|
return -EINVAL; |
|
|
|
first = list_first_entry(pkt_queue, struct htc_packet, list); |
|
|
|
if (first->endpoint >= ENDPOINT_MAX) { |
|
WARN_ON_ONCE(1); |
|
return -EINVAL; |
|
} |
|
|
|
ath6kl_dbg(ATH6KL_DBG_HTC, "%s: epid: %d, cnt:%d, len: %d\n", |
|
__func__, first->endpoint, get_queue_depth(pkt_queue), |
|
first->buf_len); |
|
|
|
ep = &target->endpoint[first->endpoint]; |
|
|
|
spin_lock_bh(&target->rx_lock); |
|
|
|
/* store receive packets */ |
|
list_splice_tail_init(pkt_queue, &ep->rx_bufq); |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
|
|
if (status != 0) { |
|
/* walk through queue and mark each one canceled */ |
|
list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) { |
|
packet->status = -ECANCELED; |
|
} |
|
|
|
do_recv_completion(ep, pkt_queue); |
|
} |
|
|
|
return status; |
|
} |
|
|
|
static void ath6kl_htc_pipe_activity_changed(struct htc_target *target, |
|
enum htc_endpoint_id ep, |
|
bool active) |
|
{ |
|
/* TODO */ |
|
} |
|
|
|
static void ath6kl_htc_pipe_flush_rx_buf(struct htc_target *target) |
|
{ |
|
struct htc_endpoint *endpoint; |
|
struct htc_packet *packet, *tmp_pkt; |
|
int i; |
|
|
|
for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) { |
|
endpoint = &target->endpoint[i]; |
|
|
|
spin_lock_bh(&target->rx_lock); |
|
|
|
list_for_each_entry_safe(packet, tmp_pkt, |
|
&endpoint->rx_bufq, list) { |
|
list_del(&packet->list); |
|
spin_unlock_bh(&target->rx_lock); |
|
ath6kl_dbg(ATH6KL_DBG_HTC, |
|
"htc rx flush pkt 0x%p len %d ep %d\n", |
|
packet, packet->buf_len, |
|
packet->endpoint); |
|
dev_kfree_skb(packet->pkt_cntxt); |
|
spin_lock_bh(&target->rx_lock); |
|
} |
|
|
|
spin_unlock_bh(&target->rx_lock); |
|
} |
|
} |
|
|
|
static int ath6kl_htc_pipe_credit_setup(struct htc_target *target, |
|
struct ath6kl_htc_credit_info *info) |
|
{ |
|
return 0; |
|
} |
|
|
|
static const struct ath6kl_htc_ops ath6kl_htc_pipe_ops = { |
|
.create = ath6kl_htc_pipe_create, |
|
.wait_target = ath6kl_htc_pipe_wait_target, |
|
.start = ath6kl_htc_pipe_start, |
|
.conn_service = ath6kl_htc_pipe_conn_service, |
|
.tx = ath6kl_htc_pipe_tx, |
|
.stop = ath6kl_htc_pipe_stop, |
|
.cleanup = ath6kl_htc_pipe_cleanup, |
|
.flush_txep = ath6kl_htc_pipe_flush_txep, |
|
.flush_rx_buf = ath6kl_htc_pipe_flush_rx_buf, |
|
.activity_changed = ath6kl_htc_pipe_activity_changed, |
|
.get_rxbuf_num = ath6kl_htc_pipe_get_rxbuf_num, |
|
.add_rxbuf_multiple = ath6kl_htc_pipe_add_rxbuf_multiple, |
|
.credit_setup = ath6kl_htc_pipe_credit_setup, |
|
.tx_complete = ath6kl_htc_pipe_tx_complete, |
|
.rx_complete = ath6kl_htc_pipe_rx_complete, |
|
}; |
|
|
|
void ath6kl_htc_pipe_attach(struct ath6kl *ar) |
|
{ |
|
ar->htc_ops = &ath6kl_htc_pipe_ops; |
|
}
|
|
|