PCI cleanup and better BAR handling
[akaros.git] / kern / drivers / net / 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  * @author David Zhu <yuzhu@cs.berkeley.edu>
10  *
11  */
12
13 #ifdef __SHARC__
14 #pragma nosharc
15 #endif
16
17 #include <arch/mmu.h>
18 #include <arch/x86.h>
19 #include <arch/smp.h>
20 #include <arch/apic.h>
21 #include <arch/pci.h>
22 #include <net/nic_common.h>
23 #include "e1000.h"
24
25 #include <ros/memlayout.h>
26
27 #include <atomic.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <trap.h>
31 #include <kmalloc.h>
32
33 #include <pmap.h>
34 #include <frontend.h>
35 #include <arch/frontend.h>
36 #include <eth_audio.h>
37 #include <net/ip.h>
38
39 #define NUM_TX_DESCRIPTORS E1000_NUM_TX_DESCRIPTORS
40 #define NUM_RX_DESCRIPTORS E1000_NUM_RX_DESCRIPTORS
41
42
43 // Global variables for the device
44 uint32_t e1000_mmio_base_addr = 0;
45 uint32_t e1000_io_base_addr = 0;
46 uint32_t e1000_irq = 0;
47 uint32_t e1000_addr_size = 0;
48
49 // The device's MAC address (read from the device)
50 unsigned char device_mac[6];
51
52 // Vars relating to the receive descriptor ring
53 // pointer to receive descriptors
54 struct e1000_rx_desc *rx_des_kva;
55 unsigned long rx_des_pa;
56 // current rx index
57 uint32_t e1000_rx_index = 0;
58
59
60 // Vars relating to the transmit descriptor ring
61 struct e1000_tx_desc *tx_des_kva;
62 unsigned long tx_des_pa;
63 uint32_t e1000_tx_index = 0;
64
65 extern uint8_t eth_up;
66
67 // The PCI device ID we detect
68 // This is used for quark behavior
69 uint16_t device_id = 0;
70
71
72 // Hacky variables relating to delivering packets
73 extern uint32_t packet_buffer_count;
74 extern char* packet_buffers[MAX_PACKET_BUFFERS];
75 extern uint32_t packet_buffers_sizes[MAX_PACKET_BUFFERS];
76 extern uint32_t packet_buffers_head;
77 extern uint32_t packet_buffers_tail;
78 spinlock_t packet_buffers_lock;
79
80 // Allow us to register our send_frame as the global send_frame
81 extern int (*send_frame)(const char *CT(len) data, size_t len);
82
83 // compat defines that make transitioning easier
84 #define E1000_RX_DESC(x) rx_des_kva[x]
85
86 void e1000_dump_rx() {
87
88         for (int i = 0; i < 10; i++) {
89                 
90                 printk("%u:  %lx%lx\n", i, *(uint64_t*)(&rx_des_kva[i]), *((uint64_t*)(&rx_des_kva[i]) + 1));
91                 printk("%ud: %lx\n", i, *(uint64_t*)(KADDR(rx_des_kva[i].buffer_addr)));        
92         }
93
94 }
95
96 void e1000_dump_stats() {
97
98         uint32_t offset = 0x04000;
99         
100         while (offset <= 0x040FC) {
101                 if ((offset % 16) == 0)
102                         printk("\n");
103                 printk("%x:%d ", offset,e1000_rr32(offset));
104
105                 offset = offset + 4;
106         }
107 }
108
109 // Main init sequence. This is whats called to configure the device
110 // This includes detection of the device.
111 void e1000_init() {
112
113         // Detect if the device is present
114         if (e1000_scan_pci() < 0) return;
115
116         // Allocate and program the descriptors for the ring
117         // Note: Does not tell the device to use them, yet.
118         e1000_setup_descriptors();
119         e1000_configure();
120         printk("Network Card MAC Address: %02x:%02x:%02x:%02x:%02x:%02x\n", 
121            device_mac[0],device_mac[1],device_mac[2],
122            device_mac[3],device_mac[4],device_mac[5]);
123
124         e1000_setup_interrupts();
125
126         // "Register" our send_frame with the global system
127         send_frame = &e1000_send_frame;
128         send_pbuf = &e1000_send_pbuf;
129         recv_pbuf = &e1000_recv_pbuf;
130
131         // sudo /sbin/ifconfig eth0 up
132         eth_up = 1;
133         
134         return;
135 }
136
137 /* Given a addr read from bar0, determine the IO mode,
138  * determine the addr range, and map the MMIO region in.
139  *
140  * Note: This must be called from a scan_pci() context, as it
141  * relies on the state of the PCI_CONFIG_ADDR register.
142  */
143 void e1000_handle_bar0(uint32_t addr) {
144
145         if (addr & PCI_BAR_IO) {
146                 e1000_debug("-->IO PORT MODE\n");
147                 panic("IO PORT MODE NOT SUPPORTED\n");
148         } else {
149                 e1000_debug("-->MMIO Mode\n");
150                 
151                 // Now we do magic to find the size
152                 // The first non zero bit after we
153                 // write all 1's denotes the size
154                 outl(PCI_CONFIG_DATA, 0xFFFFFFFF);
155                 uint32_t result = inl(PCI_CONFIG_DATA);
156                 result = result & PCI_BAR_MEM_MASK;
157                 result = (result ^ 0xFFFFFFFF) + 1;
158                 e1000_addr_size = result;
159                 e1000_debug("-->MMIO Size %x\n", e1000_addr_size);
160                 
161                 // Restore the MMIO addr to the device (unchanged)
162                 outl(PCI_CONFIG_DATA, addr);
163
164                 /* Get a virt address chunk */
165                 e1000_mmio_base_addr = get_vmap_segment(e1000_addr_size >> PGSHIFT);
166                 if (!e1000_mmio_base_addr)
167                         panic("Could not aquire VM space for e1000 MMIO\n");
168                 /* Map the pages in */
169                 if (map_vmap_segment(e1000_mmio_base_addr, addr,
170                                      e1000_addr_size >> PGSHIFT, PTE_P | PTE_KERN_RW))
171                         panic("Unable to map e1000 MMIO\n");
172         }
173         return;
174 }
175
176 // Scan the PCI data structures for our device.
177 int e1000_scan_pci(void)
178 {
179         struct pci_device *pcidev;
180         uint32_t result;
181         printk("Searching for Intel E1000 Network device...");
182         STAILQ_FOREACH(pcidev, &pci_devices, all_dev) {
183                 /* Ignore non Intel Devices */
184                 if (pcidev->ven_id != INTEL_VENDOR_ID)
185                         continue;
186                 /* Ignore non E1000 devices */
187                 switch (pcidev->dev_id) {
188                         case (INTEL_82543GC_ID):
189                         case (INTEL_82540EM_ID):
190                         case (INTEL_82545EM_ID):
191                         case (INTEL_82576_ID):
192                         case (INTEL_82576NS_ID):
193                                 break;
194                         default:
195                                 continue;
196                 }
197                 printk(" found on BUS %x DEV %x FUNC %x\n", pcidev->bus, pcidev->dev,
198                        pcidev->func);
199                 /* TODO: WARNING - EXTREMELY GHETTO  (can only handle 1 NIC) */
200                 if (device_id) {
201                         printk("[e1000] Already configured a device, won't do another\n");
202                         continue;
203                 }
204                 device_id = pcidev->dev_id;
205                 /* Find the IRQ */
206                 e1000_irq = pcidev->irqline;
207                 e1000_debug("-->IRQ: %u\n", e1000_irq);
208                 /* Loop over the BARs */
209                 /* TODO: pci layer should scan these things and put them in a pci_dev
210                  * struct */
211                 /* SelectBars based on the IORESOURCE_MEM */
212                 for (int k = 0; k <= 5; k++) {
213                 /* TODO: clarify this magic */
214                         int reg = 4 + k;
215                         result = pcidev_read32(pcidev, reg << 2);
216
217                         if (result == 0) // (0 denotes no valid data)
218                                 continue;
219                         // Read the bottom bit of the BAR. 
220                         if (result & PCI_BAR_IO) {
221                                 result = result & PCI_BAR_IO_MASK;
222                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "IO", result);
223                         } else {
224                                 result = result & PCI_BAR_MEM_MASK;
225                                 e1000_debug("-->BAR%u: %s --> %x\n", k, "MEM", result);
226                         }
227                         if (k == 0) { // BAR0 denotes the IO Addr for the device
228                                 if (result & PCI_BAR_IO) {
229                                         e1000_debug("-->IO PORT MODE\n");
230                                         panic("IO PORT MODE NOT SUPPORTED\n");
231                                 } else {
232                                         e1000_debug("-->MMIO Mode, Base: %p\n", result);
233                                         // Deal with the MMIO base, mapping, and size.
234                                         e1000_handle_bar0(result);
235                                 }                                               
236                         }
237                 }
238         }
239         if (device_id)
240                 return 0;
241         printk(" not found. No device configured.\n");
242         return -1;
243 }
244
245 /* E1000 Read Register 32bit
246  * Read a 32 bit value from a register at the given offset in the 
247  * E1000 MMIO range.
248  *
249  * This function has IOPORT support, but is not used.
250  */
251 uint32_t e1000_rr32(uint32_t offset) {
252
253         if (e1000_mmio_base_addr) {
254                 return read_mmreg32(e1000_mmio_base_addr + offset);
255         } else {
256                 return inl(e1000_io_base_addr + offset);
257         }
258 }
259
260
261 /* E1000 Write Register 32bit
262  * Write a 32 bit value from a register at the given offset in the 
263  * E1000 MMIO range.
264  *
265  * This function has IOPORT support, but is not used.
266  */
267 void e1000_wr32(uint32_t offset, uint32_t val) {
268
269         if (e1000_mmio_base_addr) {
270                 write_mmreg32(e1000_mmio_base_addr + offset, val);
271         } else {
272                 outl(e1000_io_base_addr + offset, val);
273         }
274 }
275
276 /* E1000 Read From EEPROM
277  * Read a 16 bit value from the EEPROM at the given offset 
278  * in the EEPROM.
279  *
280  * WARNING: USE CAREFULLY. THIS HAS A WHILE LOOP IN IT.
281  * if MMIO is not configured correctly, this will lock the kernel.
282  */
283 uint16_t e1000_read_eeprom(uint32_t offset) {
284
285         uint16_t eeprom_data;
286         uint32_t eeprom_reg_val = e1000_rr32(E1000_EECD);
287
288         // Request access to the EEPROM, then wait for access
289         eeprom_reg_val = eeprom_reg_val | E1000_EECD_REQ;
290         e1000_wr32(E1000_EECD, eeprom_reg_val);
291         while((e1000_rr32(E1000_EECD) & E1000_EECD_GNT) == 0);
292
293         // We now have access, write what value we want to read, then wait for access
294         eeprom_reg_val = E1000_EERD_START | (offset << E1000_EERD_ADDR_SHIFT);
295         e1000_wr32(E1000_EERD, eeprom_reg_val);
296         while(((eeprom_reg_val = e1000_rr32(E1000_EERD)) & E1000_EERD_DONE) == 0);
297         eeprom_data = (eeprom_reg_val & E1000_EERD_DATA_MASK) >> E1000_EERD_DATA_SHIFT;
298         
299         // Read the value (finally)
300         eeprom_reg_val = e1000_rr32(E1000_EECD);
301
302         // Tell the EEPROM we are done.
303         e1000_wr32(E1000_EECD, eeprom_reg_val & ~E1000_EECD_REQ);
304
305         return eeprom_data;
306
307 }
308
309 // Discover and record the MAC address for this device.
310 void e1000_setup_mac() {
311
312         uint16_t eeprom_data = 0;
313         uint32_t mmio_data = 0;
314
315         /* TODO: WARNING - EXTREMELY GHETTO */
316         e1000_debug("-->Setting up MAC addr\n");
317
318         // Quark: For ID0 type, we read from the EEPROm. Else we read from RAL/RAH.
319         if (device_id == INTEL_82540EM_ID) {
320
321                 // This is ungodly slow. Like, person perceivable time slow.
322                 for (int i = 0; i < 3; i++) {
323
324                         eeprom_data = e1000_read_eeprom(i);
325                         device_mac[2*i] = eeprom_data & 0x00FF;
326                         device_mac[2*i + 1] = (eeprom_data & 0xFF00) >> 8;
327
328                 }
329
330         } else {
331                 
332                 // Get the data from RAL
333                 mmio_data = e1000_rr32(E1000_RAL);
334
335                 // Do the big magic rain dance
336                 device_mac[0] = mmio_data & 0xFF;
337                 device_mac[1] = (mmio_data >> 8) & 0xFF;
338                 device_mac[2] = (mmio_data >> 16) & 0xFF;
339                 device_mac[3] = (mmio_data >> 24) & 0xFF;
340
341                 // Get the rest of the MAC data from RAH.
342                 mmio_data = e1000_rr32(E1000_RAH);
343                 
344                 // Continue magic dance.
345                 device_mac[4] = mmio_data & 0xFF;
346                 device_mac[5] = (mmio_data >> 8) & 0xFF;
347         }
348
349         // Check if we need to invert the higher order bits (some E1000's)
350         // Got this behavior from Barrelfish.
351         // It's worth noting that if MMIO is screwed up, this is generally
352         // the first warning sign.
353         mmio_data = e1000_rr32(E1000_STATUS);
354         if (mmio_data & E1000_STATUS_FUNC_MASK) {
355                 printk("UNTESTED LANB FUNCTIONALITY! MAY BE BREAKING MAC\n");
356                 device_mac[5] ^= 0x0100;
357         }       
358
359         // Program the device to use this mac (really only needed for ID0 type)
360         e1000_wr32(E1000_RAH, 0x00000); // Set MAC invalid
361         e1000_wr32(E1000_RAL, *(uint32_t*)device_mac);
362         e1000_wr32(E1000_RAH, *(uint16_t*)(device_mac + 4) | 0x80000000);
363         
364         // Now make sure it read back out.
365         // This is done to make sure everything is working correctly with the NIC
366         mmio_data = e1000_rr32(E1000_RAL);
367         device_mac[0] = mmio_data & 0xFF;
368         device_mac[1] = (mmio_data >> 8) & 0xFF;
369         device_mac[2] = (mmio_data >> 16) & 0xFF;
370         device_mac[3] = (mmio_data >> 24) & 0xFF;
371         mmio_data = e1000_rr32(E1000_RAH);
372         device_mac[4] = mmio_data & 0xFF;
373         device_mac[5] = (mmio_data >> 8) & 0xFF;
374
375         // Clear the MAC's from all the other filters
376         // Must clear high to low.
377         // TODO: Get the right number of filters. Not sure how.
378         //       however they SHOULD all default to all 0's, so
379         //       this shouldnt be needed.
380         for (int i = 1; i < 16; i++) {
381                 e1000_wr32(E1000_RAH + 8 * i, 0x0);
382                 e1000_wr32(E1000_RAL + 8 * i, 0x0);
383         }
384
385
386         // Clear MTA Table
387         // TODO: Get the right number of filters. See above.
388         for (int i = 0; i < 0x7F; i++) {
389                 e1000_wr32(E1000_MTA + 4 * i, 0x0);
390         }
391
392         e1000_debug("-->DEVICE MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
393                     0xFF & device_mac[0], 0xFF & device_mac[1],
394                     0xFF & device_mac[2], 0xFF & device_mac[3],
395                     0xFF & device_mac[4], 0xFF & device_mac[5]);
396         return;
397 }
398
399 // Allocate and configure all the transmit and receive descriptors.
400 void e1000_setup_descriptors() {
401
402         e1000_debug("-->Setting up tx/rx descriptors.\n");
403
404         // Allocate room for the buffers. 
405         // Must be 16 byte aligned
406
407         // How many pages do we need?
408   uint32_t num_rx_pages = ROUNDUP(NUM_RX_DESCRIPTORS * sizeof(struct e1000_rx_desc), PGSIZE) / PGSIZE;
409   uint32_t num_tx_pages = ROUNDUP(NUM_TX_DESCRIPTORS * sizeof(struct e1000_tx_desc), PGSIZE) / PGSIZE;
410         
411         // Get the pages
412         rx_des_kva = get_cont_pages(LOG2_UP(num_rx_pages), 0);
413         tx_des_kva = get_cont_pages(LOG2_UP(num_tx_pages), 0);
414
415         // +1 point for checking malloc result
416         if (rx_des_kva == NULL) panic("Can't allocate page for RX Ring");
417         if (tx_des_kva == NULL) panic("Can't allocate page for TX Ring");
418         
419         // Get the phys addr
420         rx_des_pa = PADDR(rx_des_kva);
421         tx_des_pa = PADDR(tx_des_kva);
422         
423         // Configure each descriptor.
424         for (int i = 0; i < NUM_RX_DESCRIPTORS; i++) 
425                 e1000_set_rx_descriptor(i, TRUE); // True == Allocate memory for the descriptor
426                 
427         for (int i = 0; i < NUM_TX_DESCRIPTORS; i++) 
428                 e1000_set_tx_descriptor(i);
429
430         return;
431 }
432
433 // Configure a specific RX descriptor.
434 // Serves as a reset, too (with reset_buffer set to FALSE).
435 void e1000_set_rx_descriptor(uint32_t des_num, uint8_t reset_buffer) {
436         
437         //memset(&rx_des_kva[des_num], 0x00, sizeof(struct e1000_rx_desc));
438         rx_des_kva[des_num].length = 0;
439         rx_des_kva[des_num].csum = 0;
440         rx_des_kva[des_num].status = 0;
441         rx_des_kva[des_num].errors = 0;
442         rx_des_kva[des_num].special = 0;
443         
444         // Check if we are allocating a buffer.
445         // Note: setting this to TRUE not at boot time results in a memory leak.
446         if (reset_buffer) {
447                 
448                 // Alloc a buffer
449                 char *rx_buffer = kmalloc(E1000_RX_MAX_BUFFER_SIZE, 0);
450                 if (rx_buffer == NULL) panic ("Can't allocate page for RX Buffer");
451                 
452                 // Set the buffer addr
453                 rx_des_kva[des_num].buffer_addr = PADDR(rx_buffer);
454         }
455
456         return;
457 }
458
459 // Configure a specific TX descriptor.
460 // Calling not at boot results in a memory leak.
461 void e1000_set_tx_descriptor(uint32_t des_num) {
462         
463         // Clear the bits.
464         memset(&tx_des_kva[des_num], 0x00, sizeof(struct e1000_tx_desc));
465         
466         // Alloc space for the buffer
467         char *tx_buffer = kmalloc(E1000_TX_MAX_BUFFER_SIZE, 0);
468         if (tx_buffer == NULL) panic ("Can't allocate page for TX Buffer");
469
470         // Set it.
471         tx_des_kva[des_num].buffer_addr = PADDR(tx_buffer);
472         return;
473 }
474
475 /* Actually configure the device.
476  * This goes through the painstaking process of actually configuring the device
477  * and preparing it for use. After this function, the device is turned on
478  * in a good and functioning state (except interrupts are off).
479  *
480  * I give a brief description of what each bit of code does, but
481  * the details of the bits are in most cases from the spec sheet
482  * and exact details are a bit obfuscated. 
483  *
484  * This startup sequence is taken with love from BarrelFish.
485  * <3 the multikernel.
486  */
487 void e1000_configure() {
488         
489         uint32_t data;
490
491         e1000_debug("-->Configuring Device.\n");
492         
493         // Clear Interrupts
494         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
495         E1000_WRITE_FLUSH();
496
497         // Disable receiver and transmitter
498         e1000_wr32(E1000_RCTL, 0x00);
499         e1000_wr32(E1000_TCTL, 0x00);
500
501         // Reset the device
502         e1000_reset();  
503
504         // Clear interrupts
505         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
506
507         // Fix PHY_RESET
508         data = e1000_rr32(E1000_CTRL);
509         data = data & ~E1000_CTRL_PHY_RST;
510         e1000_wr32(E1000_CTRL, data);
511         data = e1000_rr32(E1000_STATUS);
512         data = data & ~E1000_STATUS_MTXCKOK; // XXX: Against spec
513         e1000_wr32(E1000_STATUS, data);
514
515         // Link MAC and PHY
516         data = e1000_rr32(E1000_CTRL);
517         data = data & E1000_CTRL_SLU;
518         e1000_wr32(E1000_CTRL, data);
519
520         // Set PHY mode
521         data = e1000_rr32(E1000_CTRL_EXT);
522         data = (data & ~E1000_CTRL_EXT_LINK_MODE_MASK) | E1000_CTRL_EXT_LINK_MODE_GMII;
523         e1000_wr32(E1000_CTRL_EXT, data);
524
525         // Set full-duplex
526         data = e1000_rr32(E1000_CTRL);
527         data = data & E1000_CTRL_FD;
528         e1000_wr32(E1000_CTRL, data);
529
530         // Set CTRL speed (from STATUS speed)
531         {
532                 data = e1000_rr32(E1000_CTRL);
533                 uint32_t status = e1000_rr32(E1000_STATUS);
534                 status = (status & E1000_STATUS_SPEED_MASK) >> 6;
535                 data = (data & ~E1000_CTRL_SPD_SEL) | (status << 8);
536                 e1000_wr32(E1000_CTRL, data);
537         }
538
539         // Turn off flow control
540         e1000_wr32(E1000_FCAL, 0x00);
541         e1000_wr32(E1000_FCAH, 0x00);
542         e1000_wr32(E1000_FCT,  0x00);
543
544         // Setup MAC address
545         e1000_setup_mac();      
546
547         // Set RX Ring
548         e1000_wr32(E1000_RDBAL, rx_des_pa);
549         e1000_wr32(E1000_RDBAH, 0x00);
550
551         // Set RX Ring Size
552         // Size in bytes.
553         e1000_wr32(E1000_RDLEN, (NUM_RX_DESCRIPTORS / 8) << 7);
554        
555         // Disablie the split and replication control queue 
556         e1000_wr32(E1000_SRRCTRL, 0x00);
557
558         // Set head and tail pointers.
559         e1000_wr32(E1000_RDH, 0x00);
560         e1000_wr32(E1000_RDT, 0x00);
561
562         // Receive descriptor control
563         e1000_wr32(E1000_RXDCTL, E1000_RXDCTL_ENABLE | E1000_RXDCTL_WBT | E1000_RXDCTL_MAGIC);
564
565         // Disable packet splitting.
566         data = e1000_rr32(E1000_RFCTL);
567         data = data & ~E1000_RFCTL_EXTEN;
568         e1000_wr32(E1000_RFCTL, data);
569
570         // Enable packet reception
571         data = e1000_rr32(E1000_RCTL);
572         data = data | E1000_RCTL_EN | E1000_RCTL_BAM;
573         e1000_wr32(E1000_RCTL, data);
574
575         // Bump the tail pointer. This MUST be done at this point 
576         // _AFTER_ packet receiption is enabled. See 85276 spec sheet.
577         e1000_wr32(E1000_RDT, NUM_RX_DESCRIPTORS - 1);
578
579         // Set TX Ring
580         e1000_wr32(E1000_TDBAL, tx_des_pa);
581         e1000_wr32(E1000_TDBAH, 0x00);
582
583         // Set TX Des Size.
584         // This is the number of 8 descriptor sets, it starts at the 7th bit.
585         e1000_wr32(E1000_TDLEN, ((NUM_TX_DESCRIPTORS / 8) << 7));
586
587         // Transmit inter packet gap register
588         // XXX: Recomended magic. See 13.4.34
589         e1000_wr32(E1000_TIPG, 0x00702008);
590
591         // Set head and tail pointers.
592         e1000_wr32(E1000_TDH, 0x00);
593         e1000_wr32(E1000_TDT, 0x00);
594
595         // Tansmit desc control
596         e1000_wr32(E1000_TXDCTL, E1000_TXDCTL_MAGIC | E1000_TXDCTL_ENABLE);
597
598         // Enable transmit
599         // Enable + pad short packets + Back off time + Collision thresh
600         // The 0x0F000 is the back off time, and 0x0010 is the collision thresh.
601         e1000_wr32(E1000_TCTL, E1000_TCTL_EN | E1000_TCTL_PSP | 0x0F010);
602
603         return;
604 }
605
606 // Reset the device.
607 void e1000_reset() {
608         e1000_debug("-->Resetting device..... ");
609
610         e1000_wr32(E1000_CTRL, e1000_rr32(E1000_CTRL) | E1000_CTRL_RST);
611
612         e1000_debug(" done.\n");
613
614         return;
615 }
616
617 void e1000_irq_enable() {
618         printk("e1000 enabled\n");
619         e1000_wr32(E1000_IMS, IMS_ENABLE_MASK);
620         E1000_WRITE_FLUSH();
621 }
622
623 // Configure and enable interrupts
624 void e1000_setup_interrupts() {
625         
626         extern handler_t interrupt_handlers[];
627         
628         e1000_debug("-->Setting interrupts.\n");
629         
630         // Set throttle register
631         e1000_wr32(E1000_ITR, 0x0000);
632         
633         // Clear interrupts
634         e1000_wr32(E1000_IMS, 0xFFFFFFFF);
635         e1000_wr32(E1000_IMC, E1000_IMC_ALL);
636         
637         // Set interrupts
638         e1000_irq_enable();
639
640         // Kernel based interrupt stuff
641         register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + e1000_irq, e1000_interrupt_handler, 0);
642
643         // Enable irqs for the e1000
644         // TODO: figure out where the interrupts are actually going..
645 #ifdef CONFIG_ENABLE_MPTABLES
646         /* TODO: this should be for any IOAPIC EOI, not just MPTABLES */
647         ioapic_route_irq(e1000_irq, E1000_IRQ_CPU);     
648         printk("ioapic rout\n");
649
650 #else 
651         // This will route the interrupts automatically to CORE 0
652         // Call send_kernel_message if you want to route them somewhere else
653         pic_unmask_irq(e1000_irq);
654         unmask_lapic_lvt(LAPIC_LVT_LINT0);
655         enable_irq();
656         printk("picroute\n");
657 #endif
658
659         return;
660 }
661
662 // Code that is executed when an interrupt comes in on IRQ e1000_irq
663 void e1000_interrupt_handler(struct hw_trapframe *hw_tf, void *data)
664 {
665         e1000_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
666
667         // Read the offending interrupt(s)
668         // Note: Reading clears the interrupts
669         uint32_t icr = e1000_rr32(E1000_ICR);
670
671         
672         /* Interrupt did not come from our card.., handle one interrupt per isr */
673         if (!icr) return; 
674         /* disable interrupts, this may not be necessary as AUTOMASK of interrupts
675          * is enabled on some cards
676          * but we do it anyways to be safe..
677          */
678         e1000_wr32(E1000_IMC, ~0);
679         E1000_WRITE_FLUSH();
680
681         //printk("Interrupt status: %x\n", icr);
682
683         if ((icr & E1000_ICR_INT_ASSERTED) && (icr & E1000_ICR_RXT0)){
684                 e1000_interrupt_debug("---->Packet Received\n");
685 #ifdef CONFIG_SOCKET
686 //#if 0
687                 e1000_clean_rx_irq();
688                 // e1000_recv_pbuf(); // really it is now performing the function of rx_clean
689 #else
690                 e1000_handle_rx_packet();
691 #endif
692         }       
693         e1000_irq_enable();
694 }
695
696 void process_pbuf(uint32_t srcid, long a0, long a1, long a2)
697 {
698         if (srcid != core_id())
699                 warn("pbuf came from a different core\n");
700         /* assume it is an ip packet */
701         struct pbuf* pb = (struct pbuf*) a0;
702         //printk("processing pbuf \n");
703         /*TODO: check checksum and drop */
704         /*check packet type*/
705         struct ethernet_hdr *ethhdr = (struct ethernet_hdr *) pb->payload;
706         //printk("start of eth %p \n", pb->payload);
707         //print_pbuf(pb);
708         if (memcmp(ethhdr->dst_mac, device_mac, 6)){
709                 e1000_debug("mac address do not match, pbuf freed \n");
710                 pbuf_free(pb);
711         }
712         switch(htons(ethhdr->eth_type)){
713                 case ETHTYPE_IP:
714                         if (!pbuf_header(pb, -(ETH_HDR_SZ)))
715                                 ip_input(pb);
716                         else
717                                 warn("moving ethernet header in pbuf failed..\n");
718                         break;
719                 case ETHTYPE_ARP:
720                         break;
721                 default:
722                         //warn("packet type unknown");
723                         pbuf_free(pb);
724         }
725 }
726
727 static void schedule_pb(struct pbuf* pb) {
728         /* routine kernel message is kind of heavy weight, because it records src/dst etc */
729         /* TODO: consider a core-local chain of pbufs */
730         // using core 3 for network stuff..XXX
731         send_kernel_message(3, (amr_t) process_pbuf, (long)pb, 0, 0, KMSG_ROUTINE);
732         // send_kernel_message(core_id(), (amr_t) process_pbuf, (long)pb, 0, 0, KMSG_ROUTINE);
733         return;
734 }
735 // Check to see if a packet arrived, and process the packet.
736 void e1000_handle_rx_packet() {
737         
738         uint16_t packet_size;
739         uint32_t status;
740         // find rx descriptor head
741         uint32_t head = e1000_rr32(E1000_RDH);
742
743         //printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
744         //printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
745         
746         // If the HEAD is where we last processed, no new packets.
747         if (head == e1000_rx_index) {
748                 e1000_frame_debug("-->Nothing to process. Returning.");
749                 return;
750         }
751         
752         // Set our current descriptor to where we last left off.
753         uint32_t rx_des_loop_cur = e1000_rx_index;
754         uint32_t frame_size = 0;
755         uint32_t fragment_size = 0;
756         uint32_t num_frags = 0;
757         
758         // Grab a buffer for this packet.
759         char *rx_buffer = kmalloc(MAX_FRAME_SIZE, 0);
760         if (rx_buffer == NULL) panic ("Can't allocate page for incoming packet.");
761         
762         
763         do {
764                 // Get the descriptor status
765                 status = rx_des_kva[rx_des_loop_cur].status;
766
767                 // If the status is 0x00, it means we are somehow trying to process 
768                 //  a packet that hasnt been written by the NIC yet.
769                 if (status == 0x0) {
770                         warn("ERROR: E1000: Packet owned by hardware has 0 status value\n");
771                         /* It's possible we are processing a packet that is a fragment
772                          * before the entire packet arrives.  The code currently assumes
773                          * that all of the packets fragments are there, so it assumes the
774                          * next one is ready.  We'll spin until it shows up...  This could
775                          * deadlock, and sucks in general, but will help us diagnose the
776                          * driver's issues.  TODO: determine root cause and fix this shit.*/
777                         while(rx_des_kva[rx_des_loop_cur].status == 0x0)
778                                 cpu_relax();
779                         status = rx_des_kva[rx_des_loop_cur].status;
780                 }
781         
782                 // See how big this fragment? is.
783                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
784                 
785                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
786                 // Panic or clear all descriptors? This is a nic hardware error. 
787                 if (num_frags && (rx_des_loop_cur == head)) {
788                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
789                         panic("RX Descriptor Ring out of sync.");
790                 }
791                 
792                 // Denote that we have at least 1 fragment.
793                 num_frags++;
794                 
795                 // Make sure ownership is correct. Packet owned by the NIC (ready for kernel reading)
796                 //  is denoted by a 1. Packet owned by the kernel (ready for NIC use) is denoted by 0.
797                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
798                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
799                         panic("RX Descriptor Ring OWN out of sync");
800                 }
801                 
802                 // Deal with packets too large
803                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
804                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
805                         panic("NIC Sent packets larger than configured.");
806                 }
807                 
808                 // Move the fragment data into the buffer
809                 memcpy(rx_buffer + frame_size, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
810                 
811                 // Reset the descriptor. Reuse current buffer (False means don't realloc).
812                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
813                 
814                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 2048 of them.
815                 // This can not overflow the uint32_t we allocated for frame size, so
816                 // we dont need to worry about mallocing too little then overflowing when we read.
817                 frame_size = frame_size + fragment_size;
818                 
819                 // Advance to the next descriptor
820                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
821
822         } while ((status & E1000_RXD_STAT_EOP) == 0); // Check to see if we are at the final fragment
823
824
825 #ifdef CONFIG_APPSERVER
826         // Treat as a syscall frontend response packet if eth_type says so
827         // Will eventually go away, so not too worried about elegance here...
828         uint16_t eth_type = htons(*(uint16_t*)(rx_buffer + 12));
829         if(eth_type == APPSERVER_ETH_TYPE) {
830                 handle_appserver_packet(rx_buffer, frame_size);
831                 kfree(rx_buffer);
832
833                 // Advance the tail pointer                             
834                 e1000_rx_index = rx_des_loop_cur;
835                 e1000_wr32(E1000_RDT, e1000_rx_index);
836                 return;
837         }
838 #endif
839
840 #ifdef CONFIG_ETH_AUDIO
841         /* TODO: move this, and all packet processing, out of this driver (including
842          * the ghetto buffer).  Note we don't handle IP fragment reassembly (though
843          * this isn't an issue for the eth_audio). */
844         struct ethaud_udp_packet *packet = (struct ethaud_udp_packet*)rx_buffer;
845         uint8_t protocol = packet->ip_hdr.protocol;
846         uint16_t udp_port = ntohs(packet->udp_hdr.dst_port);
847         if (protocol == IPPROTO_UDP && udp_port == ETH_AUDIO_RCV_PORT) {
848                 eth_audio_newpacket(packet);
849                 // Advance the tail pointer                             
850                 e1000_rx_index = rx_des_loop_cur;
851                 e1000_wr32(E1000_RDT, e1000_rx_index);
852                 return;
853         }
854 #endif /* CONFIG_ETH_AUDIO */
855
856         // Paul:Mildly hacky stuff for LWIP
857         // TODO: Why was this necessary for LWIP?
858         spin_lock(&packet_buffers_lock);
859
860         if (num_packet_buffers >= MAX_PACKET_BUFFERS) {
861                 printd("WARNING: DROPPING PACKET!\n");
862                 spin_unlock(&packet_buffers_lock);
863                 kfree(rx_buffer);
864         
865                 // Advance the tail pointer                             
866                 e1000_rx_index = rx_des_loop_cur;
867         e1000_wr32(E1000_RDT, (e1000_rx_index -1) % NUM_RX_DESCRIPTORS);
868                 return;
869         }
870
871         packet_buffers[packet_buffers_tail] = rx_buffer;
872         packet_buffers_sizes[packet_buffers_tail] = frame_size;
873                 
874         packet_buffers_tail = (packet_buffers_tail + 1) % MAX_PACKET_BUFFERS;
875         num_packet_buffers++;
876
877         spin_unlock(&packet_buffers_lock);
878         // End mildy hacky stuff for LWIP
879
880         //Log where we should start reading from next time we trap                              
881         e1000_rx_index = rx_des_loop_cur;
882         
883         // Bump the tail pointer. It should be 1 behind where we start reading from.
884         e1000_wr32(E1000_RDT, (e1000_rx_index -1) % NUM_RX_DESCRIPTORS);
885         dumppacket((unsigned char *)rx_buffer, frame_size);
886                                 
887         // Chew on the frame data. Command bits should be the same for all frags.
888         //e1000_process_frame(rx_buffer, frame_size, current_command);
889         
890         return;
891 }
892
893 static void e1000_clean_rx_irq() {
894         // e1000_rx_index is the last one that we have processed
895         uint32_t i= e1000_rx_index;
896         // E1000 RDH is the last descriptor written by the hardware
897         uint32_t head = e1000_rr32(E1000_RDH);
898         uint32_t length = 0;
899         struct e1000_rx_desc *rx_desc =  &(E1000_RX_DESC(i));
900
901         // what happens when i go around the ring? 
902         while (rx_desc->status & E1000_RXD_STAT_DD){
903                 struct pbuf* pb;
904                 uint8_t status;
905                 rx_desc = &rx_des_kva[i];
906                 // buffer_info = &rx_des_kva[i];
907                 status = rx_desc->status;
908                 pb = pbuf_alloc(PBUF_RAW, 0 , PBUF_MTU);
909 #if ETH_PAD_SIZE
910                 pbuf_header(pb, -ETH_PAD_SIZE); /* drop the padding word */
911 #endif
912                 // fragment size
913                 length = le16_to_cpu(rx_desc->length);
914
915                 length -= 4;
916
917                 memcpy(pb->payload, KADDR(E1000_RX_DESC(i).buffer_addr), length);
918                 // skb_put(skb, length);
919                 pb->len = length;
920                 pb->tot_len = length;
921                 schedule_pb(pb);
922                 // do all the error handling 
923 next_desc:
924                 // this replaces e1000_set_rx_descriptor
925                 rx_desc->status = 0;
926                 if (++i == NUM_RX_DESCRIPTORS) i = 0;
927                 rx_desc = &(E1000_RX_DESC(i)); 
928         }
929         //setting e1000_RDH?
930                 printk ("cleaned index %d to %d \n", e1000_rx_index, i-1);
931                 e1000_rx_index = i;
932 }
933
934 struct pbuf* e1000_recv_pbuf(void) {
935         uint16_t packet_size;
936         uint32_t status;
937         // recv head
938         uint32_t head = e1000_rr32(E1000_RDH);
939
940         printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
941         printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
942         // e1000_rx_index = cleaned
943         // If the HEAD is where we last processed, no new packets.
944         if (head == e1000_rx_index) {
945                 e1000_frame_debug("-->Nothing to process. Returning.");
946                 return NULL;
947         }
948         // Set our current descriptor to where we last left off.
949         uint32_t rx_des_loop_cur = e1000_rx_index;
950         uint32_t frame_size = 0;
951         uint32_t fragment_size = 0;
952         uint32_t num_frags = 0;
953
954         uint32_t top_fragment = rx_des_loop_cur; 
955         struct pbuf* pb = pbuf_alloc(PBUF_RAW, 0, PBUF_MTU);
956         if (!pb){
957                 warn("pbuf allocation failed, packet dropped\n");
958                 return NULL;
959         }
960
961         uint32_t copied = 0;
962 #if ETH_PAD_SIZE
963         pbuf_header(pb, -ETH_PAD_SIZE); /* drop the padding word */
964 #endif
965         // pblen is way too big? it is not an indication of the size but the allocation
966         printk("pb loc %p , pb len %d \n", pb, pb->len);
967         void* rx_buffer = pb->payload;
968
969         /* The following loop generates 1 and only 1 pbuf out of 1(likely) 
970          * or more fragments. 
971          * TODO: convert this loop to clean rx irq style which is capable of 
972          * handling multiple packet / pbuf receptions
973          */
974
975         do {
976                 // Get the descriptor status
977                 status = rx_des_kva[rx_des_loop_cur].status;
978
979                 // If the status is 0x00, it means we are somehow trying to process 
980                 // a packet that hasnt been written by the NIC yet.
981                 if (status & E1000_RXD_STAT_DD) {
982                         warn("ERROR: E1000: Packet owned by hardware has 0 status value\n");
983                         /* It's possible we are processing a packet that is a fragment
984                          * before the entire packet arrives.  The code currently assumes
985                          * that all of the packets fragments are there, so it assumes the
986                          * next one is ready.  We'll spin until it shows up...  This could
987                          * deadlock, and sucks in general, but will help us diagnose the
988                          * driver's issues.  TODO: determine root cause and fix this shit.*/
989                         while(rx_des_kva[rx_des_loop_cur].status == 0x0)
990                                 cpu_relax();
991                         status = rx_des_kva[rx_des_loop_cur].status;
992                 }
993                 printk ("got out of the dead loop \n");
994         
995                 // See how big this fragment is.
996                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
997                 printk("fragment size %d\n",fragment_size);
998                 
999                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
1000                 // Panic or clear all descriptors? This is a nic hardware error. 
1001                 if (num_frags && (rx_des_loop_cur == head)) {
1002                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
1003                         panic("RX Descriptor Ring out of sync.");
1004                 }
1005                 // Denote that we have at least 1 fragment.
1006                 num_frags++;
1007                 if (num_frags > 1) warn ("we have fragments in the network \n");
1008                 // Make sure ownership is correct. Packet owned by the NIC (ready for kernel reading)
1009                 // is denoted by a 1. Packet owned by the kernel (ready for NIC use) is denoted by 0.
1010                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
1011                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
1012                         warn("RX Descriptor Ring OWN out of sync");
1013                 }
1014                 
1015                 // Deal with packets too large
1016                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
1017                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
1018                         warn("NIC Sent packets larger than configured.");
1019                 }
1020                 
1021                 memcpy(rx_buffer, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
1022                 copied += fragment_size;
1023                 printk("fragment size %d \n", fragment_size);
1024                 rx_buffer += fragment_size;
1025                 
1026
1027                 // Copy into pbuf allocated for this     
1028                 // TODO: reuse the pbuf later
1029                 // TODO:real driver uses a pbuf allocated (MTU sized) per descriptor and recycles that
1030                 // TODO:real driver also does not handle fragments.. simply drops them
1031
1032                 // Reset the descriptor. Reuse current buffer (False means don't realloc).
1033                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
1034                 
1035                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 2048 of them.
1036                 // This can not overflow the uint32_t we allocated for frame size, so
1037                 // we dont need to worry about mallocing too little then overflowing when we read.
1038                 frame_size = frame_size + fragment_size;
1039                 
1040                 /*Advance to the next descriptor*/
1041                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
1042
1043         } while ((status & E1000_RXD_STAT_EOP) == 0); // Check to see if we are at the final fragment
1044
1045         // rx_des_loop_cur has gone past the top_fragment
1046         // printk("Copied %d bytes of data \n", copied);
1047         // ethernet crc performed in hardware
1048         copied -= 4;
1049
1050         pb->len = copied;
1051         pb->tot_len = copied;
1052         schedule_pb(pb);
1053         return pb;
1054 }
1055
1056 #if 0
1057
1058 int e1000_clean_rx(){
1059         struct net_device *netdev = adapter->netdev;
1060         struct pci_dev *pdev = adapter->pdev;
1061         struct e1000_rx_desc *rx_desc, *next_rxd;
1062         struct e1000_buffer *buffer_info, *next_buffer;
1063         unsigned long flags;
1064         uint32_t length;
1065         uint8_t last_byte;
1066         unsigned int i;
1067         int cleaned_count = 0;
1068         boolean_t cleaned = FALSE;
1069         unsigned int total_rx_bytes=0, total_rx_packets=0;
1070
1071         i = rx_ring->next_to_clean;
1072         // rx_desc is the same as rx_des_kva[rx_des_loop_cur]
1073         rx_desc = E1000_RX_DESC(*rx_ring, i);
1074         buffer_info = &rx_ring->buffer_info[i];
1075
1076         while (rx_desc->status & E1000_RXD_STAT_DD) {
1077                 struct sk_buff *skb;
1078                 u8 status;
1079
1080 #ifdef CONFIG_E1000_NAPI
1081                 if (*work_done >= work_to_do)
1082                         break;
1083                 (*work_done)++;
1084 #endif
1085                 status = rx_desc->status;
1086                 skb = buffer_info->skb;
1087                 buffer_info->skb = NULL;
1088
1089                 prefetch(skb->data - NET_IP_ALIGN);
1090
1091                 if (++i == rx_ring->count) i = 0;
1092                 next_rxd = E1000_RX_DESC(*rx_ring, i);
1093                 prefetch(next_rxd);
1094
1095                 next_buffer = &rx_ring->buffer_info[i];
1096
1097                 cleaned = TRUE;
1098                 cleaned_count++;
1099                 pci_unmap_single(pdev,
1100                                  buffer_info->dma,
1101                                  buffer_info->length,
1102                                  PCI_DMA_FROMDEVICE);
1103
1104                 length = le16_to_cpu(rx_desc->length);
1105
1106                 if (unlikely(!(status & E1000_RXD_STAT_EOP))) {
1107                         /* All receives must fit into a single buffer */
1108                         E1000_DBG("%s: Receive packet consumed multiple"
1109                                   " buffers\n", netdev->name);
1110                         /* recycle */
1111                         buffer_info->skb = skb;
1112                         goto next_desc;
1113                 }
1114
1115                 if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
1116                         last_byte = *(skb->data + length - 1);
1117                         if (TBI_ACCEPT(&adapter->hw, status,
1118                                       rx_desc->errors, length, last_byte)) {
1119                                 spin_lock_irqsave(&adapter->stats_lock, flags);
1120                                 e1000_tbi_adjust_stats(&adapter->hw,
1121                                                        &adapter->stats,
1122                                                        length, skb->data);
1123                                 spin_unlock_irqrestore(&adapter->stats_lock,
1124                                                        flags);
1125                                 length--;
1126                         } else {
1127                                 /* recycle */
1128                                 buffer_info->skb = skb;
1129                                 goto next_desc;
1130                         }
1131                 }
1132
1133                 /* adjust length to remove Ethernet CRC, this must be
1134                  * done after the TBI_ACCEPT workaround above */
1135                 length -= 4;
1136
1137                 /* probably a little skewed due to removing CRC */
1138                 total_rx_bytes += length;
1139                 total_rx_packets++;
1140
1141                 /* code added for copybreak, this should improve
1142                  * performance for small packets with large amounts
1143                  * of reassembly being done in the stack */
1144                 if (length < copybreak) {
1145                         struct sk_buff *new_skb =
1146                             netdev_alloc_skb(netdev, length + NET_IP_ALIGN);
1147                         if (new_skb) {
1148                                 skb_reserve(new_skb, NET_IP_ALIGN);
1149                                 memcpy(new_skb->data - NET_IP_ALIGN,
1150                                        skb->data - NET_IP_ALIGN,
1151                                        length + NET_IP_ALIGN);
1152                                 /* save the skb in buffer_info as good */
1153                                 buffer_info->skb = skb;
1154                                 skb = new_skb;
1155                         }
1156                         /* else just continue with the old one */
1157                 }
1158                 /* end copybreak code */
1159                 skb_put(skb, length);
1160
1161                 /* Receive Checksum Offload */
1162                 e1000_rx_checksum(adapter,
1163                                   (uint32_t)(status) |
1164                                   ((uint32_t)(rx_desc->errors) << 24),
1165                                   le16_to_cpu(rx_desc->csum), skb);
1166
1167                 skb->protocol = eth_type_trans(skb, netdev);
1168 #ifdef CONFIG_E1000_NAPI
1169                 if (unlikely(adapter->vlgrp &&
1170                             (status & E1000_RXD_STAT_VP))) {
1171                         vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
1172                                                  le16_to_cpu(rx_desc->special) &
1173                                                  E1000_RXD_SPC_VLAN_MASK);
1174                 } else {
1175                         netif_receive_skb(skb);
1176                 }
1177 #else /* CONFIG_E1000_NAPI */
1178                 if (unlikely(adapter->vlgrp &&
1179                             (status & E1000_RXD_STAT_VP))) {
1180                         vlan_hwaccel_rx(skb, adapter->vlgrp,
1181                                         le16_to_cpu(rx_desc->special) &
1182                                         E1000_RXD_SPC_VLAN_MASK);
1183                 } else {
1184                         netif_rx(skb);
1185                 }
1186 #endif /* CONFIG_E1000_NAPI */
1187                 netdev->last_rx = jiffies;
1188
1189 next_desc:
1190                 rx_desc->status = 0;
1191
1192                 /* return some buffers to hardware, one at a time is too slow */
1193                 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
1194                         adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
1195                         cleaned_count = 0;
1196                 }
1197
1198                 /* use prefetched values */
1199                 rx_desc = next_rxd;
1200                 buffer_info = next_buffer;
1201         }
1202         rx_ring->next_to_clean = i;
1203
1204         cleaned_count = E1000_DESC_UNUSED(rx_ring);
1205         if (cleaned_count)
1206                 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
1207
1208         adapter->total_rx_packets += total_rx_packets;
1209         adapter->total_rx_bytes += total_rx_bytes;
1210         return cleaned;
1211 }
1212 }
1213
1214 #endif
1215
1216 int e1000_send_pbuf(struct pbuf *p) {
1217         int len = p->tot_len;
1218         // print_pbuf(p);
1219         if (p == NULL) 
1220                 return -1;
1221         if (len == 0)
1222                 return 0;
1223         
1224         // Find where we want to write
1225         uint32_t head = e1000_rr32(E1000_TDH);
1226
1227         
1228         // Fail if we are out of space
1229         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
1230                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
1231                 return -1;
1232         }
1233         
1234         // Fail if we are too large
1235         if (len > MAX_FRAME_SIZE) {
1236                 e1000_frame_debug("-->Frame Too Large!\n");
1237                 return -1;
1238         }
1239         
1240         // Move the data
1241         int cplen = pbuf_copy_out(p, KADDR(tx_des_kva[e1000_tx_index].buffer_addr), len, 0);
1242
1243         for(int i = 0; i< cplen; i++){
1244                 printd("%x", ((uint8_t*)KADDR(tx_des_kva[e1000_tx_index].buffer_addr))[i]);
1245         }
1246         // Set the length
1247         tx_des_kva[e1000_tx_index].lower.flags.length = len;
1248         
1249         // Magic that means send 1 fragment and report.
1250         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
1251
1252         // Track our location
1253         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
1254         
1255         // Bump the tail.
1256         e1000_wr32(E1000_TDT, e1000_tx_index);
1257
1258         e1000_frame_debug("-->Sent packet.\n");
1259         
1260         return len;
1261 }
1262 // Main routine to send a frame. Just sends it and goes.
1263 // Card supports sending across multiple fragments, we don't.
1264 // Would we want to write a function that takes a larger packet and generates fragments?
1265 // This seems like the stacks responsibility. Leave this for now. may in future
1266 // Remove the max size cap and generate multiple packets.
1267 int e1000_send_frame(const char *data, size_t len) {
1268
1269         if (data == NULL)
1270                 return -1;
1271         if (len == 0)
1272                 return 0;
1273
1274         // Find where we want to write
1275         uint32_t head = e1000_rr32(E1000_TDH);
1276
1277         
1278         // Fail if we are out of space
1279         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
1280                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
1281                 return -1;
1282         }
1283         
1284         // Fail if we are too large
1285         if (len > MAX_FRAME_SIZE) {
1286                 e1000_frame_debug("-->Frame Too Large!\n");
1287                 return -1;
1288         }
1289         
1290         // Move the data
1291         memcpy(KADDR(tx_des_kva[e1000_tx_index].buffer_addr), data, len);
1292
1293         // Set the length
1294         tx_des_kva[e1000_tx_index].lower.flags.length = len;
1295         
1296         // Magic that means send 1 fragment and report.
1297         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
1298
1299         // Track our location
1300         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
1301         
1302         // Bump the tail.
1303         e1000_wr32(E1000_TDT, e1000_tx_index);
1304
1305         e1000_frame_debug("-->Sent packet.\n");
1306         
1307 return len;
1308 }