1 /*******************************************************************************
3 Intel PRO/1000 Linux driver
4 Copyright(c) 1999 - 2008 Intel Corporation.
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.
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
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.
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
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
27 *******************************************************************************/
29 #include "e1000_api.h"
31 static u8
e1000_calculate_checksum(u8
*buffer
, u32 length
);
34 * e1000_calculate_checksum - Calculate checksum for buffer
35 * @buffer: pointer to EEPROM
36 * @length: size of EEPROM to calculate a checksum for
38 * Calculates the checksum for some buffer on a specified length. The
39 * checksum calculated is returned.
41 static u8
e1000_calculate_checksum(u8
*buffer
, u32 length
)
46 DEBUGFUNC("e1000_calculate_checksum");
51 for (i
= 0; i
< length
; i
++)
54 return (u8
) (0 - sum
);
58 * e1000_mng_enable_host_if_generic - Checks host interface is enabled
59 * @hw: pointer to the HW structure
61 * Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
63 * This function checks whether the HOST IF is enabled for command operation
64 * and also checks whether the previous command is completed. It busy waits
65 * in case of previous command is not completed.
67 s32
e1000_mng_enable_host_if_generic(struct e1000_hw
*hw
)
70 s32 ret_val
= E1000_SUCCESS
;
73 DEBUGFUNC("e1000_mng_enable_host_if_generic");
75 /* Check that the host interface is enabled. */
76 hicr
= E1000_READ_REG(hw
, E1000_HICR
);
77 if ((hicr
& E1000_HICR_EN
) == 0) {
78 DEBUGOUT("E1000_HOST_EN bit disabled.\n");
79 ret_val
= -E1000_ERR_HOST_INTERFACE_COMMAND
;
82 /* check the previous command is completed */
83 for (i
= 0; i
< E1000_MNG_DHCP_COMMAND_TIMEOUT
; i
++) {
84 hicr
= E1000_READ_REG(hw
, E1000_HICR
);
85 if (!(hicr
& E1000_HICR_C
))
90 if (i
== E1000_MNG_DHCP_COMMAND_TIMEOUT
) {
91 DEBUGOUT("Previous command timeout failed .\n");
92 ret_val
= -E1000_ERR_HOST_INTERFACE_COMMAND
;
101 * e1000_check_mng_mode_generic - Generic check management mode
102 * @hw: pointer to the HW structure
104 * Reads the firmware semaphore register and returns true (>0) if
105 * manageability is enabled, else false (0).
107 bool e1000_check_mng_mode_generic(struct e1000_hw
*hw
)
111 DEBUGFUNC("e1000_check_mng_mode_generic");
113 fwsm
= E1000_READ_REG(hw
, E1000_FWSM
);
115 return (fwsm
& E1000_FWSM_MODE_MASK
) ==
116 (E1000_MNG_IAMT_MODE
<< E1000_FWSM_MODE_SHIFT
);
120 * e1000_enable_tx_pkt_filtering_generic - Enable packet filtering on TX
121 * @hw: pointer to the HW structure
123 * Enables packet filtering on transmit packets if manageability is enabled
124 * and host interface is enabled.
126 bool e1000_enable_tx_pkt_filtering_generic(struct e1000_hw
*hw
)
128 struct e1000_host_mng_dhcp_cookie
*hdr
= &hw
->mng_cookie
;
129 u32
*buffer
= (u32
*)&hw
->mng_cookie
;
131 s32 ret_val
, hdr_csum
, csum
;
133 bool tx_filter
= true;
135 DEBUGFUNC("e1000_enable_tx_pkt_filtering_generic");
137 /* No manageability, no filtering */
138 if (!hw
->mac
.ops
.check_mng_mode(hw
)) {
144 * If we can't read from the host interface for whatever
145 * reason, disable filtering.
147 ret_val
= hw
->mac
.ops
.mng_enable_host_if(hw
);
148 if (ret_val
!= E1000_SUCCESS
) {
153 /* Read in the header. Length and offset are in dwords. */
154 len
= E1000_MNG_DHCP_COOKIE_LENGTH
>> 2;
155 offset
= E1000_MNG_DHCP_COOKIE_OFFSET
>> 2;
156 for (i
= 0; i
< len
; i
++) {
157 *(buffer
+ i
) = E1000_READ_REG_ARRAY_DWORD(hw
,
161 hdr_csum
= hdr
->checksum
;
163 csum
= e1000_calculate_checksum((u8
*)hdr
,
164 E1000_MNG_DHCP_COOKIE_LENGTH
);
166 * If either the checksums or signature don't match, then
167 * the cookie area isn't considered valid, in which case we
168 * take the safe route of assuming Tx filtering is enabled.
170 if (hdr_csum
!= csum
)
172 if (hdr
->signature
!= E1000_IAMT_SIGNATURE
)
175 /* Cookie area is valid, make the final check for filtering. */
176 if (!(hdr
->status
& E1000_MNG_DHCP_COOKIE_STATUS_PARSING
))
180 hw
->mac
.tx_pkt_filtering
= tx_filter
;
185 * e1000_mng_write_dhcp_info_generic - Writes DHCP info to host interface
186 * @hw: pointer to the HW structure
187 * @buffer: pointer to the host interface
188 * @length: size of the buffer
190 * Writes the DHCP information to the host interface.
192 s32
e1000_mng_write_dhcp_info_generic(struct e1000_hw
*hw
, u8
*buffer
,
195 struct e1000_host_mng_command_header hdr
;
199 DEBUGFUNC("e1000_mng_write_dhcp_info_generic");
201 hdr
.command_id
= E1000_MNG_DHCP_TX_PAYLOAD_CMD
;
202 hdr
.command_length
= length
;
207 /* Enable the host interface */
208 ret_val
= hw
->mac
.ops
.mng_enable_host_if(hw
);
212 /* Populate the host interface with the contents of "buffer". */
213 ret_val
= hw
->mac
.ops
.mng_host_if_write(hw
, buffer
, length
,
214 sizeof(hdr
), &(hdr
.checksum
));
218 /* Write the manageability command header */
219 ret_val
= hw
->mac
.ops
.mng_write_cmd_header(hw
, &hdr
);
223 /* Tell the ARC a new command is pending. */
224 hicr
= E1000_READ_REG(hw
, E1000_HICR
);
225 E1000_WRITE_REG(hw
, E1000_HICR
, hicr
| E1000_HICR_C
);
232 * e1000_mng_write_cmd_header_generic - Writes manageability command header
233 * @hw: pointer to the HW structure
234 * @hdr: pointer to the host interface command header
236 * Writes the command header after does the checksum calculation.
238 s32
e1000_mng_write_cmd_header_generic(struct e1000_hw
*hw
,
239 struct e1000_host_mng_command_header
*hdr
)
241 u16 i
, length
= sizeof(struct e1000_host_mng_command_header
);
243 DEBUGFUNC("e1000_mng_write_cmd_header_generic");
245 /* Write the whole command header structure with new checksum. */
247 hdr
->checksum
= e1000_calculate_checksum((u8
*)hdr
, length
);
250 /* Write the relevant command block into the ram area. */
251 for (i
= 0; i
< length
; i
++) {
252 E1000_WRITE_REG_ARRAY_DWORD(hw
, E1000_HOST_IF
, i
,
254 E1000_WRITE_FLUSH(hw
);
257 return E1000_SUCCESS
;
261 * e1000_mng_host_if_write_generic - Write to the manageability host interface
262 * @hw: pointer to the HW structure
263 * @buffer: pointer to the host interface buffer
264 * @length: size of the buffer
265 * @offset: location in the buffer to write to
266 * @sum: sum of the data (not checksum)
268 * This function writes the buffer content at the offset given on the host if.
269 * It also does alignment considerations to do the writes in most efficient
270 * way. Also fills up the sum of the buffer in *buffer parameter.
272 s32
e1000_mng_host_if_write_generic(struct e1000_hw
*hw
, u8
*buffer
,
273 u16 length
, u16 offset
, u8
*sum
)
278 s32 ret_val
= E1000_SUCCESS
;
279 u16 remaining
, i
, j
, prev_bytes
;
281 DEBUGFUNC("e1000_mng_host_if_write_generic");
283 /* sum = only sum of the data and it is not checksum */
285 if (length
== 0 || offset
+ length
> E1000_HI_MAX_MNG_DATA_LENGTH
) {
286 ret_val
= -E1000_ERR_PARAM
;
291 prev_bytes
= offset
& 0x3;
295 data
= E1000_READ_REG_ARRAY_DWORD(hw
, E1000_HOST_IF
, offset
);
296 for (j
= prev_bytes
; j
< sizeof(u32
); j
++) {
297 *(tmp
+ j
) = *bufptr
++;
300 E1000_WRITE_REG_ARRAY_DWORD(hw
, E1000_HOST_IF
, offset
, data
);
301 length
-= j
- prev_bytes
;
305 remaining
= length
& 0x3;
308 /* Calculate length in DWORDs */
312 * The device driver writes the relevant command block into the
315 for (i
= 0; i
< length
; i
++) {
316 for (j
= 0; j
< sizeof(u32
); j
++) {
317 *(tmp
+ j
) = *bufptr
++;
321 E1000_WRITE_REG_ARRAY_DWORD(hw
, E1000_HOST_IF
, offset
+ i
,
325 for (j
= 0; j
< sizeof(u32
); j
++) {
327 *(tmp
+ j
) = *bufptr
++;
333 E1000_WRITE_REG_ARRAY_DWORD(hw
, E1000_HOST_IF
, offset
+ i
, data
);
341 * e1000_enable_mng_pass_thru - Enable processing of ARP's
342 * @hw: pointer to the HW structure
344 * Verifies the hardware needs to allow ARPs to be processed by the host.
346 bool e1000_enable_mng_pass_thru(struct e1000_hw
*hw
)
350 bool ret_val
= false;
352 DEBUGFUNC("e1000_enable_mng_pass_thru");
354 if (!hw
->mac
.asf_firmware_present
)
357 manc
= E1000_READ_REG(hw
, E1000_MANC
);
359 if (!(manc
& E1000_MANC_RCV_TCO_EN
) ||
360 !(manc
& E1000_MANC_EN_MAC_ADDR_FILTER
))
363 if (hw
->mac
.arc_subsystem_valid
) {
364 fwsm
= E1000_READ_REG(hw
, E1000_FWSM
);
365 factps
= E1000_READ_REG(hw
, E1000_FACTPS
);
367 if (!(factps
& E1000_FACTPS_MNGCG
) &&
368 ((fwsm
& E1000_FWSM_MODE_MASK
) ==
369 (e1000_mng_mode_pt
<< E1000_FWSM_MODE_SHIFT
))) {
374 if ((manc
& E1000_MANC_SMBUS_EN
) &&
375 !(manc
& E1000_MANC_ASF_EN
)) {