new 64b kernel memory map (not userspace yet)
[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 #include <eth_audio.h>
36
37 #define NUM_TX_DESCRIPTORS E1000_NUM_TX_DESCRIPTORS
38 #define NUM_RX_DESCRIPTORS E1000_NUM_RX_DESCRIPTORS
39
40
41 // Global variables for the device
42 uint32_t e1000_mmio_base_addr = 0;
43 uint32_t e1000_io_base_addr = 0;
44 uint32_t e1000_irq = 0;
45 uint32_t e1000_addr_size = 0;
46
47 // The device's MAC address (read from the device)
48 unsigned char device_mac[6];
49
50 // Vars relating to the receive descriptor ring
51 struct e1000_rx_desc *rx_des_kva;
52 unsigned long rx_des_pa;
53 uint32_t e1000_rx_index = 0;
54
55
56 // Vars relating to the transmit descriptor ring
57 struct e1000_tx_desc *tx_des_kva;
58 unsigned long tx_des_pa;
59 uint32_t e1000_tx_index = 0;
60
61 extern uint8_t eth_up;
62
63 // The PCI device ID we detect
64 // This is used for quark behavior
65 uint16_t device_id;
66
67
68 // Hacky variables relating to delivering packets
69 extern uint32_t packet_buffer_count;
70 extern char* packet_buffers[MAX_PACKET_BUFFERS];
71 extern uint32_t packet_buffers_sizes[MAX_PACKET_BUFFERS];
72 extern uint32_t packet_buffers_head;
73 extern uint32_t packet_buffers_tail;
74 spinlock_t packet_buffers_lock;
75
76 // Allow us to register our send_frame as the global send_frameuint16_t device_id;
77 extern int (*send_frame)(const char *CT(len) data, size_t len);
78
79 void e1000_dump_rx() {
80
81         for (int i = 0; i < 10; i++) {
82                 
83                 printk("%u:  %lx%lx\n", i, *(uint64_t*)(&rx_des_kva[i]), *((uint64_t*)(&rx_des_kva[i]) + 1));
84                 printk("%ud: %lx\n", i, *(uint64_t*)(KADDR(rx_des_kva[i].buffer_addr)));        
85         }
86
87 }
88
89 void e1000_dump_stats() {
90
91         uint32_t offset = 0x04000;
92         
93         while (offset <= 0x040FC) {
94                 if ((offset % 16) == 0)
95                         printk("\n");
96                 printk("%x:%d ", offset,e1000_rr32(offset));
97
98                 offset = offset + 4;
99         }
100 }
101
102 // Main init sequence. This is whats called to configure the device
103 // This includes detection of the device.
104 void e1000_init() {
105
106         // Detect if the device is present
107         if (e1000_scan_pci() < 0) return;
108
109         // Allocate and program the descriptors for the ring
110         // Note: Does not tell the device to use them, yet.
111         e1000_setup_descriptors();
112         e1000_configure();
113         printk("Network Card MAC Address: %02x:%02x:%02x:%02x:%02x:%02x\n", 
114            device_mac[0],device_mac[1],device_mac[2],
115            device_mac[3],device_mac[4],device_mac[5]);
116
117         e1000_setup_interrupts();
118
119         // "Register" our send_frame with the global system
120         send_frame = &e1000_send_frame;
121
122         // sudo /sbin/ifconfig eth0 up
123         eth_up = 1;
124         
125         return;
126 }
127
128 /* Given a addr read from bar0, determine the IO mode,
129  * determine the addr range, and map the MMIO region in.
130  *
131  * Note: This must be called from a scan_pci() context, as it
132  * relies on the state of the PCI_CONFIG_ADDR register.
133  */
134 void e1000_handle_bar0(uint32_t addr) {
135
136         if (addr & PCI_BAR_IO_MASK) {
137                 e1000_debug("-->IO PORT MODE\n");
138                 panic("IO PORT MODE NOT SUPPORTED\n");
139         } else {
140                 e1000_debug("-->MMIO Mode\n");
141                 
142                 // Now we do magic to find the size
143                 // The first non zero bit after we
144                 // write all 1's denotes the size
145                 outl(PCI_CONFIG_DATA, 0xFFFFFFFF);
146                 uint32_t result = inl(PCI_CONFIG_DATA);
147                 result = result & PCI_MEM_MASK;
148                 result = (result ^ 0xFFFFFFFF) + 1;
149                 e1000_addr_size = result;
150                 e1000_debug("-->MMIO Size %x\n", e1000_addr_size);
151                 
152                 // Restore the MMIO addr to the device (unchanged)
153                 outl(PCI_CONFIG_DATA, addr);
154
155                 // Map the page in.
156                 e1000_mmio_base_addr = (uint32_t)mmio_alloc(addr, e1000_addr_size);
157                 if (e1000_mmio_base_addr == 0x00) {
158                         panic("Could not map in E1000 MMIO space\n");
159                 }
160         }
161         return;
162 }
163
164 // Scan the PCI data structures for our device.
165 int e1000_scan_pci() {
166         struct pci_device *pcidev;
167         uint32_t result;
168         unsigned int once = 0;
169         printk("Searching for Intel E1000 Network device...");
170         STAILQ_FOREACH(pcidev, &pci_devices, all_dev) {
171                 /* Ignore non Intel Devices */
172                 if (pcidev->ven_id != INTEL_VENDOR_ID)
173                         continue;
174                 /* Ignore non E1000 devices */
175                 if ((pcidev->dev_id != INTEL_DEV_ID0) && 
176                     (pcidev->dev_id != INTEL_DEV_ID1) &&
177                     (pcidev->dev_id != INTEL_DEV_ID2))
178                         continue;
179                 printk(" found on BUS %x DEV %x FUNC %x\n", pcidev->bus, pcidev->dev,
180                        pcidev->func);
181                 /* TODO: (ghetto) Skip the management nic on the 16 core box.  It is
182                  * probably the first one found (check this) */
183                 if ((pcidev->dev_id == INTEL_DEV_ID1) && (once++ == 0)) 
184                         continue;
185                 /* TODO: WARNING - EXTREMELY GHETTO */
186                 device_id = pcidev->dev_id;
187                 /* Find the IRQ */
188                 e1000_irq = pcidev->irqline;
189                 e1000_debug("-->IRQ: %u\n", e1000_irq);
190                 /* Loop over the BARs */
191                 for (int k = 0; k <= 5; k++) {
192                         int reg = 4 + k;
193                 result = pcidev_read32(pcidev, reg << 2);       // SHAME!
194                         if (result == 0) // (0 denotes no valid data)
195                                 continue;
196                         // Read the bottom bit of the BAR. 
197                         if (result & PCI_BAR_IO_MASK) {
198                                 result = result & PCI_IO_MASK;
199                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "IO", result);
200                         } else {
201                                 result = result & PCI_MEM_MASK;
202                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "MEM", result);
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, Base: %08p\n", result);
210                                         // Deal with the MMIO base, mapping, and size.
211                                         e1000_handle_bar0(result);
212                                 }                                               
213                         }
214                                 
215                         // We found the device and configured it (if we get here). Return OK
216                         return 0;
217                 }
218         }
219         printk(" not found. No device configured.\n");
220         return -1;
221 }
222
223 /* E1000 Read Register 32bit
224  * Read a 32 bit value from a register at the given offset in the 
225  * E1000 MMIO range.
226  *
227  * This function has IOPORT support, but is not used.
228  */
229 uint32_t e1000_rr32(uint32_t offset) {
230
231         if (e1000_mmio_base_addr) {
232                 return read_mmreg32(e1000_mmio_base_addr + offset);
233         } else {
234                 return inl(e1000_io_base_addr + offset);
235         }
236 }
237
238
239 /* E1000 Write Register 32bit
240  * Write a 32 bit value from a register at the given offset in the 
241  * E1000 MMIO range.
242  *
243  * This function has IOPORT support, but is not used.
244  */
245 void e1000_wr32(uint32_t offset, uint32_t val) {
246
247         if (e1000_mmio_base_addr) {
248                 write_mmreg32(e1000_mmio_base_addr + offset, val);
249         } else {
250                 outl(e1000_io_base_addr + offset, val);
251         }
252 }
253
254
255 /* E1000 Read From EEPROM
256  * Read a 16 bit value from the EEPROM at the given offset 
257  * in the EEPROM.
258  *
259  * WARNING: USE CAREFULLY. THIS HAS A WHILE LOOP IN IT.
260  * if MMIO is not configured correctly, this will lock the kernel.
261  */
262 uint16_t e1000_read_eeprom(uint32_t offset) {
263
264         uint16_t eeprom_data;
265         uint32_t eeprom_reg_val = e1000_rr32(E1000_EECD);
266
267         // Request access to the EEPROM, then wait for access
268         eeprom_reg_val = eeprom_reg_val | E1000_EECD_REQ;
269         e1000_wr32(E1000_EECD, eeprom_reg_val);
270         while((e1000_rr32(E1000_EECD) & E1000_EECD_GNT) == 0);
271
272         // We now have access, write what value we want to read, then wait for access
273         eeprom_reg_val = E1000_EERD_START | (offset << E1000_EERD_ADDR_SHIFT);
274         e1000_wr32(E1000_EERD, eeprom_reg_val);
275         while(((eeprom_reg_val = e1000_rr32(E1000_EERD)) & E1000_EERD_DONE) == 0);
276         eeprom_data = (eeprom_reg_val & E1000_EERD_DATA_MASK) >> E1000_EERD_DATA_SHIFT;
277         
278         // Read the value (finally)
279         eeprom_reg_val = e1000_rr32(E1000_EECD);
280
281         // Tell the EEPROM we are done.
282         e1000_wr32(E1000_EECD, eeprom_reg_val & ~E1000_EECD_REQ);
283
284         return eeprom_data;
285
286 }
287
288 // Discover and record the MAC address for this device.
289 void e1000_setup_mac() {
290
291         uint16_t eeprom_data = 0;
292         uint32_t mmio_data = 0;
293
294         /* TODO: WARNING - EXTREMELY GHETTO */
295         e1000_debug("-->Setting up MAC addr\n");
296
297         // Quark: For ID0 type, we read from the EEPROm. Else we read from RAL/RAH.
298         if (device_id == INTEL_DEV_ID0) {
299
300                 // This is ungodly slow. Like, person perceivable time slow.
301                 for (int i = 0; i < 3; i++) {
302
303                         eeprom_data = e1000_read_eeprom(i);
304                         device_mac[2*i] = eeprom_data & 0x00FF;
305                         device_mac[2*i + 1] = (eeprom_data & 0xFF00) >> 8;
306
307                 }
308
309         } else {
310                 
311                 // Get the data from RAL
312                 mmio_data = e1000_rr32(E1000_RAL);
313
314                 // Do the big magic rain dance
315                 device_mac[0] = mmio_data & 0xFF;
316                 device_mac[1] = (mmio_data >> 8) & 0xFF;
317                 device_mac[2] = (mmio_data >> 16) & 0xFF;
318                 device_mac[3] = (mmio_data >> 24) & 0xFF;
319
320                 // Get the rest of the MAC data from RAH.
321                 mmio_data = e1000_rr32(E1000_RAH);
322                 
323                 // Continue magic dance.
324                 device_mac[4] = mmio_data & 0xFF;
325                 device_mac[5] = (mmio_data >> 8) & 0xFF;
326         }
327
328         // Check if we need to invert the higher order bits (some E1000's)
329         // Got this behavior from Barrelfish.
330         // It's worth noting that if MMIO is screwed up, this is generally
331         // the first warning sign.
332         mmio_data = e1000_rr32(E1000_STATUS);
333         if (mmio_data & E1000_STATUS_FUNC_MASK) {
334                 printk("UNTESTED LANB FUNCTIONALITY! MAY BE BREAKING MAC\n");
335                 device_mac[5] ^= 0x0100;
336         }       
337
338         // Program the device to use this mac (really only needed for ID0 type)
339         e1000_wr32(E1000_RAH, 0x00000); // Set MAC invalid
340         e1000_wr32(E1000_RAL, *(uint32_t*)device_mac);
341         e1000_wr32(E1000_RAH, *(uint16_t*)(device_mac + 4) | 0x80000000);
342         
343         // Now make sure it read back out.
344         // This is done to make sure everything is working correctly with the NIC
345         mmio_data = e1000_rr32(E1000_RAL);
346         device_mac[0] = mmio_data & 0xFF;
347         device_mac[1] = (mmio_data >> 8) & 0xFF;
348         device_mac[2] = (mmio_data >> 16) & 0xFF;
349         device_mac[3] = (mmio_data >> 24) & 0xFF;
350         mmio_data = e1000_rr32(E1000_RAH);
351         device_mac[4] = mmio_data & 0xFF;
352         device_mac[5] = (mmio_data >> 8) & 0xFF;
353
354         // Clear the MAC's from all the other filters
355         // Must clear high to low.
356         // TODO: Get the right number of filters. Not sure how.
357         //       however they SHOULD all default to all 0's, so
358         //       this shouldnt be needed.
359         for (int i = 1; i < 16; i++) {
360                 e1000_wr32(E1000_RAH + 8 * i, 0x0);
361                 e1000_wr32(E1000_RAL + 8 * i, 0x0);
362         }
363
364
365         // Clear MTA Table
366         // TODO: Get the right number of filters. See above.
367         for (int i = 0; i < 0x7F; i++) {
368                 e1000_wr32(E1000_MTA + 4 * i, 0x0);
369         }
370
371         e1000_debug("-->DEVICE MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
372                     0xFF & device_mac[0], 0xFF & device_mac[1],
373                     0xFF & device_mac[2], 0xFF & device_mac[3],
374                     0xFF & device_mac[4], 0xFF & device_mac[5]);
375         return;
376 }
377
378 // Allocate and configure all the transmit and receive descriptors.
379 void e1000_setup_descriptors() {
380
381         e1000_debug("-->Setting up tx/rx descriptors.\n");
382
383         // Allocate room for the buffers. 
384         // Must be 16 byte aligned
385
386         // How many pages do we need?
387         uint32_t num_rx_pages = ROUNDUP(NUM_RX_DESCRIPTORS * sizeof(struct e1000_rx_desc), PGSIZE) / PGSIZE;
388         uint32_t num_tx_pages = ROUNDUP(NUM_TX_DESCRIPTORS * sizeof(struct e1000_tx_desc), PGSIZE) / PGSIZE;
389         
390         // Get the pages
391         rx_des_kva = get_cont_pages(LOG2_UP(num_rx_pages), 0);
392         tx_des_kva = get_cont_pages(LOG2_UP(num_tx_pages), 0);
393
394         // +1 point for checking malloc result
395         if (rx_des_kva == NULL) panic("Can't allocate page for RX Ring");
396         if (tx_des_kva == NULL) panic("Can't allocate page for TX Ring");
397         
398         // Get the phys addr
399         rx_des_pa = PADDR(rx_des_kva);
400         tx_des_pa = PADDR(tx_des_kva);
401         
402         // Configure each descriptor.
403         for (int i = 0; i < NUM_RX_DESCRIPTORS; i++) 
404                 e1000_set_rx_descriptor(i, TRUE); // True == Allocate memory for the descriptor
405                 
406         for (int i = 0; i < NUM_TX_DESCRIPTORS; i++) 
407                 e1000_set_tx_descriptor(i);
408
409         return;
410 }
411
412 // Configure a specific RX descriptor.
413 // Serves as a reset, too (with reset_buffer set to FALSE).
414 void e1000_set_rx_descriptor(uint32_t des_num, uint8_t reset_buffer) {
415         
416         //memset(&rx_des_kva[des_num], 0x00, sizeof(struct e1000_rx_desc));
417         rx_des_kva[des_num].length = 0;
418         rx_des_kva[des_num].csum = 0;
419         rx_des_kva[des_num].status = 0;
420         rx_des_kva[des_num].errors = 0;
421         rx_des_kva[des_num].special = 0;
422         
423         // Check if we are allocating a buffer.
424         // Note: setting this to TRUE not at boot time results in a memory leak.
425         if (reset_buffer) {
426                 
427                 // Alloc a buffer
428                 char *rx_buffer = kmalloc(E1000_RX_MAX_BUFFER_SIZE, 0);
429                 if (rx_buffer == NULL) panic ("Can't allocate page for RX Buffer");
430                 
431                 // Set the buffer addr
432                 rx_des_kva[des_num].buffer_addr = PADDR(rx_buffer);
433         }
434
435         return;
436 }
437
438 // Configure a specific TX descriptor.
439 // Calling not at boot results in a memory leak.
440 void e1000_set_tx_descriptor(uint32_t des_num) {
441         
442         // Clear the bits.
443         memset(&tx_des_kva[des_num], 0x00, sizeof(struct e1000_tx_desc));
444         
445         // Alloc space for the buffer
446         char *tx_buffer = kmalloc(E1000_TX_MAX_BUFFER_SIZE, 0);
447         if (tx_buffer == NULL) panic ("Can't allocate page for TX Buffer");
448
449         // Set it.
450         tx_des_kva[des_num].buffer_addr = PADDR(tx_buffer);
451         return;
452 }
453
454 /* Actually configure the device.
455  * This goes through the painstaking process of actually configuring the device
456  * and preparing it for use. After this function, the device is turned on
457  * in a good and functioning state (except interrupts are off).
458  *
459  * I give a brief description of what each bit of code does, but
460  * the details of the bits are in most cases from the spec sheet
461  * and exact details are a bit obfuscated. 
462  *
463  * This startup sequence is taken with love from BarrelFish.
464  * <3 the multikernel.
465  */
466 void e1000_configure() {
467         
468         uint32_t data;
469
470         e1000_debug("-->Configuring Device.\n");
471         
472         // Clear interrupts
473         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
474
475         // Disable receiver and transmitter
476         e1000_wr32(E1000_RCTL, 0x00);
477         e1000_wr32(E1000_TCTL, 0x00);
478
479         // Reset the device
480         e1000_reset();  
481
482         // Clear interrupts
483         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
484
485         // Fix PHY_RESET
486         data = e1000_rr32(E1000_CTRL);
487         data = data & ~E1000_CTRL_PHY_RST;
488         e1000_wr32(E1000_CTRL, data);
489         data = e1000_rr32(E1000_STATUS);
490         data = data & ~E1000_STATUS_MTXCKOK; // XXX: Against spec
491         e1000_wr32(E1000_STATUS, data);
492
493         // Link MAC and PHY
494         data = e1000_rr32(E1000_CTRL);
495         data = data & E1000_CTRL_SLU;
496         e1000_wr32(E1000_CTRL, data);
497
498         // Set PHY mode
499         data = e1000_rr32(E1000_CTRL_EXT);
500         data = (data & ~E1000_CTRL_EXT_LINK_MODE_MASK) | E1000_CTRL_EXT_LINK_MODE_GMII;
501         e1000_wr32(E1000_CTRL_EXT, data);
502
503         // Set full-duplex
504         data = e1000_rr32(E1000_CTRL);
505         data = data & E1000_CTRL_FD;
506         e1000_wr32(E1000_CTRL, data);
507
508         // Set CTRL speed (from STATUS speed)
509         {
510                 data = e1000_rr32(E1000_CTRL);
511                 uint32_t status = e1000_rr32(E1000_STATUS);
512                 status = (status & E1000_STATUS_SPEED_MASK) >> 6;
513                 data = (data & ~E1000_CTRL_SPD_SEL) | (status << 8);
514                 e1000_wr32(E1000_CTRL, data);
515         }
516
517         // Turn off flow control
518         e1000_wr32(E1000_FCAL, 0x00);
519         e1000_wr32(E1000_FCAH, 0x00);
520         e1000_wr32(E1000_FCT,  0x00);
521
522         // Setup MAC address
523         e1000_setup_mac();      
524
525         // Set RX Ring
526         e1000_wr32(E1000_RDBAL, rx_des_pa);
527         e1000_wr32(E1000_RDBAH, 0x00);
528
529         // Set RX Ring Size
530         // Size in bytes.
531         e1000_wr32(E1000_RDLEN, (NUM_RX_DESCRIPTORS / 8) << 7);
532        
533         // Disablie the split and replication control queue 
534         e1000_wr32(E1000_SRRCTRL, 0x00);
535
536         // Set head and tail pointers.
537         e1000_wr32(E1000_RDH, 0x00);
538         e1000_wr32(E1000_RDT, 0x00);
539
540         // Receive descriptor control
541         e1000_wr32(E1000_RXDCTL, E1000_RXDCTL_ENABLE | E1000_RXDCTL_WBT | E1000_RXDCTL_MAGIC);
542
543         // Disable packet splitting.
544         data = e1000_rr32(E1000_RFCTL);
545         data = data & ~E1000_RFCTL_EXTEN;
546         e1000_wr32(E1000_RFCTL, data);
547
548         // Enable packet reception
549         data = e1000_rr32(E1000_RCTL);
550         data = data | E1000_RCTL_EN | E1000_RCTL_BAM;
551         e1000_wr32(E1000_RCTL, data);
552
553         // Bump the tail pointer. This MUST be done at this point 
554         // _AFTER_ packet receiption is enabled. See 85276 spec sheet.
555         e1000_wr32(E1000_RDT, NUM_RX_DESCRIPTORS - 1);
556
557         // Set TX Ring
558         e1000_wr32(E1000_TDBAL, tx_des_pa);
559         e1000_wr32(E1000_TDBAH, 0x00);
560
561         // Set TX Des Size.
562         // This is the number of 8 descriptor sets, it starts at the 7th bit.
563         e1000_wr32(E1000_TDLEN, ((NUM_TX_DESCRIPTORS / 8) << 7));
564
565         // Transmit inter packet gap register
566         // XXX: Recomended magic. See 13.4.34
567         e1000_wr32(E1000_TIPG, 0x00702008);
568
569         // Set head and tail pointers.
570         e1000_wr32(E1000_TDH, 0x00);
571         e1000_wr32(E1000_TDT, 0x00);
572
573         // Tansmit desc control
574         e1000_wr32(E1000_TXDCTL, E1000_TXDCTL_MAGIC | E1000_TXDCTL_ENABLE);
575
576         // Enable transmit
577         // Enable + pad short packets + Back off time + Collision thresh
578         // The 0x0F000 is the back off time, and 0x0010 is the collision thresh.
579         e1000_wr32(E1000_TCTL, E1000_TCTL_EN | E1000_TCTL_PSP | 0x0F010);
580
581         return;
582 }
583
584 // Reset the device.
585 void e1000_reset() {
586         e1000_debug("-->Resetting device..... ");
587
588         // Get control
589         uint32_t ctrl = e1000_rr32(E1000_CTRL);
590
591         // Set the reset bit
592         ctrl = ctrl & E1000_CTRL_RST;
593
594         // Write the reset bit
595         e1000_wr32(E1000_CTRL, ctrl);
596
597         e1000_debug(" done.\n");
598
599         return;
600 }
601
602 void enable_e1000_irq(struct trapframe *tf, uint32_t src_id, 
603                                 void* a0, void* a1, void* a2)
604 {
605         pic_unmask_irq(e1000_irq);
606         unmask_lapic_lvt(LAPIC_LVT_LINT0);
607         enable_irq();
608 }
609
610 // Configure and enable interrupts
611 void e1000_setup_interrupts() {
612         
613         extern handler_t interrupt_handlers[];
614         
615         e1000_debug("-->Setting interrupts.\n");
616         
617         // Set throttle register
618         e1000_wr32(E1000_ITR, 0x0000);
619         
620         // Clear interrupts
621         e1000_wr32(E1000_IMS, 0xFFFFFFFF);
622         e1000_wr32(E1000_IMC, 0xFFFFFFFF);
623         
624         // Set interrupts
625         // TODO: Make this only enable stuff we want
626         e1000_wr32(E1000_IMS, 0xFFFFFFFF); 
627
628         // Kernel based interrupt stuff
629         register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + e1000_irq, e1000_interrupt_handler, 0);
630
631         // Enable irqs for the e1000
632 #ifdef __CONFIG_ENABLE_MPTABLES__
633         /* TODO: this should be for any IOAPIC EOI, not just MPTABLES */
634         ioapic_route_irq(e1000_irq, E1000_IRQ_CPU);     
635 #else 
636         // This will route the interrupts automatically to CORE 0
637         // Call send_kernel_message if you want to route them somewhere else
638         enable_e1000_irq(NULL,0,0,0,0);
639 #endif
640
641         return;
642 }
643
644 // Code that is executed when an interrupt comes in on IRQ e1000_irq
645 void e1000_interrupt_handler(trapframe_t *tf, void* data) {
646
647 //      printk("About to spam to mac addr: 00:14:4F:D1:EC:6C\n");
648 //      while(1) {
649 //              appserver_packet_t p;
650 //              p.header.dst_mac[0] = 0x00;
651 //              p.header.dst_mac[1] = 0x14;
652 //              p.header.dst_mac[2] = 0x4f;
653 //              p.header.dst_mac[3] = 0xd1;
654 //              p.header.dst_mac[4] = 0xec;
655 //              p.header.dst_mac[5] = 0x6c;
656 //              p.header.src_mac[0] = 0x00;
657 //              p.header.src_mac[1] = 0x23;
658 //              p.header.src_mac[2] = 0x8b;
659 //              p.header.src_mac[3] = 0x42;
660 //              p.header.src_mac[4] = 0x80;
661 //              p.header.src_mac[5] = 0xb8;
662 //              p.header.ethertype = 0x8888;
663 //              send_frame((char*)&p,0);
664 //      }
665
666         e1000_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
667                                 
668         // Read the offending interrupt(s)
669         // Note: Reading clears the interrupts
670         uint32_t interrupt_status = e1000_rr32(E1000_ICR);
671
672         // Loop to deal with TOCTOU 
673         while (interrupt_status != 0x0000) {
674
675                 //printk("Interrupt status: %x\n", interrupt_status);
676
677                 // Check to see if the interrupt was packet based.
678                 if ((interrupt_status & E1000_ICR_INT_ASSERTED) && (interrupt_status & E1000_ICR_RXT0)) {
679                         e1000_interrupt_debug("---->Packet Received\n");
680                         e1000_handle_rx_packet();
681                 }       
682                 // Clear interrupts     
683                 interrupt_status = e1000_rr32(E1000_ICR);
684         }
685         
686         // In the event that we got really unlucky and more data arrived after we set 
687         //  set the bit last, try one more check
688         e1000_handle_rx_packet();
689
690         return;
691 }
692
693 // Check to see if a packet arrived, and process the packet.
694 void e1000_handle_rx_packet() {
695         
696         uint16_t packet_size;
697         uint32_t status;
698         uint32_t head = e1000_rr32(E1000_RDH);
699
700         //printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
701         //printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
702         
703         // If the HEAD is where we last processed, no new packets.
704         if (head == e1000_rx_index) {
705                 e1000_frame_debug("-->Nothing to process. Returning.");
706                 return;
707         }
708         
709         // Set our current descriptor to where we last left off.
710         uint32_t rx_des_loop_cur = e1000_rx_index;
711         uint32_t frame_size = 0;
712         uint32_t fragment_size = 0;
713         uint32_t num_frags = 0;
714         
715         // Grab a buffer for this packet.
716         char *rx_buffer = kmalloc(MAX_FRAME_SIZE, 0);
717         if (rx_buffer == NULL) panic ("Can't allocate page for incoming packet.");
718         
719         
720         do {
721                 // Get the descriptor status
722                 status = rx_des_kva[rx_des_loop_cur].status;
723
724                 // If the status is 0x00, it means we are somehow trying to process 
725                 //  a packet that hasnt been written by the NIC yet.
726                 if (status == 0x0) {
727                         warn("ERROR: E1000: Packet owned by hardware has 0 status value\n");
728                         /* It's possible we are processing a packet that is a fragment
729                          * before the entire packet arrives.  The code currently assumes
730                          * that all of the packets fragments are there, so it assumes the
731                          * next one is ready.  We'll spin until it shows up...  This could
732                          * deadlock, and sucks in general, but will help us diagnose the
733                          * driver's issues.  TODO: determine root cause and fix this shit.*/
734                         while(rx_des_kva[rx_des_loop_cur].status == 0x0)
735                                 cpu_relax();
736                         status = rx_des_kva[rx_des_loop_cur].status;
737                 }
738         
739                 // See how big this fragment? is.
740                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
741                 
742                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
743                 // Panic or clear all descriptors? This is a nic hardware error. 
744                 if (num_frags && (rx_des_loop_cur == head)) {
745                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
746                         panic("RX Descriptor Ring out of sync.");
747                 }
748                 
749                 // Denote that we have at least 1 fragment.
750                 num_frags++;
751                 
752                 // Make sure ownership is correct. Packet owned by the NIC (ready for kernel reading)
753                 //  is denoted by a 1. Packet owned by the kernel (ready for NIC use) is denoted by 0.
754                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
755                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
756                         panic("RX Descriptor Ring OWN out of sync");
757                 }
758                 
759                 // Deal with packets too large
760                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
761                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
762                         panic("NIC Sent packets larger than configured.");
763                 }
764                 
765                 // Move the fragment data into the buffer
766                 memcpy(rx_buffer + frame_size, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
767                 
768                 // Reset the descriptor. Reuse current buffer (False means don't realloc).
769                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
770                 
771                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 2048 of them.
772                 // This can not overflow the uint32_t we allocated for frame size, so
773                 // we dont need to worry about mallocing too little then overflowing when we read.
774                 frame_size = frame_size + fragment_size;
775                 
776                 // Advance to the next descriptor
777                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
778
779         } while ((status & E1000_RXD_STAT_EOP) == 0); // Check to see if we are at the final fragment
780
781 #ifdef __CONFIG_APPSERVER__
782         // Treat as a syscall frontend response packet if eth_type says so
783         // Will eventually go away, so not too worried about elegance here...
784         uint16_t eth_type = htons(*(uint16_t*)(rx_buffer + 12));
785         if(eth_type == APPSERVER_ETH_TYPE) {
786                 handle_appserver_packet(rx_buffer, frame_size);
787                 kfree(rx_buffer);
788
789                 // Advance the tail pointer                             
790                 e1000_rx_index = rx_des_loop_cur;
791                 e1000_wr32(E1000_RDT, e1000_rx_index);
792                 return;
793         }
794 #endif
795
796 #ifdef __CONFIG_ETH_AUDIO__
797         /* TODO: move this, and all packet processing, out of this driver (including
798          * the ghetto buffer).  Note we don't handle IP fragment reassembly (though
799          * this isn't an issue for the eth_audio). */
800         struct ethaud_udp_packet *packet = (struct ethaud_udp_packet*)rx_buffer;
801         uint8_t protocol = packet->ip_hdr.protocol;
802         uint16_t udp_port = ntohs(packet->udp_hdr.dst_port);
803         if (protocol == IPPROTO_UDP && udp_port == ETH_AUDIO_RCV_PORT) {
804                 eth_audio_newpacket(packet);
805                 // Advance the tail pointer                             
806                 e1000_rx_index = rx_des_loop_cur;
807                 e1000_wr32(E1000_RDT, e1000_rx_index);
808                 return;
809         }
810 #endif /* __CONFIG_ETH_AUDIO__ */
811
812         // Paul:Mildly hacky stuff for LWIP
813         // TODO: Why was this necessary for LWIP?
814         spin_lock(&packet_buffers_lock);
815
816         if (num_packet_buffers >= MAX_PACKET_BUFFERS) {
817                 printd("WARNING: DROPPING PACKET!\n");
818                 spin_unlock(&packet_buffers_lock);
819                 kfree(rx_buffer);
820         
821                 // Advance the tail pointer                             
822                 e1000_rx_index = rx_des_loop_cur;
823         e1000_wr32(E1000_RDT, (e1000_rx_index -1) % NUM_RX_DESCRIPTORS);
824                 return;
825         }
826
827         packet_buffers[packet_buffers_tail] = rx_buffer;
828         packet_buffers_sizes[packet_buffers_tail] = frame_size;
829                 
830         packet_buffers_tail = (packet_buffers_tail + 1) % MAX_PACKET_BUFFERS;
831         num_packet_buffers++;
832
833         spin_unlock(&packet_buffers_lock);
834         // End mildy hacky stuff for LWIP
835
836         //Log where we should start reading from next time we trap                              
837         e1000_rx_index = rx_des_loop_cur;
838         
839         // Bump the tail pointer. It should be 1 behind where we start reading from.
840         e1000_wr32(E1000_RDT, (e1000_rx_index -1) % NUM_RX_DESCRIPTORS);
841                                 
842         // Chew on the frame data. Command bits should be the same for all frags.
843         //e1000_process_frame(rx_buffer, frame_size, current_command);
844         
845         return;
846 }
847
848 // Main routine to send a frame. Just sends it and goes.
849 // Card supports sending across multiple fragments, we don't.
850 // Would we want to write a function that takes a larger packet and generates fragments?
851 // This seems like the stacks responsibility. Leave this for now. may in future
852 // Remove the max size cap and generate multiple packets.
853 int e1000_send_frame(const char *data, size_t len) {
854
855         if (data == NULL)
856                 return -1;
857         if (len == 0)
858                 return 0;
859
860         // Find where we want to write
861         uint32_t head = e1000_rr32(E1000_TDH);
862
863         
864         // Fail if we are out of space
865         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
866                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
867                 return -1;
868         }
869         
870         // Fail if we are too large
871         if (len > MAX_FRAME_SIZE) {
872                 e1000_frame_debug("-->Frame Too Large!\n");
873                 return -1;
874         }
875         
876         // Move the data
877         memcpy(KADDR(tx_des_kva[e1000_tx_index].buffer_addr), data, len);
878
879         // Set the length
880         tx_des_kva[e1000_tx_index].lower.flags.length = len;
881         
882         // Magic that means send 1 fragment and report.
883         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
884
885         // Track our location
886         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
887         
888         // Bump the tail.
889         e1000_wr32(E1000_TDT, e1000_tx_index);
890
891         e1000_frame_debug("-->Sent packet.\n");
892         
893 return len;
894 }