igbvf: cleanup flags and allow for rx checksum to be disabled
[linux-2.6.git] / drivers / net / igbvf / mbx.c
1 /*******************************************************************************
2
3   Intel(R) 82576 Virtual Function Linux driver
4   Copyright(c) 2009 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   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
24   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
25
26 *******************************************************************************/
27
28 #include "mbx.h"
29
30 /**
31  *  e1000_poll_for_msg - Wait for message notification
32  *  @hw: pointer to the HW structure
33  *
34  *  returns SUCCESS if it successfully received a message notification
35  **/
36 static s32 e1000_poll_for_msg(struct e1000_hw *hw)
37 {
38         struct e1000_mbx_info *mbx = &hw->mbx;
39         int countdown = mbx->timeout;
40
41         if (!mbx->ops.check_for_msg)
42                 goto out;
43
44         while (countdown && mbx->ops.check_for_msg(hw)) {
45                 countdown--;
46                 udelay(mbx->usec_delay);
47         }
48
49         /* if we failed, all future posted messages fail until reset */
50         if (!countdown)
51                 mbx->timeout = 0;
52 out:
53         return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
54 }
55
56 /**
57  *  e1000_poll_for_ack - Wait for message acknowledgement
58  *  @hw: pointer to the HW structure
59  *
60  *  returns SUCCESS if it successfully received a message acknowledgement
61  **/
62 static s32 e1000_poll_for_ack(struct e1000_hw *hw)
63 {
64         struct e1000_mbx_info *mbx = &hw->mbx;
65         int countdown = mbx->timeout;
66
67         if (!mbx->ops.check_for_ack)
68                 goto out;
69
70         while (countdown && mbx->ops.check_for_ack(hw)) {
71                 countdown--;
72                 udelay(mbx->usec_delay);
73         }
74
75         /* if we failed, all future posted messages fail until reset */
76         if (!countdown)
77                 mbx->timeout = 0;
78 out:
79         return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
80 }
81
82 /**
83  *  e1000_read_posted_mbx - Wait for message notification and receive message
84  *  @hw: pointer to the HW structure
85  *  @msg: The message buffer
86  *  @size: Length of buffer
87  *
88  *  returns SUCCESS if it successfully received a message notification and
89  *  copied it into the receive buffer.
90  **/
91 static s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size)
92 {
93         struct e1000_mbx_info *mbx = &hw->mbx;
94         s32 ret_val = -E1000_ERR_MBX;
95
96         if (!mbx->ops.read)
97                 goto out;
98
99         ret_val = e1000_poll_for_msg(hw);
100
101         /* if ack received read message, otherwise we timed out */
102         if (!ret_val)
103                 ret_val = mbx->ops.read(hw, msg, size);
104 out:
105         return ret_val;
106 }
107
108 /**
109  *  e1000_write_posted_mbx - Write a message to the mailbox, wait for ack
110  *  @hw: pointer to the HW structure
111  *  @msg: The message buffer
112  *  @size: Length of buffer
113  *
114  *  returns SUCCESS if it successfully copied message into the buffer and
115  *  received an ack to that message within delay * timeout period
116  **/
117 static s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size)
118 {
119         struct e1000_mbx_info *mbx = &hw->mbx;
120         s32 ret_val = -E1000_ERR_MBX;
121
122         /* exit if we either can't write or there isn't a defined timeout */
123         if (!mbx->ops.write || !mbx->timeout)
124                 goto out;
125
126         /* send msg*/
127         ret_val = mbx->ops.write(hw, msg, size);
128
129         /* if msg sent wait until we receive an ack */
130         if (!ret_val)
131                 ret_val = e1000_poll_for_ack(hw);
132 out:
133         return ret_val;
134 }
135
136 /**
137  *  e1000_read_v2p_mailbox - read v2p mailbox
138  *  @hw: pointer to the HW structure
139  *
140  *  This function is used to read the v2p mailbox without losing the read to
141  *  clear status bits.
142  **/
143 static u32 e1000_read_v2p_mailbox(struct e1000_hw *hw)
144 {
145         u32 v2p_mailbox = er32(V2PMAILBOX(0));
146
147         v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox;
148         hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS;
149
150         return v2p_mailbox;
151 }
152
153 /**
154  *  e1000_check_for_bit_vf - Determine if a status bit was set
155  *  @hw: pointer to the HW structure
156  *  @mask: bitmask for bits to be tested and cleared
157  *
158  *  This function is used to check for the read to clear bits within
159  *  the V2P mailbox.
160  **/
161 static s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
162 {
163         u32 v2p_mailbox = e1000_read_v2p_mailbox(hw);
164         s32 ret_val = -E1000_ERR_MBX;
165
166         if (v2p_mailbox & mask)
167                 ret_val = E1000_SUCCESS;
168
169         hw->dev_spec.vf.v2p_mailbox &= ~mask;
170
171         return ret_val;
172 }
173
174 /**
175  *  e1000_check_for_msg_vf - checks to see if the PF has sent mail
176  *  @hw: pointer to the HW structure
177  *
178  *  returns SUCCESS if the PF has set the Status bit or else ERR_MBX
179  **/
180 static s32 e1000_check_for_msg_vf(struct e1000_hw *hw)
181 {
182         s32 ret_val = -E1000_ERR_MBX;
183
184         if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) {
185                 ret_val = E1000_SUCCESS;
186                 hw->mbx.stats.reqs++;
187         }
188
189         return ret_val;
190 }
191
192 /**
193  *  e1000_check_for_ack_vf - checks to see if the PF has ACK'd
194  *  @hw: pointer to the HW structure
195  *
196  *  returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
197  **/
198 static s32 e1000_check_for_ack_vf(struct e1000_hw *hw)
199 {
200         s32 ret_val = -E1000_ERR_MBX;
201
202         if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) {
203                 ret_val = E1000_SUCCESS;
204                 hw->mbx.stats.acks++;
205         }
206
207         return ret_val;
208 }
209
210 /**
211  *  e1000_check_for_rst_vf - checks to see if the PF has reset
212  *  @hw: pointer to the HW structure
213  *
214  *  returns true if the PF has set the reset done bit or else false
215  **/
216 static s32 e1000_check_for_rst_vf(struct e1000_hw *hw)
217 {
218         s32 ret_val = -E1000_ERR_MBX;
219
220         if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD |
221                                          E1000_V2PMAILBOX_RSTI))) {
222                 ret_val = E1000_SUCCESS;
223                 hw->mbx.stats.rsts++;
224         }
225
226         return ret_val;
227 }
228
229 /**
230  *  e1000_obtain_mbx_lock_vf - obtain mailbox lock
231  *  @hw: pointer to the HW structure
232  *
233  *  return SUCCESS if we obtained the mailbox lock
234  **/
235 static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
236 {
237         s32 ret_val = -E1000_ERR_MBX;
238
239         /* Take ownership of the buffer */
240         ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
241
242         /* reserve mailbox for vf use */
243         if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU)
244                 ret_val = E1000_SUCCESS;
245
246         return ret_val;
247 }
248
249 /**
250  *  e1000_write_mbx_vf - Write a message to the mailbox
251  *  @hw: pointer to the HW structure
252  *  @msg: The message buffer
253  *  @size: Length of buffer
254  *
255  *  returns SUCCESS if it successfully copied message into the buffer
256  **/
257 static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size)
258 {
259         s32 err;
260         u16 i;
261
262         /* lock the mailbox to prevent pf/vf race condition */
263         err = e1000_obtain_mbx_lock_vf(hw);
264         if (err)
265                 goto out_no_write;
266
267         /* flush any ack or msg as we are going to overwrite mailbox */
268         e1000_check_for_ack_vf(hw);
269         e1000_check_for_msg_vf(hw);
270
271         /* copy the caller specified message to the mailbox memory buffer */
272         for (i = 0; i < size; i++)
273                 array_ew32(VMBMEM(0), i, msg[i]);
274
275         /* update stats */
276         hw->mbx.stats.msgs_tx++;
277
278         /* Drop VFU and interrupt the PF to tell it a message has been sent */
279         ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);
280
281 out_no_write:
282         return err;
283 }
284
285 /**
286  *  e1000_read_mbx_vf - Reads a message from the inbox intended for vf
287  *  @hw: pointer to the HW structure
288  *  @msg: The message buffer
289  *  @size: Length of buffer
290  *
291  *  returns SUCCESS if it successfuly read message from buffer
292  **/
293 static s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size)
294 {
295         s32 err;
296         u16 i;
297
298         /* lock the mailbox to prevent pf/vf race condition */
299         err = e1000_obtain_mbx_lock_vf(hw);
300         if (err)
301                 goto out_no_read;
302
303         /* copy the message from the mailbox memory buffer */
304         for (i = 0; i < size; i++)
305                 msg[i] = array_er32(VMBMEM(0), i);
306
307         /* Acknowledge receipt and release mailbox, then we're done */
308         ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
309
310         /* update stats */
311         hw->mbx.stats.msgs_rx++;
312
313 out_no_read:
314         return err;
315 }
316
317 /**
318  *  e1000_init_mbx_params_vf - set initial values for vf mailbox
319  *  @hw: pointer to the HW structure
320  *
321  *  Initializes the hw->mbx struct to correct values for vf mailbox
322  */
323 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
324 {
325         struct e1000_mbx_info *mbx = &hw->mbx;
326
327         /* start mailbox as timed out and let the reset_hw call set the timeout
328          * value to being communications */
329         mbx->timeout = 0;
330         mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
331
332         mbx->size = E1000_VFMAILBOX_SIZE;
333
334         mbx->ops.read = e1000_read_mbx_vf;
335         mbx->ops.write = e1000_write_mbx_vf;
336         mbx->ops.read_posted = e1000_read_posted_mbx;
337         mbx->ops.write_posted = e1000_write_posted_mbx;
338         mbx->ops.check_for_msg = e1000_check_for_msg_vf;
339         mbx->ops.check_for_ack = e1000_check_for_ack_vf;
340         mbx->ops.check_for_rst = e1000_check_for_rst_vf;
341
342         mbx->stats.msgs_tx = 0;
343         mbx->stats.msgs_rx = 0;
344         mbx->stats.reqs = 0;
345         mbx->stats.acks = 0;
346         mbx->stats.rsts = 0;
347
348         return E1000_SUCCESS;
349 }
350