iwl-trans.h 39 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228
  1. /******************************************************************************
  2. *
  3. * This file is provided under a dual BSD/GPLv2 license. When using or
  4. * redistributing this file, you may do so under either license.
  5. *
  6. * GPL LICENSE SUMMARY
  7. *
  8. * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved.
  9. * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  10. *
  11. * This program is free software; you can redistribute it and/or modify
  12. * it under the terms of version 2 of the GNU General Public License as
  13. * published by the Free Software Foundation.
  14. *
  15. * This program is distributed in the hope that it will be useful, but
  16. * WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18. * General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  23. * USA
  24. *
  25. * The full GNU General Public License is included in this distribution
  26. * in the file called COPYING.
  27. *
  28. * Contact Information:
  29. * Intel Linux Wireless <linuxwifi@intel.com>
  30. * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  31. *
  32. * BSD LICENSE
  33. *
  34. * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  35. * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  36. * All rights reserved.
  37. *
  38. * Redistribution and use in source and binary forms, with or without
  39. * modification, are permitted provided that the following conditions
  40. * are met:
  41. *
  42. * * Redistributions of source code must retain the above copyright
  43. * notice, this list of conditions and the following disclaimer.
  44. * * Redistributions in binary form must reproduce the above copyright
  45. * notice, this list of conditions and the following disclaimer in
  46. * the documentation and/or other materials provided with the
  47. * distribution.
  48. * * Neither the name Intel Corporation nor the names of its
  49. * contributors may be used to endorse or promote products derived
  50. * from this software without specific prior written permission.
  51. *
  52. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  53. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  54. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  55. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  56. * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  57. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  58. * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  59. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  60. * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  61. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  62. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  63. *
  64. *****************************************************************************/
  65. #ifndef __iwl_trans_h__
  66. #define __iwl_trans_h__
  67. #include <linux/ieee80211.h>
  68. #include <linux/mm.h> /* for page_address */
  69. #include <linux/lockdep.h>
  70. #include <linux/kernel.h>
  71. #include "iwl-debug.h"
  72. #include "iwl-config.h"
  73. #include "iwl-fw.h"
  74. #include "iwl-op-mode.h"
  75. /**
  76. * DOC: Transport layer - what is it ?
  77. *
  78. * The transport layer is the layer that deals with the HW directly. It provides
  79. * an abstraction of the underlying HW to the upper layer. The transport layer
  80. * doesn't provide any policy, algorithm or anything of this kind, but only
  81. * mechanisms to make the HW do something. It is not completely stateless but
  82. * close to it.
  83. * We will have an implementation for each different supported bus.
  84. */
  85. /**
  86. * DOC: Life cycle of the transport layer
  87. *
  88. * The transport layer has a very precise life cycle.
  89. *
  90. * 1) A helper function is called during the module initialization and
  91. * registers the bus driver's ops with the transport's alloc function.
  92. * 2) Bus's probe calls to the transport layer's allocation functions.
  93. * Of course this function is bus specific.
  94. * 3) This allocation functions will spawn the upper layer which will
  95. * register mac80211.
  96. *
  97. * 4) At some point (i.e. mac80211's start call), the op_mode will call
  98. * the following sequence:
  99. * start_hw
  100. * start_fw
  101. *
  102. * 5) Then when finished (or reset):
  103. * stop_device
  104. *
  105. * 6) Eventually, the free function will be called.
  106. */
  107. /**
  108. * DOC: Host command section
  109. *
  110. * A host command is a command issued by the upper layer to the fw. There are
  111. * several versions of fw that have several APIs. The transport layer is
  112. * completely agnostic to these differences.
  113. * The transport does provide helper functionality (i.e. SYNC / ASYNC mode),
  114. */
  115. #define SEQ_TO_QUEUE(s) (((s) >> 8) & 0x1f)
  116. #define QUEUE_TO_SEQ(q) (((q) & 0x1f) << 8)
  117. #define SEQ_TO_INDEX(s) ((s) & 0xff)
  118. #define INDEX_TO_SEQ(i) ((i) & 0xff)
  119. #define SEQ_RX_FRAME cpu_to_le16(0x8000)
  120. /*
  121. * those functions retrieve specific information from
  122. * the id field in the iwl_host_cmd struct which contains
  123. * the command id, the group id and the version of the command
  124. * and vice versa
  125. */
  126. static inline u8 iwl_cmd_opcode(u32 cmdid)
  127. {
  128. return cmdid & 0xFF;
  129. }
  130. static inline u8 iwl_cmd_groupid(u32 cmdid)
  131. {
  132. return ((cmdid & 0xFF00) >> 8);
  133. }
  134. static inline u8 iwl_cmd_version(u32 cmdid)
  135. {
  136. return ((cmdid & 0xFF0000) >> 16);
  137. }
  138. static inline u32 iwl_cmd_id(u8 opcode, u8 groupid, u8 version)
  139. {
  140. return opcode + (groupid << 8) + (version << 16);
  141. }
  142. /* make u16 wide id out of u8 group and opcode */
  143. #define WIDE_ID(grp, opcode) ((grp << 8) | opcode)
  144. /* due to the conversion, this group is special; new groups
  145. * should be defined in the appropriate fw-api header files
  146. */
  147. #define IWL_ALWAYS_LONG_GROUP 1
  148. /**
  149. * struct iwl_cmd_header
  150. *
  151. * This header format appears in the beginning of each command sent from the
  152. * driver, and each response/notification received from uCode.
  153. */
  154. struct iwl_cmd_header {
  155. u8 cmd; /* Command ID: REPLY_RXON, etc. */
  156. u8 group_id;
  157. /*
  158. * The driver sets up the sequence number to values of its choosing.
  159. * uCode does not use this value, but passes it back to the driver
  160. * when sending the response to each driver-originated command, so
  161. * the driver can match the response to the command. Since the values
  162. * don't get used by uCode, the driver may set up an arbitrary format.
  163. *
  164. * There is one exception: uCode sets bit 15 when it originates
  165. * the response/notification, i.e. when the response/notification
  166. * is not a direct response to a command sent by the driver. For
  167. * example, uCode issues REPLY_RX when it sends a received frame
  168. * to the driver; it is not a direct response to any driver command.
  169. *
  170. * The Linux driver uses the following format:
  171. *
  172. * 0:7 tfd index - position within TX queue
  173. * 8:12 TX queue id
  174. * 13:14 reserved
  175. * 15 unsolicited RX or uCode-originated notification
  176. */
  177. __le16 sequence;
  178. } __packed;
  179. /**
  180. * struct iwl_cmd_header_wide
  181. *
  182. * This header format appears in the beginning of each command sent from the
  183. * driver, and each response/notification received from uCode.
  184. * this is the wide version that contains more information about the command
  185. * like length, version and command type
  186. */
  187. struct iwl_cmd_header_wide {
  188. u8 cmd;
  189. u8 group_id;
  190. __le16 sequence;
  191. __le16 length;
  192. u8 reserved;
  193. u8 version;
  194. } __packed;
  195. #define FH_RSCSR_FRAME_SIZE_MSK 0x00003FFF /* bits 0-13 */
  196. #define FH_RSCSR_FRAME_INVALID 0x55550000
  197. #define FH_RSCSR_FRAME_ALIGN 0x40
  198. struct iwl_rx_packet {
  199. /*
  200. * The first 4 bytes of the RX frame header contain both the RX frame
  201. * size and some flags.
  202. * Bit fields:
  203. * 31: flag flush RB request
  204. * 30: flag ignore TC (terminal counter) request
  205. * 29: flag fast IRQ request
  206. * 28-14: Reserved
  207. * 13-00: RX frame size
  208. */
  209. __le32 len_n_flags;
  210. struct iwl_cmd_header hdr;
  211. u8 data[];
  212. } __packed;
  213. static inline u32 iwl_rx_packet_len(const struct iwl_rx_packet *pkt)
  214. {
  215. return le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
  216. }
  217. static inline u32 iwl_rx_packet_payload_len(const struct iwl_rx_packet *pkt)
  218. {
  219. return iwl_rx_packet_len(pkt) - sizeof(pkt->hdr);
  220. }
  221. /**
  222. * enum CMD_MODE - how to send the host commands ?
  223. *
  224. * @CMD_ASYNC: Return right away and don't wait for the response
  225. * @CMD_WANT_SKB: Not valid with CMD_ASYNC. The caller needs the buffer of
  226. * the response. The caller needs to call iwl_free_resp when done.
  227. * @CMD_HIGH_PRIO: The command is high priority - it goes to the front of the
  228. * command queue, but after other high priority commands. Valid only
  229. * with CMD_ASYNC.
  230. * @CMD_SEND_IN_IDLE: The command should be sent even when the trans is idle.
  231. * @CMD_MAKE_TRANS_IDLE: The command response should mark the trans as idle.
  232. * @CMD_WAKE_UP_TRANS: The command response should wake up the trans
  233. * (i.e. mark it as non-idle).
  234. * @CMD_WANT_ASYNC_CALLBACK: the op_mode's async callback function must be
  235. * called after this command completes. Valid only with CMD_ASYNC.
  236. * @CMD_TB_BITMAP_POS: Position of the first bit for the TB bitmap. We need to
  237. * check that we leave enough room for the TBs bitmap which needs 20 bits.
  238. */
  239. enum CMD_MODE {
  240. CMD_ASYNC = BIT(0),
  241. CMD_WANT_SKB = BIT(1),
  242. CMD_SEND_IN_RFKILL = BIT(2),
  243. CMD_HIGH_PRIO = BIT(3),
  244. CMD_SEND_IN_IDLE = BIT(4),
  245. CMD_MAKE_TRANS_IDLE = BIT(5),
  246. CMD_WAKE_UP_TRANS = BIT(6),
  247. CMD_WANT_ASYNC_CALLBACK = BIT(7),
  248. CMD_TB_BITMAP_POS = 11,
  249. };
  250. #define DEF_CMD_PAYLOAD_SIZE 320
  251. /**
  252. * struct iwl_device_cmd
  253. *
  254. * For allocation of the command and tx queues, this establishes the overall
  255. * size of the largest command we send to uCode, except for commands that
  256. * aren't fully copied and use other TFD space.
  257. */
  258. struct iwl_device_cmd {
  259. union {
  260. struct {
  261. struct iwl_cmd_header hdr; /* uCode API */
  262. u8 payload[DEF_CMD_PAYLOAD_SIZE];
  263. };
  264. struct {
  265. struct iwl_cmd_header_wide hdr_wide;
  266. u8 payload_wide[DEF_CMD_PAYLOAD_SIZE -
  267. sizeof(struct iwl_cmd_header_wide) +
  268. sizeof(struct iwl_cmd_header)];
  269. };
  270. };
  271. } __packed;
  272. #define TFD_MAX_PAYLOAD_SIZE (sizeof(struct iwl_device_cmd))
  273. /*
  274. * number of transfer buffers (fragments) per transmit frame descriptor;
  275. * this is just the driver's idea, the hardware supports 20
  276. */
  277. #define IWL_MAX_CMD_TBS_PER_TFD 2
  278. /**
  279. * struct iwl_hcmd_dataflag - flag for each one of the chunks of the command
  280. *
  281. * @IWL_HCMD_DFL_NOCOPY: By default, the command is copied to the host command's
  282. * ring. The transport layer doesn't map the command's buffer to DMA, but
  283. * rather copies it to a previously allocated DMA buffer. This flag tells
  284. * the transport layer not to copy the command, but to map the existing
  285. * buffer (that is passed in) instead. This saves the memcpy and allows
  286. * commands that are bigger than the fixed buffer to be submitted.
  287. * Note that a TFD entry after a NOCOPY one cannot be a normal copied one.
  288. * @IWL_HCMD_DFL_DUP: Only valid without NOCOPY, duplicate the memory for this
  289. * chunk internally and free it again after the command completes. This
  290. * can (currently) be used only once per command.
  291. * Note that a TFD entry after a DUP one cannot be a normal copied one.
  292. */
  293. enum iwl_hcmd_dataflag {
  294. IWL_HCMD_DFL_NOCOPY = BIT(0),
  295. IWL_HCMD_DFL_DUP = BIT(1),
  296. };
  297. /**
  298. * struct iwl_host_cmd - Host command to the uCode
  299. *
  300. * @data: array of chunks that composes the data of the host command
  301. * @resp_pkt: response packet, if %CMD_WANT_SKB was set
  302. * @_rx_page_order: (internally used to free response packet)
  303. * @_rx_page_addr: (internally used to free response packet)
  304. * @flags: can be CMD_*
  305. * @len: array of the lengths of the chunks in data
  306. * @dataflags: IWL_HCMD_DFL_*
  307. * @id: command id of the host command, for wide commands encoding the
  308. * version and group as well
  309. */
  310. struct iwl_host_cmd {
  311. const void *data[IWL_MAX_CMD_TBS_PER_TFD];
  312. struct iwl_rx_packet *resp_pkt;
  313. unsigned long _rx_page_addr;
  314. u32 _rx_page_order;
  315. u32 flags;
  316. u32 id;
  317. u16 len[IWL_MAX_CMD_TBS_PER_TFD];
  318. u8 dataflags[IWL_MAX_CMD_TBS_PER_TFD];
  319. };
  320. static inline void iwl_free_resp(struct iwl_host_cmd *cmd)
  321. {
  322. free_pages(cmd->_rx_page_addr, cmd->_rx_page_order);
  323. }
  324. struct iwl_rx_cmd_buffer {
  325. struct page *_page;
  326. int _offset;
  327. bool _page_stolen;
  328. u32 _rx_page_order;
  329. unsigned int truesize;
  330. };
  331. static inline void *rxb_addr(struct iwl_rx_cmd_buffer *r)
  332. {
  333. return (void *)((unsigned long)page_address(r->_page) + r->_offset);
  334. }
  335. static inline int rxb_offset(struct iwl_rx_cmd_buffer *r)
  336. {
  337. return r->_offset;
  338. }
  339. static inline struct page *rxb_steal_page(struct iwl_rx_cmd_buffer *r)
  340. {
  341. r->_page_stolen = true;
  342. get_page(r->_page);
  343. return r->_page;
  344. }
  345. static inline void iwl_free_rxb(struct iwl_rx_cmd_buffer *r)
  346. {
  347. __free_pages(r->_page, r->_rx_page_order);
  348. }
  349. #define MAX_NO_RECLAIM_CMDS 6
  350. /*
  351. * The first entry in driver_data array in ieee80211_tx_info
  352. * that can be used by the transport.
  353. */
  354. #define IWL_TRANS_FIRST_DRIVER_DATA 2
  355. #define IWL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo))))
  356. /*
  357. * Maximum number of HW queues the transport layer
  358. * currently supports
  359. */
  360. #define IWL_MAX_HW_QUEUES 32
  361. #define IWL_MAX_TID_COUNT 8
  362. #define IWL_FRAME_LIMIT 64
  363. #define IWL_MAX_RX_HW_QUEUES 16
  364. /**
  365. * enum iwl_wowlan_status - WoWLAN image/device status
  366. * @IWL_D3_STATUS_ALIVE: firmware is still running after resume
  367. * @IWL_D3_STATUS_RESET: device was reset while suspended
  368. */
  369. enum iwl_d3_status {
  370. IWL_D3_STATUS_ALIVE,
  371. IWL_D3_STATUS_RESET,
  372. };
  373. /**
  374. * enum iwl_trans_status: transport status flags
  375. * @STATUS_SYNC_HCMD_ACTIVE: a SYNC command is being processed
  376. * @STATUS_DEVICE_ENABLED: APM is enabled
  377. * @STATUS_TPOWER_PMI: the device might be asleep (need to wake it up)
  378. * @STATUS_INT_ENABLED: interrupts are enabled
  379. * @STATUS_RFKILL: the HW RFkill switch is in KILL position
  380. * @STATUS_FW_ERROR: the fw is in error state
  381. * @STATUS_TRANS_GOING_IDLE: shutting down the trans, only special commands
  382. * are sent
  383. * @STATUS_TRANS_IDLE: the trans is idle - general commands are not to be sent
  384. * @STATUS_TRANS_DEAD: trans is dead - avoid any read/write operation
  385. */
  386. enum iwl_trans_status {
  387. STATUS_SYNC_HCMD_ACTIVE,
  388. STATUS_DEVICE_ENABLED,
  389. STATUS_TPOWER_PMI,
  390. STATUS_INT_ENABLED,
  391. STATUS_RFKILL,
  392. STATUS_FW_ERROR,
  393. STATUS_TRANS_GOING_IDLE,
  394. STATUS_TRANS_IDLE,
  395. STATUS_TRANS_DEAD,
  396. };
  397. static inline int
  398. iwl_trans_get_rb_size_order(enum iwl_amsdu_size rb_size)
  399. {
  400. switch (rb_size) {
  401. case IWL_AMSDU_4K:
  402. return get_order(4 * 1024);
  403. case IWL_AMSDU_8K:
  404. return get_order(8 * 1024);
  405. case IWL_AMSDU_12K:
  406. return get_order(12 * 1024);
  407. default:
  408. WARN_ON(1);
  409. return -1;
  410. }
  411. }
  412. struct iwl_hcmd_names {
  413. u8 cmd_id;
  414. const char *const cmd_name;
  415. };
  416. #define HCMD_NAME(x) \
  417. { .cmd_id = x, .cmd_name = #x }
  418. struct iwl_hcmd_arr {
  419. const struct iwl_hcmd_names *arr;
  420. int size;
  421. };
  422. #define HCMD_ARR(x) \
  423. { .arr = x, .size = ARRAY_SIZE(x) }
  424. /**
  425. * struct iwl_trans_config - transport configuration
  426. *
  427. * @op_mode: pointer to the upper layer.
  428. * @cmd_queue: the index of the command queue.
  429. * Must be set before start_fw.
  430. * @cmd_fifo: the fifo for host commands
  431. * @cmd_q_wdg_timeout: the timeout of the watchdog timer for the command queue.
  432. * @no_reclaim_cmds: Some devices erroneously don't set the
  433. * SEQ_RX_FRAME bit on some notifications, this is the
  434. * list of such notifications to filter. Max length is
  435. * %MAX_NO_RECLAIM_CMDS.
  436. * @n_no_reclaim_cmds: # of commands in list
  437. * @rx_buf_size: RX buffer size needed for A-MSDUs
  438. * if unset 4k will be the RX buffer size
  439. * @bc_table_dword: set to true if the BC table expects the byte count to be
  440. * in DWORD (as opposed to bytes)
  441. * @scd_set_active: should the transport configure the SCD for HCMD queue
  442. * @wide_cmd_header: firmware supports wide host command header
  443. * @sw_csum_tx: transport should compute the TCP checksum
  444. * @command_groups: array of command groups, each member is an array of the
  445. * commands in the group; for debugging only
  446. * @command_groups_size: number of command groups, to avoid illegal access
  447. * @sdio_adma_addr: the default address to set for the ADMA in SDIO mode until
  448. * we get the ALIVE from the uCode
  449. */
  450. struct iwl_trans_config {
  451. struct iwl_op_mode *op_mode;
  452. u8 cmd_queue;
  453. u8 cmd_fifo;
  454. unsigned int cmd_q_wdg_timeout;
  455. const u8 *no_reclaim_cmds;
  456. unsigned int n_no_reclaim_cmds;
  457. enum iwl_amsdu_size rx_buf_size;
  458. bool bc_table_dword;
  459. bool scd_set_active;
  460. bool wide_cmd_header;
  461. bool sw_csum_tx;
  462. const struct iwl_hcmd_arr *command_groups;
  463. int command_groups_size;
  464. u32 sdio_adma_addr;
  465. };
  466. struct iwl_trans_dump_data {
  467. u32 len;
  468. u8 data[];
  469. };
  470. struct iwl_trans;
  471. struct iwl_trans_txq_scd_cfg {
  472. u8 fifo;
  473. s8 sta_id;
  474. u8 tid;
  475. bool aggregate;
  476. int frame_limit;
  477. };
  478. /**
  479. * struct iwl_trans_ops - transport specific operations
  480. *
  481. * All the handlers MUST be implemented
  482. *
  483. * @start_hw: starts the HW. If low_power is true, the NIC needs to be taken
  484. * out of a low power state. From that point on, the HW can send
  485. * interrupts. May sleep.
  486. * @op_mode_leave: Turn off the HW RF kill indication if on
  487. * May sleep
  488. * @start_fw: allocates and inits all the resources for the transport
  489. * layer. Also kick a fw image.
  490. * May sleep
  491. * @fw_alive: called when the fw sends alive notification. If the fw provides
  492. * the SCD base address in SRAM, then provide it here, or 0 otherwise.
  493. * May sleep
  494. * @stop_device: stops the whole device (embedded CPU put to reset) and stops
  495. * the HW. If low_power is true, the NIC will be put in low power state.
  496. * From that point on, the HW will be stopped but will still issue an
  497. * interrupt if the HW RF kill switch is triggered.
  498. * This callback must do the right thing and not crash even if %start_hw()
  499. * was called but not &start_fw(). May sleep.
  500. * @d3_suspend: put the device into the correct mode for WoWLAN during
  501. * suspend. This is optional, if not implemented WoWLAN will not be
  502. * supported. This callback may sleep.
  503. * @d3_resume: resume the device after WoWLAN, enabling the opmode to
  504. * talk to the WoWLAN image to get its status. This is optional, if not
  505. * implemented WoWLAN will not be supported. This callback may sleep.
  506. * @send_cmd:send a host command. Must return -ERFKILL if RFkill is asserted.
  507. * If RFkill is asserted in the middle of a SYNC host command, it must
  508. * return -ERFKILL straight away.
  509. * May sleep only if CMD_ASYNC is not set
  510. * @tx: send an skb. The transport relies on the op_mode to zero the
  511. * the ieee80211_tx_info->driver_data. If the MPDU is an A-MSDU, all
  512. * the CSUM will be taken care of (TCP CSUM and IP header in case of
  513. * IPv4). If the MPDU is a single MSDU, the op_mode must compute the IP
  514. * header if it is IPv4.
  515. * Must be atomic
  516. * @reclaim: free packet until ssn. Returns a list of freed packets.
  517. * Must be atomic
  518. * @txq_enable: setup a queue. To setup an AC queue, use the
  519. * iwl_trans_ac_txq_enable wrapper. fw_alive must have been called before
  520. * this one. The op_mode must not configure the HCMD queue. The scheduler
  521. * configuration may be %NULL, in which case the hardware will not be
  522. * configured. May sleep.
  523. * @txq_disable: de-configure a Tx queue to send AMPDUs
  524. * Must be atomic
  525. * @wait_tx_queue_empty: wait until tx queues are empty. May sleep.
  526. * @freeze_txq_timer: prevents the timer of the queue from firing until the
  527. * queue is set to awake. Must be atomic.
  528. * @block_txq_ptrs: stop updating the write pointers of the Tx queues. Note
  529. * that the transport needs to refcount the calls since this function
  530. * will be called several times with block = true, and then the queues
  531. * need to be unblocked only after the same number of calls with
  532. * block = false.
  533. * @write8: write a u8 to a register at offset ofs from the BAR
  534. * @write32: write a u32 to a register at offset ofs from the BAR
  535. * @read32: read a u32 register at offset ofs from the BAR
  536. * @read_prph: read a DWORD from a periphery register
  537. * @write_prph: write a DWORD to a periphery register
  538. * @read_mem: read device's SRAM in DWORD
  539. * @write_mem: write device's SRAM in DWORD. If %buf is %NULL, then the memory
  540. * will be zeroed.
  541. * @configure: configure parameters required by the transport layer from
  542. * the op_mode. May be called several times before start_fw, can't be
  543. * called after that.
  544. * @set_pmi: set the power pmi state
  545. * @grab_nic_access: wake the NIC to be able to access non-HBUS regs.
  546. * Sleeping is not allowed between grab_nic_access and
  547. * release_nic_access.
  548. * @release_nic_access: let the NIC go to sleep. The "flags" parameter
  549. * must be the same one that was sent before to the grab_nic_access.
  550. * @set_bits_mask - set SRAM register according to value and mask.
  551. * @ref: grab a reference to the transport/FW layers, disallowing
  552. * certain low power states
  553. * @unref: release a reference previously taken with @ref. Note that
  554. * initially the reference count is 1, making an initial @unref
  555. * necessary to allow low power states.
  556. * @dump_data: return a vmalloc'ed buffer with debug data, maybe containing last
  557. * TX'ed commands and similar. The buffer will be vfree'd by the caller.
  558. * Note that the transport must fill in the proper file headers.
  559. */
  560. struct iwl_trans_ops {
  561. int (*start_hw)(struct iwl_trans *iwl_trans, bool low_power);
  562. void (*op_mode_leave)(struct iwl_trans *iwl_trans);
  563. int (*start_fw)(struct iwl_trans *trans, const struct fw_img *fw,
  564. bool run_in_rfkill);
  565. int (*update_sf)(struct iwl_trans *trans,
  566. struct iwl_sf_region *st_fwrd_space);
  567. void (*fw_alive)(struct iwl_trans *trans, u32 scd_addr);
  568. void (*stop_device)(struct iwl_trans *trans, bool low_power);
  569. void (*d3_suspend)(struct iwl_trans *trans, bool test, bool reset);
  570. int (*d3_resume)(struct iwl_trans *trans, enum iwl_d3_status *status,
  571. bool test, bool reset);
  572. int (*send_cmd)(struct iwl_trans *trans, struct iwl_host_cmd *cmd);
  573. int (*tx)(struct iwl_trans *trans, struct sk_buff *skb,
  574. struct iwl_device_cmd *dev_cmd, int queue);
  575. void (*reclaim)(struct iwl_trans *trans, int queue, int ssn,
  576. struct sk_buff_head *skbs);
  577. void (*txq_enable)(struct iwl_trans *trans, int queue, u16 ssn,
  578. const struct iwl_trans_txq_scd_cfg *cfg,
  579. unsigned int queue_wdg_timeout);
  580. void (*txq_disable)(struct iwl_trans *trans, int queue,
  581. bool configure_scd);
  582. int (*wait_tx_queue_empty)(struct iwl_trans *trans, u32 txq_bm);
  583. void (*freeze_txq_timer)(struct iwl_trans *trans, unsigned long txqs,
  584. bool freeze);
  585. void (*block_txq_ptrs)(struct iwl_trans *trans, bool block);
  586. void (*write8)(struct iwl_trans *trans, u32 ofs, u8 val);
  587. void (*write32)(struct iwl_trans *trans, u32 ofs, u32 val);
  588. u32 (*read32)(struct iwl_trans *trans, u32 ofs);
  589. u32 (*read_prph)(struct iwl_trans *trans, u32 ofs);
  590. void (*write_prph)(struct iwl_trans *trans, u32 ofs, u32 val);
  591. int (*read_mem)(struct iwl_trans *trans, u32 addr,
  592. void *buf, int dwords);
  593. int (*write_mem)(struct iwl_trans *trans, u32 addr,
  594. const void *buf, int dwords);
  595. void (*configure)(struct iwl_trans *trans,
  596. const struct iwl_trans_config *trans_cfg);
  597. void (*set_pmi)(struct iwl_trans *trans, bool state);
  598. bool (*grab_nic_access)(struct iwl_trans *trans, unsigned long *flags);
  599. void (*release_nic_access)(struct iwl_trans *trans,
  600. unsigned long *flags);
  601. void (*set_bits_mask)(struct iwl_trans *trans, u32 reg, u32 mask,
  602. u32 value);
  603. void (*ref)(struct iwl_trans *trans);
  604. void (*unref)(struct iwl_trans *trans);
  605. int (*suspend)(struct iwl_trans *trans);
  606. void (*resume)(struct iwl_trans *trans);
  607. struct iwl_trans_dump_data *(*dump_data)(struct iwl_trans *trans,
  608. const struct iwl_fw_dbg_trigger_tlv
  609. *trigger);
  610. };
  611. /**
  612. * enum iwl_trans_state - state of the transport layer
  613. *
  614. * @IWL_TRANS_NO_FW: no fw has sent an alive response
  615. * @IWL_TRANS_FW_ALIVE: a fw has sent an alive response
  616. */
  617. enum iwl_trans_state {
  618. IWL_TRANS_NO_FW = 0,
  619. IWL_TRANS_FW_ALIVE = 1,
  620. };
  621. /**
  622. * DOC: Platform power management
  623. *
  624. * There are two types of platform power management: system-wide
  625. * (WoWLAN) and runtime.
  626. *
  627. * In system-wide power management the entire platform goes into a low
  628. * power state (e.g. idle or suspend to RAM) at the same time and the
  629. * device is configured as a wakeup source for the entire platform.
  630. * This is usually triggered by userspace activity (e.g. the user
  631. * presses the suspend button or a power management daemon decides to
  632. * put the platform in low power mode). The device's behavior in this
  633. * mode is dictated by the wake-on-WLAN configuration.
  634. *
  635. * In runtime power management, only the devices which are themselves
  636. * idle enter a low power state. This is done at runtime, which means
  637. * that the entire system is still running normally. This mode is
  638. * usually triggered automatically by the device driver and requires
  639. * the ability to enter and exit the low power modes in a very short
  640. * time, so there is not much impact in usability.
  641. *
  642. * The terms used for the device's behavior are as follows:
  643. *
  644. * - D0: the device is fully powered and the host is awake;
  645. * - D3: the device is in low power mode and only reacts to
  646. * specific events (e.g. magic-packet received or scan
  647. * results found);
  648. * - D0I3: the device is in low power mode and reacts to any
  649. * activity (e.g. RX);
  650. *
  651. * These terms reflect the power modes in the firmware and are not to
  652. * be confused with the physical device power state. The NIC can be
  653. * in D0I3 mode even if, for instance, the PCI device is in D3 state.
  654. */
  655. /**
  656. * enum iwl_plat_pm_mode - platform power management mode
  657. *
  658. * This enumeration describes the device's platform power management
  659. * behavior when in idle mode (i.e. runtime power management) or when
  660. * in system-wide suspend (i.e WoWLAN).
  661. *
  662. * @IWL_PLAT_PM_MODE_DISABLED: power management is disabled for this
  663. * device. At runtime, this means that nothing happens and the
  664. * device always remains in active. In system-wide suspend mode,
  665. * it means that the all connections will be closed automatically
  666. * by mac80211 before the platform is suspended.
  667. * @IWL_PLAT_PM_MODE_D3: the device goes into D3 mode (i.e. WoWLAN).
  668. * For runtime power management, this mode is not officially
  669. * supported.
  670. * @IWL_PLAT_PM_MODE_D0I3: the device goes into D0I3 mode.
  671. */
  672. enum iwl_plat_pm_mode {
  673. IWL_PLAT_PM_MODE_DISABLED,
  674. IWL_PLAT_PM_MODE_D3,
  675. IWL_PLAT_PM_MODE_D0I3,
  676. };
  677. /* Max time to wait for trans to become idle/non-idle on d0i3
  678. * enter/exit (in msecs).
  679. */
  680. #define IWL_TRANS_IDLE_TIMEOUT 2000
  681. /**
  682. * struct iwl_trans - transport common data
  683. *
  684. * @ops - pointer to iwl_trans_ops
  685. * @op_mode - pointer to the op_mode
  686. * @cfg - pointer to the configuration
  687. * @status: a bit-mask of transport status flags
  688. * @dev - pointer to struct device * that represents the device
  689. * @max_skb_frags: maximum number of fragments an SKB can have when transmitted.
  690. * 0 indicates that frag SKBs (NETIF_F_SG) aren't supported.
  691. * @hw_id: a u32 with the ID of the device / sub-device.
  692. * Set during transport allocation.
  693. * @hw_id_str: a string with info about HW ID. Set during transport allocation.
  694. * @pm_support: set to true in start_hw if link pm is supported
  695. * @ltr_enabled: set to true if the LTR is enabled
  696. * @num_rx_queues: number of RX queues allocated by the transport;
  697. * the transport must set this before calling iwl_drv_start()
  698. * @dev_cmd_pool: pool for Tx cmd allocation - for internal use only.
  699. * The user should use iwl_trans_{alloc,free}_tx_cmd.
  700. * @dev_cmd_headroom: room needed for the transport's private use before the
  701. * device_cmd for Tx - for internal use only
  702. * The user should use iwl_trans_{alloc,free}_tx_cmd.
  703. * @rx_mpdu_cmd: MPDU RX command ID, must be assigned by opmode before
  704. * starting the firmware, used for tracing
  705. * @rx_mpdu_cmd_hdr_size: used for tracing, amount of data before the
  706. * start of the 802.11 header in the @rx_mpdu_cmd
  707. * @dflt_pwr_limit: default power limit fetched from the platform (ACPI)
  708. * @dbg_dest_tlv: points to the destination TLV for debug
  709. * @dbg_conf_tlv: array of pointers to configuration TLVs for debug
  710. * @dbg_trigger_tlv: array of pointers to triggers TLVs for debug
  711. * @dbg_dest_reg_num: num of reg_ops in %dbg_dest_tlv
  712. * @paging_req_addr: The location were the FW will upload / download the pages
  713. * from. The address is set by the opmode
  714. * @paging_db: Pointer to the opmode paging data base, the pointer is set by
  715. * the opmode.
  716. * @paging_download_buf: Buffer used for copying all of the pages before
  717. * downloading them to the FW. The buffer is allocated in the opmode
  718. * @system_pm_mode: the system-wide power management mode in use.
  719. * This mode is set dynamically, depending on the WoWLAN values
  720. * configured from the userspace at runtime.
  721. * @runtime_pm_mode: the runtime power management mode in use. This
  722. * mode is set during the initialization phase and is not
  723. * supposed to change during runtime.
  724. */
  725. struct iwl_trans {
  726. const struct iwl_trans_ops *ops;
  727. struct iwl_op_mode *op_mode;
  728. const struct iwl_cfg *cfg;
  729. enum iwl_trans_state state;
  730. unsigned long status;
  731. struct device *dev;
  732. u32 max_skb_frags;
  733. u32 hw_rev;
  734. u32 hw_id;
  735. char hw_id_str[52];
  736. u8 rx_mpdu_cmd, rx_mpdu_cmd_hdr_size;
  737. bool pm_support;
  738. bool ltr_enabled;
  739. const struct iwl_hcmd_arr *command_groups;
  740. int command_groups_size;
  741. u8 num_rx_queues;
  742. /* The following fields are internal only */
  743. struct kmem_cache *dev_cmd_pool;
  744. size_t dev_cmd_headroom;
  745. char dev_cmd_pool_name[50];
  746. struct dentry *dbgfs_dir;
  747. #ifdef CONFIG_LOCKDEP
  748. struct lockdep_map sync_cmd_lockdep_map;
  749. #endif
  750. u64 dflt_pwr_limit;
  751. const struct iwl_fw_dbg_dest_tlv *dbg_dest_tlv;
  752. const struct iwl_fw_dbg_conf_tlv *dbg_conf_tlv[FW_DBG_CONF_MAX];
  753. struct iwl_fw_dbg_trigger_tlv * const *dbg_trigger_tlv;
  754. u8 dbg_dest_reg_num;
  755. /*
  756. * Paging parameters - All of the parameters should be set by the
  757. * opmode when paging is enabled
  758. */
  759. u32 paging_req_addr;
  760. struct iwl_fw_paging *paging_db;
  761. void *paging_download_buf;
  762. enum iwl_plat_pm_mode system_pm_mode;
  763. enum iwl_plat_pm_mode runtime_pm_mode;
  764. bool suspending;
  765. /* pointer to trans specific struct */
  766. /*Ensure that this pointer will always be aligned to sizeof pointer */
  767. char trans_specific[0] __aligned(sizeof(void *));
  768. };
  769. const char *iwl_get_cmd_string(struct iwl_trans *trans, u32 id);
  770. int iwl_cmd_groups_verify_sorted(const struct iwl_trans_config *trans);
  771. static inline void iwl_trans_configure(struct iwl_trans *trans,
  772. const struct iwl_trans_config *trans_cfg)
  773. {
  774. trans->op_mode = trans_cfg->op_mode;
  775. trans->ops->configure(trans, trans_cfg);
  776. WARN_ON(iwl_cmd_groups_verify_sorted(trans_cfg));
  777. }
  778. static inline int _iwl_trans_start_hw(struct iwl_trans *trans, bool low_power)
  779. {
  780. might_sleep();
  781. return trans->ops->start_hw(trans, low_power);
  782. }
  783. static inline int iwl_trans_start_hw(struct iwl_trans *trans)
  784. {
  785. return trans->ops->start_hw(trans, true);
  786. }
  787. static inline void iwl_trans_op_mode_leave(struct iwl_trans *trans)
  788. {
  789. might_sleep();
  790. if (trans->ops->op_mode_leave)
  791. trans->ops->op_mode_leave(trans);
  792. trans->op_mode = NULL;
  793. trans->state = IWL_TRANS_NO_FW;
  794. }
  795. static inline void iwl_trans_fw_alive(struct iwl_trans *trans, u32 scd_addr)
  796. {
  797. might_sleep();
  798. trans->state = IWL_TRANS_FW_ALIVE;
  799. trans->ops->fw_alive(trans, scd_addr);
  800. }
  801. static inline int iwl_trans_start_fw(struct iwl_trans *trans,
  802. const struct fw_img *fw,
  803. bool run_in_rfkill)
  804. {
  805. might_sleep();
  806. WARN_ON_ONCE(!trans->rx_mpdu_cmd);
  807. clear_bit(STATUS_FW_ERROR, &trans->status);
  808. return trans->ops->start_fw(trans, fw, run_in_rfkill);
  809. }
  810. static inline int iwl_trans_update_sf(struct iwl_trans *trans,
  811. struct iwl_sf_region *st_fwrd_space)
  812. {
  813. might_sleep();
  814. if (trans->ops->update_sf)
  815. return trans->ops->update_sf(trans, st_fwrd_space);
  816. return 0;
  817. }
  818. static inline void _iwl_trans_stop_device(struct iwl_trans *trans,
  819. bool low_power)
  820. {
  821. might_sleep();
  822. trans->ops->stop_device(trans, low_power);
  823. trans->state = IWL_TRANS_NO_FW;
  824. }
  825. static inline void iwl_trans_stop_device(struct iwl_trans *trans)
  826. {
  827. _iwl_trans_stop_device(trans, true);
  828. }
  829. static inline void iwl_trans_d3_suspend(struct iwl_trans *trans, bool test,
  830. bool reset)
  831. {
  832. might_sleep();
  833. if (trans->ops->d3_suspend)
  834. trans->ops->d3_suspend(trans, test, reset);
  835. }
  836. static inline int iwl_trans_d3_resume(struct iwl_trans *trans,
  837. enum iwl_d3_status *status,
  838. bool test, bool reset)
  839. {
  840. might_sleep();
  841. if (!trans->ops->d3_resume)
  842. return 0;
  843. return trans->ops->d3_resume(trans, status, test, reset);
  844. }
  845. static inline void iwl_trans_ref(struct iwl_trans *trans)
  846. {
  847. if (trans->ops->ref)
  848. trans->ops->ref(trans);
  849. }
  850. static inline void iwl_trans_unref(struct iwl_trans *trans)
  851. {
  852. if (trans->ops->unref)
  853. trans->ops->unref(trans);
  854. }
  855. static inline int iwl_trans_suspend(struct iwl_trans *trans)
  856. {
  857. if (!trans->ops->suspend)
  858. return 0;
  859. return trans->ops->suspend(trans);
  860. }
  861. static inline void iwl_trans_resume(struct iwl_trans *trans)
  862. {
  863. if (trans->ops->resume)
  864. trans->ops->resume(trans);
  865. }
  866. static inline struct iwl_trans_dump_data *
  867. iwl_trans_dump_data(struct iwl_trans *trans,
  868. const struct iwl_fw_dbg_trigger_tlv *trigger)
  869. {
  870. if (!trans->ops->dump_data)
  871. return NULL;
  872. return trans->ops->dump_data(trans, trigger);
  873. }
  874. static inline struct iwl_device_cmd *
  875. iwl_trans_alloc_tx_cmd(struct iwl_trans *trans)
  876. {
  877. u8 *dev_cmd_ptr = kmem_cache_alloc(trans->dev_cmd_pool, GFP_ATOMIC);
  878. if (unlikely(dev_cmd_ptr == NULL))
  879. return NULL;
  880. return (struct iwl_device_cmd *)
  881. (dev_cmd_ptr + trans->dev_cmd_headroom);
  882. }
  883. int iwl_trans_send_cmd(struct iwl_trans *trans, struct iwl_host_cmd *cmd);
  884. static inline void iwl_trans_free_tx_cmd(struct iwl_trans *trans,
  885. struct iwl_device_cmd *dev_cmd)
  886. {
  887. u8 *dev_cmd_ptr = (u8 *)dev_cmd - trans->dev_cmd_headroom;
  888. kmem_cache_free(trans->dev_cmd_pool, dev_cmd_ptr);
  889. }
  890. static inline int iwl_trans_tx(struct iwl_trans *trans, struct sk_buff *skb,
  891. struct iwl_device_cmd *dev_cmd, int queue)
  892. {
  893. if (unlikely(test_bit(STATUS_FW_ERROR, &trans->status)))
  894. return -EIO;
  895. if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
  896. IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
  897. return -EIO;
  898. }
  899. return trans->ops->tx(trans, skb, dev_cmd, queue);
  900. }
  901. static inline void iwl_trans_reclaim(struct iwl_trans *trans, int queue,
  902. int ssn, struct sk_buff_head *skbs)
  903. {
  904. if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
  905. IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
  906. return;
  907. }
  908. trans->ops->reclaim(trans, queue, ssn, skbs);
  909. }
  910. static inline void iwl_trans_txq_disable(struct iwl_trans *trans, int queue,
  911. bool configure_scd)
  912. {
  913. trans->ops->txq_disable(trans, queue, configure_scd);
  914. }
  915. static inline void
  916. iwl_trans_txq_enable_cfg(struct iwl_trans *trans, int queue, u16 ssn,
  917. const struct iwl_trans_txq_scd_cfg *cfg,
  918. unsigned int queue_wdg_timeout)
  919. {
  920. might_sleep();
  921. if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
  922. IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
  923. return;
  924. }
  925. trans->ops->txq_enable(trans, queue, ssn, cfg, queue_wdg_timeout);
  926. }
  927. static inline void iwl_trans_txq_enable(struct iwl_trans *trans, int queue,
  928. int fifo, int sta_id, int tid,
  929. int frame_limit, u16 ssn,
  930. unsigned int queue_wdg_timeout)
  931. {
  932. struct iwl_trans_txq_scd_cfg cfg = {
  933. .fifo = fifo,
  934. .sta_id = sta_id,
  935. .tid = tid,
  936. .frame_limit = frame_limit,
  937. .aggregate = sta_id >= 0,
  938. };
  939. iwl_trans_txq_enable_cfg(trans, queue, ssn, &cfg, queue_wdg_timeout);
  940. }
  941. static inline
  942. void iwl_trans_ac_txq_enable(struct iwl_trans *trans, int queue, int fifo,
  943. unsigned int queue_wdg_timeout)
  944. {
  945. struct iwl_trans_txq_scd_cfg cfg = {
  946. .fifo = fifo,
  947. .sta_id = -1,
  948. .tid = IWL_MAX_TID_COUNT,
  949. .frame_limit = IWL_FRAME_LIMIT,
  950. .aggregate = false,
  951. };
  952. iwl_trans_txq_enable_cfg(trans, queue, 0, &cfg, queue_wdg_timeout);
  953. }
  954. static inline void iwl_trans_freeze_txq_timer(struct iwl_trans *trans,
  955. unsigned long txqs,
  956. bool freeze)
  957. {
  958. if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
  959. IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
  960. return;
  961. }
  962. if (trans->ops->freeze_txq_timer)
  963. trans->ops->freeze_txq_timer(trans, txqs, freeze);
  964. }
  965. static inline void iwl_trans_block_txq_ptrs(struct iwl_trans *trans,
  966. bool block)
  967. {
  968. if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
  969. IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
  970. return;
  971. }
  972. if (trans->ops->block_txq_ptrs)
  973. trans->ops->block_txq_ptrs(trans, block);
  974. }
  975. static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans,
  976. u32 txqs)
  977. {
  978. if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
  979. IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
  980. return -EIO;
  981. }
  982. return trans->ops->wait_tx_queue_empty(trans, txqs);
  983. }
  984. static inline void iwl_trans_write8(struct iwl_trans *trans, u32 ofs, u8 val)
  985. {
  986. trans->ops->write8(trans, ofs, val);
  987. }
  988. static inline void iwl_trans_write32(struct iwl_trans *trans, u32 ofs, u32 val)
  989. {
  990. trans->ops->write32(trans, ofs, val);
  991. }
  992. static inline u32 iwl_trans_read32(struct iwl_trans *trans, u32 ofs)
  993. {
  994. return trans->ops->read32(trans, ofs);
  995. }
  996. static inline u32 iwl_trans_read_prph(struct iwl_trans *trans, u32 ofs)
  997. {
  998. return trans->ops->read_prph(trans, ofs);
  999. }
  1000. static inline void iwl_trans_write_prph(struct iwl_trans *trans, u32 ofs,
  1001. u32 val)
  1002. {
  1003. return trans->ops->write_prph(trans, ofs, val);
  1004. }
  1005. static inline int iwl_trans_read_mem(struct iwl_trans *trans, u32 addr,
  1006. void *buf, int dwords)
  1007. {
  1008. return trans->ops->read_mem(trans, addr, buf, dwords);
  1009. }
  1010. #define iwl_trans_read_mem_bytes(trans, addr, buf, bufsize) \
  1011. do { \
  1012. if (__builtin_constant_p(bufsize)) \
  1013. BUILD_BUG_ON((bufsize) % sizeof(u32)); \
  1014. iwl_trans_read_mem(trans, addr, buf, (bufsize) / sizeof(u32));\
  1015. } while (0)
  1016. static inline u32 iwl_trans_read_mem32(struct iwl_trans *trans, u32 addr)
  1017. {
  1018. u32 value;
  1019. if (WARN_ON(iwl_trans_read_mem(trans, addr, &value, 1)))
  1020. return 0xa5a5a5a5;
  1021. return value;
  1022. }
  1023. static inline int iwl_trans_write_mem(struct iwl_trans *trans, u32 addr,
  1024. const void *buf, int dwords)
  1025. {
  1026. return trans->ops->write_mem(trans, addr, buf, dwords);
  1027. }
  1028. static inline u32 iwl_trans_write_mem32(struct iwl_trans *trans, u32 addr,
  1029. u32 val)
  1030. {
  1031. return iwl_trans_write_mem(trans, addr, &val, 1);
  1032. }
  1033. static inline void iwl_trans_set_pmi(struct iwl_trans *trans, bool state)
  1034. {
  1035. if (trans->ops->set_pmi)
  1036. trans->ops->set_pmi(trans, state);
  1037. }
  1038. static inline void
  1039. iwl_trans_set_bits_mask(struct iwl_trans *trans, u32 reg, u32 mask, u32 value)
  1040. {
  1041. trans->ops->set_bits_mask(trans, reg, mask, value);
  1042. }
  1043. #define iwl_trans_grab_nic_access(trans, flags) \
  1044. __cond_lock(nic_access, \
  1045. likely((trans)->ops->grab_nic_access(trans, flags)))
  1046. static inline void __releases(nic_access)
  1047. iwl_trans_release_nic_access(struct iwl_trans *trans, unsigned long *flags)
  1048. {
  1049. trans->ops->release_nic_access(trans, flags);
  1050. __release(nic_access);
  1051. }
  1052. static inline void iwl_trans_fw_error(struct iwl_trans *trans)
  1053. {
  1054. if (WARN_ON_ONCE(!trans->op_mode))
  1055. return;
  1056. /* prevent double restarts due to the same erroneous FW */
  1057. if (!test_and_set_bit(STATUS_FW_ERROR, &trans->status))
  1058. iwl_op_mode_nic_error(trans->op_mode);
  1059. }
  1060. /*****************************************************
  1061. * transport helper functions
  1062. *****************************************************/
  1063. struct iwl_trans *iwl_trans_alloc(unsigned int priv_size,
  1064. struct device *dev,
  1065. const struct iwl_cfg *cfg,
  1066. const struct iwl_trans_ops *ops,
  1067. size_t dev_cmd_headroom);
  1068. void iwl_trans_free(struct iwl_trans *trans);
  1069. /*****************************************************
  1070. * driver (transport) register/unregister functions
  1071. ******************************************************/
  1072. int __must_check iwl_pci_register_driver(void);
  1073. void iwl_pci_unregister_driver(void);
  1074. #endif /* __iwl_trans_h__ */