Quick hack to fix e1000
[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         struct pci_device *pcidev;
142         uint32_t result;
143         unsigned int once = 0;
144         printk("Searching for Intel E1000 Network device...");
145         STAILQ_FOREACH(pcidev, &pci_devices, all_dev) {
146                 /* Ignore non Intel Devices */
147                 if (pcidev->ven_id != INTEL_VENDOR_ID)
148                         continue;
149                 /* Ignore non E1000 devices */
150                 if ((pcidev->dev_id != INTEL_DEV_ID0) && 
151                     (pcidev->dev_id != INTEL_DEV_ID1) &&
152                     (pcidev->dev_id != INTEL_DEV_ID2))
153                         continue;
154                 printk(" found on BUS %x DEV %x FUNC %x\n", pcidev->bus, pcidev->dev,
155                        pcidev->func);
156                 /* TODO: (ghetto) Skip the management nic on the 16 core box.  It is
157                  * probably the first one found (check this) */
158                 if ((pcidev->dev_id == INTEL_DEV_ID1) && (once++ == 0)) 
159                         continue;
160                 /* TODO: WARNING - EXTREMELY GHETTO */
161                 device_id = pcidev->dev_id;
162                 /* Find the IRQ */
163                 e1000_irq = pcidev->irqline;
164                 e1000_debug("-->IRQ: %u\n", e1000_irq);
165                 /* Loop over the BARs */
166                 for (int k = 0; k <= 5; k++) {
167                         int reg = 4 + k;
168                 result = pcidev_read32(pcidev, reg << 2);       // SHAME!
169                         if (result == 0) // (0 denotes no valid data)
170                                 continue;
171                         // Read the bottom bit of the BAR. 
172                         if (result & PCI_BAR_IO_MASK) {
173                                 result = result & PCI_IO_MASK;
174                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "IO", result);
175                         } else {
176                                 result = result & PCI_MEM_MASK;
177                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "MEM", result);
178                         }
179                         if (k == 0) { // BAR0 denotes the IO Addr for the device
180                                 if (result & PCI_BAR_IO_MASK) {
181                                         e1000_debug("-->IO PORT MODE\n");
182                                         panic("IO PORT MODE NOT SUPPORTED\n");
183                                 } else {
184                                         e1000_debug("-->MMIO Mode, Base: %08p\n", result);
185                                         e1000_mmio_base_addr = result;
186                                         // Now we do magic to find the size
187                                         // The first non zero bit after we
188                                         // write all 1's denotes the size
189                                         outl(PCI_CONFIG_DATA, 0xFFFFFFFF);
190                                         result = inl(PCI_CONFIG_DATA);
191                                         result = result & PCI_MEM_MASK;
192                                         result = (result ^ 0xFFFFFFFF) + 1;
193                                         e1000_addr_size = result;
194                     e1000_debug("-->MMIO Size %x\n", e1000_addr_size);
195                                         outl(PCI_CONFIG_DATA, e1000_mmio_base_addr);
196                 
197                                         #ifdef __CONFIG_E1000_MMIO_HACK__
198                                         /* TODO: WARNING - EXTREMELY GHETTO */
199                                         // Map the page in.
200                                         e1000_debug("HACK FOR BROKEN MMIO\n");
201                                         e1000_mmio_base_addr = E1000_MMIO_ADDR;
202                                         outl(PCI_CONFIG_DATA, e1000_mmio_base_addr);
203                                         e1000_mmio_base_addr = 0xfee00000 + 0x1000;
204                                         #endif
205                                 }
206                         }                                               
207                 }
208                 return 0;
209         }
210         printk(" not found. No device configured.\n");
211         return -1;
212 }
213
214 uint32_t e1000_rr32(uint32_t offset) {
215
216         if (e1000_mmio_base_addr) {
217                 return read_mmreg32(e1000_mmio_base_addr + offset);
218         } else {
219                 return inl(e1000_io_base_addr + offset);
220         }
221 }
222
223 void e1000_wr32(uint32_t offset, uint32_t val) {
224
225         if (e1000_mmio_base_addr) {
226                 write_mmreg32(e1000_mmio_base_addr + offset, val);
227         } else {
228                 outl(e1000_io_base_addr + offset, val);
229         }
230 }
231
232
233 uint16_t e1000_read_eeprom(uint32_t offset) {
234
235         uint16_t eeprom_data;
236         uint32_t eeprom_reg_val = e1000_rr32(E1000_EECD);
237
238         eeprom_reg_val = eeprom_reg_val | E1000_EECD_REQ;
239         e1000_wr32(E1000_EECD, eeprom_reg_val);
240         while((e1000_rr32(E1000_EECD) & E1000_EECD_GNT) == 0);
241
242         eeprom_reg_val = E1000_EERD_START | (offset << E1000_EERD_ADDR_SHIFT);
243         e1000_wr32(E1000_EERD, eeprom_reg_val);
244         while(((eeprom_reg_val = e1000_rr32(E1000_EERD)) & E1000_EERD_DONE) == 0);
245         eeprom_data = (eeprom_reg_val & E1000_EERD_DATA_MASK) >> E1000_EERD_DATA_SHIFT;
246         
247         eeprom_reg_val = e1000_rr32(E1000_EECD);
248         e1000_wr32(E1000_EECD, eeprom_reg_val & ~E1000_EECD_REQ);
249
250         return eeprom_data;
251
252 }
253
254 void e1000_setup_mac() {
255
256         uint16_t eeprom_data = 0;
257         uint32_t mmio_data = 0;
258
259         /* TODO: WARNING - EXTREMELY GHETTO */
260         if (device_id == INTEL_DEV_ID0) {
261
262                 for (int i = 0; i < 3; i++) {
263
264                         eeprom_data = e1000_read_eeprom(i);
265                         device_mac[2*i] = eeprom_data & 0x00FF;
266                         device_mac[2*i + 1] = (eeprom_data & 0xFF00) >> 8;
267
268                 }
269
270         } else {
271
272                 mmio_data = e1000_rr32(E1000_RAL);
273                 device_mac[0] = mmio_data & 0xFF;
274                 device_mac[1] = (mmio_data >> 8) & 0xFF;
275                 device_mac[2] = (mmio_data >> 16) & 0xFF;
276                 device_mac[3] = (mmio_data >> 24) & 0xFF;
277                 mmio_data = e1000_rr32(E1000_RAH);
278                 device_mac[4] = mmio_data & 0xFF;
279                 device_mac[5] = (mmio_data >> 8) & 0xFF;
280         }
281
282         // Check if we need to invert the higher order bits (some E1000's)
283         mmio_data = e1000_rr32(E1000_STATUS);
284
285         if (mmio_data & E1000_STATUS_FUNC_MASK) {
286                 printk("UNTESTED LANB FUNCTIONALITY! MAY BE BREAKING MAC\n");
287                 device_mac[5] ^= 0x0100;
288         }       
289
290         // Program the device to use this mac
291         e1000_wr32(E1000_RAH, 0x00000); // Set MAC invalid
292         e1000_wr32(E1000_RAL, *(uint32_t*)device_mac);
293         e1000_wr32(E1000_RAH, *(uint16_t*)(device_mac + 4) | 0x80000000);
294         
295         // Now make sure it read back out.
296         mmio_data = e1000_rr32(E1000_RAL);
297         device_mac[0] = mmio_data & 0xFF;
298         device_mac[1] = (mmio_data >> 8) & 0xFF;
299         device_mac[2] = (mmio_data >> 16) & 0xFF;
300         device_mac[3] = (mmio_data >> 24) & 0xFF;
301         mmio_data = e1000_rr32(E1000_RAH);
302         device_mac[4] = mmio_data & 0xFF;
303         device_mac[5] = (mmio_data >> 8) & 0xFF;
304
305         // Clear the MAC's from all the other filters
306         // Must clear high to low.
307         // TODO: Get the right number of filters
308         for (int i = 1; i < 16; i++) {
309                 e1000_wr32(E1000_RAH + 8 * i, 0x0);
310                 e1000_wr32(E1000_RAL + 8 * i, 0x0);
311         }
312
313
314         // Clear MTA Table
315         // TODO: Get the right number of filters
316         for (int i = 0; i < 0x7F; i++) {
317                 e1000_wr32(E1000_MTA + 4 * i, 0x0);
318         }
319
320         e1000_debug("-->DEVICE MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
321                     0xFF & device_mac[0], 0xFF & device_mac[1],
322                     0xFF & device_mac[2], 0xFF & device_mac[3],
323                     0xFF & device_mac[4], 0xFF & device_mac[5]);
324         return;
325 }
326
327 void e1000_setup_descriptors() {
328
329         e1000_debug("-->Setting up tx/rx descriptors.\n");
330
331         // Allocate room for the buffers. 
332         // Must be 16 byte aligned
333         uint32_t num_rx_pages = ROUNDUP(NUM_RX_DESCRIPTORS * sizeof(struct e1000_rx_desc), PGSIZE) / PGSIZE;
334         uint32_t num_tx_pages = ROUNDUP(NUM_TX_DESCRIPTORS * sizeof(struct e1000_tx_desc), PGSIZE) / PGSIZE;
335         
336         rx_des_kva = get_cont_pages(LOG2_UP(num_rx_pages), 0);
337         tx_des_kva = get_cont_pages(LOG2_UP(num_tx_pages), 0);
338
339         if (rx_des_kva == NULL) panic("Can't allocate page for RX Ring");
340         if (tx_des_kva == NULL) panic("Can't allocate page for TX Ring");
341         
342         rx_des_pa = PADDR(rx_des_kva);
343         tx_des_pa = PADDR(tx_des_kva);
344         
345         for (int i = 0; i < NUM_RX_DESCRIPTORS; i++) 
346                 e1000_set_rx_descriptor(i, TRUE); // Allocate memory for the descriptor
347                 
348         for (int i = 0; i < NUM_TX_DESCRIPTORS; i++) 
349                 e1000_set_tx_descriptor(i);
350         return;
351 }
352
353
354 void e1000_set_rx_descriptor(uint32_t des_num, uint8_t reset_buffer) {
355         
356         //memset(&rx_des_kva[des_num], 0x00, sizeof(struct e1000_rx_desc));
357         rx_des_kva[des_num].length = 0;
358         rx_des_kva[des_num].csum = 0;
359         rx_des_kva[des_num].status = 0;
360         rx_des_kva[des_num].errors = 0;
361         rx_des_kva[des_num].special = 0;
362         
363         if (reset_buffer) {
364                 char *rx_buffer = kmalloc(E1000_RX_MAX_BUFFER_SIZE, 0);
365                 if (rx_buffer == NULL) panic ("Can't allocate page for RX Buffer");
366
367                 rx_des_kva[des_num].buffer_addr = PADDR(rx_buffer);
368         }
369
370         return;
371 }
372
373 void e1000_set_tx_descriptor(uint32_t des_num) {
374         
375         // Clear the bits.
376         memset(&tx_des_kva[des_num], 0x00, sizeof(struct e1000_tx_desc));
377         
378         char *tx_buffer = kmalloc(E1000_TX_MAX_BUFFER_SIZE, 0);
379
380         if (tx_buffer == NULL) panic ("Can't allocate page for TX Buffer");
381
382         tx_des_kva[des_num].buffer_addr = PADDR(tx_buffer);
383         return;
384 }
385
386 // This startup sequence is taken with love from BarrelFish.
387 // <3 the multikernel.
388 void e1000_configure() {
389         
390         uint32_t data;
391
392         e1000_debug("-->Configuring Device.\n");
393         
394         // Clear interrupts
395         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
396
397         // Disable receiver and transmitter
398         e1000_wr32(E1000_RCTL, 0x00);
399         e1000_wr32(E1000_TCTL, 0x00);
400
401         // Reset
402         e1000_reset();  
403
404         // Clear interrupts
405         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
406
407         // Fix PHY_RESET
408         data = e1000_rr32(E1000_CTRL);
409         data = data & ~E1000_CTRL_PHY_RST;
410         e1000_wr32(E1000_CTRL, data);
411         data = e1000_rr32(E1000_STATUS);
412         data = data & ~E1000_STATUS_MTXCKOK; // XXX: Against spec
413         e1000_wr32(E1000_STATUS, data);
414
415         // Link MAC and PHY
416         data = e1000_rr32(E1000_CTRL);
417         data = data & E1000_CTRL_SLU;
418         e1000_wr32(E1000_CTRL, data);
419
420         // Set PHY mode
421         data = e1000_rr32(E1000_CTRL_EXT);
422         data = (data & ~E1000_CTRL_EXT_LINK_MODE_MASK) | E1000_CTRL_EXT_LINK_MODE_GMII;
423         e1000_wr32(E1000_CTRL_EXT, data);
424
425         // Set full-duplex
426         data = e1000_rr32(E1000_CTRL);
427         data = data & E1000_CTRL_FD;
428         e1000_wr32(E1000_CTRL, data);
429
430         // Set CTRL speed (from STATUS speed)
431         {
432                 data = e1000_rr32(E1000_CTRL);
433                 uint32_t status = e1000_rr32(E1000_STATUS);
434                 status = (status & E1000_STATUS_SPEED_MASK) >> 6;
435                 data = (data & ~E1000_CTRL_SPD_SEL) | (status << 8);
436                 e1000_wr32(E1000_CTRL, data);
437         }
438
439         // Turn off flow control
440         e1000_wr32(E1000_FCAL, 0x00);
441         e1000_wr32(E1000_FCAH, 0x00);
442         e1000_wr32(E1000_FCT,  0x00);
443
444         // Set stat counters
445
446         // Setup MAC address
447         e1000_setup_mac();      
448
449         // Set RX Ring
450         e1000_wr32(E1000_RDBAL, rx_des_pa);
451         e1000_wr32(E1000_RDBAH, 0x00);
452
453         // Set RX Ring Size
454         // This is the number of desc's, divided by 8. It starts
455         // at bit 7.
456         e1000_wr32(E1000_RDLEN, NUM_RX_DESCRIPTORS * 16);
457         
458         e1000_wr32(0x0280C, 0x00);
459
460         // Set head and tail pointers.
461         e1000_wr32(E1000_RDH, 0x00);
462         e1000_wr32(E1000_RDT, 0x00);
463
464         // Receive descriptor control
465         e1000_wr32(E1000_RXDCTL, 0x02000000 | 0x01010000);
466
467         data = e1000_rr32(E1000_RFCTL);
468         data = data & ~E1000_RFCTL_EXTEN;
469         e1000_wr32(E1000_RFCTL, data);
470
471         // Enable packet reception
472         data = e1000_rr32(E1000_RCTL);
473         data = data | E1000_RCTL_EN | E1000_RCTL_BAM;
474         e1000_wr32(E1000_RCTL, data);
475
476         e1000_wr32(E1000_RDT, NUM_RX_DESCRIPTORS - 1);
477
478         // Set TX Ring
479         e1000_wr32(E1000_TDBAL, tx_des_pa);
480         e1000_wr32(E1000_TDBAH, 0x00);
481
482         // Set TX Des Size
483         e1000_wr32(E1000_TDLEN, ((NUM_TX_DESCRIPTORS / 8) << 7));
484
485         // Transmit inter packet gap register
486         // XXX: Recomended magic. See 13.4.34
487         e1000_wr32(E1000_TIPG, 0x00702008);
488
489         // Set head and tail pointers.
490         e1000_wr32(E1000_TDH, 0x00);
491         e1000_wr32(E1000_TDT, 0x00);
492
493         // Tansmit desc control
494         e1000_wr32(E1000_TXDCTL, 0x01000000 | 0x02000000);
495
496         e1000_wr32(E1000_TDT, NUM_TX_DESCRIPTORS - 1);
497
498         // Enable transmit
499         // XXX: MAGIC (not really paul just hasn't enumerated yet)
500         e1000_wr32(E1000_TCTL, 0x0F01A);
501
502         return;
503 }
504
505 void e1000_reset() {
506         e1000_debug("-->Resetting device..... ");
507
508         uint32_t ctrl = e1000_rr32(E1000_CTRL);
509
510         ctrl = ctrl & E1000_CTRL_RST;
511
512         e1000_wr32(E1000_CTRL, ctrl);
513
514         e1000_debug(" done.\n");
515
516         return;
517 }
518
519 void enable_e1000_irq(struct trapframe *tf, uint32_t src_id, 
520                                 void* a0, void* a1, void* a2)
521 {
522         pic_unmask_irq(e1000_irq);
523         unmask_lapic_lvt(LAPIC_LVT_LINT0);
524         enable_irq();
525 }
526
527 void e1000_setup_interrupts() {
528         
529         extern handler_t interrupt_handlers[];
530         
531         e1000_debug("-->Setting interrupts.\n");
532         
533         // Set throttle register
534         e1000_wr32(E1000_ITR, 0x0000);
535         
536         // Clear interrupts
537         e1000_wr32(E1000_IMS, 0xFFFFFFFF);
538         e1000_wr32(E1000_IMC, 0xFFFFFFFF);
539         
540         // Set interrupts
541         // TODO: Make this only enable stuff we want
542         e1000_wr32(E1000_IMS, 0xFFFFFFFF); 
543
544         // Kernel based interrupt stuff
545         register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + e1000_irq, e1000_interrupt_handler, 0);
546
547         // Enable irqs for the e1000
548 #ifdef __CONFIG_DISABLE_MPTABLES__
549         // This will route the interrupts automatically to CORE 0
550         // Call send_kernel_message if you want to route them somewhere else
551         enable_e1000_irq(NULL,0,0,0,0);
552 #else 
553         ioapic_route_irq(e1000_irq, E1000_IRQ_CPU);     
554 #endif
555
556         return;
557 }
558
559 void e1000_interrupt_handler(trapframe_t *tf, void* data) {
560
561 //      printk("About to spam to mac addr: 00:14:4F:D1:EC:6C\n");
562 //      while(1) {
563 //              appserver_packet_t p;
564 //              p.header.dst_mac[0] = 0x00;
565 //              p.header.dst_mac[1] = 0x14;
566 //              p.header.dst_mac[2] = 0x4f;
567 //              p.header.dst_mac[3] = 0xd1;
568 //              p.header.dst_mac[4] = 0xec;
569 //              p.header.dst_mac[5] = 0x6c;
570 //              p.header.src_mac[0] = 0x00;
571 //              p.header.src_mac[1] = 0x23;
572 //              p.header.src_mac[2] = 0x8b;
573 //              p.header.src_mac[3] = 0x42;
574 //              p.header.src_mac[4] = 0x80;
575 //              p.header.src_mac[5] = 0xb8;
576 //              p.header.ethertype = 0x8888;
577 //              send_frame((char*)&p,0);
578 //      }
579
580         e1000_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
581                                 
582         // Read the offending interrupt(s)
583         // Note: Reading clears the interrupts
584         uint32_t interrupt_status = e1000_rr32(E1000_ICR);
585
586         // Loop to deal with TOCTOU 
587         while (interrupt_status != 0x0000) {
588
589                 //printk("Interrupt status: %x\n", interrupt_status);
590
591                 if ((interrupt_status & E1000_ICR_INT_ASSERTED) && (interrupt_status & E1000_ICR_RXT0)) {
592                         e1000_debug("---->Packet Received\n");
593                         e1000_handle_rx_packet();
594                 }       
595                 // Clear interrupts     
596                 interrupt_status = e1000_rr32(E1000_ICR);
597         }
598         
599         // In the event that we got really unlucky and more data arrived after we set 
600         //  set the bit last, try one more check
601         e1000_handle_rx_packet();
602
603         return;
604 }
605
606 void e1000_handle_rx_packet() {
607         
608         uint16_t packet_size;
609         uint32_t status;
610         uint32_t head = e1000_rr32(E1000_RDH);
611
612         //printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
613         //printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
614         
615         if (head == e1000_rx_index) {
616                 e1000_frame_debug("-->Nothing to process. Returning.");
617                 return;
618         }
619         
620         uint32_t rx_des_loop_cur = e1000_rx_index;
621         uint32_t frame_size = 0;
622         uint32_t fragment_size = 0;
623         uint32_t num_frags = 0;
624         
625         char *rx_buffer = kmalloc(MAX_FRAME_SIZE, 0);
626         
627         if (rx_buffer == NULL) panic ("Can't allocate page for incoming packet.");
628         
629         do {
630                 status =  rx_des_kva[rx_des_loop_cur].status;
631
632                 if (status == 0x0) {
633                         warn("ERROR: E1000: Packet owned by hardware has 0 status value\n");
634                         /* It's possible we are processing a packet that is a fragment
635                          * before the entire packet arrives.  The code currently assumes
636                          * that all of the packets fragments are there, so it assumes the
637                          * next one is ready.  We'll spin until it shows up...  This could
638                          * deadlock, and sucks in general, but will help us diagnose the
639                          * driver's issues.  TODO: determine root cause and fix this shit.*/
640                         while(rx_des_kva[rx_des_loop_cur].status == 0x0)
641                                 cpu_relax();
642                         status = rx_des_kva[rx_des_loop_cur].status;
643                 }
644         
645                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
646                 
647                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
648                 // Panic or clear all descriptors? This is a nic hardware error. 
649                 if (num_frags && (rx_des_loop_cur == head)) {
650                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
651                         panic("RX Descriptor Ring out of sync.");
652                 }
653                 
654                 num_frags++;
655                 
656                 // Make sure we own the current packet. Kernel ownership is denoted by a 0. Nic by a 1.
657                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
658                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
659                         panic("RX Descriptor Ring OWN out of sync");
660                 }
661                 
662                 // Deal with packets too large
663                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
664                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
665                         panic("NIC Sent packets larger than configured.");
666                 }
667                 
668                 // Move the fragment data into the buffer
669                 memcpy(rx_buffer + frame_size, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
670                 
671                 // Reset the descriptor. No reuse buffer.
672                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
673                 
674                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 1024 of them.
675                 // This can not overflow the uint32_t we allocated for frame size, so
676                 // we dont need to worry about mallocing too little then overflowing when we read.
677                 frame_size = frame_size + fragment_size;
678                 
679                 // Advance to the next descriptor
680                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
681
682         } while ((status & E1000_RXD_STAT_EOP) == 0);
683
684 #ifdef __CONFIG_APPSERVER__
685         // Treat as a syscall frontend response packet if eth_type says so
686         // Will eventually go away, so not too worried about elegance here...
687         uint16_t eth_type = htons(*(uint16_t*)(rx_buffer + 12));
688         if(eth_type == APPSERVER_ETH_TYPE) {
689                 handle_appserver_packet(rx_buffer, frame_size);
690                 kfree(rx_buffer);
691
692                 // Advance the tail pointer                             
693                 e1000_rx_index = rx_des_loop_cur;
694                 e1000_wr32(E1000_RDT, e1000_rx_index);
695                 return;
696         }
697 #endif
698
699         spin_lock(&packet_buffers_lock);
700
701         if (num_packet_buffers >= MAX_PACKET_BUFFERS) {
702                 printd("WARNING: DROPPING PACKET!\n");
703                 spin_unlock(&packet_buffers_lock);
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         packet_buffers[packet_buffers_tail] = rx_buffer;
713         packet_buffers_sizes[packet_buffers_tail] = frame_size;
714                 
715         packet_buffers_tail = (packet_buffers_tail + 1) % MAX_PACKET_BUFFERS;
716         num_packet_buffers++;
717
718         spin_unlock(&packet_buffers_lock);
719
720         // Advance the tail pointer                             
721         e1000_rx_index = rx_des_loop_cur;
722         e1000_wr32(E1000_RDT, e1000_rx_index);
723                                 
724         // Chew on the frame data. Command bits should be the same for all frags.
725         //e1000_process_frame(rx_buffer, frame_size, current_command);
726         
727         return;
728 }
729
730 // Main routine to send a frame. Just sends it and goes.
731 // Card supports sending across multiple fragments.
732 // Would we want to write a function that takes a larger packet and generates fragments?
733 // This seems like the stacks responsibility. Leave this for now. may in future
734 // Remove the max size cap and generate multiple packets.
735 int e1000_send_frame(const char *data, size_t len) {
736
737         if (data == NULL)
738                 return -1;
739         if (len == 0)
740                 return 0;
741
742         uint32_t head = e1000_rr32(E1000_TDH);
743
744         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
745                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
746                 return -1;
747         }
748         
749         if (len > MAX_FRAME_SIZE) {
750                 e1000_frame_debug("-->Frame Too Large!\n");
751                 return -1;
752         }
753         
754         memcpy(KADDR(tx_des_kva[e1000_tx_index].buffer_addr), data, len);
755
756         tx_des_kva[e1000_tx_index].lower.flags.length = len;
757         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
758
759         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
760         e1000_wr32(E1000_TDT, e1000_tx_index);
761
762         e1000_frame_debug("-->Sent packet.\n");
763         
764 return len;
765 }