NIC drivers use register_dev_irq()
[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_dev_irq(e1000_irq, e1000_interrupt_handler, 0);
642 }
643
644 // Code that is executed when an interrupt comes in on IRQ e1000_irq
645 void e1000_interrupt_handler(struct hw_trapframe *hw_tf, void *data)
646 {
647         e1000_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
648
649         // Read the offending interrupt(s)
650         // Note: Reading clears the interrupts
651         uint32_t icr = e1000_rr32(E1000_ICR);
652
653         
654         /* Interrupt did not come from our card.., handle one interrupt per isr */
655         if (!icr) return; 
656         /* disable interrupts, this may not be necessary as AUTOMASK of interrupts
657          * is enabled on some cards
658          * but we do it anyways to be safe..
659          */
660         e1000_wr32(E1000_IMC, ~0);
661         E1000_WRITE_FLUSH();
662
663         //printk("Interrupt status: %x\n", icr);
664
665         if ((icr & E1000_ICR_INT_ASSERTED) && (icr & E1000_ICR_RXT0)){
666                 e1000_interrupt_debug("---->Packet Received\n");
667 #ifdef CONFIG_SOCKET
668 //#if 0
669                 e1000_clean_rx_irq();
670                 // e1000_recv_pbuf(); // really it is now performing the function of rx_clean
671 #else
672                 e1000_handle_rx_packet();
673 #endif
674         }       
675         e1000_irq_enable();
676 }
677
678 void process_pbuf(uint32_t srcid, long a0, long a1, long a2)
679 {
680         if (srcid != core_id())
681                 warn("pbuf came from a different core\n");
682         /* assume it is an ip packet */
683         struct pbuf* pb = (struct pbuf*) a0;
684         //printk("processing pbuf \n");
685         /*TODO: check checksum and drop */
686         /*check packet type*/
687         struct ethernet_hdr *ethhdr = (struct ethernet_hdr *) pb->payload;
688         //printk("start of eth %p \n", pb->payload);
689         //print_pbuf(pb);
690         if (memcmp(ethhdr->dst_mac, device_mac, 6)){
691                 e1000_debug("mac address do not match, pbuf freed \n");
692                 pbuf_free(pb);
693         }
694         switch(htons(ethhdr->eth_type)){
695                 case ETHTYPE_IP:
696                         if (!pbuf_header(pb, -(ETH_HDR_SZ)))
697                                 ip_input(pb);
698                         else
699                                 warn("moving ethernet header in pbuf failed..\n");
700                         break;
701                 case ETHTYPE_ARP:
702                         break;
703                 default:
704                         //warn("packet type unknown");
705                         pbuf_free(pb);
706         }
707 }
708
709 static void schedule_pb(struct pbuf* pb) {
710         /* routine kernel message is kind of heavy weight, because it records src/dst etc */
711         /* TODO: consider a core-local chain of pbufs */
712         // using core 3 for network stuff..XXX
713         send_kernel_message(3, (amr_t) process_pbuf, (long)pb, 0, 0, KMSG_ROUTINE);
714         // send_kernel_message(core_id(), (amr_t) process_pbuf, (long)pb, 0, 0, KMSG_ROUTINE);
715         return;
716 }
717 // Check to see if a packet arrived, and process the packet.
718 void e1000_handle_rx_packet() {
719         
720         uint16_t packet_size;
721         uint32_t status;
722         // find rx descriptor head
723         uint32_t head = e1000_rr32(E1000_RDH);
724
725         //printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
726         //printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
727         
728         // If the HEAD is where we last processed, no new packets.
729         if (head == e1000_rx_index) {
730                 e1000_frame_debug("-->Nothing to process. Returning.");
731                 return;
732         }
733         
734         // Set our current descriptor to where we last left off.
735         uint32_t rx_des_loop_cur = e1000_rx_index;
736         uint32_t frame_size = 0;
737         uint32_t fragment_size = 0;
738         uint32_t num_frags = 0;
739         
740         // Grab a buffer for this packet.
741         char *rx_buffer = kmalloc(MAX_FRAME_SIZE, 0);
742         if (rx_buffer == NULL) panic ("Can't allocate page for incoming packet.");
743         
744         
745         do {
746                 // Get the descriptor status
747                 status = rx_des_kva[rx_des_loop_cur].status;
748
749                 // If the status is 0x00, it means we are somehow trying to process 
750                 //  a packet that hasnt been written by the NIC yet.
751                 if (status == 0x0) {
752                         warn("ERROR: E1000: Packet owned by hardware has 0 status value\n");
753                         /* It's possible we are processing a packet that is a fragment
754                          * before the entire packet arrives.  The code currently assumes
755                          * that all of the packets fragments are there, so it assumes the
756                          * next one is ready.  We'll spin until it shows up...  This could
757                          * deadlock, and sucks in general, but will help us diagnose the
758                          * driver's issues.  TODO: determine root cause and fix this shit.*/
759                         while(rx_des_kva[rx_des_loop_cur].status == 0x0)
760                                 cpu_relax();
761                         status = rx_des_kva[rx_des_loop_cur].status;
762                 }
763         
764                 // See how big this fragment? is.
765                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
766                 
767                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
768                 // Panic or clear all descriptors? This is a nic hardware error. 
769                 if (num_frags && (rx_des_loop_cur == head)) {
770                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
771                         panic("RX Descriptor Ring out of sync.");
772                 }
773                 
774                 // Denote that we have at least 1 fragment.
775                 num_frags++;
776                 
777                 // Make sure ownership is correct. Packet owned by the NIC (ready for kernel reading)
778                 //  is denoted by a 1. Packet owned by the kernel (ready for NIC use) is denoted by 0.
779                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
780                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
781                         panic("RX Descriptor Ring OWN out of sync");
782                 }
783                 
784                 // Deal with packets too large
785                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
786                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
787                         panic("NIC Sent packets larger than configured.");
788                 }
789                 
790                 // Move the fragment data into the buffer
791                 memcpy(rx_buffer + frame_size, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
792                 
793                 // Reset the descriptor. Reuse current buffer (False means don't realloc).
794                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
795                 
796                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 2048 of them.
797                 // This can not overflow the uint32_t we allocated for frame size, so
798                 // we dont need to worry about mallocing too little then overflowing when we read.
799                 frame_size = frame_size + fragment_size;
800                 
801                 // Advance to the next descriptor
802                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
803
804         } while ((status & E1000_RXD_STAT_EOP) == 0); // Check to see if we are at the final fragment
805
806
807 #ifdef CONFIG_APPSERVER
808         // Treat as a syscall frontend response packet if eth_type says so
809         // Will eventually go away, so not too worried about elegance here...
810         uint16_t eth_type = htons(*(uint16_t*)(rx_buffer + 12));
811         if(eth_type == APPSERVER_ETH_TYPE) {
812                 handle_appserver_packet(rx_buffer, frame_size);
813                 kfree(rx_buffer);
814
815                 // Advance the tail pointer                             
816                 e1000_rx_index = rx_des_loop_cur;
817                 e1000_wr32(E1000_RDT, e1000_rx_index);
818                 return;
819         }
820 #endif
821
822 #ifdef CONFIG_ETH_AUDIO
823         /* TODO: move this, and all packet processing, out of this driver (including
824          * the ghetto buffer).  Note we don't handle IP fragment reassembly (though
825          * this isn't an issue for the eth_audio). */
826         struct ethaud_udp_packet *packet = (struct ethaud_udp_packet*)rx_buffer;
827         uint8_t protocol = packet->ip_hdr.protocol;
828         uint16_t udp_port = ntohs(packet->udp_hdr.dst_port);
829         if (protocol == IPPROTO_UDP && udp_port == ETH_AUDIO_RCV_PORT) {
830                 eth_audio_newpacket(packet);
831                 // Advance the tail pointer                             
832                 e1000_rx_index = rx_des_loop_cur;
833                 e1000_wr32(E1000_RDT, e1000_rx_index);
834                 return;
835         }
836 #endif /* CONFIG_ETH_AUDIO */
837
838         // Paul:Mildly hacky stuff for LWIP
839         // TODO: Why was this necessary for LWIP?
840         spin_lock(&packet_buffers_lock);
841
842         if (num_packet_buffers >= MAX_PACKET_BUFFERS) {
843                 printd("WARNING: DROPPING PACKET!\n");
844                 spin_unlock(&packet_buffers_lock);
845                 kfree(rx_buffer);
846         
847                 // Advance the tail pointer                             
848                 e1000_rx_index = rx_des_loop_cur;
849         e1000_wr32(E1000_RDT, (e1000_rx_index -1) % NUM_RX_DESCRIPTORS);
850                 return;
851         }
852
853         packet_buffers[packet_buffers_tail] = rx_buffer;
854         packet_buffers_sizes[packet_buffers_tail] = frame_size;
855                 
856         packet_buffers_tail = (packet_buffers_tail + 1) % MAX_PACKET_BUFFERS;
857         num_packet_buffers++;
858
859         spin_unlock(&packet_buffers_lock);
860         // End mildy hacky stuff for LWIP
861
862         //Log where we should start reading from next time we trap                              
863         e1000_rx_index = rx_des_loop_cur;
864         
865         // Bump the tail pointer. It should be 1 behind where we start reading from.
866         e1000_wr32(E1000_RDT, (e1000_rx_index -1) % NUM_RX_DESCRIPTORS);
867         dumppacket((unsigned char *)rx_buffer, frame_size);
868                                 
869         // Chew on the frame data. Command bits should be the same for all frags.
870         //e1000_process_frame(rx_buffer, frame_size, current_command);
871         
872         return;
873 }
874
875 static void e1000_clean_rx_irq() {
876         // e1000_rx_index is the last one that we have processed
877         uint32_t i= e1000_rx_index;
878         // E1000 RDH is the last descriptor written by the hardware
879         uint32_t head = e1000_rr32(E1000_RDH);
880         uint32_t length = 0;
881         struct e1000_rx_desc *rx_desc =  &(E1000_RX_DESC(i));
882
883         // what happens when i go around the ring? 
884         while (rx_desc->status & E1000_RXD_STAT_DD){
885                 struct pbuf* pb;
886                 uint8_t status;
887                 rx_desc = &rx_des_kva[i];
888                 // buffer_info = &rx_des_kva[i];
889                 status = rx_desc->status;
890                 pb = pbuf_alloc(PBUF_RAW, 0 , PBUF_MTU);
891 #if ETH_PAD_SIZE
892                 pbuf_header(pb, -ETH_PAD_SIZE); /* drop the padding word */
893 #endif
894                 // fragment size
895                 length = le16_to_cpu(rx_desc->length);
896
897                 length -= 4;
898
899                 memcpy(pb->payload, KADDR(E1000_RX_DESC(i).buffer_addr), length);
900                 // skb_put(skb, length);
901                 pb->len = length;
902                 pb->tot_len = length;
903                 schedule_pb(pb);
904                 // do all the error handling 
905 next_desc:
906                 // this replaces e1000_set_rx_descriptor
907                 rx_desc->status = 0;
908                 if (++i == NUM_RX_DESCRIPTORS) i = 0;
909                 rx_desc = &(E1000_RX_DESC(i)); 
910         }
911         //setting e1000_RDH?
912                 printk ("cleaned index %d to %d \n", e1000_rx_index, i-1);
913                 e1000_rx_index = i;
914 }
915
916 struct pbuf* e1000_recv_pbuf(void) {
917         uint16_t packet_size;
918         uint32_t status;
919         // recv head
920         uint32_t head = e1000_rr32(E1000_RDH);
921
922         printk("Current head is: %x\n", e1000_rr32(E1000_RDH));
923         printk("Current tail is: %x\n", e1000_rr32(E1000_RDT));
924         // e1000_rx_index = cleaned
925         // If the HEAD is where we last processed, no new packets.
926         if (head == e1000_rx_index) {
927                 e1000_frame_debug("-->Nothing to process. Returning.");
928                 return NULL;
929         }
930         // Set our current descriptor to where we last left off.
931         uint32_t rx_des_loop_cur = e1000_rx_index;
932         uint32_t frame_size = 0;
933         uint32_t fragment_size = 0;
934         uint32_t num_frags = 0;
935
936         uint32_t top_fragment = rx_des_loop_cur; 
937         struct pbuf* pb = pbuf_alloc(PBUF_RAW, 0, PBUF_MTU);
938         if (!pb){
939                 warn("pbuf allocation failed, packet dropped\n");
940                 return NULL;
941         }
942
943         uint32_t copied = 0;
944 #if ETH_PAD_SIZE
945         pbuf_header(pb, -ETH_PAD_SIZE); /* drop the padding word */
946 #endif
947         // pblen is way too big? it is not an indication of the size but the allocation
948         printk("pb loc %p , pb len %d \n", pb, pb->len);
949         void* rx_buffer = pb->payload;
950
951         /* The following loop generates 1 and only 1 pbuf out of 1(likely) 
952          * or more fragments. 
953          * TODO: convert this loop to clean rx irq style which is capable of 
954          * handling multiple packet / pbuf receptions
955          */
956
957         do {
958                 // Get the descriptor status
959                 status = rx_des_kva[rx_des_loop_cur].status;
960
961                 // If the status is 0x00, it means we are somehow trying to process 
962                 // a packet that hasnt been written by the NIC yet.
963                 if (status & E1000_RXD_STAT_DD) {
964                         warn("ERROR: E1000: Packet owned by hardware has 0 status value\n");
965                         /* It's possible we are processing a packet that is a fragment
966                          * before the entire packet arrives.  The code currently assumes
967                          * that all of the packets fragments are there, so it assumes the
968                          * next one is ready.  We'll spin until it shows up...  This could
969                          * deadlock, and sucks in general, but will help us diagnose the
970                          * driver's issues.  TODO: determine root cause and fix this shit.*/
971                         while(rx_des_kva[rx_des_loop_cur].status == 0x0)
972                                 cpu_relax();
973                         status = rx_des_kva[rx_des_loop_cur].status;
974                 }
975                 printk ("got out of the dead loop \n");
976         
977                 // See how big this fragment is.
978                 fragment_size = rx_des_kva[rx_des_loop_cur].length;
979                 printk("fragment size %d\n",fragment_size);
980                 
981                 // If we've looped through the entire ring and not found a terminating packet, bad nic state.
982                 // Panic or clear all descriptors? This is a nic hardware error. 
983                 if (num_frags && (rx_des_loop_cur == head)) {
984                         e1000_frame_debug("-->ERR: No ending segment found in RX buffer.\n");
985                         panic("RX Descriptor Ring out of sync.");
986                 }
987                 // Denote that we have at least 1 fragment.
988                 num_frags++;
989                 if (num_frags > 1) warn ("we have fragments in the network \n");
990                 // Make sure ownership is correct. Packet owned by the NIC (ready for kernel reading)
991                 // is denoted by a 1. Packet owned by the kernel (ready for NIC use) is denoted by 0.
992                 if ((status & E1000_RXD_STAT_DD) == 0x0) {
993                         e1000_frame_debug("-->ERR: Current RX descriptor not owned by software. Panic!");
994                         warn("RX Descriptor Ring OWN out of sync");
995                 }
996                 
997                 // Deal with packets too large
998                 if ((frame_size + fragment_size) > MAX_FRAME_SIZE) {
999                         e1000_frame_debug("-->ERR: Nic sent %u byte packet. Max is %u\n", frame_size, MAX_FRAME_SIZE);
1000                         warn("NIC Sent packets larger than configured.");
1001                 }
1002                 
1003                 memcpy(rx_buffer, KADDR(rx_des_kva[rx_des_loop_cur].buffer_addr), fragment_size);
1004                 copied += fragment_size;
1005                 printk("fragment size %d \n", fragment_size);
1006                 rx_buffer += fragment_size;
1007                 
1008
1009                 // Copy into pbuf allocated for this     
1010                 // TODO: reuse the pbuf later
1011                 // TODO:real driver uses a pbuf allocated (MTU sized) per descriptor and recycles that
1012                 // TODO:real driver also does not handle fragments.. simply drops them
1013
1014                 // Reset the descriptor. Reuse current buffer (False means don't realloc).
1015                 e1000_set_rx_descriptor(rx_des_loop_cur, FALSE);
1016                 
1017                 // Note: We mask out fragment sizes at 0x3FFFF. There can be at most 2048 of them.
1018                 // This can not overflow the uint32_t we allocated for frame size, so
1019                 // we dont need to worry about mallocing too little then overflowing when we read.
1020                 frame_size = frame_size + fragment_size;
1021                 
1022                 /*Advance to the next descriptor*/
1023                 rx_des_loop_cur = (rx_des_loop_cur + 1) % NUM_RX_DESCRIPTORS;
1024
1025         } while ((status & E1000_RXD_STAT_EOP) == 0); // Check to see if we are at the final fragment
1026
1027         // rx_des_loop_cur has gone past the top_fragment
1028         // printk("Copied %d bytes of data \n", copied);
1029         // ethernet crc performed in hardware
1030         copied -= 4;
1031
1032         pb->len = copied;
1033         pb->tot_len = copied;
1034         schedule_pb(pb);
1035         return pb;
1036 }
1037
1038 #if 0
1039
1040 int e1000_clean_rx(){
1041         struct net_device *netdev = adapter->netdev;
1042         struct pci_dev *pdev = adapter->pdev;
1043         struct e1000_rx_desc *rx_desc, *next_rxd;
1044         struct e1000_buffer *buffer_info, *next_buffer;
1045         unsigned long flags;
1046         uint32_t length;
1047         uint8_t last_byte;
1048         unsigned int i;
1049         int cleaned_count = 0;
1050         boolean_t cleaned = FALSE;
1051         unsigned int total_rx_bytes=0, total_rx_packets=0;
1052
1053         i = rx_ring->next_to_clean;
1054         // rx_desc is the same as rx_des_kva[rx_des_loop_cur]
1055         rx_desc = E1000_RX_DESC(*rx_ring, i);
1056         buffer_info = &rx_ring->buffer_info[i];
1057
1058         while (rx_desc->status & E1000_RXD_STAT_DD) {
1059                 struct sk_buff *skb;
1060                 u8 status;
1061
1062 #ifdef CONFIG_E1000_NAPI
1063                 if (*work_done >= work_to_do)
1064                         break;
1065                 (*work_done)++;
1066 #endif
1067                 status = rx_desc->status;
1068                 skb = buffer_info->skb;
1069                 buffer_info->skb = NULL;
1070
1071                 prefetch(skb->data - NET_IP_ALIGN);
1072
1073                 if (++i == rx_ring->count) i = 0;
1074                 next_rxd = E1000_RX_DESC(*rx_ring, i);
1075                 prefetch(next_rxd);
1076
1077                 next_buffer = &rx_ring->buffer_info[i];
1078
1079                 cleaned = TRUE;
1080                 cleaned_count++;
1081                 pci_unmap_single(pdev,
1082                                  buffer_info->dma,
1083                                  buffer_info->length,
1084                                  PCI_DMA_FROMDEVICE);
1085
1086                 length = le16_to_cpu(rx_desc->length);
1087
1088                 if (unlikely(!(status & E1000_RXD_STAT_EOP))) {
1089                         /* All receives must fit into a single buffer */
1090                         E1000_DBG("%s: Receive packet consumed multiple"
1091                                   " buffers\n", netdev->name);
1092                         /* recycle */
1093                         buffer_info->skb = skb;
1094                         goto next_desc;
1095                 }
1096
1097                 if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
1098                         last_byte = *(skb->data + length - 1);
1099                         if (TBI_ACCEPT(&adapter->hw, status,
1100                                       rx_desc->errors, length, last_byte)) {
1101                                 spin_lock_irqsave(&adapter->stats_lock, flags);
1102                                 e1000_tbi_adjust_stats(&adapter->hw,
1103                                                        &adapter->stats,
1104                                                        length, skb->data);
1105                                 spin_unlock_irqrestore(&adapter->stats_lock,
1106                                                        flags);
1107                                 length--;
1108                         } else {
1109                                 /* recycle */
1110                                 buffer_info->skb = skb;
1111                                 goto next_desc;
1112                         }
1113                 }
1114
1115                 /* adjust length to remove Ethernet CRC, this must be
1116                  * done after the TBI_ACCEPT workaround above */
1117                 length -= 4;
1118
1119                 /* probably a little skewed due to removing CRC */
1120                 total_rx_bytes += length;
1121                 total_rx_packets++;
1122
1123                 /* code added for copybreak, this should improve
1124                  * performance for small packets with large amounts
1125                  * of reassembly being done in the stack */
1126                 if (length < copybreak) {
1127                         struct sk_buff *new_skb =
1128                             netdev_alloc_skb(netdev, length + NET_IP_ALIGN);
1129                         if (new_skb) {
1130                                 skb_reserve(new_skb, NET_IP_ALIGN);
1131                                 memcpy(new_skb->data - NET_IP_ALIGN,
1132                                        skb->data - NET_IP_ALIGN,
1133                                        length + NET_IP_ALIGN);
1134                                 /* save the skb in buffer_info as good */
1135                                 buffer_info->skb = skb;
1136                                 skb = new_skb;
1137                         }
1138                         /* else just continue with the old one */
1139                 }
1140                 /* end copybreak code */
1141                 skb_put(skb, length);
1142
1143                 /* Receive Checksum Offload */
1144                 e1000_rx_checksum(adapter,
1145                                   (uint32_t)(status) |
1146                                   ((uint32_t)(rx_desc->errors) << 24),
1147                                   le16_to_cpu(rx_desc->csum), skb);
1148
1149                 skb->protocol = eth_type_trans(skb, netdev);
1150 #ifdef CONFIG_E1000_NAPI
1151                 if (unlikely(adapter->vlgrp &&
1152                             (status & E1000_RXD_STAT_VP))) {
1153                         vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
1154                                                  le16_to_cpu(rx_desc->special) &
1155                                                  E1000_RXD_SPC_VLAN_MASK);
1156                 } else {
1157                         netif_receive_skb(skb);
1158                 }
1159 #else /* CONFIG_E1000_NAPI */
1160                 if (unlikely(adapter->vlgrp &&
1161                             (status & E1000_RXD_STAT_VP))) {
1162                         vlan_hwaccel_rx(skb, adapter->vlgrp,
1163                                         le16_to_cpu(rx_desc->special) &
1164                                         E1000_RXD_SPC_VLAN_MASK);
1165                 } else {
1166                         netif_rx(skb);
1167                 }
1168 #endif /* CONFIG_E1000_NAPI */
1169                 netdev->last_rx = jiffies;
1170
1171 next_desc:
1172                 rx_desc->status = 0;
1173
1174                 /* return some buffers to hardware, one at a time is too slow */
1175                 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
1176                         adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
1177                         cleaned_count = 0;
1178                 }
1179
1180                 /* use prefetched values */
1181                 rx_desc = next_rxd;
1182                 buffer_info = next_buffer;
1183         }
1184         rx_ring->next_to_clean = i;
1185
1186         cleaned_count = E1000_DESC_UNUSED(rx_ring);
1187         if (cleaned_count)
1188                 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
1189
1190         adapter->total_rx_packets += total_rx_packets;
1191         adapter->total_rx_bytes += total_rx_bytes;
1192         return cleaned;
1193 }
1194 }
1195
1196 #endif
1197
1198 int e1000_send_pbuf(struct pbuf *p) {
1199         int len = p->tot_len;
1200         // print_pbuf(p);
1201         if (p == NULL) 
1202                 return -1;
1203         if (len == 0)
1204                 return 0;
1205         
1206         // Find where we want to write
1207         uint32_t head = e1000_rr32(E1000_TDH);
1208
1209         
1210         // Fail if we are out of space
1211         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
1212                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
1213                 return -1;
1214         }
1215         
1216         // Fail if we are too large
1217         if (len > MAX_FRAME_SIZE) {
1218                 e1000_frame_debug("-->Frame Too Large!\n");
1219                 return -1;
1220         }
1221         
1222         // Move the data
1223         int cplen = pbuf_copy_out(p, KADDR(tx_des_kva[e1000_tx_index].buffer_addr), len, 0);
1224
1225         for(int i = 0; i< cplen; i++){
1226                 printd("%x", ((uint8_t*)KADDR(tx_des_kva[e1000_tx_index].buffer_addr))[i]);
1227         }
1228         // Set the length
1229         tx_des_kva[e1000_tx_index].lower.flags.length = len;
1230         
1231         // Magic that means send 1 fragment and report.
1232         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
1233
1234         // Track our location
1235         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
1236         
1237         // Bump the tail.
1238         e1000_wr32(E1000_TDT, e1000_tx_index);
1239
1240         e1000_frame_debug("-->Sent packet.\n");
1241         
1242         return len;
1243 }
1244 // Main routine to send a frame. Just sends it and goes.
1245 // Card supports sending across multiple fragments, we don't.
1246 // Would we want to write a function that takes a larger packet and generates fragments?
1247 // This seems like the stacks responsibility. Leave this for now. may in future
1248 // Remove the max size cap and generate multiple packets.
1249 int e1000_send_frame(const char *data, size_t len) {
1250
1251         if (data == NULL)
1252                 return -1;
1253         if (len == 0)
1254                 return 0;
1255
1256         // Find where we want to write
1257         uint32_t head = e1000_rr32(E1000_TDH);
1258
1259         
1260         // Fail if we are out of space
1261         if (((e1000_tx_index + 1) % NUM_TX_DESCRIPTORS) == head) {
1262                 e1000_frame_debug("-->TX Ring Buffer Full!\n");
1263                 return -1;
1264         }
1265         
1266         // Fail if we are too large
1267         if (len > MAX_FRAME_SIZE) {
1268                 e1000_frame_debug("-->Frame Too Large!\n");
1269                 return -1;
1270         }
1271         
1272         // Move the data
1273         memcpy(KADDR(tx_des_kva[e1000_tx_index].buffer_addr), data, len);
1274
1275         // Set the length
1276         tx_des_kva[e1000_tx_index].lower.flags.length = len;
1277         
1278         // Magic that means send 1 fragment and report.
1279         tx_des_kva[e1000_tx_index].lower.flags.cmd = 0x0B;
1280
1281         // Track our location
1282         e1000_tx_index = (e1000_tx_index + 1) % NUM_TX_DESCRIPTORS;
1283         
1284         // Bump the tail.
1285         e1000_wr32(E1000_TDT, e1000_tx_index);
1286
1287         e1000_frame_debug("-->Sent packet.\n");
1288         
1289 return len;
1290 }