diff options
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-3945.c | 19 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-4965.c | 18 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-io.h | 9 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl3945-base.c | 30 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl4965-base.c | 34 |
5 files changed, 54 insertions, 56 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c index 59e2fa270924..077fa1023fe5 100644 --- a/drivers/net/wireless/iwlwifi/iwl-3945.c +++ b/drivers/net/wireless/iwlwifi/iwl-3945.c | |||
@@ -96,7 +96,7 @@ const struct iwl_rate_info iwl_rates[IWL_RATE_COUNT] = { | |||
96 | * ... and set IWL_EVT_DISABLE to 1. */ | 96 | * ... and set IWL_EVT_DISABLE to 1. */ |
97 | void iwl_disable_events(struct iwl_priv *priv) | 97 | void iwl_disable_events(struct iwl_priv *priv) |
98 | { | 98 | { |
99 | int rc; | 99 | int ret; |
100 | int i; | 100 | int i; |
101 | u32 base; /* SRAM address of event log header */ | 101 | u32 base; /* SRAM address of event log header */ |
102 | u32 disable_ptr; /* SRAM address of event-disable bitmap array */ | 102 | u32 disable_ptr; /* SRAM address of event-disable bitmap array */ |
@@ -157,25 +157,24 @@ void iwl_disable_events(struct iwl_priv *priv) | |||
157 | return; | 157 | return; |
158 | } | 158 | } |
159 | 159 | ||
160 | rc = iwl_grab_restricted_access(priv); | 160 | ret = iwl_grab_restricted_access(priv); |
161 | if (rc) { | 161 | if (ret) { |
162 | IWL_WARNING("Can not read from adapter at this time.\n"); | 162 | IWL_WARNING("Can not read from adapter at this time.\n"); |
163 | return; | 163 | return; |
164 | } | 164 | } |
165 | 165 | ||
166 | disable_ptr = iwl_read_restricted_mem(priv, base + (4 * sizeof(u32))); | 166 | disable_ptr = iwl_read_targ_mem(priv, base + (4 * sizeof(u32))); |
167 | array_size = iwl_read_restricted_mem(priv, base + (5 * sizeof(u32))); | 167 | array_size = iwl_read_targ_mem(priv, base + (5 * sizeof(u32))); |
168 | iwl_release_restricted_access(priv); | 168 | iwl_release_restricted_access(priv); |
169 | 169 | ||
170 | if (IWL_EVT_DISABLE && (array_size == IWL_EVT_DISABLE_SIZE)) { | 170 | if (IWL_EVT_DISABLE && (array_size == IWL_EVT_DISABLE_SIZE)) { |
171 | IWL_DEBUG_INFO("Disabling selected uCode log events at 0x%x\n", | 171 | IWL_DEBUG_INFO("Disabling selected uCode log events at 0x%x\n", |
172 | disable_ptr); | 172 | disable_ptr); |
173 | rc = iwl_grab_restricted_access(priv); | 173 | ret = iwl_grab_restricted_access(priv); |
174 | for (i = 0; i < IWL_EVT_DISABLE_SIZE; i++) | 174 | for (i = 0; i < IWL_EVT_DISABLE_SIZE; i++) |
175 | iwl_write_restricted_mem(priv, | 175 | iwl_write_targ_mem(priv, |
176 | disable_ptr + | 176 | disable_ptr + (i * sizeof(u32)), |
177 | (i * sizeof(u32)), | 177 | evt_disable[i]); |
178 | evt_disable[i]); | ||
179 | 178 | ||
180 | iwl_release_restricted_access(priv); | 179 | iwl_release_restricted_access(priv); |
181 | } else { | 180 | } else { |
diff --git a/drivers/net/wireless/iwlwifi/iwl-4965.c b/drivers/net/wireless/iwlwifi/iwl-4965.c index 1e56dfa0cfbc..5914657f1ca3 100644 --- a/drivers/net/wireless/iwlwifi/iwl-4965.c +++ b/drivers/net/wireless/iwlwifi/iwl-4965.c | |||
@@ -1657,11 +1657,11 @@ int iwl4965_alive_notify(struct iwl_priv *priv) | |||
1657 | priv->scd_base_addr = iwl_read_prph(priv, SCD_SRAM_BASE_ADDR); | 1657 | priv->scd_base_addr = iwl_read_prph(priv, SCD_SRAM_BASE_ADDR); |
1658 | a = priv->scd_base_addr + SCD_CONTEXT_DATA_OFFSET; | 1658 | a = priv->scd_base_addr + SCD_CONTEXT_DATA_OFFSET; |
1659 | for (; a < priv->scd_base_addr + SCD_TX_STTS_BITMAP_OFFSET; a += 4) | 1659 | for (; a < priv->scd_base_addr + SCD_TX_STTS_BITMAP_OFFSET; a += 4) |
1660 | iwl_write_restricted_mem(priv, a, 0); | 1660 | iwl_write_targ_mem(priv, a, 0); |
1661 | for (; a < priv->scd_base_addr + SCD_TRANSLATE_TBL_OFFSET; a += 4) | 1661 | for (; a < priv->scd_base_addr + SCD_TRANSLATE_TBL_OFFSET; a += 4) |
1662 | iwl_write_restricted_mem(priv, a, 0); | 1662 | iwl_write_targ_mem(priv, a, 0); |
1663 | for (; a < sizeof(u16) * priv->hw_setting.max_txq_num; a += 4) | 1663 | for (; a < sizeof(u16) * priv->hw_setting.max_txq_num; a += 4) |
1664 | iwl_write_restricted_mem(priv, a, 0); | 1664 | iwl_write_targ_mem(priv, a, 0); |
1665 | 1665 | ||
1666 | iwl_write_prph(priv, SCD_DRAM_BASE_ADDR, | 1666 | iwl_write_prph(priv, SCD_DRAM_BASE_ADDR, |
1667 | (priv->hw_setting.shared_phys + | 1667 | (priv->hw_setting.shared_phys + |
@@ -1672,12 +1672,12 @@ int iwl4965_alive_notify(struct iwl_priv *priv) | |||
1672 | for (i = 0; i < priv->hw_setting.max_txq_num; i++) { | 1672 | for (i = 0; i < priv->hw_setting.max_txq_num; i++) { |
1673 | iwl_write_prph(priv, SCD_QUEUE_RDPTR(i), 0); | 1673 | iwl_write_prph(priv, SCD_QUEUE_RDPTR(i), 0); |
1674 | iwl_write_restricted(priv, HBUS_TARG_WRPTR, 0 | (i << 8)); | 1674 | iwl_write_restricted(priv, HBUS_TARG_WRPTR, 0 | (i << 8)); |
1675 | iwl_write_restricted_mem(priv, priv->scd_base_addr + | 1675 | iwl_write_targ_mem(priv, priv->scd_base_addr + |
1676 | SCD_CONTEXT_QUEUE_OFFSET(i), | 1676 | SCD_CONTEXT_QUEUE_OFFSET(i), |
1677 | (SCD_WIN_SIZE << | 1677 | (SCD_WIN_SIZE << |
1678 | SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) & | 1678 | SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) & |
1679 | SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK); | 1679 | SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK); |
1680 | iwl_write_restricted_mem(priv, priv->scd_base_addr + | 1680 | iwl_write_targ_mem(priv, priv->scd_base_addr + |
1681 | SCD_CONTEXT_QUEUE_OFFSET(i) + | 1681 | SCD_CONTEXT_QUEUE_OFFSET(i) + |
1682 | sizeof(u32), | 1682 | sizeof(u32), |
1683 | (SCD_FRAME_LIMIT << | 1683 | (SCD_FRAME_LIMIT << |
@@ -4156,14 +4156,14 @@ static int iwl4965_tx_queue_set_q2ratid(struct iwl_priv *priv, u16 ra_tid, | |||
4156 | tbl_dw_addr = priv->scd_base_addr + | 4156 | tbl_dw_addr = priv->scd_base_addr + |
4157 | SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id); | 4157 | SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id); |
4158 | 4158 | ||
4159 | tbl_dw = iwl_read_restricted_mem(priv, tbl_dw_addr); | 4159 | tbl_dw = iwl_read_targ_mem(priv, tbl_dw_addr); |
4160 | 4160 | ||
4161 | if (txq_id & 0x1) | 4161 | if (txq_id & 0x1) |
4162 | tbl_dw = (scd_q2ratid << 16) | (tbl_dw & 0x0000FFFF); | 4162 | tbl_dw = (scd_q2ratid << 16) | (tbl_dw & 0x0000FFFF); |
4163 | else | 4163 | else |
4164 | tbl_dw = scd_q2ratid | (tbl_dw & 0xFFFF0000); | 4164 | tbl_dw = scd_q2ratid | (tbl_dw & 0xFFFF0000); |
4165 | 4165 | ||
4166 | iwl_write_restricted_mem(priv, tbl_dw_addr, tbl_dw); | 4166 | iwl_write_targ_mem(priv, tbl_dw_addr, tbl_dw); |
4167 | 4167 | ||
4168 | return 0; | 4168 | return 0; |
4169 | } | 4169 | } |
@@ -4207,12 +4207,12 @@ static int iwl4965_tx_queue_agg_enable(struct iwl_priv *priv, int txq_id, | |||
4207 | /* supposes that ssn_idx is valid (!= 0xFFF) */ | 4207 | /* supposes that ssn_idx is valid (!= 0xFFF) */ |
4208 | iwl4965_set_wr_ptrs(priv, txq_id, ssn_idx); | 4208 | iwl4965_set_wr_ptrs(priv, txq_id, ssn_idx); |
4209 | 4209 | ||
4210 | iwl_write_restricted_mem(priv, | 4210 | iwl_write_targ_mem(priv, |
4211 | priv->scd_base_addr + SCD_CONTEXT_QUEUE_OFFSET(txq_id), | 4211 | priv->scd_base_addr + SCD_CONTEXT_QUEUE_OFFSET(txq_id), |
4212 | (SCD_WIN_SIZE << SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) & | 4212 | (SCD_WIN_SIZE << SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) & |
4213 | SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK); | 4213 | SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK); |
4214 | 4214 | ||
4215 | iwl_write_restricted_mem(priv, priv->scd_base_addr + | 4215 | iwl_write_targ_mem(priv, priv->scd_base_addr + |
4216 | SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32), | 4216 | SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32), |
4217 | (SCD_FRAME_LIMIT << SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) | 4217 | (SCD_FRAME_LIMIT << SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) |
4218 | & SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK); | 4218 | & SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK); |
diff --git a/drivers/net/wireless/iwlwifi/iwl-io.h b/drivers/net/wireless/iwlwifi/iwl-io.h index b78afed9c799..5cdcfc43fa14 100644 --- a/drivers/net/wireless/iwlwifi/iwl-io.h +++ b/drivers/net/wireless/iwlwifi/iwl-io.h | |||
@@ -411,21 +411,20 @@ static inline void iwl_clear_bits_prph(struct iwl_priv | |||
411 | _iwl_write_prph(priv, reg, (val & ~mask)); | 411 | _iwl_write_prph(priv, reg, (val & ~mask)); |
412 | } | 412 | } |
413 | 413 | ||
414 | static inline u32 iwl_read_restricted_mem(struct iwl_priv *priv, u32 addr) | 414 | static inline u32 iwl_read_targ_mem(struct iwl_priv *priv, u32 addr) |
415 | { | 415 | { |
416 | iwl_write_restricted(priv, HBUS_TARG_MEM_RADDR, addr); | 416 | iwl_write_restricted(priv, HBUS_TARG_MEM_RADDR, addr); |
417 | return iwl_read_restricted(priv, HBUS_TARG_MEM_RDAT); | 417 | return iwl_read_restricted(priv, HBUS_TARG_MEM_RDAT); |
418 | } | 418 | } |
419 | 419 | ||
420 | static inline void iwl_write_restricted_mem(struct iwl_priv *priv, u32 addr, | 420 | static inline void iwl_write_targ_mem(struct iwl_priv *priv, u32 addr, u32 val) |
421 | u32 val) | ||
422 | { | 421 | { |
423 | iwl_write_restricted(priv, HBUS_TARG_MEM_WADDR, addr); | 422 | iwl_write_restricted(priv, HBUS_TARG_MEM_WADDR, addr); |
424 | iwl_write_restricted(priv, HBUS_TARG_MEM_WDAT, val); | 423 | iwl_write_restricted(priv, HBUS_TARG_MEM_WDAT, val); |
425 | } | 424 | } |
426 | 425 | ||
427 | static inline void iwl_write_restricted_mems(struct iwl_priv *priv, u32 addr, | 426 | static inline void iwl_write_targ_mem_buf(struct iwl_priv *priv, u32 addr, |
428 | u32 len, u32 *values) | 427 | u32 len, u32 *values) |
429 | { | 428 | { |
430 | iwl_write_restricted(priv, HBUS_TARG_MEM_WADDR, addr); | 429 | iwl_write_restricted(priv, HBUS_TARG_MEM_WADDR, addr); |
431 | for (; 0 < len; len -= sizeof(u32), values++) | 430 | for (; 0 < len; len -= sizeof(u32), values++) |
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c index 676023a0a76f..96cb68ebc61b 100644 --- a/drivers/net/wireless/iwlwifi/iwl3945-base.c +++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c | |||
@@ -4457,7 +4457,7 @@ static void iwl_dump_nic_error_log(struct iwl_priv *priv) | |||
4457 | return; | 4457 | return; |
4458 | } | 4458 | } |
4459 | 4459 | ||
4460 | count = iwl_read_restricted_mem(priv, base); | 4460 | count = iwl_read_targ_mem(priv, base); |
4461 | 4461 | ||
4462 | if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) { | 4462 | if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) { |
4463 | IWL_ERROR("Start IWL Error Log Dump:\n"); | 4463 | IWL_ERROR("Start IWL Error Log Dump:\n"); |
@@ -4470,19 +4470,19 @@ static void iwl_dump_nic_error_log(struct iwl_priv *priv) | |||
4470 | for (i = ERROR_START_OFFSET; | 4470 | for (i = ERROR_START_OFFSET; |
4471 | i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET; | 4471 | i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET; |
4472 | i += ERROR_ELEM_SIZE) { | 4472 | i += ERROR_ELEM_SIZE) { |
4473 | desc = iwl_read_restricted_mem(priv, base + i); | 4473 | desc = iwl_read_targ_mem(priv, base + i); |
4474 | time = | 4474 | time = |
4475 | iwl_read_restricted_mem(priv, base + i + 1 * sizeof(u32)); | 4475 | iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32)); |
4476 | blink1 = | 4476 | blink1 = |
4477 | iwl_read_restricted_mem(priv, base + i + 2 * sizeof(u32)); | 4477 | iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32)); |
4478 | blink2 = | 4478 | blink2 = |
4479 | iwl_read_restricted_mem(priv, base + i + 3 * sizeof(u32)); | 4479 | iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32)); |
4480 | ilink1 = | 4480 | ilink1 = |
4481 | iwl_read_restricted_mem(priv, base + i + 4 * sizeof(u32)); | 4481 | iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32)); |
4482 | ilink2 = | 4482 | ilink2 = |
4483 | iwl_read_restricted_mem(priv, base + i + 5 * sizeof(u32)); | 4483 | iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32)); |
4484 | data1 = | 4484 | data1 = |
4485 | iwl_read_restricted_mem(priv, base + i + 6 * sizeof(u32)); | 4485 | iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32)); |
4486 | 4486 | ||
4487 | IWL_ERROR | 4487 | IWL_ERROR |
4488 | ("%-13s (#%d) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n", | 4488 | ("%-13s (#%d) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n", |
@@ -4525,14 +4525,14 @@ static void iwl_print_event_log(struct iwl_priv *priv, u32 start_idx, | |||
4525 | /* "time" is actually "data" for mode 0 (no timestamp). | 4525 | /* "time" is actually "data" for mode 0 (no timestamp). |
4526 | * place event id # at far right for easier visual parsing. */ | 4526 | * place event id # at far right for easier visual parsing. */ |
4527 | for (i = 0; i < num_events; i++) { | 4527 | for (i = 0; i < num_events; i++) { |
4528 | ev = iwl_read_restricted_mem(priv, ptr); | 4528 | ev = iwl_read_targ_mem(priv, ptr); |
4529 | ptr += sizeof(u32); | 4529 | ptr += sizeof(u32); |
4530 | time = iwl_read_restricted_mem(priv, ptr); | 4530 | time = iwl_read_targ_mem(priv, ptr); |
4531 | ptr += sizeof(u32); | 4531 | ptr += sizeof(u32); |
4532 | if (mode == 0) | 4532 | if (mode == 0) |
4533 | IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */ | 4533 | IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */ |
4534 | else { | 4534 | else { |
4535 | data = iwl_read_restricted_mem(priv, ptr); | 4535 | data = iwl_read_targ_mem(priv, ptr); |
4536 | ptr += sizeof(u32); | 4536 | ptr += sizeof(u32); |
4537 | IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev); | 4537 | IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev); |
4538 | } | 4538 | } |
@@ -4562,10 +4562,10 @@ static void iwl_dump_nic_event_log(struct iwl_priv *priv) | |||
4562 | } | 4562 | } |
4563 | 4563 | ||
4564 | /* event log header */ | 4564 | /* event log header */ |
4565 | capacity = iwl_read_restricted_mem(priv, base); | 4565 | capacity = iwl_read_targ_mem(priv, base); |
4566 | mode = iwl_read_restricted_mem(priv, base + (1 * sizeof(u32))); | 4566 | mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32))); |
4567 | num_wraps = iwl_read_restricted_mem(priv, base + (2 * sizeof(u32))); | 4567 | num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32))); |
4568 | next_entry = iwl_read_restricted_mem(priv, base + (3 * sizeof(u32))); | 4568 | next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32))); |
4569 | 4569 | ||
4570 | size = num_wraps ? capacity : next_entry; | 4570 | size = num_wraps ? capacity : next_entry; |
4571 | 4571 | ||
diff --git a/drivers/net/wireless/iwlwifi/iwl4965-base.c b/drivers/net/wireless/iwlwifi/iwl4965-base.c index e74f71fdaf92..5d19ce9bb1aa 100644 --- a/drivers/net/wireless/iwlwifi/iwl4965-base.c +++ b/drivers/net/wireless/iwlwifi/iwl4965-base.c | |||
@@ -4785,7 +4785,7 @@ static void iwl_dump_nic_error_log(struct iwl_priv *priv) | |||
4785 | return; | 4785 | return; |
4786 | } | 4786 | } |
4787 | 4787 | ||
4788 | count = iwl_read_restricted_mem(priv, base); | 4788 | count = iwl_read_targ_mem(priv, base); |
4789 | 4789 | ||
4790 | if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) { | 4790 | if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) { |
4791 | IWL_ERROR("Start IWL Error Log Dump:\n"); | 4791 | IWL_ERROR("Start IWL Error Log Dump:\n"); |
@@ -4793,15 +4793,15 @@ static void iwl_dump_nic_error_log(struct iwl_priv *priv) | |||
4793 | priv->status, priv->config, count); | 4793 | priv->status, priv->config, count); |
4794 | } | 4794 | } |
4795 | 4795 | ||
4796 | desc = iwl_read_restricted_mem(priv, base + 1 * sizeof(u32)); | 4796 | desc = iwl_read_targ_mem(priv, base + 1 * sizeof(u32)); |
4797 | blink1 = iwl_read_restricted_mem(priv, base + 3 * sizeof(u32)); | 4797 | blink1 = iwl_read_targ_mem(priv, base + 3 * sizeof(u32)); |
4798 | blink2 = iwl_read_restricted_mem(priv, base + 4 * sizeof(u32)); | 4798 | blink2 = iwl_read_targ_mem(priv, base + 4 * sizeof(u32)); |
4799 | ilink1 = iwl_read_restricted_mem(priv, base + 5 * sizeof(u32)); | 4799 | ilink1 = iwl_read_targ_mem(priv, base + 5 * sizeof(u32)); |
4800 | ilink2 = iwl_read_restricted_mem(priv, base + 6 * sizeof(u32)); | 4800 | ilink2 = iwl_read_targ_mem(priv, base + 6 * sizeof(u32)); |
4801 | data1 = iwl_read_restricted_mem(priv, base + 7 * sizeof(u32)); | 4801 | data1 = iwl_read_targ_mem(priv, base + 7 * sizeof(u32)); |
4802 | data2 = iwl_read_restricted_mem(priv, base + 8 * sizeof(u32)); | 4802 | data2 = iwl_read_targ_mem(priv, base + 8 * sizeof(u32)); |
4803 | line = iwl_read_restricted_mem(priv, base + 9 * sizeof(u32)); | 4803 | line = iwl_read_targ_mem(priv, base + 9 * sizeof(u32)); |
4804 | time = iwl_read_restricted_mem(priv, base + 11 * sizeof(u32)); | 4804 | time = iwl_read_targ_mem(priv, base + 11 * sizeof(u32)); |
4805 | 4805 | ||
4806 | IWL_ERROR("Desc Time " | 4806 | IWL_ERROR("Desc Time " |
4807 | "data1 data2 line\n"); | 4807 | "data1 data2 line\n"); |
@@ -4845,14 +4845,14 @@ static void iwl_print_event_log(struct iwl_priv *priv, u32 start_idx, | |||
4845 | /* "time" is actually "data" for mode 0 (no timestamp). | 4845 | /* "time" is actually "data" for mode 0 (no timestamp). |
4846 | * place event id # at far right for easier visual parsing. */ | 4846 | * place event id # at far right for easier visual parsing. */ |
4847 | for (i = 0; i < num_events; i++) { | 4847 | for (i = 0; i < num_events; i++) { |
4848 | ev = iwl_read_restricted_mem(priv, ptr); | 4848 | ev = iwl_read_targ_mem(priv, ptr); |
4849 | ptr += sizeof(u32); | 4849 | ptr += sizeof(u32); |
4850 | time = iwl_read_restricted_mem(priv, ptr); | 4850 | time = iwl_read_targ_mem(priv, ptr); |
4851 | ptr += sizeof(u32); | 4851 | ptr += sizeof(u32); |
4852 | if (mode == 0) | 4852 | if (mode == 0) |
4853 | IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */ | 4853 | IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */ |
4854 | else { | 4854 | else { |
4855 | data = iwl_read_restricted_mem(priv, ptr); | 4855 | data = iwl_read_targ_mem(priv, ptr); |
4856 | ptr += sizeof(u32); | 4856 | ptr += sizeof(u32); |
4857 | IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev); | 4857 | IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev); |
4858 | } | 4858 | } |
@@ -4882,10 +4882,10 @@ static void iwl_dump_nic_event_log(struct iwl_priv *priv) | |||
4882 | } | 4882 | } |
4883 | 4883 | ||
4884 | /* event log header */ | 4884 | /* event log header */ |
4885 | capacity = iwl_read_restricted_mem(priv, base); | 4885 | capacity = iwl_read_targ_mem(priv, base); |
4886 | mode = iwl_read_restricted_mem(priv, base + (1 * sizeof(u32))); | 4886 | mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32))); |
4887 | num_wraps = iwl_read_restricted_mem(priv, base + (2 * sizeof(u32))); | 4887 | num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32))); |
4888 | next_entry = iwl_read_restricted_mem(priv, base + (3 * sizeof(u32))); | 4888 | next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32))); |
4889 | 4889 | ||
4890 | size = num_wraps ? capacity : next_entry; | 4890 | size = num_wraps ? capacity : next_entry; |
4891 | 4891 | ||