93a98634bd2ee2e5603e41249f02fa919022bc31
[people/oremanj/gpxe.git] / src / include / gpxe / netdevice.h
1 #ifndef _NETDEVICE_H
2 #define _NETDEVICE_H
3
4 /** @file
5  *
6  * Network device and network interface
7  *
8  */
9
10 #include <stdint.h>
11 #include <gpxe/list.h>
12
13 struct net_device;
14 struct net_interface;
15 struct pk_buff;
16
17 /** Maximum length of a link-layer address */
18 #define MAX_LLH_ADDR_LEN 6
19
20 /** Maximum length of a network-layer address */
21 #define MAX_NET_ADDR_LEN 4
22
23 /**
24  * A network device
25  *
26  * This structure represents a piece of networking hardware.  It has
27  * properties such as a link-layer address and methods for
28  * transmitting and receiving raw packets.  It does not know anything
29  * about network-layer protocols (e.g. IP) or their addresses; these
30  * are handled by struct @c net_interface instead.
31  *
32  * Note that this structure must represent a generic network device,
33  * not just an Ethernet device.
34  */
35 struct net_device {
36         /** Transmit packet
37          *
38          * @v netdev    Network device
39          * @v pkb       Packet buffer
40          * @ret rc      Return status code
41          *
42          * This method should cause the hardware to initiate
43          * transmission of the packet buffer.  The buffer may be
44          * reused immediately after the method returns, and so the
45          * method should either wait for packet transmission to
46          * complete, or take a copy of the buffer contents.
47          */
48         int ( * transmit ) ( struct net_device *netdev,
49                              struct pk_buff *pkb );
50         /** Poll for received packet
51          *
52          * @v netdev    Network device
53          * @v pkb       Packet buffer to contain received packet
54          * @ret rc      Return status code
55          *
56          * This method should cause the hardware to check for a
57          * received packet.  If no packet is available, the method
58          * should return -EAGAIN (i.e. this method is *always*
59          * considered to be a non-blocking read).  If a packet is
60          * available, the method should fill the packet buffer and
61          * return zero for success.
62          */
63         int ( * poll ) ( struct net_device *netdev, struct pk_buff *pkb );
64         /** Build link-layer header
65          *
66          * @v netdev    Network device
67          * @v pkb       Packet buffer
68          * @ret rc      Return status code
69          *
70          * This method should fill in the link-layer header based on
71          * the metadata contained in @c pkb.
72          *
73          * If a link-layer header cannot be constructed (e.g. because
74          * of a missing ARP cache entry), then this method should
75          * return an error (after transmitting an ARP request, if
76          * applicable).
77          */
78         int ( * build_llh ) ( struct net_device *netdev, struct pk_buff *pkb );
79         /** Parse link-layer header
80          *
81          * @v netdev    Network device
82          * @v pkb       Packet buffer
83          * @ret rc      Return status code
84          *
85          * This method should parse the link-layer header and fill in
86          * the metadata in @c pkb.
87          */
88         int ( * parse_llh ) ( struct net_device *netdev, struct pk_buff *pkb );
89         /** Link-layer protocol
90          *
91          * This is an ARPHRD_XXX constant, in network byte order.
92          */
93         uint16_t ll_proto;
94         /** Link-layer header length */
95         uint8_t ll_hlen;
96         /** Link-layer address length */
97         uint8_t ll_addr_len;
98         /** Link-layer address
99          *
100          * For Ethernet, this is the MAC address.
101          */
102         uint8_t ll_addr[MAX_LLH_ADDR_LEN];
103         /** Linked list of network devices */
104         struct list_head devices;
105         /** List of network interfaces */
106         struct list_head interfaces;
107         /** Driver private data */
108         void *priv;
109 };
110
111 /**
112  * A network interface
113  *
114  * This structure represents a particular network layer protocol's
115  * interface to a piece of network hardware (a struct @c net_device).
116  *
117  */
118 struct net_interface {
119         /** Underlying net device */
120         struct net_device *netdev;
121         /** Linked list of interfaces for this device */
122         struct list_head interfaces;
123         /** Network-layer protocol
124          *
125          * This is an ETH_P_XXX constant, in network byte order.
126          */
127         uint16_t net_proto;
128         /** Network-layer address length */
129         uint8_t net_addr_len;
130         /** Network-layer address */
131         uint8_t net_addr[MAX_NET_ADDR_LEN];
132         /** Fill in packet metadata
133          *
134          * @v netif     Network interface
135          * @v pkb       Packet buffer
136          * @ret rc      Return status code
137          *
138          * This method should fill in the @c pkb metadata with enough
139          * information to enable net_device::build_llh to construct
140          * the link-layer header.
141          */
142         int ( * add_llh_metadata ) ( struct net_interface *netif,
143                                      struct pk_buff *pkb );
144         /** Received packet processor
145          *
146          * @v netif     Network interface
147          * @v pkb       Packet buffer
148          * @ret rc      Return status code
149          *
150          * This method is called for packets arriving on the
151          * associated network device that match this interface's
152          * network-layer protocol.
153          *
154          * When this method is called, the link-layer header will
155          * already have been stripped from the packet.
156          */
157         int ( * rx_packet ) ( struct net_interface *netif,
158                               struct pk_buff *pkb );
159 };
160
161 /**
162  * Find interface for a specific protocol
163  *
164  * @v netdev    Network device
165  * @v net_proto Network-layer protocol, in network byte order
166  * @ret netif   Network interface, or NULL if none found
167  *
168  */
169 static inline struct net_interface *
170 netdev_find_netif ( const struct net_device *netdev, uint16_t net_proto ) {
171         struct net_interface *netif;
172
173         list_for_each_entry ( netif, &netdev->interfaces, interfaces ) {
174                 if ( netif->net_proto == net_proto )
175                         return netif;
176         }
177         return NULL;
178 }
179
180 extern int register_netdevice ( struct net_device *netdev );
181 extern void unregister_netdevice ( struct net_device *netdev );
182 extern int netdev_send ( struct net_device *netdev, struct pk_buff *pkb );
183 extern int netdev_poll ( struct net_device *netdev, struct pk_buff *pkb );
184 extern int netif_send ( struct net_interface *netif, struct pk_buff *pkb );
185 extern int netdev_rx_packet ( struct net_device *netdev, struct pk_buff *pkb );
186 extern int net_poll ( struct pk_buff *pkb, struct net_device **netdev );
187
188
189
190 extern struct net_device static_single_netdev;
191
192 /* Must be a macro because priv_data[] is of variable size */
193 #define alloc_netdevice( priv_size ) ( {                \
194         static char priv_data[priv_size];               \
195         static_single_netdev.priv = priv_data;  \
196         &static_single_netdev; } )
197
198
199 static inline void free_netdevice ( struct net_device *netdev __unused ) {
200         /* Do nothing */
201 }
202
203 #endif /* _NETDEVICE_H */