Fix error path when adding ATA devices
[helenos.git] / uspace / lib / nic / src / nic_impl.c
blobd3595471be70b3a6cc23b16fe03eb7f854a72dc6
1 /*
2 * Copyright (c) 2011 Radim Vansa
3 * All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
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.
29 /**
30 * @addtogroup libnic
31 * @{
33 /**
34 * @file
35 * @brief Default DDF NIC interface methods implementations
38 #include <errno.h>
39 #include <str_error.h>
40 #include <ipc/services.h>
41 #include <ns.h>
42 #include "nic_driver.h"
43 #include "nic_ev.h"
44 #include "nic_impl.h"
46 /**
47 * Default implementation of the set_state method. Trivial.
49 * @param fun
50 * @param[out] state
52 * @return EOK always.
54 errno_t nic_get_state_impl(ddf_fun_t *fun, nic_device_state_t *state)
56 nic_t *nic_data = nic_get_from_ddf_fun(fun);
57 fibril_rwlock_read_lock(&nic_data->main_lock);
58 *state = nic_data->state;
59 fibril_rwlock_read_unlock(&nic_data->main_lock);
60 return EOK;
63 /**
64 * Default implementation of the set_state method. Changes the internal
65 * driver's state, calls the appropriate callback and notifies the NIL service
66 * about this change.
68 * @param fun
69 * @param state The new device's state
71 * @return EOK If the state was changed
72 * @return EINVAL If the state cannot be changed
74 errno_t nic_set_state_impl(ddf_fun_t *fun, nic_device_state_t state)
76 if (state >= NIC_STATE_MAX) {
77 return EINVAL;
80 nic_t *nic_data = nic_get_from_ddf_fun(fun);
82 fibril_rwlock_write_lock(&nic_data->main_lock);
83 if (nic_data->state == state) {
84 /* No change, nothing to do */
85 fibril_rwlock_write_unlock(&nic_data->main_lock);
86 return EOK;
88 if (state == NIC_STATE_ACTIVE) {
89 if (nic_data->client_session == NULL) {
90 fibril_rwlock_write_unlock(&nic_data->main_lock);
91 return EINVAL;
95 state_change_handler event_handler = NULL;
96 switch (state) {
97 case NIC_STATE_STOPPED:
98 event_handler = nic_data->on_stopping;
99 break;
100 case NIC_STATE_DOWN:
101 event_handler = nic_data->on_going_down;
102 break;
103 case NIC_STATE_ACTIVE:
104 event_handler = nic_data->on_activating;
105 break;
106 default:
107 break;
109 if (event_handler != NULL) {
110 errno_t rc = event_handler(nic_data);
111 if (rc != EOK) {
112 fibril_rwlock_write_unlock(&nic_data->main_lock);
113 return EINVAL;
117 if (state == NIC_STATE_STOPPED) {
118 /* Notify upper layers that we are reseting the MAC */
119 errno_t rc = nic_ev_addr_changed(nic_data->client_session,
120 &nic_data->default_mac);
121 nic_data->poll_mode = nic_data->default_poll_mode;
122 memcpy(&nic_data->poll_period, &nic_data->default_poll_period,
123 sizeof(struct timespec));
124 if (rc != EOK) {
126 * We have already ran the on stopped handler, even if we
127 * terminated the state change we would end up in undefined state.
128 * Therefore we just log the problem.
132 fibril_rwlock_write_lock(&nic_data->stats_lock);
133 memset(&nic_data->stats, 0, sizeof(nic_device_stats_t));
134 fibril_rwlock_write_unlock(&nic_data->stats_lock);
136 fibril_rwlock_write_lock(&nic_data->rxc_lock);
137 nic_rxc_clear(&nic_data->rx_control);
138 /* Reinsert device's default MAC */
139 nic_rxc_set_addr(&nic_data->rx_control, NULL,
140 &nic_data->default_mac);
141 fibril_rwlock_write_unlock(&nic_data->rxc_lock);
142 memcpy(&nic_data->mac, &nic_data->default_mac, sizeof (nic_address_t));
144 fibril_rwlock_write_lock(&nic_data->wv_lock);
145 nic_wol_virtues_clear(&nic_data->wol_virtues);
146 fibril_rwlock_write_unlock(&nic_data->wv_lock);
148 /* Ensure stopping period of NIC_POLL_SOFTWARE_PERIODIC */
149 nic_sw_period_stop(nic_data);
152 nic_data->state = state;
154 nic_ev_device_state(nic_data->client_session, state);
156 fibril_rwlock_write_unlock(&nic_data->main_lock);
158 return EOK;
162 * Default implementation of the send_frame method.
163 * Send messages to the network.
165 * @param fun
166 * @param data Frame data
167 * @param size Frame size in bytes
169 * @return EOK If the message was sent
170 * @return EBUSY If the device is not in state when the frame can be sent.
172 errno_t nic_send_frame_impl(ddf_fun_t *fun, void *data, size_t size)
174 nic_t *nic_data = nic_get_from_ddf_fun(fun);
176 fibril_rwlock_read_lock(&nic_data->main_lock);
177 if (nic_data->state != NIC_STATE_ACTIVE || nic_data->tx_busy) {
178 fibril_rwlock_read_unlock(&nic_data->main_lock);
179 return EBUSY;
182 nic_data->send_frame(nic_data, data, size);
183 fibril_rwlock_read_unlock(&nic_data->main_lock);
184 return EOK;
188 * Default implementation of the connect_client method.
189 * Creates callback connection to the client.
191 * @param fun
193 * @return EOK On success, or an error code.
195 errno_t nic_callback_create_impl(ddf_fun_t *fun)
197 nic_t *nic = nic_get_from_ddf_fun(fun);
198 fibril_rwlock_write_lock(&nic->main_lock);
200 nic->client_session = async_callback_receive(EXCHANGE_SERIALIZE);
201 if (nic->client_session == NULL) {
202 fibril_rwlock_write_unlock(&nic->main_lock);
203 return ENOMEM;
206 fibril_rwlock_write_unlock(&nic->main_lock);
207 return EOK;
211 * Default implementation of the get_address method.
212 * Retrieves the NIC's physical address.
214 * @param fun
215 * @param address Pointer to the structure where the address will be stored.
217 * @return EOK If the services were bound
218 * @return ELIMIT If the buffer is too short
220 errno_t nic_get_address_impl(ddf_fun_t *fun, nic_address_t *address)
222 assert(address);
223 nic_t *nic_data = nic_get_from_ddf_fun(fun);
224 fibril_rwlock_read_lock(&nic_data->main_lock);
225 memcpy(address, &nic_data->mac, sizeof (nic_address_t));
226 fibril_rwlock_read_unlock(&nic_data->main_lock);
227 return EOK;
231 * Default implementation of the get_stats method. Copies the statistics from
232 * the drivers data to supplied buffer.
234 * @param fun
235 * @param[out] stats The buffer for statistics
237 * @return EOK (cannot fail)
239 errno_t nic_get_stats_impl(ddf_fun_t *fun, nic_device_stats_t *stats)
241 nic_t *nic_data = nic_get_from_ddf_fun(fun);
242 assert (stats != NULL);
243 fibril_rwlock_read_lock(&nic_data->stats_lock);
244 memcpy(stats, &nic_data->stats, sizeof (nic_device_stats_t));
245 fibril_rwlock_read_unlock(&nic_data->stats_lock);
246 return EOK;
250 * Default implementation of unicast_get_mode method.
252 * @param fun
253 * @param[out] mode Current operation mode
254 * @param[in] max_count Max number of addresses that can be written into the
255 * buffer (addr_list).
256 * @param[out] addr_list Buffer for addresses
257 * @param[out] addr_count Number of addresses written into the list
259 * @return EOK
261 errno_t nic_unicast_get_mode_impl(ddf_fun_t *fun, nic_unicast_mode_t *mode,
262 size_t max_count, nic_address_t *addr_list, size_t *addr_count)
264 nic_t *nic_data = nic_get_from_ddf_fun(fun);
265 fibril_rwlock_read_lock(&nic_data->rxc_lock);
266 nic_rxc_unicast_get_mode(&nic_data->rx_control, mode, max_count,
267 addr_list, addr_count);
268 fibril_rwlock_read_unlock(&nic_data->rxc_lock);
269 return EOK;
273 * Default implementation of unicast_set_mode method.
275 * @param fun
276 * @param[in] mode New operation mode
277 * @param[in] addr_list List of unicast addresses
278 * @param[in] addr_count Number of addresses in the list
280 * @return EOK
281 * @return EINVAL
282 * @return ENOTSUP
283 * @return ENOMEM
285 errno_t nic_unicast_set_mode_impl(ddf_fun_t *fun,
286 nic_unicast_mode_t mode, const nic_address_t *addr_list, size_t addr_count)
288 assert((addr_count == 0 && addr_list == NULL) ||
289 (addr_count != 0 && addr_list != NULL));
290 size_t i;
291 for (i = 0; i < addr_count; ++i) {
292 if (addr_list[i].address[0] & 1)
293 return EINVAL;
296 nic_t *nic_data = nic_get_from_ddf_fun(fun);
297 fibril_rwlock_write_lock(&nic_data->rxc_lock);
298 errno_t rc = ENOTSUP;
299 if (nic_data->on_unicast_mode_change) {
300 rc = nic_data->on_unicast_mode_change(nic_data,
301 mode, addr_list, addr_count);
303 if (rc == EOK) {
304 rc = nic_rxc_unicast_set_mode(&nic_data->rx_control, mode,
305 addr_list, addr_count);
307 * After changing the mode the addr db gets cleared, therefore we have
308 * to reinsert also the physical address of NIC.
310 nic_rxc_set_addr(&nic_data->rx_control, NULL, &nic_data->mac);
312 fibril_rwlock_write_unlock(&nic_data->rxc_lock);
313 return rc;
317 * Default implementation of multicast_get_mode method.
319 * @param fun
320 * @param[out] mode Current operation mode
321 * @param[in] max_count Max number of addresses that can be written into the
322 * buffer (addr_list).
323 * @param[out] addr_list Buffer for addresses
324 * @param[out] addr_count Number of addresses written into the list
326 * @return EOK
328 errno_t nic_multicast_get_mode_impl(ddf_fun_t *fun, nic_multicast_mode_t *mode,
329 size_t max_count, nic_address_t *addr_list, size_t *addr_count)
331 nic_t *nic_data = nic_get_from_ddf_fun(fun);
332 fibril_rwlock_read_lock(&nic_data->rxc_lock);
333 nic_rxc_multicast_get_mode(&nic_data->rx_control, mode, max_count,
334 addr_list, addr_count);
335 fibril_rwlock_read_unlock(&nic_data->rxc_lock);
336 return EOK;
340 * Default implementation of multicast_set_mode method.
342 * @param fun
343 * @param[in] mode New operation mode
344 * @param[in] addr_list List of multicast addresses
345 * @param[in] addr_count Number of addresses in the list
347 * @return EOK
348 * @return EINVAL
349 * @return ENOTSUP
350 * @return ENOMEM
352 errno_t nic_multicast_set_mode_impl(ddf_fun_t *fun, nic_multicast_mode_t mode,
353 const nic_address_t *addr_list, size_t addr_count)
355 assert((addr_count == 0 && addr_list == NULL) ||
356 (addr_count != 0 && addr_list != NULL));
357 size_t i;
358 for (i = 0; i < addr_count; ++i) {
359 if (!(addr_list[i].address[0] & 1))
360 return EINVAL;
363 nic_t *nic_data = nic_get_from_ddf_fun(fun);
364 fibril_rwlock_write_lock(&nic_data->rxc_lock);
365 errno_t rc = ENOTSUP;
366 if (nic_data->on_multicast_mode_change) {
367 rc = nic_data->on_multicast_mode_change(nic_data, mode, addr_list, addr_count);
369 if (rc == EOK) {
370 rc = nic_rxc_multicast_set_mode(&nic_data->rx_control, mode,
371 addr_list, addr_count);
373 fibril_rwlock_write_unlock(&nic_data->rxc_lock);
374 return rc;
378 * Default implementation of broadcast_get_mode method.
380 * @param fun
381 * @param[out] mode Current operation mode
383 * @return EOK
385 errno_t nic_broadcast_get_mode_impl(ddf_fun_t *fun, nic_broadcast_mode_t *mode)
387 nic_t *nic_data = nic_get_from_ddf_fun(fun);
388 fibril_rwlock_read_lock(&nic_data->rxc_lock);
389 nic_rxc_broadcast_get_mode(&nic_data->rx_control, mode);
390 fibril_rwlock_read_unlock(&nic_data->rxc_lock);
391 return EOK;
395 * Default implementation of broadcast_set_mode method.
397 * @param fun
398 * @param[in] mode New operation mode
400 * @return EOK
401 * @return EINVAL
402 * @return ENOTSUP
403 * @return ENOMEM
405 errno_t nic_broadcast_set_mode_impl(ddf_fun_t *fun, nic_broadcast_mode_t mode)
407 nic_t *nic_data = nic_get_from_ddf_fun(fun);
408 fibril_rwlock_write_lock(&nic_data->rxc_lock);
409 errno_t rc = ENOTSUP;
410 if (nic_data->on_broadcast_mode_change) {
411 rc = nic_data->on_broadcast_mode_change(nic_data, mode);
413 if (rc == EOK) {
414 rc = nic_rxc_broadcast_set_mode(&nic_data->rx_control, mode);
416 fibril_rwlock_write_unlock(&nic_data->rxc_lock);
417 return rc;
421 * Default implementation of blocked_sources_get method.
423 * @param fun
424 * @param[in] max_count Max number of addresses that can be written into the
425 * buffer (addr_list).
426 * @param[out] addr_list Buffer for addresses
427 * @param[out] addr_count Number of addresses written into the list
429 * @return EOK
431 errno_t nic_blocked_sources_get_impl(ddf_fun_t *fun,
432 size_t max_count, nic_address_t *addr_list, size_t *addr_count)
434 nic_t *nic_data = nic_get_from_ddf_fun(fun);
435 fibril_rwlock_read_lock(&nic_data->rxc_lock);
436 nic_rxc_blocked_sources_get(&nic_data->rx_control,
437 max_count, addr_list, addr_count);
438 fibril_rwlock_read_unlock(&nic_data->rxc_lock);
439 return EOK;
443 * Default implementation of blocked_sources_set method.
445 * @param fun
446 * @param[in] addr_list List of blocked addresses
447 * @param[in] addr_count Number of addresses in the list
449 * @return EOK
450 * @return EINVAL
451 * @return ENOTSUP
452 * @return ENOMEM
454 errno_t nic_blocked_sources_set_impl(ddf_fun_t *fun,
455 const nic_address_t *addr_list, size_t addr_count)
457 nic_t *nic_data = nic_get_from_ddf_fun(fun);
458 fibril_rwlock_write_lock(&nic_data->rxc_lock);
459 if (nic_data->on_blocked_sources_change) {
460 nic_data->on_blocked_sources_change(nic_data, addr_list, addr_count);
462 errno_t rc = nic_rxc_blocked_sources_set(&nic_data->rx_control,
463 addr_list, addr_count);
464 fibril_rwlock_write_unlock(&nic_data->rxc_lock);
465 return rc;
469 * Default implementation of vlan_get_mask method.
471 * @param fun
472 * @param[out] mask Current VLAN mask
474 * @return EOK
475 * @return ENOENT If the mask is not set
477 errno_t nic_vlan_get_mask_impl(ddf_fun_t *fun, nic_vlan_mask_t *mask)
479 nic_t *nic_data = nic_get_from_ddf_fun(fun);
480 fibril_rwlock_read_lock(&nic_data->rxc_lock);
481 errno_t rc = nic_rxc_vlan_get_mask(&nic_data->rx_control, mask);
482 fibril_rwlock_read_unlock(&nic_data->rxc_lock);
483 return rc;
487 * Default implementation of vlan_set_mask method.
489 * @param fun
490 * @param[in] mask The new VLAN mask
492 * @return EOK
493 * @return ENOMEM
495 errno_t nic_vlan_set_mask_impl(ddf_fun_t *fun, const nic_vlan_mask_t *mask)
497 nic_t *nic_data = nic_get_from_ddf_fun(fun);
498 fibril_rwlock_write_lock(&nic_data->rxc_lock);
499 errno_t rc = nic_rxc_vlan_set_mask(&nic_data->rx_control, mask);
500 if (rc == EOK && nic_data->on_vlan_mask_change) {
501 nic_data->on_vlan_mask_change(nic_data, mask);
503 fibril_rwlock_write_unlock(&nic_data->rxc_lock);
504 return rc;
508 * Default implementation of the wol_virtue_add method.
509 * Create a new WOL virtue.
511 * @param[in] fun
512 * @param[in] type Type of the virtue
513 * @param[in] data Data required for this virtue (depends on type)
514 * @param[in] length Length of the data
515 * @param[out] filter Identifier of the new virtue
517 * @return EOK If the operation was successfully completed
518 * @return EINVAL If virtue type is not supported or the data are invalid
519 * @return ELIMIT If the driver does not allow to create more virtues
520 * @return ENOMEM If there was not enough memory to complete the operation
522 errno_t nic_wol_virtue_add_impl(ddf_fun_t *fun, nic_wv_type_t type,
523 const void *data, size_t length, nic_wv_id_t *new_id)
525 nic_t *nic_data = nic_get_from_ddf_fun(fun);
526 if (nic_data->on_wol_virtue_add == NULL ||
527 nic_data->on_wol_virtue_remove == NULL) {
528 return ENOTSUP;
530 if (type == NIC_WV_NONE || type >= NIC_WV_MAX) {
531 return EINVAL;
533 if (nic_wol_virtues_verify(type, data, length) != EOK) {
534 return EINVAL;
536 nic_wol_virtue_t *virtue = malloc(sizeof (nic_wol_virtue_t));
537 if (virtue == NULL) {
538 return ENOMEM;
540 memset(virtue, 0, sizeof(nic_wol_virtue_t));
541 if (length != 0) {
542 virtue->data = malloc(length);
543 if (virtue->data == NULL) {
544 free(virtue);
545 return ENOMEM;
547 memcpy((void *) virtue->data, data, length);
549 virtue->type = type;
550 virtue->length = length;
552 fibril_rwlock_write_lock(&nic_data->wv_lock);
553 /* Check if we haven't reached the maximum */
554 if (nic_data->wol_virtues.caps_max[type] < 0) {
555 fibril_rwlock_write_unlock(&nic_data->wv_lock);
556 free(virtue->data);
557 free(virtue);
558 return EINVAL;
560 if ((int) nic_data->wol_virtues.lists_sizes[type] >=
561 nic_data->wol_virtues.caps_max[type]) {
562 fibril_rwlock_write_unlock(&nic_data->wv_lock);
563 free(virtue->data);
564 free(virtue);
565 return ELIMIT;
567 /* Call the user-defined add callback */
568 errno_t rc = nic_data->on_wol_virtue_add(nic_data, virtue);
569 if (rc != EOK) {
570 free(virtue->data);
571 free(virtue);
572 fibril_rwlock_write_unlock(&nic_data->wv_lock);
573 return rc;
575 rc = nic_wol_virtues_add(&nic_data->wol_virtues, virtue);
576 if (rc != EOK) {
577 /* If the adding fails, call user-defined remove callback */
578 nic_data->on_wol_virtue_remove(nic_data, virtue);
579 fibril_rwlock_write_unlock(&nic_data->wv_lock);
580 free(virtue->data);
581 free(virtue);
582 return rc;
583 } else {
584 *new_id = virtue->id;
585 fibril_rwlock_write_unlock(&nic_data->wv_lock);
587 return EOK;
591 * Default implementation of the wol_virtue_remove method.
592 * Destroys the WOL virtue.
594 * @param[in] fun
595 * @param[in] id WOL virtue identification
597 * @return EOK If the operation was successfully completed
598 * @return ENOTSUP If the function is not supported by the driver or device
599 * @return ENOENT If the virtue identifier is not valid.
601 errno_t nic_wol_virtue_remove_impl(ddf_fun_t *fun, nic_wv_id_t id)
603 nic_t *nic_data = nic_get_from_ddf_fun(fun);
604 if (nic_data->on_wol_virtue_add == NULL ||
605 nic_data->on_wol_virtue_remove == NULL) {
606 return ENOTSUP;
608 fibril_rwlock_write_lock(&nic_data->wv_lock);
609 nic_wol_virtue_t *virtue =
610 nic_wol_virtues_remove(&nic_data->wol_virtues, id);
611 if (virtue == NULL) {
612 fibril_rwlock_write_unlock(&nic_data->wv_lock);
613 return ENOENT;
615 /* The event handler is called after the filter was removed */
616 nic_data->on_wol_virtue_remove(nic_data, virtue);
617 fibril_rwlock_write_unlock(&nic_data->wv_lock);
618 free(virtue->data);
619 free(virtue);
620 return EOK;
624 * Default implementation of the wol_virtue_probe method.
625 * Queries the type and data of the virtue.
627 * @param[in] fun
628 * @param[in] id Virtue identifier
629 * @param[out] type Type of the virtue. Can be NULL.
630 * @param[out] data Data used when the virtue was created. Can be NULL.
631 * @param[out] length Length of the data. Can be NULL.
633 * @return EOK If the operation was successfully completed
634 * @return ENOENT If the virtue identifier is not valid.
635 * @return ENOMEM If there was not enough memory to complete the operation
637 errno_t nic_wol_virtue_probe_impl(ddf_fun_t *fun, nic_wv_id_t id,
638 nic_wv_type_t *type, size_t max_length, void *data, size_t *length)
640 nic_t *nic_data = nic_get_from_ddf_fun(fun);
641 fibril_rwlock_read_lock(&nic_data->wv_lock);
642 const nic_wol_virtue_t *virtue =
643 nic_wol_virtues_find(&nic_data->wol_virtues, id);
644 if (virtue == NULL) {
645 *type = NIC_WV_NONE;
646 *length = 0;
647 fibril_rwlock_read_unlock(&nic_data->wv_lock);
648 return ENOENT;
649 } else {
650 *type = virtue->type;
651 if (max_length > virtue->length) {
652 max_length = virtue->length;
654 memcpy(data, virtue->data, max_length);
655 *length = virtue->length;
656 fibril_rwlock_read_unlock(&nic_data->wv_lock);
657 return EOK;
662 * Default implementation of the wol_virtue_list method.
663 * List filters of the specified type. If NIC_WV_NONE is the type, it lists all
664 * filters.
666 * @param[in] fun
667 * @param[in] type Type of the virtues
668 * @param[out] virtues Vector of virtue ID's.
669 * @param[out] count Length of the data. Can be NULL.
671 * @return EOK If the operation was successfully completed
672 * @return ENOENT If the filter identification is not valid.
673 * @return ENOMEM If there was not enough memory to complete the operation
675 errno_t nic_wol_virtue_list_impl(ddf_fun_t *fun, nic_wv_type_t type,
676 size_t max_count, nic_wv_id_t *id_list, size_t *id_count)
678 nic_t *nic_data = nic_get_from_ddf_fun(fun);
679 fibril_rwlock_read_lock(&nic_data->wv_lock);
680 errno_t rc = nic_wol_virtues_list(&nic_data->wol_virtues, type,
681 max_count, id_list, id_count);
682 fibril_rwlock_read_unlock(&nic_data->wv_lock);
683 return rc;
687 * Default implementation of the wol_virtue_get_caps method.
688 * Queries for the current capabilities for some type of filter.
690 * @param[in] fun
691 * @param[in] type Type of the virtues
692 * @param[out] count Number of virtues of this type that can be currently set
694 * @return EOK If the operation was successfully completed
696 errno_t nic_wol_virtue_get_caps_impl(ddf_fun_t *fun, nic_wv_type_t type, int *count)
698 nic_t *nic_data = nic_get_from_ddf_fun(fun);
699 fibril_rwlock_read_lock(&nic_data->wv_lock);
700 *count = nic_data->wol_virtues.caps_max[type] -
701 (int) nic_data->wol_virtues.lists_sizes[type];
702 fibril_rwlock_read_unlock(&nic_data->wv_lock);
703 return EOK;
707 * Default implementation of the poll_get_mode method.
708 * Queries the current interrupt/poll mode of the NIC
710 * @param[in] fun
711 * @param[out] mode Current poll mode
712 * @param[out] period Period used in periodic polling. Can be NULL.
714 * @return EOK If the operation was successfully completed
715 * @return ENOTSUP This function is not supported.
716 * @return EPARTY Error in communication protocol
718 errno_t nic_poll_get_mode_impl(ddf_fun_t *fun,
719 nic_poll_mode_t *mode, struct timespec *period)
721 nic_t *nic_data = nic_get_from_ddf_fun(fun);
722 fibril_rwlock_read_lock(&nic_data->main_lock);
723 *mode = nic_data->poll_mode;
724 memcpy(period, &nic_data->poll_period, sizeof(struct timespec));
725 fibril_rwlock_read_unlock(&nic_data->main_lock);
726 return EOK;
730 * Default implementation of the poll_set_mode_impl method.
731 * Sets the interrupt/poll mode of the NIC.
733 * @param[in] fun
734 * @param[in] mode The new poll mode
735 * @param[in] period Period used in periodic polling. Can be NULL.
737 * @return EOK If the operation was successfully completed
738 * @return ENOTSUP This operation is not supported.
739 * @return EPARTY Error in communication protocol
741 errno_t nic_poll_set_mode_impl(ddf_fun_t *fun,
742 nic_poll_mode_t mode, const struct timespec *period)
744 nic_t *nic_data = nic_get_from_ddf_fun(fun);
746 * If the driver does not implement the poll mode change handler it cannot
747 * switch off interrupts and this is not supported.
749 if (nic_data->on_poll_mode_change == NULL)
750 return ENOTSUP;
752 if ((mode == NIC_POLL_ON_DEMAND) && nic_data->on_poll_request == NULL)
753 return ENOTSUP;
755 if (mode == NIC_POLL_PERIODIC || mode == NIC_POLL_SOFTWARE_PERIODIC) {
756 if (period == NULL)
757 return EINVAL;
758 if (period->tv_sec == 0 && period->tv_nsec == 0)
759 return EINVAL;
760 if (period->tv_sec < 0 || period->tv_nsec < 0)
761 return EINVAL;
763 fibril_rwlock_write_lock(&nic_data->main_lock);
764 errno_t rc = nic_data->on_poll_mode_change(nic_data, mode, period);
765 assert(rc == EOK || rc == ENOTSUP || rc == EINVAL);
766 if (rc == ENOTSUP && (nic_data->on_poll_request != NULL) &&
767 (mode == NIC_POLL_PERIODIC || mode == NIC_POLL_SOFTWARE_PERIODIC)) {
769 rc = nic_data->on_poll_mode_change(nic_data, NIC_POLL_ON_DEMAND, NULL);
770 assert(rc == EOK || rc == ENOTSUP);
771 if (rc == EOK)
772 nic_sw_period_start(nic_data);
774 if (rc == EOK) {
775 nic_data->poll_mode = mode;
776 if (period)
777 nic_data->poll_period = *period;
779 fibril_rwlock_write_unlock(&nic_data->main_lock);
780 return rc;
784 * Default implementation of the poll_now method.
785 * Wrapper for the actual poll implementation.
787 * @param[in] fun
789 * @return EOK If the NIC was polled
790 * @return ENOTSUP If the function is not supported
791 * @return EINVAL If the NIC is not in state where it allows on demand polling
793 errno_t nic_poll_now_impl(ddf_fun_t *fun)
795 nic_t *nic_data = nic_get_from_ddf_fun(fun);
796 fibril_rwlock_read_lock(&nic_data->main_lock);
797 if (nic_data->poll_mode != NIC_POLL_ON_DEMAND) {
798 fibril_rwlock_read_unlock(&nic_data->main_lock);
799 return EINVAL;
801 if (nic_data->on_poll_request != NULL) {
802 nic_data->on_poll_request(nic_data);
803 fibril_rwlock_read_unlock(&nic_data->main_lock);
804 return EOK;
805 } else {
806 fibril_rwlock_read_unlock(&nic_data->main_lock);
807 return ENOTSUP;
812 * Default handler for unknown methods (outside of the NIC interface).
813 * Logs a warning message and returns ENOTSUP to the caller.
815 * @param fun The DDF function where the method should be called.
816 * @param call IPC call data
819 void nic_default_handler_impl(ddf_fun_t *fun, ipc_call_t *call)
821 async_answer_0(call, ENOTSUP);
825 * Default (empty) OPEN function implementation.
827 * @param fun The DDF function
829 * @return EOK always.
831 errno_t nic_open_impl(ddf_fun_t *fun)
833 return EOK;
837 * Default (empty) OPEN function implementation.
839 * @param fun The DDF function
841 void nic_close_impl(ddf_fun_t *fun)
845 /** @}