source: mainline/uspace/drv/nic/rtl8139/driver.c@ 4cb0148

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

support for kernel notification multiplexing in the async framework

  • rename SYS_EVENT_* and SYS_IRQ_* syscalls to unify the terminology
  • add SYS_IPC_EVENT_UNSUBSCRIBE
  • remove IRQ handler multiplexing from DDF, the generic mechanism replaces it (unfortunatelly the order of arguments used by interrupt_handler_t needs to be permutated to align with the async framework conventions)
  • Property mode set to 100644
File size: 58.2 KB
Line 
1/*
2 * Copyright (c) 2011 Jiri Michalec
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#include <assert.h>
30#include <errno.h>
31#include <align.h>
32#include <byteorder.h>
33#include <libarch/barrier.h>
34#include <as.h>
35#include <ddf/log.h>
36#include <ddf/interrupt.h>
37#include <io/log.h>
38#include <nic.h>
39#include <pci_dev_iface.h>
40#include <irc.h>
41#include <stdio.h>
42#include <str.h>
43
44#include "defs.h"
45#include "driver.h"
46#include "general.h"
47
48/** Global mutex for work with shared irq structure */
49FIBRIL_MUTEX_INITIALIZE(irq_reg_lock);
50
51/** Lock interrupt structure mutex */
52#define RTL8139_IRQ_STRUCT_LOCK() \
53 fibril_mutex_lock(&irq_reg_lock)
54
55/** Unlock interrupt structure mutex */
56#define RTL8139_IRQ_STRUCT_UNLOCK() \
57 fibril_mutex_unlock(&irq_reg_lock)
58
59/** PCI clock frequency in kHz */
60#define RTL8139_PCI_FREQ_KHZ 33000
61
62#define RTL8139_AUTONEG_CAPS (ETH_AUTONEG_10BASE_T_HALF | \
63 ETH_AUTONEG_10BASE_T_FULL | ETH_AUTONEG_100BASE_TX_HALF | \
64 ETH_AUTONEG_100BASE_TX_FULL | ETH_AUTONEG_PAUSE_SYMETRIC)
65
66/** Lock transmitter and receiver data
67 *
68 * This function shall be called whenever
69 * both transmitter and receiver locking
70 * to force safe lock ordering (deadlock prevention)
71 *
72 * @param rtl8139 RTL8139 private data
73 *
74 */
75inline static void rtl8139_lock_all(rtl8139_t *rtl8139)
76{
77 assert(rtl8139);
78 fibril_mutex_lock(&rtl8139->tx_lock);
79 fibril_mutex_lock(&rtl8139->rx_lock);
80}
81
82/** Unlock transmitter and receiver data
83 *
84 * @param rtl8139 RTL8139 private data
85 *
86 */
87inline static void rtl8139_unlock_all(rtl8139_t *rtl8139)
88{
89 assert(rtl8139);
90 fibril_mutex_unlock(&rtl8139->rx_lock);
91 fibril_mutex_unlock(&rtl8139->tx_lock);
92}
93
94#ifndef RXBUF_SIZE_FLAGS
95 /** Flags for receiver buffer - 16kB default */
96 #define RXBUF_SIZE_FLAGS RTL8139_RXFLAGS_SIZE_16
97#endif
98
99#if (RXBUF_SIZE_FLAGS > RTL8139_RXFLAGS_SIZE_64) || (RXBUF_SIZE_FLAGS < 0)
100 #error Bad receiver buffer flags size flags
101#endif
102
103/** Size of the receiver buffer
104 *
105 * Incrementing flags by one twices the buffer size
106 * the lowest size is 8*1024 (flags = 0)
107 */
108#define RxBUF_SIZE RTL8139_RXSIZE(RXBUF_SIZE_FLAGS)
109
110/** Total size of the receiver buffer to allocate */
111#define RxBUF_TOT_LENGTH RTL8139_RXBUF_LENGTH(RXBUF_SIZE_FLAGS)
112
113
114/** Default interrupt mask */
115#define RTL_DEFAULT_INTERRUPTS UINT16_C(0xFFFF)
116
117/** Obtain the value of the register part
118 * The bit operations will be done
119 * The _SHIFT and _MASK for the register part must exists as macros
120 * or variables
121 */
122#define REG_GET_VAL(value, reg_part)\
123 (((value) >> reg_part##_SHIFT) & reg_part##_MASK)
124
125
126/** Disable interrupts on controller
127 *
128 * @param rtl8139 The card private structure
129 */
130inline static void rtl8139_hw_int_disable(rtl8139_t *rtl8139)
131{
132 pio_write_16(rtl8139->io_port + IMR, 0x0);
133}
134/** Enable interrupts on controller
135 *
136 * @param rtl8139 The card private structure
137 */
138inline static void rtl8139_hw_int_enable(rtl8139_t *rtl8139)
139{
140 pio_write_16(rtl8139->io_port + IMR, rtl8139->int_mask);
141}
142
143/** Check on the controller if the receiving buffer is empty
144 *
145 * @param rtl8139 The controller data
146 *
147 * @return Nonzero if empty, zero otherwise
148 */
149inline static int rtl8139_hw_buffer_empty(rtl8139_t *rtl8139)
150{
151 return pio_read_16(rtl8139->io_port + CR) & CR_BUFE;
152}
153
154/** Update the mask of accepted frames in the RCR register according to
155 * rcr_accept_mode value in rtl8139_t
156 *
157 * @param rtl8139 The rtl8139 private data
158 */
159static void rtl8139_hw_update_rcr(rtl8139_t *rtl8139)
160{
161 uint32_t rcr = rtl8139->rcr_data.rcr_base | rtl8139->rcr_data.ucast_mask
162 | rtl8139->rcr_data.mcast_mask | rtl8139->rcr_data.bcast_mask
163 | rtl8139->rcr_data.defect_mask |
164 (RXBUF_SIZE_FLAGS << RCR_RBLEN_SHIFT);
165
166 ddf_msg(LVL_DEBUG, "Rewriting rcr: %x -> %x", pio_read_32(rtl8139->io_port + RCR),
167 rcr);
168
169 pio_write_32(rtl8139->io_port + RCR, rcr);
170}
171
172/** Fill the mask of accepted multicast frames in the card registers
173 *
174 * @param rtl8139 The rtl8139 private data
175 * @param mask The mask to set
176 */
177inline static void rtl8139_hw_set_mcast_mask(rtl8139_t *rtl8139,
178 uint64_t mask)
179{
180 pio_write_32(rtl8139->io_port + MAR0, (uint32_t) mask);
181 pio_write_32(rtl8139->io_port + MAR0 + sizeof(uint32_t),
182 (uint32_t)(mask >> 32));
183 return;
184}
185
186/** Set PmEn (Power management enable) bit value
187 *
188 * @param rtl8139 rtl8139 card data
189 * @param bit_val If bit_val is zero pmen is set to 0, otherwise pmen is set to 1
190 */
191inline static void rtl8139_hw_pmen_set(rtl8139_t *rtl8139, uint8_t bit_val)
192{
193 uint8_t config1 = pio_read_8(rtl8139->io_port + CONFIG1);
194 uint8_t config1_new;
195 if (bit_val)
196 config1_new = config1 | CONFIG1_PMEn;
197 else
198 config1_new = config1 & ~(uint8_t)(CONFIG1_PMEn);
199
200 if (config1_new == config1)
201 return;
202
203 rtl8139_regs_unlock(rtl8139->io_port);
204 pio_write_8(rtl8139->io_port + CONFIG1, config1_new);
205 rtl8139_regs_lock(rtl8139->io_port);
206
207 async_sess_t *pci_sess =
208 ddf_dev_parent_sess_get(nic_get_ddf_dev(rtl8139->nic_data));
209
210 if (bit_val) {
211 uint8_t pmen;
212 pci_config_space_read_8(pci_sess, 0x55, &pmen);
213 pci_config_space_write_8(pci_sess, 0x55, pmen | 1 | (1 << 7));
214 } else {
215 uint8_t pmen;
216 pci_config_space_read_8(pci_sess, 0x55, &pmen);
217 pci_config_space_write_8(pci_sess, 0x55, pmen & ~(1 | (1 << 7)));
218 }
219}
220
221/** Get MAC address of the RTL8139 adapter
222 *
223 * @param rtl8139 The RTL8139 device
224 * @param address The place to store the address
225 *
226 * @return EOK if succeed, negative error code otherwise
227 */
228inline static void rtl8139_hw_get_addr(rtl8139_t *rtl8139,
229 nic_address_t *addr)
230{
231 assert(rtl8139);
232 assert(addr);
233
234 uint32_t *mac0_dest = (uint32_t *)addr->address;
235 uint16_t *mac4_dest = (uint16_t *)(addr->address + 4);
236
237 /* Read MAC address from the i/o (4byte + 2byte reads) */
238 *mac0_dest = pio_read_32(rtl8139->io_port + MAC0);
239 *mac4_dest = pio_read_16(rtl8139->io_port + MAC0 + 4);
240};
241
242/** Set MAC address to the device
243 *
244 * @param rtl8139 Controller private structure
245 * @param addr The address to set
246 */
247static void rtl8139_hw_set_addr(rtl8139_t *rtl8139, const nic_address_t *addr)
248{
249 assert(rtl8139);
250 assert(addr);
251
252 const uint32_t *val1 = (const uint32_t*)addr->address;
253 const uint16_t *val2 = (const uint16_t*)(addr->address + sizeof(uint32_t));
254
255 rtl8139_regs_unlock(rtl8139->io_port);
256 pio_write_32(rtl8139->io_port + MAC0, *val1);
257 pio_write_32(rtl8139->io_port + MAC0 + 4, *val2);
258 rtl8139_regs_lock(rtl8139->io_port);
259}
260
261/** Provide OR in the 8bit register (set selected bits to 1)
262 *
263 * @param rtl8139 The rtl8139 structure
264 * @param reg_offset Register offset in the device IO space
265 * @param bits_add The value to or
266 */
267inline static void rtl8139_hw_reg_add_8(rtl8139_t * rtl8139, size_t reg_offset,
268 uint8_t bits_add)
269{
270 uint8_t value = pio_read_8(rtl8139->io_port + reg_offset);
271 value |= bits_add;
272 pio_write_8(rtl8139->io_port + reg_offset, value);
273}
274
275/** Provide OR in the 32bit register (set selected bits to 1)
276 *
277 * @param rtl8139 The rtl8139 structure
278 * @param reg_offset Register offset in the device IO space
279 * @param bits_add The value to or
280 */
281inline static void rtl8139_hw_reg_add_32(rtl8139_t * rtl8139, size_t reg_offset,
282 uint32_t bits_add)
283{
284 uint32_t value = pio_read_32(rtl8139->io_port + reg_offset);
285 value |= bits_add;
286 pio_write_32(rtl8139->io_port + reg_offset, value);
287}
288
289/** Unset selected bits in 8bit register
290 *
291 * @param rtl8139 The rtl8139 structure
292 * @param reg_offset Register offset in the device IO space
293 * @param bits_add The mask of bits to remove
294 */
295inline static void rtl8139_hw_reg_rem_8(rtl8139_t * rtl8139, size_t reg_offset,
296 uint8_t bits_add)
297{
298 uint8_t value = pio_read_8(rtl8139->io_port + reg_offset);
299 value &= ~bits_add;
300 pio_write_8(rtl8139->io_port + reg_offset, value);
301}
302
303/** Unset selected bits in 32bit register
304 *
305 * @param rtl8139 The rtl8139 structure
306 * @param reg_offset Register offset in the device IO space
307 * @param bits_add The mask of bits to remove
308 */
309inline static void rtl8139_hw_reg_rem_32(rtl8139_t * rtl8139, size_t reg_offset,
310 uint32_t bits_add)
311{
312 uint32_t value = pio_read_32(rtl8139->io_port + reg_offset);
313 value &= ~bits_add;
314 pio_write_32(rtl8139->io_port + reg_offset, value);
315}
316
317
318static int rtl8139_set_addr(ddf_fun_t *fun, const nic_address_t *);
319static int rtl8139_get_device_info(ddf_fun_t *fun, nic_device_info_t *info);
320static int rtl8139_get_cable_state(ddf_fun_t *fun, nic_cable_state_t *state);
321static int rtl8139_get_operation_mode(ddf_fun_t *fun, int *speed,
322 nic_channel_mode_t *duplex, nic_role_t *role);
323static int rtl8139_set_operation_mode(ddf_fun_t *fun, int speed,
324 nic_channel_mode_t duplex, nic_role_t);
325
326static int rtl8139_pause_get(ddf_fun_t*, nic_result_t*, nic_result_t*,
327 uint16_t *);
328static int rtl8139_pause_set(ddf_fun_t*, int, int, uint16_t);
329
330static int rtl8139_autoneg_enable(ddf_fun_t *fun, uint32_t advertisement);
331static int rtl8139_autoneg_disable(ddf_fun_t *fun);
332static int rtl8139_autoneg_probe(ddf_fun_t *fun, uint32_t *our_advertisement,
333 uint32_t *their_advertisement, nic_result_t *result,
334 nic_result_t *their_result);
335static int rtl8139_autoneg_restart(ddf_fun_t *fun);
336
337static int rtl8139_defective_get_mode(ddf_fun_t *fun, uint32_t *mode);
338static int rtl8139_defective_set_mode(ddf_fun_t *fun, uint32_t mode);
339
340static int rtl8139_wol_virtue_add(nic_t *nic_data,
341 const nic_wol_virtue_t *virtue);
342static void rtl8139_wol_virtue_rem(nic_t *nic_data,
343 const nic_wol_virtue_t *virtue);
344
345static int rtl8139_poll_mode_change(nic_t *nic_data, nic_poll_mode_t mode,
346 const struct timeval *period);
347static void rtl8139_poll(nic_t *nic_data);
348
349/** Network interface options for RTL8139 card driver */
350static nic_iface_t rtl8139_nic_iface = {
351 .set_address = &rtl8139_set_addr,
352 .get_device_info = &rtl8139_get_device_info,
353 .get_cable_state = &rtl8139_get_cable_state,
354 .get_operation_mode = &rtl8139_get_operation_mode,
355 .set_operation_mode = &rtl8139_set_operation_mode,
356
357 .get_pause = &rtl8139_pause_get,
358 .set_pause = &rtl8139_pause_set,
359
360 .autoneg_enable = &rtl8139_autoneg_enable,
361 .autoneg_disable = &rtl8139_autoneg_disable,
362 .autoneg_probe = &rtl8139_autoneg_probe,
363 .autoneg_restart = &rtl8139_autoneg_restart,
364
365 .defective_get_mode = &rtl8139_defective_get_mode,
366 .defective_set_mode = &rtl8139_defective_set_mode,
367};
368
369/** Basic device operations for RTL8139 driver */
370static ddf_dev_ops_t rtl8139_dev_ops;
371
372static int rtl8139_dev_add(ddf_dev_t *dev);
373
374/** Basic driver operations for RTL8139 driver */
375static driver_ops_t rtl8139_driver_ops = {
376 .dev_add = &rtl8139_dev_add,
377};
378
379/** Driver structure for RTL8139 driver */
380static driver_t rtl8139_driver = {
381 .name = NAME,
382 .driver_ops = &rtl8139_driver_ops
383};
384
385/* The default implementation callbacks */
386static int rtl8139_on_activated(nic_t *nic_data);
387static int rtl8139_on_stopped(nic_t *nic_data);
388static void rtl8139_send_frame(nic_t *nic_data, void *data, size_t size);
389
390/** Check if the transmit buffer is busy */
391#define rtl8139_tbuf_busy(tsd) ((pio_read_32(tsd) & TSD_OWN) == 0)
392
393/** Send frame with the hardware
394 *
395 * note: the main_lock is locked when framework calls this function
396 *
397 * @param nic_data The nic driver data structure
398 * @param data Frame data
399 * @param size Frame size in bytes
400 *
401 * @return EOK if succeed, error code in the case of error
402 */
403static void rtl8139_send_frame(nic_t *nic_data, void *data, size_t size)
404{
405 assert(nic_data);
406
407 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
408 assert(rtl8139);
409 ddf_msg(LVL_DEBUG, "Sending frame");
410
411 if (size > RTL8139_FRAME_MAX_LENGTH) {
412 ddf_msg(LVL_ERROR, "Send frame: frame too long, %zu bytes",
413 size);
414 nic_report_send_error(rtl8139->nic_data, NIC_SEC_OTHER, 1);
415 goto err_size;
416 }
417
418 assert((size & TSD_SIZE_MASK) == size);
419
420 /* Lock transmitter structure for obtaining next buffer */
421 fibril_mutex_lock(&rtl8139->tx_lock);
422
423 /* Check if there is free buffer */
424 if (rtl8139->tx_next - TX_BUFF_COUNT == rtl8139->tx_used) {
425 nic_set_tx_busy(nic_data, 1);
426 fibril_mutex_unlock(&rtl8139->tx_lock);
427 nic_report_send_error(nic_data, NIC_SEC_BUFFER_FULL, 1);
428 goto err_busy_no_inc;
429 }
430
431 /* Get buffer id to use and set next buffer to use */
432 size_t tx_curr = rtl8139->tx_next++ % TX_BUFF_COUNT;
433
434 fibril_mutex_unlock(&rtl8139->tx_lock);
435
436 /* Get address of the buffer descriptor and frame data */
437 void *tsd = rtl8139->io_port + TSD0 + tx_curr * 4;
438 void *buf_addr = rtl8139->tx_buff[tx_curr];
439
440 /* Wait until the buffer is free */
441 assert(!rtl8139_tbuf_busy(tsd));
442
443 /* Write frame data to the buffer, set the size to TSD and clear OWN bit */
444 memcpy(buf_addr, data, size);
445
446 /* Set size of the data to send */
447 uint32_t tsd_value = pio_read_32(tsd);
448 tsd_value = rtl8139_tsd_set_size(tsd_value, size);
449 pio_write_32(tsd, tsd_value);
450
451 /* barrier for HW to really see the current buffer data */
452 write_barrier();
453
454 tsd_value &= ~(uint32_t)TSD_OWN;
455 pio_write_32(tsd, tsd_value);
456 return;
457
458err_busy_no_inc:
459err_size:
460 return;
461};
462
463
464/** Reset the controller
465 *
466 * @param io_base The address of the i/o port mapping start
467 */
468inline static void rtl8139_hw_soft_reset(void *io_base)
469{
470 pio_write_8(io_base + CR, CR_RST);
471 memory_barrier();
472 while(pio_read_8(io_base + CR) & CR_RST) {
473 usleep(1);
474 read_barrier();
475 }
476}
477
478/** Provide soft reset of the controller
479 *
480 * The caller must lock tx_lock and rx_lock before calling this function
481 *
482 */
483static void rtl8139_soft_reset(rtl8139_t *rtl8139)
484{
485 assert(rtl8139);
486
487 rtl8139_hw_soft_reset(rtl8139->io_port);
488 nic_t *nic_data = rtl8139->nic_data;
489
490 /* Write MAC address to the card */
491 nic_address_t addr;
492 nic_query_address(nic_data, &addr);
493 rtl8139_hw_set_addr(rtl8139, &addr);
494
495 /* Recover accept modes back */
496 rtl8139_hw_set_mcast_mask(rtl8139, nic_query_mcast_hash(nic_data));
497 rtl8139_hw_update_rcr(rtl8139);
498
499 rtl8139->tx_used = 0;
500 rtl8139->tx_next = 0;
501 nic_set_tx_busy(rtl8139->nic_data, 0);
502}
503
504/** Create frame structure from the buffer data
505 *
506 * @param nic_data NIC driver data
507 * @param rx_buffer The receiver buffer
508 * @param rx_size The buffer size
509 * @param frame_start The offset where packet data start
510 * @param frame_size The size of the frame data
511 *
512 * @return The frame list node (not connected)
513 *
514 */
515static nic_frame_t *rtl8139_read_frame(nic_t *nic_data,
516 void *rx_buffer, size_t rx_size, size_t frame_start, size_t frame_size)
517{
518 nic_frame_t *frame = nic_alloc_frame(nic_data, frame_size);
519 if (! frame) {
520 ddf_msg(LVL_ERROR, "Can not allocate frame for received frame.");
521 return NULL;
522 }
523
524 void *ret = rtl8139_memcpy_wrapped(frame->data, rx_buffer, frame_start,
525 RxBUF_SIZE, frame_size);
526 if (ret == NULL) {
527 nic_release_frame(nic_data, frame);
528 return NULL;
529 }
530 return frame;
531}
532
533/* Reset receiver
534 *
535 * Use in the case of receiver error (lost in the rx_buff)
536 *
537 * @param rtl8139 controller private data
538 */
539static void rtl8139_rx_reset(rtl8139_t *rtl8139)
540{
541 /* Disable receiver, update offset and enable receiver again */
542 uint8_t cr = pio_read_8(rtl8139->io_port + CR);
543 rtl8139_regs_unlock(rtl8139);
544
545 pio_write_8(rtl8139->io_port + CR, cr & ~(uint8_t)CR_RE);
546
547 write_barrier();
548 pio_write_32(rtl8139->io_port + CAPR, 0);
549 pio_write_32(rtl8139->io_port + RBSTART,
550 PTR2U32(rtl8139->rx_buff_phys));
551
552 write_barrier();
553
554 rtl8139_hw_update_rcr(rtl8139);
555 pio_write_8(rtl8139->io_port + CR, cr);
556 rtl8139_regs_lock(rtl8139);
557
558 nic_report_receive_error(rtl8139->nic_data, NIC_REC_OTHER, 1);
559}
560
561/** Receive all frames in queue
562 *
563 * @param nic_data The controller data
564 * @return The linked list of nic_frame_list_t nodes, each containing one frame
565 */
566static nic_frame_list_t *rtl8139_frame_receive(nic_t *nic_data)
567{
568 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
569 if (rtl8139_hw_buffer_empty(rtl8139))
570 return NULL;
571
572 nic_frame_list_t *frames = nic_alloc_frame_list();
573 if (!frames)
574 ddf_msg(LVL_ERROR, "Can not allocate frame list for received frames.");
575
576 void *rx_buffer = rtl8139->rx_buff_virt;
577
578 /* where to start reading */
579 uint16_t rx_offset = pio_read_16(rtl8139->io_port + CAPR) + 16;
580 /* unread bytes count */
581 uint16_t bytes_received = pio_read_16(rtl8139->io_port + CBA);
582 uint16_t max_read;
583 uint16_t cur_read = 0;
584
585 /* get values to the <0, buffer size) */
586 bytes_received %= RxBUF_SIZE;
587 rx_offset %= RxBUF_SIZE;
588
589 /* count how many bytes to read maximaly */
590 if (bytes_received < rx_offset)
591 max_read = bytes_received + (RxBUF_SIZE - rx_offset);
592 else
593 max_read = bytes_received - rx_offset;
594
595 memory_barrier();
596 while (!rtl8139_hw_buffer_empty(rtl8139)) {
597 void *rx_ptr = rx_buffer + rx_offset % RxBUF_SIZE;
598 uint32_t frame_header = uint32_t_le2host( *((uint32_t*)rx_ptr) );
599 uint16_t size = frame_header >> 16;
600 uint16_t frame_size = size - RTL8139_CRC_SIZE;
601 /* received frame flags in frame header */
602 uint16_t rcs = (uint16_t) frame_header;
603
604 if (size == RTL8139_EARLY_SIZE) {
605 /* The frame copying is still in progress, break receiving */
606 ddf_msg(LVL_DEBUG, "Early threshold reached, not completely coppied");
607 break;
608 }
609
610 /* Check if the header is valid, otherwise we are lost in the buffer */
611 if (size == 0 || size > RTL8139_FRAME_MAX_LENGTH) {
612 ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (size: %4" PRIu16 ", "
613 "header 0x%4" PRIx32 ". Offset: %" PRIu16 ")", size, frame_header,
614 rx_offset);
615 goto rx_err;
616 }
617 if (size < RTL8139_RUNT_MAX_SIZE && !(rcs & RSR_RUNT)) {
618 ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (%"PRIx16")", size);
619 goto rx_err;
620 }
621
622 cur_read += size + RTL_FRAME_HEADER_SIZE;
623 if (cur_read > max_read)
624 break;
625
626 if (frames) {
627 nic_frame_t *frame = rtl8139_read_frame(nic_data, rx_buffer,
628 RxBUF_SIZE, rx_offset + RTL_FRAME_HEADER_SIZE, frame_size);
629
630 if (frame)
631 nic_frame_list_append(frames, frame);
632 }
633
634 /* Update offset */
635 rx_offset = ALIGN_UP(rx_offset + size + RTL_FRAME_HEADER_SIZE, 4);
636
637 /* Write lesser value to prevent overflow into unread frame
638 * (the recomendation from the RealTech rtl8139 programming guide)
639 */
640 uint16_t capr_val = rx_offset - 16;
641 pio_write_16(rtl8139->io_port + CAPR, capr_val);
642
643 /* Ensure no CR read optimalization during next empty buffer test */
644 memory_barrier();
645 }
646 return frames;
647rx_err:
648 rtl8139_rx_reset(rtl8139);
649 return frames;
650};
651
652
653irq_pio_range_t rtl8139_irq_pio_ranges[] = {
654 {
655 .base = 0,
656 .size = RTL8139_IO_SIZE
657 }
658};
659
660/** Commands to deal with interrupt
661 *
662 * Read ISR, check if tere is any interrupt pending.
663 * If so, reset it and accept the interrupt.
664 * The .addr of the first and third command must
665 * be filled to the ISR port address
666 */
667irq_cmd_t rtl8139_irq_commands[] = {
668 {
669 /* Get the interrupt status */
670 .cmd = CMD_PIO_READ_16,
671 .addr = NULL,
672 .dstarg = 2
673 },
674 {
675 .cmd = CMD_PREDICATE,
676 .value = 3,
677 .srcarg = 2
678 },
679 {
680 /* Mark interrupts as solved */
681 .cmd = CMD_PIO_WRITE_16,
682 .addr = NULL,
683 .value = 0xFFFF
684 },
685 {
686 /* Disable interrupts until interrupt routine is finished */
687 .cmd = CMD_PIO_WRITE_16,
688 .addr = NULL,
689 .value = 0x0000
690 },
691 {
692 .cmd = CMD_ACCEPT
693 }
694};
695
696/** Interrupt code definition */
697irq_code_t rtl8139_irq_code = {
698 .rangecount = sizeof(rtl8139_irq_pio_ranges) / sizeof(irq_pio_range_t),
699 .ranges = rtl8139_irq_pio_ranges,
700 .cmdcount = sizeof(rtl8139_irq_commands) / sizeof(irq_cmd_t),
701 .cmds = rtl8139_irq_commands
702};
703
704/** Deal with transmitter interrupt
705 *
706 * @param nic_data Nic driver data
707 */
708static void rtl8139_tx_interrupt(nic_t *nic_data)
709{
710 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
711
712 fibril_mutex_lock(&rtl8139->tx_lock);
713
714 size_t tx_next = rtl8139->tx_next;
715 size_t tx_used = rtl8139->tx_used;
716 while (tx_used != tx_next) {
717 size_t desc_to_check = tx_used % TX_BUFF_COUNT;
718 void * tsd_to_check = rtl8139->io_port + TSD0
719 + desc_to_check * sizeof(uint32_t);
720 uint32_t tsd_value = pio_read_32(tsd_to_check);
721
722 /* If sending is still in the progress */
723 if ((tsd_value & TSD_OWN) == 0)
724 break;
725
726 tx_used++;
727
728 /* If the frame was sent */
729 if (tsd_value & TSD_TOK) {
730 size_t size = REG_GET_VAL(tsd_value, TSD_SIZE);
731 nic_report_send_ok(nic_data, 1, size);
732 } else if (tsd_value & TSD_CRS) {
733 nic_report_send_error(nic_data, NIC_SEC_CARRIER_LOST, 1);
734 } else if (tsd_value & TSD_OWC) {
735 nic_report_send_error(nic_data, NIC_SEC_WINDOW_ERROR, 1);
736 } else if (tsd_value & TSD_TABT) {
737 nic_report_send_error(nic_data, NIC_SEC_ABORTED, 1);
738 } else if (tsd_value & TSD_CDH) {
739 nic_report_send_error(nic_data, NIC_SEC_HEARTBEAT, 1);
740 }
741
742 unsigned collisions = REG_GET_VAL(tsd_value, TSD_NCC);
743 if (collisions > 0) {
744 nic_report_collisions(nic_data, collisions);
745 }
746
747 if (tsd_value & TSD_TUN) {
748 nic_report_send_error(nic_data, NIC_SEC_FIFO_OVERRUN, 1);
749 }
750 }
751 if (rtl8139->tx_used != tx_used) {
752 rtl8139->tx_used = tx_used;
753 nic_set_tx_busy(nic_data, 0);
754 }
755 fibril_mutex_unlock(&rtl8139->tx_lock);
756}
757
758/** Receive all frames from the buffer
759 *
760 * @param rtl8139 driver private data
761 */
762static void rtl8139_receive_frames(nic_t *nic_data)
763{
764 assert(nic_data);
765
766 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
767 assert(rtl8139);
768
769 fibril_mutex_lock(&rtl8139->rx_lock);
770 nic_frame_list_t *frames = rtl8139_frame_receive(nic_data);
771 fibril_mutex_unlock(&rtl8139->rx_lock);
772
773 if (frames)
774 nic_received_frame_list(nic_data, frames);
775}
776
777
778/** Deal with poll interrupt
779 *
780 * @param nic_data Nic driver data
781 */
782static int rtl8139_poll_interrupt(nic_t *nic_data)
783{
784 assert(nic_data);
785
786 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
787 assert(rtl8139);
788
789 uint32_t timer_val;
790 int receive = rtl8139_timer_act_step(&rtl8139->poll_timer, &timer_val);
791
792 assert(timer_val);
793 pio_write_32(rtl8139->io_port + TIMERINT, timer_val);
794 pio_write_32(rtl8139->io_port + TCTR, 0x0);
795 ddf_msg(LVL_DEBUG, "rtl8139 timer: %"PRIu32"\treceive: %d", timer_val, receive);
796 return receive;
797}
798
799
800/** Poll device according to isr status
801 *
802 * The isr value must be obtained and cleared by the caller. The reason
803 * of this function separate is to allow polling from both interrupt
804 * (which clears controller ISR before the handler runs) and the polling
805 * callbacks.
806 *
807 * @param nic_data Driver data
808 * @param isr Interrupt status register value
809 */
810static void rtl8139_interrupt_impl(nic_t *nic_data, uint16_t isr)
811{
812 assert(nic_data);
813
814 nic_poll_mode_t poll_mode = nic_query_poll_mode(nic_data, 0);
815
816 /* Process only when should in the polling mode */
817 if (poll_mode == NIC_POLL_PERIODIC) {
818 int receive = 0;
819 if (isr & INT_TIME_OUT) {
820 receive = rtl8139_poll_interrupt(nic_data);
821 }
822 if (! receive)
823 return;
824 }
825
826 /* Check transmittion interrupts first to allow transmit next frames
827 * sooner
828 */
829 if (isr & (INT_TOK | INT_TER)) {
830 rtl8139_tx_interrupt(nic_data);
831 }
832 if (isr & INT_ROK) {
833 rtl8139_receive_frames(nic_data);
834 }
835 if (isr & (INT_RER | INT_RXOVW | INT_FIFOOVW)) {
836 if (isr & INT_RER) {
837 //TODO: is this only the general error, or any particular?
838 }
839 if (isr & (INT_FIFOOVW)) {
840 nic_report_receive_error(nic_data, NIC_REC_FIFO_OVERRUN, 1);
841 } else if (isr & (INT_RXOVW)) {
842 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
843 assert(rtl8139);
844
845 uint32_t miss = pio_read_32(rtl8139->io_port + MPC) & MPC_VMASK;
846 pio_write_32(rtl8139->io_port + MPC, 0);
847 nic_report_receive_error(nic_data, NIC_REC_BUFFER_OVERFLOW, miss);
848 }
849 }
850}
851
852/** Handle device interrupt
853 *
854 * @param iid The IPC call id
855 * @param icall The IPC call structure
856 * @param dev The rtl8139 device
857 *
858 */
859static void rtl8139_interrupt_handler(ipc_callid_t iid, ipc_call_t *icall,
860 ddf_dev_t *dev)
861{
862 assert(dev);
863 assert(icall);
864
865 uint16_t isr = (uint16_t) IPC_GET_ARG2(*icall);
866 nic_t *nic_data = nic_get_from_ddf_dev(dev);
867 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
868
869 rtl8139_interrupt_impl(nic_data, isr);
870
871 /* Turn the interrupts on again */
872 rtl8139_hw_int_enable(rtl8139);
873};
874
875/** Register interrupt handler for the card in the system
876 *
877 * Note: the global irq_reg_mutex is locked because of work with global
878 * structure.
879 *
880 * @param nic_data The driver data
881 *
882 * @return EOK if the handler was registered, negative error code otherwise
883 */
884inline static int rtl8139_register_int_handler(nic_t *nic_data)
885{
886 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
887
888 /* Lock the mutex in whole driver while working with global structure */
889 RTL8139_IRQ_STRUCT_LOCK();
890
891 rtl8139_irq_code.ranges[0].base = (uintptr_t) rtl8139->io_addr;
892 rtl8139_irq_code.cmds[0].addr = rtl8139->io_addr + ISR;
893 rtl8139_irq_code.cmds[2].addr = rtl8139->io_addr + ISR;
894 rtl8139_irq_code.cmds[3].addr = rtl8139->io_addr + IMR;
895 int rc = register_interrupt_handler(nic_get_ddf_dev(nic_data),
896 rtl8139->irq, rtl8139_interrupt_handler, &rtl8139_irq_code);
897
898 RTL8139_IRQ_STRUCT_UNLOCK();
899
900 return rc;
901}
902
903/** Start the controller
904 *
905 * The caller must lock tx_lock and rx_lock before calling this function
906 *
907 * @param rtl8139 The card private data
908 */
909inline static void rtl8139_card_up(rtl8139_t *rtl8139)
910{
911 void *io_base = rtl8139->io_port;
912 size_t i;
913
914 /* Wake up the device */
915 pio_write_8(io_base + CONFIG1, 0x00);
916 /* Reset the device */
917 rtl8139_soft_reset(rtl8139);
918
919 /* Write transmittion buffer addresses */
920 for(i = 0; i < TX_BUFF_COUNT; ++i) {
921 uint32_t addr = PTR2U32(rtl8139->tx_buff_phys + i*TX_BUFF_SIZE);
922 pio_write_32(io_base + TSAD0 + 4*i, addr);
923 }
924 rtl8139->tx_next = 0;
925 rtl8139->tx_used = 0;
926 nic_set_tx_busy(rtl8139->nic_data, 0);
927
928 pio_write_32(io_base + RBSTART, PTR2U32(rtl8139->rx_buff_phys));
929
930 /* Enable transmitter and receiver */
931 uint8_t cr_value = pio_read_8(io_base + CR);
932 pio_write_8(io_base + CR, cr_value | CR_TE | CR_RE);
933 rtl8139_hw_update_rcr(rtl8139);
934}
935
936/** Activate the device to receive and transmit frames
937 *
938 * @param nic_data The nic driver data
939 *
940 * @return EOK if activated successfully, error code otherwise
941 */
942static int rtl8139_on_activated(nic_t *nic_data)
943{
944 assert(nic_data);
945 ddf_msg(LVL_NOTE, "Activating device");
946
947 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
948 assert(rtl8139);
949
950 rtl8139_lock_all(rtl8139);
951 rtl8139_card_up(rtl8139);
952 rtl8139_unlock_all(rtl8139);
953
954 rtl8139->int_mask = RTL_DEFAULT_INTERRUPTS;
955 rtl8139_hw_int_enable(rtl8139);
956
957 int rc = irc_enable_interrupt(rtl8139->irq);
958 if (rc != EOK) {
959 rtl8139_on_stopped(nic_data);
960 return rc;
961 }
962
963 ddf_msg(LVL_DEBUG, "Device activated, interrupt %d registered", rtl8139->irq);
964 return EOK;
965}
966
967/** Callback for NIC_STATE_STOPPED change
968 *
969 * @param nic_data The nic driver data
970 *
971 * @return EOK if succeed, error code otherwise
972 */
973static int rtl8139_on_stopped(nic_t *nic_data)
974{
975 assert(nic_data);
976
977 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
978 assert(rtl8139);
979
980 rtl8139->rcr_data.ucast_mask = RTL8139_RCR_UCAST_DEFAULT;
981 rtl8139->rcr_data.mcast_mask = RTL8139_RCR_MCAST_DEFAULT;
982 rtl8139->rcr_data.bcast_mask = RTL8139_RCR_BCAST_DEFAULT;
983 rtl8139->rcr_data.defect_mask = RTL8139_RCR_DEFECT_DEFAULT;
984
985 /* Reset the card to the initial state (interrupts, Tx and Rx disabled) */
986 rtl8139_lock_all(rtl8139);
987 rtl8139_soft_reset(rtl8139);
988 rtl8139_unlock_all(rtl8139);
989 return EOK;
990}
991
992
993static int rtl8139_unicast_set(nic_t *nic_data, nic_unicast_mode_t mode,
994 const nic_address_t *, size_t);
995static int rtl8139_multicast_set(nic_t *nic_data, nic_multicast_mode_t mode,
996 const nic_address_t *addr, size_t addr_count);
997static int rtl8139_broadcast_set(nic_t *nic_data, nic_broadcast_mode_t mode);
998
999
1000/** Create driver data structure
1001 *
1002 * @return Intialized device data structure or NULL
1003 */
1004static rtl8139_t *rtl8139_create_dev_data(ddf_dev_t *dev)
1005{
1006 assert(dev);
1007 assert(!nic_get_from_ddf_dev(dev));
1008
1009 nic_t *nic_data = nic_create_and_bind(dev);
1010 if (!nic_data)
1011 return NULL;
1012
1013 rtl8139_t *rtl8139 = malloc(sizeof(rtl8139_t));
1014 if (!rtl8139) {
1015 nic_unbind_and_destroy(dev);
1016 return NULL;
1017 }
1018
1019 memset(rtl8139, 0, sizeof(rtl8139_t));
1020
1021 rtl8139->nic_data = nic_data;
1022 nic_set_specific(nic_data, rtl8139);
1023 nic_set_send_frame_handler(nic_data, rtl8139_send_frame);
1024 nic_set_state_change_handlers(nic_data,
1025 rtl8139_on_activated, NULL, rtl8139_on_stopped);
1026 nic_set_filtering_change_handlers(nic_data,
1027 rtl8139_unicast_set, rtl8139_multicast_set, rtl8139_broadcast_set,
1028 NULL, NULL);
1029 nic_set_wol_virtue_change_handlers(nic_data,
1030 rtl8139_wol_virtue_add, rtl8139_wol_virtue_rem);
1031 nic_set_poll_handlers(nic_data, rtl8139_poll_mode_change, rtl8139_poll);
1032
1033
1034 fibril_mutex_initialize(&rtl8139->rx_lock);
1035 fibril_mutex_initialize(&rtl8139->tx_lock);
1036
1037 nic_set_wol_max_caps(nic_data, NIC_WV_BROADCAST, 1);
1038 nic_set_wol_max_caps(nic_data, NIC_WV_LINK_CHANGE, 1);
1039 nic_set_wol_max_caps(nic_data, NIC_WV_MAGIC_PACKET, 1);
1040
1041 return rtl8139;
1042}
1043
1044/** Clean up the rtl8139 device structure.
1045 *
1046 * @param dev The device structure.
1047 */
1048static void rtl8139_dev_cleanup(ddf_dev_t *dev)
1049{
1050 assert(dev);
1051
1052 if (ddf_dev_data_get(dev))
1053 nic_unbind_and_destroy(dev);
1054}
1055
1056/** Fill the irq and io_addr part of device data structure
1057 *
1058 * The hw_resources must be obtained before calling this function
1059 *
1060 * @param dev The device structure
1061 * @param hw_resources Devices hardware resources
1062 *
1063 * @return EOK if succeed, negative error code otherwise
1064 */
1065static int rtl8139_fill_resource_info(ddf_dev_t *dev, const hw_res_list_parsed_t
1066 *hw_resources)
1067{
1068 assert(dev);
1069 assert(hw_resources);
1070
1071 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_dev(dev));
1072 assert(rtl8139);
1073
1074 if (hw_resources->irqs.count != 1) {
1075 ddf_msg(LVL_ERROR, "%s device: unexpected irq count", ddf_dev_get_name(dev));
1076 return EINVAL;
1077 };
1078 if (hw_resources->io_ranges.count != 1) {
1079 ddf_msg(LVL_ERROR, "%s device: unexpected io ranges count", ddf_dev_get_name(dev));
1080 return EINVAL;
1081 }
1082
1083 rtl8139->irq = hw_resources->irqs.irqs[0];
1084 ddf_msg(LVL_DEBUG, "%s device: irq 0x%x assigned", ddf_dev_get_name(dev), rtl8139->irq);
1085
1086 rtl8139->io_addr = IOADDR_TO_PTR(RNGABS(hw_resources->io_ranges.ranges[0]));
1087 if (hw_resources->io_ranges.ranges[0].size < RTL8139_IO_SIZE) {
1088 ddf_msg(LVL_ERROR, "i/o range assigned to the device "
1089 "%s is too small.", ddf_dev_get_name(dev));
1090 return EINVAL;
1091 }
1092 ddf_msg(LVL_DEBUG, "%s device: i/o addr %p assigned.", ddf_dev_get_name(dev), rtl8139->io_addr);
1093
1094 return EOK;
1095}
1096
1097/** Obtain information about hardware resources of the device
1098 *
1099 * The device must be connected to the parent
1100 *
1101 * @param dev The device structure
1102 *
1103 * @return EOK if succeed, negative error code otherwise
1104 */
1105static int rtl8139_get_resource_info(ddf_dev_t *dev)
1106{
1107 assert(dev);
1108
1109 nic_t *nic_data = nic_get_from_ddf_dev(dev);
1110 assert(nic_data);
1111
1112 hw_res_list_parsed_t hw_res_parsed;
1113 hw_res_list_parsed_init(&hw_res_parsed);
1114
1115 /* Get hw resources form parent driver */
1116 int rc = nic_get_resources(nic_data, &hw_res_parsed);
1117 if (rc != EOK)
1118 return rc;
1119
1120 /* Fill resources information to the device */
1121 int ret = rtl8139_fill_resource_info(dev, &hw_res_parsed);
1122 hw_res_list_parsed_clean(&hw_res_parsed);
1123
1124 return ret;
1125}
1126
1127
1128/** Allocate buffers using DMA framework
1129 *
1130 * The buffers structures in the device specific data is filled
1131 *
1132 * @param data The device specific structure to fill
1133 *
1134 * @return EOK in the case of success, error code otherwise
1135 */
1136static int rtl8139_buffers_create(rtl8139_t *rtl8139)
1137{
1138 size_t i = 0;
1139 int rc;
1140
1141 ddf_msg(LVL_DEBUG, "Creating buffers");
1142
1143 rtl8139->tx_buff_virt = AS_AREA_ANY;
1144 rc = dmamem_map_anonymous(TX_PAGES * PAGE_SIZE, DMAMEM_4GiB,
1145 AS_AREA_WRITE, 0, &rtl8139->tx_buff_phys, &rtl8139->tx_buff_virt);
1146 if (rc != EOK) {
1147 ddf_msg(LVL_ERROR, "Can not allocate transmitter buffers.");
1148 goto err_tx_alloc;
1149 }
1150
1151 for (i = 0; i < TX_BUFF_COUNT; ++i)
1152 rtl8139->tx_buff[i] = rtl8139->tx_buff_virt + i * TX_BUFF_SIZE;
1153
1154 ddf_msg(LVL_DEBUG, "The transmittion buffers allocated");
1155
1156 /* Use the first buffer for next transmittion */
1157 rtl8139->tx_next = 0;
1158 rtl8139->tx_used = 0;
1159
1160 /* Allocate buffer for receiver */
1161 ddf_msg(LVL_DEBUG, "Allocating receiver buffer of the size %d bytes",
1162 RxBUF_TOT_LENGTH);
1163
1164 rtl8139->rx_buff_virt = AS_AREA_ANY;
1165 rc = dmamem_map_anonymous(RxBUF_TOT_LENGTH, DMAMEM_4GiB,
1166 AS_AREA_READ, 0, &rtl8139->rx_buff_phys, &rtl8139->rx_buff_virt);
1167 if (rc != EOK) {
1168 ddf_msg(LVL_ERROR, "Can not allocate receive buffer.");
1169 goto err_rx_alloc;
1170 }
1171 ddf_msg(LVL_DEBUG, "The buffers created");
1172
1173 return EOK;
1174
1175err_rx_alloc:
1176 dmamem_unmap_anonymous(&rtl8139->tx_buff_virt);
1177err_tx_alloc:
1178 return rc;
1179}
1180
1181/** Initialize the rtl8139 device structure
1182 *
1183 * @param dev The device information
1184 *
1185 * @return EOK if succeed, negative error code otherwise
1186 */
1187static int rtl8139_device_initialize(ddf_dev_t *dev)
1188{
1189 ddf_msg(LVL_DEBUG, "rtl8139_dev_initialize %s", ddf_dev_get_name(dev));
1190
1191 int ret = EOK;
1192
1193 ddf_msg(LVL_DEBUG, "rtl8139: creating device data");
1194
1195 /* Allocate driver data for the device. */
1196 rtl8139_t *rtl8139 = rtl8139_create_dev_data(dev);
1197 if (rtl8139 == NULL) {
1198 ddf_msg(LVL_ERROR, "Not enough memory for initializing %s.", ddf_dev_get_name(dev));
1199 return ENOMEM;
1200 }
1201
1202 ddf_msg(LVL_DEBUG, "rtl8139: dev_data created");
1203
1204 /* Obtain and fill hardware resources info and connect to parent */
1205 ret = rtl8139_get_resource_info(dev);
1206 if (ret != EOK) {
1207 ddf_msg(LVL_ERROR, "Can not obatin hw resources information");
1208 goto failed;
1209 }
1210
1211 ddf_msg(LVL_DEBUG, "rtl8139: resource_info obtained");
1212
1213 /* Allocate DMA buffers */
1214 ret = rtl8139_buffers_create(rtl8139);
1215 if (ret != EOK)
1216 goto failed;
1217
1218 /* Set default frame acceptance */
1219 rtl8139->rcr_data.ucast_mask = RTL8139_RCR_UCAST_DEFAULT;
1220 rtl8139->rcr_data.mcast_mask = RTL8139_RCR_MCAST_DEFAULT;
1221 rtl8139->rcr_data.bcast_mask = RTL8139_RCR_BCAST_DEFAULT;
1222 rtl8139->rcr_data.defect_mask = RTL8139_RCR_DEFECT_DEFAULT;
1223 /* Set receiver early treshold to 8/16 of frame length */
1224 rtl8139->rcr_data.rcr_base = (0x8 << RCR_ERTH_SHIFT);
1225
1226 ddf_msg(LVL_DEBUG, "The device is initialized");
1227 return ret;
1228
1229failed:
1230 ddf_msg(LVL_ERROR, "The device initialization failed");
1231 rtl8139_dev_cleanup(dev);
1232 return ret;
1233}
1234
1235/** Enable the i/o ports of the device.
1236 *
1237 * @param dev The RTL8139 device.
1238 *
1239 * @return EOK if successed, negative error code otherwise
1240 */
1241static int rtl8139_pio_enable(ddf_dev_t *dev)
1242{
1243 ddf_msg(LVL_DEBUG, NAME ": rtl8139_pio_enable %s", ddf_dev_get_name(dev));
1244
1245 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_dev(dev));
1246
1247 /* Gain control over port's registers. */
1248 if (pio_enable(rtl8139->io_addr, RTL8139_IO_SIZE, &rtl8139->io_port)) {
1249 ddf_msg(LVL_ERROR, "Cannot gain the port %p for device %s.", rtl8139->io_addr,
1250 ddf_dev_get_name(dev));
1251 return EADDRNOTAVAIL;
1252 }
1253
1254 return EOK;
1255}
1256
1257/** Initialize the driver private data according to the
1258 * device registers
1259 *
1260 * @param rtl8139 rtl8139 private data
1261 */
1262static void rtl8139_data_init(rtl8139_t *rtl8139)
1263{
1264 assert(rtl8139);
1265
1266 /* Check the version id */
1267 uint32_t tcr = pio_read_32(rtl8139->io_port + TCR);
1268 uint32_t hwverid = RTL8139_HWVERID(tcr);
1269 size_t i = 0;
1270 rtl8139->hw_version = RTL8139_VER_COUNT;
1271 for (i = 0; i < RTL8139_VER_COUNT; ++i) {
1272 if (rtl8139_versions[i].hwverid == 0)
1273 break;
1274
1275 if (rtl8139_versions[i].hwverid == hwverid) {
1276 rtl8139->hw_version = rtl8139_versions[i].ver_id;
1277 ddf_msg(LVL_NOTE, "HW version found: index %zu, ver_id %d (%s)", i,
1278 rtl8139_versions[i].ver_id, model_names[rtl8139->hw_version]);
1279 }
1280 }
1281}
1282
1283/** The add_device callback of RTL8139 callback
1284 *
1285 * Probe and initialize the newly added device.
1286 *
1287 * @param dev The RTL8139 device.
1288 *
1289 * @return EOK if added successfully, negative error code otherwise
1290 */
1291int rtl8139_dev_add(ddf_dev_t *dev)
1292{
1293 ddf_fun_t *fun;
1294
1295 assert(dev);
1296 ddf_msg(LVL_NOTE, "RTL8139_dev_add %s (handle = %zu)",
1297 ddf_dev_get_name(dev), ddf_dev_get_handle(dev));
1298
1299 /* Init device structure for rtl8139 */
1300 int rc = rtl8139_device_initialize(dev);
1301 if (rc != EOK)
1302 return rc;
1303
1304 /* Map I/O ports */
1305 rc = rtl8139_pio_enable(dev);
1306 if (rc != EOK)
1307 goto err_destroy;
1308
1309 nic_t *nic_data = nic_get_from_ddf_dev(dev);
1310 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
1311
1312 nic_address_t addr;
1313 rtl8139_hw_get_addr(rtl8139, &addr);
1314 rc = nic_report_address(nic_data, &addr);
1315 if (rc != EOK)
1316 goto err_pio;
1317
1318 /* Initialize the driver private structure */
1319 rtl8139_data_init(rtl8139);
1320
1321 /* Register interrupt handler */
1322 rc = rtl8139_register_int_handler(nic_data);
1323 if (rc != EOK)
1324 goto err_pio;
1325
1326 fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
1327 if (fun == NULL) {
1328 ddf_msg(LVL_ERROR, "Failed creating device function");
1329 goto err_srv;
1330 }
1331
1332 nic_set_ddf_fun(nic_data, fun);
1333 ddf_fun_set_ops(fun, &rtl8139_dev_ops);
1334
1335 rc = ddf_fun_bind(fun);
1336 if (rc != EOK) {
1337 ddf_msg(LVL_ERROR, "Failed binding device function");
1338 goto err_fun_create;
1339 }
1340 rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
1341 if (rc != EOK) {
1342 ddf_msg(LVL_ERROR, "Failed adding function to category");
1343 goto err_fun_bind;
1344 }
1345
1346 ddf_msg(LVL_NOTE, "The %s device has been successfully initialized.",
1347 ddf_dev_get_name(dev));
1348
1349 return EOK;
1350
1351err_fun_bind:
1352 ddf_fun_unbind(fun);
1353err_fun_create:
1354 ddf_fun_destroy(fun);
1355err_srv:
1356 unregister_interrupt_handler(dev, rtl8139->irq);
1357err_pio:
1358 // rtl8139_pio_disable(dev);
1359 /* TODO: find out if the pio_disable is needed */
1360err_destroy:
1361 rtl8139_dev_cleanup(dev);
1362 return rc;
1363};
1364
1365/** Set card MAC address
1366 *
1367 * @param device The RTL8139 device
1368 * @param address The place to store the address
1369 * @param max_len Maximal addresss length to store
1370 *
1371 * @return EOK if succeed, negative error code otherwise
1372 */
1373static int rtl8139_set_addr(ddf_fun_t *fun, const nic_address_t *addr)
1374{
1375 assert(fun);
1376 assert(addr);
1377
1378 nic_t *nic_data =nic_get_from_ddf_fun((fun));
1379 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
1380 assert(rtl8139);
1381
1382 rtl8139_lock_all(rtl8139);
1383
1384 int rc = nic_report_address(nic_data, addr);
1385 if ( rc != EOK) {
1386 rtl8139_unlock_all(rtl8139);
1387 return rc;
1388 }
1389
1390 rtl8139_hw_set_addr(rtl8139, addr);
1391
1392 rtl8139_unlock_all(rtl8139);
1393 return EOK;
1394}
1395
1396/** Get the device information
1397 *
1398 * @param dev The NIC device
1399 * @param info The information to fill
1400 *
1401 * @return EOK
1402 */
1403static int rtl8139_get_device_info(ddf_fun_t *fun, nic_device_info_t *info)
1404{
1405 assert(fun);
1406 assert(info);
1407
1408 nic_t *nic_data = nic_get_from_ddf_fun(fun);
1409 assert(nic_data);
1410 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
1411 assert(rtl8139);
1412
1413 /* TODO: fill the information more completely */
1414 info->vendor_id = 0x10ec;
1415 str_cpy(info->vendor_name, NIC_VENDOR_MAX_LENGTH, "Realtek");
1416
1417 if (rtl8139->hw_version < RTL8139_VER_COUNT) {
1418 str_cpy(info->model_name, NIC_MODEL_MAX_LENGTH,
1419 model_names[rtl8139->hw_version]);
1420 } else {
1421 str_cpy(info->model_name, NIC_MODEL_MAX_LENGTH, "RTL8139");
1422 }
1423
1424 info->ethernet_support[ETH_10M] = ETH_10BASE_T;
1425 info->ethernet_support[ETH_100M] = ETH_100BASE_TX;
1426
1427 info->autoneg_support = RTL8139_AUTONEG_CAPS;
1428 return EOK;
1429}
1430
1431/** Check the cable state
1432 *
1433 * @param[in] dev The device
1434 * @param[out] state The state to fill
1435 *
1436 * @return EOK
1437 */
1438static int rtl8139_get_cable_state(ddf_fun_t *fun, nic_cable_state_t *state)
1439{
1440 assert(fun);
1441 assert(state);
1442
1443 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1444 assert(rtl8139);
1445
1446 if (pio_read_16(rtl8139->io_port + CSCR) & CS_CON_STATUS) {
1447 *state = NIC_CS_PLUGGED;
1448 } else {
1449 *state = NIC_CS_UNPLUGGED;
1450 }
1451
1452 return EOK;
1453}
1454
1455/** Get operation mode of the device
1456 */
1457static int rtl8139_get_operation_mode(ddf_fun_t *fun, int *speed,
1458 nic_channel_mode_t *duplex, nic_role_t *role)
1459{
1460 assert(fun);
1461 assert(speed);
1462 assert(duplex);
1463 assert(role);
1464
1465 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1466 assert(rtl8139);
1467
1468 uint16_t bmcr_val = pio_read_16(rtl8139->io_port + BMCR);
1469 uint8_t msr_val = pio_read_8(rtl8139->io_port + MSR);
1470
1471 if (bmcr_val & BMCR_DUPLEX) {
1472 *duplex = NIC_CM_FULL_DUPLEX;
1473 } else {
1474 *duplex = NIC_CM_HALF_DUPLEX;
1475 }
1476
1477 if (msr_val & MSR_SPEED10) {
1478 *speed = 10;
1479 } else {
1480 *speed = 100;
1481 }
1482
1483 *role = NIC_ROLE_UNKNOWN;
1484 return EOK;
1485}
1486
1487/** Value validity */
1488enum access_mode {
1489 /** Value is invalid now */
1490 VALUE_INVALID = 0,
1491 /** Read-only */
1492 VALUE_RO,
1493 /** Read-write */
1494 VALUE_RW
1495};
1496
1497/** Check if pause frame operations are valid in current situation
1498 *
1499 * @param rtl8139 RTL8139 private structure
1500 *
1501 * @return VALUE_INVALID if the value has no sense in current moment
1502 * @return VALUE_RO if the state is read-only in current moment
1503 * @return VALUE_RW if the state can be modified
1504 */
1505static int rtl8139_pause_is_valid(rtl8139_t *rtl8139)
1506{
1507 assert(rtl8139);
1508
1509 uint16_t bmcr = pio_read_16(rtl8139->io_port + BMCR);
1510 if ((bmcr & (BMCR_AN_ENABLE | BMCR_DUPLEX)) == 0)
1511 return VALUE_INVALID;
1512
1513 if (bmcr & BMCR_AN_ENABLE) {
1514 uint16_t anar_lp = pio_read_16(rtl8139->io_port + ANLPAR);
1515 if (anar_lp & ANAR_PAUSE)
1516 return VALUE_RO;
1517 }
1518
1519 return VALUE_RW;
1520}
1521
1522/** Get current pause frame configuration
1523 *
1524 * Values are filled with NIC_RESULT_NOT_AVAILABLE if the value has no sense in
1525 * the moment (half-duplex).
1526 *
1527 * @param[in] fun The DDF structure of the RTL8139
1528 * @param[out] we_send Sign if local constroller sends pause frame
1529 * @param[out] we_receive Sign if local constroller receives pause frame
1530 * @param[out] time Time filled in pause frames. 0xFFFF in rtl8139
1531 *
1532 * @return EOK if succeed
1533 */
1534static int rtl8139_pause_get(ddf_fun_t *fun, nic_result_t *we_send,
1535 nic_result_t *we_receive, uint16_t *time)
1536{
1537 assert(fun);
1538 assert(we_send);
1539 assert(we_receive);
1540
1541 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1542 assert(rtl8139);
1543
1544 if (rtl8139_pause_is_valid(rtl8139) == VALUE_INVALID) {
1545 *we_send = NIC_RESULT_NOT_AVAILABLE;
1546 *we_receive = NIC_RESULT_NOT_AVAILABLE;
1547 *time = 0;
1548 return EOK;
1549 }
1550
1551 uint8_t msr = pio_read_8(rtl8139->io_port + MSR);
1552
1553 *we_send = (msr & MSR_TXFCE) ? NIC_RESULT_ENABLED : NIC_RESULT_DISABLED;
1554 *we_receive = (msr & MSR_RXFCE) ? NIC_RESULT_ENABLED : NIC_RESULT_DISABLED;
1555 *time = RTL8139_PAUSE_VAL;
1556
1557 return EOK;
1558};
1559
1560/** Set current pause frame configuration
1561 *
1562 * @param fun The DDF structure of the RTL8139
1563 * @param allow_send Sign if local constroller sends pause frame
1564 * @param allow_receive Sign if local constroller receives pause frames
1565 * @param time Time to use, ignored (not supported by device)
1566 *
1567 * @return EOK if succeed, INVAL if the pause frame has no sence
1568 */
1569static int rtl8139_pause_set(ddf_fun_t *fun, int allow_send, int allow_receive,
1570 uint16_t time)
1571{
1572 assert(fun);
1573
1574 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1575 assert(rtl8139);
1576
1577 if (rtl8139_pause_is_valid(rtl8139) != VALUE_RW)
1578 return EINVAL;
1579
1580 uint8_t msr = pio_read_8(rtl8139->io_port + MSR);
1581 msr &= ~(uint8_t)(MSR_TXFCE | MSR_RXFCE);
1582
1583 if (allow_receive)
1584 msr |= MSR_RXFCE;
1585 if (allow_send)
1586 msr |= MSR_TXFCE;
1587
1588 pio_write_8(rtl8139->io_port + MSR, msr);
1589
1590 if (allow_send && time > 0) {
1591 ddf_msg(LVL_WARN, "Time setting is not supported in set_pause method.");
1592 }
1593 return EOK;
1594};
1595
1596/** Set operation mode of the device
1597 *
1598 */
1599static int rtl8139_set_operation_mode(ddf_fun_t *fun, int speed,
1600 nic_channel_mode_t duplex, nic_role_t role)
1601{
1602 assert(fun);
1603
1604 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1605 assert(rtl8139);
1606
1607 if (speed != 10 && speed != 100)
1608 return EINVAL;
1609 if (duplex != NIC_CM_HALF_DUPLEX && duplex != NIC_CM_FULL_DUPLEX)
1610 return EINVAL;
1611
1612 uint16_t bmcr_val = pio_read_16(rtl8139->io_port + BMCR);
1613
1614 /* Set autonegotion disabled */
1615 bmcr_val &= ~(uint16_t)BMCR_AN_ENABLE;
1616
1617 if (duplex == NIC_CM_FULL_DUPLEX) {
1618 bmcr_val |= BMCR_DUPLEX;
1619 } else {
1620 bmcr_val &= ~((uint16_t)BMCR_DUPLEX);
1621 }
1622
1623 if (speed == 100) {
1624 bmcr_val |= BMCR_Spd_100;
1625 } else {
1626 bmcr_val &= ~((uint16_t)BMCR_Spd_100);
1627 }
1628
1629 rtl8139_regs_unlock(rtl8139->io_port);
1630 pio_write_16(rtl8139->io_port + BMCR, bmcr_val);
1631 rtl8139_regs_lock(rtl8139->io_port);
1632 return EOK;
1633}
1634
1635/** Enable autonegoation with specific advertisement
1636 *
1637 * @param dev The device to update
1638 * @param advertisement The advertisement to set
1639 *
1640 * @returns EINVAL if the advertisement mode is not supproted
1641 * @returns EOK if advertisement mode set successfully
1642 */
1643static int rtl8139_autoneg_enable(ddf_fun_t *fun, uint32_t advertisement)
1644{
1645 assert(fun);
1646
1647 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1648 assert(rtl8139);
1649
1650 if (advertisement == 0) {
1651 advertisement = RTL8139_AUTONEG_CAPS;
1652 }
1653
1654 if ((advertisement | RTL8139_AUTONEG_CAPS) != RTL8139_AUTONEG_CAPS)
1655 return EINVAL; /* some unsuported mode is requested */
1656
1657 assert(advertisement != 0);
1658
1659 /* Set the autonegotiation advertisement */
1660 uint16_t anar = ANAR_SELECTOR; /* default selector */
1661 if (advertisement & ETH_AUTONEG_10BASE_T_FULL)
1662 anar |= ANAR_10_FD;
1663 if (advertisement & ETH_AUTONEG_10BASE_T_HALF)
1664 anar |= ANAR_10_HD;
1665 if (advertisement & ETH_AUTONEG_100BASE_TX_FULL)
1666 anar |= ANAR_100TX_FD;
1667 if (advertisement & ETH_AUTONEG_100BASE_TX_HALF)
1668 anar |= ANAR_100TX_HD;
1669 if (advertisement & ETH_AUTONEG_PAUSE_SYMETRIC)
1670 anar |= ANAR_PAUSE;
1671
1672 uint16_t bmcr_val = pio_read_16(rtl8139->io_port + BMCR);
1673 bmcr_val |= BMCR_AN_ENABLE;
1674
1675 pio_write_16(rtl8139->io_port + ANAR, anar);
1676
1677 rtl8139_regs_unlock(rtl8139->io_port);
1678 pio_write_16(rtl8139->io_port + BMCR, bmcr_val);
1679 rtl8139_regs_lock(rtl8139->io_port);
1680 return EOK;
1681}
1682
1683/** Disable advertisement functionality
1684 *
1685 * @param dev The device to update
1686 *
1687 * @returns EOK
1688 */
1689static int rtl8139_autoneg_disable(ddf_fun_t *fun)
1690{
1691 assert(fun);
1692
1693 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1694 assert(rtl8139);
1695
1696 uint16_t bmcr_val = pio_read_16(rtl8139->io_port + BMCR);
1697
1698 bmcr_val &= ~((uint16_t)BMCR_AN_ENABLE);
1699
1700 rtl8139_regs_unlock(rtl8139->io_port);
1701 pio_write_16(rtl8139->io_port + BMCR, bmcr_val);
1702 rtl8139_regs_lock(rtl8139->io_port);
1703
1704 return EOK;
1705}
1706
1707/** Obtain the advertisement NIC framework value from the ANAR/ANLPAR register
1708 * value
1709 *
1710 * @param[in] anar The ANAR register value
1711 * @param[out] advertisement The advertisement result
1712 */
1713static void rtl8139_get_anar_state(uint16_t anar, uint32_t *advertisement)
1714{
1715 *advertisement = 0;
1716 if (anar & ANAR_10_HD)
1717 *advertisement |= ETH_AUTONEG_10BASE_T_HALF;
1718 if (anar & ANAR_10_FD)
1719 *advertisement |= ETH_AUTONEG_10BASE_T_FULL;
1720 if (anar & ANAR_100TX_HD)
1721 *advertisement |= ETH_AUTONEG_100BASE_TX_HALF;
1722 if (anar & ANAR_100TX_FD)
1723 *advertisement |= ETH_AUTONEG_100BASE_TX_FULL;
1724 if (anar & ANAR_100T4)
1725 *advertisement |= ETH_AUTONEG_100BASE_T4_HALF;
1726 if (anar & ANAR_PAUSE)
1727 *advertisement |= ETH_AUTONEG_PAUSE_SYMETRIC;
1728}
1729
1730/** Check the autonegotion state
1731 *
1732 * @param[in] dev The device to check
1733 * @param[out] advertisement The device advertisement
1734 * @param[out] their_adv The partners advertisement
1735 * @param[out] result The autonegotion state
1736 * @param[out] their_result The link partner autonegotion status
1737 *
1738 * @returns EOK
1739 */
1740static int rtl8139_autoneg_probe(ddf_fun_t *fun, uint32_t *advertisement,
1741 uint32_t *their_adv, nic_result_t *result, nic_result_t *their_result)
1742{
1743 assert(fun);
1744
1745 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1746 assert(rtl8139);
1747
1748 uint16_t bmcr = pio_read_16(rtl8139->io_port + BMCR);
1749 uint16_t anar = pio_read_16(rtl8139->io_port + ANAR);
1750 uint16_t anar_lp = pio_read_16(rtl8139->io_port + ANLPAR);
1751 uint16_t aner = pio_read_16(rtl8139->io_port + ANER);
1752
1753 if (bmcr & BMCR_AN_ENABLE) {
1754 *result = NIC_RESULT_ENABLED;
1755 } else {
1756 *result = NIC_RESULT_DISABLED;
1757 }
1758
1759 if (aner & ANER_LP_NW_ABLE) {
1760 *their_result = NIC_RESULT_ENABLED;
1761 } else {
1762 *their_result = NIC_RESULT_DISABLED;
1763 }
1764
1765 rtl8139_get_anar_state(anar, advertisement);
1766 rtl8139_get_anar_state(anar_lp, their_adv);
1767
1768 return EOK;
1769}
1770
1771/** Restart autonegotiation process
1772 *
1773 * @param dev The device to update
1774 *
1775 * @returns EOK
1776 */
1777static int rtl8139_autoneg_restart(ddf_fun_t *fun)
1778{
1779 assert(fun);
1780
1781 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1782 assert(rtl8139);
1783
1784 uint16_t bmcr = pio_read_16(rtl8139->io_port + BMCR);
1785 bmcr |= BMCR_AN_RESTART;
1786 bmcr |= BMCR_AN_ENABLE;
1787
1788 rtl8139_regs_unlock(rtl8139);
1789 pio_write_16(rtl8139->io_port + BMCR, bmcr);
1790 rtl8139_regs_lock(rtl8139);
1791
1792 return EOK;
1793}
1794
1795/** Notify NIC framework about HW filtering state when promisc mode was disabled
1796 *
1797 * @param nic_data The NIC data
1798 * @param mcast_mode Current multicast mode
1799 * @param was_promisc Sign if the promiscuous mode was active before disabling
1800 */
1801inline static void rtl8139_rcx_promics_rem(nic_t *nic_data,
1802 nic_multicast_mode_t mcast_mode, uint8_t was_promisc)
1803{
1804 assert(nic_data);
1805
1806 if (was_promisc != 0) {
1807 if (mcast_mode == NIC_MULTICAST_LIST)
1808 nic_report_hw_filtering(nic_data, 1, 0, -1);
1809 else
1810 nic_report_hw_filtering(nic_data, 1, 1, -1);
1811 } else {
1812 nic_report_hw_filtering(nic_data, 1, -1, -1);
1813 }
1814}
1815
1816/** Set unicast frames acceptance mode
1817 *
1818 * @param nic_data The nic device to update
1819 * @param mode The mode to set
1820 * @param addr Ignored, no HW support, just use unicast promisc
1821 * @param addr_cnt Ignored, no HW support
1822 *
1823 * @returns EOK
1824 */
1825static int rtl8139_unicast_set(nic_t *nic_data, nic_unicast_mode_t mode,
1826 const nic_address_t *addr, size_t addr_cnt)
1827{
1828 assert(nic_data);
1829
1830 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
1831 assert(rtl8139);
1832
1833 uint8_t was_promisc = rtl8139->rcr_data.ucast_mask & RCR_ACCEPT_ALL_PHYS;
1834
1835 nic_multicast_mode_t mcast_mode;
1836 nic_query_multicast(nic_data, &mcast_mode, 0, NULL, NULL);
1837
1838 switch (mode) {
1839 case NIC_UNICAST_BLOCKED:
1840 rtl8139->rcr_data.ucast_mask = 0;
1841 rtl8139_rcx_promics_rem(nic_data, mcast_mode, was_promisc);
1842 break;
1843 case NIC_UNICAST_DEFAULT:
1844 rtl8139->rcr_data.ucast_mask = RCR_ACCEPT_PHYS_MATCH;
1845 rtl8139_rcx_promics_rem(nic_data, mcast_mode, was_promisc);
1846 break;
1847 case NIC_UNICAST_LIST:
1848 rtl8139->rcr_data.ucast_mask = RCR_ACCEPT_PHYS_MATCH
1849 | RCR_ACCEPT_ALL_PHYS;
1850
1851 if (mcast_mode == NIC_MULTICAST_PROMISC)
1852 nic_report_hw_filtering(nic_data, 0, 1, -1);
1853 else
1854 nic_report_hw_filtering(nic_data, 0, 0, -1);
1855 break;
1856 case NIC_UNICAST_PROMISC:
1857 rtl8139->rcr_data.ucast_mask = RCR_ACCEPT_PHYS_MATCH
1858 | RCR_ACCEPT_ALL_PHYS;
1859
1860 if (mcast_mode == NIC_MULTICAST_PROMISC)
1861 nic_report_hw_filtering(nic_data, 1, 1, -1);
1862 else
1863 nic_report_hw_filtering(nic_data, 1, 0, -1);
1864 break;
1865 default:
1866 return ENOTSUP;
1867 }
1868 fibril_mutex_lock(&rtl8139->rx_lock);
1869 rtl8139_hw_update_rcr(rtl8139);
1870 fibril_mutex_unlock(&rtl8139->rx_lock);
1871 return EOK;
1872}
1873
1874/** Set multicast frames acceptance mode
1875 *
1876 * @param nic_data The nic device to update
1877 * @param mode The mode to set
1878 * @param addr Addresses to accept
1879 * @param addr_cnt Addresses count
1880 *
1881 * @returns EOK
1882 */
1883static int rtl8139_multicast_set(nic_t *nic_data, nic_multicast_mode_t mode,
1884 const nic_address_t *addr, size_t addr_count)
1885{
1886 assert(nic_data);
1887 assert(addr_count == 0 || addr);
1888
1889 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
1890 assert(rtl8139);
1891
1892 switch (mode) {
1893 case NIC_MULTICAST_BLOCKED:
1894 rtl8139->rcr_data.mcast_mask = 0;
1895 if ((rtl8139->rcr_data.ucast_mask & RCR_ACCEPT_ALL_PHYS) != 0)
1896 nic_report_hw_filtering(nic_data, -1, 0, -1);
1897 else
1898 nic_report_hw_filtering(nic_data, -1, 1, -1);
1899 break;
1900 case NIC_MULTICAST_LIST:
1901 rtl8139_hw_set_mcast_mask(rtl8139, nic_mcast_hash(addr, addr_count));
1902 rtl8139->rcr_data.mcast_mask = RCR_ACCEPT_MULTICAST;
1903 nic_report_hw_filtering(nic_data, -1, 0, -1);
1904 break;
1905 case NIC_MULTICAST_PROMISC:
1906 rtl8139_hw_set_mcast_mask(rtl8139, RTL8139_MCAST_MASK_PROMISC);
1907 rtl8139->rcr_data.mcast_mask = RCR_ACCEPT_MULTICAST;
1908 nic_report_hw_filtering(nic_data, -1, 1, -1);
1909 break;
1910 default:
1911 return ENOTSUP;
1912 }
1913 fibril_mutex_lock(&rtl8139->rx_lock);
1914 rtl8139_hw_update_rcr(rtl8139);
1915 fibril_mutex_unlock(&rtl8139->rx_lock);
1916 return EOK;
1917}
1918
1919/** Set broadcast frames acceptance mode
1920 *
1921 * @param nic_data The nic device to update
1922 * @param mode The mode to set
1923 *
1924 * @returns EOK
1925 */
1926static int rtl8139_broadcast_set(nic_t *nic_data, nic_broadcast_mode_t mode)
1927{
1928 assert(nic_data);
1929
1930 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
1931 assert(rtl8139);
1932
1933 switch (mode) {
1934 case NIC_BROADCAST_BLOCKED:
1935 rtl8139->rcr_data.bcast_mask = 0;
1936 break;
1937 case NIC_BROADCAST_ACCEPTED:
1938 rtl8139->rcr_data.bcast_mask = RCR_ACCEPT_BROADCAST;
1939 break;
1940 default:
1941 return ENOTSUP;
1942 }
1943 fibril_mutex_lock(&rtl8139->rx_lock);
1944 rtl8139_hw_update_rcr(rtl8139);
1945 fibril_mutex_unlock(&rtl8139->rx_lock);
1946 return EOK;
1947}
1948
1949/** Get state of acceptance of weird frames
1950 *
1951 * @param[in] device The device to check
1952 * @param[out] mode The current mode
1953 */
1954static int rtl8139_defective_get_mode(ddf_fun_t *fun, uint32_t *mode)
1955{
1956 assert(fun);
1957 assert(mode);
1958
1959 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1960 assert(rtl8139);
1961
1962 *mode = 0;
1963 if (rtl8139->rcr_data.defect_mask & RCR_ACCEPT_ERROR)
1964 *mode |= NIC_DEFECTIVE_BAD_CRC;
1965 if (rtl8139->rcr_data.defect_mask & RCR_ACCEPT_RUNT)
1966 *mode |= NIC_DEFECTIVE_SHORT;
1967
1968 return EOK;
1969};
1970
1971/** Set acceptance of weird frames
1972 *
1973 * @param device The device to update
1974 * @param mode The mode to set
1975 *
1976 * @returns ENOTSUP if the mode is not supported
1977 * @returns EOK of mode was set
1978 */
1979static int rtl8139_defective_set_mode(ddf_fun_t *fun, uint32_t mode)
1980{
1981 assert(fun);
1982
1983 rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_fun(fun));
1984 assert(rtl8139);
1985
1986 if ((mode & (NIC_DEFECTIVE_SHORT | NIC_DEFECTIVE_BAD_CRC)) != mode)
1987 return ENOTSUP;
1988
1989 rtl8139->rcr_data.defect_mask = 0;
1990 if (mode & NIC_DEFECTIVE_SHORT)
1991 rtl8139->rcr_data.defect_mask |= RCR_ACCEPT_RUNT;
1992 if (mode & NIC_DEFECTIVE_BAD_CRC)
1993 rtl8139->rcr_data.defect_mask |= RCR_ACCEPT_ERROR;
1994
1995 fibril_mutex_lock(&rtl8139->rx_lock);
1996 rtl8139_hw_update_rcr(rtl8139);
1997 fibril_mutex_unlock(&rtl8139->rx_lock);
1998 return EOK;
1999};
2000
2001
2002/** Turn Wakeup On Lan method on
2003 *
2004 * @param nic_data The NIC to update
2005 * @param virtue The method to turn on
2006 *
2007 * @returns EINVAL if the method is not supported
2008 * @returns EOK if succeed
2009 * @returns ELIMIT if no more methods of this kind can be enabled
2010 */
2011static int rtl8139_wol_virtue_add(nic_t *nic_data,
2012 const nic_wol_virtue_t *virtue)
2013{
2014 assert(nic_data);
2015 assert(virtue);
2016
2017 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
2018 assert(rtl8139);
2019
2020 switch(virtue->type) {
2021 case NIC_WV_BROADCAST:
2022 rtl8139_hw_reg_add_8(rtl8139, CONFIG5, CONFIG5_BROADCAST_WAKEUP);
2023 break;
2024 case NIC_WV_LINK_CHANGE:
2025 rtl8139_regs_unlock(rtl8139->io_port);
2026 rtl8139_hw_reg_add_8(rtl8139, CONFIG3, CONFIG3_LINK_UP);
2027 rtl8139_regs_lock(rtl8139->io_port);
2028 break;
2029 case NIC_WV_MAGIC_PACKET:
2030 if (virtue->data)
2031 return EINVAL;
2032 rtl8139_regs_unlock(rtl8139->io_port);
2033 rtl8139_hw_reg_add_8(rtl8139, CONFIG3, CONFIG3_MAGIC);
2034 rtl8139_regs_lock(rtl8139->io_port);
2035 break;
2036 default:
2037 return EINVAL;
2038 };
2039 if(rtl8139->pm.active++ == 0)
2040 rtl8139_hw_pmen_set(rtl8139, 1);
2041 return EOK;
2042}
2043
2044/** Turn Wakeup On Lan method off
2045 *
2046 * @param nic_data The NIC to update
2047 * @param virtue The method to turn off
2048 */
2049static void rtl8139_wol_virtue_rem(nic_t *nic_data,
2050 const nic_wol_virtue_t *virtue)
2051{
2052 assert(nic_data);
2053 assert(virtue);
2054
2055 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
2056 assert(rtl8139);
2057
2058 switch(virtue->type) {
2059 case NIC_WV_BROADCAST:
2060 rtl8139_hw_reg_rem_8(rtl8139, CONFIG5, CONFIG5_BROADCAST_WAKEUP);
2061 break;
2062 case NIC_WV_LINK_CHANGE:
2063 rtl8139_regs_unlock(rtl8139->io_port);
2064 rtl8139_hw_reg_rem_8(rtl8139, CONFIG3, CONFIG3_LINK_UP);
2065 rtl8139_regs_lock(rtl8139->io_port);
2066 break;
2067 case NIC_WV_MAGIC_PACKET:
2068 rtl8139_regs_unlock(rtl8139->io_port);
2069 rtl8139_hw_reg_rem_8(rtl8139, CONFIG3, CONFIG3_MAGIC);
2070 rtl8139_regs_lock(rtl8139->io_port);
2071 break;
2072 default:
2073 return;
2074 };
2075 rtl8139->pm.active--;
2076 if (rtl8139->pm.active == 0)
2077 rtl8139_hw_pmen_set(rtl8139, 0);
2078}
2079
2080
2081/** Set polling mode
2082 *
2083 * @param device The device to set
2084 * @param mode The mode to set
2085 * @param period The period for NIC_POLL_PERIODIC
2086 *
2087 * @returns EOK if succeed
2088 * @returns ENOTSUP if the mode is not supported
2089 */
2090static int rtl8139_poll_mode_change(nic_t *nic_data, nic_poll_mode_t mode,
2091 const struct timeval *period)
2092{
2093 assert(nic_data);
2094 int rc = EOK;
2095
2096 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
2097 assert(rtl8139);
2098
2099 fibril_mutex_lock(&rtl8139->rx_lock);
2100
2101 switch(mode) {
2102 case NIC_POLL_IMMEDIATE:
2103 rtl8139->int_mask = RTL_DEFAULT_INTERRUPTS;
2104 break;
2105 case NIC_POLL_ON_DEMAND:
2106 rtl8139->int_mask = 0;
2107 break;
2108 case NIC_POLL_PERIODIC:
2109 assert(period);
2110
2111 rtl8139_timer_act_t new_timer;
2112 rc = rtl8139_timer_act_init(&new_timer, RTL8139_PCI_FREQ_KHZ, period);
2113 if (rc != EOK)
2114 break;
2115
2116 /* Disable timer interrupts while working with timer-related data */
2117 rtl8139->int_mask = 0;
2118 rtl8139_hw_int_enable(rtl8139);
2119
2120 rtl8139->poll_timer = new_timer;
2121 rtl8139->int_mask = INT_TIME_OUT;
2122
2123 /* Force timer interrupt start be writing nonzero value to timer
2124 * interrutp register (should be small to prevent big delay)
2125 * Read TCTR to reset timer counter
2126 * Change values to simulate the last interrupt from the period.
2127 */
2128 pio_write_32(rtl8139->io_port + TIMERINT, 10);
2129 pio_write_32(rtl8139->io_port + TCTR, 0);
2130
2131 ddf_msg(LVL_DEBUG, "Periodic mode. Interrupt mask %" PRIx16 ", "
2132 "poll.full_skips %zu, last timer %" PRIu32,
2133 rtl8139->int_mask, rtl8139->poll_timer.full_skips,
2134 rtl8139->poll_timer.last_val);
2135 break;
2136 default:
2137 rc = ENOTSUP;
2138 break;
2139 }
2140
2141 rtl8139_hw_int_enable(rtl8139);
2142
2143 fibril_mutex_unlock(&rtl8139->rx_lock);
2144
2145 return rc;
2146}
2147
2148/** Force receiving all frames in the receive buffer
2149 *
2150 * @param device The device to receive
2151 */
2152static void rtl8139_poll(nic_t *nic_data)
2153{
2154 assert(nic_data);
2155
2156 rtl8139_t *rtl8139 = nic_get_specific(nic_data);
2157 assert(rtl8139);
2158
2159 uint16_t isr = pio_read_16(rtl8139->io_port + ISR);
2160 pio_write_16(rtl8139->io_port + ISR, 0);
2161
2162 rtl8139_interrupt_impl(nic_data, isr);
2163}
2164
2165
2166/** Main function of RTL8139 driver
2167 *
2168 * Just initialize the driver structures and
2169 * put it into the device drivers interface
2170 */
2171int main(void)
2172{
2173 printf("%s: HelenOS RTL8139 network adapter driver\n", NAME);
2174
2175 int rc = nic_driver_init(NAME);
2176 if (rc != EOK)
2177 return rc;
2178
2179 nic_driver_implement(&rtl8139_driver_ops, &rtl8139_dev_ops,
2180 &rtl8139_nic_iface);
2181
2182 ddf_log_init(NAME);
2183 return ddf_driver_main(&rtl8139_driver);
2184}
Note: See TracBrowser for help on using the repository browser.