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