Make open() and close() an official part of the netdevice API.
[people/dverkamp/gpxe.git] / src / drivers / net / pnic.c
1 /**************************************************************************
2 Etherboot -  BOOTP/TFTP Bootstrap Program
3 Bochs Pseudo NIC driver for Etherboot
4 ***************************************************************************/
5
6 /*
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation; either version 2, or (at
10  * your option) any later version.
11  *
12  * See pnic_api.h for an explanation of the Bochs Pseudo NIC.
13  */
14
15 #include <stdint.h>
16 #include <io.h>
17 #include <vsprintf.h>
18 #include <errno.h>
19 #include <gpxe/pci.h>
20 #include <gpxe/if_ether.h>
21 #include <gpxe/ethernet.h>
22 #include <gpxe/pkbuff.h>
23 #include <gpxe/netdevice.h>
24
25 #include "pnic_api.h"
26
27 struct pnic {
28         unsigned short ioaddr;
29 };
30
31 /* 
32  * Utility functions: issue a PNIC command, retrieve result.  Use
33  * pnic_command_quiet if you don't want failure codes to be
34  * automatically printed.  Returns the PNIC status code.
35  * 
36  * Set output_length to NULL only if you expect to receive exactly
37  * output_max_length bytes, otherwise it'll complain that you didn't
38  * get enough data (on the assumption that if you not interested in
39  * discovering the output length then you're expecting a fixed amount
40  * of data).
41  */
42
43 static uint16_t pnic_command_quiet ( struct pnic *pnic, uint16_t command,
44                                      void *input, uint16_t input_length,
45                                      void *output, uint16_t output_max_length,
46                                      uint16_t *output_length ) {
47         uint16_t status;
48         uint16_t _output_length;
49
50         if ( input != NULL ) {
51                 /* Write input length */
52                 outw ( input_length, pnic->ioaddr + PNIC_REG_LEN );
53                 /* Write input data */
54                 outsb ( pnic->ioaddr + PNIC_REG_DATA, input, input_length );
55         }
56         /* Write command */
57         outw ( command, pnic->ioaddr + PNIC_REG_CMD );
58         /* Retrieve status */
59         status = inw ( pnic->ioaddr + PNIC_REG_STAT );
60         /* Retrieve output length */
61         _output_length = inw ( pnic->ioaddr + PNIC_REG_LEN );
62         if ( output_length == NULL ) {
63                 if ( _output_length != output_max_length ) {
64                         printf ( "pnic_command %#hx: wrong data length "
65                                  "returned (expected %d, got %d)\n", command,
66                                  output_max_length, _output_length );
67                 }
68         } else {
69                 *output_length = _output_length;
70         }
71         if ( output != NULL ) {
72                 if ( _output_length > output_max_length ) {
73                         printf ( "pnic_command %#hx: output buffer too small "
74                                  "(have %d, need %d)\n", command,
75                                  output_max_length, _output_length );
76                         _output_length = output_max_length;
77                 }
78                 /* Retrieve output data */
79                 insb ( pnic->ioaddr + PNIC_REG_DATA, output, _output_length );
80         }
81         return status;
82 }
83
84 static uint16_t pnic_command ( struct pnic *pnic, uint16_t command,
85                                void *input, uint16_t input_length,
86                                void *output, uint16_t output_max_length,
87                                uint16_t *output_length ) {
88         uint16_t status = pnic_command_quiet ( pnic, command,
89                                                input, input_length,
90                                                output, output_max_length,
91                                                output_length );
92         if ( status == PNIC_STATUS_OK ) return status;
93         printf ( "PNIC command %#hx (len %#hx) failed with status %#hx\n",
94                  command, input_length, status );
95         return status;
96 }
97
98 /* Check API version matches that of NIC */
99 static int pnic_api_check ( uint16_t api_version ) {
100         if ( api_version != PNIC_API_VERSION ) {
101                 printf ( "Warning: API version mismatch! "
102                          "(NIC's is %d.%d, ours is %d.%d)\n",
103                          api_version >> 8, api_version & 0xff,
104                          PNIC_API_VERSION >> 8, PNIC_API_VERSION & 0xff );
105         }
106         if ( api_version < PNIC_API_VERSION ) {
107                 printf ( "** You may need to update your copy of Bochs **\n" );
108         }
109         return ( api_version == PNIC_API_VERSION );
110 }
111
112 /**************************************************************************
113 POLL - Wait for a frame
114 ***************************************************************************/
115 static void pnic_poll ( struct net_device *netdev ) {
116         struct pnic *pnic = netdev->priv;
117         struct pk_buff *pkb;
118         uint16_t length;
119         uint16_t qlen;
120
121         /* Fetch all available packets */
122         while ( 1 ) {
123                 if ( pnic_command ( pnic, PNIC_CMD_RECV_QLEN, NULL, 0,
124                                     &qlen, sizeof ( qlen ), NULL )
125                      != PNIC_STATUS_OK )
126                         break;
127                 if ( qlen == 0 )
128                         break;
129                 pkb = alloc_pkb ( ETH_FRAME_LEN );
130                 if ( ! pkb ) {
131                         printf ( "could not allocate buffer\n" );
132                         break;
133                 }
134                 if ( pnic_command ( pnic, PNIC_CMD_RECV, NULL, 0,
135                                     pkb->data, ETH_FRAME_LEN, &length )
136                      != PNIC_STATUS_OK ) {
137                         free_pkb ( pkb );
138                         break;
139                 }
140                 pkb_put ( pkb, length );
141                 netdev_rx ( netdev, pkb );
142         }
143 }
144
145 /**************************************************************************
146 TRANSMIT - Transmit a frame
147 ***************************************************************************/
148 static int pnic_transmit ( struct net_device *netdev, struct pk_buff *pkb ) {
149         struct pnic *pnic = netdev->priv;
150         int pad_len;
151
152         /* Pad to minimum packet length */
153         pad_len = ( ETH_ZLEN - pkb_len ( pkb ) );
154         if ( pad_len > 0 )
155                 memset ( pkb_put ( pkb, pad_len ), 0, pad_len );
156
157         /* Send packet */
158         pnic_command ( pnic, PNIC_CMD_XMIT, pkb->data, pkb_len ( pkb ),
159                        NULL, 0, NULL );
160
161         free_pkb ( pkb );
162         return 0;
163 }
164
165 /**************************************************************************
166 IRQ - Handle card interrupt status
167 ***************************************************************************/
168 #if 0
169 static void pnic_irq ( struct net_device *netdev, irq_action_t action ) {
170         struct pnic *pnic = netdev->priv;
171         uint8_t enabled;
172
173         switch ( action ) {
174         case DISABLE :
175         case ENABLE :
176                 enabled = ( action == ENABLE ? 1 : 0 );
177                 pnic_command ( pnic, PNIC_CMD_MASK_IRQ,
178                                &enabled, sizeof ( enabled ), NULL, 0, NULL );
179                 break;
180         case FORCE :
181                 pnic_command ( pnic, PNIC_CMD_FORCE_IRQ,
182                                NULL, 0, NULL, 0, NULL );
183                 break;
184         }
185 }
186 #endif
187
188 /**************************************************************************
189 OPEN - Open network device
190 ***************************************************************************/
191 static int pnic_open ( struct net_device *netdev __unused ) {
192         return 0;
193 }
194
195 /**************************************************************************
196 CLOSE - Close network device
197 ***************************************************************************/
198 static void pnic_close ( struct net_device *netdev __unused ) {
199         /* Nothing to do */
200 }
201
202 /**************************************************************************
203 DISABLE - Turn off ethernet interface
204 ***************************************************************************/
205 static void pnic_remove ( struct pci_device *pci ) {
206         struct net_device *netdev = pci_get_drvdata ( pci );
207         struct pnic *pnic = netdev->priv;
208
209         unregister_netdev ( netdev );
210         pnic_command ( pnic, PNIC_CMD_RESET, NULL, 0, NULL, 0, NULL );
211         free_netdev ( netdev );
212 }
213
214 /**************************************************************************
215 PROBE - Look for an adapter, this routine's visible to the outside
216 ***************************************************************************/
217 static int pnic_probe ( struct pci_device *pci,
218                         const struct pci_device_id *id __unused ) {
219         struct net_device *netdev;
220         struct pnic *pnic;
221         uint16_t api_version;
222         uint16_t status;
223         int rc;
224
225         /* Fix up PCI device */
226         adjust_pci_device ( pci );
227         
228         /* Allocate net device */
229         netdev = alloc_etherdev ( sizeof ( *pnic ) );
230         if ( ! netdev ) {
231                 rc = -ENOMEM;
232                 goto err;
233         }
234         pnic = netdev->priv;
235         pci_set_drvdata ( pci, netdev );
236         pnic->ioaddr = pci->ioaddr;
237
238         /* API version check */
239         status = pnic_command_quiet ( pnic, PNIC_CMD_API_VER, NULL, 0,
240                                       &api_version,
241                                       sizeof ( api_version ), NULL );
242         if ( status != PNIC_STATUS_OK ) {
243                 printf ( "PNIC failed installation check, code %#hx\n",
244                          status );
245                 rc = -EIO;
246                 goto err;
247         }
248         pnic_api_check ( api_version );
249
250         /* Get MAC address */
251         status = pnic_command ( pnic, PNIC_CMD_READ_MAC, NULL, 0,
252                                 netdev->ll_addr, ETH_ALEN, NULL );
253
254         /* Point to NIC specific routines */
255         netdev->open     = pnic_open;
256         netdev->close    = pnic_close;
257         netdev->poll     = pnic_poll;
258         netdev->transmit = pnic_transmit;
259
260         /* Register network device */
261         if ( ( rc = register_netdev ( netdev ) ) != 0 )
262                 goto err;
263
264         return 0;
265
266  err:
267         /* Free net device */
268         free_netdev ( netdev );
269         return rc;
270 }
271
272 static struct pci_device_id pnic_nics[] = {
273 /* genrules.pl doesn't let us use macros for PCI IDs...*/
274 PCI_ROM ( 0xfefe, 0xefef, "pnic", "Bochs Pseudo NIC Adaptor" ),
275 };
276
277 struct pci_driver pnic_driver __pci_driver = {
278         .ids = pnic_nics,
279         .id_count = ( sizeof ( pnic_nics ) / sizeof ( pnic_nics[0] ) ),
280         .probe = pnic_probe,
281         .remove = pnic_remove,
282 };