1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/** @file
*
*
*
*/
/*
* Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <gpxe/netdevice.h>
#include "pxe.h"
struct net_device *pxe_netdev = NULL;
/**
* Set network device as current PXE network device
*
* @v netdev Network device, or NULL
*/
void pxe_set_netdev ( struct net_device *netdev ) {
if ( pxe_netdev )
netdev_put ( pxe_netdev );
pxe_netdev = NULL;
if ( netdev )
pxe_netdev = netdev_get ( netdev );
}
#if 0
/* Global pointer to currently installed PXE stack */
pxe_stack_t *pxe_stack = NULL;
/* Various startup/shutdown routines. The startup/shutdown call
* sequence is incredibly badly defined in the Intel PXE spec, for
* example:
*
* PXENV_UNDI_INITIALIZE says that the parameters used to initialize
* the adaptor should be those supplied to the most recent
* PXENV_UNDI_STARTUP call. PXENV_UNDI_STARTUP takes no parameters.
*
* PXENV_UNDI_CLEANUP says that the rest of the API will not be
* available after making this call. Figure 3-3 ("Early UNDI API
* usage") shows a call to PXENV_UNDI_CLEANUP being followed by a
* call to the supposedly now unavailable PXENV_STOP_UNDI.
*
* PXENV_UNLOAD_BASE_STACK talks about freeing up the memory
* occupied by the PXE stack. Figure 4-3 ("PXE IPL") shows a call
* to PXENV_STOP_UNDI being made after the call to
* PXENV_UNLOAD_BASE_STACK, by which time the entire PXE stack
* should have been freed (and, potentially, zeroed).
*
* Nothing, anywhere, seems to mention who's responsible for freeing
* up the base memory allocated for the stack segment. It's not
* even clear whether or not this is expected to be in free base
* memory rather than claimed base memory.
*
* Consequently, we adopt a rather defensive strategy, designed to
* work with any conceivable sequence of initialisation or shutdown
* calls. We have only two things that we care about:
*
* 1. Have we hooked INT 1A and INT 15,E820(etc.)?
* 2. Is the NIC initialised?
*
* The NIC should never be initialised without the vectors being
* hooked, similarly the vectors should never be unhooked with the NIC
* still initialised. We do, however, want to be able to have the
* vectors hooked with the NIC shutdown. We therefore have three
* possible states:
*
* 1. Ready to unload: interrupts unhooked, NIC shutdown.
* 2. Midway: interrupts hooked, NIC shutdown.
* 3. Fully ready: interrupts hooked, NIC initialised.
*
* We provide the three states CAN_UNLOAD, MIDWAY and READY to define
* these, and the call pxe_ensure_state() to ensure that the stack is
* in the specified state. All our PXE API call implementations
* should use this call to ensure that the state is as required for
* that PXE API call. This enables us to cope with whatever the
* end-user's interpretation of the PXE spec may be. It even allows
* for someone calling e.g. PXENV_START_UNDI followed by
* PXENV_UDP_WRITE, without bothering with any of the intervening
* calls.
*
* pxe_ensure_state() returns 1 for success, 0 for failure. In the
* event of failure (which can arise from e.g. asking for state READY
* when we don't know where our NIC is), the error code
* PXENV_STATUS_UNDI_INVALID_STATE should be returned to the user.
* The macros ENSURE_XXX() can be used to achieve this without lots of
* duplicated code.
*/
/* pxe_[un]hook_stack are architecture-specific and provided in
* pxe_callbacks.c
*/
int pxe_initialise_nic ( void ) {
if ( pxe_stack->state >= READY ) return 1;
#warning "device probing mechanism has completely changed"
#if 0
/* Check if NIC is initialised. dev.disable is set to 0
* when disable() is called, so we use this.
*/
if ( dev.disable ) {
/* NIC may have been initialised independently
* (e.g. when we set up the stack prior to calling the
* NBP).
*/
pxe_stack->state = READY;
return 1;
}
/* If we already have a NIC defined, reuse that one with
* PROBE_AWAKE. If one was specifed via PXENV_START_UNDI, try
* that one first. Otherwise, set PROBE_FIRST.
*/
if ( dev.state.pci.dev.use_specified == 1 ) {
dev.how_probe = PROBE_NEXT;
DBG ( " initialising NIC specified via START_UNDI" );
} else if ( dev.state.pci.dev.driver ) {
DBG ( " reinitialising NIC" );
dev.how_probe = PROBE_AWAKE;
} else {
DBG ( " probing for any NIC" );
dev.how_probe = PROBE_FIRST;
}
/* Call probe routine to bring up the NIC */
if ( eth_probe ( &dev ) != PROBE_WORKED ) {
DBG ( " failed" );
return 0;
}
#endif
pxe_stack->state = READY;
return 1;
}
int pxe_shutdown_nic ( void ) {
if ( pxe_stack->state <= MIDWAY ) return 1;
eth_irq ( DISABLE );
disable ( &dev );
pxe_stack->state = MIDWAY;
return 1;
}
int ensure_pxe_state ( pxe_stack_state_t wanted ) {
int success = 1;
if ( ! pxe_stack ) return 0;
if ( wanted >= MIDWAY )
success = success & hook_pxe_stack();
if ( wanted > MIDWAY ) {
success = success & pxe_initialise_nic();
} else {
success = success & pxe_shutdown_nic();
}
if ( wanted < MIDWAY )
success = success & unhook_pxe_stack();
return success;
}
#endif
|
