* Is this a toolchain bug?
@ 2002-02-23 1:57 Matthew Dharm
2002-02-24 2:06 ` Daniel Jacobowitz
2002-02-25 18:36 ` Kevin Paul Herbert
0 siblings, 2 replies; 10+ messages in thread
From: Matthew Dharm @ 2002-02-23 1:57 UTC (permalink / raw)
To: Linux-MIPS
[-- Attachment #1: Type: text/plain, Size: 1942 bytes --]
I'm trying to get the e1000 driver working on my MIPS target... I've
managed to hack it a bit so it works, but at least one of these hacks
looks like a workaround for a toolchain bug.
Attached to this message is the mixed-mode (source and assembly) dump
of one of the driver files.
Specifically, look at the code dealing with the variable
e1000_proc_dir; here is one example:
if(e1000_proc_dir == NULL)
53c: 3c020000 lui v0,0x0
540: 8c420000 lw v0,0(v0)
544: 1440000d bnez v0,57c <e1000_probe+0x44c>
548: 00000000 nop
Is it me, or is that wrong? load-upper-immediate with zero, then
load-word from that address? Clearly, v0 is _supposed_ to contain the
value of e1000_proc_dir based on the branch-compare instruction....
but this code just crashes.
In fact, all the references to e1000_proc_dir seem to use the same
lui/lw pair of instructions.
For reference e1000_proc_dir is an extern struct pointer. No compiler
warnings about it.
Before anyone asks, the assembly doesn't change when linked against
the code that actually declares the variable.
The toolchain I'm using is the one from oss.sgi.com by H.J. Liu
(toolchain-20011020-1). Because of the way the e1000 driver Makefile
works, I'm actually compiling it using the native compiler on-target.
Full source code available on request (I don't want to spam the list),
or directly from Intel. I'm using kernel 2.4.17 from CVS (plus the
patch I sent yesterday) with e1000 driver version 4.0.7
If this is user-error, I'd love to know what I'm doing wrong. If this
is a toolchain bug, who do I report this to?
Matt
--
Matthew D. Dharm Senior Software Designer
Momentum Computer Inc. 1815 Aston Ave. Suite 107
(760) 431-8663 X-115 Carlsbad, CA 92008-7310
Momentum Works For You www.momenco.com
[-- Attachment #2: e1000_main.dis --]
[-- Type: application/octet-stream, Size: 423044 bytes --]
e1000_main.o: file format elf32-tradbigmips
Disassembly of section .text:
00000000 <e1000_init_module>:
0: 27bdffe8 addiu sp,sp,-24
4: afb00010 sw s0,16(sp)
8: afbf0014 sw ra,20(sp)
E1000_DBG("e1000_init_module\n");
/* Print the driver ID string and copyright notice */
printk("%s - version %s\n%s\n", e1000_driver_string, e1000_driver_version,
c: 3c040000 lui a0,0x0
10: 24840158 addiu a0,a0,344
14: 3c050000 lui a1,0x0
18: 24a50000 addiu a1,a1,0
1c: 3c060000 lui a2,0x0
20: 24c60000 addiu a2,a2,0
24: 3c070000 lui a3,0x0
28: 24e70000 addiu a3,a3,0
2c: 3c020000 lui v0,0x0
30: 24420000 addiu v0,v0,0
34: 0040f809 jalr v0
38: 00000000 nop
* This MUST stay in a header, as it checks for -DMODULE
*/
static inline int pci_module_init(struct pci_driver *drv)
{
int rc = pci_register_driver (drv);
3c: 3c040000 lui a0,0x0
40: 24840288 addiu a0,a0,648
44: 3c020000 lui v0,0x0
48: 24420000 addiu v0,v0,0
4c: 0040f809 jalr v0
50: 00000000 nop
54: 00408021 move s0,v0
if (rc > 0)
return 0;
/* iff CONFIG_HOTPLUG and built into kernel, we should
* leave the driver around for future hotplug events.
* For the module case, a hotplug daemon of some sort
* should load a module in response to an insert event. */
#if defined(CONFIG_HOTPLUG) && !defined(MODULE)
if (rc == 0)
return 0;
#else
if (rc == 0)
rc = -ENODEV;
#endif
/* if we get here, we need to clean up pci driver instance
* and return some sort of error */
pci_unregister_driver (drv);
58: 3c040000 lui a0,0x0
5c: 24840288 addiu a0,a0,648
60: 3c030000 lui v1,0x0
64: 24630000 addiu v1,v1,0
68: 1e000006 bgtz s0,84 <e1000_init_module+0x84>
6c: 00001021 move v0,zero
70: 52000001 beqzl s0,78 <e1000_init_module+0x78>
74: 2410ffed li s0,-19
78: 0060f809 jalr v1
7c: 00000000 nop
return rc;
80: 02001021 move v0,s0
e1000_copyright);
/* register the driver with the PCI subsystem */
return pci_module_init(&e1000_driver);
84: 8fbf0014 lw ra,20(sp)
88: 8fb00010 lw s0,16(sp)
8c: 03e00008 jr ra
90: 27bd0018 addiu sp,sp,24
00000094 <cleanup_module>:
94: 27bdffe8 addiu sp,sp,-24
}
/* this macro creates a special symbol in the object file that
* identifies the driver initialization routine
*/
module_init(e1000_init_module);
/**
* e1000_exit_module - Driver Exit Cleanup Routine
*
* e1000_exit_module is called just before the driver is removed
* from memory.
**/
void
e1000_exit_module()
{
#ifdef CONFIG_PROC_FS
struct proc_dir_entry *de;
#endif
E1000_DBG("e1000_exit_module\n");
pci_unregister_driver(&e1000_driver);
98: 3c020000 lui v0,0x0
9c: 24420000 addiu v0,v0,0
a0: afbf0010 sw ra,16(sp)
a4: 3c040000 lui a0,0x0
a8: 24840288 addiu a0,a0,648
ac: 0040f809 jalr v0
b0: 00000000 nop
#ifdef CONFIG_PROC_FS
/* if there is no e1000_proc_dir (proc creation failure on load)
* then we're done
*/
if(e1000_proc_dir == NULL)
b4: 3c020000 lui v0,0x0
b8: 8c420000 lw v0,0(v0)
bc: 1040001a beqz v0,128 <cleanup_module+0x94>
c0: 8fbf0010 lw ra,16(sp)
return;
/* If ADAPTERS_PROC_DIR (/proc/net/PRO_LAN_Adapters) is empty
* it can be removed now (might still be in use by e100)
*/
for(de = e1000_proc_dir->subdir; de; de = de->next) {
c4: 8c450034 lw a1,52(v0)
c8: 10a0000e beqz a1,104 <cleanup_module+0x70>
cc: 2404002e li a0,46
/* ignore . and .. */
if(*(de->name) == '.')
d0: 8ca20004 lw v0,4(a1)
d4: 80430000 lb v1,0(v0)
d8: 14640008 bne v1,a0,fc <cleanup_module+0x68>
dc: 00000000 nop
e0: 8ca5002c lw a1,44(a1)
e4: 10a00007 beqz a1,104 <cleanup_module+0x70>
e8: 00000000 nop
ec: 8ca20004 lw v0,4(a1)
f0: 80430000 lb v1,0(v0)
f4: 5064fffb beql v1,a0,e4 <cleanup_module+0x50>
f8: 8ca5002c lw a1,44(a1)
continue;
break;
}
if(de)
fc: 14a0000a bnez a1,128 <cleanup_module+0x94>
100: 8fbf0010 lw ra,16(sp)
return;
remove_proc_entry(ADAPTERS_PROC_DIR, proc_net);
104: 3c050000 lui a1,0x0
108: 8ca50000 lw a1,0(a1)
10c: 3c040000 lui a0,0x0
110: 2484016c addiu a0,a0,364
114: 3c020000 lui v0,0x0
118: 24420000 addiu v0,v0,0
11c: 0040f809 jalr v0
120: 00000000 nop
#endif
return;
}
124: 8fbf0010 lw ra,16(sp)
128: 03e00008 jr ra
12c: 27bd0018 addiu sp,sp,24
00000130 <e1000_probe>:
130: 27bdffd0 addiu sp,sp,-48
134: afb30024 sw s3,36(sp)
138: afb00018 sw s0,24(sp)
13c: afbf0028 sw ra,40(sp)
140: afb20020 sw s2,32(sp)
144: afb1001c sw s1,28(sp)
/* this macro creates a special symbol in the object file that
* identifies the driver cleanup routine
*/
module_exit(e1000_exit_module);
/**
* e1000_probe - Device Initialization Routine
* @pdev: PCI device information struct
* @ent: entry in e1000_pci_table
*
* Returns 0 on success, negative on failure
*
* e1000_probe initializes an adapter identified by a pci_dev
* structure. The OS initialization is handled here, and
* e1000_sw_init and e1000_hw_init are called to handle the driver
* specific software structures and hardware initialization
* respectively.
**/
int
e1000_probe(struct pci_dev *pdev,
const struct pci_device_id *ent)
{
struct net_device *netdev = NULL;
struct e1000_adapter *adapter;
static int cards_found = 0;
#ifdef CONFIG_PROC_FS
int len;
#endif
E1000_DBG("e1000_probe\n");
/* Make sure the PCI device has the proper resources available */
if(pci_enable_device(pdev) != 0) {
148: 3c020000 lui v0,0x0
14c: 24420000 addiu v0,v0,0
150: 00808021 move s0,a0
154: 0040f809 jalr v0
158: 00a09821 move s3,a1
15c: 10400005 beqz v0,174 <e1000_probe+0x44>
160: 00000000 nop
E1000_ERR("pci_enable_device failed\n");
164: 3c040000 lui a0,0x0
168: 24840180 addiu a0,a0,384
return -ENODEV;
16c: 0800006b j 1ac <e1000_probe+0x7c>
170: 00000000 nop
}
/* Make sure we are enabled as a bus mastering device */
pci_set_master(pdev);
174: 3c020000 lui v0,0x0
178: 24420000 addiu v0,v0,0
17c: 0040f809 jalr v0
180: 02002021 move a0,s0
/* Check to see if our PCI addressing needs are supported */
if(pci_set_dma_mask(pdev, E1000_DMA_MASK) < 0) {
184: 24060000 li a2,0
188: 2407ffff li a3,-1
18c: 3c020000 lui v0,0x0
190: 24420000 addiu v0,v0,0
194: 0040f809 jalr v0
198: 02002021 move a0,s0
19c: 04410009 bgez v0,1c4 <e1000_probe+0x94>
1a0: 00002021 move a0,zero
E1000_ERR("PCI DMA not supported by the system\n");
1a4: 3c040000 lui a0,0x0
1a8: 248401a4 addiu a0,a0,420
1ac: 3c020000 lui v0,0x0
1b0: 24420000 addiu v0,v0,0
1b4: 0040f809 jalr v0
1b8: 00000000 nop
return -ENODEV;
1bc: 0800018b j 62c <e1000_probe+0x4fc>
1c0: 2402ffed li v0,-19
}
/* Register a new network interface + allocate
* private data structure (struct e1000_adapter)
*/
netdev = init_etherdev(netdev, sizeof(struct e1000_adapter));
1c4: 3c020000 lui v0,0x0
1c8: 24420000 addiu v0,v0,0
1cc: 0040f809 jalr v0
1d0: 240503b0 li a1,944
1d4: 00409021 move s2,v0
if(netdev == NULL) {
1d8: 56400009 bnezl s2,200 <e1000_probe+0xd0>
1dc: 8e510064 lw s1,100(s2)
E1000_ERR("Unable to allocate net_device struct\n");
1e0: 3c040000 lui a0,0x0
1e4: 248401d4 addiu a0,a0,468
1e8: 3c020000 lui v0,0x0
1ec: 24420000 addiu v0,v0,0
1f0: 0040f809 jalr v0
1f4: 00000000 nop
return -ENOMEM;
1f8: 0800018b j 62c <e1000_probe+0x4fc>
1fc: 2402fff4 li v0,-12
}
/* Calling init_etherdev with sizeof(struct e1000_adapter) allocates
* a single buffer of size net_device + struct e1000_adapter +
* alignment. If this is not done then the struct e1000_adapter needs
* to be allocated and freed separately.
*/
adapter = (struct e1000_adapter *) netdev->priv;
memset(adapter, 0, sizeof(struct e1000_adapter));
200: 00002821 move a1,zero
204: 240603b0 li a2,944
208: 3c020000 lui v0,0x0
20c: 24420000 addiu v0,v0,0
210: 0040f809 jalr v0
214: 02202021 move a0,s1
adapter->netdev = netdev;
adapter->pdev = pdev;
218: ae30014c sw s0,332(s1)
21c: ae320148 sw s2,328(s1)
/* link the struct e1000_adapter into the list */
if(e1000_adapter_list != NULL)
220: 3c020000 lui v0,0x0
224: 8c420000 lw v0,0(v0)
228: 50400005 beqzl v0,240 <e1000_probe+0x110>
22c: ae220000 sw v0,0(s1)
e1000_adapter_list->prev = adapter;
230: ac510004 sw s1,4(v0)
234: 3c020000 lui v0,0x0
238: 8c420000 lw v0,0(v0)
adapter->next = e1000_adapter_list;
23c: ae220000 sw v0,0(s1)
e1000_adapter_list = adapter;
240: 3c010000 lui at,0x0
244: ac310000 sw s1,0(at)
adapter->shared.back = (void *) adapter;
248: ae310014 sw s1,20(s1)
/* reserve the MMIO region as ours */
if(!request_mem_region
24c: 8e030064 lw v1,100(s0)
250: 14600005 bnez v1,268 <e1000_probe+0x138>
254: 8e020068 lw v0,104(s0)
258: 10400005 beqz v0,270 <e1000_probe+0x140>
25c: 00003021 move a2,zero
260: 0800009b j 26c <e1000_probe+0x13c>
264: 00431023 subu v0,v0,v1
268: 00431023 subu v0,v0,v1
26c: 24460001 addiu a2,v0,1
270: 3c070000 lui a3,0x0
274: 24e70000 addiu a3,a3,0
278: 3c040000 lui a0,0x0
27c: 24840000 addiu a0,a0,0
280: 3c020000 lui v0,0x0
284: 24420000 addiu v0,v0,0
288: 0040f809 jalr v0
28c: 8e050064 lw a1,100(s0)
290: 54400009 bnezl v0,2b8 <e1000_probe+0x188>
294: 8e040064 lw a0,100(s0)
(pci_resource_start(pdev, BAR_0), pci_resource_len(pdev, BAR_0),
e1000_driver_name)) {
E1000_ERR("request_mem_region failed\n");
298: 3c040000 lui a0,0x0
29c: 24840204 addiu a0,a0,516
2a0: 3c020000 lui v0,0x0
2a4: 24420000 addiu v0,v0,0
2a8: 0040f809 jalr v0
2ac: 00000000 nop
e1000_remove(pdev);
return -ENODEV;
2b0: 08000121 j 484 <e1000_probe+0x354>
2b4: 00000000 nop
}
/* map the MMIO region into the kernel virtual address space */
adapter->shared.hw_addr =
2b8: 14800005 bnez a0,2d0 <e1000_probe+0x1a0>
2bc: 8e020068 lw v0,104(s0)
2c0: 10400005 beqz v0,2d8 <e1000_probe+0x1a8>
2c4: 00002821 move a1,zero
2c8: 080000b5 j 2d4 <e1000_probe+0x1a4>
2cc: 00441023 subu v0,v0,a0
2d0: 00441023 subu v0,v0,a0
2d4: 24450001 addiu a1,v0,1
extern void * __ioremap(phys_t offset, phys_t size, unsigned long flags);
static inline void *ioremap(phys_t offset, unsigned long size)
{
return __ioremap(offset, size, _CACHE_UNCACHED);
2d8: 3c020000 lui v0,0x0
2dc: 24420000 addiu v0,v0,0
2e0: 0040f809 jalr v0
2e4: 24060400 li a2,1024
ioremap(pci_resource_start(pdev, BAR_0), pci_resource_len(pdev, BAR_0));
if(adapter->shared.hw_addr == NULL) {
2e8: 1440001c bnez v0,35c <e1000_probe+0x22c>
2ec: ae220008 sw v0,8(s1)
E1000_ERR("ioremap failed\n");
2f0: 3c040000 lui a0,0x0
2f4: 2484022c addiu a0,a0,556
2f8: 3c020000 lui v0,0x0
2fc: 24420000 addiu v0,v0,0
300: 0040f809 jalr v0
304: 00000000 nop
release_mem_region(pci_resource_start(pdev, BAR_0),
308: 8e030064 lw v1,100(s0)
30c: 14600005 bnez v1,324 <e1000_probe+0x1f4>
310: 8e020068 lw v0,104(s0)
314: 10400005 beqz v0,32c <e1000_probe+0x1fc>
318: 00003021 move a2,zero
31c: 080000ca j 328 <e1000_probe+0x1f8>
320: 00431023 subu v0,v0,v1
324: 00431023 subu v0,v0,v1
328: 24460001 addiu a2,v0,1
32c: 3c040000 lui a0,0x0
330: 24840000 addiu a0,a0,0
334: 3c020000 lui v0,0x0
338: 24420000 addiu v0,v0,0
33c: 0040f809 jalr v0
340: 8e050064 lw a1,100(s0)
pci_resource_len(pdev, BAR_0));
e1000_remove(pdev);
344: 3c020000 lui v0,0x0
348: 24420000 addiu v0,v0,0
34c: 0040f809 jalr v0
350: 02002021 move a0,s0
return -ENOMEM;
354: 0800018b j 62c <e1000_probe+0x4fc>
358: 2402fff4 li v0,-12
}
/* don't actually register the interrupt handler until e1000_open */
netdev->irq = pdev->irq;
35c: 8e02005c lw v0,92(s0)
360: ae420024 sw v0,36(s2)
/* Set the MMIO base address for the NIC */
#ifdef IANS
netdev->base_addr = pci_resource_start(pdev, BAR_0);
#endif
netdev->mem_start = pci_resource_start(pdev, BAR_0);
364: 8e030064 lw v1,100(s0)
368: ae43001c sw v1,28(s2)
netdev->mem_end = netdev->mem_start + pci_resource_len(pdev, BAR_0);
36c: 8e040064 lw a0,100(s0)
370: 14800005 bnez a0,388 <e1000_probe+0x258>
374: 8e020068 lw v0,104(s0)
378: 10400006 beqz v0,394 <e1000_probe+0x264>
37c: 00605021 move t2,v1
380: 080000e3 j 38c <e1000_probe+0x25c>
384: 00441023 subu v0,v0,a0
388: 00441023 subu v0,v0,a0
38c: 00621021 addu v0,v1,v0
390: 244a0001 addiu t2,v0,1
/* set up function pointers to driver entry points */
netdev->open = &e1000_open;
netdev->stop = &e1000_close;
netdev->hard_start_xmit = &e1000_xmit_frame;
netdev->get_stats = &e1000_get_stats;
netdev->set_multicast_list = &e1000_set_multi;
netdev->set_mac_address = &e1000_set_mac;
394: 3c070000 lui a3,0x0
398: 24e70000 addiu a3,a3,0
netdev->change_mtu = &e1000_change_mtu;
39c: 3c080000 lui t0,0x0
3a0: 25080000 addiu t0,t0,0
netdev->do_ioctl = &e1000_ioctl;
3a4: 3c090000 lui t1,0x0
3a8: 25290000 addiu t1,t1,0
3ac: 3c020000 lui v0,0x0
3b0: 24420000 addiu v0,v0,0
3b4: 3c030000 lui v1,0x0
3b8: 24630000 addiu v1,v1,0
3bc: 3c040000 lui a0,0x0
3c0: 24840000 addiu a0,a0,0
3c4: 3c050000 lui a1,0x0
3c8: 24a50000 addiu a1,a1,0
3cc: 3c060000 lui a2,0x0
3d0: 24c60000 addiu a2,a2,0
3d4: ae4a0018 sw t2,24(s2)
3d8: ae470108 sw a3,264(s2)
3dc: ae48011c sw t0,284(s2)
3e0: ae49010c sw t1,268(s2)
3e4: ae4400f8 sw a0,248(s2)
3e8: ae450044 sw a1,68(s2)
3ec: ae4200f0 sw v0,240(s2)
3f0: ae4300f4 sw v1,244(s2)
3f4: ae460104 sw a2,260(s2)
/* set up the struct e1000_adapter */
adapter->bd_number = cards_found;
3f8: 3c020000 lui v0,0x0
3fc: 8c42043c lw v0,1084(v0)
adapter->id_string = e1000_strings[ent->driver_data];
printk("\n%s\n", adapter->id_string);
400: 3c040000 lui a0,0x0
404: 24840248 addiu a0,a0,584
408: ae220090 sw v0,144(s1)
40c: 8e630018 lw v1,24(s3)
410: 3c020000 lui v0,0x0
414: 24420000 addiu v0,v0,0
418: 00031880 sll v1,v1,0x2
41c: 3c060000 lui a2,0x0
420: 00c33021 addu a2,a2,v1
424: 8cc6027c lw a2,636(a2)
428: 00c02821 move a1,a2
42c: 0040f809 jalr v0
430: ae2601ac sw a2,428(s1)
/* Order is important here. e1000_sw_init also identifies the
* hardware, so that e1000_check_options can treat command line parameters
* differently depending on the hardware.
*/
e1000_sw_init(adapter);
434: 3c020000 lui v0,0x0
438: 244215a0 addiu v0,v0,5536
43c: 0040f809 jalr v0
440: 02202021 move a0,s1
e1000_check_options(adapter);
444: 3c030000 lui v1,0x0
448: 24630794 addiu v1,v1,1940
44c: 0060f809 jalr v1
450: 02202021 move a0,s1
#ifdef MAX_SKB_FRAGS
if(adapter->shared.mac_type >= e1000_82543) {
454: 8e22000c lw v0,12(s1)
458: 2c420002 sltiu v0,v0,2
45c: 54400002 bnezl v0,468 <e1000_probe+0x338>
460: 24020021 li v0,33
netdev->features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_HIGHDMA;
} else {
464: 24020023 li v0,35
netdev->features = NETIF_F_SG | NETIF_F_HIGHDMA;
468: ae4200e4 sw v0,228(s2)
}
#endif
#ifdef IANS
adapter->iANSdata = kmalloc(sizeof(iANSsupport_t), GFP_KERNEL);
if(adapter->iANSdata == NULL) {
e1000_remove(pdev);
return -ENOMEM;
}
memset(adapter->iANSdata, 0, sizeof(iANSsupport_t));
bd_ans_drv_InitANS(adapter, adapter->iANSdata);
#endif
/* finally, we get around to setting up the hardware */
if(e1000_hw_init(adapter) < 0) {
46c: 3c020000 lui v0,0x0
470: 244217c4 addiu v0,v0,6084
474: 0040f809 jalr v0
478: 02202021 move a0,s1
47c: 04430007 bgezl v0,49c <e1000_probe+0x36c>
480: 26300008 addiu s0,s1,8
e1000_remove(pdev);
484: 3c020000 lui v0,0x0
488: 24420000 addiu v0,v0,0
48c: 0040f809 jalr v0
490: 02002021 move a0,s0
return -ENODEV;
494: 0800018b j 62c <e1000_probe+0x4fc>
498: 2402ffed li v0,-19
}
cards_found++;
49c: 3c020000 lui v0,0x0
4a0: 8c42043c lw v0,1084(v0)
4a4: 24420001 addiu v0,v0,1
/* reset stats */
e1000_clear_hw_cntrs(&adapter->shared);
4a8: 3c030000 lui v1,0x0
4ac: 24630000 addiu v1,v1,0
4b0: 3c010000 lui at,0x0
4b4: ac22043c sw v0,1084(at)
4b8: 0060f809 jalr v1
4bc: 02002021 move a0,s0
e1000_phy_get_info(&adapter->shared, &adapter->phy_info);
4c0: 02002021 move a0,s0
4c4: 3c020000 lui v0,0x0
4c8: 24420000 addiu v0,v0,0
4cc: 0040f809 jalr v0
4d0: 262501b8 addiu a1,s1,440
#ifdef CONFIG_PROC_FS
/* set up the proc fs entry */
len = strlen(ADAPTERS_PROC_DIR);
for(e1000_proc_dir = proc_net->subdir; e1000_proc_dir;
4d4: 3c030000 lui v1,0x0
4d8: 8c630000 lw v1,0(v1)
4dc: 24130010 li s3,16
4e0: 3c100000 lui s0,0x0
4e4: 26100000 addiu s0,s0,0
4e8: 0800013f j 4fc <e1000_probe+0x3cc>
4ec: 8c620034 lw v0,52(v1)
e1000_proc_dir = e1000_proc_dir->next) {
4f0: 3c040000 lui a0,0x0
4f4: 8c840000 lw a0,0(a0)
4f8: 8c82002c lw v0,44(a0)
4fc: 3c010000 lui at,0x0
500: ac220000 sw v0,0(at)
504: 3c030000 lui v1,0x0
508: 8c630000 lw v1,0(v1)
if((e1000_proc_dir->namelen == len) &&
50c: 3c050000 lui a1,0x0
510: 24a5016c addiu a1,a1,364
514: 24060010 li a2,16
518: 1060000c beqz v1,54c <e1000_probe+0x41c>
51c: 00602021 move a0,v1
520: 94620002 lhu v0,2(v1)
524: 5453fff5 bnel v0,s3,4fc <e1000_probe+0x3cc>
528: 8c82002c lw v0,44(a0)
52c: 0200f809 jalr s0
530: 8c640004 lw a0,4(v1)
534: 1440ffee bnez v0,4f0 <e1000_probe+0x3c0>
538: 00000000 nop
(memcmp(e1000_proc_dir->name, ADAPTERS_PROC_DIR, len) == 0))
break;
}
if(e1000_proc_dir == NULL)
53c: 3c020000 lui v0,0x0
540: 8c420000 lw v0,0(v0)
544: 1440000d bnez v0,57c <e1000_probe+0x44c>
548: 00000000 nop
e1000_proc_dir =
54c: 3c060000 lui a2,0x0
550: 8cc60000 lw a2,0(a2)
554: 3c040000 lui a0,0x0
558: 2484016c addiu a0,a0,364
55c: 3c020000 lui v0,0x0
560: 24420000 addiu v0,v0,0
564: 0040f809 jalr v0
568: 24054000 li a1,16384
56c: 3c010000 lui at,0x0
570: ac220000 sw v0,0(at)
create_proc_entry(ADAPTERS_PROC_DIR, S_IFDIR, proc_net);
if(e1000_proc_dir != NULL)
574: 5040000c beqzl v0,5a8 <e1000_probe+0x478>
578: 8e2300b0 lw v1,176(s1)
if(e1000_create_proc_dev(adapter) < 0) {
57c: 3c020000 lui v0,0x0
580: 24420000 addiu v0,v0,0
584: 0040f809 jalr v0
588: 02202021 move a0,s1
58c: 04430006 bgezl v0,5a8 <e1000_probe+0x478>
590: 8e2300b0 lw v1,176(s1)
e1000_remove_proc_dev(adapter->netdev);
594: 3c020000 lui v0,0x0
598: 24420000 addiu v0,v0,0
59c: 0040f809 jalr v0
5a0: 8e240148 lw a0,328(s1)
}
#endif
/* print the link status */
if(adapter->link_active == 1)
5a4: 8e2300b0 lw v1,176(s1)
5a8: 24020001 li v0,1
5ac: 14620017 bne v1,v0,60c <e1000_probe+0x4dc>
5b0: 02402821 move a1,s2
printk("%s: Mem:0x%p IRQ:%d Speed:%d Mbps Duplex:%s\n",
5b4: 962200b4 lhu v0,180(s1)
5b8: 24040002 li a0,2
5bc: afa20010 sw v0,16(sp)
5c0: 962300b6 lhu v1,182(s1)
5c4: 14640005 bne v1,a0,5dc <e1000_probe+0x4ac>
5c8: 00000000 nop
5cc: 3c020000 lui v0,0x0
5d0: 24420284 addiu v0,v0,644
5d4: 0800017a j 5e8 <e1000_probe+0x4b8>
5d8: afa20014 sw v0,20(sp)
5dc: 3c020000 lui v0,0x0
5e0: 2442028c addiu v0,v0,652
5e4: afa20014 sw v0,20(sp)
5e8: 8ca6001c lw a2,28(a1)
5ec: 3c040000 lui a0,0x0
5f0: 24840250 addiu a0,a0,592
5f4: 3c020000 lui v0,0x0
5f8: 24420000 addiu v0,v0,0
5fc: 0040f809 jalr v0
600: 8ca70024 lw a3,36(a1)
604: 0800018b j 62c <e1000_probe+0x4fc>
608: 00001021 move v0,zero
netdev->name, (void *) netdev->mem_start, netdev->irq,
adapter->link_speed,
adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half");
else
printk("%s: Mem:0x%p IRQ:%d Speed:N/A Duplex:N/A\n", netdev->name,
60c: 8ca6001c lw a2,28(a1)
610: 3c040000 lui a0,0x0
614: 24840294 addiu a0,a0,660
618: 3c020000 lui v0,0x0
61c: 24420000 addiu v0,v0,0
620: 0040f809 jalr v0
624: 8ca70024 lw a3,36(a1)
(void *) netdev->mem_start, netdev->irq);
return 0;
628: 00001021 move v0,zero
}
62c: 8fbf0028 lw ra,40(sp)
630: 8fb30024 lw s3,36(sp)
634: 8fb20020 lw s2,32(sp)
638: 8fb1001c lw s1,28(sp)
63c: 8fb00018 lw s0,24(sp)
640: 03e00008 jr ra
644: 27bd0030 addiu sp,sp,48
00000648 <e1000_remove>:
648: 27bdffd8 addiu sp,sp,-40
64c: afb00010 sw s0,16(sp)
/**
* e1000_remove - Device Removal Routine
* @pdev: PCI device information struct
*
* e1000_remove is called by the PCI subsystem to alert the driver
* that it should release a PCI device. The could be caused by a
* Hot-Plug event, or because the driver is going to be removed from
* memory.
*
* This routine is also called to clean up from a failure in
* e1000_probe. The Adapter struct and netdev will always exist,
* all other pointers must be checked for NULL before freeing.
**/
void
e1000_remove(struct pci_dev *pdev)
{
struct net_device *netdev;
struct e1000_adapter *adapter;
/* find the Adapter struct that matches this PCI device */
for(adapter = e1000_adapter_list; adapter != NULL; adapter = adapter->next) {
650: 3c100000 lui s0,0x0
654: 8e100000 lw s0,0(s0)
658: afb10014 sw s1,20(sp)
65c: afbf0020 sw ra,32(sp)
660: afb3001c sw s3,28(sp)
664: afb20018 sw s2,24(sp)
if(adapter->pdev == pdev)
668: 00808821 move s1,a0
66c: 12000043 beqz s0,77c <e1000_remove+0x134>
670: 8fbf0020 lw ra,32(sp)
674: 8e02014c lw v0,332(s0)
678: 5451fffc bnel v0,s1,66c <e1000_remove+0x24>
67c: 8e100000 lw s0,0(s0)
break;
}
if(adapter == NULL)
680: 1200003e beqz s0,77c <e1000_remove+0x134>
684: 26120008 addiu s2,s0,8
return;
netdev = adapter->netdev;
688: 8e130148 lw s3,328(s0)
/* this must be called before freeing anything,
* otherwise there is a case where the open entry point can be
* running at the same time as remove. Calling unregister_netdev on an
* open interface results in a call to dev_close, which locks
* properly against the other netdev entry points, so this takes
* care of the hotplug issue of removing an active interface as well.
*/
unregister_netdev(netdev);
68c: 3c020000 lui v0,0x0
690: 24420000 addiu v0,v0,0
694: 0040f809 jalr v0
698: 02602021 move a0,s3
e1000_phy_hw_reset(&adapter->shared);
69c: 3c020000 lui v0,0x0
6a0: 24420000 addiu v0,v0,0
6a4: 0040f809 jalr v0
6a8: 02402021 move a0,s2
#ifdef CONFIG_PROC_FS
/* remove the proc nodes */
if(e1000_proc_dir != NULL)
6ac: 3c030000 lui v1,0x0
6b0: 8c630000 lw v1,0(v1)
6b4: 10600005 beqz v1,6cc <e1000_remove+0x84>
6b8: 00000000 nop
e1000_remove_proc_dev(adapter->netdev);
6bc: 3c020000 lui v0,0x0
6c0: 24420000 addiu v0,v0,0
6c4: 0040f809 jalr v0
6c8: 8e040148 lw a0,328(s0)
#endif
/* remove from the adapter list */
if(e1000_adapter_list == adapter)
6cc: 3c020000 lui v0,0x0
6d0: 8c420000 lw v0,0(v0)
6d4: 54500005 bnel v0,s0,6ec <e1000_remove+0xa4>
6d8: 8e030000 lw v1,0(s0)
e1000_adapter_list = adapter->next;
6dc: 8e020000 lw v0,0(s0)
6e0: 3c010000 lui at,0x0
6e4: ac220000 sw v0,0(at)
if(adapter->next != NULL)
6e8: 8e030000 lw v1,0(s0)
6ec: 50600004 beqzl v1,700 <e1000_remove+0xb8>
6f0: 8e030004 lw v1,4(s0)
adapter->next->prev = adapter->prev;
6f4: 8e020004 lw v0,4(s0)
6f8: ac620004 sw v0,4(v1)
if(adapter->prev != NULL)
6fc: 8e030004 lw v1,4(s0)
700: 50600004 beqzl v1,714 <e1000_remove+0xcc>
704: 8e440000 lw a0,0(s2)
adapter->prev->next = adapter->next;
708: 8e020000 lw v0,0(s0)
70c: ac620000 sw v0,0(v1)
/* free system resources */
#ifdef IANS
if(adapter->iANSdata != NULL)
kfree(adapter->iANSdata);
#endif
if(adapter->shared.hw_addr != NULL) {
710: 8e440000 lw a0,0(s2)
714: 10800014 beqz a0,768 <e1000_remove+0x120>
718: 00000000 nop
iounmap((void *) adapter->shared.hw_addr);
71c: 3c020000 lui v0,0x0
720: 24420000 addiu v0,v0,0
724: 0040f809 jalr v0
728: 00000000 nop
release_mem_region(pci_resource_start(pdev, BAR_0),
72c: 8e230064 lw v1,100(s1)
730: 14600005 bnez v1,748 <e1000_remove+0x100>
734: 8e220068 lw v0,104(s1)
738: 10400005 beqz v0,750 <e1000_remove+0x108>
73c: 00003021 move a2,zero
740: 080001d3 j 74c <e1000_remove+0x104>
744: 00431023 subu v0,v0,v1
748: 00431023 subu v0,v0,v1
74c: 24460001 addiu a2,v0,1
750: 3c040000 lui a0,0x0
754: 24840000 addiu a0,a0,0
758: 3c020000 lui v0,0x0
75c: 24420000 addiu v0,v0,0
760: 0040f809 jalr v0
764: 8e250064 lw a1,100(s1)
pci_resource_len(pdev, BAR_0));
}
/* free the net_device _and_ struct e1000_adapter memory */
kfree(netdev);
768: 3c020000 lui v0,0x0
76c: 24420000 addiu v0,v0,0
770: 0040f809 jalr v0
774: 02602021 move a0,s3
return;
}
778: 8fbf0020 lw ra,32(sp)
77c: 8fb3001c lw s3,28(sp)
780: 8fb20018 lw s2,24(sp)
784: 8fb10014 lw s1,20(sp)
788: 8fb00010 lw s0,16(sp)
78c: 03e00008 jr ra
790: 27bd0028 addiu sp,sp,40
00000794 <e1000_check_options>:
794: 27bdffd8 addiu sp,sp,-40
798: afb10014 sw s1,20(sp)
79c: afbf0020 sw ra,32(sp)
7a0: afb3001c sw s3,28(sp)
7a4: afb20018 sw s2,24(sp)
7a8: afb00010 sw s0,16(sp)
7ac: 00808821 move s1,a0
/**
* e1000_check_options - Range Checking for Command Line Parameters
* @adapter: board private structure
*
* This routine checks all command line paramters for valid user
* input. If an invalid value is given, or if no user specified
* value exists, a default value is used. The final value is stored
* in a variable in the Adapter structure.
**/
static void
e1000_check_options(struct e1000_adapter *adapter)
{
int board = adapter->bd_number;
7b0: 8e250090 lw a1,144(s1)
if(board >= E1000_MAX_NIC) {
7b4: 28a20008 slti v0,a1,8
7b8: 5440000d bnezl v0,7f0 <e1000_check_options+0x5c>
7bc: 00059080 sll s2,a1,0x2
printk("Warning: no configuration for board #%i\n", board);
7c0: 3c040000 lui a0,0x0
7c4: 248402c4 addiu a0,a0,708
7c8: 3c130000 lui s3,0x0
7cc: 26730000 addiu s3,s3,0
7d0: 0260f809 jalr s3
7d4: 00000000 nop
printk("Using defaults for all values\n");
7d8: 3c040000 lui a0,0x0
7dc: 248402f0 addiu a0,a0,752
7e0: 0260f809 jalr s3
7e4: 00000000 nop
board = E1000_MAX_NIC;
7e8: 24050008 li a1,8
}
E1000_DBG("e1000_check_options\n");
/* Transmit Descriptor Count */
if(TxDescriptors[board] == OPTION_UNSET) {
7ec: 00059080 sll s2,a1,0x2
7f0: 3c030000 lui v1,0x0
7f4: 246302b0 addiu v1,v1,688
7f8: 00721821 addu v1,v1,s2
7fc: 8c650000 lw a1,0(v1)
800: 2402ffff li v0,-1
804: 14a20005 bne a1,v0,81c <e1000_check_options+0x88>
808: 24a2ffb0 addiu v0,a1,-80
adapter->tx_ring.count = DEFAULT_TXD;
80c: 24020100 li v0,256
810: ae2200f0 sw v0,240(s1)
TxDescriptors[board] = DEFAULT_TXD;
} else
814: 08000234 j 8d0 <e1000_check_options+0x13c>
818: ac620000 sw v0,0(v1)
if(((TxDescriptors[board] > MAX_TXD) ||
81c: 2c4200b1 sltiu v0,v0,177
820: 1440000d bnez v0,858 <e1000_check_options+0xc4>
824: 00000000 nop
828: 8e22000c lw v0,12(s1)
82c: 2c420003 sltiu v0,v0,3
830: 10400009 beqz v0,858 <e1000_check_options+0xc4>
834: 00000000 nop
(TxDescriptors[board] < MIN_TXD)) &&
(adapter->shared.mac_type <= e1000_82543)) {
printk("Invalid TxDescriptors specified (%i), using default %i\n",
838: 3c040000 lui a0,0x0
83c: 24840310 addiu a0,a0,784
840: 3c130000 lui s3,0x0
844: 26730000 addiu s3,s3,0
848: 0260f809 jalr s3
84c: 24060100 li a2,256
TxDescriptors[board], DEFAULT_TXD);
adapter->tx_ring.count = DEFAULT_TXD;
} else
850: 08000233 j 8cc <e1000_check_options+0x138>
854: 24030100 li v1,256
if(((TxDescriptors[board] > MAX_82544_TXD) ||
858: 3c050000 lui a1,0x0
85c: 00b22821 addu a1,a1,s2
860: 8ca502b0 lw a1,688(a1)
864: 24a2ffb0 addiu v0,a1,-80
868: 2c420fb1 sltiu v0,v0,4017
86c: 1440000d bnez v0,8a4 <e1000_check_options+0x110>
870: 00000000 nop
874: 8e22000c lw v0,12(s1)
878: 2c420003 sltiu v0,v0,3
87c: 14400009 bnez v0,8a4 <e1000_check_options+0x110>
880: 00000000 nop
(TxDescriptors[board] < MIN_TXD)) &&
(adapter->shared.mac_type > e1000_82543)) {
printk("Invalid TxDescriptors specified (%i), using default %i\n",
884: 3c040000 lui a0,0x0
888: 24840310 addiu a0,a0,784
88c: 3c130000 lui s3,0x0
890: 26730000 addiu s3,s3,0
894: 0260f809 jalr s3
898: 24060100 li a2,256
TxDescriptors[board], DEFAULT_TXD);
adapter->tx_ring.count = DEFAULT_TXD;
} else {
89c: 08000233 j 8cc <e1000_check_options+0x138>
8a0: 24030100 li v1,256
printk("Using specified value of %i TxDescriptors\n",
8a4: 3c100000 lui s0,0x0
8a8: 261002b0 addiu s0,s0,688
8ac: 02128021 addu s0,s0,s2
8b0: 3c040000 lui a0,0x0
8b4: 24840348 addiu a0,a0,840
8b8: 3c130000 lui s3,0x0
8bc: 26730000 addiu s3,s3,0
8c0: 0260f809 jalr s3
8c4: 8e050000 lw a1,0(s0)
TxDescriptors[board]);
adapter->tx_ring.count = TxDescriptors[board];
8c8: 8e030000 lw v1,0(s0)
8cc: ae2300f0 sw v1,240(s1)
}
/* tx_ring.count must be a multiple of 8 */
adapter->tx_ring.count = E1000_ROUNDUP2(adapter->tx_ring.count,
8d0: 8e2200f0 lw v0,240(s1)
8d4: 2403fff8 li v1,-8
REQ_TX_DESCRIPTOR_MULTIPLE);
/* Receive Descriptor Count */
if(RxDescriptors[board] == OPTION_UNSET) {
8d8: 3c040000 lui a0,0x0
8dc: 248402d4 addiu a0,a0,724
8e0: 00922021 addu a0,a0,s2
8e4: 24420007 addiu v0,v0,7
8e8: 00431024 and v0,v0,v1
8ec: ae2200f0 sw v0,240(s1)
8f0: 8c850000 lw a1,0(a0)
8f4: 2402ffff li v0,-1
8f8: 14a20005 bne a1,v0,910 <e1000_check_options+0x17c>
8fc: 24a2ffb0 addiu v0,a1,-80
adapter->rx_ring.count = DEFAULT_RXD;
900: 24020100 li v0,256
904: ae22011c sw v0,284(s1)
RxDescriptors[board] = DEFAULT_RXD;
} else
908: 08000271 j 9c4 <e1000_check_options+0x230>
90c: ac820000 sw v0,0(a0)
if(((RxDescriptors[board] > MAX_RXD) ||
910: 2c4200b1 sltiu v0,v0,177
914: 1440000d bnez v0,94c <e1000_check_options+0x1b8>
918: 00000000 nop
91c: 8e22000c lw v0,12(s1)
920: 2c420003 sltiu v0,v0,3
924: 10400009 beqz v0,94c <e1000_check_options+0x1b8>
928: 00000000 nop
(RxDescriptors[board] < MIN_RXD)) &&
(adapter->shared.mac_type <= e1000_82543)) {
printk("Invalid RxDescriptors specified (%i), using default %i\n",
92c: 3c040000 lui a0,0x0
930: 24840374 addiu a0,a0,884
934: 3c130000 lui s3,0x0
938: 26730000 addiu s3,s3,0
93c: 0260f809 jalr s3
940: 24060100 li a2,256
RxDescriptors[board], DEFAULT_RXD);
adapter->rx_ring.count = DEFAULT_RXD;
} else
944: 08000270 j 9c0 <e1000_check_options+0x22c>
948: 24030100 li v1,256
if(((RxDescriptors[board] > MAX_82544_RXD) ||
94c: 3c050000 lui a1,0x0
950: 00b22821 addu a1,a1,s2
954: 8ca502d4 lw a1,724(a1)
958: 24a2ffb0 addiu v0,a1,-80
95c: 2c420fb1 sltiu v0,v0,4017
960: 1440000d bnez v0,998 <e1000_check_options+0x204>
964: 00000000 nop
968: 8e22000c lw v0,12(s1)
96c: 2c420003 sltiu v0,v0,3
970: 14400009 bnez v0,998 <e1000_check_options+0x204>
974: 00000000 nop
(RxDescriptors[board] < MIN_RXD)) &&
(adapter->shared.mac_type > e1000_82543)) {
printk("Invalid RxDescriptors specified (%i), using default %i\n",
978: 3c040000 lui a0,0x0
97c: 24840374 addiu a0,a0,884
980: 3c130000 lui s3,0x0
984: 26730000 addiu s3,s3,0
988: 0260f809 jalr s3
98c: 24060100 li a2,256
RxDescriptors[board], DEFAULT_RXD);
adapter->rx_ring.count = DEFAULT_RXD;
} else {
990: 08000270 j 9c0 <e1000_check_options+0x22c>
994: 24030100 li v1,256
printk("Using specified value of %i RxDescriptors\n",
998: 3c100000 lui s0,0x0
99c: 261002d4 addiu s0,s0,724
9a0: 02128021 addu s0,s0,s2
9a4: 3c040000 lui a0,0x0
9a8: 248403ac addiu a0,a0,940
9ac: 3c130000 lui s3,0x0
9b0: 26730000 addiu s3,s3,0
9b4: 0260f809 jalr s3
9b8: 8e050000 lw a1,0(s0)
RxDescriptors[board]);
adapter->rx_ring.count = RxDescriptors[board];
9bc: 8e030000 lw v1,0(s0)
9c0: ae23011c sw v1,284(s1)
}
/* rx_ring.count must be a multiple of 8 */
adapter->rx_ring.count =
9c4: 8e22011c lw v0,284(s1)
9c8: 2403fff8 li v1,-8
E1000_ROUNDUP2(adapter->rx_ring.count, REQ_RX_DESCRIPTOR_MULTIPLE);
/* Receive Checksum Offload Enable */
if(XsumRX[board] == OPTION_UNSET) {
9cc: 3c040000 lui a0,0x0
9d0: 24840388 addiu a0,a0,904
9d4: 00922021 addu a0,a0,s2
9d8: 24420007 addiu v0,v0,7
9dc: 00431024 and v0,v0,v1
9e0: ae22011c sw v0,284(s1)
9e4: 8c850000 lw a1,0(a0)
9e8: 2402ffff li v0,-1
9ec: 14a20005 bne a1,v0,a04 <e1000_check_options+0x270>
9f0: 2ca20002 sltiu v0,a1,2
adapter->RxChecksum = XSUMRX_DEFAULT;
9f4: 24020001 li v0,1
9f8: ae2201b0 sw v0,432(s1)
XsumRX[board] = XSUMRX_DEFAULT;
} else if((XsumRX[board] != OPTION_ENABLED) &&
9fc: 0800029b j a6c <e1000_check_options+0x2d8>
a00: ac820000 sw v0,0(a0)
a04: 54400009 bnezl v0,a2c <e1000_check_options+0x298>
a08: 24020001 li v0,1
(XsumRX[board] != OPTION_DISABLED)) {
printk("Invalid XsumRX specified (%i), using default of %i\n",
a0c: 3c040000 lui a0,0x0
a10: 248403d8 addiu a0,a0,984
a14: 3c130000 lui s3,0x0
a18: 26730000 addiu s3,s3,0
a1c: 0260f809 jalr s3
a20: 24060001 li a2,1
XsumRX[board], XSUMRX_DEFAULT);
adapter->RxChecksum = XSUMRX_DEFAULT;
} else {
a24: 0800029a j a68 <e1000_check_options+0x2d4>
a28: 24030001 li v1,1
printk("Receive Checksum Offload %s\n",
a2c: 3c030000 lui v1,0x0
a30: 2463042c addiu v1,v1,1068
a34: 10a20003 beq a1,v0,a44 <e1000_check_options+0x2b0>
a38: 00000000 nop
a3c: 3c030000 lui v1,0x0
a40: 24630434 addiu v1,v1,1076
a44: 3c040000 lui a0,0x0
a48: 2484040c addiu a0,a0,1036
a4c: 3c130000 lui s3,0x0
a50: 26730000 addiu s3,s3,0
a54: 0260f809 jalr s3
a58: 00602821 move a1,v1
XsumRX[board] == OPTION_ENABLED ? "Enabled" : "Disabled");
adapter->RxChecksum = XsumRX[board];
a5c: 3c030000 lui v1,0x0
a60: 00721821 addu v1,v1,s2
a64: 8c630388 lw v1,904(v1)
a68: ae2301b0 sw v1,432(s1)
}
/* Flow Control */
if(FlowControl[board] == OPTION_UNSET) {
a6c: 3c030000 lui v1,0x0
a70: 24630364 addiu v1,v1,868
a74: 00721821 addu v1,v1,s2
a78: 8c650000 lw a1,0(v1)
a7c: 2402ffff li v0,-1
a80: 14a20005 bne a1,v0,a98 <e1000_check_options+0x304>
a84: 2ca20004 sltiu v0,a1,4
adapter->shared.fc = e1000_fc_default;
a88: 240200ff li v0,255
a8c: ae220018 sw v0,24(s1)
FlowControl[board] = e1000_fc_default;
} else if((FlowControl[board] > e1000_fc_full) ||
a90: 080002dc j b70 <e1000_check_options+0x3dc>
a94: ac620000 sw v0,0(v1)
a98: 1440000a bnez v0,ac4 <e1000_check_options+0x330>
a9c: 24020002 li v0,2
(FlowControl[board] < e1000_fc_none)) {
printk("Invalid FlowControl specified (%i), "
aa0: 3c040000 lui a0,0x0
aa4: 24840440 addiu a0,a0,1088
aa8: 3c020000 lui v0,0x0
aac: 24420000 addiu v0,v0,0
ab0: 0040f809 jalr v0
ab4: 00000000 nop
"reading default settings from the EEPROM\n",
FlowControl[board]);
adapter->shared.fc = e1000_fc_default;
ab8: 240300ff li v1,255
} else {
abc: 080002dc j b70 <e1000_check_options+0x3dc>
ac0: ae230018 sw v1,24(s1)
adapter->shared.fc = FlowControl[board];
switch (adapter->shared.fc) {
ac4: 10a20018 beq a1,v0,b28 <e1000_check_options+0x394>
ac8: ae250018 sw a1,24(s1)
acc: 2ca20003 sltiu v0,a1,3
ad0: 10400007 beqz v0,af0 <e1000_check_options+0x35c>
ad4: 24020003 li v0,3
ad8: 10a0000b beqz a1,b08 <e1000_check_options+0x374>
adc: 24020001 li v0,1
ae0: 10a2000d beq a1,v0,b18 <e1000_check_options+0x384>
ae4: 00000000 nop
ae8: 080002dc j b70 <e1000_check_options+0x3dc>
aec: 00000000 nop
af0: 10a20015 beq a1,v0,b48 <e1000_check_options+0x3b4>
af4: 240200ff li v0,255
af8: 10a20019 beq a1,v0,b60 <e1000_check_options+0x3cc>
afc: 00000000 nop
b00: 080002dc j b70 <e1000_check_options+0x3dc>
b04: 00000000 nop
case e1000_fc_none:
printk("Flow Control Disabled\n");
b08: 3c040000 lui a0,0x0
b0c: 24840490 addiu a0,a0,1168
break;
b10: 080002cc j b30 <e1000_check_options+0x39c>
b14: 00000000 nop
case e1000_fc_rx_pause:
printk("Flow Control Receive Only\n");
b18: 3c040000 lui a0,0x0
b1c: 248404a8 addiu a0,a0,1192
break;
b20: 080002cc j b30 <e1000_check_options+0x39c>
b24: 00000000 nop
case e1000_fc_tx_pause:
printk("Flow Control Transmit Only\n");
b28: 3c040000 lui a0,0x0
b2c: 248404c4 addiu a0,a0,1220
b30: 3c020000 lui v0,0x0
b34: 24420000 addiu v0,v0,0
b38: 0040f809 jalr v0
b3c: 00000000 nop
break;
b40: 080002dc j b70 <e1000_check_options+0x3dc>
b44: 00000000 nop
case e1000_fc_full:
printk("Flow Control Enabled\n");
b48: 3c040000 lui a0,0x0
b4c: 248404e0 addiu a0,a0,1248
b50: 3c130000 lui s3,0x0
b54: 26730000 addiu s3,s3,0
b58: 0260f809 jalr s3
b5c: 00000000 nop
case e1000_fc_default:
printk("Flow Control Hardware Default\n");
b60: 3c040000 lui a0,0x0
b64: 248404f8 addiu a0,a0,1272
b68: 0260f809 jalr s3
b6c: 00000000 nop
}
}
/* Transmit Interrupt Delay */
if(TxIntDelay[board] == OPTION_UNSET) {
b70: 3c100000 lui s0,0x0
b74: 261003ac addiu s0,s0,940
b78: 02128021 addu s0,s0,s2
b7c: 8e050000 lw a1,0(s0)
b80: 2402ffff li v0,-1
b84: 14a20005 bne a1,v0,b9c <e1000_check_options+0x408>
b88: 3402ffff li v0,0xffff
adapter->tx_int_delay = DEFAULT_TIDV;
b8c: 24020040 li v0,64
b90: ae220104 sw v0,260(s1)
TxIntDelay[board] = DEFAULT_TIDV;
} else if((TxIntDelay[board] > MAX_TIDV) || (TxIntDelay[board] < MIN_TIDV)) {
b94: 080002fa j be8 <e1000_check_options+0x454>
b98: ae020000 sw v0,0(s0)
b9c: 0045102b sltu v0,v0,a1
ba0: 10400009 beqz v0,bc8 <e1000_check_options+0x434>
ba4: 00000000 nop
printk("Invalid TxIntDelay specified (%i), using default %i\n",
ba8: 3c040000 lui a0,0x0
bac: 24840518 addiu a0,a0,1304
bb0: 3c020000 lui v0,0x0
bb4: 24420000 addiu v0,v0,0
bb8: 0040f809 jalr v0
bbc: 24060040 li a2,64
TxIntDelay[board], DEFAULT_TIDV);
adapter->tx_int_delay = DEFAULT_TIDV;
} else {
bc0: 080002f9 j be4 <e1000_check_options+0x450>
bc4: 24030040 li v1,64
printk("Using specified TxIntDelay of %i\n", TxIntDelay[board]);
bc8: 3c040000 lui a0,0x0
bcc: 24840550 addiu a0,a0,1360
bd0: 3c020000 lui v0,0x0
bd4: 24420000 addiu v0,v0,0
bd8: 0040f809 jalr v0
bdc: 00000000 nop
adapter->tx_int_delay = TxIntDelay[board];
be0: 8e030000 lw v1,0(s0)
be4: ae230104 sw v1,260(s1)
}
/* Receive Interrupt Delay */
if(RxIntDelay[board] == OPTION_UNSET) {
be8: 3c100000 lui s0,0x0
bec: 261003d0 addiu s0,s0,976
bf0: 02128021 addu s0,s0,s2
bf4: 8e050000 lw a1,0(s0)
bf8: 2402ffff li v0,-1
bfc: 14a20005 bne a1,v0,c14 <e1000_check_options+0x480>
c00: 3402ffff li v0,0xffff
adapter->rx_int_delay = DEFAULT_RIDV;
c04: 24020040 li v0,64
c08: ae220130 sw v0,304(s1)
RxIntDelay[board] = DEFAULT_RIDV;
} else if((RxIntDelay[board] > MAX_RIDV) || (RxIntDelay[board] < MIN_RIDV)) {
c0c: 08000318 j c60 <e1000_check_options+0x4cc>
c10: ae020000 sw v0,0(s0)
c14: 0045102b sltu v0,v0,a1
c18: 10400009 beqz v0,c40 <e1000_check_options+0x4ac>
c1c: 00000000 nop
printk("Invalid RxIntDelay specified (%i), using default %i\n",
c20: 3c040000 lui a0,0x0
c24: 24840574 addiu a0,a0,1396
c28: 3c020000 lui v0,0x0
c2c: 24420000 addiu v0,v0,0
c30: 0040f809 jalr v0
c34: 24060040 li a2,64
RxIntDelay[board], DEFAULT_RIDV);
adapter->rx_int_delay = DEFAULT_RIDV;
} else {
c38: 08000317 j c5c <e1000_check_options+0x4c8>
c3c: 24030040 li v1,64
printk("Using specified RxIntDelay of %i\n", RxIntDelay[board]);
c40: 3c040000 lui a0,0x0
c44: 248405ac addiu a0,a0,1452
c48: 3c020000 lui v0,0x0
c4c: 24420000 addiu v0,v0,0
c50: 0040f809 jalr v0
c54: 00000000 nop
adapter->rx_int_delay = RxIntDelay[board];
c58: 8e030000 lw v1,0(s0)
c5c: ae230130 sw v1,304(s1)
}
if(adapter->shared.media_type == e1000_media_type_copper) {
c60: 8e330010 lw s3,16(s1)
c64: 16600038 bnez s3,d48 <e1000_check_options+0x5b4>
c68: 2402ffff li v0,-1
/* MDI/MDI-X Support */
if(MdiX[board] == OPTION_UNSET) {
c6c: 3c100000 lui s0,0x0
c70: 261003f4 addiu s0,s0,1012
c74: 02128021 addu s0,s0,s2
c78: 8e050000 lw a1,0(s0)
c7c: 14a20004 bne a1,v0,c90 <e1000_check_options+0x4fc>
c80: 2ca20004 sltiu v0,a1,4
adapter->shared.mdix = DEFAULT_MDIX;
c84: a2200079 sb zero,121(s1)
MdiX[board] = DEFAULT_MDIX;
} else if((MdiX[board] > MAX_MDIX) || (MdiX[board] < MIN_MDIX)) {
c88: 08000336 j cd8 <e1000_check_options+0x544>
c8c: ae000000 sw zero,0(s0)
c90: 14400009 bnez v0,cb8 <e1000_check_options+0x524>
c94: 00000000 nop
printk("Invalid MDI/MDI-X specified (%i), using default %i\n",
c98: 3c040000 lui a0,0x0
c9c: 248405d0 addiu a0,a0,1488
ca0: 3c020000 lui v0,0x0
ca4: 24420000 addiu v0,v0,0
ca8: 0040f809 jalr v0
cac: 00003021 move a2,zero
MdiX[board], DEFAULT_MDIX);
adapter->shared.mdix = DEFAULT_MDIX;
} else {
cb0: 08000336 j cd8 <e1000_check_options+0x544>
cb4: a2200079 sb zero,121(s1)
printk("Using specified MDI/MDI-X of %i\n", MdiX[board]);
cb8: 3c040000 lui a0,0x0
cbc: 24840604 addiu a0,a0,1540
cc0: 3c020000 lui v0,0x0
cc4: 24420000 addiu v0,v0,0
cc8: 0040f809 jalr v0
ccc: 00000000 nop
adapter->shared.mdix = MdiX[board];
cd0: 92030003 lbu v1,3(s0)
cd4: a2230079 sb v1,121(s1)
}
/* Automatic Correction for Reverse Cable Polarity */
if(DisablePolarityCorrection[board] == OPTION_UNSET) {
cd8: 3c100000 lui s0,0x0
cdc: 26100418 addiu s0,s0,1048
ce0: 02128021 addu s0,s0,s2
ce4: 8e050000 lw a1,0(s0)
ce8: 2402ffff li v0,-1
cec: 14a20004 bne a1,v0,d00 <e1000_check_options+0x56c>
cf0: 2ca20002 sltiu v0,a1,2
adapter->shared.disable_polarity_correction = OPTION_DISABLED;
cf4: ae200054 sw zero,84(s1)
DisablePolarityCorrection[board] = OPTION_DISABLED;
} else if((DisablePolarityCorrection[board] != OPTION_ENABLED) &&
cf8: 08000352 j d48 <e1000_check_options+0x5b4>
cfc: ae000000 sw zero,0(s0)
d00: 14400009 bnez v0,d28 <e1000_check_options+0x594>
d04: 00000000 nop
(DisablePolarityCorrection[board] != OPTION_DISABLED)) {
printk("Invalid polarity correction specified (%i),"
d08: 3c040000 lui a0,0x0
d0c: 24840628 addiu a0,a0,1576
d10: 3c020000 lui v0,0x0
d14: 24420000 addiu v0,v0,0
d18: 0040f809 jalr v0
d1c: 00003021 move a2,zero
" using default %i\n", DisablePolarityCorrection[board],
OPTION_DISABLED);
adapter->shared.disable_polarity_correction = OPTION_DISABLED;
} else {
d20: 08000352 j d48 <e1000_check_options+0x5b4>
d24: ae200054 sw zero,84(s1)
printk("Using specified polarity correction of %i\n",
d28: 3c040000 lui a0,0x0
d2c: 2484066c addiu a0,a0,1644
d30: 3c020000 lui v0,0x0
d34: 24420000 addiu v0,v0,0
d38: 0040f809 jalr v0
d3c: 00000000 nop
DisablePolarityCorrection[board]);
adapter->shared.disable_polarity_correction =
d40: 8e030000 lw v1,0(s0)
d44: ae230054 sw v1,84(s1)
DisablePolarityCorrection[board];
}
}
/* Speed, Duplex, and AutoNeg */
switch (adapter->shared.media_type) {
d48: 12600009 beqz s3,d70 <e1000_check_options+0x5dc>
d4c: 24020001 li v0,1
d50: 1662000d bne s3,v0,d88 <e1000_check_options+0x5f4>
d54: 00000000 nop
case e1000_media_type_fiber:
e1000_check_fiber_options(adapter);
d58: 3c020000 lui v0,0x0
d5c: 24420dbc addiu v0,v0,3516
d60: 0040f809 jalr v0
d64: 02202021 move a0,s1
break;
d68: 08000369 j da4 <e1000_check_options+0x610>
d6c: 8fbf0020 lw ra,32(sp)
case e1000_media_type_copper:
e1000_check_copper_options(adapter);
d70: 3c020000 lui v0,0x0
d74: 24420ecc addiu v0,v0,3788
d78: 0040f809 jalr v0
d7c: 02202021 move a0,s1
break;
d80: 08000369 j da4 <e1000_check_options+0x610>
d84: 8fbf0020 lw ra,32(sp)
default:
printk("Unknown Media Type\n");
d88: 3c040000 lui a0,0x0
d8c: 24840698 addiu a0,a0,1688
d90: 3c020000 lui v0,0x0
d94: 24420000 addiu v0,v0,0
d98: 0040f809 jalr v0
d9c: 00000000 nop
break;
}
return;
}
da0: 8fbf0020 lw ra,32(sp)
da4: 8fb3001c lw s3,28(sp)
da8: 8fb20018 lw s2,24(sp)
dac: 8fb10014 lw s1,20(sp)
db0: 8fb00010 lw s0,16(sp)
db4: 03e00008 jr ra
db8: 27bd0028 addiu sp,sp,40
00000dbc <e1000_check_fiber_options>:
dbc: 27bdffd8 addiu sp,sp,-40
dc0: afb40020 sw s4,32(sp)
dc4: afb3001c sw s3,28(sp)
dc8: afb20018 sw s2,24(sp)
dcc: afb10014 sw s1,20(sp)
dd0: afbf0024 sw ra,36(sp)
dd4: afb00010 sw s0,16(sp)
/**
* e1000_check_fiber_options - Range Checking for Link Options, Fiber Version
* @adapter: board private structure
*
* Handles speed and duplex options on fiber based adapters
**/
static void
e1000_check_fiber_options(struct e1000_adapter *adapter)
{
int board =
dd8: 8c830090 lw v1,144(a0)
adapter->bd_number > E1000_MAX_NIC ? E1000_MAX_NIC : adapter->bd_number;
E1000_DBG("CheckSpeedDuplexFiber\n");
/* Speed, Duplex, and AutoNeg are not valid on fiber NICs */
if((Speed[board] != OPTION_UNSET)) {
Speed[board] = 0;
printk("Warning: Speed not valid for fiber adapters\n");
ddc: 3c020000 lui v0,0x0
de0: 244206ac addiu v0,v0,1708
de4: 3c120000 lui s2,0x0
de8: 26520000 addiu s2,s2,0
dec: 00402021 move a0,v0
printk("Speed Parameter Ignored\n");
}
if((Duplex[board] != OPTION_UNSET)) {
Duplex[board] = 0;
printk("Warning: Duplex not valid for fiber adapters\n");
df0: 02409821 move s3,s2
df4: 2c620009 sltiu v0,v1,9
printk("Duplex Parameter Ignored\n");
}
if((AutoNeg[board] != OPTION_UNSET)) {
AutoNeg[board] = AUTONEG_ADV_DEFAULT;
printk("Warning: AutoNeg not valid for fiber adapters\n");
df8: 0260a021 move s4,s3
dfc: 14400002 bnez v0,e08 <e1000_check_fiber_options+0x4c>
e00: 2411ffff li s1,-1
e04: 24030008 li v1,8
e08: 00038080 sll s0,v1,0x2
e0c: 3c030000 lui v1,0x0
e10: 246302f8 addiu v1,v1,760
e14: 00701821 addu v1,v1,s0
e18: 8c620000 lw v0,0(v1)
e1c: 10510007 beq v0,s1,e3c <e1000_check_fiber_options+0x80>
e20: 00000000 nop
e24: 0240f809 jalr s2
e28: ac600000 sw zero,0(v1)
e2c: 3c040000 lui a0,0x0
e30: 248406dc addiu a0,a0,1756
e34: 0240f809 jalr s2
e38: 00000000 nop
e3c: 3c030000 lui v1,0x0
e40: 2463031c addiu v1,v1,796
e44: 00701821 addu v1,v1,s0
e48: 8c620000 lw v0,0(v1)
e4c: 3c040000 lui a0,0x0
e50: 248406f8 addiu a0,a0,1784
e54: 10510007 beq v0,s1,e74 <e1000_check_fiber_options+0xb8>
e58: 00000000 nop
e5c: 0260f809 jalr s3
e60: ac600000 sw zero,0(v1)
e64: 3c040000 lui a0,0x0
e68: 24840728 addiu a0,a0,1832
e6c: 0260f809 jalr s3
e70: 00000000 nop
e74: 3c030000 lui v1,0x0
e78: 24630340 addiu v1,v1,832
e7c: 00701821 addu v1,v1,s0
e80: 8c620000 lw v0,0(v1)
e84: 3c040000 lui a0,0x0
e88: 24840744 addiu a0,a0,1860
e8c: 10510007 beq v0,s1,eac <e1000_check_fiber_options+0xf0>
e90: 2402002f li v0,47
e94: 0280f809 jalr s4
e98: ac620000 sw v0,0(v1)
printk("AutoNeg Parameter Ignored\n");
e9c: 3c040000 lui a0,0x0
ea0: 24840774 addiu a0,a0,1908
ea4: 0280f809 jalr s4
ea8: 00000000 nop
}
return;
}
eac: 8fbf0024 lw ra,36(sp)
eb0: 8fb40020 lw s4,32(sp)
eb4: 8fb3001c lw s3,28(sp)
eb8: 8fb20018 lw s2,24(sp)
ebc: 8fb10014 lw s1,20(sp)
ec0: 8fb00010 lw s0,16(sp)
ec4: 03e00008 jr ra
ec8: 27bd0028 addiu sp,sp,40
00000ecc <e1000_check_copper_options>:
ecc: 27bdffd0 addiu sp,sp,-48
ed0: afb20018 sw s2,24(sp)
ed4: afbf0028 sw ra,40(sp)
ed8: afb50024 sw s5,36(sp)
edc: afb40020 sw s4,32(sp)
ee0: afb3001c sw s3,28(sp)
ee4: afb10014 sw s1,20(sp)
ee8: afb00010 sw s0,16(sp)
eec: 00809021 move s2,a0
/**
* e1000_check_copper_options - Range Checking for Link Options, Copper Version
* @adapter: board private structure
*
* Handles speed and duplex options on copper based adapters
**/
static void
e1000_check_copper_options(struct e1000_adapter *adapter)
{
int board =
ef0: 8e430090 lw v1,144(s2)
ef4: 2c620009 sltiu v0,v1,9
ef8: 50400001 beqzl v0,f00 <e1000_check_copper_options+0x34>
efc: 24030008 li v1,8
adapter->bd_number > E1000_MAX_NIC ? E1000_MAX_NIC : adapter->bd_number;
int speed, duplex;
boolean_t all_default = TRUE;
E1000_DBG("CheckSpeedDuplexCopper\n");
/* User Specified Auto-negotiation Settings */
if(AutoNeg[board] == OPTION_UNSET) {
f00: 00038880 sll s1,v1,0x2
f04: 3c040000 lui a0,0x0
f08: 24840340 addiu a0,a0,832
f0c: 00912021 addu a0,a0,s1
f10: 8c850000 lw a1,0(a0)
f14: 2402ffff li v0,-1
f18: 14a2000a bne a1,v0,f44 <e1000_check_copper_options+0x78>
f1c: 24140001 li s4,1
adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
f20: 2402002f li v0,47
AutoNeg[board] = AUTONEG_ADV_DEFAULT;
f24: 2403002f li v1,47
f28: a6420048 sh v0,72(s2)
} else if((Speed[board] != 0 && Speed[board] != OPTION_UNSET) ||
f2c: 3c130000 lui s3,0x0
f30: 267302f8 addiu s3,s3,760
f34: 3c150000 lui s5,0x0
f38: 26b5031c addiu s5,s5,796
f3c: 08000463 j 118c <e1000_check_copper_options+0x2c0>
f40: ac830000 sw v1,0(a0)
f44: 3c020000 lui v0,0x0
f48: 00511021 addu v0,v0,s1
f4c: 8c4202f8 lw v0,760(v0)
f50: 3c130000 lui s3,0x0
f54: 267302f8 addiu s3,s3,760
f58: 24420001 addiu v0,v0,1
f5c: 2c420002 sltiu v0,v0,2
f60: 1040000c beqz v0,f94 <e1000_check_copper_options+0xc8>
f64: 00000000 nop
f68: 3c020000 lui v0,0x0
f6c: 00511021 addu v0,v0,s1
f70: 8c42031c lw v0,796(v0)
f74: 3c150000 lui s5,0x0
f78: 26b5031c addiu s5,s5,796
f7c: 24420001 addiu v0,v0,1
f80: 2c420002 sltiu v0,v0,2
f84: 14400012 bnez v0,fd0 <e1000_check_copper_options+0x104>
f88: 2402ffd0 li v0,-48
f8c: 080003e7 j f9c <e1000_check_copper_options+0xd0>
f90: 00000000 nop
f94: 3c150000 lui s5,0x0
f98: 26b5031c addiu s5,s5,796
(Duplex[board] != 0 && Duplex[board] != OPTION_UNSET)) {
printk("Warning: AutoNeg specified along with Speed or Duplex\n");
f9c: 3c040000 lui a0,0x0
fa0: 24840790 addiu a0,a0,1936
fa4: 3c100000 lui s0,0x0
fa8: 26100000 addiu s0,s0,0
fac: 0200f809 jalr s0
fb0: 00000000 nop
printk("AutoNeg Parameter Ignored\n");
fb4: 3c040000 lui a0,0x0
fb8: 24840774 addiu a0,a0,1908
fbc: 0200f809 jalr s0
fc0: 00000000 nop
adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
fc4: 2403002f li v1,47
} else {
fc8: 08000463 j 118c <e1000_check_copper_options+0x2c0>
fcc: a6430048 sh v1,72(s2)
if(AutoNeg[board] & ~AUTONEG_ADV_MASK) {
fd0: 00a21024 and v0,a1,v0
fd4: 5040000a beqzl v0,1000 <e1000_check_copper_options+0x134>
fd8: 94820002 lhu v0,2(a0)
printk("Invalid AutoNeg Specified (0x%X), Parameter Ignored\n",
fdc: 3c040000 lui a0,0x0
fe0: 248407c8 addiu a0,a0,1992
fe4: 3c100000 lui s0,0x0
fe8: 26100000 addiu s0,s0,0
fec: 0200f809 jalr s0
ff0: 00000000 nop
AutoNeg[board]);
adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
ff4: 2403002f li v1,47
} else {
ff8: 08000403 j 100c <e1000_check_copper_options+0x140>
ffc: a6430048 sh v1,72(s2)
adapter->shared.autoneg_advertised = AutoNeg[board];
1000: 3c100000 lui s0,0x0
1004: 26100000 addiu s0,s0,0
1008: a6420048 sh v0,72(s2)
}
printk("AutoNeg Advertising ");
100c: 3c040000 lui a0,0x0
1010: 24840800 addiu a0,a0,2048
1014: 0200f809 jalr s0
1018: 00000000 nop
if(adapter->shared.autoneg_advertised & ADVERTISE_1000_FULL) {
101c: 96430048 lhu v1,72(s2)
1020: 30620020 andi v0,v1,0x20
1024: 5040000f beqzl v0,1064 <e1000_check_copper_options+0x198>
1028: 30620010 andi v0,v1,0x10
printk("1000/FD");
102c: 3c040000 lui a0,0x0
1030: 24840818 addiu a0,a0,2072
1034: 0200f809 jalr s0
1038: 00000000 nop
if(adapter->shared.autoneg_advertised & (ADVERTISE_1000_FULL - 1))
103c: 96430048 lhu v1,72(s2)
1040: 3062001f andi v0,v1,0x1f
1044: 50400007 beqzl v0,1064 <e1000_check_copper_options+0x198>
1048: 30620010 andi v0,v1,0x10
printk(", ");
104c: 3c040000 lui a0,0x0
1050: 24840820 addiu a0,a0,2080
1054: 0200f809 jalr s0
1058: 00000000 nop
105c: 96430048 lhu v1,72(s2)
}
if(adapter->shared.autoneg_advertised & ADVERTISE_1000_HALF) {
1060: 30620010 andi v0,v1,0x10
1064: 5040000f beqzl v0,10a4 <e1000_check_copper_options+0x1d8>
1068: 30620008 andi v0,v1,0x8
printk("1000/HD");
106c: 3c040000 lui a0,0x0
1070: 24840824 addiu a0,a0,2084
1074: 0200f809 jalr s0
1078: 00000000 nop
if(adapter->shared.autoneg_advertised & (ADVERTISE_1000_HALF - 1))
107c: 96430048 lhu v1,72(s2)
1080: 3062000f andi v0,v1,0xf
1084: 50400007 beqzl v0,10a4 <e1000_check_copper_options+0x1d8>
1088: 30620008 andi v0,v1,0x8
printk(", ");
108c: 3c040000 lui a0,0x0
1090: 24840820 addiu a0,a0,2080
1094: 0200f809 jalr s0
1098: 00000000 nop
109c: 96430048 lhu v1,72(s2)
}
if(adapter->shared.autoneg_advertised & ADVERTISE_100_FULL) {
10a0: 30620008 andi v0,v1,0x8
10a4: 5040000f beqzl v0,10e4 <e1000_check_copper_options+0x218>
10a8: 30620004 andi v0,v1,0x4
printk("100/FD");
10ac: 3c040000 lui a0,0x0
10b0: 2484082c addiu a0,a0,2092
10b4: 0200f809 jalr s0
10b8: 00000000 nop
if(adapter->shared.autoneg_advertised & (ADVERTISE_100_FULL - 1))
10bc: 96430048 lhu v1,72(s2)
10c0: 30620007 andi v0,v1,0x7
10c4: 50400007 beqzl v0,10e4 <e1000_check_copper_options+0x218>
10c8: 30620004 andi v0,v1,0x4
printk(", ");
10cc: 3c040000 lui a0,0x0
10d0: 24840820 addiu a0,a0,2080
10d4: 0200f809 jalr s0
10d8: 00000000 nop
10dc: 96430048 lhu v1,72(s2)
}
if(adapter->shared.autoneg_advertised & ADVERTISE_100_HALF) {
10e0: 30620004 andi v0,v1,0x4
10e4: 5040000f beqzl v0,1124 <e1000_check_copper_options+0x258>
10e8: 30620002 andi v0,v1,0x2
printk("100/HD");
10ec: 3c040000 lui a0,0x0
10f0: 24840834 addiu a0,a0,2100
10f4: 0200f809 jalr s0
10f8: 00000000 nop
if(adapter->shared.autoneg_advertised & (ADVERTISE_100_HALF - 1))
10fc: 96430048 lhu v1,72(s2)
1100: 30620003 andi v0,v1,0x3
1104: 50400007 beqzl v0,1124 <e1000_check_copper_options+0x258>
1108: 30620002 andi v0,v1,0x2
printk(", ");
110c: 3c040000 lui a0,0x0
1110: 24840820 addiu a0,a0,2080
1114: 0200f809 jalr s0
1118: 00000000 nop
111c: 96430048 lhu v1,72(s2)
}
if(adapter->shared.autoneg_advertised & ADVERTISE_10_FULL) {
1120: 30620002 andi v0,v1,0x2
1124: 5040000f beqzl v0,1164 <e1000_check_copper_options+0x298>
1128: 30620001 andi v0,v1,0x1
printk("10/FD");
112c: 3c040000 lui a0,0x0
1130: 2484083c addiu a0,a0,2108
1134: 0200f809 jalr s0
1138: 00000000 nop
if(adapter->shared.autoneg_advertised & (ADVERTISE_10_FULL - 1))
113c: 96430048 lhu v1,72(s2)
1140: 30630001 andi v1,v1,0x1
1144: 1060000d beqz v1,117c <e1000_check_copper_options+0x2b0>
1148: 00000000 nop
printk(", ");
114c: 3c040000 lui a0,0x0
1150: 24840820 addiu a0,a0,2080
1154: 0200f809 jalr s0
1158: 00000000 nop
115c: 96430048 lhu v1,72(s2)
}
if(adapter->shared.autoneg_advertised & ADVERTISE_10_HALF)
1160: 30620001 andi v0,v1,0x1
1164: 10400005 beqz v0,117c <e1000_check_copper_options+0x2b0>
1168: 00000000 nop
printk("10/HD");
116c: 3c040000 lui a0,0x0
1170: 24840844 addiu a0,a0,2116
1174: 0200f809 jalr s0
1178: 00000000 nop
printk("\n");
117c: 3c040000 lui a0,0x0
1180: 2484084c addiu a0,a0,2124
1184: 0200f809 jalr s0
1188: 00000000 nop
}
/* Forced Speed and Duplex */
switch (Speed[board]) {
118c: 02331021 addu v0,s1,s3
1190: 8c440000 lw a0,0(v0)
1194: 2403000a li v1,10
1198: 10830019 beq a0,v1,1200 <e1000_check_copper_options+0x334>
119c: 2882000b slti v0,a0,11
11a0: 10400008 beqz v0,11c4 <e1000_check_copper_options+0x2f8>
11a4: 24020064 li v0,100
11a8: 2402ffff li v0,-1
11ac: 10820011 beq a0,v0,11f4 <e1000_check_copper_options+0x328>
11b0: 02331021 addu v0,s1,s3
11b4: 50800014 beqzl a0,1208 <e1000_check_copper_options+0x33c>
11b8: 8c500000 lw s0,0(v0)
11bc: 08000476 j 11d8 <e1000_check_copper_options+0x30c>
11c0: 8c450000 lw a1,0(v0)
11c4: 1082000e beq a0,v0,1200 <e1000_check_copper_options+0x334>
11c8: 240203e8 li v0,1000
11cc: 1082000c beq a0,v0,1200 <e1000_check_copper_options+0x334>
11d0: 02331021 addu v0,s1,s3
default:
printk("Invalid Speed Specified (%i), Parameter Ignored\n",
11d4: 8c450000 lw a1,0(v0)
11d8: 3c040000 lui a0,0x0
11dc: 24840850 addiu a0,a0,2128
11e0: 3c020000 lui v0,0x0
11e4: 24420000 addiu v0,v0,0
11e8: 0040f809 jalr v0
11ec: 0000a021 move s4,zero
Speed[board]);
all_default = FALSE;
case OPTION_UNSET:
speed = 0;
Speed[board] = 0;
11f0: 02331021 addu v0,s1,s3
11f4: ac400000 sw zero,0(v0)
break;
11f8: 08000483 j 120c <e1000_check_copper_options+0x340>
11fc: 00008021 move s0,zero
case 0:
case 10:
case 100:
case 1000:
speed = Speed[board];
1200: 02331021 addu v0,s1,s3
1204: 8c500000 lw s0,0(v0)
all_default = FALSE;
1208: 0000a021 move s4,zero
break;
}
switch (Duplex[board]) {
120c: 02351021 addu v0,s1,s5
1210: 8c450000 lw a1,0(v0)
1214: 2403ffff li v1,-1
1218: 10a3000b beq a1,v1,1248 <e1000_check_copper_options+0x37c>
121c: 28a2ffff slti v0,a1,-1
1220: 14400003 bnez v0,1230 <e1000_check_copper_options+0x364>
1224: 28a20003 slti v0,a1,3
1228: 5440000a bnezl v0,1254 <e1000_check_copper_options+0x388>
122c: 0000a021 move s4,zero
default:
printk("Invalid Duplex Specified (%i), Parameter Ignored\n",
1230: 3c040000 lui a0,0x0
1234: 24840884 addiu a0,a0,2180
1238: 3c020000 lui v0,0x0
123c: 24420000 addiu v0,v0,0
1240: 0040f809 jalr v0
1244: 0000a021 move s4,zero
Duplex[board]);
all_default = FALSE;
case OPTION_UNSET:
duplex = 0;
Duplex[board] = 0;
1248: 02351021 addu v0,s1,s5
124c: ac400000 sw zero,0(v0)
break;
1250: 00002821 move a1,zero
case 0:
case 1:
case 2:
duplex = Duplex[board];
all_default = FALSE;
break;
}
switch (speed + duplex) {
1254: 02058821 addu s1,s0,a1
1258: 2413000c li s3,12
125c: 12330069 beq s1,s3,1404 <e1000_check_copper_options+0x538>
1260: 2a22000d slti v0,s1,13
1264: 10400012 beqz v0,12b0 <e1000_check_copper_options+0x3e4>
1268: 24020066 li v0,102
126c: 24020002 li v0,2
1270: 12220040 beq s1,v0,1374 <e1000_check_copper_options+0x4a8>
1274: 2a220003 slti v0,s1,3
1278: 10400007 beqz v0,1298 <e1000_check_copper_options+0x3cc>
127c: 2402000a li v0,10
1280: 12200023 beqz s1,1310 <e1000_check_copper_options+0x444>
1284: 24020001 li v0,1
1288: 1222002c beq s1,v0,133c <e1000_check_copper_options+0x470>
128c: 00000000 nop
1290: 0800054d j 1534 <e1000_check_copper_options+0x668>
1294: 00000000 nop
1298: 12220043 beq s1,v0,13a8 <e1000_check_copper_options+0x4dc>
129c: 2402000b li v0,11
12a0: 1222004e beq s1,v0,13dc <e1000_check_copper_options+0x510>
12a4: 00000000 nop
12a8: 0800054d j 1534 <e1000_check_copper_options+0x668>
12ac: 00000000 nop
12b0: 12220072 beq s1,v0,147c <e1000_check_copper_options+0x5b0>
12b4: 2a220067 slti v0,s1,103
12b8: 10400008 beqz v0,12dc <e1000_check_copper_options+0x410>
12bc: 240203e9 li v0,1001
12c0: 24020064 li v0,100
12c4: 12220057 beq s1,v0,1424 <e1000_check_copper_options+0x558>
12c8: 24020065 li v0,101
12cc: 12220063 beq s1,v0,145c <e1000_check_copper_options+0x590>
12d0: 00000000 nop
12d4: 0800054d j 1534 <e1000_check_copper_options+0x668>
12d8: 00000000 nop
12dc: 1222007e beq s1,v0,14d8 <e1000_check_copper_options+0x60c>
12e0: 2a2203ea slti v0,s1,1002
12e4: 10400006 beqz v0,1300 <e1000_check_copper_options+0x434>
12e8: 240203ea li v0,1002
12ec: 240203e8 li v0,1000
12f0: 1222006d beq s1,v0,14a8 <e1000_check_copper_options+0x5dc>
12f4: 00000000 nop
12f8: 0800054d j 1534 <e1000_check_copper_options+0x668>
12fc: 00000000 nop
1300: 12220081 beq s1,v0,1508 <e1000_check_copper_options+0x63c>
1304: 00000000 nop
1308: 0800054d j 1534 <e1000_check_copper_options+0x668>
130c: 00000000 nop
case 0:
if(all_default == FALSE)
1310: 16800008 bnez s4,1334 <e1000_check_copper_options+0x468>
1314: 24020001 li v0,1
printk("Speed and Duplex Auto-negotiation Enabled\n");
1318: 3c040000 lui a0,0x0
131c: 248408b8 addiu a0,a0,2232
1320: 3c020000 lui v0,0x0
1324: 24420000 addiu v0,v0,0
1328: 0040f809 jalr v0
132c: 00000000 nop
adapter->shared.autoneg = 1;
1330: 24020001 li v0,1
break;
1334: 08000553 j 154c <e1000_check_copper_options+0x680>
1338: a2420078 sb v0,120(s2)
case 1:
printk("Warning: Half Duplex specified without Speed\n");
133c: 3c040000 lui a0,0x0
1340: 248408e4 addiu a0,a0,2276
1344: 3c100000 lui s0,0x0
1348: 26100000 addiu s0,s0,0
134c: 0200f809 jalr s0
1350: 00000000 nop
printk("Using Auto-negotiation at Half Duplex only\n");
1354: 3c040000 lui a0,0x0
1358: 24840914 addiu a0,a0,2324
135c: 0200f809 jalr s0
1360: 00000000 nop
adapter->shared.autoneg = 1;
adapter->shared.autoneg_advertised =
1364: 24030005 li v1,5
1368: a2510078 sb s1,120(s2)
ADVERTISE_10_HALF | ADVERTISE_100_HALF;
break;
136c: 08000553 j 154c <e1000_check_copper_options+0x680>
1370: a6430048 sh v1,72(s2)
case 2:
printk("Warning: Full Duplex specified without Speed\n");
1374: 3c040000 lui a0,0x0
1378: 24840940 addiu a0,a0,2368
137c: 3c100000 lui s0,0x0
1380: 26100000 addiu s0,s0,0
1384: 0200f809 jalr s0
1388: 00000000 nop
printk("Using Auto-negotiation at Full Duplex only\n");
138c: 3c040000 lui a0,0x0
1390: 24840970 addiu a0,a0,2416
1394: 0200f809 jalr s0
1398: 00000000 nop
adapter->shared.autoneg = 1;
139c: 24030001 li v1,1
adapter->shared.autoneg_advertised =
ADVERTISE_10_FULL | ADVERTISE_100_FULL | ADVERTISE_1000_FULL;
break;
13a0: 0800054a j 1528 <e1000_check_copper_options+0x65c>
13a4: 2402002a li v0,42
case 10:
printk("Warning: 10 Mbps Speed specified without Duplex\n");
13a8: 3c040000 lui a0,0x0
13ac: 2484099c addiu a0,a0,2460
13b0: 3c100000 lui s0,0x0
13b4: 26100000 addiu s0,s0,0
13b8: 0200f809 jalr s0
13bc: 00000000 nop
printk("Using Auto-negotiation at 10 Mbps only\n");
13c0: 3c040000 lui a0,0x0
13c4: 248409d0 addiu a0,a0,2512
13c8: 0200f809 jalr s0
13cc: 00000000 nop
adapter->shared.autoneg = 1;
13d0: 24030001 li v1,1
adapter->shared.autoneg_advertised =
ADVERTISE_10_HALF | ADVERTISE_10_FULL;
break;
13d4: 0800054a j 1528 <e1000_check_copper_options+0x65c>
13d8: 24020003 li v0,3
case 11:
printk("Forcing to 10 Mbps Half Duplex\n");
13dc: 3c040000 lui a0,0x0
13e0: 248409f8 addiu a0,a0,2552
13e4: 3c020000 lui v0,0x0
13e8: 24420000 addiu v0,v0,0
13ec: 0040f809 jalr v0
13f0: 00000000 nop
adapter->shared.autoneg = 0;
13f4: a2400078 sb zero,120(s2)
adapter->shared.forced_speed_duplex = e1000_10_half;
13f8: a240007a sb zero,122(s2)
adapter->shared.autoneg_advertised = 0;
break;
13fc: 08000553 j 154c <e1000_check_copper_options+0x680>
1400: a6400048 sh zero,72(s2)
case 12:
printk("Forcing to 10 Mbps Full Duplex\n");
1404: 3c040000 lui a0,0x0
1408: 24840a18 addiu a0,a0,2584
140c: 3c020000 lui v0,0x0
1410: 24420000 addiu v0,v0,0
1414: 0040f809 jalr v0
1418: 00000000 nop
adapter->shared.autoneg = 0;
adapter->shared.forced_speed_duplex = e1000_10_full;
adapter->shared.autoneg_advertised = 0;
break;
141c: 08000526 j 1498 <e1000_check_copper_options+0x5cc>
1420: 24030001 li v1,1
case 100:
printk("Warning: 100 Mbps Speed specified without Duplex\n");
1424: 3c040000 lui a0,0x0
1428: 24840a38 addiu a0,a0,2616
142c: 3c100000 lui s0,0x0
1430: 26100000 addiu s0,s0,0
1434: 0200f809 jalr s0
1438: 00000000 nop
printk("Using Auto-negotiation at 100 Mbps only\n");
143c: 3c040000 lui a0,0x0
1440: 24840a6c addiu a0,a0,2668
1444: 0200f809 jalr s0
1448: 00000000 nop
adapter->shared.autoneg = 1;
144c: 24030001 li v1,1
1450: a2430078 sb v1,120(s2)
adapter->shared.autoneg_advertised =
ADVERTISE_100_HALF | ADVERTISE_100_FULL;
break;
1454: 08000553 j 154c <e1000_check_copper_options+0x680>
1458: a6530048 sh s3,72(s2)
case 101:
printk("Forcing to 100 Mbps Half Duplex\n");
145c: 3c040000 lui a0,0x0
1460: 24840a98 addiu a0,a0,2712
1464: 3c020000 lui v0,0x0
1468: 24420000 addiu v0,v0,0
146c: 0040f809 jalr v0
1470: 00000000 nop
adapter->shared.autoneg = 0;
adapter->shared.forced_speed_duplex = e1000_100_half;
adapter->shared.autoneg_advertised = 0;
break;
1474: 08000526 j 1498 <e1000_check_copper_options+0x5cc>
1478: 24030002 li v1,2
case 102:
printk("Forcing to 100 Mbps Full Duplex\n");
147c: 3c040000 lui a0,0x0
1480: 24840abc addiu a0,a0,2748
1484: 3c020000 lui v0,0x0
1488: 24420000 addiu v0,v0,0
148c: 0040f809 jalr v0
1490: 00000000 nop
adapter->shared.autoneg = 0;
adapter->shared.forced_speed_duplex = e1000_100_full;
1494: 24030003 li v1,3
1498: a243007a sb v1,122(s2)
149c: a2400078 sb zero,120(s2)
adapter->shared.autoneg_advertised = 0;
break;
14a0: 08000553 j 154c <e1000_check_copper_options+0x680>
14a4: a6400048 sh zero,72(s2)
case 1000:
printk("Warning: 1000 Mbps Speed specified without Duplex\n");
14a8: 3c040000 lui a0,0x0
14ac: 24840ae0 addiu a0,a0,2784
14b0: 3c100000 lui s0,0x0
14b4: 26100000 addiu s0,s0,0
14b8: 0200f809 jalr s0
14bc: 00000000 nop
printk("Using Auto-negotiation at 1000 Mbps Full Duplex only\n");
14c0: 3c040000 lui a0,0x0
14c4: 24840b14 addiu a0,a0,2836
14c8: 0200f809 jalr s0
14cc: 00000000 nop
adapter->shared.autoneg = 1;
adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL;
break;
14d0: 08000549 j 1524 <e1000_check_copper_options+0x658>
14d4: 24030001 li v1,1
case 1001:
printk("Warning: Half Duplex is not supported at 1000 Mbps\n");
14d8: 3c040000 lui a0,0x0
14dc: 24840b4c addiu a0,a0,2892
14e0: 3c100000 lui s0,0x0
14e4: 26100000 addiu s0,s0,0
14e8: 0200f809 jalr s0
14ec: 00000000 nop
printk("Using Auto-negotiation at 1000 Mbps Full Duplex only\n");
14f0: 3c040000 lui a0,0x0
14f4: 24840b14 addiu a0,a0,2836
14f8: 0200f809 jalr s0
14fc: 00000000 nop
adapter->shared.autoneg = 1;
adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL;
break;
1500: 08000549 j 1524 <e1000_check_copper_options+0x658>
1504: 24030001 li v1,1
case 1002:
printk("Using Auto-negotiation at 1000 Mbps Full Duplex only\n");
1508: 3c040000 lui a0,0x0
150c: 24840b14 addiu a0,a0,2836
1510: 3c020000 lui v0,0x0
1514: 24420000 addiu v0,v0,0
1518: 0040f809 jalr v0
151c: 00000000 nop
adapter->shared.autoneg = 1;
1520: 24030001 li v1,1
adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL;
1524: 24020020 li v0,32
1528: a2430078 sb v1,120(s2)
break;
152c: 08000553 j 154c <e1000_check_copper_options+0x680>
1530: a6420048 sh v0,72(s2)
default:
panic("something is wrong in e1000_check_copper_options");
1534: 3c040000 lui a0,0x0
1538: 24840b80 addiu a0,a0,2944
153c: 3c020000 lui v0,0x0
1540: 24420000 addiu v0,v0,0
1544: 0040f809 jalr v0
1548: 00000000 nop
}
/* Speed, AutoNeg and MDI/MDI-X */
if (!e1000_validate_mdi_setting(&(adapter->shared))) {
154c: 3c020000 lui v0,0x0
1550: 24420000 addiu v0,v0,0
1554: 0040f809 jalr v0
1558: 26440008 addiu a0,s2,8
155c: 14400008 bnez v0,1580 <e1000_check_copper_options+0x6b4>
1560: 8fbf0028 lw ra,40(sp)
printk ("Speed, AutoNeg and MDI-X specifications are incompatible."
1564: 3c040000 lui a0,0x0
1568: 24840bb4 addiu a0,a0,2996
156c: 3c020000 lui v0,0x0
1570: 24420000 addiu v0,v0,0
1574: 0040f809 jalr v0
1578: 00000000 nop
" Setting MDI-X to a compatible value.\n");
}
return;
}
157c: 8fbf0028 lw ra,40(sp)
1580: 8fb50024 lw s5,36(sp)
1584: 8fb40020 lw s4,32(sp)
1588: 8fb3001c lw s3,28(sp)
158c: 8fb20018 lw s2,24(sp)
1590: 8fb10014 lw s1,20(sp)
1594: 8fb00010 lw s0,16(sp)
1598: 03e00008 jr ra
159c: 27bd0030 addiu sp,sp,48
000015a0 <e1000_sw_init>:
15a0: 27bdffd8 addiu sp,sp,-40
15a4: afb20018 sw s2,24(sp)
15a8: afb10014 sw s1,20(sp)
15ac: 00809021 move s2,a0
15b0: afbf0020 sw ra,32(sp)
15b4: afb3001c sw s3,28(sp)
15b8: afb00010 sw s0,16(sp)
/**
* e1000_sw_init - Initialize general software structures (struct e1000_adapter)
* @adapter: board private structure to initialize
*
* Returns 0 on success, negative on failure
*
* e1000_sw_init initializes the Adapter private data structure.
* Fields are initialized based on PCI device information and
* OS network device settings (MTU size).
**/
static int
e1000_sw_init(struct e1000_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev;
15bc: 8e50014c lw s0,332(s2)
uint32_t status;
E1000_DBG("e1000_sw_init\n");
/* PCI config space info */
pci_read_config_word(pdev, PCI_VENDOR_ID, &adapter->vendor_id);
15c0: 3c110000 lui s1,0x0
15c4: 26310000 addiu s1,s1,0
15c8: 264600bc addiu a2,s2,188
15cc: 02002021 move a0,s0
15d0: 00002821 move a1,zero
15d4: 0220f809 jalr s1
15d8: 8e530148 lw s3,328(s2)
pci_read_config_word(pdev, PCI_DEVICE_ID, &adapter->device_id);
15dc: 264600be addiu a2,s2,190
15e0: 02002021 move a0,s0
15e4: 0220f809 jalr s1
15e8: 24050002 li a1,2
pci_read_config_byte(pdev, PCI_REVISION_ID, &adapter->rev_id);
15ec: 264600c0 addiu a2,s2,192
15f0: 02002021 move a0,s0
15f4: 3c020000 lui v0,0x0
15f8: 24420000 addiu v0,v0,0
15fc: 0040f809 jalr v0
1600: 24050008 li a1,8
pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &adapter->subven_id);
1604: 264600c2 addiu a2,s2,194
1608: 02002021 move a0,s0
160c: 0220f809 jalr s1
1610: 2405002c li a1,44
pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &adapter->subsys_id);
1614: 264600c4 addiu a2,s2,196
1618: 02002021 move a0,s0
161c: 0220f809 jalr s1
1620: 2405002e li a1,46
pci_read_config_word(pdev, PCI_COMMAND, &adapter->shared.pci_cmd_word);
1624: 2646004a addiu a2,s2,74
1628: 02002021 move a0,s0
162c: 0220f809 jalr s1
1630: 24050004 li a1,4
/* Initial Receive Buffer Length */
if((netdev->mtu + ENET_HEADER_SIZE + CRC_LENGTH) < E1000_RXBUFFER_2048)
1634: 8e63005c lw v1,92(s3)
1638: 24630012 addiu v1,v1,18
163c: 2c620800 sltiu v0,v1,2048
1640: 50400003 beqzl v0,1650 <e1000_sw_init+0xb0>
1644: 2c621000 sltiu v0,v1,4096
adapter->rx_buffer_len = E1000_RXBUFFER_2048;
1648: 0800059b j 166c <e1000_sw_init+0xcc>
164c: 24020800 li v0,2048
else if((netdev->mtu + ENET_HEADER_SIZE + CRC_LENGTH) < E1000_RXBUFFER_4096)
1650: 50400003 beqzl v0,1660 <e1000_sw_init+0xc0>
1654: 2c622000 sltiu v0,v1,8192
adapter->rx_buffer_len = E1000_RXBUFFER_4096;
1658: 0800059b j 166c <e1000_sw_init+0xcc>
165c: 24021000 li v0,4096
else if((netdev->mtu + ENET_HEADER_SIZE + CRC_LENGTH) < E1000_RXBUFFER_8192)
1660: 50400002 beqzl v0,166c <e1000_sw_init+0xcc>
1664: 24024000 li v0,16384
adapter->rx_buffer_len = E1000_RXBUFFER_8192;
1668: 24022000 li v0,8192
else
adapter->rx_buffer_len = E1000_RXBUFFER_16384;
166c: ae4200b8 sw v0,184(s2)
adapter->shared.max_frame_size =
netdev->mtu + ENET_HEADER_SIZE + CRC_LENGTH;
/* MAC and Phy settings */
switch (adapter->device_id) {
1670: 964200be lhu v0,190(s2)
1674: 8e63005c lw v1,92(s3)
1678: 2444f000 addiu a0,v0,-4096
167c: 24630012 addiu v1,v1,18
1680: 2c82000e sltiu v0,a0,14
1684: 1040001f beqz v0,1704 <e1000_sw_init+0x164>
1688: ae43003c sw v1,60(s2)
168c: 00041080 sll v0,a0,0x2
1690: 3c030000 lui v1,0x0
1694: 00621821 addu v1,v1,v0
1698: 8c630c70 lw v1,3184(v1)
169c: 00600008 jr v1
16a0: 00000000 nop
case E1000_DEV_ID_82542:
switch (adapter->rev_id) {
16a4: 924300c0 lbu v1,192(s2)
16a8: 24020002 li v0,2
16ac: 1062000b beq v1,v0,16dc <e1000_sw_init+0x13c>
16b0: 24020003 li v0,3
16b4: 1062000b beq v1,v0,16e4 <e1000_sw_init+0x144>
16b8: 24020001 li v0,1
case E1000_82542_2_0_REV_ID:
adapter->shared.mac_type = e1000_82542_rev2_0;
break;
case E1000_82542_2_1_REV_ID:
adapter->shared.mac_type = e1000_82542_rev2_1;
break;
default:
adapter->shared.mac_type = e1000_82542_rev2_0;
E1000_ERR("Could not identify 82542 revision\n");
16bc: 3c040000 lui a0,0x0
16c0: 24840c14 addiu a0,a0,3092
16c4: 3c020000 lui v0,0x0
16c8: 24420000 addiu v0,v0,0
16cc: 0040f809 jalr v0
16d0: ae40000c sw zero,12(s2)
}
break;
16d4: 080005ca j 1728 <e1000_sw_init+0x188>
16d8: 8e42000c lw v0,12(s2)
16dc: 080005c9 j 1724 <e1000_sw_init+0x184>
16e0: ae40000c sw zero,12(s2)
16e4: 080005c9 j 1724 <e1000_sw_init+0x184>
16e8: ae42000c sw v0,12(s2)
case E1000_DEV_ID_82543GC_FIBER:
case E1000_DEV_ID_82543GC_COPPER:
adapter->shared.mac_type = e1000_82543;
16ec: 24020002 li v0,2
break;
16f0: 080005c9 j 1724 <e1000_sw_init+0x184>
16f4: ae42000c sw v0,12(s2)
case E1000_DEV_ID_82544EI_COPPER:
case E1000_DEV_ID_82544EI_FIBER:
case E1000_DEV_ID_82544GC_COPPER:
case E1000_DEV_ID_82544GC_LOM:
adapter->shared.mac_type = e1000_82544;
16f8: 24020003 li v0,3
break;
16fc: 080005c9 j 1724 <e1000_sw_init+0x184>
1700: ae42000c sw v0,12(s2)
default:
E1000_ERR("Could not identify hardware\n");
1704: 3c040000 lui a0,0x0
1708: 24840c44 addiu a0,a0,3140
170c: 3c020000 lui v0,0x0
1710: 24420000 addiu v0,v0,0
1714: 0040f809 jalr v0
1718: 00000000 nop
return -ENODEV;
171c: 080005ea j 17a8 <e1000_sw_init+0x208>
1720: 2402ffed li v0,-19
}
adapter->shared.fc_high_water = FC_DEFAULT_HI_THRESH;
adapter->shared.fc_low_water = FC_DEFAULT_LO_THRESH;
adapter->shared.fc_pause_time = FC_DEFAULT_TX_TIMER;
adapter->shared.fc_send_xon = 1;
/* Identify the Hardware - this is done by the gigabit shared code
* in e1000_init_hw, but it would help to identify the NIC
* before bringing the hardware online for use in e1000_check_options.
*/
if(adapter->shared.mac_type >= e1000_82543) {
1724: 8e42000c lw v0,12(s2)
1728: 34048000 li a0,0x8000
172c: 24054000 li a1,16384
1730: 24030100 li v1,256
1734: 24060001 li a2,1
1738: 2c420002 sltiu v0,v0,2
173c: a644004c sh a0,76(s2)
1740: a645004e sh a1,78(s2)
1744: a6430050 sh v1,80(s2)
1748: 14400009 bnez v0,1770 <e1000_sw_init+0x1d0>
174c: ae460068 sw a2,104(s2)
status = E1000_READ_REG(&adapter->shared, STATUS);
1750: 8e430008 lw v1,8(s2)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
1754: 8c620008 lw v0,8(v1)
return __arch__swab32(x);
1758: 00021602 srl v0,v0,0x18
if(status & E1000_STATUS_TBIMODE) {
175c: 30420020 andi v0,v0,0x20
1760: 54400004 bnezl v0,1774 <e1000_sw_init+0x1d4>
1764: ae460010 sw a2,16(s2)
adapter->shared.media_type = e1000_media_type_fiber;
} else {
adapter->shared.media_type = e1000_media_type_copper;
}
} else {
1768: 080005dd j 1774 <e1000_sw_init+0x1d4>
176c: ae400010 sw zero,16(s2)
adapter->shared.media_type = e1000_media_type_fiber;
1770: ae460010 sw a2,16(s2)
}
if((E1000_REPORT_TX_EARLY == 0) || (E1000_REPORT_TX_EARLY == 1)) {
adapter->shared.report_tx_early = E1000_REPORT_TX_EARLY;
} else {
if(adapter->shared.mac_type < e1000_82543) {
1774: 8e42000c lw v0,12(s2)
1778: 2c420002 sltiu v0,v0,2
177c: 10400003 beqz v0,178c <e1000_sw_init+0x1ec>
1780: 24020001 li v0,1
adapter->shared.report_tx_early = 0;
} else {
1784: 080005e4 j 1790 <e1000_sw_init+0x1f0>
1788: ae40006c sw zero,108(s2)
adapter->shared.report_tx_early = 1;
178c: ae42006c sw v0,108(s2)
}
}
adapter->shared.wait_autoneg_complete = WAITFORLINK_DEFAULT;
1790: 24020001 li v0,1
adapter->shared.tbi_compatibility_en = 1;
1794: 24030001 li v1,1
1798: a242007b sb v0,123(s2)
179c: ae43005c sw v1,92(s2)
atomic_set(&adapter->tx_timeout, 0);
17a0: ae40010c sw zero,268(s2)
spin_lock_init(&adapter->stats_lock);
spin_lock_init(&adapter->rx_fill_lock);
return 0;
17a4: 00001021 move v0,zero
}
17a8: 8fbf0020 lw ra,32(sp)
17ac: 8fb3001c lw s3,28(sp)
17b0: 8fb20018 lw s2,24(sp)
17b4: 8fb10014 lw s1,20(sp)
17b8: 8fb00010 lw s0,16(sp)
17bc: 03e00008 jr ra
17c0: 27bd0028 addiu sp,sp,40
000017c4 <e1000_hw_init>:
17c4: 27bdffd8 addiu sp,sp,-40
17c8: afb20018 sw s2,24(sp)
17cc: afbf0024 sw ra,36(sp)
17d0: afb40020 sw s4,32(sp)
17d4: afb3001c sw s3,28(sp)
17d8: afb10014 sw s1,20(sp)
17dc: afb00010 sw s0,16(sp)
17e0: 00809021 move s2,a0
/**
* e1000_hw_init - prepare the hardware
* @adapter: board private struct containing configuration
*
* Returns 0 on success, negative on failure
*
* Initialize the hardware to a configuration as specified by the
* Adapter structure. The controler is reset, the EEPROM is
* verified, the MAC address is set, then the shared initilization
* routines are called.
**/
static int
e1000_hw_init(struct e1000_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
E1000_DBG("e1000_hw_init\n");
/* Repartition Pba for greater than 9k mtu
* To take effect Ctrl_Rst is required.
*/
if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
17e4: 8e4200b8 lw v0,184(s2)
17e8: 2c422001 sltiu v0,v0,8193
17ec: 14400009 bnez v0,1814 <e1000_hw_init+0x50>
17f0: 8e540148 lw s4,328(s2)
17f4: 8e42000c lw v0,12(s2)
17f8: 2c420002 sltiu v0,v0,2
17fc: 14400003 bnez v0,180c <e1000_hw_init+0x48>
1800: 8e430008 lw v1,8(s2)
E1000_WRITE_REG(&adapter->shared, PBA, E1000_JUMBO_PBA);
1804: 08000609 j 1824 <e1000_hw_init+0x60>
1808: 3c022800 lui v0,0x2800
180c: 08000609 j 1824 <e1000_hw_init+0x60>
1810: 3c022800 lui v0,0x2800
1814: 8e42000c lw v0,12(s2)
1818: 2c420002 sltiu v0,v0,2
else
E1000_WRITE_REG(&adapter->shared, PBA, E1000_DEFAULT_PBA);
181c: 8e430008 lw v1,8(s2)
1820: 3c023000 lui v0,0x3000
1824: ac621000 sw v0,4096(v1)
/* Issue a global reset */
E1000_DBG("about to global reset\n");
adapter->shared.adapter_stopped = 0;
e1000_adapter_stop(&adapter->shared);
1828: 26530008 addiu s3,s2,8
182c: 02602021 move a0,s3
1830: 3c020000 lui v0,0x0
1834: 24420000 addiu v0,v0,0
1838: 0040f809 jalr v0
183c: ae400064 sw zero,100(s2)
adapter->shared.adapter_stopped = 0;
1840: ae400064 sw zero,100(s2)
/* make sure the EEPROM is good */
E1000_DBG("about to validate eeprom\n");
if(!e1000_validate_eeprom_checksum(&adapter->shared)) {
1844: 3c020000 lui v0,0x0
1848: 24420000 addiu v0,v0,0
184c: 0040f809 jalr v0
1850: 02602021 move a0,s3
1854: 14400005 bnez v0,186c <e1000_hw_init+0xa8>
1858: 265000a8 addiu s0,s2,168
E1000_ERR("The EEPROM Checksum Is Not Valid\n");
185c: 3c040000 lui a0,0x0
1860: 24840ca8 addiu a0,a0,3240
return -1;
1864: 08000638 j 18e0 <e1000_hw_init+0x11c>
1868: 00000000 nop
}
/* copy the MAC address out of the EEPROM */
E1000_DBG("about to get mac address\n");
e1000_read_address(adapter, adapter->perm_net_addr);
186c: 3c020000 lui v0,0x0
1870: 244219d4 addiu v0,v0,6612
1874: 02002821 move a1,s0
1878: 0040f809 jalr v0
187c: 02402021 move a0,s2
memcpy(netdev->dev_addr, adapter->perm_net_addr, netdev->addr_len);
1880: 9286007c lbu a2,124(s4)
1884: 26910074 addiu s1,s4,116
1888: 02002821 move a1,s0
188c: 3c100000 lui s0,0x0
1890: 26100000 addiu s0,s0,0
1894: 0200f809 jalr s0
1898: 02202021 move a0,s1
memcpy(adapter->shared.mac_addr, netdev->dev_addr, netdev->addr_len);
189c: 9286007c lbu a2,124(s4)
18a0: 2644007d addiu a0,s2,125
18a4: 0200f809 jalr s0
18a8: 02202821 move a1,s1
E1000_DBG("about to read part number\n");
e1000_read_part_num(&adapter->shared, &(adapter->part_num));
18ac: 02602021 move a0,s3
18b0: 3c020000 lui v0,0x0
18b4: 24420000 addiu v0,v0,0
18b8: 0040f809 jalr v0
18bc: 264500c8 addiu a1,s2,200
if(!e1000_init_hw(&adapter->shared)) {
18c0: 3c020000 lui v0,0x0
18c4: 24420000 addiu v0,v0,0
18c8: 0040f809 jalr v0
18cc: 02602021 move a0,s3
18d0: 14400009 bnez v0,18f8 <e1000_hw_init+0x134>
18d4: 00000000 nop
E1000_ERR("Hardware Initialization Failed\n");
18d8: 3c040000 lui a0,0x0
18dc: 24840cd4 addiu a0,a0,3284
18e0: 3c020000 lui v0,0x0
18e4: 24420000 addiu v0,v0,0
18e8: 0040f809 jalr v0
18ec: 00000000 nop
return -1;
18f0: 0800066d j 19b4 <e1000_hw_init+0x1f0>
18f4: 2402ffff li v0,-1
}
E1000_DBG("about to enable WOL\n");
e1000_enable_WOL(adapter);
18f8: 3c020000 lui v0,0x0
18fc: 244273ec addiu v0,v0,29676
1900: 0040f809 jalr v0
1904: 02402021 move a0,s2
E1000_DBG("about to check for link\n");
adapter->shared.get_link_status = 1;
1908: 24030001 li v1,1
190c: ae430058 sw v1,88(s2)
e1000_check_for_link(&adapter->shared);
1910: 3c030000 lui v1,0x0
1914: 24630000 addiu v1,v1,0
1918: 0060f809 jalr v1
191c: 02602021 move a0,s3
1920: 8e42000c lw v0,12(s2)
1924: 2c420002 sltiu v0,v0,2
1928: 14400008 bnez v0,194c <e1000_hw_init+0x188>
192c: 8e630000 lw v1,0(s3)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
1930: 8c620008 lw v0,8(v1)
return __arch__swab32(x);
1934: 00021602 srl v0,v0,0x18
if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU)
1938: 30420002 andi v0,v0,0x2
193c: 14400008 bnez v0,1960 <e1000_hw_init+0x19c>
1940: 24020001 li v0,1
1944: 0800065b j 196c <e1000_hw_init+0x1a8>
1948: ae4000b0 sw zero,176(s2)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
194c: 8c620008 lw v0,8(v1)
return __arch__swab32(x);
1950: 00021602 srl v0,v0,0x18
1954: 30420002 andi v0,v0,0x2
1958: 10400003 beqz v0,1968 <e1000_hw_init+0x1a4>
195c: 24020001 li v0,1
adapter->link_active = TRUE;
1960: 0800065b j 196c <e1000_hw_init+0x1a8>
1964: ae4200b0 sw v0,176(s2)
else
adapter->link_active = FALSE;
1968: ae4000b0 sw zero,176(s2)
if(adapter->link_active == TRUE) {
196c: 8e4300b0 lw v1,176(s2)
1970: 24020001 li v0,1
1974: 54620009 bnel v1,v0,199c <e1000_hw_init+0x1d8>
1978: a64000b6 sh zero,182(s2)
e1000_get_speed_and_duplex(&adapter->shared, &adapter->link_speed,
197c: 264600b6 addiu a2,s2,182
1980: 264500b4 addiu a1,s2,180
1984: 3c020000 lui v0,0x0
1988: 24420000 addiu v0,v0,0
198c: 0040f809 jalr v0
1990: 02602021 move a0,s3
&adapter->link_duplex);
} else {
1994: 08000668 j 19a0 <e1000_hw_init+0x1dc>
1998: 00000000 nop
adapter->link_speed = 0;
199c: a64000b4 sh zero,180(s2)
adapter->link_duplex = 0;
}
E1000_DBG("about to get bus info\n");
e1000_get_bus_info(&adapter->shared);
19a0: 3c020000 lui v0,0x0
19a4: 24420000 addiu v0,v0,0
19a8: 0040f809 jalr v0
19ac: 02602021 move a0,s3
E1000_DBG("e1000_hw_init done\n");
return 0;
19b0: 00001021 move v0,zero
}
19b4: 8fbf0024 lw ra,36(sp)
19b8: 8fb40020 lw s4,32(sp)
19bc: 8fb3001c lw s3,28(sp)
19c0: 8fb20018 lw s2,24(sp)
19c4: 8fb10014 lw s1,20(sp)
19c8: 8fb00010 lw s0,16(sp)
19cc: 03e00008 jr ra
19d0: 27bd0028 addiu sp,sp,40
000019d4 <e1000_read_address>:
19d4: 27bdffd8 addiu sp,sp,-40
19d8: afb3001c sw s3,28(sp)
19dc: afb20018 sw s2,24(sp)
19e0: afb10014 sw s1,20(sp)
19e4: afb00010 sw s0,16(sp)
19e8: afbf0020 sw ra,32(sp)
/**
* e1000_read_address - Reads the MAC address from the EEPROM
* @adapter: board private structure
* @addr: pointer to an array of bytes
**/
static void
e1000_read_address(struct e1000_adapter *adapter,
uint8_t *addr)
{
uint16_t eeprom_word;
int i;
E1000_DBG("e1000_read_address\n");
for(i = 0; i < NODE_ADDRESS_SIZE; i += 2) {
19ec: 24920008 addiu s2,a0,8
19f0: 00a08021 move s0,a1
19f4: 00008821 move s1,zero
19f8: 3c130000 lui s3,0x0
19fc: 26730000 addiu s3,s3,0
eeprom_word =
1a00: 00112fc2 srl a1,s1,0x1f
1a04: 02252821 addu a1,s1,a1
1a08: 00052843 sra a1,a1,0x1
1a0c: 02402021 move a0,s2
1a10: 0260f809 jalr s3
1a14: 30a5ffff andi a1,a1,0xffff
1a18: 26310002 addiu s1,s1,2
e1000_read_eeprom(&adapter->shared,
EEPROM_NODE_ADDRESS_BYTE_0 + (i / 2));
addr[i] = (uint8_t) (eeprom_word & 0x00FF);
addr[i + 1] = (uint8_t) (eeprom_word >> 8);
1a1c: 00021a02 srl v1,v0,0x8
1a20: 2a240006 slti a0,s1,6
1a24: a2030001 sb v1,1(s0)
1a28: a2020000 sb v0,0(s0)
1a2c: 1480fff4 bnez a0,1a00 <e1000_read_address+0x2c>
1a30: 26100002 addiu s0,s0,2
}
return;
}
1a34: 8fbf0020 lw ra,32(sp)
1a38: 8fb3001c lw s3,28(sp)
1a3c: 8fb20018 lw s2,24(sp)
1a40: 8fb10014 lw s1,20(sp)
1a44: 8fb00010 lw s0,16(sp)
1a48: 03e00008 jr ra
1a4c: 27bd0028 addiu sp,sp,40
00001a50 <e1000_open>:
1a50: 27bdffd0 addiu sp,sp,-48
1a54: afb30024 sw s3,36(sp)
1a58: afb20020 sw s2,32(sp)
1a5c: afb00018 sw s0,24(sp)
1a60: afbf0028 sw ra,40(sp)
1a64: afb1001c sw s1,28(sp)
1a68: 00809821 move s3,a0
/**
* e1000_open - Called when a network interface is made active
* @netdev: network interface device structure
*
* Returns 0 on success, negative value on failure
*
* The open entry point is called when a network interface is made
* active by the system (IFF_UP). At this point all resources needed
* for transmit and receive operations are allocated, the interrupt
* handler is registered with the OS, the watchdog timer is started,
* and the stack is notified that the interface is ready.
**/
int
e1000_open(struct net_device *netdev)
{
struct e1000_adapter *adapter = netdev->priv;
1a6c: 8e710064 lw s1,100(s3)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
1a70: 24120001 li s2,1
1a74: 2630008c addiu s0,s1,140
1a78: c2020000 ll v0,0(s0)
1a7c: 00521825 or v1,v0,s2
1a80: e2030000 sc v1,0(s0)
1a84: 1060fffc beqz v1,1a78 <e1000_open+0x28>
1a88: 00521824 and v1,v0,s2
E1000_DBG("e1000_open\n");
/* prevent multiple opens when dealing with iANS */
if(test_and_set_bit(E1000_BOARD_OPEN, &adapter->flags)) {
1a8c: 1460009f bnez v1,1d0c <e1000_open+0x2bc>
1a90: 2402fff0 li v0,-16
return -EBUSY;
}
adapter->shared.fc = adapter->shared.original_fc;
1a94: 8e230030 lw v1,48(s1)
/* e1000_close issues a global reset (e1000_adapter_stop)
* so e1000_hw_init must be called again or the hardware
* will resume in it's default state
*/
if(e1000_hw_init(adapter) < 0) {
1a98: 02202021 move a0,s1
1a9c: 3c020000 lui v0,0x0
1aa0: 244217c4 addiu v0,v0,6084
1aa4: 0040f809 jalr v0
1aa8: ae230018 sw v1,24(s1)
1aac: 04430009 bgezl v0,1ad4 <e1000_open+0x84>
1ab0: ae200064 sw zero,100(s1)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
1ab4: c2020000 ll v0,0(s0)
1ab8: 2401fffe li at,-2
1abc: 00411024 and v0,v0,at
1ac0: e2020000 sc v0,0(s0)
1ac4: 1040fffb beqz v0,1ab4 <e1000_open+0x64>
1ac8: 00000000 nop
clear_bit(E1000_BOARD_OPEN, &adapter->flags);
return -EBUSY;
1acc: 08000743 j 1d0c <e1000_open+0x2bc>
1ad0: 2402fff0 li v0,-16
}
#ifdef IANS
/* restore VLAN settings */
if((IANS_BD_TAGGING_MODE) (ANS_PRIVATE_DATA_FIELD(adapter)->tag_mode) !=
IANS_BD_TAGGING_NONE)
bd_ans_hw_EnableVLAN(adapter);
#endif
adapter->shared.adapter_stopped = 0;
/* allocate transmit descriptors */
if(e1000_setup_tx_resources(adapter) != 0) {
1ad4: 3c020000 lui v0,0x0
1ad8: 24421e60 addiu v0,v0,7776
1adc: 0040f809 jalr v0
1ae0: 02202021 move a0,s1
1ae4: 10400005 beqz v0,1afc <e1000_open+0xac>
1ae8: 00000000 nop
e1000_adapter_stop(&adapter->shared);
1aec: 3c020000 lui v0,0x0
1af0: 24420000 addiu v0,v0,0
clear_bit(E1000_BOARD_OPEN, &adapter->flags);
return -ENOMEM;
1af4: 080006d0 j 1b40 <e1000_open+0xf0>
1af8: 26240008 addiu a0,s1,8
}
e1000_configure_tx(adapter);
1afc: 3c020000 lui v0,0x0
1b00: 24421f60 addiu v0,v0,8032
1b04: 0040f809 jalr v0
1b08: 02202021 move a0,s1
/* allocate receive descriptors and buffers */
if(e1000_setup_rx_resources(adapter) != 0) {
1b0c: 3c020000 lui v0,0x0
1b10: 24422208 addiu v0,v0,8712
1b14: 0040f809 jalr v0
1b18: 02202021 move a0,s1
1b1c: 10400012 beqz v0,1b68 <e1000_open+0x118>
1b20: 00000000 nop
e1000_adapter_stop(&adapter->shared);
1b24: 3c020000 lui v0,0x0
1b28: 24420000 addiu v0,v0,0
1b2c: 0040f809 jalr v0
1b30: 26240008 addiu a0,s1,8
e1000_free_tx_resources(adapter);
1b34: 02202021 move a0,s1
1b38: 3c020000 lui v0,0x0
1b3c: 244226b4 addiu v0,v0,9908
1b40: 0040f809 jalr v0
1b44: 00000000 nop
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
1b48: c2030000 ll v1,0(s0)
1b4c: 2401fffe li at,-2
1b50: 00611824 and v1,v1,at
1b54: e2030000 sc v1,0(s0)
1b58: 1060fffb beqz v1,1b48 <e1000_open+0xf8>
1b5c: 00000000 nop
clear_bit(E1000_BOARD_OPEN, &adapter->flags);
return -ENOMEM;
1b60: 08000743 j 1d0c <e1000_open+0x2bc>
1b64: 2402fff4 li v0,-12
}
e1000_setup_rctl(adapter);
1b68: 3c020000 lui v0,0x0
1b6c: 24422308 addiu v0,v0,8968
1b70: 0040f809 jalr v0
1b74: 02202021 move a0,s1
e1000_configure_rx(adapter);
1b78: 3c020000 lui v0,0x0
1b7c: 244223a8 addiu v0,v0,9128
1b80: 0040f809 jalr v0
1b84: 02202021 move a0,s1
/* hook the interrupt */
if(request_irq(netdev->irq, &e1000_intr,
1b88: 8e640024 lw a0,36(s3)
1b8c: 3c050000 lui a1,0x0
1b90: 24a50000 addiu a1,a1,0
1b94: 3c070000 lui a3,0x0
1b98: 24e70000 addiu a3,a3,0
1b9c: 3c060200 lui a2,0x200
1ba0: 3c020000 lui v0,0x0
1ba4: 24420000 addiu v0,v0,0
1ba8: 0040f809 jalr v0
1bac: afb30010 sw s3,16(sp)
1bb0: 5040001b beqzl v0,1c20 <e1000_open+0x1d0>
1bb4: 263000d0 addiu s0,s1,208
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
1bb8: c2020000 ll v0,0(s0)
1bbc: 2401fffe li at,-2
1bc0: 00411024 and v0,v0,at
1bc4: e2020000 sc v0,0(s0)
1bc8: 1040fffb beqz v0,1bb8 <e1000_open+0x168>
1bcc: 00000000 nop
SA_SHIRQ, e1000_driver_name, netdev) != 0) {
clear_bit(E1000_BOARD_OPEN, &adapter->flags);
e1000_adapter_stop(&adapter->shared);
1bd0: 3c020000 lui v0,0x0
1bd4: 24420000 addiu v0,v0,0
1bd8: 0040f809 jalr v0
1bdc: 26240008 addiu a0,s1,8
e1000_free_tx_resources(adapter);
1be0: 3c020000 lui v0,0x0
1be4: 244226b4 addiu v0,v0,9908
1be8: 0040f809 jalr v0
1bec: 02202021 move a0,s1
e1000_free_rx_resources(adapter);
1bf0: 3c020000 lui v0,0x0
1bf4: 2442284c addiu v0,v0,10316
1bf8: 0040f809 jalr v0
1bfc: 02202021 move a0,s1
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
1c00: c2030000 ll v1,0(s0)
1c04: 2401fffe li at,-2
1c08: 00611824 and v1,v1,at
1c0c: e2030000 sc v1,0(s0)
1c10: 1060fffb beqz v1,1c00 <e1000_open+0x1b0>
1c14: 00000000 nop
clear_bit(E1000_BOARD_OPEN, &adapter->flags);
return -EBUSY;
1c18: 08000743 j 1d0c <e1000_open+0x2bc>
1c1c: 2402fff0 li v0,-16
}
/* fill Rx ring with sk_buffs */
tasklet_init(&adapter->rx_fill_tasklet, e1000_alloc_rx_buffers,
1c20: 3c050000 lui a1,0x0
1c24: 24a55e30 addiu a1,a1,24112
1c28: 02002021 move a0,s0
1c2c: 3c020000 lui v0,0x0
1c30: 24420000 addiu v0,v0,0
1c34: 0040f809 jalr v0
1c38: 02203021 move a2,s1
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
1c3c: c22400d4 ll a0,212(s1)
1c40: 00921825 or v1,a0,s2
1c44: e22300d4 sc v1,212(s1)
1c48: 1060fffc beqz v1,1c3c <e1000_open+0x1ec>
1c4c: 00921824 and v1,a0,s2
extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t));
static inline void tasklet_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
1c50: 54600006 bnezl v1,1c6c <e1000_open+0x21c>
1c54: 26240094 addiu a0,s1,148
__tasklet_schedule(t);
1c58: 3c020000 lui v0,0x0
1c5c: 24420000 addiu v0,v0,0
1c60: 0040f809 jalr v0
1c64: 02002021 move a0,s0
extern void it_real_fn(unsigned long);
static inline void init_timer(struct timer_list * timer)
{
1c68: 26240094 addiu a0,s1,148
(unsigned long) adapter);
tasklet_schedule(&adapter->rx_fill_tasklet);
/* Set the watchdog timer for 2 seconds */
init_timer(&adapter->timer_id);
adapter->timer_id.function = &e1000_watchdog;
1c6c: 3c020000 lui v0,0x0
1c70: 24420000 addiu v0,v0,0
extern void it_real_fn(unsigned long);
static inline void init_timer(struct timer_list * timer)
{
timer->list.next = timer->list.prev = NULL;
1c74: ac800004 sw zero,4(a0)
1c78: ac800000 sw zero,0(a0)
1c7c: ae2200a4 sw v0,164(s1)
adapter->timer_id.data = (unsigned long) netdev;
1c80: ae3300a0 sw s3,160(s1)
mod_timer(&adapter->timer_id, (jiffies + 2 * HZ));
1c84: 3c050000 lui a1,0x0
1c88: 8ca50000 lw a1,0(a1)
1c8c: 3c020000 lui v0,0x0
1c90: 24420000 addiu v0,v0,0
1c94: 0040f809 jalr v0
1c98: 24a500c8 addiu a1,a1,200
/* stats accumulated while down are dropped
* this does not clear the running total
*/
e1000_clear_hw_cntrs(&adapter->shared);
1c9c: 3c020000 lui v0,0x0
1ca0: 24420000 addiu v0,v0,0
1ca4: 0040f809 jalr v0
1ca8: 26240008 addiu a0,s1,8
adapter->int_mask = IMS_ENABLE_MASK;
1cac: 2403009d li v1,157
1cb0: ae2300cc sw v1,204(s1)
e1000_irq_enable(adapter);
1cb4: 3c020000 lui v0,0x0
1cb8: 244274ac addiu v0,v0,29868
1cbc: 0040f809 jalr v0
1cc0: 02202021 move a0,s1
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
1cc4: c264002c ll a0,44(s3)
1cc8: 2401fffe li at,-2
1ccc: 00812024 and a0,a0,at
1cd0: e264002c sc a0,44(s3)
1cd4: 1080fffb beqz a0,1cc4 <e1000_open+0x274>
1cd8: 00000000 nop
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
1cdc: 3c030000 lui v1,0x0
1ce0: 24630010 addiu v1,v1,16
unsigned long temp;
__asm__ __volatile__(
1ce4: c0620000 ll v0,0(v1)
1ce8: 00521021 addu v0,v0,s2
1cec: e0620000 sc v0,0(v1)
1cf0: 1040fffc beqz v0,1ce4 <e1000_open+0x294>
1cf4: 00000000 nop
netif_start_queue(netdev);
#ifdef MODULE
/* Incrementing the module use count prevents a driver from being
* unloaded while an active network interface is using it.
*/
MOD_INC_USE_COUNT;
1cf8: 24630004 addiu v1,v1,4
1cfc: 8c640000 lw a0,0(v1)
#endif
return 0;
1d00: 00001021 move v0,zero
1d04: 34840018 ori a0,a0,0x18
1d08: ac640000 sw a0,0(v1)
}
1d0c: 8fbf0028 lw ra,40(sp)
1d10: 8fb30024 lw s3,36(sp)
1d14: 8fb20020 lw s2,32(sp)
1d18: 8fb1001c lw s1,28(sp)
1d1c: 8fb00018 lw s0,24(sp)
1d20: 03e00008 jr ra
1d24: 27bd0030 addiu sp,sp,48
00001d28 <e1000_close>:
1d28: 27bdffd8 addiu sp,sp,-40
1d2c: afb3001c sw s3,28(sp)
1d30: afb20018 sw s2,24(sp)
1d34: afb10014 sw s1,20(sp)
1d38: afbf0020 sw ra,32(sp)
1d3c: afb00010 sw s0,16(sp)
1d40: 00808821 move s1,a0
/**
* e1000_close - Disables a network interface
* @netdev: network interface device structure
*
* Returns 0, this is not allowed to fail
*
* The close entry point is called when an interface is de-activated
* by the OS. The hardware is still under the drivers control, but
* needs to be disabled. A global MAC reset is issued to stop the
* hardware, and all transmit and receive resources are freed.
**/
int
e1000_close(struct net_device *netdev)
{
struct e1000_adapter *adapter = netdev->priv;
1d44: 8e300064 lw s0,100(s1)
E1000_DBG("e1000_close\n");
if(!test_bit(E1000_BOARD_OPEN, &adapter->flags))
return 0;
/* Issue a global reset */
e1000_adapter_stop((&adapter->shared));
1d48: 3c050000 lui a1,0x0
1d4c: 24a50000 addiu a1,a1,0
1d50: 00001021 move v0,zero
* @nr: bit number to test
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
1d54: 2613008c addiu s3,s0,140
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
1d58: 8e630000 lw v1,0(s3)
1d5c: 26120008 addiu s2,s0,8
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
1d60: 30630001 andi v1,v1,0x1
1d64: 10600037 beqz v1,1e44 <e1000_close+0x11c>
1d68: 02402021 move a0,s2
1d6c: 00a0f809 jalr a1
1d70: 00000000 nop
/* Enable receiver unit after Global reset
* for WOL, so that receiver can still recive
* wake up packet and will not drop it.
*/
if(adapter->shared.mac_type > e1000_82543)
1d74: 8e02000c lw v0,12(s0)
1d78: 2c430002 sltiu v1,v0,2
1d7c: 2c420003 sltiu v0,v0,3
1d80: 14400003 bnez v0,1d90 <e1000_close+0x68>
1d84: 3c020200 lui v0,0x200
E1000_WRITE_REG(&adapter->shared, RCTL, E1000_RCTL_EN);
1d88: 8e430000 lw v1,0(s2)
1d8c: ac620100 sw v0,256(v1)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
1d90: c222002c ll v0,44(s1)
1d94: 34420001 ori v0,v0,0x1
1d98: e222002c sc v0,44(s1)
1d9c: 1040fffc beqz v0,1d90 <e1000_close+0x68>
1da0: 00000000 nop
/* free OS resources */
netif_stop_queue(netdev);
free_irq(netdev->irq, netdev);
1da4: 8e240024 lw a0,36(s1)
1da8: 3c020000 lui v0,0x0
1dac: 24420000 addiu v0,v0,0
1db0: 0040f809 jalr v0
1db4: 02202821 move a1,s1
del_timer_sync(&adapter->timer_id);
1db8: 3c020000 lui v0,0x0
1dbc: 24420000 addiu v0,v0,0
1dc0: 0040f809 jalr v0
1dc4: 26040094 addiu a0,s0,148
/* Make sure the tasklet won't be left after ifconfig down */
/*
* Assumption: tasklet is ALREADY enabled, ie, t->count == 0.
* Otherwise, tasklet is still left in the tasklet list, and,
* tasklet_kill will not be able to return (hang).
*/
tasklet_kill(&adapter->rx_fill_tasklet);
1dc8: 3c020000 lui v0,0x0
1dcc: 24420000 addiu v0,v0,0
1dd0: 0040f809 jalr v0
1dd4: 260400d0 addiu a0,s0,208
/* free software resources */
e1000_free_tx_resources(adapter);
1dd8: 3c020000 lui v0,0x0
1ddc: 244226b4 addiu v0,v0,9908
1de0: 0040f809 jalr v0
1de4: 02002021 move a0,s0
e1000_free_rx_resources(adapter);
1de8: 3c020000 lui v0,0x0
1dec: 2442284c addiu v0,v0,10316
1df0: 0040f809 jalr v0
1df4: 02002021 move a0,s0
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
1df8: 24030001 li v1,1
1dfc: 3c020000 lui v0,0x0
1e00: 24420010 addiu v0,v0,16
unsigned long temp;
__asm__ __volatile__(
1e04: c0440000 ll a0,0(v0)
1e08: 00832023 subu a0,a0,v1
1e0c: e0440000 sc a0,0(v0)
1e10: 1080fffc beqz a0,1e04 <e1000_close+0xdc>
1e14: 00000000 nop
#ifdef MODULE
/* decrement the module usage count
* so that the driver can be unloaded
*/
MOD_DEC_USE_COUNT;
1e18: 24420004 addiu v0,v0,4
1e1c: 8c430000 lw v1,0(v0)
1e20: 34630008 ori v1,v1,0x8
1e24: ac430000 sw v1,0(v0)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
1e28: c2640000 ll a0,0(s3)
1e2c: 2401fffe li at,-2
1e30: 00812024 and a0,a0,at
1e34: e2640000 sc a0,0(s3)
1e38: 1080fffb beqz a0,1e28 <e1000_close+0x100>
1e3c: 00000000 nop
#endif
clear_bit(E1000_BOARD_OPEN, &adapter->flags);
return 0;
1e40: 00001021 move v0,zero
}
1e44: 8fbf0020 lw ra,32(sp)
1e48: 8fb3001c lw s3,28(sp)
1e4c: 8fb20018 lw s2,24(sp)
1e50: 8fb10014 lw s1,20(sp)
1e54: 8fb00010 lw s0,16(sp)
1e58: 03e00008 jr ra
1e5c: 27bd0028 addiu sp,sp,40
00001e60 <e1000_setup_tx_resources>:
1e60: 27bdffd8 addiu sp,sp,-40
1e64: afb3001c sw s3,28(sp)
1e68: afb10014 sw s1,20(sp)
1e6c: afb00010 sw s0,16(sp)
1e70: 00808821 move s1,a0
1e74: afbf0020 sw ra,32(sp)
1e78: afb20018 sw s2,24(sp)
/**
* e1000_setup_tx_resources - allocate Tx resources (Descriptors)
* @adapter: board private structure
*
* Return 0 on success, negative on failure
*
* e1000_setup_tx_resources allocates all software transmit resources
* and enabled the Tx unit of the MAC.
**/
static int
e1000_setup_tx_resources(struct e1000_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
int size;
E1000_DBG("e1000_setup_tx_resources\n");
size = sizeof(struct e1000_buffer) * adapter->tx_ring.count;
1e7c: 8e2300f0 lw v1,240(s1)
adapter->tx_ring.buffer_info = kmalloc(size, GFP_KERNEL);
1e80: 240501f0 li a1,496
1e84: 3c020000 lui v0,0x0
1e88: 24420000 addiu v0,v0,0
1e8c: 00038040 sll s0,v1,0x1
1e90: 02038021 addu s0,s0,v1
1e94: 001080c0 sll s0,s0,0x3
1e98: 02002021 move a0,s0
1e9c: 0040f809 jalr v0
1ea0: 8e32014c lw s2,332(s1)
1ea4: 00401821 move v1,v0
if(adapter->tx_ring.buffer_info == NULL) {
return -ENOMEM;
}
memset(adapter->tx_ring.buffer_info, 0, size);
1ea8: 3c130000 lui s3,0x0
1eac: 26730000 addiu s3,s3,0
1eb0: 00602021 move a0,v1
1eb4: 02003021 move a2,s0
1eb8: 00002821 move a1,zero
1ebc: ae230100 sw v1,256(s1)
1ec0: 10600020 beqz v1,1f44 <e1000_setup_tx_resources+0xe4>
1ec4: 2402fff4 li v0,-12
1ec8: 0260f809 jalr s3
1ecc: 00000000 nop
/* round up to nearest 4K */
adapter->tx_ring.size = E1000_ROUNDUP2(adapter->tx_ring.count *
1ed0: 8e2300f0 lw v1,240(s1)
1ed4: 2405f000 li a1,-4096
sizeof(struct e1000_tx_desc),
4096);
adapter->tx_ring.desc = pci_alloc_consistent(pdev, adapter->tx_ring.size,
1ed8: 02402021 move a0,s2
1edc: 00031900 sll v1,v1,0x4
1ee0: 24630fff addiu v1,v1,4095
1ee4: 00651824 and v1,v1,a1
1ee8: 00602821 move a1,v1
1eec: ae2300ec sw v1,236(s1)
1ef0: 3c020000 lui v0,0x0
1ef4: 24420000 addiu v0,v0,0
1ef8: 0040f809 jalr v0
1efc: 262600e8 addiu a2,s1,232
&adapter->tx_ring.dma);
if(adapter->tx_ring.desc == NULL) {
kfree(adapter->tx_ring.buffer_info);
return -ENOMEM;
}
memset(adapter->tx_ring.desc, 0, adapter->tx_ring.size);
1f00: 00402021 move a0,v0
1f04: 00002821 move a1,zero
1f08: 3c030000 lui v1,0x0
1f0c: 24630000 addiu v1,v1,0
1f10: 14400005 bnez v0,1f28 <e1000_setup_tx_resources+0xc8>
1f14: ae2200e4 sw v0,228(s1)
1f18: 0060f809 jalr v1
1f1c: 8e240100 lw a0,256(s1)
1f20: 080007d1 j 1f44 <e1000_setup_tx_resources+0xe4>
1f24: 2402fff4 li v0,-12
1f28: 0260f809 jalr s3
1f2c: 8e2600ec lw a2,236(s1)
atomic_set(&adapter->tx_ring.unused, adapter->tx_ring.count);
1f30: 8e2300f0 lw v1,240(s1)
adapter->tx_ring.next_to_use = 0;
adapter->tx_ring.next_to_clean = 0;
1f34: ae2000fc sw zero,252(s1)
1f38: ae2000f8 sw zero,248(s1)
1f3c: ae2300f4 sw v1,244(s1)
return 0;
1f40: 00001021 move v0,zero
}
1f44: 8fbf0020 lw ra,32(sp)
1f48: 8fb3001c lw s3,28(sp)
1f4c: 8fb20018 lw s2,24(sp)
1f50: 8fb10014 lw s1,20(sp)
1f54: 8fb00010 lw s0,16(sp)
1f58: 03e00008 jr ra
1f5c: 27bd0028 addiu sp,sp,40
00001f60 <e1000_configure_tx>:
1f60: 00803821 move a3,a0
/**
* e1000_configure_tx - Configure 8254x Transmit Unit after Reset
* @adapter: board private structure
*
* Configure the Tx unit of the MAC after a reset.
**/
static void
e1000_configure_tx(struct e1000_adapter *adapter)
{
uint32_t tctl, tipg;
1f64: 8ce2000c lw v0,12(a3)
1f68: 2c420002 sltiu v0,v0,2
1f6c: 1440000e bnez v0,1fa8 <e1000_configure_tx+0x48>
1f70: 8ce500e8 lw a1,232(a3)
1f74: 8ce60008 lw a2,8(a3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
1f78: 30a4ff00 andi a0,a1,0xff00
1f7c: 00051600 sll v0,a1,0x18
1f80: 00051a02 srl v1,a1,0x8
1f84: 00042200 sll a0,a0,0x8
1f88: 00441025 or v0,v0,a0
1f8c: 3063ff00 andi v1,v1,0xff00
1f90: 00431025 or v0,v0,v1
1f94: 00052e02 srl a1,a1,0x18
1f98: 00451025 or v0,v0,a1
/* Setup the Base and Length of the Rx Descriptor Ring */
/* tx_ring.dma can be either a 32 or 64 bit value */
#if (BITS_PER_LONG == 32)
E1000_WRITE_REG(&adapter->shared, TDBAL, adapter->tx_ring.dma);
1f9c: acc23800 sw v0,14336(a2)
1fa0: 080007f6 j 1fd8 <e1000_configure_tx+0x78>
1fa4: 8ce2000c lw v0,12(a3)
1fa8: 8ce60008 lw a2,8(a3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
1fac: 30a4ff00 andi a0,a1,0xff00
1fb0: 00051600 sll v0,a1,0x18
1fb4: 00051a02 srl v1,a1,0x8
1fb8: 00042200 sll a0,a0,0x8
1fbc: 00441025 or v0,v0,a0
1fc0: 3063ff00 andi v1,v1,0xff00
1fc4: 00431025 or v0,v0,v1
1fc8: 00052e02 srl a1,a1,0x18
1fcc: 00451025 or v0,v0,a1
1fd0: acc20420 sw v0,1056(a2)
1fd4: 8ce2000c lw v0,12(a3)
1fd8: 2c420002 sltiu v0,v0,2
1fdc: 14400004 bnez v0,1ff0 <e1000_configure_tx+0x90>
1fe0: 8ce20008 lw v0,8(a3)
E1000_WRITE_REG(&adapter->shared, TDBAH, 0);
1fe4: ac403804 sw zero,14340(v0)
1fe8: 080007fe j 1ff8 <e1000_configure_tx+0x98>
1fec: 8ce2000c lw v0,12(a3)
1ff0: ac400424 sw zero,1060(v0)
1ff4: 8ce2000c lw v0,12(a3)
1ff8: 2c420002 sltiu v0,v0,2
1ffc: 1440000f bnez v0,203c <e1000_configure_tx+0xdc>
2000: 8ce400f0 lw a0,240(a3)
2004: 8ce60008 lw a2,8(a3)
2008: 00042100 sll a0,a0,0x4
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
200c: 3085ff00 andi a1,a0,0xff00
2010: 00041600 sll v0,a0,0x18
2014: 00041a02 srl v1,a0,0x8
2018: 00052a00 sll a1,a1,0x8
201c: 00451025 or v0,v0,a1
2020: 3063ff00 andi v1,v1,0xff00
2024: 00431025 or v0,v0,v1
2028: 00042602 srl a0,a0,0x18
202c: 00441025 or v0,v0,a0
#elif ( BITS_PER_LONG == 64)
E1000_WRITE_REG(&adapter->shared, TDBAL,
(uint32_t) (adapter->tx_ring.dma & 0x00000000FFFFFFFF));
E1000_WRITE_REG(&adapter->shared, TDBAH,
(uint32_t) (adapter->tx_ring.dma >> 32));
#else
#error "Unsupported System - does not use 32 or 64 bit pointers!"
#endif
E1000_WRITE_REG(&adapter->shared, TDLEN,
2030: acc23808 sw v0,14344(a2)
2034: 0800081c j 2070 <e1000_configure_tx+0x110>
2038: 8ce2000c lw v0,12(a3)
203c: 8ce60008 lw a2,8(a3)
2040: 00042100 sll a0,a0,0x4
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2044: 3085ff00 andi a1,a0,0xff00
2048: 00041600 sll v0,a0,0x18
204c: 00041a02 srl v1,a0,0x8
2050: 00052a00 sll a1,a1,0x8
2054: 00451025 or v0,v0,a1
2058: 3063ff00 andi v1,v1,0xff00
205c: 00431025 or v0,v0,v1
2060: 00042602 srl a0,a0,0x18
2064: 00441025 or v0,v0,a0
2068: acc20428 sw v0,1064(a2)
206c: 8ce2000c lw v0,12(a3)
2070: 2c420002 sltiu v0,v0,2
2074: 14400004 bnez v0,2088 <e1000_configure_tx+0x128>
2078: 8ce20008 lw v0,8(a3)
adapter->tx_ring.count * sizeof(struct e1000_tx_desc));
/* Setup the HW Tx Head and Tail descriptor pointers */
E1000_WRITE_REG(&adapter->shared, TDH, 0);
207c: ac403810 sw zero,14352(v0)
2080: 08000824 j 2090 <e1000_configure_tx+0x130>
2084: 8ce2000c lw v0,12(a3)
2088: ac400430 sw zero,1072(v0)
208c: 8ce2000c lw v0,12(a3)
2090: 2c420002 sltiu v0,v0,2
2094: 14400004 bnez v0,20a8 <e1000_configure_tx+0x148>
2098: 8ce20008 lw v0,8(a3)
E1000_WRITE_REG(&adapter->shared, TDT, 0);
209c: ac403818 sw zero,14360(v0)
20a0: 0800082c j 20b0 <e1000_configure_tx+0x150>
20a4: 8ce4000c lw a0,12(a3)
20a8: ac400438 sw zero,1080(v0)
/* Set the default values for the Tx Inter Packet Gap timer */
switch (adapter->shared.mac_type) {
20ac: 8ce4000c lw a0,12(a3)
20b0: 2c820002 sltiu v0,a0,2
20b4: 1440000d bnez v0,20ec <e1000_configure_tx+0x18c>
20b8: 3c0600a0 lui a2,0xa0
20bc: 2c820004 sltiu v0,a0,4
20c0: 5040000b beqzl v0,20f0 <e1000_configure_tx+0x190>
20c4: 34c6080a ori a2,a2,0x80a
case e1000_82543:
case e1000_82544:
if(adapter->shared.media_type == e1000_media_type_fiber)
20c8: 8ce30010 lw v1,16(a3)
20cc: 24020001 li v0,1
20d0: 10620002 beq v1,v0,20dc <e1000_configure_tx+0x17c>
20d4: 24060006 li a2,6
tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
else
tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
20d8: 24060008 li a2,8
tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
20dc: 3c020060 lui v0,0x60
20e0: 34422000 ori v0,v0,0x2000
break;
20e4: 0800083c j 20f0 <e1000_configure_tx+0x190>
20e8: 00c23025 or a2,a2,v0
case e1000_82542_rev2_0:
case e1000_82542_rev2_1:
default:
tipg = DEFAULT_82542_TIPG_IPGT;
tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
20ec: 34c6080a ori a2,a2,0x80a
break;
}
20f0: 2c820002 sltiu v0,a0,2
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
20f4: 30c3ff00 andi v1,a2,0xff00
20f8: 00031a00 sll v1,v1,0x8
20fc: 00061600 sll v0,a2,0x18
2100: 00062202 srl a0,a2,0x8
2104: 00431025 or v0,v0,v1
2108: 3084ff00 andi a0,a0,0xff00
E1000_WRITE_REG(&adapter->shared, TIPG, tipg);
210c: 8ce50008 lw a1,8(a3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2110: 00441025 or v0,v0,a0
2114: 00061e02 srl v1,a2,0x18
2118: 00431025 or v0,v0,v1
211c: aca20410 sw v0,1040(a1)
2120: 8ce2000c lw v0,12(a3)
2124: 2c420002 sltiu v0,v0,2
2128: 1440000e bnez v0,2164 <e1000_configure_tx+0x204>
212c: 8ce50104 lw a1,260(a3)
2130: 8ce60008 lw a2,8(a3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2134: 30a4ff00 andi a0,a1,0xff00
2138: 00051600 sll v0,a1,0x18
213c: 00051a02 srl v1,a1,0x8
2140: 00042200 sll a0,a0,0x8
2144: 00441025 or v0,v0,a0
2148: 3063ff00 andi v1,v1,0xff00
214c: 00431025 or v0,v0,v1
2150: 00052e02 srl a1,a1,0x18
2154: 00451025 or v0,v0,a1
/* Set the Tx Interrupt Delay register */
E1000_WRITE_REG(&adapter->shared, TIDV, adapter->tx_int_delay);
2158: acc23820 sw v0,14368(a2)
215c: 08000865 j 2194 <e1000_configure_tx+0x234>
2160: 8ce2000c lw v0,12(a3)
2164: 8ce60008 lw a2,8(a3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2168: 30a4ff00 andi a0,a1,0xff00
216c: 00051600 sll v0,a1,0x18
2170: 00051a02 srl v1,a1,0x8
2174: 00042200 sll a0,a0,0x8
2178: 00441025 or v0,v0,a0
217c: 3063ff00 andi v1,v1,0xff00
2180: 00431025 or v0,v0,v1
2184: 00052e02 srl a1,a1,0x18
2188: 00451025 or v0,v0,a1
218c: acc20440 sw v0,1088(a2)
/* Program the Transmit Control Register */
tctl =
E1000_TCTL_PSP | E1000_TCTL_EN | (E1000_COLLISION_THRESHOLD <<
E1000_CT_SHIFT);
if(adapter->link_duplex == FULL_DUPLEX) {
tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
} else {
tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
}
2190: 8ce2000c lw v0,12(a3)
2194: 2c420002 sltiu v0,v0,2
E1000_WRITE_REG(&adapter->shared, TCTL, tctl);
2198: 8ce30008 lw v1,8(a3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
219c: 3c020a01 lui v0,0xa01
21a0: 34420400 ori v0,v0,0x400
21a4: ac620400 sw v0,1024(v1)
#if defined(CONFIG_PPC) || defined(CONFIG_MIPS)
if(adapter->shared.mac_type >= e1000_82543) {
21a8: 8ce2000c lw v0,12(a3)
21ac: 2c420002 sltiu v0,v0,2
21b0: 54400005 bnezl v0,21c8 <e1000_configure_tx+0x268>
21b4: 8ce30104 lw v1,260(a3)
E1000_WRITE_REG(&adapter->shared, TXDCTL, 0x00020000);
21b8: 8ce30008 lw v1,8(a3)
21bc: 24020200 li v0,512
21c0: ac623828 sw v0,14376(v1)
}
#endif
/* Setup Transmit Descriptor Settings for this adapter */
adapter->TxdCmd = E1000_TXD_CMD_IFCS;
if(adapter->tx_int_delay > 0)
21c4: 8ce30104 lw v1,260(a3)
21c8: 3c020200 lui v0,0x200
21cc: 10600003 beqz v1,21dc <e1000_configure_tx+0x27c>
21d0: ace20108 sw v0,264(a3)
adapter->TxdCmd |= E1000_TXD_CMD_IDE;
21d4: 3c028200 lui v0,0x8200
21d8: ace20108 sw v0,264(a3)
if(adapter->shared.report_tx_early == 1)
21dc: 8ce3006c lw v1,108(a3)
21e0: 24020001 li v0,1
21e4: 14620003 bne v1,v0,21f4 <e1000_configure_tx+0x294>
21e8: 8ce20108 lw v0,264(a3)
adapter->TxdCmd |= E1000_TXD_CMD_RS;
21ec: 0800087e j 21f8 <e1000_configure_tx+0x298>
21f0: 3c030800 lui v1,0x800
else
adapter->TxdCmd |= E1000_TXD_CMD_RPS;
21f4: 3c031000 lui v1,0x1000
21f8: 00431025 or v0,v0,v1
21fc: ace20108 sw v0,264(a3)
adapter->ActiveChecksumContext = OFFLOAD_NONE;
return;
}
2200: 03e00008 jr ra
2204: ace001b4 sw zero,436(a3)
00002208 <e1000_setup_rx_resources>:
2208: 27bdffd8 addiu sp,sp,-40
220c: afb3001c sw s3,28(sp)
2210: afb10014 sw s1,20(sp)
2214: afb00010 sw s0,16(sp)
2218: 00808821 move s1,a0
221c: afbf0020 sw ra,32(sp)
2220: afb20018 sw s2,24(sp)
/**
* e1000_setup_rx_resources - allocate Rx resources (Descriptors, receive SKBs)
* @adapter: board private structure
*
* Returns 0 on success, negative on failure
*
* e1000_setup_rx_resources allocates all software receive resources
* and network buffers, and enables the Rx unit of the MAC.
**/
static int
e1000_setup_rx_resources(struct e1000_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
int size;
E1000_DBG("e1000_setup_rx_resources\n");
size = sizeof(struct e1000_buffer) * adapter->rx_ring.count;
2224: 8e23011c lw v1,284(s1)
adapter->rx_ring.buffer_info = kmalloc(size, GFP_KERNEL);
2228: 240501f0 li a1,496
222c: 3c020000 lui v0,0x0
2230: 24420000 addiu v0,v0,0
2234: 00038040 sll s0,v1,0x1
2238: 02038021 addu s0,s0,v1
223c: 001080c0 sll s0,s0,0x3
2240: 02002021 move a0,s0
2244: 0040f809 jalr v0
2248: 8e32014c lw s2,332(s1)
224c: 00401821 move v1,v0
if(adapter->rx_ring.buffer_info == NULL) {
return -ENOMEM;
}
memset(adapter->rx_ring.buffer_info, 0, size);
2250: 3c130000 lui s3,0x0
2254: 26730000 addiu s3,s3,0
2258: 00602021 move a0,v1
225c: 02003021 move a2,s0
2260: 00002821 move a1,zero
2264: ae23012c sw v1,300(s1)
2268: 10600020 beqz v1,22ec <e1000_setup_rx_resources+0xe4>
226c: 2402fff4 li v0,-12
2270: 0260f809 jalr s3
2274: 00000000 nop
/* Round up to nearest 4K */
adapter->rx_ring.size = E1000_ROUNDUP2(adapter->rx_ring.count *
2278: 8e23011c lw v1,284(s1)
227c: 2405f000 li a1,-4096
sizeof(struct e1000_rx_desc),
4096);
adapter->rx_ring.desc = pci_alloc_consistent(pdev, adapter->rx_ring.size,
2280: 02402021 move a0,s2
2284: 00031900 sll v1,v1,0x4
2288: 24630fff addiu v1,v1,4095
228c: 00651824 and v1,v1,a1
2290: 00602821 move a1,v1
2294: ae230118 sw v1,280(s1)
2298: 3c020000 lui v0,0x0
229c: 24420000 addiu v0,v0,0
22a0: 0040f809 jalr v0
22a4: 26260114 addiu a2,s1,276
&adapter->rx_ring.dma);
if(adapter->rx_ring.desc == NULL) {
kfree(adapter->rx_ring.buffer_info);
return -ENOMEM;
}
memset(adapter->rx_ring.desc, 0, adapter->rx_ring.size);
22a8: 00402021 move a0,v0
22ac: 00002821 move a1,zero
22b0: 3c030000 lui v1,0x0
22b4: 24630000 addiu v1,v1,0
22b8: 14400005 bnez v0,22d0 <e1000_setup_rx_resources+0xc8>
22bc: ae220110 sw v0,272(s1)
22c0: 0060f809 jalr v1
22c4: 8e24012c lw a0,300(s1)
22c8: 080008bb j 22ec <e1000_setup_rx_resources+0xe4>
22cc: 2402fff4 li v0,-12
22d0: 0260f809 jalr s3
22d4: 8e260118 lw a2,280(s1)
adapter->rx_ring.next_to_clean = 0;
atomic_set(&adapter->rx_ring.unused, adapter->rx_ring.count);
22d8: 8e23011c lw v1,284(s1)
adapter->rx_ring.next_to_use = 0;
22dc: ae200124 sw zero,292(s1)
22e0: ae200128 sw zero,296(s1)
22e4: ae230120 sw v1,288(s1)
return 0;
22e8: 00001021 move v0,zero
}
22ec: 8fbf0020 lw ra,32(sp)
22f0: 8fb3001c lw s3,28(sp)
22f4: 8fb20018 lw s2,24(sp)
22f8: 8fb10014 lw s1,20(sp)
22fc: 8fb00010 lw s0,16(sp)
2300: 03e00008 jr ra
2304: 27bd0028 addiu sp,sp,40
00002308 <e1000_setup_rctl>:
2308: 00802821 move a1,a0
/**
* e1000_setup_rctl - configure the receive control register
* @adapter: Board private structure
**/
static void
e1000_setup_rctl(struct e1000_adapter *adapter)
{
uint32_t rctl;
/* Setup the Receive Control Register */
rctl =
230c: 8ca20040 lw v0,64(a1)
E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
E1000_RCTL_RDMTS_HALF | (adapter->shared.
mc_filter_type << E1000_RCTL_MO_SHIFT);
if(adapter->shared.tbi_compatibility_on == 1)
2310: 8ca40060 lw a0,96(a1)
2314: 24030001 li v1,1
2318: 00021300 sll v0,v0,0xc
231c: 14830002 bne a0,v1,2328 <e1000_setup_rctl+0x20>
2320: 34468002 ori a2,v0,0x8002
rctl |= E1000_RCTL_SBP;
2324: 34468006 ori a2,v0,0x8006
switch (adapter->rx_buffer_len) {
2328: 8ca300b8 lw v1,184(a1)
232c: 24021000 li v0,4096
2330: 1062000c beq v1,v0,2364 <e1000_setup_rctl+0x5c>
2334: 3c020203 lui v0,0x203
2338: 2c621001 sltiu v0,v1,4097
233c: 5440000c bnezl v0,2370 <e1000_setup_rctl+0x68>
2340: 8ca2000c lw v0,12(a1)
2344: 24022000 li v0,8192
2348: 10620006 beq v1,v0,2364 <e1000_setup_rctl+0x5c>
234c: 3c020202 lui v0,0x202
2350: 24024000 li v0,16384
2354: 50620003 beql v1,v0,2364 <e1000_setup_rctl+0x5c>
2358: 3c020201 lui v0,0x201
235c: 080008dc j 2370 <e1000_setup_rctl+0x68>
2360: 8ca2000c lw v0,12(a1)
case E1000_RXBUFFER_2048:
default:
rctl |= E1000_RCTL_SZ_2048;
break;
case E1000_RXBUFFER_4096:
rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
break;
case E1000_RXBUFFER_8192:
rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
break;
case E1000_RXBUFFER_16384:
rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2364: 34420020 ori v0,v0,0x20
2368: 00c23025 or a2,a2,v0
break;
}
236c: 8ca2000c lw v0,12(a1)
2370: 2c420002 sltiu v0,v0,2
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2374: 30c3ff00 andi v1,a2,0xff00
2378: 00031a00 sll v1,v1,0x8
237c: 00061600 sll v0,a2,0x18
2380: 00062202 srl a0,a2,0x8
2384: 00431025 or v0,v0,v1
E1000_WRITE_REG(&adapter->shared, RCTL, rctl);
2388: 8ca50008 lw a1,8(a1)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
238c: 3084ff00 andi a0,a0,0xff00
2390: 00441025 or v0,v0,a0
2394: 00061e02 srl v1,a2,0x18
2398: 00431025 or v0,v0,v1
239c: aca20100 sw v0,256(a1)
}
23a0: 03e00008 jr ra
23a4: 00000000 nop
000023a8 <e1000_configure_rx>:
23a8: 00804021 move t0,a0
/**
* e1000_configure_rx - Configure 8254x Receive Unit after Reset
* @adapter: board private structure
*
* Configure the Rx unit of the MAC after a reset.
**/
static void
e1000_configure_rx(struct e1000_adapter *adapter)
{
uint32_t rctl;
23ac: 8d04000c lw a0,12(t0)
23b0: 00803821 move a3,a0
23b4: 2ce20002 sltiu v0,a3,2
uint32_t rxcsum;
/* make sure receives are disabled while setting up the descriptor ring */
rctl = E1000_READ_REG(&adapter->shared, RCTL);
23b8: 8d060008 lw a2,8(t0)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
23bc: 8cc50100 lw a1,256(a2)
return __arch__swab32(x);
23c0: 30a3ff00 andi v1,a1,0xff00
23c4: 00052600 sll a0,a1,0x18
23c8: 00051202 srl v0,a1,0x8
23cc: 00031a00 sll v1,v1,0x8
23d0: 00832025 or a0,a0,v1
23d4: 3042ff00 andi v0,v0,0xff00
23d8: 00822025 or a0,a0,v0
23dc: 00052e02 srl a1,a1,0x18
23e0: 00854825 or t1,a0,a1
23e4: 2ce20002 sltiu v0,a3,2
E1000_WRITE_REG(&adapter->shared, RCTL, rctl & ~E1000_RCTL_EN);
23e8: 2404fffd li a0,-3
23ec: 01242024 and a0,t1,a0
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
23f0: 312200fd andi v0,t1,0xfd
23f4: 312aff00 andi t2,t1,0xff00
23f8: 00041a02 srl v1,a0,0x8
23fc: 00021600 sll v0,v0,0x18
2400: 000a2a00 sll a1,t2,0x8
2404: 00451025 or v0,v0,a1
2408: 3063ff00 andi v1,v1,0xff00
240c: 00431025 or v0,v0,v1
2410: 00042602 srl a0,a0,0x18
2414: 00441025 or v0,v0,a0
2418: acc20100 sw v0,256(a2)
241c: 8d02000c lw v0,12(t0)
2420: 2c420002 sltiu v0,v0,2
2424: 14400010 bnez v0,2468 <e1000_configure_rx+0xc0>
2428: 8d040130 lw a0,304(t0)
242c: 3c028000 lui v0,0x8000
2430: 8d060008 lw a2,8(t0)
2434: 00822025 or a0,a0,v0
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2438: 3085ff00 andi a1,a0,0xff00
243c: 00041600 sll v0,a0,0x18
2440: 00041a02 srl v1,a0,0x8
2444: 00052a00 sll a1,a1,0x8
2448: 00451025 or v0,v0,a1
244c: 3063ff00 andi v1,v1,0xff00
2450: 00431025 or v0,v0,v1
2454: 00042602 srl a0,a0,0x18
2458: 00441025 or v0,v0,a0
/* set the Receive Delay Timer Register */
E1000_WRITE_REG(&adapter->shared, RDTR,
245c: acc22820 sw v0,10272(a2)
2460: 08000928 j 24a0 <e1000_configure_rx+0xf8>
2464: 8d02000c lw v0,12(t0)
2468: 3c028000 lui v0,0x8000
246c: 8d060008 lw a2,8(t0)
2470: 00822025 or a0,a0,v0
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2474: 3085ff00 andi a1,a0,0xff00
2478: 00041600 sll v0,a0,0x18
247c: 00041a02 srl v1,a0,0x8
2480: 00052a00 sll a1,a1,0x8
2484: 00451025 or v0,v0,a1
2488: 3063ff00 andi v1,v1,0xff00
248c: 00431025 or v0,v0,v1
2490: 00042602 srl a0,a0,0x18
2494: 00441025 or v0,v0,a0
2498: acc20108 sw v0,264(a2)
249c: 8d02000c lw v0,12(t0)
24a0: 2c420002 sltiu v0,v0,2
24a4: 1440000e bnez v0,24e0 <e1000_configure_rx+0x138>
24a8: 8d050114 lw a1,276(t0)
24ac: 8d060008 lw a2,8(t0)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
24b0: 30a4ff00 andi a0,a1,0xff00
24b4: 00051600 sll v0,a1,0x18
24b8: 00051a02 srl v1,a1,0x8
24bc: 00042200 sll a0,a0,0x8
24c0: 00441025 or v0,v0,a0
24c4: 3063ff00 andi v1,v1,0xff00
24c8: 00431025 or v0,v0,v1
24cc: 00052e02 srl a1,a1,0x18
24d0: 00451025 or v0,v0,a1
adapter->rx_int_delay | E1000_RDT_FPDB);
/* Setup the Base and Length of the Rx Descriptor Ring */
/* rx_ring.dma can be either a 32 or 64 bit value */
#if (BITS_PER_LONG == 32)
E1000_WRITE_REG(&adapter->shared, RDBAL, adapter->rx_ring.dma);
24d4: acc22800 sw v0,10240(a2)
24d8: 08000944 j 2510 <e1000_configure_rx+0x168>
24dc: 8d02000c lw v0,12(t0)
24e0: 8d060008 lw a2,8(t0)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
24e4: 30a4ff00 andi a0,a1,0xff00
24e8: 00051600 sll v0,a1,0x18
24ec: 00051a02 srl v1,a1,0x8
24f0: 00042200 sll a0,a0,0x8
24f4: 00441025 or v0,v0,a0
24f8: 3063ff00 andi v1,v1,0xff00
24fc: 00431025 or v0,v0,v1
2500: 00052e02 srl a1,a1,0x18
2504: 00451025 or v0,v0,a1
2508: acc20110 sw v0,272(a2)
250c: 8d02000c lw v0,12(t0)
2510: 2c420002 sltiu v0,v0,2
2514: 14400004 bnez v0,2528 <e1000_configure_rx+0x180>
2518: 8d020008 lw v0,8(t0)
E1000_WRITE_REG(&adapter->shared, RDBAH, 0);
251c: ac402804 sw zero,10244(v0)
2520: 0800094c j 2530 <e1000_configure_rx+0x188>
2524: 8d02000c lw v0,12(t0)
2528: ac400114 sw zero,276(v0)
252c: 8d02000c lw v0,12(t0)
2530: 2c420002 sltiu v0,v0,2
2534: 1440000f bnez v0,2574 <e1000_configure_rx+0x1cc>
2538: 8d04011c lw a0,284(t0)
253c: 8d060008 lw a2,8(t0)
2540: 00042100 sll a0,a0,0x4
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2544: 3085ff00 andi a1,a0,0xff00
2548: 00041600 sll v0,a0,0x18
254c: 00041a02 srl v1,a0,0x8
2550: 00052a00 sll a1,a1,0x8
2554: 00451025 or v0,v0,a1
2558: 3063ff00 andi v1,v1,0xff00
255c: 00431025 or v0,v0,v1
2560: 00042602 srl a0,a0,0x18
2564: 00441025 or v0,v0,a0
#elif ( BITS_PER_LONG == 64)
E1000_WRITE_REG(&adapter->shared, RDBAL,
(uint32_t) (adapter->rx_ring.dma & 0x00000000FFFFFFFF));
E1000_WRITE_REG(&adapter->shared, RDBAH,
(uint32_t) (adapter->rx_ring.dma >> 32));
#else
#error "Unsupported System - does not use 32 or 64 bit pointers!"
#endif
E1000_WRITE_REG(&adapter->shared, RDLEN,
2568: acc22808 sw v0,10248(a2)
256c: 0800096a j 25a8 <e1000_configure_rx+0x200>
2570: 8d02000c lw v0,12(t0)
2574: 8d060008 lw a2,8(t0)
2578: 00042100 sll a0,a0,0x4
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
257c: 3085ff00 andi a1,a0,0xff00
2580: 00041600 sll v0,a0,0x18
2584: 00041a02 srl v1,a0,0x8
2588: 00052a00 sll a1,a1,0x8
258c: 00451025 or v0,v0,a1
2590: 3063ff00 andi v1,v1,0xff00
2594: 00431025 or v0,v0,v1
2598: 00042602 srl a0,a0,0x18
259c: 00441025 or v0,v0,a0
25a0: acc20118 sw v0,280(a2)
25a4: 8d02000c lw v0,12(t0)
25a8: 2c420002 sltiu v0,v0,2
25ac: 14400004 bnez v0,25c0 <e1000_configure_rx+0x218>
25b0: 8d020008 lw v0,8(t0)
adapter->rx_ring.count * sizeof(struct e1000_rx_desc));
/* Setup the HW Rx Head and Tail Descriptor Pointers */
E1000_WRITE_REG(&adapter->shared, RDH, 0);
25b4: ac402810 sw zero,10256(v0)
25b8: 08000972 j 25c8 <e1000_configure_rx+0x220>
25bc: 8d02000c lw v0,12(t0)
25c0: ac400120 sw zero,288(v0)
25c4: 8d02000c lw v0,12(t0)
25c8: 2c420002 sltiu v0,v0,2
25cc: 14400004 bnez v0,25e0 <e1000_configure_rx+0x238>
25d0: 8d020008 lw v0,8(t0)
E1000_WRITE_REG(&adapter->shared, RDT, 0);
25d4: ac402818 sw zero,10264(v0)
25d8: 0800097a j 25e8 <e1000_configure_rx+0x240>
25dc: 8d04000c lw a0,12(t0)
25e0: ac400128 sw zero,296(v0)
/* Enable 82543 Receive Checksum Offload for TCP and UDP */
if((adapter->shared.mac_type >= e1000_82543) &&
25e4: 8d04000c lw a0,12(t0)
25e8: 2c820002 sltiu v0,a0,2
25ec: 54400026 bnezl v0,2688 <e1000_configure_rx+0x2e0>
25f0: 000a2200 sll a0,t2,0x8
25f4: 8d0301b0 lw v1,432(t0)
25f8: 24020001 li v0,1
25fc: 1462001a bne v1,v0,2668 <e1000_configure_rx+0x2c0>
2600: 2c820002 sltiu v0,a0,2
(adapter->RxChecksum == TRUE)) {
rxcsum = E1000_READ_REG(&adapter->shared, RXCSUM);
2604: 8d070008 lw a3,8(t0)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2608: 3c0600ff lui a2,0xff
260c: 8ce55000 lw a1,20480(a3)
2610: 30a4ff00 andi a0,a1,0xff00
2614: 00a61024 and v0,a1,a2
2618: 00042200 sll a0,a0,0x8
261c: 00051e00 sll v1,a1,0x18
2620: 00641825 or v1,v1,a0
2624: 00021202 srl v0,v0,0x8
2628: 00621825 or v1,v1,v0
262c: 00052e02 srl a1,a1,0x18
2630: 00651825 or v1,v1,a1
rxcsum |= E1000_RXCSUM_TUOFL;
2634: 34630200 ori v1,v1,0x200
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2638: 3064ff00 andi a0,v1,0xff00
263c: 00042200 sll a0,a0,0x8
2640: 00663024 and a2,v1,a2
2644: 00031600 sll v0,v1,0x18
2648: 00441025 or v0,v0,a0
264c: 00063202 srl a2,a2,0x8
2650: 00461025 or v0,v0,a2
2654: 00031e02 srl v1,v1,0x18
2658: 00431025 or v0,v0,v1
E1000_WRITE_REG(&adapter->shared, RXCSUM, rxcsum);
265c: ace25000 sw v0,20480(a3)
2660: 8d04000c lw a0,12(t0)
}
#if defined(CONFIG_PPC) || defined(CONFIG_MIPS)
if(adapter->shared.mac_type >= e1000_82543) {
2664: 2c820002 sltiu v0,a0,2
2668: 14400007 bnez v0,2688 <e1000_configure_rx+0x2e0>
266c: 000a2200 sll a0,t2,0x8
E1000_WRITE_REG(&adapter->shared, RXDCTL, 0x00020000);
2670: 8d040008 lw a0,8(t0)
2674: 24030200 li v1,512
2678: ac832828 sw v1,10280(a0)
}
267c: 8d02000c lw v0,12(t0)
2680: 2c420002 sltiu v0,v0,2
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2684: 000a2200 sll a0,t2,0x8
2688: 00091600 sll v0,t1,0x18
268c: 00091a02 srl v1,t1,0x8
2690: 00441025 or v0,v0,a0
#endif
/* Enable Receives */
E1000_WRITE_REG(&adapter->shared, RCTL, rctl);
2694: 8d050008 lw a1,8(t0)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2698: 3063ff00 andi v1,v1,0xff00
269c: 00431025 or v0,v0,v1
26a0: 00092602 srl a0,t1,0x18
26a4: 00441025 or v0,v0,a0
26a8: aca20100 sw v0,256(a1)
return;
}
26ac: 03e00008 jr ra
26b0: 00000000 nop
000026b4 <e1000_free_tx_resources>:
26b4: 27bdffe0 addiu sp,sp,-32
26b8: afbf0018 sw ra,24(sp)
26bc: afb00010 sw s0,16(sp)
26c0: afb10014 sw s1,20(sp)
26c4: 00808021 move s0,a0
/**
* e1000_free_tx_resources - Free Tx Resources
* @adapter: board private structure
*
* Free all transmit software resources
**/
static void
e1000_free_tx_resources(struct e1000_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
E1000_DBG("e1000_free_tx_resources\n");
e1000_clean_tx_ring(adapter);
26c8: 3c020000 lui v0,0x0
26cc: 24422720 addiu v0,v0,10016
26d0: 0040f809 jalr v0
26d4: 8e11014c lw s1,332(s0)
kfree(adapter->tx_ring.buffer_info);
26d8: 3c020000 lui v0,0x0
26dc: 24420000 addiu v0,v0,0
26e0: 0040f809 jalr v0
26e4: 8e040100 lw a0,256(s0)
adapter->tx_ring.buffer_info = NULL;
pci_free_consistent(pdev, adapter->tx_ring.size, adapter->tx_ring.desc,
26e8: 8e0500ec lw a1,236(s0)
26ec: 8e0600e4 lw a2,228(s0)
26f0: 8e0700e8 lw a3,232(s0)
26f4: 02202021 move a0,s1
26f8: 3c020000 lui v0,0x0
26fc: 24420000 addiu v0,v0,0
2700: 0040f809 jalr v0
2704: ae000100 sw zero,256(s0)
adapter->tx_ring.dma);
adapter->tx_ring.desc = NULL;
return;
}
2708: 8fbf0018 lw ra,24(sp)
270c: ae0000e4 sw zero,228(s0)
2710: 8fb10014 lw s1,20(sp)
2714: 8fb00010 lw s0,16(sp)
2718: 03e00008 jr ra
271c: 27bd0020 addiu sp,sp,32
00002720 <e1000_clean_tx_ring>:
2720: 27bdffd0 addiu sp,sp,-48
2724: afb10014 sw s1,20(sp)
2728: afb00010 sw s0,16(sp)
272c: afbf0028 sw ra,40(sp)
2730: afb50024 sw s5,36(sp)
2734: afb40020 sw s4,32(sp)
2738: afb3001c sw s3,28(sp)
273c: afb20018 sw s2,24(sp)
2740: 00808821 move s1,a0
/**
* e1000_clean_tx_ring - Free Tx Buffers
* @adapter: board private structure
**/
static void
e1000_clean_tx_ring(struct e1000_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
unsigned long size;
int i;
/* Free all the Tx ring sk_buffs */
for(i = 0; i < adapter->tx_ring.count; i++) {
2744: 8e2700f0 lw a3,240(s1)
2748: 10e00026 beqz a3,27e4 <e1000_clean_tx_ring+0xc4>
274c: 00008021 move s0,zero
2750: 8e250100 lw a1,256(s1)
2754: 3c150000 lui s5,0x0
2758: 26b50000 addiu s5,s5,0
275c: 0000a021 move s4,zero
2760: 00009821 move s3,zero
2764: 00009021 move s2,zero
if(adapter->tx_ring.buffer_info[i].skb != NULL) {
2768: 02451021 addu v0,s2,a1
276c: 8c430000 lw v1,0(v0)
pci_unmap_page(pdev, adapter->tx_ring.buffer_info[i].dma,
adapter->tx_ring.buffer_info[i].length,
PCI_DMA_TODEVICE);
dev_kfree_skb(adapter->tx_ring.buffer_info[i].skb);
2770: 02652021 addu a0,s3,a1
2774: 10600013 beqz v1,27c4 <e1000_clean_tx_ring+0xa4>
2778: 24060001 li a2,1
* hit zero.
*/
static inline void kfree_skb(struct sk_buff *skb)
{
277c: 8c840000 lw a0,0(a0)
if (atomic_read(&skb->users) == 1 || atomic_dec_and_test(&skb->users))
2780: 8c820070 lw v0,112(a0)
2784: 10460008 beq v0,a2,27a8 <e1000_clean_tx_ring+0x88>
2788: 24850070 addiu a1,a0,112
extern __inline__ int atomic_sub_return(int i, atomic_t * v)
{
unsigned long temp, result;
__asm__ __volatile__(
278c: c0a30000 ll v1,0(a1)
2790: 00661023 subu v0,v1,a2
2794: e0a20000 sc v0,0(a1)
2798: 1040fffc beqz v0,278c <e1000_clean_tx_ring+0x6c>
279c: 00661023 subu v0,v1,a2
*/
static inline void kfree_skb(struct sk_buff *skb)
{
if (atomic_read(&skb->users) == 1 || atomic_dec_and_test(&skb->users))
27a0: 54400004 bnezl v0,27b4 <e1000_clean_tx_ring+0x94>
27a4: 8e220100 lw v0,256(s1)
__kfree_skb(skb);
27a8: 02a0f809 jalr s5
27ac: 00000000 nop
adapter->tx_ring.buffer_info[i].skb = NULL;
27b0: 8e220100 lw v0,256(s1)
27b4: 02821021 addu v0,s4,v0
27b8: ac400000 sw zero,0(v0)
27bc: 8e250100 lw a1,256(s1)
27c0: 8e2700f0 lw a3,240(s1)
27c4: 26100001 addiu s0,s0,1
27c8: 0207102b sltu v0,s0,a3
27cc: 26940018 addiu s4,s4,24
27d0: 26730018 addiu s3,s3,24
27d4: 1440ffe4 bnez v0,2768 <e1000_clean_tx_ring+0x48>
27d8: 26520018 addiu s2,s2,24
27dc: 080009fb j 27ec <e1000_clean_tx_ring+0xcc>
27e0: 00073040 sll a2,a3,0x1
27e4: 8e250100 lw a1,256(s1)
}
}
size = sizeof(struct e1000_buffer) * adapter->tx_ring.count;
27e8: 00073040 sll a2,a3,0x1
27ec: 00c73021 addu a2,a2,a3
memset(adapter->tx_ring.buffer_info, 0, size);
27f0: 00a02021 move a0,a1
27f4: 3c100000 lui s0,0x0
27f8: 26100000 addiu s0,s0,0
27fc: 000630c0 sll a2,a2,0x3
2800: 0200f809 jalr s0
2804: 00002821 move a1,zero
/* Zero out the descriptor ring */
memset(adapter->tx_ring.desc, 0, adapter->tx_ring.size);
2808: 8e2400e4 lw a0,228(s1)
280c: 8e2600ec lw a2,236(s1)
2810: 0200f809 jalr s0
2814: 00002821 move a1,zero
atomic_set(&adapter->tx_ring.unused, adapter->tx_ring.count);
2818: 8e2300f0 lw v1,240(s1)
adapter->tx_ring.next_to_use = 0;
adapter->tx_ring.next_to_clean = 0;
281c: ae2000fc sw zero,252(s1)
2820: ae2000f8 sw zero,248(s1)
2824: ae2300f4 sw v1,244(s1)
return;
}
2828: 8fbf0028 lw ra,40(sp)
282c: 8fb50024 lw s5,36(sp)
2830: 8fb40020 lw s4,32(sp)
2834: 8fb3001c lw s3,28(sp)
2838: 8fb20018 lw s2,24(sp)
283c: 8fb10014 lw s1,20(sp)
2840: 8fb00010 lw s0,16(sp)
2844: 03e00008 jr ra
2848: 27bd0030 addiu sp,sp,48
0000284c <e1000_free_rx_resources>:
284c: 27bdffe0 addiu sp,sp,-32
2850: afb00010 sw s0,16(sp)
2854: afbf0018 sw ra,24(sp)
2858: 00808021 move s0,a0
285c: afb10014 sw s1,20(sp)
/**
* e1000_free_rx_resources - Free Rx Resources
* @adapter: board private structure
*
* Free all receive software resources
**/
static void
e1000_free_rx_resources(struct e1000_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
2860: 8e11014c lw s1,332(s0)
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
2864: 24030001 li v1,1
2868: 260200d8 addiu v0,s0,216
unsigned long temp;
__asm__ __volatile__(
286c: c0440000 ll a0,0(v0)
2870: 00832021 addu a0,a0,v1
2874: e0440000 sc a0,0(v0)
2878: 1080fffc beqz a0,286c <e1000_free_rx_resources+0x20>
287c: 00000000 nop
E1000_DBG("e1000_free_rx_resources\n");
tasklet_disable(&adapter->rx_fill_tasklet);
e1000_clean_rx_ring(adapter);
2880: 3c020000 lui v0,0x0
2884: 244228d8 addiu v0,v0,10456
2888: 0040f809 jalr v0
288c: 02002021 move a0,s0
kfree(adapter->rx_ring.buffer_info);
2890: 3c020000 lui v0,0x0
2894: 24420000 addiu v0,v0,0
2898: 0040f809 jalr v0
289c: 8e04012c lw a0,300(s0)
adapter->rx_ring.buffer_info = NULL;
pci_free_consistent(pdev, adapter->rx_ring.size, adapter->rx_ring.desc,
28a0: 8e050118 lw a1,280(s0)
28a4: 8e060110 lw a2,272(s0)
28a8: 8e070114 lw a3,276(s0)
28ac: 02202021 move a0,s1
28b0: 3c020000 lui v0,0x0
28b4: 24420000 addiu v0,v0,0
28b8: 0040f809 jalr v0
28bc: ae00012c sw zero,300(s0)
adapter->rx_ring.dma);
adapter->rx_ring.desc = NULL;
return;
}
28c0: 8fbf0018 lw ra,24(sp)
28c4: ae000110 sw zero,272(s0)
28c8: 8fb10014 lw s1,20(sp)
28cc: 8fb00010 lw s0,16(sp)
28d0: 03e00008 jr ra
28d4: 27bd0020 addiu sp,sp,32
000028d8 <e1000_clean_rx_ring>:
28d8: 27bdffd0 addiu sp,sp,-48
28dc: afb10014 sw s1,20(sp)
28e0: afb00010 sw s0,16(sp)
28e4: afbf0028 sw ra,40(sp)
28e8: afb50024 sw s5,36(sp)
28ec: afb40020 sw s4,32(sp)
28f0: afb3001c sw s3,28(sp)
28f4: afb20018 sw s2,24(sp)
28f8: 00808821 move s1,a0
/**
* e1000_clean_rx_ring - Free Rx Buffers
* @adapter: board private structure
**/
static void
e1000_clean_rx_ring(struct e1000_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
unsigned long size;
int i;
/* Free all the Rx ring sk_buffs */
for(i = 0; i < adapter->rx_ring.count; i++) {
28fc: 8e27011c lw a3,284(s1)
2900: 10e00026 beqz a3,299c <e1000_clean_rx_ring+0xc4>
2904: 00008021 move s0,zero
2908: 8e25012c lw a1,300(s1)
290c: 3c150000 lui s5,0x0
2910: 26b50000 addiu s5,s5,0
2914: 0000a021 move s4,zero
2918: 00009821 move s3,zero
291c: 00009021 move s2,zero
if(adapter->rx_ring.buffer_info[i].skb != NULL) {
2920: 02451021 addu v0,s2,a1
2924: 8c430000 lw v1,0(v0)
pci_unmap_single(pdev, adapter->rx_ring.buffer_info[i].dma,
adapter->rx_ring.buffer_info[i].length,
PCI_DMA_FROMDEVICE);
dev_kfree_skb(adapter->rx_ring.buffer_info[i].skb);
2928: 02652021 addu a0,s3,a1
292c: 10600013 beqz v1,297c <e1000_clean_rx_ring+0xa4>
2930: 24060001 li a2,1
* hit zero.
*/
static inline void kfree_skb(struct sk_buff *skb)
{
2934: 8c840000 lw a0,0(a0)
if (atomic_read(&skb->users) == 1 || atomic_dec_and_test(&skb->users))
2938: 8c820070 lw v0,112(a0)
293c: 10460008 beq v0,a2,2960 <e1000_clean_rx_ring+0x88>
2940: 24850070 addiu a1,a0,112
extern __inline__ int atomic_sub_return(int i, atomic_t * v)
{
unsigned long temp, result;
__asm__ __volatile__(
2944: c0a30000 ll v1,0(a1)
2948: 00661023 subu v0,v1,a2
294c: e0a20000 sc v0,0(a1)
2950: 1040fffc beqz v0,2944 <e1000_clean_rx_ring+0x6c>
2954: 00661023 subu v0,v1,a2
*/
static inline void kfree_skb(struct sk_buff *skb)
{
if (atomic_read(&skb->users) == 1 || atomic_dec_and_test(&skb->users))
2958: 54400004 bnezl v0,296c <e1000_clean_rx_ring+0x94>
295c: 8e22012c lw v0,300(s1)
__kfree_skb(skb);
2960: 02a0f809 jalr s5
2964: 00000000 nop
adapter->rx_ring.buffer_info[i].skb = NULL;
2968: 8e22012c lw v0,300(s1)
296c: 02821021 addu v0,s4,v0
2970: ac400000 sw zero,0(v0)
2974: 8e25012c lw a1,300(s1)
2978: 8e27011c lw a3,284(s1)
297c: 26100001 addiu s0,s0,1
2980: 0207102b sltu v0,s0,a3
2984: 26940018 addiu s4,s4,24
2988: 26730018 addiu s3,s3,24
298c: 1440ffe4 bnez v0,2920 <e1000_clean_rx_ring+0x48>
2990: 26520018 addiu s2,s2,24
2994: 08000a69 j 29a4 <e1000_clean_rx_ring+0xcc>
2998: 00073040 sll a2,a3,0x1
299c: 8e25012c lw a1,300(s1)
}
}
size = sizeof(struct e1000_buffer) * adapter->rx_ring.count;
29a0: 00073040 sll a2,a3,0x1
29a4: 00c73021 addu a2,a2,a3
memset(adapter->rx_ring.buffer_info, 0, size);
29a8: 00a02021 move a0,a1
29ac: 3c100000 lui s0,0x0
29b0: 26100000 addiu s0,s0,0
29b4: 000630c0 sll a2,a2,0x3
29b8: 0200f809 jalr s0
29bc: 00002821 move a1,zero
/* Zero out the descriptor ring */
memset(adapter->rx_ring.desc, 0, adapter->rx_ring.size);
29c0: 8e240110 lw a0,272(s1)
29c4: 8e260118 lw a2,280(s1)
29c8: 0200f809 jalr s0
29cc: 00002821 move a1,zero
atomic_set(&adapter->rx_ring.unused, adapter->rx_ring.count);
29d0: 8e23011c lw v1,284(s1)
adapter->rx_ring.next_to_clean = 0;
adapter->rx_ring.next_to_use = 0;
29d4: ae200124 sw zero,292(s1)
29d8: ae200128 sw zero,296(s1)
29dc: ae230120 sw v1,288(s1)
return;
}
29e0: 8fbf0028 lw ra,40(sp)
29e4: 8fb50024 lw s5,36(sp)
29e8: 8fb40020 lw s4,32(sp)
29ec: 8fb3001c lw s3,28(sp)
29f0: 8fb20018 lw s2,24(sp)
29f4: 8fb10014 lw s1,20(sp)
29f8: 8fb00010 lw s0,16(sp)
29fc: 03e00008 jr ra
2a00: 27bd0030 addiu sp,sp,48
00002a04 <e1000_set_multi>:
2a04: 27bdfcd0 addiu sp,sp,-816
2a08: afb40320 sw s4,800(sp)
2a0c: afbf032c sw ra,812(sp)
2a10: afb60328 sw s6,808(sp)
2a14: afb50324 sw s5,804(sp)
2a18: afb3031c sw s3,796(sp)
2a1c: afb20318 sw s2,792(sp)
2a20: afb10314 sw s1,788(sp)
2a24: afb00310 sw s0,784(sp)
2a28: 0080a021 move s4,a0
/**
* e1000_set_multi - Multicast and Promiscuous mode set
* @netdev: network interface device structure
*
* The set_multi entry point is called whenever the multicast address
* list or the network interface flags are updated. This routine is
* resposible for configuring the hardware for proper multicast,
* promiscuous mode, and all-multi behavior.
**/
void
e1000_set_multi(struct net_device *netdev)
{
struct e1000_adapter *adapter = netdev->priv;
2a2c: 8e910064 lw s1,100(s4)
struct pci_dev *pdev = adapter->pdev;
2a30: 8e33000c lw s3,12(s1)
2a34: 8e35014c lw s5,332(s1)
2a38: 2e620002 sltiu v0,s3,2
uint32_t rctl;
uint8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
uint16_t pci_command_word;
struct dev_mc_list *mc_ptr;
int i;
E1000_DBG("e1000_set_multi\n");
rctl = E1000_READ_REG(&adapter->shared, RCTL);
2a3c: 8e320008 lw s2,8(s1)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
2a40: 8e450100 lw a1,256(s2)
return __arch__swab32(x);
2a44: 30a3ff00 andi v1,a1,0xff00
2a48: 00052600 sll a0,a1,0x18
2a4c: 00051202 srl v0,a1,0x8
2a50: 00031a00 sll v1,v1,0x8
2a54: 00832025 or a0,a0,v1
2a58: 3042ff00 andi v0,v0,0xff00
2a5c: 00822025 or a0,a0,v0
2a60: 00052e02 srl a1,a1,0x18
if(adapter->shared.mac_type == e1000_82542_rev2_0) {
2a64: 1660002d bnez s3,2b1c <e1000_set_multi+0x118>
2a68: 00858025 or s0,a0,a1
if(adapter->shared.pci_cmd_word & PCI_COMMAND_INVALIDATE) {
2a6c: 9626004a lhu a2,74(s1)
2a70: 30c20010 andi v0,a2,0x10
2a74: 10400006 beqz v0,2a90 <e1000_set_multi+0x8c>
2a78: 30c6ffef andi a2,a2,0xffef
pci_command_word =
adapter->shared.pci_cmd_word & ~PCI_COMMAND_INVALIDATE;
pci_write_config_word(pdev, PCI_COMMAND, pci_command_word);
2a7c: 02a02021 move a0,s5
2a80: 3c020000 lui v0,0x0
2a84: 24420000 addiu v0,v0,0
2a88: 0040f809 jalr v0
2a8c: 24050004 li a1,4
}
rctl |= E1000_RCTL_RST;
2a90: 36100001 ori s0,s0,0x1
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2a94: 3204ff00 andi a0,s0,0xff00
2a98: 00042200 sll a0,a0,0x8
2a9c: 00101e00 sll v1,s0,0x18
2aa0: 00101202 srl v0,s0,0x8
2aa4: 00641825 or v1,v1,a0
2aa8: 3042ff00 andi v0,v0,0xff00
2aac: 00621825 or v1,v1,v0
2ab0: 00102602 srl a0,s0,0x18
2ab4: 00641825 or v1,v1,a0
E1000_WRITE_REG(&adapter->shared, RCTL, rctl);
2ab8: ae430100 sw v1,256(s2)
extern __inline__ void __udelay(unsigned long usecs, unsigned long lpj)
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
2abc: 3c027fff lui v0,0x7fff
2ac0: 3c030000 lui v1,0x0
2ac4: 8c630000 lw v1,0(v1)
2ac8: 3442f1c0 ori v0,v0,0xf1c0
__asm__("multu\t%2,%3"
2acc: 00430019 multu v0,v1
2ad0: 00001010 mfhi v0
...
2adc: 1440ffff bnez v0,2adc <e1000_set_multi+0xd8>
2ae0: 2442ffff addiu v0,v0,-1
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
2ae4: 8e23008c lw v1,140(s1)
2ae8: 30630001 andi v1,v1,0x1
mdelay(5);
if(test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
2aec: 1060000b beqz v1,2b1c <e1000_set_multi+0x118>
2af0: 24030001 li v1,1
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
2af4: 262200d8 addiu v0,s1,216
unsigned long temp;
__asm__ __volatile__(
2af8: c0440000 ll a0,0(v0)
2afc: 00832021 addu a0,a0,v1
2b00: e0440000 sc a0,0(v0)
2b04: 1080fffc beqz a0,2af8 <e1000_set_multi+0xf4>
2b08: 00000000 nop
tasklet_disable(&adapter->rx_fill_tasklet);
e1000_clean_rx_ring(adapter);
2b0c: 3c020000 lui v0,0x0
2b10: 244228d8 addiu v0,v0,10456
2b14: 0040f809 jalr v0
2b18: 02202021 move a0,s1
}
}
/* Check for Promiscuous and All Multicast modes */
if(netdev->flags & IFF_PROMISC) {
2b1c: 96830054 lhu v1,84(s4)
2b20: 30620100 andi v0,v1,0x100
2b24: 10400003 beqz v0,2b34 <e1000_set_multi+0x130>
2b28: 30620200 andi v0,v1,0x200
rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
} else if(netdev->flags & IFF_ALLMULTI) {
2b2c: 08000ad3 j 2b4c <e1000_set_multi+0x148>
2b30: 36100018 ori s0,s0,0x18
2b34: 10400003 beqz v0,2b44 <e1000_set_multi+0x140>
2b38: 2402fff7 li v0,-9
rctl |= E1000_RCTL_MPE;
rctl &= ~E1000_RCTL_UPE;
} else {
2b3c: 08000ad2 j 2b48 <e1000_set_multi+0x144>
2b40: 36100010 ori s0,s0,0x10
rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
2b44: 2402ffe7 li v0,-25
2b48: 02028024 and s0,s0,v0
}
if(netdev->mc_count > MAX_NUM_MULTICAST_ADDRESSES) {
2b4c: 8e820084 lw v0,132(s4)
2b50: 28420081 slti v0,v0,129
2b54: 1440000e bnez v0,2b90 <e1000_set_multi+0x18c>
2b58: 2e620002 sltiu v0,s3,2
rctl |= E1000_RCTL_MPE;
2b5c: 36100010 ori s0,s0,0x10
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2b60: 3204ff00 andi a0,s0,0xff00
2b64: 00042200 sll a0,a0,0x8
2b68: 00101600 sll v0,s0,0x18
2b6c: 00101a02 srl v1,s0,0x8
2b70: 00441025 or v0,v0,a0
2b74: 3063ff00 andi v1,v1,0xff00
2b78: 00431025 or v0,v0,v1
2b7c: 00102602 srl a0,s0,0x18
2b80: 00441025 or v0,v0,a0
E1000_WRITE_REG(&adapter->shared, RCTL, rctl);
2b84: ae420100 sw v0,256(s2)
} else {
2b88: 08000b05 j 2c14 <e1000_set_multi+0x210>
2b8c: 8e22000c lw v0,12(s1)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2b90: 3204ff00 andi a0,s0,0xff00
2b94: 00042200 sll a0,a0,0x8
2b98: 00101600 sll v0,s0,0x18
2b9c: 00101a02 srl v1,s0,0x8
2ba0: 00441025 or v0,v0,a0
2ba4: 3063ff00 andi v1,v1,0xff00
2ba8: 00431025 or v0,v0,v1
2bac: 00102602 srl a0,s0,0x18
2bb0: 00441025 or v0,v0,a0
E1000_WRITE_REG(&adapter->shared, RCTL, rctl);
2bb4: ae420100 sw v0,256(s2)
for(i = 0, mc_ptr = netdev->mc_list; mc_ptr; i++, mc_ptr = mc_ptr->next)
2bb8: 8e820080 lw v0,128(s4)
2bbc: 5040000e beqzl v0,2bf8 <e1000_set_multi+0x1f4>
2bc0: 8e860084 lw a2,132(s4)
2bc4: 02c01821 move v1,s6
memcpy(&mta[i * ETH_LENGTH_OF_ADDRESS], mc_ptr->dmi_addr,
2bc8: 88440004 lwl a0,4(v0)
2bcc: 98440007 lwr a0,7(v0)
2bd0: 80450008 lb a1,8(v0)
2bd4: 80460009 lb a2,9(v0)
2bd8: a8640000 swl a0,0(v1)
2bdc: b8640003 swr a0,3(v1)
2be0: a0650004 sb a1,4(v1)
2be4: a0660005 sb a2,5(v1)
2be8: 8c420000 lw v0,0(v0)
2bec: 1440fff6 bnez v0,2bc8 <e1000_set_multi+0x1c4>
2bf0: 24630006 addiu v1,v1,6
ETH_LENGTH_OF_ADDRESS);
e1000_mc_addr_list_update(&adapter->shared, mta, netdev->mc_count, 0);
2bf4: 8e860084 lw a2,132(s4)
2bf8: 26240008 addiu a0,s1,8
2bfc: 27a50010 addiu a1,sp,16
2c00: 3c020000 lui v0,0x0
2c04: 24420000 addiu v0,v0,0
2c08: 0040f809 jalr v0
2c0c: 00003821 move a3,zero
}
if(adapter->shared.mac_type == e1000_82542_rev2_0) {
2c10: 8e22000c lw v0,12(s1)
2c14: 1440003b bnez v0,2d04 <e1000_set_multi+0x300>
2c18: 8fbf032c lw ra,812(sp)
rctl = E1000_READ_REG(&adapter->shared, RCTL);
2c1c: 8e280008 lw t0,8(s1)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2c20: 3c0700ff lui a3,0xff
extern __inline__ void __udelay(unsigned long usecs, unsigned long lpj)
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
2c24: 3c067fff lui a2,0x7fff
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
2c28: 8d020100 lw v0,256(t0)
extern __inline__ void __udelay(unsigned long usecs, unsigned long lpj)
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
2c2c: 34c6f1c0 ori a2,a2,0xf1c0
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2c30: 3043ff00 andi v1,v0,0xff00
2c34: 00472024 and a0,v0,a3
2c38: 00031a00 sll v1,v1,0x8
2c3c: 00022e00 sll a1,v0,0x18
2c40: 00a32825 or a1,a1,v1
2c44: 00042202 srl a0,a0,0x8
2c48: 00021602 srl v0,v0,0x18
2c4c: 00a42825 or a1,a1,a0
rctl &= ~E1000_RCTL_RST;
2c50: 304200fe andi v0,v0,0xfe
2c54: 00458025 or s0,v0,a1
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
2c58: 3204ff00 andi a0,s0,0xff00
2c5c: 00042200 sll a0,a0,0x8
2c60: 02073824 and a3,s0,a3
2c64: 00101e00 sll v1,s0,0x18
2c68: 00641825 or v1,v1,a0
2c6c: 00073a02 srl a3,a3,0x8
2c70: 00101602 srl v0,s0,0x18
2c74: 00671825 or v1,v1,a3
2c78: 00621825 or v1,v1,v0
E1000_WRITE_REG(&adapter->shared, RCTL, rctl);
2c7c: ad030100 sw v1,256(t0)
* first constant multiplications gets optimized away if the delay is
* a constant)
*/
extern __inline__ void __udelay(unsigned long usecs, unsigned long lpj)
{
2c80: 3c020000 lui v0,0x0
2c84: 8c420000 lw v0,0(v0)
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
__asm__("multu\t%2,%3"
2c88: 00c20019 multu a2,v0
2c8c: 00003010 mfhi a2
...
2c98: 14c0ffff bnez a2,2c98 <e1000_set_multi+0x294>
2c9c: 24c6ffff addiu a2,a2,-1
mdelay(5);
if(adapter->shared.pci_cmd_word & PCI_COMMAND_INVALIDATE) {
2ca0: 9622004a lhu v0,74(s1)
2ca4: 30420010 andi v0,v0,0x10
2ca8: 10400006 beqz v0,2cc4 <e1000_set_multi+0x2c0>
2cac: 02a02021 move a0,s5
pci_write_config_word(pdev, PCI_COMMAND,
2cb0: 9626004a lhu a2,74(s1)
2cb4: 3c020000 lui v0,0x0
2cb8: 24420000 addiu v0,v0,0
2cbc: 0040f809 jalr v0
2cc0: 24050004 li a1,4
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
2cc4: 8e22008c lw v0,140(s1)
2cc8: 30420001 andi v0,v0,0x1
adapter->shared.pci_cmd_word);
}
if(test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
2ccc: 1040000d beqz v0,2d04 <e1000_set_multi+0x300>
2cd0: 8fbf032c lw ra,812(sp)
e1000_configure_rx(adapter);
2cd4: 3c020000 lui v0,0x0
2cd8: 244223a8 addiu v0,v0,9128
2cdc: 0040f809 jalr v0
2ce0: 02202021 move a0,s1
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
2ce4: 262300d8 addiu v1,s1,216
2ce8: 24020001 li v0,1
unsigned long temp;
__asm__ __volatile__(
2cec: c0640000 ll a0,0(v1)
2cf0: 00822023 subu a0,a0,v0
2cf4: e0640000 sc a0,0(v1)
2cf8: 1080fffc beqz a0,2cec <e1000_set_multi+0x2e8>
2cfc: 00000000 nop
tasklet_enable(&adapter->rx_fill_tasklet);
}
}
return;
}
2d00: 8fbf032c lw ra,812(sp)
2d04: 8fb60328 lw s6,808(sp)
2d08: 8fb50324 lw s5,804(sp)
2d0c: 8fb40320 lw s4,800(sp)
2d10: 8fb3031c lw s3,796(sp)
2d14: 8fb20318 lw s2,792(sp)
2d18: 8fb10314 lw s1,788(sp)
2d1c: 8fb00310 lw s0,784(sp)
2d20: 03e00008 jr ra
2d24: 27bd0330 addiu sp,sp,816
00002d28 <e1000_watchdog>:
2d28: 27bdffd0 addiu sp,sp,-48
2d2c: afb50024 sw s5,36(sp)
2d30: afb40020 sw s4,32(sp)
2d34: afb3001c sw s3,28(sp)
2d38: afbf0028 sw ra,40(sp)
2d3c: afb20018 sw s2,24(sp)
2d40: afb10014 sw s1,20(sp)
2d44: afb00010 sw s0,16(sp)
2d48: 0080a821 move s5,a0
#ifdef IANS
/* flush Tx queue without link */
static void
e1000_tx_flush(struct e1000_adapter *adapter)
{
uint32_t ctrl, txcw, icr;
adapter->int_mask = 0;
e1000_irq_disable(adapter);
synchronize_irq();
if(adapter->shared.mac_type < e1000_82543) {
/* Transmit Unit Reset */
E1000_WRITE_REG(&adapter->shared, TCTL, E1000_TCTL_RST);
E1000_WRITE_REG(&adapter->shared, TCTL, 0);
e1000_clean_tx_ring(adapter);
e1000_configure_tx(adapter);
} else {
/* turn off autoneg, set link up, and invert loss of signal */
txcw = E1000_READ_REG(&adapter->shared, TXCW);
ctrl = E1000_READ_REG(&adapter->shared, CTRL);
E1000_WRITE_REG(&adapter->shared, TXCW, txcw & ~E1000_TXCW_ANE);
E1000_WRITE_REG(&adapter->shared, CTRL,
(ctrl | E1000_CTRL_SLU | E1000_CTRL_ILOS));
/* delay to flush queue, then clean up */
mdelay(20);
e1000_clean_tx_irq(adapter);
E1000_WRITE_REG(&adapter->shared, CTRL, ctrl);
E1000_WRITE_REG(&adapter->shared, TXCW, txcw);
/* clear the link status change interrupts this caused */
icr = E1000_READ_REG(&adapter->shared, ICR);
}
adapter->int_mask = IMS_ENABLE_MASK;
e1000_irq_enable(adapter);
return;
}
#endif
/**
* e1000_watchdog - Timer Call-back
* @data: pointer to netdev cast into an unsigned long
**/
void
e1000_watchdog(unsigned long data)
{
struct net_device *netdev = (struct net_device *) data;
struct e1000_adapter *adapter = netdev->priv;
2d4c: 8eb20064 lw s2,100(s5)
#ifdef IANS
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
int flags;
#endif
#endif
e1000_check_for_link(&adapter->shared);
2d50: 3c020000 lui v0,0x0
2d54: 24420000 addiu v0,v0,0
2d58: 26540008 addiu s4,s2,8
2d5c: 0040f809 jalr v0
2d60: 02802021 move a0,s4
* It also implies a memory barrier.
*/
extern __inline__ int
test_and_clear_bit(int nr, volatile void *addr)
{
2d64: 2653008c addiu s3,s2,140
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
2d68: 24020008 li v0,8
2d6c: c2640000 ll a0,0(s3)
2d70: 00821825 or v1,a0,v0
2d74: 00621826 xor v1,v1,v0
2d78: e2630000 sc v1,0(s3)
2d7c: 1060fffb beqz v1,2d6c <e1000_watchdog+0x44>
2d80: 00821824 and v1,a0,v0
if (test_and_clear_bit(E1000_LINK_STATUS_CHANGED, &adapter->flags))
2d84: 50600007 beqzl v1,2da4 <e1000_watchdog+0x7c>
2d88: 8e42000c lw v0,12(s2)
e1000_phy_get_info(&adapter->shared, &adapter->phy_info);
2d8c: 264501b8 addiu a1,s2,440
2d90: 3c020000 lui v0,0x0
2d94: 24420000 addiu v0,v0,0
2d98: 0040f809 jalr v0
2d9c: 02802021 move a0,s4
2da0: 8e42000c lw v0,12(s2)
2da4: 2c420002 sltiu v0,v0,2
2da8: 14400008 bnez v0,2dcc <e1000_watchdog+0xa4>
2dac: 8e830000 lw v1,0(s4)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
2db0: 8c620008 lw v0,8(v1)
return __arch__swab32(x);
2db4: 00021602 srl v0,v0,0x18
if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU) {
2db8: 30420002 andi v0,v0,0x2
2dbc: 14400008 bnez v0,2de0 <e1000_watchdog+0xb8>
2dc0: 8e4200b0 lw v0,176(s2)
2dc4: 08000bc6 j 2f18 <e1000_watchdog+0x1f0>
2dc8: 00000000 nop
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
2dcc: 8c620008 lw v0,8(v1)
return __arch__swab32(x);
2dd0: 00021602 srl v0,v0,0x18
2dd4: 30420002 andi v0,v0,0x2
2dd8: 1040004f beqz v0,2f18 <e1000_watchdog+0x1f0>
2ddc: 8e4200b0 lw v0,176(s2)
if(adapter->link_active != TRUE) {
2de0: 24030001 li v1,1
2de4: 10430058 beq v0,v1,2f48 <e1000_watchdog+0x220>
2de8: 00000000 nop
* It also implies a memory barrier.
*/
extern __inline__ int
test_and_clear_bit(int nr, volatile void *addr)
{
2dec: 26a5002c addiu a1,s5,44
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
2df0: c0a40000 ll a0,0(a1)
2df4: 00831025 or v0,a0,v1
2df8: 00431026 xor v0,v0,v1
2dfc: e0a20000 sc v0,0(a1)
2e00: 1040fffb beqz v0,2df0 <e1000_watchdog+0xc8>
2e04: 00831024 and v0,a0,v1
}
static inline void netif_wake_queue(struct net_device *dev)
{
if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
2e08: 10400025 beqz v0,2ea0 <e1000_watchdog+0x178>
2e0c: 265100b4 addiu s1,s2,180
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
2e10: 24020008 li v0,8
2e14: c0a40000 ll a0,0(a1)
2e18: 00821825 or v1,a0,v0
2e1c: e0a30000 sc v1,0(a1)
2e20: 1060fffc beqz v1,2e14 <e1000_watchdog+0xec>
2e24: 00821824 and v1,a0,v0
#define HAVE_NETIF_QUEUE
static inline void __netif_schedule(struct net_device *dev)
{
if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
2e28: 1460001d bnez v1,2ea0 <e1000_watchdog+0x178>
2e2c: 265100b4 addiu s1,s2,180
unsigned long flags;
int cpu = smp_processor_id();
local_irq_save(flags);
2e30: 40106000 mfc0 s0,$12
2e34: 00000000 nop
2e38: 36010001 ori at,s0,0x1
2e3c: 38210001 xori at,at,0x1
2e40: 40816000 mtc0 at,$12
2e44: 00000040 sll zero,zero,0x1
2e48: 00000040 sll zero,zero,0x1
2e4c: 00000040 sll zero,zero,0x1
dev->next_sched = softnet_data[cpu].output_queue;
2e50: 3c030000 lui v1,0x0
2e54: 8c63001c lw v1,28(v1)
softnet_data[cpu].output_queue = dev;
cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
2e58: 00002021 move a0,zero
2e5c: aea30038 sw v1,56(s5)
2e60: 3c020000 lui v0,0x0
2e64: 24420000 addiu v0,v0,0
2e68: 3c010000 lui at,0x0
2e6c: ac35001c sw s5,28(at)
2e70: 0040f809 jalr v0
2e74: 24050001 li a1,1
local_irq_restore(flags);
2e78: 40016000 mfc0 at,$12
2e7c: 32100001 andi s0,s0,0x1
2e80: 34210001 ori at,at,0x1
2e84: 38210001 xori at,at,0x1
2e88: 02018025 or s0,s0,at
2e8c: 40906000 mtc0 s0,$12
...
#ifdef IANS
if((adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) &&
(adapter->iANSdata->reporting_mode == IANS_STATUS_REPORTING_ON))
if(ans_notify)
ans_notify(netdev, IANS_IND_XMIT_QUEUE_READY);
#endif
netif_wake_queue(netdev);
e1000_get_speed_and_duplex(&adapter->shared, &adapter->link_speed,
2e9c: 265100b4 addiu s1,s2,180
2ea0: 265000b6 addiu s0,s2,182
2ea4: 02003021 move a2,s0
2ea8: 3c020000 lui v0,0x0
2eac: 24420000 addiu v0,v0,0
2eb0: 02802021 move a0,s4
2eb4: 0040f809 jalr v0
2eb8: 02202821 move a1,s1
&adapter->link_duplex);
printk(KERN_ERR "e1000: %s NIC Link is Up %d Mbps %s\n",
2ebc: 96030000 lhu v1,0(s0)
2ec0: 24020002 li v0,2
2ec4: 3c070000 lui a3,0x0
2ec8: 24e70d28 addiu a3,a3,3368
2ecc: 10620003 beq v1,v0,2edc <e1000_watchdog+0x1b4>
2ed0: 96260000 lhu a2,0(s1)
2ed4: 3c070000 lui a3,0x0
2ed8: 24e70d34 addiu a3,a3,3380
2edc: 3c040000 lui a0,0x0
2ee0: 24840d00 addiu a0,a0,3328
2ee4: 3c020000 lui v0,0x0
2ee8: 24420000 addiu v0,v0,0
2eec: 0040f809 jalr v0
2ef0: 02a02821 move a1,s5
netdev->name, adapter->link_speed,
adapter->link_duplex ==
FULL_DUPLEX ? "Full Duplex" : "Half Duplex");
adapter->link_active = TRUE;
2ef4: 24030001 li v1,1
2ef8: ae4300b0 sw v1,176(s2)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
2efc: c2620000 ll v0,0(s3)
2f00: 34420008 ori v0,v0,0x8
2f04: e2620000 sc v0,0(s3)
2f08: 1040fffc beqz v0,2efc <e1000_watchdog+0x1d4>
2f0c: 00000000 nop
set_bit(E1000_LINK_STATUS_CHANGED, &adapter->flags);
}
} else {
2f10: 08000bd2 j 2f48 <e1000_watchdog+0x220>
2f14: 00000000 nop
if(adapter->link_active != FALSE) {
2f18: 1040000b beqz v0,2f48 <e1000_watchdog+0x220>
2f1c: 00000000 nop
adapter->link_speed = 0;
adapter->link_duplex = 0;
printk(KERN_ERR "e1000: %s NIC Link is Down\n", netdev->name);
2f20: 3c040000 lui a0,0x0
2f24: 24840d40 addiu a0,a0,3392
2f28: a64000b4 sh zero,180(s2)
2f2c: a64000b6 sh zero,182(s2)
2f30: 3c020000 lui v0,0x0
2f34: 24420000 addiu v0,v0,0
2f38: 0040f809 jalr v0
2f3c: 02a02821 move a1,s5
adapter->link_active = FALSE;
2f40: ae4000b0 sw zero,176(s2)
atomic_set(&adapter->tx_timeout, 0);
2f44: ae40010c sw zero,268(s2)
}
}
e1000_update_stats(adapter);
2f48: 3c030000 lui v1,0x0
2f4c: 24634044 addiu v1,v1,16452
2f50: 0060f809 jalr v1
2f54: 02402021 move a0,s2
if(atomic_read(&adapter->tx_timeout) > 1)
2f58: 8e42010c lw v0,268(s2)
2f5c: 28420002 slti v0,v0,2
2f60: 54400009 bnezl v0,2f88 <e1000_watchdog+0x260>
2f64: 8e4300b0 lw v1,176(s2)
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
2f68: 24020001 li v0,1
2f6c: 2643010c addiu v1,s2,268
unsigned long temp;
__asm__ __volatile__(
2f70: c0640000 ll a0,0(v1)
2f74: 00822023 subu a0,a0,v0
2f78: e0640000 sc a0,0(v1)
2f7c: 1080fffc beqz a0,2f70 <e1000_watchdog+0x248>
2f80: 00000000 nop
atomic_dec(&adapter->tx_timeout);
if((adapter->link_active == TRUE) &&
2f84: 8e4300b0 lw v1,176(s2)
2f88: 24020001 li v0,1
2f8c: 54620021 bnel v1,v0,3014 <e1000_watchdog+0x2ec>
2f90: 8e620000 lw v0,0(s3)
2f94: 8e42010c lw v0,268(s2)
2f98: 5443001e bnel v0,v1,3014 <e1000_watchdog+0x2ec>
2f9c: 8e620000 lw v0,0(s3)
(atomic_read(&adapter->tx_timeout) == 1)) {
if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_TXOFF) {
2fa0: 8e42000c lw v0,12(s2)
2fa4: 2c420002 sltiu v0,v0,2
2fa8: 14400008 bnez v0,2fcc <e1000_watchdog+0x2a4>
2fac: 8e430008 lw v1,8(s2)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
2fb0: 8c620008 lw v0,8(v1)
return __arch__swab32(x);
2fb4: 00021602 srl v0,v0,0x18
2fb8: 30420010 andi v0,v0,0x10
2fbc: 14400008 bnez v0,2fe0 <e1000_watchdog+0x2b8>
2fc0: 24020003 li v0,3
2fc4: 08000bfb j 2fec <e1000_watchdog+0x2c4>
2fc8: 00000000 nop
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
2fcc: 8c620008 lw v0,8(v1)
return __arch__swab32(x);
2fd0: 00021602 srl v0,v0,0x18
2fd4: 30420010 andi v0,v0,0x10
2fd8: 10400004 beqz v0,2fec <e1000_watchdog+0x2c4>
2fdc: 24020003 li v0,3
atomic_set(&adapter->tx_timeout, 3);
2fe0: ae42010c sw v0,268(s2)
} else {
2fe4: 08000c05 j 3014 <e1000_watchdog+0x2ec>
2fe8: 8e620000 lw v0,0(s3)
e1000_hibernate_adapter(netdev);
2fec: 3c020000 lui v0,0x0
2ff0: 24420000 addiu v0,v0,0
2ff4: 0040f809 jalr v0
2ff8: 02a02021 move a0,s5
#ifdef IANS
if((adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) &&
(adapter->iANSdata->reporting_mode == IANS_STATUS_REPORTING_ON)) {
adapter->link_active = FALSE;
bd_ans_os_Watchdog(netdev, adapter);
adapter->link_active = TRUE;
}
#endif
atomic_set(&adapter->tx_timeout, 0);
2ffc: ae40010c sw zero,268(s2)
e1000_wakeup_adapter(netdev);
3000: 3c020000 lui v0,0x0
3004: 24420000 addiu v0,v0,0
3008: 0040f809 jalr v0
300c: 02a02021 move a0,s5
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
3010: 8e620000 lw v0,0(s3)
3014: 00021042 srl v0,v0,0x1
3018: 30420001 andi v0,v0,0x1
}
}
#ifdef IANS
if(adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) {
if(adapter->iANSdata->reporting_mode == IANS_STATUS_REPORTING_ON)
bd_ans_os_Watchdog(netdev, adapter);
if(adapter->link_active == FALSE) {
/* don't sit on SKBs while link is down */
if(atomic_read(&adapter->tx_ring.unused) < adapter->tx_ring.count) {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
spin_lock_irqsave(&netdev->xmit_lock, flags);
e1000_tx_flush(adapter);
spin_unlock_irqrestore(&netdev->xmit_lock, flags);
#else
e1000_tx_flush(adapter);
#endif
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
spin_lock_irqsave(&netdev->queue_lock, flags);
qdisc_reset(netdev->qdisc);
spin_unlock_irqrestore(&netdev->queue_lock, flags);
#else
qdisc_reset(netdev->qdisc);
#endif
}
}
#endif
if(test_bit(E1000_RX_REFILL, &adapter->flags)) {
301c: 1040000d beqz v0,3054 <e1000_watchdog+0x32c>
3020: 24020001 li v0,1
extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t));
static inline void tasklet_schedule(struct tasklet_struct *t)
{
3024: 264500d0 addiu a1,s2,208
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
3028: c24400d4 ll a0,212(s2)
302c: 00821825 or v1,a0,v0
3030: e24300d4 sc v1,212(s2)
3034: 1060fffc beqz v1,3028 <e1000_watchdog+0x300>
3038: 00821824 and v1,a0,v0
extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t));
static inline void tasklet_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
303c: 14600005 bnez v1,3054 <e1000_watchdog+0x32c>
3040: 00000000 nop
__tasklet_schedule(t);
3044: 3c020000 lui v0,0x0
3048: 24420000 addiu v0,v0,0
304c: 0040f809 jalr v0
3050: 00a02021 move a0,a1
tasklet_schedule(&adapter->rx_fill_tasklet);
}
/* Reset the timer */
mod_timer(&adapter->timer_id, jiffies + 2 * HZ);
3054: 3c050000 lui a1,0x0
3058: 8ca50000 lw a1,0(a1)
305c: 26440094 addiu a0,s2,148
3060: 3c020000 lui v0,0x0
3064: 24420000 addiu v0,v0,0
3068: 0040f809 jalr v0
306c: 24a500c8 addiu a1,a1,200
return;
}
3070: 8fbf0028 lw ra,40(sp)
3074: 8fb50024 lw s5,36(sp)
3078: 8fb40020 lw s4,32(sp)
307c: 8fb3001c lw s3,28(sp)
3080: 8fb20018 lw s2,24(sp)
3084: 8fb10014 lw s1,20(sp)
3088: 8fb00010 lw s0,16(sp)
308c: 03e00008 jr ra
3090: 27bd0030 addiu sp,sp,48
00003094 <e1000_xmit_frame>:
3094: 27bdff80 addiu sp,sp,-128
3098: afbf007c sw ra,124(sp)
309c: afbe0078 sw s8,120(sp)
30a0: afb70074 sw s7,116(sp)
30a4: afb60070 sw s6,112(sp)
30a8: afb5006c sw s5,108(sp)
30ac: afb40068 sw s4,104(sp)
30b0: afb30064 sw s3,100(sp)
30b4: afb20060 sw s2,96(sp)
30b8: afb1005c sw s1,92(sp)
30bc: afb00058 sw s0,88(sp)
30c0: afa50084 sw a1,132(sp)
/**
* e1000_tx_checksum_setup
* @adapter:
* @skb:
* @txd_upper:
* @txd_lower:
**/
static inline void
e1000_tx_checksum_setup(struct e1000_adapter *adapter,
struct sk_buff *skb,
uint32_t *txd_upper,
uint32_t *txd_lower)
{
struct e1000_context_desc *desc;
int i;
if(skb->protocol != __constant_htons(ETH_P_IP)) {
*txd_upper = 0;
*txd_lower = adapter->TxdCmd;
return;
}
switch (skb->nh.iph->protocol) {
case IPPROTO_TCP:
/* Offload TCP checksum */
*txd_upper = E1000_TXD_POPTS_TXSM << 8;
*txd_lower = adapter->TxdCmd | E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
if(adapter->ActiveChecksumContext == OFFLOAD_TCP_IP)
return;
else
adapter->ActiveChecksumContext = OFFLOAD_TCP_IP;
break;
case IPPROTO_UDP:
/* Offload UDP checksum */
*txd_upper = E1000_TXD_POPTS_TXSM << 8;
*txd_lower = adapter->TxdCmd | E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
if(adapter->ActiveChecksumContext == OFFLOAD_UDP_IP)
return;
else
adapter->ActiveChecksumContext = OFFLOAD_UDP_IP;
break;
default:
/* no checksum to offload */
*txd_upper = 0;
*txd_lower = adapter->TxdCmd;
return;
}
/* If we reach this point, the checksum offload context
* needs to be reset
*/
i = adapter->tx_ring.next_to_use;
desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
desc->lower_setup.ip_fields.ipcss = skb->nh.raw - skb->data;
desc->lower_setup.ip_fields.ipcso =
((skb->nh.raw + offsetof(struct iphdr, check)) - skb->data);
desc->lower_setup.ip_fields.ipcse = cpu_to_le16(skb->h.raw - skb->data - 1);
desc->upper_setup.tcp_fields.tucss = (skb->h.raw - skb->data);
desc->upper_setup.tcp_fields.tucso = ((skb->h.raw + skb->csum) - skb->data);
desc->upper_setup.tcp_fields.tucse = 0;
desc->tcp_seg_setup.data = 0;
desc->cmd_and_length = cpu_to_le32(E1000_TXD_CMD_DEXT) | adapter->TxdCmd;
i = (i + 1) % adapter->tx_ring.count;
atomic_dec(&adapter->tx_ring.unused);
adapter->tx_ring.next_to_use = i;
E1000_WRITE_REG(&adapter->shared, TDT, adapter->tx_ring.next_to_use);
return;
}
/**
* e1000_xmit_frame - Transmit entry point
* @skb: buffer with frame data to transmit
* @netdev: network interface device structure
*
* Returns 0 on success, negative on error
*
* e1000_xmit_frame is called by the stack to initiate a transmit.
* The out of resource condition is checked after each successful Tx
* so that the stack can be notified, preventing the driver from
* ever needing to drop a frame. The atomic operations on
* tx_ring.unused are used to syncronize with the transmit
* interrupt processing code without the need for a spinlock.
**/
int
e1000_xmit_frame(struct sk_buff *skb,
struct net_device *netdev)
{
struct e1000_adapter *adapter = netdev->priv;
30c4: 8cb30064 lw s3,100(a1)
30c8: afa40080 sw a0,128(sp)
struct pci_dev *pdev = adapter->pdev;
struct e1000_tx_desc *tx_desc;
int i, len, offset, txd_needed;
uint32_t txd_upper, txd_lower;
#define TXD_USE_COUNT(x) (((x) >> 12) + ((x) & 0x0fff ? 1 : 0))
#ifdef MAX_SKB_FRAGS
int f;
skb_frag_t *frag;
#endif
E1000_DBG("e1000_xmit_frame\n");
if(adapter->link_active == FALSE) {
30cc: 8e6200b0 lw v0,176(s3)
30d0: 54400008 bnezl v0,30f4 <e1000_xmit_frame+0x60>
30d4: 8fa20080 lw v0,128(sp)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
30d8: c0a2002c ll v0,44(a1)
30dc: 34420001 ori v0,v0,0x1
30e0: e0a2002c sc v0,44(a1)
30e4: 1040fffc beqz v0,30d8 <e1000_xmit_frame+0x44>
30e8: 00000000 nop
#ifdef IANS
if((adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) &&
(adapter->iANSdata->reporting_mode == IANS_STATUS_REPORTING_ON))
if(ans_notify)
ans_notify(netdev, IANS_IND_XMIT_QUEUE_FULL);
#endif
netif_stop_queue(netdev);
return 1;
30ec: 08000ee6 j 3b98 <e1000_xmit_frame+0xb04>
30f0: 24020001 li v0,1
}
#ifdef MAX_SKB_FRAGS
txd_needed = TXD_USE_COUNT(skb->len - skb->data_len);
for(f = 0; f < skb_shinfo(skb)->nr_frags; f++) {
30f4: 00006821 move t5,zero
30f8: 8c470088 lw a3,136(v0)
30fc: 8c48005c lw t0,92(v0)
3100: 8c450060 lw a1,96(v0)
3104: 8ce40004 lw a0,4(a3)
3108: 01051023 subu v0,t0,a1
310c: 30430fff andi v1,v0,0xfff
3110: 0003182b sltu v1,zero,v1
3114: 00021302 srl v0,v0,0xc
3118: 1080000d beqz a0,3150 <e1000_xmit_frame+0xbc>
311c: 00433021 addu a2,v0,v1
frag = &skb_shinfo(skb)->frags[f];
3120: 000d10c0 sll v0,t5,0x3
3124: 00e21021 addu v0,a3,v0
txd_needed += TXD_USE_COUNT(frag->size);
3128: 94430012 lhu v1,18(v0)
312c: 8ce40004 lw a0,4(a3)
3130: 25ad0001 addiu t5,t5,1
3134: 30620fff andi v0,v1,0xfff
3138: 00031b02 srl v1,v1,0xc
313c: 00c31821 addu v1,a2,v1
3140: 0002102b sltu v0,zero,v0
3144: 01a4202b sltu a0,t5,a0
3148: 1480fff5 bnez a0,3120 <e1000_xmit_frame+0x8c>
314c: 00623021 addu a2,v1,v0
}
#else
txd_needed = TXD_USE_COUNT(skb->len);
#endif
/* make sure there are enough Tx descriptors available in the ring */
if(atomic_read(&adapter->tx_ring.unused) <= (txd_needed + 1)) {
3150: 8e6300f4 lw v1,244(s3)
3154: 24c20001 addiu v0,a2,1
3158: 0043102a slt v0,v0,v1
315c: 5440000c bnezl v0,3190 <e1000_xmit_frame+0xfc>
3160: 8fa70080 lw a3,128(sp)
adapter->net_stats.tx_dropped++;
3164: 8e62016c lw v0,364(s3)
3168: 24420001 addiu v0,v0,1
316c: ae62016c sw v0,364(s3)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
3170: 8fa40084 lw a0,132(sp)
3174: c083002c ll v1,44(a0)
3178: 34630001 ori v1,v1,0x1
317c: e083002c sc v1,44(a0)
3180: 1060fffc beqz v1,3174 <e1000_xmit_frame+0xe0>
3184: 00000000 nop
#ifdef IANS
if((adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) &&
(adapter->iANSdata->reporting_mode == IANS_STATUS_REPORTING_ON))
if(ans_notify)
ans_notify(netdev, IANS_IND_XMIT_QUEUE_FULL);
#endif
netif_stop_queue(netdev);
return 1;
3188: 08000ee6 j 3b98 <e1000_xmit_frame+0xb04>
318c: 24020001 li v0,1
}
if(skb->ip_summed == CHECKSUM_HW) {
3190: 24020001 li v0,1
3194: 90e6006b lbu a2,107(a3)
3198: 54c20084 bnel a2,v0,33ac <e1000_xmit_frame+0x318>
319c: afa00010 sw zero,16(sp)
31a0: 94e30074 lhu v1,116(a3)
31a4: 24020800 li v0,2048
31a8: 10620006 beq v1,v0,31c4 <e1000_xmit_frame+0x130>
31ac: 266300f4 addiu v1,s3,244
31b0: afa00010 sw zero,16(sp)
31b4: 8e620108 lw v0,264(s3)
31b8: afa30040 sw v1,64(sp)
31bc: 08000cef j 33bc <e1000_xmit_frame+0x328>
31c0: afa20014 sw v0,20(sp)
31c4: 8fa40080 lw a0,128(sp)
31c8: 24030006 li v1,6
31cc: 8c820020 lw v0,32(a0)
31d0: 90440009 lbu a0,9(v0)
31d4: 10830005 beq a0,v1,31ec <e1000_xmit_frame+0x158>
31d8: 24020011 li v0,17
31dc: 5082000d beql a0,v0,3214 <e1000_xmit_frame+0x180>
31e0: 8e620108 lw v0,264(s3)
31e4: 08000ceb j 33ac <e1000_xmit_frame+0x318>
31e8: afa00010 sw zero,16(sp)
31ec: 8e620108 lw v0,264(s3)
31f0: 8e6401b4 lw a0,436(s3)
31f4: 3c032010 lui v1,0x2010
31f8: 00431025 or v0,v0,v1
31fc: 266700f4 addiu a3,s3,244
3200: 24030200 li v1,512
3204: afa20014 sw v0,20(sp)
3208: afa30010 sw v1,16(sp)
320c: 08000c8e j 3238 <e1000_xmit_frame+0x1a4>
3210: afa70040 sw a3,64(sp)
3214: 8e6401b4 lw a0,436(s3)
3218: 3c032010 lui v1,0x2010
321c: 00431025 or v0,v0,v1
3220: afa20014 sw v0,20(sp)
3224: 266300f4 addiu v1,s3,244
3228: 24020200 li v0,512
322c: 24060002 li a2,2
3230: afa20010 sw v0,16(sp)
3234: afa30040 sw v1,64(sp)
3238: 50860061 beql a0,a2,33c0 <e1000_xmit_frame+0x32c>
323c: 8e7500f8 lw s5,248(s3)
3240: ae6601b4 sw a2,436(s3)
3244: 8fa80080 lw t0,128(sp)
3248: 8e6700f8 lw a3,248(s3)
324c: 8e6500e4 lw a1,228(s3)
3250: 91030083 lbu v1,131(t0)
3254: 91040023 lbu a0,35(t0)
3258: 00071100 sll v0,a3,0x4
325c: 00a22821 addu a1,a1,v0
3260: 00832023 subu a0,a0,v1
3264: a0a40000 sb a0,0(a1)
3268: 91020083 lbu v0,131(t0)
326c: 91030023 lbu v1,35(t0)
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
3270: 266400f4 addiu a0,s3,244
3274: 24e70001 addiu a3,a3,1
3278: 00621823 subu v1,v1,v0
327c: 2463000a addiu v1,v1,10
3280: a0a30001 sb v1,1(a1)
3284: 95030082 lhu v1,130(t0)
3288: 9502001e lhu v0,30(t0)
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
328c: afa40040 sw a0,64(sp)
3290: 24060001 li a2,1
3294: 00431023 subu v0,v0,v1
3298: 2442ffff addiu v0,v0,-1
329c: 3042ffff andi v0,v0,0xffff
static __inline__ __const__ __u16 __fswab16(__u16 x)
{
return __arch__swab16(x);
32a0: 304300ff andi v1,v0,0xff
32a4: 00031a00 sll v1,v1,0x8
32a8: 00021202 srl v0,v0,0x8
32ac: 00621825 or v1,v1,v0
32b0: a4a30002 sh v1,2(a1)
32b4: 91030083 lbu v1,131(t0)
32b8: 9102001f lbu v0,31(t0)
32bc: 00431023 subu v0,v0,v1
32c0: a0a20004 sb v0,4(a1)
32c4: 8d020064 lw v0,100(t0)
32c8: 8d03001c lw v1,28(t0)
32cc: 91040083 lbu a0,131(t0)
32d0: a4a00006 sh zero,6(a1)
32d4: 00621821 addu v1,v1,v0
32d8: 00641823 subu v1,v1,a0
32dc: a0a30005 sb v1,5(a1)
32e0: aca0000c sw zero,12(a1)
32e4: 8e620108 lw v0,264(s3)
32e8: 34420020 ori v0,v0,0x20
32ec: aca20008 sw v0,8(a1)
32f0: 8e6300f0 lw v1,240(s3)
32f4: 00e3001b divu zero,a3,v1
32f8: 50600001 beqzl v1,3300 <e1000_xmit_frame+0x26c>
32fc: 0007000d break 0x7
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
3300: 8fa20040 lw v0,64(sp)
3304: 00003810 mfhi a3
...
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
3310: c0440000 ll a0,0(v0)
3314: 00862023 subu a0,a0,a2
3318: e0440000 sc a0,0(v0)
331c: 1080fffc beqz a0,3310 <e1000_xmit_frame+0x27c>
3320: 00000000 nop
3324: 8e62000c lw v0,12(s3)
3328: 2c420002 sltiu v0,v0,2
332c: 14400010 bnez v0,3370 <e1000_xmit_frame+0x2dc>
3330: ae6700f8 sw a3,248(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3334: 30e3ff00 andi v1,a3,0xff00
3338: 00031a00 sll v1,v1,0x8
333c: 00071600 sll v0,a3,0x18
3340: 00072202 srl a0,a3,0x8
3344: 00431025 or v0,v0,v1
3348: 8e650008 lw a1,8(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
334c: 3084ff00 andi a0,a0,0xff00
3350: 00071e02 srl v1,a3,0x18
3354: 00441025 or v0,v0,a0
3358: 00431025 or v0,v0,v1
335c: aca23818 sw v0,14360(a1)
3360: 8fa30080 lw v1,128(sp)
3364: 8c68005c lw t0,92(v1)
3368: 08000cef j 33bc <e1000_xmit_frame+0x328>
336c: 8c650060 lw a1,96(v1)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3370: 30e3ff00 andi v1,a3,0xff00
3374: 00031a00 sll v1,v1,0x8
3378: 00071600 sll v0,a3,0x18
337c: 00072202 srl a0,a3,0x8
3380: 00431025 or v0,v0,v1
3384: 3084ff00 andi a0,a0,0xff00
3388: 8e650008 lw a1,8(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
338c: 00441025 or v0,v0,a0
3390: 00071e02 srl v1,a3,0x18
3394: 00431025 or v0,v0,v1
3398: aca20438 sw v0,1080(a1)
339c: 8fa40080 lw a0,128(sp)
33a0: 8c88005c lw t0,92(a0)
33a4: 08000cef j 33bc <e1000_xmit_frame+0x328>
33a8: 8c850060 lw a1,96(a0)
e1000_tx_checksum_setup(adapter, skb, &txd_upper, &txd_lower);
} else {
txd_upper = 0;
txd_lower = adapter->TxdCmd;
33ac: 8e670108 lw a3,264(s3)
33b0: 266200f4 addiu v0,s3,244
33b4: afa20040 sw v0,64(sp)
33b8: afa70014 sw a3,20(sp)
}
i = adapter->tx_ring.next_to_use;
33bc: 8e7500f8 lw s5,248(s3)
tx_desc = E1000_TX_DESC(adapter->tx_ring, i);
33c0: 8e6200e4 lw v0,228(s3)
#ifdef IANS
if(adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) {
tx_desc->lower.data = cpu_to_le32(txd_lower);
tx_desc->upper.data = cpu_to_le32(txd_upper);
if(bd_ans_os_Transmit(adapter, tx_desc, &skb) == BD_ANS_FAILURE) {
return 1;
}
txd_lower = le32_to_cpu(tx_desc->lower.data);
txd_upper = le32_to_cpu(tx_desc->upper.data);
}
#endif
#ifdef MAX_SKB_FRAGS
len = skb->len - skb->data_len;
33c4: 0105b823 subu s7,t0,a1
33c8: 00151900 sll v1,s5,0x4
#else
len = skb->len;
#endif
offset = 0;
while(len > 4096) {
33cc: 2ae41001 slti a0,s7,4097
33d0: 0043b021 addu s6,v0,v1
33d4: 14800070 bnez a0,3598 <e1000_xmit_frame+0x504>
33d8: 00007821 move t7,zero
33dc: 8fa30014 lw v1,20(sp)
33e0: 3c0d00ff lui t5,0xff
33e4: 8fb20040 lw s2,64(sp)
33e8: 34651000 ori a1,v1,0x1000
33ec: 30a3ff00 andi v1,a1,0xff00
33f0: 00052600 sll a0,a1,0x18
33f4: 00ad1024 and v0,a1,t5
33f8: 00031a00 sll v1,v1,0x8
33fc: 00832025 or a0,a0,v1
3400: 00021202 srl v0,v0,0x8
3404: 00822025 or a0,a0,v0
3408: 00052e02 srl a1,a1,0x18
340c: 00852025 or a0,a0,a1
3410: afa40018 sw a0,24(sp)
3414: 8fa40010 lw a0,16(sp)
3418: 3c1eff00 lui s8,0xff00
341c: 24140001 li s4,1
3420: 00042200 sll a0,a0,0x8
3424: afa4001c sw a0,28(sp)
adapter->tx_ring.buffer_info[i].length = 4096;
3428: 8e630100 lw v1,256(s3)
342c: 00158840 sll s1,s5,0x1
3430: 02358821 addu s1,s1,s5
3434: 001188c0 sll s1,s1,0x3
3438: 02231821 addu v1,s1,v1
343c: 24021000 li v0,4096
3440: ac620010 sw v0,16(v1)
adapter->tx_ring.buffer_info[i].dma =
3444: 8fa50080 lw a1,128(sp)
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
3448: 3c030000 lui v1,0x0
344c: 8c630000 lw v1,0(v1)
3450: 8ca40080 lw a0,128(a1)
3454: 008f2021 addu a0,a0,t7
3458: 3c028000 lui v0,0x8000
345c: 00441021 addu v0,v0,a0
3460: 00021302 srl v0,v0,0xc
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
3464: 00021180 sll v0,v0,0x6
3468: 00431021 addu v0,v0,v1
346c: 30840fff andi a0,a0,0xfff
if (direction == PCI_DMA_NONE)
BUG();
addr = (unsigned long) page_address(page);
3470: 8c500038 lw s0,56(v0)
addr += offset;
#ifdef CONFIG_NONCOHERENT_IO
dma_cache_wback_inv(addr, size);
3474: 3c030000 lui v1,0x0
3478: 8c630000 lw v1,0(v1)
347c: 24051000 li a1,4096
3480: 02048021 addu s0,s0,a0
3484: 02002021 move a0,s0
3488: afad0048 sw t5,72(sp)
348c: 0060f809 jalr v1
3490: afaf0050 sw t7,80(sp)
pci_map_page(pdev, virt_to_page(skb->data + offset),
(unsigned long) (skb->data + offset) & ~~PAGE_MASK,
4096, PCI_DMA_TODEVICE);
3494: 8e650100 lw a1,256(s3)
* IO bus memory addresses are also 1:1 with the physical address
*/
static inline unsigned long virt_to_bus(volatile void * address)
{
return PHYSADDR(address);
3498: 3c041fff lui a0,0x1fff
349c: 3484ffff ori a0,a0,0xffff
34a0: 02041824 and v1,s0,a0
34a4: 02252821 addu a1,s1,a1
34a8: 00001021 move v0,zero
34ac: aca20008 sw v0,8(a1)
34b0: aca3000c sw v1,12(a1)
34b4: 8e640100 lw a0,256(s3)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
34b8: 00003021 move a2,zero
tx_desc->buffer_addr = cpu_to_le64(adapter->tx_ring.buffer_info[i].dma);
tx_desc->lower.data = cpu_to_le32(txd_lower | 4096);
tx_desc->upper.data = cpu_to_le32(txd_upper);
len -= 4096;
34bc: 26f7f000 addiu s7,s7,-4096
34c0: 02248821 addu s1,s1,a0
34c4: 8fa4001c lw a0,28(sp)
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
34c8: 8e25000c lw a1,12(s1)
34cc: 8e280008 lw t0,8(s1)
34d0: aec4000c sw a0,12(s6)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
34d4: 8fad0048 lw t5,72(sp)
34d8: 30a4ff00 andi a0,a1,0xff00
34dc: 00042200 sll a0,a0,0x8
34e0: 00ad5024 and t2,a1,t5
34e4: 00056600 sll t4,a1,0x18
34e8: 310bff00 andi t3,t0,0xff00
34ec: 01846025 or t4,t4,a0
34f0: 000a5202 srl t2,t2,0x8
34f4: 010d2024 and a0,t0,t5
34f8: 00be2824 and a1,a1,s8
34fc: 000b5a00 sll t3,t3,0x8
3500: 00084e00 sll t1,t0,0x18
3504: 018a6025 or t4,t4,t2
3508: 012b4825 or t1,t1,t3
350c: 00052e02 srl a1,a1,0x18
3510: 00042202 srl a0,a0,0x8
3514: 011e4024 and t0,t0,s8
}
static __inline__ __u32 __swab32p(__u32 *x)
{
return __arch__swab32p(x);
}
static __inline__ void __swab32s(__u32 *addr)
{
__arch__swab32s(addr);
}
#ifdef __BYTEORDER_HAS_U64__
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
3518: 01851825 or v1,t4,a1
351c: 01244825 or t1,t1,a0
3520: 00084602 srl t0,t0,0x18
3524: 01283825 or a3,t1,t0
3528: 00031000 sll v0,v1,0x0
352c: 00001821 move v1,zero
3530: 00461025 or v0,v0,a2
3534: 00671825 or v1,v1,a3
3538: aec20000 sw v0,0(s6)
353c: aec30004 sw v1,4(s6)
3540: 8fa50018 lw a1,24(sp)
offset += 4096;
i = (i + 1) % adapter->tx_ring.count;
3544: 26a30001 addiu v1,s5,1
3548: aec50008 sw a1,8(s6)
354c: 8e6200f0 lw v0,240(s3)
3550: 0062001b divu zero,v1,v0
3554: 50400001 beqzl v0,355c <e1000_xmit_frame+0x4c8>
3558: 0007000d break 0x7
355c: 8faf0050 lw t7,80(sp)
3560: 25ef1000 addiu t7,t7,4096
3564: 00002010 mfhi a0
3568: 0080a821 move s5,a0
356c: 00000000 nop
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
3570: c2420000 ll v0,0(s2)
3574: 00541023 subu v0,v0,s4
3578: e2420000 sc v0,0(s2)
357c: 1040fffc beqz v0,3570 <e1000_xmit_frame+0x4dc>
3580: 00000000 nop
atomic_dec(&adapter->tx_ring.unused);
tx_desc = E1000_TX_DESC(adapter->tx_ring, i);
3584: 8e6400e4 lw a0,228(s3)
3588: 00151100 sll v0,s5,0x4
}
358c: 2ae31001 slti v1,s7,4097
3590: 1060ffa5 beqz v1,3428 <e1000_xmit_frame+0x394>
3594: 0082b021 addu s6,a0,v0
adapter->tx_ring.buffer_info[i].length = len;
3598: 8e620100 lw v0,256(s3)
359c: 00159040 sll s2,s5,0x1
35a0: 02558821 addu s1,s2,s5
35a4: 001188c0 sll s1,s1,0x3
35a8: 02221021 addu v0,s1,v0
35ac: ac570010 sw s7,16(v0)
adapter->tx_ring.buffer_info[i].dma =
35b0: 8fa20080 lw v0,128(sp)
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
35b4: 3c040000 lui a0,0x0
35b8: 8c840000 lw a0,0(a0)
35bc: 8c430080 lw v1,128(v0)
35c0: 006f1821 addu v1,v1,t7
35c4: 3c028000 lui v0,0x8000
35c8: 00431021 addu v0,v0,v1
35cc: 00021302 srl v0,v0,0xc
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
35d0: 00021180 sll v0,v0,0x6
35d4: 00441021 addu v0,v0,a0
35d8: 30630fff andi v1,v1,0xfff
if (direction == PCI_DMA_NONE)
BUG();
addr = (unsigned long) page_address(page);
35dc: 8c500038 lw s0,56(v0)
addr += offset;
#ifdef CONFIG_NONCOHERENT_IO
dma_cache_wback_inv(addr, size);
35e0: 3c060000 lui a2,0x0
35e4: 8cc60000 lw a2,0(a2)
35e8: 02038021 addu s0,s0,v1
35ec: 02002021 move a0,s0
35f0: 00c0f809 jalr a2
35f4: 02e02821 move a1,s7
pci_map_page(pdev, virt_to_page(skb->data + offset),
(unsigned long) (skb->data + offset) & ~PAGE_MASK, len,
PCI_DMA_TODEVICE);
35f8: 8e650100 lw a1,256(s3)
* IO bus memory addresses are also 1:1 with the physical address
*/
static inline unsigned long virt_to_bus(volatile void * address)
{
return PHYSADDR(address);
35fc: 3c041fff lui a0,0x1fff
3600: 3484ffff ori a0,a0,0xffff
3604: 02041824 and v1,s0,a0
3608: 02252821 addu a1,s1,a1
360c: 00001021 move v0,zero
3610: aca20008 sw v0,8(a1)
3614: aca3000c sw v1,12(a1)
3618: 8e640100 lw a0,256(s3)
tx_desc->buffer_addr = cpu_to_le64(adapter->tx_ring.buffer_info[i].dma);
361c: 8fa30014 lw v1,20(sp)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3620: 3c0700ff lui a3,0xff
3624: 02248821 addu s1,s1,a0
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
3628: 8e2a000c lw t2,12(s1)
362c: 8e2b0008 lw t3,8(s1)
3630: 00776025 or t4,v1,s7
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3634: 3142ff00 andi v0,t2,0xff00
3638: 01471824 and v1,t2,a3
363c: 318dff00 andi t5,t4,0xff00
3640: 00021200 sll v0,v0,0x8
3644: 000a4600 sll t0,t2,0x18
3648: 3164ff00 andi a0,t3,0xff00
364c: 01024025 or t0,t0,v0
3650: 00031a02 srl v1,v1,0x8
3654: 01671024 and v0,t3,a3
3658: 00042200 sll a0,a0,0x8
365c: 000b4e00 sll t1,t3,0x18
3660: 01873824 and a3,t4,a3
3664: 000c3600 sll a2,t4,0x18
3668: 000d6a00 sll t5,t5,0x8
366c: 01034025 or t0,t0,v1
3670: 01244825 or t1,t1,a0
3674: 00021202 srl v0,v0,0x8
3678: 00073a02 srl a3,a3,0x8
367c: 000a5602 srl t2,t2,0x18
3680: 00cd3025 or a2,a2,t5
3684: 01224825 or t1,t1,v0
}
static __inline__ __u32 __swab32p(__u32 *x)
{
return __arch__swab32p(x);
}
static __inline__ void __swab32s(__u32 *addr)
{
__arch__swab32s(addr);
}
#ifdef __BYTEORDER_HAS_U64__
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
3688: 010a2825 or a1,t0,t2
368c: 00c73025 or a2,a2,a3
3690: 000b5e02 srl t3,t3,0x18
3694: 8fa70010 lw a3,16(sp)
3698: 00002021 move a0,zero
369c: 012b1825 or v1,t1,t3
36a0: 00001021 move v0,zero
36a4: 00052000 sll a0,a1,0x0
36a8: 00002821 move a1,zero
36ac: 00822025 or a0,a0,v0
36b0: 000c6602 srl t4,t4,0x18
36b4: 00a32825 or a1,a1,v1
36b8: 00cc3025 or a2,a2,t4
36bc: 00071200 sll v0,a3,0x8
36c0: aec40000 sw a0,0(s6)
36c4: aec50004 sw a1,4(s6)
tx_desc->lower.data = cpu_to_le32(txd_lower | len);
36c8: aec60008 sw a2,8(s6)
tx_desc->upper.data = cpu_to_le32(txd_upper);
36cc: aec2000c sw v0,12(s6)
#ifdef MAX_SKB_FRAGS
if(skb_shinfo(skb)->nr_frags > 0) {
36d0: 8fa80080 lw t0,128(sp)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
36d4: 00003021 move a2,zero
36d8: 00001821 move v1,zero
36dc: 8d070088 lw a3,136(t0)
36e0: 8ce20004 lw v0,4(a3)
36e4: 104000eb beqz v0,3a94 <e1000_xmit_frame+0xa00>
36e8: 00002021 move a0,zero
for(f = 0; f < skb_shinfo(skb)->nr_frags; f++) {
36ec: 104000e9 beqz v0,3a94 <e1000_xmit_frame+0xa00>
36f0: 00006821 move t5,zero
36f4: 8fa20014 lw v0,20(sp)
36f8: afa30038 sw v1,56(sp)
36fc: 8fa30010 lw v1,16(sp)
3700: 34421000 ori v0,v0,0x1000
3704: 8fb40040 lw s4,64(sp)
3708: afa4003c sw a0,60(sp)
370c: 00022600 sll a0,v0,0x18
3710: afa20024 sw v0,36(sp)
3714: afa60034 sw a2,52(sp)
3718: 240e0001 li t6,1
371c: afa30030 sw v1,48(sp)
3720: afa40028 sw a0,40(sp)
frag = &skb_shinfo(skb)->frags[f];
i = (i + 1) % adapter->tx_ring.count;
3724: 8e6400f0 lw a0,240(s3)
3728: 26a20001 addiu v0,s5,1
372c: 000d18c0 sll v1,t5,0x3
3730: 0044001b divu zero,v0,a0
3734: 00e31821 addu v1,a3,v1
3738: 50800001 beqzl a0,3740 <e1000_xmit_frame+0x6ac>
373c: 0007000d break 0x7
3740: 247e000c addiu s8,v1,12
3744: 00002810 mfhi a1
3748: 00a0a821 move s5,a1
374c: 00000000 nop
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
3750: c2820000 ll v0,0(s4)
3754: 004e1023 subu v0,v0,t6
3758: e2820000 sc v0,0(s4)
375c: 1040fffc beqz v0,3750 <e1000_xmit_frame+0x6bc>
3760: 00000000 nop
atomic_dec(&adapter->tx_ring.unused);
tx_desc = E1000_TX_DESC(adapter->tx_ring, i);
len = frag->size;
3764: 97d70006 lhu s7,6(s8)
3768: 8e6300e4 lw v1,228(s3)
376c: 00151100 sll v0,s5,0x4
offset = 0;
while(len > 4096) {
3770: 2ae41001 slti a0,s7,4097
3774: 0062b021 addu s6,v1,v0
3778: 1480006a bnez a0,3924 <e1000_xmit_frame+0x890>
377c: 00007821 move t7,zero
3780: 8fa30024 lw v1,36(sp)
3784: 8fa40028 lw a0,40(sp)
3788: 3c1900ff lui t9,0xff
378c: 3062ff00 andi v0,v1,0xff00
3790: 8fa50024 lw a1,36(sp)
3794: 00021200 sll v0,v0,0x8
3798: 00791824 and v1,v1,t9
379c: 8fa70010 lw a3,16(sp)
37a0: 00821025 or v0,a0,v0
37a4: 00031a02 srl v1,v1,0x8
37a8: 00431025 or v0,v0,v1
37ac: 00052602 srl a0,a1,0x18
37b0: 00441025 or v0,v0,a0
37b4: 00073a00 sll a3,a3,0x8
37b8: afa20020 sw v0,32(sp)
37bc: 3c12ff00 lui s2,0xff00
37c0: afa7002c sw a3,44(sp)
adapter->tx_ring.buffer_info[i].length = 4096;
37c4: 8e630100 lw v1,256(s3)
37c8: 00158040 sll s0,s5,0x1
37cc: 02158021 addu s0,s0,s5
37d0: 001080c0 sll s0,s0,0x3
37d4: 02031821 addu v1,s0,v1
37d8: 24021000 li v0,4096
37dc: ac620010 sw v0,16(v1)
adapter->tx_ring.buffer_info[i].dma =
37e0: 97c40004 lhu a0,4(s8)
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
37e4: 8fc20000 lw v0,0(s8)
37e8: 008f2021 addu a0,a0,t7
unsigned long addr;
if (direction == PCI_DMA_NONE)
BUG();
addr = (unsigned long) page_address(page);
37ec: 8c510038 lw s1,56(v0)
addr += offset;
#ifdef CONFIG_NONCOHERENT_IO
dma_cache_wback_inv(addr, size);
37f0: 3c030000 lui v1,0x0
37f4: 8c630000 lw v1,0(v1)
37f8: 24051000 li a1,4096
37fc: 02248821 addu s1,s1,a0
3800: 02202021 move a0,s1
3804: afae004c sw t6,76(sp)
3808: afaf0050 sw t7,80(sp)
380c: afb90054 sw t9,84(sp)
3810: 0060f809 jalr v1
3814: afad0048 sw t5,72(sp)
pci_map_page(pdev, frag->page, frag->page_offset + offset,
4096, PCI_DMA_TODEVICE);
3818: 8e650100 lw a1,256(s3)
* IO bus memory addresses are also 1:1 with the physical address
*/
static inline unsigned long virt_to_bus(volatile void * address)
{
return PHYSADDR(address);
381c: 3c041fff lui a0,0x1fff
3820: 3484ffff ori a0,a0,0xffff
3824: 02241824 and v1,s1,a0
3828: 02052821 addu a1,s0,a1
382c: 00001021 move v0,zero
3830: aca20008 sw v0,8(a1)
3834: aca3000c sw v1,12(a1)
tx_desc->buffer_addr =
3838: 8e640100 lw a0,256(s3)
cpu_to_le64(adapter->tx_ring.buffer_info[i].dma);
tx_desc->lower.data = cpu_to_le32(txd_lower | 4096);
tx_desc->upper.data = cpu_to_le32(txd_upper);
383c: 8fa8002c lw t0,44(sp)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
3840: 00003021 move a2,zero
3844: 02048021 addu s0,s0,a0
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
3848: 8e05000c lw a1,12(s0)
384c: 8e0a0008 lw t2,8(s0)
3850: aec8000c sw t0,12(s6)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3854: 8fb90054 lw t9,84(sp)
3858: 30a4ff00 andi a0,a1,0xff00
385c: 00042200 sll a0,a0,0x8
3860: 00b95824 and t3,a1,t9
3864: 00054600 sll t0,a1,0x18
3868: 314cff00 andi t4,t2,0xff00
386c: 01594824 and t1,t2,t9
3870: 01044025 or t0,t0,a0
3874: 000b5a02 srl t3,t3,0x8
3878: 00b22824 and a1,a1,s2
387c: 000c6200 sll t4,t4,0x8
3880: 000a2600 sll a0,t2,0x18
3884: 010b4025 or t0,t0,t3
3888: 008c2025 or a0,a0,t4
388c: 00052e02 srl a1,a1,0x18
3890: 00094a02 srl t1,t1,0x8
3894: 01525024 and t2,t2,s2
3898: 00892025 or a0,a0,t1
}
static __inline__ __u32 __swab32p(__u32 *x)
{
return __arch__swab32p(x);
}
static __inline__ void __swab32s(__u32 *addr)
{
__arch__swab32s(addr);
}
#ifdef __BYTEORDER_HAS_U64__
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
389c: 01051825 or v1,t0,a1
38a0: 000a5602 srl t2,t2,0x18
38a4: 008a3825 or a3,a0,t2
38a8: 00031000 sll v0,v1,0x0
38ac: 00001821 move v1,zero
38b0: 00461025 or v0,v0,a2
38b4: 00671825 or v1,v1,a3
38b8: aec20000 sw v0,0(s6)
38bc: aec30004 sw v1,4(s6)
38c0: 8fa20020 lw v0,32(sp)
len -= 4096;
38c4: 26f7f000 addiu s7,s7,-4096
38c8: aec20008 sw v0,8(s6)
offset += 4096;
i = (i + 1) % adapter->tx_ring.count;
38cc: 8e6300f0 lw v1,240(s3)
38d0: 26a20001 addiu v0,s5,1
38d4: 0043001b divu zero,v0,v1
38d8: 50600001 beqzl v1,38e0 <e1000_xmit_frame+0x84c>
38dc: 0007000d break 0x7
38e0: 8faf0050 lw t7,80(sp)
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
38e4: 8fae004c lw t6,76(sp)
38e8: 25ef1000 addiu t7,t7,4096
38ec: 00002010 mfhi a0
38f0: 0080a821 move s5,a0
38f4: 00000000 nop
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
38f8: c2820000 ll v0,0(s4)
38fc: 004e1023 subu v0,v0,t6
3900: e2820000 sc v0,0(s4)
3904: 1040fffc beqz v0,38f8 <e1000_xmit_frame+0x864>
3908: 00000000 nop
atomic_dec(&adapter->tx_ring.unused);
tx_desc = E1000_TX_DESC(adapter->tx_ring, i);
390c: 8e6400e4 lw a0,228(s3)
3910: 00151100 sll v0,s5,0x4
}
3914: 2ae31001 slti v1,s7,4097
3918: 0082b021 addu s6,a0,v0
391c: 1060ffa9 beqz v1,37c4 <e1000_xmit_frame+0x730>
3920: 8fad0048 lw t5,72(sp)
adapter->tx_ring.buffer_info[i].length = len;
3924: 8e620100 lw v0,256(s3)
3928: 00159040 sll s2,s5,0x1
392c: 02558821 addu s1,s2,s5
3930: 001188c0 sll s1,s1,0x3
3934: 02221021 addu v0,s1,v0
3938: ac570010 sw s7,16(v0)
adapter->tx_ring.buffer_info[i].dma =
393c: 97c30004 lhu v1,4(s8)
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
3940: 8fc20000 lw v0,0(s8)
3944: 006f1821 addu v1,v1,t7
unsigned long addr;
if (direction == PCI_DMA_NONE)
BUG();
addr = (unsigned long) page_address(page);
3948: 8c500038 lw s0,56(v0)
addr += offset;
#ifdef CONFIG_NONCOHERENT_IO
dma_cache_wback_inv(addr, size);
394c: 3c060000 lui a2,0x0
3950: 8cc60000 lw a2,0(a2)
3954: 02038021 addu s0,s0,v1
3958: 02002021 move a0,s0
395c: 02e02821 move a1,s7
3960: afad0048 sw t5,72(sp)
3964: 00c0f809 jalr a2
3968: afae004c sw t6,76(sp)
pci_map_page(pdev, frag->page, frag->page_offset + offset, len,
PCI_DMA_TODEVICE);
396c: 8e650100 lw a1,256(s3)
* IO bus memory addresses are also 1:1 with the physical address
*/
static inline unsigned long virt_to_bus(volatile void * address)
{
return PHYSADDR(address);
3970: 3c041fff lui a0,0x1fff
3974: 3484ffff ori a0,a0,0xffff
3978: 02041824 and v1,s0,a0
397c: 02252821 addu a1,s1,a1
3980: 00001021 move v0,zero
3984: aca20008 sw v0,8(a1)
3988: aca3000c sw v1,12(a1)
tx_desc->buffer_addr =
398c: 8e640100 lw a0,256(s3)
cpu_to_le64(adapter->tx_ring.buffer_info[i].dma);
3990: 8fa20014 lw v0,20(sp)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3994: 3c0500ff lui a1,0xff
3998: 02248821 addu s1,s1,a0
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
399c: 8e23000c lw v1,12(s1)
39a0: 8e290008 lw t1,8(s1)
39a4: 00575825 or t3,v0,s7
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
39a8: 3062ff00 andi v0,v1,0xff00
39ac: 00652024 and a0,v1,a1
39b0: 00021200 sll v0,v0,0x8
39b4: 00033600 sll a2,v1,0x18
39b8: 3125ff00 andi a1,t1,0xff00
39bc: 3c0800ff lui t0,0xff
39c0: 00c23025 or a2,a2,v0
39c4: 00052a00 sll a1,a1,0x8
39c8: 01281024 and v0,t1,t0
39cc: 00095600 sll t2,t1,0x18
39d0: 01455025 or t2,t2,a1
39d4: 00021202 srl v0,v0,0x8
39d8: 3c07ff00 lui a3,0xff00
39dc: 01425025 or t2,t2,v0
39e0: 8fa20030 lw v0,48(sp)
39e4: 00042202 srl a0,a0,0x8
39e8: 00671824 and v1,v1,a3
39ec: 00c43025 or a2,a2,a0
39f0: 00031e02 srl v1,v1,0x18
}
static __inline__ __u32 __swab32p(__u32 *x)
{
return __arch__swab32p(x);
}
static __inline__ void __swab32s(__u32 *addr)
{
__arch__swab32s(addr);
}
#ifdef __BYTEORDER_HAS_U64__
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
39f4: 00c32825 or a1,a2,v1
39f8: 00023200 sll a2,v0,0x8
39fc: 8fa20034 lw v0,52(sp)
3a00: 316cff00 andi t4,t3,0xff00
3a04: 01274824 and t1,t1,a3
3a08: 01684024 and t0,t3,t0
3a0c: 000b3e00 sll a3,t3,0x18
3a10: 3c03ff00 lui v1,0xff00
3a14: 000c6200 sll t4,t4,0x8
3a18: 00094e02 srl t1,t1,0x18
3a1c: 00002021 move a0,zero
3a20: 00084202 srl t0,t0,0x8
3a24: 01635824 and t3,t3,v1
3a28: 00463025 or a2,v0,a2
3a2c: 01491825 or v1,t2,t1
3a30: 00001021 move v0,zero
3a34: 00ec3825 or a3,a3,t4
3a38: 00052000 sll a0,a1,0x0
3a3c: 00002821 move a1,zero
3a40: 00822025 or a0,a0,v0
3a44: 00e83825 or a3,a3,t0
3a48: 8fa80038 lw t0,56(sp)
3a4c: 00a32825 or a1,a1,v1
3a50: 8fa2003c lw v0,60(sp)
3a54: 000b5e02 srl t3,t3,0x18
3a58: 00c83025 or a2,a2,t0
3a5c: 00eb3825 or a3,a3,t3
3a60: 00c23025 or a2,a2,v0
3a64: aec40000 sw a0,0(s6)
3a68: aec50004 sw a1,4(s6)
tx_desc->lower.data = cpu_to_le32(txd_lower | len);
3a6c: aec70008 sw a3,8(s6)
tx_desc->upper.data = cpu_to_le32(txd_upper);
3a70: aec6000c sw a2,12(s6)
3a74: 8fa30080 lw v1,128(sp)
3a78: 8fad0048 lw t5,72(sp)
3a7c: 8c670088 lw a3,136(v1)
3a80: 25ad0001 addiu t5,t5,1
3a84: 8ce20004 lw v0,4(a3)
3a88: 01a2102b sltu v0,t5,v0
3a8c: 1440ff25 bnez v0,3724 <e1000_xmit_frame+0x690>
3a90: 8fae004c lw t6,76(sp)
}
}
3a94: 8ec20008 lw v0,8(s6)
#endif
/* EOP and SKB pointer go with the last fragment */
tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP);
adapter->tx_ring.buffer_info[i].skb = skb;
3a98: 02552021 addu a0,s2,s5
3a9c: 000420c0 sll a0,a0,0x3
3aa0: 34420001 ori v0,v0,0x1
3aa4: aec20008 sw v0,8(s6)
3aa8: 8e630100 lw v1,256(s3)
3aac: 8fa70080 lw a3,128(sp)
i = (i + 1) % adapter->tx_ring.count;
3ab0: 26a50001 addiu a1,s5,1
3ab4: 00832021 addu a0,a0,v1
3ab8: ac870000 sw a3,0(a0)
3abc: 8e6300f0 lw v1,240(s3)
3ac0: 3c0600ff lui a2,0xff
3ac4: 3c11ff00 lui s1,0xff00
3ac8: 00a3001b divu zero,a1,v1
3acc: 50600001 beqzl v1,3ad4 <e1000_xmit_frame+0xa40>
3ad0: 0007000d break 0x7
3ad4: 24020001 li v0,1
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
3ad8: 8fa30040 lw v1,64(sp)
3adc: 00008010 mfhi s0
...
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
3ae8: c0640000 ll a0,0(v1)
3aec: 00822023 subu a0,a0,v0
3af0: e0640000 sc a0,0(v1)
3af4: 1080fffc beqz a0,3ae8 <e1000_xmit_frame+0xa54>
3af8: 00000000 nop
atomic_dec(&adapter->tx_ring.unused);
/* Move the HW Tx Tail Pointer */
adapter->tx_ring.next_to_use = i;
3afc: 8e63000c lw v1,12(s3)
3b00: 2c630002 sltiu v1,v1,2
3b04: 1460000f bnez v1,3b44 <e1000_xmit_frame+0xab0>
3b08: ae7000f8 sw s0,248(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3b0c: 3203ff00 andi v1,s0,0xff00
3b10: 00031a00 sll v1,v1,0x8
3b14: 02062824 and a1,s0,a2
3b18: 00101600 sll v0,s0,0x18
3b1c: 00431025 or v0,v0,v1
3b20: 02112024 and a0,s0,s1
3b24: 00052a02 srl a1,a1,0x8
3b28: 8e630008 lw v1,8(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3b2c: 00451025 or v0,v0,a1
3b30: 00042602 srl a0,a0,0x18
3b34: 00441025 or v0,v0,a0
E1000_WRITE_REG(&adapter->shared, TDT, adapter->tx_ring.next_to_use);
3b38: ac623818 sw v0,14360(v1)
3b3c: 08000edd j 3b74 <e1000_xmit_frame+0xae0>
3b40: 00000000 nop
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3b44: 3203ff00 andi v1,s0,0xff00
3b48: 00031a00 sll v1,v1,0x8
3b4c: 02062824 and a1,s0,a2
3b50: 00101600 sll v0,s0,0x18
3b54: 00431025 or v0,v0,v1
3b58: 02112024 and a0,s0,s1
3b5c: 00052a02 srl a1,a1,0x8
3b60: 8e630008 lw v1,8(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3b64: 00451025 or v0,v0,a1
3b68: 00042602 srl a0,a0,0x18
3b6c: 00441025 or v0,v0,a0
3b70: ac620438 sw v0,1080(v1)
if(atomic_read(&adapter->tx_timeout) == 0)
3b74: 8e62010c lw v0,268(s3)
3b78: 14400002 bnez v0,3b84 <e1000_xmit_frame+0xaf0>
3b7c: 24020003 li v0,3
atomic_set(&adapter->tx_timeout, 3);
3b80: ae62010c sw v0,268(s3)
netdev->trans_start = jiffies;
3b84: 3c030000 lui v1,0x0
3b88: 8c630000 lw v1,0(v1)
3b8c: 8fa40084 lw a0,132(sp)
return 0;
3b90: 00001021 move v0,zero
3b94: ac83004c sw v1,76(a0)
}
3b98: 8fbf007c lw ra,124(sp)
3b9c: 8fbe0078 lw s8,120(sp)
3ba0: 8fb70074 lw s7,116(sp)
3ba4: 8fb60070 lw s6,112(sp)
3ba8: 8fb5006c lw s5,108(sp)
3bac: 8fb40068 lw s4,104(sp)
3bb0: 8fb30064 lw s3,100(sp)
3bb4: 8fb20060 lw s2,96(sp)
3bb8: 8fb1005c lw s1,92(sp)
3bbc: 8fb00058 lw s0,88(sp)
3bc0: 03e00008 jr ra
3bc4: 27bd0080 addiu sp,sp,128
00003bc8 <e1000_get_stats>:
/**
* e1000_get_stats - Get System Network Statistics
* @netdev: network interface device structure
*
* Returns the address of the device statistics structure.
* The statistics are actually updated from the timer callback.
**/
struct net_device_stats *
e1000_get_stats(struct net_device *netdev)
{
struct e1000_adapter *adapter = netdev->priv;
3bc8: 8c820064 lw v0,100(a0)
E1000_DBG("e1000_get_stats\n");
return &adapter->net_stats;
3bcc: 03e00008 jr ra
3bd0: 24420150 addiu v0,v0,336
00003bd4 <e1000_change_mtu>:
3bd4: 27bdffd0 addiu sp,sp,-48
3bd8: afb50024 sw s5,36(sp)
3bdc: afb40020 sw s4,32(sp)
3be0: afbf0028 sw ra,40(sp)
3be4: afb3001c sw s3,28(sp)
3be8: afb20018 sw s2,24(sp)
3bec: afb10014 sw s1,20(sp)
3bf0: afb00010 sw s0,16(sp)
3bf4: 0080a821 move s5,a0
3bf8: 00a0a021 move s4,a1
}
/**
* e1000_change_mtu - Change the Maximum Transfer Unit
* @netdev: network interface device structure
* @new_mtu: new value for maximum frame size
*
* Returns 0 on success, negative on failure
**/
int
e1000_change_mtu(struct net_device *netdev,
int new_mtu)
{
struct e1000_adapter *adapter = netdev->priv;
3bfc: 8eb20064 lw s2,100(s5)
uint32_t old_mtu = adapter->rx_buffer_len;
E1000_DBG("e1000_change_mtu\n");
if((new_mtu < MINIMUM_ETHERNET_PACKET_SIZE - ENET_HEADER_SIZE) ||
3c00: 2682ffd2 addiu v0,s4,-46
3c04: 2c423ec5 sltiu v0,v0,16069
3c08: 14400005 bnez v0,3c20 <e1000_change_mtu+0x4c>
3c0c: 8e4300b8 lw v1,184(s2)
(new_mtu > MAX_JUMBO_FRAME_SIZE - ENET_HEADER_SIZE)) {
E1000_ERR("Invalid MTU setting\n");
3c10: 3c040000 lui a0,0x0
3c14: 24840d60 addiu a0,a0,3424
return -EINVAL;
3c18: 08000f12 j 3c48 <e1000_change_mtu+0x74>
3c1c: 00000000 nop
}
if(new_mtu <= MAXIMUM_ETHERNET_PACKET_SIZE - ENET_HEADER_SIZE) {
3c20: 2a8205dd slti v0,s4,1501
3c24: 50400003 beqzl v0,3c34 <e1000_change_mtu+0x60>
3c28: 8e42000c lw v0,12(s2)
/* 2k buffers */
adapter->rx_buffer_len = E1000_RXBUFFER_2048;
} else if(adapter->shared.mac_type < e1000_82543) {
3c2c: 08000f1f j 3c7c <e1000_change_mtu+0xa8>
3c30: 24020800 li v0,2048
3c34: 2c420002 sltiu v0,v0,2
3c38: 10400009 beqz v0,3c60 <e1000_change_mtu+0x8c>
3c3c: 2a820fef slti v0,s4,4079
E1000_ERR("Jumbo Frames not supported on 82542\n");
3c40: 3c040000 lui a0,0x0
3c44: 24840d80 addiu a0,a0,3456
3c48: 3c020000 lui v0,0x0
3c4c: 24420000 addiu v0,v0,0
3c50: 0040f809 jalr v0
3c54: 00000000 nop
return -EINVAL;
3c58: 08000f70 j 3dc0 <e1000_change_mtu+0x1ec>
3c5c: 2402ffea li v0,-22
} else if(new_mtu <= E1000_RXBUFFER_4096 - ENET_HEADER_SIZE - CRC_LENGTH) {
3c60: 50400003 beqzl v0,3c70 <e1000_change_mtu+0x9c>
3c64: 2a821fef slti v0,s4,8175
/* 4k buffers */
adapter->rx_buffer_len = E1000_RXBUFFER_4096;
} else if(new_mtu <= E1000_RXBUFFER_8192 - ENET_HEADER_SIZE - CRC_LENGTH) {
3c68: 08000f1f j 3c7c <e1000_change_mtu+0xa8>
3c6c: 24021000 li v0,4096
3c70: 50400002 beqzl v0,3c7c <e1000_change_mtu+0xa8>
3c74: 24024000 li v0,16384
/* 8k buffers */
adapter->rx_buffer_len = E1000_RXBUFFER_8192;
} else {
3c78: 24022000 li v0,8192
/* 16k buffers */
adapter->rx_buffer_len = E1000_RXBUFFER_16384;
3c7c: ae4200b8 sw v0,184(s2)
}
if(old_mtu != adapter->rx_buffer_len &&
3c80: 8e4200b8 lw v0,184(s2)
3c84: 1062004b beq v1,v0,3db4 <e1000_change_mtu+0x1e0>
3c88: 26820012 addiu v0,s4,18
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
3c8c: 8e42008c lw v0,140(s2)
3c90: 30420001 andi v0,v0,0x1
test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
3c94: 10400046 beqz v0,3db0 <e1000_change_mtu+0x1dc>
3c98: 24100001 li s0,1
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
3c9c: 265100d8 addiu s1,s2,216
unsigned long temp;
__asm__ __volatile__(
3ca0: c2220000 ll v0,0(s1)
3ca4: 00501021 addu v0,v0,s0
3ca8: e2220000 sc v0,0(s1)
3cac: 1040fffc beqz v0,3ca0 <e1000_change_mtu+0xcc>
3cb0: 00000000 nop
* restricted to acting on a single-word quantity.
*/
extern __inline__ void
set_bit(int nr, volatile void *addr)
{
3cb4: 26b3002c addiu s3,s5,44
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
3cb8: c2620000 ll v0,0(s3)
3cbc: 34420001 ori v0,v0,0x1
3cc0: e2620000 sc v0,0(s3)
3cc4: 1040fffc beqz v0,3cb8 <e1000_change_mtu+0xe4>
3cc8: 00000000 nop
/* stop */
tasklet_disable(&adapter->rx_fill_tasklet);
netif_stop_queue(netdev);
adapter->shared.adapter_stopped = 0;
e1000_adapter_stop(&adapter->shared);
3ccc: 26440008 addiu a0,s2,8
3cd0: 3c020000 lui v0,0x0
3cd4: 24420000 addiu v0,v0,0
3cd8: 0040f809 jalr v0
3cdc: ae400064 sw zero,100(s2)
/* clean out old buffers */
e1000_clean_rx_ring(adapter);
3ce0: 3c020000 lui v0,0x0
3ce4: 244228d8 addiu v0,v0,10456
3ce8: 0040f809 jalr v0
3cec: 02402021 move a0,s2
e1000_clean_tx_ring(adapter);
3cf0: 3c020000 lui v0,0x0
3cf4: 24422720 addiu v0,v0,10016
3cf8: 0040f809 jalr v0
3cfc: 02402021 move a0,s2
/* reset hardware */
adapter->shared.adapter_stopped = 0;
e1000_hw_init(adapter);
3d00: 02402021 move a0,s2
3d04: 3c020000 lui v0,0x0
3d08: 244217c4 addiu v0,v0,6084
3d0c: 0040f809 jalr v0
3d10: ae400064 sw zero,100(s2)
/* go */
e1000_setup_rctl(adapter);
3d14: 3c020000 lui v0,0x0
3d18: 24422308 addiu v0,v0,8968
3d1c: 0040f809 jalr v0
3d20: 02402021 move a0,s2
e1000_configure_rx(adapter);
3d24: 3c020000 lui v0,0x0
3d28: 244223a8 addiu v0,v0,9128
3d2c: 0040f809 jalr v0
3d30: 02402021 move a0,s2
e1000_configure_tx(adapter);
3d34: 3c020000 lui v0,0x0
3d38: 24421f60 addiu v0,v0,8032
3d3c: 0040f809 jalr v0
3d40: 02402021 move a0,s2
smp_mb();
}
static inline void tasklet_enable(struct tasklet_struct *t)
{
3d44: 264500d0 addiu a1,s2,208
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
3d48: c2230000 ll v1,0(s1)
3d4c: 00701823 subu v1,v1,s0
3d50: e2230000 sc v1,0(s1)
3d54: 1060fffc beqz v1,3d48 <e1000_change_mtu+0x174>
3d58: 00000000 nop
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
3d5c: c24400d4 ll a0,212(s2)
3d60: 00901025 or v0,a0,s0
3d64: e24200d4 sc v0,212(s2)
3d68: 1040fffc beqz v0,3d5c <e1000_change_mtu+0x188>
3d6c: 00901024 and v0,a0,s0
extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t));
static inline void tasklet_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
3d70: 14400005 bnez v0,3d88 <e1000_change_mtu+0x1b4>
3d74: 00000000 nop
__tasklet_schedule(t);
3d78: 3c020000 lui v0,0x0
3d7c: 24420000 addiu v0,v0,0
3d80: 0040f809 jalr v0
3d84: 00a02021 move a0,a1
#ifdef IANS
/* restore VLAN settings */
if((IANS_BD_TAGGING_MODE) (ANS_PRIVATE_DATA_FIELD(adapter)->tag_mode)
!= IANS_BD_TAGGING_NONE)
bd_ans_hw_EnableVLAN(adapter);
#endif
tasklet_enable(&adapter->rx_fill_tasklet);
tasklet_schedule(&adapter->rx_fill_tasklet);
e1000_irq_enable(adapter);
3d88: 3c020000 lui v0,0x0
3d8c: 244274ac addiu v0,v0,29868
3d90: 0040f809 jalr v0
3d94: 02402021 move a0,s2
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
3d98: c2630000 ll v1,0(s3)
3d9c: 2401fffe li at,-2
3da0: 00611824 and v1,v1,at
3da4: e2630000 sc v1,0(s3)
3da8: 1060fffb beqz v1,3d98 <e1000_change_mtu+0x1c4>
3dac: 00000000 nop
netif_start_queue(netdev);
}
netdev->mtu = new_mtu;
adapter->shared.max_frame_size = new_mtu + ENET_HEADER_SIZE + CRC_LENGTH;
3db0: 26820012 addiu v0,s4,18
3db4: aeb4005c sw s4,92(s5)
3db8: ae42003c sw v0,60(s2)
return 0;
3dbc: 00001021 move v0,zero
}
3dc0: 8fbf0028 lw ra,40(sp)
3dc4: 8fb50024 lw s5,36(sp)
3dc8: 8fb40020 lw s4,32(sp)
3dcc: 8fb3001c lw s3,28(sp)
3dd0: 8fb20018 lw s2,24(sp)
3dd4: 8fb10014 lw s1,20(sp)
3dd8: 8fb00010 lw s0,16(sp)
3ddc: 03e00008 jr ra
3de0: 27bd0030 addiu sp,sp,48
00003de4 <e1000_set_mac>:
3de4: 27bdffd0 addiu sp,sp,-48
3de8: afb20018 sw s2,24(sp)
3dec: afb00010 sw s0,16(sp)
3df0: afbf0028 sw ra,40(sp)
3df4: afb50024 sw s5,36(sp)
3df8: afb40020 sw s4,32(sp)
3dfc: afb3001c sw s3,28(sp)
3e00: afb10014 sw s1,20(sp)
3e04: 00808021 move s0,a0
/**
* e1000_set_mac - Change the Ethernet Address of the NIC
* @netdev: network interface device structure
* @p: pointer to an address structure
*
* Returns 0 on success, negative on failure
**/
int
e1000_set_mac(struct net_device *netdev,
void *p)
{
struct e1000_adapter *adapter = netdev->priv;
3e08: 8e130064 lw s3,100(s0)
3e0c: 00a09021 move s2,a1
struct pci_dev *pdev = adapter->pdev;
struct sockaddr *addr = (struct sockaddr *) p;
3e10: 8e66000c lw a2,12(s3)
3e14: 8e75014c lw s5,332(s3)
3e18: 2cc20002 sltiu v0,a2,2
3e1c: 00c04021 move t0,a2
uint32_t pci_command;
uint32_t rctl;
E1000_DBG("e1000_set_mac\n");
rctl = E1000_READ_REG(&adapter->shared, RCTL);
3e20: 8e670008 lw a3,8(s3)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
3e24: 8ce50100 lw a1,256(a3)
return __arch__swab32(x);
3e28: 30a3ff00 andi v1,a1,0xff00
3e2c: 00052600 sll a0,a1,0x18
3e30: 00051202 srl v0,a1,0x8
3e34: 00031a00 sll v1,v1,0x8
3e38: 00832025 or a0,a0,v1
3e3c: 3042ff00 andi v0,v0,0xff00
3e40: 00822025 or a0,a0,v0
3e44: 00052e02 srl a1,a1,0x18
if(adapter->shared.mac_type == e1000_82542_rev2_0) {
3e48: 15000031 bnez t0,3f10 <e1000_set_mac+0x12c>
3e4c: 0085a025 or s4,a0,a1
if(adapter->shared.pci_cmd_word & PCI_COMMAND_INVALIDATE) {
3e50: 9662004a lhu v0,74(s3)
3e54: 30420010 andi v0,v0,0x10
3e58: 10400009 beqz v0,3e80 <e1000_set_mac+0x9c>
3e5c: 02a02021 move a0,s5
pci_command =
3e60: 9666004a lhu a2,74(s3)
adapter->shared.pci_cmd_word & ~PCI_COMMAND_INVALIDATE;
pci_write_config_word(pdev, PCI_COMMAND, pci_command);
3e64: 24050004 li a1,4
3e68: 3c020000 lui v0,0x0
3e6c: 24420000 addiu v0,v0,0
3e70: 0040f809 jalr v0
3e74: 30c6ffef andi a2,a2,0xffef
3e78: 8e66000c lw a2,12(s3)
3e7c: 8e670008 lw a3,8(s3)
}
3e80: 2cc20002 sltiu v0,a2,2
E1000_WRITE_REG(&adapter->shared, RCTL, rctl | E1000_RCTL_RST);
3e84: 36850001 ori a1,s4,0x1
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3e88: 30a4ff00 andi a0,a1,0xff00
3e8c: 00051600 sll v0,a1,0x18
3e90: 00051a02 srl v1,a1,0x8
3e94: 00042200 sll a0,a0,0x8
3e98: 00441025 or v0,v0,a0
3e9c: 3063ff00 andi v1,v1,0xff00
3ea0: 00431025 or v0,v0,v1
3ea4: 00052e02 srl a1,a1,0x18
3ea8: 00451025 or v0,v0,a1
3eac: ace20100 sw v0,256(a3)
extern __inline__ void __udelay(unsigned long usecs, unsigned long lpj)
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
3eb0: 3c027fff lui v0,0x7fff
3eb4: 3c030000 lui v1,0x0
3eb8: 8c630000 lw v1,0(v1)
3ebc: 3442f1c0 ori v0,v0,0xf1c0
__asm__("multu\t%2,%3"
3ec0: 00430019 multu v0,v1
3ec4: 00001010 mfhi v0
...
3ed0: 1440ffff bnez v0,3ed0 <e1000_set_mac+0xec>
3ed4: 2442ffff addiu v0,v0,-1
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
3ed8: 8e63008c lw v1,140(s3)
3edc: 30630001 andi v1,v1,0x1
mdelay(5);
if(test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
3ee0: 1060000b beqz v1,3f10 <e1000_set_mac+0x12c>
3ee4: 24030001 li v1,1
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
3ee8: 266200d8 addiu v0,s3,216
unsigned long temp;
__asm__ __volatile__(
3eec: c0440000 ll a0,0(v0)
3ef0: 00832021 addu a0,a0,v1
3ef4: e0440000 sc a0,0(v0)
3ef8: 1080fffc beqz a0,3eec <e1000_set_mac+0x108>
3efc: 00000000 nop
tasklet_disable(&adapter->rx_fill_tasklet);
e1000_clean_rx_ring(adapter);
3f00: 3c020000 lui v0,0x0
3f04: 244228d8 addiu v0,v0,10456
3f08: 0040f809 jalr v0
3f0c: 02602021 move a0,s3
}
}
memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
3f10: 9206007c lbu a2,124(s0)
3f14: 26520002 addiu s2,s2,2
3f18: 26040074 addiu a0,s0,116
3f1c: 3c110000 lui s1,0x0
3f20: 26310000 addiu s1,s1,0
3f24: 0220f809 jalr s1
3f28: 02402821 move a1,s2
memcpy(adapter->shared.mac_addr, addr->sa_data, netdev->addr_len);
3f2c: 9206007c lbu a2,124(s0)
3f30: 2670007d addiu s0,s3,125
3f34: 02402821 move a1,s2
3f38: 02002021 move a0,s0
3f3c: 0220f809 jalr s1
3f40: 26720008 addiu s2,s3,8
e1000_rar_set(&adapter->shared, adapter->shared.mac_addr, 0);
3f44: 02002821 move a1,s0
3f48: 02402021 move a0,s2
3f4c: 3c020000 lui v0,0x0
3f50: 24420000 addiu v0,v0,0
3f54: 0040f809 jalr v0
3f58: 00003021 move a2,zero
if(adapter->shared.mac_type == e1000_82542_rev2_0) {
3f5c: 8e63000c lw v1,12(s3)
3f60: 1460002f bnez v1,4020 <e1000_set_mac+0x23c>
3f64: 8fbf0028 lw ra,40(sp)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3f68: 3282ff00 andi v0,s4,0xff00
3f6c: 00021200 sll v0,v0,0x8
3f70: 00141e00 sll v1,s4,0x18
3f74: 00142202 srl a0,s4,0x8
3f78: 00621825 or v1,v1,v0
E1000_WRITE_REG(&adapter->shared, RCTL, rctl);
3f7c: 8e450000 lw a1,0(s2)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
3f80: 3084ff00 andi a0,a0,0xff00
3f84: 00141602 srl v0,s4,0x18
3f88: 00641825 or v1,v1,a0
3f8c: 00621825 or v1,v1,v0
3f90: aca30100 sw v1,256(a1)
extern __inline__ void __udelay(unsigned long usecs, unsigned long lpj)
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
3f94: 3c027fff lui v0,0x7fff
3f98: 3c030000 lui v1,0x0
3f9c: 8c630000 lw v1,0(v1)
3fa0: 3442f1c0 ori v0,v0,0xf1c0
__asm__("multu\t%2,%3"
3fa4: 00430019 multu v0,v1
3fa8: 00001010 mfhi v0
...
3fb4: 1440ffff bnez v0,3fb4 <e1000_set_mac+0x1d0>
3fb8: 2442ffff addiu v0,v0,-1
mdelay(5);
if(adapter->shared.pci_cmd_word & PCI_COMMAND_INVALIDATE) {
3fbc: 9663004a lhu v1,74(s3)
3fc0: 30630010 andi v1,v1,0x10
3fc4: 10600006 beqz v1,3fe0 <e1000_set_mac+0x1fc>
3fc8: 02a02021 move a0,s5
pci_write_config_word(pdev, PCI_COMMAND,
3fcc: 9666004a lhu a2,74(s3)
3fd0: 3c020000 lui v0,0x0
3fd4: 24420000 addiu v0,v0,0
3fd8: 0040f809 jalr v0
3fdc: 24050004 li a1,4
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
3fe0: 8e62008c lw v0,140(s3)
3fe4: 30420001 andi v0,v0,0x1
adapter->shared.pci_cmd_word);
}
if(test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
3fe8: 1040000d beqz v0,4020 <e1000_set_mac+0x23c>
3fec: 8fbf0028 lw ra,40(sp)
e1000_configure_rx(adapter);
3ff0: 3c020000 lui v0,0x0
3ff4: 244223a8 addiu v0,v0,9128
3ff8: 0040f809 jalr v0
3ffc: 02602021 move a0,s3
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
4000: 266300d8 addiu v1,s3,216
4004: 24020001 li v0,1
unsigned long temp;
__asm__ __volatile__(
4008: c0640000 ll a0,0(v1)
400c: 00822023 subu a0,a0,v0
4010: e0640000 sc a0,0(v1)
4014: 1080fffc beqz a0,4008 <e1000_set_mac+0x224>
4018: 00000000 nop
tasklet_enable(&adapter->rx_fill_tasklet);
}
}
return 0;
401c: 8fbf0028 lw ra,40(sp)
4020: 8fb50024 lw s5,36(sp)
4024: 8fb40020 lw s4,32(sp)
4028: 8fb3001c lw s3,28(sp)
402c: 8fb20018 lw s2,24(sp)
4030: 8fb10014 lw s1,20(sp)
4034: 8fb00010 lw s0,16(sp)
4038: 00001021 move v0,zero
403c: 03e00008 jr ra
4040: 27bd0030 addiu sp,sp,48
00004044 <e1000_update_stats>:
4044: 27bdffd8 addiu sp,sp,-40
4048: afb3001c sw s3,28(sp)
404c: afbf0024 sw ra,36(sp)
4050: afb40020 sw s4,32(sp)
4054: afb20018 sw s2,24(sp)
4058: afb10014 sw s1,20(sp)
405c: afb00010 sw s0,16(sp)
4060: 00809821 move s3,a0
}
/**
* e1000_update_stats - Update the board statistics counters
* @adapter: board private structure
**/
static void
e1000_update_stats(struct e1000_adapter *adapter)
{
unsigned long flags;
#define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
spin_lock_irqsave(&adapter->stats_lock, flags);
4064: 40146000 mfc0 s4,$12
4068: 00000000 nop
406c: 36810001 ori at,s4,0x1
4070: 38210001 xori at,at,0x1
4074: 40816000 mtc0 at,$12
4078: 00000040 sll zero,zero,0x1
407c: 00000040 sll zero,zero,0x1
4080: 00000040 sll zero,zero,0x1
4084: 8e6801d8 lw t0,472(s3)
4088: 8e6901dc lw t1,476(s3)
408c: 8e62000c lw v0,12(s3)
4090: 2c420002 sltiu v0,v0,2
adapter->stats.crcerrs += E1000_READ_REG(&adapter->shared, CRCERRS);
4094: 8e640008 lw a0,8(s3)
4098: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
409c: 8c874000 lw a3,16384(a0)
return __arch__swab32(x);
40a0: 30e5ff00 andi a1,a3,0xff00
40a4: 00073600 sll a2,a3,0x18
40a8: 00072202 srl a0,a3,0x8
40ac: 00052a00 sll a1,a1,0x8
40b0: 3084ff00 andi a0,a0,0xff00
40b4: 00c53025 or a2,a2,a1
40b8: 00c43025 or a2,a2,a0
40bc: 00073e02 srl a3,a3,0x18
40c0: 00c71825 or v1,a2,a3
40c4: 01233821 addu a3,t1,v1
40c8: 00e3202b sltu a0,a3,v1
40cc: 01023021 addu a2,t0,v0
40d0: 00c43021 addu a2,a2,a0
40d4: 8e62000c lw v0,12(s3)
40d8: ae6601d8 sw a2,472(s3)
40dc: ae6701dc sw a3,476(s3)
40e0: 8e6801e8 lw t0,488(s3)
40e4: 8e6901ec lw t1,492(s3)
40e8: 2c420002 sltiu v0,v0,2
adapter->stats.symerrs += E1000_READ_REG(&adapter->shared, SYMERRS);
40ec: 8e640008 lw a0,8(s3)
40f0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
40f4: 8c874008 lw a3,16392(a0)
return __arch__swab32(x);
40f8: 30e5ff00 andi a1,a3,0xff00
40fc: 00073600 sll a2,a3,0x18
4100: 00072202 srl a0,a3,0x8
4104: 00052a00 sll a1,a1,0x8
4108: 3084ff00 andi a0,a0,0xff00
410c: 00c53025 or a2,a2,a1
4110: 00c43025 or a2,a2,a0
4114: 00073e02 srl a3,a3,0x18
4118: 00c71825 or v1,a2,a3
411c: 01233821 addu a3,t1,v1
4120: 00e3202b sltu a0,a3,v1
4124: 01023021 addu a2,t0,v0
4128: 00c43021 addu a2,a2,a0
412c: 8e62000c lw v0,12(s3)
4130: ae6601e8 sw a2,488(s3)
4134: ae6701ec sw a3,492(s3)
4138: 8e6801f8 lw t0,504(s3)
413c: 8e6901fc lw t1,508(s3)
4140: 2c420002 sltiu v0,v0,2
adapter->stats.mpc += E1000_READ_REG(&adapter->shared, MPC);
4144: 8e640008 lw a0,8(s3)
4148: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
414c: 8c874010 lw a3,16400(a0)
return __arch__swab32(x);
4150: 30e5ff00 andi a1,a3,0xff00
4154: 00073600 sll a2,a3,0x18
4158: 00072202 srl a0,a3,0x8
415c: 00052a00 sll a1,a1,0x8
4160: 3084ff00 andi a0,a0,0xff00
4164: 00c53025 or a2,a2,a1
4168: 00c43025 or a2,a2,a0
416c: 00073e02 srl a3,a3,0x18
4170: 00c71825 or v1,a2,a3
4174: 01233821 addu a3,t1,v1
4178: 00e3202b sltu a0,a3,v1
417c: 01023021 addu a2,t0,v0
4180: 00c43021 addu a2,a2,a0
4184: 8e62000c lw v0,12(s3)
4188: ae6601f8 sw a2,504(s3)
418c: ae6701fc sw a3,508(s3)
4190: 8e680200 lw t0,512(s3)
4194: 8e690204 lw t1,516(s3)
4198: 2c420002 sltiu v0,v0,2
adapter->stats.scc += E1000_READ_REG(&adapter->shared, SCC);
419c: 8e640008 lw a0,8(s3)
41a0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
41a4: 8c874014 lw a3,16404(a0)
return __arch__swab32(x);
41a8: 30e5ff00 andi a1,a3,0xff00
41ac: 00073600 sll a2,a3,0x18
41b0: 00072202 srl a0,a3,0x8
41b4: 00052a00 sll a1,a1,0x8
41b8: 3084ff00 andi a0,a0,0xff00
41bc: 00c53025 or a2,a2,a1
41c0: 00c43025 or a2,a2,a0
41c4: 00073e02 srl a3,a3,0x18
41c8: 00c71825 or v1,a2,a3
41cc: 01233821 addu a3,t1,v1
41d0: 00e3202b sltu a0,a3,v1
41d4: 01023021 addu a2,t0,v0
41d8: 00c43021 addu a2,a2,a0
41dc: 8e62000c lw v0,12(s3)
41e0: ae660200 sw a2,512(s3)
41e4: ae670204 sw a3,516(s3)
41e8: 8e680208 lw t0,520(s3)
41ec: 8e69020c lw t1,524(s3)
41f0: 2c420002 sltiu v0,v0,2
adapter->stats.ecol += E1000_READ_REG(&adapter->shared, ECOL);
41f4: 8e640008 lw a0,8(s3)
41f8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
41fc: 8c874018 lw a3,16408(a0)
return __arch__swab32(x);
4200: 30e5ff00 andi a1,a3,0xff00
4204: 00073600 sll a2,a3,0x18
4208: 00072202 srl a0,a3,0x8
420c: 00052a00 sll a1,a1,0x8
4210: 3084ff00 andi a0,a0,0xff00
4214: 00c53025 or a2,a2,a1
4218: 00c43025 or a2,a2,a0
421c: 00073e02 srl a3,a3,0x18
4220: 00c71825 or v1,a2,a3
4224: 01233821 addu a3,t1,v1
4228: 00e3202b sltu a0,a3,v1
422c: 01023021 addu a2,t0,v0
4230: 00c43021 addu a2,a2,a0
4234: 8e62000c lw v0,12(s3)
4238: ae660208 sw a2,520(s3)
423c: ae67020c sw a3,524(s3)
4240: 8e680210 lw t0,528(s3)
4244: 8e690214 lw t1,532(s3)
4248: 2c420002 sltiu v0,v0,2
adapter->stats.mcc += E1000_READ_REG(&adapter->shared, MCC);
424c: 8e640008 lw a0,8(s3)
4250: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4254: 8c87401c lw a3,16412(a0)
return __arch__swab32(x);
4258: 30e5ff00 andi a1,a3,0xff00
425c: 00073600 sll a2,a3,0x18
4260: 00072202 srl a0,a3,0x8
4264: 00052a00 sll a1,a1,0x8
4268: 3084ff00 andi a0,a0,0xff00
426c: 00c53025 or a2,a2,a1
4270: 00c43025 or a2,a2,a0
4274: 00073e02 srl a3,a3,0x18
4278: 00c71825 or v1,a2,a3
427c: 01233821 addu a3,t1,v1
4280: 00e3202b sltu a0,a3,v1
4284: 01023021 addu a2,t0,v0
4288: 00c43021 addu a2,a2,a0
428c: 8e62000c lw v0,12(s3)
4290: ae660210 sw a2,528(s3)
4294: ae670214 sw a3,532(s3)
4298: 8e680218 lw t0,536(s3)
429c: 8e69021c lw t1,540(s3)
42a0: 2c420002 sltiu v0,v0,2
adapter->stats.latecol += E1000_READ_REG(&adapter->shared, LATECOL);
42a4: 8e640008 lw a0,8(s3)
42a8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
42ac: 8c874020 lw a3,16416(a0)
return __arch__swab32(x);
42b0: 30e5ff00 andi a1,a3,0xff00
42b4: 00073600 sll a2,a3,0x18
42b8: 00072202 srl a0,a3,0x8
42bc: 00052a00 sll a1,a1,0x8
42c0: 3084ff00 andi a0,a0,0xff00
42c4: 00c53025 or a2,a2,a1
42c8: 00c43025 or a2,a2,a0
42cc: 00073e02 srl a3,a3,0x18
42d0: 00c71825 or v1,a2,a3
42d4: 01233821 addu a3,t1,v1
42d8: 00e3202b sltu a0,a3,v1
42dc: 01023021 addu a2,t0,v0
42e0: 00c43021 addu a2,a2,a0
42e4: 8e62000c lw v0,12(s3)
42e8: ae660218 sw a2,536(s3)
42ec: ae67021c sw a3,540(s3)
42f0: 8e680220 lw t0,544(s3)
42f4: 8e690224 lw t1,548(s3)
42f8: 2c420002 sltiu v0,v0,2
adapter->stats.colc += E1000_READ_REG(&adapter->shared, COLC);
42fc: 8e640008 lw a0,8(s3)
4300: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4304: 8c874028 lw a3,16424(a0)
return __arch__swab32(x);
4308: 30e5ff00 andi a1,a3,0xff00
430c: 00073600 sll a2,a3,0x18
4310: 00072202 srl a0,a3,0x8
4314: 00052a00 sll a1,a1,0x8
4318: 3084ff00 andi a0,a0,0xff00
431c: 00c53025 or a2,a2,a1
4320: 00c43025 or a2,a2,a0
4324: 00073e02 srl a3,a3,0x18
4328: 00c71825 or v1,a2,a3
432c: 01233821 addu a3,t1,v1
4330: 00e3202b sltu a0,a3,v1
4334: 01023021 addu a2,t0,v0
4338: 00c43021 addu a2,a2,a0
433c: 8e62000c lw v0,12(s3)
4340: ae660220 sw a2,544(s3)
4344: ae670224 sw a3,548(s3)
4348: 8e680228 lw t0,552(s3)
434c: 8e69022c lw t1,556(s3)
4350: 2c420002 sltiu v0,v0,2
adapter->stats.dc += E1000_READ_REG(&adapter->shared, DC);
4354: 8e640008 lw a0,8(s3)
4358: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
435c: 8c874030 lw a3,16432(a0)
return __arch__swab32(x);
4360: 30e5ff00 andi a1,a3,0xff00
4364: 00073600 sll a2,a3,0x18
4368: 00072202 srl a0,a3,0x8
436c: 00052a00 sll a1,a1,0x8
4370: 3084ff00 andi a0,a0,0xff00
4374: 00c53025 or a2,a2,a1
4378: 00c43025 or a2,a2,a0
437c: 00073e02 srl a3,a3,0x18
4380: 00c71825 or v1,a2,a3
4384: 01233821 addu a3,t1,v1
4388: 00e3202b sltu a0,a3,v1
438c: 01023021 addu a2,t0,v0
4390: 00c43021 addu a2,a2,a0
4394: 8e62000c lw v0,12(s3)
4398: ae660228 sw a2,552(s3)
439c: ae67022c sw a3,556(s3)
43a0: 8e680238 lw t0,568(s3)
43a4: 8e69023c lw t1,572(s3)
43a8: 2c420002 sltiu v0,v0,2
adapter->stats.sec += E1000_READ_REG(&adapter->shared, SEC);
43ac: 8e640008 lw a0,8(s3)
43b0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
43b4: 8c874038 lw a3,16440(a0)
return __arch__swab32(x);
43b8: 30e5ff00 andi a1,a3,0xff00
43bc: 00073600 sll a2,a3,0x18
43c0: 00072202 srl a0,a3,0x8
43c4: 00052a00 sll a1,a1,0x8
43c8: 3084ff00 andi a0,a0,0xff00
43cc: 00c53025 or a2,a2,a1
43d0: 00c43025 or a2,a2,a0
43d4: 00073e02 srl a3,a3,0x18
43d8: 00c71825 or v1,a2,a3
43dc: 01233821 addu a3,t1,v1
43e0: 00e3202b sltu a0,a3,v1
43e4: 01023021 addu a2,t0,v0
43e8: 00c43021 addu a2,a2,a0
43ec: 8e62000c lw v0,12(s3)
43f0: ae660238 sw a2,568(s3)
43f4: ae67023c sw a3,572(s3)
43f8: 8e680248 lw t0,584(s3)
43fc: 8e69024c lw t1,588(s3)
4400: 2c420002 sltiu v0,v0,2
adapter->stats.rlec += E1000_READ_REG(&adapter->shared, RLEC);
4404: 8e640008 lw a0,8(s3)
4408: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
440c: 8c874040 lw a3,16448(a0)
return __arch__swab32(x);
4410: 30e5ff00 andi a1,a3,0xff00
4414: 00073600 sll a2,a3,0x18
4418: 00072202 srl a0,a3,0x8
441c: 00052a00 sll a1,a1,0x8
4420: 3084ff00 andi a0,a0,0xff00
4424: 00c53025 or a2,a2,a1
4428: 00c43025 or a2,a2,a0
442c: 00073e02 srl a3,a3,0x18
4430: 00c71825 or v1,a2,a3
4434: 01233821 addu a3,t1,v1
4438: 00e3202b sltu a0,a3,v1
443c: 01023021 addu a2,t0,v0
4440: 00c43021 addu a2,a2,a0
4444: 8e62000c lw v0,12(s3)
4448: ae660248 sw a2,584(s3)
444c: ae67024c sw a3,588(s3)
4450: 8e680250 lw t0,592(s3)
4454: 8e690254 lw t1,596(s3)
4458: 2c420002 sltiu v0,v0,2
adapter->stats.xonrxc += E1000_READ_REG(&adapter->shared, XONRXC);
445c: 8e640008 lw a0,8(s3)
4460: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4464: 8c874048 lw a3,16456(a0)
return __arch__swab32(x);
4468: 30e5ff00 andi a1,a3,0xff00
446c: 00073600 sll a2,a3,0x18
4470: 00072202 srl a0,a3,0x8
4474: 00052a00 sll a1,a1,0x8
4478: 3084ff00 andi a0,a0,0xff00
447c: 00c53025 or a2,a2,a1
4480: 00c43025 or a2,a2,a0
4484: 00073e02 srl a3,a3,0x18
4488: 00c71825 or v1,a2,a3
448c: 01233821 addu a3,t1,v1
4490: 00e3202b sltu a0,a3,v1
4494: 01023021 addu a2,t0,v0
4498: 00c43021 addu a2,a2,a0
449c: 8e62000c lw v0,12(s3)
44a0: ae660250 sw a2,592(s3)
44a4: ae670254 sw a3,596(s3)
44a8: 8e680258 lw t0,600(s3)
44ac: 8e69025c lw t1,604(s3)
44b0: 2c420002 sltiu v0,v0,2
adapter->stats.xontxc += E1000_READ_REG(&adapter->shared, XONTXC);
44b4: 8e640008 lw a0,8(s3)
44b8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
44bc: 8c87404c lw a3,16460(a0)
return __arch__swab32(x);
44c0: 30e5ff00 andi a1,a3,0xff00
44c4: 00073600 sll a2,a3,0x18
44c8: 00072202 srl a0,a3,0x8
44cc: 00052a00 sll a1,a1,0x8
44d0: 3084ff00 andi a0,a0,0xff00
44d4: 00c53025 or a2,a2,a1
44d8: 00c43025 or a2,a2,a0
44dc: 00073e02 srl a3,a3,0x18
44e0: 00c71825 or v1,a2,a3
44e4: 01233821 addu a3,t1,v1
44e8: 00e3202b sltu a0,a3,v1
44ec: 01023021 addu a2,t0,v0
44f0: 00c43021 addu a2,a2,a0
44f4: 8e62000c lw v0,12(s3)
44f8: ae660258 sw a2,600(s3)
44fc: ae67025c sw a3,604(s3)
4500: 8e680260 lw t0,608(s3)
4504: 8e690264 lw t1,612(s3)
4508: 2c420002 sltiu v0,v0,2
adapter->stats.xoffrxc += E1000_READ_REG(&adapter->shared, XOFFRXC);
450c: 8e640008 lw a0,8(s3)
4510: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4514: 8c874050 lw a3,16464(a0)
return __arch__swab32(x);
4518: 30e5ff00 andi a1,a3,0xff00
451c: 00073600 sll a2,a3,0x18
4520: 00072202 srl a0,a3,0x8
4524: 00052a00 sll a1,a1,0x8
4528: 3084ff00 andi a0,a0,0xff00
452c: 00c53025 or a2,a2,a1
4530: 00c43025 or a2,a2,a0
4534: 00073e02 srl a3,a3,0x18
4538: 00c71825 or v1,a2,a3
453c: 01233821 addu a3,t1,v1
4540: 00e3202b sltu a0,a3,v1
4544: 01023021 addu a2,t0,v0
4548: 00c43021 addu a2,a2,a0
454c: 8e62000c lw v0,12(s3)
4550: ae660260 sw a2,608(s3)
4554: ae670264 sw a3,612(s3)
4558: 8e680268 lw t0,616(s3)
455c: 8e69026c lw t1,620(s3)
4560: 2c420002 sltiu v0,v0,2
adapter->stats.xofftxc += E1000_READ_REG(&adapter->shared, XOFFTXC);
4564: 8e640008 lw a0,8(s3)
4568: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
456c: 8c874054 lw a3,16468(a0)
return __arch__swab32(x);
4570: 30e5ff00 andi a1,a3,0xff00
4574: 00073600 sll a2,a3,0x18
4578: 00072202 srl a0,a3,0x8
457c: 00052a00 sll a1,a1,0x8
4580: 3084ff00 andi a0,a0,0xff00
4584: 00c53025 or a2,a2,a1
4588: 00c43025 or a2,a2,a0
458c: 00073e02 srl a3,a3,0x18
4590: 00c71825 or v1,a2,a3
4594: 01233821 addu a3,t1,v1
4598: 00e3202b sltu a0,a3,v1
459c: 01023021 addu a2,t0,v0
45a0: 00c43021 addu a2,a2,a0
45a4: 8e62000c lw v0,12(s3)
45a8: ae660268 sw a2,616(s3)
45ac: ae67026c sw a3,620(s3)
45b0: 8e680270 lw t0,624(s3)
45b4: 8e690274 lw t1,628(s3)
45b8: 2c420002 sltiu v0,v0,2
adapter->stats.fcruc += E1000_READ_REG(&adapter->shared, FCRUC);
45bc: 8e640008 lw a0,8(s3)
45c0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
45c4: 8c874058 lw a3,16472(a0)
return __arch__swab32(x);
45c8: 30e5ff00 andi a1,a3,0xff00
45cc: 00073600 sll a2,a3,0x18
45d0: 00072202 srl a0,a3,0x8
45d4: 00052a00 sll a1,a1,0x8
45d8: 3084ff00 andi a0,a0,0xff00
45dc: 00c53025 or a2,a2,a1
45e0: 00c43025 or a2,a2,a0
45e4: 00073e02 srl a3,a3,0x18
45e8: 00c71825 or v1,a2,a3
45ec: 01233821 addu a3,t1,v1
45f0: 00e3202b sltu a0,a3,v1
45f4: 01023021 addu a2,t0,v0
45f8: 00c43021 addu a2,a2,a0
45fc: 8e62000c lw v0,12(s3)
4600: ae660270 sw a2,624(s3)
4604: ae670274 sw a3,628(s3)
4608: 8e680278 lw t0,632(s3)
460c: 8e69027c lw t1,636(s3)
4610: 2c420002 sltiu v0,v0,2
adapter->stats.prc64 += E1000_READ_REG(&adapter->shared, PRC64);
4614: 8e640008 lw a0,8(s3)
4618: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
461c: 8c87405c lw a3,16476(a0)
return __arch__swab32(x);
4620: 30e5ff00 andi a1,a3,0xff00
4624: 00073600 sll a2,a3,0x18
4628: 00072202 srl a0,a3,0x8
462c: 00052a00 sll a1,a1,0x8
4630: 3084ff00 andi a0,a0,0xff00
4634: 00c53025 or a2,a2,a1
4638: 00c43025 or a2,a2,a0
463c: 00073e02 srl a3,a3,0x18
4640: 00c71825 or v1,a2,a3
4644: 01233821 addu a3,t1,v1
4648: 00e3202b sltu a0,a3,v1
464c: 01023021 addu a2,t0,v0
4650: 00c43021 addu a2,a2,a0
4654: 8e62000c lw v0,12(s3)
4658: ae660278 sw a2,632(s3)
465c: ae67027c sw a3,636(s3)
4660: 8e680280 lw t0,640(s3)
4664: 8e690284 lw t1,644(s3)
4668: 2c420002 sltiu v0,v0,2
adapter->stats.prc127 += E1000_READ_REG(&adapter->shared, PRC127);
466c: 8e640008 lw a0,8(s3)
4670: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4674: 8c874060 lw a3,16480(a0)
return __arch__swab32(x);
4678: 30e5ff00 andi a1,a3,0xff00
467c: 00073600 sll a2,a3,0x18
4680: 00072202 srl a0,a3,0x8
4684: 00052a00 sll a1,a1,0x8
4688: 3084ff00 andi a0,a0,0xff00
468c: 00c53025 or a2,a2,a1
4690: 00c43025 or a2,a2,a0
4694: 00073e02 srl a3,a3,0x18
4698: 00c71825 or v1,a2,a3
469c: 01233821 addu a3,t1,v1
46a0: 00e3202b sltu a0,a3,v1
46a4: 01023021 addu a2,t0,v0
46a8: 00c43021 addu a2,a2,a0
46ac: 8e62000c lw v0,12(s3)
46b0: ae660280 sw a2,640(s3)
46b4: ae670284 sw a3,644(s3)
46b8: 8e680288 lw t0,648(s3)
46bc: 8e69028c lw t1,652(s3)
46c0: 2c420002 sltiu v0,v0,2
adapter->stats.prc255 += E1000_READ_REG(&adapter->shared, PRC255);
46c4: 8e640008 lw a0,8(s3)
46c8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
46cc: 8c874064 lw a3,16484(a0)
return __arch__swab32(x);
46d0: 30e5ff00 andi a1,a3,0xff00
46d4: 00073600 sll a2,a3,0x18
46d8: 00072202 srl a0,a3,0x8
46dc: 00052a00 sll a1,a1,0x8
46e0: 3084ff00 andi a0,a0,0xff00
46e4: 00c53025 or a2,a2,a1
46e8: 00c43025 or a2,a2,a0
46ec: 00073e02 srl a3,a3,0x18
46f0: 00c71825 or v1,a2,a3
46f4: 01233821 addu a3,t1,v1
46f8: 00e3202b sltu a0,a3,v1
46fc: 01023021 addu a2,t0,v0
4700: 00c43021 addu a2,a2,a0
4704: 8e62000c lw v0,12(s3)
4708: ae660288 sw a2,648(s3)
470c: ae67028c sw a3,652(s3)
4710: 8e680290 lw t0,656(s3)
4714: 8e690294 lw t1,660(s3)
4718: 2c420002 sltiu v0,v0,2
adapter->stats.prc511 += E1000_READ_REG(&adapter->shared, PRC511);
471c: 8e640008 lw a0,8(s3)
4720: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4724: 8c874068 lw a3,16488(a0)
return __arch__swab32(x);
4728: 30e5ff00 andi a1,a3,0xff00
472c: 00073600 sll a2,a3,0x18
4730: 00072202 srl a0,a3,0x8
4734: 00052a00 sll a1,a1,0x8
4738: 3084ff00 andi a0,a0,0xff00
473c: 00c53025 or a2,a2,a1
4740: 00c43025 or a2,a2,a0
4744: 00073e02 srl a3,a3,0x18
4748: 00c71825 or v1,a2,a3
474c: 01233821 addu a3,t1,v1
4750: 00e3202b sltu a0,a3,v1
4754: 01023021 addu a2,t0,v0
4758: 00c43021 addu a2,a2,a0
475c: 8e62000c lw v0,12(s3)
4760: ae660290 sw a2,656(s3)
4764: ae670294 sw a3,660(s3)
4768: 8e680298 lw t0,664(s3)
476c: 8e69029c lw t1,668(s3)
4770: 2c420002 sltiu v0,v0,2
adapter->stats.prc1023 += E1000_READ_REG(&adapter->shared, PRC1023);
4774: 8e640008 lw a0,8(s3)
4778: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
477c: 8c87406c lw a3,16492(a0)
return __arch__swab32(x);
4780: 30e5ff00 andi a1,a3,0xff00
4784: 00073600 sll a2,a3,0x18
4788: 00072202 srl a0,a3,0x8
478c: 00052a00 sll a1,a1,0x8
4790: 3084ff00 andi a0,a0,0xff00
4794: 00c53025 or a2,a2,a1
4798: 00c43025 or a2,a2,a0
479c: 00073e02 srl a3,a3,0x18
47a0: 00c71825 or v1,a2,a3
47a4: 01233821 addu a3,t1,v1
47a8: 00e3202b sltu a0,a3,v1
47ac: 01023021 addu a2,t0,v0
47b0: 00c43021 addu a2,a2,a0
47b4: 8e62000c lw v0,12(s3)
47b8: ae660298 sw a2,664(s3)
47bc: ae67029c sw a3,668(s3)
47c0: 8e6802a0 lw t0,672(s3)
47c4: 8e6902a4 lw t1,676(s3)
47c8: 2c420002 sltiu v0,v0,2
adapter->stats.prc1522 += E1000_READ_REG(&adapter->shared, PRC1522);
47cc: 8e640008 lw a0,8(s3)
47d0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
47d4: 8c874070 lw a3,16496(a0)
return __arch__swab32(x);
47d8: 30e5ff00 andi a1,a3,0xff00
47dc: 00073600 sll a2,a3,0x18
47e0: 00072202 srl a0,a3,0x8
47e4: 00052a00 sll a1,a1,0x8
47e8: 3084ff00 andi a0,a0,0xff00
47ec: 00c53025 or a2,a2,a1
47f0: 00c43025 or a2,a2,a0
47f4: 00073e02 srl a3,a3,0x18
47f8: 00c71825 or v1,a2,a3
47fc: 01233821 addu a3,t1,v1
4800: 00e3202b sltu a0,a3,v1
4804: 01023021 addu a2,t0,v0
4808: 00c43021 addu a2,a2,a0
480c: 8e62000c lw v0,12(s3)
4810: ae6602a0 sw a2,672(s3)
4814: ae6702a4 sw a3,676(s3)
4818: 8e6802a8 lw t0,680(s3)
481c: 8e6902ac lw t1,684(s3)
4820: 2c420002 sltiu v0,v0,2
adapter->stats.gprc += E1000_READ_REG(&adapter->shared, GPRC);
4824: 8e640008 lw a0,8(s3)
4828: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
482c: 8c874074 lw a3,16500(a0)
return __arch__swab32(x);
4830: 30e5ff00 andi a1,a3,0xff00
4834: 00073600 sll a2,a3,0x18
4838: 00072202 srl a0,a3,0x8
483c: 00052a00 sll a1,a1,0x8
4840: 3084ff00 andi a0,a0,0xff00
4844: 00c53025 or a2,a2,a1
4848: 00c43025 or a2,a2,a0
484c: 00073e02 srl a3,a3,0x18
4850: 00c71825 or v1,a2,a3
4854: 01233821 addu a3,t1,v1
4858: 00e3202b sltu a0,a3,v1
485c: 01023021 addu a2,t0,v0
4860: 00c43021 addu a2,a2,a0
4864: 8e62000c lw v0,12(s3)
4868: ae6602a8 sw a2,680(s3)
486c: ae6702ac sw a3,684(s3)
4870: 8e6802b0 lw t0,688(s3)
4874: 8e6902b4 lw t1,692(s3)
4878: 2c420002 sltiu v0,v0,2
adapter->stats.bprc += E1000_READ_REG(&adapter->shared, BPRC);
487c: 8e640008 lw a0,8(s3)
4880: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4884: 8c874078 lw a3,16504(a0)
return __arch__swab32(x);
4888: 30e5ff00 andi a1,a3,0xff00
488c: 00073600 sll a2,a3,0x18
4890: 00072202 srl a0,a3,0x8
4894: 00052a00 sll a1,a1,0x8
4898: 3084ff00 andi a0,a0,0xff00
489c: 00c53025 or a2,a2,a1
48a0: 00c43025 or a2,a2,a0
48a4: 00073e02 srl a3,a3,0x18
48a8: 00c71825 or v1,a2,a3
48ac: 01233821 addu a3,t1,v1
48b0: 00e3202b sltu a0,a3,v1
48b4: 01023021 addu a2,t0,v0
48b8: 00c43021 addu a2,a2,a0
48bc: 8e62000c lw v0,12(s3)
48c0: ae6602b0 sw a2,688(s3)
48c4: ae6702b4 sw a3,692(s3)
48c8: 8e6802b8 lw t0,696(s3)
48cc: 8e6902bc lw t1,700(s3)
48d0: 2c420002 sltiu v0,v0,2
adapter->stats.mprc += E1000_READ_REG(&adapter->shared, MPRC);
48d4: 8e640008 lw a0,8(s3)
48d8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
48dc: 8c87407c lw a3,16508(a0)
return __arch__swab32(x);
48e0: 30e5ff00 andi a1,a3,0xff00
48e4: 00073600 sll a2,a3,0x18
48e8: 00072202 srl a0,a3,0x8
48ec: 00052a00 sll a1,a1,0x8
48f0: 3084ff00 andi a0,a0,0xff00
48f4: 00c53025 or a2,a2,a1
48f8: 00c43025 or a2,a2,a0
48fc: 00073e02 srl a3,a3,0x18
4900: 00c71825 or v1,a2,a3
4904: 01233821 addu a3,t1,v1
4908: 00e3202b sltu a0,a3,v1
490c: 01023021 addu a2,t0,v0
4910: 00c43021 addu a2,a2,a0
4914: 8e62000c lw v0,12(s3)
4918: ae6602b8 sw a2,696(s3)
491c: ae6702bc sw a3,700(s3)
4920: 8e6802c0 lw t0,704(s3)
4924: 8e6902c4 lw t1,708(s3)
4928: 2c420002 sltiu v0,v0,2
adapter->stats.gptc += E1000_READ_REG(&adapter->shared, GPTC);
492c: 8e640008 lw a0,8(s3)
4930: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4934: 8c874080 lw a3,16512(a0)
return __arch__swab32(x);
4938: 30e5ff00 andi a1,a3,0xff00
493c: 00073600 sll a2,a3,0x18
4940: 00072202 srl a0,a3,0x8
4944: 00052a00 sll a1,a1,0x8
4948: 3084ff00 andi a0,a0,0xff00
494c: 00c53025 or a2,a2,a1
4950: 00c43025 or a2,a2,a0
4954: 00073e02 srl a3,a3,0x18
4958: 00c71825 or v1,a2,a3
495c: 01233821 addu a3,t1,v1
4960: 00e3202b sltu a0,a3,v1
4964: 01023021 addu a2,t0,v0
4968: 00c43021 addu a2,a2,a0
496c: 8e62000c lw v0,12(s3)
4970: ae6602c0 sw a2,704(s3)
4974: ae6702c4 sw a3,708(s3)
4978: 8e6802c8 lw t0,712(s3)
497c: 8e6902cc lw t1,716(s3)
4980: 2c420002 sltiu v0,v0,2
/* for the 64-bit byte counters the low dword must be read first */
/* both registers clear on the read of the high dword */
adapter->stats.gorcl += E1000_READ_REG(&adapter->shared, GORCL);
4984: 8e640008 lw a0,8(s3)
4988: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
498c: 8c874088 lw a3,16520(a0)
return __arch__swab32(x);
4990: 30e5ff00 andi a1,a3,0xff00
4994: 00073600 sll a2,a3,0x18
4998: 00072202 srl a0,a3,0x8
499c: 00052a00 sll a1,a1,0x8
49a0: 3084ff00 andi a0,a0,0xff00
49a4: 00c53025 or a2,a2,a1
49a8: 00c43025 or a2,a2,a0
49ac: 00073e02 srl a3,a3,0x18
49b0: 00c71825 or v1,a2,a3
49b4: 01233821 addu a3,t1,v1
49b8: 00e3202b sltu a0,a3,v1
49bc: 01023021 addu a2,t0,v0
49c0: 00c43021 addu a2,a2,a0
49c4: 8e62000c lw v0,12(s3)
49c8: ae6602c8 sw a2,712(s3)
49cc: ae6702cc sw a3,716(s3)
49d0: 8e6802d0 lw t0,720(s3)
49d4: 8e6902d4 lw t1,724(s3)
49d8: 2c420002 sltiu v0,v0,2
adapter->stats.gorch += E1000_READ_REG(&adapter->shared, GORCH);
49dc: 8e640008 lw a0,8(s3)
49e0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
49e4: 8c87408c lw a3,16524(a0)
return __arch__swab32(x);
49e8: 30e5ff00 andi a1,a3,0xff00
49ec: 00073600 sll a2,a3,0x18
49f0: 00072202 srl a0,a3,0x8
49f4: 00052a00 sll a1,a1,0x8
49f8: 3084ff00 andi a0,a0,0xff00
49fc: 00c53025 or a2,a2,a1
4a00: 00c43025 or a2,a2,a0
4a04: 00073e02 srl a3,a3,0x18
4a08: 00c71825 or v1,a2,a3
4a0c: 01233821 addu a3,t1,v1
4a10: 00e3202b sltu a0,a3,v1
4a14: 01023021 addu a2,t0,v0
4a18: 00c43021 addu a2,a2,a0
4a1c: 8e62000c lw v0,12(s3)
4a20: ae6602d0 sw a2,720(s3)
4a24: ae6702d4 sw a3,724(s3)
4a28: 8e6802d8 lw t0,728(s3)
4a2c: 8e6902dc lw t1,732(s3)
4a30: 2c420002 sltiu v0,v0,2
adapter->stats.gotcl += E1000_READ_REG(&adapter->shared, GOTCL);
4a34: 8e640008 lw a0,8(s3)
4a38: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4a3c: 8c874090 lw a3,16528(a0)
return __arch__swab32(x);
4a40: 30e5ff00 andi a1,a3,0xff00
4a44: 00073600 sll a2,a3,0x18
4a48: 00072202 srl a0,a3,0x8
4a4c: 00052a00 sll a1,a1,0x8
4a50: 3084ff00 andi a0,a0,0xff00
4a54: 00c53025 or a2,a2,a1
4a58: 00c43025 or a2,a2,a0
4a5c: 00073e02 srl a3,a3,0x18
4a60: 00c71825 or v1,a2,a3
4a64: 01233821 addu a3,t1,v1
4a68: 00e3202b sltu a0,a3,v1
4a6c: 01023021 addu a2,t0,v0
4a70: 00c43021 addu a2,a2,a0
4a74: 8e62000c lw v0,12(s3)
4a78: ae6602d8 sw a2,728(s3)
4a7c: ae6702dc sw a3,732(s3)
4a80: 8e6802e0 lw t0,736(s3)
4a84: 8e6902e4 lw t1,740(s3)
4a88: 2c420002 sltiu v0,v0,2
adapter->stats.gotch += E1000_READ_REG(&adapter->shared, GOTCH);
4a8c: 8e640008 lw a0,8(s3)
4a90: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4a94: 8c874094 lw a3,16532(a0)
return __arch__swab32(x);
4a98: 30e5ff00 andi a1,a3,0xff00
4a9c: 00073600 sll a2,a3,0x18
4aa0: 00072202 srl a0,a3,0x8
4aa4: 00052a00 sll a1,a1,0x8
4aa8: 3084ff00 andi a0,a0,0xff00
4aac: 00c53025 or a2,a2,a1
4ab0: 00c43025 or a2,a2,a0
4ab4: 00073e02 srl a3,a3,0x18
4ab8: 00c71825 or v1,a2,a3
4abc: 01233821 addu a3,t1,v1
4ac0: 00e3202b sltu a0,a3,v1
4ac4: 01023021 addu a2,t0,v0
4ac8: 00c43021 addu a2,a2,a0
4acc: 8e62000c lw v0,12(s3)
4ad0: ae6602e0 sw a2,736(s3)
4ad4: ae6702e4 sw a3,740(s3)
4ad8: 8e6802e8 lw t0,744(s3)
4adc: 8e6902ec lw t1,748(s3)
4ae0: 2c420002 sltiu v0,v0,2
adapter->stats.rnbc += E1000_READ_REG(&adapter->shared, RNBC);
4ae4: 8e640008 lw a0,8(s3)
4ae8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4aec: 8c8740a0 lw a3,16544(a0)
return __arch__swab32(x);
4af0: 30e5ff00 andi a1,a3,0xff00
4af4: 00073600 sll a2,a3,0x18
4af8: 00072202 srl a0,a3,0x8
4afc: 00052a00 sll a1,a1,0x8
4b00: 3084ff00 andi a0,a0,0xff00
4b04: 00c53025 or a2,a2,a1
4b08: 00c43025 or a2,a2,a0
4b0c: 00073e02 srl a3,a3,0x18
4b10: 00c71825 or v1,a2,a3
4b14: 01233821 addu a3,t1,v1
4b18: 00e3202b sltu a0,a3,v1
4b1c: 01023021 addu a2,t0,v0
4b20: 00c43021 addu a2,a2,a0
4b24: 8e62000c lw v0,12(s3)
4b28: ae6602e8 sw a2,744(s3)
4b2c: ae6702ec sw a3,748(s3)
4b30: 8e6802f0 lw t0,752(s3)
4b34: 8e6902f4 lw t1,756(s3)
4b38: 2c420002 sltiu v0,v0,2
adapter->stats.ruc += E1000_READ_REG(&adapter->shared, RUC);
4b3c: 8e640008 lw a0,8(s3)
4b40: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4b44: 8c8740a4 lw a3,16548(a0)
return __arch__swab32(x);
4b48: 30e5ff00 andi a1,a3,0xff00
4b4c: 00073600 sll a2,a3,0x18
4b50: 00072202 srl a0,a3,0x8
4b54: 00052a00 sll a1,a1,0x8
4b58: 3084ff00 andi a0,a0,0xff00
4b5c: 00c53025 or a2,a2,a1
4b60: 00c43025 or a2,a2,a0
4b64: 00073e02 srl a3,a3,0x18
4b68: 00c71825 or v1,a2,a3
4b6c: 01233821 addu a3,t1,v1
4b70: 00e3202b sltu a0,a3,v1
4b74: 01023021 addu a2,t0,v0
4b78: 00c43021 addu a2,a2,a0
4b7c: 8e62000c lw v0,12(s3)
4b80: ae6602f0 sw a2,752(s3)
4b84: ae6702f4 sw a3,756(s3)
4b88: 8e6802f8 lw t0,760(s3)
4b8c: 8e6902fc lw t1,764(s3)
4b90: 2c420002 sltiu v0,v0,2
adapter->stats.rfc += E1000_READ_REG(&adapter->shared, RFC);
4b94: 8e640008 lw a0,8(s3)
4b98: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4b9c: 8c8740a8 lw a3,16552(a0)
return __arch__swab32(x);
4ba0: 30e5ff00 andi a1,a3,0xff00
4ba4: 00073600 sll a2,a3,0x18
4ba8: 00072202 srl a0,a3,0x8
4bac: 00052a00 sll a1,a1,0x8
4bb0: 3084ff00 andi a0,a0,0xff00
4bb4: 00c53025 or a2,a2,a1
4bb8: 00c43025 or a2,a2,a0
4bbc: 00073e02 srl a3,a3,0x18
4bc0: 00c71825 or v1,a2,a3
4bc4: 01233821 addu a3,t1,v1
4bc8: 00e3202b sltu a0,a3,v1
4bcc: 01023021 addu a2,t0,v0
4bd0: 00c43021 addu a2,a2,a0
4bd4: 8e62000c lw v0,12(s3)
4bd8: ae6602f8 sw a2,760(s3)
4bdc: ae6702fc sw a3,764(s3)
4be0: 8e680300 lw t0,768(s3)
4be4: 8e690304 lw t1,772(s3)
4be8: 2c420002 sltiu v0,v0,2
adapter->stats.roc += E1000_READ_REG(&adapter->shared, ROC);
4bec: 8e640008 lw a0,8(s3)
4bf0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4bf4: 8c8740ac lw a3,16556(a0)
return __arch__swab32(x);
4bf8: 30e5ff00 andi a1,a3,0xff00
4bfc: 00073600 sll a2,a3,0x18
4c00: 00072202 srl a0,a3,0x8
4c04: 00052a00 sll a1,a1,0x8
4c08: 3084ff00 andi a0,a0,0xff00
4c0c: 00c53025 or a2,a2,a1
4c10: 00c43025 or a2,a2,a0
4c14: 00073e02 srl a3,a3,0x18
4c18: 00c71825 or v1,a2,a3
4c1c: 01233821 addu a3,t1,v1
4c20: 00e3202b sltu a0,a3,v1
4c24: 01023021 addu a2,t0,v0
4c28: 00c43021 addu a2,a2,a0
4c2c: 8e62000c lw v0,12(s3)
4c30: ae660300 sw a2,768(s3)
4c34: ae670304 sw a3,772(s3)
4c38: 8e680308 lw t0,776(s3)
4c3c: 8e69030c lw t1,780(s3)
4c40: 2c420002 sltiu v0,v0,2
adapter->stats.rjc += E1000_READ_REG(&adapter->shared, RJC);
4c44: 8e640008 lw a0,8(s3)
4c48: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4c4c: 8c8740b0 lw a3,16560(a0)
return __arch__swab32(x);
4c50: 30e5ff00 andi a1,a3,0xff00
4c54: 00073600 sll a2,a3,0x18
4c58: 00072202 srl a0,a3,0x8
4c5c: 00052a00 sll a1,a1,0x8
4c60: 3084ff00 andi a0,a0,0xff00
4c64: 00c53025 or a2,a2,a1
4c68: 00c43025 or a2,a2,a0
4c6c: 00073e02 srl a3,a3,0x18
4c70: 00c71825 or v1,a2,a3
4c74: 01233821 addu a3,t1,v1
4c78: 00e3202b sltu a0,a3,v1
4c7c: 01023021 addu a2,t0,v0
4c80: 00c43021 addu a2,a2,a0
4c84: 8e62000c lw v0,12(s3)
4c88: ae660308 sw a2,776(s3)
4c8c: ae67030c sw a3,780(s3)
4c90: 8e680328 lw t0,808(s3)
4c94: 8e69032c lw t1,812(s3)
4c98: 2c420002 sltiu v0,v0,2
adapter->stats.torl += E1000_READ_REG(&adapter->shared, TORL);
4c9c: 8e640008 lw a0,8(s3)
4ca0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4ca4: 8c8740c0 lw a3,16576(a0)
return __arch__swab32(x);
4ca8: 30e5ff00 andi a1,a3,0xff00
4cac: 00073600 sll a2,a3,0x18
4cb0: 00072202 srl a0,a3,0x8
4cb4: 00052a00 sll a1,a1,0x8
4cb8: 3084ff00 andi a0,a0,0xff00
4cbc: 00c53025 or a2,a2,a1
4cc0: 00c43025 or a2,a2,a0
4cc4: 00073e02 srl a3,a3,0x18
4cc8: 00c71825 or v1,a2,a3
4ccc: 01233821 addu a3,t1,v1
4cd0: 00e3202b sltu a0,a3,v1
4cd4: 01023021 addu a2,t0,v0
4cd8: 00c43021 addu a2,a2,a0
4cdc: 8e62000c lw v0,12(s3)
4ce0: ae660328 sw a2,808(s3)
4ce4: ae67032c sw a3,812(s3)
4ce8: 8e680330 lw t0,816(s3)
4cec: 8e690334 lw t1,820(s3)
4cf0: 2c420002 sltiu v0,v0,2
adapter->stats.torh += E1000_READ_REG(&adapter->shared, TORH);
4cf4: 8e640008 lw a0,8(s3)
4cf8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4cfc: 8c8740c4 lw a3,16580(a0)
return __arch__swab32(x);
4d00: 30e5ff00 andi a1,a3,0xff00
4d04: 00073600 sll a2,a3,0x18
4d08: 00072202 srl a0,a3,0x8
4d0c: 00052a00 sll a1,a1,0x8
4d10: 3084ff00 andi a0,a0,0xff00
4d14: 00c53025 or a2,a2,a1
4d18: 00c43025 or a2,a2,a0
4d1c: 00073e02 srl a3,a3,0x18
4d20: 00c71825 or v1,a2,a3
4d24: 01233821 addu a3,t1,v1
4d28: 00e3202b sltu a0,a3,v1
4d2c: 01023021 addu a2,t0,v0
4d30: 00c43021 addu a2,a2,a0
4d34: 8e62000c lw v0,12(s3)
4d38: ae660330 sw a2,816(s3)
4d3c: ae670334 sw a3,820(s3)
4d40: 8e680338 lw t0,824(s3)
4d44: 8e69033c lw t1,828(s3)
4d48: 2c420002 sltiu v0,v0,2
adapter->stats.totl += E1000_READ_REG(&adapter->shared, TOTL);
4d4c: 8e640008 lw a0,8(s3)
4d50: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4d54: 8c8740c8 lw a3,16584(a0)
return __arch__swab32(x);
4d58: 30e5ff00 andi a1,a3,0xff00
4d5c: 00073600 sll a2,a3,0x18
4d60: 00072202 srl a0,a3,0x8
4d64: 00052a00 sll a1,a1,0x8
4d68: 3084ff00 andi a0,a0,0xff00
4d6c: 00c53025 or a2,a2,a1
4d70: 00c43025 or a2,a2,a0
4d74: 00073e02 srl a3,a3,0x18
4d78: 00c71825 or v1,a2,a3
4d7c: 01233821 addu a3,t1,v1
4d80: 00e3202b sltu a0,a3,v1
4d84: 01023021 addu a2,t0,v0
4d88: 00c43021 addu a2,a2,a0
4d8c: 8e62000c lw v0,12(s3)
4d90: ae660338 sw a2,824(s3)
4d94: ae67033c sw a3,828(s3)
4d98: 8e680340 lw t0,832(s3)
4d9c: 8e690344 lw t1,836(s3)
4da0: 2c420002 sltiu v0,v0,2
adapter->stats.toth += E1000_READ_REG(&adapter->shared, TOTH);
4da4: 8e640008 lw a0,8(s3)
4da8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4dac: 8c8740cc lw a3,16588(a0)
return __arch__swab32(x);
4db0: 30e5ff00 andi a1,a3,0xff00
4db4: 00073600 sll a2,a3,0x18
4db8: 00072202 srl a0,a3,0x8
4dbc: 00052a00 sll a1,a1,0x8
4dc0: 3084ff00 andi a0,a0,0xff00
4dc4: 00c53025 or a2,a2,a1
4dc8: 00c43025 or a2,a2,a0
4dcc: 00073e02 srl a3,a3,0x18
4dd0: 00c71825 or v1,a2,a3
4dd4: 01233821 addu a3,t1,v1
4dd8: 00e3202b sltu a0,a3,v1
4ddc: 01023021 addu a2,t0,v0
4de0: 00c43021 addu a2,a2,a0
4de4: 8e62000c lw v0,12(s3)
4de8: ae660340 sw a2,832(s3)
4dec: ae670344 sw a3,836(s3)
4df0: 8e680348 lw t0,840(s3)
4df4: 8e69034c lw t1,844(s3)
4df8: 2c420002 sltiu v0,v0,2
adapter->stats.tpr += E1000_READ_REG(&adapter->shared, TPR);
4dfc: 8e640008 lw a0,8(s3)
4e00: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4e04: 8c8740d0 lw a3,16592(a0)
return __arch__swab32(x);
4e08: 30e5ff00 andi a1,a3,0xff00
4e0c: 00073600 sll a2,a3,0x18
4e10: 00072202 srl a0,a3,0x8
4e14: 00052a00 sll a1,a1,0x8
4e18: 3084ff00 andi a0,a0,0xff00
4e1c: 00c53025 or a2,a2,a1
4e20: 00c43025 or a2,a2,a0
4e24: 00073e02 srl a3,a3,0x18
4e28: 00c71825 or v1,a2,a3
4e2c: 01233821 addu a3,t1,v1
4e30: 00e3202b sltu a0,a3,v1
4e34: 01023021 addu a2,t0,v0
4e38: 00c43021 addu a2,a2,a0
4e3c: 8e62000c lw v0,12(s3)
4e40: ae660348 sw a2,840(s3)
4e44: ae67034c sw a3,844(s3)
4e48: 8e680350 lw t0,848(s3)
4e4c: 8e690354 lw t1,852(s3)
4e50: 2c420002 sltiu v0,v0,2
adapter->stats.tpt += E1000_READ_REG(&adapter->shared, TPT);
4e54: 8e640008 lw a0,8(s3)
4e58: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4e5c: 8c8740d4 lw a3,16596(a0)
return __arch__swab32(x);
4e60: 30e5ff00 andi a1,a3,0xff00
4e64: 00073600 sll a2,a3,0x18
4e68: 00072202 srl a0,a3,0x8
4e6c: 00052a00 sll a1,a1,0x8
4e70: 3084ff00 andi a0,a0,0xff00
4e74: 00c53025 or a2,a2,a1
4e78: 00c43025 or a2,a2,a0
4e7c: 00073e02 srl a3,a3,0x18
4e80: 00c71825 or v1,a2,a3
4e84: 01233821 addu a3,t1,v1
4e88: 00e3202b sltu a0,a3,v1
4e8c: 01023021 addu a2,t0,v0
4e90: 00c43021 addu a2,a2,a0
4e94: 8e62000c lw v0,12(s3)
4e98: ae660350 sw a2,848(s3)
4e9c: ae670354 sw a3,852(s3)
4ea0: 8e680358 lw t0,856(s3)
4ea4: 8e69035c lw t1,860(s3)
4ea8: 2c420002 sltiu v0,v0,2
adapter->stats.ptc64 += E1000_READ_REG(&adapter->shared, PTC64);
4eac: 8e640008 lw a0,8(s3)
4eb0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4eb4: 8c8740d8 lw a3,16600(a0)
return __arch__swab32(x);
4eb8: 30e5ff00 andi a1,a3,0xff00
4ebc: 00073600 sll a2,a3,0x18
4ec0: 00072202 srl a0,a3,0x8
4ec4: 00052a00 sll a1,a1,0x8
4ec8: 3084ff00 andi a0,a0,0xff00
4ecc: 00c53025 or a2,a2,a1
4ed0: 00c43025 or a2,a2,a0
4ed4: 00073e02 srl a3,a3,0x18
4ed8: 00c71825 or v1,a2,a3
4edc: 01233821 addu a3,t1,v1
4ee0: 00e3202b sltu a0,a3,v1
4ee4: 01023021 addu a2,t0,v0
4ee8: 00c43021 addu a2,a2,a0
4eec: 8e62000c lw v0,12(s3)
4ef0: ae660358 sw a2,856(s3)
4ef4: ae67035c sw a3,860(s3)
4ef8: 8e680360 lw t0,864(s3)
4efc: 8e690364 lw t1,868(s3)
4f00: 2c420002 sltiu v0,v0,2
adapter->stats.ptc127 += E1000_READ_REG(&adapter->shared, PTC127);
4f04: 8e640008 lw a0,8(s3)
4f08: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4f0c: 8c8740dc lw a3,16604(a0)
return __arch__swab32(x);
4f10: 30e5ff00 andi a1,a3,0xff00
4f14: 00073600 sll a2,a3,0x18
4f18: 00072202 srl a0,a3,0x8
4f1c: 00052a00 sll a1,a1,0x8
4f20: 3084ff00 andi a0,a0,0xff00
4f24: 00c53025 or a2,a2,a1
4f28: 00c43025 or a2,a2,a0
4f2c: 00073e02 srl a3,a3,0x18
4f30: 00c71825 or v1,a2,a3
4f34: 01233821 addu a3,t1,v1
4f38: 00e3202b sltu a0,a3,v1
4f3c: 01023021 addu a2,t0,v0
4f40: 00c43021 addu a2,a2,a0
4f44: 8e62000c lw v0,12(s3)
4f48: ae660360 sw a2,864(s3)
4f4c: ae670364 sw a3,868(s3)
4f50: 8e680368 lw t0,872(s3)
4f54: 8e69036c lw t1,876(s3)
4f58: 2c420002 sltiu v0,v0,2
adapter->stats.ptc255 += E1000_READ_REG(&adapter->shared, PTC255);
4f5c: 8e640008 lw a0,8(s3)
4f60: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4f64: 8c8740e0 lw a3,16608(a0)
return __arch__swab32(x);
4f68: 30e5ff00 andi a1,a3,0xff00
4f6c: 00073600 sll a2,a3,0x18
4f70: 00072202 srl a0,a3,0x8
4f74: 00052a00 sll a1,a1,0x8
4f78: 3084ff00 andi a0,a0,0xff00
4f7c: 00c53025 or a2,a2,a1
4f80: 00c43025 or a2,a2,a0
4f84: 00073e02 srl a3,a3,0x18
4f88: 00c71825 or v1,a2,a3
4f8c: 01233821 addu a3,t1,v1
4f90: 00e3202b sltu a0,a3,v1
4f94: 01023021 addu a2,t0,v0
4f98: 00c43021 addu a2,a2,a0
4f9c: 8e62000c lw v0,12(s3)
4fa0: ae660368 sw a2,872(s3)
4fa4: ae67036c sw a3,876(s3)
4fa8: 8e680370 lw t0,880(s3)
4fac: 8e690374 lw t1,884(s3)
4fb0: 2c420002 sltiu v0,v0,2
adapter->stats.ptc511 += E1000_READ_REG(&adapter->shared, PTC511);
4fb4: 8e640008 lw a0,8(s3)
4fb8: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
4fbc: 8c8740e4 lw a3,16612(a0)
return __arch__swab32(x);
4fc0: 30e5ff00 andi a1,a3,0xff00
4fc4: 00073600 sll a2,a3,0x18
4fc8: 00072202 srl a0,a3,0x8
4fcc: 00052a00 sll a1,a1,0x8
4fd0: 3084ff00 andi a0,a0,0xff00
4fd4: 00c53025 or a2,a2,a1
4fd8: 00c43025 or a2,a2,a0
4fdc: 00073e02 srl a3,a3,0x18
4fe0: 00c71825 or v1,a2,a3
4fe4: 01233821 addu a3,t1,v1
4fe8: 00e3202b sltu a0,a3,v1
4fec: 01023021 addu a2,t0,v0
4ff0: 00c43021 addu a2,a2,a0
4ff4: 8e62000c lw v0,12(s3)
4ff8: ae660370 sw a2,880(s3)
4ffc: ae670374 sw a3,884(s3)
5000: 8e680378 lw t0,888(s3)
5004: 8e69037c lw t1,892(s3)
5008: 2c420002 sltiu v0,v0,2
adapter->stats.ptc1023 += E1000_READ_REG(&adapter->shared, PTC1023);
500c: 8e640008 lw a0,8(s3)
5010: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
5014: 8c8740e8 lw a3,16616(a0)
return __arch__swab32(x);
5018: 30e5ff00 andi a1,a3,0xff00
501c: 00073600 sll a2,a3,0x18
5020: 00072202 srl a0,a3,0x8
5024: 00052a00 sll a1,a1,0x8
5028: 3084ff00 andi a0,a0,0xff00
502c: 00c53025 or a2,a2,a1
5030: 00c43025 or a2,a2,a0
5034: 00073e02 srl a3,a3,0x18
5038: 00c71825 or v1,a2,a3
503c: 01233821 addu a3,t1,v1
5040: 00e3202b sltu a0,a3,v1
5044: 01023021 addu a2,t0,v0
5048: 00c43021 addu a2,a2,a0
504c: 8e62000c lw v0,12(s3)
5050: ae660378 sw a2,888(s3)
5054: ae67037c sw a3,892(s3)
5058: 8e680380 lw t0,896(s3)
505c: 8e690384 lw t1,900(s3)
5060: 2c420002 sltiu v0,v0,2
adapter->stats.ptc1522 += E1000_READ_REG(&adapter->shared, PTC1522);
5064: 8e640008 lw a0,8(s3)
5068: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
506c: 8c8740ec lw a3,16620(a0)
return __arch__swab32(x);
5070: 30e5ff00 andi a1,a3,0xff00
5074: 00073600 sll a2,a3,0x18
5078: 00072202 srl a0,a3,0x8
507c: 00052a00 sll a1,a1,0x8
5080: 3084ff00 andi a0,a0,0xff00
5084: 00c53025 or a2,a2,a1
5088: 00c43025 or a2,a2,a0
508c: 00073e02 srl a3,a3,0x18
5090: 00c71825 or v1,a2,a3
5094: 01233821 addu a3,t1,v1
5098: 00e3202b sltu a0,a3,v1
509c: 01023021 addu a2,t0,v0
50a0: 00c43021 addu a2,a2,a0
50a4: 8e62000c lw v0,12(s3)
50a8: ae660380 sw a2,896(s3)
50ac: ae670384 sw a3,900(s3)
50b0: 8e680388 lw t0,904(s3)
50b4: 8e69038c lw t1,908(s3)
50b8: 2c420002 sltiu v0,v0,2
adapter->stats.mptc += E1000_READ_REG(&adapter->shared, MPTC);
50bc: 8e640008 lw a0,8(s3)
50c0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
50c4: 8c8740f0 lw a3,16624(a0)
return __arch__swab32(x);
50c8: 30e5ff00 andi a1,a3,0xff00
50cc: 00073600 sll a2,a3,0x18
50d0: 00072202 srl a0,a3,0x8
50d4: 00052a00 sll a1,a1,0x8
50d8: 3084ff00 andi a0,a0,0xff00
50dc: 00c53025 or a2,a2,a1
50e0: 00c43025 or a2,a2,a0
50e4: 00073e02 srl a3,a3,0x18
50e8: 00c71825 or v1,a2,a3
50ec: 01233821 addu a3,t1,v1
50f0: 00e3202b sltu a0,a3,v1
50f4: 01023021 addu a2,t0,v0
50f8: 00c43021 addu a2,a2,a0
50fc: 8e62000c lw v0,12(s3)
5100: ae660388 sw a2,904(s3)
5104: ae67038c sw a3,908(s3)
5108: 8e680390 lw t0,912(s3)
510c: 8e690394 lw t1,916(s3)
5110: 2c420002 sltiu v0,v0,2
adapter->stats.bptc += E1000_READ_REG(&adapter->shared, BPTC);
5114: 8e640008 lw a0,8(s3)
5118: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
511c: 8c8740f4 lw a3,16628(a0)
return __arch__swab32(x);
5120: 30e5ff00 andi a1,a3,0xff00
5124: 00073600 sll a2,a3,0x18
5128: 00072202 srl a0,a3,0x8
512c: 00052a00 sll a1,a1,0x8
5130: 3084ff00 andi a0,a0,0xff00
5134: 00c53025 or a2,a2,a1
5138: 00c43025 or a2,a2,a0
513c: 00073e02 srl a3,a3,0x18
5140: 00c71825 or v1,a2,a3
5144: 01233821 addu a3,t1,v1
5148: 00e3202b sltu a0,a3,v1
514c: 01023021 addu a2,t0,v0
5150: 00c43021 addu a2,a2,a0
if(adapter->shared.mac_type >= e1000_82543) {
5154: 8e62000c lw v0,12(s3)
5158: ae660390 sw a2,912(s3)
515c: ae670394 sw a3,916(s3)
5160: 2c420002 sltiu v0,v0,2
5164: 5440008c bnezl v0,5398 <e1000_update_stats+0x1354>
5168: 8e6301dc lw v1,476(s3)
adapter->stats.algnerrc += E1000_READ_REG(&adapter->shared, ALGNERRC);
516c: 8e620008 lw v0,8(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
5170: 3c0c00ff lui t4,0xff
5174: 8e6801e0 lw t0,480(s3)
5178: 8e6901e4 lw t1,484(s3)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
517c: 8c474004 lw a3,16388(v0)
5180: 8e6a000c lw t2,12(s3)
5184: 00001021 move v0,zero
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
5188: 30e5ff00 andi a1,a3,0xff00
518c: 00073600 sll a2,a3,0x18
5190: 00ec2024 and a0,a3,t4
5194: 00052a00 sll a1,a1,0x8
5198: 00042202 srl a0,a0,0x8
519c: 00c53025 or a2,a2,a1
51a0: 00c43025 or a2,a2,a0
51a4: 00073e02 srl a3,a3,0x18
51a8: 00c71825 or v1,a2,a3
51ac: 01234821 addu t1,t1,v1
51b0: 0123202b sltu a0,t1,v1
51b4: 01024021 addu t0,t0,v0
51b8: 01044021 addu t0,t0,a0
51bc: 2d4a0002 sltiu t2,t2,2
51c0: ae6801e0 sw t0,480(s3)
51c4: ae6901e4 sw t1,484(s3)
51c8: 8e6801f0 lw t0,496(s3)
51cc: 8e6901f4 lw t1,500(s3)
51d0: 15400003 bnez t2,51e0 <e1000_update_stats+0x119c>
51d4: 3c0bff00 lui t3,0xff00
adapter->stats.rxerrc += E1000_READ_REG(&adapter->shared, RXERRC);
51d8: 0800147a j 51e8 <e1000_update_stats+0x11a4>
51dc: 8e660008 lw a2,8(s3)
51e0: 8e660008 lw a2,8(s3)
51e4: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
51e8: 8cc4400c lw a0,16396(a2)
return __arch__swab32(x);
51ec: 3085ff00 andi a1,a0,0xff00
51f0: 008c3824 and a3,a0,t4
51f4: 00043600 sll a2,a0,0x18
51f8: 00052a00 sll a1,a1,0x8
51fc: 00073a02 srl a3,a3,0x8
5200: 00c53025 or a2,a2,a1
5204: 008b2024 and a0,a0,t3
5208: 00c73025 or a2,a2,a3
520c: 00042602 srl a0,a0,0x18
5210: 00c41825 or v1,a2,a0
5214: 01233821 addu a3,t1,v1
5218: 00e3202b sltu a0,a3,v1
521c: 01023021 addu a2,t0,v0
5220: 00c43021 addu a2,a2,a0
5224: 8e62000c lw v0,12(s3)
5228: ae6601f0 sw a2,496(s3)
522c: ae6701f4 sw a3,500(s3)
5230: 8e680230 lw t0,560(s3)
5234: 8e690234 lw t1,564(s3)
5238: 2c420002 sltiu v0,v0,2
adapter->stats.tncrs += E1000_READ_REG(&adapter->shared, TNCRS);
523c: 8e640008 lw a0,8(s3)
5240: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
5244: 8c874034 lw a3,16436(a0)
return __arch__swab32(x);
5248: 30e5ff00 andi a1,a3,0xff00
524c: 00073600 sll a2,a3,0x18
5250: 00072202 srl a0,a3,0x8
5254: 00052a00 sll a1,a1,0x8
5258: 3084ff00 andi a0,a0,0xff00
525c: 00c53025 or a2,a2,a1
5260: 00c43025 or a2,a2,a0
5264: 00073e02 srl a3,a3,0x18
5268: 00c71825 or v1,a2,a3
526c: 01233821 addu a3,t1,v1
5270: 00e3202b sltu a0,a3,v1
5274: 01023021 addu a2,t0,v0
5278: 00c43021 addu a2,a2,a0
527c: 8e62000c lw v0,12(s3)
5280: ae660230 sw a2,560(s3)
5284: ae670234 sw a3,564(s3)
5288: 8e680240 lw t0,576(s3)
528c: 8e690244 lw t1,580(s3)
5290: 2c420002 sltiu v0,v0,2
adapter->stats.cexterr += E1000_READ_REG(&adapter->shared, CEXTERR);
5294: 8e640008 lw a0,8(s3)
5298: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
529c: 8c87403c lw a3,16444(a0)
return __arch__swab32(x);
52a0: 30e5ff00 andi a1,a3,0xff00
52a4: 00073600 sll a2,a3,0x18
52a8: 00072202 srl a0,a3,0x8
52ac: 00052a00 sll a1,a1,0x8
52b0: 3084ff00 andi a0,a0,0xff00
52b4: 00c53025 or a2,a2,a1
52b8: 00c43025 or a2,a2,a0
52bc: 00073e02 srl a3,a3,0x18
52c0: 00c71825 or v1,a2,a3
52c4: 01233821 addu a3,t1,v1
52c8: 00e3202b sltu a0,a3,v1
52cc: 01023021 addu a2,t0,v0
52d0: 00c43021 addu a2,a2,a0
52d4: 8e62000c lw v0,12(s3)
52d8: ae660240 sw a2,576(s3)
52dc: ae670244 sw a3,580(s3)
52e0: 8e680398 lw t0,920(s3)
52e4: 8e69039c lw t1,924(s3)
52e8: 2c420002 sltiu v0,v0,2
adapter->stats.tsctc += E1000_READ_REG(&adapter->shared, TSCTC);
52ec: 8e640008 lw a0,8(s3)
52f0: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
52f4: 8c8740f8 lw a3,16632(a0)
return __arch__swab32(x);
52f8: 30e5ff00 andi a1,a3,0xff00
52fc: 00073600 sll a2,a3,0x18
5300: 00072202 srl a0,a3,0x8
5304: 00052a00 sll a1,a1,0x8
5308: 3084ff00 andi a0,a0,0xff00
530c: 00c53025 or a2,a2,a1
5310: 00c43025 or a2,a2,a0
5314: 00073e02 srl a3,a3,0x18
5318: 00c71825 or v1,a2,a3
531c: 01233821 addu a3,t1,v1
5320: 00e3202b sltu a0,a3,v1
5324: 01023021 addu a2,t0,v0
5328: 00c43021 addu a2,a2,a0
532c: 8e62000c lw v0,12(s3)
5330: ae660398 sw a2,920(s3)
5334: ae67039c sw a3,924(s3)
5338: 8e6803a0 lw t0,928(s3)
533c: 8e6903a4 lw t1,932(s3)
5340: 2c420002 sltiu v0,v0,2
adapter->stats.tsctfc += E1000_READ_REG(&adapter->shared, TSCTFC);
5344: 8e640008 lw a0,8(s3)
5348: 00001021 move v0,zero
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
534c: 8c8740fc lw a3,16636(a0)
return __arch__swab32(x);
5350: 30e5ff00 andi a1,a3,0xff00
5354: 00073600 sll a2,a3,0x18
5358: 00072202 srl a0,a3,0x8
535c: 00052a00 sll a1,a1,0x8
5360: 3084ff00 andi a0,a0,0xff00
5364: 00c53025 or a2,a2,a1
5368: 00c43025 or a2,a2,a0
536c: 00073e02 srl a3,a3,0x18
5370: 00c71825 or v1,a2,a3
5374: 01233821 addu a3,t1,v1
5378: 00e3202b sltu a0,a3,v1
537c: 01023021 addu a2,t0,v0
5380: 00c43021 addu a2,a2,a0
5384: 00c01021 move v0,a2
5388: 00e01821 move v1,a3
538c: ae6203a0 sw v0,928(s3)
5390: ae6303a4 sw v1,932(s3)
}
/* Fill out the OS statistics structure */
adapter->net_stats.rx_packets = adapter->stats.gprc;
adapter->net_stats.tx_packets = adapter->stats.gptc;
adapter->net_stats.rx_bytes = adapter->stats.gorcl;
adapter->net_stats.tx_bytes = adapter->stats.gotcl;
adapter->net_stats.multicast = adapter->stats.mprc;
adapter->net_stats.collisions = adapter->stats.colc;
/* Rx Errors */
adapter->net_stats.rx_errors =
5394: 8e6301dc lw v1,476(s3)
5398: 8e6201f4 lw v0,500(s3)
539c: 8e6401e4 lw a0,484(s3)
53a0: 8e65024c lw a1,588(s3)
53a4: 8e6602ec lw a2,748(s3)
53a8: 00431021 addu v0,v0,v1
53ac: 8e7201fc lw s2,508(s3)
53b0: 00441021 addu v0,v0,a0
53b4: 00451021 addu v0,v0,a1
53b8: 8e710244 lw s1,580(s3)
53bc: 8e6402ac lw a0,684(s3)
53c0: 00461021 addu v0,v0,a2
adapter->stats.rxerrc + adapter->stats.crcerrs +
adapter->stats.algnerrc + adapter->stats.rlec + adapter->stats.rnbc +
adapter->stats.mpc + adapter->stats.cexterr;
adapter->net_stats.rx_dropped = adapter->stats.rnbc;
adapter->net_stats.rx_length_errors = adapter->stats.rlec;
adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
adapter->net_stats.rx_fifo_errors = adapter->stats.mpc;
adapter->net_stats.rx_missed_errors = adapter->stats.mpc;
/* Tx Errors */
adapter->net_stats.tx_errors = adapter->stats.ecol + adapter->stats.latecol;
53c4: 8e6a021c lw t2,540(s3)
53c8: 8e63020c lw v1,524(s3)
53cc: 00521021 addu v0,v0,s2
53d0: 00511021 addu v0,v0,s1
53d4: 8e6502c4 lw a1,708(s3)
53d8: 8e6602cc lw a2,716(s3)
53dc: 8e6702dc lw a3,732(s3)
53e0: 8e6802bc lw t0,700(s3)
53e4: 8e690224 lw t1,548(s3)
53e8: 8e6b02ec lw t3,748(s3)
53ec: 8e6c024c lw t4,588(s3)
53f0: 8e6d01dc lw t5,476(s3)
53f4: 8e6e01e4 lw t6,484(s3)
53f8: ae640150 sw a0,336(s3)
53fc: ae620160 sw v0,352(s3)
adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
adapter->net_stats.tx_window_errors = adapter->stats.latecol;
/* Tx Dropped needs to be maintained elsewhere */
if(adapter->shared.media_type == e1000_media_type_copper) {
5400: 8e640010 lw a0,16(s3)
5404: 8e62020c lw v0,524(s3)
5408: 02407821 move t7,s2
540c: 006a1821 addu v1,v1,t2
5410: ae630164 sw v1,356(s3)
5414: 01e08021 move s0,t7
5418: 01401821 move v1,t2
541c: ae650154 sw a1,340(s3)
5420: ae660158 sw a2,344(s3)
5424: ae67015c sw a3,348(s3)
5428: ae680170 sw t0,368(s3)
542c: ae690174 sw t1,372(s3)
5430: ae6b0168 sw t3,360(s3)
5434: ae6c0178 sw t4,376(s3)
5438: ae6d0180 sw t5,384(s3)
543c: ae6e0184 sw t6,388(s3)
5440: ae6f0188 sw t7,392(s3)
5444: ae70018c sw s0,396(s3)
5448: ae620190 sw v0,400(s3)
544c: 14800011 bnez a0,5494 <e1000_update_stats+0x1450>
5450: ae6301a0 sw v1,416(s3)
adapter->idle_errors +=
5454: 26700008 addiu s0,s3,8
5458: 02002021 move a0,s0
545c: 3c110000 lui s1,0x0
5460: 26310000 addiu s1,s1,0
5464: 0220f809 jalr s1
5468: 2405000a li a1,10
546c: 8e6303ac lw v1,940(s3)
5470: 304200ff andi v0,v0,0xff
(e1000_read_phy_reg(&adapter->shared, PHY_1000T_STATUS)
& PHY_IDLE_ERROR_COUNT_MASK);
adapter->receive_errors +=
5474: 02002021 move a0,s0
5478: 00621821 addu v1,v1,v0
547c: ae6303ac sw v1,940(s3)
5480: 0220f809 jalr s1
5484: 24050015 li a1,21
5488: 8e6303a8 lw v1,936(s3)
548c: 00621821 addu v1,v1,v0
5490: ae6303a8 sw v1,936(s3)
e1000_read_phy_reg(&adapter->shared, M88E1000_RX_ERR_CNTR);
}
spin_unlock_irqrestore(&adapter->stats_lock, flags);
5494: 40016000 mfc0 at,$12
5498: 32940001 andi s4,s4,0x1
549c: 34210001 ori at,at,0x1
54a0: 38210001 xori at,at,0x1
54a4: 0281a025 or s4,s4,at
54a8: 40946000 mtc0 s4,$12
...
return;
}
54b8: 8fbf0024 lw ra,36(sp)
54bc: 8fb40020 lw s4,32(sp)
54c0: 8fb3001c lw s3,28(sp)
54c4: 8fb20018 lw s2,24(sp)
54c8: 8fb10014 lw s1,20(sp)
54cc: 8fb00010 lw s0,16(sp)
54d0: 03e00008 jr ra
54d4: 27bd0028 addiu sp,sp,40
000054d8 <e1000_intr>:
54d8: 27bdffd0 addiu sp,sp,-48
54dc: afb10014 sw s1,20(sp)
54e0: afbf002c sw ra,44(sp)
54e4: afb60028 sw s6,40(sp)
54e8: afb50024 sw s5,36(sp)
54ec: afb40020 sw s4,32(sp)
54f0: afb3001c sw s3,28(sp)
54f4: afb20018 sw s2,24(sp)
54f8: afb00010 sw s0,16(sp)
/**
* e1000_irq_disable - Mask off interrupt generation on the NIC
* @adapter: board private structure
**/
static inline void
e1000_irq_disable(struct e1000_adapter *adapter)
{
E1000_DBG("e1000_irq_disable\n");
/* Mask off all interrupts */
E1000_WRITE_REG(&adapter->shared, IMC, ~0);
return;
}
/**
* e1000_irq_enable - Enable default interrupt generation settings
* @adapter: board private structure
**/
static inline void
e1000_irq_enable(struct e1000_adapter *adapter)
{
E1000_DBG("e1000_irq_enable\n");
E1000_WRITE_REG(&adapter->shared, IMS, adapter->int_mask);
return;
}
/**
* e1000_intr - Interrupt Handler
* @irq: interrupt number
* @data: pointer to a network interface device structure
* @pt_regs: CPU registers structure
**/
void
e1000_intr(int irq,
void *data,
struct pt_regs *regs)
{
struct net_device *netdev = (struct net_device *) data;
struct e1000_adapter *adapter = netdev->priv;
54fc: 8cb00064 lw s0,100(a1)
uint32_t icr;
uint loop_count = E1000_MAX_INTR;
5500: 24110001 li s1,1
5504: 8e02000c lw v0,12(s0)
5508: 2c420002 sltiu v0,v0,2
550c: 8e030008 lw v1,8(s0)
5510: 2402ffff li v0,-1
5514: ac6200d8 sw v0,216(v1)
E1000_DBG("e1000_intr\n");
e1000_irq_disable(adapter);
while(loop_count > 0 && (icr = E1000_READ_REG(&adapter->shared, ICR)) != 0) {
5518: 3c1300ff lui s3,0xff
551c: 3c12ff00 lui s2,0xff00
5520: 24160001 li s6,1
5524: 3c150000 lui s5,0x0
5528: 26b50000 addiu s5,s5,0
552c: 3c140000 lui s4,0x0
5530: 269458dc addiu s4,s4,22748
5534: 8e07000c lw a3,12(s0)
5538: 2ce20002 sltiu v0,a3,2
553c: 8e060008 lw a2,8(s0)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
5540: 8cc200c0 lw v0,192(a2)
return __arch__swab32(x);
5544: 3043ff00 andi v1,v0,0xff00
5548: 00022e00 sll a1,v0,0x18
554c: 00532024 and a0,v0,s3
5550: 00031a00 sll v1,v1,0x8
5554: 00a32825 or a1,a1,v1
5558: 00042202 srl a0,a0,0x8
555c: 00521024 and v0,v0,s2
5560: 00a42825 or a1,a1,a0
5564: 00021602 srl v0,v0,0x18
5568: 00a22825 or a1,a1,v0
556c: 10a00017 beqz a1,55cc <e1000_intr+0xf4>
5570: 30a2000c andi v0,a1,0xc
if(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
5574: 1040000b beqz v0,55a4 <e1000_intr+0xcc>
5578: 00000000 nop
adapter->shared.get_link_status = 1;
557c: ae160058 sw s6,88(s0)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
5580: c202008c ll v0,140(s0)
5584: 34420008 ori v0,v0,0x8
5588: e202008c sc v0,140(s0)
558c: 1040fffc beqz v0,5580 <e1000_intr+0xa8>
5590: 00000000 nop
set_bit(E1000_LINK_STATUS_CHANGED, &adapter->flags);
/* run the watchdog ASAP */
mod_timer(&adapter->timer_id, jiffies);
5594: 3c050000 lui a1,0x0
5598: 8ca50000 lw a1,0(a1)
559c: 02a0f809 jalr s5
55a0: 26040094 addiu a0,s0,148
}
e1000_clean_rx_irq(adapter);
55a4: 0280f809 jalr s4
55a8: 02002021 move a0,s0
e1000_clean_tx_irq(adapter);
loop_count--;
55ac: 2631ffff addiu s1,s1,-1
55b0: 3c020000 lui v0,0x0
55b4: 24425624 addiu v0,v0,22052
55b8: 0040f809 jalr v0
55bc: 02002021 move a0,s0
}
55c0: 1620ffdd bnez s1,5538 <e1000_intr+0x60>
55c4: 8e07000c lw a3,12(s0)
55c8: 8e060008 lw a2,8(s0)
55cc: 2ce20002 sltiu v0,a3,2
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
55d0: 8e0500cc lw a1,204(s0)
return __arch__swab32(x);
55d4: 30a4ff00 andi a0,a1,0xff00
55d8: 00051600 sll v0,a1,0x18
55dc: 00051a02 srl v1,a1,0x8
55e0: 00042200 sll a0,a0,0x8
55e4: 00441025 or v0,v0,a0
55e8: 3063ff00 andi v1,v1,0xff00
55ec: 00431025 or v0,v0,v1
55f0: 00052e02 srl a1,a1,0x18
55f4: 00451025 or v0,v0,a1
55f8: acc200d0 sw v0,208(a2)
e1000_irq_enable(adapter);
return;
}
55fc: 8fbf002c lw ra,44(sp)
5600: 8fb60028 lw s6,40(sp)
5604: 8fb50024 lw s5,36(sp)
5608: 8fb40020 lw s4,32(sp)
560c: 8fb3001c lw s3,28(sp)
5610: 8fb20018 lw s2,24(sp)
5614: 8fb10014 lw s1,20(sp)
5618: 8fb00010 lw s0,16(sp)
561c: 03e00008 jr ra
5620: 27bd0030 addiu sp,sp,48
00005624 <e1000_clean_tx_irq>:
5624: 27bdffd0 addiu sp,sp,-48
5628: afb50024 sw s5,36(sp)
562c: afb40020 sw s4,32(sp)
5630: afbf002c sw ra,44(sp)
5634: afb60028 sw s6,40(sp)
5638: afb3001c sw s3,28(sp)
563c: afb20018 sw s2,24(sp)
5640: afb10014 sw s1,20(sp)
5644: afb00010 sw s0,16(sp)
5648: 0080a021 move s4,a0
/**
* e1000_clean_tx_irq - Reclaim resources after transmit completes
* @adapter: board private structure
**/
static void
e1000_clean_tx_irq(struct e1000_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
int i;
struct e1000_tx_desc *tx_desc;
struct net_device *netdev = adapter->netdev;
E1000_DBG("e1000_clean_tx_irq\n");
i = adapter->tx_ring.next_to_clean;
564c: 8e9200fc lw s2,252(s4)
tx_desc = E1000_TX_DESC(adapter->tx_ring, i);
5650: 8e8400e4 lw a0,228(s4)
while(tx_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
5654: 3c050100 lui a1,0x100
5658: 00121900 sll v1,s2,0x4
565c: 0083a821 addu s5,a0,v1
5660: 8ea2000c lw v0,12(s5)
5664: 00451024 and v0,v0,a1
5668: 10400051 beqz v0,57b0 <e1000_clean_tx_irq+0x18c>
566c: 8e960148 lw s6,328(s4)
5670: 269300f4 addiu s3,s4,244
if(adapter->tx_ring.buffer_info[i].dma != 0) {
5674: 8e860100 lw a2,256(s4)
5678: 00121040 sll v0,s2,0x1
567c: 00521021 addu v0,v0,s2
5680: 000288c0 sll s1,v0,0x3
5684: 02262021 addu a0,s1,a2
5688: 8c820008 lw v0,8(a0)
568c: 8c83000c lw v1,12(a0)
5690: 00431025 or v0,v0,v1
5694: 10400006 beqz v0,56b0 <e1000_clean_tx_irq+0x8c>
5698: 24050001 li a1,1
pci_unmap_page(pdev, adapter->tx_ring.buffer_info[i].dma,
adapter->tx_ring.buffer_info[i].length,
PCI_DMA_TODEVICE);
adapter->tx_ring.buffer_info[i].dma = 0;
569c: 00001021 move v0,zero
56a0: 00001821 move v1,zero
56a4: ac820008 sw v0,8(a0)
56a8: ac83000c sw v1,12(a0)
56ac: 8e860100 lw a2,256(s4)
}
if(adapter->tx_ring.buffer_info[i].skb != NULL) {
56b0: 02261021 addu v0,s1,a2
56b4: 8c460000 lw a2,0(v0)
56b8: 10c00026 beqz a2,5754 <e1000_clean_tx_irq+0x130>
56bc: 24c40070 addiu a0,a2,112
extern __inline__ int atomic_sub_return(int i, atomic_t * v)
{
unsigned long temp, result;
__asm__ __volatile__(
56c0: c0830000 ll v1,0(a0)
56c4: 00651023 subu v0,v1,a1
56c8: e0820000 sc v0,0(a0)
56cc: 1040fffc beqz v0,56c0 <e1000_clean_tx_irq+0x9c>
56d0: 00651023 subu v0,v1,a1
* is executing from interrupt context.
*/
static inline void dev_kfree_skb_irq(struct sk_buff *skb)
{
if (atomic_dec_and_test(&skb->users)) {
56d4: 5440001d bnezl v0,574c <e1000_clean_tx_irq+0x128>
56d8: 8e820100 lw v0,256(s4)
int cpu =smp_processor_id();
unsigned long flags;
local_irq_save(flags);
56dc: 40106000 mfc0 s0,$12
56e0: 00000000 nop
56e4: 36010001 ori at,s0,0x1
56e8: 38210001 xori at,at,0x1
56ec: 40816000 mtc0 at,$12
56f0: 00000040 sll zero,zero,0x1
56f4: 00000040 sll zero,zero,0x1
56f8: 00000040 sll zero,zero,0x1
skb->next = softnet_data[cpu].completion_queue;
56fc: 3c030000 lui v1,0x0
5700: 8c630020 lw v1,32(v1)
softnet_data[cpu].completion_queue = skb;
cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
5704: 00002021 move a0,zero
5708: acc30000 sw v1,0(a2)
570c: 3c020000 lui v0,0x0
5710: 24420000 addiu v0,v0,0
5714: 3c010000 lui at,0x0
5718: ac260020 sw a2,32(at)
571c: 0040f809 jalr v0
5720: 24050001 li a1,1
local_irq_restore(flags);
5724: 40016000 mfc0 at,$12
5728: 32100001 andi s0,s0,0x1
572c: 34210001 ori at,at,0x1
5730: 38210001 xori at,at,0x1
5734: 02018025 or s0,s0,at
5738: 40906000 mtc0 s0,$12
...
dev_kfree_skb_irq(adapter->tx_ring.buffer_info[i].skb);
adapter->tx_ring.buffer_info[i].skb = NULL;
5748: 8e820100 lw v0,256(s4)
574c: 02221021 addu v0,s1,v0
5750: ac400000 sw zero,0(v0)
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
5754: 24020001 li v0,1
unsigned long temp;
__asm__ __volatile__(
5758: c2640000 ll a0,0(s3)
575c: 00822021 addu a0,a0,v0
5760: e2640000 sc a0,0(s3)
5764: 1080fffc beqz a0,5758 <e1000_clean_tx_irq+0x134>
5768: 00000000 nop
}
atomic_inc(&adapter->tx_ring.unused);
i = (i + 1) % adapter->tx_ring.count;
576c: 8e8300f0 lw v1,240(s4)
5770: 26420001 addiu v0,s2,1
tx_desc->upper.data = 0;
tx_desc = E1000_TX_DESC(adapter->tx_ring, i);
}
5774: 3c060100 lui a2,0x100
5778: 0043001b divu zero,v0,v1
577c: 50600001 beqzl v1,5784 <e1000_clean_tx_irq+0x160>
5780: 0007000d break 0x7
5784: aea0000c sw zero,12(s5)
5788: 8e8400e4 lw a0,228(s4)
578c: 00002810 mfhi a1
5790: 00a09021 move s2,a1
5794: 00000000 nop
5798: 00121900 sll v1,s2,0x4
579c: 0083a821 addu s5,a0,v1
57a0: 8ea2000c lw v0,12(s5)
57a4: 00461024 and v0,v0,a2
57a8: 5440ffb3 bnezl v0,5678 <e1000_clean_tx_irq+0x54>
57ac: 8e860100 lw a2,256(s4)
adapter->tx_ring.next_to_clean = i;
if(adapter->tx_ring.next_to_clean == adapter->tx_ring.next_to_use)
57b0: 8e8200f8 lw v0,248(s4)
57b4: 16420004 bne s2,v0,57c8 <e1000_clean_tx_irq+0x1a4>
57b8: ae9200fc sw s2,252(s4)
atomic_set(&adapter->tx_timeout, 0);
57bc: ae80010c sw zero,268(s4)
57c0: 080015f5 j 57d4 <e1000_clean_tx_irq+0x1b0>
57c4: 26c5002c addiu a1,s6,44
else
atomic_set(&adapter->tx_timeout, 3);
57c8: 24020003 li v0,3
57cc: ae82010c sw v0,268(s4)
* @nr: bit number to test
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
57d0: 26c5002c addiu a1,s6,44
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
57d4: 8ca20000 lw v0,0(a1)
57d8: 30420001 andi v0,v0,0x1
if(netif_queue_stopped(netdev) &&
(atomic_read(&adapter->tx_ring.unused) >
(adapter->tx_ring.count * 3 / 4))) {
57dc: 10400036 beqz v0,58b8 <e1000_clean_tx_irq+0x294>
57e0: 8fbf002c lw ra,44(sp)
57e4: 8e8200f0 lw v0,240(s4)
57e8: 8e8400f4 lw a0,244(s4)
57ec: 00021840 sll v1,v0,0x1
57f0: 00621821 addu v1,v1,v0
57f4: 00031882 srl v1,v1,0x2
57f8: 0064182b sltu v1,v1,a0
57fc: 5060002f beqzl v1,58bc <e1000_clean_tx_irq+0x298>
5800: 8fb60028 lw s6,40(sp)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
5804: 24020001 li v0,1
5808: c0a40000 ll a0,0(a1)
580c: 00821825 or v1,a0,v0
5810: 00621826 xor v1,v1,v0
5814: e0a30000 sc v1,0(a1)
5818: 1060fffb beqz v1,5808 <e1000_clean_tx_irq+0x1e4>
581c: 00821824 and v1,a0,v0
}
static inline void netif_wake_queue(struct net_device *dev)
{
if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
5820: 50600025 beqzl v1,58b8 <e1000_clean_tx_irq+0x294>
5824: 8fbf002c lw ra,44(sp)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
5828: 24020008 li v0,8
582c: c0a40000 ll a0,0(a1)
5830: 00821825 or v1,a0,v0
5834: e0a30000 sc v1,0(a1)
5838: 1060fffc beqz v1,582c <e1000_clean_tx_irq+0x208>
583c: 00821824 and v1,a0,v0
#define HAVE_NETIF_QUEUE
static inline void __netif_schedule(struct net_device *dev)
{
if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
5840: 5460001d bnezl v1,58b8 <e1000_clean_tx_irq+0x294>
5844: 8fbf002c lw ra,44(sp)
unsigned long flags;
int cpu = smp_processor_id();
local_irq_save(flags);
5848: 40106000 mfc0 s0,$12
584c: 00000000 nop
5850: 36010001 ori at,s0,0x1
5854: 38210001 xori at,at,0x1
5858: 40816000 mtc0 at,$12
585c: 00000040 sll zero,zero,0x1
5860: 00000040 sll zero,zero,0x1
5864: 00000040 sll zero,zero,0x1
dev->next_sched = softnet_data[cpu].output_queue;
5868: 3c030000 lui v1,0x0
586c: 8c63001c lw v1,28(v1)
softnet_data[cpu].output_queue = dev;
cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
5870: 00002021 move a0,zero
5874: aec30038 sw v1,56(s6)
5878: 3c020000 lui v0,0x0
587c: 24420000 addiu v0,v0,0
5880: 3c010000 lui at,0x0
5884: ac36001c sw s6,28(at)
5888: 0040f809 jalr v0
588c: 24050001 li a1,1
local_irq_restore(flags);
5890: 40016000 mfc0 at,$12
5894: 32100001 andi s0,s0,0x1
5898: 34210001 ori at,at,0x1
589c: 38210001 xori at,at,0x1
58a0: 02018025 or s0,s0,at
58a4: 40906000 mtc0 s0,$12
...
#ifdef IANS
if((adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) &&
(adapter->iANSdata->reporting_mode == IANS_STATUS_REPORTING_ON))
if(ans_notify)
ans_notify(netdev, IANS_IND_XMIT_QUEUE_READY);
#endif
netif_wake_queue(netdev);
}
return;
}
58b4: 8fbf002c lw ra,44(sp)
58b8: 8fb60028 lw s6,40(sp)
58bc: 8fb50024 lw s5,36(sp)
58c0: 8fb40020 lw s4,32(sp)
58c4: 8fb3001c lw s3,28(sp)
58c8: 8fb20018 lw s2,24(sp)
58cc: 8fb10014 lw s1,20(sp)
58d0: 8fb00010 lw s0,16(sp)
58d4: 03e00008 jr ra
58d8: 27bd0030 addiu sp,sp,48
000058dc <e1000_clean_rx_irq>:
58dc: 27bdffc0 addiu sp,sp,-64
58e0: afb60030 sw s6,48(sp)
58e4: afb30024 sw s3,36(sp)
58e8: afbf003c sw ra,60(sp)
58ec: afbe0038 sw s8,56(sp)
58f0: afb70034 sw s7,52(sp)
58f4: afb5002c sw s5,44(sp)
58f8: afb40028 sw s4,40(sp)
58fc: afb20020 sw s2,32(sp)
5900: afb1001c sw s1,28(sp)
5904: afb00018 sw s0,24(sp)
5908: 0080b021 move s6,a0
/**
* e1000_clean_rx_irq - Send received data up the network stack,
* @adapter: board private structure
**/
static void
e1000_clean_rx_irq(struct e1000_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev;
struct e1000_rx_desc *rx_desc;
int i;
uint32_t length;
struct sk_buff *skb;
uint8_t last_byte;
unsigned long flags;
E1000_DBG("e1000_clean_rx_irq\n");
i = adapter->rx_ring.next_to_clean;
590c: 8ed50128 lw s5,296(s6)
5910: 8ec30148 lw v1,328(s6)
rx_desc = E1000_RX_DESC(adapter->rx_ring, i);
5914: 8ec20110 lw v0,272(s6)
5918: afa30010 sw v1,16(sp)
591c: 00151900 sll v1,s5,0x4
5920: 00439821 addu s3,v0,v1
while(rx_desc->status & E1000_RXD_STAT_DD) {
5924: 9267000c lbu a3,12(s3)
5928: 30e20001 andi v0,a3,0x1
592c: 10400120 beqz v0,5db0 <e1000_clean_rx_irq+0x4d4>
5930: 26d40120 addiu s4,s6,288
pci_unmap_single(pdev, adapter->rx_ring.buffer_info[i].dma,
adapter->rx_ring.buffer_info[i].length,
PCI_DMA_FROMDEVICE);
skb = adapter->rx_ring.buffer_info[i].skb;
5934: 96640008 lhu a0,8(s3)
5938: 8ec5012c lw a1,300(s6)
593c: 0015f040 sll s8,s5,0x1
5940: 03d51021 addu v0,s8,s5
5944: 0002b8c0 sll s7,v0,0x3
static __inline__ __const__ __u16 __fswab16(__u16 x)
{
return __arch__swab16(x);
5948: 00041a02 srl v1,a0,0x8
594c: 00042200 sll a0,a0,0x8
5950: 00832025 or a0,a0,v1
5954: 02e52821 addu a1,s7,a1
length = le16_to_cpu(rx_desc->length);
if(!(rx_desc->status & E1000_RXD_STAT_EOP)) {
5958: 30e20002 andi v0,a3,0x2
595c: 8cb10000 lw s1,0(a1)
5960: 1440003d bnez v0,5a58 <e1000_clean_rx_irq+0x17c>
5964: 3092ffff andi s2,a0,0xffff
return result;
}
extern __inline__ int atomic_sub_return(int i, atomic_t * v)
{
5968: 24120001 li s2,1
596c: 26220070 addiu v0,s1,112
unsigned long temp, result;
__asm__ __volatile__(
5970: c0440000 ll a0,0(v0)
5974: 00921823 subu v1,a0,s2
5978: e0430000 sc v1,0(v0)
597c: 1060fffc beqz v1,5970 <e1000_clean_rx_irq+0x94>
5980: 00921823 subu v1,a0,s2
* is executing from interrupt context.
*/
static inline void dev_kfree_skb_irq(struct sk_buff *skb)
{
if (atomic_dec_and_test(&skb->users)) {
5984: 1460001d bnez v1,59fc <e1000_clean_rx_irq+0x120>
5988: 02602021 move a0,s3
int cpu =smp_processor_id();
unsigned long flags;
local_irq_save(flags);
598c: 40106000 mfc0 s0,$12
5990: 00000000 nop
5994: 36010001 ori at,s0,0x1
5998: 38210001 xori at,at,0x1
599c: 40816000 mtc0 at,$12
59a0: 00000040 sll zero,zero,0x1
59a4: 00000040 sll zero,zero,0x1
59a8: 00000040 sll zero,zero,0x1
skb->next = softnet_data[cpu].completion_queue;
59ac: 3c030000 lui v1,0x0
59b0: 8c630020 lw v1,32(v1)
softnet_data[cpu].completion_queue = skb;
cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
59b4: 00002021 move a0,zero
59b8: ae230000 sw v1,0(s1)
59bc: 3c020000 lui v0,0x0
59c0: 24420000 addiu v0,v0,0
59c4: 3c010000 lui at,0x0
59c8: ac310020 sw s1,32(at)
59cc: 0040f809 jalr v0
59d0: 24050001 li a1,1
local_irq_restore(flags);
59d4: 40016000 mfc0 at,$12
59d8: 32100001 andi s0,s0,0x1
59dc: 34210001 ori at,at,0x1
59e0: 38210001 xori at,at,0x1
59e4: 02018025 or s0,s0,at
59e8: 40906000 mtc0 s0,$12
...
/* All receives must fit into a single buffer */
E1000_DBG("Receive packet consumed multiple buffers\n");
dev_kfree_skb_irq(skb);
memset(rx_desc, 0, 16);
59f8: 02602021 move a0,s3
59fc: 00002821 move a1,zero
5a00: 3c020000 lui v0,0x0
5a04: 24420000 addiu v0,v0,0
5a08: 0040f809 jalr v0
5a0c: 24060010 li a2,16
...
mb();
adapter->rx_ring.buffer_info[i].skb = NULL;
5a30: 8ec2012c lw v0,300(s6)
5a34: 02e21021 addu v0,s7,v0
5a38: ac400000 sw zero,0(v0)
extern __inline__ void atomic_add(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
5a3c: c2830000 ll v1,0(s4)
5a40: 00721821 addu v1,v1,s2
5a44: e2830000 sc v1,0(s4)
5a48: 1060fffc beqz v1,5a3c <e1000_clean_rx_irq+0x160>
5a4c: 00000000 nop
atomic_inc(&adapter->rx_ring.unused);
i = (i + 1) % adapter->rx_ring.count;
rx_desc = E1000_RX_DESC(adapter->rx_ring, i);
continue;
5a50: 0800175b j 5d6c <e1000_clean_rx_irq+0x490>
5a54: 8ec6011c lw a2,284(s6)
}
if(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
5a58: 9262000d lbu v0,13(s3)
5a5c: 30440097 andi a0,v0,0x97
5a60: 5080007b beqzl a0,5c50 <e1000_clean_rx_irq+0x374>
5a64: 8e220060 lw v0,96(s1)
last_byte = *(skb->data + length - 1);
5a68: 8e220080 lw v0,128(s1)
if(TBI_ACCEPT
5a6c: 8ec30060 lw v1,96(s6)
5a70: 00521021 addu v0,v0,s2
5a74: 10600037 beqz v1,5b54 <e1000_clean_rx_irq+0x278>
5a78: 9042ffff lbu v0,-1(v0)
5a7c: 38830001 xori v1,a0,0x1
5a80: 3842000f xori v0,v0,0xf
5a84: 2c630001 sltiu v1,v1,1
5a88: 2c420001 sltiu v0,v0,1
5a8c: 00621824 and v1,v1,v0
5a90: 50600031 beqzl v1,5b58 <e1000_clean_rx_irq+0x27c>
5a94: 24120001 li s2,1
5a98: 9662000e lhu v0,14(s3)
5a9c: 1440000b bnez v0,5acc <e1000_clean_rx_irq+0x1f0>
5aa0: 8ec2003c lw v0,60(s6)
5aa4: 2e430041 sltiu v1,s2,65
5aa8: 38630001 xori v1,v1,0x1
5aac: 24420001 addiu v0,v0,1
5ab0: 0052102b sltu v0,v0,s2
5ab4: 38420001 xori v0,v0,0x1
5ab8: 00431024 and v0,v0,v1
5abc: 1440000b bnez v0,5aec <e1000_clean_rx_irq+0x210>
5ac0: 00000000 nop
5ac4: 080016d6 j 5b58 <e1000_clean_rx_irq+0x27c>
5ac8: 24120001 li s2,1
5acc: 2e43003d sltiu v1,s2,61
5ad0: 38630001 xori v1,v1,0x1
5ad4: 2442fffd addiu v0,v0,-3
5ad8: 0052102b sltu v0,v0,s2
5adc: 38420001 xori v0,v0,0x1
5ae0: 00431024 and v0,v0,v1
5ae4: 5040001c beqzl v0,5b58 <e1000_clean_rx_irq+0x27c>
5ae8: 24120001 li s2,1
(&adapter->shared, rx_desc->special, rx_desc->errors, length,
last_byte)) {
spin_lock_irqsave(&adapter->stats_lock, flags);
5aec: 40106000 mfc0 s0,$12
5af0: 00000000 nop
5af4: 36010001 ori at,s0,0x1
5af8: 38210001 xori at,at,0x1
5afc: 40816000 mtc0 at,$12
5b00: 00000040 sll zero,zero,0x1
5b04: 00000040 sll zero,zero,0x1
5b08: 00000040 sll zero,zero,0x1
e1000_tbi_adjust_stats(&adapter->shared, &adapter->stats,
5b0c: 26c40008 addiu a0,s6,8
5b10: 8e270080 lw a3,128(s1)
5b14: 26c501d8 addiu a1,s6,472
5b18: 3c020000 lui v0,0x0
5b1c: 24420000 addiu v0,v0,0
5b20: 0040f809 jalr v0
5b24: 02403021 move a2,s2
length, skb->data);
spin_unlock_irqrestore(&adapter->stats_lock, flags);
5b28: 40016000 mfc0 at,$12
5b2c: 32100001 andi s0,s0,0x1
5b30: 34210001 ori at,at,0x1
5b34: 38210001 xori at,at,0x1
5b38: 02018025 or s0,s0,at
5b3c: 40906000 mtc0 s0,$12
...
length--;
} else {
5b4c: 08001713 j 5c4c <e1000_clean_rx_irq+0x370>
5b50: 2652ffff addiu s2,s2,-1
return result;
}
extern __inline__ int atomic_sub_return(int i, atomic_t * v)
{
5b54: 24120001 li s2,1
5b58: 26220070 addiu v0,s1,112
unsigned long temp, result;
__asm__ __volatile__(
5b5c: c0440000 ll a0,0(v0)
5b60: 00921823 subu v1,a0,s2
5b64: e0430000 sc v1,0(v0)
5b68: 1060fffc beqz v1,5b5c <e1000_clean_rx_irq+0x280>
5b6c: 00921823 subu v1,a0,s2
* is executing from interrupt context.
*/
static inline void dev_kfree_skb_irq(struct sk_buff *skb)
{
if (atomic_dec_and_test(&skb->users)) {
5b70: 1460001d bnez v1,5be8 <e1000_clean_rx_irq+0x30c>
5b74: 02602021 move a0,s3
int cpu =smp_processor_id();
unsigned long flags;
local_irq_save(flags);
5b78: 40106000 mfc0 s0,$12
5b7c: 00000000 nop
5b80: 36010001 ori at,s0,0x1
5b84: 38210001 xori at,at,0x1
5b88: 40816000 mtc0 at,$12
5b8c: 00000040 sll zero,zero,0x1
5b90: 00000040 sll zero,zero,0x1
5b94: 00000040 sll zero,zero,0x1
skb->next = softnet_data[cpu].completion_queue;
5b98: 3c030000 lui v1,0x0
5b9c: 8c630020 lw v1,32(v1)
softnet_data[cpu].completion_queue = skb;
cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
5ba0: 00002021 move a0,zero
5ba4: ae230000 sw v1,0(s1)
5ba8: 3c020000 lui v0,0x0
5bac: 24420000 addiu v0,v0,0
5bb0: 3c010000 lui at,0x0
5bb4: ac310020 sw s1,32(at)
5bb8: 0040f809 jalr v0
5bbc: 24050001 li a1,1
local_irq_restore(flags);
5bc0: 40016000 mfc0 at,$12
5bc4: 32100001 andi s0,s0,0x1
5bc8: 34210001 ori at,at,0x1
5bcc: 38210001 xori at,at,0x1
5bd0: 02018025 or s0,s0,at
5bd4: 40906000 mtc0 s0,$12
...
E1000_DBG("Receive Errors Reported by Hardware\n");
dev_kfree_skb_irq(skb);
memset(rx_desc, 0, 16);
5be4: 02602021 move a0,s3
5be8: 00002821 move a1,zero
5bec: 3c020000 lui v0,0x0
5bf0: 24420000 addiu v0,v0,0
5bf4: 0040f809 jalr v0
5bf8: 24060010 li a2,16
...
mb();
adapter->rx_ring.buffer_info[i].skb = NULL;
5c1c: 8ec3012c lw v1,300(s6)
5c20: 03d51021 addu v0,s8,s5
5c24: 000210c0 sll v0,v0,0x3
5c28: 00431021 addu v0,v0,v1
5c2c: ac400000 sw zero,0(v0)
extern __inline__ void atomic_add(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
5c30: c2830000 ll v1,0(s4)
5c34: 00721821 addu v1,v1,s2
5c38: e2830000 sc v1,0(s4)
5c3c: 1060fffc beqz v1,5c30 <e1000_clean_rx_irq+0x354>
5c40: 00000000 nop
atomic_inc(&adapter->rx_ring.unused);
i = (i + 1) % adapter->rx_ring.count;
rx_desc = E1000_RX_DESC(adapter->rx_ring, i);
continue;
5c44: 0800175b j 5d6c <e1000_clean_rx_irq+0x490>
5c48: 8ec6011c lw a2,284(s6)
}
static inline int skb_is_nonlinear(const struct sk_buff *skb)
{
return skb->data_len;
5c4c: 8e220060 lw v0,96(s1)
}
static inline int skb_headlen(const struct sk_buff *skb)
{
return skb->len - skb->data_len;
}
#define SKB_PAGE_ASSERT(skb) do { if (skb_shinfo(skb)->nr_frags) BUG(); } while (0)
#define SKB_FRAG_ASSERT(skb) do { if (skb_shinfo(skb)->frag_list) BUG(); } while (0)
#define SKB_LINEAR_ASSERT(skb) do { if (skb_is_nonlinear(skb)) BUG(); } while (0)
/*
* Add data to an sk_buff
*/
static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
{
unsigned char *tmp=skb->tail;
SKB_LINEAR_ASSERT(skb);
skb->tail+=len;
skb->len+=len;
return tmp;
}
/**
* skb_put - add data to a buffer
* @skb: buffer to use
* @len: amount of data to add
*
* This function extends the used data area of the buffer. If this would
* exceed the total buffer size the kernel will panic. A pointer to the
* first byte of the extra data is returned.
*/
static inline unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
{
unsigned char *tmp=skb->tail;
SKB_LINEAR_ASSERT(skb);
5c50: 1040000a beqz v0,5c7c <e1000_clean_rx_irq+0x3a0>
5c54: 2650fffc addiu s0,s2,-4
5c58: 3c040000 lui a0,0x0
5c5c: 24840000 addiu a0,a0,0
5c60: 3c050000 lui a1,0x0
5c64: 24a500b4 addiu a1,a1,180
5c68: 3c020000 lui v0,0x0
5c6c: 24420000 addiu v0,v0,0
5c70: 0040f809 jalr v0
5c74: 24060315 li a2,789
5c78: ac000000 sw zero,0(zero)
skb->tail+=len;
5c7c: 8e220084 lw v0,132(s1)
skb->len+=len;
5c80: 8e23005c lw v1,92(s1)
if(skb->tail>skb->end) {
5c84: 8e240088 lw a0,136(s1)
5c88: 00501021 addu v0,v0,s0
5c8c: 00701821 addu v1,v1,s0
5c90: 0082202b sltu a0,a0,v0
5c94: ae23005c sw v1,92(s1)
5c98: 10800008 beqz a0,5cbc <e1000_clean_rx_irq+0x3e0>
5c9c: ae220084 sw v0,132(s1)
skb_over_panic(skb, len, current_text_addr());
5ca0: 02002821 move a1,s0
5ca4: 3c060000 lui a2,0x0
5ca8: 24c65ca0 addiu a2,a2,23712
5cac: 3c020000 lui v0,0x0
5cb0: 24420000 addiu v0,v0,0
5cb4: 0040f809 jalr v0
5cb8: 02202021 move a0,s1
}
}
/* Good Receive */
skb_put(skb, length - CRC_LENGTH);
/* Adjust socket buffer accounting to only cover the ethernet frame
* Not what the stack intends, but there exist TCP problems that
* break NFS for network interfaces that need 2k receive buffers
*/
skb->truesize = skb->len;
5cbc: 8e22005c lw v0,92(s1)
/* Receive Checksum Offload */
e1000_rx_checksum(adapter, rx_desc, skb);
5cc0: 02203021 move a2,s1
5cc4: 02c02021 move a0,s6
5cc8: ae220078 sw v0,120(s1)
5ccc: 3c020000 lui v0,0x0
5cd0: 244274ec addiu v0,v0,29932
5cd4: 0040f809 jalr v0
5cd8: 02602821 move a1,s3
#ifdef IANS
if(adapter->iANSdata->iANS_status == IANS_COMMUNICATION_UP) {
if(bd_ans_os_Receive(adapter, rx_desc, skb) == BD_ANS_FAILURE)
dev_kfree_skb_irq(skb);
else
netif_rx(skb);
} else {
skb->protocol = eth_type_trans(skb, netdev);
netif_rx(skb);
}
#else
skb->protocol = eth_type_trans(skb, netdev);
5cdc: 8fa50010 lw a1,16(sp)
5ce0: 3c020000 lui v0,0x0
5ce4: 24420000 addiu v0,v0,0
5ce8: 0040f809 jalr v0
5cec: 02202021 move a0,s1
5cf0: a6220074 sh v0,116(s1)
netif_rx(skb);
5cf4: 3c020000 lui v0,0x0
5cf8: 24420000 addiu v0,v0,0
5cfc: 0040f809 jalr v0
5d00: 02202021 move a0,s1
#endif
memset(rx_desc, 0, 16);
5d04: 02602021 move a0,s3
5d08: 00002821 move a1,zero
5d0c: 3c020000 lui v0,0x0
5d10: 24420000 addiu v0,v0,0
5d14: 0040f809 jalr v0
5d18: 24060010 li a2,16
...
mb();
adapter->rx_ring.buffer_info[i].skb = NULL;
5d3c: 8ec2012c lw v0,300(s6)
5d40: 03d51821 addu v1,s8,s5
5d44: 000318c0 sll v1,v1,0x3
5d48: 00621821 addu v1,v1,v0
5d4c: ac600000 sw zero,0(v1)
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
5d50: 24020001 li v0,1
unsigned long temp;
__asm__ __volatile__(
5d54: c2830000 ll v1,0(s4)
5d58: 00621821 addu v1,v1,v0
5d5c: e2830000 sc v1,0(s4)
5d60: 1060fffc beqz v1,5d54 <e1000_clean_rx_irq+0x478>
5d64: 00000000 nop
atomic_inc(&adapter->rx_ring.unused);
i = (i + 1) % adapter->rx_ring.count;
5d68: 8ec6011c lw a2,284(s6)
5d6c: 26a20001 addiu v0,s5,1
5d70: 0046001b divu zero,v0,a2
5d74: 50c00001 beqzl a2,5d7c <e1000_clean_rx_irq+0x4a0>
5d78: 0007000d break 0x7
rx_desc = E1000_RX_DESC(adapter->rx_ring, i);
5d7c: 8ec40110 lw a0,272(s6)
5d80: 00001810 mfhi v1
5d84: 0060a821 move s5,v1
5d88: 00000000 nop
5d8c: 00151100 sll v0,s5,0x4
5d90: 00829821 addu s3,a0,v0
}
5d94: 9262000c lbu v0,12(s3)
5d98: 00403821 move a3,v0
5d9c: 30e30001 andi v1,a3,0x1
5da0: 5460fee5 bnezl v1,5938 <e1000_clean_rx_irq+0x5c>
5da4: 96640008 lhu a0,8(s3)
5da8: 0800176d j 5db4 <e1000_clean_rx_irq+0x4d8>
5dac: 00000000 nop
5db0: 8ec6011c lw a2,284(s6)
/* if the Rx ring is less than 3/4 full, allocate more sk_buffs */
if(atomic_read(&adapter->rx_ring.unused) > (adapter->rx_ring.count / 4)) {
5db4: 8ec30120 lw v1,288(s6)
5db8: 00061082 srl v0,a2,0x2
5dbc: 0043102b sltu v0,v0,v1
5dc0: 5040000f beqzl v0,5e00 <e1000_clean_rx_irq+0x524>
5dc4: aed50128 sw s5,296(s6)
extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t));
static inline void tasklet_schedule(struct tasklet_struct *t)
{
5dc8: 26c500d0 addiu a1,s6,208
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
5dcc: 24020001 li v0,1
5dd0: c2c400d4 ll a0,212(s6)
5dd4: 00821825 or v1,a0,v0
5dd8: e2c300d4 sc v1,212(s6)
5ddc: 1060fffc beqz v1,5dd0 <e1000_clean_rx_irq+0x4f4>
5de0: 00821824 and v1,a0,v0
extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t));
static inline void tasklet_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
5de4: 54600006 bnezl v1,5e00 <e1000_clean_rx_irq+0x524>
5de8: aed50128 sw s5,296(s6)
__tasklet_schedule(t);
5dec: 3c020000 lui v0,0x0
5df0: 24420000 addiu v0,v0,0
5df4: 0040f809 jalr v0
5df8: 00a02021 move a0,a1
tasklet_schedule(&adapter->rx_fill_tasklet);
}
adapter->rx_ring.next_to_clean = i;
5dfc: aed50128 sw s5,296(s6)
return;
}
5e00: 8fbf003c lw ra,60(sp)
5e04: 8fbe0038 lw s8,56(sp)
5e08: 8fb70034 lw s7,52(sp)
5e0c: 8fb60030 lw s6,48(sp)
5e10: 8fb5002c lw s5,44(sp)
5e14: 8fb40028 lw s4,40(sp)
5e18: 8fb30024 lw s3,36(sp)
5e1c: 8fb20020 lw s2,32(sp)
5e20: 8fb1001c lw s1,28(sp)
5e24: 8fb00018 lw s0,24(sp)
5e28: 03e00008 jr ra
5e2c: 27bd0040 addiu sp,sp,64
00005e30 <e1000_alloc_rx_buffers>:
5e30: 27bdffb8 addiu sp,sp,-72
5e34: afb20028 sw s2,40(sp)
5e38: 00809021 move s2,a0
5e3c: afb40030 sw s4,48(sp)
5e40: afbf0044 sw ra,68(sp)
5e44: afbe0040 sw s8,64(sp)
5e48: afb7003c sw s7,60(sp)
5e4c: afb60038 sw s6,56(sp)
5e50: afb50034 sw s5,52(sp)
5e54: afb3002c sw s3,44(sp)
5e58: afb10024 sw s1,36(sp)
5e5c: afb00020 sw s0,32(sp)
* @nr: bit number to test
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
5e60: 2654008c addiu s4,s2,140
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
5e64: 8e820000 lw v0,0(s4)
/**
* e1000_alloc_rx_buffers - Replace used receive buffers
* @data: address of board private structure
**/
static void
e1000_alloc_rx_buffers(unsigned long data)
{
struct e1000_adapter *adapter = (struct e1000_adapter *) data;
struct net_device *netdev = adapter->netdev;
5e68: 8e430148 lw v1,328(s2)
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
5e6c: 30420001 andi v0,v0,0x1
struct pci_dev *pdev = adapter->pdev;
struct e1000_rx_desc *rx_desc;
struct sk_buff *skb;
int i;
int reserve_len;
E1000_DBG("e1000_alloc_rx_buffers\n");
/* kernel 2.4.7 seems to be broken with respect to tasklet locking */
if(!spin_trylock(&adapter->rx_fill_lock))
return;
if(!test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
5e70: 104000a9 beqz v0,6118 <e1000_alloc_rx_buffers+0x2e8>
5e74: afa30010 sw v1,16(sp)
spin_unlock(&adapter->rx_fill_lock);
return;
}
#ifdef IANS
reserve_len = E1000_ROUNDUP2(BD_ANS_INFO_SIZE, 16) + 2;
#else
reserve_len = 2;
#endif
i = adapter->rx_ring.next_to_use;
5e78: 8e530124 lw s3,292(s2)
while(adapter->rx_ring.buffer_info[i].skb == NULL) {
5e7c: 8e42012c lw v0,300(s2)
5e80: 00131840 sll v1,s3,0x1
5e84: 00731821 addu v1,v1,s3
5e88: 000318c0 sll v1,v1,0x3
5e8c: 00621821 addu v1,v1,v0
5e90: 8c640000 lw a0,0(v1)
5e94: 548000a0 bnezl a0,6118 <e1000_alloc_rx_buffers+0x2e8>
5e98: ae530124 sw s3,292(s2)
5e9c: 3c0d00ff lui t5,0xff
5ea0: 3c1eff00 lui s8,0xff00
5ea4: 24170001 li s7,1
5ea8: 26550120 addiu s5,s2,288
rx_desc = E1000_RX_DESC(adapter->rx_ring, i);
skb = alloc_skb(adapter->rx_buffer_len + reserve_len, GFP_ATOMIC);
5eac: 8e4400b8 lw a0,184(s2)
5eb0: 8e460110 lw a2,272(s2)
5eb4: 00131900 sll v1,s3,0x4
5eb8: 24050020 li a1,32
5ebc: afad0018 sw t5,24(sp)
5ec0: 24840002 addiu a0,a0,2
5ec4: 3c020000 lui v0,0x0
5ec8: 24420000 addiu v0,v0,0
5ecc: 0040f809 jalr v0
5ed0: 00c3b021 addu s6,a2,v1
5ed4: 00402821 move a1,v0
if(skb == NULL) {
5ed8: 14a00008 bnez a1,5efc <e1000_alloc_rx_buffers+0xcc>
5edc: 8fad0018 lw t5,24(sp)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
5ee0: c2820000 ll v0,0(s4)
5ee4: 34420002 ori v0,v0,0x2
5ee8: e2820000 sc v0,0(s4)
5eec: 1040fffc beqz v0,5ee0 <e1000_alloc_rx_buffers+0xb0>
5ef0: 00000000 nop
/* Alloc Failed; If we could not allocate a
* skb during this schedule. Wait for a while before
* tasklet to allocate skb is called again.
*/
set_bit(E1000_RX_REFILL, &adapter->flags);
break;
5ef4: 08001846 j 6118 <e1000_alloc_rx_buffers+0x2e8>
5ef8: ae530124 sw s3,292(s2)
*/
static inline void skb_reserve(struct sk_buff *skb, unsigned int len)
{
skb->data+=len;
5efc: 8ca20080 lw v0,128(a1)
skb->tail+=len;
5f00: 8ca30084 lw v1,132(a1)
}
/* Make buffer alignment 2 beyond a 16 byte boundary
* this will result in a 16 byte aligned IP header after
* the 14 byte MAC header is removed
*/
skb_reserve(skb, reserve_len);
skb->dev = netdev;
5f04: 8fa40010 lw a0,16(sp)
*/
static inline void skb_reserve(struct sk_buff *skb, unsigned int len)
{
skb->data+=len;
5f08: 24420002 addiu v0,v0,2
skb->tail+=len;
5f0c: 24630002 addiu v1,v1,2
5f10: aca20080 sw v0,128(a1)
5f14: aca40018 sw a0,24(a1)
static inline void skb_reserve(struct sk_buff *skb, unsigned int len)
{
skb->data+=len;
skb->tail+=len;
5f18: aca30084 sw v1,132(a1)
adapter->rx_ring.buffer_info[i].skb = skb;
5f1c: 8e44012c lw a0,300(s2)
5f20: 00138040 sll s0,s3,0x1
5f24: 02138021 addu s0,s0,s3
5f28: 001080c0 sll s0,s0,0x3
5f2c: 02042021 addu a0,s0,a0
5f30: ac850000 sw a1,0(a0)
adapter->rx_ring.buffer_info[i].length = adapter->rx_buffer_len;
5f34: 8e42012c lw v0,300(s2)
5f38: 8e4300b8 lw v1,184(s2)
5f3c: 02021021 addu v0,s0,v0
5f40: ac430010 sw v1,16(v0)
* until either pci_unmap_single or pci_dma_sync_single is performed.
*/
static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr,
size_t size, int direction)
{
5f44: 8cb10080 lw s1,128(a1)
5f48: 8e4500b8 lw a1,184(s2)
if (direction == PCI_DMA_NONE)
BUG();
#ifdef CONFIG_NONCOHERENT_IO
dma_cache_wback_inv((unsigned long)ptr, size);
5f4c: 3c020000 lui v0,0x0
5f50: 8c420000 lw v0,0(v0)
5f54: 02202021 move a0,s1
5f58: 0040f809 jalr v0
5f5c: afad0018 sw t5,24(sp)
adapter->rx_ring.buffer_info[i].dma =
pci_map_single(pdev, skb->data, adapter->rx_buffer_len,
PCI_DMA_FROMDEVICE);
5f60: 8e45012c lw a1,300(s2)
* IO bus memory addresses are also 1:1 with the physical address
*/
static inline unsigned long virt_to_bus(volatile void * address)
{
return PHYSADDR(address);
5f64: 3c041fff lui a0,0x1fff
5f68: 3484ffff ori a0,a0,0xffff
5f6c: 02241824 and v1,s1,a0
5f70: 02052821 addu a1,s0,a1
5f74: 00001021 move v0,zero
5f78: aca20008 sw v0,8(a1)
5f7c: aca3000c sw v1,12(a1)
5f80: 8e48012c lw t0,300(s2)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
5f84: 8fad0018 lw t5,24(sp)
}
static __inline__ __u32 __swab32p(__u32 *x)
{
return __arch__swab32p(x);
}
static __inline__ void __swab32s(__u32 *addr)
{
__arch__swab32s(addr);
}
#ifdef __BYTEORDER_HAS_U64__
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
5f88: 00002021 move a0,zero
5f8c: 02088021 addu s0,s0,t0
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
5f90: 8e03000c lw v1,12(s0)
5f94: 8e080008 lw t0,8(s0)
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
5f98: 00003021 move a2,zero
5f9c: 3062ff00 andi v0,v1,0xff00
5fa0: 00021200 sll v0,v0,0x8
5fa4: 00036600 sll t4,v1,0x18
5fa8: 006d5024 and t2,v1,t5
5fac: 310bff00 andi t3,t0,0xff00
5fb0: 01826025 or t4,t4,v0
5fb4: 00084e00 sll t1,t0,0x18
5fb8: 010d1024 and v0,t0,t5
5fbc: 000a5202 srl t2,t2,0x8
5fc0: 007e1824 and v1,v1,s8
5fc4: 000b5a00 sll t3,t3,0x8
5fc8: 00021202 srl v0,v0,0x8
5fcc: 018a6025 or t4,t4,t2
5fd0: 012b4825 or t1,t1,t3
5fd4: 00031e02 srl v1,v1,0x18
5fd8: 011e4024 and t0,t0,s8
5fdc: 01224825 or t1,t1,v0
5fe0: 01832825 or a1,t4,v1
5fe4: 00084602 srl t0,t0,0x18
5fe8: 01283825 or a3,t1,t0
5fec: 00052000 sll a0,a1,0x0
5ff0: 00002821 move a1,zero
5ff4: 00862025 or a0,a0,a2
5ff8: 00a72825 or a1,a1,a3
rx_desc->buffer_addr = cpu_to_le64(adapter->rx_ring.buffer_info[i].dma);
5ffc: aec40000 sw a0,0(s6)
6000: aec50004 sw a1,4(s6)
6004: 8e42000c lw v0,12(s2)
6008: 2c420002 sltiu v0,v0,2
600c: 1440000e bnez v0,6048 <e1000_alloc_rx_buffers+0x218>
6010: 3262ff00 andi v0,s3,0xff00
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6014: 00021200 sll v0,v0,0x8
6018: 00131e00 sll v1,s3,0x18
601c: 026d2024 and a0,s3,t5
6020: 00621825 or v1,v1,v0
6024: 00042202 srl a0,a0,0x8
6028: 8e450008 lw a1,8(s2)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
602c: 027e1024 and v0,s3,s8
6030: 00641825 or v1,v1,a0
6034: 00021602 srl v0,v0,0x18
6038: 00621825 or v1,v1,v0
/* move tail */
E1000_WRITE_REG(&adapter->shared, RDT, i);
603c: aca32818 sw v1,10264(a1)
6040: 0800181d j 6074 <e1000_alloc_rx_buffers+0x244>
6044: 00000000 nop
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6048: 00021200 sll v0,v0,0x8
604c: 00131e00 sll v1,s3,0x18
6050: 026d2024 and a0,s3,t5
6054: 00621825 or v1,v1,v0
6058: 00042202 srl a0,a0,0x8
605c: 8e450008 lw a1,8(s2)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6060: 027e1024 and v0,s3,s8
6064: 00641825 or v1,v1,a0
6068: 00021602 srl v0,v0,0x18
606c: 00621825 or v1,v1,v0
6070: aca30128 sw v1,296(a1)
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
6074: c2a20000 ll v0,0(s5)
6078: 00571023 subu v0,v0,s7
607c: e2a20000 sc v0,0(s5)
6080: 1040fffc beqz v0,6074 <e1000_alloc_rx_buffers+0x244>
6084: 00000000 nop
atomic_dec(&adapter->rx_ring.unused);
i = (i + 1) % adapter->rx_ring.count;
6088: 8e43011c lw v1,284(s2)
608c: 26640001 addiu a0,s3,1
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
6090: 24020002 li v0,2
6094: 0083001b divu zero,a0,v1
6098: 50600001 beqzl v1,60a0 <e1000_alloc_rx_buffers+0x270>
609c: 0007000d break 0x7
60a0: 00008010 mfhi s0
60a4: 02009821 move s3,s0
60a8: 00000000 nop
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
60ac: c2840000 ll a0,0(s4)
60b0: 00821825 or v1,a0,v0
60b4: 00621826 xor v1,v1,v0
60b8: e2830000 sc v1,0(s4)
60bc: 1060fffb beqz v1,60ac <e1000_alloc_rx_buffers+0x27c>
60c0: 00821824 and v1,a0,v0
if(test_and_clear_bit(E1000_RX_REFILL, &adapter->flags)) {
60c4: 5060000c beqzl v1,60f8 <e1000_alloc_rx_buffers+0x2c8>
60c8: 8e42012c lw v0,300(s2)
/* Trigger Soft Interrupt */
E1000_WRITE_REG(&adapter->shared, ICS, E1000_ICS_RXT0);
60cc: 8e42000c lw v0,12(s2)
60d0: 2c420002 sltiu v0,v0,2
60d4: 14400005 bnez v0,60ec <e1000_alloc_rx_buffers+0x2bc>
60d8: 8e420008 lw v0,8(s2)
60dc: 3c038000 lui v1,0x8000
60e0: ac4300c8 sw v1,200(v0)
60e4: 0800183e j 60f8 <e1000_alloc_rx_buffers+0x2c8>
60e8: 8e42012c lw v0,300(s2)
60ec: 3c048000 lui a0,0x8000
60f0: ac4400c8 sw a0,200(v0)
}
}
60f4: 8e42012c lw v0,300(s2)
60f8: 00101840 sll v1,s0,0x1
60fc: 00701821 addu v1,v1,s0
6100: 000318c0 sll v1,v1,0x3
6104: 00621821 addu v1,v1,v0
6108: 8c640000 lw a0,0(v1)
610c: 5080ff68 beqzl a0,5eb0 <e1000_alloc_rx_buffers+0x80>
6110: 8e4400b8 lw a0,184(s2)
adapter->rx_ring.next_to_use = i;
6114: ae530124 sw s3,292(s2)
spin_unlock(&adapter->rx_fill_lock);
return;
}
6118: 8fbf0044 lw ra,68(sp)
611c: 8fbe0040 lw s8,64(sp)
6120: 8fb7003c lw s7,60(sp)
6124: 8fb60038 lw s6,56(sp)
6128: 8fb50034 lw s5,52(sp)
612c: 8fb40030 lw s4,48(sp)
6130: 8fb3002c lw s3,44(sp)
6134: 8fb20028 lw s2,40(sp)
6138: 8fb10024 lw s1,36(sp)
613c: 8fb00020 lw s0,32(sp)
6140: 03e00008 jr ra
6144: 27bd0048 addiu sp,sp,72
00006148 <e1000_ioctl>:
6148: 27bdffe8 addiu sp,sp,-24
/**
* e1000_ioctl -
* @netdev:
* @ifreq:
* @cmd:
**/
int
e1000_ioctl(struct net_device *netdev,
struct ifreq *ifr,
int cmd)
{
#ifdef IANS
IANS_BD_PARAM_HEADER *header;
#endif
E1000_DBG("e1000_do_ioctl\n");
switch (cmd) {
614c: 34028946 li v0,0x8946
6150: afbf0010 sw ra,16(sp)
#ifdef IANS
case IANS_BASE_SIOC:
header = (IANS_BD_PARAM_HEADER *) ifr->ifr_data;
if((header->Opcode != IANS_OP_EXT_GET_STATUS) &&
(!capable(CAP_NET_ADMIN)))
return -EPERM;
return bd_ans_os_Ioctl(netdev, ifr, cmd);
break;
#endif
#ifdef IDIAG
case IDIAG_PRO_BASE_SIOC:
if(!capable(CAP_NET_ADMIN))
return -EPERM;
#ifdef DIAG_DEBUG
printk("Entering diagnostics\n");
#endif
e1000_diag_ioctl(netdev, ifr);
break;
#endif /* IDIAG */
#ifdef SIOCETHTOOL
case SIOCETHTOOL:
return e1000_ethtool_ioctl(netdev, ifr);
6154: 3c090000 lui t1,0x0
6158: 25296dd8 addiu t1,t1,28120
615c: 340389f2 li v1,0x89f2
6160: 00804021 move t0,a0
6164: 10c20013 beq a2,v0,61b4 <e1000_ioctl+0x6c>
6168: 00a03821 move a3,a1
616c: 14c30018 bne a2,v1,61d0 <e1000_ioctl+0x88>
6170: 2402ff86 li v0,-122
static inline int capable(int cap)
{
#if 1 /* ok now */
if (cap_raised(current->cap_effective, cap))
6174: 8f8301d4 lw v1,468(gp)
6178: 30631000 andi v1,v1,0x1000
#else
if (cap_is_fs_cap(cap) ? current->fsuid == 0 : current->euid == 0)
#endif
{
current->flags |= PF_SUPERPRIV;
return 1;
617c: 24060001 li a2,1
6180: 3c070000 lui a3,0x0
6184: 24e70000 addiu a3,a3,0
static inline int capable(int cap)
{
#if 1 /* ok now */
if (cap_raised(current->cap_effective, cap))
6188: 10600005 beqz v1,61a0 <e1000_ioctl+0x58>
618c: 2402ffff li v0,-1
#else
if (cap_is_fs_cap(cap) ? current->fsuid == 0 : current->euid == 0)
#endif
{
current->flags |= PF_SUPERPRIV;
6190: 8f830004 lw v1,4(gp)
6194: 34630100 ori v1,v1,0x100
return 1;
6198: 08001869 j 61a4 <e1000_ioctl+0x5c>
619c: af830004 sw v1,4(gp)
}
return 0;
61a0: 00003021 move a2,zero
61a4: 14c00007 bnez a2,61c4 <e1000_ioctl+0x7c>
61a8: 8fbf0010 lw ra,16(sp)
61ac: 08001875 j 61d4 <e1000_ioctl+0x8c>
61b0: 00000000 nop
61b4: 0120f809 jalr t1
61b8: 00000000 nop
61bc: 08001875 j 61d4 <e1000_ioctl+0x8c>
61c0: 8fbf0010 lw ra,16(sp)
61c4: 00e0f809 jalr a3
61c8: 00000000 nop
break;
#endif
default:
return -EOPNOTSUPP;
}
return 0;
61cc: 00001021 move v0,zero
}
61d0: 8fbf0010 lw ra,16(sp)
61d4: 03e00008 jr ra
61d8: 27bd0018 addiu sp,sp,24
000061dc <e1000_hibernate_adapter>:
61dc: 27bdffe0 addiu sp,sp,-32
61e0: afb20018 sw s2,24(sp)
61e4: afbf001c sw ra,28(sp)
61e8: afb10014 sw s1,20(sp)
61ec: afb00010 sw s0,16(sp)
61f0: 00809021 move s2,a0
/**
* e1000_rx_checksum - Receive Checksum Offload for 82543
* @adapter: board private structure
* @rx_desc: receive descriptor
* @sk_buff: socket buffer with received data
**/
static inline void
e1000_rx_checksum(struct e1000_adapter *adapter,
struct e1000_rx_desc *rx_desc,
struct sk_buff *skb)
{
/* 82543 or newer only */
if((adapter->shared.mac_type < e1000_82543) ||
/* Ignore Checksum bit is set */
(rx_desc->status & E1000_RXD_STAT_IXSM) ||
/* TCP Checksum has not been calculated */
(!(rx_desc->status & E1000_RXD_STAT_TCPCS))) {
skb->ip_summed = CHECKSUM_NONE;
return;
}
/* At this point we know the hardware did the TCP checksum */
/* now look at the TCP checksum error bit */
if(rx_desc->errors & E1000_RXD_ERR_TCPE) {
/* let the stack verify checksum errors */
skb->ip_summed = CHECKSUM_NONE;
adapter->XsumRXError++;
} else {
/* TCP checksum is good */
skb->ip_summed = CHECKSUM_UNNECESSARY;
adapter->XsumRXGood++;
}
return;
}
void
e1000_hibernate_adapter(struct net_device *netdev)
{
uint32_t icr;
struct e1000_adapter *adapter = netdev->priv;
61f4: 8e500064 lw s0,100(s2)
61f8: 8e02000c lw v0,12(s0)
61fc: 2c420002 sltiu v0,v0,2
6200: 8e030008 lw v1,8(s0)
6204: 2402ffff li v0,-1
6208: ac6200d8 sw v0,216(v1)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
620c: c242002c ll v0,44(s2)
6210: 34420001 ori v0,v0,0x1
6214: e242002c sc v0,44(s2)
6218: 1040fffc beqz v0,620c <e1000_hibernate_adapter+0x30>
621c: 00000000 nop
e1000_irq_disable(adapter);
netif_stop_queue(netdev);
adapter->shared.adapter_stopped = 0;
e1000_adapter_stop(&adapter->shared);
6220: 26110008 addiu s1,s0,8
6224: ae000064 sw zero,100(s0)
6228: 3c030000 lui v1,0x0
622c: 24630000 addiu v1,v1,0
6230: 0060f809 jalr v1
6234: 02202021 move a0,s1
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
6238: 8e02008c lw v0,140(s0)
623c: 30420001 andi v0,v0,0x1
if(test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
6240: 10400021 beqz v0,62c8 <e1000_hibernate_adapter+0xec>
6244: 24030001 li v1,1
* Atomically adds @i to @v. Note that the guaranteed useful range
* of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_add(int i, atomic_t * v)
{
6248: 260200d8 addiu v0,s0,216
unsigned long temp;
__asm__ __volatile__(
624c: c0440000 ll a0,0(v0)
6250: 00832021 addu a0,a0,v1
6254: e0440000 sc a0,0(v0)
6258: 1080fffc beqz a0,624c <e1000_hibernate_adapter+0x70>
625c: 00000000 nop
/* Disable tasklet only when interface is opened. */
tasklet_disable(&adapter->rx_fill_tasklet);
/* clean out old buffers */
e1000_clean_rx_ring(adapter);
6260: 3c020000 lui v0,0x0
6264: 244228d8 addiu v0,v0,10456
6268: 0040f809 jalr v0
626c: 02002021 move a0,s0
e1000_clean_tx_ring(adapter);
6270: 3c020000 lui v0,0x0
6274: 24422720 addiu v0,v0,10016
6278: 0040f809 jalr v0
627c: 02002021 move a0,s0
/* Delete watchdog timer */
del_timer(&adapter->timer_id);
6280: 3c020000 lui v0,0x0
6284: 24420000 addiu v0,v0,0
6288: 0040f809 jalr v0
628c: 26040094 addiu a0,s0,148
6290: 8e03000c lw v1,12(s0)
6294: 2c630002 sltiu v1,v1,2
6298: 8e230000 lw v1,0(s1)
629c: 2402ffff li v0,-1
62a0: ac6200d8 sw v0,216(v1)
/* Unhook irq */
e1000_irq_disable(adapter);
62a4: 8e02000c lw v0,12(s0)
62a8: 2c420002 sltiu v0,v0,2
icr = E1000_READ_REG(&adapter->shared, ICR);
62ac: 8e020008 lw v0,8(s0)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
62b0: 8c4300c0 lw v1,192(v0)
free_irq(netdev->irq, netdev);
62b4: 8e440024 lw a0,36(s2)
62b8: 3c020000 lui v0,0x0
62bc: 24420000 addiu v0,v0,0
62c0: 0040f809 jalr v0
62c4: 02402821 move a1,s2
}
}
62c8: 8fbf001c lw ra,28(sp)
62cc: 8fb20018 lw s2,24(sp)
62d0: 8fb10014 lw s1,20(sp)
62d4: 8fb00010 lw s0,16(sp)
62d8: 03e00008 jr ra
62dc: 27bd0020 addiu sp,sp,32
000062e0 <e1000_wakeup_adapter>:
62e0: 27bdffd8 addiu sp,sp,-40
62e4: afb20020 sw s2,32(sp)
62e8: afb1001c sw s1,28(sp)
62ec: afbf0024 sw ra,36(sp)
62f0: afb00018 sw s0,24(sp)
62f4: 00809021 move s2,a0
void
e1000_wakeup_adapter(struct net_device *netdev)
{
uint32_t icr;
struct e1000_adapter *adapter = netdev->priv;
62f8: 8e500064 lw s0,100(s2)
adapter->shared.adapter_stopped = 0;
e1000_adapter_stop(&adapter->shared);
62fc: 3c030000 lui v1,0x0
6300: 24630000 addiu v1,v1,0
6304: 26110008 addiu s1,s0,8
6308: 02202021 move a0,s1
630c: 0060f809 jalr v1
6310: ae000064 sw zero,100(s0)
adapter->shared.adapter_stopped = 0;
adapter->shared.fc = adapter->shared.original_fc;
6314: 8e020030 lw v0,48(s0)
6318: ae000064 sw zero,100(s0)
631c: ae020018 sw v0,24(s0)
if(!e1000_init_hw(&adapter->shared))
6320: 3c020000 lui v0,0x0
6324: 24420000 addiu v0,v0,0
6328: 0040f809 jalr v0
632c: 02202021 move a0,s1
6330: 54400008 bnezl v0,6354 <e1000_wakeup_adapter+0x74>
6334: 8e02008c lw v0,140(s0)
printk("Hardware Init Failed at wakeup\n");
6338: 3c040000 lui a0,0x0
633c: 24840db0 addiu a0,a0,3504
6340: 3c020000 lui v0,0x0
6344: 24420000 addiu v0,v0,0
6348: 0040f809 jalr v0
634c: 00000000 nop
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
6350: 8e02008c lw v0,140(s0)
6354: 30420001 andi v0,v0,0x1
if(test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
6358: 10400059 beqz v0,64c0 <e1000_wakeup_adapter+0x1e0>
635c: 8fbf0024 lw ra,36(sp)
/* Setup Rctl */
e1000_setup_rctl(adapter);
6360: 3c020000 lui v0,0x0
6364: 24422308 addiu v0,v0,8968
6368: 0040f809 jalr v0
636c: 02002021 move a0,s0
e1000_configure_rx(adapter);
6370: 3c020000 lui v0,0x0
6374: 244223a8 addiu v0,v0,9128
6378: 0040f809 jalr v0
637c: 02002021 move a0,s0
e1000_alloc_rx_buffers((unsigned long) adapter);
6380: 3c020000 lui v0,0x0
6384: 24425e30 addiu v0,v0,24112
6388: 0040f809 jalr v0
638c: 02002021 move a0,s0
e1000_set_multi(netdev);
6390: 3c020000 lui v0,0x0
6394: 24420000 addiu v0,v0,0
6398: 0040f809 jalr v0
639c: 02402021 move a0,s2
e1000_configure_tx(adapter);
63a0: 3c020000 lui v0,0x0
63a4: 24421f60 addiu v0,v0,8032
63a8: 0040f809 jalr v0
63ac: 02002021 move a0,s0
extern void it_real_fn(unsigned long);
static inline void init_timer(struct timer_list * timer)
{
63b0: 26040094 addiu a0,s0,148
#ifdef IANS
if((IANS_BD_TAGGING_MODE) (ANS_PRIVATE_DATA_FIELD(adapter)->tag_mode)
!= IANS_BD_TAGGING_NONE)
bd_ans_hw_EnableVLAN(adapter);
#endif
/* Set the watchdog timer for 2 seconds */
init_timer(&adapter->timer_id);
adapter->timer_id.function = &e1000_watchdog;
63b4: 3c020000 lui v0,0x0
63b8: 24420000 addiu v0,v0,0
extern void it_real_fn(unsigned long);
static inline void init_timer(struct timer_list * timer)
{
timer->list.next = timer->list.prev = NULL;
63bc: ac800004 sw zero,4(a0)
63c0: ac800000 sw zero,0(a0)
63c4: ae0200a4 sw v0,164(s0)
adapter->timer_id.data = (unsigned long) netdev;
63c8: ae1200a0 sw s2,160(s0)
mod_timer(&adapter->timer_id, (jiffies + 2 * HZ));
63cc: 3c050000 lui a1,0x0
63d0: 8ca50000 lw a1,0(a1)
63d4: 3c020000 lui v0,0x0
63d8: 24420000 addiu v0,v0,0
63dc: 0040f809 jalr v0
63e0: 24a500c8 addiu a1,a1,200
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
63e4: 260300d8 addiu v1,s0,216
63e8: 24020001 li v0,1
unsigned long temp;
__asm__ __volatile__(
63ec: c0650000 ll a1,0(v1)
63f0: 00a22823 subu a1,a1,v0
63f4: e0650000 sc a1,0(v1)
63f8: 10a0fffc beqz a1,63ec <e1000_wakeup_adapter+0x10c>
63fc: 00000000 nop
6400: 8e04000c lw a0,12(s0)
6404: 2c840002 sltiu a0,a0,2
6408: 8e230000 lw v1,0(s1)
640c: 2402ffff li v0,-1
6410: ac6200d8 sw v0,216(v1)
tasklet_enable(&adapter->rx_fill_tasklet);
/* Hook irq */
e1000_irq_disable(adapter);
6414: 8e02000c lw v0,12(s0)
6418: 2c420002 sltiu v0,v0,2
icr = E1000_READ_REG(&adapter->shared, ICR);
641c: 8e020008 lw v0,8(s0)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
6420: 8c4300c0 lw v1,192(v0)
if(request_irq
6424: 8e440024 lw a0,36(s2)
6428: 3c050000 lui a1,0x0
642c: 24a50000 addiu a1,a1,0
6430: 3c070000 lui a3,0x0
6434: 24e70000 addiu a3,a3,0
6438: 3c060200 lui a2,0x200
643c: 3c020000 lui v0,0x0
6440: 24420000 addiu v0,v0,0
6444: 0040f809 jalr v0
6448: afb20010 sw s2,16(sp)
644c: 50400008 beqzl v0,6470 <e1000_wakeup_adapter+0x190>
6450: 8e02000c lw v0,12(s0)
(netdev->irq, &e1000_intr, SA_SHIRQ, e1000_driver_name, netdev) != 0)
printk(KERN_ERR "e1000: Unable to hook irq.\n");
6454: 3c040000 lui a0,0x0
6458: 24840dd0 addiu a0,a0,3536
645c: 3c020000 lui v0,0x0
6460: 24420000 addiu v0,v0,0
6464: 0040f809 jalr v0
6468: 00000000 nop
646c: 8e02000c lw v0,12(s0)
6470: 2c420002 sltiu v0,v0,2
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
6474: 8e0500cc lw a1,204(s0)
6478: 8e060008 lw a2,8(s0)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
647c: 30a4ff00 andi a0,a1,0xff00
6480: 00051600 sll v0,a1,0x18
6484: 00051a02 srl v1,a1,0x8
6488: 00042200 sll a0,a0,0x8
648c: 00441025 or v0,v0,a0
6490: 3063ff00 andi v1,v1,0xff00
6494: 00431025 or v0,v0,v1
6498: 00052e02 srl a1,a1,0x18
649c: 00451025 or v0,v0,a1
64a0: acc200d0 sw v0,208(a2)
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
64a4: c242002c ll v0,44(s2)
64a8: 2401fffe li at,-2
64ac: 00411024 and v0,v0,at
64b0: e242002c sc v0,44(s2)
64b4: 1040fffb beqz v0,64a4 <e1000_wakeup_adapter+0x1c4>
64b8: 00000000 nop
e1000_irq_enable(adapter);
netif_start_queue(netdev);
}
}
64bc: 8fbf0024 lw ra,36(sp)
64c0: 8fb20020 lw s2,32(sp)
64c4: 8fb1001c lw s1,28(sp)
64c8: 8fb00018 lw s0,24(sp)
64cc: 03e00008 jr ra
64d0: 27bd0028 addiu sp,sp,40
000064d4 <e1000_xmit_lbtest_frame>:
64d4: 27bdffd8 addiu sp,sp,-40
64d8: afb40020 sw s4,32(sp)
64dc: afb3001c sw s3,28(sp)
64e0: afb20018 sw s2,24(sp)
64e4: afb10014 sw s1,20(sp)
64e8: afbf0024 sw ra,36(sp)
64ec: afb00010 sw s0,16(sp)
64f0: 00a09821 move s3,a1
#ifdef IDIAG
int
e1000_xmit_lbtest_frame(struct sk_buff *skb,
struct e1000_adapter *adapter)
{
/*struct e1000_adapter *adapter = netdev->priv; */
struct pci_dev *pdev = adapter->pdev;
struct e1000_tx_desc *tx_desc;
int i;
i = adapter->tx_ring.next_to_use;
64f4: 8e6600f8 lw a2,248(s3)
tx_desc = E1000_TX_DESC(adapter->tx_ring, i);
adapter->tx_ring.buffer_info[i].skb = skb;
64f8: 8e630100 lw v1,256(s3)
64fc: 00809021 move s2,a0
6500: 00068840 sll s1,a2,0x1
6504: 02268821 addu s1,s1,a2
6508: 001188c0 sll s1,s1,0x3
650c: 02231821 addu v1,s1,v1
6510: 8e6700e4 lw a3,228(s3)
6514: ac720000 sw s2,0(v1)
adapter->tx_ring.buffer_info[i].length = skb->len;
6518: 8e620100 lw v0,256(s3)
651c: 8e44005c lw a0,92(s2)
6520: 00063100 sll a2,a2,0x4
6524: 02221021 addu v0,s1,v0
6528: ac440010 sw a0,16(v0)
adapter->tx_ring.buffer_info[i].dma =
652c: 8e430080 lw v1,128(s2)
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
6530: 3c040000 lui a0,0x0
6534: 8c840000 lw a0,0(a0)
6538: 8e45005c lw a1,92(s2)
653c: 3c028000 lui v0,0x8000
6540: 00431021 addu v0,v0,v1
6544: 00021302 srl v0,v0,0xc
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
6548: 00021180 sll v0,v0,0x6
654c: 00e6a021 addu s4,a3,a2
*/
static inline dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
unsigned long offset, size_t size,
int direction)
{
6550: 00441021 addu v0,v0,a0
6554: 30630fff andi v1,v1,0xfff
if (direction == PCI_DMA_NONE)
BUG();
addr = (unsigned long) page_address(page);
6558: 8c500038 lw s0,56(v0)
addr += offset;
#ifdef CONFIG_NONCOHERENT_IO
dma_cache_wback_inv(addr, size);
655c: 3c060000 lui a2,0x0
6560: 8cc60000 lw a2,0(a2)
6564: 02038021 addu s0,s0,v1
6568: 00c0f809 jalr a2
656c: 02002021 move a0,s0
pci_map_page(pdev, virt_to_page(skb->data),
(unsigned long) skb->data & ~PAGE_MASK, skb->len,
PCI_DMA_TODEVICE);
6570: 8e650100 lw a1,256(s3)
* IO bus memory addresses are also 1:1 with the physical address
*/
static inline unsigned long virt_to_bus(volatile void * address)
{
return PHYSADDR(address);
6574: 3c041fff lui a0,0x1fff
6578: 3484ffff ori a0,a0,0xffff
657c: 02041824 and v1,s0,a0
6580: 02252821 addu a1,s1,a1
6584: 00001021 move v0,zero
6588: aca20008 sw v0,8(a1)
658c: aca3000c sw v1,12(a1)
6590: 8e640100 lw a0,256(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6594: 3c0d00ff lui t5,0xff
6598: 02248821 addu s1,s1,a0
static __inline__ __const__ __u64 __fswab64(__u64 x)
{
# ifdef __SWAB_64_THRU_32__
__u32 h = x >> 32;
__u32 l = x & ((1ULL<<32)-1);
659c: 8e2b000c lw t3,12(s1)
65a0: 8e2c0008 lw t4,8(s1)
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
65a4: 00002021 move a0,zero
65a8: 3166ff00 andi a2,t3,0xff00
65ac: 016d4024 and t0,t3,t5
65b0: 00063200 sll a2,a2,0x8
65b4: 000b5600 sll t2,t3,0x18
65b8: 3189ff00 andi t1,t4,0xff00
65bc: 01465025 or t2,t2,a2
65c0: 000c3e00 sll a3,t4,0x18
65c4: 018d3024 and a2,t4,t5
65c8: 00084202 srl t0,t0,0x8
65cc: 00094a00 sll t1,t1,0x8
65d0: 00063202 srl a2,a2,0x8
65d4: 01485025 or t2,t2,t0
65d8: 00e93825 or a3,a3,t1
65dc: 000b5e02 srl t3,t3,0x18
65e0: 00e63825 or a3,a3,a2
65e4: 014b1825 or v1,t2,t3
65e8: 000c6602 srl t4,t4,0x18
65ec: 00ec2825 or a1,a3,t4
65f0: 00031000 sll v0,v1,0x0
65f4: 00001821 move v1,zero
65f8: 00441025 or v0,v0,a0
65fc: 00651825 or v1,v1,a1
tx_desc->buffer_addr = cpu_to_le64(adapter->tx_ring.buffer_info[i].dma);
6600: ae820000 sw v0,0(s4)
6604: ae830004 sw v1,4(s4)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
6608: 8e44005c lw a0,92(s2)
tx_desc->lower.data = cpu_to_le32(skb->len);
/* zero out the status field in the descriptor */
tx_desc->upper.data = 0;
tx_desc->lower.data |= E1000_TXD_CMD_EOP;
660c: 3c050100 lui a1,0x100
tx_desc->lower.data |= E1000_TXD_CMD_IFCS;
6610: 3c060200 lui a2,0x200
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6614: 3083ff00 andi v1,a0,0xff00
6618: 00031a00 sll v1,v1,0x8
661c: 008d6824 and t5,a0,t5
6620: 00041600 sll v0,a0,0x18
6624: 00431025 or v0,v0,v1
6628: 000d6a02 srl t5,t5,0x8
662c: 00042602 srl a0,a0,0x18
6630: 004d1025 or v0,v0,t5
6634: 00441025 or v0,v0,a0
6638: 00451025 or v0,v0,a1
663c: 00461025 or v0,v0,a2
tx_desc->lower.data |= E1000_TXD_CMD_IDE;
6640: 3c038000 lui v1,0x8000
6644: 00432025 or a0,v0,v1
6648: ae80000c sw zero,12(s4)
664c: ae840008 sw a0,8(s4)
if(adapter->shared.report_tx_early == 1)
6650: 8e63006c lw v1,108(s3)
6654: 24020001 li v0,1
6658: 54620002 bnel v1,v0,6664 <e1000_xmit_lbtest_frame+0x190>
665c: 3c021000 lui v0,0x1000
tx_desc->lower.data |= E1000_TXD_CMD_RS;
6660: 3c020800 lui v0,0x800
else
tx_desc->lower.data |= E1000_TXD_CMD_RPS;
6664: 00821025 or v0,a0,v0
6668: ae820008 sw v0,8(s4)
/* Move the HW Tx Tail Pointer */
adapter->tx_ring.next_to_use++;
666c: 8e6200f8 lw v0,248(s3)
adapter->tx_ring.next_to_use %= adapter->tx_ring.count;
6670: 8e6300f0 lw v1,240(s3)
6674: 24420001 addiu v0,v0,1
6678: 0043001b divu zero,v0,v1
667c: ae6200f8 sw v0,248(s3)
6680: 50600001 beqzl v1,6688 <e1000_xmit_lbtest_frame+0x1b4>
6684: 0007000d break 0x7
6688: 8e62000c lw v0,12(s3)
668c: 2c420002 sltiu v0,v0,2
6690: 00003010 mfhi a2
6694: 1440000e bnez v0,66d0 <e1000_xmit_lbtest_frame+0x1fc>
6698: ae6600f8 sw a2,248(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
669c: 30c3ff00 andi v1,a2,0xff00
66a0: 00031a00 sll v1,v1,0x8
66a4: 00061600 sll v0,a2,0x18
66a8: 00062202 srl a0,a2,0x8
66ac: 00431025 or v0,v0,v1
66b0: 3084ff00 andi a0,a0,0xff00
66b4: 8e650008 lw a1,8(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
66b8: 00441025 or v0,v0,a0
66bc: 00061e02 srl v1,a2,0x18
66c0: 00431025 or v0,v0,v1
E1000_WRITE_REG(&adapter->shared, TDT, adapter->tx_ring.next_to_use);
66c4: aca23818 sw v0,14360(a1)
66c8: 080019bf j 66fc <e1000_xmit_lbtest_frame+0x228>
66cc: 00000000 nop
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
66d0: 30c3ff00 andi v1,a2,0xff00
66d4: 00031a00 sll v1,v1,0x8
66d8: 00061600 sll v0,a2,0x18
66dc: 00062202 srl a0,a2,0x8
66e0: 00431025 or v0,v0,v1
66e4: 3084ff00 andi a0,a0,0xff00
66e8: 8e650008 lw a1,8(s3)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
66ec: 00441025 or v0,v0,a0
66f0: 00061e02 srl v1,a2,0x18
66f4: 00431025 or v0,v0,v1
66f8: aca20438 sw v0,1080(a1)
mdelay(10);
66fc: 3c040000 lui a0,0x0
6700: 8c840000 lw a0,0(a0)
6704: 3c031999 lui v1,0x1999
6708: 24050009 li a1,9
670c: 346396c0 ori v1,v1,0x96c0
6710: 2406ffff li a2,-1
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
__asm__("multu\t%2,%3"
6714: 00640019 multu v1,a0
6718: 00001010 mfhi v0
...
6724: 1440ffff bnez v0,6724 <e1000_xmit_lbtest_frame+0x250>
6728: 2442ffff addiu v0,v0,-1
672c: 24a5ffff addiu a1,a1,-1
6730: 14a6fff8 bne a1,a2,6714 <e1000_xmit_lbtest_frame+0x240>
6734: 266200f4 addiu v0,s3,244
* Atomically subtracts @i from @v. Note that the guaranteed
* useful range of an atomic_t is only 24 bits.
*/
extern __inline__ void atomic_sub(int i, atomic_t * v)
{
6738: 24030001 li v1,1
unsigned long temp;
__asm__ __volatile__(
673c: c0450000 ll a1,0(v0)
6740: 00a32823 subu a1,a1,v1
6744: e0450000 sc a1,0(v0)
6748: 10a0fffc beqz a1,673c <e1000_xmit_lbtest_frame+0x268>
674c: 00000000 nop
atomic_dec(&adapter->tx_ring.unused);
if(atomic_read(&adapter->tx_ring.unused) <= 1) {
6750: 8c440000 lw a0,0(v0)
6754: 28840002 slti a0,a0,2
6758: 50800005 beqzl a0,6770 <e1000_xmit_lbtest_frame+0x29c>
675c: 24020001 li v0,1
/* this driver never actually drops transmits,
* so use tx_dropped count to indicate the number of times
* netif_stop_queue is called due to no available descriptors
*/
adapter->net_stats.tx_dropped++;
6760: 8e63016c lw v1,364(s3)
return (0);
6764: 00001021 move v0,zero
6768: 24630001 addiu v1,v1,1
676c: ae63016c sw v1,364(s3)
}
return (1);
}
6770: 8fbf0024 lw ra,36(sp)
6774: 8fb40020 lw s4,32(sp)
6778: 8fb3001c lw s3,28(sp)
677c: 8fb20018 lw s2,24(sp)
6780: 8fb10014 lw s1,20(sp)
6784: 8fb00010 lw s0,16(sp)
6788: 03e00008 jr ra
678c: 27bd0028 addiu sp,sp,40
00006790 <e1000_rcv_lbtest_frame>:
int
e1000_rcv_lbtest_frame(struct e1000_adapter *adapter,
unsigned int frame_size)
{
struct pci_dev *pdev = adapter->pdev;
struct e1000_rx_desc *rx_desc;
int i, j = 0, rcved_pkt = 0;
uint32_t Length;
struct sk_buff *skb;
mdelay(500);
6790: 3c060000 lui a2,0x0
6794: 8cc60000 lw a2,0(a2)
6798: 27bdffb8 addiu sp,sp,-72
679c: 3c031999 lui v1,0x1999
67a0: afbe0040 sw s8,64(sp)
67a4: afa5004c sw a1,76(sp)
67a8: 0080f021 move s8,a0
67ac: afbf0044 sw ra,68(sp)
67b0: afb7003c sw s7,60(sp)
67b4: afb60038 sw s6,56(sp)
67b8: afb50034 sw s5,52(sp)
67bc: afb40030 sw s4,48(sp)
67c0: afb3002c sw s3,44(sp)
67c4: afb20028 sw s2,40(sp)
67c8: afb10024 sw s1,36(sp)
67cc: afb00020 sw s0,32(sp)
67d0: afa00010 sw zero,16(sp)
67d4: 00003821 move a3,zero
67d8: 240401f3 li a0,499
67dc: 346396c0 ori v1,v1,0x96c0
67e0: 2405ffff li a1,-1
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
__asm__("multu\t%2,%3"
67e4: 00660019 multu v1,a2
67e8: 00001010 mfhi v0
...
67f4: 1440ffff bnez v0,67f4 <e1000_rcv_lbtest_frame+0x64>
67f8: 2442ffff addiu v0,v0,-1
67fc: 2484ffff addiu a0,a0,-1
6800: 1485fff8 bne a0,a1,67e4 <e1000_rcv_lbtest_frame+0x54>
6804: 00000000 nop
i = adapter->rx_ring.next_to_clean;
6808: 8fd20128 lw s2,296(s8)
rx_desc = E1000_RX_DESC(adapter->rx_ring, i);
680c: 8fc40110 lw a0,272(s8)
6810: 00121900 sll v1,s2,0x4
6814: 0083b021 addu s6,a0,v1
while(rx_desc->status & E1000_RXD_STAT_DD) {
6818: 92c2000c lbu v0,12(s6)
681c: 30420001 andi v0,v0,0x1
6820: 1040005e beqz v0,699c <e1000_rcv_lbtest_frame+0x20c>
6824: 3c157fff lui s5,0x7fff
6828: 24130001 li s3,1
682c: 27d40120 addiu s4,s8,288
6830: 36b5f1c0 ori s5,s5,0xf1c0
Length = le16_to_cpu(rx_desc->length) - CRC_LENGTH;
skb = adapter->rx_ring.buffer_info[i].skb;
6834: 8fc3012c lw v1,300(s8)
6838: 00121040 sll v0,s2,0x1
683c: 00521021 addu v0,v0,s2
6840: 0002b8c0 sll s7,v0,0x3
6844: 02e31821 addu v1,s7,v1
6848: 8c710000 lw s1,0(v1)
/* Snoop the packet for pattern */
rcved_pkt = e1000_check_lbtest_frame(skb, frame_size);
684c: 8fa5004c lw a1,76(sp)
6850: 3c020000 lui v0,0x0
6854: 24426d8c addiu v0,v0,28044
6858: 0040f809 jalr v0
685c: 02202021 move a0,s1
6860: 00403821 move a3,v0
return result;
}
extern __inline__ int atomic_sub_return(int i, atomic_t * v)
{
6864: 26220070 addiu v0,s1,112
unsigned long temp, result;
__asm__ __volatile__(
6868: c0440000 ll a0,0(v0)
686c: 00931823 subu v1,a0,s3
6870: e0430000 sc v1,0(v0)
6874: 1060fffc beqz v1,6868 <e1000_rcv_lbtest_frame+0xd8>
6878: 00931823 subu v1,a0,s3
* is executing from interrupt context.
*/
static inline void dev_kfree_skb_irq(struct sk_buff *skb)
{
if (atomic_dec_and_test(&skb->users)) {
687c: 5460001f bnezl v1,68fc <e1000_rcv_lbtest_frame+0x16c>
6880: 8fc2012c lw v0,300(s8)
int cpu =smp_processor_id();
unsigned long flags;
local_irq_save(flags);
6884: 40106000 mfc0 s0,$12
6888: 00000000 nop
688c: 36010001 ori at,s0,0x1
6890: 38210001 xori at,at,0x1
6894: 40816000 mtc0 at,$12
6898: 00000040 sll zero,zero,0x1
689c: 00000040 sll zero,zero,0x1
68a0: 00000040 sll zero,zero,0x1
skb->next = softnet_data[cpu].completion_queue;
68a4: 3c030000 lui v1,0x0
68a8: 8c630020 lw v1,32(v1)
softnet_data[cpu].completion_queue = skb;
cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
68ac: 00002021 move a0,zero
68b0: 24050001 li a1,1
68b4: ae230000 sw v1,0(s1)
68b8: 3c020000 lui v0,0x0
68bc: 24420000 addiu v0,v0,0
68c0: 3c010000 lui at,0x0
68c4: ac310020 sw s1,32(at)
68c8: 0040f809 jalr v0
68cc: afa70018 sw a3,24(sp)
local_irq_restore(flags);
68d0: 40016000 mfc0 at,$12
68d4: 32100001 andi s0,s0,0x1
68d8: 34210001 ori at,at,0x1
68dc: 38210001 xori at,at,0x1
68e0: 02018025 or s0,s0,at
68e4: 40906000 mtc0 s0,$12
...
68f4: 8fa70018 lw a3,24(sp)
pci_unmap_single(pdev, adapter->rx_ring.buffer_info[i].dma,
adapter->rx_ring.buffer_info[i].length,
PCI_DMA_FROMDEVICE);
dev_kfree_skb_irq(skb);
adapter->rx_ring.buffer_info[i].skb = NULL;
68f8: 8fc2012c lw v0,300(s8)
68fc: 02e21021 addu v0,s7,v0
6900: ac400000 sw zero,0(v0)
rx_desc->status = 0;
6904: a2c0000c sb zero,12(s6)
extern __inline__ void atomic_add(int i, atomic_t * v)
{
unsigned long temp;
__asm__ __volatile__(
6908: c2830000 ll v1,0(s4)
690c: 00731821 addu v1,v1,s3
6910: e2830000 sc v1,0(s4)
6914: 1060fffc beqz v1,6908 <e1000_rcv_lbtest_frame+0x178>
6918: 00000000 nop
atomic_inc(&adapter->rx_ring.unused);
i++;
i %= adapter->rx_ring.count;
691c: 8fc2011c lw v0,284(s8)
6920: 26520001 addiu s2,s2,1
rx_desc = E1000_RX_DESC(adapter->rx_ring, i);
if(rcved_pkt)
break;
/* waited enough */
if(j++ >= adapter->rx_ring.count)
6924: 8fa30010 lw v1,16(sp)
6928: 0242001b divu zero,s2,v0
692c: 50400001 beqzl v0,6934 <e1000_rcv_lbtest_frame+0x1a4>
6930: 0007000d break 0x7
6934: 8fc50110 lw a1,272(s8)
6938: 0062302b sltu a2,v1,v0
693c: 00601021 move v0,v1
6940: 24420001 addiu v0,v0,1
6944: afa20010 sw v0,16(sp)
6948: 00001021 move v0,zero
694c: 00002010 mfhi a0
6950: 00809021 move s2,a0
6954: 00000000 nop
6958: 00121900 sll v1,s2,0x4
695c: 14e0000f bnez a3,699c <e1000_rcv_lbtest_frame+0x20c>
6960: 00a3b021 addu s6,a1,v1
6964: 10c00010 beqz a2,69a8 <e1000_rcv_lbtest_frame+0x218>
6968: 8fbf0044 lw ra,68(sp)
* first constant multiplications gets optimized away if the delay is
* a constant)
*/
extern __inline__ void __udelay(unsigned long usecs, unsigned long lpj)
{
696c: 3c020000 lui v0,0x0
6970: 8c420000 lw v0,0(v0)
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
__asm__("multu\t%2,%3"
6974: 02a20019 multu s5,v0
6978: 00001010 mfhi v0
...
6984: 1440ffff bnez v0,6984 <e1000_rcv_lbtest_frame+0x1f4>
6988: 2442ffff addiu v0,v0,-1
return 0;
mdelay(5);
}
698c: 92c3000c lbu v1,12(s6)
6990: 30630001 andi v1,v1,0x1
6994: 5460ffa8 bnezl v1,6838 <e1000_rcv_lbtest_frame+0xa8>
6998: 8fc3012c lw v1,300(s8)
adapter->rx_ring.next_to_clean = i;
699c: afd20128 sw s2,296(s8)
return (rcved_pkt);
69a0: 00e01021 move v0,a3
}
69a4: 8fbf0044 lw ra,68(sp)
69a8: 8fbe0040 lw s8,64(sp)
69ac: 8fb7003c lw s7,60(sp)
69b0: 8fb60038 lw s6,56(sp)
69b4: 8fb50034 lw s5,52(sp)
69b8: 8fb40030 lw s4,48(sp)
69bc: 8fb3002c lw s3,44(sp)
69c0: 8fb20028 lw s2,40(sp)
69c4: 8fb10024 lw s1,36(sp)
69c8: 8fb00020 lw s0,32(sp)
69cc: 03e00008 jr ra
69d0: 27bd0048 addiu sp,sp,72
000069d4 <e1000_selective_wakeup_adapter>:
69d4: 27bdffe0 addiu sp,sp,-32
69d8: afb10014 sw s1,20(sp)
69dc: afbf0018 sw ra,24(sp)
69e0: afb00010 sw s0,16(sp)
void
e1000_selective_wakeup_adapter(struct net_device *netdev)
{
struct e1000_adapter *adapter = netdev->priv;
69e4: 8c900064 lw s0,100(a0)
uint32_t ctrl, txcw;
e1000_init_hw(&adapter->shared);
69e8: 3c020000 lui v0,0x0
69ec: 24420000 addiu v0,v0,0
69f0: 26110008 addiu s1,s0,8
69f4: 0040f809 jalr v0
69f8: 02202021 move a0,s1
if((adapter->link_active == FALSE) &&
69fc: 8e0300b0 lw v1,176(s0)
6a00: 14600048 bnez v1,6b24 <e1000_selective_wakeup_adapter+0x150>
6a04: 2604008c addiu a0,s0,140
6a08: 8e0a000c lw t2,12(s0)
6a0c: 24020002 li v0,2
6a10: 55420045 bnel t2,v0,6b28 <e1000_selective_wakeup_adapter+0x154>
6a14: 8c820000 lw v0,0(a0)
(adapter->shared.mac_type == e1000_82543)) {
txcw = E1000_READ_REG(&adapter->shared, TXCW);
6a18: 8e220000 lw v0,0(s1)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6a1c: 3c0700ff lui a3,0xff
ctrl = E1000_READ_REG(&adapter->shared, CTRL);
6a20: 2d4a0002 sltiu t2,t2,2
6a24: 00405821 move t3,v0
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
6a28: 8c480178 lw t0,376(v0)
6a2c: 8d690000 lw t1,0(t3)
return __arch__swab32(x);
6a30: 3104ff00 andi a0,t0,0xff00
6a34: 3125ff00 andi a1,t1,0xff00
6a38: 01273024 and a2,t1,a3
6a3c: 00081e00 sll v1,t0,0x18
6a40: 01073824 and a3,t0,a3
6a44: 00091600 sll v0,t1,0x18
6a48: 00042200 sll a0,a0,0x8
6a4c: 00052a00 sll a1,a1,0x8
6a50: 00063202 srl a2,a2,0x8
6a54: 00641825 or v1,v1,a0
6a58: 00451025 or v0,v0,a1
6a5c: 00073a02 srl a3,a3,0x8
6a60: 00671825 or v1,v1,a3
6a64: 00461025 or v0,v0,a2
6a68: 00084602 srl t0,t0,0x18
6a6c: 00094e02 srl t1,t1,0x18
6a70: 00681825 or v1,v1,t0
6a74: 00493025 or a2,v0,t1
E1000_WRITE_REG(&adapter->shared, TXCW, txcw & ~E1000_TXCW_ANE);
6a78: 3c047fff lui a0,0x7fff
6a7c: 3484ffff ori a0,a0,0xffff
6a80: 00642024 and a0,v1,a0
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6a84: 3065ff00 andi a1,v1,0xff00
6a88: 00031600 sll v0,v1,0x18
6a8c: 00052a00 sll a1,a1,0x8
6a90: 00041a02 srl v1,a0,0x8
6a94: 00451025 or v0,v0,a1
6a98: 3063ff00 andi v1,v1,0xff00
6a9c: 00431025 or v0,v0,v1
6aa0: 00042602 srl a0,a0,0x18
6aa4: 00441025 or v0,v0,a0
6aa8: ad620178 sw v0,376(t3)
6aac: 8e02000c lw v0,12(s0)
6ab0: 2c420002 sltiu v0,v0,2
E1000_WRITE_REG(&adapter->shared, CTRL,
6ab4: 34c500c1 ori a1,a2,0xc1
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6ab8: 30a3ff00 andi v1,a1,0xff00
6abc: 00031a00 sll v1,v1,0x8
6ac0: 00051600 sll v0,a1,0x18
6ac4: 00052202 srl a0,a1,0x8
6ac8: 00431025 or v0,v0,v1
6acc: 3084ff00 andi a0,a0,0xff00
6ad0: 8e030008 lw v1,8(s0)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6ad4: 00441025 or v0,v0,a0
6ad8: 00052e02 srl a1,a1,0x18
6adc: 00451025 or v0,v0,a1
6ae0: ac620000 sw v0,0(v1)
(ctrl | E1000_CTRL_SLU | E1000_CTRL_ILOS |
E1000_CTRL_FD));
mdelay(20);
6ae4: 3c040000 lui a0,0x0
6ae8: 8c840000 lw a0,0(a0)
6aec: 3c031999 lui v1,0x1999
6af0: 24050013 li a1,19
6af4: 346396c0 ori v1,v1,0x96c0
6af8: 2406ffff li a2,-1
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
__asm__("multu\t%2,%3"
6afc: 00640019 multu v1,a0
6b00: 00001010 mfhi v0
...
6b0c: 1440ffff bnez v0,6b0c <e1000_selective_wakeup_adapter+0x138>
6b10: 2442ffff addiu v0,v0,-1
6b14: 24a5ffff addiu a1,a1,-1
6b18: 14a6fff8 bne a1,a2,6afc <e1000_selective_wakeup_adapter+0x128>
6b1c: 00000000 nop
* @nr: bit number to test
* @addr: Address to start counting from
*/
extern __inline__ int test_bit(int nr, volatile void *addr)
{
6b20: 2604008c addiu a0,s0,140
return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
6b24: 8c820000 lw v0,0(a0)
6b28: 30420001 andi v0,v0,0x1
}
if(!test_bit(E1000_BOARD_OPEN, &adapter->flags)) {
6b2c: 14400013 bnez v0,6b7c <e1000_selective_wakeup_adapter+0x1a8>
6b30: 00000000 nop
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
6b34: c0820000 ll v0,0(a0)
6b38: 34420001 ori v0,v0,0x1
6b3c: e0820000 sc v0,0(a0)
6b40: 1040fffc beqz v0,6b34 <e1000_selective_wakeup_adapter+0x160>
6b44: 00000000 nop
6b48: c0830000 ll v1,0(a0)
6b4c: 34630004 ori v1,v1,0x4
6b50: e0830000 sc v1,0(a0)
6b54: 1060fffc beqz v1,6b48 <e1000_selective_wakeup_adapter+0x174>
6b58: 00000000 nop
set_bit(E1000_BOARD_OPEN, &adapter->flags);
set_bit(E1000_DIAG_OPEN, &adapter->flags);
e1000_setup_tx_resources(adapter);
6b5c: 3c020000 lui v0,0x0
6b60: 24421e60 addiu v0,v0,7776
6b64: 0040f809 jalr v0
6b68: 02002021 move a0,s0
e1000_setup_rx_resources(adapter);
6b6c: 3c020000 lui v0,0x0
6b70: 24422208 addiu v0,v0,8712
6b74: 0040f809 jalr v0
6b78: 02002021 move a0,s0
}
e1000_setup_rctl(adapter);
6b7c: 3c020000 lui v0,0x0
6b80: 24422308 addiu v0,v0,8968
6b84: 0040f809 jalr v0
6b88: 02002021 move a0,s0
e1000_configure_rx(adapter);
6b8c: 3c020000 lui v0,0x0
6b90: 244223a8 addiu v0,v0,9128
6b94: 0040f809 jalr v0
6b98: 02002021 move a0,s0
e1000_alloc_rx_buffers((unsigned long) adapter);
6b9c: 3c020000 lui v0,0x0
6ba0: 24425e30 addiu v0,v0,24112
6ba4: 0040f809 jalr v0
6ba8: 02002021 move a0,s0
e1000_configure_tx(adapter);
6bac: 3c020000 lui v0,0x0
6bb0: 24421f60 addiu v0,v0,8032
6bb4: 0040f809 jalr v0
6bb8: 02002021 move a0,s0
}
6bbc: 8fbf0018 lw ra,24(sp)
6bc0: 8fb10014 lw s1,20(sp)
6bc4: 8fb00010 lw s0,16(sp)
6bc8: 03e00008 jr ra
6bcc: 27bd0020 addiu sp,sp,32
00006bd0 <e1000_selective_hibernate_adapter>:
6bd0: 27bdffe0 addiu sp,sp,-32
6bd4: afbf0018 sw ra,24(sp)
6bd8: afb10014 sw s1,20(sp)
6bdc: afb00010 sw s0,16(sp)
void
e1000_selective_hibernate_adapter(struct net_device *netdev)
{
struct e1000_adapter *adapter = netdev->priv;
6be0: 8c910064 lw s1,100(a0)
uint32_t ctrl, txcw;
if((adapter->link_active == FALSE) &&
6be4: 8e2200b0 lw v0,176(s1)
6be8: 14400043 bnez v0,6cf8 <e1000_selective_hibernate_adapter+0x128>
6bec: 24020002 li v0,2
6bf0: 8e2a000c lw t2,12(s1)
6bf4: 15420040 bne t2,v0,6cf8 <e1000_selective_hibernate_adapter+0x128>
6bf8: 3c0700ff lui a3,0xff
(adapter->shared.mac_type == e1000_82543)) {
txcw = E1000_READ_REG(&adapter->shared, TXCW);
6bfc: 8e2b0008 lw t3,8(s1)
ctrl = E1000_READ_REG(&adapter->shared, CTRL);
ctrl &= ~E1000_CTRL_SLU & ~E1000_CTRL_ILOS;
6c00: 2d4a0002 sltiu t2,t2,2
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
6c04: 8d690178 lw t1,376(t3)
6c08: 8d620000 lw v0,0(t3)
return __arch__swab32(x);
6c0c: 3124ff00 andi a0,t1,0xff00
6c10: 3045ff00 andi a1,v0,0xff00
6c14: 00474024 and t0,v0,a3
6c18: 00093600 sll a2,t1,0x18
6c1c: 01273824 and a3,t1,a3
6c20: 00021e00 sll v1,v0,0x18
6c24: 00042200 sll a0,a0,0x8
6c28: 00052a00 sll a1,a1,0x8
6c2c: 00073a02 srl a3,a3,0x8
6c30: 00c43025 or a2,a2,a0
6c34: 00651825 or v1,v1,a1
6c38: 00084202 srl t0,t0,0x8
6c3c: 00021602 srl v0,v0,0x18
6c40: 00c73025 or a2,a2,a3
6c44: 00681825 or v1,v1,t0
6c48: 00094e02 srl t1,t1,0x18
6c4c: 3042003f andi v0,v0,0x3f
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6c50: 00c93025 or a2,a2,t1
6c54: 00433825 or a3,v0,v1
E1000_WRITE_REG(&adapter->shared, TXCW, txcw | E1000_TXCW_ANE);
6c58: 3c038000 lui v1,0x8000
6c5c: 00c31825 or v1,a2,v1
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6c60: 3065ff00 andi a1,v1,0xff00
6c64: 00031600 sll v0,v1,0x18
6c68: 00032202 srl a0,v1,0x8
6c6c: 00052a00 sll a1,a1,0x8
6c70: 00451025 or v0,v0,a1
6c74: 3084ff00 andi a0,a0,0xff00
6c78: 00441025 or v0,v0,a0
6c7c: 00031e02 srl v1,v1,0x18
6c80: 00431025 or v0,v0,v1
6c84: ad620178 sw v0,376(t3)
6c88: 8e22000c lw v0,12(s1)
6c8c: 2c420002 sltiu v0,v0,2
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6c90: 30e3ff00 andi v1,a3,0xff00
6c94: 00031a00 sll v1,v1,0x8
6c98: 00071600 sll v0,a3,0x18
6c9c: 00072202 srl a0,a3,0x8
6ca0: 00431025 or v0,v0,v1
6ca4: 3084ff00 andi a0,a0,0xff00
E1000_WRITE_REG(&adapter->shared, CTRL, ctrl);
6ca8: 8e250008 lw a1,8(s1)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
6cac: 00441025 or v0,v0,a0
6cb0: 00071e02 srl v1,a3,0x18
6cb4: 00431025 or v0,v0,v1
6cb8: aca20000 sw v0,0(a1)
mdelay(20);
6cbc: 3c040000 lui a0,0x0
6cc0: 8c840000 lw a0,0(a0)
6cc4: 3c031999 lui v1,0x1999
6cc8: 24050013 li a1,19
6ccc: 346396c0 ori v1,v1,0x96c0
6cd0: 2406ffff li a2,-1
{
unsigned long lo;
usecs *= 0x00068db8; /* 2**32 / (1000000 / HZ) */
__asm__("multu\t%2,%3"
6cd4: 00640019 multu v1,a0
6cd8: 00001010 mfhi v0
...
6ce4: 1440ffff bnez v0,6ce4 <e1000_selective_hibernate_adapter+0x114>
6ce8: 2442ffff addiu v0,v0,-1
6cec: 24a5ffff addiu a1,a1,-1
6cf0: 14a6fff8 bne a1,a2,6cd4 <e1000_selective_hibernate_adapter+0x104>
6cf4: 00000000 nop
}
/* clean out old buffers */
e1000_clean_rx_ring(adapter);
6cf8: 3c020000 lui v0,0x0
6cfc: 244228d8 addiu v0,v0,10456
6d00: 0040f809 jalr v0
6d04: 02202021 move a0,s1
e1000_clean_tx_ring(adapter);
6d08: 3c020000 lui v0,0x0
6d0c: 24422720 addiu v0,v0,10016
6d10: 0040f809 jalr v0
6d14: 02202021 move a0,s1
* It also implies a memory barrier.
*/
extern __inline__ int
test_and_clear_bit(int nr, volatile void *addr)
{
6d18: 2630008c addiu s0,s1,140
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp, res;
__asm__ __volatile__(
6d1c: 24020004 li v0,4
6d20: c2040000 ll a0,0(s0)
6d24: 00821825 or v1,a0,v0
6d28: 00621826 xor v1,v1,v0
6d2c: e2030000 sc v1,0(s0)
6d30: 1060fffb beqz v1,6d20 <e1000_selective_hibernate_adapter+0x150>
6d34: 00821824 and v1,a0,v0
if(test_and_clear_bit(E1000_DIAG_OPEN, &adapter->flags)) {
6d38: 10600010 beqz v1,6d7c <e1000_selective_hibernate_adapter+0x1ac>
6d3c: 8fbf0018 lw ra,24(sp)
e1000_free_tx_resources(adapter);
6d40: 3c020000 lui v0,0x0
6d44: 244226b4 addiu v0,v0,9908
6d48: 0040f809 jalr v0
6d4c: 02202021 move a0,s1
e1000_free_rx_resources(adapter);
6d50: 3c020000 lui v0,0x0
6d54: 2442284c addiu v0,v0,10316
6d58: 0040f809 jalr v0
6d5c: 02202021 move a0,s1
{
unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
unsigned long temp;
__asm__ __volatile__(
6d60: c2030000 ll v1,0(s0)
6d64: 2401fffe li at,-2
6d68: 00611824 and v1,v1,at
6d6c: e2030000 sc v1,0(s0)
6d70: 1060fffb beqz v1,6d60 <e1000_selective_hibernate_adapter+0x190>
6d74: 00000000 nop
clear_bit(E1000_BOARD_OPEN, &adapter->flags);
}
}
6d78: 8fbf0018 lw ra,24(sp)
6d7c: 8fb10014 lw s1,20(sp)
6d80: 8fb00010 lw s0,16(sp)
6d84: 03e00008 jr ra
6d88: 27bd0020 addiu sp,sp,32
00006d8c <e1000_check_lbtest_frame>:
static int
e1000_check_lbtest_frame(struct sk_buff *skb,
unsigned int frame_size)
{
frame_size = (frame_size % 2) ? (frame_size - 1) : frame_size;
if(*(skb->data + 3) == 0xFF) {
6d8c: 8c860080 lw a2,128(a0)
6d90: 30a20001 andi v0,a1,0x1
6d94: 00a22823 subu a1,a1,v0
6d98: 90c40003 lbu a0,3(a2)
if((*(skb->data + frame_size / 2 + 10) == 0xBE) &&
6d9c: 00052842 srl a1,a1,0x1
6da0: 240300ff li v1,255
6da4: 240700be li a3,190
6da8: 14830008 bne a0,v1,6dcc <e1000_check_lbtest_frame+0x40>
6dac: 00c53021 addu a2,a2,a1
6db0: 90c3000a lbu v1,10(a2)
6db4: 240400af li a0,175
6db8: 14670004 bne v1,a3,6dcc <e1000_check_lbtest_frame+0x40>
6dbc: 24020001 li v0,1
6dc0: 90c3000c lbu v1,12(a2)
6dc4: 10640002 beq v1,a0,6dd0 <e1000_check_lbtest_frame+0x44>
6dc8: 00000000 nop
(*(skb->data + frame_size / 2 + 12) == 0xAF)) {
return 1;
}
}
return 0;
6dcc: 00001021 move v0,zero
}
6dd0: 03e00008 jr ra
6dd4: 00000000 nop
00006dd8 <e1000_ethtool_ioctl>:
6dd8: 27bdfeb8 addiu sp,sp,-328
6ddc: afb5013c sw s5,316(sp)
6de0: afb40138 sw s4,312(sp)
6de4: afb30134 sw s3,308(sp)
6de8: afb1012c sw s1,300(sp)
6dec: afbf0140 sw ra,320(sp)
6df0: afb20130 sw s2,304(sp)
6df4: afb00128 sw s0,296(sp)
6df8: 00a09821 move s3,a1
#endif /* IDIAG */
#ifdef SIOCETHTOOL
/**
* e1000_ethtool_ioctl - Ethtool Ioctl Support
* @netdev: net device structure
* @ifr: interface request structure
**/
static int
e1000_ethtool_ioctl(struct net_device *netdev,
struct ifreq *ifr)
{
struct ethtool_cmd eth_cmd;
struct e1000_adapter *adapter = netdev->priv;
boolean_t re_initiate = FALSE;
#ifdef ETHTOOL_GLINK
struct ethtool_value eth_e1000_linkinfo;
#endif
#ifdef ETHTOOL_GDRVINFO
struct ethtool_drvinfo eth_e1000_info;
#endif
#ifdef ETHTOOL_GWOL
struct ethtool_wolinfo eth_e1000_wolinfo;
#endif
/* Get the data structure */
if(copy_from_user(ð_cmd, ifr->ifr_data, sizeof(eth_cmd)))
6dfc: 8e650010 lw a1,16(s3)
6e00: 8f8303bc lw v1,956(gp)
6e04: 0080a821 move s5,a0
6e08: 24a2002c addiu v0,a1,44
6e0c: 00a21025 or v0,a1,v0
6e10: 00621824 and v1,v1,v0
6e14: 8eb20064 lw s2,100(s5)
6e18: 00008821 move s1,zero
6e1c: 27b40010 addiu s4,sp,16
6e20: 04600006 bltz v1,6e3c <e1000_ethtool_ioctl+0x64>
6e24: 2406002c li a2,44
6e28: 02802021 move a0,s4
6e2c: 3c010000 lui at,0x0
6e30: 24210000 addiu at,at,0
6e34: 0020f809 jalr at
6e38: 00a60821 addu at,a1,a2
6e3c: 14c00162 bnez a2,73c8 <e1000_ethtool_ioctl+0x5f0>
6e40: 2402fff2 li v0,-14
return -EFAULT;
switch (eth_cmd.cmd) {
6e44: 8fa20010 lw v0,16(sp)
6e48: 2442ffff addiu v0,v0,-1
6e4c: 2c43000a sltiu v1,v0,10
6e50: 5060015d beqzl v1,73c8 <e1000_ethtool_ioctl+0x5f0>
6e54: 2402ff86 li v0,-122
6e58: 00021080 sll v0,v0,0x2
6e5c: 3c030000 lui v1,0x0
6e60: 00621821 addu v1,v1,v0
6e64: 8c630f48 lw v1,3912(v1)
6e68: 00600008 jr v1
6e6c: 00000000 nop
/* Get the information */
case ETHTOOL_GSET:
if(adapter->shared.media_type == e1000_media_type_copper) {
6e70: 8e420010 lw v0,16(s2)
6e74: 1440000c bnez v0,6ea8 <e1000_ethtool_ioctl+0xd0>
6e78: 24030440 li v1,1088
eth_cmd.supported = E1000_ETHTOOL_COPPER_INTERFACE_SUPPORTS;
6e7c: 2404026f li a0,623
eth_cmd.advertising = E1000_ETHTOOL_COPPER_INTERFACE_ADVERTISE;
eth_cmd.port = PORT_MII;
6e80: 24020002 li v0,2
6e84: afa40018 sw a0,24(sp)
6e88: a3a2001f sb v0,31(sp)
6e8c: afa40014 sw a0,20(sp)
eth_cmd.phy_address = adapter->shared.phy_addr;
6e90: 9243002f lbu v1,47(s2)
6e94: a3a30020 sb v1,32(sp)
eth_cmd.transceiver =
6e98: 8e42000c lw v0,12(s2)
6e9c: 2c420003 sltiu v0,v0,3
(adapter->shared.mac_type >
e1000_82543) ? XCVR_INTERNAL : XCVR_EXTERNAL;
} else {
6ea0: 08001bae j 6eb8 <e1000_ethtool_ioctl+0xe0>
6ea4: a3a20021 sb v0,33(sp)
eth_cmd.supported = E1000_ETHTOOL_FIBER_INTERFACE_SUPPORTS;
eth_cmd.advertising = E1000_ETHTOOL_FIBER_INTERFACE_ADVERTISE;
eth_cmd.port = PORT_FIBRE;
6ea8: 24020003 li v0,3
6eac: afa30018 sw v1,24(sp)
6eb0: a3a2001f sb v0,31(sp)
6eb4: afa30014 sw v1,20(sp)
}
if(adapter->link_active == TRUE) {
6eb8: 8e4300b0 lw v1,176(s2)
6ebc: 24020001 li v0,1
6ec0: 54620010 bnel v1,v0,6f04 <e1000_ethtool_ioctl+0x12c>
6ec4: a7a0001c sh zero,28(sp)
e1000_get_speed_and_duplex(&adapter->shared, &adapter->link_speed,
6ec8: 265000b4 addiu s0,s2,180
6ecc: 265100b6 addiu s1,s2,182
6ed0: 3c020000 lui v0,0x0
6ed4: 24420000 addiu v0,v0,0
6ed8: 26440008 addiu a0,s2,8
6edc: 02002821 move a1,s0
6ee0: 0040f809 jalr v0
6ee4: 02203021 move a2,s1
&adapter->link_duplex);
eth_cmd.speed = adapter->link_speed;
6ee8: 96030000 lhu v1,0(s0)
6eec: a7a3001c sh v1,28(sp)
eth_cmd.duplex =
6ef0: 96220000 lhu v0,0(s1)
6ef4: 38420002 xori v0,v0,0x2
6ef8: 2c420001 sltiu v0,v0,1
(adapter->link_duplex ==
FULL_DUPLEX) ? DUPLEX_FULL : DUPLEX_HALF;
} else {
6efc: 08001bc2 j 6f08 <e1000_ethtool_ioctl+0x130>
6f00: a3a2001e sb v0,30(sp)
eth_cmd.speed = 0;
eth_cmd.duplex = 0;
6f04: a3a0001e sb zero,30(sp)
}
if(adapter->shared.autoneg)
6f08: 92420078 lbu v0,120(s2)
6f0c: 10400003 beqz v0,6f1c <e1000_ethtool_ioctl+0x144>
6f10: 24020001 li v0,1
eth_cmd.autoneg = AUTONEG_ENABLE;
6f14: 08001bc8 j 6f20 <e1000_ethtool_ioctl+0x148>
6f18: a3a20022 sb v0,34(sp)
else
eth_cmd.autoneg = AUTONEG_DISABLE;
6f1c: a3a00022 sb zero,34(sp)
if(copy_to_user(ifr->ifr_data, ð_cmd, sizeof(eth_cmd)))
6f20: 8e640010 lw a0,16(s3)
6f24: 8f8303bc lw v1,956(gp)
6f28: 2482002c addiu v0,a0,44
6f2c: 00821025 or v0,a0,v0
6f30: 00621824 and v1,v1,v0
6f34: 0460011d bltz v1,73ac <e1000_ethtool_ioctl+0x5d4>
6f38: 2406002c li a2,44
6f3c: 02802821 move a1,s4
6f40: 3c010000 lui at,0x0
6f44: 24210000 addiu at,at,0
6f48: 0020f809 jalr at
6f4c: 00000000 nop
return -EFAULT;
6f50: 08001ceb j 73ac <e1000_ethtool_ioctl+0x5d4>
6f54: 00000000 nop
static inline int capable(int cap)
{
#if 1 /* ok now */
if (cap_raised(current->cap_effective, cap))
6f58: 8f8201d4 lw v0,468(gp)
6f5c: 30421000 andi v0,v0,0x1000
6f60: 10400005 beqz v0,6f78 <e1000_ethtool_ioctl+0x1a0>
6f64: 24030001 li v1,1
#else
if (cap_is_fs_cap(cap) ? current->fsuid == 0 : current->euid == 0)
#endif
{
current->flags |= PF_SUPERPRIV;
6f68: 8f820004 lw v0,4(gp)
6f6c: 34420100 ori v0,v0,0x100
return 1;
6f70: 08001bdf j 6f7c <e1000_ethtool_ioctl+0x1a4>
6f74: af820004 sw v0,4(gp)
}
return 0;
6f78: 00001821 move v1,zero
break;
/* set information */
case ETHTOOL_SSET:
/* need proper permission to do set */
if(!capable(CAP_NET_ADMIN))
6f7c: 10600112 beqz v1,73c8 <e1000_ethtool_ioctl+0x5f0>
6f80: 2402ffff li v0,-1
return -EPERM;
/* Cannot Force speed/duplex and at the same time autoneg.
* Autoneg will override forcing.
* For example to force speed/duplex pass in
* 'speed 100 duplex half autoneg off'
* pass in 'autoneg on' to start autoneg.
*/
printk("e1000: Requested link to be forced to %d Speed, %s Duplex "
6f84: 93a2001e lbu v0,30(sp)
6f88: 3c060000 lui a2,0x0
6f8c: 24c60284 addiu a2,a2,644
6f90: 14400003 bnez v0,6fa0 <e1000_ethtool_ioctl+0x1c8>
6f94: 97a5001c lhu a1,28(sp)
6f98: 3c060000 lui a2,0x0
6f9c: 24c6028c addiu a2,a2,652
6fa0: 93a20022 lbu v0,34(sp)
6fa4: 3c070000 lui a3,0x0
6fa8: 24e70e30 addiu a3,a3,3632
6fac: 14400003 bnez v0,6fbc <e1000_ethtool_ioctl+0x1e4>
6fb0: 00000000 nop
6fb4: 3c070000 lui a3,0x0
6fb8: 24e70e44 addiu a3,a3,3652
6fbc: 3c040000 lui a0,0x0
6fc0: 24840df0 addiu a0,a0,3568
6fc4: 3c100000 lui s0,0x0
6fc8: 26100000 addiu s0,s0,0
6fcc: 0200f809 jalr s0
6fd0: 00000000 nop
"%s\n", eth_cmd.speed, (eth_cmd.duplex ? "Full" : "Half"),
(eth_cmd.autoneg ? "and Autonegotiate" : "."));
if(eth_cmd.autoneg && eth_cmd.speed)
6fd4: 93a30022 lbu v1,34(sp)
6fd8: 10600016 beqz v1,7034 <e1000_ethtool_ioctl+0x25c>
6fdc: 97a2001c lhu v0,28(sp)
6fe0: 10400006 beqz v0,6ffc <e1000_ethtool_ioctl+0x224>
6fe4: 00000000 nop
printk("e1000: Autoneg request will over-ride speed forcing\n");
6fe8: 3c040000 lui a0,0x0
6fec: 24840e48 addiu a0,a0,3656
6ff0: 0200f809 jalr s0
6ff4: 00000000 nop
6ff8: 93a30022 lbu v1,34(sp)
/* if not in autoneg mode and have been asked to enable autoneg */
if(eth_cmd.autoneg) {
6ffc: 1060000d beqz v1,7034 <e1000_ethtool_ioctl+0x25c>
7000: 97a2001c lhu v0,28(sp)
if(adapter->shared.autoneg &&
7004: 92420078 lbu v0,120(s2)
7008: 10400004 beqz v0,701c <e1000_ethtool_ioctl+0x244>
700c: 2403002f li v1,47
7010: 96440048 lhu a0,72(s2)
7014: 108300ec beq a0,v1,73c8 <e1000_ethtool_ioctl+0x5f0>
7018: 00001021 move v0,zero
adapter->shared.autoneg_advertised == AUTONEG_ADV_DEFAULT)
/* If already in Autoneg */
return 0;
else {
adapter->shared.autoneg = 1;
701c: 24030001 li v1,1
adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
7020: 2402002f li v0,47
7024: a6420048 sh v0,72(s2)
7028: a2430078 sb v1,120(s2)
re_initiate = TRUE;
}
}
702c: 08001c6c j 71b0 <e1000_ethtool_ioctl+0x3d8>
7030: 24110001 li s1,1
/* Force link to whatever speed and duplex */
/* Also turning off Autoneg in case of non-gig speeds */
else if(eth_cmd.speed) {
7034: 1040005e beqz v0,71b0 <e1000_ethtool_ioctl+0x3d8>
7038: 00402021 move a0,v0
/* Check for invalid request */
if(((eth_cmd.speed != SPEED_10) && (eth_cmd.speed != SPEED_100) &&
703c: 3883000a xori v1,a0,0xa
7040: 38820064 xori v0,a0,0x64
7044: 0003182b sltu v1,zero,v1
7048: 0002102b sltu v0,zero,v0
704c: 00621824 and v1,v1,v0
7050: 10600003 beqz v1,7060 <e1000_ethtool_ioctl+0x288>
7054: 240203e8 li v0,1000
7058: 148200db bne a0,v0,73c8 <e1000_ethtool_ioctl+0x5f0>
705c: 2402ffea li v0,-22
7060: 93a2001e lbu v0,30(sp)
7064: 2c420002 sltiu v0,v0,2
7068: 104000d7 beqz v0,73c8 <e1000_ethtool_ioctl+0x5f0>
706c: 2402ffea li v0,-22
7070: 8e430010 lw v1,16(s2)
7074: 24020001 li v0,1
7078: 10620063 beq v1,v0,7208 <e1000_ethtool_ioctl+0x430>
707c: 265000b4 addiu s0,s2,180
(eth_cmd.speed != SPEED_1000)) ||
((eth_cmd.duplex != DUPLEX_HALF) &&
(eth_cmd.duplex != DUPLEX_FULL)) ||
(adapter->shared.media_type == e1000_media_type_fiber))
return -EINVAL;
e1000_get_speed_and_duplex(&adapter->shared, &adapter->link_speed,
7080: 265100b6 addiu s1,s2,182
7084: 26440008 addiu a0,s2,8
7088: 02002821 move a1,s0
708c: 3c020000 lui v0,0x0
7090: 24420000 addiu v0,v0,0
7094: 0040f809 jalr v0
7098: 02203021 move a2,s1
&adapter->link_duplex);
/* If we are already forced to requested speed and duplex
* Donot do anything, just return
*/
if(!adapter->shared.autoneg &&
709c: 92430078 lbu v1,120(s2)
70a0: 5460000b bnezl v1,70d0 <e1000_ethtool_ioctl+0x2f8>
70a4: a2400078 sb zero,120(s2)
70a8: 96030000 lhu v1,0(s0)
70ac: 97a2001c lhu v0,28(sp)
70b0: 54620007 bnel v1,v0,70d0 <e1000_ethtool_ioctl+0x2f8>
70b4: a2400078 sb zero,120(s2)
70b8: 93a3001e lbu v1,30(sp)
70bc: 96240000 lhu a0,0(s1)
70c0: 24630001 addiu v1,v1,1
70c4: 108300c0 beq a0,v1,73c8 <e1000_ethtool_ioctl+0x5f0>
70c8: 00001021 move v0,zero
(adapter->link_speed == eth_cmd.speed) &&
(adapter->link_duplex == (eth_cmd.duplex + 1)))
return 0;
adapter->shared.autoneg = 0;
70cc: a2400078 sb zero,120(s2)
adapter->shared.autoneg_advertised = 0;
70d0: a6400048 sh zero,72(s2)
re_initiate = TRUE;
switch (eth_cmd.speed + eth_cmd.duplex) {
70d4: 97a2001c lhu v0,28(sp)
70d8: 93a3001e lbu v1,30(sp)
70dc: 24040064 li a0,100
70e0: 00431821 addu v1,v0,v1
70e4: 1064001a beq v1,a0,7150 <e1000_ethtool_ioctl+0x378>
70e8: 24110001 li s1,1
70ec: 28620065 slti v0,v1,101
70f0: 10400008 beqz v0,7114 <e1000_ethtool_ioctl+0x33c>
70f4: 240203e8 li v0,1000
70f8: 2402000a li v0,10
70fc: 10620012 beq v1,v0,7148 <e1000_ethtool_ioctl+0x370>
7100: 2402000b li v0,11
7104: 10620015 beq v1,v0,715c <e1000_ethtool_ioctl+0x384>
7108: 24030001 li v1,1
710c: 08001c6a j 71a8 <e1000_ethtool_ioctl+0x3d0>
7110: 24020020 li v0,32
7114: 10620016 beq v1,v0,7170 <e1000_ethtool_ioctl+0x398>
7118: 286203e9 slti v0,v1,1001
711c: 10400006 beqz v0,7138 <e1000_ethtool_ioctl+0x360>
7120: 240203e9 li v0,1001
7124: 24020065 li v0,101
7128: 1062000e beq v1,v0,7164 <e1000_ethtool_ioctl+0x38c>
712c: 24030001 li v1,1
7130: 08001c6a j 71a8 <e1000_ethtool_ioctl+0x3d0>
7134: 24020020 li v0,32
7138: 10620013 beq v1,v0,7188 <e1000_ethtool_ioctl+0x3b0>
713c: 24030001 li v1,1
7140: 08001c6a j 71a8 <e1000_ethtool_ioctl+0x3d0>
7144: 24020020 li v0,32
case (SPEED_10 + DUPLEX_HALF):
adapter->shared.forced_speed_duplex = e1000_10_half;
break;
7148: 08001c6c j 71b0 <e1000_ethtool_ioctl+0x3d8>
714c: a240007a sb zero,122(s2)
case (SPEED_100 + DUPLEX_HALF):
adapter->shared.forced_speed_duplex = e1000_100_half;
7150: 24020002 li v0,2
break;
7154: 08001c6c j 71b0 <e1000_ethtool_ioctl+0x3d8>
7158: a242007a sb v0,122(s2)
case (SPEED_10 + DUPLEX_FULL):
adapter->shared.forced_speed_duplex = e1000_10_full;
break;
715c: 08001c6c j 71b0 <e1000_ethtool_ioctl+0x3d8>
7160: a251007a sb s1,122(s2)
case (SPEED_100 + DUPLEX_FULL):
adapter->shared.forced_speed_duplex = e1000_100_full;
7164: 24020003 li v0,3
break;
7168: 08001c6c j 71b0 <e1000_ethtool_ioctl+0x3d8>
716c: a242007a sb v0,122(s2)
case (SPEED_1000 + DUPLEX_HALF):
printk("Half Duplex is not supported at 1000 Mbps\n");
7170: 3c040000 lui a0,0x0
7174: 24840e80 addiu a0,a0,3712
7178: 3c020000 lui v0,0x0
717c: 24420000 addiu v0,v0,0
7180: 0040f809 jalr v0
7184: 00000000 nop
case (SPEED_1000 + DUPLEX_FULL):
printk("Using Auto-neg at 1000 Mbps Full Duplex\n");
7188: 3c040000 lui a0,0x0
718c: 24840eac addiu a0,a0,3756
7190: 3c020000 lui v0,0x0
7194: 24420000 addiu v0,v0,0
7198: 0040f809 jalr v0
719c: 00000000 nop
default:
adapter->shared.autoneg = 1;
71a0: 24030001 li v1,1
adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL;
71a4: 24020020 li v0,32
71a8: a6420048 sh v0,72(s2)
71ac: a2430078 sb v1,120(s2)
break;
}
}
/* End of force */
/* Put the adapter to new settings */
if(re_initiate == TRUE) {
71b0: 24020001 li v0,1
71b4: 56220005 bnel s1,v0,71cc <e1000_ethtool_ioctl+0x3f4>
71b8: 93a20022 lbu v0,34(sp)
e1000_hibernate_adapter(netdev);
71bc: 3c020000 lui v0,0x0
71c0: 24420000 addiu v0,v0,0
e1000_wakeup_adapter(netdev);
} else if(!eth_cmd.autoneg && !eth_cmd.speed) {
71c4: 08001c96 j 7258 <e1000_ethtool_ioctl+0x480>
71c8: 02a02021 move a0,s5
71cc: 1440007e bnez v0,73c8 <e1000_ethtool_ioctl+0x5f0>
71d0: 2402ff86 li v0,-122
71d4: 97a2001c lhu v0,28(sp)
71d8: 5440007b bnezl v0,73c8 <e1000_ethtool_ioctl+0x5f0>
71dc: 2402ff86 li v0,-122
printk("Cannot turn off autoneg without "
71e0: 3c040000 lui a0,0x0
71e4: 24840ed8 addiu a0,a0,3800
71e8: 3c100000 lui s0,0x0
71ec: 26100000 addiu s0,s0,0
71f0: 0200f809 jalr s0
71f4: 00000000 nop
"knowing what speed to force the link\n");
printk("Speed specified was %dMbps\n", eth_cmd.speed);
71f8: 3c040000 lui a0,0x0
71fc: 24840f20 addiu a0,a0,3872
7200: 0200f809 jalr s0
7204: 97a5001c lhu a1,28(sp)
return -EINVAL;
7208: 08001cf2 j 73c8 <e1000_ethtool_ioctl+0x5f0>
720c: 2402ffea li v0,-22
static inline int capable(int cap)
{
#if 1 /* ok now */
if (cap_raised(current->cap_effective, cap))
7210: 8f8201d4 lw v0,468(gp)
7214: 30421000 andi v0,v0,0x1000
7218: 10400005 beqz v0,7230 <e1000_ethtool_ioctl+0x458>
721c: 24030001 li v1,1
#else
if (cap_is_fs_cap(cap) ? current->fsuid == 0 : current->euid == 0)
#endif
{
current->flags |= PF_SUPERPRIV;
7220: 8f820004 lw v0,4(gp)
7224: 34420100 ori v0,v0,0x100
return 1;
7228: 08001c8d j 7234 <e1000_ethtool_ioctl+0x45c>
722c: af820004 sw v0,4(gp)
}
return 0;
7230: 00001821 move v1,zero
}
/* We donot support setting of
* whatever else that was requested */
else
return -EOPNOTSUPP;
break;
#ifdef ETHTOOL_NWAY_RST
case ETHTOOL_NWAY_RST:
/* need proper permission to restart auto-negotiation */
if(!capable(CAP_NET_ADMIN))
7234: 10600064 beqz v1,73c8 <e1000_ethtool_ioctl+0x5f0>
7238: 2402ffff li v0,-1
return -EPERM;
adapter->shared.autoneg = 1;
723c: 24030001 li v1,1
adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
7240: 2402002f li v0,47
7244: a6420048 sh v0,72(s2)
e1000_hibernate_adapter(netdev);
7248: 02a02021 move a0,s5
724c: 3c020000 lui v0,0x0
7250: 24420000 addiu v0,v0,0
7254: a2430078 sb v1,120(s2)
7258: 0040f809 jalr v0
725c: 00000000 nop
e1000_wakeup_adapter(netdev);
7260: 3c020000 lui v0,0x0
7264: 24420000 addiu v0,v0,0
7268: 0040f809 jalr v0
726c: 02a02021 move a0,s5
break;
7270: 08001cf2 j 73c8 <e1000_ethtool_ioctl+0x5f0>
7274: 00001021 move v0,zero
#endif
#ifdef ETHTOOL_GLINK
case ETHTOOL_GLINK:
eth_e1000_linkinfo.data = adapter->link_active;
7278: 8e4200b0 lw v0,176(s2)
if(copy_to_user(ifr->ifr_data, ð_e1000_linkinfo, sizeof(eth_e1000_linkinfo)))
727c: 8e640010 lw a0,16(s3)
7280: 27a50040 addiu a1,sp,64
7284: afa20044 sw v0,68(sp)
7288: 8f8303bc lw v1,956(gp)
728c: 24820008 addiu v0,a0,8
7290: 00821025 or v0,a0,v0
7294: 00621824 and v1,v1,v0
7298: 04600044 bltz v1,73ac <e1000_ethtool_ioctl+0x5d4>
729c: 24060008 li a2,8
72a0: 3c010000 lui at,0x0
72a4: 24210000 addiu at,at,0
72a8: 0020f809 jalr at
72ac: 00000000 nop
return -EFAULT;
72b0: 08001ceb j 73ac <e1000_ethtool_ioctl+0x5d4>
72b4: 00000000 nop
break;
#endif
#ifdef ETHTOOL_GDRVINFO
case ETHTOOL_GDRVINFO:
strcpy(eth_e1000_info.driver, e1000_driver_name);
72b8: 27a3004c addiu v1,sp,76
72bc: 3c020000 lui v0,0x0
72c0: 24420000 addiu v0,v0,0
extern __inline__ char *strcpy(char *__dest, __const__ char *__src)
{
char *__xdest = __dest;
__asm__ __volatile__(
72c4: 90410000 lbu at,0(v0)
72c8: 24420001 addiu v0,v0,1
72cc: a0610000 sb at,0(v1)
72d0: 1420fffc bnez at,72c4 <e1000_ethtool_ioctl+0x4ec>
72d4: 24630001 addiu v1,v1,1
strcpy(eth_e1000_info.version, e1000_driver_version);
72d8: 27a4006c addiu a0,sp,108
72dc: 3c020000 lui v0,0x0
72e0: 24420000 addiu v0,v0,0
extern __inline__ char *strcpy(char *__dest, __const__ char *__src)
{
char *__xdest = __dest;
__asm__ __volatile__(
72e4: 90410000 lbu at,0(v0)
72e8: 24420001 addiu v0,v0,1
72ec: a0810000 sb at,0(a0)
72f0: 1420fffc bnez at,72e4 <e1000_ethtool_ioctl+0x50c>
72f4: 24840001 addiu a0,a0,1
strcpy(eth_e1000_info.fw_version, "None");
72f8: 27a3008c addiu v1,sp,140
72fc: 3c020000 lui v0,0x0
7300: 24420f3c addiu v0,v0,3900
extern __inline__ char *strcpy(char *__dest, __const__ char *__src)
{
char *__xdest = __dest;
__asm__ __volatile__(
7304: 90410000 lbu at,0(v0)
7308: 24420001 addiu v0,v0,1
730c: a0610000 sb at,0(v1)
7310: 1420fffc bnez at,7304 <e1000_ethtool_ioctl+0x52c>
7314: 24630001 addiu v1,v1,1
strcpy(eth_e1000_info.bus_info, adapter->pdev->slot_name);
7318: 8e44014c lw a0,332(s2)
731c: 27a200ac addiu v0,sp,172
7320: 24840270 addiu a0,a0,624
extern __inline__ char *strcpy(char *__dest, __const__ char *__src)
{
char *__xdest = __dest;
__asm__ __volatile__(
7324: 90810000 lbu at,0(a0)
7328: 24840001 addiu a0,a0,1
732c: a0410000 sb at,0(v0)
7330: 1420fffc bnez at,7324 <e1000_ethtool_ioctl+0x54c>
7334: 24420001 addiu v0,v0,1
if(copy_to_user(ifr->ifr_data, ð_e1000_info, sizeof(eth_e1000_info)))
7338: 8e640010 lw a0,16(s3)
733c: 8f8303bc lw v1,956(gp)
7340: 27a50048 addiu a1,sp,72
7344: 248200c4 addiu v0,a0,196
7348: 00821025 or v0,a0,v0
734c: 00621824 and v1,v1,v0
7350: 04600016 bltz v1,73ac <e1000_ethtool_ioctl+0x5d4>
7354: 240600c4 li a2,196
7358: 3c010000 lui at,0x0
735c: 24210000 addiu at,at,0
7360: 0020f809 jalr at
7364: 00000000 nop
return -EFAULT;
7368: 08001ceb j 73ac <e1000_ethtool_ioctl+0x5d4>
736c: 00000000 nop
break;
#endif
#ifdef ETHTOOL_GWOL
case ETHTOOL_GWOL:
eth_e1000_wolinfo.supported = eth_e1000_wolinfo.wolopts = WAKE_MAGIC;
if(copy_to_user
7370: 8e640010 lw a0,16(s3)
7374: 24020020 li v0,32
7378: afa20114 sw v0,276(sp)
737c: afa20118 sw v0,280(sp)
7380: 8f8303bc lw v1,956(gp)
7384: 24820014 addiu v0,a0,20
7388: 00821025 or v0,a0,v0
738c: 00621824 and v1,v1,v0
7390: 27a50110 addiu a1,sp,272
7394: 04600005 bltz v1,73ac <e1000_ethtool_ioctl+0x5d4>
7398: 24060014 li a2,20
739c: 3c010000 lui at,0x0
73a0: 24210000 addiu at,at,0
73a4: 0020f809 jalr at
73a8: 00000000 nop
73ac: 10c00005 beqz a2,73c4 <e1000_ethtool_ioctl+0x5ec>
73b0: 2402fff2 li v0,-14
(ifr->ifr_data, ð_e1000_wolinfo, sizeof(eth_e1000_wolinfo)))
return -EFAULT;
73b4: 08001cf3 j 73cc <e1000_ethtool_ioctl+0x5f4>
73b8: 8fbf0140 lw ra,320(sp)
break;
#endif
default:
return -EOPNOTSUPP;
73bc: 08001cf2 j 73c8 <e1000_ethtool_ioctl+0x5f0>
73c0: 2402ff86 li v0,-122
}
return 0;
73c4: 00001021 move v0,zero
}
73c8: 8fbf0140 lw ra,320(sp)
73cc: 8fb5013c lw s5,316(sp)
73d0: 8fb40138 lw s4,312(sp)
73d4: 8fb30134 lw s3,308(sp)
73d8: 8fb20130 lw s2,304(sp)
73dc: 8fb1012c lw s1,300(sp)
73e0: 8fb00128 lw s0,296(sp)
73e4: 03e00008 jr ra
73e8: 27bd0148 addiu sp,sp,328
000073ec <e1000_enable_WOL>:
73ec: 00804021 move t0,a0
#endif /* SIOCETHTOOL */
/**
* e1000_enable_WOL - Wake On Lan Support (Magic Pkt)
* @adapter: Adapter structure
**/
static void
e1000_enable_WOL(struct e1000_adapter *adapter)
{
uint32_t wuc_val;
if(adapter->shared.mac_type <= e1000_82543)
73f0: 8d06000c lw a2,12(t0)
73f4: 2cc20003 sltiu v0,a2,3
73f8: 1440001f bnez v0,7478 <e1000_enable_WOL+0x8c>
73fc: 2cc20002 sltiu v0,a2,2
return;
/* Set up Wake-Up Ctrl reg */
wuc_val = E1000_READ_REG(&adapter->shared, WUC);
7400: 8d070008 lw a3,8(t0)
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
7404: 8ce55800 lw a1,22528(a3)
return __arch__swab32(x);
7408: 30a3ff00 andi v1,a1,0xff00
740c: 00052600 sll a0,a1,0x18
7410: 00051202 srl v0,a1,0x8
7414: 00031a00 sll v1,v1,0x8
7418: 00832025 or a0,a0,v1
741c: 3042ff00 andi v0,v0,0xff00
7420: 00822025 or a0,a0,v0
7424: 00052e02 srl a1,a1,0x18
7428: 00852825 or a1,a0,a1
wuc_val &= ~(E1000_WUC_APME | E1000_WUC_APMPME);
742c: 2402fff6 li v0,-10
7430: 00a22824 and a1,a1,v0
wuc_val |= (E1000_WUC_PME_STATUS | E1000_WUC_PME_EN);
7434: 2cc30002 sltiu v1,a2,2
7438: 34a50006 ori a1,a1,0x6
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
743c: 30a4ff00 andi a0,a1,0xff00
7440: 00042200 sll a0,a0,0x8
7444: 00051600 sll v0,a1,0x18
7448: 00051a02 srl v1,a1,0x8
744c: 00441025 or v0,v0,a0
7450: 3063ff00 andi v1,v1,0xff00
7454: 00431025 or v0,v0,v1
7458: 00052602 srl a0,a1,0x18
745c: 00441025 or v0,v0,a0
E1000_WRITE_REG(&adapter->shared, WUC, wuc_val);
7460: ace25800 sw v0,22528(a3)
7464: 8d02000c lw v0,12(t0)
7468: 2c420002 sltiu v0,v0,2
/* Set up Wake-up Filter */
E1000_WRITE_REG(&adapter->shared, WUFC, E1000_WUFC_MAG);
return;
}
746c: 8d030008 lw v1,8(t0)
7470: 3c020200 lui v0,0x200
7474: ac625808 sw v0,22536(v1)
7478: 03e00008 jr ra
747c: 00000000 nop
00007480 <e1000_write_pci_cfg>:
7480: 27bdffe8 addiu sp,sp,-24
7484: afbf0010 sw ra,16(sp)
/**
* e1000_write_pci_cg -
* @shared:
* @reg:
* @value:
**/
void
e1000_write_pci_cfg(struct e1000_shared_adapter *shared,
uint32_t reg,
uint16_t *value)
{
struct e1000_adapter *adapter = (struct e1000_adapter *) shared->back;
7488: 8c82000c lw v0,12(a0)
pci_write_config_word(adapter->pdev, reg, *value);
748c: 8c44014c lw a0,332(v0)
7490: 3c020000 lui v0,0x0
7494: 24420000 addiu v0,v0,0
7498: 0040f809 jalr v0
749c: 94c60000 lhu a2,0(a2)
return;
}
74a0: 8fbf0010 lw ra,16(sp)
74a4: 03e00008 jr ra
74a8: 27bd0018 addiu sp,sp,24
000074ac <e1000_irq_enable>:
74ac: 8c82000c lw v0,12(a0)
74b0: 2c420002 sltiu v0,v0,2
__arch__swab16s(addr);
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
74b4: 8c8500cc lw a1,204(a0)
74b8: 8c860008 lw a2,8(a0)
}
static __inline__ __const__ __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
74bc: 30a4ff00 andi a0,a1,0xff00
74c0: 00051600 sll v0,a1,0x18
74c4: 00051a02 srl v1,a1,0x8
74c8: 00042200 sll a0,a0,0x8
74cc: 00441025 or v0,v0,a0
74d0: 3063ff00 andi v1,v1,0xff00
74d4: 00431025 or v0,v0,v1
74d8: 00052e02 srl a1,a1,0x18
74dc: 00451025 or v0,v0,a1
74e0: acc200d0 sw v0,208(a2)
74e4: 03e00008 jr ra
74e8: 00000000 nop
000074ec <e1000_rx_checksum>:
74ec: 00803821 move a3,a0
74f0: 8ce2000c lw v0,12(a3)
74f4: 2c420002 sltiu v0,v0,2
74f8: 14400006 bnez v0,7514 <e1000_rx_checksum+0x28>
74fc: 3c042000 lui a0,0x2000
7500: 8ca2000c lw v0,12(a1)
7504: 3c032400 lui v1,0x2400
7508: 00431024 and v0,v0,v1
750c: 50440003 beql v0,a0,751c <e1000_rx_checksum+0x30>
7510: 90a2000d lbu v0,13(a1)
7514: 03e00008 jr ra
7518: a0c0006b sb zero,107(a2)
751c: 30420020 andi v0,v0,0x20
7520: 1040000b beqz v0,7550 <e1000_rx_checksum+0x64>
7524: 24020002 li v0,2
7528: a0c0006b sb zero,107(a2)
752c: 8ce20140 lw v0,320(a3)
7530: 8ce30144 lw v1,324(a3)
7534: 24630001 addiu v1,v1,1
7538: 2c640001 sltiu a0,v1,1
753c: 00441021 addu v0,v0,a0
7540: ace20140 sw v0,320(a3)
7544: ace30144 sw v1,324(a3)
7548: 03e00008 jr ra
754c: 00000000 nop
7550: a0c2006b sb v0,107(a2)
7554: 8ce40138 lw a0,312(a3)
7558: 8ce5013c lw a1,316(a3)
755c: 24a50001 addiu a1,a1,1
7560: 2ca20001 sltiu v0,a1,1
7564: 00822021 addu a0,a0,v0
7568: ace40138 sw a0,312(a3)
756c: ace5013c sw a1,316(a3)
7570: 03e00008 jr ra
...
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: Is this a toolchain bug?
2002-02-23 1:57 Is this a toolchain bug? Matthew Dharm
@ 2002-02-24 2:06 ` Daniel Jacobowitz
2002-02-25 2:30 ` Matthew Dharm
2002-02-25 18:36 ` Kevin Paul Herbert
1 sibling, 1 reply; 10+ messages in thread
From: Daniel Jacobowitz @ 2002-02-24 2:06 UTC (permalink / raw)
To: Matthew Dharm; +Cc: Linux-MIPS
On Fri, Feb 22, 2002 at 05:57:08PM -0800, Matthew Dharm wrote:
> If this is user-error, I'd love to know what I'm doing wrong. If this
> is a toolchain bug, who do I report this to?
User error, at least what you've described. Add the -r flag to the
objdump command line, or look at a statically linked object.
--
Daniel Jacobowitz Carnegie Mellon University
MontaVista Software Debian GNU/Linux Developer
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: Is this a toolchain bug?
2002-02-24 2:06 ` Daniel Jacobowitz
@ 2002-02-25 2:30 ` Matthew Dharm
0 siblings, 0 replies; 10+ messages in thread
From: Matthew Dharm @ 2002-02-25 2:30 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: Linux-MIPS
Okay, so I added that flag, and it actually seems to be correct.
But, the question remains, why does accessing that variable cause a
problem? I'm going to do some more digging when I'm in the office
tomorrow, but one of the tests I already did was to put
e1000_proc_dev = NULL;
at one point in the code. That line caused a crash with what looked like a
NULL-ptr dereference.
I'm going to re-examine this tomorrow, but I'm wondering if any of the
people on this list that are using this driver have CONFIG_PROC_FS turned
on.
Matt
On Sat, Feb 23, 2002 at 09:06:08PM -0500, Daniel Jacobowitz wrote:
> On Fri, Feb 22, 2002 at 05:57:08PM -0800, Matthew Dharm wrote:
> > If this is user-error, I'd love to know what I'm doing wrong. If this
> > is a toolchain bug, who do I report this to?
>
> User error, at least what you've described. Add the -r flag to the
> objdump command line, or look at a statically linked object.
>
> --
> Daniel Jacobowitz Carnegie Mellon University
> MontaVista Software Debian GNU/Linux Developer
--
Matthew Dharm Work: mdharm@momenco.com
Senior Software Designer, Momentum Computer
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: Is this a toolchain bug?
2002-02-23 1:57 Is this a toolchain bug? Matthew Dharm
2002-02-24 2:06 ` Daniel Jacobowitz
@ 2002-02-25 18:36 ` Kevin Paul Herbert
2002-02-25 19:54 ` Matthew Dharm
2002-02-25 20:30 ` Matthew Dharm
1 sibling, 2 replies; 10+ messages in thread
From: Kevin Paul Herbert @ 2002-02-25 18:36 UTC (permalink / raw)
To: Matthew Dharm, Linux-MIPS
At 5:57 PM -0800 2/22/02, Matthew Dharm wrote:
>
>The toolchain I'm using is the one from oss.sgi.com by H.J. Liu
>(toolchain-20011020-1). Because of the way the e1000 driver Makefile
>works, I'm actually compiling it using the native compiler on-target.
I just tossed out most of intel's makefile so that I could build it
as part of our cross-build (hosted on RedHat i386), building it as a
module. When I was using the 3.0 driver, I hacked it to be built with
the kernel (not a module at all). It was just a few minutes of
makefile hacking, and may save you some grief.
There is a driver V4.0.7? I *just* picked up 3.5 a little while
ago... can you point me at where on intel's website you got your
driver?
Thanks,
Kevin
--
^ permalink raw reply [flat|nested] 10+ messages in thread
* RE: Is this a toolchain bug?
2002-02-25 18:36 ` Kevin Paul Herbert
@ 2002-02-25 19:54 ` Matthew Dharm
2002-02-25 20:30 ` Matthew Dharm
1 sibling, 0 replies; 10+ messages in thread
From: Matthew Dharm @ 2002-02-25 19:54 UTC (permalink / raw)
To: Kevin Paul Herbert, Linux-MIPS
Umm...
http://downloadfinder2.intel.com/scripts-df/filter_results.asp?strOSs=
39&strTypes=DRV%2CUTL&ProductID=415&OSFullName=Linux*&submit=Go%21
Or, click support -> downloads -> enter 82543 as the product, and then
follow the links from there.
Matt
--
Matthew D. Dharm Senior Software Designer
Momentum Computer Inc. 1815 Aston Ave. Suite 107
(760) 431-8663 X-115 Carlsbad, CA 92008-7310
Momentum Works For You www.momenco.com
> -----Original Message-----
> From: owner-linux-mips@oss.sgi.com
> [mailto:owner-linux-mips@oss.sgi.com]On Behalf Of Kevin Paul Herbert
> Sent: Monday, February 25, 2002 10:36 AM
> To: Matthew Dharm; Linux-MIPS
> Subject: Re: Is this a toolchain bug?
>
>
> At 5:57 PM -0800 2/22/02, Matthew Dharm wrote:
> >
> >The toolchain I'm using is the one from oss.sgi.com by H.J. Liu
> >(toolchain-20011020-1). Because of the way the e1000
> driver Makefile
> >works, I'm actually compiling it using the native compiler
> on-target.
> I just tossed out most of intel's makefile so that I could build it
> as part of our cross-build (hosted on RedHat i386),
> building it as a
> module. When I was using the 3.0 driver, I hacked it to be
> built with
> the kernel (not a module at all). It was just a few minutes of
> makefile hacking, and may save you some grief.
>
> There is a driver V4.0.7? I *just* picked up 3.5 a little while
> ago... can you point me at where on intel's website you got your
> driver?
>
> Thanks,
> Kevin
> --
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* RE: Is this a toolchain bug?
2002-02-25 18:36 ` Kevin Paul Herbert
2002-02-25 19:54 ` Matthew Dharm
@ 2002-02-25 20:30 ` Matthew Dharm
2002-02-26 1:13 ` Daniel Jacobowitz
2002-02-26 10:31 ` Tommy S. Christensen
1 sibling, 2 replies; 10+ messages in thread
From: Matthew Dharm @ 2002-02-25 20:30 UTC (permalink / raw)
To: Kevin Paul Herbert, Linux-MIPS
Well, that fixes it. The driver works out-of-the-box with just some
minor makefile modifications.
So, we've got a problem somewhere in the module handling. Either the
symbol wasn't being relocated properly, or it wasn't being allocated
properly, or something. I'm not an expert in this region of the
kernel, but my guess is that we're going to see this more and more
often, so someone with a clue should take a look at this.
I'm more than willing to help, as I seem to be the only person with a
100% reproducable situation. But I really have no idea even where to
begin looking... my expertise ends right about at objdump, and even
then I'm not certain how some of that data should look for loadable
modules.
Matt
--
Matthew D. Dharm Senior Software Designer
Momentum Computer Inc. 1815 Aston Ave. Suite 107
(760) 431-8663 X-115 Carlsbad, CA 92008-7310
Momentum Works For You www.momenco.com
> -----Original Message-----
> From: owner-linux-mips@oss.sgi.com
> [mailto:owner-linux-mips@oss.sgi.com]On Behalf Of Kevin Paul Herbert
> Sent: Monday, February 25, 2002 10:36 AM
> To: Matthew Dharm; Linux-MIPS
> Subject: Re: Is this a toolchain bug?
>
>
> At 5:57 PM -0800 2/22/02, Matthew Dharm wrote:
> >
> >The toolchain I'm using is the one from oss.sgi.com by H.J. Liu
> >(toolchain-20011020-1). Because of the way the e1000
> driver Makefile
> >works, I'm actually compiling it using the native compiler
> on-target.
> I just tossed out most of intel's makefile so that I could build it
> as part of our cross-build (hosted on RedHat i386),
> building it as a
> module. When I was using the 3.0 driver, I hacked it to be
> built with
> the kernel (not a module at all). It was just a few minutes of
> makefile hacking, and may save you some grief.
>
> There is a driver V4.0.7? I *just* picked up 3.5 a little while
> ago... can you point me at where on intel's website you got your
> driver?
>
> Thanks,
> Kevin
> --
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: Is this a toolchain bug?
2002-02-25 20:30 ` Matthew Dharm
@ 2002-02-26 1:13 ` Daniel Jacobowitz
2002-02-26 1:18 ` Matthew Dharm
2002-02-26 10:31 ` Tommy S. Christensen
1 sibling, 1 reply; 10+ messages in thread
From: Daniel Jacobowitz @ 2002-02-26 1:13 UTC (permalink / raw)
To: Matthew Dharm; +Cc: Kevin Paul Herbert, Linux-MIPS
On Mon, Feb 25, 2002 at 12:30:38PM -0800, Matthew Dharm wrote:
> Well, that fixes it. The driver works out-of-the-box with just some
> minor makefile modifications.
>
> So, we've got a problem somewhere in the module handling. Either the
> symbol wasn't being relocated properly, or it wasn't being allocated
> properly, or something. I'm not an expert in this region of the
> kernel, but my guess is that we're going to see this more and more
> often, so someone with a clue should take a look at this.
>
> I'm more than willing to help, as I seem to be the only person with a
> 100% reproducable situation. But I really have no idea even where to
> begin looking... my expertise ends right about at objdump, and even
> then I'm not certain how some of that data should look for loadable
> modules.
Silly question... was the module built with the correct flags? Look at
a command line; does it have all the same options as when you build a
module in the kernel source?
I bet something's missing. Probably -G 0...
--
Daniel Jacobowitz Carnegie Mellon University
MontaVista Software Debian GNU/Linux Developer
^ permalink raw reply [flat|nested] 10+ messages in thread
* RE: Is this a toolchain bug?
2002-02-26 1:13 ` Daniel Jacobowitz
@ 2002-02-26 1:18 ` Matthew Dharm
0 siblings, 0 replies; 10+ messages in thread
From: Matthew Dharm @ 2002-02-26 1:18 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: Kevin Paul Herbert, Linux-MIPS
Got the -G 0....
Honestly, I'm pretty sure it was compiled with the right flags. They
match the flags I'm using to build the kernel, at least as far as I
can see.
Matt
--
Matthew D. Dharm Senior Software Designer
Momentum Computer Inc. 1815 Aston Ave. Suite 107
(760) 431-8663 X-115 Carlsbad, CA 92008-7310
Momentum Works For You www.momenco.com
> -----Original Message-----
> From: Daniel Jacobowitz [mailto:dan@debian.org]
> Sent: Monday, February 25, 2002 5:13 PM
> To: Matthew Dharm
> Cc: Kevin Paul Herbert; Linux-MIPS
> Subject: Re: Is this a toolchain bug?
>
>
> On Mon, Feb 25, 2002 at 12:30:38PM -0800, Matthew Dharm wrote:
> > Well, that fixes it. The driver works out-of-the-box
> with just some
> > minor makefile modifications.
> >
> > So, we've got a problem somewhere in the module handling.
> Either the
> > symbol wasn't being relocated properly, or it wasn't
> being allocated
> > properly, or something. I'm not an expert in this region of the
> > kernel, but my guess is that we're going to see this more and more
> > often, so someone with a clue should take a look at this.
> >
> > I'm more than willing to help, as I seem to be the only
> person with a
> > 100% reproducable situation. But I really have no idea
> even where to
> > begin looking... my expertise ends right about at
> objdump, and even
> > then I'm not certain how some of that data should look
> for loadable
> > modules.
>
> Silly question... was the module built with the correct
> flags? Look at
> a command line; does it have all the same options as when
> you build a
> module in the kernel source?
>
> I bet something's missing. Probably -G 0...
>
> --
> Daniel Jacobowitz Carnegie Mellon
> University
> MontaVista Software Debian
> GNU/Linux Developer
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: Is this a toolchain bug?
2002-02-25 20:30 ` Matthew Dharm
2002-02-26 1:13 ` Daniel Jacobowitz
@ 2002-02-26 10:31 ` Tommy S. Christensen
2002-02-26 20:29 ` Matthew Dharm
1 sibling, 1 reply; 10+ messages in thread
From: Tommy S. Christensen @ 2002-02-26 10:31 UTC (permalink / raw)
To: Matthew Dharm; +Cc: Kevin Paul Herbert, Linux-MIPS
Matthew Dharm wrote:
>
> So, we've got a problem somewhere in the module handling. Either the
> symbol wasn't being relocated properly, or it wasn't being allocated
> properly, or something. I'm not an expert in this region of the
> kernel, but my guess is that we're going to see this more and more
> often, so someone with a clue should take a look at this.
To me, this looks like a problem with common symbols that I have run
into a couple of times (I think it was in i2o).
Compiling with -fno-common or linking with -d worked for me.
(Or avoid having uninitialized global variables.)
I guess insmod should actually complain in this case ?!
-Tommy
^ permalink raw reply [flat|nested] 10+ messages in thread
* RE: Is this a toolchain bug?
2002-02-26 10:31 ` Tommy S. Christensen
@ 2002-02-26 20:29 ` Matthew Dharm
0 siblings, 0 replies; 10+ messages in thread
From: Matthew Dharm @ 2002-02-26 20:29 UTC (permalink / raw)
To: Tommy S. Christensen; +Cc: Kevin Paul Herbert, Linux-MIPS
Either insmod or depmod should complain if it can detect a scenario
like this.
Matt
--
Matthew D. Dharm Senior Software Designer
Momentum Computer Inc. 1815 Aston Ave. Suite 107
(760) 431-8663 X-115 Carlsbad, CA 92008-7310
Momentum Works For You www.momenco.com
> -----Original Message-----
> From: owner-linux-mips@oss.sgi.com
> [mailto:owner-linux-mips@oss.sgi.com]On Behalf Of Tommy S.
> Christensen
> Sent: Tuesday, February 26, 2002 2:31 AM
> To: Matthew Dharm
> Cc: Kevin Paul Herbert; Linux-MIPS
> Subject: Re: Is this a toolchain bug?
>
>
> Matthew Dharm wrote:
> >
> > So, we've got a problem somewhere in the module handling.
> Either the
> > symbol wasn't being relocated properly, or it wasn't
> being allocated
> > properly, or something. I'm not an expert in this region of the
> > kernel, but my guess is that we're going to see this more and more
> > often, so someone with a clue should take a look at this.
>
> To me, this looks like a problem with common symbols that I have run
> into a couple of times (I think it was in i2o).
>
> Compiling with -fno-common or linking with -d worked for me.
> (Or avoid having uninitialized global variables.)
>
> I guess insmod should actually complain in this case ?!
>
> -Tommy
>
^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2002-02-26 21:30 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2002-02-23 1:57 Is this a toolchain bug? Matthew Dharm
2002-02-24 2:06 ` Daniel Jacobowitz
2002-02-25 2:30 ` Matthew Dharm
2002-02-25 18:36 ` Kevin Paul Herbert
2002-02-25 19:54 ` Matthew Dharm
2002-02-25 20:30 ` Matthew Dharm
2002-02-26 1:13 ` Daniel Jacobowitz
2002-02-26 1:18 ` Matthew Dharm
2002-02-26 10:31 ` Tommy S. Christensen
2002-02-26 20:29 ` Matthew Dharm
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox