source: mainline/uspace/drv/nic/ne2k/ne2k.c@ 5fd9c30

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 5fd9c30 was d51838f, checked in by Jiri Svoboda <jiri@…>, 8 years ago

Let leaf drivers enable/disable/clear interrupts via hw_res instead of directly using irc.
  • Property mode set to 100644
File size: 10.9 KB
Line 
1/*
2 * Copyright (c) 2011 Martin Decky
3 * Copyright (c) 2011 Radim Vansa
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/**
31 * @addtogroup drv_ne2k
32 * @brief Novell NE2000 NIC driver
33 * @{
34 */
35/**
36 * @file
37 * @brief Bridge between NICF, DDF and business logic for the NIC
38 */
39
40#include <stdio.h>
41#include <errno.h>
42#include <device/hw_res.h>
43#include <stdlib.h>
44#include <str_error.h>
45#include <async.h>
46#include "dp8390.h"
47
48#define NAME "ne2k"
49
50/** Return the ISR from the interrupt call.
51 *
52 * @param[in] call The interrupt call.
53 *
54 */
55#define IRQ_GET_ISR(call) ((int) IPC_GET_ARG2(call))
56
57/** Return the TSR from the interrupt call.
58 *
59 * @param[in] call The interrupt call.
60 *
61 */
62#define IRQ_GET_TSR(call) ((int) IPC_GET_ARG3(call))
63
64#define DRIVER_DATA(dev) ((nic_t *) ddf_dev_data_get(dev))
65#define NE2K(device) ((ne2k_t *) nic_get_specific(DRIVER_DATA(device)))
66
67static irq_pio_range_t ne2k_ranges_prototype[] = {
68 {
69 .base = 0,
70 .size = NE2K_IO_SIZE,
71 }
72};
73
74/** NE2000 kernel interrupt command sequence.
75 *
76 */
77static irq_cmd_t ne2k_cmds_prototype[] = {
78 {
79 /* Read Interrupt Status Register */
80 .cmd = CMD_PIO_READ_8,
81 .addr = NULL,
82 .dstarg = 2
83 },
84 {
85 /* Mask supported interrupt causes */
86 .cmd = CMD_AND,
87 .value = (ISR_PRX | ISR_PTX | ISR_RXE | ISR_TXE | ISR_OVW |
88 ISR_CNT | ISR_RDC),
89 .srcarg = 2,
90 .dstarg = 3,
91 },
92 {
93 /* Predicate for accepting the interrupt */
94 .cmd = CMD_PREDICATE,
95 .value = 4,
96 .srcarg = 3
97 },
98 {
99 /*
100 * Mask future interrupts via
101 * Interrupt Mask Register
102 */
103 .cmd = CMD_PIO_WRITE_8,
104 .addr = NULL,
105 .value = 0
106 },
107 {
108 /* Acknowledge the current interrupt */
109 .cmd = CMD_PIO_WRITE_A_8,
110 .addr = NULL,
111 .srcarg = 3
112 },
113 {
114 /* Read Transmit Status Register */
115 .cmd = CMD_PIO_READ_8,
116 .addr = NULL,
117 .dstarg = 3
118 },
119 {
120 .cmd = CMD_ACCEPT
121 }
122};
123
124static void ne2k_interrupt_handler(ipc_callid_t, ipc_call_t *, ddf_dev_t *);
125
126static int ne2k_register_interrupt(nic_t *nic_data)
127{
128 ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
129
130 if (ne2k->code.cmdcount == 0) {
131 irq_pio_range_t *ne2k_ranges;
132 irq_cmd_t *ne2k_cmds;
133
134 ne2k_ranges = malloc(sizeof(ne2k_ranges_prototype));
135 if (!ne2k_ranges)
136 return ENOMEM;
137 memcpy(ne2k_ranges, ne2k_ranges_prototype,
138 sizeof(ne2k_ranges_prototype));
139 ne2k_ranges[0].base = (uintptr_t) ne2k->base_port;
140
141 ne2k_cmds = malloc(sizeof(ne2k_cmds_prototype));
142 if (!ne2k_cmds) {
143 free(ne2k_ranges);
144 return ENOMEM;
145 }
146 memcpy(ne2k_cmds, ne2k_cmds_prototype,
147 sizeof(ne2k_cmds_prototype));
148 ne2k_cmds[0].addr = ne2k->base_port + DP_ISR;
149 ne2k_cmds[3].addr = ne2k->base_port + DP_IMR;
150 ne2k_cmds[4].addr = ne2k_cmds[0].addr;
151 ne2k_cmds[5].addr = ne2k->base_port + DP_TSR;
152
153 ne2k->code.rangecount = sizeof(ne2k_ranges_prototype) /
154 sizeof(irq_pio_range_t);
155 ne2k->code.ranges = ne2k_ranges;
156
157 ne2k->code.cmdcount = sizeof(ne2k_cmds_prototype) /
158 sizeof(irq_cmd_t);
159 ne2k->code.cmds = ne2k_cmds;
160 }
161
162 int irq_cap = register_interrupt_handler(nic_get_ddf_dev(nic_data),
163 ne2k->irq, ne2k_interrupt_handler, &ne2k->code);
164 return irq_cap;
165}
166
167static ddf_dev_ops_t ne2k_dev_ops;
168
169static void ne2k_dev_cleanup(ddf_dev_t *dev)
170{
171 if (ddf_dev_data_get(dev) != NULL) {
172 ne2k_t *ne2k = NE2K(dev);
173 if (ne2k) {
174 free(ne2k->code.ranges);
175 free(ne2k->code.cmds);
176 }
177 nic_unbind_and_destroy(dev);
178 }
179}
180
181static int ne2k_dev_init(nic_t *nic_data)
182{
183 /* Get HW resources */
184 hw_res_list_parsed_t hw_res_parsed;
185 hw_res_list_parsed_init(&hw_res_parsed);
186
187 int rc = nic_get_resources(nic_data, &hw_res_parsed);
188
189 if (rc != EOK)
190 goto failed;
191
192 if (hw_res_parsed.irqs.count == 0) {
193 rc = EINVAL;
194 goto failed;
195 }
196
197 if (hw_res_parsed.io_ranges.count == 0) {
198 rc = EINVAL;
199 goto failed;
200 }
201
202 if (hw_res_parsed.io_ranges.ranges[0].size < NE2K_IO_SIZE) {
203 rc = EINVAL;
204 goto failed;
205 }
206
207 ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
208 ne2k->irq = hw_res_parsed.irqs.irqs[0];
209
210 addr_range_t regs = hw_res_parsed.io_ranges.ranges[0];
211 ne2k->base_port = RNGABSPTR(regs);
212
213 hw_res_list_parsed_clean(&hw_res_parsed);
214
215 /* Enable programmed I/O */
216 if (pio_enable_range(&regs, &ne2k->port) != EOK)
217 return EADDRNOTAVAIL;
218
219 ne2k->data_port = ne2k->port + NE2K_DATA;
220 ne2k->receive_configuration = RCR_AB | RCR_AM;
221 ne2k->probed = false;
222 ne2k->up = false;
223
224 /* Find out whether the device is present. */
225 if (ne2k_probe(ne2k) != EOK)
226 return ENOENT;
227
228 ne2k->probed = true;
229
230 int irq_cap = ne2k_register_interrupt(nic_data);
231 if (irq_cap < 0)
232 return EINVAL;
233
234 return EOK;
235
236failed:
237 hw_res_list_parsed_clean(&hw_res_parsed);
238 return rc;
239}
240
241void ne2k_interrupt_handler(ipc_callid_t iid, ipc_call_t *call, ddf_dev_t *dev)
242{
243 nic_t *nic_data = DRIVER_DATA(dev);
244 ne2k_interrupt(nic_data, IRQ_GET_ISR(*call), IRQ_GET_TSR(*call));
245
246 async_answer_0(iid, EOK);
247}
248
249static int ne2k_on_activating(nic_t *nic_data)
250{
251 ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
252
253 if (!ne2k->up) {
254 int rc = ne2k_up(ne2k);
255 if (rc != EOK)
256 return rc;
257
258 rc = hw_res_enable_interrupt(ne2k->parent_sess, ne2k->irq);
259 if (rc != EOK) {
260 ne2k_down(ne2k);
261 return rc;
262 }
263 }
264 return EOK;
265}
266
267static int ne2k_on_stopping(nic_t *nic_data)
268{
269 ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
270
271 (void) hw_res_disable_interrupt(ne2k->parent_sess, ne2k->irq);
272 ne2k->receive_configuration = RCR_AB | RCR_AM;
273 ne2k_down(ne2k);
274 return EOK;
275}
276
277static int ne2k_set_address(ddf_fun_t *fun, const nic_address_t *address)
278{
279 nic_t *nic_data = DRIVER_DATA(ddf_fun_get_dev(fun));
280 int rc = nic_report_address(nic_data, address);
281 if (rc != EOK) {
282 return EINVAL;
283 }
284 /* Note: some frame with previous physical address may slip to NIL here
285 * (for a moment the filtering is not exact), but ethernet should be OK with
286 * that. Some frames may also be lost, but this is not a problem.
287 */
288 ne2k_set_physical_address((ne2k_t *) nic_get_specific(nic_data), address);
289 return EOK;
290}
291
292static int ne2k_on_unicast_mode_change(nic_t *nic_data,
293 nic_unicast_mode_t new_mode,
294 const nic_address_t *address_list, size_t address_count)
295{
296 ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
297 switch (new_mode) {
298 case NIC_UNICAST_BLOCKED:
299 ne2k_set_promisc_phys(ne2k, false);
300 nic_report_hw_filtering(nic_data, 0, -1, -1);
301 return EOK;
302 case NIC_UNICAST_DEFAULT:
303 ne2k_set_promisc_phys(ne2k, false);
304 nic_report_hw_filtering(nic_data, 1, -1, -1);
305 return EOK;
306 case NIC_UNICAST_LIST:
307 ne2k_set_promisc_phys(ne2k, true);
308 nic_report_hw_filtering(nic_data, 0, -1, -1);
309 return EOK;
310 case NIC_UNICAST_PROMISC:
311 ne2k_set_promisc_phys(ne2k, true);
312 nic_report_hw_filtering(nic_data, 1, -1, -1);
313 return EOK;
314 default:
315 return ENOTSUP;
316 }
317}
318
319static int ne2k_on_multicast_mode_change(nic_t *nic_data,
320 nic_multicast_mode_t new_mode,
321 const nic_address_t *address_list, size_t address_count)
322{
323 ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
324 switch (new_mode) {
325 case NIC_MULTICAST_BLOCKED:
326 ne2k_set_accept_mcast(ne2k, false);
327 nic_report_hw_filtering(nic_data, -1, 1, -1);
328 return EOK;
329 case NIC_MULTICAST_LIST:
330 ne2k_set_accept_mcast(ne2k, true);
331 ne2k_set_mcast_hash(ne2k,
332 nic_mcast_hash(address_list, address_count));
333 nic_report_hw_filtering(nic_data, -1, 0, -1);
334 return EOK;
335 case NIC_MULTICAST_PROMISC:
336 ne2k_set_accept_mcast(ne2k, true);
337 ne2k_set_mcast_hash(ne2k, 0xFFFFFFFFFFFFFFFFllu);
338 nic_report_hw_filtering(nic_data, -1, 1, -1);
339 return EOK;
340 default:
341 return ENOTSUP;
342 }
343}
344
345static int ne2k_on_broadcast_mode_change(nic_t *nic_data,
346 nic_broadcast_mode_t new_mode)
347{
348 ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
349 switch (new_mode) {
350 case NIC_BROADCAST_BLOCKED:
351 ne2k_set_accept_bcast(ne2k, false);
352 return EOK;
353 case NIC_BROADCAST_ACCEPTED:
354 ne2k_set_accept_bcast(ne2k, true);
355 return EOK;
356 default:
357 return ENOTSUP;
358 }
359}
360
361static int ne2k_dev_add(ddf_dev_t *dev)
362{
363 ddf_fun_t *fun;
364
365 /* Allocate driver data for the device. */
366 nic_t *nic_data = nic_create_and_bind(dev);
367 if (nic_data == NULL)
368 return ENOMEM;
369
370 nic_set_send_frame_handler(nic_data, ne2k_send);
371 nic_set_state_change_handlers(nic_data,
372 ne2k_on_activating, NULL, ne2k_on_stopping);
373 nic_set_filtering_change_handlers(nic_data,
374 ne2k_on_unicast_mode_change, ne2k_on_multicast_mode_change,
375 ne2k_on_broadcast_mode_change, NULL, NULL);
376
377 ne2k_t *ne2k = malloc(sizeof(ne2k_t));
378 if (NULL != ne2k) {
379 memset(ne2k, 0, sizeof(ne2k_t));
380 nic_set_specific(nic_data, ne2k);
381 } else {
382 nic_unbind_and_destroy(dev);
383 return ENOMEM;
384 }
385
386 ne2k->dev = dev;
387 ne2k->parent_sess = ddf_dev_parent_sess_get(dev);
388 if (ne2k->parent_sess == NULL) {
389 ne2k_dev_cleanup(dev);
390 return ENOMEM;
391 }
392
393 int rc = ne2k_dev_init(nic_data);
394 if (rc != EOK) {
395 ne2k_dev_cleanup(dev);
396 return rc;
397 }
398
399 rc = nic_report_address(nic_data, &ne2k->mac);
400 if (rc != EOK) {
401 ne2k_dev_cleanup(dev);
402 return rc;
403 }
404
405 fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
406 if (fun == NULL) {
407 ne2k_dev_cleanup(dev);
408 return ENOMEM;
409 }
410
411 nic_set_ddf_fun(nic_data, fun);
412 ddf_fun_set_ops(fun, &ne2k_dev_ops);
413
414 rc = ddf_fun_bind(fun);
415 if (rc != EOK) {
416 ddf_fun_destroy(fun);
417 ne2k_dev_cleanup(dev);
418 return rc;
419 }
420
421 rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
422 if (rc != EOK) {
423 ddf_fun_unbind(fun);
424 ddf_fun_destroy(fun);
425 return rc;
426 }
427
428 return EOK;
429}
430
431static nic_iface_t ne2k_nic_iface = {
432 .set_address = ne2k_set_address
433};
434
435static driver_ops_t ne2k_driver_ops = {
436 .dev_add = ne2k_dev_add
437};
438
439static driver_t ne2k_driver = {
440 .name = NAME,
441 .driver_ops = &ne2k_driver_ops
442};
443
444int main(int argc, char *argv[])
445{
446 printf("%s: HelenOS NE 2000 network adapter driver\n", NAME);
447
448 nic_driver_init(NAME);
449 nic_driver_implement(&ne2k_driver_ops, &ne2k_dev_ops, &ne2k_nic_iface);
450
451 return ddf_driver_main(&ne2k_driver);
452}
453
454/** @}
455 */
Note: See TracBrowser for help on using the repository browser.