]>
Commit | Line | Data |
---|---|---|
bb9f8692 ZY |
1 | /* |
2 | * Intel Wireless Multicomm 3200 WiFi driver | |
3 | * | |
4 | * Copyright (C) 2009 Intel Corporation. All rights reserved. | |
5 | * | |
6 | * Redistribution and use in source and binary forms, with or without | |
7 | * modification, are permitted provided that the following conditions | |
8 | * are met: | |
9 | * | |
10 | * * Redistributions of source code must retain the above copyright | |
11 | * notice, this list of conditions and the following disclaimer. | |
12 | * * Redistributions in binary form must reproduce the above copyright | |
13 | * notice, this list of conditions and the following disclaimer in | |
14 | * the documentation and/or other materials provided with the | |
15 | * distribution. | |
16 | * * Neither the name of Intel Corporation nor the names of its | |
17 | * contributors may be used to endorse or promote products derived | |
18 | * from this software without specific prior written permission. | |
19 | * | |
20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
31 | * | |
32 | * | |
33 | * Intel Corporation <ilw@linux.intel.com> | |
34 | * Samuel Ortiz <samuel.ortiz@intel.com> | |
35 | * Zhu Yi <yi.zhu@intel.com> | |
36 | * | |
37 | */ | |
38 | ||
39 | /* | |
40 | * Hardware Abstraction Layer for iwm. | |
41 | * | |
42 | * This file mostly defines an abstraction API for | |
43 | * sending various commands to the target. | |
44 | * | |
45 | * We have 2 types of commands: wifi and non-wifi ones. | |
46 | * | |
47 | * - wifi commands: | |
48 | * They are used for sending LMAC and UMAC commands, | |
49 | * and thus are the most commonly used ones. | |
50 | * There are 2 different wifi command types, the regular | |
51 | * one and the LMAC one. The former is used to send | |
52 | * UMAC commands (see UMAC_CMD_OPCODE_* from umac.h) | |
53 | * while the latter is used for sending commands to the | |
54 | * LMAC. If you look at LMAC commands you'll se that they | |
55 | * are actually regular iwlwifi target commands encapsulated | |
56 | * into a special UMAC command called UMAC passthrough. | |
57 | * This is due to the fact the the host talks exclusively | |
58 | * to the UMAC and so there needs to be a special UMAC | |
59 | * command for talking to the LMAC. | |
60 | * This is how a wifi command is layed out: | |
61 | * ------------------------ | |
62 | * | iwm_udma_out_wifi_hdr | | |
63 | * ------------------------ | |
64 | * | SW meta_data (32 bits) | | |
65 | * ------------------------ | |
66 | * | iwm_dev_cmd_hdr | | |
67 | * ------------------------ | |
68 | * | payload | | |
69 | * | .... | | |
70 | * | |
71 | * - non-wifi, or general commands: | |
72 | * Those commands are handled by the device's bootrom, | |
73 | * and are typically sent when the UMAC and the LMAC | |
74 | * are not yet available. | |
75 | * * This is how a non-wifi command is layed out: | |
76 | * --------------------------- | |
77 | * | iwm_udma_out_nonwifi_hdr | | |
78 | * --------------------------- | |
79 | * | payload | | |
80 | * | .... | | |
81 | ||
82 | * | |
83 | * All the commands start with a UDMA header, which is | |
84 | * basically a 32 bits field. The 4 LSB there define | |
85 | * an opcode that allows the target to differentiate | |
86 | * between wifi (opcode is 0xf) and non-wifi commands | |
87 | * (opcode is [0..0xe]). | |
88 | * | |
89 | * When a command (wifi or non-wifi) is supposed to receive | |
90 | * an answer, we queue the command buffer. When we do receive | |
91 | * a command response from the UMAC, we go through the list | |
92 | * of pending command, and pass both the command and the answer | |
93 | * to the rx handler. Each command is sent with a unique | |
94 | * sequence id, and the answer is sent with the same one. This | |
95 | * is how we're supposed to match an answer with its command. | |
96 | * See rx.c:iwm_rx_handle_[non]wifi() and iwm_get_pending_[non]wifi() | |
97 | * for the implementation details. | |
98 | */ | |
99 | #include <linux/kernel.h> | |
100 | #include <linux/netdevice.h> | |
5a0e3ad6 | 101 | #include <linux/slab.h> |
bb9f8692 ZY |
102 | |
103 | #include "iwm.h" | |
104 | #include "bus.h" | |
105 | #include "hal.h" | |
106 | #include "umac.h" | |
107 | #include "debug.h" | |
108 | ||
971ad011 ZY |
109 | static int iwm_nonwifi_cmd_init(struct iwm_priv *iwm, |
110 | struct iwm_nonwifi_cmd *cmd, | |
111 | struct iwm_udma_nonwifi_cmd *udma_cmd) | |
bb9f8692 ZY |
112 | { |
113 | INIT_LIST_HEAD(&cmd->pending); | |
114 | ||
115 | spin_lock(&iwm->cmd_lock); | |
116 | ||
117 | cmd->resp_received = 0; | |
118 | ||
119 | cmd->seq_num = iwm->nonwifi_seq_num; | |
120 | udma_cmd->seq_num = cpu_to_le16(cmd->seq_num); | |
121 | ||
971ad011 | 122 | iwm->nonwifi_seq_num++; |
bb9f8692 ZY |
123 | iwm->nonwifi_seq_num %= UMAC_NONWIFI_SEQ_NUM_MAX; |
124 | ||
125 | if (udma_cmd->resp) | |
126 | list_add_tail(&cmd->pending, &iwm->nonwifi_pending_cmd); | |
127 | ||
128 | spin_unlock(&iwm->cmd_lock); | |
129 | ||
130 | cmd->buf.start = cmd->buf.payload; | |
131 | cmd->buf.len = 0; | |
132 | ||
133 | memcpy(&cmd->udma_cmd, udma_cmd, sizeof(*udma_cmd)); | |
971ad011 ZY |
134 | |
135 | return cmd->seq_num; | |
bb9f8692 ZY |
136 | } |
137 | ||
138 | u16 iwm_alloc_wifi_cmd_seq(struct iwm_priv *iwm) | |
139 | { | |
140 | u16 seq_num = iwm->wifi_seq_num; | |
141 | ||
142 | iwm->wifi_seq_num++; | |
143 | iwm->wifi_seq_num %= UMAC_WIFI_SEQ_NUM_MAX; | |
144 | ||
145 | return seq_num; | |
146 | } | |
147 | ||
148 | static void iwm_wifi_cmd_init(struct iwm_priv *iwm, | |
149 | struct iwm_wifi_cmd *cmd, | |
150 | struct iwm_udma_wifi_cmd *udma_cmd, | |
151 | struct iwm_umac_cmd *umac_cmd, | |
152 | struct iwm_lmac_cmd *lmac_cmd, | |
153 | u16 payload_size) | |
154 | { | |
155 | INIT_LIST_HEAD(&cmd->pending); | |
156 | ||
157 | spin_lock(&iwm->cmd_lock); | |
158 | ||
159 | cmd->seq_num = iwm_alloc_wifi_cmd_seq(iwm); | |
160 | umac_cmd->seq_num = cpu_to_le16(cmd->seq_num); | |
161 | ||
162 | if (umac_cmd->resp) | |
163 | list_add_tail(&cmd->pending, &iwm->wifi_pending_cmd); | |
164 | ||
165 | spin_unlock(&iwm->cmd_lock); | |
166 | ||
167 | cmd->buf.start = cmd->buf.payload; | |
168 | cmd->buf.len = 0; | |
169 | ||
170 | if (lmac_cmd) { | |
171 | cmd->buf.start -= sizeof(struct iwm_lmac_hdr); | |
172 | ||
173 | lmac_cmd->seq_num = cpu_to_le16(cmd->seq_num); | |
174 | lmac_cmd->count = cpu_to_le16(payload_size); | |
175 | ||
176 | memcpy(&cmd->lmac_cmd, lmac_cmd, sizeof(*lmac_cmd)); | |
177 | ||
178 | umac_cmd->count = cpu_to_le16(sizeof(struct iwm_lmac_hdr)); | |
179 | } else | |
180 | umac_cmd->count = 0; | |
181 | ||
182 | umac_cmd->count = cpu_to_le16(payload_size + | |
183 | le16_to_cpu(umac_cmd->count)); | |
184 | udma_cmd->count = cpu_to_le16(sizeof(struct iwm_umac_fw_cmd_hdr) + | |
185 | le16_to_cpu(umac_cmd->count)); | |
186 | ||
187 | memcpy(&cmd->udma_cmd, udma_cmd, sizeof(*udma_cmd)); | |
188 | memcpy(&cmd->umac_cmd, umac_cmd, sizeof(*umac_cmd)); | |
189 | } | |
190 | ||
191 | void iwm_cmd_flush(struct iwm_priv *iwm) | |
192 | { | |
193 | struct iwm_wifi_cmd *wcmd, *wnext; | |
194 | struct iwm_nonwifi_cmd *nwcmd, *nwnext; | |
195 | ||
196 | list_for_each_entry_safe(wcmd, wnext, &iwm->wifi_pending_cmd, pending) { | |
197 | list_del(&wcmd->pending); | |
198 | kfree(wcmd); | |
199 | } | |
200 | ||
201 | list_for_each_entry_safe(nwcmd, nwnext, &iwm->nonwifi_pending_cmd, | |
202 | pending) { | |
203 | list_del(&nwcmd->pending); | |
204 | kfree(nwcmd); | |
205 | } | |
206 | } | |
207 | ||
208 | struct iwm_wifi_cmd *iwm_get_pending_wifi_cmd(struct iwm_priv *iwm, u16 seq_num) | |
209 | { | |
210 | struct iwm_wifi_cmd *cmd, *next; | |
211 | ||
212 | list_for_each_entry_safe(cmd, next, &iwm->wifi_pending_cmd, pending) | |
213 | if (cmd->seq_num == seq_num) { | |
214 | list_del(&cmd->pending); | |
215 | return cmd; | |
216 | } | |
217 | ||
218 | return NULL; | |
219 | } | |
220 | ||
221 | struct iwm_nonwifi_cmd * | |
222 | iwm_get_pending_nonwifi_cmd(struct iwm_priv *iwm, u8 seq_num, u8 cmd_opcode) | |
223 | { | |
224 | struct iwm_nonwifi_cmd *cmd, *next; | |
225 | ||
226 | list_for_each_entry_safe(cmd, next, &iwm->nonwifi_pending_cmd, pending) | |
227 | if ((cmd->seq_num == seq_num) && | |
228 | (cmd->udma_cmd.opcode == cmd_opcode) && | |
229 | (cmd->resp_received)) { | |
230 | list_del(&cmd->pending); | |
231 | return cmd; | |
232 | } | |
233 | ||
234 | return NULL; | |
235 | } | |
236 | ||
237 | static void iwm_build_udma_nonwifi_hdr(struct iwm_priv *iwm, | |
238 | struct iwm_udma_out_nonwifi_hdr *hdr, | |
239 | struct iwm_udma_nonwifi_cmd *cmd) | |
240 | { | |
241 | memset(hdr, 0, sizeof(*hdr)); | |
242 | ||
243 | SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_OPCODE, cmd->opcode); | |
244 | SET_VAL32(hdr->cmd, UDMA_HDI_OUT_NW_CMD_RESP, cmd->resp); | |
245 | SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, 1); | |
246 | SET_VAL32(hdr->cmd, UDMA_HDI_OUT_NW_CMD_HANDLE_BY_HW, | |
247 | cmd->handle_by_hw); | |
248 | SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_SIGNATURE, UMAC_HDI_OUT_SIGNATURE); | |
249 | SET_VAL32(hdr->cmd, UDMA_HDI_OUT_CMD_NON_WIFI_HW_SEQ_NUM, | |
250 | le16_to_cpu(cmd->seq_num)); | |
251 | ||
252 | hdr->addr = cmd->addr; | |
253 | hdr->op1_sz = cmd->op1_sz; | |
254 | hdr->op2 = cmd->op2; | |
255 | } | |
256 | ||
257 | static int iwm_send_udma_nonwifi_cmd(struct iwm_priv *iwm, | |
258 | struct iwm_nonwifi_cmd *cmd) | |
259 | { | |
260 | struct iwm_udma_out_nonwifi_hdr *udma_hdr; | |
261 | struct iwm_nonwifi_cmd_buff *buf; | |
262 | struct iwm_udma_nonwifi_cmd *udma_cmd = &cmd->udma_cmd; | |
263 | ||
264 | buf = &cmd->buf; | |
265 | ||
266 | buf->start -= sizeof(struct iwm_umac_nonwifi_out_hdr); | |
267 | buf->len += sizeof(struct iwm_umac_nonwifi_out_hdr); | |
268 | ||
269 | udma_hdr = (struct iwm_udma_out_nonwifi_hdr *)(buf->start); | |
270 | ||
271 | iwm_build_udma_nonwifi_hdr(iwm, udma_hdr, udma_cmd); | |
272 | ||
273 | IWM_DBG_CMD(iwm, DBG, | |
274 | "Send UDMA nonwifi cmd: opcode = 0x%x, resp = 0x%x, " | |
275 | "hw = 0x%x, seqnum = %d, addr = 0x%x, op1_sz = 0x%x, " | |
276 | "op2 = 0x%x\n", udma_cmd->opcode, udma_cmd->resp, | |
277 | udma_cmd->handle_by_hw, cmd->seq_num, udma_cmd->addr, | |
278 | udma_cmd->op1_sz, udma_cmd->op2); | |
279 | ||
280 | return iwm_bus_send_chunk(iwm, buf->start, buf->len); | |
281 | } | |
282 | ||
283 | void iwm_udma_wifi_hdr_set_eop(struct iwm_priv *iwm, u8 *buf, u8 eop) | |
284 | { | |
285 | struct iwm_udma_out_wifi_hdr *hdr = (struct iwm_udma_out_wifi_hdr *)buf; | |
286 | ||
287 | SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, eop); | |
288 | } | |
289 | ||
290 | void iwm_build_udma_wifi_hdr(struct iwm_priv *iwm, | |
291 | struct iwm_udma_out_wifi_hdr *hdr, | |
292 | struct iwm_udma_wifi_cmd *cmd) | |
293 | { | |
294 | memset(hdr, 0, sizeof(*hdr)); | |
295 | ||
296 | SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_OPCODE, UMAC_HDI_OUT_OPCODE_WIFI); | |
297 | SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, cmd->eop); | |
298 | SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_SIGNATURE, UMAC_HDI_OUT_SIGNATURE); | |
299 | ||
300 | SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_BYTE_COUNT, | |
301 | le16_to_cpu(cmd->count)); | |
302 | SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_CREDIT_GRP, cmd->credit_group); | |
303 | SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_RATID, cmd->ra_tid); | |
304 | SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_LMAC_OFFSET, cmd->lmac_offset); | |
305 | } | |
306 | ||
307 | void iwm_build_umac_hdr(struct iwm_priv *iwm, | |
308 | struct iwm_umac_fw_cmd_hdr *hdr, | |
309 | struct iwm_umac_cmd *cmd) | |
310 | { | |
311 | memset(hdr, 0, sizeof(*hdr)); | |
312 | ||
313 | SET_VAL32(hdr->meta_data, UMAC_FW_CMD_BYTE_COUNT, | |
314 | le16_to_cpu(cmd->count)); | |
315 | SET_VAL32(hdr->meta_data, UMAC_FW_CMD_TX_STA_COLOR, cmd->color); | |
316 | SET_VAL8(hdr->cmd.flags, UMAC_DEV_CMD_FLAGS_RESP_REQ, cmd->resp); | |
317 | ||
318 | hdr->cmd.cmd = cmd->id; | |
319 | hdr->cmd.seq_num = cmd->seq_num; | |
320 | } | |
321 | ||
322 | static int iwm_send_udma_wifi_cmd(struct iwm_priv *iwm, | |
323 | struct iwm_wifi_cmd *cmd) | |
324 | { | |
325 | struct iwm_umac_wifi_out_hdr *umac_hdr; | |
326 | struct iwm_wifi_cmd_buff *buf; | |
327 | struct iwm_udma_wifi_cmd *udma_cmd = &cmd->udma_cmd; | |
328 | struct iwm_umac_cmd *umac_cmd = &cmd->umac_cmd; | |
329 | int ret; | |
330 | ||
331 | buf = &cmd->buf; | |
332 | ||
333 | buf->start -= sizeof(struct iwm_umac_wifi_out_hdr); | |
334 | buf->len += sizeof(struct iwm_umac_wifi_out_hdr); | |
335 | ||
336 | umac_hdr = (struct iwm_umac_wifi_out_hdr *)(buf->start); | |
337 | ||
338 | iwm_build_udma_wifi_hdr(iwm, &umac_hdr->hw_hdr, udma_cmd); | |
339 | iwm_build_umac_hdr(iwm, &umac_hdr->sw_hdr, umac_cmd); | |
340 | ||
341 | IWM_DBG_CMD(iwm, DBG, | |
342 | "Send UDMA wifi cmd: opcode = 0x%x, UMAC opcode = 0x%x, " | |
343 | "eop = 0x%x, count = 0x%x, credit_group = 0x%x, " | |
344 | "ra_tid = 0x%x, lmac_offset = 0x%x, seqnum = %d\n", | |
345 | UMAC_HDI_OUT_OPCODE_WIFI, umac_cmd->id, | |
346 | udma_cmd->eop, udma_cmd->count, udma_cmd->credit_group, | |
347 | udma_cmd->ra_tid, udma_cmd->lmac_offset, cmd->seq_num); | |
348 | ||
349 | if (umac_cmd->id == UMAC_CMD_OPCODE_WIFI_PASS_THROUGH) | |
350 | IWM_DBG_CMD(iwm, DBG, "\tLMAC opcode: 0x%x\n", | |
351 | cmd->lmac_cmd.id); | |
352 | ||
353 | ret = iwm_tx_credit_alloc(iwm, udma_cmd->credit_group, buf->len); | |
354 | ||
355 | /* We keep sending UMAC reset regardless of the command credits. | |
356 | * The UMAC is supposed to be reset anyway and the Tx credits are | |
357 | * reinitialized afterwards. If we are lucky, the reset could | |
358 | * still be done even though we have run out of credits for the | |
359 | * command pool at this moment.*/ | |
360 | if (ret && (umac_cmd->id != UMAC_CMD_OPCODE_RESET)) { | |
361 | IWM_DBG_TX(iwm, DBG, "Failed to alloc tx credit for cmd %d\n", | |
362 | umac_cmd->id); | |
363 | return ret; | |
364 | } | |
365 | ||
366 | return iwm_bus_send_chunk(iwm, buf->start, buf->len); | |
367 | } | |
368 | ||
369 | /* target_cmd a.k.a udma_nonwifi_cmd can be sent when UMAC is not available */ | |
370 | int iwm_hal_send_target_cmd(struct iwm_priv *iwm, | |
371 | struct iwm_udma_nonwifi_cmd *udma_cmd, | |
372 | const void *payload) | |
373 | { | |
374 | struct iwm_nonwifi_cmd *cmd; | |
971ad011 | 375 | int ret, seq_num; |
bb9f8692 ZY |
376 | |
377 | cmd = kzalloc(sizeof(struct iwm_nonwifi_cmd), GFP_KERNEL); | |
378 | if (!cmd) { | |
379 | IWM_ERR(iwm, "Couldn't alloc memory for hal cmd\n"); | |
380 | return -ENOMEM; | |
381 | } | |
382 | ||
971ad011 | 383 | seq_num = iwm_nonwifi_cmd_init(iwm, cmd, udma_cmd); |
bb9f8692 ZY |
384 | |
385 | if (cmd->udma_cmd.opcode == UMAC_HDI_OUT_OPCODE_WRITE || | |
386 | cmd->udma_cmd.opcode == UMAC_HDI_OUT_OPCODE_WRITE_PERSISTENT) { | |
387 | cmd->buf.len = le32_to_cpu(cmd->udma_cmd.op1_sz); | |
388 | memcpy(&cmd->buf.payload, payload, cmd->buf.len); | |
389 | } | |
390 | ||
391 | ret = iwm_send_udma_nonwifi_cmd(iwm, cmd); | |
392 | ||
393 | if (!udma_cmd->resp) | |
394 | kfree(cmd); | |
395 | ||
396 | if (ret < 0) | |
397 | return ret; | |
398 | ||
971ad011 | 399 | return seq_num; |
bb9f8692 ZY |
400 | } |
401 | ||
402 | static void iwm_build_lmac_hdr(struct iwm_priv *iwm, struct iwm_lmac_hdr *hdr, | |
403 | struct iwm_lmac_cmd *cmd) | |
404 | { | |
405 | memset(hdr, 0, sizeof(*hdr)); | |
406 | ||
407 | hdr->id = cmd->id; | |
408 | hdr->flags = 0; /* Is this ever used? */ | |
409 | hdr->seq_num = cmd->seq_num; | |
410 | } | |
411 | ||
412 | /* | |
413 | * iwm_hal_send_host_cmd(): sends commands to the UMAC or the LMAC. | |
414 | * Sending command to the LMAC is equivalent to sending a | |
af901ca1 | 415 | * regular UMAC command with the LMAC passthrough or the LMAC |
bb9f8692 ZY |
416 | * wrapper UMAC command IDs. |
417 | */ | |
418 | int iwm_hal_send_host_cmd(struct iwm_priv *iwm, | |
419 | struct iwm_udma_wifi_cmd *udma_cmd, | |
420 | struct iwm_umac_cmd *umac_cmd, | |
421 | struct iwm_lmac_cmd *lmac_cmd, | |
422 | const void *payload, u16 payload_size) | |
423 | { | |
424 | struct iwm_wifi_cmd *cmd; | |
425 | struct iwm_lmac_hdr *hdr; | |
426 | int lmac_hdr_len = 0; | |
427 | int ret; | |
428 | ||
429 | cmd = kzalloc(sizeof(struct iwm_wifi_cmd), GFP_KERNEL); | |
430 | if (!cmd) { | |
431 | IWM_ERR(iwm, "Couldn't alloc memory for wifi hal cmd\n"); | |
432 | return -ENOMEM; | |
433 | } | |
434 | ||
435 | iwm_wifi_cmd_init(iwm, cmd, udma_cmd, umac_cmd, lmac_cmd, payload_size); | |
436 | ||
437 | if (lmac_cmd) { | |
438 | hdr = (struct iwm_lmac_hdr *)(cmd->buf.start); | |
439 | ||
440 | iwm_build_lmac_hdr(iwm, hdr, &cmd->lmac_cmd); | |
441 | lmac_hdr_len = sizeof(struct iwm_lmac_hdr); | |
442 | } | |
443 | ||
444 | memcpy(cmd->buf.payload, payload, payload_size); | |
445 | cmd->buf.len = le16_to_cpu(umac_cmd->count); | |
446 | ||
447 | ret = iwm_send_udma_wifi_cmd(iwm, cmd); | |
448 | ||
449 | /* We free the cmd if we're not expecting any response */ | |
450 | if (!umac_cmd->resp) | |
451 | kfree(cmd); | |
452 | return ret; | |
453 | } | |
454 | ||
455 | /* | |
456 | * iwm_hal_send_umac_cmd(): This is a special case for | |
457 | * iwm_hal_send_host_cmd() to send direct UMAC cmd (without | |
458 | * LMAC involved). | |
459 | */ | |
460 | int iwm_hal_send_umac_cmd(struct iwm_priv *iwm, | |
461 | struct iwm_udma_wifi_cmd *udma_cmd, | |
462 | struct iwm_umac_cmd *umac_cmd, | |
463 | const void *payload, u16 payload_size) | |
464 | { | |
465 | return iwm_hal_send_host_cmd(iwm, udma_cmd, umac_cmd, NULL, | |
466 | payload, payload_size); | |
467 | } |