.. | .. |
---|
1 | | -/* Copyright (c) 2014 Broadcom Corporation |
---|
2 | | - * |
---|
3 | | - * Permission to use, copy, modify, and/or distribute this software for any |
---|
4 | | - * purpose with or without fee is hereby granted, provided that the above |
---|
5 | | - * copyright notice and this permission notice appear in all copies. |
---|
6 | | - * |
---|
7 | | - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
---|
8 | | - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
---|
9 | | - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
---|
10 | | - * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
---|
11 | | - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
---|
12 | | - * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
---|
13 | | - * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
---|
| 1 | +// SPDX-License-Identifier: ISC |
---|
| 2 | +/* |
---|
| 3 | + * Copyright (c) 2014 Broadcom Corporation |
---|
14 | 4 | */ |
---|
15 | 5 | |
---|
16 | 6 | /******************************************************************************* |
---|
.. | .. |
---|
64 | 54 | #define BRCMF_IOCTL_REQ_PKTID 0xFFFE |
---|
65 | 55 | |
---|
66 | 56 | #define BRCMF_MSGBUF_MAX_PKT_SIZE 2048 |
---|
| 57 | +#define BRCMF_MSGBUF_MAX_CTL_PKT_SIZE 8192 |
---|
67 | 58 | #define BRCMF_MSGBUF_RXBUFPOST_THRESHOLD 32 |
---|
68 | 59 | #define BRCMF_MSGBUF_MAX_IOCTLRESPBUF_POST 8 |
---|
69 | 60 | #define BRCMF_MSGBUF_MAX_EVENTBUF_POST 8 |
---|
.. | .. |
---|
132 | 123 | struct msgbuf_completion_hdr { |
---|
133 | 124 | __le16 status; |
---|
134 | 125 | __le16 flow_ring_id; |
---|
| 126 | +}; |
---|
| 127 | + |
---|
| 128 | +/* Data struct for the MSGBUF_TYPE_GEN_STATUS */ |
---|
| 129 | +struct msgbuf_gen_status { |
---|
| 130 | + struct msgbuf_common_hdr msg; |
---|
| 131 | + struct msgbuf_completion_hdr compl_hdr; |
---|
| 132 | + __le16 write_idx; |
---|
| 133 | + __le32 rsvd0[3]; |
---|
| 134 | +}; |
---|
| 135 | + |
---|
| 136 | +/* Data struct for the MSGBUF_TYPE_RING_STATUS */ |
---|
| 137 | +struct msgbuf_ring_status { |
---|
| 138 | + struct msgbuf_common_hdr msg; |
---|
| 139 | + struct msgbuf_completion_hdr compl_hdr; |
---|
| 140 | + __le16 write_idx; |
---|
| 141 | + __le16 rsvd0[5]; |
---|
135 | 142 | }; |
---|
136 | 143 | |
---|
137 | 144 | struct msgbuf_rx_event { |
---|
.. | .. |
---|
339 | 346 | count++; |
---|
340 | 347 | } while (count < pktids->array_size); |
---|
341 | 348 | |
---|
342 | | - if (count == pktids->array_size) |
---|
| 349 | + if (count == pktids->array_size) { |
---|
| 350 | + dma_unmap_single(dev, *physaddr, skb->len - data_offset, |
---|
| 351 | + pktids->direction); |
---|
343 | 352 | return -ENOMEM; |
---|
| 353 | + } |
---|
344 | 354 | |
---|
345 | 355 | array[*idx].data_offset = data_offset; |
---|
346 | 356 | array[*idx].physaddr = *physaddr; |
---|
.. | .. |
---|
431 | 441 | brcmf_commonring_lock(commonring); |
---|
432 | 442 | ret_ptr = brcmf_commonring_reserve_for_write(commonring); |
---|
433 | 443 | if (!ret_ptr) { |
---|
434 | | - brcmf_err("Failed to reserve space in commonring\n"); |
---|
| 444 | + bphy_err(drvr, "Failed to reserve space in commonring\n"); |
---|
435 | 445 | brcmf_commonring_unlock(commonring); |
---|
436 | 446 | return -ENOMEM; |
---|
437 | 447 | } |
---|
.. | .. |
---|
495 | 505 | |
---|
496 | 506 | timeout = brcmf_msgbuf_ioctl_resp_wait(msgbuf); |
---|
497 | 507 | if (!timeout) { |
---|
498 | | - brcmf_err("Timeout on response for query command\n"); |
---|
| 508 | + bphy_err(drvr, "Timeout on response for query command\n"); |
---|
499 | 509 | return -EIO; |
---|
500 | 510 | } |
---|
501 | 511 | |
---|
.. | .. |
---|
529 | 539 | return -ENODEV; |
---|
530 | 540 | } |
---|
531 | 541 | |
---|
532 | | -static void brcmf_msgbuf_rxreorder(struct brcmf_if *ifp, struct sk_buff *skb) |
---|
| 542 | +static void brcmf_msgbuf_rxreorder(struct brcmf_if *ifp, struct sk_buff *skb, |
---|
| 543 | + bool inirq) |
---|
533 | 544 | { |
---|
534 | 545 | } |
---|
535 | 546 | |
---|
.. | .. |
---|
572 | 583 | brcmf_msgbuf_flowring_create_worker(struct brcmf_msgbuf *msgbuf, |
---|
573 | 584 | struct brcmf_msgbuf_work_item *work) |
---|
574 | 585 | { |
---|
| 586 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
575 | 587 | struct msgbuf_tx_flowring_create_req *create; |
---|
576 | 588 | struct brcmf_commonring *commonring; |
---|
577 | 589 | void *ret_ptr; |
---|
.. | .. |
---|
587 | 599 | &msgbuf->flowring_dma_handle[flowid], |
---|
588 | 600 | GFP_KERNEL); |
---|
589 | 601 | if (!dma_buf) { |
---|
590 | | - brcmf_err("dma_alloc_coherent failed\n"); |
---|
| 602 | + bphy_err(drvr, "dma_alloc_coherent failed\n"); |
---|
591 | 603 | brcmf_flowring_delete(msgbuf->flow, flowid); |
---|
592 | 604 | return BRCMF_FLOWRING_INVALID_ID; |
---|
593 | 605 | } |
---|
.. | .. |
---|
600 | 612 | brcmf_commonring_lock(commonring); |
---|
601 | 613 | ret_ptr = brcmf_commonring_reserve_for_write(commonring); |
---|
602 | 614 | if (!ret_ptr) { |
---|
603 | | - brcmf_err("Failed to reserve space in commonring\n"); |
---|
| 615 | + bphy_err(drvr, "Failed to reserve space in commonring\n"); |
---|
604 | 616 | brcmf_commonring_unlock(commonring); |
---|
605 | 617 | brcmf_msgbuf_remove_flowring(msgbuf, flowid); |
---|
606 | 618 | return BRCMF_FLOWRING_INVALID_ID; |
---|
.. | .. |
---|
627 | 639 | err = brcmf_commonring_write_complete(commonring); |
---|
628 | 640 | brcmf_commonring_unlock(commonring); |
---|
629 | 641 | if (err) { |
---|
630 | | - brcmf_err("Failed to write commonring\n"); |
---|
| 642 | + bphy_err(drvr, "Failed to write commonring\n"); |
---|
631 | 643 | brcmf_msgbuf_remove_flowring(msgbuf, flowid); |
---|
632 | 644 | return BRCMF_FLOWRING_INVALID_ID; |
---|
633 | 645 | } |
---|
.. | .. |
---|
686 | 698 | static void brcmf_msgbuf_txflow(struct brcmf_msgbuf *msgbuf, u16 flowid) |
---|
687 | 699 | { |
---|
688 | 700 | struct brcmf_flowring *flow = msgbuf->flow; |
---|
| 701 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
689 | 702 | struct brcmf_commonring *commonring; |
---|
690 | 703 | void *ret_ptr; |
---|
691 | 704 | u32 count; |
---|
.. | .. |
---|
705 | 718 | while (brcmf_flowring_qlen(flow, flowid)) { |
---|
706 | 719 | skb = brcmf_flowring_dequeue(flow, flowid); |
---|
707 | 720 | if (skb == NULL) { |
---|
708 | | - brcmf_err("No SKB, but qlen %d\n", |
---|
709 | | - brcmf_flowring_qlen(flow, flowid)); |
---|
| 721 | + bphy_err(drvr, "No SKB, but qlen %d\n", |
---|
| 722 | + brcmf_flowring_qlen(flow, flowid)); |
---|
710 | 723 | break; |
---|
711 | 724 | } |
---|
712 | 725 | skb_orphan(skb); |
---|
.. | .. |
---|
714 | 727 | msgbuf->tx_pktids, skb, ETH_HLEN, |
---|
715 | 728 | &physaddr, &pktid)) { |
---|
716 | 729 | brcmf_flowring_reinsert(flow, flowid, skb); |
---|
717 | | - brcmf_err("No PKTID available !!\n"); |
---|
| 730 | + bphy_err(drvr, "No PKTID available !!\n"); |
---|
718 | 731 | break; |
---|
719 | 732 | } |
---|
720 | 733 | ret_ptr = brcmf_commonring_reserve_for_write(commonring); |
---|
.. | .. |
---|
729 | 742 | tx_msghdr = (struct msgbuf_tx_msghdr *)ret_ptr; |
---|
730 | 743 | |
---|
731 | 744 | tx_msghdr->msg.msgtype = MSGBUF_TYPE_TX_POST; |
---|
732 | | - tx_msghdr->msg.request_id = cpu_to_le32(pktid); |
---|
| 745 | + tx_msghdr->msg.request_id = cpu_to_le32(pktid + 1); |
---|
733 | 746 | tx_msghdr->msg.ifidx = brcmf_flowring_ifidx_get(flow, flowid); |
---|
734 | 747 | tx_msghdr->flags = BRCMF_MSGBUF_PKT_FLAGS_FRAME_802_3; |
---|
735 | 748 | tx_msghdr->flags |= (skb->priority & 0x07) << |
---|
.. | .. |
---|
866 | 879 | u16 flowid; |
---|
867 | 880 | |
---|
868 | 881 | tx_status = (struct msgbuf_tx_status *)buf; |
---|
869 | | - idx = le32_to_cpu(tx_status->msg.request_id); |
---|
| 882 | + idx = le32_to_cpu(tx_status->msg.request_id) - 1; |
---|
870 | 883 | flowid = le16_to_cpu(tx_status->compl_hdr.flow_ring_id); |
---|
871 | 884 | flowid -= BRCMF_H2D_MSGRING_FLOWRING_IDSTART; |
---|
872 | 885 | skb = brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev, |
---|
.. | .. |
---|
885 | 898 | |
---|
886 | 899 | static u32 brcmf_msgbuf_rxbuf_data_post(struct brcmf_msgbuf *msgbuf, u32 count) |
---|
887 | 900 | { |
---|
| 901 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
888 | 902 | struct brcmf_commonring *commonring; |
---|
889 | 903 | void *ret_ptr; |
---|
890 | 904 | struct sk_buff *skb; |
---|
.. | .. |
---|
912 | 926 | skb = brcmu_pkt_buf_get_skb(BRCMF_MSGBUF_MAX_PKT_SIZE); |
---|
913 | 927 | |
---|
914 | 928 | if (skb == NULL) { |
---|
915 | | - brcmf_err("Failed to alloc SKB\n"); |
---|
| 929 | + bphy_err(drvr, "Failed to alloc SKB\n"); |
---|
916 | 930 | brcmf_commonring_write_cancel(commonring, alloced - i); |
---|
917 | 931 | break; |
---|
918 | 932 | } |
---|
.. | .. |
---|
922 | 936 | msgbuf->rx_pktids, skb, 0, |
---|
923 | 937 | &physaddr, &pktid)) { |
---|
924 | 938 | dev_kfree_skb_any(skb); |
---|
925 | | - brcmf_err("No PKTID available !!\n"); |
---|
| 939 | + bphy_err(drvr, "No PKTID available !!\n"); |
---|
926 | 940 | brcmf_commonring_write_cancel(commonring, alloced - i); |
---|
927 | 941 | break; |
---|
928 | 942 | } |
---|
.. | .. |
---|
992 | 1006 | brcmf_msgbuf_rxbuf_ctrl_post(struct brcmf_msgbuf *msgbuf, bool event_buf, |
---|
993 | 1007 | u32 count) |
---|
994 | 1008 | { |
---|
| 1009 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
995 | 1010 | struct brcmf_commonring *commonring; |
---|
996 | 1011 | void *ret_ptr; |
---|
997 | 1012 | struct sk_buff *skb; |
---|
.. | .. |
---|
1009 | 1024 | count, |
---|
1010 | 1025 | &alloced); |
---|
1011 | 1026 | if (!ret_ptr) { |
---|
1012 | | - brcmf_err("Failed to reserve space in commonring\n"); |
---|
| 1027 | + bphy_err(drvr, "Failed to reserve space in commonring\n"); |
---|
1013 | 1028 | brcmf_commonring_unlock(commonring); |
---|
1014 | 1029 | return 0; |
---|
1015 | 1030 | } |
---|
.. | .. |
---|
1018 | 1033 | rx_bufpost = (struct msgbuf_rx_ioctl_resp_or_event *)ret_ptr; |
---|
1019 | 1034 | memset(rx_bufpost, 0, sizeof(*rx_bufpost)); |
---|
1020 | 1035 | |
---|
1021 | | - skb = brcmu_pkt_buf_get_skb(BRCMF_MSGBUF_MAX_PKT_SIZE); |
---|
| 1036 | + skb = brcmu_pkt_buf_get_skb(BRCMF_MSGBUF_MAX_CTL_PKT_SIZE); |
---|
1022 | 1037 | |
---|
1023 | 1038 | if (skb == NULL) { |
---|
1024 | | - brcmf_err("Failed to alloc SKB\n"); |
---|
| 1039 | + bphy_err(drvr, "Failed to alloc SKB\n"); |
---|
1025 | 1040 | brcmf_commonring_write_cancel(commonring, alloced - i); |
---|
1026 | 1041 | break; |
---|
1027 | 1042 | } |
---|
.. | .. |
---|
1031 | 1046 | msgbuf->rx_pktids, skb, 0, |
---|
1032 | 1047 | &physaddr, &pktid)) { |
---|
1033 | 1048 | dev_kfree_skb_any(skb); |
---|
1034 | | - brcmf_err("No PKTID available !!\n"); |
---|
| 1049 | + bphy_err(drvr, "No PKTID available !!\n"); |
---|
1035 | 1050 | brcmf_commonring_write_cancel(commonring, alloced - i); |
---|
1036 | 1051 | break; |
---|
1037 | 1052 | } |
---|
.. | .. |
---|
1083 | 1098 | |
---|
1084 | 1099 | static void brcmf_msgbuf_process_event(struct brcmf_msgbuf *msgbuf, void *buf) |
---|
1085 | 1100 | { |
---|
| 1101 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
1086 | 1102 | struct msgbuf_rx_event *event; |
---|
1087 | 1103 | u32 idx; |
---|
1088 | 1104 | u16 buflen; |
---|
.. | .. |
---|
1109 | 1125 | |
---|
1110 | 1126 | ifp = brcmf_get_ifp(msgbuf->drvr, event->msg.ifidx); |
---|
1111 | 1127 | if (!ifp || !ifp->ndev) { |
---|
1112 | | - brcmf_err("Received pkt for invalid ifidx %d\n", |
---|
1113 | | - event->msg.ifidx); |
---|
| 1128 | + bphy_err(drvr, "Received pkt for invalid ifidx %d\n", |
---|
| 1129 | + event->msg.ifidx); |
---|
1114 | 1130 | goto exit; |
---|
1115 | 1131 | } |
---|
1116 | 1132 | |
---|
1117 | 1133 | skb->protocol = eth_type_trans(skb, ifp->ndev); |
---|
1118 | 1134 | |
---|
1119 | | - brcmf_fweh_process_skb(ifp->drvr, skb, 0); |
---|
| 1135 | + brcmf_fweh_process_skb(ifp->drvr, skb, 0, GFP_KERNEL); |
---|
1120 | 1136 | |
---|
1121 | 1137 | exit: |
---|
1122 | 1138 | brcmu_pkt_buf_free_skb(skb); |
---|
.. | .. |
---|
1126 | 1142 | static void |
---|
1127 | 1143 | brcmf_msgbuf_process_rx_complete(struct brcmf_msgbuf *msgbuf, void *buf) |
---|
1128 | 1144 | { |
---|
| 1145 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
1129 | 1146 | struct msgbuf_rx_complete *rx_complete; |
---|
1130 | 1147 | struct sk_buff *skb; |
---|
1131 | 1148 | u16 data_offset; |
---|
.. | .. |
---|
1159 | 1176 | ifp = msgbuf->drvr->mon_if; |
---|
1160 | 1177 | |
---|
1161 | 1178 | if (!ifp) { |
---|
1162 | | - brcmf_err("Received unexpected monitor pkt\n"); |
---|
| 1179 | + bphy_err(drvr, "Received unexpected monitor pkt\n"); |
---|
1163 | 1180 | brcmu_pkt_buf_free_skb(skb); |
---|
1164 | 1181 | return; |
---|
1165 | 1182 | } |
---|
.. | .. |
---|
1170 | 1187 | |
---|
1171 | 1188 | ifp = brcmf_get_ifp(msgbuf->drvr, rx_complete->msg.ifidx); |
---|
1172 | 1189 | if (!ifp || !ifp->ndev) { |
---|
1173 | | - brcmf_err("Received pkt for invalid ifidx %d\n", |
---|
1174 | | - rx_complete->msg.ifidx); |
---|
| 1190 | + bphy_err(drvr, "Received pkt for invalid ifidx %d\n", |
---|
| 1191 | + rx_complete->msg.ifidx); |
---|
1175 | 1192 | brcmu_pkt_buf_free_skb(skb); |
---|
1176 | 1193 | return; |
---|
1177 | 1194 | } |
---|
1178 | 1195 | |
---|
1179 | 1196 | skb->protocol = eth_type_trans(skb, ifp->ndev); |
---|
1180 | | - brcmf_netif_rx(ifp, skb); |
---|
| 1197 | + brcmf_netif_rx(ifp, skb, false); |
---|
1181 | 1198 | } |
---|
1182 | 1199 | |
---|
| 1200 | +static void brcmf_msgbuf_process_gen_status(struct brcmf_msgbuf *msgbuf, |
---|
| 1201 | + void *buf) |
---|
| 1202 | +{ |
---|
| 1203 | + struct msgbuf_gen_status *gen_status = buf; |
---|
| 1204 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
| 1205 | + int err; |
---|
| 1206 | + |
---|
| 1207 | + err = le16_to_cpu(gen_status->compl_hdr.status); |
---|
| 1208 | + if (err) |
---|
| 1209 | + bphy_err(drvr, "Firmware reported general error: %d\n", err); |
---|
| 1210 | +} |
---|
| 1211 | + |
---|
| 1212 | +static void brcmf_msgbuf_process_ring_status(struct brcmf_msgbuf *msgbuf, |
---|
| 1213 | + void *buf) |
---|
| 1214 | +{ |
---|
| 1215 | + struct msgbuf_ring_status *ring_status = buf; |
---|
| 1216 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
| 1217 | + int err; |
---|
| 1218 | + |
---|
| 1219 | + err = le16_to_cpu(ring_status->compl_hdr.status); |
---|
| 1220 | + if (err) { |
---|
| 1221 | + int ring = le16_to_cpu(ring_status->compl_hdr.flow_ring_id); |
---|
| 1222 | + |
---|
| 1223 | + bphy_err(drvr, "Firmware reported ring %d error: %d\n", ring, |
---|
| 1224 | + err); |
---|
| 1225 | + } |
---|
| 1226 | +} |
---|
1183 | 1227 | |
---|
1184 | 1228 | static void |
---|
1185 | 1229 | brcmf_msgbuf_process_flow_ring_create_response(struct brcmf_msgbuf *msgbuf, |
---|
1186 | 1230 | void *buf) |
---|
1187 | 1231 | { |
---|
| 1232 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
1188 | 1233 | struct msgbuf_flowring_create_resp *flowring_create_resp; |
---|
1189 | 1234 | u16 status; |
---|
1190 | 1235 | u16 flowid; |
---|
.. | .. |
---|
1196 | 1241 | status = le16_to_cpu(flowring_create_resp->compl_hdr.status); |
---|
1197 | 1242 | |
---|
1198 | 1243 | if (status) { |
---|
1199 | | - brcmf_err("Flowring creation failed, code %d\n", status); |
---|
| 1244 | + bphy_err(drvr, "Flowring creation failed, code %d\n", status); |
---|
1200 | 1245 | brcmf_msgbuf_remove_flowring(msgbuf, flowid); |
---|
1201 | 1246 | return; |
---|
1202 | 1247 | } |
---|
.. | .. |
---|
1213 | 1258 | brcmf_msgbuf_process_flow_ring_delete_response(struct brcmf_msgbuf *msgbuf, |
---|
1214 | 1259 | void *buf) |
---|
1215 | 1260 | { |
---|
| 1261 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
1216 | 1262 | struct msgbuf_flowring_delete_resp *flowring_delete_resp; |
---|
1217 | 1263 | u16 status; |
---|
1218 | 1264 | u16 flowid; |
---|
.. | .. |
---|
1224 | 1270 | status = le16_to_cpu(flowring_delete_resp->compl_hdr.status); |
---|
1225 | 1271 | |
---|
1226 | 1272 | if (status) { |
---|
1227 | | - brcmf_err("Flowring deletion failed, code %d\n", status); |
---|
| 1273 | + bphy_err(drvr, "Flowring deletion failed, code %d\n", status); |
---|
1228 | 1274 | brcmf_flowring_delete(msgbuf->flow, flowid); |
---|
1229 | 1275 | return; |
---|
1230 | 1276 | } |
---|
.. | .. |
---|
1237 | 1283 | |
---|
1238 | 1284 | static void brcmf_msgbuf_process_msgtype(struct brcmf_msgbuf *msgbuf, void *buf) |
---|
1239 | 1285 | { |
---|
| 1286 | + struct brcmf_pub *drvr = msgbuf->drvr; |
---|
1240 | 1287 | struct msgbuf_common_hdr *msg; |
---|
1241 | 1288 | |
---|
1242 | 1289 | msg = (struct msgbuf_common_hdr *)buf; |
---|
1243 | 1290 | switch (msg->msgtype) { |
---|
| 1291 | + case MSGBUF_TYPE_GEN_STATUS: |
---|
| 1292 | + brcmf_dbg(MSGBUF, "MSGBUF_TYPE_GEN_STATUS\n"); |
---|
| 1293 | + brcmf_msgbuf_process_gen_status(msgbuf, buf); |
---|
| 1294 | + break; |
---|
| 1295 | + case MSGBUF_TYPE_RING_STATUS: |
---|
| 1296 | + brcmf_dbg(MSGBUF, "MSGBUF_TYPE_RING_STATUS\n"); |
---|
| 1297 | + brcmf_msgbuf_process_ring_status(msgbuf, buf); |
---|
| 1298 | + break; |
---|
1244 | 1299 | case MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT: |
---|
1245 | 1300 | brcmf_dbg(MSGBUF, "MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT\n"); |
---|
1246 | 1301 | brcmf_msgbuf_process_flow_ring_create_response(msgbuf, buf); |
---|
.. | .. |
---|
1269 | 1324 | brcmf_msgbuf_process_rx_complete(msgbuf, buf); |
---|
1270 | 1325 | break; |
---|
1271 | 1326 | default: |
---|
1272 | | - brcmf_err("Unsupported msgtype %d\n", msg->msgtype); |
---|
| 1327 | + bphy_err(drvr, "Unsupported msgtype %d\n", msg->msgtype); |
---|
1273 | 1328 | break; |
---|
1274 | 1329 | } |
---|
1275 | 1330 | } |
---|
.. | .. |
---|
1348 | 1403 | u8 ifidx; |
---|
1349 | 1404 | int err; |
---|
1350 | 1405 | |
---|
| 1406 | + /* no need to submit if firmware can not be reached */ |
---|
| 1407 | + if (drvr->bus_if->state != BRCMF_BUS_UP) { |
---|
| 1408 | + brcmf_dbg(MSGBUF, "bus down, flowring will be removed\n"); |
---|
| 1409 | + brcmf_msgbuf_remove_flowring(msgbuf, flowid); |
---|
| 1410 | + return; |
---|
| 1411 | + } |
---|
| 1412 | + |
---|
1351 | 1413 | commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_CONTROL_SUBMIT]; |
---|
1352 | 1414 | brcmf_commonring_lock(commonring); |
---|
1353 | 1415 | ret_ptr = brcmf_commonring_reserve_for_write(commonring); |
---|
1354 | 1416 | if (!ret_ptr) { |
---|
1355 | | - brcmf_err("FW unaware, flowring will be removed !!\n"); |
---|
| 1417 | + bphy_err(drvr, "FW unaware, flowring will be removed !!\n"); |
---|
1356 | 1418 | brcmf_commonring_unlock(commonring); |
---|
1357 | 1419 | brcmf_msgbuf_remove_flowring(msgbuf, flowid); |
---|
1358 | 1420 | return; |
---|
.. | .. |
---|
1376 | 1438 | err = brcmf_commonring_write_complete(commonring); |
---|
1377 | 1439 | brcmf_commonring_unlock(commonring); |
---|
1378 | 1440 | if (err) { |
---|
1379 | | - brcmf_err("Failed to submit RING_DELETE, flowring will be removed\n"); |
---|
| 1441 | + bphy_err(drvr, "Failed to submit RING_DELETE, flowring will be removed\n"); |
---|
1380 | 1442 | brcmf_msgbuf_remove_flowring(msgbuf, flowid); |
---|
1381 | 1443 | } |
---|
1382 | 1444 | } |
---|
.. | .. |
---|
1411 | 1473 | seq_printf(seq, "\nh2d_flowrings: depth %u\n", |
---|
1412 | 1474 | BRCMF_H2D_TXFLOWRING_MAX_ITEM); |
---|
1413 | 1475 | seq_puts(seq, "Active flowrings:\n"); |
---|
1414 | | - hash = msgbuf->flow->hash; |
---|
1415 | 1476 | for (i = 0; i < msgbuf->flow->nrofrings; i++) { |
---|
1416 | 1477 | if (!msgbuf->flow->rings[i]) |
---|
1417 | 1478 | continue; |
---|
.. | .. |
---|
1451 | 1512 | if_msgbuf = drvr->bus_if->msgbuf; |
---|
1452 | 1513 | |
---|
1453 | 1514 | if (if_msgbuf->max_flowrings >= BRCMF_FLOWRING_HASHSIZE) { |
---|
1454 | | - brcmf_err("driver not configured for this many flowrings %d\n", |
---|
1455 | | - if_msgbuf->max_flowrings); |
---|
| 1515 | + bphy_err(drvr, "driver not configured for this many flowrings %d\n", |
---|
| 1516 | + if_msgbuf->max_flowrings); |
---|
1456 | 1517 | if_msgbuf->max_flowrings = BRCMF_FLOWRING_HASHSIZE - 1; |
---|
1457 | 1518 | } |
---|
1458 | 1519 | |
---|
.. | .. |
---|
1462 | 1523 | |
---|
1463 | 1524 | msgbuf->txflow_wq = create_singlethread_workqueue("msgbuf_txflow"); |
---|
1464 | 1525 | if (msgbuf->txflow_wq == NULL) { |
---|
1465 | | - brcmf_err("workqueue creation failed\n"); |
---|
| 1526 | + bphy_err(drvr, "workqueue creation failed\n"); |
---|
1466 | 1527 | goto fail; |
---|
1467 | 1528 | } |
---|
1468 | 1529 | INIT_WORK(&msgbuf->txflow_work, brcmf_msgbuf_txflow_worker); |
---|