net/bnx2x: get cache line size from build configuration
[dpdk.git] / drivers / net / e1000 / igb_regs.h
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2015 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 #ifndef _IGB_REGS_H_
34 #define _IGB_REGS_H_
35
36 #include "e1000_ethdev.h"
37
38 struct reg_info {
39         uint32_t base_addr;
40         uint32_t count;
41         uint32_t stride;
42         const char *name;
43 };
44
45 static const struct reg_info igb_regs_general[] = {
46         {E1000_CTRL, 1, 1, "E1000_CTRL"},
47         {E1000_STATUS, 1, 1, "E1000_STATUS"},
48         {E1000_CTRL_EXT, 1, 1, "E1000_CTRL_EXT"},
49         {E1000_MDIC, 1, 1, "E1000_MDIC"},
50         {E1000_SCTL, 1, 1, "E1000_SCTL"},
51         {E1000_CONNSW, 1, 1, "E1000_CONNSW"},
52         {E1000_VET, 1, 1, "E1000_VET"},
53         {E1000_LEDCTL, 1, 1, "E1000_LEDCTL"},
54         {E1000_PBA, 1, 1, "E1000_PBA"},
55         {E1000_PBS, 1, 1, "E1000_PBS"},
56         {E1000_FRTIMER, 1, 1, "E1000_FRTIMER"},
57         {E1000_TCPTIMER, 1, 1, "E1000_TCPTIMER"},
58         {0, 0, 0, ""}
59 };
60
61 static const struct reg_info igb_regs_nvm[] = {
62         {E1000_EECD, 1, 1, "E1000_EECD"},
63         {0, 0, 0, ""}
64 };
65
66 static const struct reg_info igb_regs_interrupt[] = {
67         {E1000_EICS, 1, 1, "E1000_EICS"},
68         {E1000_EIMS, 1, 1, "E1000_EIMS"},
69         {E1000_EIMC, 1, 1, "E1000_EIMC"},
70         {E1000_EIAC, 1, 1, "E1000_EIAC"},
71         {E1000_EIAM, 1, 1, "E1000_EIAM"},
72         {E1000_ICS, 1, 1, "E1000_ICS"},
73         {E1000_IMS, 1, 1, "E1000_IMS"},
74         {E1000_IMC, 1, 1, "E1000_IMC"},
75         {E1000_IAC, 1, 1, "E1000_IAC"},
76         {E1000_IAM,  1, 1, "E1000_IAM"},
77         {E1000_IMIRVP, 1, 1, "E1000_IMIRVP"},
78         {E1000_EITR(0), 10, 4, "E1000_EITR"},
79         {E1000_IMIR(0), 8, 4, "E1000_IMIR"},
80         {E1000_IMIREXT(0), 8, 4, "E1000_IMIREXT"},
81         {0, 0, 0, ""}
82 };
83
84 static const struct reg_info igb_regs_fctl[] = {
85         {E1000_FCAL, 1, 1, "E1000_FCAL"},
86         {E1000_FCAH, 1, 1, "E1000_FCAH"},
87         {E1000_FCTTV, 1, 1, "E1000_FCTTV"},
88         {E1000_FCRTL, 1, 1, "E1000_FCRTL"},
89         {E1000_FCRTH, 1, 1, "E1000_FCRTH"},
90         {E1000_FCRTV, 1, 1, "E1000_FCRTV"},
91         {0, 0, 0, ""}
92 };
93
94 static const struct reg_info igb_regs_rxdma[] = {
95         {E1000_RDBAL(0), 4, 0x100, "E1000_RDBAL"},
96         {E1000_RDBAH(0), 4, 0x100, "E1000_RDBAH"},
97         {E1000_RDLEN(0), 4, 0x100, "E1000_RDLEN"},
98         {E1000_RDH(0), 4, 0x100, "E1000_RDH"},
99         {E1000_RDT(0), 4, 0x100, "E1000_RDT"},
100         {E1000_RXCTL(0), 4, 0x100, "E1000_RXCTL"},
101         {E1000_SRRCTL(0), 4, 0x100, "E1000_SRRCTL"},
102         {E1000_DCA_RXCTRL(0), 4, 0x100, "E1000_DCA_RXCTRL"},
103         {0, 0, 0, ""}
104 };
105
106 static const struct reg_info igb_regs_rx[] = {
107         {E1000_RCTL, 1, 1, "E1000_RCTL"},
108         {E1000_RXCSUM, 1, 1, "E1000_RXCSUM"},
109         {E1000_RLPML, 1, 1, "E1000_RLPML"},
110         {E1000_RFCTL, 1, 1, "E1000_RFCTL"},
111         {E1000_MRQC, 1, 1, "E1000_MRQC"},
112         {E1000_VT_CTL, 1, 1, "E1000_VT_CTL"},
113         {E1000_RAL(0), 16, 8, "E1000_RAL"},
114         {E1000_RAH(0), 16, 8, "E1000_RAH"},
115         {0, 0, 0, ""}
116 };
117
118 static const struct reg_info igb_regs_tx[] = {
119         {E1000_TCTL, 1, 1, "E1000_TCTL"},
120         {E1000_TCTL_EXT, 1, 1, "E1000_TCTL_EXT"},
121         {E1000_TIPG, 1, 1, "E1000_TIPG"},
122         {E1000_DTXCTL, 1, 1, "E1000_DTXCTL"},
123         {E1000_TDBAL(0), 4, 0x100, "E1000_TDBAL"},
124         {E1000_TDBAH(0), 4, 0x100, "E1000_TDBAH"},
125         {E1000_TDLEN(0), 4, 0x100, "E1000_TDLEN"},
126         {E1000_TDH(0), 4, 0x100, "E1000_TDLEN"},
127         {E1000_TDT(0), 4, 0x100, "E1000_TDT"},
128         {E1000_TXDCTL(0), 4, 0x100, "E1000_TXDCTL"},
129         {E1000_TDWBAL(0), 4, 0x100, "E1000_TDWBAL"},
130         {E1000_TDWBAH(0), 4, 0x100, "E1000_TDWBAH"},
131         {E1000_DCA_TXCTRL(0), 4, 0x100, "E1000_DCA_TXCTRL"},
132         {E1000_TDFH, 1, 1, "E1000_TDFH"},
133         {E1000_TDFT, 1, 1, "E1000_TDFT"},
134         {E1000_TDFHS, 1, 1, "E1000_TDFHS"},
135         {E1000_TDFPC, 1, 1, "E1000_TDFPC"},
136         {0, 0, 0, ""}
137 };
138
139 static const struct reg_info igb_regs_wakeup[] = {
140         {E1000_WUC, 1, 1, "E1000_WUC"},
141         {E1000_WUFC, 1, 1, "E1000_WUFC"},
142         {E1000_WUS, 1, 1, "E1000_WUS"},
143         {E1000_IPAV, 1, 1, "E1000_IPAV"},
144         {E1000_WUPL, 1, 1, "E1000_WUPL"},
145         {E1000_IP4AT_REG(0), 4, 8, "E1000_IP4AT_REG"},
146         {E1000_IP6AT_REG(0), 4, 4, "E1000_IP6AT_REG"},
147         {E1000_WUPM_REG(0), 4, 4, "E1000_WUPM_REG"},
148         {E1000_FFMT_REG(0), 4, 8, "E1000_FFMT_REG"},
149         {E1000_FFVT_REG(0), 4, 8, "E1000_FFVT_REG"},
150         {E1000_FFLT_REG(0), 4, 8, "E1000_FFLT_REG"},
151         {0, 0, 0, ""}
152 };
153
154 static const struct reg_info igb_regs_mac[] = {
155         {E1000_PCS_CFG0, 1, 1, "E1000_PCS_CFG0"},
156         {E1000_PCS_LCTL, 1, 1, "E1000_PCS_LCTL"},
157         {E1000_PCS_LSTAT, 1, 1, "E1000_PCS_LSTAT"},
158         {E1000_PCS_ANADV, 1, 1, "E1000_PCS_ANADV"},
159         {E1000_PCS_LPAB, 1, 1, "E1000_PCS_LPAB"},
160         {E1000_PCS_NPTX, 1, 1, "E1000_PCS_NPTX"},
161         {E1000_PCS_LPABNP, 1, 1, "E1000_PCS_LPABNP"},
162         {0, 0, 0, ""}
163 };
164
165 static const struct reg_info *igb_regs[] = {
166                                 igb_regs_general,
167                                 igb_regs_nvm,
168                                 igb_regs_interrupt,
169                                 igb_regs_fctl,
170                                 igb_regs_rxdma,
171                                 igb_regs_rx,
172                                 igb_regs_tx,
173                                 igb_regs_wakeup,
174                                 igb_regs_mac,
175                                 NULL};
176
177 /* FIXME: reading igb_regs_interrupt results side-effect which doesn't
178  * work with VFIO; re-install igb_regs_interrupt once issue is resolved.
179  */
180 static const struct reg_info *igbvf_regs[] = {
181                                 igb_regs_general,
182                                 igb_regs_rxdma,
183                                 igb_regs_tx,
184                                 NULL};
185
186 static inline int
187 igb_read_regs(struct e1000_hw *hw, const struct reg_info *reg,
188         uint32_t *reg_buf)
189 {
190         unsigned int i;
191
192         for (i = 0; i < reg->count; i++) {
193                 reg_buf[i] = E1000_READ_REG(hw,
194                                 reg->base_addr + i * reg->stride);
195         }
196         return reg->count;
197 };
198
199 static inline int
200 igb_reg_group_count(const struct reg_info *regs)
201 {
202         int count = 0;
203         int i = 0;
204
205         while (regs[i].count)
206                 count += regs[i++].count;
207         return count;
208 };
209
210 static inline int
211 igb_read_regs_group(struct rte_eth_dev *dev, uint32_t *reg_buf,
212                 const struct reg_info *regs)
213 {
214         int count = 0;
215         int i = 0;
216         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
217
218         while (regs[i].count)
219                 count += igb_read_regs(hw, &regs[i++], &reg_buf[count]);
220         return count;
221 };
222
223 #endif /* _IGB_REGS_H_ */