e79b76475ffae0b2f8b68eaa5c746c2489c02c8f
[people/lynusvaz/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 /* to get some global routines like printf */
16 #include "etherboot.h"
17 /* to get the interface to the body of the program */
18 #include "nic.h"
19 /* to get the PCI support functions, if this is a PCI NIC */
20 #include "pci.h"
21
22 /* PNIC API */
23 #include "pnic_api.h"
24
25 /* Function prototypes */
26 static int pnic_api_check ( uint16_t api_version );
27
28 /* NIC specific static variables go here */
29 static uint8_t tx_buffer[ETH_FRAME_LEN];
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 nic *nic, 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, nic->ioaddr + PNIC_REG_LEN );
54                 /* Write input data */
55                 for ( i = 0; i < input_length; i++ ) {
56                         outb( ((char*)input)[i], nic->ioaddr + PNIC_REG_DATA );
57                 }
58         }
59         /* Write command */
60         outw ( command, nic->ioaddr + PNIC_REG_CMD );
61         /* Retrieve status */
62         status = inw ( nic->ioaddr + PNIC_REG_STAT );
63         /* Retrieve output length */
64         _output_length = inw ( nic->ioaddr + PNIC_REG_LEN );
65         if ( output_length == NULL ) {
66                 if ( _output_length != output_max_length ) {
67                         printf ( "pnic_command %#hx: wrong data length "
68                                  "returned (expected %d, got %d)\n", command,
69                                  output_max_length, _output_length );
70                 }
71         } else {
72                 *output_length = _output_length;
73         }
74         if ( output != NULL ) {
75                 if ( _output_length > output_max_length ) {
76                         printf ( "pnic_command %#hx: output buffer too small "
77                                  "(have %d, need %d)\n", command,
78                                  output_max_length, _output_length );
79                         _output_length = output_max_length;
80                 }
81                 /* Retrieve output data */
82                 for ( i = 0; i < _output_length; i++ ) {
83                         ((char*)output)[i] =
84                                 inb ( nic->ioaddr + PNIC_REG_DATA );
85                 }
86         }
87         return status;
88 }
89
90 static uint16_t pnic_command ( struct nic *nic, uint16_t command,
91                                void *input, uint16_t input_length,
92                                void *output, uint16_t output_max_length,
93                                uint16_t *output_length ) {
94         uint16_t status = pnic_command_quiet ( nic, command,
95                                                input, input_length,
96                                                output, output_max_length,
97                                                output_length );
98         if ( status == PNIC_STATUS_OK ) return status;
99         printf ( "PNIC command %#hx (len %#hx) failed with status %#hx\n",
100                  command, input_length, status );
101         return status;
102 }
103
104 /* Check API version matches that of NIC */
105 static int pnic_api_check ( uint16_t api_version ) {
106         if ( api_version != PNIC_API_VERSION ) {
107                 printf ( "Warning: API version mismatch! "
108                          "(NIC's is %d.%d, ours is %d.%d)\n",
109                          api_version >> 8, api_version & 0xff,
110                          PNIC_API_VERSION >> 8, PNIC_API_VERSION & 0xff );
111         }
112         if ( api_version < PNIC_API_VERSION ) {
113                 printf ( "*** You may need to update your copy of Bochs ***\n" );
114         }
115         return ( api_version == PNIC_API_VERSION );
116 }
117
118 /**************************************************************************
119 CONNECT - connect adapter to the network
120 ***************************************************************************/
121 static int pnic_connect ( struct nic *nic __unused ) {
122         /* Nothing to do */
123         return 1;
124 }
125
126 /**************************************************************************
127 POLL - Wait for a frame
128 ***************************************************************************/
129 static int pnic_poll ( struct nic *nic, int retrieve ) {
130         uint16_t length;
131         uint16_t qlen;
132
133         /* Check receive queue length to see if there's anything to
134          * get.  Necessary since once we've called PNIC_CMD_RECV we
135          * have to read out the packet, otherwise it's lost forever.
136          */
137         if ( pnic_command ( nic, PNIC_CMD_RECV_QLEN, NULL, 0,
138                             &qlen, sizeof(qlen), NULL )
139              != PNIC_STATUS_OK ) return ( 0 );
140         if ( qlen == 0 ) return ( 0 );
141
142         /* There is a packet ready.  Return 1 if we're only checking. */
143         if ( ! retrieve ) return ( 1 );
144
145         /* Retrieve the packet */
146         if ( pnic_command ( nic, PNIC_CMD_RECV, NULL, 0,
147                             nic->packet, ETH_FRAME_LEN, &length )
148              != PNIC_STATUS_OK ) return ( 0 );
149         nic->packetlen = length;
150         return ( 1 );
151 }
152
153 /**************************************************************************
154 TRANSMIT - Transmit a frame
155 ***************************************************************************/
156 static void pnic_transmit ( struct nic *nic, const char *dest,
157                             unsigned int type, unsigned int size,
158                             const char *data ) {
159         unsigned int nstype = htons ( type );
160
161         if ( ( ETH_HLEN + size ) >= ETH_FRAME_LEN ) {
162                 printf ( "pnic_transmit: packet too large\n" );
163                 return;
164         }
165
166         /* Assemble packet */
167         memcpy ( tx_buffer, dest, ETH_ALEN );
168         memcpy ( tx_buffer + ETH_ALEN, nic->node_addr, ETH_ALEN );
169         memcpy ( tx_buffer + 2 * ETH_ALEN, &nstype, 2 );
170         memcpy ( tx_buffer + ETH_HLEN, data, size );
171
172         pnic_command ( nic, PNIC_CMD_XMIT, tx_buffer, ETH_HLEN + size,
173                        NULL, 0, NULL );
174 }
175
176 /**************************************************************************
177 DISABLE - Turn off ethernet interface
178 ***************************************************************************/
179 static void pnic_disable ( struct nic *nic ) {
180         pnic_command ( nic, PNIC_CMD_RESET, NULL, 0, NULL, 0, NULL );
181 }
182
183 /**************************************************************************
184 IRQ - Handle card interrupt status
185 ***************************************************************************/
186 static void pnic_irq ( struct nic *nic, irq_action_t action ) {
187         uint8_t enabled;
188
189         switch ( action ) {
190         case DISABLE :
191         case ENABLE :
192                 enabled = ( action == ENABLE ? 1 : 0 );
193                 pnic_command ( nic, PNIC_CMD_MASK_IRQ,
194                                &enabled, sizeof(enabled), NULL, 0, NULL );
195                 break;
196         case FORCE :
197                 pnic_command ( nic, PNIC_CMD_FORCE_IRQ,
198                                NULL, 0, NULL, 0, NULL );
199                 break;
200         }
201 }
202
203 /**************************************************************************
204 NIC operations table
205 ***************************************************************************/
206 static struct nic_operations pnic_operations = {
207         .connect        = pnic_connect,
208         .poll           = pnic_poll,
209         .transmit       = pnic_transmit,
210         .irq            = pnic_irq,
211         .disable        = pnic_disable,
212 };
213
214 /**************************************************************************
215 PROBE - Look for an adapter, this routine's visible to the outside
216 ***************************************************************************/
217
218 static int pnic_probe ( struct dev *dev, struct pci_device *pci ) {
219         struct nic *nic = nic_device ( dev );
220         uint16_t api_version;
221         uint16_t status;
222
223         /* Retrieve relevant information about PCI device */
224         nic->ioaddr = pci->ioaddr;
225         nic->irqno = pci->irq;
226
227         /* API version check */
228         status = pnic_command_quiet( nic, PNIC_CMD_API_VER, NULL, 0,
229                                      &api_version,
230                                      sizeof(api_version), NULL );
231         if ( status != PNIC_STATUS_OK ) {
232                 printf ( "PNIC failed installation check, code %#hx\n",
233                          status );
234                 return 0;
235         }
236         pnic_api_check(api_version);
237
238         /* Get MAC address */
239         status = pnic_command ( nic, PNIC_CMD_READ_MAC, NULL, 0,
240                                 nic->node_addr, ETH_ALEN, NULL );
241
242         /* point to NIC specific routines */
243         nic->nic_op     = &pnic_operations;
244         return 1;
245 }
246
247 static struct pci_id pnic_nics[] = {
248 /* genrules.pl doesn't let us use macros for PCI IDs...*/
249 PCI_ROM ( 0xfefe, 0xefef, "pnic", "Bochs Pseudo NIC Adaptor" ),
250 };
251
252 static struct pci_driver pnic_driver =
253         PCI_DRIVER ( "PNIC", pnic_nics, PCI_NO_CLASS );
254
255 BOOT_DRIVER ( "PNIC", find_pci_boot_device, pnic_driver, pnic_probe );