Fixed DISABLE_SMT to report the right max_vcores
[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         
383         if (reset_buffer) {
384                 char *rx_buffer = kmalloc(E1000_RX_MAX_BUFFER_SIZE, 0);
385                 char *hdr_buffer = kmalloc(E1000_RX_MAX_BUFFER_SIZE, 0);        
386                 if (rx_buffer == NULL) panic ("Can't allocate page for RX Buffer");
387                 if (rx_buffer == NULL) panic ("Can't allocate page for HDR Buffer");
388
389                 rx_des_kva[des_num].buffer_addr = PADDR(rx_buffer);
390                 *(((uint64_t*)&rx_des_kva[des_num].buffer_addr) + 1) = PADDR(rx_buffer);
391         }
392
393         return;
394 }
395
396 void e1000_set_tx_descriptor(uint32_t des_num) {
397         
398         // Clear the bits.
399         memset(&tx_des_kva[des_num], 0x00, sizeof(struct e1000_tx_desc));
400         
401         char *tx_buffer = kmalloc(E1000_TX_MAX_BUFFER_SIZE, 0);
402
403         if (tx_buffer == NULL) panic ("Can't allocate page for TX Buffer");
404
405         tx_des_kva[des_num].buffer_addr = PADDR(tx_buffer);
406         return;
407 }
408
409 // This startup sequence is taken with love from BarrelFish.
410 // <3 the multikernel.
411 void e1000_configure() {
412         
413         uint32_t data;
414
415         e1000_debug("-->Configuring Device.\n");
416         
417         // Clear interrupts
418         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
419
420         // Disable receiver and transmitter
421         e1000_wr32(E1000_RCTL, 0x00);
422         e1000_wr32(E1000_TCTL, 0x00);
423
424         // Reset
425         e1000_reset();  
426
427         // Clear interrupts
428         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
429
430         // Fix PHY_RESET
431         data = e1000_rr32(E1000_CTRL);
432         data = data & ~E1000_CTRL_PHY_RST;
433         e1000_wr32(E1000_CTRL, data);
434         data = e1000_rr32(E1000_STATUS);
435         data = data & ~E1000_STATUS_MTXCKOK; // XXX: Against spec
436         e1000_wr32(E1000_STATUS, data);
437
438         // Link MAC and PHY
439         data = e1000_rr32(E1000_CTRL);
440         data = data & E1000_CTRL_SLU;
441         e1000_wr32(E1000_CTRL, data);
442
443         // Set PHY mode
444         data = e1000_rr32(E1000_CTRL_EXT);
445         data = (data & ~E1000_CTRL_EXT_LINK_MODE_MASK) | E1000_CTRL_EXT_LINK_MODE_GMII;
446         e1000_wr32(E1000_CTRL_EXT, data);
447
448         // Set full-duplex
449         data = e1000_rr32(E1000_CTRL);
450         data = data & E1000_CTRL_FD;
451         e1000_wr32(E1000_CTRL, data);
452
453         // Set CTRL speed (from STATUS speed)
454         {
455                 data = e1000_rr32(E1000_CTRL);
456                 uint32_t status = e1000_rr32(E1000_STATUS);
457                 status = (status & E1000_STATUS_SPEED_MASK) >> 6;
458                 data = (data & ~E1000_CTRL_SPD_SEL) | (status << 8);
459                 e1000_wr32(E1000_CTRL, data);
460         }
461
462         // Turn off flow control
463         e1000_wr32(E1000_FCAL, 0x00);
464         e1000_wr32(E1000_FCAH, 0x00);
465         e1000_wr32(E1000_FCT,  0x00);
466
467         // Set stat counters
468
469         // Setup MAC address
470         e1000_setup_mac();      
471
472         // Set RX Ring
473         e1000_wr32(E1000_RDBAL, rx_des_pa);
474         e1000_wr32(E1000_RDBAH, 0x00);
475
476         // Set RX Ring Size
477         // This is the number of desc's, divided by 8. It starts
478         // at bit 7.
479         e1000_wr32(E1000_RDLEN, NUM_RX_DESCRIPTORS * 16);
480         
481         e1000_wr32(0x0280C, 0x00);
482
483         // Set head and tail pointers.
484         e1000_wr32(E1000_RDH, 0x00);
485         e1000_wr32(E1000_RDT, 0x00);
486
487         // Receive descriptor control
488         e1000_wr32(E1000_RXDCTL, 0x02000000 | 0x01010000);
489
490         data = e1000_rr32(E1000_RFCTL);
491         data = data & ~E1000_RFCTL_EXTEN;
492         e1000_wr32(E1000_RFCTL, data);
493
494         // Enable packet reception
495         data = e1000_rr32(E1000_RCTL);
496         data = data | E1000_RCTL_EN | E1000_RCTL_BAM;
497         e1000_wr32(E1000_RCTL, data);
498
499         e1000_wr32(E1000_RDT, NUM_RX_DESCRIPTORS - 1);
500
501         // Set TX Ring
502         e1000_wr32(E1000_TDBAL, tx_des_pa);
503         e1000_wr32(E1000_TDBAH, 0x00);
504
505         // Set TX Des Size
506         e1000_wr32(E1000_TDLEN, ((NUM_TX_DESCRIPTORS / 8) << 7));
507
508         // Transmit inter packet gap register
509         // XXX: Recomended magic. See 13.4.34
510         e1000_wr32(E1000_TIPG, 0x00702008);
511
512         // Set head and tail pointers.
513         e1000_wr32(E1000_TDH, 0x00);
514         e1000_wr32(E1000_TDT, 0x00);
515
516         // Tansmit desc control
517         e1000_wr32(E1000_TXDCTL, 0x01000000 | 0x02000000);
518
519         e1000_wr32(E1000_TDT, NUM_TX_DESCRIPTORS - 1);
520
521         // Enable transmit
522         // XXX: MAGIC (not really paul just hasn't enumerated yet)
523         e1000_wr32(E1000_TCTL, 0x0F01A);
524
525         return;
526 }
527
528 void e1000_reset() {
529         e1000_debug("-->Resetting device..... ");
530
531         uint32_t ctrl = e1000_rr32(E1000_CTRL);
532
533         ctrl = ctrl & E1000_CTRL_RST;
534
535         e1000_wr32(E1000_CTRL, ctrl);
536
537         e1000_debug(" done.\n");
538
539         return;
540 }
541
542 void enable_e1000_irq(struct trapframe *tf, uint32_t src_id, 
543                                 void* a0, void* a1, void* a2)
544 {
545         pic_unmask_irq(e1000_irq);
546         unmask_lapic_lvt(LAPIC_LVT_LINT0);
547         enable_irq();
548 }
549
550 void e1000_setup_interrupts() {
551         
552         extern handler_t interrupt_handlers[];
553         
554         e1000_debug("-->Setting interrupts.\n");
555         
556         // Set throttle register
557         e1000_wr32(E1000_ITR, 0x0000);
558         
559         // Clear interrupts
560         e1000_wr32(E1000_IMS, 0xFFFFFFFF);
561         e1000_wr32(E1000_IMC, 0xFFFFFFFF);
562         
563         // Set interrupts
564         // TODO: Make this only enable stuff we want
565         e1000_wr32(E1000_IMS, 0xFFFFFFFF); 
566
567         // Kernel based interrupt stuff
568         register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + e1000_irq, e1000_interrupt_handler, 0);
569
570         // Enable irqs for the e1000
571 #ifdef __CONFIG_DISABLE_MPTABLES__
572         // This will route the interrupts automatically to CORE 0
573         // Call send_kernel_message if you want to route them somewhere else
574         enable_e1000_irq(NULL,0,0,0,0);
575 #else 
576         ioapic_route_irq(e1000_irq, E1000_IRQ_CPU);     
577 #endif
578
579         return;
580 }
581
582 void e1000_interrupt_handler(trapframe_t *tf, void* data) {
583
584 //      printk("About to spam to mac addr: 00:14:4F:D1:EC:6C\n");
585 //      while(1) {
586 //              appserver_packet_t p;
587 //              p.header.dst_mac[0] = 0x00;
588 //              p.header.dst_mac[1] = 0x14;
589 //              p.header.dst_mac[2] = 0x4f;
590 //              p.header.dst_mac[3] = 0xd1;
591 //              p.header.dst_mac[4] = 0xec;
592 //              p.header.dst_mac[5] = 0x6c;
593 //              p.header.src_mac[0] = 0x00;
594 //              p.header.src_mac[1] = 0x23;
595 //              p.header.src_mac[2] = 0x8b;
596 //              p.header.src_mac[3] = 0x42;
597 //              p.header.src_mac[4] = 0x80;
598 //              p.header.src_mac[5] = 0xb8;
599 //              p.header.ethertype = 0x8888;
600 //              send_frame((char*)&p,0);
601 //      }
602
603         e1000_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
604                                 
605         // Read the offending interrupt(s)
606         // Note: Reading clears the interrupts
607         uint32_t interrupt_status = e1000_rr32(E1000_ICR);
608
609         // Loop to deal with TOCTOU 
610         while (interrupt_status != 0x0000) {
611
612                 //printk("Interrupt status: %x\n", interrupt_status);
613
614                 if ((interrupt_status & E1000_ICR_INT_ASSERTED) && (interrupt_status & E1000_ICR_RXT0)) {
615                         e1000_debug("---->Packet Received\n");
616                         e1000_handle_rx_packet();
617                 }       
618                 // Clear interrupts     
619                 interrupt_status = e1000_rr32(E1000_ICR);
620         }
621         
622         // In the event that we got really unlucky and more data arrived after we set 
623         //  set the bit last, try one more check
624         e1000_handle_rx_packet();
625
626         return;
627 }
628
629 void e1000_handle_rx_packet() {
630         
631         uint16_t packet_size;
632         uint32_t status;
633         uint32_t head = e1000_rr32(E1000_RDH);
634
635         //printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
636         //printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
637         
638         if (head == e1000_rx_index) {
639                 e1000_frame_debug("-->Nothing to process. Returning.");
640                 return;
641         }
642         
643         uint32_t rx_des_loop_cur = e1000_rx_index;
644         uint32_t frame_size = 0;
645         uint32_t fragment_size = 0;
646         uint32_t num_frags = 0;
647         
648         char *rx_buffer = kmalloc(MAX_FRAME_SIZE, 0);
649         
650         if (rx_buffer == NULL) panic ("Can't allocate page for incoming packet.");
651         
652         do {
653                 status =  rx_des_kva[rx_des_loop_cur].status;
654
655                 if (status == 0x0) {
656                         //panic("ERROR: E1000: Packet owned by hardware has 0 status value\n");
657                         warn("ERROR: E1000: Packet owned by hardware has 0 status value\n");
658                 }
659         
660                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
661                 
662                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
663                 // Panic or clear all descriptors? This is a nic hardware error. 
664                 if (num_frags && (rx_des_loop_cur == head)) {
665                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
666                         panic("RX Descriptor Ring out of sync.");
667                 }
668                 
669                 num_frags++;
670                 
671                 // Make sure we own the current packet. Kernel ownership is denoted by a 0. Nic by a 1.
672                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
673                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
674                         panic("RX Descriptor Ring OWN out of sync");
675                 }
676                 
677                 // Deal with packets too large
678                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
679                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
680                         panic("NIC Sent packets larger than configured.");
681                 }
682                 
683                 // Move the fragment data into the buffer
684                 memcpy(rx_buffer + frame_size, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
685                 
686                 // Reset the descriptor. No reuse buffer.
687                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
688                 
689                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 1024 of them.
690                 // This can not overflow the uint32_t we allocated for frame size, so
691                 // we dont need to worry about mallocing too little then overflowing when we read.
692                 frame_size = frame_size + fragment_size;
693                 
694                 // Advance to the next descriptor
695                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
696
697         } while ((status & E1000_RXD_STAT_EOP) == 0);
698
699         // Treat as a syscall frontend response packet if eth_type says so
700         // Will eventually go away, so not too worried about elegance here...
701         uint16_t eth_type = htons(*(uint16_t*)(rx_buffer + 12));
702         if(eth_type == APPSERVER_ETH_TYPE) {
703                 handle_appserver_packet(rx_buffer, frame_size);
704                 kfree(rx_buffer);
705
706                 // Advance the tail pointer                             
707                 e1000_rx_index = rx_des_loop_cur;
708                 e1000_wr32(E1000_RDT, e1000_rx_index);
709                 return;
710         }
711
712         spin_lock(&packet_buffers_lock);
713
714         if (num_packet_buffers >= MAX_PACKET_BUFFERS) {
715                 printd("WARNING: DROPPING PACKET!\n");
716                 spin_unlock(&packet_buffers_lock);
717                 kfree(rx_buffer);
718         
719                 // Advance the tail pointer                             
720                 e1000_rx_index = rx_des_loop_cur;
721                 e1000_wr32(E1000_RDT, e1000_rx_index);
722                 return;
723         }
724
725         packet_buffers[packet_buffers_tail] = rx_buffer;
726         packet_buffers_sizes[packet_buffers_tail] = frame_size;
727                 
728         packet_buffers_tail = (packet_buffers_tail + 1) % MAX_PACKET_BUFFERS;
729         num_packet_buffers++;
730
731         spin_unlock(&packet_buffers_lock);
732
733         // Advance the tail pointer                             
734         e1000_rx_index = rx_des_loop_cur;
735         e1000_wr32(E1000_RDT, e1000_rx_index);
736                                 
737         // Chew on the frame data. Command bits should be the same for all frags.
738         //e1000_process_frame(rx_buffer, frame_size, current_command);
739         
740         return;
741 }
742
743 // Main routine to send a frame. Just sends it and goes.
744 // Card supports sending across multiple fragments.
745 // Would we want to write a function that takes a larger packet and generates fragments?
746 // This seems like the stacks responsibility. Leave this for now. may in future
747 // Remove the max size cap and generate multiple packets.
748 int e1000_send_frame(const char *data, size_t len) {
749
750         if (data == NULL)
751                 return -1;
752         if (len == 0)
753                 return 0;
754
755         uint32_t head = e1000_rr32(E1000_TDH);
756
757         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
758                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
759                 return -1;
760         }
761         
762         if (len > MAX_FRAME_SIZE) {
763                 e1000_frame_debug("-->Frame Too Large!\n");
764                 return -1;
765         }
766         
767         memcpy(KADDR(tx_des_kva[e1000_tx_index].buffer_addr), data, len);
768
769         tx_des_kva[e1000_tx_index].lower.flags.length = len;
770         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
771
772         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
773         e1000_wr32(E1000_TDT, e1000_tx_index);
774
775         e1000_frame_debug("-->Sent packet.\n");
776         
777 return len;
778 }