source: mainline/uspace/srv/hw/netif/dp8390/dp8390_module.c@ 7c34b28f

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 7c34b28f was acc7ce4, checked in by Martin Decky <martin@…>, 14 years ago

uspace interrupt controller drivers for i8259 and APIC (non-functional yet)
convert NE2000 driver to use these drivers (not enabling the IRQ in kernel), this solves the "spurious interrupt" issue
(however, on SMP machines this renders the driver unusable for now since the APIC driver does not do anything yet)
  • Property mode set to 100644
File size: 9.7 KB
Line 
1/*
2 * Copyright (c) 2009 Lukas Mejdrech
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup dp8390
30 * @{
31 */
32
33/** @file
34 * DP8390 network interface implementation.
35 */
36
37#include <assert.h>
38#include <async.h>
39#include <ddi.h>
40#include <errno.h>
41#include <err.h>
42#include <malloc.h>
43#include <sysinfo.h>
44#include <ipc/ipc.h>
45#include <ipc/services.h>
46#include <ipc/irc.h>
47#include <net/modules.h>
48#include <packet_client.h>
49#include <adt/measured_strings.h>
50#include <net/device.h>
51#include <nil_interface.h>
52#include <netif_interface.h>
53#include <netif_local.h>
54#include "dp8390.h"
55#include "dp8390_drv.h"
56#include "dp8390_port.h"
57
58/** DP8390 module name.
59 */
60#define NAME "dp8390"
61
62/** Return the device from the interrupt call.
63 *
64 * @param[in] call The interrupt call.
65 *
66 */
67#define IRQ_GET_DEVICE(call) ((device_id_t) IPC_GET_IMETHOD(call))
68
69/** Return the ISR from the interrupt call.
70 *
71 * @param[in] call The interrupt call.
72 *
73 */
74#define IRQ_GET_ISR(call) ((int) IPC_GET_ARG2(call))
75
76static int irc_service = 0;
77static int irc_phone = -1;
78
79/** DP8390 kernel interrupt command sequence.
80 */
81static irq_cmd_t dp8390_cmds[] = {
82 {
83 .cmd = CMD_PIO_READ_8,
84 .addr = NULL,
85 .dstarg = 2
86 },
87 {
88 .cmd = CMD_BTEST,
89 .value = 0x7f,
90 .srcarg = 2,
91 .dstarg = 3,
92 },
93 {
94 .cmd = CMD_PREDICATE,
95 .value = 2,
96 .srcarg = 3
97 },
98 {
99 .cmd = CMD_PIO_WRITE_A_8,
100 .addr = NULL,
101 .srcarg = 3
102 },
103 {
104 .cmd = CMD_ACCEPT
105 }
106};
107
108/** DP8390 kernel interrupt code.
109 */
110static irq_code_t dp8390_code = {
111 sizeof(dp8390_cmds) / sizeof(irq_cmd_t),
112 dp8390_cmds
113};
114
115/** Handles the interrupt messages.
116 * This is the interrupt handler callback function.
117 * @param[in] iid The interrupt message identifier.
118 * @param[in] call The interrupt message.
119 */
120static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
121{
122 device_id_t device_id = IRQ_GET_DEVICE(*call);
123 netif_device_t *device;
124 int nil_phone;
125 dpeth_t *dep;
126
127 fibril_rwlock_write_lock(&netif_globals.lock);
128
129 if (find_device(device_id, &device) == EOK) {
130 nil_phone = device->nil_phone;
131 dep = (dpeth_t *) device->specific;
132 } else
133 dep = NULL;
134
135 fibril_rwlock_write_unlock(&netif_globals.lock);
136
137 if ((dep != NULL) && (dep->up)) {
138 assert(dep->enabled);
139 dp_check_ints(nil_phone, device_id, dep, IRQ_GET_ISR(*call));
140 }
141}
142
143/** Change the network interface state.
144 *
145 * @param[in,out] device The network interface.
146 * @param[in] state The new state.
147 *
148 * @return The new state.
149 *
150 */
151static int change_state(netif_device_t *device, device_state_t state)
152{
153 if (device->state != state) {
154 device->state = state;
155
156 printf("%s: State changed to %s\n", NAME,
157 (state == NETIF_ACTIVE) ? "active" : "stopped");
158
159 return state;
160 }
161
162 return EOK;
163}
164
165int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
166 ipc_call_t *answer, int *answer_count)
167{
168 return ENOTSUP;
169}
170
171int netif_get_device_stats(device_id_t device_id, device_stats_t *stats)
172{
173 netif_device_t * device;
174 eth_stat_t * de_stat;
175 int rc;
176
177 if (!stats)
178 return EBADMEM;
179
180 rc = find_device(device_id, &device);
181 if (rc != EOK)
182 return rc;
183
184 de_stat = &((dpeth_t *) device->specific)->de_stat;
185
186 null_device_stats(stats);
187 stats->receive_errors = de_stat->ets_recvErr;
188 stats->send_errors = de_stat->ets_sendErr;
189 stats->receive_crc_errors = de_stat->ets_CRCerr;
190 stats->receive_frame_errors = de_stat->ets_frameAll;
191 stats->receive_missed_errors = de_stat->ets_missedP;
192 stats->receive_packets = de_stat->ets_packetR;
193 stats->send_packets = de_stat->ets_packetT;
194 stats->collisions = de_stat->ets_collision;
195 stats->send_aborted_errors = de_stat->ets_transAb;
196 stats->send_carrier_errors = de_stat->ets_carrSense;
197 stats->send_heartbeat_errors = de_stat->ets_CDheartbeat;
198 stats->send_window_errors = de_stat->ets_OWC;
199
200 return EOK;
201}
202
203int netif_get_addr_message(device_id_t device_id, measured_string_t *address)
204{
205 netif_device_t *device;
206 int rc;
207
208 if (!address)
209 return EBADMEM;
210
211 rc = find_device(device_id, &device);
212 if (rc != EOK)
213 return rc;
214
215 address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
216 address->length = sizeof(ether_addr_t);
217 return EOK;
218}
219
220int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
221{
222 netif_device_t *device;
223 dpeth_t *dep;
224 int rc;
225
226 device = (netif_device_t *) malloc(sizeof(netif_device_t));
227 if (!device)
228 return ENOMEM;
229
230 dep = (dpeth_t *) malloc(sizeof(dpeth_t));
231 if (!dep) {
232 free(device);
233 return ENOMEM;
234 }
235
236 bzero(device, sizeof(netif_device_t));
237 bzero(dep, sizeof(dpeth_t));
238 device->device_id = device_id;
239 device->nil_phone = -1;
240 device->specific = (void *) dep;
241 device->state = NETIF_STOPPED;
242 dep->de_irq = irq;
243 dep->up = false;
244
245 //TODO address?
246 rc = pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port);
247 if (rc != EOK) {
248 free(dep);
249 free(device);
250 return rc;
251 }
252
253 rc = do_probe(dep);
254 if (rc != EOK) {
255 free(dep);
256 free(device);
257 return rc;
258 }
259
260 rc = netif_device_map_add(&netif_globals.device_map, device->device_id, device);
261 if (rc != EOK) {
262 free(dep);
263 free(device);
264 return rc;
265 }
266
267 return EOK;
268}
269
270int netif_send_message(device_id_t device_id, packet_t *packet,
271 services_t sender)
272{
273 netif_device_t *device;
274 dpeth_t *dep;
275 packet_t *next;
276 int rc;
277
278 rc = find_device(device_id, &device);
279 if (rc != EOK)
280 return rc;
281
282 if (device->state != NETIF_ACTIVE) {
283 netif_pq_release(packet_get_id(packet));
284 return EFORWARD;
285 }
286
287 dep = (dpeth_t *) device->specific;
288
289 /* Process packet queue */
290 do {
291 next = pq_detach(packet);
292
293 if (do_pwrite(dep, packet, false) != EBUSY)
294 netif_pq_release(packet_get_id(packet));
295
296 packet = next;
297 } while (packet);
298
299 return EOK;
300}
301
302int netif_start_message(netif_device_t * device)
303{
304 dpeth_t *dep;
305 int rc;
306
307 if (device->state != NETIF_ACTIVE) {
308 dep = (dpeth_t *) device->specific;
309 dp8390_cmds[0].addr = (void *) (uintptr_t) (dep->de_dp8390_port + DP_ISR);
310 dp8390_cmds[3].addr = dp8390_cmds[0].addr;
311
312 rc = ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code);
313 if (rc != EOK)
314 return rc;
315
316 rc = do_init(dep);
317 if (rc != EOK) {
318 ipc_unregister_irq(dep->de_irq, device->device_id);
319 return rc;
320 }
321
322 rc = change_state(device, NETIF_ACTIVE);
323
324 if (irc_service)
325 async_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, dep->de_irq);
326
327 return rc;
328 }
329
330 return EOK;
331}
332
333int netif_stop_message(netif_device_t * device)
334{
335 dpeth_t *dep;
336
337 if (device->state != NETIF_STOPPED) {
338 dep = (dpeth_t *) device->specific;
339 do_stop(dep);
340 ipc_unregister_irq(dep->de_irq, device->device_id);
341 return change_state(device, NETIF_STOPPED);
342 }
343
344 return EOK;
345}
346
347int netif_initialize(void)
348{
349 sysarg_t apic;
350 sysarg_t i8259;
351
352 if ((sysinfo_get_value("apic", &apic) == EOK) && (apic))
353 irc_service = SERVICE_APIC;
354 else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))
355 irc_service = SERVICE_I8259;
356
357 if (irc_service) {
358 while (irc_phone < 0) {
359 irc_phone = ipc_connect_me_to_blocking(PHONE_NS, irc_service,
360 0, 0);
361 }
362 }
363
364 async_set_interrupt_received(irq_handler);
365
366 sysarg_t phonehash;
367 return ipc_connect_to_me(PHONE_NS, SERVICE_DP8390, 0, 0, &phonehash);
368}
369
370/** Default thread for new connections.
371 *
372 * @param[in] iid The initial message identifier.
373 * @param[in] icall The initial message call structure.
374 *
375 */
376static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
377{
378 /*
379 * Accept the connection
380 * - Answer the first IPC_M_CONNECT_ME_TO call.
381 */
382 ipc_answer_0(iid, EOK);
383
384 while (true) {
385 ipc_call_t answer;
386 int answer_count;
387
388 /* Clear the answer structure */
389 refresh_answer(&answer, &answer_count);
390
391 /* Fetch the next message */
392 ipc_call_t call;
393 ipc_callid_t callid = async_get_call(&call);
394
395 /* Process the message */
396 int res = netif_module_message(NAME, callid, &call, &answer,
397 &answer_count);
398
399 /* End if said to either by the message or the processing result */
400 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
401 return;
402
403 /* Answer the message */
404 answer_call(callid, res, &answer, answer_count);
405 }
406}
407
408/** Start the module.
409 *
410 * @param argc The count of the command line arguments. Ignored parameter.
411 * @param argv The command line parameters. Ignored parameter.
412 *
413 * @returns EOK on success.
414 * @returns Other error codes as defined for each specific module start function.
415 *
416 */
417int main(int argc, char *argv[])
418{
419 /* Start the module */
420 return netif_module_start(netif_client_connection);
421}
422
423/** @}
424 */
Note: See TracBrowser for help on using the repository browser.