diff options
Diffstat (limited to 'drivers/net/wireless/iwlwifi/iwl-io.h')
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-io.h | 253 |
1 files changed, 159 insertions, 94 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-io.h b/drivers/net/wireless/iwlwifi/iwl-io.h index 083ea1ffbe87..d30cb0275d19 100644 --- a/drivers/net/wireless/iwlwifi/iwl-io.h +++ b/drivers/net/wireless/iwlwifi/iwl-io.h | |||
@@ -131,9 +131,23 @@ static inline void __iwl_set_bit(const char *f, u32 l, | |||
131 | IWL_DEBUG_IO(priv, "set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val); | 131 | IWL_DEBUG_IO(priv, "set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val); |
132 | _iwl_write32(priv, reg, val); | 132 | _iwl_write32(priv, reg, val); |
133 | } | 133 | } |
134 | #define iwl_set_bit(p, r, m) __iwl_set_bit(__FILE__, __LINE__, p, r, m) | 134 | static inline void iwl_set_bit(struct iwl_priv *p, u32 r, u32 m) |
135 | { | ||
136 | unsigned long reg_flags; | ||
137 | |||
138 | spin_lock_irqsave(&p->reg_lock, reg_flags); | ||
139 | __iwl_set_bit(__FILE__, __LINE__, p, r, m); | ||
140 | spin_unlock_irqrestore(&p->reg_lock, reg_flags); | ||
141 | } | ||
135 | #else | 142 | #else |
136 | #define iwl_set_bit(p, r, m) _iwl_set_bit(p, r, m) | 143 | static inline void iwl_set_bit(struct iwl_priv *p, u32 r, u32 m) |
144 | { | ||
145 | unsigned long reg_flags; | ||
146 | |||
147 | spin_lock_irqsave(&p->reg_lock, reg_flags); | ||
148 | _iwl_set_bit(p, r, m); | ||
149 | spin_unlock_irqrestore(&p->reg_lock, reg_flags); | ||
150 | } | ||
137 | #endif | 151 | #endif |
138 | 152 | ||
139 | static inline void _iwl_clear_bit(struct iwl_priv *priv, u32 reg, u32 mask) | 153 | static inline void _iwl_clear_bit(struct iwl_priv *priv, u32 reg, u32 mask) |
@@ -148,19 +162,30 @@ static inline void __iwl_clear_bit(const char *f, u32 l, | |||
148 | IWL_DEBUG_IO(priv, "clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val); | 162 | IWL_DEBUG_IO(priv, "clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val); |
149 | _iwl_write32(priv, reg, val); | 163 | _iwl_write32(priv, reg, val); |
150 | } | 164 | } |
151 | #define iwl_clear_bit(p, r, m) __iwl_clear_bit(__FILE__, __LINE__, p, r, m) | 165 | static inline void iwl_clear_bit(struct iwl_priv *p, u32 r, u32 m) |
166 | { | ||
167 | unsigned long reg_flags; | ||
168 | |||
169 | spin_lock_irqsave(&p->reg_lock, reg_flags); | ||
170 | __iwl_clear_bit(__FILE__, __LINE__, p, r, m); | ||
171 | spin_unlock_irqrestore(&p->reg_lock, reg_flags); | ||
172 | } | ||
152 | #else | 173 | #else |
153 | #define iwl_clear_bit(p, r, m) _iwl_clear_bit(p, r, m) | 174 | static inline void iwl_clear_bit(struct iwl_priv *p, u32 r, u32 m) |
175 | { | ||
176 | unsigned long reg_flags; | ||
177 | |||
178 | spin_lock_irqsave(&p->reg_lock, reg_flags); | ||
179 | _iwl_clear_bit(p, r, m); | ||
180 | spin_unlock_irqrestore(&p->reg_lock, reg_flags); | ||
181 | } | ||
154 | #endif | 182 | #endif |
155 | 183 | ||
156 | static inline int _iwl_grab_nic_access(struct iwl_priv *priv) | 184 | static inline int _iwl_grab_nic_access(struct iwl_priv *priv) |
157 | { | 185 | { |
158 | int ret; | 186 | int ret; |
159 | u32 val; | 187 | u32 val; |
160 | #ifdef CONFIG_IWLWIFI_DEBUG | 188 | |
161 | if (atomic_read(&priv->restrict_refcnt)) | ||
162 | return 0; | ||
163 | #endif | ||
164 | /* this bit wakes up the NIC */ | 189 | /* this bit wakes up the NIC */ |
165 | _iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ); | 190 | _iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ); |
166 | ret = _iwl_poll_bit(priv, CSR_GP_CNTRL, | 191 | ret = _iwl_poll_bit(priv, CSR_GP_CNTRL, |
@@ -170,12 +195,10 @@ static inline int _iwl_grab_nic_access(struct iwl_priv *priv) | |||
170 | if (ret < 0) { | 195 | if (ret < 0) { |
171 | val = _iwl_read32(priv, CSR_GP_CNTRL); | 196 | val = _iwl_read32(priv, CSR_GP_CNTRL); |
172 | IWL_ERR(priv, "MAC is in deep sleep!. CSR_GP_CNTRL = 0x%08X\n", val); | 197 | IWL_ERR(priv, "MAC is in deep sleep!. CSR_GP_CNTRL = 0x%08X\n", val); |
198 | _iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_FORCE_NMI); | ||
173 | return -EIO; | 199 | return -EIO; |
174 | } | 200 | } |
175 | 201 | ||
176 | #ifdef CONFIG_IWLWIFI_DEBUG | ||
177 | atomic_inc(&priv->restrict_refcnt); | ||
178 | #endif | ||
179 | return 0; | 202 | return 0; |
180 | } | 203 | } |
181 | 204 | ||
@@ -183,9 +206,6 @@ static inline int _iwl_grab_nic_access(struct iwl_priv *priv) | |||
183 | static inline int __iwl_grab_nic_access(const char *f, u32 l, | 206 | static inline int __iwl_grab_nic_access(const char *f, u32 l, |
184 | struct iwl_priv *priv) | 207 | struct iwl_priv *priv) |
185 | { | 208 | { |
186 | if (atomic_read(&priv->restrict_refcnt)) | ||
187 | IWL_ERR(priv, "Grabbing access while already held %s %d.\n", f, l); | ||
188 | |||
189 | IWL_DEBUG_IO(priv, "grabbing nic access - %s %d\n", f, l); | 209 | IWL_DEBUG_IO(priv, "grabbing nic access - %s %d\n", f, l); |
190 | return _iwl_grab_nic_access(priv); | 210 | return _iwl_grab_nic_access(priv); |
191 | } | 211 | } |
@@ -198,18 +218,13 @@ static inline int __iwl_grab_nic_access(const char *f, u32 l, | |||
198 | 218 | ||
199 | static inline void _iwl_release_nic_access(struct iwl_priv *priv) | 219 | static inline void _iwl_release_nic_access(struct iwl_priv *priv) |
200 | { | 220 | { |
201 | #ifdef CONFIG_IWLWIFI_DEBUG | 221 | _iwl_clear_bit(priv, CSR_GP_CNTRL, |
202 | if (atomic_dec_and_test(&priv->restrict_refcnt)) | 222 | CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ); |
203 | #endif | ||
204 | _iwl_clear_bit(priv, CSR_GP_CNTRL, | ||
205 | CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ); | ||
206 | } | 223 | } |
207 | #ifdef CONFIG_IWLWIFI_DEBUG | 224 | #ifdef CONFIG_IWLWIFI_DEBUG |
208 | static inline void __iwl_release_nic_access(const char *f, u32 l, | 225 | static inline void __iwl_release_nic_access(const char *f, u32 l, |
209 | struct iwl_priv *priv) | 226 | struct iwl_priv *priv) |
210 | { | 227 | { |
211 | if (atomic_read(&priv->restrict_refcnt) <= 0) | ||
212 | IWL_ERR(priv, "Release unheld nic access at line %s %d.\n", f, l); | ||
213 | 228 | ||
214 | IWL_DEBUG_IO(priv, "releasing nic access - %s %d\n", f, l); | 229 | IWL_DEBUG_IO(priv, "releasing nic access - %s %d\n", f, l); |
215 | _iwl_release_nic_access(priv); | 230 | _iwl_release_nic_access(priv); |
@@ -230,16 +245,37 @@ static inline u32 __iwl_read_direct32(const char *f, u32 l, | |||
230 | struct iwl_priv *priv, u32 reg) | 245 | struct iwl_priv *priv, u32 reg) |
231 | { | 246 | { |
232 | u32 value = _iwl_read_direct32(priv, reg); | 247 | u32 value = _iwl_read_direct32(priv, reg); |
233 | if (!atomic_read(&priv->restrict_refcnt)) | ||
234 | IWL_ERR(priv, "Nic access not held from %s %d\n", f, l); | ||
235 | IWL_DEBUG_IO(priv, "read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value, | 248 | IWL_DEBUG_IO(priv, "read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value, |
236 | f, l); | 249 | f, l); |
237 | return value; | 250 | return value; |
238 | } | 251 | } |
239 | #define iwl_read_direct32(priv, reg) \ | 252 | static inline u32 iwl_read_direct32(struct iwl_priv *priv, u32 reg) |
240 | __iwl_read_direct32(__FILE__, __LINE__, priv, reg) | 253 | { |
254 | u32 value; | ||
255 | unsigned long reg_flags; | ||
256 | |||
257 | spin_lock_irqsave(&priv->reg_lock, reg_flags); | ||
258 | iwl_grab_nic_access(priv); | ||
259 | value = __iwl_read_direct32(__FILE__, __LINE__, priv, reg); | ||
260 | iwl_release_nic_access(priv); | ||
261 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
262 | return value; | ||
263 | } | ||
264 | |||
241 | #else | 265 | #else |
242 | #define iwl_read_direct32 _iwl_read_direct32 | 266 | static inline u32 iwl_read_direct32(struct iwl_priv *priv, u32 reg) |
267 | { | ||
268 | u32 value; | ||
269 | unsigned long reg_flags; | ||
270 | |||
271 | spin_lock_irqsave(&priv->reg_lock, reg_flags); | ||
272 | iwl_grab_nic_access(priv); | ||
273 | value = _iwl_read_direct32(priv, reg); | ||
274 | iwl_release_nic_access(priv); | ||
275 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
276 | return value; | ||
277 | |||
278 | } | ||
243 | #endif | 279 | #endif |
244 | 280 | ||
245 | static inline void _iwl_write_direct32(struct iwl_priv *priv, | 281 | static inline void _iwl_write_direct32(struct iwl_priv *priv, |
@@ -247,19 +283,17 @@ static inline void _iwl_write_direct32(struct iwl_priv *priv, | |||
247 | { | 283 | { |
248 | _iwl_write32(priv, reg, value); | 284 | _iwl_write32(priv, reg, value); |
249 | } | 285 | } |
250 | #ifdef CONFIG_IWLWIFI_DEBUG | 286 | static inline void iwl_write_direct32(struct iwl_priv *priv, u32 reg, u32 value) |
251 | static void __iwl_write_direct32(const char *f , u32 line, | ||
252 | struct iwl_priv *priv, u32 reg, u32 value) | ||
253 | { | 287 | { |
254 | if (!atomic_read(&priv->restrict_refcnt)) | 288 | unsigned long reg_flags; |
255 | IWL_ERR(priv, "Nic access not held from %s line %d\n", f, line); | 289 | |
256 | _iwl_write_direct32(priv, reg, value); | 290 | spin_lock_irqsave(&priv->reg_lock, reg_flags); |
291 | if (!iwl_grab_nic_access(priv)) { | ||
292 | _iwl_write_direct32(priv, reg, value); | ||
293 | iwl_release_nic_access(priv); | ||
294 | } | ||
295 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
257 | } | 296 | } |
258 | #define iwl_write_direct32(priv, reg, value) \ | ||
259 | __iwl_write_direct32(__func__, __LINE__, priv, reg, value) | ||
260 | #else | ||
261 | #define iwl_write_direct32 _iwl_write_direct32 | ||
262 | #endif | ||
263 | 297 | ||
264 | static inline void iwl_write_reg_buf(struct iwl_priv *priv, | 298 | static inline void iwl_write_reg_buf(struct iwl_priv *priv, |
265 | u32 reg, u32 len, u32 *values) | 299 | u32 reg, u32 len, u32 *values) |
@@ -268,14 +302,23 @@ static inline void iwl_write_reg_buf(struct iwl_priv *priv, | |||
268 | 302 | ||
269 | if ((priv != NULL) && (values != NULL)) { | 303 | if ((priv != NULL) && (values != NULL)) { |
270 | for (; 0 < len; len -= count, reg += count, values++) | 304 | for (; 0 < len; len -= count, reg += count, values++) |
271 | _iwl_write_direct32(priv, reg, *values); | 305 | iwl_write_direct32(priv, reg, *values); |
272 | } | 306 | } |
273 | } | 307 | } |
274 | 308 | ||
275 | static inline int _iwl_poll_direct_bit(struct iwl_priv *priv, u32 addr, | 309 | static inline int _iwl_poll_direct_bit(struct iwl_priv *priv, u32 addr, |
276 | u32 mask, int timeout) | 310 | u32 mask, int timeout) |
277 | { | 311 | { |
278 | return _iwl_poll_bit(priv, addr, mask, mask, timeout); | 312 | int t = 0; |
313 | |||
314 | do { | ||
315 | if ((iwl_read_direct32(priv, addr) & mask) == mask) | ||
316 | return t; | ||
317 | udelay(IWL_POLL_INTERVAL); | ||
318 | t += IWL_POLL_INTERVAL; | ||
319 | } while (t < timeout); | ||
320 | |||
321 | return -ETIMEDOUT; | ||
279 | } | 322 | } |
280 | 323 | ||
281 | #ifdef CONFIG_IWLWIFI_DEBUG | 324 | #ifdef CONFIG_IWLWIFI_DEBUG |
@@ -305,20 +348,18 @@ static inline u32 _iwl_read_prph(struct iwl_priv *priv, u32 reg) | |||
305 | rmb(); | 348 | rmb(); |
306 | return _iwl_read_direct32(priv, HBUS_TARG_PRPH_RDAT); | 349 | return _iwl_read_direct32(priv, HBUS_TARG_PRPH_RDAT); |
307 | } | 350 | } |
308 | #ifdef CONFIG_IWLWIFI_DEBUG | 351 | static inline u32 iwl_read_prph(struct iwl_priv *priv, u32 reg) |
309 | static inline u32 __iwl_read_prph(const char *f, u32 line, | ||
310 | struct iwl_priv *priv, u32 reg) | ||
311 | { | 352 | { |
312 | if (!atomic_read(&priv->restrict_refcnt)) | 353 | unsigned long reg_flags; |
313 | IWL_ERR(priv, "Nic access not held from %s line %d\n", f, line); | 354 | u32 val; |
314 | return _iwl_read_prph(priv, reg); | ||
315 | } | ||
316 | 355 | ||
317 | #define iwl_read_prph(priv, reg) \ | 356 | spin_lock_irqsave(&priv->reg_lock, reg_flags); |
318 | __iwl_read_prph(__func__, __LINE__, priv, reg) | 357 | iwl_grab_nic_access(priv); |
319 | #else | 358 | val = _iwl_read_prph(priv, reg); |
320 | #define iwl_read_prph _iwl_read_prph | 359 | iwl_release_nic_access(priv); |
321 | #endif | 360 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); |
361 | return val; | ||
362 | } | ||
322 | 363 | ||
323 | static inline void _iwl_write_prph(struct iwl_priv *priv, | 364 | static inline void _iwl_write_prph(struct iwl_priv *priv, |
324 | u32 addr, u32 val) | 365 | u32 addr, u32 val) |
@@ -328,83 +369,107 @@ static inline void _iwl_write_prph(struct iwl_priv *priv, | |||
328 | wmb(); | 369 | wmb(); |
329 | _iwl_write_direct32(priv, HBUS_TARG_PRPH_WDAT, val); | 370 | _iwl_write_direct32(priv, HBUS_TARG_PRPH_WDAT, val); |
330 | } | 371 | } |
331 | #ifdef CONFIG_IWLWIFI_DEBUG | 372 | |
332 | static inline void __iwl_write_prph(const char *f, u32 line, | 373 | static inline void iwl_write_prph(struct iwl_priv *priv, u32 addr, u32 val) |
333 | struct iwl_priv *priv, u32 addr, u32 val) | ||
334 | { | 374 | { |
335 | if (!atomic_read(&priv->restrict_refcnt)) | 375 | unsigned long reg_flags; |
336 | IWL_ERR(priv, "Nic access not held from %s line %d\n", f, line); | ||
337 | _iwl_write_prph(priv, addr, val); | ||
338 | } | ||
339 | 376 | ||
340 | #define iwl_write_prph(priv, addr, val) \ | 377 | spin_lock_irqsave(&priv->reg_lock, reg_flags); |
341 | __iwl_write_prph(__func__, __LINE__, priv, addr, val); | 378 | if (!iwl_grab_nic_access(priv)) { |
342 | #else | 379 | _iwl_write_prph(priv, addr, val); |
343 | #define iwl_write_prph _iwl_write_prph | 380 | iwl_release_nic_access(priv); |
344 | #endif | 381 | } |
382 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
383 | } | ||
345 | 384 | ||
346 | #define _iwl_set_bits_prph(priv, reg, mask) \ | 385 | #define _iwl_set_bits_prph(priv, reg, mask) \ |
347 | _iwl_write_prph(priv, reg, (_iwl_read_prph(priv, reg) | mask)) | 386 | _iwl_write_prph(priv, reg, (_iwl_read_prph(priv, reg) | mask)) |
348 | #ifdef CONFIG_IWLWIFI_DEBUG | 387 | |
349 | static inline void __iwl_set_bits_prph(const char *f, u32 line, | 388 | static inline void iwl_set_bits_prph(struct iwl_priv *priv, u32 reg, u32 mask) |
350 | struct iwl_priv *priv, | ||
351 | u32 reg, u32 mask) | ||
352 | { | 389 | { |
353 | if (!atomic_read(&priv->restrict_refcnt)) | 390 | unsigned long reg_flags; |
354 | IWL_ERR(priv, "Nic access not held from %s line %d\n", f, line); | ||
355 | 391 | ||
392 | spin_lock_irqsave(&priv->reg_lock, reg_flags); | ||
393 | iwl_grab_nic_access(priv); | ||
356 | _iwl_set_bits_prph(priv, reg, mask); | 394 | _iwl_set_bits_prph(priv, reg, mask); |
395 | iwl_release_nic_access(priv); | ||
396 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
357 | } | 397 | } |
358 | #define iwl_set_bits_prph(priv, reg, mask) \ | ||
359 | __iwl_set_bits_prph(__func__, __LINE__, priv, reg, mask) | ||
360 | #else | ||
361 | #define iwl_set_bits_prph _iwl_set_bits_prph | ||
362 | #endif | ||
363 | 398 | ||
364 | #define _iwl_set_bits_mask_prph(priv, reg, bits, mask) \ | 399 | #define _iwl_set_bits_mask_prph(priv, reg, bits, mask) \ |
365 | _iwl_write_prph(priv, reg, ((_iwl_read_prph(priv, reg) & mask) | bits)) | 400 | _iwl_write_prph(priv, reg, ((_iwl_read_prph(priv, reg) & mask) | bits)) |
366 | 401 | ||
367 | #ifdef CONFIG_IWLWIFI_DEBUG | 402 | static inline void iwl_set_bits_mask_prph(struct iwl_priv *priv, u32 reg, |
368 | static inline void __iwl_set_bits_mask_prph(const char *f, u32 line, | 403 | u32 bits, u32 mask) |
369 | struct iwl_priv *priv, u32 reg, u32 bits, u32 mask) | ||
370 | { | 404 | { |
371 | if (!atomic_read(&priv->restrict_refcnt)) | 405 | unsigned long reg_flags; |
372 | IWL_ERR(priv, "Nic access not held from %s line %d\n", f, line); | 406 | |
407 | spin_lock_irqsave(&priv->reg_lock, reg_flags); | ||
408 | iwl_grab_nic_access(priv); | ||
373 | _iwl_set_bits_mask_prph(priv, reg, bits, mask); | 409 | _iwl_set_bits_mask_prph(priv, reg, bits, mask); |
410 | iwl_release_nic_access(priv); | ||
411 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
374 | } | 412 | } |
375 | #define iwl_set_bits_mask_prph(priv, reg, bits, mask) \ | ||
376 | __iwl_set_bits_mask_prph(__func__, __LINE__, priv, reg, bits, mask) | ||
377 | #else | ||
378 | #define iwl_set_bits_mask_prph _iwl_set_bits_mask_prph | ||
379 | #endif | ||
380 | 413 | ||
381 | static inline void iwl_clear_bits_prph(struct iwl_priv | 414 | static inline void iwl_clear_bits_prph(struct iwl_priv |
382 | *priv, u32 reg, u32 mask) | 415 | *priv, u32 reg, u32 mask) |
383 | { | 416 | { |
384 | u32 val = _iwl_read_prph(priv, reg); | 417 | unsigned long reg_flags; |
418 | u32 val; | ||
419 | |||
420 | spin_lock_irqsave(&priv->reg_lock, reg_flags); | ||
421 | iwl_grab_nic_access(priv); | ||
422 | val = _iwl_read_prph(priv, reg); | ||
385 | _iwl_write_prph(priv, reg, (val & ~mask)); | 423 | _iwl_write_prph(priv, reg, (val & ~mask)); |
424 | iwl_release_nic_access(priv); | ||
425 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
386 | } | 426 | } |
387 | 427 | ||
388 | static inline u32 iwl_read_targ_mem(struct iwl_priv *priv, u32 addr) | 428 | static inline u32 iwl_read_targ_mem(struct iwl_priv *priv, u32 addr) |
389 | { | 429 | { |
390 | iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, addr); | 430 | unsigned long reg_flags; |
431 | u32 value; | ||
432 | |||
433 | spin_lock_irqsave(&priv->reg_lock, reg_flags); | ||
434 | iwl_grab_nic_access(priv); | ||
435 | |||
436 | _iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, addr); | ||
391 | rmb(); | 437 | rmb(); |
392 | return iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT); | 438 | value = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT); |
439 | |||
440 | iwl_release_nic_access(priv); | ||
441 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
442 | return value; | ||
393 | } | 443 | } |
394 | 444 | ||
395 | static inline void iwl_write_targ_mem(struct iwl_priv *priv, u32 addr, u32 val) | 445 | static inline void iwl_write_targ_mem(struct iwl_priv *priv, u32 addr, u32 val) |
396 | { | 446 | { |
397 | iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr); | 447 | unsigned long reg_flags; |
398 | wmb(); | 448 | |
399 | iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, val); | 449 | spin_lock_irqsave(&priv->reg_lock, reg_flags); |
450 | if (!iwl_grab_nic_access(priv)) { | ||
451 | _iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr); | ||
452 | wmb(); | ||
453 | _iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, val); | ||
454 | iwl_release_nic_access(priv); | ||
455 | } | ||
456 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
400 | } | 457 | } |
401 | 458 | ||
402 | static inline void iwl_write_targ_mem_buf(struct iwl_priv *priv, u32 addr, | 459 | static inline void iwl_write_targ_mem_buf(struct iwl_priv *priv, u32 addr, |
403 | u32 len, u32 *values) | 460 | u32 len, u32 *values) |
404 | { | 461 | { |
405 | iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr); | 462 | unsigned long reg_flags; |
406 | wmb(); | 463 | |
407 | for (; 0 < len; len -= sizeof(u32), values++) | 464 | spin_lock_irqsave(&priv->reg_lock, reg_flags); |
408 | iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, *values); | 465 | if (!iwl_grab_nic_access(priv)) { |
466 | _iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr); | ||
467 | wmb(); | ||
468 | for (; 0 < len; len -= sizeof(u32), values++) | ||
469 | _iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, *values); | ||
470 | |||
471 | iwl_release_nic_access(priv); | ||
472 | } | ||
473 | spin_unlock_irqrestore(&priv->reg_lock, reg_flags); | ||
409 | } | 474 | } |
410 | #endif | 475 | #endif |