884a6468839e2a5dda4adaa71fc0f00c7d4efeda
[akaros.git] / kern / arch / i686 / e1000.c
1 /** @file
2  * @brief E1000 Driver       
3  *
4  * EXPERIMENTAL. DO NOT USE IF YOU DONT KNOW WHAT YOU ARE DOING
5  *
6  * See Info below 
7  *
8  * @author Paul Pearce <pearce@eecs.berkeley.edu>
9  *
10  */
11
12 #ifdef __SHARC__
13 #pragma nosharc
14 #endif
15
16 #include <arch/mmu.h>
17 #include <arch/x86.h>
18 #include <arch/smp.h>
19 #include <arch/apic.h>
20 #include <arch/pci.h>
21 #include <arch/e1000.h>
22
23 #include <ros/memlayout.h>
24
25 #include <atomic.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <trap.h>
29 #include <kmalloc.h>
30
31 #include <pmap.h>
32
33 #define NUM_TX_DESCRIPTORS E1000_NUM_TX_DESCRIPTORS
34 #define NUM_RX_DESCRIPTORS E1000_NUM_RX_DESCRIPTORS
35
36 /** @file
37  * @brief Intel E1000 Driver
38  *
39  * EXPERIMENTAL. DO NOT USE IF YOU DONT KNOW WHAT YOU ARE DOING
40  *
41  * To enable use, define __NETWORK__ in your Makelocal
42  *
43  * @author Paul Pearce <pearce@eecs.berkeley.edu>
44  *
45  * @todo Move documention below into doxygen format.
46  * @todo See list in code
47  */
48
49 // TODO REWRITE THIS 
50 /* RealTek 8168d (8111d) NIC Driver
51  *
52  * Written by Paul Pearce.
53  *
54  * This is a really rough "driver". Really, its not a driver, just a kernel hack to give
55  * the kernel a way to receive and send packets. The basis of the init code is the OSDEV
56  * page on the 8169 chipset, which is a varient of this chipset (most 8169 drivers work 
57  * on the 8168d). http://wiki.osdev.org/RTL8169
58  * 
59  * Basic ideas (although no direct code) were gleamed from the OpenBSD re(4) driver,
60  * which can be found in sys/dev/ic/re.c. sys/dev/ic/rtl81x9reg.h is needed to make
61  * sense of the constants used in re.c.
62  *
63  * This is an ongoing work in progress. Main thing is we need a kernel interface for PCI
64  * devices and network devices, that we can hook into, instead of providing arbitary functions
65  * 
66  */
67
68 uint32_t e1000_mmio_base_addr = 0;
69 uint32_t e1000_io_base_addr = 0;
70 uint32_t e1000_irq = 0;
71 uint32_t e1000_addr_size = 0;
72 unsigned char device_mac[6];
73
74 struct e1000_rx_desc *rx_des_kva;
75 unsigned long rx_des_pa;
76
77 struct e1000_tx_desc *tx_des_kva;
78 unsigned long tx_des_pa;
79
80 uint32_t e1000_rx_index = 0;
81 uint32_t e1000_tx_index = 0;
82
83 extern uint8_t eth_up;
84 extern uint32_t packet_buffer_count;
85 extern char* packet_buffers[MAX_PACKET_BUFFERS];
86 extern uint32_t packet_buffers_sizes[MAX_PACKET_BUFFERS];
87 extern uint32_t packet_buffers_head;
88 extern uint32_t packet_buffers_tail;
89 spinlock_t packet_buffers_lock;
90
91 uint16_t device_id;
92
93 extern int (*send_frame)(const char *CT(len) data, size_t len);
94
95 void e1000_dump_rx() {
96
97         for (int i = 0; i < 10; i++) {
98                 
99                 printk("%u:  %lx%lx\n", i, *(uint64_t*)(&rx_des_kva[i]), *((uint64_t*)(&rx_des_kva[i]) + 1));
100                 printk("%ud: %lx\n", i, *(uint64_t*)(KADDR(rx_des_kva[i].buffer_addr)));        
101         }
102
103 }
104
105 void e1000_dump_stats() {
106
107         uint32_t offset = 0x04000;
108         
109         while (offset <= 0x040FC) {
110                 if ((offset % 16) == 0)
111                         printk("\n");
112                 printk("%x:%d ", offset,e1000_rr32(offset));
113
114                 offset = offset + 4;
115         }
116 }
117
118 void e1000_init() {
119
120         if (e1000_scan_pci() < 0) return;
121
122         e1000_setup_descriptors();
123
124         e1000_configure();
125         //e1000_dump_rx();
126         e1000_setup_interrupts();
127
128         send_frame = &e1000_send_frame;
129
130         eth_up = 1;
131         
132         return;
133 }
134
135 int e1000_scan_pci() {
136         
137         extern pci_dev_entry_t pci_dev_map[PCI_MAX_BUS][PCI_MAX_DEV][PCI_MAX_FUNC];
138         extern uint16_t pci_irq_map[PCI_MAX_BUS][PCI_MAX_DEV][PCI_MAX_FUNC];
139
140         printk("Searching for Intel E1000 Network device...");
141
142         for (int i = 0; i < PCI_MAX_BUS; i++) {
143                 for (int j = 0; j < PCI_MAX_DEV; j++) {
144                         for (int k = 0; k < PCI_MAX_FUNC; k++) {
145                                 uint32_t address;
146                                 uint32_t bus = i;
147                                 uint32_t dev = j;
148                                 uint32_t func = k;
149                                 uint32_t reg = 0; 
150                                 uint32_t result  = 0;
151         
152                                 uint16_t curr_dev_id = pci_dev_map[i][j][k].dev_id;
153                                 uint16_t curr_ven_id = pci_dev_map[i][j][k].ven_id;
154
155                                 // Vender DNE
156                                 if (curr_ven_id == INVALID_VENDOR_ID) 
157                                         continue;
158
159                                 // Ignore non Intel E1000 Devices
160                                 if (curr_ven_id != INTEL_VENDOR_ID)
161                                         continue;
162
163                                 // Ignore non E1000 devices
164                                 if ((curr_dev_id != INTEL_DEV_ID0) && 
165                                     (curr_dev_id != INTEL_DEV_ID1) &&
166                                     (curr_dev_id != INTEL_DEV_ID2))
167                                         continue;
168                                 printk(" found on BUS %x DEV %x FUNC %x\n", i, j, k);
169                                 
170                                 // Skip the management nic on the 16 core box
171                                 if ((curr_dev_id == INTEL_DEV_ID1) && (k == 0)) 
172                                         continue;
173
174                                 device_id = curr_dev_id;
175
176                                 // Find the IRQ
177                                 e1000_irq = pci_irq_map[i][j][k];
178                                 e1000_debug("-->IRQ: %u\n", e1000_irq);
179
180                                 // Loop over the BARs
181                                 for (int k = 0; k <= 5; k++) {
182                                         reg = 4 + k;
183                                         address = MK_CONFIG_ADDR(bus, dev, func, reg << 2);     
184                                         outl(PCI_CONFIG_ADDR, address);
185                                         result = inl(PCI_CONFIG_DATA);
186
187                                         if (result == 0) // (0 denotes no valid data)
188                                                 continue;
189
190                                         // Read the bottom bit of the BAR. 
191                                         if (result & PCI_BAR_IO_MASK) {
192                                                 result = result & PCI_IO_MASK;
193                                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "IO", result);
194                                         } else {
195                                                 result = result & PCI_MEM_MASK;
196                                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "MEM", result);
197                                         }
198                         
199                                         if (k == 0) { // BAR0 denotes the IO Addr for the device
200                                                 if (result & PCI_BAR_IO_MASK) {
201                                                         e1000_debug("-->IO PORT MODE\n");
202                                                         panic("IO PORT MODE NOT SUPPORTED\n");
203                                                 } else {
204                                                         e1000_debug("-->MMIO Mode\n");
205                                                         e1000_mmio_base_addr = result;
206                                                         // Now we do magic to find the size
207                                                         // The first non zero bit after we
208                                                         // write all 1's denotes the size
209                                                         outl(PCI_CONFIG_DATA, 0xFFFFFFFF);
210                                                         result = inl(PCI_CONFIG_DATA);
211                                                         printk("Result of writing all 1's: %x\n", result);
212                                                         result = result & PCI_MEM_MASK;
213                                                         result = (result ^ 0xFFFFFFFF) + 1;
214                                                         e1000_addr_size = result;
215
216                                                         // Map the page in.
217                                                         printk("HACK FIX\n");
218                                                         e1000_mmio_base_addr = 0xfbee0000;
219                                                         outl(PCI_CONFIG_DATA, e1000_mmio_base_addr);
220                                                         e1000_mmio_base_addr = 0xfee00000 + 0x20000;
221                                                         e1000_debug("-->MMIO Size %x\n", e1000_addr_size);
222
223                                                 }
224                                         }                                               
225                                 }
226                                 return 0;
227                         }
228                 }
229         }
230         cprintf(" not found. No device configured.\n");
231         
232         return -1;
233 }
234
235 uint32_t e1000_rr32(uint32_t offset) {
236
237         if (e1000_mmio_base_addr) {
238                 return read_mmreg32(e1000_mmio_base_addr + offset);
239         } else {
240                 return inl(e1000_io_base_addr + offset);
241         }
242 }
243
244 void e1000_wr32(uint32_t offset, uint32_t val) {
245
246         if (e1000_mmio_base_addr) {
247                 write_mmreg32(e1000_mmio_base_addr + offset, val);
248         } else {
249                 outl(e1000_io_base_addr + offset, val);
250         }
251 }
252
253
254 uint16_t e1000_read_eeprom(uint32_t offset) {
255
256         uint16_t eeprom_data;
257         uint32_t eeprom_reg_val = e1000_rr32(E1000_EECD);
258
259         eeprom_reg_val = eeprom_reg_val | E1000_EECD_REQ;
260         e1000_wr32(E1000_EECD, eeprom_reg_val);
261         while((e1000_rr32(E1000_EECD) & E1000_EECD_GNT) == 0);
262
263         eeprom_reg_val = E1000_EERD_START | (offset << E1000_EERD_ADDR_SHIFT);
264         e1000_wr32(E1000_EERD, eeprom_reg_val);
265         while(((eeprom_reg_val = e1000_rr32(E1000_EERD)) & E1000_EERD_DONE) == 0);
266         eeprom_data = (eeprom_reg_val & E1000_EERD_DATA_MASK) >> E1000_EERD_DATA_SHIFT;
267         
268         eeprom_reg_val = e1000_rr32(E1000_EECD);
269         e1000_wr32(E1000_EECD, eeprom_reg_val & ~E1000_EECD_REQ);
270
271         return eeprom_data;
272
273 }
274
275 void e1000_setup_mac() {
276
277         uint16_t eeprom_data = 0;
278         uint32_t mmio_data = 0;
279
280         if (device_id == INTEL_DEV_ID0) {
281
282                 for (int i = 0; i < 3; i++) {
283
284                         eeprom_data = e1000_read_eeprom(i);
285                         device_mac[2*i] = eeprom_data & 0x00FF;
286                         device_mac[2*i + 1] = (eeprom_data & 0xFF00) >> 8;
287
288                 }
289
290         } else {
291
292                 mmio_data = e1000_rr32(E1000_RAL);
293                 device_mac[0] = mmio_data & 0xFF;
294                 device_mac[1] = (mmio_data >> 8) & 0xFF;
295                 device_mac[2] = (mmio_data >> 16) & 0xFF;
296                 device_mac[3] = (mmio_data >> 24) & 0xFF;
297                 mmio_data = e1000_rr32(E1000_RAH);
298                 device_mac[4] = mmio_data & 0xFF;
299                 device_mac[5] = (mmio_data >> 8) & 0xFF;
300         }
301
302         // Check if we need to invert the higher order bits (some E1000's)
303         mmio_data = e1000_rr32(E1000_STATUS);
304
305         if (mmio_data & E1000_STATUS_FUNC_MASK) {
306                 printk("UNTESTED LANB FUNCTIONALITY! MAY BE BREAKING MAC\n");
307                 device_mac[5] ^= 0x0100;
308         }       
309
310         // Program the device to use this mac
311         e1000_wr32(E1000_RAH, 0x00000); // Set MAC invalid
312         e1000_wr32(E1000_RAL, *(uint32_t*)device_mac);
313         e1000_wr32(E1000_RAH, *(uint16_t*)(device_mac + 4) | 0x80000000);
314         
315         // Now make sure it read back out.
316         mmio_data = e1000_rr32(E1000_RAL);
317         device_mac[0] = mmio_data & 0xFF;
318         device_mac[1] = (mmio_data >> 8) & 0xFF;
319         device_mac[2] = (mmio_data >> 16) & 0xFF;
320         device_mac[3] = (mmio_data >> 24) & 0xFF;
321         mmio_data = e1000_rr32(E1000_RAH);
322         device_mac[4] = mmio_data & 0xFF;
323         device_mac[5] = (mmio_data >> 8) & 0xFF;
324
325         // Clear the MAC's from all the other filters
326         // Must clear high to low.
327         // TODO: Get the right number of filters
328         for (int i = 1; i < 16; i++) {
329                 e1000_wr32(E1000_RAH + 8 * i, 0x0);
330                 e1000_wr32(E1000_RAL + 8 * i, 0x0);
331         }
332
333
334         // Clear MTA Table
335         // TODO: Get the right number of filters
336         for (int i = 0; i < 0x7F; i++) {
337                 e1000_wr32(E1000_MTA + 4 * i, 0x0);
338         }
339
340         e1000_debug("-->DEVICE MAC: %02x:%02x:%02x:%02x:%02x:%02x\n", 0xFF & device_mac[0], 0xFF & device_mac[1],
341                                                                       0xFF & device_mac[2], 0xFF & device_mac[3],
342                                                                       0xFF & device_mac[4], 0xFF & device_mac[5]);
343         return;
344 }
345
346 void e1000_setup_descriptors() {
347
348         e1000_debug("-->Setting up tx/rx descriptors.\n");
349
350         // Allocate room for the buffers. 
351         // Must be 16 byte aligned
352         uint32_t num_rx_pages = ROUNDUP(NUM_RX_DESCRIPTORS * sizeof(struct e1000_rx_desc), PGSIZE) / PGSIZE;
353         uint32_t num_tx_pages = ROUNDUP(NUM_TX_DESCRIPTORS * sizeof(struct e1000_tx_desc), PGSIZE) / PGSIZE;
354         
355         rx_des_kva = get_cont_pages(LOG2_UP(num_rx_pages), 0);
356         tx_des_kva = get_cont_pages(LOG2_UP(num_tx_pages), 0);
357
358         if (rx_des_kva == NULL) panic("Can't allocate page for RX Ring");
359         if (tx_des_kva == NULL) panic("Can't allocate page for TX Ring");
360         
361         rx_des_pa = PADDR(rx_des_kva);
362         tx_des_pa = PADDR(tx_des_kva);
363         
364         for (int i = 0; i < NUM_RX_DESCRIPTORS; i++) 
365                 e1000_set_rx_descriptor(i, TRUE); // Allocate memory for the descriptor
366                 
367         for (int i = 0; i < NUM_TX_DESCRIPTORS; i++) 
368                 e1000_set_tx_descriptor(i);
369         return;
370 }
371
372
373 void e1000_set_rx_descriptor(uint32_t des_num, uint8_t reset_buffer) {
374         
375         memset(&rx_des_kva[des_num], 0x00, sizeof(struct e1000_rx_desc));
376         
377         if (reset_buffer) {
378                 char *rx_buffer = kmalloc(E1000_RX_MAX_BUFFER_SIZE, 0);
379                 char *hdr_buffer = kmalloc(E1000_RX_MAX_BUFFER_SIZE, 0);        
380                 if (rx_buffer == NULL) panic ("Can't allocate page for RX Buffer");
381                 if (rx_buffer == NULL) panic ("Can't allocate page for HDR Buffer");
382
383                 rx_des_kva[des_num].buffer_addr = PADDR(rx_buffer);
384                 *(((uint64_t*)&rx_des_kva[des_num].buffer_addr) + 1) = PADDR(rx_buffer);
385         }
386
387         return;
388 }
389
390 void e1000_set_tx_descriptor(uint32_t des_num) {
391         
392         // Clear the bits.
393         memset(&tx_des_kva[des_num], 0x00, sizeof(struct e1000_tx_desc));
394         
395         char *tx_buffer = kmalloc(E1000_TX_MAX_BUFFER_SIZE, 0);
396
397         if (tx_buffer == NULL) panic ("Can't allocate page for TX Buffer");
398
399         tx_des_kva[des_num].buffer_addr = PADDR(tx_buffer);
400         return;
401 }
402
403 // This startup sequence is taken with love from BarrelFish.
404 // <3 the multikernel.
405 void e1000_configure() {
406         
407         uint32_t data;
408
409         e1000_debug("-->Configuring Device.\n");
410         
411         // Clear interrupts
412         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
413
414         // Disable receiver and transmitter
415         e1000_wr32(E1000_RCTL, 0x00);
416         e1000_wr32(E1000_TCTL, 0x00);
417
418         // Reset
419         e1000_reset();  
420
421         // Clear interrupts
422         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
423
424         // Fix PHY_RESET
425         data = e1000_rr32(E1000_CTRL);
426         data = data & ~E1000_CTRL_PHY_RST;
427         e1000_wr32(E1000_CTRL, data);
428         data = e1000_rr32(E1000_STATUS);
429         data = data & ~E1000_STATUS_MTXCKOK; // XXX: Against spec
430         e1000_wr32(E1000_STATUS, data);
431
432         // Link MAC and PHY
433         data = e1000_rr32(E1000_CTRL);
434         data = data & E1000_CTRL_SLU;
435         e1000_wr32(E1000_CTRL, data);
436
437         // Set PHY mode
438         data = e1000_rr32(E1000_CTRL_EXT);
439         data = (data & ~E1000_CTRL_EXT_LINK_MODE_MASK) | E1000_CTRL_EXT_LINK_MODE_GMII;
440         e1000_wr32(E1000_CTRL_EXT, data);
441
442         // Set full-duplex
443         data = e1000_rr32(E1000_CTRL);
444         data = data & E1000_CTRL_FD;
445         e1000_wr32(E1000_CTRL, data);
446
447         // Set CTRL speed (from STATUS speed)
448         {
449                 data = e1000_rr32(E1000_CTRL);
450                 uint32_t status = e1000_rr32(E1000_STATUS);
451                 status = (status & E1000_STATUS_SPEED_MASK) >> 6;
452                 data = (data & ~E1000_CTRL_SPD_SEL) | (status << 8);
453                 e1000_wr32(E1000_CTRL, data);
454         }
455
456         // Turn off flow control
457         e1000_wr32(E1000_FCAL, 0x00);
458         e1000_wr32(E1000_FCAH, 0x00);
459         e1000_wr32(E1000_FCT,  0x00);
460
461         // Set stat counters
462
463         // Setup MAC address
464         e1000_setup_mac();      
465
466         // Set RX Ring
467         e1000_wr32(E1000_RDBAL, rx_des_pa);
468         e1000_wr32(E1000_RDBAH, 0x00);
469
470         // Set RX Ring Size
471         // This is the number of desc's, divided by 8. It starts
472         // at bit 7.
473         printk("rdlen: %x\n", e1000_rr32(E1000_RDLEN));
474         e1000_wr32(E1000_RDLEN, NUM_RX_DESCRIPTORS * 16);
475         printk("rdlen: %x\n", e1000_rr32(E1000_RDLEN));
476         
477         e1000_wr32(0x0280C, 0x00);
478
479         // Set head and tail pointers.
480         e1000_wr32(E1000_RDH, 0x00);
481         e1000_wr32(E1000_RDT, 0x00);
482
483         // Receive descriptor control
484         e1000_wr32(E1000_RXDCTL, 0x02000000 | 0x01010000);
485
486         data = e1000_rr32(E1000_RFCTL);
487         data = data & ~E1000_RFCTL_EXTEN;
488         e1000_wr32(E1000_RFCTL, data);
489
490         // Enable packet reception
491         data = e1000_rr32(E1000_RCTL);
492         data = data | E1000_RCTL_EN | E1000_RCTL_BAM;
493         e1000_wr32(E1000_RCTL, data);
494
495         e1000_wr32(E1000_RDT, NUM_RX_DESCRIPTORS - 1);
496
497         // Set TX Ring
498         e1000_wr32(E1000_TDBAL, tx_des_pa);
499         e1000_wr32(E1000_TDBAH, 0x00);
500
501         // Set TX Des Size
502         e1000_wr32(E1000_TDLEN, ((NUM_TX_DESCRIPTORS / 8) << 7));
503
504         // Transmit inter packet gap register
505         // XXX: Recomended magic. See 13.4.34
506         e1000_wr32(E1000_TIPG, 0x00702008);
507
508         // Set head and tail pointers.
509         e1000_wr32(E1000_TDH, 0x00);
510         e1000_wr32(E1000_TDT, 0x00);
511
512         // Tansmit desc control
513         e1000_wr32(E1000_TXDCTL, 0x01000000 | 0x02000000);
514
515         e1000_wr32(E1000_TDT, NUM_TX_DESCRIPTORS - 1);
516
517         // Enable transmit
518         // XXX: MAGIC (not really paul just hasn't enumerated yet)
519         e1000_wr32(E1000_TCTL, 0x0F01A);
520
521         return;
522 }
523
524 void e1000_reset() {
525         e1000_debug("-->Resetting device..... ");
526
527         uint32_t ctrl = e1000_rr32(E1000_CTRL);
528
529         ctrl = ctrl & E1000_CTRL_RST;
530
531         e1000_wr32(E1000_CTRL, ctrl);
532
533         e1000_debug(" done.\n");
534
535         return;
536 }
537
538
539 void e1000_setup_interrupts() {
540         
541         extern handler_t interrupt_handlers[];
542         
543         e1000_debug("-->Setting interrupts.\n");
544         
545         // Set throttle register
546         e1000_wr32(E1000_ITR, 0x0000);
547         
548         // Clear interrupts
549         e1000_wr32(E1000_IMS, 0xFFFFFFFF);
550         e1000_wr32(E1000_IMC, 0xFFFFFFFF);
551         
552         // Set interrupts
553         // TODO: Make this only enable stuff we want
554         e1000_wr32(E1000_IMS, 0xFFFFFFFF); 
555
556         // Kernel based interrupt stuff
557         register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + e1000_irq, e1000_interrupt_handler, 0);
558         
559         ioapic_route_irq(e1000_irq, E1000_IRQ_CPU);     
560         
561         return;
562 }
563
564 void e1000_interrupt_handler(trapframe_t *tf, void* data) {
565
566         e1000_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
567                                 
568         // Read the offending interrupt(s)
569         // Note: Reading clears the interrupts
570         uint32_t interrupt_status = e1000_rr32(E1000_ICR);
571
572         // Loop to deal with TOCTOU 
573         while (interrupt_status != 0x0000) {
574
575                 //printk("Interrupt status: %x\n", interrupt_status);
576
577                 if ((interrupt_status & E1000_ICR_INT_ASSERTED) && (interrupt_status & E1000_ICR_RXT0)) {
578                         e1000_debug("---->Packet Received\n");
579                         e1000_handle_rx_packet();
580                 }       
581                 // Clear interrupts     
582                 interrupt_status = e1000_rr32(E1000_ICR);
583         }
584         
585         // In the event that we got really unlucky and more data arrived after we set 
586         //  set the bit last, try one more check
587         e1000_handle_rx_packet();
588
589         return;
590 }
591
592 void e1000_handle_rx_packet() {
593         
594         uint16_t packet_size;
595         uint32_t status;
596         uint32_t head = e1000_rr32(E1000_RDH);
597
598         //printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
599         //printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
600         
601         if (head == e1000_rx_index) {
602                 e1000_frame_debug("-->Nothing to process. Returning.");
603                 return;
604         }
605         
606         uint32_t rx_des_loop_cur = e1000_rx_index;
607         uint32_t frame_size = 0;
608         uint32_t fragment_size = 0;
609         uint32_t num_frags = 0;
610         
611         char *rx_buffer = kmalloc(MAX_FRAME_SIZE, 0);
612         
613         if (rx_buffer == NULL) panic ("Can't allocate page for incoming packet.");
614         
615         do {
616                 status =  rx_des_kva[rx_des_loop_cur].status;
617
618                 if (status == 0x0) {
619                         panic("ERROR: E1000: Packet owned by hardware has 0 status value\n");
620                 }
621         
622                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
623                 
624                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
625                 // Panic or clear all descriptors? This is a nic hardware error. 
626                 if (num_frags && (rx_des_loop_cur == head)) {
627                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
628                         panic("RX Descriptor Ring out of sync.");
629                 }
630                 
631                 num_frags++;
632                 
633                 // Make sure we own the current packet. Kernel ownership is denoted by a 0. Nic by a 1.
634                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
635                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
636                         panic("RX Descriptor Ring OWN out of sync");
637                 }
638                 
639                 // Deal with packets too large
640                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
641                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
642                         panic("NIC Sent packets larger than configured.");
643                 }
644                 
645                 // Move the fragment data into the buffer
646                 memcpy(rx_buffer + frame_size, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
647                 
648                 // Reset the descriptor. No reuse buffer.
649                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
650                 
651                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 1024 of them.
652                 // This can not overflow the uint32_t we allocated for frame size, so
653                 // we dont need to worry about mallocing too little then overflowing when we read.
654                 frame_size = frame_size + fragment_size;
655                 
656                 // Advance to the next descriptor
657                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
658
659         } while ((status & E1000_RXD_STAT_EOP) == 0);
660
661         spin_lock(&packet_buffers_lock);
662
663         if (num_packet_buffers >= MAX_PACKET_BUFFERS) {
664                 printk("WARNING: DROPPING PACKET!\n");
665                 spin_unlock(&packet_buffers_lock);
666                 kfree(rx_buffer);
667                 return;
668         }
669
670         packet_buffers[packet_buffers_tail] = rx_buffer;
671         packet_buffers_sizes[packet_buffers_tail] = frame_size;
672                 
673         packet_buffers_tail = (packet_buffers_tail + 1) % MAX_PACKET_BUFFERS;
674         num_packet_buffers++;
675
676         spin_unlock(&packet_buffers_lock);
677
678         // Advance the tail pointer                             
679         e1000_rx_index = rx_des_loop_cur;
680         e1000_wr32(E1000_RDT, e1000_rx_index);
681                                 
682         // Chew on the frame data. Command bits should be the same for all frags.
683         //e1000_process_frame(rx_buffer, frame_size, current_command);
684         
685         return;
686 }
687
688 // Main routine to send a frame. Just sends it and goes.
689 // Card supports sending across multiple fragments.
690 // Would we want to write a function that takes a larger packet and generates fragments?
691 // This seems like the stacks responsibility. Leave this for now. may in future
692 // Remove the max size cap and generate multiple packets.
693 int e1000_send_frame(const char *data, size_t len) {
694
695         if (data == NULL)
696                 return -1;
697         if (len == 0)
698                 return 0;
699
700         uint32_t head = e1000_rr32(E1000_TDH);
701
702         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
703                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
704                 return -1;
705         }
706         
707         if (len > MAX_FRAME_SIZE) {
708                 e1000_frame_debug("-->Frame Too Large!\n");
709                 return -1;
710         }
711         
712         memcpy(KADDR(tx_des_kva[e1000_tx_index].buffer_addr), data, len);
713
714         tx_des_kva[e1000_tx_index].lower.flags.length = len;
715         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
716
717         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
718         e1000_wr32(E1000_TDT, e1000_tx_index);
719
720         e1000_frame_debug("-->Sent packet.\n");
721         
722 return len;
723 }