82e97f1ea735383aefa210eed4ffbb124a2b8ffc
[barrelfish] / usr / drivers / enet / enet_module.c
1 /**
2  * \file
3  * \brief imx8 NIC driver module
4  */
5 /*
6  * Copyright (c) 2017, ETH Zurich.
7  * All rights reserved.
8  *
9  * This file is distributed under the terms in the attached LICENSE file.
10  * If you do not find this file, copies can be found by writing to:
11  * ETH Zurich D-INFK, Universitaetstrasse 6, CH-8092 Zurich. Attn: Systems Group.
12  */
13
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include <string.h>
17 #include <assert.h>
18
19 #include <devif/queue_interface_backend.h>
20 #include <barrelfish/barrelfish.h>
21 #include <barrelfish/deferred.h>
22 #include <driverkit/driverkit.h>
23 #include <driverkit/iommu.h>
24 #include <dev/enet_dev.h>
25
26 #include "enet.h"
27
28 #define PHY_ID 0x2
29 static void some_sleep(uint64_t rep)
30 {    
31     // TODO some sleep, barrelfish_usleep() seems to be broken!
32     while(rep) {
33         for(volatile int i = 0; i < 100000; i++) {
34             i++;
35             i--;
36         }
37
38         rep--;
39     }
40 }
41
42 static struct region_entry* get_region(struct enet_queue* q, regionid_t rid)
43 {
44     struct region_entry* entry = q->regions;
45     while (entry != NULL) {
46         if (entry->rid == rid) {
47             return entry;
48         }
49         entry = entry->next;
50     }
51     return NULL;
52 }
53
54 static errval_t enet_register(struct devq* q, struct capref cap, regionid_t rid)
55 {
56     errval_t err;
57     struct enet_queue* queue = (struct enet_queue*) q;
58
59     // keep track of regions since we need the virtual address ...
60     struct region_entry* entry = calloc(1, sizeof(struct region_entry));
61     assert(entry);
62     entry->rid = rid;
63     entry->next = NULL;
64     
65     struct frame_identity id;
66     err = frame_identify(cap, &id);
67     if (err_is_fail(err)) {
68         return err;
69     }
70
71     void* va;
72     err = vspace_map_one_frame_attr(&va, id.bytes, cap,
73                                     VREGION_FLAGS_READ_WRITE,
74                                     NULL, NULL);
75     if (err_is_fail(err)) {
76         return err;
77     }
78
79     entry->mem.devaddr = id.base;
80     entry->mem.vbase = (lvaddr_t) va;
81     entry->mem.mem = cap;
82     entry->mem.size = id.bytes;
83     
84     ENET_DEBUG("register region id %d base=%lx \n", rid, entry->mem.devaddr);
85     // linked list of regions
86     struct region_entry* cur = queue->regions;
87     if (cur == NULL) {
88         queue->regions = entry;
89         return SYS_ERR_OK;
90     }
91
92     while (cur->next != NULL) {
93         cur = cur->next;
94     }
95     
96     cur->next = entry;
97
98     ENET_DEBUG("registerd region id %d base=%p len=%ld \n", rid, 
99                 (void*) entry->mem.vbase, entry->mem.size);
100     return SYS_ERR_OK;
101 }
102
103 static inline size_t enet_full_slots(struct enet_queue* q)
104 {
105     size_t head = q->head;
106     size_t tail = q->tail;
107     size_t size = q->size;
108
109     if (tail >= head) {
110         return (tail - head);
111     } else {
112         return (tail + size - head);
113     }
114 }
115
116 static errval_t enet_rx_dequeue(struct devq* que, regionid_t* rid,
117                                 genoffset_t* offset,
118                                 genoffset_t* length,
119                                 genoffset_t* valid_data,
120                                 genoffset_t* valid_length,
121                                 uint64_t* flags)
122 {
123     struct enet_queue* q = (struct enet_queue*) que;      
124     enet_bufdesc_t desc = q->ring[q->head];
125     struct devq_buf* buf = &q->ring_bufs[q->head];
126
127     __builtin___clear_cache(desc, desc+sizeof(enet_bufdesc_t));
128
129     uint16_t status = enet_bufdesc_sc_extract(desc);
130
131     ENET_DEBUG("Try dequeue %d RADR %d ENABLED %d STATUS %lx \n", q->head, 
132                enet_rdar_rdar_rdf(q->d), enet_ecr_etheren_rdf(q->d), status);
133     
134     if (!(status & ENET_RX_EMPTY)) {
135         // TODO error handling!
136         *valid_length = enet_bufdesc_len_extract(desc);
137         ENET_DEBUG("Received Packet %lu \n", *valid_length);
138         *offset = buf->offset;
139         *valid_data = 0;
140         *rid = buf->rid;
141         *flags = buf->flags;
142     } else {
143         return DEVQ_ERR_QUEUE_EMPTY;
144     }
145     status &= ~ENET_RX_STATS;
146     //status |= ENET_RX_EMPTY;
147     // TODO this might already had back ownership!! 
148     
149     enet_bufdesc_sc_insert(desc, status);
150     
151     __builtin___clear_cache(q->ring[q->head], q->ring[q->head+1]);
152
153     q->head = (q->head+1) & (q->size -1);
154
155     return  SYS_ERR_OK;
156 }
157
158 static errval_t enet_tx_dequeue(struct devq* que, regionid_t* rid,
159                                 genoffset_t* offset,
160                                 genoffset_t* length,
161                                 genoffset_t* valid_data,
162                                 genoffset_t* valid_length,
163                                 uint64_t* flags)
164 {
165     struct enet_queue* q = (struct enet_queue*) que;      
166
167     if (enet_full_slots(q)) {
168         enet_bufdesc_t desc = q->ring[q->head];
169         __builtin___clear_cache(q->ring[q->head], q->ring[q->head+1]);
170         desc = q->ring[q->head];
171         struct devq_buf* buf= &q->ring_bufs[q->head];
172
173         if (!(enet_bufdesc_sc_extract(desc) & ENET_TX_READY)) {
174             ENET_DEBUG("We sent something!! \n");
175             *valid_length = buf->valid_length;
176             *offset = buf->offset;
177             *length = 2048;
178             *valid_data = 0;
179             *rid = buf->rid;
180             *flags = buf->flags;
181         } else {
182             return DEVQ_ERR_QUEUE_EMPTY;
183         }
184     } else {
185         return DEVQ_ERR_QUEUE_EMPTY;
186     }
187
188     ENET_DEBUG("Deq TX head=%zu \n", q->head);
189     q->head = (q->head + 1) & (q->size -1);
190     return SYS_ERR_OK;
191 }
192
193
194 static void enet_activate_tx_ring(enet_t * d)
195 {
196     ENET_DEBUG("Activating TX ring \n");
197     // bit is always set to 1 only when ring is empty then it is set to 0
198     enet_tdar_tdar_wrf(d, 1); 
199 }
200
201 static errval_t enet_tx_enqueue(struct devq* que, regionid_t rid, genoffset_t offset,
202                                 genoffset_t length, genoffset_t valid_data,
203                                 genoffset_t valid_length, uint64_t flags)
204 {
205     
206     struct enet_queue* q = (struct enet_queue*) que;   
207
208     assert(valid_length > 0 && valid_length < ENET_MAX_PKT_SIZE);
209
210     lpaddr_t addr = 0;
211     lvaddr_t vaddr = 0;
212     struct region_entry *entry = get_region(q, rid);
213     assert(entry);    
214     addr = (lpaddr_t) entry->mem.devaddr + offset + valid_data;
215     vaddr = (lvaddr_t) entry->mem.vbase + offset + valid_data;
216     
217     struct devq_buf* buf= &q->ring_bufs[q->tail];
218     buf->offset = offset;
219     buf->length = length;
220     buf->valid_length = valid_length;
221     buf->valid_data = valid_data;
222     buf->rid = rid;
223     buf->flags = flags;
224  
225     // TODO alignment
226     
227     enet_bufdesc_t desc = q->ring[q->tail];
228     enet_bufdesc_addr_insert(desc, addr);
229     enet_bufdesc_len_insert(desc, valid_length);
230
231     __builtin___clear_cache((void*) vaddr, (void*) vaddr+valid_length);
232
233     if (q->tail == (q->size -1)) {
234         enet_bufdesc_sc_insert(desc, ENET_TX_READY | ENET_TX_CRC | 
235                                ENET_TX_LAST | ENET_TX_WRAP);
236     } else {
237         enet_bufdesc_sc_insert(desc, ENET_TX_READY | ENET_TX_CRC | ENET_TX_LAST);
238     }
239
240     __builtin___clear_cache(q->ring[q->tail], q->ring[q->tail+1]);
241     // activate TX
242     enet_activate_tx_ring(q->d);
243
244     // wait until sent
245     int timeout = 5000;
246     while(timeout--) {
247         if (!(enet_tdar_tdar_rdf(q->d))) {
248             break;
249         }
250     }
251  
252     if (timeout == 0) {
253         debug_printf("Failed sending!! \n");
254         return NIC_ERR_TX_PKT;
255     }
256
257     timeout = 5000;
258     // make sure it is really sent!!
259     while(timeout--) {
260         __builtin___clear_cache(q->ring[q->tail], q->ring[q->tail+1]);
261         desc = q->ring[q->tail];
262         if (!(enet_bufdesc_sc_extract(desc) & ENET_TX_READY)) {
263             break;
264         }
265     }
266
267     debug_printf("Descriptor %lx \n", desc);
268     if (timeout == 0) {
269         debug_printf("Failed sending!! \n");
270         return NIC_ERR_TX_PKT;
271     } else {
272         q->tail = (q->tail + 1) & (q->size -1);
273     }
274
275     return SYS_ERR_OK;
276 }
277 static errval_t enet_rx_enqueue(struct devq* que, regionid_t rid, genoffset_t offset,
278                                 genoffset_t length, genoffset_t valid_data,
279                                 genoffset_t valid_length, uint64_t flags)
280 {
281     struct enet_queue* q = (struct enet_queue*) que;   
282     //enet_bufdesc_addr_insert(desc, );
283     struct region_entry *entry = get_region(q, rid);
284     assert(entry);    
285     
286     // TODO SEE IF THERE IS SPACE!
287    
288     lpaddr_t addr = 0;
289     addr = (lpaddr_t) entry->mem.devaddr + offset;
290  
291     struct devq_buf buf= q->ring_bufs[q->tail];
292     buf.offset = offset;
293     buf.length = length;
294     buf.valid_length = valid_length;
295     buf.valid_data = valid_data;
296     buf.rid = rid;
297     buf.flags = flags;
298    
299     enet_bufdesc_t desc = q->ring[q->tail];
300     enet_bufdesc_addr_insert(desc, addr);
301     enet_bufdesc_len_insert(desc, 0);
302
303     if (q->tail == (q->size -1)) {
304         enet_bufdesc_sc_insert(desc, ENET_SC_WRAP | ENET_RX_EMPTY);
305     } else {
306         enet_bufdesc_sc_insert(desc, ENET_RX_EMPTY);
307     }
308
309     __builtin___clear_cache(q->ring[q->tail], q->ring[q->tail+1]);
310     /*ENET_DEBUG("enqueue ring_buf[%d]=%p phys=%lx offset=%lx length=%zu\n", q->tail, 
311                 q->ring[q->tail], addr, offset, length);
312     */
313     q->tail = (q->tail + 1) & (q->size -1);
314     return SYS_ERR_OK;
315 }
316
317 static errval_t enet_write_mdio(struct enet_driver_state* st, int8_t phyaddr,
318                                 int8_t regaddr, int16_t data)
319 {
320     
321     // Some protocol ...
322
323     enet_mmfr_t reg = 0;
324     reg = enet_mmfr_pa_insert(reg, phyaddr);
325     reg = enet_mmfr_ra_insert(reg, regaddr);
326     reg = enet_mmfr_data_insert(reg, data);   
327     reg = enet_mmfr_st_insert(reg, 0x1);   
328     reg = enet_mmfr_ta_insert(reg, 0x2);   
329
330     // 1 is write 2 is read
331     reg = enet_mmfr_op_insert(reg, 0x1);   
332  
333     ENET_DEBUG("Write MDIO: write cmd %lx \n", reg);
334
335     enet_mmfr_wr(st->d, reg);
336
337     uint16_t tries = 1000;
338     while (!(enet_eir_mii_rdf(st->d) & 0x1)) {
339         tries--;
340         //barrelfish_usleep(10);
341         if (tries == 0) {
342             return ENET_ERR_MDIO_WRITE;
343         }
344     }
345    
346     enet_eir_mii_wrf(st->d, 0x1);
347     return SYS_ERR_OK;
348 }
349
350 static errval_t enet_read_mdio(struct enet_driver_state* st, int8_t phyaddr,
351                                int8_t regaddr, int16_t *data)
352 {
353     
354     // Some protocol ...
355     enet_eir_mii_wrf(st->d, 0x1);
356
357     enet_mmfr_t reg = 0;
358     reg = enet_mmfr_pa_insert(reg, phyaddr);
359     reg = enet_mmfr_ra_insert(reg, regaddr);
360     reg = enet_mmfr_st_insert(reg, 0x1);   
361     reg = enet_mmfr_ta_insert(reg, 0x2);   
362     // 1 is write 2 is read
363     reg = enet_mmfr_op_insert(reg, 0x2);   
364
365     enet_mmfr_wr(st->d, reg);
366     
367     ENET_DEBUG("Read MDIO: read cmd %lx \n", reg);
368
369     uint16_t tries = 1000;
370     while (!(enet_eir_mii_rdf(st->d) & 0x1)) {
371         barrelfish_usleep(10);
372         tries--;
373         if (tries == 0) {
374             return ENET_ERR_MDIO_WRITE;
375         }
376     }
377     
378     enet_eir_mii_wrf(st->d, 0x1);
379     *data = enet_mmfr_data_rdf(st->d);
380     
381     return SYS_ERR_OK;
382 }
383
384 static errval_t enet_get_phy_id(struct enet_driver_state* st)
385 {
386     errval_t err;
387     int16_t data; 
388     uint32_t phy_id;
389
390     // get phy ID1
391     err = enet_read_mdio(st, PHY_ID,  0x2, &data);
392     if (err_is_fail(err))  {
393         return err;
394     }   
395     phy_id = data << 16;
396
397     // get phy ID2
398     err = enet_read_mdio(st, PHY_ID,  0x3, &data);
399     if (err_is_fail(err))  {
400         return err;
401     }   
402
403     phy_id |= data;
404     st->phy_id = phy_id;    
405     return err;
406 }
407
408 #define PHY_RESET 0x8000
409
410 #define PHY_RESET_CMD 0x0
411 #define PHY_STATUS_CMD 0x1
412 #define PHY_AUTONEG_CMD 0x4
413 #define PHY_LPA_CMD 0x5
414 #define PHY_CTRL1000_CMD 0x09
415 #define PHY_STAT1000_CMD 0x0a
416
417 static errval_t enet_reset_phy(struct enet_driver_state* st)
418 {
419     debug_printf("PHY ID %d \n", st->phy_id);
420     errval_t err;
421     err = enet_write_mdio(st, PHY_ID, PHY_RESET_CMD, PHY_RESET);
422     if (err_is_fail(err))  {
423         return err;
424     }   
425
426     int16_t data;
427     err = enet_read_mdio(st, PHY_ID, PHY_RESET_CMD, &data);
428     if (err_is_fail(err))  {
429         return err;
430     }   
431     
432     int timeout = 500;
433     while ((data & PHY_RESET) && timeout > 0) {
434         err = enet_read_mdio(st, PHY_ID, PHY_RESET_CMD, &data);
435         if (err_is_fail(err))  {
436             return err;
437         }   
438     
439         barrelfish_usleep(1000);
440         timeout--;
441     }
442
443     if (data & PHY_RESET) {
444         return ENET_ERR_PHY_RESET;
445     }
446
447     return SYS_ERR_OK;
448 }
449
450 static errval_t enet_setup_autoneg(struct enet_driver_state* st)
451 {
452     errval_t err;
453     int16_t status;
454     int16_t autoneg;
455
456     // Read BASIC MODE status register
457     err = enet_read_mdio(st, PHY_ID, 0x1, &status);
458     if (err_is_fail(err))  {
459         return err;
460     }   
461
462     // READ autoneg status
463     err = enet_read_mdio(st, PHY_ID, PHY_AUTONEG_CMD, &autoneg);
464     if (err_is_fail(err))  {
465         return err;
466     }   
467     
468     // Read BASIC contorl register
469     err = enet_read_mdio(st, PHY_ID, PHY_RESET_CMD, &status);
470     if (err_is_fail(err))  {
471         return err;
472     }   
473
474     // TODO uboot driver seems to only read this stuff ?
475     return SYS_ERR_OK;
476 }
477
478 #define AUTONEG_100FULL 0x0100
479 #define AUTONEG_100HALF 0x0080
480 #define AUTONEG_10FULL  0x0040
481 #define AUTONEG_10HALF  0x0020
482 #define AUTONEG_PSB_802_3 0x0001
483
484 #define AUTONEG_ENABLE 0x1000
485 #define AUTONEG_RESTART 0x0200
486 static errval_t enet_restart_autoneg(struct enet_driver_state* st)
487 {
488     errval_t err;
489     err = enet_write_mdio(st, PHY_ID, PHY_RESET_CMD, PHY_RESET);
490     if (err_is_fail(err)) {
491         return err;
492     }
493
494     some_sleep(1000);
495     //barrelfish_usleep(1000);
496
497     err = enet_write_mdio(st, PHY_ID, PHY_AUTONEG_CMD, 
498                           AUTONEG_100FULL | AUTONEG_100HALF | AUTONEG_10FULL |
499                           AUTONEG_10HALF | AUTONEG_PSB_802_3);
500     if (err_is_fail(err)) {
501         return err;
502     }
503  
504     err = enet_write_mdio(st, PHY_ID, PHY_RESET_CMD, 
505                           AUTONEG_ENABLE | AUTONEG_RESTART);
506     if (err_is_fail(err)) {
507         return err;
508     }
509    
510     return SYS_ERR_OK;
511 }
512
513
514 static errval_t enet_init_phy(struct enet_driver_state* st)
515 {
516     errval_t err;
517     err = enet_get_phy_id(st);
518     if (err_is_fail(err))  {
519         return err;
520     }   
521  
522     err = enet_reset_phy(st);
523     if (err_is_fail(err))  {
524         return err;
525     }   
526    
527     // board_phy_config in uboot driver. Don't know what
528     // this actually does ...
529     err = enet_write_mdio(st, PHY_ID, 0x1d, 0x1f);
530     assert(err_is_ok(err));
531     err = enet_write_mdio(st, PHY_ID, 0x1e, 0x8);
532     assert(err_is_ok(err));
533     err = enet_write_mdio(st, PHY_ID, 0x1d, 0x00);
534     assert(err_is_ok(err));
535     err = enet_write_mdio(st, PHY_ID, 0x1e, 0x82ee);
536     assert(err_is_ok(err));
537     err = enet_write_mdio(st, PHY_ID, 0x1d, 0x05);
538     assert(err_is_ok(err));
539     err = enet_write_mdio(st, PHY_ID, 0x1e, 0x100);
540     assert(err_is_ok(err));
541
542     err = enet_setup_autoneg(st);
543     if (err_is_fail(err))  {
544         return err;
545     }   
546
547     return SYS_ERR_OK;
548 }
549
550
551
552 #define PHY_STATUS_LSTATUS 0x0004
553 #define PHY_STATUS_ANEG_COMP 0x0020
554 #define PHY_STATUS_ESTAT 0x0100
555 #define PHY_STATUS_ERCAP 0x0001
556
557
558 #define PHY_LPA_100HALF  0x0080
559 #define PHY_LPA_100FULL 0x0100
560 #define PHY_LPA_10FULL  0x0040
561 // TODO check for rest of link capabilities
562 static void enet_parse_link(struct enet_driver_state* st)
563 {
564     // just a sanity check if values are ok
565     errval_t err;
566     int16_t status;
567     err = enet_read_mdio(st, PHY_ID, PHY_STAT1000_CMD, &status);
568     assert(err_is_ok(err));
569
570     int16_t mii_reg;
571     err = enet_read_mdio(st, PHY_ID, PHY_STATUS_CMD, &mii_reg);
572     assert(err_is_ok(err));
573
574     if (status < 0) {   
575         debug_printf("ENET not capable of 1G \n");
576         return;
577     } else {
578         err = enet_read_mdio(st, PHY_ID, PHY_CTRL1000_CMD, &status);
579         assert(err_is_ok(err));
580         
581         if (status == 0) {
582             int16_t lpa, lpa2;   
583             err = enet_read_mdio(st, PHY_ID, PHY_AUTONEG_CMD, &lpa);
584             assert(err_is_ok(err));
585
586             err = enet_read_mdio(st, PHY_ID, PHY_LPA_CMD, &lpa2);
587             assert(err_is_ok(err));
588         
589             lpa &= lpa2;
590             if (lpa & (PHY_LPA_100FULL | PHY_LPA_100HALF)) {
591                 if (lpa & PHY_LPA_100FULL) {
592                     debug_printf("LINK 100 Mbit/s FULL duplex \n");
593                 } else {
594                     debug_printf("LINK 100 Mbit/s half\n");
595                 }
596             }
597         }
598     }
599
600 }
601
602 static errval_t enet_phy_startup(struct enet_driver_state* st)
603 {
604     errval_t err;
605     // board_phy_config in uboot driver. Don't know what
606     // this actually does ...
607     int16_t mii_reg;
608     err = enet_read_mdio(st, PHY_ID, PHY_STATUS_CMD, &mii_reg);
609     assert(err_is_ok(err));
610
611     if (mii_reg & PHY_STATUS_LSTATUS) {
612         debug_printf("LINK already UP\n");
613         return SYS_ERR_OK;
614     }
615     
616     if (!(mii_reg & PHY_STATUS_ANEG_COMP)) {
617         ENET_DEBUG("Staring autonegotiation \n");
618         while(!(mii_reg & PHY_STATUS_ANEG_COMP))  {
619             err = enet_read_mdio(st, PHY_ID, PHY_STATUS_CMD, &mii_reg);
620             assert(err_is_ok(err));
621             some_sleep(1000);
622         }
623         
624         ENET_DEBUG("Autonegotation done\n");
625     }
626     
627     enet_parse_link(st);
628     
629     return SYS_ERR_OK;
630 }
631
632 // bool promiscous for promiscous mode. 
633 // This will also set it so that all multicast packets will also be received!
634 /*
635 static void enet_init_multicast_filt(struct enet_driver_state* st, bool promisc)
636 {
637     if (promisc) {
638         enet_rcr_prom_wrf(st->d, 1);
639         return;
640     }
641
642     enet_rcr_prom_wrf(st->d, 0);
643     
644     // TODO Catching all multicast packets for now
645     enet_gaur_wr(st->d, 0xFFFFFFFF);
646     enet_galr_wr(st->d, 0xFFFFFFFF);
647     // TODO if we do not catch all multicast packet then do this:
648     // crc32 value of mac address
649     #if 0
650     unsigned int crc = 0xffffffff;
651     unsigned char hash;
652     unsigned int hash_high = 0, hash_low = 0;
653     for (int i = 0; i < 6; i++) {
654         unsigned char data = ((uint8_t*) &st->mac)[i];
655
656         for (int bit = 0; bit < 8; bit++, data >>= 1) {
657             crc = (crc >> 1) ^ (((crc ^ data) & 1) ? ENET_CRC32_POLY : 0);  
658         }
659         
660         hash = (crc >> (32 - ENET_HASH_BITS)) & 0x3f;  
661         
662         if (hash > 31) {
663             hash_high |= 1 << (hash - 32);
664         } else {
665             hash_low |= 1 << hash;
666         }
667     } 
668   
669     enet_gaur_gaddr_wrf(st->d, hash_high);
670     enet_galr_gaddr_wrf(st->d, hash_low);
671     #endif
672     // TODO if this is M5272 then set the hash table entries to 0 ...
673 }
674 */
675
676 static void enet_read_mac(struct enet_driver_state* st)
677 {
678     uint64_t lower = enet_palr_paddr1_rdf(st->d);
679     uint64_t upper = enet_paur_paddr2_rdf(st->d);
680     // this is weird lower seems to be the upper part of the address ..
681     uint64_t mac = (lower << 16) | upper;
682
683     ENET_DEBUG("MAC %lx \n", mac);
684     st->mac = mac;  
685 }
686
687 static void enet_write_mac(struct enet_driver_state* st)
688 {
689     
690     uint64_t lower = st->mac >> 16;
691     uint32_t upper = st->mac & 0xFFFF;
692
693     enet_palr_paddr1_wrf(st->d, lower);
694     enet_paur_paddr2_wrf(st->d, upper);
695 }
696
697 static void enet_activate_rx_ring(struct enet_driver_state* st)
698 {
699     ENET_DEBUG("Activating RX ring \n");
700     // bit is always set to 1 only when ring is empty then it is set to 0
701     enet_rdar_rdar_wrf(st->d, 1); 
702     some_sleep(1000);
703 }
704
705 /*
706 static errval_t enet_rings_start(struct enet_driver_state* st) 
707 {   
708     // tell the card the start of the RX descriptor ring
709     enet_rdsr_wr(st->d, st->rxq->desc_mem.devaddr);
710     
711     // Normally 2048er buffs but the alignment constraints are worst case 64
712     enet_mrbr_wr(st->d, ROUND_DOWN(2048-64, 64));
713     
714     // RX: For other queues would be possible to enable DMA here (1+2)
715     // Not needed for queue 0
716     
717     // tell the card the start of the TX descriptor ring
718     enet_tdsr_wr(st->d, st->txq->desc_mem.devaddr);
719         
720     // TX: For other queues would be possible to enable DMA here (1+2)
721     // Not needed for queue 0
722
723     errval_t err = SYS_ERR_OK;
724     return err;
725 }
726
727 static void enet_init_mii(struct enet_driver_state* st)
728 {
729     // TODO check these vlaues: set by using register dump on linux
730     // set MII speed
731     enet_mscr_mii_speed_wrf(st->d, 1);
732     // set hold time 
733     enet_mscr_hold_time_wrf(st->d, 0);
734 }
735 */
736
737
738 static errval_t enet_reset(struct enet_driver_state* st)
739 {
740     // reset device
741     ENET_DEBUG("Reset device\n");
742     
743     uint64_t ecr = enet_ecr_rd(st->d);
744     enet_ecr_wr(st->d, ecr | 0x1);
745     int timeout = 500;
746     while ((enet_ecr_rd(st->d) & 0x1) && timeout > 0) {
747         barrelfish_usleep(10);
748         // TODO timeout
749     }
750
751     if (timeout <= 0) {
752         return ENET_ERR_DEV_RESET;
753     }
754    
755     return SYS_ERR_OK;
756 }
757
758 static void enet_reg_setup(struct enet_driver_state* st)
759 {
760     // Set interrupt mask register
761     ENET_DEBUG("Set interrupt mask register\n");
762     enet_eimr_wr(st->d, 0x0);
763     // Clear outstanding interrupts
764     ENET_DEBUG("Clear outstanding interrupts\n");
765     enet_eir_wr(st->d, 0xFFFFFFFF);
766     
767     uint64_t reg; 
768     // TODO see if other fields are required, not in dump
769     reg = enet_rcr_rd(st->d);
770     reg = enet_rcr_loop_insert(reg, 0x0);
771     reg = enet_rcr_rmii_mode_insert(reg, 0x1);
772     reg = enet_rcr_mii_mode_insert(reg, 0x1);
773     reg = enet_rcr_fce_insert(reg, 0x1);
774     reg = enet_rcr_max_fl_insert(reg, 1522);
775     enet_rcr_wr(st->d, reg);   
776 }
777
778 static errval_t enet_rings_init(struct enet_driver_state* st)
779 {
780     // init receive buffer descriptors
781     enet_bufdesc_t desc;
782     uint16_t val;
783
784     memset(st->txq->ring, 0, st->txq->size*sizeof(enet_bufdesc_t));
785     ENET_DEBUG("TX %p ring init to default values \n", st->txq->ring);
786     // init send buffer descriptors
787     for (int i = 0; i < st->txq->size; i++) {
788         desc = st->txq->ring[i];
789         enet_bufdesc_sc_insert(desc, 0);
790         enet_bufdesc_addr_insert(desc, 0);
791     }
792
793     // set last one to wrap
794     desc = st->txq->ring[st->txq->size - 1];
795     val = enet_bufdesc_sc_extract(desc);
796     val |= ENET_SC_WRAP;
797     enet_bufdesc_sc_insert(desc, val);
798
799     st->txq->head = 0;
800     st->txq->tail = 0;
801
802     // TODO dchace flush
803
804     memset(st->rxq->ring, 0, st->rxq->size*sizeof(enet_bufdesc_t));
805     ENET_DEBUG("RX %p ring init to default values \n", st->rxq->ring);
806     for (int i = 0; i < st->rxq->size; i++) {
807         desc = st->rxq->ring[i];
808         enet_bufdesc_sc_insert(desc, 0);
809     }
810
811     // set last one to wrap
812     desc = st->rxq->ring[st->rxq->size - 1];
813     val = enet_bufdesc_sc_extract(desc);
814     val |= ENET_SC_WRAP;
815     enet_bufdesc_sc_insert(desc, val);
816     st->rxq->head = 0;
817     st->rxq->tail = 0;
818     
819     // TODO dchace flush
820     return SYS_ERR_OK;
821 }
822
823 static errval_t enet_open(struct enet_driver_state *st)
824 {
825     errval_t err = SYS_ERR_OK;
826     // Enable full duplex, disable heartbeet
827     enet_tcr_fden_wrf(st->d, 0x1);
828
829     // Invalidate rx descriptors
830     st->rxq->tail = 0;
831     err = frame_alloc(&st->rx_mem, 512*2048, NULL);
832     if (err_is_fail(err)) {
833         return err;
834     }
835
836     regionid_t rid;
837     err = devq_register((struct devq*) st->rxq, st->rx_mem, &rid);
838     if (err_is_fail(err)) {
839         return err;
840     }
841
842     for (int i = 0; i < st->rxq->size-1; i++) {
843         err = devq_enqueue((struct devq*) st->rxq, rid, i*(2048), 2048,
844                             0, 2048, 0);
845         if (err_is_fail(err)) {
846             return err;
847         }
848     }
849
850     // Enable HW endian swap
851     enet_ecr_dbswp_wrf(st->d, 0x1);
852     enet_ecr_en1588_wrf(st->d, 0x0);
853     // Enable store and forward mode
854     enet_tfwr_strfwd_wrf(st->d, 0x1);
855     // Enable controler
856     enet_ecr_etheren_wrf(st->d, 0x1);
857
858     // TODO don't think this is MX25/MX53 or MX6SL
859     // Startup PHY
860     err = enet_phy_startup(st);
861     if (err_is_fail(err))  {
862         return err;
863     } 
864
865     uint8_t speed = enet_ecr_speed_rdf(st->d);
866     
867     if (!speed) {
868         enet_rcr_rmii_10t_wrf(st->d, 0x0);
869     }
870
871     enet_activate_rx_ring(st);
872     ENET_DEBUG("Init done! \n");
873     return err;
874 }
875
876 static errval_t enet_init(struct enet_driver_state* st)
877 {
878     errval_t err = SYS_ERR_OK;
879     // set HW addreses
880     enet_iaur_wr(st->d, 0);
881     enet_ialr_wr(st->d, 0);
882     enet_gaur_wr(st->d, 0);
883     enet_galr_wr(st->d, 0);
884     enet_write_mac(st);
885
886     ENET_DEBUG("Setting RX/TX rings to default values \n");
887     // Init rings
888     err = enet_rings_init(st);
889     if (err_is_fail(err)){
890         return err;
891     }
892
893     enet_reg_setup(st);
894
895     uint64_t reg; 
896     // Set MII speed, do not drop preamble and set hold time to 10ns
897     reg = enet_mscr_rd(st->d);
898     reg = enet_mscr_mii_speed_insert(reg, 0x18);
899     reg = enet_mscr_hold_time_insert(reg, 0x1);
900     enet_mscr_wr(st->d, reg);
901
902     // Set Opcode and Pause duration
903     enet_opd_wr(st->d, 0x00010020);
904     enet_tfwr_tfwr_wrf(st->d, 0x2);
905
906     // Set multicast addr filter
907     enet_gaur_wr(st->d, 0);
908     enet_galr_wr(st->d, 0);
909
910     // Max pkt size rewrite ...
911     reg = enet_rcr_rd(st->d);
912     reg = enet_rcr_max_fl_insert(reg, ENET_MAX_PKT_SIZE);
913     reg = enet_rcr_prom_insert(reg, 1);
914     enet_rcr_wr(st->d, reg);   
915
916     // Tell card beginning of rx/tx rings
917     enet_rdsr_wr(st->d, st->rxq->desc_mem.devaddr);
918     enet_tdsr_wr(st->d, st->txq->desc_mem.devaddr);
919
920     err = enet_restart_autoneg(st);
921     if (err_is_fail(err)) {
922         return err;
923     }
924
925     err = enet_open(st);
926     if (err_is_fail(err)) {
927         // TODO cleanup
928         return err;
929     }
930
931     return err;
932 }
933
934 static errval_t enet_probe(struct enet_driver_state* st)
935 {
936     errval_t err;
937     err = enet_reset(st);
938     if (err_is_fail(err)) {
939         return err;
940     }
941  
942     enet_reg_setup(st);
943    
944     uint64_t reg; 
945     // Set MII speed, do not drop preamble and set hold time to 10ns
946     reg = enet_mscr_rd(st->d);
947     reg = enet_mscr_mii_speed_insert(reg, 0x18);
948     reg = enet_mscr_hold_time_insert(reg, 0x1);
949     enet_mscr_wr(st->d, reg);
950
951     err = enet_init_phy(st);
952     if (err_is_fail(err))  {
953         debug_printf("Failed PHY reset\n");
954         return err;
955     }   
956
957     // Write back mac again
958     ENET_DEBUG("Reset MAC\n");
959     // TODO do this later? NOT in dump
960     enet_write_mac(st);
961     enet_read_mac(st);
962
963     // TODO checked dump until here! 
964     return SYS_ERR_OK;
965 }
966
967 static errval_t enet_alloc_queues(struct enet_driver_state* st)
968 {   
969     errval_t err;
970     ENET_DEBUG("Allocating TX/RX ring data structures \n");
971     st->rxq = calloc(1, sizeof(struct enet_queue));
972     st->txq = calloc(1, sizeof(struct enet_queue));
973     st->rxq->size = RX_RING_SIZE;
974     st->txq->size = TX_RING_SIZE;
975     st->txq->d = st->d;
976     st->rxq->d = st->d;
977
978     assert(st->rxq);
979     assert(st->txq);
980
981     st->rxq->align = 0x3f;
982     st->txq->align = 0;
983
984     // TODO check for advanced descriptors
985     // TODO linking iommu driverkit library does not seem to work ...
986     ENET_DEBUG("Allocating RX/TX descriptor ring \n");
987     size_t tot_size = (st->rxq->size + st->txq->size)*sizeof(enet_bufdesc_t);
988     err = frame_alloc(&(st->rxq->desc_mem.mem), tot_size, (size_t *)&(st->rxq->desc_mem.size));
989     if (err_is_fail(err)) {
990         return err;
991     }
992
993     ENET_DEBUG("Mapping RX/TX descriptor ring\n");
994     err = vspace_map_one_frame_attr((void**) &(st->rxq->desc_mem.vbase), tot_size, 
995                                     st->rxq->desc_mem.mem, 
996                                     VREGION_FLAGS_READ_WRITE_NOCACHE, NULL, NULL);
997     if (err_is_fail(err)) {
998         cap_destroy(st->rxq->desc_mem.mem);
999         DEBUG_ERR(err, "vspace_map_one_frame failed");
1000         return err;
1001     }
1002
1003     struct frame_identity id;
1004     err = frame_identify(st->rxq->desc_mem.mem, &id);
1005     if (err_is_fail(err)) {
1006         return err;
1007     }
1008
1009     st->rxq->desc_mem.devaddr = id.base;
1010
1011     /*
1012     err = driverkit_iommu_mmap_cl(NULL, st->rxq->size + st->txq->size*
1013                                   sizeof(enet_bufdesc_t), VREGION_FLAGS_READ_WRITE, 
1014                                   &st->rxq->desc_mem);
1015     if (err_is_fail(err)) {
1016         // TODO cleanup
1017         return DRIVERKIT_ERR_DRIVER_INIT;
1018     }
1019     */
1020     st->rxq->ring = (void*) st->rxq->desc_mem.vbase;
1021     assert(st->rxq->ring);
1022     assert((st->rxq->desc_mem.devaddr & st->rxq->align) == 0);
1023
1024     memset(st->rxq->ring, 0, st->rxq->size*sizeof(enet_bufdesc_t));
1025
1026     st->txq->desc_mem.vbase = (st->rxq->desc_mem.vbase + (st->rxq->size*sizeof(enet_bufdesc_t)));
1027     st->txq->desc_mem.devaddr = (st->rxq->desc_mem.devaddr + (st->rxq->size*sizeof(enet_bufdesc_t)));
1028     st->txq->ring = (void*) st->txq->desc_mem.vbase;
1029     st->txq->desc_mem.size = st->rxq->desc_mem.size;
1030
1031     assert(st->txq->ring);
1032     assert((st->txq->desc_mem.devaddr & st->txq->align) == 0);
1033
1034     memset(st->txq->ring, 0, st->txq->size*sizeof(enet_bufdesc_t));
1035     /*
1036     // Disable RX
1037     uint32_t reg_val = enet_eimr_rd(st->d);
1038     enet_eimr_rxf_insert(reg_val, 0);
1039     enet_eimr_rxf1_insert(reg_val, 0);
1040     enet_eimr_rxf2_insert(reg_val, 0);
1041     enet_eimr_wr(st->d, reg_val);
1042     */
1043     ENET_DEBUG("RX phys=%p virt=%p \n", (void*) st->rxq->desc_mem.devaddr,
1044                 (void*) st->rxq->ring);
1045     ENET_DEBUG("TX phys=%p virt=%p \n", (void*) st->txq->desc_mem.devaddr,
1046                 (void*) st->txq->ring);
1047
1048     return SYS_ERR_OK;
1049 }
1050
1051 uint16_t packet[21] = { 0xffff, 0xffff, 0xffff, 0x507b,
1052                         0x9d2b, 0x1cbe, 0x0806, 0x0001,
1053                         0x0800, 0x0604, 0x0001, 0x507b,
1054                         0x9d2b, 0x1cbe, 0x0a05, 0x29d6,
1055                         0x0000, 0x0000, 0x0000, 0x0a6e,
1056                         0x0404};
1057
1058 static void print_tx_stats(struct enet_driver_state* st)
1059 {
1060     debug_printf("TX PKT %d \n", enet_rmon_t_packets_rd(st->txq->d));
1061     debug_printf("TX PKT BC %d \n", enet_rmon_t_bc_pkt_rd(st->txq->d));
1062     debug_printf("TX PKT MC %d \n", enet_rmon_t_mc_pkt_rd(st->txq->d));
1063     debug_printf("TX PKT CRC/Align %d \n", enet_rmon_t_crc_align_rd(st->txq->d));
1064     debug_printf("TX PKT Undersized %d \n", enet_rmon_t_undersize_rd(st->txq->d));
1065     debug_printf("TX PKT Oversized %d \n", enet_rmon_t_oversize_rd(st->txq->d));
1066     debug_printf("TX PKT Undersized bad CRC %d \n", enet_rmon_t_frag_rd(st->txq->d));
1067     debug_printf("TX PKT Oversized bad CRC %d \n", enet_rmon_t_jab_rd(st->txq->d));
1068     debug_printf("TX PKT Collision %d \n", enet_rmon_t_col_rd(st->txq->d));
1069
1070 }
1071
1072 static errval_t send_pkt(struct enet_driver_state* st, regionid_t rid) 
1073 {
1074     struct region_entry *entry = get_region(st->txq, rid);
1075     assert(entry);    
1076     memcpy((void*) entry->mem.vbase, (void *) packet, 21*sizeof(uint16_t));
1077
1078     // try sending buffer 0
1079     
1080     struct devq_buf buf;
1081     buf.rid = rid;
1082     buf.offset = 0;
1083     buf.valid_data = 0;
1084     buf.length = 2048;
1085     buf.valid_length = 21*sizeof(uint16_t);
1086     buf.flags = 0;
1087
1088     errval_t err;
1089     err = devq_enqueue((struct devq*) st->txq, buf.rid, buf.offset,
1090                        buf.length, buf.valid_data, buf.valid_length,
1091                        buf.flags);
1092     if (err_is_ok(err)) {
1093         // cleanup
1094         while(true) {
1095             err = devq_dequeue((struct devq*) st->txq, &buf.rid, &buf.offset,
1096                                &buf.length, &buf.valid_data, &buf.valid_length,
1097                                &buf.flags);
1098             if (err_is_ok(err)) {
1099                 break;
1100             }
1101         }
1102     }
1103     print_tx_stats(st);
1104     debug_printf("Finished sending packet \n");
1105     return err;
1106 }
1107
1108 /**
1109  * Driver initialization function. This function is called by the driver domain
1110  * (see also 'create_handler' in ddomain_service.c).
1111  * Typically through a request from the device manager.
1112  *
1113  * The init function is supposed to set `dev` to the exported service iref.
1114  * The init function may use `bfi->dstate` to store additional state about the device.
1115  *
1116  * \param[in]   bfi   The instance of this driver.
1117  * \param[in]   flags Additional flags (The exact flags supported is device/driver specific).
1118  * \param[out]  dev   The service iref over which the device can be contacted.
1119  *
1120  * \retval SYS_ERR_OK Device initialized successfully.
1121  * \retval LIB_ERR_MALLOC_FAIL Unable to allocate memory for the driver.
1122  */
1123 static errval_t init(struct bfdriver_instance* bfi, uint64_t flags, iref_t* dev) {
1124     ENET_DEBUG("%s:%s:%d: %s\n", __FILE__, __FUNCTION__, __LINE__, bfi->driver->name);
1125     errval_t err;
1126
1127     bfi->dstate = malloc(sizeof(struct enet_driver_state));
1128     struct enet_driver_state * st = (struct enet_driver_state*) bfi->dstate;    
1129     st->bfi = bfi;
1130
1131     if (bfi->dstate == NULL) {
1132         return LIB_ERR_MALLOC_FAIL;
1133     }
1134     assert(bfi->dstate != NULL);
1135     
1136     err = driverkit_get_bar_cap(st->bfi, 0, &st->regs);
1137     if (err_is_fail(err)) {
1138         USER_PANIC("pcid_get_bar_cap failed \n");
1139     }
1140
1141     err = map_device_cap(st->regs, &st->d_vaddr);
1142     if (err_is_fail(err)) {
1143         USER_PANIC("map_device_cap failed \n");
1144     }
1145
1146     
1147     /* Initialize Mackerel binding */
1148     st->d = (enet_t *) malloc(sizeof(enet_t));
1149     enet_initialize(st->d, (void *) st->d_vaddr);
1150
1151     assert(st->d != NULL);
1152     enet_read_mac(st);
1153     /*
1154     lower = enet_mac_low_addr_rdf(st->d);
1155     upper = enet_mac_high_addr_rdf(st->d);
1156     // this is weird lower seems to be the upper part of the address ..
1157     mac = (lower << 16) | upper;
1158
1159     ENET_DEBUG("MAC lower %lx \n", lower);
1160     ENET_DEBUG("MAC upper %lx \n", upper);
1161     ENET_DEBUG("MAC %lx \n", mac);
1162     */
1163     // TODO rest phy devm_gpio_request_one()? 
1164     
1165     // Alloc queues
1166     err = enet_alloc_queues(st);
1167     if (err_is_fail(err)) {
1168         USER_PANIC("Failed initalizing queues \n");
1169         return err;
1170     }
1171
1172     // Alloc cleanq data structs
1173     
1174     st->rxq->ring_bufs = calloc(st->rxq->size, sizeof(struct devq_buf));
1175     st->txq->ring_bufs = calloc(st->txq->size, sizeof(struct devq_buf));
1176     assert(st->rxq->ring_bufs);
1177     assert(st->txq->ring_bufs);
1178
1179     err = enet_probe(st);
1180     if (err_is_fail(err)) {
1181         // TODO cleanup
1182         return err;
1183     }
1184
1185     //ENET_DEBUG("Init MII bus\n");
1186     //enet_init_mii(st);
1187
1188     err = devq_init(&st->rxq->q, false);
1189     if (err_is_fail(err)) {
1190         debug_printf("enet devq_init error\n");
1191         return err;
1192     }
1193
1194     err = devq_init(&st->txq->q, false);
1195     if (err_is_fail(err)) {
1196         debug_printf("enet devq_init error\n");
1197         return err;
1198     }
1199
1200     st->rxq->q.f.reg = enet_register;
1201     st->rxq->q.f.enq = enet_rx_enqueue;
1202     st->rxq->q.f.deq = enet_rx_dequeue;
1203
1204
1205     st->txq->q.f.reg = enet_register;
1206     st->txq->q.f.enq = enet_tx_enqueue;
1207     st->txq->q.f.deq = enet_tx_dequeue;
1208
1209     err = enet_init(st);
1210     if (err_is_fail(err)) {
1211         // TODO cleanup
1212         return err;
1213     }
1214
1215     err = frame_alloc(&st->tx_mem, 512*2048, NULL);
1216     if (err_is_fail(err)) {
1217         return err;
1218     }
1219
1220     regionid_t rid;
1221     err = devq_register((struct devq*) st->txq, st->tx_mem, &rid);
1222     if (err_is_fail(err)) {
1223         return err;
1224     }
1225     
1226     struct devq_buf buf;
1227     while(true) {
1228         err = devq_dequeue((struct devq*) st->rxq, &buf.rid, &buf.offset,
1229                            &buf.length, &buf.valid_data, &buf.valid_length,
1230                            &buf.flags);
1231         if (err_is_ok(err)) {
1232             
1233         } else {
1234
1235         }
1236
1237         some_sleep(1000);
1238         err = send_pkt(st, rid);
1239     }
1240     *dev = 0x00;
1241
1242     return SYS_ERR_OK;
1243 }
1244
1245 /**
1246  * Instructs driver to attach to the device.
1247  * This function is only called if the driver has previously detached
1248  * from the device (see also detach).
1249  *
1250  * \note After detachment the driver can not assume anything about the
1251  * configuration of the device.
1252  *
1253  * \param[in]   bfi   The instance of this driver.
1254  * \retval SYS_ERR_OK Device initialized successfully.
1255  */
1256 static errval_t attach(struct bfdriver_instance* bfi) {
1257     ENET_DEBUG("%s:%s:%d: %s\n", __FILE__, __FUNCTION__, __LINE__, bfi->driver->name);
1258
1259     return SYS_ERR_OK;
1260 }
1261
1262 /**
1263  * Instructs driver to detach from the device.
1264  * The driver must yield any control over to the device after this function returns.
1265  * The device may be left in any state.
1266  *
1267  * \param[in]   bfi   The instance of this driver.
1268  * \retval SYS_ERR_OK Device initialized successfully.
1269  */
1270 static errval_t detach(struct bfdriver_instance* bfi) {
1271     ENET_DEBUG("%s:%s:%d: %s\n", __FILE__, __FUNCTION__, __LINE__, bfi->driver->name);
1272
1273     return SYS_ERR_OK;
1274 }
1275
1276 /**
1277  * Instructs the driver to go in a particular sleep state.
1278  * Supported states are platform/device specific.
1279  *
1280  * \param[in]   bfi   The instance of this driver.
1281  * \retval SYS_ERR_OK Device initialized successfully.
1282  */
1283 static errval_t set_sleep_level(struct bfdriver_instance* bfi, uint32_t level) {
1284     ENET_DEBUG("%s:%s:%d: %s\n", __FILE__, __FUNCTION__, __LINE__, bfi->driver->name);
1285
1286     return SYS_ERR_OK;
1287 }
1288
1289 /**
1290  * Destroys this driver instance. The driver will yield any
1291  * control over the device and free any state allocated.
1292  *
1293  * \param[in]   bfi   The instance of this driver.
1294  * \retval SYS_ERR_OK Device initialized successfully.
1295  */
1296 static errval_t destroy(struct bfdriver_instance* bfi) {
1297     ENET_DEBUG("%s:%s:%d: %s\n", __FILE__, __FUNCTION__, __LINE__, bfi->driver->name);
1298     struct enet_driver_state* uds = bfi->dstate;
1299     free(uds);
1300     bfi->dstate = NULL;
1301
1302     // XXX: Tear-down the service
1303     bfi->device = 0x0;
1304
1305     return SYS_ERR_OK;
1306 }
1307
1308 static errval_t get_ep(struct bfdriver_instance* bfi, bool lmp, struct capref* ret_cap)
1309 {
1310     ENET_DEBUG("Endpoint was requested \n");
1311   
1312     errval_t err = SYS_ERR_OK;  
1313     return err;
1314 }
1315
1316 /**
1317  * Registers the driver module with the system.
1318  *
1319  * To link this particular module in your driver domain,
1320  * add it to the addModules list in the Hakefile.
1321  */
1322 DEFINE_MODULE(enet_module, init, attach, detach, set_sleep_level, destroy, get_ep);