net/af_packet: handle possible null pointer
[dpdk.git] / drivers / net / ixgbe / ixgbe_bypass_api.h
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #ifndef _IXGBE_BYPASS_API_H_
35 #define _IXGBE_BYPASS_API_H_
36
37 #ifdef RTE_NIC_BYPASS
38
39 #include "ixgbe_bypass_defines.h"
40 /**
41  *  ixgbe_bypass_rw_generic - Bit bang data into by_pass FW
42  *
43  *  @hw: pointer to hardware structure
44  *  @cmd: Command we send to the FW
45  *  @status: The reply from the FW
46  *
47  *  Bit-bangs the cmd to the by_pass FW status points to what is returned.
48  **/
49 #define IXGBE_BYPASS_BB_WAIT 1
50 static s32 ixgbe_bypass_rw_generic(struct ixgbe_hw *hw, u32 cmd, u32 *status)
51 {
52         int i;
53         u32 sck, sdi, sdo, dir_sck, dir_sdi, dir_sdo;
54         u32 esdp;
55
56         if (!status)
57                 return IXGBE_ERR_PARAM;
58
59         *status = 0;
60
61         /* SDP vary by MAC type */
62         switch (hw->mac.type) {
63         case ixgbe_mac_82599EB:
64                 sck = IXGBE_ESDP_SDP7;
65                 sdi = IXGBE_ESDP_SDP0;
66                 sdo = IXGBE_ESDP_SDP6;
67                 dir_sck = IXGBE_ESDP_SDP7_DIR;
68                 dir_sdi = IXGBE_ESDP_SDP0_DIR;
69                 dir_sdo = IXGBE_ESDP_SDP6_DIR;
70                 break;
71         case ixgbe_mac_X540:
72                 sck = IXGBE_ESDP_SDP2;
73                 sdi = IXGBE_ESDP_SDP0;
74                 sdo = IXGBE_ESDP_SDP1;
75                 dir_sck = IXGBE_ESDP_SDP2_DIR;
76                 dir_sdi = IXGBE_ESDP_SDP0_DIR;
77                 dir_sdo = IXGBE_ESDP_SDP1_DIR;
78                 break;
79         case ixgbe_mac_X550:
80         case ixgbe_mac_X550EM_x:
81         case ixgbe_mac_X550EM_a:
82                 sck = IXGBE_ESDP_SDP2;
83                 sdi = IXGBE_ESDP_SDP0;
84                 sdo = IXGBE_ESDP_SDP1;
85                 dir_sck = IXGBE_ESDP_SDP2_DIR;
86                 dir_sdi = IXGBE_ESDP_SDP0_DIR;
87                 dir_sdo = IXGBE_ESDP_SDP1_DIR;
88                 break;
89         default:
90                 return IXGBE_ERR_DEVICE_NOT_SUPPORTED;
91         }
92
93         /* Set SDP pins direction */
94         esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
95         esdp |= dir_sck;        /* SCK as output */
96         esdp |= dir_sdi;        /* SDI as output */
97         esdp &= ~dir_sdo;       /* SDO as input */
98         esdp |= sck;
99         esdp |= sdi;
100         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
101         IXGBE_WRITE_FLUSH(hw);
102   //  TODO:
103         msleep(IXGBE_BYPASS_BB_WAIT);
104
105         /* Generate start condition */
106         esdp &= ~sdi;
107         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
108         IXGBE_WRITE_FLUSH(hw);
109         msleep(IXGBE_BYPASS_BB_WAIT);
110
111         esdp &= ~sck;
112         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
113         IXGBE_WRITE_FLUSH(hw);
114         msleep(IXGBE_BYPASS_BB_WAIT);
115
116         /* Clock out the new control word and clock in the status */
117         for (i = 0; i < 32; i++) {
118                 if ((cmd >> (31 - i)) & 0x01) {
119                         esdp |= sdi;
120                         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
121                 } else {
122                         esdp &= ~sdi;
123                         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
124                 }
125                 IXGBE_WRITE_FLUSH(hw);
126                 msleep(IXGBE_BYPASS_BB_WAIT);
127
128                 esdp |= sck;
129                 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
130                 IXGBE_WRITE_FLUSH(hw);
131                 msleep(IXGBE_BYPASS_BB_WAIT);
132
133                 esdp &= ~sck;
134                 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
135                 IXGBE_WRITE_FLUSH(hw);
136                 msleep(IXGBE_BYPASS_BB_WAIT);
137
138                 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
139                 if (esdp & sdo)
140                         *status = (*status << 1) | 0x01;
141                 else
142                         *status = (*status << 1) | 0x00;
143                 msleep(IXGBE_BYPASS_BB_WAIT);
144         }
145
146         /* stop condition */
147         esdp |= sck;
148         esdp &= ~sdi;
149         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
150         IXGBE_WRITE_FLUSH(hw);
151         msleep(IXGBE_BYPASS_BB_WAIT);
152
153         esdp |= sdi;
154         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
155         IXGBE_WRITE_FLUSH(hw);
156
157         /* set the page bits to match the cmd that the status it belongs to */
158         *status = (*status & 0x3fffffff) | (cmd & 0xc0000000);
159
160         return 0;
161 }
162
163 /**
164  * ixgbe_bypass_valid_rd_generic - Verify valid return from bit-bang.
165  *
166  * If we send a write we can't be sure it took until we can read back
167  * that same register.  It can be a problem as some of the feilds may
168  * for valid reasons change between the time wrote the register and
169  * we read it again to verify.  So this function check everything we
170  * can check and then assumes it worked.
171  *
172  * @u32 in_reg - The register cmd for the bit-bang read.
173  * @u32 out_reg - The register returned from a bit-bang read.
174  **/
175 static bool ixgbe_bypass_valid_rd_generic(u32 in_reg, u32 out_reg)
176 {
177         u32 mask;
178
179         /* Page must match for all control pages */
180         if ((in_reg & BYPASS_PAGE_M) != (out_reg & BYPASS_PAGE_M))
181                 return false;
182
183         switch (in_reg & BYPASS_PAGE_M) {
184         case BYPASS_PAGE_CTL0:
185                 /* All the following can't change since the last write
186                  *  - All the event actions
187                  *  - The timeout value
188                  */
189                 mask = BYPASS_AUX_ON_M | BYPASS_MAIN_ON_M |
190                        BYPASS_MAIN_OFF_M | BYPASS_AUX_OFF_M |
191                        BYPASS_WDTIMEOUT_M |
192                        BYPASS_WDT_VALUE_M;
193                 if ((out_reg & mask) != (in_reg & mask))
194                         return false;
195
196                 /* 0x0 is never a valid value for bypass status */
197                 if (!(out_reg & BYPASS_STATUS_OFF_M))
198                         return false;
199                 break;
200         case BYPASS_PAGE_CTL1:
201                 /* All the following can't change since the last write
202                  *  - time valid bit
203                  *  - time we last sent
204                  */
205                 mask = BYPASS_CTL1_VALID_M | BYPASS_CTL1_TIME_M;
206                 if ((out_reg & mask) != (in_reg & mask))
207                         return false;
208                 break;
209         case BYPASS_PAGE_CTL2:
210                 /* All we can check in this page is control number
211                  * which is already done above.
212                  */
213                 break;
214         }
215
216         /* We are as sure as we can be return true */
217         return true;
218 }
219
220 /**
221  *  ixgbe_bypass_set_generic - Set a bypass field in the FW CTRL Regiter.
222  *
223  *  @hw: pointer to hardware structure
224  *  @cmd: The control word we are setting.
225  *  @event: The event we are setting in the FW.  This also happens to
226  *          be the mask for the event we are setting (handy)
227  *  @action: The action we set the event to in the FW. This is in a
228  *           bit field that happens to be what we want to put in
229  *           the event spot (also handy)
230  **/
231 static s32 ixgbe_bypass_set_generic(struct ixgbe_hw *hw, u32 ctrl, u32 event,
232                              u32 action)
233 {
234         u32 by_ctl = 0;
235         u32 cmd, verify;
236         u32 count = 0;
237
238         /* Get current values */
239         cmd = ctrl;     /* just reading only need control number */
240         if (ixgbe_bypass_rw_generic(hw, cmd, &by_ctl))
241                 return IXGBE_ERR_INVALID_ARGUMENT;
242
243         /* Set to new action */
244         cmd = (by_ctl & ~event) | BYPASS_WE | action;
245         if (ixgbe_bypass_rw_generic(hw, cmd, &by_ctl))
246                 return IXGBE_ERR_INVALID_ARGUMENT;
247
248         /* Page 0 force a FW eeprom write which is slow so verify */
249         if ((cmd & BYPASS_PAGE_M) == BYPASS_PAGE_CTL0) {
250                 verify = BYPASS_PAGE_CTL0;
251                 do {
252                         if (count++ > 5)
253                                 return IXGBE_BYPASS_FW_WRITE_FAILURE;
254
255                         if (ixgbe_bypass_rw_generic(hw, verify, &by_ctl))
256                                 return IXGBE_ERR_INVALID_ARGUMENT;
257                 } while (!ixgbe_bypass_valid_rd_generic(cmd, by_ctl));
258         } else {
259                 /* We have give the FW time for the write to stick */
260                 msleep(100);
261         }
262
263         return 0;
264 }
265
266 /**
267  *  ixgbe_bypass_rd_eep_generic - Read the bypass FW eeprom address.
268  *
269  *  @hw: pointer to hardware structure
270  *  @addr: The bypass eeprom address to read.
271  *  @value: The 8b of data at the address above.
272  **/
273 static s32 ixgbe_bypass_rd_eep_generic(struct ixgbe_hw *hw, u32 addr, u8 *value)
274 {
275         u32 cmd;
276         u32 status;
277
278
279         /* send the request */
280         cmd = BYPASS_PAGE_CTL2 | BYPASS_WE;
281         cmd |= (addr << BYPASS_CTL2_OFFSET_SHIFT) & BYPASS_CTL2_OFFSET_M;
282         if (ixgbe_bypass_rw_generic(hw, cmd, &status))
283                 return IXGBE_ERR_INVALID_ARGUMENT;
284
285         /* We have give the FW time for the write to stick */
286         msleep(100);
287
288         /* now read the results */
289         cmd &= ~BYPASS_WE;
290         if (ixgbe_bypass_rw_generic(hw, cmd, &status))
291                 return IXGBE_ERR_INVALID_ARGUMENT;
292
293         *value = status & BYPASS_CTL2_DATA_M;
294
295         return 0;
296 }
297
298 #endif /* RTE_NIC_BYPASS */
299
300 #endif /* _IXGBE_BYPASS_API_H_ */