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