[infiniband] Add support for performing service record lookups
[ipxe.git] / src / include / nic.h
1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License as
4 * published by the Free Software Foundation; either version 2 of the
5 * License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful, but
8 * WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10 * General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15 * 02110-1301, USA.
16 */
17
18 FILE_LICENCE ( GPL2_OR_LATER );
19
20 #ifndef NIC_H
21 #define NIC_H
22
23 #include <stdint.h>
24 #include <string.h>
25 #include <stdio.h>
26 #include <byteswap.h>
27 #include <ipxe/pci.h>
28 #include <ipxe/isapnp.h>
29 #include <ipxe/isa.h>
30 #include <ipxe/eisa.h>
31 #include <ipxe/mca.h>
32 #include <ipxe/io.h>
33
34 typedef enum {
35 DISABLE = 0,
36 ENABLE,
37 FORCE
38 } irq_action_t;
39
40 typedef enum duplex {
41 HALF_DUPLEX = 1,
42 FULL_DUPLEX
43 } duplex_t;
44
45 /*
46 * Structure returned from eth_probe and passed to other driver
47 * functions.
48 */
49 struct nic {
50 struct nic_operations *nic_op;
51 int flags; /* driver specific flags */
52 unsigned char *node_addr;
53 unsigned char *packet;
54 unsigned int packetlen;
55 unsigned int ioaddr;
56 unsigned char irqno;
57 unsigned int mbps;
58 duplex_t duplex;
59 void *priv_data; /* driver private data */
60 };
61
62 struct nic_operations {
63 int ( *connect ) ( struct nic * );
64 int ( *poll ) ( struct nic *, int retrieve );
65 void ( *transmit ) ( struct nic *, const char *,
66 unsigned int, unsigned int, const char * );
67 void ( *irq ) ( struct nic *, irq_action_t );
68 };
69
70 extern struct nic nic;
71
72 static inline int eth_poll ( int retrieve ) {
73 return nic.nic_op->poll ( &nic, retrieve );
74 }
75
76 static inline void eth_transmit ( const char *dest, unsigned int type,
77 unsigned int size, const void *packet ) {
78 nic.nic_op->transmit ( &nic, dest, type, size, packet );
79 }
80
81 /*
82 * Function prototypes
83 *
84 */
85 extern int dummy_connect ( struct nic *nic );
86 extern void dummy_irq ( struct nic *nic, irq_action_t irq_action );
87 extern int legacy_probe ( void *hwdev,
88 void ( * set_drvdata ) ( void *hwdev, void *priv ),
89 struct device *dev,
90 int ( * probe ) ( struct nic *nic, void *hwdev ),
91 void ( * disable ) ( struct nic *nic, void *hwdev ));
92 void legacy_remove ( void *hwdev,
93 void * ( * get_drvdata ) ( void *hwdev ),
94 void ( * disable ) ( struct nic *nic, void *hwdev ) );
95
96 #define PCI_DRIVER(_name,_ids,_class) \
97 static inline int \
98 _name ## _pci_legacy_probe ( struct pci_device *pci ); \
99 static inline void \
100 _name ## _pci_legacy_remove ( struct pci_device *pci ); \
101 struct pci_driver _name __pci_driver = { \
102 .ids = _ids, \
103 .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \
104 .probe = _name ## _pci_legacy_probe, \
105 .remove = _name ## _pci_legacy_remove, \
106 }; \
107 REQUIRE_OBJECT ( pci );
108
109 static inline void legacy_pci_set_drvdata ( void *hwdev, void *priv ) {
110 pci_set_drvdata ( hwdev, priv );
111 }
112 static inline void * legacy_pci_get_drvdata ( void *hwdev ) {
113 return pci_get_drvdata ( hwdev );
114 }
115
116 #define ISAPNP_DRIVER(_name,_ids) \
117 static inline int \
118 _name ## _isapnp_legacy_probe ( struct isapnp_device *isapnp, \
119 const struct isapnp_device_id *id ); \
120 static inline void \
121 _name ## _isapnp_legacy_remove ( struct isapnp_device *isapnp ); \
122 struct isapnp_driver _name __isapnp_driver = { \
123 .ids = _ids, \
124 .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \
125 .probe = _name ## _isapnp_legacy_probe, \
126 .remove = _name ## _isapnp_legacy_remove, \
127 }; \
128 REQUIRE_OBJECT ( isapnp );
129
130 static inline void legacy_isapnp_set_drvdata ( void *hwdev, void *priv ) {
131 isapnp_set_drvdata ( hwdev, priv );
132 }
133 static inline void * legacy_isapnp_get_drvdata ( void *hwdev ) {
134 return isapnp_get_drvdata ( hwdev );
135 }
136
137 #define EISA_DRIVER(_name,_ids) \
138 static inline int \
139 _name ## _eisa_legacy_probe ( struct eisa_device *eisa, \
140 const struct eisa_device_id *id ); \
141 static inline void \
142 _name ## _eisa_legacy_remove ( struct eisa_device *eisa ); \
143 struct eisa_driver _name __eisa_driver = { \
144 .ids = _ids, \
145 .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \
146 .probe = _name ## _eisa_legacy_probe, \
147 .remove = _name ## _eisa_legacy_remove, \
148 }; \
149 REQUIRE_OBJECT ( eisa );
150
151 static inline void legacy_eisa_set_drvdata ( void *hwdev, void *priv ) {
152 eisa_set_drvdata ( hwdev, priv );
153 }
154 static inline void * legacy_eisa_get_drvdata ( void *hwdev ) {
155 return eisa_get_drvdata ( hwdev );
156 }
157
158 #define MCA_DRIVER(_name,_ids) \
159 static inline int \
160 _name ## _mca_legacy_probe ( struct mca_device *mca, \
161 const struct mca_device_id *id ); \
162 static inline void \
163 _name ## _mca_legacy_remove ( struct mca_device *mca ); \
164 struct mca_driver _name __mca_driver = { \
165 .ids = _ids, \
166 .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \
167 .probe = _name ## _mca_legacy_probe, \
168 .remove = _name ## _mca_legacy_remove, \
169 }; \
170 REQUIRE_OBJECT ( mca );
171
172 static inline void legacy_mca_set_drvdata ( void *hwdev, void *priv ) {
173 mca_set_drvdata ( hwdev, priv );
174 }
175 static inline void * legacy_mca_get_drvdata ( void *hwdev ) {
176 return mca_get_drvdata ( hwdev );
177 }
178
179 #define ISA_DRIVER(_name,_probe_addrs,_probe_addr,_vendor_id,_prod_id) \
180 static inline int \
181 _name ## _isa_legacy_probe ( struct isa_device *isa ); \
182 static inline int \
183 _name ## _isa_legacy_probe_at_addr ( struct isa_device *isa ) { \
184 if ( ! _probe_addr ( isa->ioaddr ) ) \
185 return -ENODEV; \
186 return _name ## _isa_legacy_probe ( isa ); \
187 } \
188 static inline void \
189 _name ## _isa_legacy_remove ( struct isa_device *isa ); \
190 static const char _name ## _text[]; \
191 struct isa_driver _name __isa_driver = { \
192 .name = _name ## _text, \
193 .probe_addrs = _probe_addrs, \
194 .addr_count = ( sizeof ( _probe_addrs ) / \
195 sizeof ( _probe_addrs[0] ) ), \
196 .vendor_id = _vendor_id, \
197 .prod_id = _prod_id, \
198 .probe = _name ## _isa_legacy_probe_at_addr, \
199 .remove = _name ## _isa_legacy_remove, \
200 }; \
201 REQUIRE_OBJECT ( isa );
202
203 static inline void legacy_isa_set_drvdata ( void *hwdev, void *priv ) {
204 isa_set_drvdata ( hwdev, priv );
205 }
206 static inline void * legacy_isa_get_drvdata ( void *hwdev ) {
207 return isa_get_drvdata ( hwdev );
208 }
209
210 #undef DRIVER
211 #define DRIVER(_name_text,_unused2,_unused3,_name,_probe,_disable) \
212 static const char _name ## _text[] = _name_text; \
213 static inline int \
214 _name ## _probe ( struct nic *nic, void *hwdev ) { \
215 return _probe ( nic, hwdev ); \
216 } \
217 static inline void \
218 _name ## _disable ( struct nic *nic, void *hwdev ) { \
219 void ( * _unsafe_disable ) () = _disable; \
220 _unsafe_disable ( nic, hwdev ); \
221 } \
222 static inline int \
223 _name ## _pci_legacy_probe ( struct pci_device *pci ) { \
224 return legacy_probe ( pci, legacy_pci_set_drvdata, \
225 &pci->dev, _name ## _probe, \
226 _name ## _disable ); \
227 } \
228 static inline void \
229 _name ## _pci_legacy_remove ( struct pci_device *pci ) { \
230 return legacy_remove ( pci, legacy_pci_get_drvdata, \
231 _name ## _disable ); \
232 } \
233 static inline int \
234 _name ## _isapnp_legacy_probe ( struct isapnp_device *isapnp, \
235 const struct isapnp_device_id *id __unused ) { \
236 return legacy_probe ( isapnp, legacy_isapnp_set_drvdata, \
237 &isapnp->dev, _name ## _probe, \
238 _name ## _disable ); \
239 } \
240 static inline void \
241 _name ## _isapnp_legacy_remove ( struct isapnp_device *isapnp ) { \
242 return legacy_remove ( isapnp, legacy_isapnp_get_drvdata, \
243 _name ## _disable ); \
244 } \
245 static inline int \
246 _name ## _eisa_legacy_probe ( struct eisa_device *eisa, \
247 const struct eisa_device_id *id __unused ) { \
248 return legacy_probe ( eisa, legacy_eisa_set_drvdata, \
249 &eisa->dev, _name ## _probe, \
250 _name ## _disable ); \
251 } \
252 static inline void \
253 _name ## _eisa_legacy_remove ( struct eisa_device *eisa ) { \
254 return legacy_remove ( eisa, legacy_eisa_get_drvdata, \
255 _name ## _disable ); \
256 } \
257 static inline int \
258 _name ## _mca_legacy_probe ( struct mca_device *mca, \
259 const struct mca_device_id *id __unused ) { \
260 return legacy_probe ( mca, legacy_mca_set_drvdata, \
261 &mca->dev, _name ## _probe, \
262 _name ## _disable ); \
263 } \
264 static inline void \
265 _name ## _mca_legacy_remove ( struct mca_device *mca ) { \
266 return legacy_remove ( mca, legacy_mca_get_drvdata, \
267 _name ## _disable ); \
268 } \
269 static inline int \
270 _name ## _isa_legacy_probe ( struct isa_device *isa ) { \
271 return legacy_probe ( isa, legacy_isa_set_drvdata, \
272 &isa->dev, _name ## _probe, \
273 _name ## _disable ); \
274 } \
275 static inline void \
276 _name ## _isa_legacy_remove ( struct isa_device *isa ) { \
277 return legacy_remove ( isa, legacy_isa_get_drvdata, \
278 _name ## _disable ); \
279 } \
280 PROVIDE_REQUIRING_SYMBOL()
281
282 #endif /* NIC_H */