1 /******************************************************************************
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.
8 * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * The full GNU General Public License is included in this distribution
25 * in the file called COPYING.
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
33 * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
34 * All rights reserved.
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62 *****************************************************************************/
63 #include "iwl-trans.h"
65 #include "iwl-eeprom-parse.h"
66 #include "iwl-eeprom-read.h"
67 #include "iwl-nvm-parse.h"
69 /* list of NVM sections we are allowed/need to read */
70 static const int nvm_to_read
[] = {
73 NVM_SECTION_TYPE_CALIBRATION
,
74 NVM_SECTION_TYPE_PRODUCTION
,
77 /* Default NVM size to read */
78 #define IWL_NVM_DEFAULT_CHUNK_SIZE (2*1024);
80 static inline void iwl_nvm_fill_read(struct iwl_nvm_access_cmd
*cmd
,
81 u16 offset
, u16 length
, u16 section
)
83 cmd
->offset
= cpu_to_le16(offset
);
84 cmd
->length
= cpu_to_le16(length
);
85 cmd
->type
= cpu_to_le16(section
);
88 static int iwl_nvm_read_chunk(struct iwl_mvm
*mvm
, u16 section
,
89 u16 offset
, u16 length
, u8
*data
)
91 struct iwl_nvm_access_cmd nvm_access_cmd
= {};
92 struct iwl_nvm_access_resp
*nvm_resp
;
93 struct iwl_rx_packet
*pkt
;
94 struct iwl_host_cmd cmd
= {
96 .flags
= CMD_SYNC
| CMD_WANT_SKB
,
97 .data
= { &nvm_access_cmd
, },
99 int ret
, bytes_read
, offset_read
;
102 iwl_nvm_fill_read(&nvm_access_cmd
, offset
, length
, section
);
103 cmd
.len
[0] = sizeof(struct iwl_nvm_access_cmd
);
105 ret
= iwl_mvm_send_cmd(mvm
, &cmd
);
110 if (pkt
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
111 IWL_ERR(mvm
, "Bad return from NVM_ACCES_COMMAND (0x%08X)\n",
117 /* Extract NVM response */
118 nvm_resp
= (void *)pkt
->data
;
119 ret
= le16_to_cpu(nvm_resp
->status
);
120 bytes_read
= le16_to_cpu(nvm_resp
->length
);
121 offset_read
= le16_to_cpu(nvm_resp
->offset
);
122 resp_data
= nvm_resp
->data
;
125 "NVM access command failed with status %d (device: %s)\n",
126 ret
, mvm
->cfg
->name
);
131 if (offset_read
!= offset
) {
132 IWL_ERR(mvm
, "NVM ACCESS response with invalid offset %d\n",
138 /* Write data to NVM */
139 memcpy(data
+ offset
, resp_data
, bytes_read
);
148 * Reads an NVM section completely.
149 * NICs prior to 7000 family doesn't have a real NVM, but just read
150 * section 0 which is the EEPROM. Because the EEPROM reading is unlimited
151 * by uCode, we need to manually check in this case that we don't
152 * overflow and try to read more than the EEPROM size.
153 * For 7000 family NICs, we supply the maximal size we can read, and
154 * the uCode fills the response with as much data as we can,
155 * without overflowing, so no check is needed.
157 static int iwl_nvm_read_section(struct iwl_mvm
*mvm
, u16 section
,
160 u16 length
, offset
= 0;
163 /* Set nvm section read length */
164 length
= IWL_NVM_DEFAULT_CHUNK_SIZE
;
168 /* Read the NVM until exhausted (reading less than requested) */
169 while (ret
== length
) {
170 ret
= iwl_nvm_read_chunk(mvm
, section
, offset
, length
, data
);
173 "Cannot read NVM from section %d offset %d, length %d\n",
174 section
, offset
, length
);
180 IWL_INFO(mvm
, "NVM section %d read completed\n", section
);
184 static struct iwl_nvm_data
*
185 iwl_parse_nvm_sections(struct iwl_mvm
*mvm
)
187 struct iwl_nvm_section
*sections
= mvm
->nvm_sections
;
188 const __le16
*hw
, *sw
, *calib
;
190 /* Checking for required sections */
191 if (!mvm
->nvm_sections
[NVM_SECTION_TYPE_SW
].data
||
192 !mvm
->nvm_sections
[NVM_SECTION_TYPE_HW
].data
) {
193 IWL_ERR(mvm
, "Can't parse empty NVM sections\n");
197 if (WARN_ON(!mvm
->cfg
))
200 hw
= (const __le16
*)sections
[NVM_SECTION_TYPE_HW
].data
;
201 sw
= (const __le16
*)sections
[NVM_SECTION_TYPE_SW
].data
;
202 calib
= (const __le16
*)sections
[NVM_SECTION_TYPE_CALIBRATION
].data
;
203 return iwl_parse_nvm_data(mvm
->trans
->dev
, mvm
->cfg
, hw
, sw
, calib
);
206 int iwl_nvm_init(struct iwl_mvm
*mvm
)
209 u8
*nvm_buffer
, *temp
;
211 /* TODO: find correct NVM max size for a section */
212 nvm_buffer
= kmalloc(mvm
->cfg
->base_params
->eeprom_size
,
216 for (i
= 0; i
< ARRAY_SIZE(nvm_to_read
); i
++) {
217 section
= nvm_to_read
[i
];
218 /* we override the constness for initial read */
219 ret
= iwl_nvm_read_section(mvm
, section
, nvm_buffer
);
222 temp
= kmemdup(nvm_buffer
, ret
, GFP_KERNEL
);
227 mvm
->nvm_sections
[section
].data
= temp
;
228 mvm
->nvm_sections
[section
].length
= ret
;
235 mvm
->nvm_data
= iwl_parse_nvm_sections(mvm
);