Network API now allows for multiple network devices (although the
[people/oremanj/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         int i;
48         uint16_t status;
49         uint16_t _output_length;
50
51         if ( input != NULL ) {
52                 /* Write input length */
53                 outw ( input_length, pnic->ioaddr + PNIC_REG_LEN );
54                 /* Write input data */
55                 for ( i = 0; i < input_length; i++ ) {
56                         outb( ((char*)input)[i],
57                               pnic->ioaddr + PNIC_REG_DATA );
58                 }
59         }
60         /* Write command */
61         outw ( command, pnic->ioaddr + PNIC_REG_CMD );
62         /* Retrieve status */
63         status = inw ( pnic->ioaddr + PNIC_REG_STAT );
64         /* Retrieve output length */
65         _output_length = inw ( pnic->ioaddr + PNIC_REG_LEN );
66         if ( output_length == NULL ) {
67                 if ( _output_length != output_max_length ) {
68                         printf ( "pnic_command %#hx: wrong data length "
69                                  "returned (expected %d, got %d)\n", command,
70                                  output_max_length, _output_length );
71                 }
72         } else {
73                 *output_length = _output_length;
74         }
75         if ( output != NULL ) {
76                 if ( _output_length > output_max_length ) {
77                         printf ( "pnic_command %#hx: output buffer too small "
78                                  "(have %d, need %d)\n", command,
79                                  output_max_length, _output_length );
80                         _output_length = output_max_length;
81                 }
82                 /* Retrieve output data */
83                 for ( i = 0; i < _output_length; i++ ) {
84                         ((char*)output)[i] =
85                                 inb ( pnic->ioaddr + PNIC_REG_DATA );
86                 }
87         }
88         return status;
89 }
90
91 static uint16_t pnic_command ( struct pnic *pnic, uint16_t command,
92                                void *input, uint16_t input_length,
93                                void *output, uint16_t output_max_length,
94                                uint16_t *output_length ) {
95         uint16_t status = pnic_command_quiet ( pnic, command,
96                                                input, input_length,
97                                                output, output_max_length,
98                                                output_length );
99         if ( status == PNIC_STATUS_OK ) return status;
100         printf ( "PNIC command %#hx (len %#hx) failed with status %#hx\n",
101                  command, input_length, status );
102         return status;
103 }
104
105 /* Check API version matches that of NIC */
106 static int pnic_api_check ( uint16_t api_version ) {
107         if ( api_version != PNIC_API_VERSION ) {
108                 printf ( "Warning: API version mismatch! "
109                          "(NIC's is %d.%d, ours is %d.%d)\n",
110                          api_version >> 8, api_version & 0xff,
111                          PNIC_API_VERSION >> 8, PNIC_API_VERSION & 0xff );
112         }
113         if ( api_version < PNIC_API_VERSION ) {
114                 printf ( "** You may need to update your copy of Bochs **\n" );
115         }
116         return ( api_version == PNIC_API_VERSION );
117 }
118
119 /**************************************************************************
120 POLL - Wait for a frame
121 ***************************************************************************/
122 static void pnic_poll ( struct net_device *netdev ) {
123         struct pnic *pnic = netdev->priv;
124         struct pk_buff *pkb;
125         uint16_t length;
126         uint16_t qlen;
127
128         /* Fetch all available packets */
129         while ( 1 ) {
130                 if ( pnic_command ( pnic, PNIC_CMD_RECV_QLEN, NULL, 0,
131                                     &qlen, sizeof ( qlen ), NULL )
132                      != PNIC_STATUS_OK )
133                         break;
134                 if ( qlen == 0 )
135                         break;
136                 pkb = alloc_pkb ( ETH_FRAME_LEN );
137                 if ( ! pkb )
138                         break;
139                 if ( pnic_command ( pnic, PNIC_CMD_RECV, NULL, 0,
140                                     pkb->data, ETH_FRAME_LEN, &length )
141                      != PNIC_STATUS_OK ) {
142                         free_pkb ( pkb );
143                         break;
144                 }
145                 pkb_put ( pkb, length );
146                 netdev_rx ( netdev, pkb );
147         }
148 }
149
150 /**************************************************************************
151 TRANSMIT - Transmit a frame
152 ***************************************************************************/
153 static int pnic_transmit ( struct net_device *netdev, struct pk_buff *pkb ) {
154         struct pnic *pnic = netdev->priv;
155
156         pnic_command ( pnic, PNIC_CMD_XMIT, pkb, pkb_len ( pkb ),
157                        NULL, 0, NULL );
158         free_pkb ( pkb );
159         return 0;
160 }
161
162 /**************************************************************************
163 IRQ - Handle card interrupt status
164 ***************************************************************************/
165 #if 0
166 static void pnic_irq ( struct net_device *netdev, irq_action_t action ) {
167         struct pnic *pnic = netdev->priv;
168         uint8_t enabled;
169
170         switch ( action ) {
171         case DISABLE :
172         case ENABLE :
173                 enabled = ( action == ENABLE ? 1 : 0 );
174                 pnic_command ( pnic, PNIC_CMD_MASK_IRQ,
175                                &enabled, sizeof ( enabled ), NULL, 0, NULL );
176                 break;
177         case FORCE :
178                 pnic_command ( pnic, PNIC_CMD_FORCE_IRQ,
179                                NULL, 0, NULL, 0, NULL );
180                 break;
181         }
182 }
183 #endif
184
185 /**************************************************************************
186 DISABLE - Turn off ethernet interface
187 ***************************************************************************/
188 static void pnic_remove ( struct pci_device *pci ) {
189         struct net_device *netdev = pci_get_drvdata ( pci );
190         struct pnic *pnic = netdev->priv;
191
192         unregister_netdev ( netdev );
193         pnic_command ( pnic, PNIC_CMD_RESET, NULL, 0, NULL, 0, NULL );
194 }
195
196 /**************************************************************************
197 PROBE - Look for an adapter, this routine's visible to the outside
198 ***************************************************************************/
199 static int pnic_probe ( struct pci_device *pci ) {
200         struct net_device *netdev;
201         struct pnic *pnic;
202         uint16_t api_version;
203         uint16_t status;
204         int rc;
205
206         /* Allocate net device */
207         netdev = alloc_etherdev ( sizeof ( *pnic ) );
208         if ( ! netdev ) {
209                 rc = -ENOMEM;
210                 goto err;
211         }
212         pnic = netdev->priv;
213         pci_set_drvdata ( pci, netdev );
214         pnic->ioaddr = pci->ioaddr;
215
216         /* API version check */
217         status = pnic_command_quiet ( pnic, PNIC_CMD_API_VER, NULL, 0,
218                                       &api_version,
219                                       sizeof ( api_version ), NULL );
220         if ( status != PNIC_STATUS_OK ) {
221                 printf ( "PNIC failed installation check, code %#hx\n",
222                          status );
223                 rc = -EIO;
224                 goto err;
225         }
226         pnic_api_check ( api_version );
227
228         /* Get MAC address */
229         status = pnic_command ( pnic, PNIC_CMD_READ_MAC, NULL, 0,
230                                 netdev->ll_addr, ETH_ALEN, NULL );
231
232         /* Point to NIC specific routines */
233         netdev->poll     = pnic_poll;
234         netdev->transmit = pnic_transmit;
235
236         return 0;
237
238  err:
239         /* Free net device */
240         free_netdev ( netdev );
241         return rc;
242 }
243
244 static struct pci_id pnic_nics[] = {
245 /* genrules.pl doesn't let us use macros for PCI IDs...*/
246 PCI_ROM ( 0xfefe, 0xefef, "pnic", "Bochs Pseudo NIC Adaptor" ),
247 };
248
249 static struct pci_driver pnic_driver = {
250         .ids = pnic_nics,
251         .id_count = ( sizeof ( pnic_nics ) / sizeof ( pnic_nics[0] ) ),
252         .class = PCI_NO_CLASS,
253         //      .probe = pnic_probe,
254         //      .remove = pnic_remove,
255 };
256
257 // PCI_DRIVER ( pnic_driver );
258
259 #include "dev.h"
260 extern struct type_driver test_driver;
261
262 DRIVER ( "PNIC", test_driver, pci_driver, pnic_driver,
263          pnic_probe, pnic_remove );