|
1 /******************************************************************************* |
|
2 |
|
3 Intel PRO/1000 Linux driver |
|
4 Copyright(c) 1999 - 2012 Intel Corporation. |
|
5 |
|
6 This program is free software; you can redistribute it and/or modify it |
|
7 under the terms and conditions of the GNU General Public License, |
|
8 version 2, as published by the Free Software Foundation. |
|
9 |
|
10 This program is distributed in the hope it will be useful, but WITHOUT |
|
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
|
13 more details. |
|
14 |
|
15 You should have received a copy of the GNU General Public License along with |
|
16 this program; if not, write to the Free Software Foundation, Inc., |
|
17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
|
19 The full GNU General Public License is included in this distribution in |
|
20 the file called "COPYING". |
|
21 |
|
22 Contact Information: |
|
23 Linux NICS <linux.nics@intel.com> |
|
24 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> |
|
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 |
|
26 |
|
27 *******************************************************************************/ |
|
28 |
|
29 #include "e1000.h" |
|
30 |
|
31 enum e1000_mng_mode { |
|
32 e1000_mng_mode_none = 0, |
|
33 e1000_mng_mode_asf, |
|
34 e1000_mng_mode_pt, |
|
35 e1000_mng_mode_ipmi, |
|
36 e1000_mng_mode_host_if_only |
|
37 }; |
|
38 |
|
39 #define E1000_FACTPS_MNGCG 0x20000000 |
|
40 |
|
41 /* Intel(R) Active Management Technology signature */ |
|
42 #define E1000_IAMT_SIGNATURE 0x544D4149 |
|
43 |
|
44 /** |
|
45 * e1000_calculate_checksum - Calculate checksum for buffer |
|
46 * @buffer: pointer to EEPROM |
|
47 * @length: size of EEPROM to calculate a checksum for |
|
48 * |
|
49 * Calculates the checksum for some buffer on a specified length. The |
|
50 * checksum calculated is returned. |
|
51 **/ |
|
52 static u8 e1000_calculate_checksum(u8 *buffer, u32 length) |
|
53 { |
|
54 u32 i; |
|
55 u8 sum = 0; |
|
56 |
|
57 if (!buffer) |
|
58 return 0; |
|
59 |
|
60 for (i = 0; i < length; i++) |
|
61 sum += buffer[i]; |
|
62 |
|
63 return (u8)(0 - sum); |
|
64 } |
|
65 |
|
66 /** |
|
67 * e1000_mng_enable_host_if - Checks host interface is enabled |
|
68 * @hw: pointer to the HW structure |
|
69 * |
|
70 * Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND |
|
71 * |
|
72 * This function checks whether the HOST IF is enabled for command operation |
|
73 * and also checks whether the previous command is completed. It busy waits |
|
74 * in case of previous command is not completed. |
|
75 **/ |
|
76 static s32 e1000_mng_enable_host_if(struct e1000_hw *hw) |
|
77 { |
|
78 u32 hicr; |
|
79 u8 i; |
|
80 |
|
81 if (!hw->mac.arc_subsystem_valid) { |
|
82 e_dbg("ARC subsystem not valid.\n"); |
|
83 return -E1000_ERR_HOST_INTERFACE_COMMAND; |
|
84 } |
|
85 |
|
86 /* Check that the host interface is enabled. */ |
|
87 hicr = er32(HICR); |
|
88 if (!(hicr & E1000_HICR_EN)) { |
|
89 e_dbg("E1000_HOST_EN bit disabled.\n"); |
|
90 return -E1000_ERR_HOST_INTERFACE_COMMAND; |
|
91 } |
|
92 /* check the previous command is completed */ |
|
93 for (i = 0; i < E1000_MNG_DHCP_COMMAND_TIMEOUT; i++) { |
|
94 hicr = er32(HICR); |
|
95 if (!(hicr & E1000_HICR_C)) |
|
96 break; |
|
97 mdelay(1); |
|
98 } |
|
99 |
|
100 if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) { |
|
101 e_dbg("Previous command timeout failed .\n"); |
|
102 return -E1000_ERR_HOST_INTERFACE_COMMAND; |
|
103 } |
|
104 |
|
105 return 0; |
|
106 } |
|
107 |
|
108 /** |
|
109 * e1000e_check_mng_mode_generic - Generic check management mode |
|
110 * @hw: pointer to the HW structure |
|
111 * |
|
112 * Reads the firmware semaphore register and returns true (>0) if |
|
113 * manageability is enabled, else false (0). |
|
114 **/ |
|
115 bool e1000e_check_mng_mode_generic(struct e1000_hw *hw) |
|
116 { |
|
117 u32 fwsm = er32(FWSM); |
|
118 |
|
119 return (fwsm & E1000_FWSM_MODE_MASK) == |
|
120 (E1000_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT); |
|
121 } |
|
122 |
|
123 /** |
|
124 * e1000e_enable_tx_pkt_filtering - Enable packet filtering on Tx |
|
125 * @hw: pointer to the HW structure |
|
126 * |
|
127 * Enables packet filtering on transmit packets if manageability is enabled |
|
128 * and host interface is enabled. |
|
129 **/ |
|
130 bool e1000e_enable_tx_pkt_filtering(struct e1000_hw *hw) |
|
131 { |
|
132 struct e1000_host_mng_dhcp_cookie *hdr = &hw->mng_cookie; |
|
133 u32 *buffer = (u32 *)&hw->mng_cookie; |
|
134 u32 offset; |
|
135 s32 ret_val, hdr_csum, csum; |
|
136 u8 i, len; |
|
137 |
|
138 hw->mac.tx_pkt_filtering = true; |
|
139 |
|
140 /* No manageability, no filtering */ |
|
141 if (!hw->mac.ops.check_mng_mode(hw)) { |
|
142 hw->mac.tx_pkt_filtering = false; |
|
143 return hw->mac.tx_pkt_filtering; |
|
144 } |
|
145 |
|
146 /* If we can't read from the host interface for whatever |
|
147 * reason, disable filtering. |
|
148 */ |
|
149 ret_val = e1000_mng_enable_host_if(hw); |
|
150 if (ret_val) { |
|
151 hw->mac.tx_pkt_filtering = false; |
|
152 return hw->mac.tx_pkt_filtering; |
|
153 } |
|
154 |
|
155 /* Read in the header. Length and offset are in dwords. */ |
|
156 len = E1000_MNG_DHCP_COOKIE_LENGTH >> 2; |
|
157 offset = E1000_MNG_DHCP_COOKIE_OFFSET >> 2; |
|
158 for (i = 0; i < len; i++) |
|
159 *(buffer + i) = E1000_READ_REG_ARRAY(hw, E1000_HOST_IF, |
|
160 offset + i); |
|
161 hdr_csum = hdr->checksum; |
|
162 hdr->checksum = 0; |
|
163 csum = e1000_calculate_checksum((u8 *)hdr, |
|
164 E1000_MNG_DHCP_COOKIE_LENGTH); |
|
165 /* If either the checksums or signature don't match, then |
|
166 * the cookie area isn't considered valid, in which case we |
|
167 * take the safe route of assuming Tx filtering is enabled. |
|
168 */ |
|
169 if ((hdr_csum != csum) || (hdr->signature != E1000_IAMT_SIGNATURE)) { |
|
170 hw->mac.tx_pkt_filtering = true; |
|
171 return hw->mac.tx_pkt_filtering; |
|
172 } |
|
173 |
|
174 /* Cookie area is valid, make the final check for filtering. */ |
|
175 if (!(hdr->status & E1000_MNG_DHCP_COOKIE_STATUS_PARSING)) |
|
176 hw->mac.tx_pkt_filtering = false; |
|
177 |
|
178 return hw->mac.tx_pkt_filtering; |
|
179 } |
|
180 |
|
181 /** |
|
182 * e1000_mng_write_cmd_header - Writes manageability command header |
|
183 * @hw: pointer to the HW structure |
|
184 * @hdr: pointer to the host interface command header |
|
185 * |
|
186 * Writes the command header after does the checksum calculation. |
|
187 **/ |
|
188 static s32 e1000_mng_write_cmd_header(struct e1000_hw *hw, |
|
189 struct e1000_host_mng_command_header *hdr) |
|
190 { |
|
191 u16 i, length = sizeof(struct e1000_host_mng_command_header); |
|
192 |
|
193 /* Write the whole command header structure with new checksum. */ |
|
194 |
|
195 hdr->checksum = e1000_calculate_checksum((u8 *)hdr, length); |
|
196 |
|
197 length >>= 2; |
|
198 /* Write the relevant command block into the ram area. */ |
|
199 for (i = 0; i < length; i++) { |
|
200 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, i, *((u32 *)hdr + i)); |
|
201 e1e_flush(); |
|
202 } |
|
203 |
|
204 return 0; |
|
205 } |
|
206 |
|
207 /** |
|
208 * e1000_mng_host_if_write - Write to the manageability host interface |
|
209 * @hw: pointer to the HW structure |
|
210 * @buffer: pointer to the host interface buffer |
|
211 * @length: size of the buffer |
|
212 * @offset: location in the buffer to write to |
|
213 * @sum: sum of the data (not checksum) |
|
214 * |
|
215 * This function writes the buffer content at the offset given on the host if. |
|
216 * It also does alignment considerations to do the writes in most efficient |
|
217 * way. Also fills up the sum of the buffer in *buffer parameter. |
|
218 **/ |
|
219 static s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer, |
|
220 u16 length, u16 offset, u8 *sum) |
|
221 { |
|
222 u8 *tmp; |
|
223 u8 *bufptr = buffer; |
|
224 u32 data = 0; |
|
225 u16 remaining, i, j, prev_bytes; |
|
226 |
|
227 /* sum = only sum of the data and it is not checksum */ |
|
228 |
|
229 if (length == 0 || offset + length > E1000_HI_MAX_MNG_DATA_LENGTH) |
|
230 return -E1000_ERR_PARAM; |
|
231 |
|
232 tmp = (u8 *)&data; |
|
233 prev_bytes = offset & 0x3; |
|
234 offset >>= 2; |
|
235 |
|
236 if (prev_bytes) { |
|
237 data = E1000_READ_REG_ARRAY(hw, E1000_HOST_IF, offset); |
|
238 for (j = prev_bytes; j < sizeof(u32); j++) { |
|
239 *(tmp + j) = *bufptr++; |
|
240 *sum += *(tmp + j); |
|
241 } |
|
242 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset, data); |
|
243 length -= j - prev_bytes; |
|
244 offset++; |
|
245 } |
|
246 |
|
247 remaining = length & 0x3; |
|
248 length -= remaining; |
|
249 |
|
250 /* Calculate length in DWORDs */ |
|
251 length >>= 2; |
|
252 |
|
253 /* The device driver writes the relevant command block into the |
|
254 * ram area. |
|
255 */ |
|
256 for (i = 0; i < length; i++) { |
|
257 for (j = 0; j < sizeof(u32); j++) { |
|
258 *(tmp + j) = *bufptr++; |
|
259 *sum += *(tmp + j); |
|
260 } |
|
261 |
|
262 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset + i, data); |
|
263 } |
|
264 if (remaining) { |
|
265 for (j = 0; j < sizeof(u32); j++) { |
|
266 if (j < remaining) |
|
267 *(tmp + j) = *bufptr++; |
|
268 else |
|
269 *(tmp + j) = 0; |
|
270 |
|
271 *sum += *(tmp + j); |
|
272 } |
|
273 E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset + i, data); |
|
274 } |
|
275 |
|
276 return 0; |
|
277 } |
|
278 |
|
279 /** |
|
280 * e1000e_mng_write_dhcp_info - Writes DHCP info to host interface |
|
281 * @hw: pointer to the HW structure |
|
282 * @buffer: pointer to the host interface |
|
283 * @length: size of the buffer |
|
284 * |
|
285 * Writes the DHCP information to the host interface. |
|
286 **/ |
|
287 s32 e1000e_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length) |
|
288 { |
|
289 struct e1000_host_mng_command_header hdr; |
|
290 s32 ret_val; |
|
291 u32 hicr; |
|
292 |
|
293 hdr.command_id = E1000_MNG_DHCP_TX_PAYLOAD_CMD; |
|
294 hdr.command_length = length; |
|
295 hdr.reserved1 = 0; |
|
296 hdr.reserved2 = 0; |
|
297 hdr.checksum = 0; |
|
298 |
|
299 /* Enable the host interface */ |
|
300 ret_val = e1000_mng_enable_host_if(hw); |
|
301 if (ret_val) |
|
302 return ret_val; |
|
303 |
|
304 /* Populate the host interface with the contents of "buffer". */ |
|
305 ret_val = e1000_mng_host_if_write(hw, buffer, length, |
|
306 sizeof(hdr), &(hdr.checksum)); |
|
307 if (ret_val) |
|
308 return ret_val; |
|
309 |
|
310 /* Write the manageability command header */ |
|
311 ret_val = e1000_mng_write_cmd_header(hw, &hdr); |
|
312 if (ret_val) |
|
313 return ret_val; |
|
314 |
|
315 /* Tell the ARC a new command is pending. */ |
|
316 hicr = er32(HICR); |
|
317 ew32(HICR, hicr | E1000_HICR_C); |
|
318 |
|
319 return 0; |
|
320 } |
|
321 |
|
322 /** |
|
323 * e1000e_enable_mng_pass_thru - Check if management passthrough is needed |
|
324 * @hw: pointer to the HW structure |
|
325 * |
|
326 * Verifies the hardware needs to leave interface enabled so that frames can |
|
327 * be directed to and from the management interface. |
|
328 **/ |
|
329 bool e1000e_enable_mng_pass_thru(struct e1000_hw *hw) |
|
330 { |
|
331 u32 manc; |
|
332 u32 fwsm, factps; |
|
333 |
|
334 manc = er32(MANC); |
|
335 |
|
336 if (!(manc & E1000_MANC_RCV_TCO_EN)) |
|
337 return false; |
|
338 |
|
339 if (hw->mac.has_fwsm) { |
|
340 fwsm = er32(FWSM); |
|
341 factps = er32(FACTPS); |
|
342 |
|
343 if (!(factps & E1000_FACTPS_MNGCG) && |
|
344 ((fwsm & E1000_FWSM_MODE_MASK) == |
|
345 (e1000_mng_mode_pt << E1000_FWSM_MODE_SHIFT))) |
|
346 return true; |
|
347 } else if ((hw->mac.type == e1000_82574) || |
|
348 (hw->mac.type == e1000_82583)) { |
|
349 u16 data; |
|
350 |
|
351 factps = er32(FACTPS); |
|
352 e1000_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &data); |
|
353 |
|
354 if (!(factps & E1000_FACTPS_MNGCG) && |
|
355 ((data & E1000_NVM_INIT_CTRL2_MNGM) == |
|
356 (e1000_mng_mode_pt << 13))) |
|
357 return true; |
|
358 } else if ((manc & E1000_MANC_SMBUS_EN) && |
|
359 !(manc & E1000_MANC_ASF_EN)) { |
|
360 return true; |
|
361 } |
|
362 |
|
363 return false; |
|
364 } |