diff options
Diffstat (limited to 'drivers')
129 files changed, 12310 insertions, 7055 deletions
diff --git a/drivers/Kconfig b/drivers/Kconfig index aeb5ab2391e4..8b11cebe65df 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig | |||
@@ -72,4 +72,6 @@ source "drivers/edac/Kconfig" | |||
72 | 72 | ||
73 | source "drivers/rtc/Kconfig" | 73 | source "drivers/rtc/Kconfig" |
74 | 74 | ||
75 | source "drivers/dma/Kconfig" | ||
76 | |||
75 | endmenu | 77 | endmenu |
diff --git a/drivers/Makefile b/drivers/Makefile index 447d8e68887a..3c5170310bd0 100644 --- a/drivers/Makefile +++ b/drivers/Makefile | |||
@@ -74,3 +74,4 @@ obj-$(CONFIG_SGI_SN) += sn/ | |||
74 | obj-y += firmware/ | 74 | obj-y += firmware/ |
75 | obj-$(CONFIG_CRYPTO) += crypto/ | 75 | obj-$(CONFIG_CRYPTO) += crypto/ |
76 | obj-$(CONFIG_SUPERH) += sh/ | 76 | obj-$(CONFIG_SUPERH) += sh/ |
77 | obj-$(CONFIG_DMA_ENGINE) += dma/ | ||
diff --git a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c index 07bc6dfe662b..8920e8c6e246 100644 --- a/drivers/acpi/pci_link.c +++ b/drivers/acpi/pci_link.c | |||
@@ -812,6 +812,9 @@ static int irqrouter_resume(struct sys_device *dev) | |||
812 | 812 | ||
813 | ACPI_FUNCTION_TRACE("irqrouter_resume"); | 813 | ACPI_FUNCTION_TRACE("irqrouter_resume"); |
814 | 814 | ||
815 | /* Make sure SCI is enabled again (Apple firmware bug?) */ | ||
816 | acpi_set_register(ACPI_BITREG_SCI_ENABLE, 1, ACPI_MTX_DO_NOT_LOCK); | ||
817 | |||
815 | acpi_in_resume = 1; | 818 | acpi_in_resume = 1; |
816 | list_for_each(node, &acpi_link.entries) { | 819 | list_for_each(node, &acpi_link.entries) { |
817 | link = list_entry(node, struct acpi_pci_link, node); | 820 | link = list_entry(node, struct acpi_pci_link, node); |
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c index abbdb37a7f5f..f36db22ce1ae 100644 --- a/drivers/acpi/processor_perflib.c +++ b/drivers/acpi/processor_perflib.c | |||
@@ -577,6 +577,8 @@ acpi_processor_register_performance(struct acpi_processor_performance | |||
577 | return_VALUE(-EBUSY); | 577 | return_VALUE(-EBUSY); |
578 | } | 578 | } |
579 | 579 | ||
580 | WARN_ON(!performance); | ||
581 | |||
580 | pr->performance = performance; | 582 | pr->performance = performance; |
581 | 583 | ||
582 | if (acpi_processor_get_performance_info(pr)) { | 584 | if (acpi_processor_get_performance_info(pr)) { |
@@ -609,7 +611,8 @@ acpi_processor_unregister_performance(struct acpi_processor_performance | |||
609 | return_VOID; | 611 | return_VOID; |
610 | } | 612 | } |
611 | 613 | ||
612 | kfree(pr->performance->states); | 614 | if (pr->performance) |
615 | kfree(pr->performance->states); | ||
613 | pr->performance = NULL; | 616 | pr->performance = NULL; |
614 | 617 | ||
615 | acpi_cpufreq_remove_file(pr); | 618 | acpi_cpufreq_remove_file(pr); |
diff --git a/drivers/block/aoe/aoenet.c b/drivers/block/aoe/aoenet.c index fdff774b8ab9..c1434ed11880 100644 --- a/drivers/block/aoe/aoenet.c +++ b/drivers/block/aoe/aoenet.c | |||
@@ -116,8 +116,7 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt, | |||
116 | skb = skb_share_check(skb, GFP_ATOMIC); | 116 | skb = skb_share_check(skb, GFP_ATOMIC); |
117 | if (skb == NULL) | 117 | if (skb == NULL) |
118 | return 0; | 118 | return 0; |
119 | if (skb_is_nonlinear(skb)) | 119 | if (skb_linearize(skb)) |
120 | if (skb_linearize(skb, GFP_ATOMIC) < 0) | ||
121 | goto exit; | 120 | goto exit; |
122 | if (!is_aoe_netif(ifp)) | 121 | if (!is_aoe_netif(ifp)) |
123 | goto exit; | 122 | goto exit; |
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c index a59876a0bfa1..3170eaa25087 100644 --- a/drivers/cdrom/cdrom.c +++ b/drivers/cdrom/cdrom.c | |||
@@ -1009,9 +1009,9 @@ int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip, struct file *fp) | |||
1009 | if (fp->f_mode & FMODE_WRITE) { | 1009 | if (fp->f_mode & FMODE_WRITE) { |
1010 | ret = -EROFS; | 1010 | ret = -EROFS; |
1011 | if (cdrom_open_write(cdi)) | 1011 | if (cdrom_open_write(cdi)) |
1012 | goto err; | 1012 | goto err_release; |
1013 | if (!CDROM_CAN(CDC_RAM)) | 1013 | if (!CDROM_CAN(CDC_RAM)) |
1014 | goto err; | 1014 | goto err_release; |
1015 | ret = 0; | 1015 | ret = 0; |
1016 | cdi->media_written = 0; | 1016 | cdi->media_written = 0; |
1017 | } | 1017 | } |
@@ -1026,6 +1026,8 @@ int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip, struct file *fp) | |||
1026 | not be mounting, but opening with O_NONBLOCK */ | 1026 | not be mounting, but opening with O_NONBLOCK */ |
1027 | check_disk_change(ip->i_bdev); | 1027 | check_disk_change(ip->i_bdev); |
1028 | return 0; | 1028 | return 0; |
1029 | err_release: | ||
1030 | cdi->ops->release(cdi); | ||
1029 | err: | 1031 | err: |
1030 | cdi->use_count--; | 1032 | cdi->use_count--; |
1031 | return ret; | 1033 | return ret; |
diff --git a/drivers/char/Makefile b/drivers/char/Makefile index f5b01c6d498e..fb919bfb2824 100644 --- a/drivers/char/Makefile +++ b/drivers/char/Makefile | |||
@@ -41,9 +41,9 @@ obj-$(CONFIG_N_HDLC) += n_hdlc.o | |||
41 | obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o | 41 | obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o |
42 | obj-$(CONFIG_SX) += sx.o generic_serial.o | 42 | obj-$(CONFIG_SX) += sx.o generic_serial.o |
43 | obj-$(CONFIG_RIO) += rio/ generic_serial.o | 43 | obj-$(CONFIG_RIO) += rio/ generic_serial.o |
44 | obj-$(CONFIG_HVC_DRIVER) += hvc_console.o | ||
45 | obj-$(CONFIG_HVC_CONSOLE) += hvc_vio.o hvsi.o | 44 | obj-$(CONFIG_HVC_CONSOLE) += hvc_vio.o hvsi.o |
46 | obj-$(CONFIG_HVC_RTAS) += hvc_rtas.o | 45 | obj-$(CONFIG_HVC_RTAS) += hvc_rtas.o |
46 | obj-$(CONFIG_HVC_DRIVER) += hvc_console.o | ||
47 | obj-$(CONFIG_RAW_DRIVER) += raw.o | 47 | obj-$(CONFIG_RAW_DRIVER) += raw.o |
48 | obj-$(CONFIG_SGI_SNSC) += snsc.o snsc_event.o | 48 | obj-$(CONFIG_SGI_SNSC) += snsc.o snsc_event.o |
49 | obj-$(CONFIG_MMTIMER) += mmtimer.o | 49 | obj-$(CONFIG_MMTIMER) += mmtimer.o |
diff --git a/drivers/char/agp/alpha-agp.c b/drivers/char/agp/alpha-agp.c index 2b5838e64751..b4e00a343da9 100644 --- a/drivers/char/agp/alpha-agp.c +++ b/drivers/char/agp/alpha-agp.c | |||
@@ -46,12 +46,6 @@ struct vm_operations_struct alpha_core_agp_vm_ops = { | |||
46 | }; | 46 | }; |
47 | 47 | ||
48 | 48 | ||
49 | static int alpha_core_agp_nop(void) | ||
50 | { | ||
51 | /* just return success */ | ||
52 | return 0; | ||
53 | } | ||
54 | |||
55 | static int alpha_core_agp_fetch_size(void) | 49 | static int alpha_core_agp_fetch_size(void) |
56 | { | 50 | { |
57 | return alpha_core_agp_sizes[0].size; | 51 | return alpha_core_agp_sizes[0].size; |
@@ -120,6 +114,11 @@ static int alpha_core_agp_remove_memory(struct agp_memory *mem, off_t pg_start, | |||
120 | return status; | 114 | return status; |
121 | } | 115 | } |
122 | 116 | ||
117 | static int alpha_core_agp_create_free_gatt_table(struct agp_bridge_data *a) | ||
118 | { | ||
119 | return 0; | ||
120 | } | ||
121 | |||
123 | struct agp_bridge_driver alpha_core_agp_driver = { | 122 | struct agp_bridge_driver alpha_core_agp_driver = { |
124 | .owner = THIS_MODULE, | 123 | .owner = THIS_MODULE, |
125 | .aperture_sizes = alpha_core_agp_sizes, | 124 | .aperture_sizes = alpha_core_agp_sizes, |
@@ -135,8 +134,8 @@ struct agp_bridge_driver alpha_core_agp_driver = { | |||
135 | .tlb_flush = alpha_core_agp_tlbflush, | 134 | .tlb_flush = alpha_core_agp_tlbflush, |
136 | .mask_memory = agp_generic_mask_memory, | 135 | .mask_memory = agp_generic_mask_memory, |
137 | .cache_flush = global_cache_flush, | 136 | .cache_flush = global_cache_flush, |
138 | .create_gatt_table = alpha_core_agp_nop, | 137 | .create_gatt_table = alpha_core_agp_create_free_gatt_table, |
139 | .free_gatt_table = alpha_core_agp_nop, | 138 | .free_gatt_table = alpha_core_agp_create_free_gatt_table, |
140 | .insert_memory = alpha_core_agp_insert_memory, | 139 | .insert_memory = alpha_core_agp_insert_memory, |
141 | .remove_memory = alpha_core_agp_remove_memory, | 140 | .remove_memory = alpha_core_agp_remove_memory, |
142 | .alloc_by_type = agp_generic_alloc_by_type, | 141 | .alloc_by_type = agp_generic_alloc_by_type, |
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c index 4e1891e2c035..a92ab53a1370 100644 --- a/drivers/char/agp/generic.c +++ b/drivers/char/agp/generic.c | |||
@@ -809,12 +809,10 @@ int agp_generic_create_gatt_table(struct agp_bridge_data *bridge) | |||
809 | case U32_APER_SIZE: | 809 | case U32_APER_SIZE: |
810 | bridge->current_size = A_IDX32(bridge); | 810 | bridge->current_size = A_IDX32(bridge); |
811 | break; | 811 | break; |
812 | /* This case will never really happen. */ | 812 | /* These cases will never really happen. */ |
813 | case FIXED_APER_SIZE: | 813 | case FIXED_APER_SIZE: |
814 | case LVL2_APER_SIZE: | 814 | case LVL2_APER_SIZE: |
815 | default: | 815 | default: |
816 | bridge->current_size = | ||
817 | bridge->current_size; | ||
818 | break; | 816 | break; |
819 | } | 817 | } |
820 | temp = bridge->current_size; | 818 | temp = bridge->current_size; |
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c index bddcae54b16d..61ac3809f997 100644 --- a/drivers/char/agp/intel-agp.c +++ b/drivers/char/agp/intel-agp.c | |||
@@ -736,7 +736,7 @@ static int intel_i915_remove_entries(struct agp_memory *mem,off_t pg_start, | |||
736 | static int intel_i915_fetch_size(void) | 736 | static int intel_i915_fetch_size(void) |
737 | { | 737 | { |
738 | struct aper_size_info_fixed *values; | 738 | struct aper_size_info_fixed *values; |
739 | u32 temp, offset = 0; | 739 | u32 temp, offset; |
740 | 740 | ||
741 | #define I915_256MB_ADDRESS_MASK (1<<27) | 741 | #define I915_256MB_ADDRESS_MASK (1<<27) |
742 | 742 | ||
diff --git a/drivers/char/agp/uninorth-agp.c b/drivers/char/agp/uninorth-agp.c index 9846defbddb4..1de1b12043bf 100644 --- a/drivers/char/agp/uninorth-agp.c +++ b/drivers/char/agp/uninorth-agp.c | |||
@@ -329,7 +329,7 @@ static int agp_uninorth_suspend(struct pci_dev *pdev) | |||
329 | /* turn off AGP on the bridge */ | 329 | /* turn off AGP on the bridge */ |
330 | agp = pci_find_capability(pdev, PCI_CAP_ID_AGP); | 330 | agp = pci_find_capability(pdev, PCI_CAP_ID_AGP); |
331 | pci_read_config_dword(pdev, agp + PCI_AGP_COMMAND, &cmd); | 331 | pci_read_config_dword(pdev, agp + PCI_AGP_COMMAND, &cmd); |
332 | bridge->dev_private_data = (void *)cmd; | 332 | bridge->dev_private_data = (void *)(long)cmd; |
333 | if (cmd & PCI_AGP_COMMAND_AGP) { | 333 | if (cmd & PCI_AGP_COMMAND_AGP) { |
334 | printk("uninorth-agp: disabling AGP on bridge %s\n", | 334 | printk("uninorth-agp: disabling AGP on bridge %s\n", |
335 | pci_name(pdev)); | 335 | pci_name(pdev)); |
@@ -351,7 +351,7 @@ static int agp_uninorth_resume(struct pci_dev *pdev) | |||
351 | if (bridge == NULL) | 351 | if (bridge == NULL) |
352 | return -ENODEV; | 352 | return -ENODEV; |
353 | 353 | ||
354 | command = (u32)bridge->dev_private_data; | 354 | command = (long)bridge->dev_private_data; |
355 | bridge->dev_private_data = NULL; | 355 | bridge->dev_private_data = NULL; |
356 | if (!(command & PCI_AGP_COMMAND_AGP)) | 356 | if (!(command & PCI_AGP_COMMAND_AGP)) |
357 | return 0; | 357 | return 0; |
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c index ede365d05387..b9371d5bf790 100644 --- a/drivers/char/n_tty.c +++ b/drivers/char/n_tty.c | |||
@@ -1384,8 +1384,10 @@ do_it_again: | |||
1384 | * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode, | 1384 | * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode, |
1385 | * we won't get any more characters. | 1385 | * we won't get any more characters. |
1386 | */ | 1386 | */ |
1387 | if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) | 1387 | if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) { |
1388 | n_tty_set_room(tty); | ||
1388 | check_unthrottle(tty); | 1389 | check_unthrottle(tty); |
1390 | } | ||
1389 | 1391 | ||
1390 | if (b - buf >= minimum) | 1392 | if (b - buf >= minimum) |
1391 | break; | 1393 | break; |
diff --git a/drivers/connector/cn_queue.c b/drivers/connector/cn_queue.c index 9f2f00d82917..05f8ce2cfb4a 100644 --- a/drivers/connector/cn_queue.c +++ b/drivers/connector/cn_queue.c | |||
@@ -127,7 +127,7 @@ void cn_queue_del_callback(struct cn_queue_dev *dev, struct cb_id *id) | |||
127 | 127 | ||
128 | if (found) { | 128 | if (found) { |
129 | cn_queue_free_callback(cbq); | 129 | cn_queue_free_callback(cbq); |
130 | atomic_dec_and_test(&dev->refcnt); | 130 | atomic_dec(&dev->refcnt); |
131 | } | 131 | } |
132 | } | 132 | } |
133 | 133 | ||
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c index 29b2fa5534ae..44d1eca83a72 100644 --- a/drivers/cpufreq/cpufreq.c +++ b/drivers/cpufreq/cpufreq.c | |||
@@ -257,7 +257,7 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state) | |||
257 | if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) { | 257 | if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) { |
258 | if ((policy) && (policy->cpu == freqs->cpu) && | 258 | if ((policy) && (policy->cpu == freqs->cpu) && |
259 | (policy->cur) && (policy->cur != freqs->old)) { | 259 | (policy->cur) && (policy->cur != freqs->old)) { |
260 | dprintk(KERN_WARNING "Warning: CPU frequency is" | 260 | dprintk("Warning: CPU frequency is" |
261 | " %u, cpufreq assumed %u kHz.\n", | 261 | " %u, cpufreq assumed %u kHz.\n", |
262 | freqs->old, policy->cur); | 262 | freqs->old, policy->cur); |
263 | freqs->old = policy->cur; | 263 | freqs->old = policy->cur; |
@@ -874,7 +874,7 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigne | |||
874 | { | 874 | { |
875 | struct cpufreq_freqs freqs; | 875 | struct cpufreq_freqs freqs; |
876 | 876 | ||
877 | dprintk(KERN_WARNING "Warning: CPU frequency out of sync: cpufreq and timing " | 877 | dprintk("Warning: CPU frequency out of sync: cpufreq and timing " |
878 | "core thinks of %u, is %u kHz.\n", old_freq, new_freq); | 878 | "core thinks of %u, is %u kHz.\n", old_freq, new_freq); |
879 | 879 | ||
880 | freqs.cpu = cpu; | 880 | freqs.cpu = cpu; |
@@ -1006,7 +1006,7 @@ static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg) | |||
1006 | struct cpufreq_freqs freqs; | 1006 | struct cpufreq_freqs freqs; |
1007 | 1007 | ||
1008 | if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) | 1008 | if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) |
1009 | dprintk(KERN_DEBUG "Warning: CPU frequency is %u, " | 1009 | dprintk("Warning: CPU frequency is %u, " |
1010 | "cpufreq assumed %u kHz.\n", | 1010 | "cpufreq assumed %u kHz.\n", |
1011 | cur_freq, cpu_policy->cur); | 1011 | cur_freq, cpu_policy->cur); |
1012 | 1012 | ||
@@ -1087,7 +1087,7 @@ static int cpufreq_resume(struct sys_device * sysdev) | |||
1087 | struct cpufreq_freqs freqs; | 1087 | struct cpufreq_freqs freqs; |
1088 | 1088 | ||
1089 | if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) | 1089 | if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) |
1090 | dprintk(KERN_WARNING "Warning: CPU frequency" | 1090 | dprintk("Warning: CPU frequency" |
1091 | "is %u, cpufreq assumed %u kHz.\n", | 1091 | "is %u, cpufreq assumed %u kHz.\n", |
1092 | cur_freq, cpu_policy->cur); | 1092 | cur_freq, cpu_policy->cur); |
1093 | 1093 | ||
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c index 9694b6ed3268..c576c0b3f452 100644 --- a/drivers/cpufreq/cpufreq_stats.c +++ b/drivers/cpufreq/cpufreq_stats.c | |||
@@ -74,7 +74,7 @@ static ssize_t | |||
74 | show_total_trans(struct cpufreq_policy *policy, char *buf) | 74 | show_total_trans(struct cpufreq_policy *policy, char *buf) |
75 | { | 75 | { |
76 | struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu]; | 76 | struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu]; |
77 | if(!stat) | 77 | if (!stat) |
78 | return 0; | 78 | return 0; |
79 | return sprintf(buf, "%d\n", | 79 | return sprintf(buf, "%d\n", |
80 | cpufreq_stats_table[stat->cpu]->total_trans); | 80 | cpufreq_stats_table[stat->cpu]->total_trans); |
@@ -86,7 +86,7 @@ show_time_in_state(struct cpufreq_policy *policy, char *buf) | |||
86 | ssize_t len = 0; | 86 | ssize_t len = 0; |
87 | int i; | 87 | int i; |
88 | struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu]; | 88 | struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu]; |
89 | if(!stat) | 89 | if (!stat) |
90 | return 0; | 90 | return 0; |
91 | cpufreq_stats_update(stat->cpu); | 91 | cpufreq_stats_update(stat->cpu); |
92 | for (i = 0; i < stat->state_num; i++) { | 92 | for (i = 0; i < stat->state_num; i++) { |
@@ -104,7 +104,7 @@ show_trans_table(struct cpufreq_policy *policy, char *buf) | |||
104 | int i, j; | 104 | int i, j; |
105 | 105 | ||
106 | struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu]; | 106 | struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu]; |
107 | if(!stat) | 107 | if (!stat) |
108 | return 0; | 108 | return 0; |
109 | cpufreq_stats_update(stat->cpu); | 109 | cpufreq_stats_update(stat->cpu); |
110 | len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n"); | 110 | len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n"); |
diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c index a4818ce88919..551f4ccf87fd 100644 --- a/drivers/cpufreq/freq_table.c +++ b/drivers/cpufreq/freq_table.c | |||
@@ -20,7 +20,7 @@ int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, | |||
20 | { | 20 | { |
21 | unsigned int min_freq = ~0; | 21 | unsigned int min_freq = ~0; |
22 | unsigned int max_freq = 0; | 22 | unsigned int max_freq = 0; |
23 | unsigned int i = 0; | 23 | unsigned int i; |
24 | 24 | ||
25 | for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) { | 25 | for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) { |
26 | unsigned int freq = table[i].frequency; | 26 | unsigned int freq = table[i].frequency; |
@@ -51,7 +51,7 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, | |||
51 | struct cpufreq_frequency_table *table) | 51 | struct cpufreq_frequency_table *table) |
52 | { | 52 | { |
53 | unsigned int next_larger = ~0; | 53 | unsigned int next_larger = ~0; |
54 | unsigned int i = 0; | 54 | unsigned int i; |
55 | unsigned int count = 0; | 55 | unsigned int count = 0; |
56 | 56 | ||
57 | dprintk("request for verification of policy (%u - %u kHz) for cpu %u\n", policy->min, policy->max, policy->cpu); | 57 | dprintk("request for verification of policy (%u - %u kHz) for cpu %u\n", policy->min, policy->max, policy->cpu); |
@@ -91,20 +91,24 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy, | |||
91 | unsigned int relation, | 91 | unsigned int relation, |
92 | unsigned int *index) | 92 | unsigned int *index) |
93 | { | 93 | { |
94 | struct cpufreq_frequency_table optimal = { .index = ~0, }; | 94 | struct cpufreq_frequency_table optimal = { |
95 | struct cpufreq_frequency_table suboptimal = { .index = ~0, }; | 95 | .index = ~0, |
96 | .frequency = 0, | ||
97 | }; | ||
98 | struct cpufreq_frequency_table suboptimal = { | ||
99 | .index = ~0, | ||
100 | .frequency = 0, | ||
101 | }; | ||
96 | unsigned int i; | 102 | unsigned int i; |
97 | 103 | ||
98 | dprintk("request for target %u kHz (relation: %u) for cpu %u\n", target_freq, relation, policy->cpu); | 104 | dprintk("request for target %u kHz (relation: %u) for cpu %u\n", target_freq, relation, policy->cpu); |
99 | 105 | ||
100 | switch (relation) { | 106 | switch (relation) { |
101 | case CPUFREQ_RELATION_H: | 107 | case CPUFREQ_RELATION_H: |
102 | optimal.frequency = 0; | ||
103 | suboptimal.frequency = ~0; | 108 | suboptimal.frequency = ~0; |
104 | break; | 109 | break; |
105 | case CPUFREQ_RELATION_L: | 110 | case CPUFREQ_RELATION_L: |
106 | optimal.frequency = ~0; | 111 | optimal.frequency = ~0; |
107 | suboptimal.frequency = 0; | ||
108 | break; | 112 | break; |
109 | } | 113 | } |
110 | 114 | ||
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig new file mode 100644 index 000000000000..30d021d1a07c --- /dev/null +++ b/drivers/dma/Kconfig | |||
@@ -0,0 +1,34 @@ | |||
1 | # | ||
2 | # DMA engine configuration | ||
3 | # | ||
4 | |||
5 | menu "DMA Engine support" | ||
6 | |||
7 | config DMA_ENGINE | ||
8 | bool "Support for DMA engines" | ||
9 | ---help--- | ||
10 | DMA engines offload copy operations from the CPU to dedicated | ||
11 | hardware, allowing the copies to happen asynchronously. | ||
12 | |||
13 | comment "DMA Clients" | ||
14 | |||
15 | config NET_DMA | ||
16 | bool "Network: TCP receive copy offload" | ||
17 | depends on DMA_ENGINE && NET | ||
18 | default y | ||
19 | ---help--- | ||
20 | This enables the use of DMA engines in the network stack to | ||
21 | offload receive copy-to-user operations, freeing CPU cycles. | ||
22 | Since this is the main user of the DMA engine, it should be enabled; | ||
23 | say Y here. | ||
24 | |||
25 | comment "DMA Devices" | ||
26 | |||
27 | config INTEL_IOATDMA | ||
28 | tristate "Intel I/OAT DMA support" | ||
29 | depends on DMA_ENGINE && PCI | ||
30 | default m | ||
31 | ---help--- | ||
32 | Enable support for the Intel(R) I/OAT DMA engine. | ||
33 | |||
34 | endmenu | ||
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile new file mode 100644 index 000000000000..bdcfdbdb1aec --- /dev/null +++ b/drivers/dma/Makefile | |||
@@ -0,0 +1,3 @@ | |||
1 | obj-$(CONFIG_DMA_ENGINE) += dmaengine.o | ||
2 | obj-$(CONFIG_NET_DMA) += iovlock.o | ||
3 | obj-$(CONFIG_INTEL_IOATDMA) += ioatdma.o | ||
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c new file mode 100644 index 000000000000..5829143558e1 --- /dev/null +++ b/drivers/dma/dmaengine.c | |||
@@ -0,0 +1,408 @@ | |||
1 | /* | ||
2 | * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms of the GNU General Public License as published by the Free | ||
6 | * Software Foundation; either version 2 of the License, or (at your option) | ||
7 | * any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., 59 | ||
16 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | * | ||
18 | * The full GNU General Public License is included in this distribution in the | ||
19 | * file called COPYING. | ||
20 | */ | ||
21 | |||
22 | /* | ||
23 | * This code implements the DMA subsystem. It provides a HW-neutral interface | ||
24 | * for other kernel code to use asynchronous memory copy capabilities, | ||
25 | * if present, and allows different HW DMA drivers to register as providing | ||
26 | * this capability. | ||
27 | * | ||
28 | * Due to the fact we are accelerating what is already a relatively fast | ||
29 | * operation, the code goes to great lengths to avoid additional overhead, | ||
30 | * such as locking. | ||
31 | * | ||
32 | * LOCKING: | ||
33 | * | ||
34 | * The subsystem keeps two global lists, dma_device_list and dma_client_list. | ||
35 | * Both of these are protected by a mutex, dma_list_mutex. | ||
36 | * | ||
37 | * Each device has a channels list, which runs unlocked but is never modified | ||
38 | * once the device is registered, it's just setup by the driver. | ||
39 | * | ||
40 | * Each client has a channels list, it's only modified under the client->lock | ||
41 | * and in an RCU callback, so it's safe to read under rcu_read_lock(). | ||
42 | * | ||
43 | * Each device has a kref, which is initialized to 1 when the device is | ||
44 | * registered. A kref_put is done for each class_device registered. When the | ||
45 | * class_device is released, the coresponding kref_put is done in the release | ||
46 | * method. Every time one of the device's channels is allocated to a client, | ||
47 | * a kref_get occurs. When the channel is freed, the coresponding kref_put | ||
48 | * happens. The device's release function does a completion, so | ||
49 | * unregister_device does a remove event, class_device_unregister, a kref_put | ||
50 | * for the first reference, then waits on the completion for all other | ||
51 | * references to finish. | ||
52 | * | ||
53 | * Each channel has an open-coded implementation of Rusty Russell's "bigref," | ||
54 | * with a kref and a per_cpu local_t. A single reference is set when on an | ||
55 | * ADDED event, and removed with a REMOVE event. Net DMA client takes an | ||
56 | * extra reference per outstanding transaction. The relase function does a | ||
57 | * kref_put on the device. -ChrisL | ||
58 | */ | ||
59 | |||
60 | #include <linux/init.h> | ||
61 | #include <linux/module.h> | ||
62 | #include <linux/device.h> | ||
63 | #include <linux/dmaengine.h> | ||
64 | #include <linux/hardirq.h> | ||
65 | #include <linux/spinlock.h> | ||
66 | #include <linux/percpu.h> | ||
67 | #include <linux/rcupdate.h> | ||
68 | #include <linux/mutex.h> | ||
69 | |||
70 | static DEFINE_MUTEX(dma_list_mutex); | ||
71 | static LIST_HEAD(dma_device_list); | ||
72 | static LIST_HEAD(dma_client_list); | ||
73 | |||
74 | /* --- sysfs implementation --- */ | ||
75 | |||
76 | static ssize_t show_memcpy_count(struct class_device *cd, char *buf) | ||
77 | { | ||
78 | struct dma_chan *chan = container_of(cd, struct dma_chan, class_dev); | ||
79 | unsigned long count = 0; | ||
80 | int i; | ||
81 | |||
82 | for_each_possible_cpu(i) | ||
83 | count += per_cpu_ptr(chan->local, i)->memcpy_count; | ||
84 | |||
85 | return sprintf(buf, "%lu\n", count); | ||
86 | } | ||
87 | |||
88 | static ssize_t show_bytes_transferred(struct class_device *cd, char *buf) | ||
89 | { | ||
90 | struct dma_chan *chan = container_of(cd, struct dma_chan, class_dev); | ||
91 | unsigned long count = 0; | ||
92 | int i; | ||
93 | |||
94 | for_each_possible_cpu(i) | ||
95 | count += per_cpu_ptr(chan->local, i)->bytes_transferred; | ||
96 | |||
97 | return sprintf(buf, "%lu\n", count); | ||
98 | } | ||
99 | |||
100 | static ssize_t show_in_use(struct class_device *cd, char *buf) | ||
101 | { | ||
102 | struct dma_chan *chan = container_of(cd, struct dma_chan, class_dev); | ||
103 | |||
104 | return sprintf(buf, "%d\n", (chan->client ? 1 : 0)); | ||
105 | } | ||
106 | |||
107 | static struct class_device_attribute dma_class_attrs[] = { | ||
108 | __ATTR(memcpy_count, S_IRUGO, show_memcpy_count, NULL), | ||
109 | __ATTR(bytes_transferred, S_IRUGO, show_bytes_transferred, NULL), | ||
110 | __ATTR(in_use, S_IRUGO, show_in_use, NULL), | ||
111 | __ATTR_NULL | ||
112 | }; | ||
113 | |||
114 | static void dma_async_device_cleanup(struct kref *kref); | ||
115 | |||
116 | static void dma_class_dev_release(struct class_device *cd) | ||
117 | { | ||
118 | struct dma_chan *chan = container_of(cd, struct dma_chan, class_dev); | ||
119 | kref_put(&chan->device->refcount, dma_async_device_cleanup); | ||
120 | } | ||
121 | |||
122 | static struct class dma_devclass = { | ||
123 | .name = "dma", | ||
124 | .class_dev_attrs = dma_class_attrs, | ||
125 | .release = dma_class_dev_release, | ||
126 | }; | ||
127 | |||
128 | /* --- client and device registration --- */ | ||
129 | |||
130 | /** | ||
131 | * dma_client_chan_alloc - try to allocate a channel to a client | ||
132 | * @client: &dma_client | ||
133 | * | ||
134 | * Called with dma_list_mutex held. | ||
135 | */ | ||
136 | static struct dma_chan *dma_client_chan_alloc(struct dma_client *client) | ||
137 | { | ||
138 | struct dma_device *device; | ||
139 | struct dma_chan *chan; | ||
140 | unsigned long flags; | ||
141 | int desc; /* allocated descriptor count */ | ||
142 | |||
143 | /* Find a channel, any DMA engine will do */ | ||
144 | list_for_each_entry(device, &dma_device_list, global_node) { | ||
145 | list_for_each_entry(chan, &device->channels, device_node) { | ||
146 | if (chan->client) | ||
147 | continue; | ||
148 | |||
149 | desc = chan->device->device_alloc_chan_resources(chan); | ||
150 | if (desc >= 0) { | ||
151 | kref_get(&device->refcount); | ||
152 | kref_init(&chan->refcount); | ||
153 | chan->slow_ref = 0; | ||
154 | INIT_RCU_HEAD(&chan->rcu); | ||
155 | chan->client = client; | ||
156 | spin_lock_irqsave(&client->lock, flags); | ||
157 | list_add_tail_rcu(&chan->client_node, | ||
158 | &client->channels); | ||
159 | spin_unlock_irqrestore(&client->lock, flags); | ||
160 | return chan; | ||
161 | } | ||
162 | } | ||
163 | } | ||
164 | |||
165 | return NULL; | ||
166 | } | ||
167 | |||
168 | /** | ||
169 | * dma_client_chan_free - release a DMA channel | ||
170 | * @chan: &dma_chan | ||
171 | */ | ||
172 | void dma_chan_cleanup(struct kref *kref) | ||
173 | { | ||
174 | struct dma_chan *chan = container_of(kref, struct dma_chan, refcount); | ||
175 | chan->device->device_free_chan_resources(chan); | ||
176 | chan->client = NULL; | ||
177 | kref_put(&chan->device->refcount, dma_async_device_cleanup); | ||
178 | } | ||
179 | |||
180 | static void dma_chan_free_rcu(struct rcu_head *rcu) | ||
181 | { | ||
182 | struct dma_chan *chan = container_of(rcu, struct dma_chan, rcu); | ||
183 | int bias = 0x7FFFFFFF; | ||
184 | int i; | ||
185 | for_each_possible_cpu(i) | ||
186 | bias -= local_read(&per_cpu_ptr(chan->local, i)->refcount); | ||
187 | atomic_sub(bias, &chan->refcount.refcount); | ||
188 | kref_put(&chan->refcount, dma_chan_cleanup); | ||
189 | } | ||
190 | |||
191 | static void dma_client_chan_free(struct dma_chan *chan) | ||
192 | { | ||
193 | atomic_add(0x7FFFFFFF, &chan->refcount.refcount); | ||
194 | chan->slow_ref = 1; | ||
195 | call_rcu(&chan->rcu, dma_chan_free_rcu); | ||
196 | } | ||
197 | |||
198 | /** | ||
199 | * dma_chans_rebalance - reallocate channels to clients | ||
200 | * | ||
201 | * When the number of DMA channel in the system changes, | ||
202 | * channels need to be rebalanced among clients | ||
203 | */ | ||
204 | static void dma_chans_rebalance(void) | ||
205 | { | ||
206 | struct dma_client *client; | ||
207 | struct dma_chan *chan; | ||
208 | unsigned long flags; | ||
209 | |||
210 | mutex_lock(&dma_list_mutex); | ||
211 | |||
212 | list_for_each_entry(client, &dma_client_list, global_node) { | ||
213 | while (client->chans_desired > client->chan_count) { | ||
214 | chan = dma_client_chan_alloc(client); | ||
215 | if (!chan) | ||
216 | break; | ||
217 | client->chan_count++; | ||
218 | client->event_callback(client, | ||
219 | chan, | ||
220 | DMA_RESOURCE_ADDED); | ||
221 | } | ||
222 | while (client->chans_desired < client->chan_count) { | ||
223 | spin_lock_irqsave(&client->lock, flags); | ||
224 | chan = list_entry(client->channels.next, | ||
225 | struct dma_chan, | ||
226 | client_node); | ||
227 | list_del_rcu(&chan->client_node); | ||
228 | spin_unlock_irqrestore(&client->lock, flags); | ||
229 | client->chan_count--; | ||
230 | client->event_callback(client, | ||
231 | chan, | ||
232 | DMA_RESOURCE_REMOVED); | ||
233 | dma_client_chan_free(chan); | ||
234 | } | ||
235 | } | ||
236 | |||
237 | mutex_unlock(&dma_list_mutex); | ||
238 | } | ||
239 | |||
240 | /** | ||
241 | * dma_async_client_register - allocate and register a &dma_client | ||
242 | * @event_callback: callback for notification of channel addition/removal | ||
243 | */ | ||
244 | struct dma_client *dma_async_client_register(dma_event_callback event_callback) | ||
245 | { | ||
246 | struct dma_client *client; | ||
247 | |||
248 | client = kzalloc(sizeof(*client), GFP_KERNEL); | ||
249 | if (!client) | ||
250 | return NULL; | ||
251 | |||
252 | INIT_LIST_HEAD(&client->channels); | ||
253 | spin_lock_init(&client->lock); | ||
254 | client->chans_desired = 0; | ||
255 | client->chan_count = 0; | ||
256 | client->event_callback = event_callback; | ||
257 | |||
258 | mutex_lock(&dma_list_mutex); | ||
259 | list_add_tail(&client->global_node, &dma_client_list); | ||
260 | mutex_unlock(&dma_list_mutex); | ||
261 | |||
262 | return client; | ||
263 | } | ||
264 | |||
265 | /** | ||
266 | * dma_async_client_unregister - unregister a client and free the &dma_client | ||
267 | * @client: | ||
268 | * | ||
269 | * Force frees any allocated DMA channels, frees the &dma_client memory | ||
270 | */ | ||
271 | void dma_async_client_unregister(struct dma_client *client) | ||
272 | { | ||
273 | struct dma_chan *chan; | ||
274 | |||
275 | if (!client) | ||
276 | return; | ||
277 | |||
278 | rcu_read_lock(); | ||
279 | list_for_each_entry_rcu(chan, &client->channels, client_node) | ||
280 | dma_client_chan_free(chan); | ||
281 | rcu_read_unlock(); | ||
282 | |||
283 | mutex_lock(&dma_list_mutex); | ||
284 | list_del(&client->global_node); | ||
285 | mutex_unlock(&dma_list_mutex); | ||
286 | |||
287 | kfree(client); | ||
288 | dma_chans_rebalance(); | ||
289 | } | ||
290 | |||
291 | /** | ||
292 | * dma_async_client_chan_request - request DMA channels | ||
293 | * @client: &dma_client | ||
294 | * @number: count of DMA channels requested | ||
295 | * | ||
296 | * Clients call dma_async_client_chan_request() to specify how many | ||
297 | * DMA channels they need, 0 to free all currently allocated. | ||
298 | * The resulting allocations/frees are indicated to the client via the | ||
299 | * event callback. | ||
300 | */ | ||
301 | void dma_async_client_chan_request(struct dma_client *client, | ||
302 | unsigned int number) | ||
303 | { | ||
304 | client->chans_desired = number; | ||
305 | dma_chans_rebalance(); | ||
306 | } | ||
307 | |||
308 | /** | ||
309 | * dma_async_device_register - | ||
310 | * @device: &dma_device | ||
311 | */ | ||
312 | int dma_async_device_register(struct dma_device *device) | ||
313 | { | ||
314 | static int id; | ||
315 | int chancnt = 0; | ||
316 | struct dma_chan* chan; | ||
317 | |||
318 | if (!device) | ||
319 | return -ENODEV; | ||
320 | |||
321 | init_completion(&device->done); | ||
322 | kref_init(&device->refcount); | ||
323 | device->dev_id = id++; | ||
324 | |||
325 | /* represent channels in sysfs. Probably want devs too */ | ||
326 | list_for_each_entry(chan, &device->channels, device_node) { | ||
327 | chan->local = alloc_percpu(typeof(*chan->local)); | ||
328 | if (chan->local == NULL) | ||
329 | continue; | ||
330 | |||
331 | chan->chan_id = chancnt++; | ||
332 | chan->class_dev.class = &dma_devclass; | ||
333 | chan->class_dev.dev = NULL; | ||
334 | snprintf(chan->class_dev.class_id, BUS_ID_SIZE, "dma%dchan%d", | ||
335 | device->dev_id, chan->chan_id); | ||
336 | |||
337 | kref_get(&device->refcount); | ||
338 | class_device_register(&chan->class_dev); | ||
339 | } | ||
340 | |||
341 | mutex_lock(&dma_list_mutex); | ||
342 | list_add_tail(&device->global_node, &dma_device_list); | ||
343 | mutex_unlock(&dma_list_mutex); | ||
344 | |||
345 | dma_chans_rebalance(); | ||
346 | |||
347 | return 0; | ||
348 | } | ||
349 | |||
350 | /** | ||
351 | * dma_async_device_unregister - | ||
352 | * @device: &dma_device | ||
353 | */ | ||
354 | static void dma_async_device_cleanup(struct kref *kref) | ||
355 | { | ||
356 | struct dma_device *device; | ||
357 | |||
358 | device = container_of(kref, struct dma_device, refcount); | ||
359 | complete(&device->done); | ||
360 | } | ||
361 | |||
362 | void dma_async_device_unregister(struct dma_device* device) | ||
363 | { | ||
364 | struct dma_chan *chan; | ||
365 | unsigned long flags; | ||
366 | |||
367 | mutex_lock(&dma_list_mutex); | ||
368 | list_del(&device->global_node); | ||
369 | mutex_unlock(&dma_list_mutex); | ||
370 | |||
371 | list_for_each_entry(chan, &device->channels, device_node) { | ||
372 | if (chan->client) { | ||
373 | spin_lock_irqsave(&chan->client->lock, flags); | ||
374 | list_del(&chan->client_node); | ||
375 | chan->client->chan_count--; | ||
376 | spin_unlock_irqrestore(&chan->client->lock, flags); | ||
377 | chan->client->event_callback(chan->client, | ||
378 | chan, | ||
379 | DMA_RESOURCE_REMOVED); | ||
380 | dma_client_chan_free(chan); | ||
381 | } | ||
382 | class_device_unregister(&chan->class_dev); | ||
383 | } | ||
384 | dma_chans_rebalance(); | ||
385 | |||
386 | kref_put(&device->refcount, dma_async_device_cleanup); | ||
387 | wait_for_completion(&device->done); | ||
388 | } | ||
389 | |||
390 | static int __init dma_bus_init(void) | ||
391 | { | ||
392 | mutex_init(&dma_list_mutex); | ||
393 | return class_register(&dma_devclass); | ||
394 | } | ||
395 | |||
396 | subsys_initcall(dma_bus_init); | ||
397 | |||
398 | EXPORT_SYMBOL(dma_async_client_register); | ||
399 | EXPORT_SYMBOL(dma_async_client_unregister); | ||
400 | EXPORT_SYMBOL(dma_async_client_chan_request); | ||
401 | EXPORT_SYMBOL(dma_async_memcpy_buf_to_buf); | ||
402 | EXPORT_SYMBOL(dma_async_memcpy_buf_to_pg); | ||
403 | EXPORT_SYMBOL(dma_async_memcpy_pg_to_pg); | ||
404 | EXPORT_SYMBOL(dma_async_memcpy_complete); | ||
405 | EXPORT_SYMBOL(dma_async_memcpy_issue_pending); | ||
406 | EXPORT_SYMBOL(dma_async_device_register); | ||
407 | EXPORT_SYMBOL(dma_async_device_unregister); | ||
408 | EXPORT_SYMBOL(dma_chan_cleanup); | ||
diff --git a/drivers/dma/ioatdma.c b/drivers/dma/ioatdma.c new file mode 100644 index 000000000000..0fdf7fbd6495 --- /dev/null +++ b/drivers/dma/ioatdma.c | |||
@@ -0,0 +1,840 @@ | |||
1 | /* | ||
2 | * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms of the GNU General Public License as published by the Free | ||
6 | * Software Foundation; either version 2 of the License, or (at your option) | ||
7 | * any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., 59 | ||
16 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | * | ||
18 | * The full GNU General Public License is included in this distribution in the | ||
19 | * file called COPYING. | ||
20 | */ | ||
21 | |||
22 | /* | ||
23 | * This driver supports an Intel I/OAT DMA engine, which does asynchronous | ||
24 | * copy operations. | ||
25 | */ | ||
26 | |||
27 | #include <linux/init.h> | ||
28 | #include <linux/module.h> | ||
29 | #include <linux/pci.h> | ||
30 | #include <linux/interrupt.h> | ||
31 | #include <linux/dmaengine.h> | ||
32 | #include <linux/delay.h> | ||
33 | #include <linux/dma-mapping.h> | ||
34 | #include "ioatdma.h" | ||
35 | #include "ioatdma_io.h" | ||
36 | #include "ioatdma_registers.h" | ||
37 | #include "ioatdma_hw.h" | ||
38 | |||
39 | #define to_ioat_chan(chan) container_of(chan, struct ioat_dma_chan, common) | ||
40 | #define to_ioat_device(dev) container_of(dev, struct ioat_device, common) | ||
41 | #define to_ioat_desc(lh) container_of(lh, struct ioat_desc_sw, node) | ||
42 | |||
43 | /* internal functions */ | ||
44 | static int __devinit ioat_probe(struct pci_dev *pdev, const struct pci_device_id *ent); | ||
45 | static void __devexit ioat_remove(struct pci_dev *pdev); | ||
46 | |||
47 | static int enumerate_dma_channels(struct ioat_device *device) | ||
48 | { | ||
49 | u8 xfercap_scale; | ||
50 | u32 xfercap; | ||
51 | int i; | ||
52 | struct ioat_dma_chan *ioat_chan; | ||
53 | |||
54 | device->common.chancnt = ioatdma_read8(device, IOAT_CHANCNT_OFFSET); | ||
55 | xfercap_scale = ioatdma_read8(device, IOAT_XFERCAP_OFFSET); | ||
56 | xfercap = (xfercap_scale == 0 ? -1 : (1UL << xfercap_scale)); | ||
57 | |||
58 | for (i = 0; i < device->common.chancnt; i++) { | ||
59 | ioat_chan = kzalloc(sizeof(*ioat_chan), GFP_KERNEL); | ||
60 | if (!ioat_chan) { | ||
61 | device->common.chancnt = i; | ||
62 | break; | ||
63 | } | ||
64 | |||
65 | ioat_chan->device = device; | ||
66 | ioat_chan->reg_base = device->reg_base + (0x80 * (i + 1)); | ||
67 | ioat_chan->xfercap = xfercap; | ||
68 | spin_lock_init(&ioat_chan->cleanup_lock); | ||
69 | spin_lock_init(&ioat_chan->desc_lock); | ||
70 | INIT_LIST_HEAD(&ioat_chan->free_desc); | ||
71 | INIT_LIST_HEAD(&ioat_chan->used_desc); | ||
72 | /* This should be made common somewhere in dmaengine.c */ | ||
73 | ioat_chan->common.device = &device->common; | ||
74 | ioat_chan->common.client = NULL; | ||
75 | list_add_tail(&ioat_chan->common.device_node, | ||
76 | &device->common.channels); | ||
77 | } | ||
78 | return device->common.chancnt; | ||
79 | } | ||
80 | |||
81 | static struct ioat_desc_sw *ioat_dma_alloc_descriptor( | ||
82 | struct ioat_dma_chan *ioat_chan, | ||
83 | int flags) | ||
84 | { | ||
85 | struct ioat_dma_descriptor *desc; | ||
86 | struct ioat_desc_sw *desc_sw; | ||
87 | struct ioat_device *ioat_device; | ||
88 | dma_addr_t phys; | ||
89 | |||
90 | ioat_device = to_ioat_device(ioat_chan->common.device); | ||
91 | desc = pci_pool_alloc(ioat_device->dma_pool, flags, &phys); | ||
92 | if (unlikely(!desc)) | ||
93 | return NULL; | ||
94 | |||
95 | desc_sw = kzalloc(sizeof(*desc_sw), flags); | ||
96 | if (unlikely(!desc_sw)) { | ||
97 | pci_pool_free(ioat_device->dma_pool, desc, phys); | ||
98 | return NULL; | ||
99 | } | ||
100 | |||
101 | memset(desc, 0, sizeof(*desc)); | ||
102 | desc_sw->hw = desc; | ||
103 | desc_sw->phys = phys; | ||
104 | |||
105 | return desc_sw; | ||
106 | } | ||
107 | |||
108 | #define INITIAL_IOAT_DESC_COUNT 128 | ||
109 | |||
110 | static void ioat_start_null_desc(struct ioat_dma_chan *ioat_chan); | ||
111 | |||
112 | /* returns the actual number of allocated descriptors */ | ||
113 | static int ioat_dma_alloc_chan_resources(struct dma_chan *chan) | ||
114 | { | ||
115 | struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan); | ||
116 | struct ioat_desc_sw *desc = NULL; | ||
117 | u16 chanctrl; | ||
118 | u32 chanerr; | ||
119 | int i; | ||
120 | LIST_HEAD(tmp_list); | ||
121 | |||
122 | /* | ||
123 | * In-use bit automatically set by reading chanctrl | ||
124 | * If 0, we got it, if 1, someone else did | ||
125 | */ | ||
126 | chanctrl = ioatdma_chan_read16(ioat_chan, IOAT_CHANCTRL_OFFSET); | ||
127 | if (chanctrl & IOAT_CHANCTRL_CHANNEL_IN_USE) | ||
128 | return -EBUSY; | ||
129 | |||
130 | /* Setup register to interrupt and write completion status on error */ | ||
131 | chanctrl = IOAT_CHANCTRL_CHANNEL_IN_USE | | ||
132 | IOAT_CHANCTRL_ERR_INT_EN | | ||
133 | IOAT_CHANCTRL_ANY_ERR_ABORT_EN | | ||
134 | IOAT_CHANCTRL_ERR_COMPLETION_EN; | ||
135 | ioatdma_chan_write16(ioat_chan, IOAT_CHANCTRL_OFFSET, chanctrl); | ||
136 | |||
137 | chanerr = ioatdma_chan_read32(ioat_chan, IOAT_CHANERR_OFFSET); | ||
138 | if (chanerr) { | ||
139 | printk("IOAT: CHANERR = %x, clearing\n", chanerr); | ||
140 | ioatdma_chan_write32(ioat_chan, IOAT_CHANERR_OFFSET, chanerr); | ||
141 | } | ||
142 | |||
143 | /* Allocate descriptors */ | ||
144 | for (i = 0; i < INITIAL_IOAT_DESC_COUNT; i++) { | ||
145 | desc = ioat_dma_alloc_descriptor(ioat_chan, GFP_KERNEL); | ||
146 | if (!desc) { | ||
147 | printk(KERN_ERR "IOAT: Only %d initial descriptors\n", i); | ||
148 | break; | ||
149 | } | ||
150 | list_add_tail(&desc->node, &tmp_list); | ||
151 | } | ||
152 | spin_lock_bh(&ioat_chan->desc_lock); | ||
153 | list_splice(&tmp_list, &ioat_chan->free_desc); | ||
154 | spin_unlock_bh(&ioat_chan->desc_lock); | ||
155 | |||
156 | /* allocate a completion writeback area */ | ||
157 | /* doing 2 32bit writes to mmio since 1 64b write doesn't work */ | ||
158 | ioat_chan->completion_virt = | ||
159 | pci_pool_alloc(ioat_chan->device->completion_pool, | ||
160 | GFP_KERNEL, | ||
161 | &ioat_chan->completion_addr); | ||
162 | memset(ioat_chan->completion_virt, 0, | ||
163 | sizeof(*ioat_chan->completion_virt)); | ||
164 | ioatdma_chan_write32(ioat_chan, IOAT_CHANCMP_OFFSET_LOW, | ||
165 | ((u64) ioat_chan->completion_addr) & 0x00000000FFFFFFFF); | ||
166 | ioatdma_chan_write32(ioat_chan, IOAT_CHANCMP_OFFSET_HIGH, | ||
167 | ((u64) ioat_chan->completion_addr) >> 32); | ||
168 | |||
169 | ioat_start_null_desc(ioat_chan); | ||
170 | return i; | ||
171 | } | ||
172 | |||
173 | static void ioat_dma_memcpy_cleanup(struct ioat_dma_chan *ioat_chan); | ||
174 | |||
175 | static void ioat_dma_free_chan_resources(struct dma_chan *chan) | ||
176 | { | ||
177 | struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan); | ||
178 | struct ioat_device *ioat_device = to_ioat_device(chan->device); | ||
179 | struct ioat_desc_sw *desc, *_desc; | ||
180 | u16 chanctrl; | ||
181 | int in_use_descs = 0; | ||
182 | |||
183 | ioat_dma_memcpy_cleanup(ioat_chan); | ||
184 | |||
185 | ioatdma_chan_write8(ioat_chan, IOAT_CHANCMD_OFFSET, IOAT_CHANCMD_RESET); | ||
186 | |||
187 | spin_lock_bh(&ioat_chan->desc_lock); | ||
188 | list_for_each_entry_safe(desc, _desc, &ioat_chan->used_desc, node) { | ||
189 | in_use_descs++; | ||
190 | list_del(&desc->node); | ||
191 | pci_pool_free(ioat_device->dma_pool, desc->hw, desc->phys); | ||
192 | kfree(desc); | ||
193 | } | ||
194 | list_for_each_entry_safe(desc, _desc, &ioat_chan->free_desc, node) { | ||
195 | list_del(&desc->node); | ||
196 | pci_pool_free(ioat_device->dma_pool, desc->hw, desc->phys); | ||
197 | kfree(desc); | ||
198 | } | ||
199 | spin_unlock_bh(&ioat_chan->desc_lock); | ||
200 | |||
201 | pci_pool_free(ioat_device->completion_pool, | ||
202 | ioat_chan->completion_virt, | ||
203 | ioat_chan->completion_addr); | ||
204 | |||
205 | /* one is ok since we left it on there on purpose */ | ||
206 | if (in_use_descs > 1) | ||
207 | printk(KERN_ERR "IOAT: Freeing %d in use descriptors!\n", | ||
208 | in_use_descs - 1); | ||
209 | |||
210 | ioat_chan->last_completion = ioat_chan->completion_addr = 0; | ||
211 | |||
212 | /* Tell hw the chan is free */ | ||
213 | chanctrl = ioatdma_chan_read16(ioat_chan, IOAT_CHANCTRL_OFFSET); | ||
214 | chanctrl &= ~IOAT_CHANCTRL_CHANNEL_IN_USE; | ||
215 | ioatdma_chan_write16(ioat_chan, IOAT_CHANCTRL_OFFSET, chanctrl); | ||
216 | } | ||
217 | |||
218 | /** | ||
219 | * do_ioat_dma_memcpy - actual function that initiates a IOAT DMA transaction | ||
220 | * @chan: IOAT DMA channel handle | ||
221 | * @dest: DMA destination address | ||
222 | * @src: DMA source address | ||
223 | * @len: transaction length in bytes | ||
224 | */ | ||
225 | |||
226 | static dma_cookie_t do_ioat_dma_memcpy(struct ioat_dma_chan *ioat_chan, | ||
227 | dma_addr_t dest, | ||
228 | dma_addr_t src, | ||
229 | size_t len) | ||
230 | { | ||
231 | struct ioat_desc_sw *first; | ||
232 | struct ioat_desc_sw *prev; | ||
233 | struct ioat_desc_sw *new; | ||
234 | dma_cookie_t cookie; | ||
235 | LIST_HEAD(new_chain); | ||
236 | u32 copy; | ||
237 | size_t orig_len; | ||
238 | dma_addr_t orig_src, orig_dst; | ||
239 | unsigned int desc_count = 0; | ||
240 | unsigned int append = 0; | ||
241 | |||
242 | if (!ioat_chan || !dest || !src) | ||
243 | return -EFAULT; | ||
244 | |||
245 | if (!len) | ||
246 | return ioat_chan->common.cookie; | ||
247 | |||
248 | orig_len = len; | ||
249 | orig_src = src; | ||
250 | orig_dst = dest; | ||
251 | |||
252 | first = NULL; | ||
253 | prev = NULL; | ||
254 | |||
255 | spin_lock_bh(&ioat_chan->desc_lock); | ||
256 | |||
257 | while (len) { | ||
258 | if (!list_empty(&ioat_chan->free_desc)) { | ||
259 | new = to_ioat_desc(ioat_chan->free_desc.next); | ||
260 | list_del(&new->node); | ||
261 | } else { | ||
262 | /* try to get another desc */ | ||
263 | new = ioat_dma_alloc_descriptor(ioat_chan, GFP_ATOMIC); | ||
264 | /* will this ever happen? */ | ||
265 | /* TODO add upper limit on these */ | ||
266 | BUG_ON(!new); | ||
267 | } | ||
268 | |||
269 | copy = min((u32) len, ioat_chan->xfercap); | ||
270 | |||
271 | new->hw->size = copy; | ||
272 | new->hw->ctl = 0; | ||
273 | new->hw->src_addr = src; | ||
274 | new->hw->dst_addr = dest; | ||
275 | new->cookie = 0; | ||
276 | |||
277 | /* chain together the physical address list for the HW */ | ||
278 | if (!first) | ||
279 | first = new; | ||
280 | else | ||
281 | prev->hw->next = (u64) new->phys; | ||
282 | |||
283 | prev = new; | ||
284 | |||
285 | len -= copy; | ||
286 | dest += copy; | ||
287 | src += copy; | ||
288 | |||
289 | list_add_tail(&new->node, &new_chain); | ||
290 | desc_count++; | ||
291 | } | ||
292 | new->hw->ctl = IOAT_DMA_DESCRIPTOR_CTL_CP_STS; | ||
293 | new->hw->next = 0; | ||
294 | |||
295 | /* cookie incr and addition to used_list must be atomic */ | ||
296 | |||
297 | cookie = ioat_chan->common.cookie; | ||
298 | cookie++; | ||
299 | if (cookie < 0) | ||
300 | cookie = 1; | ||
301 | ioat_chan->common.cookie = new->cookie = cookie; | ||
302 | |||
303 | pci_unmap_addr_set(new, src, orig_src); | ||
304 | pci_unmap_addr_set(new, dst, orig_dst); | ||
305 | pci_unmap_len_set(new, src_len, orig_len); | ||
306 | pci_unmap_len_set(new, dst_len, orig_len); | ||
307 | |||
308 | /* write address into NextDescriptor field of last desc in chain */ | ||
309 | to_ioat_desc(ioat_chan->used_desc.prev)->hw->next = first->phys; | ||
310 | list_splice_init(&new_chain, ioat_chan->used_desc.prev); | ||
311 | |||
312 | ioat_chan->pending += desc_count; | ||
313 | if (ioat_chan->pending >= 20) { | ||
314 | append = 1; | ||
315 | ioat_chan->pending = 0; | ||
316 | } | ||
317 | |||
318 | spin_unlock_bh(&ioat_chan->desc_lock); | ||
319 | |||
320 | if (append) | ||
321 | ioatdma_chan_write8(ioat_chan, | ||
322 | IOAT_CHANCMD_OFFSET, | ||
323 | IOAT_CHANCMD_APPEND); | ||
324 | return cookie; | ||
325 | } | ||
326 | |||
327 | /** | ||
328 | * ioat_dma_memcpy_buf_to_buf - wrapper that takes src & dest bufs | ||
329 | * @chan: IOAT DMA channel handle | ||
330 | * @dest: DMA destination address | ||
331 | * @src: DMA source address | ||
332 | * @len: transaction length in bytes | ||
333 | */ | ||
334 | |||
335 | static dma_cookie_t ioat_dma_memcpy_buf_to_buf(struct dma_chan *chan, | ||
336 | void *dest, | ||
337 | void *src, | ||
338 | size_t len) | ||
339 | { | ||
340 | dma_addr_t dest_addr; | ||
341 | dma_addr_t src_addr; | ||
342 | struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan); | ||
343 | |||
344 | dest_addr = pci_map_single(ioat_chan->device->pdev, | ||
345 | dest, len, PCI_DMA_FROMDEVICE); | ||
346 | src_addr = pci_map_single(ioat_chan->device->pdev, | ||
347 | src, len, PCI_DMA_TODEVICE); | ||
348 | |||
349 | return do_ioat_dma_memcpy(ioat_chan, dest_addr, src_addr, len); | ||
350 | } | ||
351 | |||
352 | /** | ||
353 | * ioat_dma_memcpy_buf_to_pg - wrapper, copying from a buf to a page | ||
354 | * @chan: IOAT DMA channel handle | ||
355 | * @page: pointer to the page to copy to | ||
356 | * @offset: offset into that page | ||
357 | * @src: DMA source address | ||
358 | * @len: transaction length in bytes | ||
359 | */ | ||
360 | |||
361 | static dma_cookie_t ioat_dma_memcpy_buf_to_pg(struct dma_chan *chan, | ||
362 | struct page *page, | ||
363 | unsigned int offset, | ||
364 | void *src, | ||
365 | size_t len) | ||
366 | { | ||
367 | dma_addr_t dest_addr; | ||
368 | dma_addr_t src_addr; | ||
369 | struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan); | ||
370 | |||
371 | dest_addr = pci_map_page(ioat_chan->device->pdev, | ||
372 | page, offset, len, PCI_DMA_FROMDEVICE); | ||
373 | src_addr = pci_map_single(ioat_chan->device->pdev, | ||
374 | src, len, PCI_DMA_TODEVICE); | ||
375 | |||
376 | return do_ioat_dma_memcpy(ioat_chan, dest_addr, src_addr, len); | ||
377 | } | ||
378 | |||
379 | /** | ||
380 | * ioat_dma_memcpy_pg_to_pg - wrapper, copying between two pages | ||
381 | * @chan: IOAT DMA channel handle | ||
382 | * @dest_pg: pointer to the page to copy to | ||
383 | * @dest_off: offset into that page | ||
384 | * @src_pg: pointer to the page to copy from | ||
385 | * @src_off: offset into that page | ||
386 | * @len: transaction length in bytes. This is guaranteed to not make a copy | ||
387 | * across a page boundary. | ||
388 | */ | ||
389 | |||
390 | static dma_cookie_t ioat_dma_memcpy_pg_to_pg(struct dma_chan *chan, | ||
391 | struct page *dest_pg, | ||
392 | unsigned int dest_off, | ||
393 | struct page *src_pg, | ||
394 | unsigned int src_off, | ||
395 | size_t len) | ||
396 | { | ||
397 | dma_addr_t dest_addr; | ||
398 | dma_addr_t src_addr; | ||
399 | struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan); | ||
400 | |||
401 | dest_addr = pci_map_page(ioat_chan->device->pdev, | ||
402 | dest_pg, dest_off, len, PCI_DMA_FROMDEVICE); | ||
403 | src_addr = pci_map_page(ioat_chan->device->pdev, | ||
404 | src_pg, src_off, len, PCI_DMA_TODEVICE); | ||
405 | |||
406 | return do_ioat_dma_memcpy(ioat_chan, dest_addr, src_addr, len); | ||
407 | } | ||
408 | |||
409 | /** | ||
410 | * ioat_dma_memcpy_issue_pending - push potentially unrecognoized appended descriptors to hw | ||
411 | * @chan: DMA channel handle | ||
412 | */ | ||
413 | |||
414 | static void ioat_dma_memcpy_issue_pending(struct dma_chan *chan) | ||
415 | { | ||
416 | struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan); | ||
417 | |||
418 | if (ioat_chan->pending != 0) { | ||
419 | ioat_chan->pending = 0; | ||
420 | ioatdma_chan_write8(ioat_chan, | ||
421 | IOAT_CHANCMD_OFFSET, | ||
422 | IOAT_CHANCMD_APPEND); | ||
423 | } | ||
424 | } | ||
425 | |||
426 | static void ioat_dma_memcpy_cleanup(struct ioat_dma_chan *chan) | ||
427 | { | ||
428 | unsigned long phys_complete; | ||
429 | struct ioat_desc_sw *desc, *_desc; | ||
430 | dma_cookie_t cookie = 0; | ||
431 | |||
432 | prefetch(chan->completion_virt); | ||
433 | |||
434 | if (!spin_trylock(&chan->cleanup_lock)) | ||
435 | return; | ||
436 | |||
437 | /* The completion writeback can happen at any time, | ||
438 | so reads by the driver need to be atomic operations | ||
439 | The descriptor physical addresses are limited to 32-bits | ||
440 | when the CPU can only do a 32-bit mov */ | ||
441 | |||
442 | #if (BITS_PER_LONG == 64) | ||
443 | phys_complete = | ||
444 | chan->completion_virt->full & IOAT_CHANSTS_COMPLETED_DESCRIPTOR_ADDR; | ||
445 | #else | ||
446 | phys_complete = chan->completion_virt->low & IOAT_LOW_COMPLETION_MASK; | ||
447 | #endif | ||
448 | |||
449 | if ((chan->completion_virt->full & IOAT_CHANSTS_DMA_TRANSFER_STATUS) == | ||
450 | IOAT_CHANSTS_DMA_TRANSFER_STATUS_HALTED) { | ||
451 | printk("IOAT: Channel halted, chanerr = %x\n", | ||
452 | ioatdma_chan_read32(chan, IOAT_CHANERR_OFFSET)); | ||
453 | |||
454 | /* TODO do something to salvage the situation */ | ||
455 | } | ||
456 | |||
457 | if (phys_complete == chan->last_completion) { | ||
458 | spin_unlock(&chan->cleanup_lock); | ||
459 | return; | ||
460 | } | ||
461 | |||
462 | spin_lock_bh(&chan->desc_lock); | ||
463 | list_for_each_entry_safe(desc, _desc, &chan->used_desc, node) { | ||
464 | |||
465 | /* | ||
466 | * Incoming DMA requests may use multiple descriptors, due to | ||
467 | * exceeding xfercap, perhaps. If so, only the last one will | ||
468 | * have a cookie, and require unmapping. | ||
469 | */ | ||
470 | if (desc->cookie) { | ||
471 | cookie = desc->cookie; | ||
472 | |||
473 | /* yes we are unmapping both _page and _single alloc'd | ||
474 | regions with unmap_page. Is this *really* that bad? | ||
475 | */ | ||
476 | pci_unmap_page(chan->device->pdev, | ||
477 | pci_unmap_addr(desc, dst), | ||
478 | pci_unmap_len(desc, dst_len), | ||
479 | PCI_DMA_FROMDEVICE); | ||
480 | pci_unmap_page(chan->device->pdev, | ||
481 | pci_unmap_addr(desc, src), | ||
482 | pci_unmap_len(desc, src_len), | ||
483 | PCI_DMA_TODEVICE); | ||
484 | } | ||
485 | |||
486 | if (desc->phys != phys_complete) { | ||
487 | /* a completed entry, but not the last, so cleanup */ | ||
488 | list_del(&desc->node); | ||
489 | list_add_tail(&desc->node, &chan->free_desc); | ||
490 | } else { | ||
491 | /* last used desc. Do not remove, so we can append from | ||
492 | it, but don't look at it next time, either */ | ||
493 | desc->cookie = 0; | ||
494 | |||
495 | /* TODO check status bits? */ | ||
496 | break; | ||
497 | } | ||
498 | } | ||
499 | |||
500 | spin_unlock_bh(&chan->desc_lock); | ||
501 | |||
502 | chan->last_completion = phys_complete; | ||
503 | if (cookie != 0) | ||
504 | chan->completed_cookie = cookie; | ||
505 | |||
506 | spin_unlock(&chan->cleanup_lock); | ||
507 | } | ||
508 | |||
509 | /** | ||
510 | * ioat_dma_is_complete - poll the status of a IOAT DMA transaction | ||
511 | * @chan: IOAT DMA channel handle | ||
512 | * @cookie: DMA transaction identifier | ||
513 | */ | ||
514 | |||
515 | static enum dma_status ioat_dma_is_complete(struct dma_chan *chan, | ||
516 | dma_cookie_t cookie, | ||
517 | dma_cookie_t *done, | ||
518 | dma_cookie_t *used) | ||
519 | { | ||
520 | struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan); | ||
521 | dma_cookie_t last_used; | ||
522 | dma_cookie_t last_complete; | ||
523 | enum dma_status ret; | ||
524 | |||
525 | last_used = chan->cookie; | ||
526 | last_complete = ioat_chan->completed_cookie; | ||
527 | |||
528 | if (done) | ||
529 | *done= last_complete; | ||
530 | if (used) | ||
531 | *used = last_used; | ||
532 | |||
533 | ret = dma_async_is_complete(cookie, last_complete, last_used); | ||
534 | if (ret == DMA_SUCCESS) | ||
535 | return ret; | ||
536 | |||
537 | ioat_dma_memcpy_cleanup(ioat_chan); | ||
538 | |||
539 | last_used = chan->cookie; | ||
540 | last_complete = ioat_chan->completed_cookie; | ||
541 | |||
542 | if (done) | ||
543 | *done= last_complete; | ||
544 | if (used) | ||
545 | *used = last_used; | ||
546 | |||
547 | return dma_async_is_complete(cookie, last_complete, last_used); | ||
548 | } | ||
549 | |||
550 | /* PCI API */ | ||
551 | |||
552 | static struct pci_device_id ioat_pci_tbl[] = { | ||
553 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT) }, | ||
554 | { 0, } | ||
555 | }; | ||
556 | |||
557 | static struct pci_driver ioat_pci_drv = { | ||
558 | .name = "ioatdma", | ||
559 | .id_table = ioat_pci_tbl, | ||
560 | .probe = ioat_probe, | ||
561 | .remove = __devexit_p(ioat_remove), | ||
562 | }; | ||
563 | |||
564 | static irqreturn_t ioat_do_interrupt(int irq, void *data, struct pt_regs *regs) | ||
565 | { | ||
566 | struct ioat_device *instance = data; | ||
567 | unsigned long attnstatus; | ||
568 | u8 intrctrl; | ||
569 | |||
570 | intrctrl = ioatdma_read8(instance, IOAT_INTRCTRL_OFFSET); | ||
571 | |||
572 | if (!(intrctrl & IOAT_INTRCTRL_MASTER_INT_EN)) | ||
573 | return IRQ_NONE; | ||
574 | |||
575 | if (!(intrctrl & IOAT_INTRCTRL_INT_STATUS)) { | ||
576 | ioatdma_write8(instance, IOAT_INTRCTRL_OFFSET, intrctrl); | ||
577 | return IRQ_NONE; | ||
578 | } | ||
579 | |||
580 | attnstatus = ioatdma_read32(instance, IOAT_ATTNSTATUS_OFFSET); | ||
581 | |||
582 | printk(KERN_ERR "ioatdma error: interrupt! status %lx\n", attnstatus); | ||
583 | |||
584 | ioatdma_write8(instance, IOAT_INTRCTRL_OFFSET, intrctrl); | ||
585 | return IRQ_HANDLED; | ||
586 | } | ||
587 | |||
588 | static void ioat_start_null_desc(struct ioat_dma_chan *ioat_chan) | ||
589 | { | ||
590 | struct ioat_desc_sw *desc; | ||
591 | |||
592 | spin_lock_bh(&ioat_chan->desc_lock); | ||
593 | |||
594 | if (!list_empty(&ioat_chan->free_desc)) { | ||
595 | desc = to_ioat_desc(ioat_chan->free_desc.next); | ||
596 | list_del(&desc->node); | ||
597 | } else { | ||
598 | /* try to get another desc */ | ||
599 | spin_unlock_bh(&ioat_chan->desc_lock); | ||
600 | desc = ioat_dma_alloc_descriptor(ioat_chan, GFP_KERNEL); | ||
601 | spin_lock_bh(&ioat_chan->desc_lock); | ||
602 | /* will this ever happen? */ | ||
603 | BUG_ON(!desc); | ||
604 | } | ||
605 | |||
606 | desc->hw->ctl = IOAT_DMA_DESCRIPTOR_NUL; | ||
607 | desc->hw->next = 0; | ||
608 | |||
609 | list_add_tail(&desc->node, &ioat_chan->used_desc); | ||
610 | spin_unlock_bh(&ioat_chan->desc_lock); | ||
611 | |||
612 | #if (BITS_PER_LONG == 64) | ||
613 | ioatdma_chan_write64(ioat_chan, IOAT_CHAINADDR_OFFSET, desc->phys); | ||
614 | #else | ||
615 | ioatdma_chan_write32(ioat_chan, | ||
616 | IOAT_CHAINADDR_OFFSET_LOW, | ||
617 | (u32) desc->phys); | ||
618 | ioatdma_chan_write32(ioat_chan, IOAT_CHAINADDR_OFFSET_HIGH, 0); | ||
619 | #endif | ||
620 | ioatdma_chan_write8(ioat_chan, IOAT_CHANCMD_OFFSET, IOAT_CHANCMD_START); | ||
621 | } | ||
622 | |||
623 | /* | ||
624 | * Perform a IOAT transaction to verify the HW works. | ||
625 | */ | ||
626 | #define IOAT_TEST_SIZE 2000 | ||
627 | |||
628 | static int ioat_self_test(struct ioat_device *device) | ||
629 | { | ||
630 | int i; | ||
631 | u8 *src; | ||
632 | u8 *dest; | ||
633 | struct dma_chan *dma_chan; | ||
634 | dma_cookie_t cookie; | ||
635 | int err = 0; | ||
636 | |||
637 | src = kzalloc(sizeof(u8) * IOAT_TEST_SIZE, SLAB_KERNEL); | ||
638 | if (!src) | ||
639 | return -ENOMEM; | ||
640 | dest = kzalloc(sizeof(u8) * IOAT_TEST_SIZE, SLAB_KERNEL); | ||
641 | if (!dest) { | ||
642 | kfree(src); | ||
643 | return -ENOMEM; | ||
644 | } | ||
645 | |||
646 | /* Fill in src buffer */ | ||
647 | for (i = 0; i < IOAT_TEST_SIZE; i++) | ||
648 | src[i] = (u8)i; | ||
649 | |||
650 | /* Start copy, using first DMA channel */ | ||
651 | dma_chan = container_of(device->common.channels.next, | ||
652 | struct dma_chan, | ||
653 | device_node); | ||
654 | if (ioat_dma_alloc_chan_resources(dma_chan) < 1) { | ||
655 | err = -ENODEV; | ||
656 | goto out; | ||
657 | } | ||
658 | |||
659 | cookie = ioat_dma_memcpy_buf_to_buf(dma_chan, dest, src, IOAT_TEST_SIZE); | ||
660 | ioat_dma_memcpy_issue_pending(dma_chan); | ||
661 | msleep(1); | ||
662 | |||
663 | if (ioat_dma_is_complete(dma_chan, cookie, NULL, NULL) != DMA_SUCCESS) { | ||
664 | printk(KERN_ERR "ioatdma: Self-test copy timed out, disabling\n"); | ||
665 | err = -ENODEV; | ||
666 | goto free_resources; | ||
667 | } | ||
668 | if (memcmp(src, dest, IOAT_TEST_SIZE)) { | ||
669 | printk(KERN_ERR "ioatdma: Self-test copy failed compare, disabling\n"); | ||
670 | err = -ENODEV; | ||
671 | goto free_resources; | ||
672 | } | ||
673 | |||
674 | free_resources: | ||
675 | ioat_dma_free_chan_resources(dma_chan); | ||
676 | out: | ||
677 | kfree(src); | ||
678 | kfree(dest); | ||
679 | return err; | ||
680 | } | ||
681 | |||
682 | static int __devinit ioat_probe(struct pci_dev *pdev, | ||
683 | const struct pci_device_id *ent) | ||
684 | { | ||
685 | int err; | ||
686 | unsigned long mmio_start, mmio_len; | ||
687 | void *reg_base; | ||
688 | struct ioat_device *device; | ||
689 | |||
690 | err = pci_enable_device(pdev); | ||
691 | if (err) | ||
692 | goto err_enable_device; | ||
693 | |||
694 | err = pci_set_dma_mask(pdev, DMA_64BIT_MASK); | ||
695 | if (err) | ||
696 | err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); | ||
697 | if (err) | ||
698 | goto err_set_dma_mask; | ||
699 | |||
700 | err = pci_request_regions(pdev, ioat_pci_drv.name); | ||
701 | if (err) | ||
702 | goto err_request_regions; | ||
703 | |||
704 | mmio_start = pci_resource_start(pdev, 0); | ||
705 | mmio_len = pci_resource_len(pdev, 0); | ||
706 | |||
707 | reg_base = ioremap(mmio_start, mmio_len); | ||
708 | if (!reg_base) { | ||
709 | err = -ENOMEM; | ||
710 | goto err_ioremap; | ||
711 | } | ||
712 | |||
713 | device = kzalloc(sizeof(*device), GFP_KERNEL); | ||
714 | if (!device) { | ||
715 | err = -ENOMEM; | ||
716 | goto err_kzalloc; | ||
717 | } | ||
718 | |||
719 | /* DMA coherent memory pool for DMA descriptor allocations */ | ||
720 | device->dma_pool = pci_pool_create("dma_desc_pool", pdev, | ||
721 | sizeof(struct ioat_dma_descriptor), 64, 0); | ||
722 | if (!device->dma_pool) { | ||
723 | err = -ENOMEM; | ||
724 | goto err_dma_pool; | ||
725 | } | ||
726 | |||
727 | device->completion_pool = pci_pool_create("completion_pool", pdev, sizeof(u64), SMP_CACHE_BYTES, SMP_CACHE_BYTES); | ||
728 | if (!device->completion_pool) { | ||
729 | err = -ENOMEM; | ||
730 | goto err_completion_pool; | ||
731 | } | ||
732 | |||
733 | device->pdev = pdev; | ||
734 | pci_set_drvdata(pdev, device); | ||
735 | #ifdef CONFIG_PCI_MSI | ||
736 | if (pci_enable_msi(pdev) == 0) { | ||
737 | device->msi = 1; | ||
738 | } else { | ||
739 | device->msi = 0; | ||
740 | } | ||
741 | #endif | ||
742 | err = request_irq(pdev->irq, &ioat_do_interrupt, SA_SHIRQ, "ioat", | ||
743 | device); | ||
744 | if (err) | ||
745 | goto err_irq; | ||
746 | |||
747 | device->reg_base = reg_base; | ||
748 | |||
749 | ioatdma_write8(device, IOAT_INTRCTRL_OFFSET, IOAT_INTRCTRL_MASTER_INT_EN); | ||
750 | pci_set_master(pdev); | ||
751 | |||
752 | INIT_LIST_HEAD(&device->common.channels); | ||
753 | enumerate_dma_channels(device); | ||
754 | |||
755 | device->common.device_alloc_chan_resources = ioat_dma_alloc_chan_resources; | ||
756 | device->common.device_free_chan_resources = ioat_dma_free_chan_resources; | ||
757 | device->common.device_memcpy_buf_to_buf = ioat_dma_memcpy_buf_to_buf; | ||
758 | device->common.device_memcpy_buf_to_pg = ioat_dma_memcpy_buf_to_pg; | ||
759 | device->common.device_memcpy_pg_to_pg = ioat_dma_memcpy_pg_to_pg; | ||
760 | device->common.device_memcpy_complete = ioat_dma_is_complete; | ||
761 | device->common.device_memcpy_issue_pending = ioat_dma_memcpy_issue_pending; | ||
762 | printk(KERN_INFO "Intel(R) I/OAT DMA Engine found, %d channels\n", | ||
763 | device->common.chancnt); | ||
764 | |||
765 | err = ioat_self_test(device); | ||
766 | if (err) | ||
767 | goto err_self_test; | ||
768 | |||
769 | dma_async_device_register(&device->common); | ||
770 | |||
771 | return 0; | ||
772 | |||
773 | err_self_test: | ||
774 | err_irq: | ||
775 | pci_pool_destroy(device->completion_pool); | ||
776 | err_completion_pool: | ||
777 | pci_pool_destroy(device->dma_pool); | ||
778 | err_dma_pool: | ||
779 | kfree(device); | ||
780 | err_kzalloc: | ||
781 | iounmap(reg_base); | ||
782 | err_ioremap: | ||
783 | pci_release_regions(pdev); | ||
784 | err_request_regions: | ||
785 | err_set_dma_mask: | ||
786 | pci_disable_device(pdev); | ||
787 | err_enable_device: | ||
788 | return err; | ||
789 | } | ||
790 | |||
791 | static void __devexit ioat_remove(struct pci_dev *pdev) | ||
792 | { | ||
793 | struct ioat_device *device; | ||
794 | struct dma_chan *chan, *_chan; | ||
795 | struct ioat_dma_chan *ioat_chan; | ||
796 | |||
797 | device = pci_get_drvdata(pdev); | ||
798 | dma_async_device_unregister(&device->common); | ||
799 | |||
800 | free_irq(device->pdev->irq, device); | ||
801 | #ifdef CONFIG_PCI_MSI | ||
802 | if (device->msi) | ||
803 | pci_disable_msi(device->pdev); | ||
804 | #endif | ||
805 | pci_pool_destroy(device->dma_pool); | ||
806 | pci_pool_destroy(device->completion_pool); | ||
807 | iounmap(device->reg_base); | ||
808 | pci_release_regions(pdev); | ||
809 | pci_disable_device(pdev); | ||
810 | list_for_each_entry_safe(chan, _chan, &device->common.channels, device_node) { | ||
811 | ioat_chan = to_ioat_chan(chan); | ||
812 | list_del(&chan->device_node); | ||
813 | kfree(ioat_chan); | ||
814 | } | ||
815 | kfree(device); | ||
816 | } | ||
817 | |||
818 | /* MODULE API */ | ||
819 | MODULE_VERSION("1.7"); | ||
820 | MODULE_LICENSE("GPL"); | ||
821 | MODULE_AUTHOR("Intel Corporation"); | ||
822 | |||
823 | static int __init ioat_init_module(void) | ||
824 | { | ||
825 | /* it's currently unsafe to unload this module */ | ||
826 | /* if forced, worst case is that rmmod hangs */ | ||
827 | if (THIS_MODULE != NULL) | ||
828 | THIS_MODULE->unsafe = 1; | ||
829 | |||
830 | return pci_module_init(&ioat_pci_drv); | ||
831 | } | ||
832 | |||
833 | module_init(ioat_init_module); | ||
834 | |||
835 | static void __exit ioat_exit_module(void) | ||
836 | { | ||
837 | pci_unregister_driver(&ioat_pci_drv); | ||
838 | } | ||
839 | |||
840 | module_exit(ioat_exit_module); | ||
diff --git a/drivers/dma/ioatdma.h b/drivers/dma/ioatdma.h new file mode 100644 index 000000000000..a5d3b3644160 --- /dev/null +++ b/drivers/dma/ioatdma.h | |||
@@ -0,0 +1,125 @@ | |||
1 | /* | ||
2 | * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms of the GNU General Public License as published by the Free | ||
6 | * Software Foundation; either version 2 of the License, or (at your option) | ||
7 | * any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., 59 | ||
16 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | * | ||
18 | * The full GNU General Public License is included in this distribution in the | ||
19 | * file called COPYING. | ||
20 | */ | ||
21 | #ifndef IOATDMA_H | ||
22 | #define IOATDMA_H | ||
23 | |||
24 | #include <linux/dmaengine.h> | ||
25 | #include "ioatdma_hw.h" | ||
26 | #include <linux/init.h> | ||
27 | #include <linux/dmapool.h> | ||
28 | #include <linux/cache.h> | ||
29 | #include <linux/pci_ids.h> | ||
30 | |||
31 | #define IOAT_LOW_COMPLETION_MASK 0xffffffc0 | ||
32 | |||
33 | extern struct list_head dma_device_list; | ||
34 | extern struct list_head dma_client_list; | ||
35 | |||
36 | /** | ||
37 | * struct ioat_device - internal representation of a IOAT device | ||
38 | * @pdev: PCI-Express device | ||
39 | * @reg_base: MMIO register space base address | ||
40 | * @dma_pool: for allocating DMA descriptors | ||
41 | * @common: embedded struct dma_device | ||
42 | * @msi: Message Signaled Interrupt number | ||
43 | */ | ||
44 | |||
45 | struct ioat_device { | ||
46 | struct pci_dev *pdev; | ||
47 | void *reg_base; | ||
48 | struct pci_pool *dma_pool; | ||
49 | struct pci_pool *completion_pool; | ||
50 | |||
51 | struct dma_device common; | ||
52 | u8 msi; | ||
53 | }; | ||
54 | |||
55 | /** | ||
56 | * struct ioat_dma_chan - internal representation of a DMA channel | ||
57 | * @device: | ||
58 | * @reg_base: | ||
59 | * @sw_in_use: | ||
60 | * @completion: | ||
61 | * @completion_low: | ||
62 | * @completion_high: | ||
63 | * @completed_cookie: last cookie seen completed on cleanup | ||
64 | * @cookie: value of last cookie given to client | ||
65 | * @last_completion: | ||
66 | * @xfercap: | ||
67 | * @desc_lock: | ||
68 | * @free_desc: | ||
69 | * @used_desc: | ||
70 | * @resource: | ||
71 | * @device_node: | ||
72 | */ | ||
73 | |||
74 | struct ioat_dma_chan { | ||
75 | |||
76 | void *reg_base; | ||
77 | |||
78 | dma_cookie_t completed_cookie; | ||
79 | unsigned long last_completion; | ||
80 | |||
81 | u32 xfercap; /* XFERCAP register value expanded out */ | ||
82 | |||
83 | spinlock_t cleanup_lock; | ||
84 | spinlock_t desc_lock; | ||
85 | struct list_head free_desc; | ||
86 | struct list_head used_desc; | ||
87 | |||
88 | int pending; | ||
89 | |||
90 | struct ioat_device *device; | ||
91 | struct dma_chan common; | ||
92 | |||
93 | dma_addr_t completion_addr; | ||
94 | union { | ||
95 | u64 full; /* HW completion writeback */ | ||
96 | struct { | ||
97 | u32 low; | ||
98 | u32 high; | ||
99 | }; | ||
100 | } *completion_virt; | ||
101 | }; | ||
102 | |||
103 | /* wrapper around hardware descriptor format + additional software fields */ | ||
104 | |||
105 | /** | ||
106 | * struct ioat_desc_sw - wrapper around hardware descriptor | ||
107 | * @hw: hardware DMA descriptor | ||
108 | * @node: | ||
109 | * @cookie: | ||
110 | * @phys: | ||
111 | */ | ||
112 | |||
113 | struct ioat_desc_sw { | ||
114 | struct ioat_dma_descriptor *hw; | ||
115 | struct list_head node; | ||
116 | dma_cookie_t cookie; | ||
117 | dma_addr_t phys; | ||
118 | DECLARE_PCI_UNMAP_ADDR(src) | ||
119 | DECLARE_PCI_UNMAP_LEN(src_len) | ||
120 | DECLARE_PCI_UNMAP_ADDR(dst) | ||
121 | DECLARE_PCI_UNMAP_LEN(dst_len) | ||
122 | }; | ||
123 | |||
124 | #endif /* IOATDMA_H */ | ||
125 | |||
diff --git a/drivers/dma/ioatdma_hw.h b/drivers/dma/ioatdma_hw.h new file mode 100644 index 000000000000..4d7a12880be3 --- /dev/null +++ b/drivers/dma/ioatdma_hw.h | |||
@@ -0,0 +1,52 @@ | |||
1 | /* | ||
2 | * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms of the GNU General Public License as published by the Free | ||
6 | * Software Foundation; either version 2 of the License, or (at your option) | ||
7 | * any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., 59 | ||
16 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | * | ||
18 | * The full GNU General Public License is included in this distribution in the | ||
19 | * file called COPYING. | ||
20 | */ | ||
21 | #ifndef _IOAT_HW_H_ | ||
22 | #define _IOAT_HW_H_ | ||
23 | |||
24 | /* PCI Configuration Space Values */ | ||
25 | #define IOAT_PCI_VID 0x8086 | ||
26 | #define IOAT_PCI_DID 0x1A38 | ||
27 | #define IOAT_PCI_RID 0x00 | ||
28 | #define IOAT_PCI_SVID 0x8086 | ||
29 | #define IOAT_PCI_SID 0x8086 | ||
30 | #define IOAT_VER 0x12 /* Version 1.2 */ | ||
31 | |||
32 | struct ioat_dma_descriptor { | ||
33 | uint32_t size; | ||
34 | uint32_t ctl; | ||
35 | uint64_t src_addr; | ||
36 | uint64_t dst_addr; | ||
37 | uint64_t next; | ||
38 | uint64_t rsv1; | ||
39 | uint64_t rsv2; | ||
40 | uint64_t user1; | ||
41 | uint64_t user2; | ||
42 | }; | ||
43 | |||
44 | #define IOAT_DMA_DESCRIPTOR_CTL_INT_GN 0x00000001 | ||
45 | #define IOAT_DMA_DESCRIPTOR_CTL_SRC_SN 0x00000002 | ||
46 | #define IOAT_DMA_DESCRIPTOR_CTL_DST_SN 0x00000004 | ||
47 | #define IOAT_DMA_DESCRIPTOR_CTL_CP_STS 0x00000008 | ||
48 | #define IOAT_DMA_DESCRIPTOR_CTL_FRAME 0x00000010 | ||
49 | #define IOAT_DMA_DESCRIPTOR_NUL 0x00000020 | ||
50 | #define IOAT_DMA_DESCRIPTOR_OPCODE 0xFF000000 | ||
51 | |||
52 | #endif | ||
diff --git a/drivers/dma/ioatdma_io.h b/drivers/dma/ioatdma_io.h new file mode 100644 index 000000000000..c0b4bf66c920 --- /dev/null +++ b/drivers/dma/ioatdma_io.h | |||
@@ -0,0 +1,118 @@ | |||
1 | /* | ||
2 | * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms of the GNU General Public License as published by the Free | ||
6 | * Software Foundation; either version 2 of the License, or (at your option) | ||
7 | * any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., 59 | ||
16 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | * | ||
18 | * The full GNU General Public License is included in this distribution in the | ||
19 | * file called COPYING. | ||
20 | */ | ||
21 | #ifndef IOATDMA_IO_H | ||
22 | #define IOATDMA_IO_H | ||
23 | |||
24 | #include <asm/io.h> | ||
25 | |||
26 | /* | ||
27 | * device and per-channel MMIO register read and write functions | ||
28 | * this is a lot of anoying inline functions, but it's typesafe | ||
29 | */ | ||
30 | |||
31 | static inline u8 ioatdma_read8(struct ioat_device *device, | ||
32 | unsigned int offset) | ||
33 | { | ||
34 | return readb(device->reg_base + offset); | ||
35 | } | ||
36 | |||
37 | static inline u16 ioatdma_read16(struct ioat_device *device, | ||
38 | unsigned int offset) | ||
39 | { | ||
40 | return readw(device->reg_base + offset); | ||
41 | } | ||
42 | |||
43 | static inline u32 ioatdma_read32(struct ioat_device *device, | ||
44 | unsigned int offset) | ||
45 | { | ||
46 | return readl(device->reg_base + offset); | ||
47 | } | ||
48 | |||
49 | static inline void ioatdma_write8(struct ioat_device *device, | ||
50 | unsigned int offset, u8 value) | ||
51 | { | ||
52 | writeb(value, device->reg_base + offset); | ||
53 | } | ||
54 | |||
55 | static inline void ioatdma_write16(struct ioat_device *device, | ||
56 | unsigned int offset, u16 value) | ||
57 | { | ||
58 | writew(value, device->reg_base + offset); | ||
59 | } | ||
60 | |||
61 | static inline void ioatdma_write32(struct ioat_device *device, | ||
62 | unsigned int offset, u32 value) | ||
63 | { | ||
64 | writel(value, device->reg_base + offset); | ||
65 | } | ||
66 | |||
67 | static inline u8 ioatdma_chan_read8(struct ioat_dma_chan *chan, | ||
68 | unsigned int offset) | ||
69 | { | ||
70 | return readb(chan->reg_base + offset); | ||
71 | } | ||
72 | |||
73 | static inline u16 ioatdma_chan_read16(struct ioat_dma_chan *chan, | ||
74 | unsigned int offset) | ||
75 | { | ||
76 | return readw(chan->reg_base + offset); | ||
77 | } | ||
78 | |||
79 | static inline u32 ioatdma_chan_read32(struct ioat_dma_chan *chan, | ||
80 | unsigned int offset) | ||
81 | { | ||
82 | return readl(chan->reg_base + offset); | ||
83 | } | ||
84 | |||
85 | static inline void ioatdma_chan_write8(struct ioat_dma_chan *chan, | ||
86 | unsigned int offset, u8 value) | ||
87 | { | ||
88 | writeb(value, chan->reg_base + offset); | ||
89 | } | ||
90 | |||
91 | static inline void ioatdma_chan_write16(struct ioat_dma_chan *chan, | ||
92 | unsigned int offset, u16 value) | ||
93 | { | ||
94 | writew(value, chan->reg_base + offset); | ||
95 | } | ||
96 | |||
97 | static inline void ioatdma_chan_write32(struct ioat_dma_chan *chan, | ||
98 | unsigned int offset, u32 value) | ||
99 | { | ||
100 | writel(value, chan->reg_base + offset); | ||
101 | } | ||
102 | |||
103 | #if (BITS_PER_LONG == 64) | ||
104 | static inline u64 ioatdma_chan_read64(struct ioat_dma_chan *chan, | ||
105 | unsigned int offset) | ||
106 | { | ||
107 | return readq(chan->reg_base + offset); | ||
108 | } | ||
109 | |||
110 | static inline void ioatdma_chan_write64(struct ioat_dma_chan *chan, | ||
111 | unsigned int offset, u64 value) | ||
112 | { | ||
113 | writeq(value, chan->reg_base + offset); | ||
114 | } | ||
115 | #endif | ||
116 | |||
117 | #endif /* IOATDMA_IO_H */ | ||
118 | |||
diff --git a/drivers/dma/ioatdma_registers.h b/drivers/dma/ioatdma_registers.h new file mode 100644 index 000000000000..41a21ab2b000 --- /dev/null +++ b/drivers/dma/ioatdma_registers.h | |||
@@ -0,0 +1,126 @@ | |||
1 | /* | ||
2 | * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms of the GNU General Public License as published by the Free | ||
6 | * Software Foundation; either version 2 of the License, or (at your option) | ||
7 | * any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., 59 | ||
16 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | * | ||
18 | * The full GNU General Public License is included in this distribution in the | ||
19 | * file called COPYING. | ||
20 | */ | ||
21 | #ifndef _IOAT_REGISTERS_H_ | ||
22 | #define _IOAT_REGISTERS_H_ | ||
23 | |||
24 | |||
25 | /* MMIO Device Registers */ | ||
26 | #define IOAT_CHANCNT_OFFSET 0x00 /* 8-bit */ | ||
27 | |||
28 | #define IOAT_XFERCAP_OFFSET 0x01 /* 8-bit */ | ||
29 | #define IOAT_XFERCAP_4KB 12 | ||
30 | #define IOAT_XFERCAP_8KB 13 | ||
31 | #define IOAT_XFERCAP_16KB 14 | ||
32 | #define IOAT_XFERCAP_32KB 15 | ||
33 | #define IOAT_XFERCAP_32GB 0 | ||
34 | |||
35 | #define IOAT_GENCTRL_OFFSET 0x02 /* 8-bit */ | ||
36 | #define IOAT_GENCTRL_DEBUG_EN 0x01 | ||
37 | |||
38 | #define IOAT_INTRCTRL_OFFSET 0x03 /* 8-bit */ | ||
39 | #define IOAT_INTRCTRL_MASTER_INT_EN 0x01 /* Master Interrupt Enable */ | ||
40 | #define IOAT_INTRCTRL_INT_STATUS 0x02 /* ATTNSTATUS -or- Channel Int */ | ||
41 | #define IOAT_INTRCTRL_INT 0x04 /* INT_STATUS -and- MASTER_INT_EN */ | ||
42 | |||
43 | #define IOAT_ATTNSTATUS_OFFSET 0x04 /* Each bit is a channel */ | ||
44 | |||
45 | #define IOAT_VER_OFFSET 0x08 /* 8-bit */ | ||
46 | #define IOAT_VER_MAJOR_MASK 0xF0 | ||
47 | #define IOAT_VER_MINOR_MASK 0x0F | ||
48 | #define GET_IOAT_VER_MAJOR(x) ((x) & IOAT_VER_MAJOR_MASK) | ||
49 | #define GET_IOAT_VER_MINOR(x) ((x) & IOAT_VER_MINOR_MASK) | ||
50 | |||
51 | #define IOAT_PERPORTOFFSET_OFFSET 0x0A /* 16-bit */ | ||
52 | |||
53 | #define IOAT_INTRDELAY_OFFSET 0x0C /* 16-bit */ | ||
54 | #define IOAT_INTRDELAY_INT_DELAY_MASK 0x3FFF /* Interrupt Delay Time */ | ||
55 | #define IOAT_INTRDELAY_COALESE_SUPPORT 0x8000 /* Interrupt Coalesing Supported */ | ||
56 | |||
57 | #define IOAT_DEVICE_STATUS_OFFSET 0x0E /* 16-bit */ | ||
58 | #define IOAT_DEVICE_STATUS_DEGRADED_MODE 0x0001 | ||
59 | |||
60 | |||
61 | #define IOAT_CHANNEL_MMIO_SIZE 0x80 /* Each Channel MMIO space is this size */ | ||
62 | |||
63 | /* DMA Channel Registers */ | ||
64 | #define IOAT_CHANCTRL_OFFSET 0x00 /* 16-bit Channel Control Register */ | ||
65 | #define IOAT_CHANCTRL_CHANNEL_PRIORITY_MASK 0xF000 | ||
66 | #define IOAT_CHANCTRL_CHANNEL_IN_USE 0x0100 | ||
67 | #define IOAT_CHANCTRL_DESCRIPTOR_ADDR_SNOOP_CONTROL 0x0020 | ||
68 | #define IOAT_CHANCTRL_ERR_INT_EN 0x0010 | ||
69 | #define IOAT_CHANCTRL_ANY_ERR_ABORT_EN 0x0008 | ||
70 | #define IOAT_CHANCTRL_ERR_COMPLETION_EN 0x0004 | ||
71 | #define IOAT_CHANCTRL_INT_DISABLE 0x0001 | ||
72 | |||
73 | #define IOAT_DMA_COMP_OFFSET 0x02 /* 16-bit DMA channel compatability */ | ||
74 | #define IOAT_DMA_COMP_V1 0x0001 /* Compatability with DMA version 1 */ | ||
75 | |||
76 | #define IOAT_CHANSTS_OFFSET 0x04 /* 64-bit Channel Status Register */ | ||
77 | #define IOAT_CHANSTS_OFFSET_LOW 0x04 | ||
78 | #define IOAT_CHANSTS_OFFSET_HIGH 0x08 | ||
79 | #define IOAT_CHANSTS_COMPLETED_DESCRIPTOR_ADDR 0xFFFFFFFFFFFFFFC0 | ||
80 | #define IOAT_CHANSTS_SOFT_ERR 0x0000000000000010 | ||
81 | #define IOAT_CHANSTS_DMA_TRANSFER_STATUS 0x0000000000000007 | ||
82 | #define IOAT_CHANSTS_DMA_TRANSFER_STATUS_ACTIVE 0x0 | ||
83 | #define IOAT_CHANSTS_DMA_TRANSFER_STATUS_DONE 0x1 | ||
84 | #define IOAT_CHANSTS_DMA_TRANSFER_STATUS_SUSPENDED 0x2 | ||
85 | #define IOAT_CHANSTS_DMA_TRANSFER_STATUS_HALTED 0x3 | ||
86 | |||
87 | #define IOAT_CHAINADDR_OFFSET 0x0C /* 64-bit Descriptor Chain Address Register */ | ||
88 | #define IOAT_CHAINADDR_OFFSET_LOW 0x0C | ||
89 | #define IOAT_CHAINADDR_OFFSET_HIGH 0x10 | ||
90 | |||
91 | #define IOAT_CHANCMD_OFFSET 0x14 /* 8-bit DMA Channel Command Register */ | ||
92 | #define IOAT_CHANCMD_RESET 0x20 | ||
93 | #define IOAT_CHANCMD_RESUME 0x10 | ||
94 | #define IOAT_CHANCMD_ABORT 0x08 | ||
95 | #define IOAT_CHANCMD_SUSPEND 0x04 | ||
96 | #define IOAT_CHANCMD_APPEND 0x02 | ||
97 | #define IOAT_CHANCMD_START 0x01 | ||
98 | |||
99 | #define IOAT_CHANCMP_OFFSET 0x18 /* 64-bit Channel Completion Address Register */ | ||
100 | #define IOAT_CHANCMP_OFFSET_LOW 0x18 | ||
101 | #define IOAT_CHANCMP_OFFSET_HIGH 0x1C | ||
102 | |||
103 | #define IOAT_CDAR_OFFSET 0x20 /* 64-bit Current Descriptor Address Register */ | ||
104 | #define IOAT_CDAR_OFFSET_LOW 0x20 | ||
105 | #define IOAT_CDAR_OFFSET_HIGH 0x24 | ||
106 | |||
107 | #define IOAT_CHANERR_OFFSET 0x28 /* 32-bit Channel Error Register */ | ||
108 | #define IOAT_CHANERR_DMA_TRANSFER_SRC_ADDR_ERR 0x0001 | ||
109 | #define IOAT_CHANERR_DMA_TRANSFER_DEST_ADDR_ERR 0x0002 | ||
110 | #define IOAT_CHANERR_NEXT_DESCRIPTOR_ADDR_ERR 0x0004 | ||
111 | #define IOAT_CHANERR_NEXT_DESCRIPTOR_ALIGNMENT_ERR 0x0008 | ||
112 | #define IOAT_CHANERR_CHAIN_ADDR_VALUE_ERR 0x0010 | ||
113 | #define IOAT_CHANERR_CHANCMD_ERR 0x0020 | ||
114 | #define IOAT_CHANERR_CHIPSET_UNCORRECTABLE_DATA_INTEGRITY_ERR 0x0040 | ||
115 | #define IOAT_CHANERR_DMA_UNCORRECTABLE_DATA_INTEGRITY_ERR 0x0080 | ||
116 | #define IOAT_CHANERR_READ_DATA_ERR 0x0100 | ||
117 | #define IOAT_CHANERR_WRITE_DATA_ERR 0x0200 | ||
118 | #define IOAT_CHANERR_DESCRIPTOR_CONTROL_ERR 0x0400 | ||
119 | #define IOAT_CHANERR_DESCRIPTOR_LENGTH_ERR 0x0800 | ||
120 | #define IOAT_CHANERR_COMPLETION_ADDR_ERR 0x1000 | ||
121 | #define IOAT_CHANERR_INT_CONFIGURATION_ERR 0x2000 | ||
122 | #define IOAT_CHANERR_SOFT_ERR 0x4000 | ||
123 | |||
124 | #define IOAT_CHANERR_MASK_OFFSET 0x2C /* 32-bit Channel Error Register */ | ||
125 | |||
126 | #endif /* _IOAT_REGISTERS_H_ */ | ||
diff --git a/drivers/dma/iovlock.c b/drivers/dma/iovlock.c new file mode 100644 index 000000000000..5ed327e453a2 --- /dev/null +++ b/drivers/dma/iovlock.c | |||
@@ -0,0 +1,301 @@ | |||
1 | /* | ||
2 | * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved. | ||
3 | * Portions based on net/core/datagram.c and copyrighted by their authors. | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify it | ||
6 | * under the terms of the GNU General Public License as published by the Free | ||
7 | * Software Foundation; either version 2 of the License, or (at your option) | ||
8 | * any later version. | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
13 | * more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License along with | ||
16 | * this program; if not, write to the Free Software Foundation, Inc., 59 | ||
17 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
18 | * | ||
19 | * The full GNU General Public License is included in this distribution in the | ||
20 | * file called COPYING. | ||
21 | */ | ||
22 | |||
23 | /* | ||
24 | * This code allows the net stack to make use of a DMA engine for | ||
25 | * skb to iovec copies. | ||
26 | */ | ||
27 | |||
28 | #include <linux/dmaengine.h> | ||
29 | #include <linux/pagemap.h> | ||
30 | #include <net/tcp.h> /* for memcpy_toiovec */ | ||
31 | #include <asm/io.h> | ||
32 | #include <asm/uaccess.h> | ||
33 | |||
34 | int num_pages_spanned(struct iovec *iov) | ||
35 | { | ||
36 | return | ||
37 | ((PAGE_ALIGN((unsigned long)iov->iov_base + iov->iov_len) - | ||
38 | ((unsigned long)iov->iov_base & PAGE_MASK)) >> PAGE_SHIFT); | ||
39 | } | ||
40 | |||
41 | /* | ||
42 | * Pin down all the iovec pages needed for len bytes. | ||
43 | * Return a struct dma_pinned_list to keep track of pages pinned down. | ||
44 | * | ||
45 | * We are allocating a single chunk of memory, and then carving it up into | ||
46 | * 3 sections, the latter 2 whose size depends on the number of iovecs and the | ||
47 | * total number of pages, respectively. | ||
48 | */ | ||
49 | struct dma_pinned_list *dma_pin_iovec_pages(struct iovec *iov, size_t len) | ||
50 | { | ||
51 | struct dma_pinned_list *local_list; | ||
52 | struct page **pages; | ||
53 | int i; | ||
54 | int ret; | ||
55 | int nr_iovecs = 0; | ||
56 | int iovec_len_used = 0; | ||
57 | int iovec_pages_used = 0; | ||
58 | long err; | ||
59 | |||
60 | /* don't pin down non-user-based iovecs */ | ||
61 | if (segment_eq(get_fs(), KERNEL_DS)) | ||
62 | return NULL; | ||
63 | |||
64 | /* determine how many iovecs/pages there are, up front */ | ||
65 | do { | ||
66 | iovec_len_used += iov[nr_iovecs].iov_len; | ||
67 | iovec_pages_used += num_pages_spanned(&iov[nr_iovecs]); | ||
68 | nr_iovecs++; | ||
69 | } while (iovec_len_used < len); | ||
70 | |||
71 | /* single kmalloc for pinned list, page_list[], and the page arrays */ | ||
72 | local_list = kmalloc(sizeof(*local_list) | ||
73 | + (nr_iovecs * sizeof (struct dma_page_list)) | ||
74 | + (iovec_pages_used * sizeof (struct page*)), GFP_KERNEL); | ||
75 | if (!local_list) { | ||
76 | err = -ENOMEM; | ||
77 | goto out; | ||
78 | } | ||
79 | |||
80 | /* list of pages starts right after the page list array */ | ||
81 | pages = (struct page **) &local_list->page_list[nr_iovecs]; | ||
82 | |||
83 | for (i = 0; i < nr_iovecs; i++) { | ||
84 | struct dma_page_list *page_list = &local_list->page_list[i]; | ||
85 | |||
86 | len -= iov[i].iov_len; | ||
87 | |||
88 | if (!access_ok(VERIFY_WRITE, iov[i].iov_base, iov[i].iov_len)) { | ||
89 | err = -EFAULT; | ||
90 | goto unpin; | ||
91 | } | ||
92 | |||
93 | page_list->nr_pages = num_pages_spanned(&iov[i]); | ||
94 | page_list->base_address = iov[i].iov_base; | ||
95 | |||
96 | page_list->pages = pages; | ||
97 | pages += page_list->nr_pages; | ||
98 | |||
99 | /* pin pages down */ | ||
100 | down_read(¤t->mm->mmap_sem); | ||
101 | ret = get_user_pages( | ||
102 | current, | ||
103 | current->mm, | ||
104 | (unsigned long) iov[i].iov_base, | ||
105 | page_list->nr_pages, | ||
106 | 1, /* write */ | ||
107 | 0, /* force */ | ||
108 | page_list->pages, | ||
109 | NULL); | ||
110 | up_read(¤t->mm->mmap_sem); | ||
111 | |||
112 | if (ret != page_list->nr_pages) { | ||
113 | err = -ENOMEM; | ||
114 | goto unpin; | ||
115 | } | ||
116 | |||
117 | local_list->nr_iovecs = i + 1; | ||
118 | } | ||
119 | |||
120 | return local_list; | ||
121 | |||
122 | unpin: | ||
123 | dma_unpin_iovec_pages(local_list); | ||
124 | out: | ||
125 | return ERR_PTR(err); | ||
126 | } | ||
127 | |||
128 | void dma_unpin_iovec_pages(struct dma_pinned_list *pinned_list) | ||
129 | { | ||
130 | int i, j; | ||
131 | |||
132 | if (!pinned_list) | ||
133 | return; | ||
134 | |||
135 | for (i = 0; i < pinned_list->nr_iovecs; i++) { | ||
136 | struct dma_page_list *page_list = &pinned_list->page_list[i]; | ||
137 | for (j = 0; j < page_list->nr_pages; j++) { | ||
138 | set_page_dirty_lock(page_list->pages[j]); | ||
139 | page_cache_release(page_list->pages[j]); | ||
140 | } | ||
141 | } | ||
142 | |||
143 | kfree(pinned_list); | ||
144 | } | ||
145 | |||
146 | static dma_cookie_t dma_memcpy_to_kernel_iovec(struct dma_chan *chan, struct | ||
147 | iovec *iov, unsigned char *kdata, size_t len) | ||
148 | { | ||
149 | dma_cookie_t dma_cookie = 0; | ||
150 | |||
151 | while (len > 0) { | ||
152 | if (iov->iov_len) { | ||
153 | int copy = min_t(unsigned int, iov->iov_len, len); | ||
154 | dma_cookie = dma_async_memcpy_buf_to_buf( | ||
155 | chan, | ||
156 | iov->iov_base, | ||
157 | kdata, | ||
158 | copy); | ||
159 | kdata += copy; | ||
160 | len -= copy; | ||
161 | iov->iov_len -= copy; | ||
162 | iov->iov_base += copy; | ||
163 | } | ||
164 | iov++; | ||
165 | } | ||
166 | |||
167 | return dma_cookie; | ||
168 | } | ||
169 | |||
170 | /* | ||
171 | * We have already pinned down the pages we will be using in the iovecs. | ||
172 | * Each entry in iov array has corresponding entry in pinned_list->page_list. | ||
173 | * Using array indexing to keep iov[] and page_list[] in sync. | ||
174 | * Initial elements in iov array's iov->iov_len will be 0 if already copied into | ||
175 | * by another call. | ||
176 | * iov array length remaining guaranteed to be bigger than len. | ||
177 | */ | ||
178 | dma_cookie_t dma_memcpy_to_iovec(struct dma_chan *chan, struct iovec *iov, | ||
179 | struct dma_pinned_list *pinned_list, unsigned char *kdata, size_t len) | ||
180 | { | ||
181 | int iov_byte_offset; | ||
182 | int copy; | ||
183 | dma_cookie_t dma_cookie = 0; | ||
184 | int iovec_idx; | ||
185 | int page_idx; | ||
186 | |||
187 | if (!chan) | ||
188 | return memcpy_toiovec(iov, kdata, len); | ||
189 | |||
190 | /* -> kernel copies (e.g. smbfs) */ | ||
191 | if (!pinned_list) | ||
192 | return dma_memcpy_to_kernel_iovec(chan, iov, kdata, len); | ||
193 | |||
194 | iovec_idx = 0; | ||
195 | while (iovec_idx < pinned_list->nr_iovecs) { | ||
196 | struct dma_page_list *page_list; | ||
197 | |||
198 | /* skip already used-up iovecs */ | ||
199 | while (!iov[iovec_idx].iov_len) | ||
200 | iovec_idx++; | ||
201 | |||
202 | page_list = &pinned_list->page_list[iovec_idx]; | ||
203 | |||
204 | iov_byte_offset = ((unsigned long)iov[iovec_idx].iov_base & ~PAGE_MASK); | ||
205 | page_idx = (((unsigned long)iov[iovec_idx].iov_base & PAGE_MASK) | ||
206 | - ((unsigned long)page_list->base_address & PAGE_MASK)) >> PAGE_SHIFT; | ||
207 | |||
208 | /* break up copies to not cross page boundary */ | ||
209 | while (iov[iovec_idx].iov_len) { | ||
210 | copy = min_t(int, PAGE_SIZE - iov_byte_offset, len); | ||
211 | copy = min_t(int, copy, iov[iovec_idx].iov_len); | ||
212 | |||
213 | dma_cookie = dma_async_memcpy_buf_to_pg(chan, | ||
214 | page_list->pages[page_idx], | ||
215 | iov_byte_offset, | ||
216 | kdata, | ||
217 | copy); | ||
218 | |||
219 | len -= copy; | ||
220 | iov[iovec_idx].iov_len -= copy; | ||
221 | iov[iovec_idx].iov_base += copy; | ||
222 | |||
223 | if (!len) | ||
224 | return dma_cookie; | ||
225 | |||
226 | kdata += copy; | ||
227 | iov_byte_offset = 0; | ||
228 | page_idx++; | ||
229 | } | ||
230 | iovec_idx++; | ||
231 | } | ||
232 | |||
233 | /* really bad if we ever run out of iovecs */ | ||
234 | BUG(); | ||
235 | return -EFAULT; | ||
236 | } | ||
237 | |||
238 | dma_cookie_t dma_memcpy_pg_to_iovec(struct dma_chan *chan, struct iovec *iov, | ||
239 | struct dma_pinned_list *pinned_list, struct page *page, | ||
240 | unsigned int offset, size_t len) | ||
241 | { | ||
242 | int iov_byte_offset; | ||
243 | int copy; | ||
244 | dma_cookie_t dma_cookie = 0; | ||
245 | int iovec_idx; | ||
246 | int page_idx; | ||
247 | int err; | ||
248 | |||
249 | /* this needs as-yet-unimplemented buf-to-buff, so punt. */ | ||
250 | /* TODO: use dma for this */ | ||
251 | if (!chan || !pinned_list) { | ||
252 | u8 *vaddr = kmap(page); | ||
253 | err = memcpy_toiovec(iov, vaddr + offset, len); | ||
254 | kunmap(page); | ||
255 | return err; | ||
256 | } | ||
257 | |||
258 | iovec_idx = 0; | ||
259 | while (iovec_idx < pinned_list->nr_iovecs) { | ||
260 | struct dma_page_list *page_list; | ||
261 | |||
262 | /* skip already used-up iovecs */ | ||
263 | while (!iov[iovec_idx].iov_len) | ||
264 | iovec_idx++; | ||
265 | |||
266 | page_list = &pinned_list->page_list[iovec_idx]; | ||
267 | |||
268 | iov_byte_offset = ((unsigned long)iov[iovec_idx].iov_base & ~PAGE_MASK); | ||
269 | page_idx = (((unsigned long)iov[iovec_idx].iov_base & PAGE_MASK) | ||
270 | - ((unsigned long)page_list->base_address & PAGE_MASK)) >> PAGE_SHIFT; | ||
271 | |||
272 | /* break up copies to not cross page boundary */ | ||
273 | while (iov[iovec_idx].iov_len) { | ||
274 | copy = min_t(int, PAGE_SIZE - iov_byte_offset, len); | ||
275 | copy = min_t(int, copy, iov[iovec_idx].iov_len); | ||
276 | |||
277 | dma_cookie = dma_async_memcpy_pg_to_pg(chan, | ||
278 | page_list->pages[page_idx], | ||
279 | iov_byte_offset, | ||
280 | page, | ||
281 | offset, | ||
282 | copy); | ||
283 | |||
284 | len -= copy; | ||
285 | iov[iovec_idx].iov_len -= copy; | ||
286 | iov[iovec_idx].iov_base += copy; | ||
287 | |||
288 | if (!len) | ||
289 | return dma_cookie; | ||
290 | |||
291 | offset += copy; | ||
292 | iov_byte_offset = 0; | ||
293 | page_idx++; | ||
294 | } | ||
295 | iovec_idx++; | ||
296 | } | ||
297 | |||
298 | /* really bad if we ever run out of iovecs */ | ||
299 | BUG(); | ||
300 | return -EFAULT; | ||
301 | } | ||
diff --git a/drivers/infiniband/Kconfig b/drivers/infiniband/Kconfig index afc612b8577d..ba2d6505e9a4 100644 --- a/drivers/infiniband/Kconfig +++ b/drivers/infiniband/Kconfig | |||
@@ -29,6 +29,11 @@ config INFINIBAND_USER_ACCESS | |||
29 | libibverbs, libibcm and a hardware driver library from | 29 | libibverbs, libibcm and a hardware driver library from |
30 | <http://www.openib.org>. | 30 | <http://www.openib.org>. |
31 | 31 | ||
32 | config INFINIBAND_ADDR_TRANS | ||
33 | bool | ||
34 | depends on INFINIBAND && INET | ||
35 | default y | ||
36 | |||
32 | source "drivers/infiniband/hw/mthca/Kconfig" | 37 | source "drivers/infiniband/hw/mthca/Kconfig" |
33 | source "drivers/infiniband/hw/ipath/Kconfig" | 38 | source "drivers/infiniband/hw/ipath/Kconfig" |
34 | 39 | ||
diff --git a/drivers/infiniband/core/Makefile b/drivers/infiniband/core/Makefile index ec3353f24b27..68e73ec2d1f8 100644 --- a/drivers/infiniband/core/Makefile +++ b/drivers/infiniband/core/Makefile | |||
@@ -1,5 +1,7 @@ | |||
1 | infiniband-$(CONFIG_INFINIBAND_ADDR_TRANS) := ib_addr.o rdma_cm.o | ||
2 | |||
1 | obj-$(CONFIG_INFINIBAND) += ib_core.o ib_mad.o ib_sa.o \ | 3 | obj-$(CONFIG_INFINIBAND) += ib_core.o ib_mad.o ib_sa.o \ |
2 | ib_cm.o | 4 | ib_cm.o $(infiniband-y) |
3 | obj-$(CONFIG_INFINIBAND_USER_MAD) += ib_umad.o | 5 | obj-$(CONFIG_INFINIBAND_USER_MAD) += ib_umad.o |
4 | obj-$(CONFIG_INFINIBAND_USER_ACCESS) += ib_uverbs.o ib_ucm.o | 6 | obj-$(CONFIG_INFINIBAND_USER_ACCESS) += ib_uverbs.o ib_ucm.o |
5 | 7 | ||
@@ -12,8 +14,13 @@ ib_sa-y := sa_query.o | |||
12 | 14 | ||
13 | ib_cm-y := cm.o | 15 | ib_cm-y := cm.o |
14 | 16 | ||
17 | rdma_cm-y := cma.o | ||
18 | |||
19 | ib_addr-y := addr.o | ||
20 | |||
15 | ib_umad-y := user_mad.o | 21 | ib_umad-y := user_mad.o |
16 | 22 | ||
17 | ib_ucm-y := ucm.o | 23 | ib_ucm-y := ucm.o |
18 | 24 | ||
19 | ib_uverbs-y := uverbs_main.o uverbs_cmd.o uverbs_mem.o | 25 | ib_uverbs-y := uverbs_main.o uverbs_cmd.o uverbs_mem.o \ |
26 | uverbs_marshall.o | ||
diff --git a/drivers/infiniband/core/addr.c b/drivers/infiniband/core/addr.c new file mode 100644 index 000000000000..d294bbc42f09 --- /dev/null +++ b/drivers/infiniband/core/addr.c | |||
@@ -0,0 +1,367 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2005 Voltaire Inc. All rights reserved. | ||
3 | * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved. | ||
4 | * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved. | ||
5 | * Copyright (c) 2005 Intel Corporation. All rights reserved. | ||
6 | * | ||
7 | * This Software is licensed under one of the following licenses: | ||
8 | * | ||
9 | * 1) under the terms of the "Common Public License 1.0" a copy of which is | ||
10 | * available from the Open Source Initiative, see | ||
11 | * http://www.opensource.org/licenses/cpl.php. | ||
12 | * | ||
13 | * 2) under the terms of the "The BSD License" a copy of which is | ||
14 | * available from the Open Source Initiative, see | ||
15 | * http://www.opensource.org/licenses/bsd-license.php. | ||
16 | * | ||
17 | * 3) under the terms of the "GNU General Public License (GPL) Version 2" a | ||
18 | * copy of which is available from the Open Source Initiative, see | ||
19 | * http://www.opensource.org/licenses/gpl-license.php. | ||
20 | * | ||
21 | * Licensee has the right to choose one of the above licenses. | ||
22 | * | ||
23 | * Redistributions of source code must retain the above copyright | ||
24 | * notice and one of the license notices. | ||
25 | * | ||
26 | * Redistributions in binary form must reproduce both the above copyright | ||
27 | * notice, one of the license notices in the documentation | ||
28 | * and/or other materials provided with the distribution. | ||
29 | */ | ||
30 | |||
31 | #include <linux/mutex.h> | ||
32 | #include <linux/inetdevice.h> | ||
33 | #include <linux/workqueue.h> | ||
34 | #include <linux/if_arp.h> | ||
35 | #include <net/arp.h> | ||
36 | #include <net/neighbour.h> | ||
37 | #include <net/route.h> | ||
38 | #include <rdma/ib_addr.h> | ||
39 | |||
40 | MODULE_AUTHOR("Sean Hefty"); | ||
41 | MODULE_DESCRIPTION("IB Address Translation"); | ||
42 | MODULE_LICENSE("Dual BSD/GPL"); | ||
43 | |||
44 | struct addr_req { | ||
45 | struct list_head list; | ||
46 | struct sockaddr src_addr; | ||
47 | struct sockaddr dst_addr; | ||
48 | struct rdma_dev_addr *addr; | ||
49 | void *context; | ||
50 | void (*callback)(int status, struct sockaddr *src_addr, | ||
51 | struct rdma_dev_addr *addr, void *context); | ||
52 | unsigned long timeout; | ||
53 | int status; | ||
54 | }; | ||
55 | |||
56 | static void process_req(void *data); | ||
57 | |||
58 | static DEFINE_MUTEX(lock); | ||
59 | static LIST_HEAD(req_list); | ||
60 | static DECLARE_WORK(work, process_req, NULL); | ||
61 | static struct workqueue_struct *addr_wq; | ||
62 | |||
63 | static int copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev, | ||
64 | unsigned char *dst_dev_addr) | ||
65 | { | ||
66 | switch (dev->type) { | ||
67 | case ARPHRD_INFINIBAND: | ||
68 | dev_addr->dev_type = IB_NODE_CA; | ||
69 | break; | ||
70 | default: | ||
71 | return -EADDRNOTAVAIL; | ||
72 | } | ||
73 | |||
74 | memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN); | ||
75 | memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN); | ||
76 | if (dst_dev_addr) | ||
77 | memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN); | ||
78 | return 0; | ||
79 | } | ||
80 | |||
81 | int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr) | ||
82 | { | ||
83 | struct net_device *dev; | ||
84 | u32 ip = ((struct sockaddr_in *) addr)->sin_addr.s_addr; | ||
85 | int ret; | ||
86 | |||
87 | dev = ip_dev_find(ip); | ||
88 | if (!dev) | ||
89 | return -EADDRNOTAVAIL; | ||
90 | |||
91 | ret = copy_addr(dev_addr, dev, NULL); | ||
92 | dev_put(dev); | ||
93 | return ret; | ||
94 | } | ||
95 | EXPORT_SYMBOL(rdma_translate_ip); | ||
96 | |||
97 | static void set_timeout(unsigned long time) | ||
98 | { | ||
99 | unsigned long delay; | ||
100 | |||
101 | cancel_delayed_work(&work); | ||
102 | |||
103 | delay = time - jiffies; | ||
104 | if ((long)delay <= 0) | ||
105 | delay = 1; | ||
106 | |||
107 | queue_delayed_work(addr_wq, &work, delay); | ||
108 | } | ||
109 | |||
110 | static void queue_req(struct addr_req *req) | ||
111 | { | ||
112 | struct addr_req *temp_req; | ||
113 | |||
114 | mutex_lock(&lock); | ||
115 | list_for_each_entry_reverse(temp_req, &req_list, list) { | ||
116 | if (time_after(req->timeout, temp_req->timeout)) | ||
117 | break; | ||
118 | } | ||
119 | |||
120 | list_add(&req->list, &temp_req->list); | ||
121 | |||
122 | if (req_list.next == &req->list) | ||
123 | set_timeout(req->timeout); | ||
124 | mutex_unlock(&lock); | ||
125 | } | ||
126 | |||
127 | static void addr_send_arp(struct sockaddr_in *dst_in) | ||
128 | { | ||
129 | struct rtable *rt; | ||
130 | struct flowi fl; | ||
131 | u32 dst_ip = dst_in->sin_addr.s_addr; | ||
132 | |||
133 | memset(&fl, 0, sizeof fl); | ||
134 | fl.nl_u.ip4_u.daddr = dst_ip; | ||
135 | if (ip_route_output_key(&rt, &fl)) | ||
136 | return; | ||
137 | |||
138 | arp_send(ARPOP_REQUEST, ETH_P_ARP, rt->rt_gateway, rt->idev->dev, | ||
139 | rt->rt_src, NULL, rt->idev->dev->dev_addr, NULL); | ||
140 | ip_rt_put(rt); | ||
141 | } | ||
142 | |||
143 | static int addr_resolve_remote(struct sockaddr_in *src_in, | ||
144 | struct sockaddr_in *dst_in, | ||
145 | struct rdma_dev_addr *addr) | ||
146 | { | ||
147 | u32 src_ip = src_in->sin_addr.s_addr; | ||
148 | u32 dst_ip = dst_in->sin_addr.s_addr; | ||
149 | struct flowi fl; | ||
150 | struct rtable *rt; | ||
151 | struct neighbour *neigh; | ||
152 | int ret; | ||
153 | |||
154 | memset(&fl, 0, sizeof fl); | ||
155 | fl.nl_u.ip4_u.daddr = dst_ip; | ||
156 | fl.nl_u.ip4_u.saddr = src_ip; | ||
157 | ret = ip_route_output_key(&rt, &fl); | ||
158 | if (ret) | ||
159 | goto out; | ||
160 | |||
161 | /* If the device does ARP internally, return 'done' */ | ||
162 | if (rt->idev->dev->flags & IFF_NOARP) { | ||
163 | copy_addr(addr, rt->idev->dev, NULL); | ||
164 | goto put; | ||
165 | } | ||
166 | |||
167 | neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, rt->idev->dev); | ||
168 | if (!neigh) { | ||
169 | ret = -ENODATA; | ||
170 | goto put; | ||
171 | } | ||
172 | |||
173 | if (!(neigh->nud_state & NUD_VALID)) { | ||
174 | ret = -ENODATA; | ||
175 | goto release; | ||
176 | } | ||
177 | |||
178 | if (!src_ip) { | ||
179 | src_in->sin_family = dst_in->sin_family; | ||
180 | src_in->sin_addr.s_addr = rt->rt_src; | ||
181 | } | ||
182 | |||
183 | ret = copy_addr(addr, neigh->dev, neigh->ha); | ||
184 | release: | ||
185 | neigh_release(neigh); | ||
186 | put: | ||
187 | ip_rt_put(rt); | ||
188 | out: | ||
189 | return ret; | ||
190 | } | ||
191 | |||
192 | static void process_req(void *data) | ||
193 | { | ||
194 | struct addr_req *req, *temp_req; | ||
195 | struct sockaddr_in *src_in, *dst_in; | ||
196 | struct list_head done_list; | ||
197 | |||
198 | INIT_LIST_HEAD(&done_list); | ||
199 | |||
200 | mutex_lock(&lock); | ||
201 | list_for_each_entry_safe(req, temp_req, &req_list, list) { | ||
202 | if (req->status) { | ||
203 | src_in = (struct sockaddr_in *) &req->src_addr; | ||
204 | dst_in = (struct sockaddr_in *) &req->dst_addr; | ||
205 | req->status = addr_resolve_remote(src_in, dst_in, | ||
206 | req->addr); | ||
207 | } | ||
208 | if (req->status && time_after(jiffies, req->timeout)) | ||
209 | req->status = -ETIMEDOUT; | ||
210 | else if (req->status == -ENODATA) | ||
211 | continue; | ||
212 | |||
213 | list_del(&req->list); | ||
214 | list_add_tail(&req->list, &done_list); | ||
215 | } | ||
216 | |||
217 | if (!list_empty(&req_list)) { | ||
218 | req = list_entry(req_list.next, struct addr_req, list); | ||
219 | set_timeout(req->timeout); | ||
220 | } | ||
221 | mutex_unlock(&lock); | ||
222 | |||
223 | list_for_each_entry_safe(req, temp_req, &done_list, list) { | ||
224 | list_del(&req->list); | ||
225 | req->callback(req->status, &req->src_addr, req->addr, | ||
226 | req->context); | ||
227 | kfree(req); | ||
228 | } | ||
229 | } | ||
230 | |||
231 | static int addr_resolve_local(struct sockaddr_in *src_in, | ||
232 | struct sockaddr_in *dst_in, | ||
233 | struct rdma_dev_addr *addr) | ||
234 | { | ||
235 | struct net_device *dev; | ||
236 | u32 src_ip = src_in->sin_addr.s_addr; | ||
237 | u32 dst_ip = dst_in->sin_addr.s_addr; | ||
238 | int ret; | ||
239 | |||
240 | dev = ip_dev_find(dst_ip); | ||
241 | if (!dev) | ||
242 | return -EADDRNOTAVAIL; | ||
243 | |||
244 | if (ZERONET(src_ip)) { | ||
245 | src_in->sin_family = dst_in->sin_family; | ||
246 | src_in->sin_addr.s_addr = dst_ip; | ||
247 | ret = copy_addr(addr, dev, dev->dev_addr); | ||
248 | } else if (LOOPBACK(src_ip)) { | ||
249 | ret = rdma_translate_ip((struct sockaddr *)dst_in, addr); | ||
250 | if (!ret) | ||
251 | memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN); | ||
252 | } else { | ||
253 | ret = rdma_translate_ip((struct sockaddr *)src_in, addr); | ||
254 | if (!ret) | ||
255 | memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN); | ||
256 | } | ||
257 | |||
258 | dev_put(dev); | ||
259 | return ret; | ||
260 | } | ||
261 | |||
262 | int rdma_resolve_ip(struct sockaddr *src_addr, struct sockaddr *dst_addr, | ||
263 | struct rdma_dev_addr *addr, int timeout_ms, | ||
264 | void (*callback)(int status, struct sockaddr *src_addr, | ||
265 | struct rdma_dev_addr *addr, void *context), | ||
266 | void *context) | ||
267 | { | ||
268 | struct sockaddr_in *src_in, *dst_in; | ||
269 | struct addr_req *req; | ||
270 | int ret = 0; | ||
271 | |||
272 | req = kmalloc(sizeof *req, GFP_KERNEL); | ||
273 | if (!req) | ||
274 | return -ENOMEM; | ||
275 | memset(req, 0, sizeof *req); | ||
276 | |||
277 | if (src_addr) | ||
278 | memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr)); | ||
279 | memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr)); | ||
280 | req->addr = addr; | ||
281 | req->callback = callback; | ||
282 | req->context = context; | ||
283 | |||
284 | src_in = (struct sockaddr_in *) &req->src_addr; | ||
285 | dst_in = (struct sockaddr_in *) &req->dst_addr; | ||
286 | |||
287 | req->status = addr_resolve_local(src_in, dst_in, addr); | ||
288 | if (req->status == -EADDRNOTAVAIL) | ||
289 | req->status = addr_resolve_remote(src_in, dst_in, addr); | ||
290 | |||
291 | switch (req->status) { | ||
292 | case 0: | ||
293 | req->timeout = jiffies; | ||
294 | queue_req(req); | ||
295 | break; | ||
296 | case -ENODATA: | ||
297 | req->timeout = msecs_to_jiffies(timeout_ms) + jiffies; | ||
298 | queue_req(req); | ||
299 | addr_send_arp(dst_in); | ||
300 | break; | ||
301 | default: | ||
302 | ret = req->status; | ||
303 | kfree(req); | ||
304 | break; | ||
305 | } | ||
306 | return ret; | ||
307 | } | ||
308 | EXPORT_SYMBOL(rdma_resolve_ip); | ||
309 | |||
310 | void rdma_addr_cancel(struct rdma_dev_addr *addr) | ||
311 | { | ||
312 | struct addr_req *req, *temp_req; | ||
313 | |||
314 | mutex_lock(&lock); | ||
315 | list_for_each_entry_safe(req, temp_req, &req_list, list) { | ||
316 | if (req->addr == addr) { | ||
317 | req->status = -ECANCELED; | ||
318 | req->timeout = jiffies; | ||
319 | list_del(&req->list); | ||
320 | list_add(&req->list, &req_list); | ||
321 | set_timeout(req->timeout); | ||
322 | break; | ||
323 | } | ||
324 | } | ||
325 | mutex_unlock(&lock); | ||
326 | } | ||
327 | EXPORT_SYMBOL(rdma_addr_cancel); | ||
328 | |||
329 | static int addr_arp_recv(struct sk_buff *skb, struct net_device *dev, | ||
330 | struct packet_type *pkt, struct net_device *orig_dev) | ||
331 | { | ||
332 | struct arphdr *arp_hdr; | ||
333 | |||
334 | arp_hdr = (struct arphdr *) skb->nh.raw; | ||
335 | |||
336 | if (arp_hdr->ar_op == htons(ARPOP_REQUEST) || | ||
337 | arp_hdr->ar_op == htons(ARPOP_REPLY)) | ||
338 | set_timeout(jiffies); | ||
339 | |||
340 | kfree_skb(skb); | ||
341 | return 0; | ||
342 | } | ||
343 | |||
344 | static struct packet_type addr_arp = { | ||
345 | .type = __constant_htons(ETH_P_ARP), | ||
346 | .func = addr_arp_recv, | ||
347 | .af_packet_priv = (void*) 1, | ||
348 | }; | ||
349 | |||
350 | static int addr_init(void) | ||
351 | { | ||
352 | addr_wq = create_singlethread_workqueue("ib_addr_wq"); | ||
353 | if (!addr_wq) | ||
354 | return -ENOMEM; | ||
355 | |||
356 | dev_add_pack(&addr_arp); | ||
357 | return 0; | ||
358 | } | ||
359 | |||
360 | static void addr_cleanup(void) | ||
361 | { | ||
362 | dev_remove_pack(&addr_arp); | ||
363 | destroy_workqueue(addr_wq); | ||
364 | } | ||
365 | |||
366 | module_init(addr_init); | ||
367 | module_exit(addr_cleanup); | ||
diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c index 50364c0b090c..e05ca2cdc73f 100644 --- a/drivers/infiniband/core/cache.c +++ b/drivers/infiniband/core/cache.c | |||
@@ -191,6 +191,24 @@ int ib_find_cached_pkey(struct ib_device *device, | |||
191 | } | 191 | } |
192 | EXPORT_SYMBOL(ib_find_cached_pkey); | 192 | EXPORT_SYMBOL(ib_find_cached_pkey); |
193 | 193 | ||
194 | int ib_get_cached_lmc(struct ib_device *device, | ||
195 | u8 port_num, | ||
196 | u8 *lmc) | ||
197 | { | ||
198 | unsigned long flags; | ||
199 | int ret = 0; | ||
200 | |||
201 | if (port_num < start_port(device) || port_num > end_port(device)) | ||
202 | return -EINVAL; | ||
203 | |||
204 | read_lock_irqsave(&device->cache.lock, flags); | ||
205 | *lmc = device->cache.lmc_cache[port_num - start_port(device)]; | ||
206 | read_unlock_irqrestore(&device->cache.lock, flags); | ||
207 | |||
208 | return ret; | ||
209 | } | ||
210 | EXPORT_SYMBOL(ib_get_cached_lmc); | ||
211 | |||
194 | static void ib_cache_update(struct ib_device *device, | 212 | static void ib_cache_update(struct ib_device *device, |
195 | u8 port) | 213 | u8 port) |
196 | { | 214 | { |
@@ -251,6 +269,8 @@ static void ib_cache_update(struct ib_device *device, | |||
251 | device->cache.pkey_cache[port - start_port(device)] = pkey_cache; | 269 | device->cache.pkey_cache[port - start_port(device)] = pkey_cache; |
252 | device->cache.gid_cache [port - start_port(device)] = gid_cache; | 270 | device->cache.gid_cache [port - start_port(device)] = gid_cache; |
253 | 271 | ||
272 | device->cache.lmc_cache[port - start_port(device)] = tprops->lmc; | ||
273 | |||
254 | write_unlock_irq(&device->cache.lock); | 274 | write_unlock_irq(&device->cache.lock); |
255 | 275 | ||
256 | kfree(old_pkey_cache); | 276 | kfree(old_pkey_cache); |
@@ -305,7 +325,13 @@ static void ib_cache_setup_one(struct ib_device *device) | |||
305 | kmalloc(sizeof *device->cache.gid_cache * | 325 | kmalloc(sizeof *device->cache.gid_cache * |
306 | (end_port(device) - start_port(device) + 1), GFP_KERNEL); | 326 | (end_port(device) - start_port(device) + 1), GFP_KERNEL); |
307 | 327 | ||
308 | if (!device->cache.pkey_cache || !device->cache.gid_cache) { | 328 | device->cache.lmc_cache = kmalloc(sizeof *device->cache.lmc_cache * |
329 | (end_port(device) - | ||
330 | start_port(device) + 1), | ||
331 | GFP_KERNEL); | ||
332 | |||
333 | if (!device->cache.pkey_cache || !device->cache.gid_cache || | ||
334 | !device->cache.lmc_cache) { | ||
309 | printk(KERN_WARNING "Couldn't allocate cache " | 335 | printk(KERN_WARNING "Couldn't allocate cache " |
310 | "for %s\n", device->name); | 336 | "for %s\n", device->name); |
311 | goto err; | 337 | goto err; |
@@ -333,6 +359,7 @@ err_cache: | |||
333 | err: | 359 | err: |
334 | kfree(device->cache.pkey_cache); | 360 | kfree(device->cache.pkey_cache); |
335 | kfree(device->cache.gid_cache); | 361 | kfree(device->cache.gid_cache); |
362 | kfree(device->cache.lmc_cache); | ||
336 | } | 363 | } |
337 | 364 | ||
338 | static void ib_cache_cleanup_one(struct ib_device *device) | 365 | static void ib_cache_cleanup_one(struct ib_device *device) |
@@ -349,6 +376,7 @@ static void ib_cache_cleanup_one(struct ib_device *device) | |||
349 | 376 | ||
350 | kfree(device->cache.pkey_cache); | 377 | kfree(device->cache.pkey_cache); |
351 | kfree(device->cache.gid_cache); | 378 | kfree(device->cache.gid_cache); |
379 | kfree(device->cache.lmc_cache); | ||
352 | } | 380 | } |
353 | 381 | ||
354 | static struct ib_client cache_client = { | 382 | static struct ib_client cache_client = { |
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c index 86fee43502cd..450adfe0a4f1 100644 --- a/drivers/infiniband/core/cm.c +++ b/drivers/infiniband/core/cm.c | |||
@@ -32,7 +32,7 @@ | |||
32 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | 32 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
33 | * SOFTWARE. | 33 | * SOFTWARE. |
34 | * | 34 | * |
35 | * $Id: cm.c 2821 2005-07-08 17:07:28Z sean.hefty $ | 35 | * $Id: cm.c 4311 2005-12-05 18:42:01Z sean.hefty $ |
36 | */ | 36 | */ |
37 | 37 | ||
38 | #include <linux/completion.h> | 38 | #include <linux/completion.h> |
@@ -132,6 +132,7 @@ struct cm_id_private { | |||
132 | /* todo: use alternate port on send failure */ | 132 | /* todo: use alternate port on send failure */ |
133 | struct cm_av av; | 133 | struct cm_av av; |
134 | struct cm_av alt_av; | 134 | struct cm_av alt_av; |
135 | struct ib_cm_compare_data *compare_data; | ||
135 | 136 | ||
136 | void *private_data; | 137 | void *private_data; |
137 | __be64 tid; | 138 | __be64 tid; |
@@ -253,23 +254,13 @@ static void cm_set_private_data(struct cm_id_private *cm_id_priv, | |||
253 | cm_id_priv->private_data_len = private_data_len; | 254 | cm_id_priv->private_data_len = private_data_len; |
254 | } | 255 | } |
255 | 256 | ||
256 | static void cm_set_ah_attr(struct ib_ah_attr *ah_attr, u8 port_num, | 257 | static void cm_init_av_for_response(struct cm_port *port, struct ib_wc *wc, |
257 | u16 dlid, u8 sl, u16 src_path_bits) | 258 | struct ib_grh *grh, struct cm_av *av) |
258 | { | ||
259 | memset(ah_attr, 0, sizeof ah_attr); | ||
260 | ah_attr->dlid = dlid; | ||
261 | ah_attr->sl = sl; | ||
262 | ah_attr->src_path_bits = src_path_bits; | ||
263 | ah_attr->port_num = port_num; | ||
264 | } | ||
265 | |||
266 | static void cm_init_av_for_response(struct cm_port *port, | ||
267 | struct ib_wc *wc, struct cm_av *av) | ||
268 | { | 259 | { |
269 | av->port = port; | 260 | av->port = port; |
270 | av->pkey_index = wc->pkey_index; | 261 | av->pkey_index = wc->pkey_index; |
271 | cm_set_ah_attr(&av->ah_attr, port->port_num, wc->slid, | 262 | ib_init_ah_from_wc(port->cm_dev->device, port->port_num, wc, |
272 | wc->sl, wc->dlid_path_bits); | 263 | grh, &av->ah_attr); |
273 | } | 264 | } |
274 | 265 | ||
275 | static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av) | 266 | static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av) |
@@ -299,9 +290,8 @@ static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av) | |||
299 | return ret; | 290 | return ret; |
300 | 291 | ||
301 | av->port = port; | 292 | av->port = port; |
302 | cm_set_ah_attr(&av->ah_attr, av->port->port_num, | 293 | ib_init_ah_from_path(cm_dev->device, port->port_num, path, |
303 | be16_to_cpu(path->dlid), path->sl, | 294 | &av->ah_attr); |
304 | be16_to_cpu(path->slid) & 0x7F); | ||
305 | av->packet_life_time = path->packet_life_time; | 295 | av->packet_life_time = path->packet_life_time; |
306 | return 0; | 296 | return 0; |
307 | } | 297 | } |
@@ -357,6 +347,41 @@ static struct cm_id_private * cm_acquire_id(__be32 local_id, __be32 remote_id) | |||
357 | return cm_id_priv; | 347 | return cm_id_priv; |
358 | } | 348 | } |
359 | 349 | ||
350 | static void cm_mask_copy(u8 *dst, u8 *src, u8 *mask) | ||
351 | { | ||
352 | int i; | ||
353 | |||
354 | for (i = 0; i < IB_CM_COMPARE_SIZE / sizeof(unsigned long); i++) | ||
355 | ((unsigned long *) dst)[i] = ((unsigned long *) src)[i] & | ||
356 | ((unsigned long *) mask)[i]; | ||
357 | } | ||
358 | |||
359 | static int cm_compare_data(struct ib_cm_compare_data *src_data, | ||
360 | struct ib_cm_compare_data *dst_data) | ||
361 | { | ||
362 | u8 src[IB_CM_COMPARE_SIZE]; | ||
363 | u8 dst[IB_CM_COMPARE_SIZE]; | ||
364 | |||
365 | if (!src_data || !dst_data) | ||
366 | return 0; | ||
367 | |||
368 | cm_mask_copy(src, src_data->data, dst_data->mask); | ||
369 | cm_mask_copy(dst, dst_data->data, src_data->mask); | ||
370 | return memcmp(src, dst, IB_CM_COMPARE_SIZE); | ||
371 | } | ||
372 | |||
373 | static int cm_compare_private_data(u8 *private_data, | ||
374 | struct ib_cm_compare_data *dst_data) | ||
375 | { | ||
376 | u8 src[IB_CM_COMPARE_SIZE]; | ||
377 | |||
378 | if (!dst_data) | ||
379 | return 0; | ||
380 | |||
381 | cm_mask_copy(src, private_data, dst_data->mask); | ||
382 | return memcmp(src, dst_data->data, IB_CM_COMPARE_SIZE); | ||
383 | } | ||
384 | |||
360 | static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv) | 385 | static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv) |
361 | { | 386 | { |
362 | struct rb_node **link = &cm.listen_service_table.rb_node; | 387 | struct rb_node **link = &cm.listen_service_table.rb_node; |
@@ -364,14 +389,18 @@ static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv) | |||
364 | struct cm_id_private *cur_cm_id_priv; | 389 | struct cm_id_private *cur_cm_id_priv; |
365 | __be64 service_id = cm_id_priv->id.service_id; | 390 | __be64 service_id = cm_id_priv->id.service_id; |
366 | __be64 service_mask = cm_id_priv->id.service_mask; | 391 | __be64 service_mask = cm_id_priv->id.service_mask; |
392 | int data_cmp; | ||
367 | 393 | ||
368 | while (*link) { | 394 | while (*link) { |
369 | parent = *link; | 395 | parent = *link; |
370 | cur_cm_id_priv = rb_entry(parent, struct cm_id_private, | 396 | cur_cm_id_priv = rb_entry(parent, struct cm_id_private, |
371 | service_node); | 397 | service_node); |
398 | data_cmp = cm_compare_data(cm_id_priv->compare_data, | ||
399 | cur_cm_id_priv->compare_data); | ||
372 | if ((cur_cm_id_priv->id.service_mask & service_id) == | 400 | if ((cur_cm_id_priv->id.service_mask & service_id) == |
373 | (service_mask & cur_cm_id_priv->id.service_id) && | 401 | (service_mask & cur_cm_id_priv->id.service_id) && |
374 | (cm_id_priv->id.device == cur_cm_id_priv->id.device)) | 402 | (cm_id_priv->id.device == cur_cm_id_priv->id.device) && |
403 | !data_cmp) | ||
375 | return cur_cm_id_priv; | 404 | return cur_cm_id_priv; |
376 | 405 | ||
377 | if (cm_id_priv->id.device < cur_cm_id_priv->id.device) | 406 | if (cm_id_priv->id.device < cur_cm_id_priv->id.device) |
@@ -380,6 +409,10 @@ static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv) | |||
380 | link = &(*link)->rb_right; | 409 | link = &(*link)->rb_right; |
381 | else if (service_id < cur_cm_id_priv->id.service_id) | 410 | else if (service_id < cur_cm_id_priv->id.service_id) |
382 | link = &(*link)->rb_left; | 411 | link = &(*link)->rb_left; |
412 | else if (service_id > cur_cm_id_priv->id.service_id) | ||
413 | link = &(*link)->rb_right; | ||
414 | else if (data_cmp < 0) | ||
415 | link = &(*link)->rb_left; | ||
383 | else | 416 | else |
384 | link = &(*link)->rb_right; | 417 | link = &(*link)->rb_right; |
385 | } | 418 | } |
@@ -389,16 +422,20 @@ static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv) | |||
389 | } | 422 | } |
390 | 423 | ||
391 | static struct cm_id_private * cm_find_listen(struct ib_device *device, | 424 | static struct cm_id_private * cm_find_listen(struct ib_device *device, |
392 | __be64 service_id) | 425 | __be64 service_id, |
426 | u8 *private_data) | ||
393 | { | 427 | { |
394 | struct rb_node *node = cm.listen_service_table.rb_node; | 428 | struct rb_node *node = cm.listen_service_table.rb_node; |
395 | struct cm_id_private *cm_id_priv; | 429 | struct cm_id_private *cm_id_priv; |
430 | int data_cmp; | ||
396 | 431 | ||
397 | while (node) { | 432 | while (node) { |
398 | cm_id_priv = rb_entry(node, struct cm_id_private, service_node); | 433 | cm_id_priv = rb_entry(node, struct cm_id_private, service_node); |
434 | data_cmp = cm_compare_private_data(private_data, | ||
435 | cm_id_priv->compare_data); | ||
399 | if ((cm_id_priv->id.service_mask & service_id) == | 436 | if ((cm_id_priv->id.service_mask & service_id) == |
400 | cm_id_priv->id.service_id && | 437 | cm_id_priv->id.service_id && |
401 | (cm_id_priv->id.device == device)) | 438 | (cm_id_priv->id.device == device) && !data_cmp) |
402 | return cm_id_priv; | 439 | return cm_id_priv; |
403 | 440 | ||
404 | if (device < cm_id_priv->id.device) | 441 | if (device < cm_id_priv->id.device) |
@@ -407,6 +444,10 @@ static struct cm_id_private * cm_find_listen(struct ib_device *device, | |||
407 | node = node->rb_right; | 444 | node = node->rb_right; |
408 | else if (service_id < cm_id_priv->id.service_id) | 445 | else if (service_id < cm_id_priv->id.service_id) |
409 | node = node->rb_left; | 446 | node = node->rb_left; |
447 | else if (service_id > cm_id_priv->id.service_id) | ||
448 | node = node->rb_right; | ||
449 | else if (data_cmp < 0) | ||
450 | node = node->rb_left; | ||
410 | else | 451 | else |
411 | node = node->rb_right; | 452 | node = node->rb_right; |
412 | } | 453 | } |
@@ -730,15 +771,14 @@ retest: | |||
730 | wait_for_completion(&cm_id_priv->comp); | 771 | wait_for_completion(&cm_id_priv->comp); |
731 | while ((work = cm_dequeue_work(cm_id_priv)) != NULL) | 772 | while ((work = cm_dequeue_work(cm_id_priv)) != NULL) |
732 | cm_free_work(work); | 773 | cm_free_work(work); |
733 | if (cm_id_priv->private_data && cm_id_priv->private_data_len) | 774 | kfree(cm_id_priv->compare_data); |
734 | kfree(cm_id_priv->private_data); | 775 | kfree(cm_id_priv->private_data); |
735 | kfree(cm_id_priv); | 776 | kfree(cm_id_priv); |
736 | } | 777 | } |
737 | EXPORT_SYMBOL(ib_destroy_cm_id); | 778 | EXPORT_SYMBOL(ib_destroy_cm_id); |
738 | 779 | ||
739 | int ib_cm_listen(struct ib_cm_id *cm_id, | 780 | int ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id, __be64 service_mask, |
740 | __be64 service_id, | 781 | struct ib_cm_compare_data *compare_data) |
741 | __be64 service_mask) | ||
742 | { | 782 | { |
743 | struct cm_id_private *cm_id_priv, *cur_cm_id_priv; | 783 | struct cm_id_private *cm_id_priv, *cur_cm_id_priv; |
744 | unsigned long flags; | 784 | unsigned long flags; |
@@ -752,7 +792,19 @@ int ib_cm_listen(struct ib_cm_id *cm_id, | |||
752 | return -EINVAL; | 792 | return -EINVAL; |
753 | 793 | ||
754 | cm_id_priv = container_of(cm_id, struct cm_id_private, id); | 794 | cm_id_priv = container_of(cm_id, struct cm_id_private, id); |
755 | BUG_ON(cm_id->state != IB_CM_IDLE); | 795 | if (cm_id->state != IB_CM_IDLE) |
796 | return -EINVAL; | ||
797 | |||
798 | if (compare_data) { | ||
799 | cm_id_priv->compare_data = kzalloc(sizeof *compare_data, | ||
800 | GFP_KERNEL); | ||
801 | if (!cm_id_priv->compare_data) | ||
802 | return -ENOMEM; | ||
803 | cm_mask_copy(cm_id_priv->compare_data->data, | ||
804 | compare_data->data, compare_data->mask); | ||
805 | memcpy(cm_id_priv->compare_data->mask, compare_data->mask, | ||
806 | IB_CM_COMPARE_SIZE); | ||
807 | } | ||
756 | 808 | ||
757 | cm_id->state = IB_CM_LISTEN; | 809 | cm_id->state = IB_CM_LISTEN; |
758 | 810 | ||
@@ -769,6 +821,8 @@ int ib_cm_listen(struct ib_cm_id *cm_id, | |||
769 | 821 | ||
770 | if (cur_cm_id_priv) { | 822 | if (cur_cm_id_priv) { |
771 | cm_id->state = IB_CM_IDLE; | 823 | cm_id->state = IB_CM_IDLE; |
824 | kfree(cm_id_priv->compare_data); | ||
825 | cm_id_priv->compare_data = NULL; | ||
772 | ret = -EBUSY; | 826 | ret = -EBUSY; |
773 | } | 827 | } |
774 | return ret; | 828 | return ret; |
@@ -1241,7 +1295,8 @@ static struct cm_id_private * cm_match_req(struct cm_work *work, | |||
1241 | 1295 | ||
1242 | /* Find matching listen request. */ | 1296 | /* Find matching listen request. */ |
1243 | listen_cm_id_priv = cm_find_listen(cm_id_priv->id.device, | 1297 | listen_cm_id_priv = cm_find_listen(cm_id_priv->id.device, |
1244 | req_msg->service_id); | 1298 | req_msg->service_id, |
1299 | req_msg->private_data); | ||
1245 | if (!listen_cm_id_priv) { | 1300 | if (!listen_cm_id_priv) { |
1246 | spin_unlock_irqrestore(&cm.lock, flags); | 1301 | spin_unlock_irqrestore(&cm.lock, flags); |
1247 | cm_issue_rej(work->port, work->mad_recv_wc, | 1302 | cm_issue_rej(work->port, work->mad_recv_wc, |
@@ -1276,6 +1331,7 @@ static int cm_req_handler(struct cm_work *work) | |||
1276 | cm_id_priv = container_of(cm_id, struct cm_id_private, id); | 1331 | cm_id_priv = container_of(cm_id, struct cm_id_private, id); |
1277 | cm_id_priv->id.remote_id = req_msg->local_comm_id; | 1332 | cm_id_priv->id.remote_id = req_msg->local_comm_id; |
1278 | cm_init_av_for_response(work->port, work->mad_recv_wc->wc, | 1333 | cm_init_av_for_response(work->port, work->mad_recv_wc->wc, |
1334 | work->mad_recv_wc->recv_buf.grh, | ||
1279 | &cm_id_priv->av); | 1335 | &cm_id_priv->av); |
1280 | cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv-> | 1336 | cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv-> |
1281 | id.local_id); | 1337 | id.local_id); |
@@ -2549,7 +2605,7 @@ static void cm_format_sidr_req(struct cm_sidr_req_msg *sidr_req_msg, | |||
2549 | cm_format_mad_hdr(&sidr_req_msg->hdr, CM_SIDR_REQ_ATTR_ID, | 2605 | cm_format_mad_hdr(&sidr_req_msg->hdr, CM_SIDR_REQ_ATTR_ID, |
2550 | cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_SIDR)); | 2606 | cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_SIDR)); |
2551 | sidr_req_msg->request_id = cm_id_priv->id.local_id; | 2607 | sidr_req_msg->request_id = cm_id_priv->id.local_id; |
2552 | sidr_req_msg->pkey = cpu_to_be16(param->pkey); | 2608 | sidr_req_msg->pkey = cpu_to_be16(param->path->pkey); |
2553 | sidr_req_msg->service_id = param->service_id; | 2609 | sidr_req_msg->service_id = param->service_id; |
2554 | 2610 | ||
2555 | if (param->private_data && param->private_data_len) | 2611 | if (param->private_data && param->private_data_len) |
@@ -2641,6 +2697,7 @@ static int cm_sidr_req_handler(struct cm_work *work) | |||
2641 | cm_id_priv->av.dgid.global.subnet_prefix = cpu_to_be64(wc->slid); | 2697 | cm_id_priv->av.dgid.global.subnet_prefix = cpu_to_be64(wc->slid); |
2642 | cm_id_priv->av.dgid.global.interface_id = 0; | 2698 | cm_id_priv->av.dgid.global.interface_id = 0; |
2643 | cm_init_av_for_response(work->port, work->mad_recv_wc->wc, | 2699 | cm_init_av_for_response(work->port, work->mad_recv_wc->wc, |
2700 | work->mad_recv_wc->recv_buf.grh, | ||
2644 | &cm_id_priv->av); | 2701 | &cm_id_priv->av); |
2645 | cm_id_priv->id.remote_id = sidr_req_msg->request_id; | 2702 | cm_id_priv->id.remote_id = sidr_req_msg->request_id; |
2646 | cm_id_priv->id.state = IB_CM_SIDR_REQ_RCVD; | 2703 | cm_id_priv->id.state = IB_CM_SIDR_REQ_RCVD; |
@@ -2654,7 +2711,8 @@ static int cm_sidr_req_handler(struct cm_work *work) | |||
2654 | goto out; /* Duplicate message. */ | 2711 | goto out; /* Duplicate message. */ |
2655 | } | 2712 | } |
2656 | cur_cm_id_priv = cm_find_listen(cm_id->device, | 2713 | cur_cm_id_priv = cm_find_listen(cm_id->device, |
2657 | sidr_req_msg->service_id); | 2714 | sidr_req_msg->service_id, |
2715 | sidr_req_msg->private_data); | ||
2658 | if (!cur_cm_id_priv) { | 2716 | if (!cur_cm_id_priv) { |
2659 | rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table); | 2717 | rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table); |
2660 | spin_unlock_irqrestore(&cm.lock, flags); | 2718 | spin_unlock_irqrestore(&cm.lock, flags); |
@@ -3291,7 +3349,6 @@ error: | |||
3291 | 3349 | ||
3292 | static void __exit ib_cm_cleanup(void) | 3350 | static void __exit ib_cm_cleanup(void) |
3293 | { | 3351 | { |
3294 | flush_workqueue(cm.wq); | ||
3295 | destroy_workqueue(cm.wq); | 3352 | destroy_workqueue(cm.wq); |
3296 | ib_unregister_client(&cm_client); | 3353 | ib_unregister_client(&cm_client); |
3297 | idr_destroy(&cm.local_id_table); | 3354 | idr_destroy(&cm.local_id_table); |
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c new file mode 100644 index 000000000000..a76834edf608 --- /dev/null +++ b/drivers/infiniband/core/cma.c | |||
@@ -0,0 +1,1927 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2005 Voltaire Inc. All rights reserved. | ||
3 | * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved. | ||
4 | * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved. | ||
5 | * Copyright (c) 2005-2006 Intel Corporation. All rights reserved. | ||
6 | * | ||
7 | * This Software is licensed under one of the following licenses: | ||
8 | * | ||
9 | * 1) under the terms of the "Common Public License 1.0" a copy of which is | ||
10 | * available from the Open Source Initiative, see | ||
11 | * http://www.opensource.org/licenses/cpl.php. | ||
12 | * | ||
13 | * 2) under the terms of the "The BSD License" a copy of which is | ||
14 | * available from the Open Source Initiative, see | ||
15 | * http://www.opensource.org/licenses/bsd-license.php. | ||
16 | * | ||
17 | * 3) under the terms of the "GNU General Public License (GPL) Version 2" a | ||
18 | * copy of which is available from the Open Source Initiative, see | ||
19 | * http://www.opensource.org/licenses/gpl-license.php. | ||
20 | * | ||
21 | * Licensee has the right to choose one of the above licenses. | ||
22 | * | ||
23 | * Redistributions of source code must retain the above copyright | ||
24 | * notice and one of the license notices. | ||
25 | * | ||
26 | * Redistributions in binary form must reproduce both the above copyright | ||
27 | * notice, one of the license notices in the documentation | ||
28 | * and/or other materials provided with the distribution. | ||
29 | * | ||
30 | */ | ||
31 | |||
32 | #include <linux/completion.h> | ||
33 | #include <linux/in.h> | ||
34 | #include <linux/in6.h> | ||
35 | #include <linux/mutex.h> | ||
36 | #include <linux/random.h> | ||
37 | #include <linux/idr.h> | ||
38 | |||
39 | #include <net/tcp.h> | ||
40 | |||
41 | #include <rdma/rdma_cm.h> | ||
42 | #include <rdma/rdma_cm_ib.h> | ||
43 | #include <rdma/ib_cache.h> | ||
44 | #include <rdma/ib_cm.h> | ||
45 | #include <rdma/ib_sa.h> | ||
46 | |||
47 | MODULE_AUTHOR("Sean Hefty"); | ||
48 | MODULE_DESCRIPTION("Generic RDMA CM Agent"); | ||
49 | MODULE_LICENSE("Dual BSD/GPL"); | ||
50 | |||
51 | #define CMA_CM_RESPONSE_TIMEOUT 20 | ||
52 | #define CMA_MAX_CM_RETRIES 3 | ||
53 | |||
54 | static void cma_add_one(struct ib_device *device); | ||
55 | static void cma_remove_one(struct ib_device *device); | ||
56 | |||
57 | static struct ib_client cma_client = { | ||
58 | .name = "cma", | ||
59 | .add = cma_add_one, | ||
60 | .remove = cma_remove_one | ||
61 | }; | ||
62 | |||
63 | static LIST_HEAD(dev_list); | ||
64 | static LIST_HEAD(listen_any_list); | ||
65 | static DEFINE_MUTEX(lock); | ||
66 | static struct workqueue_struct *cma_wq; | ||
67 | static DEFINE_IDR(sdp_ps); | ||
68 | static DEFINE_IDR(tcp_ps); | ||
69 | |||
70 | struct cma_device { | ||
71 | struct list_head list; | ||
72 | struct ib_device *device; | ||
73 | __be64 node_guid; | ||
74 | struct completion comp; | ||
75 | atomic_t refcount; | ||
76 | struct list_head id_list; | ||
77 | }; | ||
78 | |||
79 | enum cma_state { | ||
80 | CMA_IDLE, | ||
81 | CMA_ADDR_QUERY, | ||
82 | CMA_ADDR_RESOLVED, | ||
83 | CMA_ROUTE_QUERY, | ||
84 | CMA_ROUTE_RESOLVED, | ||
85 | CMA_CONNECT, | ||
86 | CMA_DISCONNECT, | ||
87 | CMA_ADDR_BOUND, | ||
88 | CMA_LISTEN, | ||
89 | CMA_DEVICE_REMOVAL, | ||
90 | CMA_DESTROYING | ||
91 | }; | ||
92 | |||
93 | struct rdma_bind_list { | ||
94 | struct idr *ps; | ||
95 | struct hlist_head owners; | ||
96 | unsigned short port; | ||
97 | }; | ||
98 | |||
99 | /* | ||
100 | * Device removal can occur at anytime, so we need extra handling to | ||
101 | * serialize notifying the user of device removal with other callbacks. | ||
102 | * We do this by disabling removal notification while a callback is in process, | ||
103 | * and reporting it after the callback completes. | ||
104 | */ | ||
105 | struct rdma_id_private { | ||
106 | struct rdma_cm_id id; | ||
107 | |||
108 | struct rdma_bind_list *bind_list; | ||
109 | struct hlist_node node; | ||
110 | struct list_head list; | ||
111 | struct list_head listen_list; | ||
112 | struct cma_device *cma_dev; | ||
113 | |||
114 | enum cma_state state; | ||
115 | spinlock_t lock; | ||
116 | struct completion comp; | ||
117 | atomic_t refcount; | ||
118 | wait_queue_head_t wait_remove; | ||
119 | atomic_t dev_remove; | ||
120 | |||
121 | int backlog; | ||
122 | int timeout_ms; | ||
123 | struct ib_sa_query *query; | ||
124 | int query_id; | ||
125 | union { | ||
126 | struct ib_cm_id *ib; | ||
127 | } cm_id; | ||
128 | |||
129 | u32 seq_num; | ||
130 | u32 qp_num; | ||
131 | enum ib_qp_type qp_type; | ||
132 | u8 srq; | ||
133 | }; | ||
134 | |||
135 | struct cma_work { | ||
136 | struct work_struct work; | ||
137 | struct rdma_id_private *id; | ||
138 | enum cma_state old_state; | ||
139 | enum cma_state new_state; | ||
140 | struct rdma_cm_event event; | ||
141 | }; | ||
142 | |||
143 | union cma_ip_addr { | ||
144 | struct in6_addr ip6; | ||
145 | struct { | ||
146 | __u32 pad[3]; | ||
147 | __u32 addr; | ||
148 | } ip4; | ||
149 | }; | ||
150 | |||
151 | struct cma_hdr { | ||
152 | u8 cma_version; | ||
153 | u8 ip_version; /* IP version: 7:4 */ | ||
154 | __u16 port; | ||
155 | union cma_ip_addr src_addr; | ||
156 | union cma_ip_addr dst_addr; | ||
157 | }; | ||
158 | |||
159 | struct sdp_hh { | ||
160 | u8 bsdh[16]; | ||
161 | u8 sdp_version; /* Major version: 7:4 */ | ||
162 | u8 ip_version; /* IP version: 7:4 */ | ||
163 | u8 sdp_specific1[10]; | ||
164 | __u16 port; | ||
165 | __u16 sdp_specific2; | ||
166 | union cma_ip_addr src_addr; | ||
167 | union cma_ip_addr dst_addr; | ||
168 | }; | ||
169 | |||
170 | struct sdp_hah { | ||
171 | u8 bsdh[16]; | ||
172 | u8 sdp_version; | ||
173 | }; | ||
174 | |||
175 | #define CMA_VERSION 0x00 | ||
176 | #define SDP_MAJ_VERSION 0x2 | ||
177 | |||
178 | static int cma_comp(struct rdma_id_private *id_priv, enum cma_state comp) | ||
179 | { | ||
180 | unsigned long flags; | ||
181 | int ret; | ||
182 | |||
183 | spin_lock_irqsave(&id_priv->lock, flags); | ||
184 | ret = (id_priv->state == comp); | ||
185 | spin_unlock_irqrestore(&id_priv->lock, flags); | ||
186 | return ret; | ||
187 | } | ||
188 | |||
189 | static int cma_comp_exch(struct rdma_id_private *id_priv, | ||
190 | enum cma_state comp, enum cma_state exch) | ||
191 | { | ||
192 | unsigned long flags; | ||
193 | int ret; | ||
194 | |||
195 | spin_lock_irqsave(&id_priv->lock, flags); | ||
196 | if ((ret = (id_priv->state == comp))) | ||
197 | id_priv->state = exch; | ||
198 | spin_unlock_irqrestore(&id_priv->lock, flags); | ||
199 | return ret; | ||
200 | } | ||
201 | |||
202 | static enum cma_state cma_exch(struct rdma_id_private *id_priv, | ||
203 | enum cma_state exch) | ||
204 | { | ||
205 | unsigned long flags; | ||
206 | enum cma_state old; | ||
207 | |||
208 | spin_lock_irqsave(&id_priv->lock, flags); | ||
209 | old = id_priv->state; | ||
210 | id_priv->state = exch; | ||
211 | spin_unlock_irqrestore(&id_priv->lock, flags); | ||
212 | return old; | ||
213 | } | ||
214 | |||
215 | static inline u8 cma_get_ip_ver(struct cma_hdr *hdr) | ||
216 | { | ||
217 | return hdr->ip_version >> 4; | ||
218 | } | ||
219 | |||
220 | static inline void cma_set_ip_ver(struct cma_hdr *hdr, u8 ip_ver) | ||
221 | { | ||
222 | hdr->ip_version = (ip_ver << 4) | (hdr->ip_version & 0xF); | ||
223 | } | ||
224 | |||
225 | static inline u8 sdp_get_majv(u8 sdp_version) | ||
226 | { | ||
227 | return sdp_version >> 4; | ||
228 | } | ||
229 | |||
230 | static inline u8 sdp_get_ip_ver(struct sdp_hh *hh) | ||
231 | { | ||
232 | return hh->ip_version >> 4; | ||
233 | } | ||
234 | |||
235 | static inline void sdp_set_ip_ver(struct sdp_hh *hh, u8 ip_ver) | ||
236 | { | ||
237 | hh->ip_version = (ip_ver << 4) | (hh->ip_version & 0xF); | ||
238 | } | ||
239 | |||
240 | static void cma_attach_to_dev(struct rdma_id_private *id_priv, | ||
241 | struct cma_device *cma_dev) | ||
242 | { | ||
243 | atomic_inc(&cma_dev->refcount); | ||
244 | id_priv->cma_dev = cma_dev; | ||
245 | id_priv->id.device = cma_dev->device; | ||
246 | list_add_tail(&id_priv->list, &cma_dev->id_list); | ||
247 | } | ||
248 | |||
249 | static inline void cma_deref_dev(struct cma_device *cma_dev) | ||
250 | { | ||
251 | if (atomic_dec_and_test(&cma_dev->refcount)) | ||
252 | complete(&cma_dev->comp); | ||
253 | } | ||
254 | |||
255 | static void cma_detach_from_dev(struct rdma_id_private *id_priv) | ||
256 | { | ||
257 | list_del(&id_priv->list); | ||
258 | cma_deref_dev(id_priv->cma_dev); | ||
259 | id_priv->cma_dev = NULL; | ||
260 | } | ||
261 | |||
262 | static int cma_acquire_ib_dev(struct rdma_id_private *id_priv) | ||
263 | { | ||
264 | struct cma_device *cma_dev; | ||
265 | union ib_gid *gid; | ||
266 | int ret = -ENODEV; | ||
267 | |||
268 | gid = ib_addr_get_sgid(&id_priv->id.route.addr.dev_addr); | ||
269 | |||
270 | mutex_lock(&lock); | ||
271 | list_for_each_entry(cma_dev, &dev_list, list) { | ||
272 | ret = ib_find_cached_gid(cma_dev->device, gid, | ||
273 | &id_priv->id.port_num, NULL); | ||
274 | if (!ret) { | ||
275 | cma_attach_to_dev(id_priv, cma_dev); | ||
276 | break; | ||
277 | } | ||
278 | } | ||
279 | mutex_unlock(&lock); | ||
280 | return ret; | ||
281 | } | ||
282 | |||
283 | static int cma_acquire_dev(struct rdma_id_private *id_priv) | ||
284 | { | ||
285 | switch (id_priv->id.route.addr.dev_addr.dev_type) { | ||
286 | case IB_NODE_CA: | ||
287 | return cma_acquire_ib_dev(id_priv); | ||
288 | default: | ||
289 | return -ENODEV; | ||
290 | } | ||
291 | } | ||
292 | |||
293 | static void cma_deref_id(struct rdma_id_private *id_priv) | ||
294 | { | ||
295 | if (atomic_dec_and_test(&id_priv->refcount)) | ||
296 | complete(&id_priv->comp); | ||
297 | } | ||
298 | |||
299 | static void cma_release_remove(struct rdma_id_private *id_priv) | ||
300 | { | ||
301 | if (atomic_dec_and_test(&id_priv->dev_remove)) | ||
302 | wake_up(&id_priv->wait_remove); | ||
303 | } | ||
304 | |||
305 | struct rdma_cm_id *rdma_create_id(rdma_cm_event_handler event_handler, | ||
306 | void *context, enum rdma_port_space ps) | ||
307 | { | ||
308 | struct rdma_id_private *id_priv; | ||
309 | |||
310 | id_priv = kzalloc(sizeof *id_priv, GFP_KERNEL); | ||
311 | if (!id_priv) | ||
312 | return ERR_PTR(-ENOMEM); | ||
313 | |||
314 | id_priv->state = CMA_IDLE; | ||
315 | id_priv->id.context = context; | ||
316 | id_priv->id.event_handler = event_handler; | ||
317 | id_priv->id.ps = ps; | ||
318 | spin_lock_init(&id_priv->lock); | ||
319 | init_completion(&id_priv->comp); | ||
320 | atomic_set(&id_priv->refcount, 1); | ||
321 | init_waitqueue_head(&id_priv->wait_remove); | ||
322 | atomic_set(&id_priv->dev_remove, 0); | ||
323 | INIT_LIST_HEAD(&id_priv->listen_list); | ||
324 | get_random_bytes(&id_priv->seq_num, sizeof id_priv->seq_num); | ||
325 | |||
326 | return &id_priv->id; | ||
327 | } | ||
328 | EXPORT_SYMBOL(rdma_create_id); | ||
329 | |||
330 | static int cma_init_ib_qp(struct rdma_id_private *id_priv, struct ib_qp *qp) | ||
331 | { | ||
332 | struct ib_qp_attr qp_attr; | ||
333 | struct rdma_dev_addr *dev_addr; | ||
334 | int ret; | ||
335 | |||
336 | dev_addr = &id_priv->id.route.addr.dev_addr; | ||
337 | ret = ib_find_cached_pkey(id_priv->id.device, id_priv->id.port_num, | ||
338 | ib_addr_get_pkey(dev_addr), | ||
339 | &qp_attr.pkey_index); | ||
340 | if (ret) | ||
341 | return ret; | ||
342 | |||
343 | qp_attr.qp_state = IB_QPS_INIT; | ||
344 | qp_attr.qp_access_flags = IB_ACCESS_LOCAL_WRITE; | ||
345 | qp_attr.port_num = id_priv->id.port_num; | ||
346 | return ib_modify_qp(qp, &qp_attr, IB_QP_STATE | IB_QP_ACCESS_FLAGS | | ||
347 | IB_QP_PKEY_INDEX | IB_QP_PORT); | ||
348 | } | ||
349 | |||
350 | int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd, | ||
351 | struct ib_qp_init_attr *qp_init_attr) | ||
352 | { | ||
353 | struct rdma_id_private *id_priv; | ||
354 | struct ib_qp *qp; | ||
355 | int ret; | ||
356 | |||
357 | id_priv = container_of(id, struct rdma_id_private, id); | ||
358 | if (id->device != pd->device) | ||
359 | return -EINVAL; | ||
360 | |||
361 | qp = ib_create_qp(pd, qp_init_attr); | ||
362 | if (IS_ERR(qp)) | ||
363 | return PTR_ERR(qp); | ||
364 | |||
365 | switch (id->device->node_type) { | ||
366 | case IB_NODE_CA: | ||
367 | ret = cma_init_ib_qp(id_priv, qp); | ||
368 | break; | ||
369 | default: | ||
370 | ret = -ENOSYS; | ||
371 | break; | ||
372 | } | ||
373 | |||
374 | if (ret) | ||
375 | goto err; | ||
376 | |||
377 | id->qp = qp; | ||
378 | id_priv->qp_num = qp->qp_num; | ||
379 | id_priv->qp_type = qp->qp_type; | ||
380 | id_priv->srq = (qp->srq != NULL); | ||
381 | return 0; | ||
382 | err: | ||
383 | ib_destroy_qp(qp); | ||
384 | return ret; | ||
385 | } | ||
386 | EXPORT_SYMBOL(rdma_create_qp); | ||
387 | |||
388 | void rdma_destroy_qp(struct rdma_cm_id *id) | ||
389 | { | ||
390 | ib_destroy_qp(id->qp); | ||
391 | } | ||
392 | EXPORT_SYMBOL(rdma_destroy_qp); | ||
393 | |||
394 | static int cma_modify_qp_rtr(struct rdma_cm_id *id) | ||
395 | { | ||
396 | struct ib_qp_attr qp_attr; | ||
397 | int qp_attr_mask, ret; | ||
398 | |||
399 | if (!id->qp) | ||
400 | return 0; | ||
401 | |||
402 | /* Need to update QP attributes from default values. */ | ||
403 | qp_attr.qp_state = IB_QPS_INIT; | ||
404 | ret = rdma_init_qp_attr(id, &qp_attr, &qp_attr_mask); | ||
405 | if (ret) | ||
406 | return ret; | ||
407 | |||
408 | ret = ib_modify_qp(id->qp, &qp_attr, qp_attr_mask); | ||
409 | if (ret) | ||
410 | return ret; | ||
411 | |||
412 | qp_attr.qp_state = IB_QPS_RTR; | ||
413 | ret = rdma_init_qp_attr(id, &qp_attr, &qp_attr_mask); | ||
414 | if (ret) | ||
415 | return ret; | ||
416 | |||
417 | return ib_modify_qp(id->qp, &qp_attr, qp_attr_mask); | ||
418 | } | ||
419 | |||
420 | static int cma_modify_qp_rts(struct rdma_cm_id *id) | ||
421 | { | ||
422 | struct ib_qp_attr qp_attr; | ||
423 | int qp_attr_mask, ret; | ||
424 | |||
425 | if (!id->qp) | ||
426 | return 0; | ||
427 | |||
428 | qp_attr.qp_state = IB_QPS_RTS; | ||
429 | ret = rdma_init_qp_attr(id, &qp_attr, &qp_attr_mask); | ||
430 | if (ret) | ||
431 | return ret; | ||
432 | |||
433 | return ib_modify_qp(id->qp, &qp_attr, qp_attr_mask); | ||
434 | } | ||
435 | |||
436 | static int cma_modify_qp_err(struct rdma_cm_id *id) | ||
437 | { | ||
438 | struct ib_qp_attr qp_attr; | ||
439 | |||
440 | if (!id->qp) | ||
441 | return 0; | ||
442 | |||
443 | qp_attr.qp_state = IB_QPS_ERR; | ||
444 | return ib_modify_qp(id->qp, &qp_attr, IB_QP_STATE); | ||
445 | } | ||
446 | |||
447 | int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr, | ||
448 | int *qp_attr_mask) | ||
449 | { | ||
450 | struct rdma_id_private *id_priv; | ||
451 | int ret; | ||
452 | |||
453 | id_priv = container_of(id, struct rdma_id_private, id); | ||
454 | switch (id_priv->id.device->node_type) { | ||
455 | case IB_NODE_CA: | ||
456 | ret = ib_cm_init_qp_attr(id_priv->cm_id.ib, qp_attr, | ||
457 | qp_attr_mask); | ||
458 | if (qp_attr->qp_state == IB_QPS_RTR) | ||
459 | qp_attr->rq_psn = id_priv->seq_num; | ||
460 | break; | ||
461 | default: | ||
462 | ret = -ENOSYS; | ||
463 | break; | ||
464 | } | ||
465 | |||
466 | return ret; | ||
467 | } | ||
468 | EXPORT_SYMBOL(rdma_init_qp_attr); | ||
469 | |||
470 | static inline int cma_zero_addr(struct sockaddr *addr) | ||
471 | { | ||
472 | struct in6_addr *ip6; | ||
473 | |||
474 | if (addr->sa_family == AF_INET) | ||
475 | return ZERONET(((struct sockaddr_in *) addr)->sin_addr.s_addr); | ||
476 | else { | ||
477 | ip6 = &((struct sockaddr_in6 *) addr)->sin6_addr; | ||
478 | return (ip6->s6_addr32[0] | ip6->s6_addr32[1] | | ||
479 | ip6->s6_addr32[3] | ip6->s6_addr32[4]) == 0; | ||
480 | } | ||
481 | } | ||
482 | |||
483 | static inline int cma_loopback_addr(struct sockaddr *addr) | ||
484 | { | ||
485 | return LOOPBACK(((struct sockaddr_in *) addr)->sin_addr.s_addr); | ||
486 | } | ||
487 | |||
488 | static inline int cma_any_addr(struct sockaddr *addr) | ||
489 | { | ||
490 | return cma_zero_addr(addr) || cma_loopback_addr(addr); | ||
491 | } | ||
492 | |||
493 | static inline int cma_any_port(struct sockaddr *addr) | ||
494 | { | ||
495 | return !((struct sockaddr_in *) addr)->sin_port; | ||
496 | } | ||
497 | |||
498 | static int cma_get_net_info(void *hdr, enum rdma_port_space ps, | ||
499 | u8 *ip_ver, __u16 *port, | ||
500 | union cma_ip_addr **src, union cma_ip_addr **dst) | ||
501 | { | ||
502 | switch (ps) { | ||
503 | case RDMA_PS_SDP: | ||
504 | if (sdp_get_majv(((struct sdp_hh *) hdr)->sdp_version) != | ||
505 | SDP_MAJ_VERSION) | ||
506 | return -EINVAL; | ||
507 | |||
508 | *ip_ver = sdp_get_ip_ver(hdr); | ||
509 | *port = ((struct sdp_hh *) hdr)->port; | ||
510 | *src = &((struct sdp_hh *) hdr)->src_addr; | ||
511 | *dst = &((struct sdp_hh *) hdr)->dst_addr; | ||
512 | break; | ||
513 | default: | ||
514 | if (((struct cma_hdr *) hdr)->cma_version != CMA_VERSION) | ||
515 | return -EINVAL; | ||
516 | |||
517 | *ip_ver = cma_get_ip_ver(hdr); | ||
518 | *port = ((struct cma_hdr *) hdr)->port; | ||
519 | *src = &((struct cma_hdr *) hdr)->src_addr; | ||
520 | *dst = &((struct cma_hdr *) hdr)->dst_addr; | ||
521 | break; | ||
522 | } | ||
523 | |||
524 | if (*ip_ver != 4 && *ip_ver != 6) | ||
525 | return -EINVAL; | ||
526 | return 0; | ||
527 | } | ||
528 | |||
529 | static void cma_save_net_info(struct rdma_addr *addr, | ||
530 | struct rdma_addr *listen_addr, | ||
531 | u8 ip_ver, __u16 port, | ||
532 | union cma_ip_addr *src, union cma_ip_addr *dst) | ||
533 | { | ||
534 | struct sockaddr_in *listen4, *ip4; | ||
535 | struct sockaddr_in6 *listen6, *ip6; | ||
536 | |||
537 | switch (ip_ver) { | ||
538 | case 4: | ||
539 | listen4 = (struct sockaddr_in *) &listen_addr->src_addr; | ||
540 | ip4 = (struct sockaddr_in *) &addr->src_addr; | ||
541 | ip4->sin_family = listen4->sin_family; | ||
542 | ip4->sin_addr.s_addr = dst->ip4.addr; | ||
543 | ip4->sin_port = listen4->sin_port; | ||
544 | |||
545 | ip4 = (struct sockaddr_in *) &addr->dst_addr; | ||
546 | ip4->sin_family = listen4->sin_family; | ||
547 | ip4->sin_addr.s_addr = src->ip4.addr; | ||
548 | ip4->sin_port = port; | ||
549 | break; | ||
550 | case 6: | ||
551 | listen6 = (struct sockaddr_in6 *) &listen_addr->src_addr; | ||
552 | ip6 = (struct sockaddr_in6 *) &addr->src_addr; | ||
553 | ip6->sin6_family = listen6->sin6_family; | ||
554 | ip6->sin6_addr = dst->ip6; | ||
555 | ip6->sin6_port = listen6->sin6_port; | ||
556 | |||
557 | ip6 = (struct sockaddr_in6 *) &addr->dst_addr; | ||
558 | ip6->sin6_family = listen6->sin6_family; | ||
559 | ip6->sin6_addr = src->ip6; | ||
560 | ip6->sin6_port = port; | ||
561 | break; | ||
562 | default: | ||
563 | break; | ||
564 | } | ||
565 | } | ||
566 | |||
567 | static inline int cma_user_data_offset(enum rdma_port_space ps) | ||
568 | { | ||
569 | switch (ps) { | ||
570 | case RDMA_PS_SDP: | ||
571 | return 0; | ||
572 | default: | ||
573 | return sizeof(struct cma_hdr); | ||
574 | } | ||
575 | } | ||
576 | |||
577 | static int cma_notify_user(struct rdma_id_private *id_priv, | ||
578 | enum rdma_cm_event_type type, int status, | ||
579 | void *data, u8 data_len) | ||
580 | { | ||
581 | struct rdma_cm_event event; | ||
582 | |||
583 | event.event = type; | ||
584 | event.status = status; | ||
585 | event.private_data = data; | ||
586 | event.private_data_len = data_len; | ||
587 | |||
588 | return id_priv->id.event_handler(&id_priv->id, &event); | ||
589 | } | ||
590 | |||
591 | static void cma_cancel_route(struct rdma_id_private *id_priv) | ||
592 | { | ||
593 | switch (id_priv->id.device->node_type) { | ||
594 | case IB_NODE_CA: | ||
595 | if (id_priv->query) | ||
596 | ib_sa_cancel_query(id_priv->query_id, id_priv->query); | ||
597 | break; | ||
598 | default: | ||
599 | break; | ||
600 | } | ||
601 | } | ||
602 | |||
603 | static inline int cma_internal_listen(struct rdma_id_private *id_priv) | ||
604 | { | ||
605 | return (id_priv->state == CMA_LISTEN) && id_priv->cma_dev && | ||
606 | cma_any_addr(&id_priv->id.route.addr.src_addr); | ||
607 | } | ||
608 | |||
609 | static void cma_destroy_listen(struct rdma_id_private *id_priv) | ||
610 | { | ||
611 | cma_exch(id_priv, CMA_DESTROYING); | ||
612 | |||
613 | if (id_priv->cma_dev) { | ||
614 | switch (id_priv->id.device->node_type) { | ||
615 | case IB_NODE_CA: | ||
616 | if (id_priv->cm_id.ib && !IS_ERR(id_priv->cm_id.ib)) | ||
617 | ib_destroy_cm_id(id_priv->cm_id.ib); | ||
618 | break; | ||
619 | default: | ||
620 | break; | ||
621 | } | ||
622 | cma_detach_from_dev(id_priv); | ||
623 | } | ||
624 | list_del(&id_priv->listen_list); | ||
625 | |||
626 | cma_deref_id(id_priv); | ||
627 | wait_for_completion(&id_priv->comp); | ||
628 | |||
629 | kfree(id_priv); | ||
630 | } | ||
631 | |||
632 | static void cma_cancel_listens(struct rdma_id_private *id_priv) | ||
633 | { | ||
634 | struct rdma_id_private *dev_id_priv; | ||
635 | |||
636 | mutex_lock(&lock); | ||
637 | list_del(&id_priv->list); | ||
638 | |||
639 | while (!list_empty(&id_priv->listen_list)) { | ||
640 | dev_id_priv = list_entry(id_priv->listen_list.next, | ||
641 | struct rdma_id_private, listen_list); | ||
642 | cma_destroy_listen(dev_id_priv); | ||
643 | } | ||
644 | mutex_unlock(&lock); | ||
645 | } | ||
646 | |||
647 | static void cma_cancel_operation(struct rdma_id_private *id_priv, | ||
648 | enum cma_state state) | ||
649 | { | ||
650 | switch (state) { | ||
651 | case CMA_ADDR_QUERY: | ||
652 | rdma_addr_cancel(&id_priv->id.route.addr.dev_addr); | ||
653 | break; | ||
654 | case CMA_ROUTE_QUERY: | ||
655 | cma_cancel_route(id_priv); | ||
656 | break; | ||
657 | case CMA_LISTEN: | ||
658 | if (cma_any_addr(&id_priv->id.route.addr.src_addr) && | ||
659 | !id_priv->cma_dev) | ||
660 | cma_cancel_listens(id_priv); | ||
661 | break; | ||
662 | default: | ||
663 | break; | ||
664 | } | ||
665 | } | ||
666 | |||
667 | static void cma_release_port(struct rdma_id_private *id_priv) | ||
668 | { | ||
669 | struct rdma_bind_list *bind_list = id_priv->bind_list; | ||
670 | |||
671 | if (!bind_list) | ||
672 | return; | ||
673 | |||
674 | mutex_lock(&lock); | ||
675 | hlist_del(&id_priv->node); | ||
676 | if (hlist_empty(&bind_list->owners)) { | ||
677 | idr_remove(bind_list->ps, bind_list->port); | ||
678 | kfree(bind_list); | ||
679 | } | ||
680 | mutex_unlock(&lock); | ||
681 | } | ||
682 | |||
683 | void rdma_destroy_id(struct rdma_cm_id *id) | ||
684 | { | ||
685 | struct rdma_id_private *id_priv; | ||
686 | enum cma_state state; | ||
687 | |||
688 | id_priv = container_of(id, struct rdma_id_private, id); | ||
689 | state = cma_exch(id_priv, CMA_DESTROYING); | ||
690 | cma_cancel_operation(id_priv, state); | ||
691 | |||
692 | if (id_priv->cma_dev) { | ||
693 | switch (id->device->node_type) { | ||
694 | case IB_NODE_CA: | ||
695 | if (id_priv->cm_id.ib && !IS_ERR(id_priv->cm_id.ib)) | ||
696 | ib_destroy_cm_id(id_priv->cm_id.ib); | ||
697 | break; | ||
698 | default: | ||
699 | break; | ||
700 | } | ||
701 | mutex_lock(&lock); | ||
702 | cma_detach_from_dev(id_priv); | ||
703 | mutex_unlock(&lock); | ||
704 | } | ||
705 | |||
706 | cma_release_port(id_priv); | ||
707 | cma_deref_id(id_priv); | ||
708 | wait_for_completion(&id_priv->comp); | ||
709 | |||
710 | kfree(id_priv->id.route.path_rec); | ||
711 | kfree(id_priv); | ||
712 | } | ||
713 | EXPORT_SYMBOL(rdma_destroy_id); | ||
714 | |||
715 | static int cma_rep_recv(struct rdma_id_private *id_priv) | ||
716 | { | ||
717 | int ret; | ||
718 | |||
719 | ret = cma_modify_qp_rtr(&id_priv->id); | ||
720 | if (ret) | ||
721 | goto reject; | ||
722 | |||
723 | ret = cma_modify_qp_rts(&id_priv->id); | ||
724 | if (ret) | ||
725 | goto reject; | ||
726 | |||
727 | ret = ib_send_cm_rtu(id_priv->cm_id.ib, NULL, 0); | ||
728 | if (ret) | ||
729 | goto reject; | ||
730 | |||
731 | return 0; | ||
732 | reject: | ||
733 | cma_modify_qp_err(&id_priv->id); | ||
734 | ib_send_cm_rej(id_priv->cm_id.ib, IB_CM_REJ_CONSUMER_DEFINED, | ||
735 | NULL, 0, NULL, 0); | ||
736 | return ret; | ||
737 | } | ||
738 | |||
739 | static int cma_verify_rep(struct rdma_id_private *id_priv, void *data) | ||
740 | { | ||
741 | if (id_priv->id.ps == RDMA_PS_SDP && | ||
742 | sdp_get_majv(((struct sdp_hah *) data)->sdp_version) != | ||
743 | SDP_MAJ_VERSION) | ||
744 | return -EINVAL; | ||
745 | |||
746 | return 0; | ||
747 | } | ||
748 | |||
749 | static int cma_rtu_recv(struct rdma_id_private *id_priv) | ||
750 | { | ||
751 | int ret; | ||
752 | |||
753 | ret = cma_modify_qp_rts(&id_priv->id); | ||
754 | if (ret) | ||
755 | goto reject; | ||
756 | |||
757 | return 0; | ||
758 | reject: | ||
759 | cma_modify_qp_err(&id_priv->id); | ||
760 | ib_send_cm_rej(id_priv->cm_id.ib, IB_CM_REJ_CONSUMER_DEFINED, | ||
761 | NULL, 0, NULL, 0); | ||
762 | return ret; | ||
763 | } | ||
764 | |||
765 | static int cma_ib_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event) | ||
766 | { | ||
767 | struct rdma_id_private *id_priv = cm_id->context; | ||
768 | enum rdma_cm_event_type event; | ||
769 | u8 private_data_len = 0; | ||
770 | int ret = 0, status = 0; | ||
771 | |||
772 | atomic_inc(&id_priv->dev_remove); | ||
773 | if (!cma_comp(id_priv, CMA_CONNECT)) | ||
774 | goto out; | ||
775 | |||
776 | switch (ib_event->event) { | ||
777 | case IB_CM_REQ_ERROR: | ||
778 | case IB_CM_REP_ERROR: | ||
779 | event = RDMA_CM_EVENT_UNREACHABLE; | ||
780 | status = -ETIMEDOUT; | ||
781 | break; | ||
782 | case IB_CM_REP_RECEIVED: | ||
783 | status = cma_verify_rep(id_priv, ib_event->private_data); | ||
784 | if (status) | ||
785 | event = RDMA_CM_EVENT_CONNECT_ERROR; | ||
786 | else if (id_priv->id.qp && id_priv->id.ps != RDMA_PS_SDP) { | ||
787 | status = cma_rep_recv(id_priv); | ||
788 | event = status ? RDMA_CM_EVENT_CONNECT_ERROR : | ||
789 | RDMA_CM_EVENT_ESTABLISHED; | ||
790 | } else | ||
791 | event = RDMA_CM_EVENT_CONNECT_RESPONSE; | ||
792 | private_data_len = IB_CM_REP_PRIVATE_DATA_SIZE; | ||
793 | break; | ||
794 | case IB_CM_RTU_RECEIVED: | ||
795 | status = cma_rtu_recv(id_priv); | ||
796 | event = status ? RDMA_CM_EVENT_CONNECT_ERROR : | ||
797 | RDMA_CM_EVENT_ESTABLISHED; | ||
798 | break; | ||
799 | case IB_CM_DREQ_ERROR: | ||
800 | status = -ETIMEDOUT; /* fall through */ | ||
801 | case IB_CM_DREQ_RECEIVED: | ||
802 | case IB_CM_DREP_RECEIVED: | ||
803 | if (!cma_comp_exch(id_priv, CMA_CONNECT, CMA_DISCONNECT)) | ||
804 | goto out; | ||
805 | event = RDMA_CM_EVENT_DISCONNECTED; | ||
806 | break; | ||
807 | case IB_CM_TIMEWAIT_EXIT: | ||
808 | case IB_CM_MRA_RECEIVED: | ||
809 | /* ignore event */ | ||
810 | goto out; | ||
811 | case IB_CM_REJ_RECEIVED: | ||
812 | cma_modify_qp_err(&id_priv->id); | ||
813 | status = ib_event->param.rej_rcvd.reason; | ||
814 | event = RDMA_CM_EVENT_REJECTED; | ||
815 | break; | ||
816 | default: | ||
817 | printk(KERN_ERR "RDMA CMA: unexpected IB CM event: %d", | ||
818 | ib_event->event); | ||
819 | goto out; | ||
820 | } | ||
821 | |||
822 | ret = cma_notify_user(id_priv, event, status, ib_event->private_data, | ||
823 | private_data_len); | ||
824 | if (ret) { | ||
825 | /* Destroy the CM ID by returning a non-zero value. */ | ||
826 | id_priv->cm_id.ib = NULL; | ||
827 | cma_exch(id_priv, CMA_DESTROYING); | ||
828 | cma_release_remove(id_priv); | ||
829 | rdma_destroy_id(&id_priv->id); | ||
830 | return ret; | ||
831 | } | ||
832 | out: | ||
833 | cma_release_remove(id_priv); | ||
834 | return ret; | ||
835 | } | ||
836 | |||
837 | static struct rdma_id_private *cma_new_id(struct rdma_cm_id *listen_id, | ||
838 | struct ib_cm_event *ib_event) | ||
839 | { | ||
840 | struct rdma_id_private *id_priv; | ||
841 | struct rdma_cm_id *id; | ||
842 | struct rdma_route *rt; | ||
843 | union cma_ip_addr *src, *dst; | ||
844 | __u16 port; | ||
845 | u8 ip_ver; | ||
846 | |||
847 | id = rdma_create_id(listen_id->event_handler, listen_id->context, | ||
848 | listen_id->ps); | ||
849 | if (IS_ERR(id)) | ||
850 | return NULL; | ||
851 | |||
852 | rt = &id->route; | ||
853 | rt->num_paths = ib_event->param.req_rcvd.alternate_path ? 2 : 1; | ||
854 | rt->path_rec = kmalloc(sizeof *rt->path_rec * rt->num_paths, GFP_KERNEL); | ||
855 | if (!rt->path_rec) | ||
856 | goto err; | ||
857 | |||
858 | if (cma_get_net_info(ib_event->private_data, listen_id->ps, | ||
859 | &ip_ver, &port, &src, &dst)) | ||
860 | goto err; | ||
861 | |||
862 | cma_save_net_info(&id->route.addr, &listen_id->route.addr, | ||
863 | ip_ver, port, src, dst); | ||
864 | rt->path_rec[0] = *ib_event->param.req_rcvd.primary_path; | ||
865 | if (rt->num_paths == 2) | ||
866 | rt->path_rec[1] = *ib_event->param.req_rcvd.alternate_path; | ||
867 | |||
868 | ib_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid); | ||
869 | ib_addr_set_dgid(&rt->addr.dev_addr, &rt->path_rec[0].dgid); | ||
870 | ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey)); | ||
871 | rt->addr.dev_addr.dev_type = IB_NODE_CA; | ||
872 | |||
873 | id_priv = container_of(id, struct rdma_id_private, id); | ||
874 | id_priv->state = CMA_CONNECT; | ||
875 | return id_priv; | ||
876 | err: | ||
877 | rdma_destroy_id(id); | ||
878 | return NULL; | ||
879 | } | ||
880 | |||
881 | static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event) | ||
882 | { | ||
883 | struct rdma_id_private *listen_id, *conn_id; | ||
884 | int offset, ret; | ||
885 | |||
886 | listen_id = cm_id->context; | ||
887 | atomic_inc(&listen_id->dev_remove); | ||
888 | if (!cma_comp(listen_id, CMA_LISTEN)) { | ||
889 | ret = -ECONNABORTED; | ||
890 | goto out; | ||
891 | } | ||
892 | |||
893 | conn_id = cma_new_id(&listen_id->id, ib_event); | ||
894 | if (!conn_id) { | ||
895 | ret = -ENOMEM; | ||
896 | goto out; | ||
897 | } | ||
898 | |||
899 | atomic_inc(&conn_id->dev_remove); | ||
900 | ret = cma_acquire_ib_dev(conn_id); | ||
901 | if (ret) { | ||
902 | ret = -ENODEV; | ||
903 | cma_release_remove(conn_id); | ||
904 | rdma_destroy_id(&conn_id->id); | ||
905 | goto out; | ||
906 | } | ||
907 | |||
908 | conn_id->cm_id.ib = cm_id; | ||
909 | cm_id->context = conn_id; | ||
910 | cm_id->cm_handler = cma_ib_handler; | ||
911 | |||
912 | offset = cma_user_data_offset(listen_id->id.ps); | ||
913 | ret = cma_notify_user(conn_id, RDMA_CM_EVENT_CONNECT_REQUEST, 0, | ||
914 | ib_event->private_data + offset, | ||
915 | IB_CM_REQ_PRIVATE_DATA_SIZE - offset); | ||
916 | if (ret) { | ||
917 | /* Destroy the CM ID by returning a non-zero value. */ | ||
918 | conn_id->cm_id.ib = NULL; | ||
919 | cma_exch(conn_id, CMA_DESTROYING); | ||
920 | cma_release_remove(conn_id); | ||
921 | rdma_destroy_id(&conn_id->id); | ||
922 | } | ||
923 | out: | ||
924 | cma_release_remove(listen_id); | ||
925 | return ret; | ||
926 | } | ||
927 | |||
928 | static __be64 cma_get_service_id(enum rdma_port_space ps, struct sockaddr *addr) | ||
929 | { | ||
930 | return cpu_to_be64(((u64)ps << 16) + | ||
931 | be16_to_cpu(((struct sockaddr_in *) addr)->sin_port)); | ||
932 | } | ||
933 | |||
934 | static void cma_set_compare_data(enum rdma_port_space ps, struct sockaddr *addr, | ||
935 | struct ib_cm_compare_data *compare) | ||
936 | { | ||
937 | struct cma_hdr *cma_data, *cma_mask; | ||
938 | struct sdp_hh *sdp_data, *sdp_mask; | ||
939 | __u32 ip4_addr; | ||
940 | struct in6_addr ip6_addr; | ||
941 | |||
942 | memset(compare, 0, sizeof *compare); | ||
943 | cma_data = (void *) compare->data; | ||
944 | cma_mask = (void *) compare->mask; | ||
945 | sdp_data = (void *) compare->data; | ||
946 | sdp_mask = (void *) compare->mask; | ||
947 | |||
948 | switch (addr->sa_family) { | ||
949 | case AF_INET: | ||
950 | ip4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr; | ||
951 | if (ps == RDMA_PS_SDP) { | ||
952 | sdp_set_ip_ver(sdp_data, 4); | ||
953 | sdp_set_ip_ver(sdp_mask, 0xF); | ||
954 | sdp_data->dst_addr.ip4.addr = ip4_addr; | ||
955 | sdp_mask->dst_addr.ip4.addr = ~0; | ||
956 | } else { | ||
957 | cma_set_ip_ver(cma_data, 4); | ||
958 | cma_set_ip_ver(cma_mask, 0xF); | ||
959 | cma_data->dst_addr.ip4.addr = ip4_addr; | ||
960 | cma_mask->dst_addr.ip4.addr = ~0; | ||
961 | } | ||
962 | break; | ||
963 | case AF_INET6: | ||
964 | ip6_addr = ((struct sockaddr_in6 *) addr)->sin6_addr; | ||
965 | if (ps == RDMA_PS_SDP) { | ||
966 | sdp_set_ip_ver(sdp_data, 6); | ||
967 | sdp_set_ip_ver(sdp_mask, 0xF); | ||
968 | sdp_data->dst_addr.ip6 = ip6_addr; | ||
969 | memset(&sdp_mask->dst_addr.ip6, 0xFF, | ||
970 | sizeof sdp_mask->dst_addr.ip6); | ||
971 | } else { | ||
972 | cma_set_ip_ver(cma_data, 6); | ||
973 | cma_set_ip_ver(cma_mask, 0xF); | ||
974 | cma_data->dst_addr.ip6 = ip6_addr; | ||
975 | memset(&cma_mask->dst_addr.ip6, 0xFF, | ||
976 | sizeof cma_mask->dst_addr.ip6); | ||
977 | } | ||
978 | break; | ||
979 | default: | ||
980 | break; | ||
981 | } | ||
982 | } | ||
983 | |||
984 | static int cma_ib_listen(struct rdma_id_private *id_priv) | ||
985 | { | ||
986 | struct ib_cm_compare_data compare_data; | ||
987 | struct sockaddr *addr; | ||
988 | __be64 svc_id; | ||
989 | int ret; | ||
990 | |||
991 | id_priv->cm_id.ib = ib_create_cm_id(id_priv->id.device, cma_req_handler, | ||
992 | id_priv); | ||
993 | if (IS_ERR(id_priv->cm_id.ib)) | ||
994 | return PTR_ERR(id_priv->cm_id.ib); | ||
995 | |||
996 | addr = &id_priv->id.route.addr.src_addr; | ||
997 | svc_id = cma_get_service_id(id_priv->id.ps, addr); | ||
998 | if (cma_any_addr(addr)) | ||
999 | ret = ib_cm_listen(id_priv->cm_id.ib, svc_id, 0, NULL); | ||
1000 | else { | ||
1001 | cma_set_compare_data(id_priv->id.ps, addr, &compare_data); | ||
1002 | ret = ib_cm_listen(id_priv->cm_id.ib, svc_id, 0, &compare_data); | ||
1003 | } | ||
1004 | |||
1005 | if (ret) { | ||
1006 | ib_destroy_cm_id(id_priv->cm_id.ib); | ||
1007 | id_priv->cm_id.ib = NULL; | ||
1008 | } | ||
1009 | |||
1010 | return ret; | ||
1011 | } | ||
1012 | |||
1013 | static int cma_listen_handler(struct rdma_cm_id *id, | ||
1014 | struct rdma_cm_event *event) | ||
1015 | { | ||
1016 | struct rdma_id_private *id_priv = id->context; | ||
1017 | |||
1018 | id->context = id_priv->id.context; | ||
1019 | id->event_handler = id_priv->id.event_handler; | ||
1020 | return id_priv->id.event_handler(id, event); | ||
1021 | } | ||
1022 | |||
1023 | static void cma_listen_on_dev(struct rdma_id_private *id_priv, | ||
1024 | struct cma_device *cma_dev) | ||
1025 | { | ||
1026 | struct rdma_id_private *dev_id_priv; | ||
1027 | struct rdma_cm_id *id; | ||
1028 | int ret; | ||
1029 | |||
1030 | id = rdma_create_id(cma_listen_handler, id_priv, id_priv->id.ps); | ||
1031 | if (IS_ERR(id)) | ||
1032 | return; | ||
1033 | |||
1034 | dev_id_priv = container_of(id, struct rdma_id_private, id); | ||
1035 | |||
1036 | dev_id_priv->state = CMA_ADDR_BOUND; | ||
1037 | memcpy(&id->route.addr.src_addr, &id_priv->id.route.addr.src_addr, | ||
1038 | ip_addr_size(&id_priv->id.route.addr.src_addr)); | ||
1039 | |||
1040 | cma_attach_to_dev(dev_id_priv, cma_dev); | ||
1041 | list_add_tail(&dev_id_priv->listen_list, &id_priv->listen_list); | ||
1042 | |||
1043 | ret = rdma_listen(id, id_priv->backlog); | ||
1044 | if (ret) | ||
1045 | goto err; | ||
1046 | |||
1047 | return; | ||
1048 | err: | ||
1049 | cma_destroy_listen(dev_id_priv); | ||
1050 | } | ||
1051 | |||
1052 | static void cma_listen_on_all(struct rdma_id_private *id_priv) | ||
1053 | { | ||
1054 | struct cma_device *cma_dev; | ||
1055 | |||
1056 | mutex_lock(&lock); | ||
1057 | list_add_tail(&id_priv->list, &listen_any_list); | ||
1058 | list_for_each_entry(cma_dev, &dev_list, list) | ||
1059 | cma_listen_on_dev(id_priv, cma_dev); | ||
1060 | mutex_unlock(&lock); | ||
1061 | } | ||
1062 | |||
1063 | static int cma_bind_any(struct rdma_cm_id *id, sa_family_t af) | ||
1064 | { | ||
1065 | struct sockaddr_in addr_in; | ||
1066 | |||
1067 | memset(&addr_in, 0, sizeof addr_in); | ||
1068 | addr_in.sin_family = af; | ||
1069 | return rdma_bind_addr(id, (struct sockaddr *) &addr_in); | ||
1070 | } | ||
1071 | |||
1072 | int rdma_listen(struct rdma_cm_id *id, int backlog) | ||
1073 | { | ||
1074 | struct rdma_id_private *id_priv; | ||
1075 | int ret; | ||
1076 | |||
1077 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1078 | if (id_priv->state == CMA_IDLE) { | ||
1079 | ret = cma_bind_any(id, AF_INET); | ||
1080 | if (ret) | ||
1081 | return ret; | ||
1082 | } | ||
1083 | |||
1084 | if (!cma_comp_exch(id_priv, CMA_ADDR_BOUND, CMA_LISTEN)) | ||
1085 | return -EINVAL; | ||
1086 | |||
1087 | id_priv->backlog = backlog; | ||
1088 | if (id->device) { | ||
1089 | switch (id->device->node_type) { | ||
1090 | case IB_NODE_CA: | ||
1091 | ret = cma_ib_listen(id_priv); | ||
1092 | if (ret) | ||
1093 | goto err; | ||
1094 | break; | ||
1095 | default: | ||
1096 | ret = -ENOSYS; | ||
1097 | goto err; | ||
1098 | } | ||
1099 | } else | ||
1100 | cma_listen_on_all(id_priv); | ||
1101 | |||
1102 | return 0; | ||
1103 | err: | ||
1104 | id_priv->backlog = 0; | ||
1105 | cma_comp_exch(id_priv, CMA_LISTEN, CMA_ADDR_BOUND); | ||
1106 | return ret; | ||
1107 | } | ||
1108 | EXPORT_SYMBOL(rdma_listen); | ||
1109 | |||
1110 | static void cma_query_handler(int status, struct ib_sa_path_rec *path_rec, | ||
1111 | void *context) | ||
1112 | { | ||
1113 | struct cma_work *work = context; | ||
1114 | struct rdma_route *route; | ||
1115 | |||
1116 | route = &work->id->id.route; | ||
1117 | |||
1118 | if (!status) { | ||
1119 | route->num_paths = 1; | ||
1120 | *route->path_rec = *path_rec; | ||
1121 | } else { | ||
1122 | work->old_state = CMA_ROUTE_QUERY; | ||
1123 | work->new_state = CMA_ADDR_RESOLVED; | ||
1124 | work->event.event = RDMA_CM_EVENT_ROUTE_ERROR; | ||
1125 | } | ||
1126 | |||
1127 | queue_work(cma_wq, &work->work); | ||
1128 | } | ||
1129 | |||
1130 | static int cma_query_ib_route(struct rdma_id_private *id_priv, int timeout_ms, | ||
1131 | struct cma_work *work) | ||
1132 | { | ||
1133 | struct rdma_dev_addr *addr = &id_priv->id.route.addr.dev_addr; | ||
1134 | struct ib_sa_path_rec path_rec; | ||
1135 | |||
1136 | memset(&path_rec, 0, sizeof path_rec); | ||
1137 | path_rec.sgid = *ib_addr_get_sgid(addr); | ||
1138 | path_rec.dgid = *ib_addr_get_dgid(addr); | ||
1139 | path_rec.pkey = cpu_to_be16(ib_addr_get_pkey(addr)); | ||
1140 | path_rec.numb_path = 1; | ||
1141 | |||
1142 | id_priv->query_id = ib_sa_path_rec_get(id_priv->id.device, | ||
1143 | id_priv->id.port_num, &path_rec, | ||
1144 | IB_SA_PATH_REC_DGID | IB_SA_PATH_REC_SGID | | ||
1145 | IB_SA_PATH_REC_PKEY | IB_SA_PATH_REC_NUMB_PATH, | ||
1146 | timeout_ms, GFP_KERNEL, | ||
1147 | cma_query_handler, work, &id_priv->query); | ||
1148 | |||
1149 | return (id_priv->query_id < 0) ? id_priv->query_id : 0; | ||
1150 | } | ||
1151 | |||
1152 | static void cma_work_handler(void *data) | ||
1153 | { | ||
1154 | struct cma_work *work = data; | ||
1155 | struct rdma_id_private *id_priv = work->id; | ||
1156 | int destroy = 0; | ||
1157 | |||
1158 | atomic_inc(&id_priv->dev_remove); | ||
1159 | if (!cma_comp_exch(id_priv, work->old_state, work->new_state)) | ||
1160 | goto out; | ||
1161 | |||
1162 | if (id_priv->id.event_handler(&id_priv->id, &work->event)) { | ||
1163 | cma_exch(id_priv, CMA_DESTROYING); | ||
1164 | destroy = 1; | ||
1165 | } | ||
1166 | out: | ||
1167 | cma_release_remove(id_priv); | ||
1168 | cma_deref_id(id_priv); | ||
1169 | if (destroy) | ||
1170 | rdma_destroy_id(&id_priv->id); | ||
1171 | kfree(work); | ||
1172 | } | ||
1173 | |||
1174 | static int cma_resolve_ib_route(struct rdma_id_private *id_priv, int timeout_ms) | ||
1175 | { | ||
1176 | struct rdma_route *route = &id_priv->id.route; | ||
1177 | struct cma_work *work; | ||
1178 | int ret; | ||
1179 | |||
1180 | work = kzalloc(sizeof *work, GFP_KERNEL); | ||
1181 | if (!work) | ||
1182 | return -ENOMEM; | ||
1183 | |||
1184 | work->id = id_priv; | ||
1185 | INIT_WORK(&work->work, cma_work_handler, work); | ||
1186 | work->old_state = CMA_ROUTE_QUERY; | ||
1187 | work->new_state = CMA_ROUTE_RESOLVED; | ||
1188 | work->event.event = RDMA_CM_EVENT_ROUTE_RESOLVED; | ||
1189 | |||
1190 | route->path_rec = kmalloc(sizeof *route->path_rec, GFP_KERNEL); | ||
1191 | if (!route->path_rec) { | ||
1192 | ret = -ENOMEM; | ||
1193 | goto err1; | ||
1194 | } | ||
1195 | |||
1196 | ret = cma_query_ib_route(id_priv, timeout_ms, work); | ||
1197 | if (ret) | ||
1198 | goto err2; | ||
1199 | |||
1200 | return 0; | ||
1201 | err2: | ||
1202 | kfree(route->path_rec); | ||
1203 | route->path_rec = NULL; | ||
1204 | err1: | ||
1205 | kfree(work); | ||
1206 | return ret; | ||
1207 | } | ||
1208 | |||
1209 | int rdma_set_ib_paths(struct rdma_cm_id *id, | ||
1210 | struct ib_sa_path_rec *path_rec, int num_paths) | ||
1211 | { | ||
1212 | struct rdma_id_private *id_priv; | ||
1213 | int ret; | ||
1214 | |||
1215 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1216 | if (!cma_comp_exch(id_priv, CMA_ADDR_RESOLVED, CMA_ROUTE_RESOLVED)) | ||
1217 | return -EINVAL; | ||
1218 | |||
1219 | id->route.path_rec = kmalloc(sizeof *path_rec * num_paths, GFP_KERNEL); | ||
1220 | if (!id->route.path_rec) { | ||
1221 | ret = -ENOMEM; | ||
1222 | goto err; | ||
1223 | } | ||
1224 | |||
1225 | memcpy(id->route.path_rec, path_rec, sizeof *path_rec * num_paths); | ||
1226 | return 0; | ||
1227 | err: | ||
1228 | cma_comp_exch(id_priv, CMA_ROUTE_RESOLVED, CMA_ADDR_RESOLVED); | ||
1229 | return ret; | ||
1230 | } | ||
1231 | EXPORT_SYMBOL(rdma_set_ib_paths); | ||
1232 | |||
1233 | int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms) | ||
1234 | { | ||
1235 | struct rdma_id_private *id_priv; | ||
1236 | int ret; | ||
1237 | |||
1238 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1239 | if (!cma_comp_exch(id_priv, CMA_ADDR_RESOLVED, CMA_ROUTE_QUERY)) | ||
1240 | return -EINVAL; | ||
1241 | |||
1242 | atomic_inc(&id_priv->refcount); | ||
1243 | switch (id->device->node_type) { | ||
1244 | case IB_NODE_CA: | ||
1245 | ret = cma_resolve_ib_route(id_priv, timeout_ms); | ||
1246 | break; | ||
1247 | default: | ||
1248 | ret = -ENOSYS; | ||
1249 | break; | ||
1250 | } | ||
1251 | if (ret) | ||
1252 | goto err; | ||
1253 | |||
1254 | return 0; | ||
1255 | err: | ||
1256 | cma_comp_exch(id_priv, CMA_ROUTE_QUERY, CMA_ADDR_RESOLVED); | ||
1257 | cma_deref_id(id_priv); | ||
1258 | return ret; | ||
1259 | } | ||
1260 | EXPORT_SYMBOL(rdma_resolve_route); | ||
1261 | |||
1262 | static int cma_bind_loopback(struct rdma_id_private *id_priv) | ||
1263 | { | ||
1264 | struct cma_device *cma_dev; | ||
1265 | struct ib_port_attr port_attr; | ||
1266 | union ib_gid *gid; | ||
1267 | u16 pkey; | ||
1268 | int ret; | ||
1269 | u8 p; | ||
1270 | |||
1271 | mutex_lock(&lock); | ||
1272 | list_for_each_entry(cma_dev, &dev_list, list) | ||
1273 | for (p = 1; p <= cma_dev->device->phys_port_cnt; ++p) | ||
1274 | if (!ib_query_port (cma_dev->device, p, &port_attr) && | ||
1275 | port_attr.state == IB_PORT_ACTIVE) | ||
1276 | goto port_found; | ||
1277 | |||
1278 | if (!list_empty(&dev_list)) { | ||
1279 | p = 1; | ||
1280 | cma_dev = list_entry(dev_list.next, struct cma_device, list); | ||
1281 | } else { | ||
1282 | ret = -ENODEV; | ||
1283 | goto out; | ||
1284 | } | ||
1285 | |||
1286 | port_found: | ||
1287 | gid = ib_addr_get_sgid(&id_priv->id.route.addr.dev_addr); | ||
1288 | ret = ib_get_cached_gid(cma_dev->device, p, 0, gid); | ||
1289 | if (ret) | ||
1290 | goto out; | ||
1291 | |||
1292 | ret = ib_get_cached_pkey(cma_dev->device, p, 0, &pkey); | ||
1293 | if (ret) | ||
1294 | goto out; | ||
1295 | |||
1296 | ib_addr_set_pkey(&id_priv->id.route.addr.dev_addr, pkey); | ||
1297 | id_priv->id.port_num = p; | ||
1298 | cma_attach_to_dev(id_priv, cma_dev); | ||
1299 | out: | ||
1300 | mutex_unlock(&lock); | ||
1301 | return ret; | ||
1302 | } | ||
1303 | |||
1304 | static void addr_handler(int status, struct sockaddr *src_addr, | ||
1305 | struct rdma_dev_addr *dev_addr, void *context) | ||
1306 | { | ||
1307 | struct rdma_id_private *id_priv = context; | ||
1308 | enum rdma_cm_event_type event; | ||
1309 | |||
1310 | atomic_inc(&id_priv->dev_remove); | ||
1311 | if (!id_priv->cma_dev && !status) | ||
1312 | status = cma_acquire_dev(id_priv); | ||
1313 | |||
1314 | if (status) { | ||
1315 | if (!cma_comp_exch(id_priv, CMA_ADDR_QUERY, CMA_ADDR_BOUND)) | ||
1316 | goto out; | ||
1317 | event = RDMA_CM_EVENT_ADDR_ERROR; | ||
1318 | } else { | ||
1319 | if (!cma_comp_exch(id_priv, CMA_ADDR_QUERY, CMA_ADDR_RESOLVED)) | ||
1320 | goto out; | ||
1321 | memcpy(&id_priv->id.route.addr.src_addr, src_addr, | ||
1322 | ip_addr_size(src_addr)); | ||
1323 | event = RDMA_CM_EVENT_ADDR_RESOLVED; | ||
1324 | } | ||
1325 | |||
1326 | if (cma_notify_user(id_priv, event, status, NULL, 0)) { | ||
1327 | cma_exch(id_priv, CMA_DESTROYING); | ||
1328 | cma_release_remove(id_priv); | ||
1329 | cma_deref_id(id_priv); | ||
1330 | rdma_destroy_id(&id_priv->id); | ||
1331 | return; | ||
1332 | } | ||
1333 | out: | ||
1334 | cma_release_remove(id_priv); | ||
1335 | cma_deref_id(id_priv); | ||
1336 | } | ||
1337 | |||
1338 | static int cma_resolve_loopback(struct rdma_id_private *id_priv) | ||
1339 | { | ||
1340 | struct cma_work *work; | ||
1341 | struct sockaddr_in *src_in, *dst_in; | ||
1342 | int ret; | ||
1343 | |||
1344 | work = kzalloc(sizeof *work, GFP_KERNEL); | ||
1345 | if (!work) | ||
1346 | return -ENOMEM; | ||
1347 | |||
1348 | if (!id_priv->cma_dev) { | ||
1349 | ret = cma_bind_loopback(id_priv); | ||
1350 | if (ret) | ||
1351 | goto err; | ||
1352 | } | ||
1353 | |||
1354 | ib_addr_set_dgid(&id_priv->id.route.addr.dev_addr, | ||
1355 | ib_addr_get_sgid(&id_priv->id.route.addr.dev_addr)); | ||
1356 | |||
1357 | if (cma_zero_addr(&id_priv->id.route.addr.src_addr)) { | ||
1358 | src_in = (struct sockaddr_in *)&id_priv->id.route.addr.src_addr; | ||
1359 | dst_in = (struct sockaddr_in *)&id_priv->id.route.addr.dst_addr; | ||
1360 | src_in->sin_family = dst_in->sin_family; | ||
1361 | src_in->sin_addr.s_addr = dst_in->sin_addr.s_addr; | ||
1362 | } | ||
1363 | |||
1364 | work->id = id_priv; | ||
1365 | INIT_WORK(&work->work, cma_work_handler, work); | ||
1366 | work->old_state = CMA_ADDR_QUERY; | ||
1367 | work->new_state = CMA_ADDR_RESOLVED; | ||
1368 | work->event.event = RDMA_CM_EVENT_ADDR_RESOLVED; | ||
1369 | queue_work(cma_wq, &work->work); | ||
1370 | return 0; | ||
1371 | err: | ||
1372 | kfree(work); | ||
1373 | return ret; | ||
1374 | } | ||
1375 | |||
1376 | static int cma_bind_addr(struct rdma_cm_id *id, struct sockaddr *src_addr, | ||
1377 | struct sockaddr *dst_addr) | ||
1378 | { | ||
1379 | if (src_addr && src_addr->sa_family) | ||
1380 | return rdma_bind_addr(id, src_addr); | ||
1381 | else | ||
1382 | return cma_bind_any(id, dst_addr->sa_family); | ||
1383 | } | ||
1384 | |||
1385 | int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr, | ||
1386 | struct sockaddr *dst_addr, int timeout_ms) | ||
1387 | { | ||
1388 | struct rdma_id_private *id_priv; | ||
1389 | int ret; | ||
1390 | |||
1391 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1392 | if (id_priv->state == CMA_IDLE) { | ||
1393 | ret = cma_bind_addr(id, src_addr, dst_addr); | ||
1394 | if (ret) | ||
1395 | return ret; | ||
1396 | } | ||
1397 | |||
1398 | if (!cma_comp_exch(id_priv, CMA_ADDR_BOUND, CMA_ADDR_QUERY)) | ||
1399 | return -EINVAL; | ||
1400 | |||
1401 | atomic_inc(&id_priv->refcount); | ||
1402 | memcpy(&id->route.addr.dst_addr, dst_addr, ip_addr_size(dst_addr)); | ||
1403 | if (cma_any_addr(dst_addr)) | ||
1404 | ret = cma_resolve_loopback(id_priv); | ||
1405 | else | ||
1406 | ret = rdma_resolve_ip(&id->route.addr.src_addr, dst_addr, | ||
1407 | &id->route.addr.dev_addr, | ||
1408 | timeout_ms, addr_handler, id_priv); | ||
1409 | if (ret) | ||
1410 | goto err; | ||
1411 | |||
1412 | return 0; | ||
1413 | err: | ||
1414 | cma_comp_exch(id_priv, CMA_ADDR_QUERY, CMA_ADDR_BOUND); | ||
1415 | cma_deref_id(id_priv); | ||
1416 | return ret; | ||
1417 | } | ||
1418 | EXPORT_SYMBOL(rdma_resolve_addr); | ||
1419 | |||
1420 | static void cma_bind_port(struct rdma_bind_list *bind_list, | ||
1421 | struct rdma_id_private *id_priv) | ||
1422 | { | ||
1423 | struct sockaddr_in *sin; | ||
1424 | |||
1425 | sin = (struct sockaddr_in *) &id_priv->id.route.addr.src_addr; | ||
1426 | sin->sin_port = htons(bind_list->port); | ||
1427 | id_priv->bind_list = bind_list; | ||
1428 | hlist_add_head(&id_priv->node, &bind_list->owners); | ||
1429 | } | ||
1430 | |||
1431 | static int cma_alloc_port(struct idr *ps, struct rdma_id_private *id_priv, | ||
1432 | unsigned short snum) | ||
1433 | { | ||
1434 | struct rdma_bind_list *bind_list; | ||
1435 | int port, start, ret; | ||
1436 | |||
1437 | bind_list = kzalloc(sizeof *bind_list, GFP_KERNEL); | ||
1438 | if (!bind_list) | ||
1439 | return -ENOMEM; | ||
1440 | |||
1441 | start = snum ? snum : sysctl_local_port_range[0]; | ||
1442 | |||
1443 | do { | ||
1444 | ret = idr_get_new_above(ps, bind_list, start, &port); | ||
1445 | } while ((ret == -EAGAIN) && idr_pre_get(ps, GFP_KERNEL)); | ||
1446 | |||
1447 | if (ret) | ||
1448 | goto err; | ||
1449 | |||
1450 | if ((snum && port != snum) || | ||
1451 | (!snum && port > sysctl_local_port_range[1])) { | ||
1452 | idr_remove(ps, port); | ||
1453 | ret = -EADDRNOTAVAIL; | ||
1454 | goto err; | ||
1455 | } | ||
1456 | |||
1457 | bind_list->ps = ps; | ||
1458 | bind_list->port = (unsigned short) port; | ||
1459 | cma_bind_port(bind_list, id_priv); | ||
1460 | return 0; | ||
1461 | err: | ||
1462 | kfree(bind_list); | ||
1463 | return ret; | ||
1464 | } | ||
1465 | |||
1466 | static int cma_use_port(struct idr *ps, struct rdma_id_private *id_priv) | ||
1467 | { | ||
1468 | struct rdma_id_private *cur_id; | ||
1469 | struct sockaddr_in *sin, *cur_sin; | ||
1470 | struct rdma_bind_list *bind_list; | ||
1471 | struct hlist_node *node; | ||
1472 | unsigned short snum; | ||
1473 | |||
1474 | sin = (struct sockaddr_in *) &id_priv->id.route.addr.src_addr; | ||
1475 | snum = ntohs(sin->sin_port); | ||
1476 | if (snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) | ||
1477 | return -EACCES; | ||
1478 | |||
1479 | bind_list = idr_find(ps, snum); | ||
1480 | if (!bind_list) | ||
1481 | return cma_alloc_port(ps, id_priv, snum); | ||
1482 | |||
1483 | /* | ||
1484 | * We don't support binding to any address if anyone is bound to | ||
1485 | * a specific address on the same port. | ||
1486 | */ | ||
1487 | if (cma_any_addr(&id_priv->id.route.addr.src_addr)) | ||
1488 | return -EADDRNOTAVAIL; | ||
1489 | |||
1490 | hlist_for_each_entry(cur_id, node, &bind_list->owners, node) { | ||
1491 | if (cma_any_addr(&cur_id->id.route.addr.src_addr)) | ||
1492 | return -EADDRNOTAVAIL; | ||
1493 | |||
1494 | cur_sin = (struct sockaddr_in *) &cur_id->id.route.addr.src_addr; | ||
1495 | if (sin->sin_addr.s_addr == cur_sin->sin_addr.s_addr) | ||
1496 | return -EADDRINUSE; | ||
1497 | } | ||
1498 | |||
1499 | cma_bind_port(bind_list, id_priv); | ||
1500 | return 0; | ||
1501 | } | ||
1502 | |||
1503 | static int cma_get_port(struct rdma_id_private *id_priv) | ||
1504 | { | ||
1505 | struct idr *ps; | ||
1506 | int ret; | ||
1507 | |||
1508 | switch (id_priv->id.ps) { | ||
1509 | case RDMA_PS_SDP: | ||
1510 | ps = &sdp_ps; | ||
1511 | break; | ||
1512 | case RDMA_PS_TCP: | ||
1513 | ps = &tcp_ps; | ||
1514 | break; | ||
1515 | default: | ||
1516 | return -EPROTONOSUPPORT; | ||
1517 | } | ||
1518 | |||
1519 | mutex_lock(&lock); | ||
1520 | if (cma_any_port(&id_priv->id.route.addr.src_addr)) | ||
1521 | ret = cma_alloc_port(ps, id_priv, 0); | ||
1522 | else | ||
1523 | ret = cma_use_port(ps, id_priv); | ||
1524 | mutex_unlock(&lock); | ||
1525 | |||
1526 | return ret; | ||
1527 | } | ||
1528 | |||
1529 | int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr) | ||
1530 | { | ||
1531 | struct rdma_id_private *id_priv; | ||
1532 | int ret; | ||
1533 | |||
1534 | if (addr->sa_family != AF_INET) | ||
1535 | return -EAFNOSUPPORT; | ||
1536 | |||
1537 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1538 | if (!cma_comp_exch(id_priv, CMA_IDLE, CMA_ADDR_BOUND)) | ||
1539 | return -EINVAL; | ||
1540 | |||
1541 | if (!cma_any_addr(addr)) { | ||
1542 | ret = rdma_translate_ip(addr, &id->route.addr.dev_addr); | ||
1543 | if (!ret) | ||
1544 | ret = cma_acquire_dev(id_priv); | ||
1545 | if (ret) | ||
1546 | goto err; | ||
1547 | } | ||
1548 | |||
1549 | memcpy(&id->route.addr.src_addr, addr, ip_addr_size(addr)); | ||
1550 | ret = cma_get_port(id_priv); | ||
1551 | if (ret) | ||
1552 | goto err; | ||
1553 | |||
1554 | return 0; | ||
1555 | err: | ||
1556 | cma_comp_exch(id_priv, CMA_ADDR_BOUND, CMA_IDLE); | ||
1557 | return ret; | ||
1558 | } | ||
1559 | EXPORT_SYMBOL(rdma_bind_addr); | ||
1560 | |||
1561 | static int cma_format_hdr(void *hdr, enum rdma_port_space ps, | ||
1562 | struct rdma_route *route) | ||
1563 | { | ||
1564 | struct sockaddr_in *src4, *dst4; | ||
1565 | struct cma_hdr *cma_hdr; | ||
1566 | struct sdp_hh *sdp_hdr; | ||
1567 | |||
1568 | src4 = (struct sockaddr_in *) &route->addr.src_addr; | ||
1569 | dst4 = (struct sockaddr_in *) &route->addr.dst_addr; | ||
1570 | |||
1571 | switch (ps) { | ||
1572 | case RDMA_PS_SDP: | ||
1573 | sdp_hdr = hdr; | ||
1574 | if (sdp_get_majv(sdp_hdr->sdp_version) != SDP_MAJ_VERSION) | ||
1575 | return -EINVAL; | ||
1576 | sdp_set_ip_ver(sdp_hdr, 4); | ||
1577 | sdp_hdr->src_addr.ip4.addr = src4->sin_addr.s_addr; | ||
1578 | sdp_hdr->dst_addr.ip4.addr = dst4->sin_addr.s_addr; | ||
1579 | sdp_hdr->port = src4->sin_port; | ||
1580 | break; | ||
1581 | default: | ||
1582 | cma_hdr = hdr; | ||
1583 | cma_hdr->cma_version = CMA_VERSION; | ||
1584 | cma_set_ip_ver(cma_hdr, 4); | ||
1585 | cma_hdr->src_addr.ip4.addr = src4->sin_addr.s_addr; | ||
1586 | cma_hdr->dst_addr.ip4.addr = dst4->sin_addr.s_addr; | ||
1587 | cma_hdr->port = src4->sin_port; | ||
1588 | break; | ||
1589 | } | ||
1590 | return 0; | ||
1591 | } | ||
1592 | |||
1593 | static int cma_connect_ib(struct rdma_id_private *id_priv, | ||
1594 | struct rdma_conn_param *conn_param) | ||
1595 | { | ||
1596 | struct ib_cm_req_param req; | ||
1597 | struct rdma_route *route; | ||
1598 | void *private_data; | ||
1599 | int offset, ret; | ||
1600 | |||
1601 | memset(&req, 0, sizeof req); | ||
1602 | offset = cma_user_data_offset(id_priv->id.ps); | ||
1603 | req.private_data_len = offset + conn_param->private_data_len; | ||
1604 | private_data = kzalloc(req.private_data_len, GFP_ATOMIC); | ||
1605 | if (!private_data) | ||
1606 | return -ENOMEM; | ||
1607 | |||
1608 | if (conn_param->private_data && conn_param->private_data_len) | ||
1609 | memcpy(private_data + offset, conn_param->private_data, | ||
1610 | conn_param->private_data_len); | ||
1611 | |||
1612 | id_priv->cm_id.ib = ib_create_cm_id(id_priv->id.device, cma_ib_handler, | ||
1613 | id_priv); | ||
1614 | if (IS_ERR(id_priv->cm_id.ib)) { | ||
1615 | ret = PTR_ERR(id_priv->cm_id.ib); | ||
1616 | goto out; | ||
1617 | } | ||
1618 | |||
1619 | route = &id_priv->id.route; | ||
1620 | ret = cma_format_hdr(private_data, id_priv->id.ps, route); | ||
1621 | if (ret) | ||
1622 | goto out; | ||
1623 | req.private_data = private_data; | ||
1624 | |||
1625 | req.primary_path = &route->path_rec[0]; | ||
1626 | if (route->num_paths == 2) | ||
1627 | req.alternate_path = &route->path_rec[1]; | ||
1628 | |||
1629 | req.service_id = cma_get_service_id(id_priv->id.ps, | ||
1630 | &route->addr.dst_addr); | ||
1631 | req.qp_num = id_priv->qp_num; | ||
1632 | req.qp_type = id_priv->qp_type; | ||
1633 | req.starting_psn = id_priv->seq_num; | ||
1634 | req.responder_resources = conn_param->responder_resources; | ||
1635 | req.initiator_depth = conn_param->initiator_depth; | ||
1636 | req.flow_control = conn_param->flow_control; | ||
1637 | req.retry_count = conn_param->retry_count; | ||
1638 | req.rnr_retry_count = conn_param->rnr_retry_count; | ||
1639 | req.remote_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT; | ||
1640 | req.local_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT; | ||
1641 | req.max_cm_retries = CMA_MAX_CM_RETRIES; | ||
1642 | req.srq = id_priv->srq ? 1 : 0; | ||
1643 | |||
1644 | ret = ib_send_cm_req(id_priv->cm_id.ib, &req); | ||
1645 | out: | ||
1646 | kfree(private_data); | ||
1647 | return ret; | ||
1648 | } | ||
1649 | |||
1650 | int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param) | ||
1651 | { | ||
1652 | struct rdma_id_private *id_priv; | ||
1653 | int ret; | ||
1654 | |||
1655 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1656 | if (!cma_comp_exch(id_priv, CMA_ROUTE_RESOLVED, CMA_CONNECT)) | ||
1657 | return -EINVAL; | ||
1658 | |||
1659 | if (!id->qp) { | ||
1660 | id_priv->qp_num = conn_param->qp_num; | ||
1661 | id_priv->qp_type = conn_param->qp_type; | ||
1662 | id_priv->srq = conn_param->srq; | ||
1663 | } | ||
1664 | |||
1665 | switch (id->device->node_type) { | ||
1666 | case IB_NODE_CA: | ||
1667 | ret = cma_connect_ib(id_priv, conn_param); | ||
1668 | break; | ||
1669 | default: | ||
1670 | ret = -ENOSYS; | ||
1671 | break; | ||
1672 | } | ||
1673 | if (ret) | ||
1674 | goto err; | ||
1675 | |||
1676 | return 0; | ||
1677 | err: | ||
1678 | cma_comp_exch(id_priv, CMA_CONNECT, CMA_ROUTE_RESOLVED); | ||
1679 | return ret; | ||
1680 | } | ||
1681 | EXPORT_SYMBOL(rdma_connect); | ||
1682 | |||
1683 | static int cma_accept_ib(struct rdma_id_private *id_priv, | ||
1684 | struct rdma_conn_param *conn_param) | ||
1685 | { | ||
1686 | struct ib_cm_rep_param rep; | ||
1687 | int ret; | ||
1688 | |||
1689 | ret = cma_modify_qp_rtr(&id_priv->id); | ||
1690 | if (ret) | ||
1691 | return ret; | ||
1692 | |||
1693 | memset(&rep, 0, sizeof rep); | ||
1694 | rep.qp_num = id_priv->qp_num; | ||
1695 | rep.starting_psn = id_priv->seq_num; | ||
1696 | rep.private_data = conn_param->private_data; | ||
1697 | rep.private_data_len = conn_param->private_data_len; | ||
1698 | rep.responder_resources = conn_param->responder_resources; | ||
1699 | rep.initiator_depth = conn_param->initiator_depth; | ||
1700 | rep.target_ack_delay = CMA_CM_RESPONSE_TIMEOUT; | ||
1701 | rep.failover_accepted = 0; | ||
1702 | rep.flow_control = conn_param->flow_control; | ||
1703 | rep.rnr_retry_count = conn_param->rnr_retry_count; | ||
1704 | rep.srq = id_priv->srq ? 1 : 0; | ||
1705 | |||
1706 | return ib_send_cm_rep(id_priv->cm_id.ib, &rep); | ||
1707 | } | ||
1708 | |||
1709 | int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param) | ||
1710 | { | ||
1711 | struct rdma_id_private *id_priv; | ||
1712 | int ret; | ||
1713 | |||
1714 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1715 | if (!cma_comp(id_priv, CMA_CONNECT)) | ||
1716 | return -EINVAL; | ||
1717 | |||
1718 | if (!id->qp && conn_param) { | ||
1719 | id_priv->qp_num = conn_param->qp_num; | ||
1720 | id_priv->qp_type = conn_param->qp_type; | ||
1721 | id_priv->srq = conn_param->srq; | ||
1722 | } | ||
1723 | |||
1724 | switch (id->device->node_type) { | ||
1725 | case IB_NODE_CA: | ||
1726 | if (conn_param) | ||
1727 | ret = cma_accept_ib(id_priv, conn_param); | ||
1728 | else | ||
1729 | ret = cma_rep_recv(id_priv); | ||
1730 | break; | ||
1731 | default: | ||
1732 | ret = -ENOSYS; | ||
1733 | break; | ||
1734 | } | ||
1735 | |||
1736 | if (ret) | ||
1737 | goto reject; | ||
1738 | |||
1739 | return 0; | ||
1740 | reject: | ||
1741 | cma_modify_qp_err(id); | ||
1742 | rdma_reject(id, NULL, 0); | ||
1743 | return ret; | ||
1744 | } | ||
1745 | EXPORT_SYMBOL(rdma_accept); | ||
1746 | |||
1747 | int rdma_reject(struct rdma_cm_id *id, const void *private_data, | ||
1748 | u8 private_data_len) | ||
1749 | { | ||
1750 | struct rdma_id_private *id_priv; | ||
1751 | int ret; | ||
1752 | |||
1753 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1754 | if (!cma_comp(id_priv, CMA_CONNECT)) | ||
1755 | return -EINVAL; | ||
1756 | |||
1757 | switch (id->device->node_type) { | ||
1758 | case IB_NODE_CA: | ||
1759 | ret = ib_send_cm_rej(id_priv->cm_id.ib, | ||
1760 | IB_CM_REJ_CONSUMER_DEFINED, NULL, 0, | ||
1761 | private_data, private_data_len); | ||
1762 | break; | ||
1763 | default: | ||
1764 | ret = -ENOSYS; | ||
1765 | break; | ||
1766 | } | ||
1767 | return ret; | ||
1768 | } | ||
1769 | EXPORT_SYMBOL(rdma_reject); | ||
1770 | |||
1771 | int rdma_disconnect(struct rdma_cm_id *id) | ||
1772 | { | ||
1773 | struct rdma_id_private *id_priv; | ||
1774 | int ret; | ||
1775 | |||
1776 | id_priv = container_of(id, struct rdma_id_private, id); | ||
1777 | if (!cma_comp(id_priv, CMA_CONNECT) && | ||
1778 | !cma_comp(id_priv, CMA_DISCONNECT)) | ||
1779 | return -EINVAL; | ||
1780 | |||
1781 | ret = cma_modify_qp_err(id); | ||
1782 | if (ret) | ||
1783 | goto out; | ||
1784 | |||
1785 | switch (id->device->node_type) { | ||
1786 | case IB_NODE_CA: | ||
1787 | /* Initiate or respond to a disconnect. */ | ||
1788 | if (ib_send_cm_dreq(id_priv->cm_id.ib, NULL, 0)) | ||
1789 | ib_send_cm_drep(id_priv->cm_id.ib, NULL, 0); | ||
1790 | break; | ||
1791 | default: | ||
1792 | break; | ||
1793 | } | ||
1794 | out: | ||
1795 | return ret; | ||
1796 | } | ||
1797 | EXPORT_SYMBOL(rdma_disconnect); | ||
1798 | |||
1799 | static void cma_add_one(struct ib_device *device) | ||
1800 | { | ||
1801 | struct cma_device *cma_dev; | ||
1802 | struct rdma_id_private *id_priv; | ||
1803 | |||
1804 | cma_dev = kmalloc(sizeof *cma_dev, GFP_KERNEL); | ||
1805 | if (!cma_dev) | ||
1806 | return; | ||
1807 | |||
1808 | cma_dev->device = device; | ||
1809 | cma_dev->node_guid = device->node_guid; | ||
1810 | if (!cma_dev->node_guid) | ||
1811 | goto err; | ||
1812 | |||
1813 | init_completion(&cma_dev->comp); | ||
1814 | atomic_set(&cma_dev->refcount, 1); | ||
1815 | INIT_LIST_HEAD(&cma_dev->id_list); | ||
1816 | ib_set_client_data(device, &cma_client, cma_dev); | ||
1817 | |||
1818 | mutex_lock(&lock); | ||
1819 | list_add_tail(&cma_dev->list, &dev_list); | ||
1820 | list_for_each_entry(id_priv, &listen_any_list, list) | ||
1821 | cma_listen_on_dev(id_priv, cma_dev); | ||
1822 | mutex_unlock(&lock); | ||
1823 | return; | ||
1824 | err: | ||
1825 | kfree(cma_dev); | ||
1826 | } | ||
1827 | |||
1828 | static int cma_remove_id_dev(struct rdma_id_private *id_priv) | ||
1829 | { | ||
1830 | enum cma_state state; | ||
1831 | |||
1832 | /* Record that we want to remove the device */ | ||
1833 | state = cma_exch(id_priv, CMA_DEVICE_REMOVAL); | ||
1834 | if (state == CMA_DESTROYING) | ||
1835 | return 0; | ||
1836 | |||
1837 | cma_cancel_operation(id_priv, state); | ||
1838 | wait_event(id_priv->wait_remove, !atomic_read(&id_priv->dev_remove)); | ||
1839 | |||
1840 | /* Check for destruction from another callback. */ | ||
1841 | if (!cma_comp(id_priv, CMA_DEVICE_REMOVAL)) | ||
1842 | return 0; | ||
1843 | |||
1844 | return cma_notify_user(id_priv, RDMA_CM_EVENT_DEVICE_REMOVAL, | ||
1845 | 0, NULL, 0); | ||
1846 | } | ||
1847 | |||
1848 | static void cma_process_remove(struct cma_device *cma_dev) | ||
1849 | { | ||
1850 | struct list_head remove_list; | ||
1851 | struct rdma_id_private *id_priv; | ||
1852 | int ret; | ||
1853 | |||
1854 | INIT_LIST_HEAD(&remove_list); | ||
1855 | |||
1856 | mutex_lock(&lock); | ||
1857 | while (!list_empty(&cma_dev->id_list)) { | ||
1858 | id_priv = list_entry(cma_dev->id_list.next, | ||
1859 | struct rdma_id_private, list); | ||
1860 | |||
1861 | if (cma_internal_listen(id_priv)) { | ||
1862 | cma_destroy_listen(id_priv); | ||
1863 | continue; | ||
1864 | } | ||
1865 | |||
1866 | list_del(&id_priv->list); | ||
1867 | list_add_tail(&id_priv->list, &remove_list); | ||
1868 | atomic_inc(&id_priv->refcount); | ||
1869 | mutex_unlock(&lock); | ||
1870 | |||
1871 | ret = cma_remove_id_dev(id_priv); | ||
1872 | cma_deref_id(id_priv); | ||
1873 | if (ret) | ||
1874 | rdma_destroy_id(&id_priv->id); | ||
1875 | |||
1876 | mutex_lock(&lock); | ||
1877 | } | ||
1878 | mutex_unlock(&lock); | ||
1879 | |||
1880 | cma_deref_dev(cma_dev); | ||
1881 | wait_for_completion(&cma_dev->comp); | ||
1882 | } | ||
1883 | |||
1884 | static void cma_remove_one(struct ib_device *device) | ||
1885 | { | ||
1886 | struct cma_device *cma_dev; | ||
1887 | |||
1888 | cma_dev = ib_get_client_data(device, &cma_client); | ||
1889 | if (!cma_dev) | ||
1890 | return; | ||
1891 | |||
1892 | mutex_lock(&lock); | ||
1893 | list_del(&cma_dev->list); | ||
1894 | mutex_unlock(&lock); | ||
1895 | |||
1896 | cma_process_remove(cma_dev); | ||
1897 | kfree(cma_dev); | ||
1898 | } | ||
1899 | |||
1900 | static int cma_init(void) | ||
1901 | { | ||
1902 | int ret; | ||
1903 | |||
1904 | cma_wq = create_singlethread_workqueue("rdma_cm_wq"); | ||
1905 | if (!cma_wq) | ||
1906 | return -ENOMEM; | ||
1907 | |||
1908 | ret = ib_register_client(&cma_client); | ||
1909 | if (ret) | ||
1910 | goto err; | ||
1911 | return 0; | ||
1912 | |||
1913 | err: | ||
1914 | destroy_workqueue(cma_wq); | ||
1915 | return ret; | ||
1916 | } | ||
1917 | |||
1918 | static void cma_cleanup(void) | ||
1919 | { | ||
1920 | ib_unregister_client(&cma_client); | ||
1921 | destroy_workqueue(cma_wq); | ||
1922 | idr_destroy(&sdp_ps); | ||
1923 | idr_destroy(&tcp_ps); | ||
1924 | } | ||
1925 | |||
1926 | module_init(cma_init); | ||
1927 | module_exit(cma_cleanup); | ||
diff --git a/drivers/infiniband/core/fmr_pool.c b/drivers/infiniband/core/fmr_pool.c index 838bf54458d2..615fe9cc6c56 100644 --- a/drivers/infiniband/core/fmr_pool.c +++ b/drivers/infiniband/core/fmr_pool.c | |||
@@ -54,7 +54,7 @@ enum { | |||
54 | /* | 54 | /* |
55 | * If an FMR is not in use, then the list member will point to either | 55 | * If an FMR is not in use, then the list member will point to either |
56 | * its pool's free_list (if the FMR can be mapped again; that is, | 56 | * its pool's free_list (if the FMR can be mapped again; that is, |
57 | * remap_count < IB_FMR_MAX_REMAPS) or its pool's dirty_list (if the | 57 | * remap_count < pool->max_remaps) or its pool's dirty_list (if the |
58 | * FMR needs to be unmapped before being remapped). In either of | 58 | * FMR needs to be unmapped before being remapped). In either of |
59 | * these cases it is a bug if the ref_count is not 0. In other words, | 59 | * these cases it is a bug if the ref_count is not 0. In other words, |
60 | * if ref_count is > 0, then the list member must not be linked into | 60 | * if ref_count is > 0, then the list member must not be linked into |
@@ -84,6 +84,7 @@ struct ib_fmr_pool { | |||
84 | 84 | ||
85 | int pool_size; | 85 | int pool_size; |
86 | int max_pages; | 86 | int max_pages; |
87 | int max_remaps; | ||
87 | int dirty_watermark; | 88 | int dirty_watermark; |
88 | int dirty_len; | 89 | int dirty_len; |
89 | struct list_head free_list; | 90 | struct list_head free_list; |
@@ -214,8 +215,10 @@ struct ib_fmr_pool *ib_create_fmr_pool(struct ib_pd *pd, | |||
214 | { | 215 | { |
215 | struct ib_device *device; | 216 | struct ib_device *device; |
216 | struct ib_fmr_pool *pool; | 217 | struct ib_fmr_pool *pool; |
218 | struct ib_device_attr *attr; | ||
217 | int i; | 219 | int i; |
218 | int ret; | 220 | int ret; |
221 | int max_remaps; | ||
219 | 222 | ||
220 | if (!params) | 223 | if (!params) |
221 | return ERR_PTR(-EINVAL); | 224 | return ERR_PTR(-EINVAL); |
@@ -228,6 +231,26 @@ struct ib_fmr_pool *ib_create_fmr_pool(struct ib_pd *pd, | |||
228 | return ERR_PTR(-ENOSYS); | 231 | return ERR_PTR(-ENOSYS); |
229 | } | 232 | } |
230 | 233 | ||
234 | attr = kmalloc(sizeof *attr, GFP_KERNEL); | ||
235 | if (!attr) { | ||
236 | printk(KERN_WARNING "couldn't allocate device attr struct"); | ||
237 | return ERR_PTR(-ENOMEM); | ||
238 | } | ||
239 | |||
240 | ret = ib_query_device(device, attr); | ||
241 | if (ret) { | ||
242 | printk(KERN_WARNING "couldn't query device"); | ||
243 | kfree(attr); | ||
244 | return ERR_PTR(ret); | ||
245 | } | ||
246 | |||
247 | if (!attr->max_map_per_fmr) | ||
248 | max_remaps = IB_FMR_MAX_REMAPS; | ||
249 | else | ||
250 | max_remaps = attr->max_map_per_fmr; | ||
251 | |||
252 | kfree(attr); | ||
253 | |||
231 | pool = kmalloc(sizeof *pool, GFP_KERNEL); | 254 | pool = kmalloc(sizeof *pool, GFP_KERNEL); |
232 | if (!pool) { | 255 | if (!pool) { |
233 | printk(KERN_WARNING "couldn't allocate pool struct"); | 256 | printk(KERN_WARNING "couldn't allocate pool struct"); |
@@ -258,6 +281,7 @@ struct ib_fmr_pool *ib_create_fmr_pool(struct ib_pd *pd, | |||
258 | 281 | ||
259 | pool->pool_size = 0; | 282 | pool->pool_size = 0; |
260 | pool->max_pages = params->max_pages_per_fmr; | 283 | pool->max_pages = params->max_pages_per_fmr; |
284 | pool->max_remaps = max_remaps; | ||
261 | pool->dirty_watermark = params->dirty_watermark; | 285 | pool->dirty_watermark = params->dirty_watermark; |
262 | pool->dirty_len = 0; | 286 | pool->dirty_len = 0; |
263 | spin_lock_init(&pool->pool_lock); | 287 | spin_lock_init(&pool->pool_lock); |
@@ -279,7 +303,7 @@ struct ib_fmr_pool *ib_create_fmr_pool(struct ib_pd *pd, | |||
279 | struct ib_pool_fmr *fmr; | 303 | struct ib_pool_fmr *fmr; |
280 | struct ib_fmr_attr attr = { | 304 | struct ib_fmr_attr attr = { |
281 | .max_pages = params->max_pages_per_fmr, | 305 | .max_pages = params->max_pages_per_fmr, |
282 | .max_maps = IB_FMR_MAX_REMAPS, | 306 | .max_maps = pool->max_remaps, |
283 | .page_shift = params->page_shift | 307 | .page_shift = params->page_shift |
284 | }; | 308 | }; |
285 | 309 | ||
@@ -489,7 +513,7 @@ int ib_fmr_pool_unmap(struct ib_pool_fmr *fmr) | |||
489 | 513 | ||
490 | --fmr->ref_count; | 514 | --fmr->ref_count; |
491 | if (!fmr->ref_count) { | 515 | if (!fmr->ref_count) { |
492 | if (fmr->remap_count < IB_FMR_MAX_REMAPS) { | 516 | if (fmr->remap_count < pool->max_remaps) { |
493 | list_add_tail(&fmr->list, &pool->free_list); | 517 | list_add_tail(&fmr->list, &pool->free_list); |
494 | } else { | 518 | } else { |
495 | list_add_tail(&fmr->list, &pool->dirty_list); | 519 | list_add_tail(&fmr->list, &pool->dirty_list); |
diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c index 5ad41a64314c..b38e02a5db35 100644 --- a/drivers/infiniband/core/mad.c +++ b/drivers/infiniband/core/mad.c | |||
@@ -34,6 +34,7 @@ | |||
34 | * $Id: mad.c 5596 2006-03-03 01:00:07Z sean.hefty $ | 34 | * $Id: mad.c 5596 2006-03-03 01:00:07Z sean.hefty $ |
35 | */ | 35 | */ |
36 | #include <linux/dma-mapping.h> | 36 | #include <linux/dma-mapping.h> |
37 | #include <rdma/ib_cache.h> | ||
37 | 38 | ||
38 | #include "mad_priv.h" | 39 | #include "mad_priv.h" |
39 | #include "mad_rmpp.h" | 40 | #include "mad_rmpp.h" |
@@ -45,8 +46,7 @@ MODULE_DESCRIPTION("kernel IB MAD API"); | |||
45 | MODULE_AUTHOR("Hal Rosenstock"); | 46 | MODULE_AUTHOR("Hal Rosenstock"); |
46 | MODULE_AUTHOR("Sean Hefty"); | 47 | MODULE_AUTHOR("Sean Hefty"); |
47 | 48 | ||
48 | 49 | static kmem_cache_t *ib_mad_cache; | |
49 | kmem_cache_t *ib_mad_cache; | ||
50 | 50 | ||
51 | static struct list_head ib_mad_port_list; | 51 | static struct list_head ib_mad_port_list; |
52 | static u32 ib_mad_client_id = 0; | 52 | static u32 ib_mad_client_id = 0; |
@@ -1673,20 +1673,21 @@ static inline int rcv_has_same_class(struct ib_mad_send_wr_private *wr, | |||
1673 | rwc->recv_buf.mad->mad_hdr.mgmt_class; | 1673 | rwc->recv_buf.mad->mad_hdr.mgmt_class; |
1674 | } | 1674 | } |
1675 | 1675 | ||
1676 | static inline int rcv_has_same_gid(struct ib_mad_send_wr_private *wr, | 1676 | static inline int rcv_has_same_gid(struct ib_mad_agent_private *mad_agent_priv, |
1677 | struct ib_mad_send_wr_private *wr, | ||
1677 | struct ib_mad_recv_wc *rwc ) | 1678 | struct ib_mad_recv_wc *rwc ) |
1678 | { | 1679 | { |
1679 | struct ib_ah_attr attr; | 1680 | struct ib_ah_attr attr; |
1680 | u8 send_resp, rcv_resp; | 1681 | u8 send_resp, rcv_resp; |
1682 | union ib_gid sgid; | ||
1683 | struct ib_device *device = mad_agent_priv->agent.device; | ||
1684 | u8 port_num = mad_agent_priv->agent.port_num; | ||
1685 | u8 lmc; | ||
1681 | 1686 | ||
1682 | send_resp = ((struct ib_mad *)(wr->send_buf.mad))-> | 1687 | send_resp = ((struct ib_mad *)(wr->send_buf.mad))-> |
1683 | mad_hdr.method & IB_MGMT_METHOD_RESP; | 1688 | mad_hdr.method & IB_MGMT_METHOD_RESP; |
1684 | rcv_resp = rwc->recv_buf.mad->mad_hdr.method & IB_MGMT_METHOD_RESP; | 1689 | rcv_resp = rwc->recv_buf.mad->mad_hdr.method & IB_MGMT_METHOD_RESP; |
1685 | 1690 | ||
1686 | if (!send_resp && rcv_resp) | ||
1687 | /* is request/response. GID/LIDs are both local (same). */ | ||
1688 | return 1; | ||
1689 | |||
1690 | if (send_resp == rcv_resp) | 1691 | if (send_resp == rcv_resp) |
1691 | /* both requests, or both responses. GIDs different */ | 1692 | /* both requests, or both responses. GIDs different */ |
1692 | return 0; | 1693 | return 0; |
@@ -1695,48 +1696,78 @@ static inline int rcv_has_same_gid(struct ib_mad_send_wr_private *wr, | |||
1695 | /* Assume not equal, to avoid false positives. */ | 1696 | /* Assume not equal, to avoid false positives. */ |
1696 | return 0; | 1697 | return 0; |
1697 | 1698 | ||
1698 | if (!(attr.ah_flags & IB_AH_GRH) && !(rwc->wc->wc_flags & IB_WC_GRH)) | 1699 | if (!!(attr.ah_flags & IB_AH_GRH) != |
1699 | return attr.dlid == rwc->wc->slid; | 1700 | !!(rwc->wc->wc_flags & IB_WC_GRH)) |
1700 | else if ((attr.ah_flags & IB_AH_GRH) && | ||
1701 | (rwc->wc->wc_flags & IB_WC_GRH)) | ||
1702 | return memcmp(attr.grh.dgid.raw, | ||
1703 | rwc->recv_buf.grh->sgid.raw, 16) == 0; | ||
1704 | else | ||
1705 | /* one has GID, other does not. Assume different */ | 1701 | /* one has GID, other does not. Assume different */ |
1706 | return 0; | 1702 | return 0; |
1703 | |||
1704 | if (!send_resp && rcv_resp) { | ||
1705 | /* is request/response. */ | ||
1706 | if (!(attr.ah_flags & IB_AH_GRH)) { | ||
1707 | if (ib_get_cached_lmc(device, port_num, &lmc)) | ||
1708 | return 0; | ||
1709 | return (!lmc || !((attr.src_path_bits ^ | ||
1710 | rwc->wc->dlid_path_bits) & | ||
1711 | ((1 << lmc) - 1))); | ||
1712 | } else { | ||
1713 | if (ib_get_cached_gid(device, port_num, | ||
1714 | attr.grh.sgid_index, &sgid)) | ||
1715 | return 0; | ||
1716 | return !memcmp(sgid.raw, rwc->recv_buf.grh->dgid.raw, | ||
1717 | 16); | ||
1718 | } | ||
1719 | } | ||
1720 | |||
1721 | if (!(attr.ah_flags & IB_AH_GRH)) | ||
1722 | return attr.dlid == rwc->wc->slid; | ||
1723 | else | ||
1724 | return !memcmp(attr.grh.dgid.raw, rwc->recv_buf.grh->sgid.raw, | ||
1725 | 16); | ||
1726 | } | ||
1727 | |||
1728 | static inline int is_direct(u8 class) | ||
1729 | { | ||
1730 | return (class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE); | ||
1707 | } | 1731 | } |
1732 | |||
1708 | struct ib_mad_send_wr_private* | 1733 | struct ib_mad_send_wr_private* |
1709 | ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv, | 1734 | ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv, |
1710 | struct ib_mad_recv_wc *mad_recv_wc) | 1735 | struct ib_mad_recv_wc *wc) |
1711 | { | 1736 | { |
1712 | struct ib_mad_send_wr_private *mad_send_wr; | 1737 | struct ib_mad_send_wr_private *wr; |
1713 | struct ib_mad *mad; | 1738 | struct ib_mad *mad; |
1714 | 1739 | ||
1715 | mad = (struct ib_mad *)mad_recv_wc->recv_buf.mad; | 1740 | mad = (struct ib_mad *)wc->recv_buf.mad; |
1716 | 1741 | ||
1717 | list_for_each_entry(mad_send_wr, &mad_agent_priv->wait_list, | 1742 | list_for_each_entry(wr, &mad_agent_priv->wait_list, agent_list) { |
1718 | agent_list) { | 1743 | if ((wr->tid == mad->mad_hdr.tid) && |
1719 | if ((mad_send_wr->tid == mad->mad_hdr.tid) && | 1744 | rcv_has_same_class(wr, wc) && |
1720 | rcv_has_same_class(mad_send_wr, mad_recv_wc) && | 1745 | /* |
1721 | rcv_has_same_gid(mad_send_wr, mad_recv_wc)) | 1746 | * Don't check GID for direct routed MADs. |
1722 | return mad_send_wr; | 1747 | * These might have permissive LIDs. |
1748 | */ | ||
1749 | (is_direct(wc->recv_buf.mad->mad_hdr.mgmt_class) || | ||
1750 | rcv_has_same_gid(mad_agent_priv, wr, wc))) | ||
1751 | return wr; | ||
1723 | } | 1752 | } |
1724 | 1753 | ||
1725 | /* | 1754 | /* |
1726 | * It's possible to receive the response before we've | 1755 | * It's possible to receive the response before we've |
1727 | * been notified that the send has completed | 1756 | * been notified that the send has completed |
1728 | */ | 1757 | */ |
1729 | list_for_each_entry(mad_send_wr, &mad_agent_priv->send_list, | 1758 | list_for_each_entry(wr, &mad_agent_priv->send_list, agent_list) { |
1730 | agent_list) { | 1759 | if (is_data_mad(mad_agent_priv, wr->send_buf.mad) && |
1731 | if (is_data_mad(mad_agent_priv, mad_send_wr->send_buf.mad) && | 1760 | wr->tid == mad->mad_hdr.tid && |
1732 | mad_send_wr->tid == mad->mad_hdr.tid && | 1761 | wr->timeout && |
1733 | mad_send_wr->timeout && | 1762 | rcv_has_same_class(wr, wc) && |
1734 | rcv_has_same_class(mad_send_wr, mad_recv_wc) && | 1763 | /* |
1735 | rcv_has_same_gid(mad_send_wr, mad_recv_wc)) { | 1764 | * Don't check GID for direct routed MADs. |
1765 | * These might have permissive LIDs. | ||
1766 | */ | ||
1767 | (is_direct(wc->recv_buf.mad->mad_hdr.mgmt_class) || | ||
1768 | rcv_has_same_gid(mad_agent_priv, wr, wc))) | ||
1736 | /* Verify request has not been canceled */ | 1769 | /* Verify request has not been canceled */ |
1737 | return (mad_send_wr->status == IB_WC_SUCCESS) ? | 1770 | return (wr->status == IB_WC_SUCCESS) ? wr : NULL; |
1738 | mad_send_wr : NULL; | ||
1739 | } | ||
1740 | } | 1771 | } |
1741 | return NULL; | 1772 | return NULL; |
1742 | } | 1773 | } |
diff --git a/drivers/infiniband/core/mad_priv.h b/drivers/infiniband/core/mad_priv.h index b4fa28d3160f..d147f3bad2ce 100644 --- a/drivers/infiniband/core/mad_priv.h +++ b/drivers/infiniband/core/mad_priv.h | |||
@@ -212,8 +212,6 @@ struct ib_mad_port_private { | |||
212 | struct ib_mad_qp_info qp_info[IB_MAD_QPS_CORE]; | 212 | struct ib_mad_qp_info qp_info[IB_MAD_QPS_CORE]; |
213 | }; | 213 | }; |
214 | 214 | ||
215 | extern kmem_cache_t *ib_mad_cache; | ||
216 | |||
217 | int ib_send_mad(struct ib_mad_send_wr_private *mad_send_wr); | 215 | int ib_send_mad(struct ib_mad_send_wr_private *mad_send_wr); |
218 | 216 | ||
219 | struct ib_mad_send_wr_private * | 217 | struct ib_mad_send_wr_private * |
diff --git a/drivers/infiniband/core/sa_query.c b/drivers/infiniband/core/sa_query.c index 501cc054cb3b..e911c99ff843 100644 --- a/drivers/infiniband/core/sa_query.c +++ b/drivers/infiniband/core/sa_query.c | |||
@@ -47,6 +47,7 @@ | |||
47 | 47 | ||
48 | #include <rdma/ib_pack.h> | 48 | #include <rdma/ib_pack.h> |
49 | #include <rdma/ib_sa.h> | 49 | #include <rdma/ib_sa.h> |
50 | #include <rdma/ib_cache.h> | ||
50 | 51 | ||
51 | MODULE_AUTHOR("Roland Dreier"); | 52 | MODULE_AUTHOR("Roland Dreier"); |
52 | MODULE_DESCRIPTION("InfiniBand subnet administration query support"); | 53 | MODULE_DESCRIPTION("InfiniBand subnet administration query support"); |
@@ -441,6 +442,36 @@ void ib_sa_cancel_query(int id, struct ib_sa_query *query) | |||
441 | } | 442 | } |
442 | EXPORT_SYMBOL(ib_sa_cancel_query); | 443 | EXPORT_SYMBOL(ib_sa_cancel_query); |
443 | 444 | ||
445 | int ib_init_ah_from_path(struct ib_device *device, u8 port_num, | ||
446 | struct ib_sa_path_rec *rec, struct ib_ah_attr *ah_attr) | ||
447 | { | ||
448 | int ret; | ||
449 | u16 gid_index; | ||
450 | |||
451 | memset(ah_attr, 0, sizeof *ah_attr); | ||
452 | ah_attr->dlid = be16_to_cpu(rec->dlid); | ||
453 | ah_attr->sl = rec->sl; | ||
454 | ah_attr->src_path_bits = be16_to_cpu(rec->slid) & 0x7f; | ||
455 | ah_attr->port_num = port_num; | ||
456 | |||
457 | if (rec->hop_limit > 1) { | ||
458 | ah_attr->ah_flags = IB_AH_GRH; | ||
459 | ah_attr->grh.dgid = rec->dgid; | ||
460 | |||
461 | ret = ib_find_cached_gid(device, &rec->sgid, &port_num, | ||
462 | &gid_index); | ||
463 | if (ret) | ||
464 | return ret; | ||
465 | |||
466 | ah_attr->grh.sgid_index = gid_index; | ||
467 | ah_attr->grh.flow_label = be32_to_cpu(rec->flow_label); | ||
468 | ah_attr->grh.hop_limit = rec->hop_limit; | ||
469 | ah_attr->grh.traffic_class = rec->traffic_class; | ||
470 | } | ||
471 | return 0; | ||
472 | } | ||
473 | EXPORT_SYMBOL(ib_init_ah_from_path); | ||
474 | |||
444 | static void init_mad(struct ib_sa_mad *mad, struct ib_mad_agent *agent) | 475 | static void init_mad(struct ib_sa_mad *mad, struct ib_mad_agent *agent) |
445 | { | 476 | { |
446 | unsigned long flags; | 477 | unsigned long flags; |
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c index 9164a09b6ccd..c1c6fda9452c 100644 --- a/drivers/infiniband/core/ucm.c +++ b/drivers/infiniband/core/ucm.c | |||
@@ -30,7 +30,7 @@ | |||
30 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | 30 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
31 | * SOFTWARE. | 31 | * SOFTWARE. |
32 | * | 32 | * |
33 | * $Id: ucm.c 2594 2005-06-13 19:46:02Z libor $ | 33 | * $Id: ucm.c 4311 2005-12-05 18:42:01Z sean.hefty $ |
34 | */ | 34 | */ |
35 | 35 | ||
36 | #include <linux/completion.h> | 36 | #include <linux/completion.h> |
@@ -50,6 +50,7 @@ | |||
50 | 50 | ||
51 | #include <rdma/ib_cm.h> | 51 | #include <rdma/ib_cm.h> |
52 | #include <rdma/ib_user_cm.h> | 52 | #include <rdma/ib_user_cm.h> |
53 | #include <rdma/ib_marshall.h> | ||
53 | 54 | ||
54 | MODULE_AUTHOR("Libor Michalek"); | 55 | MODULE_AUTHOR("Libor Michalek"); |
55 | MODULE_DESCRIPTION("InfiniBand userspace Connection Manager access"); | 56 | MODULE_DESCRIPTION("InfiniBand userspace Connection Manager access"); |
@@ -63,7 +64,7 @@ struct ib_ucm_device { | |||
63 | }; | 64 | }; |
64 | 65 | ||
65 | struct ib_ucm_file { | 66 | struct ib_ucm_file { |
66 | struct semaphore mutex; | 67 | struct mutex file_mutex; |
67 | struct file *filp; | 68 | struct file *filp; |
68 | struct ib_ucm_device *device; | 69 | struct ib_ucm_device *device; |
69 | 70 | ||
@@ -152,7 +153,7 @@ static void ib_ucm_cleanup_events(struct ib_ucm_context *ctx) | |||
152 | { | 153 | { |
153 | struct ib_ucm_event *uevent; | 154 | struct ib_ucm_event *uevent; |
154 | 155 | ||
155 | down(&ctx->file->mutex); | 156 | mutex_lock(&ctx->file->file_mutex); |
156 | list_del(&ctx->file_list); | 157 | list_del(&ctx->file_list); |
157 | while (!list_empty(&ctx->events)) { | 158 | while (!list_empty(&ctx->events)) { |
158 | 159 | ||
@@ -167,7 +168,7 @@ static void ib_ucm_cleanup_events(struct ib_ucm_context *ctx) | |||
167 | 168 | ||
168 | kfree(uevent); | 169 | kfree(uevent); |
169 | } | 170 | } |
170 | up(&ctx->file->mutex); | 171 | mutex_unlock(&ctx->file->file_mutex); |
171 | } | 172 | } |
172 | 173 | ||
173 | static struct ib_ucm_context *ib_ucm_ctx_alloc(struct ib_ucm_file *file) | 174 | static struct ib_ucm_context *ib_ucm_ctx_alloc(struct ib_ucm_file *file) |
@@ -205,36 +206,6 @@ error: | |||
205 | return NULL; | 206 | return NULL; |
206 | } | 207 | } |
207 | 208 | ||
208 | static void ib_ucm_event_path_get(struct ib_ucm_path_rec *upath, | ||
209 | struct ib_sa_path_rec *kpath) | ||
210 | { | ||
211 | if (!kpath || !upath) | ||
212 | return; | ||
213 | |||
214 | memcpy(upath->dgid, kpath->dgid.raw, sizeof *upath->dgid); | ||
215 | memcpy(upath->sgid, kpath->sgid.raw, sizeof *upath->sgid); | ||
216 | |||
217 | upath->dlid = kpath->dlid; | ||
218 | upath->slid = kpath->slid; | ||
219 | upath->raw_traffic = kpath->raw_traffic; | ||
220 | upath->flow_label = kpath->flow_label; | ||
221 | upath->hop_limit = kpath->hop_limit; | ||
222 | upath->traffic_class = kpath->traffic_class; | ||
223 | upath->reversible = kpath->reversible; | ||
224 | upath->numb_path = kpath->numb_path; | ||
225 | upath->pkey = kpath->pkey; | ||
226 | upath->sl = kpath->sl; | ||
227 | upath->mtu_selector = kpath->mtu_selector; | ||
228 | upath->mtu = kpath->mtu; | ||
229 | upath->rate_selector = kpath->rate_selector; | ||
230 | upath->rate = kpath->rate; | ||
231 | upath->packet_life_time = kpath->packet_life_time; | ||
232 | upath->preference = kpath->preference; | ||
233 | |||
234 | upath->packet_life_time_selector = | ||
235 | kpath->packet_life_time_selector; | ||
236 | } | ||
237 | |||
238 | static void ib_ucm_event_req_get(struct ib_ucm_req_event_resp *ureq, | 209 | static void ib_ucm_event_req_get(struct ib_ucm_req_event_resp *ureq, |
239 | struct ib_cm_req_event_param *kreq) | 210 | struct ib_cm_req_event_param *kreq) |
240 | { | 211 | { |
@@ -253,8 +224,10 @@ static void ib_ucm_event_req_get(struct ib_ucm_req_event_resp *ureq, | |||
253 | ureq->srq = kreq->srq; | 224 | ureq->srq = kreq->srq; |
254 | ureq->port = kreq->port; | 225 | ureq->port = kreq->port; |
255 | 226 | ||
256 | ib_ucm_event_path_get(&ureq->primary_path, kreq->primary_path); | 227 | ib_copy_path_rec_to_user(&ureq->primary_path, kreq->primary_path); |
257 | ib_ucm_event_path_get(&ureq->alternate_path, kreq->alternate_path); | 228 | if (kreq->alternate_path) |
229 | ib_copy_path_rec_to_user(&ureq->alternate_path, | ||
230 | kreq->alternate_path); | ||
258 | } | 231 | } |
259 | 232 | ||
260 | static void ib_ucm_event_rep_get(struct ib_ucm_rep_event_resp *urep, | 233 | static void ib_ucm_event_rep_get(struct ib_ucm_rep_event_resp *urep, |
@@ -324,8 +297,8 @@ static int ib_ucm_event_process(struct ib_cm_event *evt, | |||
324 | info = evt->param.rej_rcvd.ari; | 297 | info = evt->param.rej_rcvd.ari; |
325 | break; | 298 | break; |
326 | case IB_CM_LAP_RECEIVED: | 299 | case IB_CM_LAP_RECEIVED: |
327 | ib_ucm_event_path_get(&uvt->resp.u.lap_resp.path, | 300 | ib_copy_path_rec_to_user(&uvt->resp.u.lap_resp.path, |
328 | evt->param.lap_rcvd.alternate_path); | 301 | evt->param.lap_rcvd.alternate_path); |
329 | uvt->data_len = IB_CM_LAP_PRIVATE_DATA_SIZE; | 302 | uvt->data_len = IB_CM_LAP_PRIVATE_DATA_SIZE; |
330 | uvt->resp.present = IB_UCM_PRES_ALTERNATE; | 303 | uvt->resp.present = IB_UCM_PRES_ALTERNATE; |
331 | break; | 304 | break; |
@@ -402,11 +375,11 @@ static int ib_ucm_event_handler(struct ib_cm_id *cm_id, | |||
402 | if (result) | 375 | if (result) |
403 | goto err2; | 376 | goto err2; |
404 | 377 | ||
405 | down(&ctx->file->mutex); | 378 | mutex_lock(&ctx->file->file_mutex); |
406 | list_add_tail(&uevent->file_list, &ctx->file->events); | 379 | list_add_tail(&uevent->file_list, &ctx->file->events); |
407 | list_add_tail(&uevent->ctx_list, &ctx->events); | 380 | list_add_tail(&uevent->ctx_list, &ctx->events); |
408 | wake_up_interruptible(&ctx->file->poll_wait); | 381 | wake_up_interruptible(&ctx->file->poll_wait); |
409 | up(&ctx->file->mutex); | 382 | mutex_unlock(&ctx->file->file_mutex); |
410 | return 0; | 383 | return 0; |
411 | 384 | ||
412 | err2: | 385 | err2: |
@@ -432,7 +405,7 @@ static ssize_t ib_ucm_event(struct ib_ucm_file *file, | |||
432 | if (copy_from_user(&cmd, inbuf, sizeof(cmd))) | 405 | if (copy_from_user(&cmd, inbuf, sizeof(cmd))) |
433 | return -EFAULT; | 406 | return -EFAULT; |
434 | 407 | ||
435 | down(&file->mutex); | 408 | mutex_lock(&file->file_mutex); |
436 | while (list_empty(&file->events)) { | 409 | while (list_empty(&file->events)) { |
437 | 410 | ||
438 | if (file->filp->f_flags & O_NONBLOCK) { | 411 | if (file->filp->f_flags & O_NONBLOCK) { |
@@ -447,9 +420,9 @@ static ssize_t ib_ucm_event(struct ib_ucm_file *file, | |||
447 | 420 | ||
448 | prepare_to_wait(&file->poll_wait, &wait, TASK_INTERRUPTIBLE); | 421 | prepare_to_wait(&file->poll_wait, &wait, TASK_INTERRUPTIBLE); |
449 | 422 | ||
450 | up(&file->mutex); | 423 | mutex_unlock(&file->file_mutex); |
451 | schedule(); | 424 | schedule(); |
452 | down(&file->mutex); | 425 | mutex_lock(&file->file_mutex); |
453 | 426 | ||
454 | finish_wait(&file->poll_wait, &wait); | 427 | finish_wait(&file->poll_wait, &wait); |
455 | } | 428 | } |
@@ -509,7 +482,7 @@ static ssize_t ib_ucm_event(struct ib_ucm_file *file, | |||
509 | kfree(uevent->info); | 482 | kfree(uevent->info); |
510 | kfree(uevent); | 483 | kfree(uevent); |
511 | done: | 484 | done: |
512 | up(&file->mutex); | 485 | mutex_unlock(&file->file_mutex); |
513 | return result; | 486 | return result; |
514 | } | 487 | } |
515 | 488 | ||
@@ -528,9 +501,9 @@ static ssize_t ib_ucm_create_id(struct ib_ucm_file *file, | |||
528 | if (copy_from_user(&cmd, inbuf, sizeof(cmd))) | 501 | if (copy_from_user(&cmd, inbuf, sizeof(cmd))) |
529 | return -EFAULT; | 502 | return -EFAULT; |
530 | 503 | ||
531 | down(&file->mutex); | 504 | mutex_lock(&file->file_mutex); |
532 | ctx = ib_ucm_ctx_alloc(file); | 505 | ctx = ib_ucm_ctx_alloc(file); |
533 | up(&file->mutex); | 506 | mutex_unlock(&file->file_mutex); |
534 | if (!ctx) | 507 | if (!ctx) |
535 | return -ENOMEM; | 508 | return -ENOMEM; |
536 | 509 | ||
@@ -637,65 +610,11 @@ static ssize_t ib_ucm_attr_id(struct ib_ucm_file *file, | |||
637 | return result; | 610 | return result; |
638 | } | 611 | } |
639 | 612 | ||
640 | static void ib_ucm_copy_ah_attr(struct ib_ucm_ah_attr *dest_attr, | ||
641 | struct ib_ah_attr *src_attr) | ||
642 | { | ||
643 | memcpy(dest_attr->grh_dgid, src_attr->grh.dgid.raw, | ||
644 | sizeof src_attr->grh.dgid); | ||
645 | dest_attr->grh_flow_label = src_attr->grh.flow_label; | ||
646 | dest_attr->grh_sgid_index = src_attr->grh.sgid_index; | ||
647 | dest_attr->grh_hop_limit = src_attr->grh.hop_limit; | ||
648 | dest_attr->grh_traffic_class = src_attr->grh.traffic_class; | ||
649 | |||
650 | dest_attr->dlid = src_attr->dlid; | ||
651 | dest_attr->sl = src_attr->sl; | ||
652 | dest_attr->src_path_bits = src_attr->src_path_bits; | ||
653 | dest_attr->static_rate = src_attr->static_rate; | ||
654 | dest_attr->is_global = (src_attr->ah_flags & IB_AH_GRH); | ||
655 | dest_attr->port_num = src_attr->port_num; | ||
656 | } | ||
657 | |||
658 | static void ib_ucm_copy_qp_attr(struct ib_ucm_init_qp_attr_resp *dest_attr, | ||
659 | struct ib_qp_attr *src_attr) | ||
660 | { | ||
661 | dest_attr->cur_qp_state = src_attr->cur_qp_state; | ||
662 | dest_attr->path_mtu = src_attr->path_mtu; | ||
663 | dest_attr->path_mig_state = src_attr->path_mig_state; | ||
664 | dest_attr->qkey = src_attr->qkey; | ||
665 | dest_attr->rq_psn = src_attr->rq_psn; | ||
666 | dest_attr->sq_psn = src_attr->sq_psn; | ||
667 | dest_attr->dest_qp_num = src_attr->dest_qp_num; | ||
668 | dest_attr->qp_access_flags = src_attr->qp_access_flags; | ||
669 | |||
670 | dest_attr->max_send_wr = src_attr->cap.max_send_wr; | ||
671 | dest_attr->max_recv_wr = src_attr->cap.max_recv_wr; | ||
672 | dest_attr->max_send_sge = src_attr->cap.max_send_sge; | ||
673 | dest_attr->max_recv_sge = src_attr->cap.max_recv_sge; | ||
674 | dest_attr->max_inline_data = src_attr->cap.max_inline_data; | ||
675 | |||
676 | ib_ucm_copy_ah_attr(&dest_attr->ah_attr, &src_attr->ah_attr); | ||
677 | ib_ucm_copy_ah_attr(&dest_attr->alt_ah_attr, &src_attr->alt_ah_attr); | ||
678 | |||
679 | dest_attr->pkey_index = src_attr->pkey_index; | ||
680 | dest_attr->alt_pkey_index = src_attr->alt_pkey_index; | ||
681 | dest_attr->en_sqd_async_notify = src_attr->en_sqd_async_notify; | ||
682 | dest_attr->sq_draining = src_attr->sq_draining; | ||
683 | dest_attr->max_rd_atomic = src_attr->max_rd_atomic; | ||
684 | dest_attr->max_dest_rd_atomic = src_attr->max_dest_rd_atomic; | ||
685 | dest_attr->min_rnr_timer = src_attr->min_rnr_timer; | ||
686 | dest_attr->port_num = src_attr->port_num; | ||
687 | dest_attr->timeout = src_attr->timeout; | ||
688 | dest_attr->retry_cnt = src_attr->retry_cnt; | ||
689 | dest_attr->rnr_retry = src_attr->rnr_retry; | ||
690 | dest_attr->alt_port_num = src_attr->alt_port_num; | ||
691 | dest_attr->alt_timeout = src_attr->alt_timeout; | ||
692 | } | ||
693 | |||
694 | static ssize_t ib_ucm_init_qp_attr(struct ib_ucm_file *file, | 613 | static ssize_t ib_ucm_init_qp_attr(struct ib_ucm_file *file, |
695 | const char __user *inbuf, | 614 | const char __user *inbuf, |
696 | int in_len, int out_len) | 615 | int in_len, int out_len) |
697 | { | 616 | { |
698 | struct ib_ucm_init_qp_attr_resp resp; | 617 | struct ib_uverbs_qp_attr resp; |
699 | struct ib_ucm_init_qp_attr cmd; | 618 | struct ib_ucm_init_qp_attr cmd; |
700 | struct ib_ucm_context *ctx; | 619 | struct ib_ucm_context *ctx; |
701 | struct ib_qp_attr qp_attr; | 620 | struct ib_qp_attr qp_attr; |
@@ -718,7 +637,7 @@ static ssize_t ib_ucm_init_qp_attr(struct ib_ucm_file *file, | |||
718 | if (result) | 637 | if (result) |
719 | goto out; | 638 | goto out; |
720 | 639 | ||
721 | ib_ucm_copy_qp_attr(&resp, &qp_attr); | 640 | ib_copy_qp_attr_to_user(&resp, &qp_attr); |
722 | 641 | ||
723 | if (copy_to_user((void __user *)(unsigned long)cmd.response, | 642 | if (copy_to_user((void __user *)(unsigned long)cmd.response, |
724 | &resp, sizeof(resp))) | 643 | &resp, sizeof(resp))) |
@@ -729,6 +648,17 @@ out: | |||
729 | return result; | 648 | return result; |
730 | } | 649 | } |
731 | 650 | ||
651 | static int ucm_validate_listen(__be64 service_id, __be64 service_mask) | ||
652 | { | ||
653 | service_id &= service_mask; | ||
654 | |||
655 | if (((service_id & IB_CMA_SERVICE_ID_MASK) == IB_CMA_SERVICE_ID) || | ||
656 | ((service_id & IB_SDP_SERVICE_ID_MASK) == IB_SDP_SERVICE_ID)) | ||
657 | return -EINVAL; | ||
658 | |||
659 | return 0; | ||
660 | } | ||
661 | |||
732 | static ssize_t ib_ucm_listen(struct ib_ucm_file *file, | 662 | static ssize_t ib_ucm_listen(struct ib_ucm_file *file, |
733 | const char __user *inbuf, | 663 | const char __user *inbuf, |
734 | int in_len, int out_len) | 664 | int in_len, int out_len) |
@@ -744,7 +674,13 @@ static ssize_t ib_ucm_listen(struct ib_ucm_file *file, | |||
744 | if (IS_ERR(ctx)) | 674 | if (IS_ERR(ctx)) |
745 | return PTR_ERR(ctx); | 675 | return PTR_ERR(ctx); |
746 | 676 | ||
747 | result = ib_cm_listen(ctx->cm_id, cmd.service_id, cmd.service_mask); | 677 | result = ucm_validate_listen(cmd.service_id, cmd.service_mask); |
678 | if (result) | ||
679 | goto out; | ||
680 | |||
681 | result = ib_cm_listen(ctx->cm_id, cmd.service_id, cmd.service_mask, | ||
682 | NULL); | ||
683 | out: | ||
748 | ib_ucm_ctx_put(ctx); | 684 | ib_ucm_ctx_put(ctx); |
749 | return result; | 685 | return result; |
750 | } | 686 | } |
@@ -793,7 +729,7 @@ static int ib_ucm_alloc_data(const void **dest, u64 src, u32 len) | |||
793 | 729 | ||
794 | static int ib_ucm_path_get(struct ib_sa_path_rec **path, u64 src) | 730 | static int ib_ucm_path_get(struct ib_sa_path_rec **path, u64 src) |
795 | { | 731 | { |
796 | struct ib_ucm_path_rec ucm_path; | 732 | struct ib_user_path_rec upath; |
797 | struct ib_sa_path_rec *sa_path; | 733 | struct ib_sa_path_rec *sa_path; |
798 | 734 | ||
799 | *path = NULL; | 735 | *path = NULL; |
@@ -805,36 +741,14 @@ static int ib_ucm_path_get(struct ib_sa_path_rec **path, u64 src) | |||
805 | if (!sa_path) | 741 | if (!sa_path) |
806 | return -ENOMEM; | 742 | return -ENOMEM; |
807 | 743 | ||
808 | if (copy_from_user(&ucm_path, (void __user *)(unsigned long)src, | 744 | if (copy_from_user(&upath, (void __user *)(unsigned long)src, |
809 | sizeof(ucm_path))) { | 745 | sizeof(upath))) { |
810 | 746 | ||
811 | kfree(sa_path); | 747 | kfree(sa_path); |
812 | return -EFAULT; | 748 | return -EFAULT; |
813 | } | 749 | } |
814 | 750 | ||
815 | memcpy(sa_path->dgid.raw, ucm_path.dgid, sizeof sa_path->dgid); | 751 | ib_copy_path_rec_from_user(sa_path, &upath); |
816 | memcpy(sa_path->sgid.raw, ucm_path.sgid, sizeof sa_path->sgid); | ||
817 | |||
818 | sa_path->dlid = ucm_path.dlid; | ||
819 | sa_path->slid = ucm_path.slid; | ||
820 | sa_path->raw_traffic = ucm_path.raw_traffic; | ||
821 | sa_path->flow_label = ucm_path.flow_label; | ||
822 | sa_path->hop_limit = ucm_path.hop_limit; | ||
823 | sa_path->traffic_class = ucm_path.traffic_class; | ||
824 | sa_path->reversible = ucm_path.reversible; | ||
825 | sa_path->numb_path = ucm_path.numb_path; | ||
826 | sa_path->pkey = ucm_path.pkey; | ||
827 | sa_path->sl = ucm_path.sl; | ||
828 | sa_path->mtu_selector = ucm_path.mtu_selector; | ||
829 | sa_path->mtu = ucm_path.mtu; | ||
830 | sa_path->rate_selector = ucm_path.rate_selector; | ||
831 | sa_path->rate = ucm_path.rate; | ||
832 | sa_path->packet_life_time = ucm_path.packet_life_time; | ||
833 | sa_path->preference = ucm_path.preference; | ||
834 | |||
835 | sa_path->packet_life_time_selector = | ||
836 | ucm_path.packet_life_time_selector; | ||
837 | |||
838 | *path = sa_path; | 752 | *path = sa_path; |
839 | return 0; | 753 | return 0; |
840 | } | 754 | } |
@@ -1130,7 +1044,6 @@ static ssize_t ib_ucm_send_sidr_req(struct ib_ucm_file *file, | |||
1130 | param.service_id = cmd.sid; | 1044 | param.service_id = cmd.sid; |
1131 | param.timeout_ms = cmd.timeout; | 1045 | param.timeout_ms = cmd.timeout; |
1132 | param.max_cm_retries = cmd.max_cm_retries; | 1046 | param.max_cm_retries = cmd.max_cm_retries; |
1133 | param.pkey = cmd.pkey; | ||
1134 | 1047 | ||
1135 | ctx = ib_ucm_ctx_get(file, cmd.id); | 1048 | ctx = ib_ucm_ctx_get(file, cmd.id); |
1136 | if (!IS_ERR(ctx)) { | 1049 | if (!IS_ERR(ctx)) { |
@@ -1263,7 +1176,7 @@ static int ib_ucm_open(struct inode *inode, struct file *filp) | |||
1263 | INIT_LIST_HEAD(&file->ctxs); | 1176 | INIT_LIST_HEAD(&file->ctxs); |
1264 | init_waitqueue_head(&file->poll_wait); | 1177 | init_waitqueue_head(&file->poll_wait); |
1265 | 1178 | ||
1266 | init_MUTEX(&file->mutex); | 1179 | mutex_init(&file->file_mutex); |
1267 | 1180 | ||
1268 | filp->private_data = file; | 1181 | filp->private_data = file; |
1269 | file->filp = filp; | 1182 | file->filp = filp; |
@@ -1277,11 +1190,11 @@ static int ib_ucm_close(struct inode *inode, struct file *filp) | |||
1277 | struct ib_ucm_file *file = filp->private_data; | 1190 | struct ib_ucm_file *file = filp->private_data; |
1278 | struct ib_ucm_context *ctx; | 1191 | struct ib_ucm_context *ctx; |
1279 | 1192 | ||
1280 | down(&file->mutex); | 1193 | mutex_lock(&file->file_mutex); |
1281 | while (!list_empty(&file->ctxs)) { | 1194 | while (!list_empty(&file->ctxs)) { |
1282 | ctx = list_entry(file->ctxs.next, | 1195 | ctx = list_entry(file->ctxs.next, |
1283 | struct ib_ucm_context, file_list); | 1196 | struct ib_ucm_context, file_list); |
1284 | up(&file->mutex); | 1197 | mutex_unlock(&file->file_mutex); |
1285 | 1198 | ||
1286 | mutex_lock(&ctx_id_mutex); | 1199 | mutex_lock(&ctx_id_mutex); |
1287 | idr_remove(&ctx_id_table, ctx->id); | 1200 | idr_remove(&ctx_id_table, ctx->id); |
@@ -1291,9 +1204,9 @@ static int ib_ucm_close(struct inode *inode, struct file *filp) | |||
1291 | ib_ucm_cleanup_events(ctx); | 1204 | ib_ucm_cleanup_events(ctx); |
1292 | kfree(ctx); | 1205 | kfree(ctx); |
1293 | 1206 | ||
1294 | down(&file->mutex); | 1207 | mutex_lock(&file->file_mutex); |
1295 | } | 1208 | } |
1296 | up(&file->mutex); | 1209 | mutex_unlock(&file->file_mutex); |
1297 | kfree(file); | 1210 | kfree(file); |
1298 | return 0; | 1211 | return 0; |
1299 | } | 1212 | } |
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h index 3372d67ff139..bb9bee56a824 100644 --- a/drivers/infiniband/core/uverbs.h +++ b/drivers/infiniband/core/uverbs.h | |||
@@ -132,7 +132,7 @@ struct ib_ucq_object { | |||
132 | u32 async_events_reported; | 132 | u32 async_events_reported; |
133 | }; | 133 | }; |
134 | 134 | ||
135 | extern struct mutex ib_uverbs_idr_mutex; | 135 | extern spinlock_t ib_uverbs_idr_lock; |
136 | extern struct idr ib_uverbs_pd_idr; | 136 | extern struct idr ib_uverbs_pd_idr; |
137 | extern struct idr ib_uverbs_mr_idr; | 137 | extern struct idr ib_uverbs_mr_idr; |
138 | extern struct idr ib_uverbs_mw_idr; | 138 | extern struct idr ib_uverbs_mw_idr; |
@@ -141,6 +141,8 @@ extern struct idr ib_uverbs_cq_idr; | |||
141 | extern struct idr ib_uverbs_qp_idr; | 141 | extern struct idr ib_uverbs_qp_idr; |
142 | extern struct idr ib_uverbs_srq_idr; | 142 | extern struct idr ib_uverbs_srq_idr; |
143 | 143 | ||
144 | void idr_remove_uobj(struct idr *idp, struct ib_uobject *uobj); | ||
145 | |||
144 | struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file, | 146 | struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file, |
145 | int is_async, int *fd); | 147 | int is_async, int *fd); |
146 | void ib_uverbs_release_event_file(struct kref *ref); | 148 | void ib_uverbs_release_event_file(struct kref *ref); |
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c index 9f69bd48eb1b..76bf61e9b552 100644 --- a/drivers/infiniband/core/uverbs_cmd.c +++ b/drivers/infiniband/core/uverbs_cmd.c | |||
@@ -50,6 +50,196 @@ | |||
50 | (udata)->outlen = (olen); \ | 50 | (udata)->outlen = (olen); \ |
51 | } while (0) | 51 | } while (0) |
52 | 52 | ||
53 | /* | ||
54 | * The ib_uobject locking scheme is as follows: | ||
55 | * | ||
56 | * - ib_uverbs_idr_lock protects the uverbs idrs themselves, so it | ||
57 | * needs to be held during all idr operations. When an object is | ||
58 | * looked up, a reference must be taken on the object's kref before | ||
59 | * dropping this lock. | ||
60 | * | ||
61 | * - Each object also has an rwsem. This rwsem must be held for | ||
62 | * reading while an operation that uses the object is performed. | ||
63 | * For example, while registering an MR, the associated PD's | ||
64 | * uobject.mutex must be held for reading. The rwsem must be held | ||
65 | * for writing while initializing or destroying an object. | ||
66 | * | ||
67 | * - In addition, each object has a "live" flag. If this flag is not | ||
68 | * set, then lookups of the object will fail even if it is found in | ||
69 | * the idr. This handles a reader that blocks and does not acquire | ||
70 | * the rwsem until after the object is destroyed. The destroy | ||
71 | * operation will set the live flag to 0 and then drop the rwsem; | ||
72 | * this will allow the reader to acquire the rwsem, see that the | ||
73 | * live flag is 0, and then drop the rwsem and its reference to | ||
74 | * object. The underlying storage will not be freed until the last | ||
75 | * reference to the object is dropped. | ||
76 | */ | ||
77 | |||
78 | static void init_uobj(struct ib_uobject *uobj, u64 user_handle, | ||
79 | struct ib_ucontext *context) | ||
80 | { | ||
81 | uobj->user_handle = user_handle; | ||
82 | uobj->context = context; | ||
83 | kref_init(&uobj->ref); | ||
84 | init_rwsem(&uobj->mutex); | ||
85 | uobj->live = 0; | ||
86 | } | ||
87 | |||
88 | static void release_uobj(struct kref *kref) | ||
89 | { | ||
90 | kfree(container_of(kref, struct ib_uobject, ref)); | ||
91 | } | ||
92 | |||
93 | static void put_uobj(struct ib_uobject *uobj) | ||
94 | { | ||
95 | kref_put(&uobj->ref, release_uobj); | ||
96 | } | ||
97 | |||
98 | static void put_uobj_read(struct ib_uobject *uobj) | ||
99 | { | ||
100 | up_read(&uobj->mutex); | ||
101 | put_uobj(uobj); | ||
102 | } | ||
103 | |||
104 | static void put_uobj_write(struct ib_uobject *uobj) | ||
105 | { | ||
106 | up_write(&uobj->mutex); | ||
107 | put_uobj(uobj); | ||
108 | } | ||
109 | |||
110 | static int idr_add_uobj(struct idr *idr, struct ib_uobject *uobj) | ||
111 | { | ||
112 | int ret; | ||
113 | |||
114 | retry: | ||
115 | if (!idr_pre_get(idr, GFP_KERNEL)) | ||
116 | return -ENOMEM; | ||
117 | |||
118 | spin_lock(&ib_uverbs_idr_lock); | ||
119 | ret = idr_get_new(idr, uobj, &uobj->id); | ||
120 | spin_unlock(&ib_uverbs_idr_lock); | ||
121 | |||
122 | if (ret == -EAGAIN) | ||
123 | goto retry; | ||
124 | |||
125 | return ret; | ||
126 | } | ||
127 | |||
128 | void idr_remove_uobj(struct idr *idr, struct ib_uobject *uobj) | ||
129 | { | ||
130 | spin_lock(&ib_uverbs_idr_lock); | ||
131 | idr_remove(idr, uobj->id); | ||
132 | spin_unlock(&ib_uverbs_idr_lock); | ||
133 | } | ||
134 | |||
135 | static struct ib_uobject *__idr_get_uobj(struct idr *idr, int id, | ||
136 | struct ib_ucontext *context) | ||
137 | { | ||
138 | struct ib_uobject *uobj; | ||
139 | |||
140 | spin_lock(&ib_uverbs_idr_lock); | ||
141 | uobj = idr_find(idr, id); | ||
142 | if (uobj) | ||
143 | kref_get(&uobj->ref); | ||
144 | spin_unlock(&ib_uverbs_idr_lock); | ||
145 | |||
146 | return uobj; | ||
147 | } | ||
148 | |||
149 | static struct ib_uobject *idr_read_uobj(struct idr *idr, int id, | ||
150 | struct ib_ucontext *context) | ||
151 | { | ||
152 | struct ib_uobject *uobj; | ||
153 | |||
154 | uobj = __idr_get_uobj(idr, id, context); | ||
155 | if (!uobj) | ||
156 | return NULL; | ||
157 | |||
158 | down_read(&uobj->mutex); | ||
159 | if (!uobj->live) { | ||
160 | put_uobj_read(uobj); | ||
161 | return NULL; | ||
162 | } | ||
163 | |||
164 | return uobj; | ||
165 | } | ||
166 | |||
167 | static struct ib_uobject *idr_write_uobj(struct idr *idr, int id, | ||
168 | struct ib_ucontext *context) | ||
169 | { | ||
170 | struct ib_uobject *uobj; | ||
171 | |||
172 | uobj = __idr_get_uobj(idr, id, context); | ||
173 | if (!uobj) | ||
174 | return NULL; | ||
175 | |||
176 | down_write(&uobj->mutex); | ||
177 | if (!uobj->live) { | ||
178 | put_uobj_write(uobj); | ||
179 | return NULL; | ||
180 | } | ||
181 | |||
182 | return uobj; | ||
183 | } | ||
184 | |||
185 | static void *idr_read_obj(struct idr *idr, int id, struct ib_ucontext *context) | ||
186 | { | ||
187 | struct ib_uobject *uobj; | ||
188 | |||
189 | uobj = idr_read_uobj(idr, id, context); | ||
190 | return uobj ? uobj->object : NULL; | ||
191 | } | ||
192 | |||
193 | static struct ib_pd *idr_read_pd(int pd_handle, struct ib_ucontext *context) | ||
194 | { | ||
195 | return idr_read_obj(&ib_uverbs_pd_idr, pd_handle, context); | ||
196 | } | ||
197 | |||
198 | static void put_pd_read(struct ib_pd *pd) | ||
199 | { | ||
200 | put_uobj_read(pd->uobject); | ||
201 | } | ||
202 | |||
203 | static struct ib_cq *idr_read_cq(int cq_handle, struct ib_ucontext *context) | ||
204 | { | ||
205 | return idr_read_obj(&ib_uverbs_cq_idr, cq_handle, context); | ||
206 | } | ||
207 | |||
208 | static void put_cq_read(struct ib_cq *cq) | ||
209 | { | ||
210 | put_uobj_read(cq->uobject); | ||
211 | } | ||
212 | |||
213 | static struct ib_ah *idr_read_ah(int ah_handle, struct ib_ucontext *context) | ||
214 | { | ||
215 | return idr_read_obj(&ib_uverbs_ah_idr, ah_handle, context); | ||
216 | } | ||
217 | |||
218 | static void put_ah_read(struct ib_ah *ah) | ||
219 | { | ||
220 | put_uobj_read(ah->uobject); | ||
221 | } | ||
222 | |||
223 | static struct ib_qp *idr_read_qp(int qp_handle, struct ib_ucontext *context) | ||
224 | { | ||
225 | return idr_read_obj(&ib_uverbs_qp_idr, qp_handle, context); | ||
226 | } | ||
227 | |||
228 | static void put_qp_read(struct ib_qp *qp) | ||
229 | { | ||
230 | put_uobj_read(qp->uobject); | ||
231 | } | ||
232 | |||
233 | static struct ib_srq *idr_read_srq(int srq_handle, struct ib_ucontext *context) | ||
234 | { | ||
235 | return idr_read_obj(&ib_uverbs_srq_idr, srq_handle, context); | ||
236 | } | ||
237 | |||
238 | static void put_srq_read(struct ib_srq *srq) | ||
239 | { | ||
240 | put_uobj_read(srq->uobject); | ||
241 | } | ||
242 | |||
53 | ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file, | 243 | ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file, |
54 | const char __user *buf, | 244 | const char __user *buf, |
55 | int in_len, int out_len) | 245 | int in_len, int out_len) |
@@ -80,8 +270,10 @@ ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file, | |||
80 | in_len - sizeof cmd, out_len - sizeof resp); | 270 | in_len - sizeof cmd, out_len - sizeof resp); |
81 | 271 | ||
82 | ucontext = ibdev->alloc_ucontext(ibdev, &udata); | 272 | ucontext = ibdev->alloc_ucontext(ibdev, &udata); |
83 | if (IS_ERR(ucontext)) | 273 | if (IS_ERR(ucontext)) { |
84 | return PTR_ERR(file->ucontext); | 274 | ret = PTR_ERR(file->ucontext); |
275 | goto err; | ||
276 | } | ||
85 | 277 | ||
86 | ucontext->device = ibdev; | 278 | ucontext->device = ibdev; |
87 | INIT_LIST_HEAD(&ucontext->pd_list); | 279 | INIT_LIST_HEAD(&ucontext->pd_list); |
@@ -278,7 +470,8 @@ ssize_t ib_uverbs_alloc_pd(struct ib_uverbs_file *file, | |||
278 | if (!uobj) | 470 | if (!uobj) |
279 | return -ENOMEM; | 471 | return -ENOMEM; |
280 | 472 | ||
281 | uobj->context = file->ucontext; | 473 | init_uobj(uobj, 0, file->ucontext); |
474 | down_write(&uobj->mutex); | ||
282 | 475 | ||
283 | pd = file->device->ib_dev->alloc_pd(file->device->ib_dev, | 476 | pd = file->device->ib_dev->alloc_pd(file->device->ib_dev, |
284 | file->ucontext, &udata); | 477 | file->ucontext, &udata); |
@@ -291,20 +484,10 @@ ssize_t ib_uverbs_alloc_pd(struct ib_uverbs_file *file, | |||
291 | pd->uobject = uobj; | 484 | pd->uobject = uobj; |
292 | atomic_set(&pd->usecnt, 0); | 485 | atomic_set(&pd->usecnt, 0); |
293 | 486 | ||
294 | mutex_lock(&ib_uverbs_idr_mutex); | 487 | uobj->object = pd; |
295 | 488 | ret = idr_add_uobj(&ib_uverbs_pd_idr, uobj); | |
296 | retry: | ||
297 | if (!idr_pre_get(&ib_uverbs_pd_idr, GFP_KERNEL)) { | ||
298 | ret = -ENOMEM; | ||
299 | goto err_up; | ||
300 | } | ||
301 | |||
302 | ret = idr_get_new(&ib_uverbs_pd_idr, pd, &uobj->id); | ||
303 | |||
304 | if (ret == -EAGAIN) | ||
305 | goto retry; | ||
306 | if (ret) | 489 | if (ret) |
307 | goto err_up; | 490 | goto err_idr; |
308 | 491 | ||
309 | memset(&resp, 0, sizeof resp); | 492 | memset(&resp, 0, sizeof resp); |
310 | resp.pd_handle = uobj->id; | 493 | resp.pd_handle = uobj->id; |
@@ -312,26 +495,27 @@ retry: | |||
312 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 495 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
313 | &resp, sizeof resp)) { | 496 | &resp, sizeof resp)) { |
314 | ret = -EFAULT; | 497 | ret = -EFAULT; |
315 | goto err_idr; | 498 | goto err_copy; |
316 | } | 499 | } |
317 | 500 | ||
318 | mutex_lock(&file->mutex); | 501 | mutex_lock(&file->mutex); |
319 | list_add_tail(&uobj->list, &file->ucontext->pd_list); | 502 | list_add_tail(&uobj->list, &file->ucontext->pd_list); |
320 | mutex_unlock(&file->mutex); | 503 | mutex_unlock(&file->mutex); |
321 | 504 | ||
322 | mutex_unlock(&ib_uverbs_idr_mutex); | 505 | uobj->live = 1; |
506 | |||
507 | up_write(&uobj->mutex); | ||
323 | 508 | ||
324 | return in_len; | 509 | return in_len; |
325 | 510 | ||
326 | err_idr: | 511 | err_copy: |
327 | idr_remove(&ib_uverbs_pd_idr, uobj->id); | 512 | idr_remove_uobj(&ib_uverbs_pd_idr, uobj); |
328 | 513 | ||
329 | err_up: | 514 | err_idr: |
330 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
331 | ib_dealloc_pd(pd); | 515 | ib_dealloc_pd(pd); |
332 | 516 | ||
333 | err: | 517 | err: |
334 | kfree(uobj); | 518 | put_uobj_write(uobj); |
335 | return ret; | 519 | return ret; |
336 | } | 520 | } |
337 | 521 | ||
@@ -340,37 +524,34 @@ ssize_t ib_uverbs_dealloc_pd(struct ib_uverbs_file *file, | |||
340 | int in_len, int out_len) | 524 | int in_len, int out_len) |
341 | { | 525 | { |
342 | struct ib_uverbs_dealloc_pd cmd; | 526 | struct ib_uverbs_dealloc_pd cmd; |
343 | struct ib_pd *pd; | ||
344 | struct ib_uobject *uobj; | 527 | struct ib_uobject *uobj; |
345 | int ret = -EINVAL; | 528 | int ret; |
346 | 529 | ||
347 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 530 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
348 | return -EFAULT; | 531 | return -EFAULT; |
349 | 532 | ||
350 | mutex_lock(&ib_uverbs_idr_mutex); | 533 | uobj = idr_write_uobj(&ib_uverbs_pd_idr, cmd.pd_handle, file->ucontext); |
534 | if (!uobj) | ||
535 | return -EINVAL; | ||
351 | 536 | ||
352 | pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle); | 537 | ret = ib_dealloc_pd(uobj->object); |
353 | if (!pd || pd->uobject->context != file->ucontext) | 538 | if (!ret) |
354 | goto out; | 539 | uobj->live = 0; |
355 | 540 | ||
356 | uobj = pd->uobject; | 541 | put_uobj_write(uobj); |
357 | 542 | ||
358 | ret = ib_dealloc_pd(pd); | ||
359 | if (ret) | 543 | if (ret) |
360 | goto out; | 544 | return ret; |
361 | 545 | ||
362 | idr_remove(&ib_uverbs_pd_idr, cmd.pd_handle); | 546 | idr_remove_uobj(&ib_uverbs_pd_idr, uobj); |
363 | 547 | ||
364 | mutex_lock(&file->mutex); | 548 | mutex_lock(&file->mutex); |
365 | list_del(&uobj->list); | 549 | list_del(&uobj->list); |
366 | mutex_unlock(&file->mutex); | 550 | mutex_unlock(&file->mutex); |
367 | 551 | ||
368 | kfree(uobj); | 552 | put_uobj(uobj); |
369 | |||
370 | out: | ||
371 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
372 | 553 | ||
373 | return ret ? ret : in_len; | 554 | return in_len; |
374 | } | 555 | } |
375 | 556 | ||
376 | ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file, | 557 | ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file, |
@@ -410,7 +591,8 @@ ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file, | |||
410 | if (!obj) | 591 | if (!obj) |
411 | return -ENOMEM; | 592 | return -ENOMEM; |
412 | 593 | ||
413 | obj->uobject.context = file->ucontext; | 594 | init_uobj(&obj->uobject, 0, file->ucontext); |
595 | down_write(&obj->uobject.mutex); | ||
414 | 596 | ||
415 | /* | 597 | /* |
416 | * We ask for writable memory if any access flags other than | 598 | * We ask for writable memory if any access flags other than |
@@ -427,23 +609,14 @@ ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file, | |||
427 | 609 | ||
428 | obj->umem.virt_base = cmd.hca_va; | 610 | obj->umem.virt_base = cmd.hca_va; |
429 | 611 | ||
430 | mutex_lock(&ib_uverbs_idr_mutex); | 612 | pd = idr_read_pd(cmd.pd_handle, file->ucontext); |
431 | 613 | if (!pd) | |
432 | pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle); | 614 | goto err_release; |
433 | if (!pd || pd->uobject->context != file->ucontext) { | ||
434 | ret = -EINVAL; | ||
435 | goto err_up; | ||
436 | } | ||
437 | |||
438 | if (!pd->device->reg_user_mr) { | ||
439 | ret = -ENOSYS; | ||
440 | goto err_up; | ||
441 | } | ||
442 | 615 | ||
443 | mr = pd->device->reg_user_mr(pd, &obj->umem, cmd.access_flags, &udata); | 616 | mr = pd->device->reg_user_mr(pd, &obj->umem, cmd.access_flags, &udata); |
444 | if (IS_ERR(mr)) { | 617 | if (IS_ERR(mr)) { |
445 | ret = PTR_ERR(mr); | 618 | ret = PTR_ERR(mr); |
446 | goto err_up; | 619 | goto err_put; |
447 | } | 620 | } |
448 | 621 | ||
449 | mr->device = pd->device; | 622 | mr->device = pd->device; |
@@ -452,53 +625,48 @@ ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file, | |||
452 | atomic_inc(&pd->usecnt); | 625 | atomic_inc(&pd->usecnt); |
453 | atomic_set(&mr->usecnt, 0); | 626 | atomic_set(&mr->usecnt, 0); |
454 | 627 | ||
455 | memset(&resp, 0, sizeof resp); | 628 | obj->uobject.object = mr; |
456 | resp.lkey = mr->lkey; | 629 | ret = idr_add_uobj(&ib_uverbs_mr_idr, &obj->uobject); |
457 | resp.rkey = mr->rkey; | ||
458 | |||
459 | retry: | ||
460 | if (!idr_pre_get(&ib_uverbs_mr_idr, GFP_KERNEL)) { | ||
461 | ret = -ENOMEM; | ||
462 | goto err_unreg; | ||
463 | } | ||
464 | |||
465 | ret = idr_get_new(&ib_uverbs_mr_idr, mr, &obj->uobject.id); | ||
466 | |||
467 | if (ret == -EAGAIN) | ||
468 | goto retry; | ||
469 | if (ret) | 630 | if (ret) |
470 | goto err_unreg; | 631 | goto err_unreg; |
471 | 632 | ||
633 | memset(&resp, 0, sizeof resp); | ||
634 | resp.lkey = mr->lkey; | ||
635 | resp.rkey = mr->rkey; | ||
472 | resp.mr_handle = obj->uobject.id; | 636 | resp.mr_handle = obj->uobject.id; |
473 | 637 | ||
474 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 638 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
475 | &resp, sizeof resp)) { | 639 | &resp, sizeof resp)) { |
476 | ret = -EFAULT; | 640 | ret = -EFAULT; |
477 | goto err_idr; | 641 | goto err_copy; |
478 | } | 642 | } |
479 | 643 | ||
644 | put_pd_read(pd); | ||
645 | |||
480 | mutex_lock(&file->mutex); | 646 | mutex_lock(&file->mutex); |
481 | list_add_tail(&obj->uobject.list, &file->ucontext->mr_list); | 647 | list_add_tail(&obj->uobject.list, &file->ucontext->mr_list); |
482 | mutex_unlock(&file->mutex); | 648 | mutex_unlock(&file->mutex); |
483 | 649 | ||
484 | mutex_unlock(&ib_uverbs_idr_mutex); | 650 | obj->uobject.live = 1; |
651 | |||
652 | up_write(&obj->uobject.mutex); | ||
485 | 653 | ||
486 | return in_len; | 654 | return in_len; |
487 | 655 | ||
488 | err_idr: | 656 | err_copy: |
489 | idr_remove(&ib_uverbs_mr_idr, obj->uobject.id); | 657 | idr_remove_uobj(&ib_uverbs_mr_idr, &obj->uobject); |
490 | 658 | ||
491 | err_unreg: | 659 | err_unreg: |
492 | ib_dereg_mr(mr); | 660 | ib_dereg_mr(mr); |
493 | atomic_dec(&pd->usecnt); | ||
494 | 661 | ||
495 | err_up: | 662 | err_put: |
496 | mutex_unlock(&ib_uverbs_idr_mutex); | 663 | put_pd_read(pd); |
497 | 664 | ||
665 | err_release: | ||
498 | ib_umem_release(file->device->ib_dev, &obj->umem); | 666 | ib_umem_release(file->device->ib_dev, &obj->umem); |
499 | 667 | ||
500 | err_free: | 668 | err_free: |
501 | kfree(obj); | 669 | put_uobj_write(&obj->uobject); |
502 | return ret; | 670 | return ret; |
503 | } | 671 | } |
504 | 672 | ||
@@ -508,37 +676,40 @@ ssize_t ib_uverbs_dereg_mr(struct ib_uverbs_file *file, | |||
508 | { | 676 | { |
509 | struct ib_uverbs_dereg_mr cmd; | 677 | struct ib_uverbs_dereg_mr cmd; |
510 | struct ib_mr *mr; | 678 | struct ib_mr *mr; |
679 | struct ib_uobject *uobj; | ||
511 | struct ib_umem_object *memobj; | 680 | struct ib_umem_object *memobj; |
512 | int ret = -EINVAL; | 681 | int ret = -EINVAL; |
513 | 682 | ||
514 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 683 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
515 | return -EFAULT; | 684 | return -EFAULT; |
516 | 685 | ||
517 | mutex_lock(&ib_uverbs_idr_mutex); | 686 | uobj = idr_write_uobj(&ib_uverbs_mr_idr, cmd.mr_handle, file->ucontext); |
518 | 687 | if (!uobj) | |
519 | mr = idr_find(&ib_uverbs_mr_idr, cmd.mr_handle); | 688 | return -EINVAL; |
520 | if (!mr || mr->uobject->context != file->ucontext) | ||
521 | goto out; | ||
522 | 689 | ||
523 | memobj = container_of(mr->uobject, struct ib_umem_object, uobject); | 690 | memobj = container_of(uobj, struct ib_umem_object, uobject); |
691 | mr = uobj->object; | ||
524 | 692 | ||
525 | ret = ib_dereg_mr(mr); | 693 | ret = ib_dereg_mr(mr); |
694 | if (!ret) | ||
695 | uobj->live = 0; | ||
696 | |||
697 | put_uobj_write(uobj); | ||
698 | |||
526 | if (ret) | 699 | if (ret) |
527 | goto out; | 700 | return ret; |
528 | 701 | ||
529 | idr_remove(&ib_uverbs_mr_idr, cmd.mr_handle); | 702 | idr_remove_uobj(&ib_uverbs_mr_idr, uobj); |
530 | 703 | ||
531 | mutex_lock(&file->mutex); | 704 | mutex_lock(&file->mutex); |
532 | list_del(&memobj->uobject.list); | 705 | list_del(&uobj->list); |
533 | mutex_unlock(&file->mutex); | 706 | mutex_unlock(&file->mutex); |
534 | 707 | ||
535 | ib_umem_release(file->device->ib_dev, &memobj->umem); | 708 | ib_umem_release(file->device->ib_dev, &memobj->umem); |
536 | kfree(memobj); | ||
537 | 709 | ||
538 | out: | 710 | put_uobj(uobj); |
539 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
540 | 711 | ||
541 | return ret ? ret : in_len; | 712 | return in_len; |
542 | } | 713 | } |
543 | 714 | ||
544 | ssize_t ib_uverbs_create_comp_channel(struct ib_uverbs_file *file, | 715 | ssize_t ib_uverbs_create_comp_channel(struct ib_uverbs_file *file, |
@@ -577,7 +748,7 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file, | |||
577 | struct ib_uverbs_create_cq cmd; | 748 | struct ib_uverbs_create_cq cmd; |
578 | struct ib_uverbs_create_cq_resp resp; | 749 | struct ib_uverbs_create_cq_resp resp; |
579 | struct ib_udata udata; | 750 | struct ib_udata udata; |
580 | struct ib_ucq_object *uobj; | 751 | struct ib_ucq_object *obj; |
581 | struct ib_uverbs_event_file *ev_file = NULL; | 752 | struct ib_uverbs_event_file *ev_file = NULL; |
582 | struct ib_cq *cq; | 753 | struct ib_cq *cq; |
583 | int ret; | 754 | int ret; |
@@ -595,10 +766,13 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file, | |||
595 | if (cmd.comp_vector >= file->device->num_comp_vectors) | 766 | if (cmd.comp_vector >= file->device->num_comp_vectors) |
596 | return -EINVAL; | 767 | return -EINVAL; |
597 | 768 | ||
598 | uobj = kmalloc(sizeof *uobj, GFP_KERNEL); | 769 | obj = kmalloc(sizeof *obj, GFP_KERNEL); |
599 | if (!uobj) | 770 | if (!obj) |
600 | return -ENOMEM; | 771 | return -ENOMEM; |
601 | 772 | ||
773 | init_uobj(&obj->uobject, cmd.user_handle, file->ucontext); | ||
774 | down_write(&obj->uobject.mutex); | ||
775 | |||
602 | if (cmd.comp_channel >= 0) { | 776 | if (cmd.comp_channel >= 0) { |
603 | ev_file = ib_uverbs_lookup_comp_file(cmd.comp_channel); | 777 | ev_file = ib_uverbs_lookup_comp_file(cmd.comp_channel); |
604 | if (!ev_file) { | 778 | if (!ev_file) { |
@@ -607,72 +781,64 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file, | |||
607 | } | 781 | } |
608 | } | 782 | } |
609 | 783 | ||
610 | uobj->uobject.user_handle = cmd.user_handle; | 784 | obj->uverbs_file = file; |
611 | uobj->uobject.context = file->ucontext; | 785 | obj->comp_events_reported = 0; |
612 | uobj->uverbs_file = file; | 786 | obj->async_events_reported = 0; |
613 | uobj->comp_events_reported = 0; | 787 | INIT_LIST_HEAD(&obj->comp_list); |
614 | uobj->async_events_reported = 0; | 788 | INIT_LIST_HEAD(&obj->async_list); |
615 | INIT_LIST_HEAD(&uobj->comp_list); | ||
616 | INIT_LIST_HEAD(&uobj->async_list); | ||
617 | 789 | ||
618 | cq = file->device->ib_dev->create_cq(file->device->ib_dev, cmd.cqe, | 790 | cq = file->device->ib_dev->create_cq(file->device->ib_dev, cmd.cqe, |
619 | file->ucontext, &udata); | 791 | file->ucontext, &udata); |
620 | if (IS_ERR(cq)) { | 792 | if (IS_ERR(cq)) { |
621 | ret = PTR_ERR(cq); | 793 | ret = PTR_ERR(cq); |
622 | goto err; | 794 | goto err_file; |
623 | } | 795 | } |
624 | 796 | ||
625 | cq->device = file->device->ib_dev; | 797 | cq->device = file->device->ib_dev; |
626 | cq->uobject = &uobj->uobject; | 798 | cq->uobject = &obj->uobject; |
627 | cq->comp_handler = ib_uverbs_comp_handler; | 799 | cq->comp_handler = ib_uverbs_comp_handler; |
628 | cq->event_handler = ib_uverbs_cq_event_handler; | 800 | cq->event_handler = ib_uverbs_cq_event_handler; |
629 | cq->cq_context = ev_file; | 801 | cq->cq_context = ev_file; |
630 | atomic_set(&cq->usecnt, 0); | 802 | atomic_set(&cq->usecnt, 0); |
631 | 803 | ||
632 | mutex_lock(&ib_uverbs_idr_mutex); | 804 | obj->uobject.object = cq; |
633 | 805 | ret = idr_add_uobj(&ib_uverbs_cq_idr, &obj->uobject); | |
634 | retry: | ||
635 | if (!idr_pre_get(&ib_uverbs_cq_idr, GFP_KERNEL)) { | ||
636 | ret = -ENOMEM; | ||
637 | goto err_up; | ||
638 | } | ||
639 | |||
640 | ret = idr_get_new(&ib_uverbs_cq_idr, cq, &uobj->uobject.id); | ||
641 | |||
642 | if (ret == -EAGAIN) | ||
643 | goto retry; | ||
644 | if (ret) | 806 | if (ret) |
645 | goto err_up; | 807 | goto err_free; |
646 | 808 | ||
647 | memset(&resp, 0, sizeof resp); | 809 | memset(&resp, 0, sizeof resp); |
648 | resp.cq_handle = uobj->uobject.id; | 810 | resp.cq_handle = obj->uobject.id; |
649 | resp.cqe = cq->cqe; | 811 | resp.cqe = cq->cqe; |
650 | 812 | ||
651 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 813 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
652 | &resp, sizeof resp)) { | 814 | &resp, sizeof resp)) { |
653 | ret = -EFAULT; | 815 | ret = -EFAULT; |
654 | goto err_idr; | 816 | goto err_copy; |
655 | } | 817 | } |
656 | 818 | ||
657 | mutex_lock(&file->mutex); | 819 | mutex_lock(&file->mutex); |
658 | list_add_tail(&uobj->uobject.list, &file->ucontext->cq_list); | 820 | list_add_tail(&obj->uobject.list, &file->ucontext->cq_list); |
659 | mutex_unlock(&file->mutex); | 821 | mutex_unlock(&file->mutex); |
660 | 822 | ||
661 | mutex_unlock(&ib_uverbs_idr_mutex); | 823 | obj->uobject.live = 1; |
824 | |||
825 | up_write(&obj->uobject.mutex); | ||
662 | 826 | ||
663 | return in_len; | 827 | return in_len; |
664 | 828 | ||
665 | err_idr: | 829 | err_copy: |
666 | idr_remove(&ib_uverbs_cq_idr, uobj->uobject.id); | 830 | idr_remove_uobj(&ib_uverbs_cq_idr, &obj->uobject); |
831 | |||
667 | 832 | ||
668 | err_up: | 833 | err_free: |
669 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
670 | ib_destroy_cq(cq); | 834 | ib_destroy_cq(cq); |
671 | 835 | ||
672 | err: | 836 | err_file: |
673 | if (ev_file) | 837 | if (ev_file) |
674 | ib_uverbs_release_ucq(file, ev_file, uobj); | 838 | ib_uverbs_release_ucq(file, ev_file, obj); |
675 | kfree(uobj); | 839 | |
840 | err: | ||
841 | put_uobj_write(&obj->uobject); | ||
676 | return ret; | 842 | return ret; |
677 | } | 843 | } |
678 | 844 | ||
@@ -693,11 +859,9 @@ ssize_t ib_uverbs_resize_cq(struct ib_uverbs_file *file, | |||
693 | (unsigned long) cmd.response + sizeof resp, | 859 | (unsigned long) cmd.response + sizeof resp, |
694 | in_len - sizeof cmd, out_len - sizeof resp); | 860 | in_len - sizeof cmd, out_len - sizeof resp); |
695 | 861 | ||
696 | mutex_lock(&ib_uverbs_idr_mutex); | 862 | cq = idr_read_cq(cmd.cq_handle, file->ucontext); |
697 | 863 | if (!cq) | |
698 | cq = idr_find(&ib_uverbs_cq_idr, cmd.cq_handle); | 864 | return -EINVAL; |
699 | if (!cq || cq->uobject->context != file->ucontext || !cq->device->resize_cq) | ||
700 | goto out; | ||
701 | 865 | ||
702 | ret = cq->device->resize_cq(cq, cmd.cqe, &udata); | 866 | ret = cq->device->resize_cq(cq, cmd.cqe, &udata); |
703 | if (ret) | 867 | if (ret) |
@@ -711,7 +875,7 @@ ssize_t ib_uverbs_resize_cq(struct ib_uverbs_file *file, | |||
711 | ret = -EFAULT; | 875 | ret = -EFAULT; |
712 | 876 | ||
713 | out: | 877 | out: |
714 | mutex_unlock(&ib_uverbs_idr_mutex); | 878 | put_cq_read(cq); |
715 | 879 | ||
716 | return ret ? ret : in_len; | 880 | return ret ? ret : in_len; |
717 | } | 881 | } |
@@ -722,6 +886,7 @@ ssize_t ib_uverbs_poll_cq(struct ib_uverbs_file *file, | |||
722 | { | 886 | { |
723 | struct ib_uverbs_poll_cq cmd; | 887 | struct ib_uverbs_poll_cq cmd; |
724 | struct ib_uverbs_poll_cq_resp *resp; | 888 | struct ib_uverbs_poll_cq_resp *resp; |
889 | struct ib_uobject *uobj; | ||
725 | struct ib_cq *cq; | 890 | struct ib_cq *cq; |
726 | struct ib_wc *wc; | 891 | struct ib_wc *wc; |
727 | int ret = 0; | 892 | int ret = 0; |
@@ -742,15 +907,17 @@ ssize_t ib_uverbs_poll_cq(struct ib_uverbs_file *file, | |||
742 | goto out_wc; | 907 | goto out_wc; |
743 | } | 908 | } |
744 | 909 | ||
745 | mutex_lock(&ib_uverbs_idr_mutex); | 910 | uobj = idr_read_uobj(&ib_uverbs_cq_idr, cmd.cq_handle, file->ucontext); |
746 | cq = idr_find(&ib_uverbs_cq_idr, cmd.cq_handle); | 911 | if (!uobj) { |
747 | if (!cq || cq->uobject->context != file->ucontext) { | ||
748 | ret = -EINVAL; | 912 | ret = -EINVAL; |
749 | goto out; | 913 | goto out; |
750 | } | 914 | } |
915 | cq = uobj->object; | ||
751 | 916 | ||
752 | resp->count = ib_poll_cq(cq, cmd.ne, wc); | 917 | resp->count = ib_poll_cq(cq, cmd.ne, wc); |
753 | 918 | ||
919 | put_uobj_read(uobj); | ||
920 | |||
754 | for (i = 0; i < resp->count; i++) { | 921 | for (i = 0; i < resp->count; i++) { |
755 | resp->wc[i].wr_id = wc[i].wr_id; | 922 | resp->wc[i].wr_id = wc[i].wr_id; |
756 | resp->wc[i].status = wc[i].status; | 923 | resp->wc[i].status = wc[i].status; |
@@ -772,7 +939,6 @@ ssize_t ib_uverbs_poll_cq(struct ib_uverbs_file *file, | |||
772 | ret = -EFAULT; | 939 | ret = -EFAULT; |
773 | 940 | ||
774 | out: | 941 | out: |
775 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
776 | kfree(resp); | 942 | kfree(resp); |
777 | 943 | ||
778 | out_wc: | 944 | out_wc: |
@@ -785,22 +951,23 @@ ssize_t ib_uverbs_req_notify_cq(struct ib_uverbs_file *file, | |||
785 | int out_len) | 951 | int out_len) |
786 | { | 952 | { |
787 | struct ib_uverbs_req_notify_cq cmd; | 953 | struct ib_uverbs_req_notify_cq cmd; |
954 | struct ib_uobject *uobj; | ||
788 | struct ib_cq *cq; | 955 | struct ib_cq *cq; |
789 | int ret = -EINVAL; | ||
790 | 956 | ||
791 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 957 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
792 | return -EFAULT; | 958 | return -EFAULT; |
793 | 959 | ||
794 | mutex_lock(&ib_uverbs_idr_mutex); | 960 | uobj = idr_read_uobj(&ib_uverbs_cq_idr, cmd.cq_handle, file->ucontext); |
795 | cq = idr_find(&ib_uverbs_cq_idr, cmd.cq_handle); | 961 | if (!uobj) |
796 | if (cq && cq->uobject->context == file->ucontext) { | 962 | return -EINVAL; |
797 | ib_req_notify_cq(cq, cmd.solicited_only ? | 963 | cq = uobj->object; |
798 | IB_CQ_SOLICITED : IB_CQ_NEXT_COMP); | ||
799 | ret = in_len; | ||
800 | } | ||
801 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
802 | 964 | ||
803 | return ret; | 965 | ib_req_notify_cq(cq, cmd.solicited_only ? |
966 | IB_CQ_SOLICITED : IB_CQ_NEXT_COMP); | ||
967 | |||
968 | put_uobj_read(uobj); | ||
969 | |||
970 | return in_len; | ||
804 | } | 971 | } |
805 | 972 | ||
806 | ssize_t ib_uverbs_destroy_cq(struct ib_uverbs_file *file, | 973 | ssize_t ib_uverbs_destroy_cq(struct ib_uverbs_file *file, |
@@ -809,52 +976,50 @@ ssize_t ib_uverbs_destroy_cq(struct ib_uverbs_file *file, | |||
809 | { | 976 | { |
810 | struct ib_uverbs_destroy_cq cmd; | 977 | struct ib_uverbs_destroy_cq cmd; |
811 | struct ib_uverbs_destroy_cq_resp resp; | 978 | struct ib_uverbs_destroy_cq_resp resp; |
979 | struct ib_uobject *uobj; | ||
812 | struct ib_cq *cq; | 980 | struct ib_cq *cq; |
813 | struct ib_ucq_object *uobj; | 981 | struct ib_ucq_object *obj; |
814 | struct ib_uverbs_event_file *ev_file; | 982 | struct ib_uverbs_event_file *ev_file; |
815 | u64 user_handle; | ||
816 | int ret = -EINVAL; | 983 | int ret = -EINVAL; |
817 | 984 | ||
818 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 985 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
819 | return -EFAULT; | 986 | return -EFAULT; |
820 | 987 | ||
821 | memset(&resp, 0, sizeof resp); | 988 | uobj = idr_write_uobj(&ib_uverbs_cq_idr, cmd.cq_handle, file->ucontext); |
822 | 989 | if (!uobj) | |
823 | mutex_lock(&ib_uverbs_idr_mutex); | 990 | return -EINVAL; |
991 | cq = uobj->object; | ||
992 | ev_file = cq->cq_context; | ||
993 | obj = container_of(cq->uobject, struct ib_ucq_object, uobject); | ||
824 | 994 | ||
825 | cq = idr_find(&ib_uverbs_cq_idr, cmd.cq_handle); | 995 | ret = ib_destroy_cq(cq); |
826 | if (!cq || cq->uobject->context != file->ucontext) | 996 | if (!ret) |
827 | goto out; | 997 | uobj->live = 0; |
828 | 998 | ||
829 | user_handle = cq->uobject->user_handle; | 999 | put_uobj_write(uobj); |
830 | uobj = container_of(cq->uobject, struct ib_ucq_object, uobject); | ||
831 | ev_file = cq->cq_context; | ||
832 | 1000 | ||
833 | ret = ib_destroy_cq(cq); | ||
834 | if (ret) | 1001 | if (ret) |
835 | goto out; | 1002 | return ret; |
836 | 1003 | ||
837 | idr_remove(&ib_uverbs_cq_idr, cmd.cq_handle); | 1004 | idr_remove_uobj(&ib_uverbs_cq_idr, uobj); |
838 | 1005 | ||
839 | mutex_lock(&file->mutex); | 1006 | mutex_lock(&file->mutex); |
840 | list_del(&uobj->uobject.list); | 1007 | list_del(&uobj->list); |
841 | mutex_unlock(&file->mutex); | 1008 | mutex_unlock(&file->mutex); |
842 | 1009 | ||
843 | ib_uverbs_release_ucq(file, ev_file, uobj); | 1010 | ib_uverbs_release_ucq(file, ev_file, obj); |
844 | 1011 | ||
845 | resp.comp_events_reported = uobj->comp_events_reported; | 1012 | memset(&resp, 0, sizeof resp); |
846 | resp.async_events_reported = uobj->async_events_reported; | 1013 | resp.comp_events_reported = obj->comp_events_reported; |
1014 | resp.async_events_reported = obj->async_events_reported; | ||
847 | 1015 | ||
848 | kfree(uobj); | 1016 | put_uobj(uobj); |
849 | 1017 | ||
850 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 1018 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
851 | &resp, sizeof resp)) | 1019 | &resp, sizeof resp)) |
852 | ret = -EFAULT; | 1020 | return -EFAULT; |
853 | |||
854 | out: | ||
855 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
856 | 1021 | ||
857 | return ret ? ret : in_len; | 1022 | return in_len; |
858 | } | 1023 | } |
859 | 1024 | ||
860 | ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file, | 1025 | ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file, |
@@ -864,7 +1029,7 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file, | |||
864 | struct ib_uverbs_create_qp cmd; | 1029 | struct ib_uverbs_create_qp cmd; |
865 | struct ib_uverbs_create_qp_resp resp; | 1030 | struct ib_uverbs_create_qp_resp resp; |
866 | struct ib_udata udata; | 1031 | struct ib_udata udata; |
867 | struct ib_uqp_object *uobj; | 1032 | struct ib_uqp_object *obj; |
868 | struct ib_pd *pd; | 1033 | struct ib_pd *pd; |
869 | struct ib_cq *scq, *rcq; | 1034 | struct ib_cq *scq, *rcq; |
870 | struct ib_srq *srq; | 1035 | struct ib_srq *srq; |
@@ -882,23 +1047,21 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file, | |||
882 | (unsigned long) cmd.response + sizeof resp, | 1047 | (unsigned long) cmd.response + sizeof resp, |
883 | in_len - sizeof cmd, out_len - sizeof resp); | 1048 | in_len - sizeof cmd, out_len - sizeof resp); |
884 | 1049 | ||
885 | uobj = kmalloc(sizeof *uobj, GFP_KERNEL); | 1050 | obj = kmalloc(sizeof *obj, GFP_KERNEL); |
886 | if (!uobj) | 1051 | if (!obj) |
887 | return -ENOMEM; | 1052 | return -ENOMEM; |
888 | 1053 | ||
889 | mutex_lock(&ib_uverbs_idr_mutex); | 1054 | init_uobj(&obj->uevent.uobject, cmd.user_handle, file->ucontext); |
1055 | down_write(&obj->uevent.uobject.mutex); | ||
890 | 1056 | ||
891 | pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle); | 1057 | pd = idr_read_pd(cmd.pd_handle, file->ucontext); |
892 | scq = idr_find(&ib_uverbs_cq_idr, cmd.send_cq_handle); | 1058 | scq = idr_read_cq(cmd.send_cq_handle, file->ucontext); |
893 | rcq = idr_find(&ib_uverbs_cq_idr, cmd.recv_cq_handle); | 1059 | rcq = idr_read_cq(cmd.recv_cq_handle, file->ucontext); |
894 | srq = cmd.is_srq ? idr_find(&ib_uverbs_srq_idr, cmd.srq_handle) : NULL; | 1060 | srq = cmd.is_srq ? idr_read_srq(cmd.srq_handle, file->ucontext) : NULL; |
895 | 1061 | ||
896 | if (!pd || pd->uobject->context != file->ucontext || | 1062 | if (!pd || !scq || !rcq || (cmd.is_srq && !srq)) { |
897 | !scq || scq->uobject->context != file->ucontext || | ||
898 | !rcq || rcq->uobject->context != file->ucontext || | ||
899 | (cmd.is_srq && (!srq || srq->uobject->context != file->ucontext))) { | ||
900 | ret = -EINVAL; | 1063 | ret = -EINVAL; |
901 | goto err_up; | 1064 | goto err_put; |
902 | } | 1065 | } |
903 | 1066 | ||
904 | attr.event_handler = ib_uverbs_qp_event_handler; | 1067 | attr.event_handler = ib_uverbs_qp_event_handler; |
@@ -915,16 +1078,14 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file, | |||
915 | attr.cap.max_recv_sge = cmd.max_recv_sge; | 1078 | attr.cap.max_recv_sge = cmd.max_recv_sge; |
916 | attr.cap.max_inline_data = cmd.max_inline_data; | 1079 | attr.cap.max_inline_data = cmd.max_inline_data; |
917 | 1080 | ||
918 | uobj->uevent.uobject.user_handle = cmd.user_handle; | 1081 | obj->uevent.events_reported = 0; |
919 | uobj->uevent.uobject.context = file->ucontext; | 1082 | INIT_LIST_HEAD(&obj->uevent.event_list); |
920 | uobj->uevent.events_reported = 0; | 1083 | INIT_LIST_HEAD(&obj->mcast_list); |
921 | INIT_LIST_HEAD(&uobj->uevent.event_list); | ||
922 | INIT_LIST_HEAD(&uobj->mcast_list); | ||
923 | 1084 | ||
924 | qp = pd->device->create_qp(pd, &attr, &udata); | 1085 | qp = pd->device->create_qp(pd, &attr, &udata); |
925 | if (IS_ERR(qp)) { | 1086 | if (IS_ERR(qp)) { |
926 | ret = PTR_ERR(qp); | 1087 | ret = PTR_ERR(qp); |
927 | goto err_up; | 1088 | goto err_put; |
928 | } | 1089 | } |
929 | 1090 | ||
930 | qp->device = pd->device; | 1091 | qp->device = pd->device; |
@@ -932,7 +1093,7 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file, | |||
932 | qp->send_cq = attr.send_cq; | 1093 | qp->send_cq = attr.send_cq; |
933 | qp->recv_cq = attr.recv_cq; | 1094 | qp->recv_cq = attr.recv_cq; |
934 | qp->srq = attr.srq; | 1095 | qp->srq = attr.srq; |
935 | qp->uobject = &uobj->uevent.uobject; | 1096 | qp->uobject = &obj->uevent.uobject; |
936 | qp->event_handler = attr.event_handler; | 1097 | qp->event_handler = attr.event_handler; |
937 | qp->qp_context = attr.qp_context; | 1098 | qp->qp_context = attr.qp_context; |
938 | qp->qp_type = attr.qp_type; | 1099 | qp->qp_type = attr.qp_type; |
@@ -942,23 +1103,14 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file, | |||
942 | if (attr.srq) | 1103 | if (attr.srq) |
943 | atomic_inc(&attr.srq->usecnt); | 1104 | atomic_inc(&attr.srq->usecnt); |
944 | 1105 | ||
945 | memset(&resp, 0, sizeof resp); | 1106 | obj->uevent.uobject.object = qp; |
946 | resp.qpn = qp->qp_num; | 1107 | ret = idr_add_uobj(&ib_uverbs_qp_idr, &obj->uevent.uobject); |
947 | |||
948 | retry: | ||
949 | if (!idr_pre_get(&ib_uverbs_qp_idr, GFP_KERNEL)) { | ||
950 | ret = -ENOMEM; | ||
951 | goto err_destroy; | ||
952 | } | ||
953 | |||
954 | ret = idr_get_new(&ib_uverbs_qp_idr, qp, &uobj->uevent.uobject.id); | ||
955 | |||
956 | if (ret == -EAGAIN) | ||
957 | goto retry; | ||
958 | if (ret) | 1108 | if (ret) |
959 | goto err_destroy; | 1109 | goto err_destroy; |
960 | 1110 | ||
961 | resp.qp_handle = uobj->uevent.uobject.id; | 1111 | memset(&resp, 0, sizeof resp); |
1112 | resp.qpn = qp->qp_num; | ||
1113 | resp.qp_handle = obj->uevent.uobject.id; | ||
962 | resp.max_recv_sge = attr.cap.max_recv_sge; | 1114 | resp.max_recv_sge = attr.cap.max_recv_sge; |
963 | resp.max_send_sge = attr.cap.max_send_sge; | 1115 | resp.max_send_sge = attr.cap.max_send_sge; |
964 | resp.max_recv_wr = attr.cap.max_recv_wr; | 1116 | resp.max_recv_wr = attr.cap.max_recv_wr; |
@@ -968,32 +1120,42 @@ retry: | |||
968 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 1120 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
969 | &resp, sizeof resp)) { | 1121 | &resp, sizeof resp)) { |
970 | ret = -EFAULT; | 1122 | ret = -EFAULT; |
971 | goto err_idr; | 1123 | goto err_copy; |
972 | } | 1124 | } |
973 | 1125 | ||
1126 | put_pd_read(pd); | ||
1127 | put_cq_read(scq); | ||
1128 | put_cq_read(rcq); | ||
1129 | if (srq) | ||
1130 | put_srq_read(srq); | ||
1131 | |||
974 | mutex_lock(&file->mutex); | 1132 | mutex_lock(&file->mutex); |
975 | list_add_tail(&uobj->uevent.uobject.list, &file->ucontext->qp_list); | 1133 | list_add_tail(&obj->uevent.uobject.list, &file->ucontext->qp_list); |
976 | mutex_unlock(&file->mutex); | 1134 | mutex_unlock(&file->mutex); |
977 | 1135 | ||
978 | mutex_unlock(&ib_uverbs_idr_mutex); | 1136 | obj->uevent.uobject.live = 1; |
1137 | |||
1138 | up_write(&obj->uevent.uobject.mutex); | ||
979 | 1139 | ||
980 | return in_len; | 1140 | return in_len; |
981 | 1141 | ||
982 | err_idr: | 1142 | err_copy: |
983 | idr_remove(&ib_uverbs_qp_idr, uobj->uevent.uobject.id); | 1143 | idr_remove_uobj(&ib_uverbs_qp_idr, &obj->uevent.uobject); |
984 | 1144 | ||
985 | err_destroy: | 1145 | err_destroy: |
986 | ib_destroy_qp(qp); | 1146 | ib_destroy_qp(qp); |
987 | atomic_dec(&pd->usecnt); | ||
988 | atomic_dec(&attr.send_cq->usecnt); | ||
989 | atomic_dec(&attr.recv_cq->usecnt); | ||
990 | if (attr.srq) | ||
991 | atomic_dec(&attr.srq->usecnt); | ||
992 | |||
993 | err_up: | ||
994 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
995 | 1147 | ||
996 | kfree(uobj); | 1148 | err_put: |
1149 | if (pd) | ||
1150 | put_pd_read(pd); | ||
1151 | if (scq) | ||
1152 | put_cq_read(scq); | ||
1153 | if (rcq) | ||
1154 | put_cq_read(rcq); | ||
1155 | if (srq) | ||
1156 | put_srq_read(srq); | ||
1157 | |||
1158 | put_uobj_write(&obj->uevent.uobject); | ||
997 | return ret; | 1159 | return ret; |
998 | } | 1160 | } |
999 | 1161 | ||
@@ -1018,15 +1180,15 @@ ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file, | |||
1018 | goto out; | 1180 | goto out; |
1019 | } | 1181 | } |
1020 | 1182 | ||
1021 | mutex_lock(&ib_uverbs_idr_mutex); | 1183 | qp = idr_read_qp(cmd.qp_handle, file->ucontext); |
1022 | 1184 | if (!qp) { | |
1023 | qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle); | ||
1024 | if (qp && qp->uobject->context == file->ucontext) | ||
1025 | ret = ib_query_qp(qp, attr, cmd.attr_mask, init_attr); | ||
1026 | else | ||
1027 | ret = -EINVAL; | 1185 | ret = -EINVAL; |
1186 | goto out; | ||
1187 | } | ||
1028 | 1188 | ||
1029 | mutex_unlock(&ib_uverbs_idr_mutex); | 1189 | ret = ib_query_qp(qp, attr, cmd.attr_mask, init_attr); |
1190 | |||
1191 | put_qp_read(qp); | ||
1030 | 1192 | ||
1031 | if (ret) | 1193 | if (ret) |
1032 | goto out; | 1194 | goto out; |
@@ -1113,10 +1275,8 @@ ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file, | |||
1113 | if (!attr) | 1275 | if (!attr) |
1114 | return -ENOMEM; | 1276 | return -ENOMEM; |
1115 | 1277 | ||
1116 | mutex_lock(&ib_uverbs_idr_mutex); | 1278 | qp = idr_read_qp(cmd.qp_handle, file->ucontext); |
1117 | 1279 | if (!qp) { | |
1118 | qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle); | ||
1119 | if (!qp || qp->uobject->context != file->ucontext) { | ||
1120 | ret = -EINVAL; | 1280 | ret = -EINVAL; |
1121 | goto out; | 1281 | goto out; |
1122 | } | 1282 | } |
@@ -1168,13 +1328,15 @@ ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file, | |||
1168 | attr->alt_ah_attr.port_num = cmd.alt_dest.port_num; | 1328 | attr->alt_ah_attr.port_num = cmd.alt_dest.port_num; |
1169 | 1329 | ||
1170 | ret = ib_modify_qp(qp, attr, cmd.attr_mask); | 1330 | ret = ib_modify_qp(qp, attr, cmd.attr_mask); |
1331 | |||
1332 | put_qp_read(qp); | ||
1333 | |||
1171 | if (ret) | 1334 | if (ret) |
1172 | goto out; | 1335 | goto out; |
1173 | 1336 | ||
1174 | ret = in_len; | 1337 | ret = in_len; |
1175 | 1338 | ||
1176 | out: | 1339 | out: |
1177 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
1178 | kfree(attr); | 1340 | kfree(attr); |
1179 | 1341 | ||
1180 | return ret; | 1342 | return ret; |
@@ -1186,8 +1348,9 @@ ssize_t ib_uverbs_destroy_qp(struct ib_uverbs_file *file, | |||
1186 | { | 1348 | { |
1187 | struct ib_uverbs_destroy_qp cmd; | 1349 | struct ib_uverbs_destroy_qp cmd; |
1188 | struct ib_uverbs_destroy_qp_resp resp; | 1350 | struct ib_uverbs_destroy_qp_resp resp; |
1351 | struct ib_uobject *uobj; | ||
1189 | struct ib_qp *qp; | 1352 | struct ib_qp *qp; |
1190 | struct ib_uqp_object *uobj; | 1353 | struct ib_uqp_object *obj; |
1191 | int ret = -EINVAL; | 1354 | int ret = -EINVAL; |
1192 | 1355 | ||
1193 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 1356 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
@@ -1195,43 +1358,43 @@ ssize_t ib_uverbs_destroy_qp(struct ib_uverbs_file *file, | |||
1195 | 1358 | ||
1196 | memset(&resp, 0, sizeof resp); | 1359 | memset(&resp, 0, sizeof resp); |
1197 | 1360 | ||
1198 | mutex_lock(&ib_uverbs_idr_mutex); | 1361 | uobj = idr_write_uobj(&ib_uverbs_qp_idr, cmd.qp_handle, file->ucontext); |
1199 | 1362 | if (!uobj) | |
1200 | qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle); | 1363 | return -EINVAL; |
1201 | if (!qp || qp->uobject->context != file->ucontext) | 1364 | qp = uobj->object; |
1202 | goto out; | 1365 | obj = container_of(uobj, struct ib_uqp_object, uevent.uobject); |
1203 | |||
1204 | uobj = container_of(qp->uobject, struct ib_uqp_object, uevent.uobject); | ||
1205 | 1366 | ||
1206 | if (!list_empty(&uobj->mcast_list)) { | 1367 | if (!list_empty(&obj->mcast_list)) { |
1207 | ret = -EBUSY; | 1368 | put_uobj_write(uobj); |
1208 | goto out; | 1369 | return -EBUSY; |
1209 | } | 1370 | } |
1210 | 1371 | ||
1211 | ret = ib_destroy_qp(qp); | 1372 | ret = ib_destroy_qp(qp); |
1373 | if (!ret) | ||
1374 | uobj->live = 0; | ||
1375 | |||
1376 | put_uobj_write(uobj); | ||
1377 | |||
1212 | if (ret) | 1378 | if (ret) |
1213 | goto out; | 1379 | return ret; |
1214 | 1380 | ||
1215 | idr_remove(&ib_uverbs_qp_idr, cmd.qp_handle); | 1381 | idr_remove_uobj(&ib_uverbs_qp_idr, uobj); |
1216 | 1382 | ||
1217 | mutex_lock(&file->mutex); | 1383 | mutex_lock(&file->mutex); |
1218 | list_del(&uobj->uevent.uobject.list); | 1384 | list_del(&uobj->list); |
1219 | mutex_unlock(&file->mutex); | 1385 | mutex_unlock(&file->mutex); |
1220 | 1386 | ||
1221 | ib_uverbs_release_uevent(file, &uobj->uevent); | 1387 | ib_uverbs_release_uevent(file, &obj->uevent); |
1222 | 1388 | ||
1223 | resp.events_reported = uobj->uevent.events_reported; | 1389 | resp.events_reported = obj->uevent.events_reported; |
1224 | 1390 | ||
1225 | kfree(uobj); | 1391 | put_uobj(uobj); |
1226 | 1392 | ||
1227 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 1393 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
1228 | &resp, sizeof resp)) | 1394 | &resp, sizeof resp)) |
1229 | ret = -EFAULT; | 1395 | return -EFAULT; |
1230 | |||
1231 | out: | ||
1232 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
1233 | 1396 | ||
1234 | return ret ? ret : in_len; | 1397 | return in_len; |
1235 | } | 1398 | } |
1236 | 1399 | ||
1237 | ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | 1400 | ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, |
@@ -1244,6 +1407,7 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | |||
1244 | struct ib_send_wr *wr = NULL, *last, *next, *bad_wr; | 1407 | struct ib_send_wr *wr = NULL, *last, *next, *bad_wr; |
1245 | struct ib_qp *qp; | 1408 | struct ib_qp *qp; |
1246 | int i, sg_ind; | 1409 | int i, sg_ind; |
1410 | int is_ud; | ||
1247 | ssize_t ret = -EINVAL; | 1411 | ssize_t ret = -EINVAL; |
1248 | 1412 | ||
1249 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 1413 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
@@ -1260,12 +1424,11 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | |||
1260 | if (!user_wr) | 1424 | if (!user_wr) |
1261 | return -ENOMEM; | 1425 | return -ENOMEM; |
1262 | 1426 | ||
1263 | mutex_lock(&ib_uverbs_idr_mutex); | 1427 | qp = idr_read_qp(cmd.qp_handle, file->ucontext); |
1264 | 1428 | if (!qp) | |
1265 | qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle); | ||
1266 | if (!qp || qp->uobject->context != file->ucontext) | ||
1267 | goto out; | 1429 | goto out; |
1268 | 1430 | ||
1431 | is_ud = qp->qp_type == IB_QPT_UD; | ||
1269 | sg_ind = 0; | 1432 | sg_ind = 0; |
1270 | last = NULL; | 1433 | last = NULL; |
1271 | for (i = 0; i < cmd.wr_count; ++i) { | 1434 | for (i = 0; i < cmd.wr_count; ++i) { |
@@ -1273,12 +1436,12 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | |||
1273 | buf + sizeof cmd + i * cmd.wqe_size, | 1436 | buf + sizeof cmd + i * cmd.wqe_size, |
1274 | cmd.wqe_size)) { | 1437 | cmd.wqe_size)) { |
1275 | ret = -EFAULT; | 1438 | ret = -EFAULT; |
1276 | goto out; | 1439 | goto out_put; |
1277 | } | 1440 | } |
1278 | 1441 | ||
1279 | if (user_wr->num_sge + sg_ind > cmd.sge_count) { | 1442 | if (user_wr->num_sge + sg_ind > cmd.sge_count) { |
1280 | ret = -EINVAL; | 1443 | ret = -EINVAL; |
1281 | goto out; | 1444 | goto out_put; |
1282 | } | 1445 | } |
1283 | 1446 | ||
1284 | next = kmalloc(ALIGN(sizeof *next, sizeof (struct ib_sge)) + | 1447 | next = kmalloc(ALIGN(sizeof *next, sizeof (struct ib_sge)) + |
@@ -1286,7 +1449,7 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | |||
1286 | GFP_KERNEL); | 1449 | GFP_KERNEL); |
1287 | if (!next) { | 1450 | if (!next) { |
1288 | ret = -ENOMEM; | 1451 | ret = -ENOMEM; |
1289 | goto out; | 1452 | goto out_put; |
1290 | } | 1453 | } |
1291 | 1454 | ||
1292 | if (!last) | 1455 | if (!last) |
@@ -1302,12 +1465,12 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | |||
1302 | next->send_flags = user_wr->send_flags; | 1465 | next->send_flags = user_wr->send_flags; |
1303 | next->imm_data = (__be32 __force) user_wr->imm_data; | 1466 | next->imm_data = (__be32 __force) user_wr->imm_data; |
1304 | 1467 | ||
1305 | if (qp->qp_type == IB_QPT_UD) { | 1468 | if (is_ud) { |
1306 | next->wr.ud.ah = idr_find(&ib_uverbs_ah_idr, | 1469 | next->wr.ud.ah = idr_read_ah(user_wr->wr.ud.ah, |
1307 | user_wr->wr.ud.ah); | 1470 | file->ucontext); |
1308 | if (!next->wr.ud.ah) { | 1471 | if (!next->wr.ud.ah) { |
1309 | ret = -EINVAL; | 1472 | ret = -EINVAL; |
1310 | goto out; | 1473 | goto out_put; |
1311 | } | 1474 | } |
1312 | next->wr.ud.remote_qpn = user_wr->wr.ud.remote_qpn; | 1475 | next->wr.ud.remote_qpn = user_wr->wr.ud.remote_qpn; |
1313 | next->wr.ud.remote_qkey = user_wr->wr.ud.remote_qkey; | 1476 | next->wr.ud.remote_qkey = user_wr->wr.ud.remote_qkey; |
@@ -1344,7 +1507,7 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | |||
1344 | sg_ind * sizeof (struct ib_sge), | 1507 | sg_ind * sizeof (struct ib_sge), |
1345 | next->num_sge * sizeof (struct ib_sge))) { | 1508 | next->num_sge * sizeof (struct ib_sge))) { |
1346 | ret = -EFAULT; | 1509 | ret = -EFAULT; |
1347 | goto out; | 1510 | goto out_put; |
1348 | } | 1511 | } |
1349 | sg_ind += next->num_sge; | 1512 | sg_ind += next->num_sge; |
1350 | } else | 1513 | } else |
@@ -1364,10 +1527,13 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file, | |||
1364 | &resp, sizeof resp)) | 1527 | &resp, sizeof resp)) |
1365 | ret = -EFAULT; | 1528 | ret = -EFAULT; |
1366 | 1529 | ||
1367 | out: | 1530 | out_put: |
1368 | mutex_unlock(&ib_uverbs_idr_mutex); | 1531 | put_qp_read(qp); |
1369 | 1532 | ||
1533 | out: | ||
1370 | while (wr) { | 1534 | while (wr) { |
1535 | if (is_ud && wr->wr.ud.ah) | ||
1536 | put_ah_read(wr->wr.ud.ah); | ||
1371 | next = wr->next; | 1537 | next = wr->next; |
1372 | kfree(wr); | 1538 | kfree(wr); |
1373 | wr = next; | 1539 | wr = next; |
@@ -1482,14 +1648,15 @@ ssize_t ib_uverbs_post_recv(struct ib_uverbs_file *file, | |||
1482 | if (IS_ERR(wr)) | 1648 | if (IS_ERR(wr)) |
1483 | return PTR_ERR(wr); | 1649 | return PTR_ERR(wr); |
1484 | 1650 | ||
1485 | mutex_lock(&ib_uverbs_idr_mutex); | 1651 | qp = idr_read_qp(cmd.qp_handle, file->ucontext); |
1486 | 1652 | if (!qp) | |
1487 | qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle); | ||
1488 | if (!qp || qp->uobject->context != file->ucontext) | ||
1489 | goto out; | 1653 | goto out; |
1490 | 1654 | ||
1491 | resp.bad_wr = 0; | 1655 | resp.bad_wr = 0; |
1492 | ret = qp->device->post_recv(qp, wr, &bad_wr); | 1656 | ret = qp->device->post_recv(qp, wr, &bad_wr); |
1657 | |||
1658 | put_qp_read(qp); | ||
1659 | |||
1493 | if (ret) | 1660 | if (ret) |
1494 | for (next = wr; next; next = next->next) { | 1661 | for (next = wr; next; next = next->next) { |
1495 | ++resp.bad_wr; | 1662 | ++resp.bad_wr; |
@@ -1503,8 +1670,6 @@ ssize_t ib_uverbs_post_recv(struct ib_uverbs_file *file, | |||
1503 | ret = -EFAULT; | 1670 | ret = -EFAULT; |
1504 | 1671 | ||
1505 | out: | 1672 | out: |
1506 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
1507 | |||
1508 | while (wr) { | 1673 | while (wr) { |
1509 | next = wr->next; | 1674 | next = wr->next; |
1510 | kfree(wr); | 1675 | kfree(wr); |
@@ -1533,14 +1698,15 @@ ssize_t ib_uverbs_post_srq_recv(struct ib_uverbs_file *file, | |||
1533 | if (IS_ERR(wr)) | 1698 | if (IS_ERR(wr)) |
1534 | return PTR_ERR(wr); | 1699 | return PTR_ERR(wr); |
1535 | 1700 | ||
1536 | mutex_lock(&ib_uverbs_idr_mutex); | 1701 | srq = idr_read_srq(cmd.srq_handle, file->ucontext); |
1537 | 1702 | if (!srq) | |
1538 | srq = idr_find(&ib_uverbs_srq_idr, cmd.srq_handle); | ||
1539 | if (!srq || srq->uobject->context != file->ucontext) | ||
1540 | goto out; | 1703 | goto out; |
1541 | 1704 | ||
1542 | resp.bad_wr = 0; | 1705 | resp.bad_wr = 0; |
1543 | ret = srq->device->post_srq_recv(srq, wr, &bad_wr); | 1706 | ret = srq->device->post_srq_recv(srq, wr, &bad_wr); |
1707 | |||
1708 | put_srq_read(srq); | ||
1709 | |||
1544 | if (ret) | 1710 | if (ret) |
1545 | for (next = wr; next; next = next->next) { | 1711 | for (next = wr; next; next = next->next) { |
1546 | ++resp.bad_wr; | 1712 | ++resp.bad_wr; |
@@ -1554,8 +1720,6 @@ ssize_t ib_uverbs_post_srq_recv(struct ib_uverbs_file *file, | |||
1554 | ret = -EFAULT; | 1720 | ret = -EFAULT; |
1555 | 1721 | ||
1556 | out: | 1722 | out: |
1557 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
1558 | |||
1559 | while (wr) { | 1723 | while (wr) { |
1560 | next = wr->next; | 1724 | next = wr->next; |
1561 | kfree(wr); | 1725 | kfree(wr); |
@@ -1587,17 +1751,15 @@ ssize_t ib_uverbs_create_ah(struct ib_uverbs_file *file, | |||
1587 | if (!uobj) | 1751 | if (!uobj) |
1588 | return -ENOMEM; | 1752 | return -ENOMEM; |
1589 | 1753 | ||
1590 | mutex_lock(&ib_uverbs_idr_mutex); | 1754 | init_uobj(uobj, cmd.user_handle, file->ucontext); |
1755 | down_write(&uobj->mutex); | ||
1591 | 1756 | ||
1592 | pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle); | 1757 | pd = idr_read_pd(cmd.pd_handle, file->ucontext); |
1593 | if (!pd || pd->uobject->context != file->ucontext) { | 1758 | if (!pd) { |
1594 | ret = -EINVAL; | 1759 | ret = -EINVAL; |
1595 | goto err_up; | 1760 | goto err; |
1596 | } | 1761 | } |
1597 | 1762 | ||
1598 | uobj->user_handle = cmd.user_handle; | ||
1599 | uobj->context = file->ucontext; | ||
1600 | |||
1601 | attr.dlid = cmd.attr.dlid; | 1763 | attr.dlid = cmd.attr.dlid; |
1602 | attr.sl = cmd.attr.sl; | 1764 | attr.sl = cmd.attr.sl; |
1603 | attr.src_path_bits = cmd.attr.src_path_bits; | 1765 | attr.src_path_bits = cmd.attr.src_path_bits; |
@@ -1613,21 +1775,13 @@ ssize_t ib_uverbs_create_ah(struct ib_uverbs_file *file, | |||
1613 | ah = ib_create_ah(pd, &attr); | 1775 | ah = ib_create_ah(pd, &attr); |
1614 | if (IS_ERR(ah)) { | 1776 | if (IS_ERR(ah)) { |
1615 | ret = PTR_ERR(ah); | 1777 | ret = PTR_ERR(ah); |
1616 | goto err_up; | 1778 | goto err; |
1617 | } | ||
1618 | |||
1619 | ah->uobject = uobj; | ||
1620 | |||
1621 | retry: | ||
1622 | if (!idr_pre_get(&ib_uverbs_ah_idr, GFP_KERNEL)) { | ||
1623 | ret = -ENOMEM; | ||
1624 | goto err_destroy; | ||
1625 | } | 1779 | } |
1626 | 1780 | ||
1627 | ret = idr_get_new(&ib_uverbs_ah_idr, ah, &uobj->id); | 1781 | ah->uobject = uobj; |
1782 | uobj->object = ah; | ||
1628 | 1783 | ||
1629 | if (ret == -EAGAIN) | 1784 | ret = idr_add_uobj(&ib_uverbs_ah_idr, uobj); |
1630 | goto retry; | ||
1631 | if (ret) | 1785 | if (ret) |
1632 | goto err_destroy; | 1786 | goto err_destroy; |
1633 | 1787 | ||
@@ -1636,27 +1790,29 @@ retry: | |||
1636 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 1790 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
1637 | &resp, sizeof resp)) { | 1791 | &resp, sizeof resp)) { |
1638 | ret = -EFAULT; | 1792 | ret = -EFAULT; |
1639 | goto err_idr; | 1793 | goto err_copy; |
1640 | } | 1794 | } |
1641 | 1795 | ||
1796 | put_pd_read(pd); | ||
1797 | |||
1642 | mutex_lock(&file->mutex); | 1798 | mutex_lock(&file->mutex); |
1643 | list_add_tail(&uobj->list, &file->ucontext->ah_list); | 1799 | list_add_tail(&uobj->list, &file->ucontext->ah_list); |
1644 | mutex_unlock(&file->mutex); | 1800 | mutex_unlock(&file->mutex); |
1645 | 1801 | ||
1646 | mutex_unlock(&ib_uverbs_idr_mutex); | 1802 | uobj->live = 1; |
1803 | |||
1804 | up_write(&uobj->mutex); | ||
1647 | 1805 | ||
1648 | return in_len; | 1806 | return in_len; |
1649 | 1807 | ||
1650 | err_idr: | 1808 | err_copy: |
1651 | idr_remove(&ib_uverbs_ah_idr, uobj->id); | 1809 | idr_remove_uobj(&ib_uverbs_ah_idr, uobj); |
1652 | 1810 | ||
1653 | err_destroy: | 1811 | err_destroy: |
1654 | ib_destroy_ah(ah); | 1812 | ib_destroy_ah(ah); |
1655 | 1813 | ||
1656 | err_up: | 1814 | err: |
1657 | mutex_unlock(&ib_uverbs_idr_mutex); | 1815 | put_uobj_write(uobj); |
1658 | |||
1659 | kfree(uobj); | ||
1660 | return ret; | 1816 | return ret; |
1661 | } | 1817 | } |
1662 | 1818 | ||
@@ -1666,35 +1822,34 @@ ssize_t ib_uverbs_destroy_ah(struct ib_uverbs_file *file, | |||
1666 | struct ib_uverbs_destroy_ah cmd; | 1822 | struct ib_uverbs_destroy_ah cmd; |
1667 | struct ib_ah *ah; | 1823 | struct ib_ah *ah; |
1668 | struct ib_uobject *uobj; | 1824 | struct ib_uobject *uobj; |
1669 | int ret = -EINVAL; | 1825 | int ret; |
1670 | 1826 | ||
1671 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 1827 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
1672 | return -EFAULT; | 1828 | return -EFAULT; |
1673 | 1829 | ||
1674 | mutex_lock(&ib_uverbs_idr_mutex); | 1830 | uobj = idr_write_uobj(&ib_uverbs_ah_idr, cmd.ah_handle, file->ucontext); |
1831 | if (!uobj) | ||
1832 | return -EINVAL; | ||
1833 | ah = uobj->object; | ||
1675 | 1834 | ||
1676 | ah = idr_find(&ib_uverbs_ah_idr, cmd.ah_handle); | 1835 | ret = ib_destroy_ah(ah); |
1677 | if (!ah || ah->uobject->context != file->ucontext) | 1836 | if (!ret) |
1678 | goto out; | 1837 | uobj->live = 0; |
1679 | 1838 | ||
1680 | uobj = ah->uobject; | 1839 | put_uobj_write(uobj); |
1681 | 1840 | ||
1682 | ret = ib_destroy_ah(ah); | ||
1683 | if (ret) | 1841 | if (ret) |
1684 | goto out; | 1842 | return ret; |
1685 | 1843 | ||
1686 | idr_remove(&ib_uverbs_ah_idr, cmd.ah_handle); | 1844 | idr_remove_uobj(&ib_uverbs_ah_idr, uobj); |
1687 | 1845 | ||
1688 | mutex_lock(&file->mutex); | 1846 | mutex_lock(&file->mutex); |
1689 | list_del(&uobj->list); | 1847 | list_del(&uobj->list); |
1690 | mutex_unlock(&file->mutex); | 1848 | mutex_unlock(&file->mutex); |
1691 | 1849 | ||
1692 | kfree(uobj); | 1850 | put_uobj(uobj); |
1693 | 1851 | ||
1694 | out: | 1852 | return in_len; |
1695 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
1696 | |||
1697 | return ret ? ret : in_len; | ||
1698 | } | 1853 | } |
1699 | 1854 | ||
1700 | ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file, | 1855 | ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file, |
@@ -1703,47 +1858,43 @@ ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file, | |||
1703 | { | 1858 | { |
1704 | struct ib_uverbs_attach_mcast cmd; | 1859 | struct ib_uverbs_attach_mcast cmd; |
1705 | struct ib_qp *qp; | 1860 | struct ib_qp *qp; |
1706 | struct ib_uqp_object *uobj; | 1861 | struct ib_uqp_object *obj; |
1707 | struct ib_uverbs_mcast_entry *mcast; | 1862 | struct ib_uverbs_mcast_entry *mcast; |
1708 | int ret = -EINVAL; | 1863 | int ret; |
1709 | 1864 | ||
1710 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 1865 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
1711 | return -EFAULT; | 1866 | return -EFAULT; |
1712 | 1867 | ||
1713 | mutex_lock(&ib_uverbs_idr_mutex); | 1868 | qp = idr_read_qp(cmd.qp_handle, file->ucontext); |
1714 | 1869 | if (!qp) | |
1715 | qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle); | 1870 | return -EINVAL; |
1716 | if (!qp || qp->uobject->context != file->ucontext) | ||
1717 | goto out; | ||
1718 | 1871 | ||
1719 | uobj = container_of(qp->uobject, struct ib_uqp_object, uevent.uobject); | 1872 | obj = container_of(qp->uobject, struct ib_uqp_object, uevent.uobject); |
1720 | 1873 | ||
1721 | list_for_each_entry(mcast, &uobj->mcast_list, list) | 1874 | list_for_each_entry(mcast, &obj->mcast_list, list) |
1722 | if (cmd.mlid == mcast->lid && | 1875 | if (cmd.mlid == mcast->lid && |
1723 | !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) { | 1876 | !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) { |
1724 | ret = 0; | 1877 | ret = 0; |
1725 | goto out; | 1878 | goto out_put; |
1726 | } | 1879 | } |
1727 | 1880 | ||
1728 | mcast = kmalloc(sizeof *mcast, GFP_KERNEL); | 1881 | mcast = kmalloc(sizeof *mcast, GFP_KERNEL); |
1729 | if (!mcast) { | 1882 | if (!mcast) { |
1730 | ret = -ENOMEM; | 1883 | ret = -ENOMEM; |
1731 | goto out; | 1884 | goto out_put; |
1732 | } | 1885 | } |
1733 | 1886 | ||
1734 | mcast->lid = cmd.mlid; | 1887 | mcast->lid = cmd.mlid; |
1735 | memcpy(mcast->gid.raw, cmd.gid, sizeof mcast->gid.raw); | 1888 | memcpy(mcast->gid.raw, cmd.gid, sizeof mcast->gid.raw); |
1736 | 1889 | ||
1737 | ret = ib_attach_mcast(qp, &mcast->gid, cmd.mlid); | 1890 | ret = ib_attach_mcast(qp, &mcast->gid, cmd.mlid); |
1738 | if (!ret) { | 1891 | if (!ret) |
1739 | uobj = container_of(qp->uobject, struct ib_uqp_object, | 1892 | list_add_tail(&mcast->list, &obj->mcast_list); |
1740 | uevent.uobject); | 1893 | else |
1741 | list_add_tail(&mcast->list, &uobj->mcast_list); | ||
1742 | } else | ||
1743 | kfree(mcast); | 1894 | kfree(mcast); |
1744 | 1895 | ||
1745 | out: | 1896 | out_put: |
1746 | mutex_unlock(&ib_uverbs_idr_mutex); | 1897 | put_qp_read(qp); |
1747 | 1898 | ||
1748 | return ret ? ret : in_len; | 1899 | return ret ? ret : in_len; |
1749 | } | 1900 | } |
@@ -1753,7 +1904,7 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file, | |||
1753 | int out_len) | 1904 | int out_len) |
1754 | { | 1905 | { |
1755 | struct ib_uverbs_detach_mcast cmd; | 1906 | struct ib_uverbs_detach_mcast cmd; |
1756 | struct ib_uqp_object *uobj; | 1907 | struct ib_uqp_object *obj; |
1757 | struct ib_qp *qp; | 1908 | struct ib_qp *qp; |
1758 | struct ib_uverbs_mcast_entry *mcast; | 1909 | struct ib_uverbs_mcast_entry *mcast; |
1759 | int ret = -EINVAL; | 1910 | int ret = -EINVAL; |
@@ -1761,19 +1912,17 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file, | |||
1761 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 1912 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
1762 | return -EFAULT; | 1913 | return -EFAULT; |
1763 | 1914 | ||
1764 | mutex_lock(&ib_uverbs_idr_mutex); | 1915 | qp = idr_read_qp(cmd.qp_handle, file->ucontext); |
1765 | 1916 | if (!qp) | |
1766 | qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle); | 1917 | return -EINVAL; |
1767 | if (!qp || qp->uobject->context != file->ucontext) | ||
1768 | goto out; | ||
1769 | 1918 | ||
1770 | ret = ib_detach_mcast(qp, (union ib_gid *) cmd.gid, cmd.mlid); | 1919 | ret = ib_detach_mcast(qp, (union ib_gid *) cmd.gid, cmd.mlid); |
1771 | if (ret) | 1920 | if (ret) |
1772 | goto out; | 1921 | goto out_put; |
1773 | 1922 | ||
1774 | uobj = container_of(qp->uobject, struct ib_uqp_object, uevent.uobject); | 1923 | obj = container_of(qp->uobject, struct ib_uqp_object, uevent.uobject); |
1775 | 1924 | ||
1776 | list_for_each_entry(mcast, &uobj->mcast_list, list) | 1925 | list_for_each_entry(mcast, &obj->mcast_list, list) |
1777 | if (cmd.mlid == mcast->lid && | 1926 | if (cmd.mlid == mcast->lid && |
1778 | !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) { | 1927 | !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) { |
1779 | list_del(&mcast->list); | 1928 | list_del(&mcast->list); |
@@ -1781,8 +1930,8 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file, | |||
1781 | break; | 1930 | break; |
1782 | } | 1931 | } |
1783 | 1932 | ||
1784 | out: | 1933 | out_put: |
1785 | mutex_unlock(&ib_uverbs_idr_mutex); | 1934 | put_qp_read(qp); |
1786 | 1935 | ||
1787 | return ret ? ret : in_len; | 1936 | return ret ? ret : in_len; |
1788 | } | 1937 | } |
@@ -1794,7 +1943,7 @@ ssize_t ib_uverbs_create_srq(struct ib_uverbs_file *file, | |||
1794 | struct ib_uverbs_create_srq cmd; | 1943 | struct ib_uverbs_create_srq cmd; |
1795 | struct ib_uverbs_create_srq_resp resp; | 1944 | struct ib_uverbs_create_srq_resp resp; |
1796 | struct ib_udata udata; | 1945 | struct ib_udata udata; |
1797 | struct ib_uevent_object *uobj; | 1946 | struct ib_uevent_object *obj; |
1798 | struct ib_pd *pd; | 1947 | struct ib_pd *pd; |
1799 | struct ib_srq *srq; | 1948 | struct ib_srq *srq; |
1800 | struct ib_srq_init_attr attr; | 1949 | struct ib_srq_init_attr attr; |
@@ -1810,17 +1959,17 @@ ssize_t ib_uverbs_create_srq(struct ib_uverbs_file *file, | |||
1810 | (unsigned long) cmd.response + sizeof resp, | 1959 | (unsigned long) cmd.response + sizeof resp, |
1811 | in_len - sizeof cmd, out_len - sizeof resp); | 1960 | in_len - sizeof cmd, out_len - sizeof resp); |
1812 | 1961 | ||
1813 | uobj = kmalloc(sizeof *uobj, GFP_KERNEL); | 1962 | obj = kmalloc(sizeof *obj, GFP_KERNEL); |
1814 | if (!uobj) | 1963 | if (!obj) |
1815 | return -ENOMEM; | 1964 | return -ENOMEM; |
1816 | 1965 | ||
1817 | mutex_lock(&ib_uverbs_idr_mutex); | 1966 | init_uobj(&obj->uobject, 0, file->ucontext); |
1967 | down_write(&obj->uobject.mutex); | ||
1818 | 1968 | ||
1819 | pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle); | 1969 | pd = idr_read_pd(cmd.pd_handle, file->ucontext); |
1820 | 1970 | if (!pd) { | |
1821 | if (!pd || pd->uobject->context != file->ucontext) { | ||
1822 | ret = -EINVAL; | 1971 | ret = -EINVAL; |
1823 | goto err_up; | 1972 | goto err; |
1824 | } | 1973 | } |
1825 | 1974 | ||
1826 | attr.event_handler = ib_uverbs_srq_event_handler; | 1975 | attr.event_handler = ib_uverbs_srq_event_handler; |
@@ -1829,69 +1978,59 @@ ssize_t ib_uverbs_create_srq(struct ib_uverbs_file *file, | |||
1829 | attr.attr.max_sge = cmd.max_sge; | 1978 | attr.attr.max_sge = cmd.max_sge; |
1830 | attr.attr.srq_limit = cmd.srq_limit; | 1979 | attr.attr.srq_limit = cmd.srq_limit; |
1831 | 1980 | ||
1832 | uobj->uobject.user_handle = cmd.user_handle; | 1981 | obj->events_reported = 0; |
1833 | uobj->uobject.context = file->ucontext; | 1982 | INIT_LIST_HEAD(&obj->event_list); |
1834 | uobj->events_reported = 0; | ||
1835 | INIT_LIST_HEAD(&uobj->event_list); | ||
1836 | 1983 | ||
1837 | srq = pd->device->create_srq(pd, &attr, &udata); | 1984 | srq = pd->device->create_srq(pd, &attr, &udata); |
1838 | if (IS_ERR(srq)) { | 1985 | if (IS_ERR(srq)) { |
1839 | ret = PTR_ERR(srq); | 1986 | ret = PTR_ERR(srq); |
1840 | goto err_up; | 1987 | goto err; |
1841 | } | 1988 | } |
1842 | 1989 | ||
1843 | srq->device = pd->device; | 1990 | srq->device = pd->device; |
1844 | srq->pd = pd; | 1991 | srq->pd = pd; |
1845 | srq->uobject = &uobj->uobject; | 1992 | srq->uobject = &obj->uobject; |
1846 | srq->event_handler = attr.event_handler; | 1993 | srq->event_handler = attr.event_handler; |
1847 | srq->srq_context = attr.srq_context; | 1994 | srq->srq_context = attr.srq_context; |
1848 | atomic_inc(&pd->usecnt); | 1995 | atomic_inc(&pd->usecnt); |
1849 | atomic_set(&srq->usecnt, 0); | 1996 | atomic_set(&srq->usecnt, 0); |
1850 | 1997 | ||
1851 | memset(&resp, 0, sizeof resp); | 1998 | obj->uobject.object = srq; |
1852 | 1999 | ret = idr_add_uobj(&ib_uverbs_srq_idr, &obj->uobject); | |
1853 | retry: | ||
1854 | if (!idr_pre_get(&ib_uverbs_srq_idr, GFP_KERNEL)) { | ||
1855 | ret = -ENOMEM; | ||
1856 | goto err_destroy; | ||
1857 | } | ||
1858 | |||
1859 | ret = idr_get_new(&ib_uverbs_srq_idr, srq, &uobj->uobject.id); | ||
1860 | |||
1861 | if (ret == -EAGAIN) | ||
1862 | goto retry; | ||
1863 | if (ret) | 2000 | if (ret) |
1864 | goto err_destroy; | 2001 | goto err_destroy; |
1865 | 2002 | ||
1866 | resp.srq_handle = uobj->uobject.id; | 2003 | memset(&resp, 0, sizeof resp); |
2004 | resp.srq_handle = obj->uobject.id; | ||
1867 | resp.max_wr = attr.attr.max_wr; | 2005 | resp.max_wr = attr.attr.max_wr; |
1868 | resp.max_sge = attr.attr.max_sge; | 2006 | resp.max_sge = attr.attr.max_sge; |
1869 | 2007 | ||
1870 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 2008 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
1871 | &resp, sizeof resp)) { | 2009 | &resp, sizeof resp)) { |
1872 | ret = -EFAULT; | 2010 | ret = -EFAULT; |
1873 | goto err_idr; | 2011 | goto err_copy; |
1874 | } | 2012 | } |
1875 | 2013 | ||
2014 | put_pd_read(pd); | ||
2015 | |||
1876 | mutex_lock(&file->mutex); | 2016 | mutex_lock(&file->mutex); |
1877 | list_add_tail(&uobj->uobject.list, &file->ucontext->srq_list); | 2017 | list_add_tail(&obj->uobject.list, &file->ucontext->srq_list); |
1878 | mutex_unlock(&file->mutex); | 2018 | mutex_unlock(&file->mutex); |
1879 | 2019 | ||
1880 | mutex_unlock(&ib_uverbs_idr_mutex); | 2020 | obj->uobject.live = 1; |
2021 | |||
2022 | up_write(&obj->uobject.mutex); | ||
1881 | 2023 | ||
1882 | return in_len; | 2024 | return in_len; |
1883 | 2025 | ||
1884 | err_idr: | 2026 | err_copy: |
1885 | idr_remove(&ib_uverbs_srq_idr, uobj->uobject.id); | 2027 | idr_remove_uobj(&ib_uverbs_srq_idr, &obj->uobject); |
1886 | 2028 | ||
1887 | err_destroy: | 2029 | err_destroy: |
1888 | ib_destroy_srq(srq); | 2030 | ib_destroy_srq(srq); |
1889 | atomic_dec(&pd->usecnt); | ||
1890 | |||
1891 | err_up: | ||
1892 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
1893 | 2031 | ||
1894 | kfree(uobj); | 2032 | err: |
2033 | put_uobj_write(&obj->uobject); | ||
1895 | return ret; | 2034 | return ret; |
1896 | } | 2035 | } |
1897 | 2036 | ||
@@ -1907,21 +2046,16 @@ ssize_t ib_uverbs_modify_srq(struct ib_uverbs_file *file, | |||
1907 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 2046 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
1908 | return -EFAULT; | 2047 | return -EFAULT; |
1909 | 2048 | ||
1910 | mutex_lock(&ib_uverbs_idr_mutex); | 2049 | srq = idr_read_srq(cmd.srq_handle, file->ucontext); |
1911 | 2050 | if (!srq) | |
1912 | srq = idr_find(&ib_uverbs_srq_idr, cmd.srq_handle); | 2051 | return -EINVAL; |
1913 | if (!srq || srq->uobject->context != file->ucontext) { | ||
1914 | ret = -EINVAL; | ||
1915 | goto out; | ||
1916 | } | ||
1917 | 2052 | ||
1918 | attr.max_wr = cmd.max_wr; | 2053 | attr.max_wr = cmd.max_wr; |
1919 | attr.srq_limit = cmd.srq_limit; | 2054 | attr.srq_limit = cmd.srq_limit; |
1920 | 2055 | ||
1921 | ret = ib_modify_srq(srq, &attr, cmd.attr_mask); | 2056 | ret = ib_modify_srq(srq, &attr, cmd.attr_mask); |
1922 | 2057 | ||
1923 | out: | 2058 | put_srq_read(srq); |
1924 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
1925 | 2059 | ||
1926 | return ret ? ret : in_len; | 2060 | return ret ? ret : in_len; |
1927 | } | 2061 | } |
@@ -1942,18 +2076,16 @@ ssize_t ib_uverbs_query_srq(struct ib_uverbs_file *file, | |||
1942 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 2076 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
1943 | return -EFAULT; | 2077 | return -EFAULT; |
1944 | 2078 | ||
1945 | mutex_lock(&ib_uverbs_idr_mutex); | 2079 | srq = idr_read_srq(cmd.srq_handle, file->ucontext); |
2080 | if (!srq) | ||
2081 | return -EINVAL; | ||
1946 | 2082 | ||
1947 | srq = idr_find(&ib_uverbs_srq_idr, cmd.srq_handle); | 2083 | ret = ib_query_srq(srq, &attr); |
1948 | if (srq && srq->uobject->context == file->ucontext) | ||
1949 | ret = ib_query_srq(srq, &attr); | ||
1950 | else | ||
1951 | ret = -EINVAL; | ||
1952 | 2084 | ||
1953 | mutex_unlock(&ib_uverbs_idr_mutex); | 2085 | put_srq_read(srq); |
1954 | 2086 | ||
1955 | if (ret) | 2087 | if (ret) |
1956 | goto out; | 2088 | return ret; |
1957 | 2089 | ||
1958 | memset(&resp, 0, sizeof resp); | 2090 | memset(&resp, 0, sizeof resp); |
1959 | 2091 | ||
@@ -1963,10 +2095,9 @@ ssize_t ib_uverbs_query_srq(struct ib_uverbs_file *file, | |||
1963 | 2095 | ||
1964 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 2096 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
1965 | &resp, sizeof resp)) | 2097 | &resp, sizeof resp)) |
1966 | ret = -EFAULT; | 2098 | return -EFAULT; |
1967 | 2099 | ||
1968 | out: | 2100 | return in_len; |
1969 | return ret ? ret : in_len; | ||
1970 | } | 2101 | } |
1971 | 2102 | ||
1972 | ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file, | 2103 | ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file, |
@@ -1975,45 +2106,45 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file, | |||
1975 | { | 2106 | { |
1976 | struct ib_uverbs_destroy_srq cmd; | 2107 | struct ib_uverbs_destroy_srq cmd; |
1977 | struct ib_uverbs_destroy_srq_resp resp; | 2108 | struct ib_uverbs_destroy_srq_resp resp; |
2109 | struct ib_uobject *uobj; | ||
1978 | struct ib_srq *srq; | 2110 | struct ib_srq *srq; |
1979 | struct ib_uevent_object *uobj; | 2111 | struct ib_uevent_object *obj; |
1980 | int ret = -EINVAL; | 2112 | int ret = -EINVAL; |
1981 | 2113 | ||
1982 | if (copy_from_user(&cmd, buf, sizeof cmd)) | 2114 | if (copy_from_user(&cmd, buf, sizeof cmd)) |
1983 | return -EFAULT; | 2115 | return -EFAULT; |
1984 | 2116 | ||
1985 | mutex_lock(&ib_uverbs_idr_mutex); | 2117 | uobj = idr_write_uobj(&ib_uverbs_srq_idr, cmd.srq_handle, file->ucontext); |
1986 | 2118 | if (!uobj) | |
1987 | memset(&resp, 0, sizeof resp); | 2119 | return -EINVAL; |
2120 | srq = uobj->object; | ||
2121 | obj = container_of(uobj, struct ib_uevent_object, uobject); | ||
1988 | 2122 | ||
1989 | srq = idr_find(&ib_uverbs_srq_idr, cmd.srq_handle); | 2123 | ret = ib_destroy_srq(srq); |
1990 | if (!srq || srq->uobject->context != file->ucontext) | 2124 | if (!ret) |
1991 | goto out; | 2125 | uobj->live = 0; |
1992 | 2126 | ||
1993 | uobj = container_of(srq->uobject, struct ib_uevent_object, uobject); | 2127 | put_uobj_write(uobj); |
1994 | 2128 | ||
1995 | ret = ib_destroy_srq(srq); | ||
1996 | if (ret) | 2129 | if (ret) |
1997 | goto out; | 2130 | return ret; |
1998 | 2131 | ||
1999 | idr_remove(&ib_uverbs_srq_idr, cmd.srq_handle); | 2132 | idr_remove_uobj(&ib_uverbs_srq_idr, uobj); |
2000 | 2133 | ||
2001 | mutex_lock(&file->mutex); | 2134 | mutex_lock(&file->mutex); |
2002 | list_del(&uobj->uobject.list); | 2135 | list_del(&uobj->list); |
2003 | mutex_unlock(&file->mutex); | 2136 | mutex_unlock(&file->mutex); |
2004 | 2137 | ||
2005 | ib_uverbs_release_uevent(file, uobj); | 2138 | ib_uverbs_release_uevent(file, obj); |
2006 | 2139 | ||
2007 | resp.events_reported = uobj->events_reported; | 2140 | memset(&resp, 0, sizeof resp); |
2141 | resp.events_reported = obj->events_reported; | ||
2008 | 2142 | ||
2009 | kfree(uobj); | 2143 | put_uobj(uobj); |
2010 | 2144 | ||
2011 | if (copy_to_user((void __user *) (unsigned long) cmd.response, | 2145 | if (copy_to_user((void __user *) (unsigned long) cmd.response, |
2012 | &resp, sizeof resp)) | 2146 | &resp, sizeof resp)) |
2013 | ret = -EFAULT; | 2147 | ret = -EFAULT; |
2014 | 2148 | ||
2015 | out: | ||
2016 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
2017 | |||
2018 | return ret ? ret : in_len; | 2149 | return ret ? ret : in_len; |
2019 | } | 2150 | } |
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c index ff092a0a94da..5ec2d49e9bb6 100644 --- a/drivers/infiniband/core/uverbs_main.c +++ b/drivers/infiniband/core/uverbs_main.c | |||
@@ -66,7 +66,7 @@ enum { | |||
66 | 66 | ||
67 | static struct class *uverbs_class; | 67 | static struct class *uverbs_class; |
68 | 68 | ||
69 | DEFINE_MUTEX(ib_uverbs_idr_mutex); | 69 | DEFINE_SPINLOCK(ib_uverbs_idr_lock); |
70 | DEFINE_IDR(ib_uverbs_pd_idr); | 70 | DEFINE_IDR(ib_uverbs_pd_idr); |
71 | DEFINE_IDR(ib_uverbs_mr_idr); | 71 | DEFINE_IDR(ib_uverbs_mr_idr); |
72 | DEFINE_IDR(ib_uverbs_mw_idr); | 72 | DEFINE_IDR(ib_uverbs_mw_idr); |
@@ -183,21 +183,21 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file, | |||
183 | if (!context) | 183 | if (!context) |
184 | return 0; | 184 | return 0; |
185 | 185 | ||
186 | mutex_lock(&ib_uverbs_idr_mutex); | ||
187 | |||
188 | list_for_each_entry_safe(uobj, tmp, &context->ah_list, list) { | 186 | list_for_each_entry_safe(uobj, tmp, &context->ah_list, list) { |
189 | struct ib_ah *ah = idr_find(&ib_uverbs_ah_idr, uobj->id); | 187 | struct ib_ah *ah = uobj->object; |
190 | idr_remove(&ib_uverbs_ah_idr, uobj->id); | 188 | |
189 | idr_remove_uobj(&ib_uverbs_ah_idr, uobj); | ||
191 | ib_destroy_ah(ah); | 190 | ib_destroy_ah(ah); |
192 | list_del(&uobj->list); | 191 | list_del(&uobj->list); |
193 | kfree(uobj); | 192 | kfree(uobj); |
194 | } | 193 | } |
195 | 194 | ||
196 | list_for_each_entry_safe(uobj, tmp, &context->qp_list, list) { | 195 | list_for_each_entry_safe(uobj, tmp, &context->qp_list, list) { |
197 | struct ib_qp *qp = idr_find(&ib_uverbs_qp_idr, uobj->id); | 196 | struct ib_qp *qp = uobj->object; |
198 | struct ib_uqp_object *uqp = | 197 | struct ib_uqp_object *uqp = |
199 | container_of(uobj, struct ib_uqp_object, uevent.uobject); | 198 | container_of(uobj, struct ib_uqp_object, uevent.uobject); |
200 | idr_remove(&ib_uverbs_qp_idr, uobj->id); | 199 | |
200 | idr_remove_uobj(&ib_uverbs_qp_idr, uobj); | ||
201 | ib_uverbs_detach_umcast(qp, uqp); | 201 | ib_uverbs_detach_umcast(qp, uqp); |
202 | ib_destroy_qp(qp); | 202 | ib_destroy_qp(qp); |
203 | list_del(&uobj->list); | 203 | list_del(&uobj->list); |
@@ -206,11 +206,12 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file, | |||
206 | } | 206 | } |
207 | 207 | ||
208 | list_for_each_entry_safe(uobj, tmp, &context->cq_list, list) { | 208 | list_for_each_entry_safe(uobj, tmp, &context->cq_list, list) { |
209 | struct ib_cq *cq = idr_find(&ib_uverbs_cq_idr, uobj->id); | 209 | struct ib_cq *cq = uobj->object; |
210 | struct ib_uverbs_event_file *ev_file = cq->cq_context; | 210 | struct ib_uverbs_event_file *ev_file = cq->cq_context; |
211 | struct ib_ucq_object *ucq = | 211 | struct ib_ucq_object *ucq = |
212 | container_of(uobj, struct ib_ucq_object, uobject); | 212 | container_of(uobj, struct ib_ucq_object, uobject); |
213 | idr_remove(&ib_uverbs_cq_idr, uobj->id); | 213 | |
214 | idr_remove_uobj(&ib_uverbs_cq_idr, uobj); | ||
214 | ib_destroy_cq(cq); | 215 | ib_destroy_cq(cq); |
215 | list_del(&uobj->list); | 216 | list_del(&uobj->list); |
216 | ib_uverbs_release_ucq(file, ev_file, ucq); | 217 | ib_uverbs_release_ucq(file, ev_file, ucq); |
@@ -218,10 +219,11 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file, | |||
218 | } | 219 | } |
219 | 220 | ||
220 | list_for_each_entry_safe(uobj, tmp, &context->srq_list, list) { | 221 | list_for_each_entry_safe(uobj, tmp, &context->srq_list, list) { |
221 | struct ib_srq *srq = idr_find(&ib_uverbs_srq_idr, uobj->id); | 222 | struct ib_srq *srq = uobj->object; |
222 | struct ib_uevent_object *uevent = | 223 | struct ib_uevent_object *uevent = |
223 | container_of(uobj, struct ib_uevent_object, uobject); | 224 | container_of(uobj, struct ib_uevent_object, uobject); |
224 | idr_remove(&ib_uverbs_srq_idr, uobj->id); | 225 | |
226 | idr_remove_uobj(&ib_uverbs_srq_idr, uobj); | ||
225 | ib_destroy_srq(srq); | 227 | ib_destroy_srq(srq); |
226 | list_del(&uobj->list); | 228 | list_del(&uobj->list); |
227 | ib_uverbs_release_uevent(file, uevent); | 229 | ib_uverbs_release_uevent(file, uevent); |
@@ -231,11 +233,11 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file, | |||
231 | /* XXX Free MWs */ | 233 | /* XXX Free MWs */ |
232 | 234 | ||
233 | list_for_each_entry_safe(uobj, tmp, &context->mr_list, list) { | 235 | list_for_each_entry_safe(uobj, tmp, &context->mr_list, list) { |
234 | struct ib_mr *mr = idr_find(&ib_uverbs_mr_idr, uobj->id); | 236 | struct ib_mr *mr = uobj->object; |
235 | struct ib_device *mrdev = mr->device; | 237 | struct ib_device *mrdev = mr->device; |
236 | struct ib_umem_object *memobj; | 238 | struct ib_umem_object *memobj; |
237 | 239 | ||
238 | idr_remove(&ib_uverbs_mr_idr, uobj->id); | 240 | idr_remove_uobj(&ib_uverbs_mr_idr, uobj); |
239 | ib_dereg_mr(mr); | 241 | ib_dereg_mr(mr); |
240 | 242 | ||
241 | memobj = container_of(uobj, struct ib_umem_object, uobject); | 243 | memobj = container_of(uobj, struct ib_umem_object, uobject); |
@@ -246,15 +248,14 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file, | |||
246 | } | 248 | } |
247 | 249 | ||
248 | list_for_each_entry_safe(uobj, tmp, &context->pd_list, list) { | 250 | list_for_each_entry_safe(uobj, tmp, &context->pd_list, list) { |
249 | struct ib_pd *pd = idr_find(&ib_uverbs_pd_idr, uobj->id); | 251 | struct ib_pd *pd = uobj->object; |
250 | idr_remove(&ib_uverbs_pd_idr, uobj->id); | 252 | |
253 | idr_remove_uobj(&ib_uverbs_pd_idr, uobj); | ||
251 | ib_dealloc_pd(pd); | 254 | ib_dealloc_pd(pd); |
252 | list_del(&uobj->list); | 255 | list_del(&uobj->list); |
253 | kfree(uobj); | 256 | kfree(uobj); |
254 | } | 257 | } |
255 | 258 | ||
256 | mutex_unlock(&ib_uverbs_idr_mutex); | ||
257 | |||
258 | return context->device->dealloc_ucontext(context); | 259 | return context->device->dealloc_ucontext(context); |
259 | } | 260 | } |
260 | 261 | ||
diff --git a/drivers/infiniband/core/uverbs_marshall.c b/drivers/infiniband/core/uverbs_marshall.c new file mode 100644 index 000000000000..ce46b13ae02b --- /dev/null +++ b/drivers/infiniband/core/uverbs_marshall.c | |||
@@ -0,0 +1,138 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2005 Intel Corporation. All rights reserved. | ||
3 | * | ||
4 | * This software is available to you under a choice of one of two | ||
5 | * licenses. You may choose to be licensed under the terms of the GNU | ||
6 | * General Public License (GPL) Version 2, available from the file | ||
7 | * COPYING in the main directory of this source tree, or the | ||
8 | * OpenIB.org BSD license below: | ||
9 | * | ||
10 | * Redistribution and use in source and binary forms, with or | ||
11 | * without modification, are permitted provided that the following | ||
12 | * conditions are met: | ||
13 | * | ||
14 | * - Redistributions of source code must retain the above | ||
15 | * copyright notice, this list of conditions and the following | ||
16 | * disclaimer. | ||
17 | * | ||
18 | * - Redistributions in binary form must reproduce the above | ||
19 | * copyright notice, this list of conditions and the following | ||
20 | * disclaimer in the documentation and/or other materials | ||
21 | * provided with the distribution. | ||
22 | * | ||
23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
25 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | ||
27 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | ||
28 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | ||
29 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
30 | * SOFTWARE. | ||
31 | */ | ||
32 | |||
33 | #include <rdma/ib_marshall.h> | ||
34 | |||
35 | static void ib_copy_ah_attr_to_user(struct ib_uverbs_ah_attr *dst, | ||
36 | struct ib_ah_attr *src) | ||
37 | { | ||
38 | memcpy(dst->grh.dgid, src->grh.dgid.raw, sizeof src->grh.dgid); | ||
39 | dst->grh.flow_label = src->grh.flow_label; | ||
40 | dst->grh.sgid_index = src->grh.sgid_index; | ||
41 | dst->grh.hop_limit = src->grh.hop_limit; | ||
42 | dst->grh.traffic_class = src->grh.traffic_class; | ||
43 | dst->dlid = src->dlid; | ||
44 | dst->sl = src->sl; | ||
45 | dst->src_path_bits = src->src_path_bits; | ||
46 | dst->static_rate = src->static_rate; | ||
47 | dst->is_global = src->ah_flags & IB_AH_GRH ? 1 : 0; | ||
48 | dst->port_num = src->port_num; | ||
49 | } | ||
50 | |||
51 | void ib_copy_qp_attr_to_user(struct ib_uverbs_qp_attr *dst, | ||
52 | struct ib_qp_attr *src) | ||
53 | { | ||
54 | dst->cur_qp_state = src->cur_qp_state; | ||
55 | dst->path_mtu = src->path_mtu; | ||
56 | dst->path_mig_state = src->path_mig_state; | ||
57 | dst->qkey = src->qkey; | ||
58 | dst->rq_psn = src->rq_psn; | ||
59 | dst->sq_psn = src->sq_psn; | ||
60 | dst->dest_qp_num = src->dest_qp_num; | ||
61 | dst->qp_access_flags = src->qp_access_flags; | ||
62 | |||
63 | dst->max_send_wr = src->cap.max_send_wr; | ||
64 | dst->max_recv_wr = src->cap.max_recv_wr; | ||
65 | dst->max_send_sge = src->cap.max_send_sge; | ||
66 | dst->max_recv_sge = src->cap.max_recv_sge; | ||
67 | dst->max_inline_data = src->cap.max_inline_data; | ||
68 | |||
69 | ib_copy_ah_attr_to_user(&dst->ah_attr, &src->ah_attr); | ||
70 | ib_copy_ah_attr_to_user(&dst->alt_ah_attr, &src->alt_ah_attr); | ||
71 | |||
72 | dst->pkey_index = src->pkey_index; | ||
73 | dst->alt_pkey_index = src->alt_pkey_index; | ||
74 | dst->en_sqd_async_notify = src->en_sqd_async_notify; | ||
75 | dst->sq_draining = src->sq_draining; | ||
76 | dst->max_rd_atomic = src->max_rd_atomic; | ||
77 | dst->max_dest_rd_atomic = src->max_dest_rd_atomic; | ||
78 | dst->min_rnr_timer = src->min_rnr_timer; | ||
79 | dst->port_num = src->port_num; | ||
80 | dst->timeout = src->timeout; | ||
81 | dst->retry_cnt = src->retry_cnt; | ||
82 | dst->rnr_retry = src->rnr_retry; | ||
83 | dst->alt_port_num = src->alt_port_num; | ||
84 | dst->alt_timeout = src->alt_timeout; | ||
85 | } | ||
86 | EXPORT_SYMBOL(ib_copy_qp_attr_to_user); | ||
87 | |||
88 | void ib_copy_path_rec_to_user(struct ib_user_path_rec *dst, | ||
89 | struct ib_sa_path_rec *src) | ||
90 | { | ||
91 | memcpy(dst->dgid, src->dgid.raw, sizeof src->dgid); | ||
92 | memcpy(dst->sgid, src->sgid.raw, sizeof src->sgid); | ||
93 | |||
94 | dst->dlid = src->dlid; | ||
95 | dst->slid = src->slid; | ||
96 | dst->raw_traffic = src->raw_traffic; | ||
97 | dst->flow_label = src->flow_label; | ||
98 | dst->hop_limit = src->hop_limit; | ||
99 | dst->traffic_class = src->traffic_class; | ||
100 | dst->reversible = src->reversible; | ||
101 | dst->numb_path = src->numb_path; | ||
102 | dst->pkey = src->pkey; | ||
103 | dst->sl = src->sl; | ||
104 | dst->mtu_selector = src->mtu_selector; | ||
105 | dst->mtu = src->mtu; | ||
106 | dst->rate_selector = src->rate_selector; | ||
107 | dst->rate = src->rate; | ||
108 | dst->packet_life_time = src->packet_life_time; | ||
109 | dst->preference = src->preference; | ||
110 | dst->packet_life_time_selector = src->packet_life_time_selector; | ||
111 | } | ||
112 | EXPORT_SYMBOL(ib_copy_path_rec_to_user); | ||
113 | |||
114 | void ib_copy_path_rec_from_user(struct ib_sa_path_rec *dst, | ||
115 | struct ib_user_path_rec *src) | ||
116 | { | ||
117 | memcpy(dst->dgid.raw, src->dgid, sizeof dst->dgid); | ||
118 | memcpy(dst->sgid.raw, src->sgid, sizeof dst->sgid); | ||
119 | |||
120 | dst->dlid = src->dlid; | ||
121 | dst->slid = src->slid; | ||
122 | dst->raw_traffic = src->raw_traffic; | ||
123 | dst->flow_label = src->flow_label; | ||
124 | dst->hop_limit = src->hop_limit; | ||
125 | dst->traffic_class = src->traffic_class; | ||
126 | dst->reversible = src->reversible; | ||
127 | dst->numb_path = src->numb_path; | ||
128 | dst->pkey = src->pkey; | ||
129 | dst->sl = src->sl; | ||
130 | dst->mtu_selector = src->mtu_selector; | ||
131 | dst->mtu = src->mtu; | ||
132 | dst->rate_selector = src->rate_selector; | ||
133 | dst->rate = src->rate; | ||
134 | dst->packet_life_time = src->packet_life_time; | ||
135 | dst->preference = src->preference; | ||
136 | dst->packet_life_time_selector = src->packet_life_time_selector; | ||
137 | } | ||
138 | EXPORT_SYMBOL(ib_copy_path_rec_from_user); | ||
diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c index b78e7dc69330..468999c38803 100644 --- a/drivers/infiniband/core/verbs.c +++ b/drivers/infiniband/core/verbs.c | |||
@@ -125,35 +125,47 @@ struct ib_ah *ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr) | |||
125 | } | 125 | } |
126 | EXPORT_SYMBOL(ib_create_ah); | 126 | EXPORT_SYMBOL(ib_create_ah); |
127 | 127 | ||
128 | struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, struct ib_wc *wc, | 128 | int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, struct ib_wc *wc, |
129 | struct ib_grh *grh, u8 port_num) | 129 | struct ib_grh *grh, struct ib_ah_attr *ah_attr) |
130 | { | 130 | { |
131 | struct ib_ah_attr ah_attr; | ||
132 | u32 flow_class; | 131 | u32 flow_class; |
133 | u16 gid_index; | 132 | u16 gid_index; |
134 | int ret; | 133 | int ret; |
135 | 134 | ||
136 | memset(&ah_attr, 0, sizeof ah_attr); | 135 | memset(ah_attr, 0, sizeof *ah_attr); |
137 | ah_attr.dlid = wc->slid; | 136 | ah_attr->dlid = wc->slid; |
138 | ah_attr.sl = wc->sl; | 137 | ah_attr->sl = wc->sl; |
139 | ah_attr.src_path_bits = wc->dlid_path_bits; | 138 | ah_attr->src_path_bits = wc->dlid_path_bits; |
140 | ah_attr.port_num = port_num; | 139 | ah_attr->port_num = port_num; |
141 | 140 | ||
142 | if (wc->wc_flags & IB_WC_GRH) { | 141 | if (wc->wc_flags & IB_WC_GRH) { |
143 | ah_attr.ah_flags = IB_AH_GRH; | 142 | ah_attr->ah_flags = IB_AH_GRH; |
144 | ah_attr.grh.dgid = grh->sgid; | 143 | ah_attr->grh.dgid = grh->sgid; |
145 | 144 | ||
146 | ret = ib_find_cached_gid(pd->device, &grh->dgid, &port_num, | 145 | ret = ib_find_cached_gid(device, &grh->dgid, &port_num, |
147 | &gid_index); | 146 | &gid_index); |
148 | if (ret) | 147 | if (ret) |
149 | return ERR_PTR(ret); | 148 | return ret; |
150 | 149 | ||
151 | ah_attr.grh.sgid_index = (u8) gid_index; | 150 | ah_attr->grh.sgid_index = (u8) gid_index; |
152 | flow_class = be32_to_cpu(grh->version_tclass_flow); | 151 | flow_class = be32_to_cpu(grh->version_tclass_flow); |
153 | ah_attr.grh.flow_label = flow_class & 0xFFFFF; | 152 | ah_attr->grh.flow_label = flow_class & 0xFFFFF; |
154 | ah_attr.grh.traffic_class = (flow_class >> 20) & 0xFF; | 153 | ah_attr->grh.hop_limit = grh->hop_limit; |
155 | ah_attr.grh.hop_limit = grh->hop_limit; | 154 | ah_attr->grh.traffic_class = (flow_class >> 20) & 0xFF; |
156 | } | 155 | } |
156 | return 0; | ||
157 | } | ||
158 | EXPORT_SYMBOL(ib_init_ah_from_wc); | ||
159 | |||
160 | struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, struct ib_wc *wc, | ||
161 | struct ib_grh *grh, u8 port_num) | ||
162 | { | ||
163 | struct ib_ah_attr ah_attr; | ||
164 | int ret; | ||
165 | |||
166 | ret = ib_init_ah_from_wc(pd->device, port_num, wc, grh, &ah_attr); | ||
167 | if (ret) | ||
168 | return ERR_PTR(ret); | ||
157 | 169 | ||
158 | return ib_create_ah(pd, &ah_attr); | 170 | return ib_create_ah(pd, &ah_attr); |
159 | } | 171 | } |
diff --git a/drivers/infiniband/hw/ipath/ipath_mad.c b/drivers/infiniband/hw/ipath/ipath_mad.c index f7f8391fe43f..1a9d0a2c33c3 100644 --- a/drivers/infiniband/hw/ipath/ipath_mad.c +++ b/drivers/infiniband/hw/ipath/ipath_mad.c | |||
@@ -137,47 +137,11 @@ static int recv_subn_get_guidinfo(struct ib_smp *smp, | |||
137 | return reply(smp); | 137 | return reply(smp); |
138 | } | 138 | } |
139 | 139 | ||
140 | struct port_info { | ||
141 | __be64 mkey; | ||
142 | __be64 gid_prefix; | ||
143 | __be16 lid; | ||
144 | __be16 sm_lid; | ||
145 | __be32 cap_mask; | ||
146 | __be16 diag_code; | ||
147 | __be16 mkey_lease_period; | ||
148 | u8 local_port_num; | ||
149 | u8 link_width_enabled; | ||
150 | u8 link_width_supported; | ||
151 | u8 link_width_active; | ||
152 | u8 linkspeed_portstate; /* 4 bits, 4 bits */ | ||
153 | u8 portphysstate_linkdown; /* 4 bits, 4 bits */ | ||
154 | u8 mkeyprot_resv_lmc; /* 2 bits, 3, 3 */ | ||
155 | u8 linkspeedactive_enabled; /* 4 bits, 4 bits */ | ||
156 | u8 neighbormtu_mastersmsl; /* 4 bits, 4 bits */ | ||
157 | u8 vlcap_inittype; /* 4 bits, 4 bits */ | ||
158 | u8 vl_high_limit; | ||
159 | u8 vl_arb_high_cap; | ||
160 | u8 vl_arb_low_cap; | ||
161 | u8 inittypereply_mtucap; /* 4 bits, 4 bits */ | ||
162 | u8 vlstallcnt_hoqlife; /* 3 bits, 5 bits */ | ||
163 | u8 operationalvl_pei_peo_fpi_fpo; /* 4 bits, 1, 1, 1, 1 */ | ||
164 | __be16 mkey_violations; | ||
165 | __be16 pkey_violations; | ||
166 | __be16 qkey_violations; | ||
167 | u8 guid_cap; | ||
168 | u8 clientrereg_resv_subnetto; /* 1 bit, 2 bits, 5 */ | ||
169 | u8 resv_resptimevalue; /* 3 bits, 5 bits */ | ||
170 | u8 localphyerrors_overrunerrors; /* 4 bits, 4 bits */ | ||
171 | __be16 max_credit_hint; | ||
172 | u8 resv; | ||
173 | u8 link_roundtrip_latency[3]; | ||
174 | } __attribute__ ((packed)); | ||
175 | |||
176 | static int recv_subn_get_portinfo(struct ib_smp *smp, | 140 | static int recv_subn_get_portinfo(struct ib_smp *smp, |
177 | struct ib_device *ibdev, u8 port) | 141 | struct ib_device *ibdev, u8 port) |
178 | { | 142 | { |
179 | struct ipath_ibdev *dev; | 143 | struct ipath_ibdev *dev; |
180 | struct port_info *pip = (struct port_info *)smp->data; | 144 | struct ib_port_info *pip = (struct ib_port_info *)smp->data; |
181 | u16 lid; | 145 | u16 lid; |
182 | u8 ibcstat; | 146 | u8 ibcstat; |
183 | u8 mtu; | 147 | u8 mtu; |
@@ -312,7 +276,7 @@ static int recv_subn_set_guidinfo(struct ib_smp *smp, | |||
312 | static int recv_subn_set_portinfo(struct ib_smp *smp, | 276 | static int recv_subn_set_portinfo(struct ib_smp *smp, |
313 | struct ib_device *ibdev, u8 port) | 277 | struct ib_device *ibdev, u8 port) |
314 | { | 278 | { |
315 | struct port_info *pip = (struct port_info *)smp->data; | 279 | struct ib_port_info *pip = (struct ib_port_info *)smp->data; |
316 | struct ib_event event; | 280 | struct ib_event event; |
317 | struct ipath_ibdev *dev; | 281 | struct ipath_ibdev *dev; |
318 | u32 flags; | 282 | u32 flags; |
@@ -445,7 +409,7 @@ static int recv_subn_set_portinfo(struct ib_smp *smp, | |||
445 | 409 | ||
446 | if (pip->clientrereg_resv_subnetto & 0x80) { | 410 | if (pip->clientrereg_resv_subnetto & 0x80) { |
447 | clientrereg = 1; | 411 | clientrereg = 1; |
448 | event.event = IB_EVENT_LID_CHANGE; | 412 | event.event = IB_EVENT_CLIENT_REREGISTER; |
449 | ib_dispatch_event(&event); | 413 | ib_dispatch_event(&event); |
450 | } | 414 | } |
451 | 415 | ||
diff --git a/drivers/infiniband/hw/mthca/mthca_cmd.c b/drivers/infiniband/hw/mthca/mthca_cmd.c index 798e13e14faf..d0f7731802c9 100644 --- a/drivers/infiniband/hw/mthca/mthca_cmd.c +++ b/drivers/infiniband/hw/mthca/mthca_cmd.c | |||
@@ -174,7 +174,6 @@ enum { | |||
174 | 174 | ||
175 | struct mthca_cmd_context { | 175 | struct mthca_cmd_context { |
176 | struct completion done; | 176 | struct completion done; |
177 | struct timer_list timer; | ||
178 | int result; | 177 | int result; |
179 | int next; | 178 | int next; |
180 | u64 out_param; | 179 | u64 out_param; |
@@ -362,15 +361,6 @@ void mthca_cmd_event(struct mthca_dev *dev, | |||
362 | complete(&context->done); | 361 | complete(&context->done); |
363 | } | 362 | } |
364 | 363 | ||
365 | static void event_timeout(unsigned long context_ptr) | ||
366 | { | ||
367 | struct mthca_cmd_context *context = | ||
368 | (struct mthca_cmd_context *) context_ptr; | ||
369 | |||
370 | context->result = -EBUSY; | ||
371 | complete(&context->done); | ||
372 | } | ||
373 | |||
374 | static int mthca_cmd_wait(struct mthca_dev *dev, | 364 | static int mthca_cmd_wait(struct mthca_dev *dev, |
375 | u64 in_param, | 365 | u64 in_param, |
376 | u64 *out_param, | 366 | u64 *out_param, |
@@ -401,11 +391,10 @@ static int mthca_cmd_wait(struct mthca_dev *dev, | |||
401 | if (err) | 391 | if (err) |
402 | goto out; | 392 | goto out; |
403 | 393 | ||
404 | context->timer.expires = jiffies + timeout; | 394 | if (!wait_for_completion_timeout(&context->done, timeout)) { |
405 | add_timer(&context->timer); | 395 | err = -EBUSY; |
406 | 396 | goto out; | |
407 | wait_for_completion(&context->done); | 397 | } |
408 | del_timer_sync(&context->timer); | ||
409 | 398 | ||
410 | err = context->result; | 399 | err = context->result; |
411 | if (err) | 400 | if (err) |
@@ -535,10 +524,6 @@ int mthca_cmd_use_events(struct mthca_dev *dev) | |||
535 | for (i = 0; i < dev->cmd.max_cmds; ++i) { | 524 | for (i = 0; i < dev->cmd.max_cmds; ++i) { |
536 | dev->cmd.context[i].token = i; | 525 | dev->cmd.context[i].token = i; |
537 | dev->cmd.context[i].next = i + 1; | 526 | dev->cmd.context[i].next = i + 1; |
538 | init_timer(&dev->cmd.context[i].timer); | ||
539 | dev->cmd.context[i].timer.data = | ||
540 | (unsigned long) &dev->cmd.context[i]; | ||
541 | dev->cmd.context[i].timer.function = event_timeout; | ||
542 | } | 527 | } |
543 | 528 | ||
544 | dev->cmd.context[dev->cmd.max_cmds - 1].next = -1; | 529 | dev->cmd.context[dev->cmd.max_cmds - 1].next = -1; |
diff --git a/drivers/infiniband/hw/mthca/mthca_cq.c b/drivers/infiniband/hw/mthca/mthca_cq.c index 205854e9c662..3e27a084257e 100644 --- a/drivers/infiniband/hw/mthca/mthca_cq.c +++ b/drivers/infiniband/hw/mthca/mthca_cq.c | |||
@@ -540,8 +540,17 @@ static inline int mthca_poll_one(struct mthca_dev *dev, | |||
540 | entry->wr_id = srq->wrid[wqe_index]; | 540 | entry->wr_id = srq->wrid[wqe_index]; |
541 | mthca_free_srq_wqe(srq, wqe); | 541 | mthca_free_srq_wqe(srq, wqe); |
542 | } else { | 542 | } else { |
543 | s32 wqe; | ||
543 | wq = &(*cur_qp)->rq; | 544 | wq = &(*cur_qp)->rq; |
544 | wqe_index = be32_to_cpu(cqe->wqe) >> wq->wqe_shift; | 545 | wqe = be32_to_cpu(cqe->wqe); |
546 | wqe_index = wqe >> wq->wqe_shift; | ||
547 | /* | ||
548 | * WQE addr == base - 1 might be reported in receive completion | ||
549 | * with error instead of (rq size - 1) by Sinai FW 1.0.800 and | ||
550 | * Arbel FW 5.1.400. This bug should be fixed in later FW revs. | ||
551 | */ | ||
552 | if (unlikely(wqe_index < 0)) | ||
553 | wqe_index = wq->max - 1; | ||
545 | entry->wr_id = (*cur_qp)->wrid[wqe_index]; | 554 | entry->wr_id = (*cur_qp)->wrid[wqe_index]; |
546 | } | 555 | } |
547 | 556 | ||
@@ -813,6 +822,7 @@ int mthca_init_cq(struct mthca_dev *dev, int nent, | |||
813 | spin_lock_init(&cq->lock); | 822 | spin_lock_init(&cq->lock); |
814 | cq->refcount = 1; | 823 | cq->refcount = 1; |
815 | init_waitqueue_head(&cq->wait); | 824 | init_waitqueue_head(&cq->wait); |
825 | mutex_init(&cq->mutex); | ||
816 | 826 | ||
817 | memset(cq_context, 0, sizeof *cq_context); | 827 | memset(cq_context, 0, sizeof *cq_context); |
818 | cq_context->flags = cpu_to_be32(MTHCA_CQ_STATUS_OK | | 828 | cq_context->flags = cpu_to_be32(MTHCA_CQ_STATUS_OK | |
diff --git a/drivers/infiniband/hw/mthca/mthca_eq.c b/drivers/infiniband/hw/mthca/mthca_eq.c index 99f109c3815d..d536217e700e 100644 --- a/drivers/infiniband/hw/mthca/mthca_eq.c +++ b/drivers/infiniband/hw/mthca/mthca_eq.c | |||
@@ -695,10 +695,6 @@ static void mthca_unmap_reg(struct mthca_dev *dev, unsigned long offset, | |||
695 | 695 | ||
696 | static int __devinit mthca_map_eq_regs(struct mthca_dev *dev) | 696 | static int __devinit mthca_map_eq_regs(struct mthca_dev *dev) |
697 | { | 697 | { |
698 | unsigned long mthca_base; | ||
699 | |||
700 | mthca_base = pci_resource_start(dev->pdev, 0); | ||
701 | |||
702 | if (mthca_is_memfree(dev)) { | 698 | if (mthca_is_memfree(dev)) { |
703 | /* | 699 | /* |
704 | * We assume that the EQ arm and EQ set CI registers | 700 | * We assume that the EQ arm and EQ set CI registers |
diff --git a/drivers/infiniband/hw/mthca/mthca_mad.c b/drivers/infiniband/hw/mthca/mthca_mad.c index 4730863ece9a..d9bc030bcccc 100644 --- a/drivers/infiniband/hw/mthca/mthca_mad.c +++ b/drivers/infiniband/hw/mthca/mthca_mad.c | |||
@@ -114,14 +114,22 @@ static void smp_snoop(struct ib_device *ibdev, | |||
114 | mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) && | 114 | mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) && |
115 | mad->mad_hdr.method == IB_MGMT_METHOD_SET) { | 115 | mad->mad_hdr.method == IB_MGMT_METHOD_SET) { |
116 | if (mad->mad_hdr.attr_id == IB_SMP_ATTR_PORT_INFO) { | 116 | if (mad->mad_hdr.attr_id == IB_SMP_ATTR_PORT_INFO) { |
117 | struct ib_port_info *pinfo = | ||
118 | (struct ib_port_info *) ((struct ib_smp *) mad)->data; | ||
119 | |||
117 | mthca_update_rate(to_mdev(ibdev), port_num); | 120 | mthca_update_rate(to_mdev(ibdev), port_num); |
118 | update_sm_ah(to_mdev(ibdev), port_num, | 121 | update_sm_ah(to_mdev(ibdev), port_num, |
119 | be16_to_cpup((__be16 *) (mad->data + 58)), | 122 | be16_to_cpu(pinfo->lid), |
120 | (*(u8 *) (mad->data + 76)) & 0xf); | 123 | pinfo->neighbormtu_mastersmsl & 0xf); |
121 | 124 | ||
122 | event.device = ibdev; | 125 | event.device = ibdev; |
123 | event.event = IB_EVENT_LID_CHANGE; | ||
124 | event.element.port_num = port_num; | 126 | event.element.port_num = port_num; |
127 | |||
128 | if(pinfo->clientrereg_resv_subnetto & 0x80) | ||
129 | event.event = IB_EVENT_CLIENT_REREGISTER; | ||
130 | else | ||
131 | event.event = IB_EVENT_LID_CHANGE; | ||
132 | |||
125 | ib_dispatch_event(&event); | 133 | ib_dispatch_event(&event); |
126 | } | 134 | } |
127 | 135 | ||
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c index a2eae8a30167..230ae21db8fd 100644 --- a/drivers/infiniband/hw/mthca/mthca_provider.c +++ b/drivers/infiniband/hw/mthca/mthca_provider.c | |||
@@ -115,6 +115,16 @@ static int mthca_query_device(struct ib_device *ibdev, | |||
115 | props->max_mcast_qp_attach = MTHCA_QP_PER_MGM; | 115 | props->max_mcast_qp_attach = MTHCA_QP_PER_MGM; |
116 | props->max_total_mcast_qp_attach = props->max_mcast_qp_attach * | 116 | props->max_total_mcast_qp_attach = props->max_mcast_qp_attach * |
117 | props->max_mcast_grp; | 117 | props->max_mcast_grp; |
118 | /* | ||
119 | * If Sinai memory key optimization is being used, then only | ||
120 | * the 8-bit key portion will change. For other HCAs, the | ||
121 | * unused index bits will also be used for FMR remapping. | ||
122 | */ | ||
123 | if (mdev->mthca_flags & MTHCA_FLAG_SINAI_OPT) | ||
124 | props->max_map_per_fmr = 255; | ||
125 | else | ||
126 | props->max_map_per_fmr = | ||
127 | (1 << (32 - long_log2(mdev->limits.num_mpts))) - 1; | ||
118 | 128 | ||
119 | err = 0; | 129 | err = 0; |
120 | out: | 130 | out: |
@@ -783,18 +793,24 @@ static int mthca_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *uda | |||
783 | if (entries < 1 || entries > dev->limits.max_cqes) | 793 | if (entries < 1 || entries > dev->limits.max_cqes) |
784 | return -EINVAL; | 794 | return -EINVAL; |
785 | 795 | ||
796 | mutex_lock(&cq->mutex); | ||
797 | |||
786 | entries = roundup_pow_of_two(entries + 1); | 798 | entries = roundup_pow_of_two(entries + 1); |
787 | if (entries == ibcq->cqe + 1) | 799 | if (entries == ibcq->cqe + 1) { |
788 | return 0; | 800 | ret = 0; |
801 | goto out; | ||
802 | } | ||
789 | 803 | ||
790 | if (cq->is_kernel) { | 804 | if (cq->is_kernel) { |
791 | ret = mthca_alloc_resize_buf(dev, cq, entries); | 805 | ret = mthca_alloc_resize_buf(dev, cq, entries); |
792 | if (ret) | 806 | if (ret) |
793 | return ret; | 807 | goto out; |
794 | lkey = cq->resize_buf->buf.mr.ibmr.lkey; | 808 | lkey = cq->resize_buf->buf.mr.ibmr.lkey; |
795 | } else { | 809 | } else { |
796 | if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) | 810 | if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) { |
797 | return -EFAULT; | 811 | ret = -EFAULT; |
812 | goto out; | ||
813 | } | ||
798 | lkey = ucmd.lkey; | 814 | lkey = ucmd.lkey; |
799 | } | 815 | } |
800 | 816 | ||
@@ -811,7 +827,7 @@ static int mthca_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *uda | |||
811 | cq->resize_buf = NULL; | 827 | cq->resize_buf = NULL; |
812 | spin_unlock_irq(&cq->lock); | 828 | spin_unlock_irq(&cq->lock); |
813 | } | 829 | } |
814 | return ret; | 830 | goto out; |
815 | } | 831 | } |
816 | 832 | ||
817 | if (cq->is_kernel) { | 833 | if (cq->is_kernel) { |
@@ -838,7 +854,10 @@ static int mthca_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *uda | |||
838 | } else | 854 | } else |
839 | ibcq->cqe = entries - 1; | 855 | ibcq->cqe = entries - 1; |
840 | 856 | ||
841 | return 0; | 857 | out: |
858 | mutex_unlock(&cq->mutex); | ||
859 | |||
860 | return ret; | ||
842 | } | 861 | } |
843 | 862 | ||
844 | static int mthca_destroy_cq(struct ib_cq *cq) | 863 | static int mthca_destroy_cq(struct ib_cq *cq) |
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.h b/drivers/infiniband/hw/mthca/mthca_provider.h index 179a8f610d0f..8de2887ba15c 100644 --- a/drivers/infiniband/hw/mthca/mthca_provider.h +++ b/drivers/infiniband/hw/mthca/mthca_provider.h | |||
@@ -214,6 +214,7 @@ struct mthca_cq { | |||
214 | int arm_sn; | 214 | int arm_sn; |
215 | 215 | ||
216 | wait_queue_head_t wait; | 216 | wait_queue_head_t wait; |
217 | struct mutex mutex; | ||
217 | }; | 218 | }; |
218 | 219 | ||
219 | struct mthca_srq { | 220 | struct mthca_srq { |
@@ -237,6 +238,7 @@ struct mthca_srq { | |||
237 | struct mthca_mr mr; | 238 | struct mthca_mr mr; |
238 | 239 | ||
239 | wait_queue_head_t wait; | 240 | wait_queue_head_t wait; |
241 | struct mutex mutex; | ||
240 | }; | 242 | }; |
241 | 243 | ||
242 | struct mthca_wq { | 244 | struct mthca_wq { |
@@ -278,6 +280,7 @@ struct mthca_qp { | |||
278 | union mthca_buf queue; | 280 | union mthca_buf queue; |
279 | 281 | ||
280 | wait_queue_head_t wait; | 282 | wait_queue_head_t wait; |
283 | struct mutex mutex; | ||
281 | }; | 284 | }; |
282 | 285 | ||
283 | struct mthca_sqp { | 286 | struct mthca_sqp { |
diff --git a/drivers/infiniband/hw/mthca/mthca_qp.c b/drivers/infiniband/hw/mthca/mthca_qp.c index 07c13be07a4a..16c387d8170c 100644 --- a/drivers/infiniband/hw/mthca/mthca_qp.c +++ b/drivers/infiniband/hw/mthca/mthca_qp.c | |||
@@ -534,7 +534,9 @@ int mthca_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, int attr_mask) | |||
534 | struct mthca_qp_context *qp_context; | 534 | struct mthca_qp_context *qp_context; |
535 | u32 sqd_event = 0; | 535 | u32 sqd_event = 0; |
536 | u8 status; | 536 | u8 status; |
537 | int err; | 537 | int err = -EINVAL; |
538 | |||
539 | mutex_lock(&qp->mutex); | ||
538 | 540 | ||
539 | if (attr_mask & IB_QP_CUR_STATE) { | 541 | if (attr_mask & IB_QP_CUR_STATE) { |
540 | cur_state = attr->cur_qp_state; | 542 | cur_state = attr->cur_qp_state; |
@@ -553,39 +555,41 @@ int mthca_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, int attr_mask) | |||
553 | "%d->%d with attr 0x%08x\n", | 555 | "%d->%d with attr 0x%08x\n", |
554 | qp->transport, cur_state, new_state, | 556 | qp->transport, cur_state, new_state, |
555 | attr_mask); | 557 | attr_mask); |
556 | return -EINVAL; | 558 | goto out; |
557 | } | 559 | } |
558 | 560 | ||
559 | if ((attr_mask & IB_QP_PKEY_INDEX) && | 561 | if ((attr_mask & IB_QP_PKEY_INDEX) && |
560 | attr->pkey_index >= dev->limits.pkey_table_len) { | 562 | attr->pkey_index >= dev->limits.pkey_table_len) { |
561 | mthca_dbg(dev, "P_Key index (%u) too large. max is %d\n", | 563 | mthca_dbg(dev, "P_Key index (%u) too large. max is %d\n", |
562 | attr->pkey_index, dev->limits.pkey_table_len-1); | 564 | attr->pkey_index, dev->limits.pkey_table_len-1); |
563 | return -EINVAL; | 565 | goto out; |
564 | } | 566 | } |
565 | 567 | ||
566 | if ((attr_mask & IB_QP_PORT) && | 568 | if ((attr_mask & IB_QP_PORT) && |
567 | (attr->port_num == 0 || attr->port_num > dev->limits.num_ports)) { | 569 | (attr->port_num == 0 || attr->port_num > dev->limits.num_ports)) { |
568 | mthca_dbg(dev, "Port number (%u) is invalid\n", attr->port_num); | 570 | mthca_dbg(dev, "Port number (%u) is invalid\n", attr->port_num); |
569 | return -EINVAL; | 571 | goto out; |
570 | } | 572 | } |
571 | 573 | ||
572 | if (attr_mask & IB_QP_MAX_QP_RD_ATOMIC && | 574 | if (attr_mask & IB_QP_MAX_QP_RD_ATOMIC && |
573 | attr->max_rd_atomic > dev->limits.max_qp_init_rdma) { | 575 | attr->max_rd_atomic > dev->limits.max_qp_init_rdma) { |
574 | mthca_dbg(dev, "Max rdma_atomic as initiator %u too large (max is %d)\n", | 576 | mthca_dbg(dev, "Max rdma_atomic as initiator %u too large (max is %d)\n", |
575 | attr->max_rd_atomic, dev->limits.max_qp_init_rdma); | 577 | attr->max_rd_atomic, dev->limits.max_qp_init_rdma); |
576 | return -EINVAL; | 578 | goto out; |
577 | } | 579 | } |
578 | 580 | ||
579 | if (attr_mask & IB_QP_MAX_DEST_RD_ATOMIC && | 581 | if (attr_mask & IB_QP_MAX_DEST_RD_ATOMIC && |
580 | attr->max_dest_rd_atomic > 1 << dev->qp_table.rdb_shift) { | 582 | attr->max_dest_rd_atomic > 1 << dev->qp_table.rdb_shift) { |
581 | mthca_dbg(dev, "Max rdma_atomic as responder %u too large (max %d)\n", | 583 | mthca_dbg(dev, "Max rdma_atomic as responder %u too large (max %d)\n", |
582 | attr->max_dest_rd_atomic, 1 << dev->qp_table.rdb_shift); | 584 | attr->max_dest_rd_atomic, 1 << dev->qp_table.rdb_shift); |
583 | return -EINVAL; | 585 | goto out; |
584 | } | 586 | } |
585 | 587 | ||
586 | mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL); | 588 | mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL); |
587 | if (IS_ERR(mailbox)) | 589 | if (IS_ERR(mailbox)) { |
588 | return PTR_ERR(mailbox); | 590 | err = PTR_ERR(mailbox); |
591 | goto out; | ||
592 | } | ||
589 | qp_param = mailbox->buf; | 593 | qp_param = mailbox->buf; |
590 | qp_context = &qp_param->context; | 594 | qp_context = &qp_param->context; |
591 | memset(qp_param, 0, sizeof *qp_param); | 595 | memset(qp_param, 0, sizeof *qp_param); |
@@ -618,7 +622,7 @@ int mthca_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, int attr_mask) | |||
618 | if (attr->path_mtu < IB_MTU_256 || attr->path_mtu > IB_MTU_2048) { | 622 | if (attr->path_mtu < IB_MTU_256 || attr->path_mtu > IB_MTU_2048) { |
619 | mthca_dbg(dev, "path MTU (%u) is invalid\n", | 623 | mthca_dbg(dev, "path MTU (%u) is invalid\n", |
620 | attr->path_mtu); | 624 | attr->path_mtu); |
621 | return -EINVAL; | 625 | goto out_mailbox; |
622 | } | 626 | } |
623 | qp_context->mtu_msgmax = (attr->path_mtu << 5) | 31; | 627 | qp_context->mtu_msgmax = (attr->path_mtu << 5) | 31; |
624 | } | 628 | } |
@@ -672,7 +676,7 @@ int mthca_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, int attr_mask) | |||
672 | if (attr_mask & IB_QP_AV) { | 676 | if (attr_mask & IB_QP_AV) { |
673 | if (mthca_path_set(dev, &attr->ah_attr, &qp_context->pri_path, | 677 | if (mthca_path_set(dev, &attr->ah_attr, &qp_context->pri_path, |
674 | attr_mask & IB_QP_PORT ? attr->port_num : qp->port)) | 678 | attr_mask & IB_QP_PORT ? attr->port_num : qp->port)) |
675 | return -EINVAL; | 679 | goto out_mailbox; |
676 | 680 | ||
677 | qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_PRIMARY_ADDR_PATH); | 681 | qp_param->opt_param_mask |= cpu_to_be32(MTHCA_QP_OPTPAR_PRIMARY_ADDR_PATH); |
678 | } | 682 | } |
@@ -686,18 +690,18 @@ int mthca_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, int attr_mask) | |||
686 | if (attr->alt_pkey_index >= dev->limits.pkey_table_len) { | 690 | if (attr->alt_pkey_index >= dev->limits.pkey_table_len) { |
687 | mthca_dbg(dev, "Alternate P_Key index (%u) too large. max is %d\n", | 691 | mthca_dbg(dev, "Alternate P_Key index (%u) too large. max is %d\n", |
688 | attr->alt_pkey_index, dev->limits.pkey_table_len-1); | 692 | attr->alt_pkey_index, dev->limits.pkey_table_len-1); |
689 | return -EINVAL; | 693 | goto out_mailbox; |
690 | } | 694 | } |
691 | 695 | ||
692 | if (attr->alt_port_num == 0 || attr->alt_port_num > dev->limits.num_ports) { | 696 | if (attr->alt_port_num == 0 || attr->alt_port_num > dev->limits.num_ports) { |
693 | mthca_dbg(dev, "Alternate port number (%u) is invalid\n", | 697 | mthca_dbg(dev, "Alternate port number (%u) is invalid\n", |
694 | attr->alt_port_num); | 698 | attr->alt_port_num); |
695 | return -EINVAL; | 699 | goto out_mailbox; |
696 | } | 700 | } |
697 | 701 | ||
698 | if (mthca_path_set(dev, &attr->alt_ah_attr, &qp_context->alt_path, | 702 | if (mthca_path_set(dev, &attr->alt_ah_attr, &qp_context->alt_path, |
699 | attr->alt_ah_attr.port_num)) | 703 | attr->alt_ah_attr.port_num)) |
700 | return -EINVAL; | 704 | goto out_mailbox; |
701 | 705 | ||
702 | qp_context->alt_path.port_pkey |= cpu_to_be32(attr->alt_pkey_index | | 706 | qp_context->alt_path.port_pkey |= cpu_to_be32(attr->alt_pkey_index | |
703 | attr->alt_port_num << 24); | 707 | attr->alt_port_num << 24); |
@@ -793,12 +797,12 @@ int mthca_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, int attr_mask) | |||
793 | err = mthca_MODIFY_QP(dev, cur_state, new_state, qp->qpn, 0, | 797 | err = mthca_MODIFY_QP(dev, cur_state, new_state, qp->qpn, 0, |
794 | mailbox, sqd_event, &status); | 798 | mailbox, sqd_event, &status); |
795 | if (err) | 799 | if (err) |
796 | goto out; | 800 | goto out_mailbox; |
797 | if (status) { | 801 | if (status) { |
798 | mthca_warn(dev, "modify QP %d->%d returned status %02x.\n", | 802 | mthca_warn(dev, "modify QP %d->%d returned status %02x.\n", |
799 | cur_state, new_state, status); | 803 | cur_state, new_state, status); |
800 | err = -EINVAL; | 804 | err = -EINVAL; |
801 | goto out; | 805 | goto out_mailbox; |
802 | } | 806 | } |
803 | 807 | ||
804 | qp->state = new_state; | 808 | qp->state = new_state; |
@@ -853,8 +857,11 @@ int mthca_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, int attr_mask) | |||
853 | } | 857 | } |
854 | } | 858 | } |
855 | 859 | ||
856 | out: | 860 | out_mailbox: |
857 | mthca_free_mailbox(dev, mailbox); | 861 | mthca_free_mailbox(dev, mailbox); |
862 | |||
863 | out: | ||
864 | mutex_unlock(&qp->mutex); | ||
858 | return err; | 865 | return err; |
859 | } | 866 | } |
860 | 867 | ||
@@ -1100,6 +1107,7 @@ static int mthca_alloc_qp_common(struct mthca_dev *dev, | |||
1100 | 1107 | ||
1101 | qp->refcount = 1; | 1108 | qp->refcount = 1; |
1102 | init_waitqueue_head(&qp->wait); | 1109 | init_waitqueue_head(&qp->wait); |
1110 | mutex_init(&qp->mutex); | ||
1103 | qp->state = IB_QPS_RESET; | 1111 | qp->state = IB_QPS_RESET; |
1104 | qp->atomic_rd_en = 0; | 1112 | qp->atomic_rd_en = 0; |
1105 | qp->resp_depth = 0; | 1113 | qp->resp_depth = 0; |
diff --git a/drivers/infiniband/hw/mthca/mthca_reset.c b/drivers/infiniband/hw/mthca/mthca_reset.c index df5e494a9d38..f4fddd5327f5 100644 --- a/drivers/infiniband/hw/mthca/mthca_reset.c +++ b/drivers/infiniband/hw/mthca/mthca_reset.c | |||
@@ -49,6 +49,12 @@ int mthca_reset(struct mthca_dev *mdev) | |||
49 | u32 *hca_header = NULL; | 49 | u32 *hca_header = NULL; |
50 | u32 *bridge_header = NULL; | 50 | u32 *bridge_header = NULL; |
51 | struct pci_dev *bridge = NULL; | 51 | struct pci_dev *bridge = NULL; |
52 | int bridge_pcix_cap = 0; | ||
53 | int hca_pcie_cap = 0; | ||
54 | int hca_pcix_cap = 0; | ||
55 | |||
56 | u16 devctl; | ||
57 | u16 linkctl; | ||
52 | 58 | ||
53 | #define MTHCA_RESET_OFFSET 0xf0010 | 59 | #define MTHCA_RESET_OFFSET 0xf0010 |
54 | #define MTHCA_RESET_VALUE swab32(1) | 60 | #define MTHCA_RESET_VALUE swab32(1) |
@@ -110,6 +116,9 @@ int mthca_reset(struct mthca_dev *mdev) | |||
110 | } | 116 | } |
111 | } | 117 | } |
112 | 118 | ||
119 | hca_pcix_cap = pci_find_capability(mdev->pdev, PCI_CAP_ID_PCIX); | ||
120 | hca_pcie_cap = pci_find_capability(mdev->pdev, PCI_CAP_ID_EXP); | ||
121 | |||
113 | if (bridge) { | 122 | if (bridge) { |
114 | bridge_header = kmalloc(256, GFP_KERNEL); | 123 | bridge_header = kmalloc(256, GFP_KERNEL); |
115 | if (!bridge_header) { | 124 | if (!bridge_header) { |
@@ -129,6 +138,13 @@ int mthca_reset(struct mthca_dev *mdev) | |||
129 | goto out; | 138 | goto out; |
130 | } | 139 | } |
131 | } | 140 | } |
141 | bridge_pcix_cap = pci_find_capability(bridge, PCI_CAP_ID_PCIX); | ||
142 | if (!bridge_pcix_cap) { | ||
143 | err = -ENODEV; | ||
144 | mthca_err(mdev, "Couldn't locate HCA bridge " | ||
145 | "PCI-X capability, aborting.\n"); | ||
146 | goto out; | ||
147 | } | ||
132 | } | 148 | } |
133 | 149 | ||
134 | /* actually hit reset */ | 150 | /* actually hit reset */ |
@@ -178,6 +194,20 @@ int mthca_reset(struct mthca_dev *mdev) | |||
178 | good: | 194 | good: |
179 | /* Now restore the PCI headers */ | 195 | /* Now restore the PCI headers */ |
180 | if (bridge) { | 196 | if (bridge) { |
197 | if (pci_write_config_dword(bridge, bridge_pcix_cap + 0x8, | ||
198 | bridge_header[(bridge_pcix_cap + 0x8) / 4])) { | ||
199 | err = -ENODEV; | ||
200 | mthca_err(mdev, "Couldn't restore HCA bridge Upstream " | ||
201 | "split transaction control, aborting.\n"); | ||
202 | goto out; | ||
203 | } | ||
204 | if (pci_write_config_dword(bridge, bridge_pcix_cap + 0xc, | ||
205 | bridge_header[(bridge_pcix_cap + 0xc) / 4])) { | ||
206 | err = -ENODEV; | ||
207 | mthca_err(mdev, "Couldn't restore HCA bridge Downstream " | ||
208 | "split transaction control, aborting.\n"); | ||
209 | goto out; | ||
210 | } | ||
181 | /* | 211 | /* |
182 | * Bridge control register is at 0x3e, so we'll | 212 | * Bridge control register is at 0x3e, so we'll |
183 | * naturally restore it last in this loop. | 213 | * naturally restore it last in this loop. |
@@ -203,6 +233,35 @@ good: | |||
203 | } | 233 | } |
204 | } | 234 | } |
205 | 235 | ||
236 | if (hca_pcix_cap) { | ||
237 | if (pci_write_config_dword(mdev->pdev, hca_pcix_cap, | ||
238 | hca_header[hca_pcix_cap / 4])) { | ||
239 | err = -ENODEV; | ||
240 | mthca_err(mdev, "Couldn't restore HCA PCI-X " | ||
241 | "command register, aborting.\n"); | ||
242 | goto out; | ||
243 | } | ||
244 | } | ||
245 | |||
246 | if (hca_pcie_cap) { | ||
247 | devctl = hca_header[(hca_pcie_cap + PCI_EXP_DEVCTL) / 4]; | ||
248 | if (pci_write_config_word(mdev->pdev, hca_pcie_cap + PCI_EXP_DEVCTL, | ||
249 | devctl)) { | ||
250 | err = -ENODEV; | ||
251 | mthca_err(mdev, "Couldn't restore HCA PCI Express " | ||
252 | "Device Control register, aborting.\n"); | ||
253 | goto out; | ||
254 | } | ||
255 | linkctl = hca_header[(hca_pcie_cap + PCI_EXP_LNKCTL) / 4]; | ||
256 | if (pci_write_config_word(mdev->pdev, hca_pcie_cap + PCI_EXP_LNKCTL, | ||
257 | linkctl)) { | ||
258 | err = -ENODEV; | ||
259 | mthca_err(mdev, "Couldn't restore HCA PCI Express " | ||
260 | "Link control register, aborting.\n"); | ||
261 | goto out; | ||
262 | } | ||
263 | } | ||
264 | |||
206 | for (i = 0; i < 16; ++i) { | 265 | for (i = 0; i < 16; ++i) { |
207 | if (i * 4 == PCI_COMMAND) | 266 | if (i * 4 == PCI_COMMAND) |
208 | continue; | 267 | continue; |
diff --git a/drivers/infiniband/hw/mthca/mthca_srq.c b/drivers/infiniband/hw/mthca/mthca_srq.c index b292fefa3b41..fab417c5cf43 100644 --- a/drivers/infiniband/hw/mthca/mthca_srq.c +++ b/drivers/infiniband/hw/mthca/mthca_srq.c | |||
@@ -243,6 +243,7 @@ int mthca_alloc_srq(struct mthca_dev *dev, struct mthca_pd *pd, | |||
243 | spin_lock_init(&srq->lock); | 243 | spin_lock_init(&srq->lock); |
244 | srq->refcount = 1; | 244 | srq->refcount = 1; |
245 | init_waitqueue_head(&srq->wait); | 245 | init_waitqueue_head(&srq->wait); |
246 | mutex_init(&srq->mutex); | ||
246 | 247 | ||
247 | if (mthca_is_memfree(dev)) | 248 | if (mthca_is_memfree(dev)) |
248 | mthca_arbel_init_srq_context(dev, pd, srq, mailbox->buf); | 249 | mthca_arbel_init_srq_context(dev, pd, srq, mailbox->buf); |
@@ -371,7 +372,11 @@ int mthca_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr, | |||
371 | if (attr_mask & IB_SRQ_LIMIT) { | 372 | if (attr_mask & IB_SRQ_LIMIT) { |
372 | if (attr->srq_limit > srq->max) | 373 | if (attr->srq_limit > srq->max) |
373 | return -EINVAL; | 374 | return -EINVAL; |
375 | |||
376 | mutex_lock(&srq->mutex); | ||
374 | ret = mthca_ARM_SRQ(dev, srq->srqn, attr->srq_limit, &status); | 377 | ret = mthca_ARM_SRQ(dev, srq->srqn, attr->srq_limit, &status); |
378 | mutex_unlock(&srq->mutex); | ||
379 | |||
375 | if (ret) | 380 | if (ret) |
376 | return ret; | 381 | return ret; |
377 | if (status) | 382 | if (status) |
diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h index 12a1e0572ef2..491d2afaf5b4 100644 --- a/drivers/infiniband/ulp/ipoib/ipoib.h +++ b/drivers/infiniband/ulp/ipoib/ipoib.h | |||
@@ -272,8 +272,7 @@ int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port); | |||
272 | void ipoib_dev_cleanup(struct net_device *dev); | 272 | void ipoib_dev_cleanup(struct net_device *dev); |
273 | 273 | ||
274 | void ipoib_mcast_join_task(void *dev_ptr); | 274 | void ipoib_mcast_join_task(void *dev_ptr); |
275 | void ipoib_mcast_send(struct net_device *dev, union ib_gid *mgid, | 275 | void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb); |
276 | struct sk_buff *skb); | ||
277 | 276 | ||
278 | void ipoib_mcast_restart_task(void *dev_ptr); | 277 | void ipoib_mcast_restart_task(void *dev_ptr); |
279 | int ipoib_mcast_start_thread(struct net_device *dev); | 278 | int ipoib_mcast_start_thread(struct net_device *dev); |
@@ -369,15 +368,26 @@ extern int ipoib_debug_level; | |||
369 | #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */ | 368 | #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */ |
370 | 369 | ||
371 | 370 | ||
372 | #define IPOIB_GID_FMT "%x:%x:%x:%x:%x:%x:%x:%x" | 371 | #define IPOIB_GID_FMT "%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:" \ |
373 | 372 | "%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x" | |
374 | #define IPOIB_GID_ARG(gid) be16_to_cpup((__be16 *) ((gid).raw + 0)), \ | 373 | |
375 | be16_to_cpup((__be16 *) ((gid).raw + 2)), \ | 374 | #define IPOIB_GID_RAW_ARG(gid) ((u8 *)(gid))[0], \ |
376 | be16_to_cpup((__be16 *) ((gid).raw + 4)), \ | 375 | ((u8 *)(gid))[1], \ |
377 | be16_to_cpup((__be16 *) ((gid).raw + 6)), \ | 376 | ((u8 *)(gid))[2], \ |
378 | be16_to_cpup((__be16 *) ((gid).raw + 8)), \ | 377 | ((u8 *)(gid))[3], \ |
379 | be16_to_cpup((__be16 *) ((gid).raw + 10)), \ | 378 | ((u8 *)(gid))[4], \ |
380 | be16_to_cpup((__be16 *) ((gid).raw + 12)), \ | 379 | ((u8 *)(gid))[5], \ |
381 | be16_to_cpup((__be16 *) ((gid).raw + 14)) | 380 | ((u8 *)(gid))[6], \ |
381 | ((u8 *)(gid))[7], \ | ||
382 | ((u8 *)(gid))[8], \ | ||
383 | ((u8 *)(gid))[9], \ | ||
384 | ((u8 *)(gid))[10],\ | ||
385 | ((u8 *)(gid))[11],\ | ||
386 | ((u8 *)(gid))[12],\ | ||
387 | ((u8 *)(gid))[13],\ | ||
388 | ((u8 *)(gid))[14],\ | ||
389 | ((u8 *)(gid))[15] | ||
390 | |||
391 | #define IPOIB_GID_ARG(gid) IPOIB_GID_RAW_ARG((gid).raw) | ||
382 | 392 | ||
383 | #endif /* _IPOIB_H */ | 393 | #endif /* _IPOIB_H */ |
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c index 8406839b91cf..5033666b1481 100644 --- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c +++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c | |||
@@ -84,15 +84,9 @@ void ipoib_free_ah(struct kref *kref) | |||
84 | 84 | ||
85 | unsigned long flags; | 85 | unsigned long flags; |
86 | 86 | ||
87 | if ((int) priv->tx_tail - (int) ah->last_send >= 0) { | 87 | spin_lock_irqsave(&priv->lock, flags); |
88 | ipoib_dbg(priv, "Freeing ah %p\n", ah->ah); | 88 | list_add_tail(&ah->list, &priv->dead_ahs); |
89 | ib_destroy_ah(ah->ah); | 89 | spin_unlock_irqrestore(&priv->lock, flags); |
90 | kfree(ah); | ||
91 | } else { | ||
92 | spin_lock_irqsave(&priv->lock, flags); | ||
93 | list_add_tail(&ah->list, &priv->dead_ahs); | ||
94 | spin_unlock_irqrestore(&priv->lock, flags); | ||
95 | } | ||
96 | } | 90 | } |
97 | 91 | ||
98 | static int ipoib_ib_post_receive(struct net_device *dev, int id) | 92 | static int ipoib_ib_post_receive(struct net_device *dev, int id) |
@@ -377,19 +371,16 @@ static void __ipoib_reap_ah(struct net_device *dev) | |||
377 | struct ipoib_ah *ah, *tah; | 371 | struct ipoib_ah *ah, *tah; |
378 | LIST_HEAD(remove_list); | 372 | LIST_HEAD(remove_list); |
379 | 373 | ||
380 | spin_lock_irq(&priv->lock); | 374 | spin_lock_irq(&priv->tx_lock); |
375 | spin_lock(&priv->lock); | ||
381 | list_for_each_entry_safe(ah, tah, &priv->dead_ahs, list) | 376 | list_for_each_entry_safe(ah, tah, &priv->dead_ahs, list) |
382 | if ((int) priv->tx_tail - (int) ah->last_send >= 0) { | 377 | if ((int) priv->tx_tail - (int) ah->last_send >= 0) { |
383 | list_del(&ah->list); | 378 | list_del(&ah->list); |
384 | list_add_tail(&ah->list, &remove_list); | 379 | ib_destroy_ah(ah->ah); |
380 | kfree(ah); | ||
385 | } | 381 | } |
386 | spin_unlock_irq(&priv->lock); | 382 | spin_unlock(&priv->lock); |
387 | 383 | spin_unlock_irq(&priv->tx_lock); | |
388 | list_for_each_entry_safe(ah, tah, &remove_list, list) { | ||
389 | ipoib_dbg(priv, "Reaping ah %p\n", ah->ah); | ||
390 | ib_destroy_ah(ah->ah); | ||
391 | kfree(ah); | ||
392 | } | ||
393 | } | 384 | } |
394 | 385 | ||
395 | void ipoib_reap_ah(void *dev_ptr) | 386 | void ipoib_reap_ah(void *dev_ptr) |
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c index cb078a7d0bf5..1c6ea1c682a5 100644 --- a/drivers/infiniband/ulp/ipoib/ipoib_main.c +++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c | |||
@@ -185,8 +185,7 @@ static int ipoib_change_mtu(struct net_device *dev, int new_mtu) | |||
185 | return 0; | 185 | return 0; |
186 | } | 186 | } |
187 | 187 | ||
188 | static struct ipoib_path *__path_find(struct net_device *dev, | 188 | static struct ipoib_path *__path_find(struct net_device *dev, void *gid) |
189 | union ib_gid *gid) | ||
190 | { | 189 | { |
191 | struct ipoib_dev_priv *priv = netdev_priv(dev); | 190 | struct ipoib_dev_priv *priv = netdev_priv(dev); |
192 | struct rb_node *n = priv->path_tree.rb_node; | 191 | struct rb_node *n = priv->path_tree.rb_node; |
@@ -196,7 +195,7 @@ static struct ipoib_path *__path_find(struct net_device *dev, | |||
196 | while (n) { | 195 | while (n) { |
197 | path = rb_entry(n, struct ipoib_path, rb_node); | 196 | path = rb_entry(n, struct ipoib_path, rb_node); |
198 | 197 | ||
199 | ret = memcmp(gid->raw, path->pathrec.dgid.raw, | 198 | ret = memcmp(gid, path->pathrec.dgid.raw, |
200 | sizeof (union ib_gid)); | 199 | sizeof (union ib_gid)); |
201 | 200 | ||
202 | if (ret < 0) | 201 | if (ret < 0) |
@@ -424,8 +423,7 @@ static void path_rec_completion(int status, | |||
424 | } | 423 | } |
425 | } | 424 | } |
426 | 425 | ||
427 | static struct ipoib_path *path_rec_create(struct net_device *dev, | 426 | static struct ipoib_path *path_rec_create(struct net_device *dev, void *gid) |
428 | union ib_gid *gid) | ||
429 | { | 427 | { |
430 | struct ipoib_dev_priv *priv = netdev_priv(dev); | 428 | struct ipoib_dev_priv *priv = netdev_priv(dev); |
431 | struct ipoib_path *path; | 429 | struct ipoib_path *path; |
@@ -440,7 +438,7 @@ static struct ipoib_path *path_rec_create(struct net_device *dev, | |||
440 | 438 | ||
441 | INIT_LIST_HEAD(&path->neigh_list); | 439 | INIT_LIST_HEAD(&path->neigh_list); |
442 | 440 | ||
443 | memcpy(path->pathrec.dgid.raw, gid->raw, sizeof (union ib_gid)); | 441 | memcpy(path->pathrec.dgid.raw, gid, sizeof (union ib_gid)); |
444 | path->pathrec.sgid = priv->local_gid; | 442 | path->pathrec.sgid = priv->local_gid; |
445 | path->pathrec.pkey = cpu_to_be16(priv->pkey); | 443 | path->pathrec.pkey = cpu_to_be16(priv->pkey); |
446 | path->pathrec.numb_path = 1; | 444 | path->pathrec.numb_path = 1; |
@@ -498,10 +496,9 @@ static void neigh_add_path(struct sk_buff *skb, struct net_device *dev) | |||
498 | */ | 496 | */ |
499 | spin_lock(&priv->lock); | 497 | spin_lock(&priv->lock); |
500 | 498 | ||
501 | path = __path_find(dev, (union ib_gid *) (skb->dst->neighbour->ha + 4)); | 499 | path = __path_find(dev, skb->dst->neighbour->ha + 4); |
502 | if (!path) { | 500 | if (!path) { |
503 | path = path_rec_create(dev, | 501 | path = path_rec_create(dev, skb->dst->neighbour->ha + 4); |
504 | (union ib_gid *) (skb->dst->neighbour->ha + 4)); | ||
505 | if (!path) | 502 | if (!path) |
506 | goto err_path; | 503 | goto err_path; |
507 | 504 | ||
@@ -551,7 +548,7 @@ static void ipoib_path_lookup(struct sk_buff *skb, struct net_device *dev) | |||
551 | /* Add in the P_Key for multicasts */ | 548 | /* Add in the P_Key for multicasts */ |
552 | skb->dst->neighbour->ha[8] = (priv->pkey >> 8) & 0xff; | 549 | skb->dst->neighbour->ha[8] = (priv->pkey >> 8) & 0xff; |
553 | skb->dst->neighbour->ha[9] = priv->pkey & 0xff; | 550 | skb->dst->neighbour->ha[9] = priv->pkey & 0xff; |
554 | ipoib_mcast_send(dev, (union ib_gid *) (skb->dst->neighbour->ha + 4), skb); | 551 | ipoib_mcast_send(dev, skb->dst->neighbour->ha + 4, skb); |
555 | } | 552 | } |
556 | 553 | ||
557 | static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev, | 554 | static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev, |
@@ -566,10 +563,9 @@ static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev, | |||
566 | */ | 563 | */ |
567 | spin_lock(&priv->lock); | 564 | spin_lock(&priv->lock); |
568 | 565 | ||
569 | path = __path_find(dev, (union ib_gid *) (phdr->hwaddr + 4)); | 566 | path = __path_find(dev, phdr->hwaddr + 4); |
570 | if (!path) { | 567 | if (!path) { |
571 | path = path_rec_create(dev, | 568 | path = path_rec_create(dev, phdr->hwaddr + 4); |
572 | (union ib_gid *) (phdr->hwaddr + 4)); | ||
573 | if (path) { | 569 | if (path) { |
574 | /* put pseudoheader back on for next time */ | 570 | /* put pseudoheader back on for next time */ |
575 | skb_push(skb, sizeof *phdr); | 571 | skb_push(skb, sizeof *phdr); |
@@ -660,7 +656,7 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
660 | phdr->hwaddr[8] = (priv->pkey >> 8) & 0xff; | 656 | phdr->hwaddr[8] = (priv->pkey >> 8) & 0xff; |
661 | phdr->hwaddr[9] = priv->pkey & 0xff; | 657 | phdr->hwaddr[9] = priv->pkey & 0xff; |
662 | 658 | ||
663 | ipoib_mcast_send(dev, (union ib_gid *) (phdr->hwaddr + 4), skb); | 659 | ipoib_mcast_send(dev, phdr->hwaddr + 4, skb); |
664 | } else { | 660 | } else { |
665 | /* unicast GID -- should be ARP or RARP reply */ | 661 | /* unicast GID -- should be ARP or RARP reply */ |
666 | 662 | ||
@@ -671,7 +667,7 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
671 | skb->dst ? "neigh" : "dst", | 667 | skb->dst ? "neigh" : "dst", |
672 | be16_to_cpup((__be16 *) skb->data), | 668 | be16_to_cpup((__be16 *) skb->data), |
673 | be32_to_cpup((__be32 *) phdr->hwaddr), | 669 | be32_to_cpup((__be32 *) phdr->hwaddr), |
674 | IPOIB_GID_ARG(*(union ib_gid *) (phdr->hwaddr + 4))); | 670 | IPOIB_GID_RAW_ARG(phdr->hwaddr + 4)); |
675 | dev_kfree_skb_any(skb); | 671 | dev_kfree_skb_any(skb); |
676 | ++priv->stats.tx_dropped; | 672 | ++priv->stats.tx_dropped; |
677 | goto out; | 673 | goto out; |
@@ -754,7 +750,7 @@ static void ipoib_neigh_destructor(struct neighbour *n) | |||
754 | ipoib_dbg(priv, | 750 | ipoib_dbg(priv, |
755 | "neigh_destructor for %06x " IPOIB_GID_FMT "\n", | 751 | "neigh_destructor for %06x " IPOIB_GID_FMT "\n", |
756 | be32_to_cpup((__be32 *) n->ha), | 752 | be32_to_cpup((__be32 *) n->ha), |
757 | IPOIB_GID_ARG(*((union ib_gid *) (n->ha + 4)))); | 753 | IPOIB_GID_RAW_ARG(n->ha + 4)); |
758 | 754 | ||
759 | spin_lock_irqsave(&priv->lock, flags); | 755 | spin_lock_irqsave(&priv->lock, flags); |
760 | 756 | ||
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c index 1dae4b238252..216471fa01cc 100644 --- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c +++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c | |||
@@ -154,7 +154,7 @@ static struct ipoib_mcast *ipoib_mcast_alloc(struct net_device *dev, | |||
154 | return mcast; | 154 | return mcast; |
155 | } | 155 | } |
156 | 156 | ||
157 | static struct ipoib_mcast *__ipoib_mcast_find(struct net_device *dev, union ib_gid *mgid) | 157 | static struct ipoib_mcast *__ipoib_mcast_find(struct net_device *dev, void *mgid) |
158 | { | 158 | { |
159 | struct ipoib_dev_priv *priv = netdev_priv(dev); | 159 | struct ipoib_dev_priv *priv = netdev_priv(dev); |
160 | struct rb_node *n = priv->multicast_tree.rb_node; | 160 | struct rb_node *n = priv->multicast_tree.rb_node; |
@@ -165,7 +165,7 @@ static struct ipoib_mcast *__ipoib_mcast_find(struct net_device *dev, union ib_g | |||
165 | 165 | ||
166 | mcast = rb_entry(n, struct ipoib_mcast, rb_node); | 166 | mcast = rb_entry(n, struct ipoib_mcast, rb_node); |
167 | 167 | ||
168 | ret = memcmp(mgid->raw, mcast->mcmember.mgid.raw, | 168 | ret = memcmp(mgid, mcast->mcmember.mgid.raw, |
169 | sizeof (union ib_gid)); | 169 | sizeof (union ib_gid)); |
170 | if (ret < 0) | 170 | if (ret < 0) |
171 | n = n->rb_left; | 171 | n = n->rb_left; |
@@ -694,8 +694,7 @@ static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast) | |||
694 | return 0; | 694 | return 0; |
695 | } | 695 | } |
696 | 696 | ||
697 | void ipoib_mcast_send(struct net_device *dev, union ib_gid *mgid, | 697 | void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb) |
698 | struct sk_buff *skb) | ||
699 | { | 698 | { |
700 | struct ipoib_dev_priv *priv = netdev_priv(dev); | 699 | struct ipoib_dev_priv *priv = netdev_priv(dev); |
701 | struct ipoib_mcast *mcast; | 700 | struct ipoib_mcast *mcast; |
@@ -718,7 +717,7 @@ void ipoib_mcast_send(struct net_device *dev, union ib_gid *mgid, | |||
718 | if (!mcast) { | 717 | if (!mcast) { |
719 | /* Let's create a new send only group now */ | 718 | /* Let's create a new send only group now */ |
720 | ipoib_dbg_mcast(priv, "setting up send only multicast group for " | 719 | ipoib_dbg_mcast(priv, "setting up send only multicast group for " |
721 | IPOIB_GID_FMT "\n", IPOIB_GID_ARG(*mgid)); | 720 | IPOIB_GID_FMT "\n", IPOIB_GID_RAW_ARG(mgid)); |
722 | 721 | ||
723 | mcast = ipoib_mcast_alloc(dev, 0); | 722 | mcast = ipoib_mcast_alloc(dev, 0); |
724 | if (!mcast) { | 723 | if (!mcast) { |
@@ -730,7 +729,7 @@ void ipoib_mcast_send(struct net_device *dev, union ib_gid *mgid, | |||
730 | } | 729 | } |
731 | 730 | ||
732 | set_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags); | 731 | set_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags); |
733 | mcast->mcmember.mgid = *mgid; | 732 | memcpy(mcast->mcmember.mgid.raw, mgid, sizeof (union ib_gid)); |
734 | __ipoib_mcast_add(dev, mcast); | 733 | __ipoib_mcast_add(dev, mcast); |
735 | list_add_tail(&mcast->list, &priv->multicast_list); | 734 | list_add_tail(&mcast->list, &priv->multicast_list); |
736 | } | 735 | } |
@@ -821,7 +820,8 @@ void ipoib_mcast_restart_task(void *dev_ptr) | |||
821 | 820 | ||
822 | ipoib_mcast_stop_thread(dev, 0); | 821 | ipoib_mcast_stop_thread(dev, 0); |
823 | 822 | ||
824 | spin_lock_irqsave(&dev->xmit_lock, flags); | 823 | local_irq_save(flags); |
824 | netif_tx_lock(dev); | ||
825 | spin_lock(&priv->lock); | 825 | spin_lock(&priv->lock); |
826 | 826 | ||
827 | /* | 827 | /* |
@@ -896,7 +896,8 @@ void ipoib_mcast_restart_task(void *dev_ptr) | |||
896 | } | 896 | } |
897 | 897 | ||
898 | spin_unlock(&priv->lock); | 898 | spin_unlock(&priv->lock); |
899 | spin_unlock_irqrestore(&dev->xmit_lock, flags); | 899 | netif_tx_unlock(dev); |
900 | local_irq_restore(flags); | ||
900 | 901 | ||
901 | /* We have to cancel outside of the spinlock */ | 902 | /* We have to cancel outside of the spinlock */ |
902 | list_for_each_entry_safe(mcast, tmcast, &remove_list, list) { | 903 | list_for_each_entry_safe(mcast, tmcast, &remove_list, list) { |
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c index 1d49d1643c59..7b717c648f72 100644 --- a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c +++ b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c | |||
@@ -255,7 +255,8 @@ void ipoib_event(struct ib_event_handler *handler, | |||
255 | record->event == IB_EVENT_PKEY_CHANGE || | 255 | record->event == IB_EVENT_PKEY_CHANGE || |
256 | record->event == IB_EVENT_PORT_ACTIVE || | 256 | record->event == IB_EVENT_PORT_ACTIVE || |
257 | record->event == IB_EVENT_LID_CHANGE || | 257 | record->event == IB_EVENT_LID_CHANGE || |
258 | record->event == IB_EVENT_SM_CHANGE) { | 258 | record->event == IB_EVENT_SM_CHANGE || |
259 | record->event == IB_EVENT_CLIENT_REREGISTER) { | ||
259 | ipoib_dbg(priv, "Port state change event\n"); | 260 | ipoib_dbg(priv, "Port state change event\n"); |
260 | queue_work(ipoib_workqueue, &priv->flush_task); | 261 | queue_work(ipoib_workqueue, &priv->flush_task); |
261 | } | 262 | } |
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c index 9cbdffa08dc2..4e22afef7206 100644 --- a/drivers/infiniband/ulp/srp/ib_srp.c +++ b/drivers/infiniband/ulp/srp/ib_srp.c | |||
@@ -62,6 +62,13 @@ MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator " | |||
62 | "v" DRV_VERSION " (" DRV_RELDATE ")"); | 62 | "v" DRV_VERSION " (" DRV_RELDATE ")"); |
63 | MODULE_LICENSE("Dual BSD/GPL"); | 63 | MODULE_LICENSE("Dual BSD/GPL"); |
64 | 64 | ||
65 | static int srp_sg_tablesize = SRP_DEF_SG_TABLESIZE; | ||
66 | static int srp_max_iu_len; | ||
67 | |||
68 | module_param(srp_sg_tablesize, int, 0444); | ||
69 | MODULE_PARM_DESC(srp_sg_tablesize, | ||
70 | "Max number of gather/scatter entries per I/O (default is 12)"); | ||
71 | |||
65 | static int topspin_workarounds = 1; | 72 | static int topspin_workarounds = 1; |
66 | 73 | ||
67 | module_param(topspin_workarounds, int, 0444); | 74 | module_param(topspin_workarounds, int, 0444); |
@@ -105,7 +112,8 @@ static struct srp_iu *srp_alloc_iu(struct srp_host *host, size_t size, | |||
105 | if (!iu->buf) | 112 | if (!iu->buf) |
106 | goto out_free_iu; | 113 | goto out_free_iu; |
107 | 114 | ||
108 | iu->dma = dma_map_single(host->dev->dma_device, iu->buf, size, direction); | 115 | iu->dma = dma_map_single(host->dev->dev->dma_device, |
116 | iu->buf, size, direction); | ||
109 | if (dma_mapping_error(iu->dma)) | 117 | if (dma_mapping_error(iu->dma)) |
110 | goto out_free_buf; | 118 | goto out_free_buf; |
111 | 119 | ||
@@ -127,7 +135,8 @@ static void srp_free_iu(struct srp_host *host, struct srp_iu *iu) | |||
127 | if (!iu) | 135 | if (!iu) |
128 | return; | 136 | return; |
129 | 137 | ||
130 | dma_unmap_single(host->dev->dma_device, iu->dma, iu->size, iu->direction); | 138 | dma_unmap_single(host->dev->dev->dma_device, |
139 | iu->dma, iu->size, iu->direction); | ||
131 | kfree(iu->buf); | 140 | kfree(iu->buf); |
132 | kfree(iu); | 141 | kfree(iu); |
133 | } | 142 | } |
@@ -147,7 +156,7 @@ static int srp_init_qp(struct srp_target_port *target, | |||
147 | if (!attr) | 156 | if (!attr) |
148 | return -ENOMEM; | 157 | return -ENOMEM; |
149 | 158 | ||
150 | ret = ib_find_cached_pkey(target->srp_host->dev, | 159 | ret = ib_find_cached_pkey(target->srp_host->dev->dev, |
151 | target->srp_host->port, | 160 | target->srp_host->port, |
152 | be16_to_cpu(target->path.pkey), | 161 | be16_to_cpu(target->path.pkey), |
153 | &attr->pkey_index); | 162 | &attr->pkey_index); |
@@ -179,7 +188,7 @@ static int srp_create_target_ib(struct srp_target_port *target) | |||
179 | if (!init_attr) | 188 | if (!init_attr) |
180 | return -ENOMEM; | 189 | return -ENOMEM; |
181 | 190 | ||
182 | target->cq = ib_create_cq(target->srp_host->dev, srp_completion, | 191 | target->cq = ib_create_cq(target->srp_host->dev->dev, srp_completion, |
183 | NULL, target, SRP_CQ_SIZE); | 192 | NULL, target, SRP_CQ_SIZE); |
184 | if (IS_ERR(target->cq)) { | 193 | if (IS_ERR(target->cq)) { |
185 | ret = PTR_ERR(target->cq); | 194 | ret = PTR_ERR(target->cq); |
@@ -198,7 +207,7 @@ static int srp_create_target_ib(struct srp_target_port *target) | |||
198 | init_attr->send_cq = target->cq; | 207 | init_attr->send_cq = target->cq; |
199 | init_attr->recv_cq = target->cq; | 208 | init_attr->recv_cq = target->cq; |
200 | 209 | ||
201 | target->qp = ib_create_qp(target->srp_host->pd, init_attr); | 210 | target->qp = ib_create_qp(target->srp_host->dev->pd, init_attr); |
202 | if (IS_ERR(target->qp)) { | 211 | if (IS_ERR(target->qp)) { |
203 | ret = PTR_ERR(target->qp); | 212 | ret = PTR_ERR(target->qp); |
204 | ib_destroy_cq(target->cq); | 213 | ib_destroy_cq(target->cq); |
@@ -250,7 +259,7 @@ static int srp_lookup_path(struct srp_target_port *target) | |||
250 | 259 | ||
251 | init_completion(&target->done); | 260 | init_completion(&target->done); |
252 | 261 | ||
253 | target->path_query_id = ib_sa_path_rec_get(target->srp_host->dev, | 262 | target->path_query_id = ib_sa_path_rec_get(target->srp_host->dev->dev, |
254 | target->srp_host->port, | 263 | target->srp_host->port, |
255 | &target->path, | 264 | &target->path, |
256 | IB_SA_PATH_REC_DGID | | 265 | IB_SA_PATH_REC_DGID | |
@@ -309,10 +318,32 @@ static int srp_send_req(struct srp_target_port *target) | |||
309 | 318 | ||
310 | req->priv.opcode = SRP_LOGIN_REQ; | 319 | req->priv.opcode = SRP_LOGIN_REQ; |
311 | req->priv.tag = 0; | 320 | req->priv.tag = 0; |
312 | req->priv.req_it_iu_len = cpu_to_be32(SRP_MAX_IU_LEN); | 321 | req->priv.req_it_iu_len = cpu_to_be32(srp_max_iu_len); |
313 | req->priv.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | | 322 | req->priv.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | |
314 | SRP_BUF_FORMAT_INDIRECT); | 323 | SRP_BUF_FORMAT_INDIRECT); |
315 | memcpy(req->priv.initiator_port_id, target->srp_host->initiator_port_id, 16); | 324 | /* |
325 | * In the published SRP specification (draft rev. 16a), the | ||
326 | * port identifier format is 8 bytes of ID extension followed | ||
327 | * by 8 bytes of GUID. Older drafts put the two halves in the | ||
328 | * opposite order, so that the GUID comes first. | ||
329 | * | ||
330 | * Targets conforming to these obsolete drafts can be | ||
331 | * recognized by the I/O Class they report. | ||
332 | */ | ||
333 | if (target->io_class == SRP_REV10_IB_IO_CLASS) { | ||
334 | memcpy(req->priv.initiator_port_id, | ||
335 | target->srp_host->initiator_port_id + 8, 8); | ||
336 | memcpy(req->priv.initiator_port_id + 8, | ||
337 | target->srp_host->initiator_port_id, 8); | ||
338 | memcpy(req->priv.target_port_id, &target->ioc_guid, 8); | ||
339 | memcpy(req->priv.target_port_id + 8, &target->id_ext, 8); | ||
340 | } else { | ||
341 | memcpy(req->priv.initiator_port_id, | ||
342 | target->srp_host->initiator_port_id, 16); | ||
343 | memcpy(req->priv.target_port_id, &target->id_ext, 8); | ||
344 | memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8); | ||
345 | } | ||
346 | |||
316 | /* | 347 | /* |
317 | * Topspin/Cisco SRP targets will reject our login unless we | 348 | * Topspin/Cisco SRP targets will reject our login unless we |
318 | * zero out the first 8 bytes of our initiator port ID. The | 349 | * zero out the first 8 bytes of our initiator port ID. The |
@@ -325,8 +356,6 @@ static int srp_send_req(struct srp_target_port *target) | |||
325 | (unsigned long long) be64_to_cpu(target->ioc_guid)); | 356 | (unsigned long long) be64_to_cpu(target->ioc_guid)); |
326 | memset(req->priv.initiator_port_id, 0, 8); | 357 | memset(req->priv.initiator_port_id, 0, 8); |
327 | } | 358 | } |
328 | memcpy(req->priv.target_port_id, &target->id_ext, 8); | ||
329 | memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8); | ||
330 | 359 | ||
331 | status = ib_send_cm_req(target->cm_id, &req->param); | 360 | status = ib_send_cm_req(target->cm_id, &req->param); |
332 | 361 | ||
@@ -359,9 +388,9 @@ static void srp_remove_work(void *target_ptr) | |||
359 | target->state = SRP_TARGET_REMOVED; | 388 | target->state = SRP_TARGET_REMOVED; |
360 | spin_unlock_irq(target->scsi_host->host_lock); | 389 | spin_unlock_irq(target->scsi_host->host_lock); |
361 | 390 | ||
362 | mutex_lock(&target->srp_host->target_mutex); | 391 | spin_lock(&target->srp_host->target_lock); |
363 | list_del(&target->list); | 392 | list_del(&target->list); |
364 | mutex_unlock(&target->srp_host->target_mutex); | 393 | spin_unlock(&target->srp_host->target_lock); |
365 | 394 | ||
366 | scsi_remove_host(target->scsi_host); | 395 | scsi_remove_host(target->scsi_host); |
367 | ib_destroy_cm_id(target->cm_id); | 396 | ib_destroy_cm_id(target->cm_id); |
@@ -421,6 +450,11 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd, | |||
421 | scmnd->sc_data_direction != DMA_FROM_DEVICE)) | 450 | scmnd->sc_data_direction != DMA_FROM_DEVICE)) |
422 | return; | 451 | return; |
423 | 452 | ||
453 | if (req->fmr) { | ||
454 | ib_fmr_pool_unmap(req->fmr); | ||
455 | req->fmr = NULL; | ||
456 | } | ||
457 | |||
424 | /* | 458 | /* |
425 | * This handling of non-SG commands can be killed when the | 459 | * This handling of non-SG commands can be killed when the |
426 | * SCSI midlayer no longer generates non-SG commands. | 460 | * SCSI midlayer no longer generates non-SG commands. |
@@ -433,18 +467,30 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd, | |||
433 | scat = &req->fake_sg; | 467 | scat = &req->fake_sg; |
434 | } | 468 | } |
435 | 469 | ||
436 | dma_unmap_sg(target->srp_host->dev->dma_device, scat, nents, | 470 | dma_unmap_sg(target->srp_host->dev->dev->dma_device, scat, nents, |
437 | scmnd->sc_data_direction); | 471 | scmnd->sc_data_direction); |
438 | } | 472 | } |
439 | 473 | ||
474 | static void srp_remove_req(struct srp_target_port *target, struct srp_request *req) | ||
475 | { | ||
476 | srp_unmap_data(req->scmnd, target, req); | ||
477 | list_move_tail(&req->list, &target->free_reqs); | ||
478 | } | ||
479 | |||
480 | static void srp_reset_req(struct srp_target_port *target, struct srp_request *req) | ||
481 | { | ||
482 | req->scmnd->result = DID_RESET << 16; | ||
483 | req->scmnd->scsi_done(req->scmnd); | ||
484 | srp_remove_req(target, req); | ||
485 | } | ||
486 | |||
440 | static int srp_reconnect_target(struct srp_target_port *target) | 487 | static int srp_reconnect_target(struct srp_target_port *target) |
441 | { | 488 | { |
442 | struct ib_cm_id *new_cm_id; | 489 | struct ib_cm_id *new_cm_id; |
443 | struct ib_qp_attr qp_attr; | 490 | struct ib_qp_attr qp_attr; |
444 | struct srp_request *req; | 491 | struct srp_request *req, *tmp; |
445 | struct ib_wc wc; | 492 | struct ib_wc wc; |
446 | int ret; | 493 | int ret; |
447 | int i; | ||
448 | 494 | ||
449 | spin_lock_irq(target->scsi_host->host_lock); | 495 | spin_lock_irq(target->scsi_host->host_lock); |
450 | if (target->state != SRP_TARGET_LIVE) { | 496 | if (target->state != SRP_TARGET_LIVE) { |
@@ -459,7 +505,7 @@ static int srp_reconnect_target(struct srp_target_port *target) | |||
459 | * Now get a new local CM ID so that we avoid confusing the | 505 | * Now get a new local CM ID so that we avoid confusing the |
460 | * target in case things are really fouled up. | 506 | * target in case things are really fouled up. |
461 | */ | 507 | */ |
462 | new_cm_id = ib_create_cm_id(target->srp_host->dev, | 508 | new_cm_id = ib_create_cm_id(target->srp_host->dev->dev, |
463 | srp_cm_handler, target); | 509 | srp_cm_handler, target); |
464 | if (IS_ERR(new_cm_id)) { | 510 | if (IS_ERR(new_cm_id)) { |
465 | ret = PTR_ERR(new_cm_id); | 511 | ret = PTR_ERR(new_cm_id); |
@@ -480,19 +526,12 @@ static int srp_reconnect_target(struct srp_target_port *target) | |||
480 | while (ib_poll_cq(target->cq, 1, &wc) > 0) | 526 | while (ib_poll_cq(target->cq, 1, &wc) > 0) |
481 | ; /* nothing */ | 527 | ; /* nothing */ |
482 | 528 | ||
483 | list_for_each_entry(req, &target->req_queue, list) { | 529 | list_for_each_entry_safe(req, tmp, &target->req_queue, list) |
484 | req->scmnd->result = DID_RESET << 16; | 530 | srp_reset_req(target, req); |
485 | req->scmnd->scsi_done(req->scmnd); | ||
486 | srp_unmap_data(req->scmnd, target, req); | ||
487 | } | ||
488 | 531 | ||
489 | target->rx_head = 0; | 532 | target->rx_head = 0; |
490 | target->tx_head = 0; | 533 | target->tx_head = 0; |
491 | target->tx_tail = 0; | 534 | target->tx_tail = 0; |
492 | INIT_LIST_HEAD(&target->free_reqs); | ||
493 | INIT_LIST_HEAD(&target->req_queue); | ||
494 | for (i = 0; i < SRP_SQ_SIZE; ++i) | ||
495 | list_add_tail(&target->req_ring[i].list, &target->free_reqs); | ||
496 | 535 | ||
497 | ret = srp_connect_target(target); | 536 | ret = srp_connect_target(target); |
498 | if (ret) | 537 | if (ret) |
@@ -528,14 +567,79 @@ err: | |||
528 | return ret; | 567 | return ret; |
529 | } | 568 | } |
530 | 569 | ||
570 | static int srp_map_fmr(struct srp_device *dev, struct scatterlist *scat, | ||
571 | int sg_cnt, struct srp_request *req, | ||
572 | struct srp_direct_buf *buf) | ||
573 | { | ||
574 | u64 io_addr = 0; | ||
575 | u64 *dma_pages; | ||
576 | u32 len; | ||
577 | int page_cnt; | ||
578 | int i, j; | ||
579 | int ret; | ||
580 | |||
581 | if (!dev->fmr_pool) | ||
582 | return -ENODEV; | ||
583 | |||
584 | len = page_cnt = 0; | ||
585 | for (i = 0; i < sg_cnt; ++i) { | ||
586 | if (sg_dma_address(&scat[i]) & ~dev->fmr_page_mask) { | ||
587 | if (i > 0) | ||
588 | return -EINVAL; | ||
589 | else | ||
590 | ++page_cnt; | ||
591 | } | ||
592 | if ((sg_dma_address(&scat[i]) + sg_dma_len(&scat[i])) & | ||
593 | ~dev->fmr_page_mask) { | ||
594 | if (i < sg_cnt - 1) | ||
595 | return -EINVAL; | ||
596 | else | ||
597 | ++page_cnt; | ||
598 | } | ||
599 | |||
600 | len += sg_dma_len(&scat[i]); | ||
601 | } | ||
602 | |||
603 | page_cnt += len >> dev->fmr_page_shift; | ||
604 | if (page_cnt > SRP_FMR_SIZE) | ||
605 | return -ENOMEM; | ||
606 | |||
607 | dma_pages = kmalloc(sizeof (u64) * page_cnt, GFP_ATOMIC); | ||
608 | if (!dma_pages) | ||
609 | return -ENOMEM; | ||
610 | |||
611 | page_cnt = 0; | ||
612 | for (i = 0; i < sg_cnt; ++i) | ||
613 | for (j = 0; j < sg_dma_len(&scat[i]); j += dev->fmr_page_size) | ||
614 | dma_pages[page_cnt++] = | ||
615 | (sg_dma_address(&scat[i]) & dev->fmr_page_mask) + j; | ||
616 | |||
617 | req->fmr = ib_fmr_pool_map_phys(dev->fmr_pool, | ||
618 | dma_pages, page_cnt, &io_addr); | ||
619 | if (IS_ERR(req->fmr)) { | ||
620 | ret = PTR_ERR(req->fmr); | ||
621 | goto out; | ||
622 | } | ||
623 | |||
624 | buf->va = cpu_to_be64(sg_dma_address(&scat[0]) & ~dev->fmr_page_mask); | ||
625 | buf->key = cpu_to_be32(req->fmr->fmr->rkey); | ||
626 | buf->len = cpu_to_be32(len); | ||
627 | |||
628 | ret = 0; | ||
629 | |||
630 | out: | ||
631 | kfree(dma_pages); | ||
632 | |||
633 | return ret; | ||
634 | } | ||
635 | |||
531 | static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, | 636 | static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, |
532 | struct srp_request *req) | 637 | struct srp_request *req) |
533 | { | 638 | { |
534 | struct scatterlist *scat; | 639 | struct scatterlist *scat; |
535 | struct srp_cmd *cmd = req->cmd->buf; | 640 | struct srp_cmd *cmd = req->cmd->buf; |
536 | int len, nents, count; | 641 | int len, nents, count; |
537 | int i; | 642 | u8 fmt = SRP_DATA_DESC_DIRECT; |
538 | u8 fmt; | ||
539 | 643 | ||
540 | if (!scmnd->request_buffer || scmnd->sc_data_direction == DMA_NONE) | 644 | if (!scmnd->request_buffer || scmnd->sc_data_direction == DMA_NONE) |
541 | return sizeof (struct srp_cmd); | 645 | return sizeof (struct srp_cmd); |
@@ -560,53 +664,63 @@ static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, | |||
560 | sg_init_one(scat, scmnd->request_buffer, scmnd->request_bufflen); | 664 | sg_init_one(scat, scmnd->request_buffer, scmnd->request_bufflen); |
561 | } | 665 | } |
562 | 666 | ||
563 | count = dma_map_sg(target->srp_host->dev->dma_device, scat, nents, | 667 | count = dma_map_sg(target->srp_host->dev->dev->dma_device, |
564 | scmnd->sc_data_direction); | 668 | scat, nents, scmnd->sc_data_direction); |
669 | |||
670 | fmt = SRP_DATA_DESC_DIRECT; | ||
671 | len = sizeof (struct srp_cmd) + sizeof (struct srp_direct_buf); | ||
565 | 672 | ||
566 | if (count == 1) { | 673 | if (count == 1) { |
674 | /* | ||
675 | * The midlayer only generated a single gather/scatter | ||
676 | * entry, or DMA mapping coalesced everything to a | ||
677 | * single entry. So a direct descriptor along with | ||
678 | * the DMA MR suffices. | ||
679 | */ | ||
567 | struct srp_direct_buf *buf = (void *) cmd->add_data; | 680 | struct srp_direct_buf *buf = (void *) cmd->add_data; |
568 | 681 | ||
569 | fmt = SRP_DATA_DESC_DIRECT; | ||
570 | |||
571 | buf->va = cpu_to_be64(sg_dma_address(scat)); | 682 | buf->va = cpu_to_be64(sg_dma_address(scat)); |
572 | buf->key = cpu_to_be32(target->srp_host->mr->rkey); | 683 | buf->key = cpu_to_be32(target->srp_host->dev->mr->rkey); |
573 | buf->len = cpu_to_be32(sg_dma_len(scat)); | 684 | buf->len = cpu_to_be32(sg_dma_len(scat)); |
574 | 685 | } else if (srp_map_fmr(target->srp_host->dev, scat, count, req, | |
575 | len = sizeof (struct srp_cmd) + | 686 | (void *) cmd->add_data)) { |
576 | sizeof (struct srp_direct_buf); | 687 | /* |
577 | } else { | 688 | * FMR mapping failed, and the scatterlist has more |
689 | * than one entry. Generate an indirect memory | ||
690 | * descriptor. | ||
691 | */ | ||
578 | struct srp_indirect_buf *buf = (void *) cmd->add_data; | 692 | struct srp_indirect_buf *buf = (void *) cmd->add_data; |
579 | u32 datalen = 0; | 693 | u32 datalen = 0; |
694 | int i; | ||
580 | 695 | ||
581 | fmt = SRP_DATA_DESC_INDIRECT; | 696 | fmt = SRP_DATA_DESC_INDIRECT; |
697 | len = sizeof (struct srp_cmd) + | ||
698 | sizeof (struct srp_indirect_buf) + | ||
699 | count * sizeof (struct srp_direct_buf); | ||
700 | |||
701 | for (i = 0; i < count; ++i) { | ||
702 | buf->desc_list[i].va = | ||
703 | cpu_to_be64(sg_dma_address(&scat[i])); | ||
704 | buf->desc_list[i].key = | ||
705 | cpu_to_be32(target->srp_host->dev->mr->rkey); | ||
706 | buf->desc_list[i].len = | ||
707 | cpu_to_be32(sg_dma_len(&scat[i])); | ||
708 | datalen += sg_dma_len(&scat[i]); | ||
709 | } | ||
582 | 710 | ||
583 | if (scmnd->sc_data_direction == DMA_TO_DEVICE) | 711 | if (scmnd->sc_data_direction == DMA_TO_DEVICE) |
584 | cmd->data_out_desc_cnt = count; | 712 | cmd->data_out_desc_cnt = count; |
585 | else | 713 | else |
586 | cmd->data_in_desc_cnt = count; | 714 | cmd->data_in_desc_cnt = count; |
587 | 715 | ||
588 | buf->table_desc.va = cpu_to_be64(req->cmd->dma + | 716 | buf->table_desc.va = |
589 | sizeof *cmd + | 717 | cpu_to_be64(req->cmd->dma + sizeof *cmd + sizeof *buf); |
590 | sizeof *buf); | ||
591 | buf->table_desc.key = | 718 | buf->table_desc.key = |
592 | cpu_to_be32(target->srp_host->mr->rkey); | 719 | cpu_to_be32(target->srp_host->dev->mr->rkey); |
593 | buf->table_desc.len = | 720 | buf->table_desc.len = |
594 | cpu_to_be32(count * sizeof (struct srp_direct_buf)); | 721 | cpu_to_be32(count * sizeof (struct srp_direct_buf)); |
595 | 722 | ||
596 | for (i = 0; i < count; ++i) { | ||
597 | buf->desc_list[i].va = cpu_to_be64(sg_dma_address(&scat[i])); | ||
598 | buf->desc_list[i].key = | ||
599 | cpu_to_be32(target->srp_host->mr->rkey); | ||
600 | buf->desc_list[i].len = cpu_to_be32(sg_dma_len(&scat[i])); | ||
601 | |||
602 | datalen += sg_dma_len(&scat[i]); | ||
603 | } | ||
604 | |||
605 | buf->len = cpu_to_be32(datalen); | 723 | buf->len = cpu_to_be32(datalen); |
606 | |||
607 | len = sizeof (struct srp_cmd) + | ||
608 | sizeof (struct srp_indirect_buf) + | ||
609 | count * sizeof (struct srp_direct_buf); | ||
610 | } | 724 | } |
611 | 725 | ||
612 | if (scmnd->sc_data_direction == DMA_TO_DEVICE) | 726 | if (scmnd->sc_data_direction == DMA_TO_DEVICE) |
@@ -617,12 +731,6 @@ static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, | |||
617 | return len; | 731 | return len; |
618 | } | 732 | } |
619 | 733 | ||
620 | static void srp_remove_req(struct srp_target_port *target, struct srp_request *req) | ||
621 | { | ||
622 | srp_unmap_data(req->scmnd, target, req); | ||
623 | list_move_tail(&req->list, &target->free_reqs); | ||
624 | } | ||
625 | |||
626 | static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp) | 734 | static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp) |
627 | { | 735 | { |
628 | struct srp_request *req; | 736 | struct srp_request *req; |
@@ -689,7 +797,7 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc) | |||
689 | 797 | ||
690 | iu = target->rx_ring[wc->wr_id & ~SRP_OP_RECV]; | 798 | iu = target->rx_ring[wc->wr_id & ~SRP_OP_RECV]; |
691 | 799 | ||
692 | dma_sync_single_for_cpu(target->srp_host->dev->dma_device, iu->dma, | 800 | dma_sync_single_for_cpu(target->srp_host->dev->dev->dma_device, iu->dma, |
693 | target->max_ti_iu_len, DMA_FROM_DEVICE); | 801 | target->max_ti_iu_len, DMA_FROM_DEVICE); |
694 | 802 | ||
695 | opcode = *(u8 *) iu->buf; | 803 | opcode = *(u8 *) iu->buf; |
@@ -726,7 +834,7 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc) | |||
726 | break; | 834 | break; |
727 | } | 835 | } |
728 | 836 | ||
729 | dma_sync_single_for_device(target->srp_host->dev->dma_device, iu->dma, | 837 | dma_sync_single_for_device(target->srp_host->dev->dev->dma_device, iu->dma, |
730 | target->max_ti_iu_len, DMA_FROM_DEVICE); | 838 | target->max_ti_iu_len, DMA_FROM_DEVICE); |
731 | } | 839 | } |
732 | 840 | ||
@@ -770,7 +878,7 @@ static int __srp_post_recv(struct srp_target_port *target) | |||
770 | 878 | ||
771 | list.addr = iu->dma; | 879 | list.addr = iu->dma; |
772 | list.length = iu->size; | 880 | list.length = iu->size; |
773 | list.lkey = target->srp_host->mr->lkey; | 881 | list.lkey = target->srp_host->dev->mr->lkey; |
774 | 882 | ||
775 | wr.next = NULL; | 883 | wr.next = NULL; |
776 | wr.sg_list = &list; | 884 | wr.sg_list = &list; |
@@ -805,12 +913,8 @@ static struct srp_iu *__srp_get_tx_iu(struct srp_target_port *target) | |||
805 | if (target->tx_head - target->tx_tail >= SRP_SQ_SIZE) | 913 | if (target->tx_head - target->tx_tail >= SRP_SQ_SIZE) |
806 | return NULL; | 914 | return NULL; |
807 | 915 | ||
808 | if (unlikely(target->req_lim < 1)) { | 916 | if (unlikely(target->req_lim < 1)) |
809 | if (printk_ratelimit()) | 917 | ++target->zero_req_lim; |
810 | printk(KERN_DEBUG PFX "Target has req_lim %d\n", | ||
811 | target->req_lim); | ||
812 | return NULL; | ||
813 | } | ||
814 | 918 | ||
815 | return target->tx_ring[target->tx_head & SRP_SQ_SIZE]; | 919 | return target->tx_ring[target->tx_head & SRP_SQ_SIZE]; |
816 | } | 920 | } |
@@ -828,7 +932,7 @@ static int __srp_post_send(struct srp_target_port *target, | |||
828 | 932 | ||
829 | list.addr = iu->dma; | 933 | list.addr = iu->dma; |
830 | list.length = len; | 934 | list.length = len; |
831 | list.lkey = target->srp_host->mr->lkey; | 935 | list.lkey = target->srp_host->dev->mr->lkey; |
832 | 936 | ||
833 | wr.next = NULL; | 937 | wr.next = NULL; |
834 | wr.wr_id = target->tx_head & SRP_SQ_SIZE; | 938 | wr.wr_id = target->tx_head & SRP_SQ_SIZE; |
@@ -870,8 +974,8 @@ static int srp_queuecommand(struct scsi_cmnd *scmnd, | |||
870 | if (!iu) | 974 | if (!iu) |
871 | goto err; | 975 | goto err; |
872 | 976 | ||
873 | dma_sync_single_for_cpu(target->srp_host->dev->dma_device, iu->dma, | 977 | dma_sync_single_for_cpu(target->srp_host->dev->dev->dma_device, iu->dma, |
874 | SRP_MAX_IU_LEN, DMA_TO_DEVICE); | 978 | srp_max_iu_len, DMA_TO_DEVICE); |
875 | 979 | ||
876 | req = list_entry(target->free_reqs.next, struct srp_request, list); | 980 | req = list_entry(target->free_reqs.next, struct srp_request, list); |
877 | 981 | ||
@@ -903,8 +1007,8 @@ static int srp_queuecommand(struct scsi_cmnd *scmnd, | |||
903 | goto err_unmap; | 1007 | goto err_unmap; |
904 | } | 1008 | } |
905 | 1009 | ||
906 | dma_sync_single_for_device(target->srp_host->dev->dma_device, iu->dma, | 1010 | dma_sync_single_for_device(target->srp_host->dev->dev->dma_device, iu->dma, |
907 | SRP_MAX_IU_LEN, DMA_TO_DEVICE); | 1011 | srp_max_iu_len, DMA_TO_DEVICE); |
908 | 1012 | ||
909 | if (__srp_post_send(target, iu, len)) { | 1013 | if (__srp_post_send(target, iu, len)) { |
910 | printk(KERN_ERR PFX "Send failed\n"); | 1014 | printk(KERN_ERR PFX "Send failed\n"); |
@@ -936,7 +1040,7 @@ static int srp_alloc_iu_bufs(struct srp_target_port *target) | |||
936 | 1040 | ||
937 | for (i = 0; i < SRP_SQ_SIZE + 1; ++i) { | 1041 | for (i = 0; i < SRP_SQ_SIZE + 1; ++i) { |
938 | target->tx_ring[i] = srp_alloc_iu(target->srp_host, | 1042 | target->tx_ring[i] = srp_alloc_iu(target->srp_host, |
939 | SRP_MAX_IU_LEN, | 1043 | srp_max_iu_len, |
940 | GFP_KERNEL, DMA_TO_DEVICE); | 1044 | GFP_KERNEL, DMA_TO_DEVICE); |
941 | if (!target->tx_ring[i]) | 1045 | if (!target->tx_ring[i]) |
942 | goto err; | 1046 | goto err; |
@@ -1107,11 +1211,10 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event) | |||
1107 | srp_cm_rej_handler(cm_id, event, target); | 1211 | srp_cm_rej_handler(cm_id, event, target); |
1108 | break; | 1212 | break; |
1109 | 1213 | ||
1110 | case IB_CM_MRA_RECEIVED: | 1214 | case IB_CM_DREQ_RECEIVED: |
1111 | printk(KERN_ERR PFX "MRA received\n"); | 1215 | printk(KERN_WARNING PFX "DREQ received - connection closed\n"); |
1112 | break; | 1216 | if (ib_send_cm_drep(cm_id, NULL, 0)) |
1113 | 1217 | printk(KERN_ERR PFX "Sending CM DREP failed\n"); | |
1114 | case IB_CM_DREP_RECEIVED: | ||
1115 | break; | 1218 | break; |
1116 | 1219 | ||
1117 | case IB_CM_TIMEWAIT_EXIT: | 1220 | case IB_CM_TIMEWAIT_EXIT: |
@@ -1121,6 +1224,11 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event) | |||
1121 | target->status = 0; | 1224 | target->status = 0; |
1122 | break; | 1225 | break; |
1123 | 1226 | ||
1227 | case IB_CM_MRA_RECEIVED: | ||
1228 | case IB_CM_DREQ_ERROR: | ||
1229 | case IB_CM_DREP_RECEIVED: | ||
1230 | break; | ||
1231 | |||
1124 | default: | 1232 | default: |
1125 | printk(KERN_WARNING PFX "Unhandled CM event %d\n", event->event); | 1233 | printk(KERN_WARNING PFX "Unhandled CM event %d\n", event->event); |
1126 | break; | 1234 | break; |
@@ -1239,11 +1347,8 @@ static int srp_reset_device(struct scsi_cmnd *scmnd) | |||
1239 | spin_lock_irq(target->scsi_host->host_lock); | 1347 | spin_lock_irq(target->scsi_host->host_lock); |
1240 | 1348 | ||
1241 | list_for_each_entry_safe(req, tmp, &target->req_queue, list) | 1349 | list_for_each_entry_safe(req, tmp, &target->req_queue, list) |
1242 | if (req->scmnd->device == scmnd->device) { | 1350 | if (req->scmnd->device == scmnd->device) |
1243 | req->scmnd->result = DID_RESET << 16; | 1351 | srp_reset_req(target, req); |
1244 | req->scmnd->scsi_done(req->scmnd); | ||
1245 | srp_remove_req(target, req); | ||
1246 | } | ||
1247 | 1352 | ||
1248 | spin_unlock_irq(target->scsi_host->host_lock); | 1353 | spin_unlock_irq(target->scsi_host->host_lock); |
1249 | 1354 | ||
@@ -1329,11 +1434,23 @@ static ssize_t show_dgid(struct class_device *cdev, char *buf) | |||
1329 | be16_to_cpu(((__be16 *) target->path.dgid.raw)[7])); | 1434 | be16_to_cpu(((__be16 *) target->path.dgid.raw)[7])); |
1330 | } | 1435 | } |
1331 | 1436 | ||
1437 | static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf) | ||
1438 | { | ||
1439 | struct srp_target_port *target = host_to_target(class_to_shost(cdev)); | ||
1440 | |||
1441 | if (target->state == SRP_TARGET_DEAD || | ||
1442 | target->state == SRP_TARGET_REMOVED) | ||
1443 | return -ENODEV; | ||
1444 | |||
1445 | return sprintf(buf, "%d\n", target->zero_req_lim); | ||
1446 | } | ||
1447 | |||
1332 | static CLASS_DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); | 1448 | static CLASS_DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); |
1333 | static CLASS_DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); | 1449 | static CLASS_DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); |
1334 | static CLASS_DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); | 1450 | static CLASS_DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); |
1335 | static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); | 1451 | static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); |
1336 | static CLASS_DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); | 1452 | static CLASS_DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); |
1453 | static CLASS_DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); | ||
1337 | 1454 | ||
1338 | static struct class_device_attribute *srp_host_attrs[] = { | 1455 | static struct class_device_attribute *srp_host_attrs[] = { |
1339 | &class_device_attr_id_ext, | 1456 | &class_device_attr_id_ext, |
@@ -1341,6 +1458,7 @@ static struct class_device_attribute *srp_host_attrs[] = { | |||
1341 | &class_device_attr_service_id, | 1458 | &class_device_attr_service_id, |
1342 | &class_device_attr_pkey, | 1459 | &class_device_attr_pkey, |
1343 | &class_device_attr_dgid, | 1460 | &class_device_attr_dgid, |
1461 | &class_device_attr_zero_req_lim, | ||
1344 | NULL | 1462 | NULL |
1345 | }; | 1463 | }; |
1346 | 1464 | ||
@@ -1354,7 +1472,6 @@ static struct scsi_host_template srp_template = { | |||
1354 | .eh_host_reset_handler = srp_reset_host, | 1472 | .eh_host_reset_handler = srp_reset_host, |
1355 | .can_queue = SRP_SQ_SIZE, | 1473 | .can_queue = SRP_SQ_SIZE, |
1356 | .this_id = -1, | 1474 | .this_id = -1, |
1357 | .sg_tablesize = SRP_MAX_INDIRECT, | ||
1358 | .cmd_per_lun = SRP_SQ_SIZE, | 1475 | .cmd_per_lun = SRP_SQ_SIZE, |
1359 | .use_clustering = ENABLE_CLUSTERING, | 1476 | .use_clustering = ENABLE_CLUSTERING, |
1360 | .shost_attrs = srp_host_attrs | 1477 | .shost_attrs = srp_host_attrs |
@@ -1365,18 +1482,17 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target) | |||
1365 | sprintf(target->target_name, "SRP.T10:%016llX", | 1482 | sprintf(target->target_name, "SRP.T10:%016llX", |
1366 | (unsigned long long) be64_to_cpu(target->id_ext)); | 1483 | (unsigned long long) be64_to_cpu(target->id_ext)); |
1367 | 1484 | ||
1368 | if (scsi_add_host(target->scsi_host, host->dev->dma_device)) | 1485 | if (scsi_add_host(target->scsi_host, host->dev->dev->dma_device)) |
1369 | return -ENODEV; | 1486 | return -ENODEV; |
1370 | 1487 | ||
1371 | mutex_lock(&host->target_mutex); | 1488 | spin_lock(&host->target_lock); |
1372 | list_add_tail(&target->list, &host->target_list); | 1489 | list_add_tail(&target->list, &host->target_list); |
1373 | mutex_unlock(&host->target_mutex); | 1490 | spin_unlock(&host->target_lock); |
1374 | 1491 | ||
1375 | target->state = SRP_TARGET_LIVE; | 1492 | target->state = SRP_TARGET_LIVE; |
1376 | 1493 | ||
1377 | /* XXX: are we supposed to have a definition of SCAN_WILD_CARD ?? */ | ||
1378 | scsi_scan_target(&target->scsi_host->shost_gendev, | 1494 | scsi_scan_target(&target->scsi_host->shost_gendev, |
1379 | 0, target->scsi_id, ~0, 0); | 1495 | 0, target->scsi_id, SCAN_WILD_CARD, 0); |
1380 | 1496 | ||
1381 | return 0; | 1497 | return 0; |
1382 | } | 1498 | } |
@@ -1410,6 +1526,8 @@ enum { | |||
1410 | SRP_OPT_PKEY = 1 << 3, | 1526 | SRP_OPT_PKEY = 1 << 3, |
1411 | SRP_OPT_SERVICE_ID = 1 << 4, | 1527 | SRP_OPT_SERVICE_ID = 1 << 4, |
1412 | SRP_OPT_MAX_SECT = 1 << 5, | 1528 | SRP_OPT_MAX_SECT = 1 << 5, |
1529 | SRP_OPT_MAX_CMD_PER_LUN = 1 << 6, | ||
1530 | SRP_OPT_IO_CLASS = 1 << 7, | ||
1413 | SRP_OPT_ALL = (SRP_OPT_ID_EXT | | 1531 | SRP_OPT_ALL = (SRP_OPT_ID_EXT | |
1414 | SRP_OPT_IOC_GUID | | 1532 | SRP_OPT_IOC_GUID | |
1415 | SRP_OPT_DGID | | 1533 | SRP_OPT_DGID | |
@@ -1418,13 +1536,15 @@ enum { | |||
1418 | }; | 1536 | }; |
1419 | 1537 | ||
1420 | static match_table_t srp_opt_tokens = { | 1538 | static match_table_t srp_opt_tokens = { |
1421 | { SRP_OPT_ID_EXT, "id_ext=%s" }, | 1539 | { SRP_OPT_ID_EXT, "id_ext=%s" }, |
1422 | { SRP_OPT_IOC_GUID, "ioc_guid=%s" }, | 1540 | { SRP_OPT_IOC_GUID, "ioc_guid=%s" }, |
1423 | { SRP_OPT_DGID, "dgid=%s" }, | 1541 | { SRP_OPT_DGID, "dgid=%s" }, |
1424 | { SRP_OPT_PKEY, "pkey=%x" }, | 1542 | { SRP_OPT_PKEY, "pkey=%x" }, |
1425 | { SRP_OPT_SERVICE_ID, "service_id=%s" }, | 1543 | { SRP_OPT_SERVICE_ID, "service_id=%s" }, |
1426 | { SRP_OPT_MAX_SECT, "max_sect=%d" }, | 1544 | { SRP_OPT_MAX_SECT, "max_sect=%d" }, |
1427 | { SRP_OPT_ERR, NULL } | 1545 | { SRP_OPT_MAX_CMD_PER_LUN, "max_cmd_per_lun=%d" }, |
1546 | { SRP_OPT_IO_CLASS, "io_class=%x" }, | ||
1547 | { SRP_OPT_ERR, NULL } | ||
1428 | }; | 1548 | }; |
1429 | 1549 | ||
1430 | static int srp_parse_options(const char *buf, struct srp_target_port *target) | 1550 | static int srp_parse_options(const char *buf, struct srp_target_port *target) |
@@ -1500,6 +1620,29 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target) | |||
1500 | target->scsi_host->max_sectors = token; | 1620 | target->scsi_host->max_sectors = token; |
1501 | break; | 1621 | break; |
1502 | 1622 | ||
1623 | case SRP_OPT_MAX_CMD_PER_LUN: | ||
1624 | if (match_int(args, &token)) { | ||
1625 | printk(KERN_WARNING PFX "bad max cmd_per_lun parameter '%s'\n", p); | ||
1626 | goto out; | ||
1627 | } | ||
1628 | target->scsi_host->cmd_per_lun = min(token, SRP_SQ_SIZE); | ||
1629 | break; | ||
1630 | |||
1631 | case SRP_OPT_IO_CLASS: | ||
1632 | if (match_hex(args, &token)) { | ||
1633 | printk(KERN_WARNING PFX "bad IO class parameter '%s' \n", p); | ||
1634 | goto out; | ||
1635 | } | ||
1636 | if (token != SRP_REV10_IB_IO_CLASS && | ||
1637 | token != SRP_REV16A_IB_IO_CLASS) { | ||
1638 | printk(KERN_WARNING PFX "unknown IO class parameter value" | ||
1639 | " %x specified (use %x or %x).\n", | ||
1640 | token, SRP_REV10_IB_IO_CLASS, SRP_REV16A_IB_IO_CLASS); | ||
1641 | goto out; | ||
1642 | } | ||
1643 | target->io_class = token; | ||
1644 | break; | ||
1645 | |||
1503 | default: | 1646 | default: |
1504 | printk(KERN_WARNING PFX "unknown parameter or missing value " | 1647 | printk(KERN_WARNING PFX "unknown parameter or missing value " |
1505 | "'%s' in target creation request\n", p); | 1648 | "'%s' in target creation request\n", p); |
@@ -1542,6 +1685,7 @@ static ssize_t srp_create_target(struct class_device *class_dev, | |||
1542 | target = host_to_target(target_host); | 1685 | target = host_to_target(target_host); |
1543 | memset(target, 0, sizeof *target); | 1686 | memset(target, 0, sizeof *target); |
1544 | 1687 | ||
1688 | target->io_class = SRP_REV16A_IB_IO_CLASS; | ||
1545 | target->scsi_host = target_host; | 1689 | target->scsi_host = target_host; |
1546 | target->srp_host = host; | 1690 | target->srp_host = host; |
1547 | 1691 | ||
@@ -1558,7 +1702,7 @@ static ssize_t srp_create_target(struct class_device *class_dev, | |||
1558 | if (ret) | 1702 | if (ret) |
1559 | goto err; | 1703 | goto err; |
1560 | 1704 | ||
1561 | ib_get_cached_gid(host->dev, host->port, 0, &target->path.sgid); | 1705 | ib_get_cached_gid(host->dev->dev, host->port, 0, &target->path.sgid); |
1562 | 1706 | ||
1563 | printk(KERN_DEBUG PFX "new target: id_ext %016llx ioc_guid %016llx pkey %04x " | 1707 | printk(KERN_DEBUG PFX "new target: id_ext %016llx ioc_guid %016llx pkey %04x " |
1564 | "service_id %016llx dgid %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", | 1708 | "service_id %016llx dgid %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", |
@@ -1579,7 +1723,7 @@ static ssize_t srp_create_target(struct class_device *class_dev, | |||
1579 | if (ret) | 1723 | if (ret) |
1580 | goto err; | 1724 | goto err; |
1581 | 1725 | ||
1582 | target->cm_id = ib_create_cm_id(host->dev, srp_cm_handler, target); | 1726 | target->cm_id = ib_create_cm_id(host->dev->dev, srp_cm_handler, target); |
1583 | if (IS_ERR(target->cm_id)) { | 1727 | if (IS_ERR(target->cm_id)) { |
1584 | ret = PTR_ERR(target->cm_id); | 1728 | ret = PTR_ERR(target->cm_id); |
1585 | goto err_free; | 1729 | goto err_free; |
@@ -1619,7 +1763,7 @@ static ssize_t show_ibdev(struct class_device *class_dev, char *buf) | |||
1619 | struct srp_host *host = | 1763 | struct srp_host *host = |
1620 | container_of(class_dev, struct srp_host, class_dev); | 1764 | container_of(class_dev, struct srp_host, class_dev); |
1621 | 1765 | ||
1622 | return sprintf(buf, "%s\n", host->dev->name); | 1766 | return sprintf(buf, "%s\n", host->dev->dev->name); |
1623 | } | 1767 | } |
1624 | 1768 | ||
1625 | static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); | 1769 | static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); |
@@ -1634,7 +1778,7 @@ static ssize_t show_port(struct class_device *class_dev, char *buf) | |||
1634 | 1778 | ||
1635 | static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); | 1779 | static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); |
1636 | 1780 | ||
1637 | static struct srp_host *srp_add_port(struct ib_device *device, u8 port) | 1781 | static struct srp_host *srp_add_port(struct srp_device *device, u8 port) |
1638 | { | 1782 | { |
1639 | struct srp_host *host; | 1783 | struct srp_host *host; |
1640 | 1784 | ||
@@ -1643,32 +1787,21 @@ static struct srp_host *srp_add_port(struct ib_device *device, u8 port) | |||
1643 | return NULL; | 1787 | return NULL; |
1644 | 1788 | ||
1645 | INIT_LIST_HEAD(&host->target_list); | 1789 | INIT_LIST_HEAD(&host->target_list); |
1646 | mutex_init(&host->target_mutex); | 1790 | spin_lock_init(&host->target_lock); |
1647 | init_completion(&host->released); | 1791 | init_completion(&host->released); |
1648 | host->dev = device; | 1792 | host->dev = device; |
1649 | host->port = port; | 1793 | host->port = port; |
1650 | 1794 | ||
1651 | host->initiator_port_id[7] = port; | 1795 | host->initiator_port_id[7] = port; |
1652 | memcpy(host->initiator_port_id + 8, &device->node_guid, 8); | 1796 | memcpy(host->initiator_port_id + 8, &device->dev->node_guid, 8); |
1653 | |||
1654 | host->pd = ib_alloc_pd(device); | ||
1655 | if (IS_ERR(host->pd)) | ||
1656 | goto err_free; | ||
1657 | |||
1658 | host->mr = ib_get_dma_mr(host->pd, | ||
1659 | IB_ACCESS_LOCAL_WRITE | | ||
1660 | IB_ACCESS_REMOTE_READ | | ||
1661 | IB_ACCESS_REMOTE_WRITE); | ||
1662 | if (IS_ERR(host->mr)) | ||
1663 | goto err_pd; | ||
1664 | 1797 | ||
1665 | host->class_dev.class = &srp_class; | 1798 | host->class_dev.class = &srp_class; |
1666 | host->class_dev.dev = device->dma_device; | 1799 | host->class_dev.dev = device->dev->dma_device; |
1667 | snprintf(host->class_dev.class_id, BUS_ID_SIZE, "srp-%s-%d", | 1800 | snprintf(host->class_dev.class_id, BUS_ID_SIZE, "srp-%s-%d", |
1668 | device->name, port); | 1801 | device->dev->name, port); |
1669 | 1802 | ||
1670 | if (class_device_register(&host->class_dev)) | 1803 | if (class_device_register(&host->class_dev)) |
1671 | goto err_mr; | 1804 | goto free_host; |
1672 | if (class_device_create_file(&host->class_dev, &class_device_attr_add_target)) | 1805 | if (class_device_create_file(&host->class_dev, &class_device_attr_add_target)) |
1673 | goto err_class; | 1806 | goto err_class; |
1674 | if (class_device_create_file(&host->class_dev, &class_device_attr_ibdev)) | 1807 | if (class_device_create_file(&host->class_dev, &class_device_attr_ibdev)) |
@@ -1681,13 +1814,7 @@ static struct srp_host *srp_add_port(struct ib_device *device, u8 port) | |||
1681 | err_class: | 1814 | err_class: |
1682 | class_device_unregister(&host->class_dev); | 1815 | class_device_unregister(&host->class_dev); |
1683 | 1816 | ||
1684 | err_mr: | 1817 | free_host: |
1685 | ib_dereg_mr(host->mr); | ||
1686 | |||
1687 | err_pd: | ||
1688 | ib_dealloc_pd(host->pd); | ||
1689 | |||
1690 | err_free: | ||
1691 | kfree(host); | 1818 | kfree(host); |
1692 | 1819 | ||
1693 | return NULL; | 1820 | return NULL; |
@@ -1695,15 +1822,62 @@ err_free: | |||
1695 | 1822 | ||
1696 | static void srp_add_one(struct ib_device *device) | 1823 | static void srp_add_one(struct ib_device *device) |
1697 | { | 1824 | { |
1698 | struct list_head *dev_list; | 1825 | struct srp_device *srp_dev; |
1826 | struct ib_device_attr *dev_attr; | ||
1827 | struct ib_fmr_pool_param fmr_param; | ||
1699 | struct srp_host *host; | 1828 | struct srp_host *host; |
1700 | int s, e, p; | 1829 | int s, e, p; |
1701 | 1830 | ||
1702 | dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL); | 1831 | dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL); |
1703 | if (!dev_list) | 1832 | if (!dev_attr) |
1704 | return; | 1833 | return; |
1705 | 1834 | ||
1706 | INIT_LIST_HEAD(dev_list); | 1835 | if (ib_query_device(device, dev_attr)) { |
1836 | printk(KERN_WARNING PFX "Query device failed for %s\n", | ||
1837 | device->name); | ||
1838 | goto free_attr; | ||
1839 | } | ||
1840 | |||
1841 | srp_dev = kmalloc(sizeof *srp_dev, GFP_KERNEL); | ||
1842 | if (!srp_dev) | ||
1843 | goto free_attr; | ||
1844 | |||
1845 | /* | ||
1846 | * Use the smallest page size supported by the HCA, down to a | ||
1847 | * minimum of 512 bytes (which is the smallest sector that a | ||
1848 | * SCSI command will ever carry). | ||
1849 | */ | ||
1850 | srp_dev->fmr_page_shift = max(9, ffs(dev_attr->page_size_cap) - 1); | ||
1851 | srp_dev->fmr_page_size = 1 << srp_dev->fmr_page_shift; | ||
1852 | srp_dev->fmr_page_mask = ~((unsigned long) srp_dev->fmr_page_size - 1); | ||
1853 | |||
1854 | INIT_LIST_HEAD(&srp_dev->dev_list); | ||
1855 | |||
1856 | srp_dev->dev = device; | ||
1857 | srp_dev->pd = ib_alloc_pd(device); | ||
1858 | if (IS_ERR(srp_dev->pd)) | ||
1859 | goto free_dev; | ||
1860 | |||
1861 | srp_dev->mr = ib_get_dma_mr(srp_dev->pd, | ||
1862 | IB_ACCESS_LOCAL_WRITE | | ||
1863 | IB_ACCESS_REMOTE_READ | | ||
1864 | IB_ACCESS_REMOTE_WRITE); | ||
1865 | if (IS_ERR(srp_dev->mr)) | ||
1866 | goto err_pd; | ||
1867 | |||
1868 | memset(&fmr_param, 0, sizeof fmr_param); | ||
1869 | fmr_param.pool_size = SRP_FMR_POOL_SIZE; | ||
1870 | fmr_param.dirty_watermark = SRP_FMR_DIRTY_SIZE; | ||
1871 | fmr_param.cache = 1; | ||
1872 | fmr_param.max_pages_per_fmr = SRP_FMR_SIZE; | ||
1873 | fmr_param.page_shift = srp_dev->fmr_page_shift; | ||
1874 | fmr_param.access = (IB_ACCESS_LOCAL_WRITE | | ||
1875 | IB_ACCESS_REMOTE_WRITE | | ||
1876 | IB_ACCESS_REMOTE_READ); | ||
1877 | |||
1878 | srp_dev->fmr_pool = ib_create_fmr_pool(srp_dev->pd, &fmr_param); | ||
1879 | if (IS_ERR(srp_dev->fmr_pool)) | ||
1880 | srp_dev->fmr_pool = NULL; | ||
1707 | 1881 | ||
1708 | if (device->node_type == IB_NODE_SWITCH) { | 1882 | if (device->node_type == IB_NODE_SWITCH) { |
1709 | s = 0; | 1883 | s = 0; |
@@ -1714,25 +1888,35 @@ static void srp_add_one(struct ib_device *device) | |||
1714 | } | 1888 | } |
1715 | 1889 | ||
1716 | for (p = s; p <= e; ++p) { | 1890 | for (p = s; p <= e; ++p) { |
1717 | host = srp_add_port(device, p); | 1891 | host = srp_add_port(srp_dev, p); |
1718 | if (host) | 1892 | if (host) |
1719 | list_add_tail(&host->list, dev_list); | 1893 | list_add_tail(&host->list, &srp_dev->dev_list); |
1720 | } | 1894 | } |
1721 | 1895 | ||
1722 | ib_set_client_data(device, &srp_client, dev_list); | 1896 | ib_set_client_data(device, &srp_client, srp_dev); |
1897 | |||
1898 | goto free_attr; | ||
1899 | |||
1900 | err_pd: | ||
1901 | ib_dealloc_pd(srp_dev->pd); | ||
1902 | |||
1903 | free_dev: | ||
1904 | kfree(srp_dev); | ||
1905 | |||
1906 | free_attr: | ||
1907 | kfree(dev_attr); | ||
1723 | } | 1908 | } |
1724 | 1909 | ||
1725 | static void srp_remove_one(struct ib_device *device) | 1910 | static void srp_remove_one(struct ib_device *device) |
1726 | { | 1911 | { |
1727 | struct list_head *dev_list; | 1912 | struct srp_device *srp_dev; |
1728 | struct srp_host *host, *tmp_host; | 1913 | struct srp_host *host, *tmp_host; |
1729 | LIST_HEAD(target_list); | 1914 | LIST_HEAD(target_list); |
1730 | struct srp_target_port *target, *tmp_target; | 1915 | struct srp_target_port *target, *tmp_target; |
1731 | unsigned long flags; | ||
1732 | 1916 | ||
1733 | dev_list = ib_get_client_data(device, &srp_client); | 1917 | srp_dev = ib_get_client_data(device, &srp_client); |
1734 | 1918 | ||
1735 | list_for_each_entry_safe(host, tmp_host, dev_list, list) { | 1919 | list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) { |
1736 | class_device_unregister(&host->class_dev); | 1920 | class_device_unregister(&host->class_dev); |
1737 | /* | 1921 | /* |
1738 | * Wait for the sysfs entry to go away, so that no new | 1922 | * Wait for the sysfs entry to go away, so that no new |
@@ -1744,15 +1928,13 @@ static void srp_remove_one(struct ib_device *device) | |||
1744 | * Mark all target ports as removed, so we stop queueing | 1928 | * Mark all target ports as removed, so we stop queueing |
1745 | * commands and don't try to reconnect. | 1929 | * commands and don't try to reconnect. |
1746 | */ | 1930 | */ |
1747 | mutex_lock(&host->target_mutex); | 1931 | spin_lock(&host->target_lock); |
1748 | list_for_each_entry_safe(target, tmp_target, | 1932 | list_for_each_entry(target, &host->target_list, list) { |
1749 | &host->target_list, list) { | 1933 | spin_lock_irq(target->scsi_host->host_lock); |
1750 | spin_lock_irqsave(target->scsi_host->host_lock, flags); | 1934 | target->state = SRP_TARGET_REMOVED; |
1751 | if (target->state != SRP_TARGET_REMOVED) | 1935 | spin_unlock_irq(target->scsi_host->host_lock); |
1752 | target->state = SRP_TARGET_REMOVED; | ||
1753 | spin_unlock_irqrestore(target->scsi_host->host_lock, flags); | ||
1754 | } | 1936 | } |
1755 | mutex_unlock(&host->target_mutex); | 1937 | spin_unlock(&host->target_lock); |
1756 | 1938 | ||
1757 | /* | 1939 | /* |
1758 | * Wait for any reconnection tasks that may have | 1940 | * Wait for any reconnection tasks that may have |
@@ -1770,18 +1952,26 @@ static void srp_remove_one(struct ib_device *device) | |||
1770 | scsi_host_put(target->scsi_host); | 1952 | scsi_host_put(target->scsi_host); |
1771 | } | 1953 | } |
1772 | 1954 | ||
1773 | ib_dereg_mr(host->mr); | ||
1774 | ib_dealloc_pd(host->pd); | ||
1775 | kfree(host); | 1955 | kfree(host); |
1776 | } | 1956 | } |
1777 | 1957 | ||
1778 | kfree(dev_list); | 1958 | if (srp_dev->fmr_pool) |
1959 | ib_destroy_fmr_pool(srp_dev->fmr_pool); | ||
1960 | ib_dereg_mr(srp_dev->mr); | ||
1961 | ib_dealloc_pd(srp_dev->pd); | ||
1962 | |||
1963 | kfree(srp_dev); | ||
1779 | } | 1964 | } |
1780 | 1965 | ||
1781 | static int __init srp_init_module(void) | 1966 | static int __init srp_init_module(void) |
1782 | { | 1967 | { |
1783 | int ret; | 1968 | int ret; |
1784 | 1969 | ||
1970 | srp_template.sg_tablesize = srp_sg_tablesize; | ||
1971 | srp_max_iu_len = (sizeof (struct srp_cmd) + | ||
1972 | sizeof (struct srp_indirect_buf) + | ||
1973 | srp_sg_tablesize * 16); | ||
1974 | |||
1785 | ret = class_register(&srp_class); | 1975 | ret = class_register(&srp_class); |
1786 | if (ret) { | 1976 | if (ret) { |
1787 | printk(KERN_ERR PFX "couldn't register class infiniband_srp\n"); | 1977 | printk(KERN_ERR PFX "couldn't register class infiniband_srp\n"); |
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h index c5cd43aae860..5b581fb8eb0d 100644 --- a/drivers/infiniband/ulp/srp/ib_srp.h +++ b/drivers/infiniband/ulp/srp/ib_srp.h | |||
@@ -46,6 +46,7 @@ | |||
46 | #include <rdma/ib_verbs.h> | 46 | #include <rdma/ib_verbs.h> |
47 | #include <rdma/ib_sa.h> | 47 | #include <rdma/ib_sa.h> |
48 | #include <rdma/ib_cm.h> | 48 | #include <rdma/ib_cm.h> |
49 | #include <rdma/ib_fmr_pool.h> | ||
49 | 50 | ||
50 | enum { | 51 | enum { |
51 | SRP_PATH_REC_TIMEOUT_MS = 1000, | 52 | SRP_PATH_REC_TIMEOUT_MS = 1000, |
@@ -55,20 +56,21 @@ enum { | |||
55 | SRP_DLID_REDIRECT = 2, | 56 | SRP_DLID_REDIRECT = 2, |
56 | 57 | ||
57 | SRP_MAX_LUN = 512, | 58 | SRP_MAX_LUN = 512, |
58 | SRP_MAX_IU_LEN = 256, | 59 | SRP_DEF_SG_TABLESIZE = 12, |
59 | 60 | ||
60 | SRP_RQ_SHIFT = 6, | 61 | SRP_RQ_SHIFT = 6, |
61 | SRP_RQ_SIZE = 1 << SRP_RQ_SHIFT, | 62 | SRP_RQ_SIZE = 1 << SRP_RQ_SHIFT, |
62 | SRP_SQ_SIZE = SRP_RQ_SIZE - 1, | 63 | SRP_SQ_SIZE = SRP_RQ_SIZE - 1, |
63 | SRP_CQ_SIZE = SRP_SQ_SIZE + SRP_RQ_SIZE, | 64 | SRP_CQ_SIZE = SRP_SQ_SIZE + SRP_RQ_SIZE, |
64 | 65 | ||
65 | SRP_TAG_TSK_MGMT = 1 << (SRP_RQ_SHIFT + 1) | 66 | SRP_TAG_TSK_MGMT = 1 << (SRP_RQ_SHIFT + 1), |
67 | |||
68 | SRP_FMR_SIZE = 256, | ||
69 | SRP_FMR_POOL_SIZE = 1024, | ||
70 | SRP_FMR_DIRTY_SIZE = SRP_FMR_POOL_SIZE / 4 | ||
66 | }; | 71 | }; |
67 | 72 | ||
68 | #define SRP_OP_RECV (1 << 31) | 73 | #define SRP_OP_RECV (1 << 31) |
69 | #define SRP_MAX_INDIRECT ((SRP_MAX_IU_LEN - \ | ||
70 | sizeof (struct srp_cmd) - \ | ||
71 | sizeof (struct srp_indirect_buf)) / 16) | ||
72 | 74 | ||
73 | enum srp_target_state { | 75 | enum srp_target_state { |
74 | SRP_TARGET_LIVE, | 76 | SRP_TARGET_LIVE, |
@@ -77,15 +79,24 @@ enum srp_target_state { | |||
77 | SRP_TARGET_REMOVED | 79 | SRP_TARGET_REMOVED |
78 | }; | 80 | }; |
79 | 81 | ||
80 | struct srp_host { | 82 | struct srp_device { |
81 | u8 initiator_port_id[16]; | 83 | struct list_head dev_list; |
82 | struct ib_device *dev; | 84 | struct ib_device *dev; |
83 | u8 port; | ||
84 | struct ib_pd *pd; | 85 | struct ib_pd *pd; |
85 | struct ib_mr *mr; | 86 | struct ib_mr *mr; |
87 | struct ib_fmr_pool *fmr_pool; | ||
88 | int fmr_page_shift; | ||
89 | int fmr_page_size; | ||
90 | unsigned long fmr_page_mask; | ||
91 | }; | ||
92 | |||
93 | struct srp_host { | ||
94 | u8 initiator_port_id[16]; | ||
95 | struct srp_device *dev; | ||
96 | u8 port; | ||
86 | struct class_device class_dev; | 97 | struct class_device class_dev; |
87 | struct list_head target_list; | 98 | struct list_head target_list; |
88 | struct mutex target_mutex; | 99 | spinlock_t target_lock; |
89 | struct completion released; | 100 | struct completion released; |
90 | struct list_head list; | 101 | struct list_head list; |
91 | }; | 102 | }; |
@@ -95,6 +106,7 @@ struct srp_request { | |||
95 | struct scsi_cmnd *scmnd; | 106 | struct scsi_cmnd *scmnd; |
96 | struct srp_iu *cmd; | 107 | struct srp_iu *cmd; |
97 | struct srp_iu *tsk_mgmt; | 108 | struct srp_iu *tsk_mgmt; |
109 | struct ib_pool_fmr *fmr; | ||
98 | /* | 110 | /* |
99 | * Fake scatterlist used when scmnd->use_sg==0. Can be killed | 111 | * Fake scatterlist used when scmnd->use_sg==0. Can be killed |
100 | * when the SCSI midlayer no longer generates non-SG commands. | 112 | * when the SCSI midlayer no longer generates non-SG commands. |
@@ -110,6 +122,7 @@ struct srp_target_port { | |||
110 | __be64 id_ext; | 122 | __be64 id_ext; |
111 | __be64 ioc_guid; | 123 | __be64 ioc_guid; |
112 | __be64 service_id; | 124 | __be64 service_id; |
125 | u16 io_class; | ||
113 | struct srp_host *srp_host; | 126 | struct srp_host *srp_host; |
114 | struct Scsi_Host *scsi_host; | 127 | struct Scsi_Host *scsi_host; |
115 | char target_name[32]; | 128 | char target_name[32]; |
@@ -126,6 +139,8 @@ struct srp_target_port { | |||
126 | int max_ti_iu_len; | 139 | int max_ti_iu_len; |
127 | s32 req_lim; | 140 | s32 req_lim; |
128 | 141 | ||
142 | int zero_req_lim; | ||
143 | |||
129 | unsigned rx_head; | 144 | unsigned rx_head; |
130 | struct srp_iu *rx_ring[SRP_RQ_SIZE]; | 145 | struct srp_iu *rx_ring[SRP_RQ_SIZE]; |
131 | 146 | ||
diff --git a/drivers/media/dvb/dvb-core/dvb_net.c b/drivers/media/dvb/dvb-core/dvb_net.c index 2f0f35811bf7..9fd87521a163 100644 --- a/drivers/media/dvb/dvb-core/dvb_net.c +++ b/drivers/media/dvb/dvb-core/dvb_net.c | |||
@@ -1052,7 +1052,7 @@ static void wq_set_multicast_list (void *data) | |||
1052 | 1052 | ||
1053 | dvb_net_feed_stop(dev); | 1053 | dvb_net_feed_stop(dev); |
1054 | priv->rx_mode = RX_MODE_UNI; | 1054 | priv->rx_mode = RX_MODE_UNI; |
1055 | spin_lock_bh(&dev->xmit_lock); | 1055 | netif_tx_lock_bh(dev); |
1056 | 1056 | ||
1057 | if (dev->flags & IFF_PROMISC) { | 1057 | if (dev->flags & IFF_PROMISC) { |
1058 | dprintk("%s: promiscuous mode\n", dev->name); | 1058 | dprintk("%s: promiscuous mode\n", dev->name); |
@@ -1077,7 +1077,7 @@ static void wq_set_multicast_list (void *data) | |||
1077 | } | 1077 | } |
1078 | } | 1078 | } |
1079 | 1079 | ||
1080 | spin_unlock_bh(&dev->xmit_lock); | 1080 | netif_tx_unlock_bh(dev); |
1081 | dvb_net_feed_start(dev); | 1081 | dvb_net_feed_start(dev); |
1082 | } | 1082 | } |
1083 | 1083 | ||
diff --git a/drivers/message/fusion/mptspi.c b/drivers/message/fusion/mptspi.c index f2a4d382ea19..3201de053943 100644 --- a/drivers/message/fusion/mptspi.c +++ b/drivers/message/fusion/mptspi.c | |||
@@ -831,6 +831,7 @@ mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) | |||
831 | return rc; | 831 | return rc; |
832 | } | 832 | } |
833 | 833 | ||
834 | #ifdef CONFIG_PM | ||
834 | /* | 835 | /* |
835 | * spi module resume handler | 836 | * spi module resume handler |
836 | */ | 837 | */ |
@@ -846,6 +847,7 @@ mptspi_resume(struct pci_dev *pdev) | |||
846 | 847 | ||
847 | return rc; | 848 | return rc; |
848 | } | 849 | } |
850 | #endif | ||
849 | 851 | ||
850 | /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ | 852 | /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ |
851 | /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ | 853 | /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ |
diff --git a/drivers/message/i2o/exec-osm.c b/drivers/message/i2o/exec-osm.c index 5ea133c59afb..7bd4d85d0b42 100644 --- a/drivers/message/i2o/exec-osm.c +++ b/drivers/message/i2o/exec-osm.c | |||
@@ -55,6 +55,7 @@ struct i2o_exec_wait { | |||
55 | u32 m; /* message id */ | 55 | u32 m; /* message id */ |
56 | struct i2o_message *msg; /* pointer to the reply message */ | 56 | struct i2o_message *msg; /* pointer to the reply message */ |
57 | struct list_head list; /* node in global wait list */ | 57 | struct list_head list; /* node in global wait list */ |
58 | spinlock_t lock; /* lock before modifying */ | ||
58 | }; | 59 | }; |
59 | 60 | ||
60 | /* Work struct needed to handle LCT NOTIFY replies */ | 61 | /* Work struct needed to handle LCT NOTIFY replies */ |
@@ -87,6 +88,7 @@ static struct i2o_exec_wait *i2o_exec_wait_alloc(void) | |||
87 | return NULL; | 88 | return NULL; |
88 | 89 | ||
89 | INIT_LIST_HEAD(&wait->list); | 90 | INIT_LIST_HEAD(&wait->list); |
91 | spin_lock_init(&wait->lock); | ||
90 | 92 | ||
91 | return wait; | 93 | return wait; |
92 | }; | 94 | }; |
@@ -125,6 +127,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg, | |||
125 | DECLARE_WAIT_QUEUE_HEAD(wq); | 127 | DECLARE_WAIT_QUEUE_HEAD(wq); |
126 | struct i2o_exec_wait *wait; | 128 | struct i2o_exec_wait *wait; |
127 | static u32 tcntxt = 0x80000000; | 129 | static u32 tcntxt = 0x80000000; |
130 | long flags; | ||
128 | int rc = 0; | 131 | int rc = 0; |
129 | 132 | ||
130 | wait = i2o_exec_wait_alloc(); | 133 | wait = i2o_exec_wait_alloc(); |
@@ -146,33 +149,28 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg, | |||
146 | wait->tcntxt = tcntxt++; | 149 | wait->tcntxt = tcntxt++; |
147 | msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt); | 150 | msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt); |
148 | 151 | ||
152 | wait->wq = &wq; | ||
153 | /* | ||
154 | * we add elements to the head, because if a entry in the list will | ||
155 | * never be removed, we have to iterate over it every time | ||
156 | */ | ||
157 | list_add(&wait->list, &i2o_exec_wait_list); | ||
158 | |||
149 | /* | 159 | /* |
150 | * Post the message to the controller. At some point later it will | 160 | * Post the message to the controller. At some point later it will |
151 | * return. If we time out before it returns then complete will be zero. | 161 | * return. If we time out before it returns then complete will be zero. |
152 | */ | 162 | */ |
153 | i2o_msg_post(c, msg); | 163 | i2o_msg_post(c, msg); |
154 | 164 | ||
155 | if (!wait->complete) { | 165 | wait_event_interruptible_timeout(wq, wait->complete, timeout * HZ); |
156 | wait->wq = &wq; | ||
157 | /* | ||
158 | * we add elements add the head, because if a entry in the list | ||
159 | * will never be removed, we have to iterate over it every time | ||
160 | */ | ||
161 | list_add(&wait->list, &i2o_exec_wait_list); | ||
162 | |||
163 | wait_event_interruptible_timeout(wq, wait->complete, | ||
164 | timeout * HZ); | ||
165 | 166 | ||
166 | wait->wq = NULL; | 167 | spin_lock_irqsave(&wait->lock, flags); |
167 | } | ||
168 | 168 | ||
169 | barrier(); | 169 | wait->wq = NULL; |
170 | 170 | ||
171 | if (wait->complete) { | 171 | if (wait->complete) |
172 | rc = le32_to_cpu(wait->msg->body[0]) >> 24; | 172 | rc = le32_to_cpu(wait->msg->body[0]) >> 24; |
173 | i2o_flush_reply(c, wait->m); | 173 | else { |
174 | i2o_exec_wait_free(wait); | ||
175 | } else { | ||
176 | /* | 174 | /* |
177 | * We cannot remove it now. This is important. When it does | 175 | * We cannot remove it now. This is important. When it does |
178 | * terminate (which it must do if the controller has not | 176 | * terminate (which it must do if the controller has not |
@@ -186,6 +184,13 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg, | |||
186 | rc = -ETIMEDOUT; | 184 | rc = -ETIMEDOUT; |
187 | } | 185 | } |
188 | 186 | ||
187 | spin_unlock_irqrestore(&wait->lock, flags); | ||
188 | |||
189 | if (rc != -ETIMEDOUT) { | ||
190 | i2o_flush_reply(c, wait->m); | ||
191 | i2o_exec_wait_free(wait); | ||
192 | } | ||
193 | |||
189 | return rc; | 194 | return rc; |
190 | }; | 195 | }; |
191 | 196 | ||
@@ -213,7 +218,6 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m, | |||
213 | { | 218 | { |
214 | struct i2o_exec_wait *wait, *tmp; | 219 | struct i2o_exec_wait *wait, *tmp; |
215 | unsigned long flags; | 220 | unsigned long flags; |
216 | static spinlock_t lock = SPIN_LOCK_UNLOCKED; | ||
217 | int rc = 1; | 221 | int rc = 1; |
218 | 222 | ||
219 | /* | 223 | /* |
@@ -223,23 +227,24 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m, | |||
223 | * already expired. Not much we can do about that except log it for | 227 | * already expired. Not much we can do about that except log it for |
224 | * debug purposes, increase timeout, and recompile. | 228 | * debug purposes, increase timeout, and recompile. |
225 | */ | 229 | */ |
226 | spin_lock_irqsave(&lock, flags); | ||
227 | list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) { | 230 | list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) { |
228 | if (wait->tcntxt == context) { | 231 | if (wait->tcntxt == context) { |
229 | list_del(&wait->list); | 232 | spin_lock_irqsave(&wait->lock, flags); |
230 | 233 | ||
231 | spin_unlock_irqrestore(&lock, flags); | 234 | list_del(&wait->list); |
232 | 235 | ||
233 | wait->m = m; | 236 | wait->m = m; |
234 | wait->msg = msg; | 237 | wait->msg = msg; |
235 | wait->complete = 1; | 238 | wait->complete = 1; |
236 | 239 | ||
237 | barrier(); | 240 | if (wait->wq) |
238 | |||
239 | if (wait->wq) { | ||
240 | wake_up_interruptible(wait->wq); | ||
241 | rc = 0; | 241 | rc = 0; |
242 | } else { | 242 | else |
243 | rc = -1; | ||
244 | |||
245 | spin_unlock_irqrestore(&wait->lock, flags); | ||
246 | |||
247 | if (rc) { | ||
243 | struct device *dev; | 248 | struct device *dev; |
244 | 249 | ||
245 | dev = &c->pdev->dev; | 250 | dev = &c->pdev->dev; |
@@ -248,15 +253,13 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m, | |||
248 | c->name); | 253 | c->name); |
249 | i2o_dma_free(dev, &wait->dma); | 254 | i2o_dma_free(dev, &wait->dma); |
250 | i2o_exec_wait_free(wait); | 255 | i2o_exec_wait_free(wait); |
251 | rc = -1; | 256 | } else |
252 | } | 257 | wake_up_interruptible(wait->wq); |
253 | 258 | ||
254 | return rc; | 259 | return rc; |
255 | } | 260 | } |
256 | } | 261 | } |
257 | 262 | ||
258 | spin_unlock_irqrestore(&lock, flags); | ||
259 | |||
260 | osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name, | 263 | osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name, |
261 | context); | 264 | context); |
262 | 265 | ||
@@ -322,14 +325,9 @@ static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL); | |||
322 | static int i2o_exec_probe(struct device *dev) | 325 | static int i2o_exec_probe(struct device *dev) |
323 | { | 326 | { |
324 | struct i2o_device *i2o_dev = to_i2o_device(dev); | 327 | struct i2o_device *i2o_dev = to_i2o_device(dev); |
325 | struct i2o_controller *c = i2o_dev->iop; | ||
326 | 328 | ||
327 | i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff); | 329 | i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff); |
328 | 330 | ||
329 | c->exec = i2o_dev; | ||
330 | |||
331 | i2o_exec_lct_notify(c, c->lct->change_ind + 1); | ||
332 | |||
333 | device_create_file(dev, &dev_attr_vendor_id); | 331 | device_create_file(dev, &dev_attr_vendor_id); |
334 | device_create_file(dev, &dev_attr_product_id); | 332 | device_create_file(dev, &dev_attr_product_id); |
335 | 333 | ||
@@ -523,6 +521,8 @@ static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind) | |||
523 | struct device *dev; | 521 | struct device *dev; |
524 | struct i2o_message *msg; | 522 | struct i2o_message *msg; |
525 | 523 | ||
524 | down(&c->lct_lock); | ||
525 | |||
526 | dev = &c->pdev->dev; | 526 | dev = &c->pdev->dev; |
527 | 527 | ||
528 | if (i2o_dma_realloc | 528 | if (i2o_dma_realloc |
@@ -545,6 +545,8 @@ static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind) | |||
545 | 545 | ||
546 | i2o_msg_post(c, msg); | 546 | i2o_msg_post(c, msg); |
547 | 547 | ||
548 | up(&c->lct_lock); | ||
549 | |||
548 | return 0; | 550 | return 0; |
549 | }; | 551 | }; |
550 | 552 | ||
diff --git a/drivers/message/i2o/iop.c b/drivers/message/i2o/iop.c index 492167446936..febbdd4e0605 100644 --- a/drivers/message/i2o/iop.c +++ b/drivers/message/i2o/iop.c | |||
@@ -804,8 +804,6 @@ void i2o_iop_remove(struct i2o_controller *c) | |||
804 | 804 | ||
805 | /* Ask the IOP to switch to RESET state */ | 805 | /* Ask the IOP to switch to RESET state */ |
806 | i2o_iop_reset(c); | 806 | i2o_iop_reset(c); |
807 | |||
808 | put_device(&c->device); | ||
809 | } | 807 | } |
810 | 808 | ||
811 | /** | 809 | /** |
@@ -1059,7 +1057,7 @@ struct i2o_controller *i2o_iop_alloc(void) | |||
1059 | 1057 | ||
1060 | snprintf(poolname, sizeof(poolname), "i2o_%s_msg_inpool", c->name); | 1058 | snprintf(poolname, sizeof(poolname), "i2o_%s_msg_inpool", c->name); |
1061 | if (i2o_pool_alloc | 1059 | if (i2o_pool_alloc |
1062 | (&c->in_msg, poolname, I2O_INBOUND_MSG_FRAME_SIZE * 4, | 1060 | (&c->in_msg, poolname, I2O_INBOUND_MSG_FRAME_SIZE * 4 + sizeof(u32), |
1063 | I2O_MSG_INPOOL_MIN)) { | 1061 | I2O_MSG_INPOOL_MIN)) { |
1064 | kfree(c); | 1062 | kfree(c); |
1065 | return ERR_PTR(-ENOMEM); | 1063 | return ERR_PTR(-ENOMEM); |
diff --git a/drivers/net/3c501.c b/drivers/net/3c501.c index f6d51ce34b00..bb44509fd404 100644 --- a/drivers/net/3c501.c +++ b/drivers/net/3c501.c | |||
@@ -909,7 +909,7 @@ MODULE_PARM_DESC(irq, "EtherLink IRQ number"); | |||
909 | * here also causes the module to be unloaded | 909 | * here also causes the module to be unloaded |
910 | */ | 910 | */ |
911 | 911 | ||
912 | int init_module(void) | 912 | int __init init_module(void) |
913 | { | 913 | { |
914 | dev_3c501 = el1_probe(-1); | 914 | dev_3c501 = el1_probe(-1); |
915 | if (IS_ERR(dev_3c501)) | 915 | if (IS_ERR(dev_3c501)) |
diff --git a/drivers/net/3c503.c b/drivers/net/3c503.c index dcc98afa65d7..cb5ef75450dc 100644 --- a/drivers/net/3c503.c +++ b/drivers/net/3c503.c | |||
@@ -688,7 +688,7 @@ MODULE_LICENSE("GPL"); | |||
688 | 688 | ||
689 | /* This is set up so that only a single autoprobe takes place per call. | 689 | /* This is set up so that only a single autoprobe takes place per call. |
690 | ISA device autoprobes on a running machine are not recommended. */ | 690 | ISA device autoprobes on a running machine are not recommended. */ |
691 | int | 691 | int __init |
692 | init_module(void) | 692 | init_module(void) |
693 | { | 693 | { |
694 | struct net_device *dev; | 694 | struct net_device *dev; |
diff --git a/drivers/net/3c505.c b/drivers/net/3c505.c index 111601ca4ca3..19c0b856c488 100644 --- a/drivers/net/3c505.c +++ b/drivers/net/3c505.c | |||
@@ -1633,7 +1633,7 @@ MODULE_PARM_DESC(io, "EtherLink Plus I/O base address(es)"); | |||
1633 | MODULE_PARM_DESC(irq, "EtherLink Plus IRQ number(s) (assigned)"); | 1633 | MODULE_PARM_DESC(irq, "EtherLink Plus IRQ number(s) (assigned)"); |
1634 | MODULE_PARM_DESC(dma, "EtherLink Plus DMA channel(s)"); | 1634 | MODULE_PARM_DESC(dma, "EtherLink Plus DMA channel(s)"); |
1635 | 1635 | ||
1636 | int init_module(void) | 1636 | int __init init_module(void) |
1637 | { | 1637 | { |
1638 | int this_dev, found = 0; | 1638 | int this_dev, found = 0; |
1639 | 1639 | ||
diff --git a/drivers/net/3c507.c b/drivers/net/3c507.c index 4db82893909c..6039049259ed 100644 --- a/drivers/net/3c507.c +++ b/drivers/net/3c507.c | |||
@@ -932,7 +932,7 @@ module_param(irq, int, 0); | |||
932 | MODULE_PARM_DESC(io, "EtherLink16 I/O base address"); | 932 | MODULE_PARM_DESC(io, "EtherLink16 I/O base address"); |
933 | MODULE_PARM_DESC(irq, "(ignored)"); | 933 | MODULE_PARM_DESC(irq, "(ignored)"); |
934 | 934 | ||
935 | int init_module(void) | 935 | int __init init_module(void) |
936 | { | 936 | { |
937 | if (io == 0) | 937 | if (io == 0) |
938 | printk("3c507: You should not use auto-probing with insmod!\n"); | 938 | printk("3c507: You should not use auto-probing with insmod!\n"); |
diff --git a/drivers/net/3c523.c b/drivers/net/3c523.c index b40885d41680..4bf8510655c5 100644 --- a/drivers/net/3c523.c +++ b/drivers/net/3c523.c | |||
@@ -1277,7 +1277,7 @@ MODULE_PARM_DESC(io, "EtherLink/MC I/O base address(es)"); | |||
1277 | MODULE_PARM_DESC(irq, "EtherLink/MC IRQ number(s)"); | 1277 | MODULE_PARM_DESC(irq, "EtherLink/MC IRQ number(s)"); |
1278 | MODULE_LICENSE("GPL"); | 1278 | MODULE_LICENSE("GPL"); |
1279 | 1279 | ||
1280 | int init_module(void) | 1280 | int __init init_module(void) |
1281 | { | 1281 | { |
1282 | int this_dev,found = 0; | 1282 | int this_dev,found = 0; |
1283 | 1283 | ||
diff --git a/drivers/net/3c527.c b/drivers/net/3c527.c index 6db3301e7965..1b1cb0026072 100644 --- a/drivers/net/3c527.c +++ b/drivers/net/3c527.c | |||
@@ -1646,7 +1646,7 @@ static struct net_device *this_device; | |||
1646 | * insmod multiple modules for now but it's a hack. | 1646 | * insmod multiple modules for now but it's a hack. |
1647 | */ | 1647 | */ |
1648 | 1648 | ||
1649 | int init_module(void) | 1649 | int __init init_module(void) |
1650 | { | 1650 | { |
1651 | this_device = mc32_probe(-1); | 1651 | this_device = mc32_probe(-1); |
1652 | if (IS_ERR(this_device)) | 1652 | if (IS_ERR(this_device)) |
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig index f499a3bc629f..0c6b45a11d15 100644 --- a/drivers/net/Kconfig +++ b/drivers/net/Kconfig | |||
@@ -447,6 +447,7 @@ config MIPS_GT96100ETH | |||
447 | config MIPS_AU1X00_ENET | 447 | config MIPS_AU1X00_ENET |
448 | bool "MIPS AU1000 Ethernet support" | 448 | bool "MIPS AU1000 Ethernet support" |
449 | depends on NET_ETHERNET && SOC_AU1X00 | 449 | depends on NET_ETHERNET && SOC_AU1X00 |
450 | select PHYLIB | ||
450 | select CRC32 | 451 | select CRC32 |
451 | help | 452 | help |
452 | If you have an Alchemy Semi AU1X00 based system | 453 | If you have an Alchemy Semi AU1X00 based system |
@@ -869,7 +870,7 @@ config SMC911X | |||
869 | tristate "SMSC LAN911[5678] support" | 870 | tristate "SMSC LAN911[5678] support" |
870 | select CRC32 | 871 | select CRC32 |
871 | select MII | 872 | select MII |
872 | depends on NET_ETHERNET | 873 | depends on NET_ETHERNET && ARCH_PXA |
873 | help | 874 | help |
874 | This is a driver for SMSC's LAN911x series of Ethernet chipsets | 875 | This is a driver for SMSC's LAN911x series of Ethernet chipsets |
875 | including the new LAN9115, LAN9116, LAN9117, and LAN9118. | 876 | including the new LAN9115, LAN9116, LAN9117, and LAN9118. |
@@ -2179,6 +2180,8 @@ config TIGON3 | |||
2179 | config BNX2 | 2180 | config BNX2 |
2180 | tristate "Broadcom NetXtremeII support" | 2181 | tristate "Broadcom NetXtremeII support" |
2181 | depends on PCI | 2182 | depends on PCI |
2183 | select CRC32 | ||
2184 | select ZLIB_INFLATE | ||
2182 | help | 2185 | help |
2183 | This driver supports Broadcom NetXtremeII gigabit Ethernet cards. | 2186 | This driver supports Broadcom NetXtremeII gigabit Ethernet cards. |
2184 | 2187 | ||
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c index e1fe960d71b3..038d5fcb15e6 100644 --- a/drivers/net/au1000_eth.c +++ b/drivers/net/au1000_eth.c | |||
@@ -9,6 +9,9 @@ | |||
9 | * Update: 2004 Bjoern Riemer, riemer@fokus.fraunhofer.de | 9 | * Update: 2004 Bjoern Riemer, riemer@fokus.fraunhofer.de |
10 | * or riemer@riemer-nt.de: fixed the link beat detection with | 10 | * or riemer@riemer-nt.de: fixed the link beat detection with |
11 | * ioctls (SIOCGMIIPHY) | 11 | * ioctls (SIOCGMIIPHY) |
12 | * Copyright 2006 Herbert Valerio Riedel <hvr@gnu.org> | ||
13 | * converted to use linux-2.6.x's PHY framework | ||
14 | * | ||
12 | * Author: MontaVista Software, Inc. | 15 | * Author: MontaVista Software, Inc. |
13 | * ppopov@mvista.com or source@mvista.com | 16 | * ppopov@mvista.com or source@mvista.com |
14 | * | 17 | * |
@@ -53,6 +56,7 @@ | |||
53 | #include <linux/skbuff.h> | 56 | #include <linux/skbuff.h> |
54 | #include <linux/delay.h> | 57 | #include <linux/delay.h> |
55 | #include <linux/crc32.h> | 58 | #include <linux/crc32.h> |
59 | #include <linux/phy.h> | ||
56 | #include <asm/mipsregs.h> | 60 | #include <asm/mipsregs.h> |
57 | #include <asm/irq.h> | 61 | #include <asm/irq.h> |
58 | #include <asm/io.h> | 62 | #include <asm/io.h> |
@@ -88,17 +92,15 @@ static int au1000_tx(struct sk_buff *, struct net_device *); | |||
88 | static int au1000_rx(struct net_device *); | 92 | static int au1000_rx(struct net_device *); |
89 | static irqreturn_t au1000_interrupt(int, void *, struct pt_regs *); | 93 | static irqreturn_t au1000_interrupt(int, void *, struct pt_regs *); |
90 | static void au1000_tx_timeout(struct net_device *); | 94 | static void au1000_tx_timeout(struct net_device *); |
91 | static int au1000_set_config(struct net_device *dev, struct ifmap *map); | ||
92 | static void set_rx_mode(struct net_device *); | 95 | static void set_rx_mode(struct net_device *); |
93 | static struct net_device_stats *au1000_get_stats(struct net_device *); | 96 | static struct net_device_stats *au1000_get_stats(struct net_device *); |
94 | static void au1000_timer(unsigned long); | ||
95 | static int au1000_ioctl(struct net_device *, struct ifreq *, int); | 97 | static int au1000_ioctl(struct net_device *, struct ifreq *, int); |
96 | static int mdio_read(struct net_device *, int, int); | 98 | static int mdio_read(struct net_device *, int, int); |
97 | static void mdio_write(struct net_device *, int, int, u16); | 99 | static void mdio_write(struct net_device *, int, int, u16); |
98 | static void dump_mii(struct net_device *dev, int phy_id); | 100 | static void au1000_adjust_link(struct net_device *); |
101 | static void enable_mac(struct net_device *, int); | ||
99 | 102 | ||
100 | // externs | 103 | // externs |
101 | extern void ack_rise_edge_irq(unsigned int); | ||
102 | extern int get_ethernet_addr(char *ethernet_addr); | 104 | extern int get_ethernet_addr(char *ethernet_addr); |
103 | extern void str2eaddr(unsigned char *ea, unsigned char *str); | 105 | extern void str2eaddr(unsigned char *ea, unsigned char *str); |
104 | extern char * __init prom_getcmdline(void); | 106 | extern char * __init prom_getcmdline(void); |
@@ -126,705 +128,83 @@ static unsigned char au1000_mac_addr[6] __devinitdata = { | |||
126 | 0x00, 0x50, 0xc2, 0x0c, 0x30, 0x00 | 128 | 0x00, 0x50, 0xc2, 0x0c, 0x30, 0x00 |
127 | }; | 129 | }; |
128 | 130 | ||
129 | #define nibswap(x) ((((x) >> 4) & 0x0f) | (((x) << 4) & 0xf0)) | ||
130 | #define RUN_AT(x) (jiffies + (x)) | ||
131 | |||
132 | // For reading/writing 32-bit words from/to DMA memory | ||
133 | #define cpu_to_dma32 cpu_to_be32 | ||
134 | #define dma32_to_cpu be32_to_cpu | ||
135 | |||
136 | struct au1000_private *au_macs[NUM_ETH_INTERFACES]; | 131 | struct au1000_private *au_macs[NUM_ETH_INTERFACES]; |
137 | 132 | ||
138 | /* FIXME | 133 | /* |
139 | * All of the PHY code really should be detached from the MAC | 134 | * board-specific configurations |
140 | * code. | 135 | * |
136 | * PHY detection algorithm | ||
137 | * | ||
138 | * If AU1XXX_PHY_STATIC_CONFIG is undefined, the PHY setup is | ||
139 | * autodetected: | ||
140 | * | ||
141 | * mii_probe() first searches the current MAC's MII bus for a PHY, | ||
142 | * selecting the first (or last, if AU1XXX_PHY_SEARCH_HIGHEST_ADDR is | ||
143 | * defined) PHY address not already claimed by another netdev. | ||
144 | * | ||
145 | * If nothing was found that way when searching for the 2nd ethernet | ||
146 | * controller's PHY and AU1XXX_PHY1_SEARCH_ON_MAC0 is defined, then | ||
147 | * the first MII bus is searched as well for an unclaimed PHY; this is | ||
148 | * needed in case of a dual-PHY accessible only through the MAC0's MII | ||
149 | * bus. | ||
150 | * | ||
151 | * Finally, if no PHY is found, then the corresponding ethernet | ||
152 | * controller is not registered to the network subsystem. | ||
141 | */ | 153 | */ |
142 | 154 | ||
143 | /* Default advertise */ | 155 | /* autodetection defaults */ |
144 | #define GENMII_DEFAULT_ADVERTISE \ | 156 | #undef AU1XXX_PHY_SEARCH_HIGHEST_ADDR |
145 | ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \ | 157 | #define AU1XXX_PHY1_SEARCH_ON_MAC0 |
146 | ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \ | ||
147 | ADVERTISED_Autoneg | ||
148 | |||
149 | #define GENMII_DEFAULT_FEATURES \ | ||
150 | SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | \ | ||
151 | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | \ | ||
152 | SUPPORTED_Autoneg | ||
153 | |||
154 | int bcm_5201_init(struct net_device *dev, int phy_addr) | ||
155 | { | ||
156 | s16 data; | ||
157 | |||
158 | /* Stop auto-negotiation */ | ||
159 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
160 | mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO); | ||
161 | |||
162 | /* Set advertisement to 10/100 and Half/Full duplex | ||
163 | * (full capabilities) */ | ||
164 | data = mdio_read(dev, phy_addr, MII_ANADV); | ||
165 | data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T; | ||
166 | mdio_write(dev, phy_addr, MII_ANADV, data); | ||
167 | |||
168 | /* Restart auto-negotiation */ | ||
169 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
170 | data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO; | ||
171 | mdio_write(dev, phy_addr, MII_CONTROL, data); | ||
172 | |||
173 | if (au1000_debug > 4) | ||
174 | dump_mii(dev, phy_addr); | ||
175 | return 0; | ||
176 | } | ||
177 | |||
178 | int bcm_5201_reset(struct net_device *dev, int phy_addr) | ||
179 | { | ||
180 | s16 mii_control, timeout; | ||
181 | |||
182 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
183 | mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET); | ||
184 | mdelay(1); | ||
185 | for (timeout = 100; timeout > 0; --timeout) { | ||
186 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
187 | if ((mii_control & MII_CNTL_RESET) == 0) | ||
188 | break; | ||
189 | mdelay(1); | ||
190 | } | ||
191 | if (mii_control & MII_CNTL_RESET) { | ||
192 | printk(KERN_ERR "%s PHY reset timeout !\n", dev->name); | ||
193 | return -1; | ||
194 | } | ||
195 | return 0; | ||
196 | } | ||
197 | |||
198 | int | ||
199 | bcm_5201_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
200 | { | ||
201 | u16 mii_data; | ||
202 | struct au1000_private *aup; | ||
203 | |||
204 | if (!dev) { | ||
205 | printk(KERN_ERR "bcm_5201_status error: NULL dev\n"); | ||
206 | return -1; | ||
207 | } | ||
208 | aup = (struct au1000_private *) dev->priv; | ||
209 | |||
210 | mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS); | ||
211 | if (mii_data & MII_STAT_LINK) { | ||
212 | *link = 1; | ||
213 | mii_data = mdio_read(dev, aup->phy_addr, MII_AUX_CNTRL); | ||
214 | if (mii_data & MII_AUX_100) { | ||
215 | if (mii_data & MII_AUX_FDX) { | ||
216 | *speed = IF_PORT_100BASEFX; | ||
217 | dev->if_port = IF_PORT_100BASEFX; | ||
218 | } | ||
219 | else { | ||
220 | *speed = IF_PORT_100BASETX; | ||
221 | dev->if_port = IF_PORT_100BASETX; | ||
222 | } | ||
223 | } | ||
224 | else { | ||
225 | *speed = IF_PORT_10BASET; | ||
226 | dev->if_port = IF_PORT_10BASET; | ||
227 | } | ||
228 | |||
229 | } | ||
230 | else { | ||
231 | *link = 0; | ||
232 | *speed = 0; | ||
233 | dev->if_port = IF_PORT_UNKNOWN; | ||
234 | } | ||
235 | return 0; | ||
236 | } | ||
237 | |||
238 | int lsi_80227_init(struct net_device *dev, int phy_addr) | ||
239 | { | ||
240 | if (au1000_debug > 4) | ||
241 | printk("lsi_80227_init\n"); | ||
242 | |||
243 | /* restart auto-negotiation */ | ||
244 | mdio_write(dev, phy_addr, MII_CONTROL, | ||
245 | MII_CNTL_F100 | MII_CNTL_AUTO | MII_CNTL_RST_AUTO); // | MII_CNTL_FDX); | ||
246 | mdelay(1); | ||
247 | |||
248 | /* set up LEDs to correct display */ | ||
249 | #ifdef CONFIG_MIPS_MTX1 | ||
250 | mdio_write(dev, phy_addr, 17, 0xff80); | ||
251 | #else | ||
252 | mdio_write(dev, phy_addr, 17, 0xffc0); | ||
253 | #endif | ||
254 | |||
255 | if (au1000_debug > 4) | ||
256 | dump_mii(dev, phy_addr); | ||
257 | return 0; | ||
258 | } | ||
259 | |||
260 | int lsi_80227_reset(struct net_device *dev, int phy_addr) | ||
261 | { | ||
262 | s16 mii_control, timeout; | ||
263 | |||
264 | if (au1000_debug > 4) { | ||
265 | printk("lsi_80227_reset\n"); | ||
266 | dump_mii(dev, phy_addr); | ||
267 | } | ||
268 | |||
269 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
270 | mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET); | ||
271 | mdelay(1); | ||
272 | for (timeout = 100; timeout > 0; --timeout) { | ||
273 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
274 | if ((mii_control & MII_CNTL_RESET) == 0) | ||
275 | break; | ||
276 | mdelay(1); | ||
277 | } | ||
278 | if (mii_control & MII_CNTL_RESET) { | ||
279 | printk(KERN_ERR "%s PHY reset timeout !\n", dev->name); | ||
280 | return -1; | ||
281 | } | ||
282 | return 0; | ||
283 | } | ||
284 | |||
285 | int | ||
286 | lsi_80227_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
287 | { | ||
288 | u16 mii_data; | ||
289 | struct au1000_private *aup; | ||
290 | |||
291 | if (!dev) { | ||
292 | printk(KERN_ERR "lsi_80227_status error: NULL dev\n"); | ||
293 | return -1; | ||
294 | } | ||
295 | aup = (struct au1000_private *) dev->priv; | ||
296 | |||
297 | mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS); | ||
298 | if (mii_data & MII_STAT_LINK) { | ||
299 | *link = 1; | ||
300 | mii_data = mdio_read(dev, aup->phy_addr, MII_LSI_PHY_STAT); | ||
301 | if (mii_data & MII_LSI_PHY_STAT_SPD) { | ||
302 | if (mii_data & MII_LSI_PHY_STAT_FDX) { | ||
303 | *speed = IF_PORT_100BASEFX; | ||
304 | dev->if_port = IF_PORT_100BASEFX; | ||
305 | } | ||
306 | else { | ||
307 | *speed = IF_PORT_100BASETX; | ||
308 | dev->if_port = IF_PORT_100BASETX; | ||
309 | } | ||
310 | } | ||
311 | else { | ||
312 | *speed = IF_PORT_10BASET; | ||
313 | dev->if_port = IF_PORT_10BASET; | ||
314 | } | ||
315 | |||
316 | } | ||
317 | else { | ||
318 | *link = 0; | ||
319 | *speed = 0; | ||
320 | dev->if_port = IF_PORT_UNKNOWN; | ||
321 | } | ||
322 | return 0; | ||
323 | } | ||
324 | |||
325 | int am79c901_init(struct net_device *dev, int phy_addr) | ||
326 | { | ||
327 | printk("am79c901_init\n"); | ||
328 | return 0; | ||
329 | } | ||
330 | |||
331 | int am79c901_reset(struct net_device *dev, int phy_addr) | ||
332 | { | ||
333 | printk("am79c901_reset\n"); | ||
334 | return 0; | ||
335 | } | ||
336 | |||
337 | int | ||
338 | am79c901_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
339 | { | ||
340 | return 0; | ||
341 | } | ||
342 | |||
343 | int am79c874_init(struct net_device *dev, int phy_addr) | ||
344 | { | ||
345 | s16 data; | ||
346 | |||
347 | /* 79c874 has quit resembled bit assignments to BCM5201 */ | ||
348 | if (au1000_debug > 4) | ||
349 | printk("am79c847_init\n"); | ||
350 | |||
351 | /* Stop auto-negotiation */ | ||
352 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
353 | mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO); | ||
354 | |||
355 | /* Set advertisement to 10/100 and Half/Full duplex | ||
356 | * (full capabilities) */ | ||
357 | data = mdio_read(dev, phy_addr, MII_ANADV); | ||
358 | data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T; | ||
359 | mdio_write(dev, phy_addr, MII_ANADV, data); | ||
360 | |||
361 | /* Restart auto-negotiation */ | ||
362 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
363 | data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO; | ||
364 | |||
365 | mdio_write(dev, phy_addr, MII_CONTROL, data); | ||
366 | |||
367 | if (au1000_debug > 4) dump_mii(dev, phy_addr); | ||
368 | return 0; | ||
369 | } | ||
370 | |||
371 | int am79c874_reset(struct net_device *dev, int phy_addr) | ||
372 | { | ||
373 | s16 mii_control, timeout; | ||
374 | |||
375 | if (au1000_debug > 4) | ||
376 | printk("am79c874_reset\n"); | ||
377 | |||
378 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
379 | mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET); | ||
380 | mdelay(1); | ||
381 | for (timeout = 100; timeout > 0; --timeout) { | ||
382 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
383 | if ((mii_control & MII_CNTL_RESET) == 0) | ||
384 | break; | ||
385 | mdelay(1); | ||
386 | } | ||
387 | if (mii_control & MII_CNTL_RESET) { | ||
388 | printk(KERN_ERR "%s PHY reset timeout !\n", dev->name); | ||
389 | return -1; | ||
390 | } | ||
391 | return 0; | ||
392 | } | ||
393 | |||
394 | int | ||
395 | am79c874_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
396 | { | ||
397 | u16 mii_data; | ||
398 | struct au1000_private *aup; | ||
399 | |||
400 | // printk("am79c874_status\n"); | ||
401 | if (!dev) { | ||
402 | printk(KERN_ERR "am79c874_status error: NULL dev\n"); | ||
403 | return -1; | ||
404 | } | ||
405 | |||
406 | aup = (struct au1000_private *) dev->priv; | ||
407 | mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS); | ||
408 | 158 | ||
409 | if (mii_data & MII_STAT_LINK) { | 159 | /* static PHY setup |
410 | *link = 1; | 160 | * |
411 | mii_data = mdio_read(dev, aup->phy_addr, MII_AMD_PHY_STAT); | 161 | * most boards PHY setup should be detectable properly with the |
412 | if (mii_data & MII_AMD_PHY_STAT_SPD) { | 162 | * autodetection algorithm in mii_probe(), but in some cases (e.g. if |
413 | if (mii_data & MII_AMD_PHY_STAT_FDX) { | 163 | * you have a switch attached, or want to use the PHY's interrupt |
414 | *speed = IF_PORT_100BASEFX; | 164 | * notification capabilities) you can provide a static PHY |
415 | dev->if_port = IF_PORT_100BASEFX; | 165 | * configuration here |
416 | } | 166 | * |
417 | else { | 167 | * IRQs may only be set, if a PHY address was configured |
418 | *speed = IF_PORT_100BASETX; | 168 | * If a PHY address is given, also a bus id is required to be set |
419 | dev->if_port = IF_PORT_100BASETX; | 169 | * |
420 | } | 170 | * ps: make sure the used irqs are configured properly in the board |
421 | } | 171 | * specific irq-map |
422 | else { | 172 | */ |
423 | *speed = IF_PORT_10BASET; | ||
424 | dev->if_port = IF_PORT_10BASET; | ||
425 | } | ||
426 | |||
427 | } | ||
428 | else { | ||
429 | *link = 0; | ||
430 | *speed = 0; | ||
431 | dev->if_port = IF_PORT_UNKNOWN; | ||
432 | } | ||
433 | return 0; | ||
434 | } | ||
435 | |||
436 | int lxt971a_init(struct net_device *dev, int phy_addr) | ||
437 | { | ||
438 | if (au1000_debug > 4) | ||
439 | printk("lxt971a_init\n"); | ||
440 | |||
441 | /* restart auto-negotiation */ | ||
442 | mdio_write(dev, phy_addr, MII_CONTROL, | ||
443 | MII_CNTL_F100 | MII_CNTL_AUTO | MII_CNTL_RST_AUTO | MII_CNTL_FDX); | ||
444 | |||
445 | /* set up LEDs to correct display */ | ||
446 | mdio_write(dev, phy_addr, 20, 0x0422); | ||
447 | |||
448 | if (au1000_debug > 4) | ||
449 | dump_mii(dev, phy_addr); | ||
450 | return 0; | ||
451 | } | ||
452 | |||
453 | int lxt971a_reset(struct net_device *dev, int phy_addr) | ||
454 | { | ||
455 | s16 mii_control, timeout; | ||
456 | |||
457 | if (au1000_debug > 4) { | ||
458 | printk("lxt971a_reset\n"); | ||
459 | dump_mii(dev, phy_addr); | ||
460 | } | ||
461 | |||
462 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
463 | mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET); | ||
464 | mdelay(1); | ||
465 | for (timeout = 100; timeout > 0; --timeout) { | ||
466 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
467 | if ((mii_control & MII_CNTL_RESET) == 0) | ||
468 | break; | ||
469 | mdelay(1); | ||
470 | } | ||
471 | if (mii_control & MII_CNTL_RESET) { | ||
472 | printk(KERN_ERR "%s PHY reset timeout !\n", dev->name); | ||
473 | return -1; | ||
474 | } | ||
475 | return 0; | ||
476 | } | ||
477 | |||
478 | int | ||
479 | lxt971a_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
480 | { | ||
481 | u16 mii_data; | ||
482 | struct au1000_private *aup; | ||
483 | |||
484 | if (!dev) { | ||
485 | printk(KERN_ERR "lxt971a_status error: NULL dev\n"); | ||
486 | return -1; | ||
487 | } | ||
488 | aup = (struct au1000_private *) dev->priv; | ||
489 | |||
490 | mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS); | ||
491 | if (mii_data & MII_STAT_LINK) { | ||
492 | *link = 1; | ||
493 | mii_data = mdio_read(dev, aup->phy_addr, MII_INTEL_PHY_STAT); | ||
494 | if (mii_data & MII_INTEL_PHY_STAT_SPD) { | ||
495 | if (mii_data & MII_INTEL_PHY_STAT_FDX) { | ||
496 | *speed = IF_PORT_100BASEFX; | ||
497 | dev->if_port = IF_PORT_100BASEFX; | ||
498 | } | ||
499 | else { | ||
500 | *speed = IF_PORT_100BASETX; | ||
501 | dev->if_port = IF_PORT_100BASETX; | ||
502 | } | ||
503 | } | ||
504 | else { | ||
505 | *speed = IF_PORT_10BASET; | ||
506 | dev->if_port = IF_PORT_10BASET; | ||
507 | } | ||
508 | |||
509 | } | ||
510 | else { | ||
511 | *link = 0; | ||
512 | *speed = 0; | ||
513 | dev->if_port = IF_PORT_UNKNOWN; | ||
514 | } | ||
515 | return 0; | ||
516 | } | ||
517 | |||
518 | int ks8995m_init(struct net_device *dev, int phy_addr) | ||
519 | { | ||
520 | s16 data; | ||
521 | |||
522 | // printk("ks8995m_init\n"); | ||
523 | /* Stop auto-negotiation */ | ||
524 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
525 | mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO); | ||
526 | |||
527 | /* Set advertisement to 10/100 and Half/Full duplex | ||
528 | * (full capabilities) */ | ||
529 | data = mdio_read(dev, phy_addr, MII_ANADV); | ||
530 | data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T; | ||
531 | mdio_write(dev, phy_addr, MII_ANADV, data); | ||
532 | |||
533 | /* Restart auto-negotiation */ | ||
534 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
535 | data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO; | ||
536 | mdio_write(dev, phy_addr, MII_CONTROL, data); | ||
537 | |||
538 | if (au1000_debug > 4) dump_mii(dev, phy_addr); | ||
539 | |||
540 | return 0; | ||
541 | } | ||
542 | |||
543 | int ks8995m_reset(struct net_device *dev, int phy_addr) | ||
544 | { | ||
545 | s16 mii_control, timeout; | ||
546 | |||
547 | // printk("ks8995m_reset\n"); | ||
548 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
549 | mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET); | ||
550 | mdelay(1); | ||
551 | for (timeout = 100; timeout > 0; --timeout) { | ||
552 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
553 | if ((mii_control & MII_CNTL_RESET) == 0) | ||
554 | break; | ||
555 | mdelay(1); | ||
556 | } | ||
557 | if (mii_control & MII_CNTL_RESET) { | ||
558 | printk(KERN_ERR "%s PHY reset timeout !\n", dev->name); | ||
559 | return -1; | ||
560 | } | ||
561 | return 0; | ||
562 | } | ||
563 | |||
564 | int ks8995m_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
565 | { | ||
566 | u16 mii_data; | ||
567 | struct au1000_private *aup; | ||
568 | |||
569 | if (!dev) { | ||
570 | printk(KERN_ERR "ks8995m_status error: NULL dev\n"); | ||
571 | return -1; | ||
572 | } | ||
573 | aup = (struct au1000_private *) dev->priv; | ||
574 | |||
575 | mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS); | ||
576 | if (mii_data & MII_STAT_LINK) { | ||
577 | *link = 1; | ||
578 | mii_data = mdio_read(dev, aup->phy_addr, MII_AUX_CNTRL); | ||
579 | if (mii_data & MII_AUX_100) { | ||
580 | if (mii_data & MII_AUX_FDX) { | ||
581 | *speed = IF_PORT_100BASEFX; | ||
582 | dev->if_port = IF_PORT_100BASEFX; | ||
583 | } | ||
584 | else { | ||
585 | *speed = IF_PORT_100BASETX; | ||
586 | dev->if_port = IF_PORT_100BASETX; | ||
587 | } | ||
588 | } | ||
589 | else { | ||
590 | *speed = IF_PORT_10BASET; | ||
591 | dev->if_port = IF_PORT_10BASET; | ||
592 | } | ||
593 | |||
594 | } | ||
595 | else { | ||
596 | *link = 0; | ||
597 | *speed = 0; | ||
598 | dev->if_port = IF_PORT_UNKNOWN; | ||
599 | } | ||
600 | return 0; | ||
601 | } | ||
602 | |||
603 | int | ||
604 | smsc_83C185_init (struct net_device *dev, int phy_addr) | ||
605 | { | ||
606 | s16 data; | ||
607 | |||
608 | if (au1000_debug > 4) | ||
609 | printk("smsc_83C185_init\n"); | ||
610 | |||
611 | /* Stop auto-negotiation */ | ||
612 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
613 | mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO); | ||
614 | |||
615 | /* Set advertisement to 10/100 and Half/Full duplex | ||
616 | * (full capabilities) */ | ||
617 | data = mdio_read(dev, phy_addr, MII_ANADV); | ||
618 | data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T; | ||
619 | mdio_write(dev, phy_addr, MII_ANADV, data); | ||
620 | |||
621 | /* Restart auto-negotiation */ | ||
622 | data = mdio_read(dev, phy_addr, MII_CONTROL); | ||
623 | data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO; | ||
624 | |||
625 | mdio_write(dev, phy_addr, MII_CONTROL, data); | ||
626 | |||
627 | if (au1000_debug > 4) dump_mii(dev, phy_addr); | ||
628 | return 0; | ||
629 | } | ||
630 | |||
631 | int | ||
632 | smsc_83C185_reset (struct net_device *dev, int phy_addr) | ||
633 | { | ||
634 | s16 mii_control, timeout; | ||
635 | |||
636 | if (au1000_debug > 4) | ||
637 | printk("smsc_83C185_reset\n"); | ||
638 | |||
639 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
640 | mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET); | ||
641 | mdelay(1); | ||
642 | for (timeout = 100; timeout > 0; --timeout) { | ||
643 | mii_control = mdio_read(dev, phy_addr, MII_CONTROL); | ||
644 | if ((mii_control & MII_CNTL_RESET) == 0) | ||
645 | break; | ||
646 | mdelay(1); | ||
647 | } | ||
648 | if (mii_control & MII_CNTL_RESET) { | ||
649 | printk(KERN_ERR "%s PHY reset timeout !\n", dev->name); | ||
650 | return -1; | ||
651 | } | ||
652 | return 0; | ||
653 | } | ||
654 | |||
655 | int | ||
656 | smsc_83C185_status (struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
657 | { | ||
658 | u16 mii_data; | ||
659 | struct au1000_private *aup; | ||
660 | |||
661 | if (!dev) { | ||
662 | printk(KERN_ERR "smsc_83C185_status error: NULL dev\n"); | ||
663 | return -1; | ||
664 | } | ||
665 | |||
666 | aup = (struct au1000_private *) dev->priv; | ||
667 | mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS); | ||
668 | |||
669 | if (mii_data & MII_STAT_LINK) { | ||
670 | *link = 1; | ||
671 | mii_data = mdio_read(dev, aup->phy_addr, 0x1f); | ||
672 | if (mii_data & (1<<3)) { | ||
673 | if (mii_data & (1<<4)) { | ||
674 | *speed = IF_PORT_100BASEFX; | ||
675 | dev->if_port = IF_PORT_100BASEFX; | ||
676 | } | ||
677 | else { | ||
678 | *speed = IF_PORT_100BASETX; | ||
679 | dev->if_port = IF_PORT_100BASETX; | ||
680 | } | ||
681 | } | ||
682 | else { | ||
683 | *speed = IF_PORT_10BASET; | ||
684 | dev->if_port = IF_PORT_10BASET; | ||
685 | } | ||
686 | } | ||
687 | else { | ||
688 | *link = 0; | ||
689 | *speed = 0; | ||
690 | dev->if_port = IF_PORT_UNKNOWN; | ||
691 | } | ||
692 | return 0; | ||
693 | } | ||
694 | |||
695 | |||
696 | #ifdef CONFIG_MIPS_BOSPORUS | ||
697 | int stub_init(struct net_device *dev, int phy_addr) | ||
698 | { | ||
699 | //printk("PHY stub_init\n"); | ||
700 | return 0; | ||
701 | } | ||
702 | |||
703 | int stub_reset(struct net_device *dev, int phy_addr) | ||
704 | { | ||
705 | //printk("PHY stub_reset\n"); | ||
706 | return 0; | ||
707 | } | ||
708 | |||
709 | int | ||
710 | stub_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed) | ||
711 | { | ||
712 | //printk("PHY stub_status\n"); | ||
713 | *link = 1; | ||
714 | /* hmmm, revisit */ | ||
715 | *speed = IF_PORT_100BASEFX; | ||
716 | dev->if_port = IF_PORT_100BASEFX; | ||
717 | return 0; | ||
718 | } | ||
719 | #endif | ||
720 | |||
721 | struct phy_ops bcm_5201_ops = { | ||
722 | bcm_5201_init, | ||
723 | bcm_5201_reset, | ||
724 | bcm_5201_status, | ||
725 | }; | ||
726 | |||
727 | struct phy_ops am79c874_ops = { | ||
728 | am79c874_init, | ||
729 | am79c874_reset, | ||
730 | am79c874_status, | ||
731 | }; | ||
732 | |||
733 | struct phy_ops am79c901_ops = { | ||
734 | am79c901_init, | ||
735 | am79c901_reset, | ||
736 | am79c901_status, | ||
737 | }; | ||
738 | |||
739 | struct phy_ops lsi_80227_ops = { | ||
740 | lsi_80227_init, | ||
741 | lsi_80227_reset, | ||
742 | lsi_80227_status, | ||
743 | }; | ||
744 | |||
745 | struct phy_ops lxt971a_ops = { | ||
746 | lxt971a_init, | ||
747 | lxt971a_reset, | ||
748 | lxt971a_status, | ||
749 | }; | ||
750 | 173 | ||
751 | struct phy_ops ks8995m_ops = { | 174 | #if defined(CONFIG_MIPS_BOSPORUS) |
752 | ks8995m_init, | 175 | /* |
753 | ks8995m_reset, | 176 | * Micrel/Kendin 5 port switch attached to MAC0, |
754 | ks8995m_status, | 177 | * MAC0 is associated with PHY address 5 (== WAN port) |
755 | }; | 178 | * MAC1 is not associated with any PHY, since it's connected directly |
179 | * to the switch. | ||
180 | * no interrupts are used | ||
181 | */ | ||
182 | # define AU1XXX_PHY_STATIC_CONFIG | ||
756 | 183 | ||
757 | struct phy_ops smsc_83C185_ops = { | 184 | # define AU1XXX_PHY0_ADDR 5 |
758 | smsc_83C185_init, | 185 | # define AU1XXX_PHY0_BUSID 0 |
759 | smsc_83C185_reset, | 186 | # undef AU1XXX_PHY0_IRQ |
760 | smsc_83C185_status, | ||
761 | }; | ||
762 | 187 | ||
763 | #ifdef CONFIG_MIPS_BOSPORUS | 188 | # undef AU1XXX_PHY1_ADDR |
764 | struct phy_ops stub_ops = { | 189 | # undef AU1XXX_PHY1_BUSID |
765 | stub_init, | 190 | # undef AU1XXX_PHY1_IRQ |
766 | stub_reset, | ||
767 | stub_status, | ||
768 | }; | ||
769 | #endif | 191 | #endif |
770 | 192 | ||
771 | static struct mii_chip_info { | 193 | #if defined(AU1XXX_PHY0_BUSID) && (AU1XXX_PHY0_BUSID > 0) |
772 | const char * name; | 194 | # error MAC0-associated PHY attached 2nd MACs MII bus not supported yet |
773 | u16 phy_id0; | ||
774 | u16 phy_id1; | ||
775 | struct phy_ops *phy_ops; | ||
776 | int dual_phy; | ||
777 | } mii_chip_table[] = { | ||
778 | {"Broadcom BCM5201 10/100 BaseT PHY",0x0040,0x6212, &bcm_5201_ops,0}, | ||
779 | {"Broadcom BCM5221 10/100 BaseT PHY",0x0040,0x61e4, &bcm_5201_ops,0}, | ||
780 | {"Broadcom BCM5222 10/100 BaseT PHY",0x0040,0x6322, &bcm_5201_ops,1}, | ||
781 | {"NS DP83847 PHY", 0x2000, 0x5c30, &bcm_5201_ops ,0}, | ||
782 | {"AMD 79C901 HomePNA PHY",0x0000,0x35c8, &am79c901_ops,0}, | ||
783 | {"AMD 79C874 10/100 BaseT PHY",0x0022,0x561b, &am79c874_ops,0}, | ||
784 | {"LSI 80227 10/100 BaseT PHY",0x0016,0xf840, &lsi_80227_ops,0}, | ||
785 | {"Intel LXT971A Dual Speed PHY",0x0013,0x78e2, &lxt971a_ops,0}, | ||
786 | {"Kendin KS8995M 10/100 BaseT PHY",0x0022,0x1450, &ks8995m_ops,0}, | ||
787 | {"SMSC LAN83C185 10/100 BaseT PHY",0x0007,0xc0a3, &smsc_83C185_ops,0}, | ||
788 | #ifdef CONFIG_MIPS_BOSPORUS | ||
789 | {"Stub", 0x1234, 0x5678, &stub_ops }, | ||
790 | #endif | 195 | #endif |
791 | {0,}, | ||
792 | }; | ||
793 | 196 | ||
794 | static int mdio_read(struct net_device *dev, int phy_id, int reg) | 197 | /* |
198 | * MII operations | ||
199 | */ | ||
200 | static int mdio_read(struct net_device *dev, int phy_addr, int reg) | ||
795 | { | 201 | { |
796 | struct au1000_private *aup = (struct au1000_private *) dev->priv; | 202 | struct au1000_private *aup = (struct au1000_private *) dev->priv; |
797 | volatile u32 *mii_control_reg; | 203 | volatile u32 *const mii_control_reg = &aup->mac->mii_control; |
798 | volatile u32 *mii_data_reg; | 204 | volatile u32 *const mii_data_reg = &aup->mac->mii_data; |
799 | u32 timedout = 20; | 205 | u32 timedout = 20; |
800 | u32 mii_control; | 206 | u32 mii_control; |
801 | 207 | ||
802 | #ifdef CONFIG_BCM5222_DUAL_PHY | ||
803 | /* First time we probe, it's for the mac0 phy. | ||
804 | * Since we haven't determined yet that we have a dual phy, | ||
805 | * aup->mii->mii_control_reg won't be setup and we'll | ||
806 | * default to the else statement. | ||
807 | * By the time we probe for the mac1 phy, the mii_control_reg | ||
808 | * will be setup to be the address of the mac0 phy control since | ||
809 | * both phys are controlled through mac0. | ||
810 | */ | ||
811 | if (aup->mii && aup->mii->mii_control_reg) { | ||
812 | mii_control_reg = aup->mii->mii_control_reg; | ||
813 | mii_data_reg = aup->mii->mii_data_reg; | ||
814 | } | ||
815 | else if (au_macs[0]->mii && au_macs[0]->mii->mii_control_reg) { | ||
816 | /* assume both phys are controlled through mac0 */ | ||
817 | mii_control_reg = au_macs[0]->mii->mii_control_reg; | ||
818 | mii_data_reg = au_macs[0]->mii->mii_data_reg; | ||
819 | } | ||
820 | else | ||
821 | #endif | ||
822 | { | ||
823 | /* default control and data reg addresses */ | ||
824 | mii_control_reg = &aup->mac->mii_control; | ||
825 | mii_data_reg = &aup->mac->mii_data; | ||
826 | } | ||
827 | |||
828 | while (*mii_control_reg & MAC_MII_BUSY) { | 208 | while (*mii_control_reg & MAC_MII_BUSY) { |
829 | mdelay(1); | 209 | mdelay(1); |
830 | if (--timedout == 0) { | 210 | if (--timedout == 0) { |
@@ -835,7 +215,7 @@ static int mdio_read(struct net_device *dev, int phy_id, int reg) | |||
835 | } | 215 | } |
836 | 216 | ||
837 | mii_control = MAC_SET_MII_SELECT_REG(reg) | | 217 | mii_control = MAC_SET_MII_SELECT_REG(reg) | |
838 | MAC_SET_MII_SELECT_PHY(phy_id) | MAC_MII_READ; | 218 | MAC_SET_MII_SELECT_PHY(phy_addr) | MAC_MII_READ; |
839 | 219 | ||
840 | *mii_control_reg = mii_control; | 220 | *mii_control_reg = mii_control; |
841 | 221 | ||
@@ -851,32 +231,14 @@ static int mdio_read(struct net_device *dev, int phy_id, int reg) | |||
851 | return (int)*mii_data_reg; | 231 | return (int)*mii_data_reg; |
852 | } | 232 | } |
853 | 233 | ||
854 | static void mdio_write(struct net_device *dev, int phy_id, int reg, u16 value) | 234 | static void mdio_write(struct net_device *dev, int phy_addr, int reg, u16 value) |
855 | { | 235 | { |
856 | struct au1000_private *aup = (struct au1000_private *) dev->priv; | 236 | struct au1000_private *aup = (struct au1000_private *) dev->priv; |
857 | volatile u32 *mii_control_reg; | 237 | volatile u32 *const mii_control_reg = &aup->mac->mii_control; |
858 | volatile u32 *mii_data_reg; | 238 | volatile u32 *const mii_data_reg = &aup->mac->mii_data; |
859 | u32 timedout = 20; | 239 | u32 timedout = 20; |
860 | u32 mii_control; | 240 | u32 mii_control; |
861 | 241 | ||
862 | #ifdef CONFIG_BCM5222_DUAL_PHY | ||
863 | if (aup->mii && aup->mii->mii_control_reg) { | ||
864 | mii_control_reg = aup->mii->mii_control_reg; | ||
865 | mii_data_reg = aup->mii->mii_data_reg; | ||
866 | } | ||
867 | else if (au_macs[0]->mii && au_macs[0]->mii->mii_control_reg) { | ||
868 | /* assume both phys are controlled through mac0 */ | ||
869 | mii_control_reg = au_macs[0]->mii->mii_control_reg; | ||
870 | mii_data_reg = au_macs[0]->mii->mii_data_reg; | ||
871 | } | ||
872 | else | ||
873 | #endif | ||
874 | { | ||
875 | /* default control and data reg addresses */ | ||
876 | mii_control_reg = &aup->mac->mii_control; | ||
877 | mii_data_reg = &aup->mac->mii_data; | ||
878 | } | ||
879 | |||
880 | while (*mii_control_reg & MAC_MII_BUSY) { | 242 | while (*mii_control_reg & MAC_MII_BUSY) { |
881 | mdelay(1); | 243 | mdelay(1); |
882 | if (--timedout == 0) { | 244 | if (--timedout == 0) { |
@@ -887,165 +249,145 @@ static void mdio_write(struct net_device *dev, int phy_id, int reg, u16 value) | |||
887 | } | 249 | } |
888 | 250 | ||
889 | mii_control = MAC_SET_MII_SELECT_REG(reg) | | 251 | mii_control = MAC_SET_MII_SELECT_REG(reg) | |
890 | MAC_SET_MII_SELECT_PHY(phy_id) | MAC_MII_WRITE; | 252 | MAC_SET_MII_SELECT_PHY(phy_addr) | MAC_MII_WRITE; |
891 | 253 | ||
892 | *mii_data_reg = value; | 254 | *mii_data_reg = value; |
893 | *mii_control_reg = mii_control; | 255 | *mii_control_reg = mii_control; |
894 | } | 256 | } |
895 | 257 | ||
258 | static int mdiobus_read(struct mii_bus *bus, int phy_addr, int regnum) | ||
259 | { | ||
260 | /* WARNING: bus->phy_map[phy_addr].attached_dev == dev does | ||
261 | * _NOT_ hold (e.g. when PHY is accessed through other MAC's MII bus) */ | ||
262 | struct net_device *const dev = bus->priv; | ||
263 | |||
264 | enable_mac(dev, 0); /* make sure the MAC associated with this | ||
265 | * mii_bus is enabled */ | ||
266 | return mdio_read(dev, phy_addr, regnum); | ||
267 | } | ||
896 | 268 | ||
897 | static void dump_mii(struct net_device *dev, int phy_id) | 269 | static int mdiobus_write(struct mii_bus *bus, int phy_addr, int regnum, |
270 | u16 value) | ||
898 | { | 271 | { |
899 | int i, val; | 272 | struct net_device *const dev = bus->priv; |
900 | 273 | ||
901 | for (i = 0; i < 7; i++) { | 274 | enable_mac(dev, 0); /* make sure the MAC associated with this |
902 | if ((val = mdio_read(dev, phy_id, i)) >= 0) | 275 | * mii_bus is enabled */ |
903 | printk("%s: MII Reg %d=%x\n", dev->name, i, val); | 276 | mdio_write(dev, phy_addr, regnum, value); |
904 | } | 277 | return 0; |
905 | for (i = 16; i < 25; i++) { | ||
906 | if ((val = mdio_read(dev, phy_id, i)) >= 0) | ||
907 | printk("%s: MII Reg %d=%x\n", dev->name, i, val); | ||
908 | } | ||
909 | } | 278 | } |
910 | 279 | ||
911 | static int mii_probe (struct net_device * dev) | 280 | static int mdiobus_reset(struct mii_bus *bus) |
912 | { | 281 | { |
913 | struct au1000_private *aup = (struct au1000_private *) dev->priv; | 282 | struct net_device *const dev = bus->priv; |
914 | int phy_addr; | ||
915 | #ifdef CONFIG_MIPS_BOSPORUS | ||
916 | int phy_found=0; | ||
917 | #endif | ||
918 | 283 | ||
919 | /* search for total of 32 possible mii phy addresses */ | 284 | enable_mac(dev, 0); /* make sure the MAC associated with this |
920 | for (phy_addr = 0; phy_addr < 32; phy_addr++) { | 285 | * mii_bus is enabled */ |
921 | u16 mii_status; | 286 | return 0; |
922 | u16 phy_id0, phy_id1; | 287 | } |
923 | int i; | ||
924 | 288 | ||
925 | #ifdef CONFIG_BCM5222_DUAL_PHY | 289 | static int mii_probe (struct net_device *dev) |
926 | /* Mask the already found phy, try next one */ | 290 | { |
927 | if (au_macs[0]->mii && au_macs[0]->mii->mii_control_reg) { | 291 | struct au1000_private *const aup = (struct au1000_private *) dev->priv; |
928 | if (au_macs[0]->phy_addr == phy_addr) | 292 | struct phy_device *phydev = NULL; |
929 | continue; | 293 | |
930 | } | 294 | #if defined(AU1XXX_PHY_STATIC_CONFIG) |
931 | #endif | 295 | BUG_ON(aup->mac_id < 0 || aup->mac_id > 1); |
932 | 296 | ||
933 | mii_status = mdio_read(dev, phy_addr, MII_STATUS); | 297 | if(aup->mac_id == 0) { /* get PHY0 */ |
934 | if (mii_status == 0xffff || mii_status == 0x0000) | 298 | # if defined(AU1XXX_PHY0_ADDR) |
935 | /* the mii is not accessable, try next one */ | 299 | phydev = au_macs[AU1XXX_PHY0_BUSID]->mii_bus.phy_map[AU1XXX_PHY0_ADDR]; |
936 | continue; | 300 | # else |
937 | 301 | printk (KERN_INFO DRV_NAME ":%s: using PHY-less setup\n", | |
938 | phy_id0 = mdio_read(dev, phy_addr, MII_PHY_ID0); | 302 | dev->name); |
939 | phy_id1 = mdio_read(dev, phy_addr, MII_PHY_ID1); | 303 | return 0; |
940 | 304 | # endif /* defined(AU1XXX_PHY0_ADDR) */ | |
941 | /* search our mii table for the current mii */ | 305 | } else if (aup->mac_id == 1) { /* get PHY1 */ |
942 | for (i = 0; mii_chip_table[i].phy_id1; i++) { | 306 | # if defined(AU1XXX_PHY1_ADDR) |
943 | if (phy_id0 == mii_chip_table[i].phy_id0 && | 307 | phydev = au_macs[AU1XXX_PHY1_BUSID]->mii_bus.phy_map[AU1XXX_PHY1_ADDR]; |
944 | phy_id1 == mii_chip_table[i].phy_id1) { | 308 | # else |
945 | struct mii_phy * mii_phy = aup->mii; | 309 | printk (KERN_INFO DRV_NAME ":%s: using PHY-less setup\n", |
946 | 310 | dev->name); | |
947 | printk(KERN_INFO "%s: %s at phy address %d\n", | 311 | return 0; |
948 | dev->name, mii_chip_table[i].name, | 312 | # endif /* defined(AU1XXX_PHY1_ADDR) */ |
949 | phy_addr); | 313 | } |
950 | #ifdef CONFIG_MIPS_BOSPORUS | 314 | |
951 | phy_found = 1; | 315 | #else /* defined(AU1XXX_PHY_STATIC_CONFIG) */ |
952 | #endif | 316 | int phy_addr; |
953 | mii_phy->chip_info = mii_chip_table+i; | 317 | |
954 | aup->phy_addr = phy_addr; | 318 | /* find the first (lowest address) PHY on the current MAC's MII bus */ |
955 | aup->want_autoneg = 1; | 319 | for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++) |
956 | aup->phy_ops = mii_chip_table[i].phy_ops; | 320 | if (aup->mii_bus.phy_map[phy_addr]) { |
957 | aup->phy_ops->phy_init(dev,phy_addr); | 321 | phydev = aup->mii_bus.phy_map[phy_addr]; |
958 | 322 | # if !defined(AU1XXX_PHY_SEARCH_HIGHEST_ADDR) | |
959 | // Check for dual-phy and then store required | 323 | break; /* break out with first one found */ |
960 | // values and set indicators. We need to do | 324 | # endif |
961 | // this now since mdio_{read,write} need the | ||
962 | // control and data register addresses. | ||
963 | #ifdef CONFIG_BCM5222_DUAL_PHY | ||
964 | if ( mii_chip_table[i].dual_phy) { | ||
965 | |||
966 | /* assume both phys are controlled | ||
967 | * through MAC0. Board specific? */ | ||
968 | |||
969 | /* sanity check */ | ||
970 | if (!au_macs[0] || !au_macs[0]->mii) | ||
971 | return -1; | ||
972 | aup->mii->mii_control_reg = (u32 *) | ||
973 | &au_macs[0]->mac->mii_control; | ||
974 | aup->mii->mii_data_reg = (u32 *) | ||
975 | &au_macs[0]->mac->mii_data; | ||
976 | } | ||
977 | #endif | ||
978 | goto found; | ||
979 | } | ||
980 | } | 325 | } |
981 | } | ||
982 | found: | ||
983 | |||
984 | #ifdef CONFIG_MIPS_BOSPORUS | ||
985 | /* This is a workaround for the Micrel/Kendin 5 port switch | ||
986 | The second MAC doesn't see a PHY connected... so we need to | ||
987 | trick it into thinking we have one. | ||
988 | |||
989 | If this kernel is run on another Au1500 development board | ||
990 | the stub will be found as well as the actual PHY. However, | ||
991 | the last found PHY will be used... usually at Addr 31 (Db1500). | ||
992 | */ | ||
993 | if ( (!phy_found) ) | ||
994 | { | ||
995 | u16 phy_id0, phy_id1; | ||
996 | int i; | ||
997 | 326 | ||
998 | phy_id0 = 0x1234; | 327 | # if defined(AU1XXX_PHY1_SEARCH_ON_MAC0) |
999 | phy_id1 = 0x5678; | 328 | /* try harder to find a PHY */ |
1000 | 329 | if (!phydev && (aup->mac_id == 1)) { | |
1001 | /* search our mii table for the current mii */ | 330 | /* no PHY found, maybe we have a dual PHY? */ |
1002 | for (i = 0; mii_chip_table[i].phy_id1; i++) { | 331 | printk (KERN_INFO DRV_NAME ": no PHY found on MAC1, " |
1003 | if (phy_id0 == mii_chip_table[i].phy_id0 && | 332 | "let's see if it's attached to MAC0...\n"); |
1004 | phy_id1 == mii_chip_table[i].phy_id1) { | 333 | |
1005 | struct mii_phy * mii_phy; | 334 | BUG_ON(!au_macs[0]); |
1006 | 335 | ||
1007 | printk(KERN_INFO "%s: %s at phy address %d\n", | 336 | /* find the first (lowest address) non-attached PHY on |
1008 | dev->name, mii_chip_table[i].name, | 337 | * the MAC0 MII bus */ |
1009 | phy_addr); | 338 | for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++) { |
1010 | mii_phy = kmalloc(sizeof(struct mii_phy), | 339 | struct phy_device *const tmp_phydev = |
1011 | GFP_KERNEL); | 340 | au_macs[0]->mii_bus.phy_map[phy_addr]; |
1012 | if (mii_phy) { | 341 | |
1013 | mii_phy->chip_info = mii_chip_table+i; | 342 | if (!tmp_phydev) |
1014 | aup->phy_addr = phy_addr; | 343 | continue; /* no PHY here... */ |
1015 | mii_phy->next = aup->mii; | 344 | |
1016 | aup->phy_ops = | 345 | if (tmp_phydev->attached_dev) |
1017 | mii_chip_table[i].phy_ops; | 346 | continue; /* already claimed by MAC0 */ |
1018 | aup->mii = mii_phy; | 347 | |
1019 | aup->phy_ops->phy_init(dev,phy_addr); | 348 | phydev = tmp_phydev; |
1020 | } else { | 349 | break; /* found it */ |
1021 | printk(KERN_ERR "%s: out of memory\n", | ||
1022 | dev->name); | ||
1023 | return -1; | ||
1024 | } | ||
1025 | mii_phy->chip_info = mii_chip_table+i; | ||
1026 | aup->phy_addr = phy_addr; | ||
1027 | aup->phy_ops = mii_chip_table[i].phy_ops; | ||
1028 | aup->phy_ops->phy_init(dev,phy_addr); | ||
1029 | break; | ||
1030 | } | ||
1031 | } | 350 | } |
1032 | } | 351 | } |
1033 | if (aup->mac_id == 0) { | 352 | # endif /* defined(AU1XXX_PHY1_SEARCH_OTHER_BUS) */ |
1034 | /* the Bosporus phy responds to addresses 0-5 but | ||
1035 | * 5 is the correct one. | ||
1036 | */ | ||
1037 | aup->phy_addr = 5; | ||
1038 | } | ||
1039 | #endif | ||
1040 | 353 | ||
1041 | if (aup->mii->chip_info == NULL) { | 354 | #endif /* defined(AU1XXX_PHY_STATIC_CONFIG) */ |
1042 | printk(KERN_ERR "%s: Au1x No known MII transceivers found!\n", | 355 | if (!phydev) { |
1043 | dev->name); | 356 | printk (KERN_ERR DRV_NAME ":%s: no PHY found\n", dev->name); |
1044 | return -1; | 357 | return -1; |
1045 | } | 358 | } |
1046 | 359 | ||
1047 | printk(KERN_INFO "%s: Using %s as default\n", | 360 | /* now we are supposed to have a proper phydev, to attach to... */ |
1048 | dev->name, aup->mii->chip_info->name); | 361 | BUG_ON(!phydev); |
362 | BUG_ON(phydev->attached_dev); | ||
363 | |||
364 | phydev = phy_connect(dev, phydev->dev.bus_id, &au1000_adjust_link, 0); | ||
365 | |||
366 | if (IS_ERR(phydev)) { | ||
367 | printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name); | ||
368 | return PTR_ERR(phydev); | ||
369 | } | ||
370 | |||
371 | /* mask with MAC supported features */ | ||
372 | phydev->supported &= (SUPPORTED_10baseT_Half | ||
373 | | SUPPORTED_10baseT_Full | ||
374 | | SUPPORTED_100baseT_Half | ||
375 | | SUPPORTED_100baseT_Full | ||
376 | | SUPPORTED_Autoneg | ||
377 | /* | SUPPORTED_Pause | SUPPORTED_Asym_Pause */ | ||
378 | | SUPPORTED_MII | ||
379 | | SUPPORTED_TP); | ||
380 | |||
381 | phydev->advertising = phydev->supported; | ||
382 | |||
383 | aup->old_link = 0; | ||
384 | aup->old_speed = 0; | ||
385 | aup->old_duplex = -1; | ||
386 | aup->phy_dev = phydev; | ||
387 | |||
388 | printk(KERN_INFO "%s: attached PHY driver [%s] " | ||
389 | "(mii_bus:phy_addr=%s, irq=%d)\n", | ||
390 | dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq); | ||
1049 | 391 | ||
1050 | return 0; | 392 | return 0; |
1051 | } | 393 | } |
@@ -1097,35 +439,38 @@ static void hard_stop(struct net_device *dev) | |||
1097 | au_sync_delay(10); | 439 | au_sync_delay(10); |
1098 | } | 440 | } |
1099 | 441 | ||
1100 | 442 | static void enable_mac(struct net_device *dev, int force_reset) | |
1101 | static void reset_mac(struct net_device *dev) | ||
1102 | { | 443 | { |
1103 | int i; | 444 | unsigned long flags; |
1104 | u32 flags; | ||
1105 | struct au1000_private *aup = (struct au1000_private *) dev->priv; | 445 | struct au1000_private *aup = (struct au1000_private *) dev->priv; |
1106 | 446 | ||
1107 | if (au1000_debug > 4) | ||
1108 | printk(KERN_INFO "%s: reset mac, aup %x\n", | ||
1109 | dev->name, (unsigned)aup); | ||
1110 | |||
1111 | spin_lock_irqsave(&aup->lock, flags); | 447 | spin_lock_irqsave(&aup->lock, flags); |
1112 | if (aup->timer.function == &au1000_timer) {/* check if timer initted */ | ||
1113 | del_timer(&aup->timer); | ||
1114 | } | ||
1115 | 448 | ||
1116 | hard_stop(dev); | 449 | if(force_reset || (!aup->mac_enabled)) { |
1117 | #ifdef CONFIG_BCM5222_DUAL_PHY | ||
1118 | if (aup->mac_id != 0) { | ||
1119 | #endif | ||
1120 | /* If BCM5222, we can't leave MAC0 in reset because then | ||
1121 | * we can't access the dual phy for ETH1 */ | ||
1122 | *aup->enable = MAC_EN_CLOCK_ENABLE; | 450 | *aup->enable = MAC_EN_CLOCK_ENABLE; |
1123 | au_sync_delay(2); | 451 | au_sync_delay(2); |
1124 | *aup->enable = 0; | 452 | *aup->enable = (MAC_EN_RESET0 | MAC_EN_RESET1 | MAC_EN_RESET2 |
453 | | MAC_EN_CLOCK_ENABLE); | ||
1125 | au_sync_delay(2); | 454 | au_sync_delay(2); |
1126 | #ifdef CONFIG_BCM5222_DUAL_PHY | 455 | |
456 | aup->mac_enabled = 1; | ||
1127 | } | 457 | } |
1128 | #endif | 458 | |
459 | spin_unlock_irqrestore(&aup->lock, flags); | ||
460 | } | ||
461 | |||
462 | static void reset_mac_unlocked(struct net_device *dev) | ||
463 | { | ||
464 | struct au1000_private *const aup = (struct au1000_private *) dev->priv; | ||
465 | int i; | ||
466 | |||
467 | hard_stop(dev); | ||
468 | |||
469 | *aup->enable = MAC_EN_CLOCK_ENABLE; | ||
470 | au_sync_delay(2); | ||
471 | *aup->enable = 0; | ||
472 | au_sync_delay(2); | ||
473 | |||
1129 | aup->tx_full = 0; | 474 | aup->tx_full = 0; |
1130 | for (i = 0; i < NUM_RX_DMA; i++) { | 475 | for (i = 0; i < NUM_RX_DMA; i++) { |
1131 | /* reset control bits */ | 476 | /* reset control bits */ |
@@ -1135,9 +480,26 @@ static void reset_mac(struct net_device *dev) | |||
1135 | /* reset control bits */ | 480 | /* reset control bits */ |
1136 | aup->tx_dma_ring[i]->buff_stat &= ~0xf; | 481 | aup->tx_dma_ring[i]->buff_stat &= ~0xf; |
1137 | } | 482 | } |
1138 | spin_unlock_irqrestore(&aup->lock, flags); | 483 | |
484 | aup->mac_enabled = 0; | ||
485 | |||
1139 | } | 486 | } |
1140 | 487 | ||
488 | static void reset_mac(struct net_device *dev) | ||
489 | { | ||
490 | struct au1000_private *const aup = (struct au1000_private *) dev->priv; | ||
491 | unsigned long flags; | ||
492 | |||
493 | if (au1000_debug > 4) | ||
494 | printk(KERN_INFO "%s: reset mac, aup %x\n", | ||
495 | dev->name, (unsigned)aup); | ||
496 | |||
497 | spin_lock_irqsave(&aup->lock, flags); | ||
498 | |||
499 | reset_mac_unlocked (dev); | ||
500 | |||
501 | spin_unlock_irqrestore(&aup->lock, flags); | ||
502 | } | ||
1141 | 503 | ||
1142 | /* | 504 | /* |
1143 | * Setup the receive and transmit "rings". These pointers are the addresses | 505 | * Setup the receive and transmit "rings". These pointers are the addresses |
@@ -1208,178 +570,31 @@ static int __init au1000_init_module(void) | |||
1208 | return 0; | 570 | return 0; |
1209 | } | 571 | } |
1210 | 572 | ||
1211 | static int au1000_setup_aneg(struct net_device *dev, u32 advertise) | 573 | /* |
1212 | { | 574 | * ethtool operations |
1213 | struct au1000_private *aup = (struct au1000_private *)dev->priv; | 575 | */ |
1214 | u16 ctl, adv; | ||
1215 | |||
1216 | /* Setup standard advertise */ | ||
1217 | adv = mdio_read(dev, aup->phy_addr, MII_ADVERTISE); | ||
1218 | adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4); | ||
1219 | if (advertise & ADVERTISED_10baseT_Half) | ||
1220 | adv |= ADVERTISE_10HALF; | ||
1221 | if (advertise & ADVERTISED_10baseT_Full) | ||
1222 | adv |= ADVERTISE_10FULL; | ||
1223 | if (advertise & ADVERTISED_100baseT_Half) | ||
1224 | adv |= ADVERTISE_100HALF; | ||
1225 | if (advertise & ADVERTISED_100baseT_Full) | ||
1226 | adv |= ADVERTISE_100FULL; | ||
1227 | mdio_write(dev, aup->phy_addr, MII_ADVERTISE, adv); | ||
1228 | |||
1229 | /* Start/Restart aneg */ | ||
1230 | ctl = mdio_read(dev, aup->phy_addr, MII_BMCR); | ||
1231 | ctl |= (BMCR_ANENABLE | BMCR_ANRESTART); | ||
1232 | mdio_write(dev, aup->phy_addr, MII_BMCR, ctl); | ||
1233 | |||
1234 | return 0; | ||
1235 | } | ||
1236 | 576 | ||
1237 | static int au1000_setup_forced(struct net_device *dev, int speed, int fd) | 577 | static int au1000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) |
1238 | { | 578 | { |
1239 | struct au1000_private *aup = (struct au1000_private *)dev->priv; | 579 | struct au1000_private *aup = (struct au1000_private *)dev->priv; |
1240 | u16 ctl; | ||
1241 | |||
1242 | ctl = mdio_read(dev, aup->phy_addr, MII_BMCR); | ||
1243 | ctl &= ~(BMCR_FULLDPLX | BMCR_SPEED100 | BMCR_ANENABLE); | ||
1244 | |||
1245 | /* First reset the PHY */ | ||
1246 | mdio_write(dev, aup->phy_addr, MII_BMCR, ctl | BMCR_RESET); | ||
1247 | |||
1248 | /* Select speed & duplex */ | ||
1249 | switch (speed) { | ||
1250 | case SPEED_10: | ||
1251 | break; | ||
1252 | case SPEED_100: | ||
1253 | ctl |= BMCR_SPEED100; | ||
1254 | break; | ||
1255 | case SPEED_1000: | ||
1256 | default: | ||
1257 | return -EINVAL; | ||
1258 | } | ||
1259 | if (fd == DUPLEX_FULL) | ||
1260 | ctl |= BMCR_FULLDPLX; | ||
1261 | mdio_write(dev, aup->phy_addr, MII_BMCR, ctl); | ||
1262 | |||
1263 | return 0; | ||
1264 | } | ||
1265 | |||
1266 | 580 | ||
1267 | static void | 581 | if (aup->phy_dev) |
1268 | au1000_start_link(struct net_device *dev, struct ethtool_cmd *cmd) | 582 | return phy_ethtool_gset(aup->phy_dev, cmd); |
1269 | { | ||
1270 | struct au1000_private *aup = (struct au1000_private *)dev->priv; | ||
1271 | u32 advertise; | ||
1272 | int autoneg; | ||
1273 | int forced_speed; | ||
1274 | int forced_duplex; | ||
1275 | |||
1276 | /* Default advertise */ | ||
1277 | advertise = GENMII_DEFAULT_ADVERTISE; | ||
1278 | autoneg = aup->want_autoneg; | ||
1279 | forced_speed = SPEED_100; | ||
1280 | forced_duplex = DUPLEX_FULL; | ||
1281 | |||
1282 | /* Setup link parameters */ | ||
1283 | if (cmd) { | ||
1284 | if (cmd->autoneg == AUTONEG_ENABLE) { | ||
1285 | advertise = cmd->advertising; | ||
1286 | autoneg = 1; | ||
1287 | } else { | ||
1288 | autoneg = 0; | ||
1289 | |||
1290 | forced_speed = cmd->speed; | ||
1291 | forced_duplex = cmd->duplex; | ||
1292 | } | ||
1293 | } | ||
1294 | 583 | ||
1295 | /* Configure PHY & start aneg */ | 584 | return -EINVAL; |
1296 | aup->want_autoneg = autoneg; | ||
1297 | if (autoneg) | ||
1298 | au1000_setup_aneg(dev, advertise); | ||
1299 | else | ||
1300 | au1000_setup_forced(dev, forced_speed, forced_duplex); | ||
1301 | mod_timer(&aup->timer, jiffies + HZ); | ||
1302 | } | 585 | } |
1303 | 586 | ||
1304 | static int au1000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) | 587 | static int au1000_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) |
1305 | { | 588 | { |
1306 | struct au1000_private *aup = (struct au1000_private *)dev->priv; | 589 | struct au1000_private *aup = (struct au1000_private *)dev->priv; |
1307 | u16 link, speed; | ||
1308 | |||
1309 | cmd->supported = GENMII_DEFAULT_FEATURES; | ||
1310 | cmd->advertising = GENMII_DEFAULT_ADVERTISE; | ||
1311 | cmd->port = PORT_MII; | ||
1312 | cmd->transceiver = XCVR_EXTERNAL; | ||
1313 | cmd->phy_address = aup->phy_addr; | ||
1314 | spin_lock_irq(&aup->lock); | ||
1315 | cmd->autoneg = aup->want_autoneg; | ||
1316 | aup->phy_ops->phy_status(dev, aup->phy_addr, &link, &speed); | ||
1317 | if ((speed == IF_PORT_100BASETX) || (speed == IF_PORT_100BASEFX)) | ||
1318 | cmd->speed = SPEED_100; | ||
1319 | else if (speed == IF_PORT_10BASET) | ||
1320 | cmd->speed = SPEED_10; | ||
1321 | if (link && (dev->if_port == IF_PORT_100BASEFX)) | ||
1322 | cmd->duplex = DUPLEX_FULL; | ||
1323 | else | ||
1324 | cmd->duplex = DUPLEX_HALF; | ||
1325 | spin_unlock_irq(&aup->lock); | ||
1326 | return 0; | ||
1327 | } | ||
1328 | 590 | ||
1329 | static int au1000_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) | 591 | if (!capable(CAP_NET_ADMIN)) |
1330 | { | 592 | return -EPERM; |
1331 | struct au1000_private *aup = (struct au1000_private *)dev->priv; | ||
1332 | unsigned long features = GENMII_DEFAULT_FEATURES; | ||
1333 | |||
1334 | if (!capable(CAP_NET_ADMIN)) | ||
1335 | return -EPERM; | ||
1336 | |||
1337 | if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE) | ||
1338 | return -EINVAL; | ||
1339 | if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0) | ||
1340 | return -EINVAL; | ||
1341 | if (cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL) | ||
1342 | return -EINVAL; | ||
1343 | if (cmd->autoneg == AUTONEG_DISABLE) | ||
1344 | switch (cmd->speed) { | ||
1345 | case SPEED_10: | ||
1346 | if (cmd->duplex == DUPLEX_HALF && | ||
1347 | (features & SUPPORTED_10baseT_Half) == 0) | ||
1348 | return -EINVAL; | ||
1349 | if (cmd->duplex == DUPLEX_FULL && | ||
1350 | (features & SUPPORTED_10baseT_Full) == 0) | ||
1351 | return -EINVAL; | ||
1352 | break; | ||
1353 | case SPEED_100: | ||
1354 | if (cmd->duplex == DUPLEX_HALF && | ||
1355 | (features & SUPPORTED_100baseT_Half) == 0) | ||
1356 | return -EINVAL; | ||
1357 | if (cmd->duplex == DUPLEX_FULL && | ||
1358 | (features & SUPPORTED_100baseT_Full) == 0) | ||
1359 | return -EINVAL; | ||
1360 | break; | ||
1361 | default: | ||
1362 | return -EINVAL; | ||
1363 | } | ||
1364 | else if ((features & SUPPORTED_Autoneg) == 0) | ||
1365 | return -EINVAL; | ||
1366 | |||
1367 | spin_lock_irq(&aup->lock); | ||
1368 | au1000_start_link(dev, cmd); | ||
1369 | spin_unlock_irq(&aup->lock); | ||
1370 | return 0; | ||
1371 | } | ||
1372 | 593 | ||
1373 | static int au1000_nway_reset(struct net_device *dev) | 594 | if (aup->phy_dev) |
1374 | { | 595 | return phy_ethtool_sset(aup->phy_dev, cmd); |
1375 | struct au1000_private *aup = (struct au1000_private *)dev->priv; | ||
1376 | 596 | ||
1377 | if (!aup->want_autoneg) | 597 | return -EINVAL; |
1378 | return -EINVAL; | ||
1379 | spin_lock_irq(&aup->lock); | ||
1380 | au1000_start_link(dev, NULL); | ||
1381 | spin_unlock_irq(&aup->lock); | ||
1382 | return 0; | ||
1383 | } | 598 | } |
1384 | 599 | ||
1385 | static void | 600 | static void |
@@ -1394,17 +609,11 @@ au1000_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) | |||
1394 | info->regdump_len = 0; | 609 | info->regdump_len = 0; |
1395 | } | 610 | } |
1396 | 611 | ||
1397 | static u32 au1000_get_link(struct net_device *dev) | ||
1398 | { | ||
1399 | return netif_carrier_ok(dev); | ||
1400 | } | ||
1401 | |||
1402 | static struct ethtool_ops au1000_ethtool_ops = { | 612 | static struct ethtool_ops au1000_ethtool_ops = { |
1403 | .get_settings = au1000_get_settings, | 613 | .get_settings = au1000_get_settings, |
1404 | .set_settings = au1000_set_settings, | 614 | .set_settings = au1000_set_settings, |
1405 | .get_drvinfo = au1000_get_drvinfo, | 615 | .get_drvinfo = au1000_get_drvinfo, |
1406 | .nway_reset = au1000_nway_reset, | 616 | .get_link = ethtool_op_get_link, |
1407 | .get_link = au1000_get_link | ||
1408 | }; | 617 | }; |
1409 | 618 | ||
1410 | static struct net_device * au1000_probe(int port_num) | 619 | static struct net_device * au1000_probe(int port_num) |
@@ -1499,23 +708,31 @@ static struct net_device * au1000_probe(int port_num) | |||
1499 | memcpy(dev->dev_addr, au1000_mac_addr, sizeof(au1000_mac_addr)); | 708 | memcpy(dev->dev_addr, au1000_mac_addr, sizeof(au1000_mac_addr)); |
1500 | dev->dev_addr[5] += port_num; | 709 | dev->dev_addr[5] += port_num; |
1501 | 710 | ||
1502 | /* Bring the device out of reset, otherwise probing the MII will hang */ | 711 | *aup->enable = 0; |
1503 | *aup->enable = MAC_EN_CLOCK_ENABLE; | 712 | aup->mac_enabled = 0; |
1504 | au_sync_delay(2); | 713 | |
1505 | *aup->enable = MAC_EN_RESET0 | MAC_EN_RESET1 | MAC_EN_RESET2 | | 714 | aup->mii_bus.priv = dev; |
1506 | MAC_EN_CLOCK_ENABLE; | 715 | aup->mii_bus.read = mdiobus_read; |
1507 | au_sync_delay(2); | 716 | aup->mii_bus.write = mdiobus_write; |
1508 | 717 | aup->mii_bus.reset = mdiobus_reset; | |
1509 | aup->mii = kmalloc(sizeof(struct mii_phy), GFP_KERNEL); | 718 | aup->mii_bus.name = "au1000_eth_mii"; |
1510 | if (!aup->mii) { | 719 | aup->mii_bus.id = aup->mac_id; |
1511 | printk(KERN_ERR "%s: out of memory\n", dev->name); | 720 | aup->mii_bus.irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL); |
1512 | goto err_out; | 721 | for(i = 0; i < PHY_MAX_ADDR; ++i) |
1513 | } | 722 | aup->mii_bus.irq[i] = PHY_POLL; |
1514 | aup->mii->next = NULL; | 723 | |
1515 | aup->mii->chip_info = NULL; | 724 | /* if known, set corresponding PHY IRQs */ |
1516 | aup->mii->status = 0; | 725 | #if defined(AU1XXX_PHY_STATIC_CONFIG) |
1517 | aup->mii->mii_control_reg = 0; | 726 | # if defined(AU1XXX_PHY0_IRQ) |
1518 | aup->mii->mii_data_reg = 0; | 727 | if (AU1XXX_PHY0_BUSID == aup->mii_bus.id) |
728 | aup->mii_bus.irq[AU1XXX_PHY0_ADDR] = AU1XXX_PHY0_IRQ; | ||
729 | # endif | ||
730 | # if defined(AU1XXX_PHY1_IRQ) | ||
731 | if (AU1XXX_PHY1_BUSID == aup->mii_bus.id) | ||
732 | aup->mii_bus.irq[AU1XXX_PHY1_ADDR] = AU1XXX_PHY1_IRQ; | ||
733 | # endif | ||
734 | #endif | ||
735 | mdiobus_register(&aup->mii_bus); | ||
1519 | 736 | ||
1520 | if (mii_probe(dev) != 0) { | 737 | if (mii_probe(dev) != 0) { |
1521 | goto err_out; | 738 | goto err_out; |
@@ -1561,7 +778,6 @@ static struct net_device * au1000_probe(int port_num) | |||
1561 | dev->set_multicast_list = &set_rx_mode; | 778 | dev->set_multicast_list = &set_rx_mode; |
1562 | dev->do_ioctl = &au1000_ioctl; | 779 | dev->do_ioctl = &au1000_ioctl; |
1563 | SET_ETHTOOL_OPS(dev, &au1000_ethtool_ops); | 780 | SET_ETHTOOL_OPS(dev, &au1000_ethtool_ops); |
1564 | dev->set_config = &au1000_set_config; | ||
1565 | dev->tx_timeout = au1000_tx_timeout; | 781 | dev->tx_timeout = au1000_tx_timeout; |
1566 | dev->watchdog_timeo = ETH_TX_TIMEOUT; | 782 | dev->watchdog_timeo = ETH_TX_TIMEOUT; |
1567 | 783 | ||
@@ -1577,7 +793,7 @@ err_out: | |||
1577 | /* here we should have a valid dev plus aup-> register addresses | 793 | /* here we should have a valid dev plus aup-> register addresses |
1578 | * so we can reset the mac properly.*/ | 794 | * so we can reset the mac properly.*/ |
1579 | reset_mac(dev); | 795 | reset_mac(dev); |
1580 | kfree(aup->mii); | 796 | |
1581 | for (i = 0; i < NUM_RX_DMA; i++) { | 797 | for (i = 0; i < NUM_RX_DMA; i++) { |
1582 | if (aup->rx_db_inuse[i]) | 798 | if (aup->rx_db_inuse[i]) |
1583 | ReleaseDB(aup, aup->rx_db_inuse[i]); | 799 | ReleaseDB(aup, aup->rx_db_inuse[i]); |
@@ -1610,19 +826,14 @@ static int au1000_init(struct net_device *dev) | |||
1610 | u32 flags; | 826 | u32 flags; |
1611 | int i; | 827 | int i; |
1612 | u32 control; | 828 | u32 control; |
1613 | u16 link, speed; | ||
1614 | 829 | ||
1615 | if (au1000_debug > 4) | 830 | if (au1000_debug > 4) |
1616 | printk("%s: au1000_init\n", dev->name); | 831 | printk("%s: au1000_init\n", dev->name); |
1617 | 832 | ||
1618 | spin_lock_irqsave(&aup->lock, flags); | ||
1619 | |||
1620 | /* bring the device out of reset */ | 833 | /* bring the device out of reset */ |
1621 | *aup->enable = MAC_EN_CLOCK_ENABLE; | 834 | enable_mac(dev, 1); |
1622 | au_sync_delay(2); | 835 | |
1623 | *aup->enable = MAC_EN_RESET0 | MAC_EN_RESET1 | | 836 | spin_lock_irqsave(&aup->lock, flags); |
1624 | MAC_EN_RESET2 | MAC_EN_CLOCK_ENABLE; | ||
1625 | au_sync_delay(20); | ||
1626 | 837 | ||
1627 | aup->mac->control = 0; | 838 | aup->mac->control = 0; |
1628 | aup->tx_head = (aup->tx_dma_ring[0]->buff_stat & 0xC) >> 2; | 839 | aup->tx_head = (aup->tx_dma_ring[0]->buff_stat & 0xC) >> 2; |
@@ -1638,12 +849,16 @@ static int au1000_init(struct net_device *dev) | |||
1638 | } | 849 | } |
1639 | au_sync(); | 850 | au_sync(); |
1640 | 851 | ||
1641 | aup->phy_ops->phy_status(dev, aup->phy_addr, &link, &speed); | 852 | control = MAC_RX_ENABLE | MAC_TX_ENABLE; |
1642 | control = MAC_DISABLE_RX_OWN | MAC_RX_ENABLE | MAC_TX_ENABLE; | ||
1643 | #ifndef CONFIG_CPU_LITTLE_ENDIAN | 853 | #ifndef CONFIG_CPU_LITTLE_ENDIAN |
1644 | control |= MAC_BIG_ENDIAN; | 854 | control |= MAC_BIG_ENDIAN; |
1645 | #endif | 855 | #endif |
1646 | if (link && (dev->if_port == IF_PORT_100BASEFX)) { | 856 | if (aup->phy_dev) { |
857 | if (aup->phy_dev->link && (DUPLEX_FULL == aup->phy_dev->duplex)) | ||
858 | control |= MAC_FULL_DUPLEX; | ||
859 | else | ||
860 | control |= MAC_DISABLE_RX_OWN; | ||
861 | } else { /* PHY-less op, assume full-duplex */ | ||
1647 | control |= MAC_FULL_DUPLEX; | 862 | control |= MAC_FULL_DUPLEX; |
1648 | } | 863 | } |
1649 | 864 | ||
@@ -1655,57 +870,84 @@ static int au1000_init(struct net_device *dev) | |||
1655 | return 0; | 870 | return 0; |
1656 | } | 871 | } |
1657 | 872 | ||
1658 | static void au1000_timer(unsigned long data) | 873 | static void |
874 | au1000_adjust_link(struct net_device *dev) | ||
1659 | { | 875 | { |
1660 | struct net_device *dev = (struct net_device *)data; | ||
1661 | struct au1000_private *aup = (struct au1000_private *) dev->priv; | 876 | struct au1000_private *aup = (struct au1000_private *) dev->priv; |
1662 | unsigned char if_port; | 877 | struct phy_device *phydev = aup->phy_dev; |
1663 | u16 link, speed; | 878 | unsigned long flags; |
1664 | 879 | ||
1665 | if (!dev) { | 880 | int status_change = 0; |
1666 | /* fatal error, don't restart the timer */ | ||
1667 | printk(KERN_ERR "au1000_timer error: NULL dev\n"); | ||
1668 | return; | ||
1669 | } | ||
1670 | 881 | ||
1671 | if_port = dev->if_port; | 882 | BUG_ON(!aup->phy_dev); |
1672 | if (aup->phy_ops->phy_status(dev, aup->phy_addr, &link, &speed) == 0) { | 883 | |
1673 | if (link) { | 884 | spin_lock_irqsave(&aup->lock, flags); |
1674 | if (!netif_carrier_ok(dev)) { | 885 | |
1675 | netif_carrier_on(dev); | 886 | if (phydev->link && (aup->old_speed != phydev->speed)) { |
1676 | printk(KERN_INFO "%s: link up\n", dev->name); | 887 | // speed changed |
1677 | } | 888 | |
1678 | } | 889 | switch(phydev->speed) { |
1679 | else { | 890 | case SPEED_10: |
1680 | if (netif_carrier_ok(dev)) { | 891 | case SPEED_100: |
1681 | netif_carrier_off(dev); | 892 | break; |
1682 | dev->if_port = 0; | 893 | default: |
1683 | printk(KERN_INFO "%s: link down\n", dev->name); | 894 | printk(KERN_WARNING |
1684 | } | 895 | "%s: Speed (%d) is not 10/100 ???\n", |
896 | dev->name, phydev->speed); | ||
897 | break; | ||
1685 | } | 898 | } |
899 | |||
900 | aup->old_speed = phydev->speed; | ||
901 | |||
902 | status_change = 1; | ||
1686 | } | 903 | } |
1687 | 904 | ||
1688 | if (link && (dev->if_port != if_port) && | 905 | if (phydev->link && (aup->old_duplex != phydev->duplex)) { |
1689 | (dev->if_port != IF_PORT_UNKNOWN)) { | 906 | // duplex mode changed |
907 | |||
908 | /* switching duplex mode requires to disable rx and tx! */ | ||
1690 | hard_stop(dev); | 909 | hard_stop(dev); |
1691 | if (dev->if_port == IF_PORT_100BASEFX) { | 910 | |
1692 | printk(KERN_INFO "%s: going to full duplex\n", | 911 | if (DUPLEX_FULL == phydev->duplex) |
1693 | dev->name); | 912 | aup->mac->control = ((aup->mac->control |
1694 | aup->mac->control |= MAC_FULL_DUPLEX; | 913 | | MAC_FULL_DUPLEX) |
1695 | au_sync_delay(1); | 914 | & ~MAC_DISABLE_RX_OWN); |
1696 | } | 915 | else |
1697 | else { | 916 | aup->mac->control = ((aup->mac->control |
1698 | aup->mac->control &= ~MAC_FULL_DUPLEX; | 917 | & ~MAC_FULL_DUPLEX) |
1699 | au_sync_delay(1); | 918 | | MAC_DISABLE_RX_OWN); |
1700 | } | 919 | au_sync_delay(1); |
920 | |||
1701 | enable_rx_tx(dev); | 921 | enable_rx_tx(dev); |
922 | aup->old_duplex = phydev->duplex; | ||
923 | |||
924 | status_change = 1; | ||
925 | } | ||
926 | |||
927 | if(phydev->link != aup->old_link) { | ||
928 | // link state changed | ||
929 | |||
930 | if (phydev->link) // link went up | ||
931 | netif_schedule(dev); | ||
932 | else { // link went down | ||
933 | aup->old_speed = 0; | ||
934 | aup->old_duplex = -1; | ||
935 | } | ||
936 | |||
937 | aup->old_link = phydev->link; | ||
938 | status_change = 1; | ||
1702 | } | 939 | } |
1703 | 940 | ||
1704 | aup->timer.expires = RUN_AT((1*HZ)); | 941 | spin_unlock_irqrestore(&aup->lock, flags); |
1705 | aup->timer.data = (unsigned long)dev; | ||
1706 | aup->timer.function = &au1000_timer; /* timer handler */ | ||
1707 | add_timer(&aup->timer); | ||
1708 | 942 | ||
943 | if (status_change) { | ||
944 | if (phydev->link) | ||
945 | printk(KERN_INFO "%s: link up (%d/%s)\n", | ||
946 | dev->name, phydev->speed, | ||
947 | DUPLEX_FULL == phydev->duplex ? "Full" : "Half"); | ||
948 | else | ||
949 | printk(KERN_INFO "%s: link down\n", dev->name); | ||
950 | } | ||
1709 | } | 951 | } |
1710 | 952 | ||
1711 | static int au1000_open(struct net_device *dev) | 953 | static int au1000_open(struct net_device *dev) |
@@ -1716,25 +958,26 @@ static int au1000_open(struct net_device *dev) | |||
1716 | if (au1000_debug > 4) | 958 | if (au1000_debug > 4) |
1717 | printk("%s: open: dev=%p\n", dev->name, dev); | 959 | printk("%s: open: dev=%p\n", dev->name, dev); |
1718 | 960 | ||
961 | if ((retval = request_irq(dev->irq, &au1000_interrupt, 0, | ||
962 | dev->name, dev))) { | ||
963 | printk(KERN_ERR "%s: unable to get IRQ %d\n", | ||
964 | dev->name, dev->irq); | ||
965 | return retval; | ||
966 | } | ||
967 | |||
1719 | if ((retval = au1000_init(dev))) { | 968 | if ((retval = au1000_init(dev))) { |
1720 | printk(KERN_ERR "%s: error in au1000_init\n", dev->name); | 969 | printk(KERN_ERR "%s: error in au1000_init\n", dev->name); |
1721 | free_irq(dev->irq, dev); | 970 | free_irq(dev->irq, dev); |
1722 | return retval; | 971 | return retval; |
1723 | } | 972 | } |
1724 | netif_start_queue(dev); | ||
1725 | 973 | ||
1726 | if ((retval = request_irq(dev->irq, &au1000_interrupt, 0, | 974 | if (aup->phy_dev) { |
1727 | dev->name, dev))) { | 975 | /* cause the PHY state machine to schedule a link state check */ |
1728 | printk(KERN_ERR "%s: unable to get IRQ %d\n", | 976 | aup->phy_dev->state = PHY_CHANGELINK; |
1729 | dev->name, dev->irq); | 977 | phy_start(aup->phy_dev); |
1730 | return retval; | ||
1731 | } | 978 | } |
1732 | 979 | ||
1733 | init_timer(&aup->timer); /* used in ioctl() */ | 980 | netif_start_queue(dev); |
1734 | aup->timer.expires = RUN_AT((3*HZ)); | ||
1735 | aup->timer.data = (unsigned long)dev; | ||
1736 | aup->timer.function = &au1000_timer; /* timer handler */ | ||
1737 | add_timer(&aup->timer); | ||
1738 | 981 | ||
1739 | if (au1000_debug > 4) | 982 | if (au1000_debug > 4) |
1740 | printk("%s: open: Initialization done.\n", dev->name); | 983 | printk("%s: open: Initialization done.\n", dev->name); |
@@ -1744,16 +987,19 @@ static int au1000_open(struct net_device *dev) | |||
1744 | 987 | ||
1745 | static int au1000_close(struct net_device *dev) | 988 | static int au1000_close(struct net_device *dev) |
1746 | { | 989 | { |
1747 | u32 flags; | 990 | unsigned long flags; |
1748 | struct au1000_private *aup = (struct au1000_private *) dev->priv; | 991 | struct au1000_private *const aup = (struct au1000_private *) dev->priv; |
1749 | 992 | ||
1750 | if (au1000_debug > 4) | 993 | if (au1000_debug > 4) |
1751 | printk("%s: close: dev=%p\n", dev->name, dev); | 994 | printk("%s: close: dev=%p\n", dev->name, dev); |
1752 | 995 | ||
1753 | reset_mac(dev); | 996 | if (aup->phy_dev) |
997 | phy_stop(aup->phy_dev); | ||
1754 | 998 | ||
1755 | spin_lock_irqsave(&aup->lock, flags); | 999 | spin_lock_irqsave(&aup->lock, flags); |
1756 | 1000 | ||
1001 | reset_mac_unlocked (dev); | ||
1002 | |||
1757 | /* stop the device */ | 1003 | /* stop the device */ |
1758 | netif_stop_queue(dev); | 1004 | netif_stop_queue(dev); |
1759 | 1005 | ||
@@ -1775,7 +1021,6 @@ static void __exit au1000_cleanup_module(void) | |||
1775 | if (dev) { | 1021 | if (dev) { |
1776 | aup = (struct au1000_private *) dev->priv; | 1022 | aup = (struct au1000_private *) dev->priv; |
1777 | unregister_netdev(dev); | 1023 | unregister_netdev(dev); |
1778 | kfree(aup->mii); | ||
1779 | for (j = 0; j < NUM_RX_DMA; j++) | 1024 | for (j = 0; j < NUM_RX_DMA; j++) |
1780 | if (aup->rx_db_inuse[j]) | 1025 | if (aup->rx_db_inuse[j]) |
1781 | ReleaseDB(aup, aup->rx_db_inuse[j]); | 1026 | ReleaseDB(aup, aup->rx_db_inuse[j]); |
@@ -1798,7 +1043,7 @@ static void update_tx_stats(struct net_device *dev, u32 status) | |||
1798 | struct net_device_stats *ps = &aup->stats; | 1043 | struct net_device_stats *ps = &aup->stats; |
1799 | 1044 | ||
1800 | if (status & TX_FRAME_ABORTED) { | 1045 | if (status & TX_FRAME_ABORTED) { |
1801 | if (dev->if_port == IF_PORT_100BASEFX) { | 1046 | if (!aup->phy_dev || (DUPLEX_FULL == aup->phy_dev->duplex)) { |
1802 | if (status & (TX_JAB_TIMEOUT | TX_UNDERRUN)) { | 1047 | if (status & (TX_JAB_TIMEOUT | TX_UNDERRUN)) { |
1803 | /* any other tx errors are only valid | 1048 | /* any other tx errors are only valid |
1804 | * in half duplex mode */ | 1049 | * in half duplex mode */ |
@@ -2072,126 +1317,15 @@ static void set_rx_mode(struct net_device *dev) | |||
2072 | } | 1317 | } |
2073 | } | 1318 | } |
2074 | 1319 | ||
2075 | |||
2076 | static int au1000_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) | 1320 | static int au1000_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) |
2077 | { | 1321 | { |
2078 | struct au1000_private *aup = (struct au1000_private *)dev->priv; | 1322 | struct au1000_private *aup = (struct au1000_private *)dev->priv; |
2079 | u16 *data = (u16 *)&rq->ifr_ifru; | ||
2080 | |||
2081 | switch(cmd) { | ||
2082 | case SIOCDEVPRIVATE: /* Get the address of the PHY in use. */ | ||
2083 | case SIOCGMIIPHY: | ||
2084 | if (!netif_running(dev)) return -EINVAL; | ||
2085 | data[0] = aup->phy_addr; | ||
2086 | case SIOCDEVPRIVATE+1: /* Read the specified MII register. */ | ||
2087 | case SIOCGMIIREG: | ||
2088 | data[3] = mdio_read(dev, data[0], data[1]); | ||
2089 | return 0; | ||
2090 | case SIOCDEVPRIVATE+2: /* Write the specified MII register */ | ||
2091 | case SIOCSMIIREG: | ||
2092 | if (!capable(CAP_NET_ADMIN)) | ||
2093 | return -EPERM; | ||
2094 | mdio_write(dev, data[0], data[1],data[2]); | ||
2095 | return 0; | ||
2096 | default: | ||
2097 | return -EOPNOTSUPP; | ||
2098 | } | ||
2099 | |||
2100 | } | ||
2101 | |||
2102 | |||
2103 | static int au1000_set_config(struct net_device *dev, struct ifmap *map) | ||
2104 | { | ||
2105 | struct au1000_private *aup = (struct au1000_private *) dev->priv; | ||
2106 | u16 control; | ||
2107 | 1323 | ||
2108 | if (au1000_debug > 4) { | 1324 | if (!netif_running(dev)) return -EINVAL; |
2109 | printk("%s: set_config called: dev->if_port %d map->port %x\n", | ||
2110 | dev->name, dev->if_port, map->port); | ||
2111 | } | ||
2112 | 1325 | ||
2113 | switch(map->port){ | 1326 | if (!aup->phy_dev) return -EINVAL; // PHY not controllable |
2114 | case IF_PORT_UNKNOWN: /* use auto here */ | ||
2115 | printk(KERN_INFO "%s: config phy for aneg\n", | ||
2116 | dev->name); | ||
2117 | dev->if_port = map->port; | ||
2118 | /* Link Down: the timer will bring it up */ | ||
2119 | netif_carrier_off(dev); | ||
2120 | |||
2121 | /* read current control */ | ||
2122 | control = mdio_read(dev, aup->phy_addr, MII_CONTROL); | ||
2123 | control &= ~(MII_CNTL_FDX | MII_CNTL_F100); | ||
2124 | |||
2125 | /* enable auto negotiation and reset the negotiation */ | ||
2126 | mdio_write(dev, aup->phy_addr, MII_CONTROL, | ||
2127 | control | MII_CNTL_AUTO | | ||
2128 | MII_CNTL_RST_AUTO); | ||
2129 | 1327 | ||
2130 | break; | 1328 | return phy_mii_ioctl(aup->phy_dev, if_mii(rq), cmd); |
2131 | |||
2132 | case IF_PORT_10BASET: /* 10BaseT */ | ||
2133 | printk(KERN_INFO "%s: config phy for 10BaseT\n", | ||
2134 | dev->name); | ||
2135 | dev->if_port = map->port; | ||
2136 | |||
2137 | /* Link Down: the timer will bring it up */ | ||
2138 | netif_carrier_off(dev); | ||
2139 | |||
2140 | /* set Speed to 10Mbps, Half Duplex */ | ||
2141 | control = mdio_read(dev, aup->phy_addr, MII_CONTROL); | ||
2142 | control &= ~(MII_CNTL_F100 | MII_CNTL_AUTO | | ||
2143 | MII_CNTL_FDX); | ||
2144 | |||
2145 | /* disable auto negotiation and force 10M/HD mode*/ | ||
2146 | mdio_write(dev, aup->phy_addr, MII_CONTROL, control); | ||
2147 | break; | ||
2148 | |||
2149 | case IF_PORT_100BASET: /* 100BaseT */ | ||
2150 | case IF_PORT_100BASETX: /* 100BaseTx */ | ||
2151 | printk(KERN_INFO "%s: config phy for 100BaseTX\n", | ||
2152 | dev->name); | ||
2153 | dev->if_port = map->port; | ||
2154 | |||
2155 | /* Link Down: the timer will bring it up */ | ||
2156 | netif_carrier_off(dev); | ||
2157 | |||
2158 | /* set Speed to 100Mbps, Half Duplex */ | ||
2159 | /* disable auto negotiation and enable 100MBit Mode */ | ||
2160 | control = mdio_read(dev, aup->phy_addr, MII_CONTROL); | ||
2161 | control &= ~(MII_CNTL_AUTO | MII_CNTL_FDX); | ||
2162 | control |= MII_CNTL_F100; | ||
2163 | mdio_write(dev, aup->phy_addr, MII_CONTROL, control); | ||
2164 | break; | ||
2165 | |||
2166 | case IF_PORT_100BASEFX: /* 100BaseFx */ | ||
2167 | printk(KERN_INFO "%s: config phy for 100BaseFX\n", | ||
2168 | dev->name); | ||
2169 | dev->if_port = map->port; | ||
2170 | |||
2171 | /* Link Down: the timer will bring it up */ | ||
2172 | netif_carrier_off(dev); | ||
2173 | |||
2174 | /* set Speed to 100Mbps, Full Duplex */ | ||
2175 | /* disable auto negotiation and enable 100MBit Mode */ | ||
2176 | control = mdio_read(dev, aup->phy_addr, MII_CONTROL); | ||
2177 | control &= ~MII_CNTL_AUTO; | ||
2178 | control |= MII_CNTL_F100 | MII_CNTL_FDX; | ||
2179 | mdio_write(dev, aup->phy_addr, MII_CONTROL, control); | ||
2180 | break; | ||
2181 | case IF_PORT_10BASE2: /* 10Base2 */ | ||
2182 | case IF_PORT_AUI: /* AUI */ | ||
2183 | /* These Modes are not supported (are they?)*/ | ||
2184 | printk(KERN_ERR "%s: 10Base2/AUI not supported", | ||
2185 | dev->name); | ||
2186 | return -EOPNOTSUPP; | ||
2187 | break; | ||
2188 | |||
2189 | default: | ||
2190 | printk(KERN_ERR "%s: Invalid media selected", | ||
2191 | dev->name); | ||
2192 | return -EINVAL; | ||
2193 | } | ||
2194 | return 0; | ||
2195 | } | 1329 | } |
2196 | 1330 | ||
2197 | static struct net_device_stats *au1000_get_stats(struct net_device *dev) | 1331 | static struct net_device_stats *au1000_get_stats(struct net_device *dev) |
diff --git a/drivers/net/au1000_eth.h b/drivers/net/au1000_eth.h index 7f9326e39cc0..41c2f848d2c4 100644 --- a/drivers/net/au1000_eth.h +++ b/drivers/net/au1000_eth.h | |||
@@ -40,120 +40,6 @@ | |||
40 | 40 | ||
41 | #define MULTICAST_FILTER_LIMIT 64 | 41 | #define MULTICAST_FILTER_LIMIT 64 |
42 | 42 | ||
43 | /* FIXME | ||
44 | * The PHY defines should be in a separate file. | ||
45 | */ | ||
46 | |||
47 | /* MII register offsets */ | ||
48 | #define MII_CONTROL 0x0000 | ||
49 | #define MII_STATUS 0x0001 | ||
50 | #define MII_PHY_ID0 0x0002 | ||
51 | #define MII_PHY_ID1 0x0003 | ||
52 | #define MII_ANADV 0x0004 | ||
53 | #define MII_ANLPAR 0x0005 | ||
54 | #define MII_AEXP 0x0006 | ||
55 | #define MII_ANEXT 0x0007 | ||
56 | #define MII_LSI_PHY_CONFIG 0x0011 | ||
57 | /* Status register */ | ||
58 | #define MII_LSI_PHY_STAT 0x0012 | ||
59 | #define MII_AMD_PHY_STAT MII_LSI_PHY_STAT | ||
60 | #define MII_INTEL_PHY_STAT 0x0011 | ||
61 | |||
62 | #define MII_AUX_CNTRL 0x0018 | ||
63 | /* mii registers specific to AMD 79C901 */ | ||
64 | #define MII_STATUS_SUMMARY = 0x0018 | ||
65 | |||
66 | /* MII Control register bit definitions. */ | ||
67 | #define MII_CNTL_FDX 0x0100 | ||
68 | #define MII_CNTL_RST_AUTO 0x0200 | ||
69 | #define MII_CNTL_ISOLATE 0x0400 | ||
70 | #define MII_CNTL_PWRDWN 0x0800 | ||
71 | #define MII_CNTL_AUTO 0x1000 | ||
72 | #define MII_CNTL_F100 0x2000 | ||
73 | #define MII_CNTL_LPBK 0x4000 | ||
74 | #define MII_CNTL_RESET 0x8000 | ||
75 | |||
76 | /* MII Status register bit */ | ||
77 | #define MII_STAT_EXT 0x0001 | ||
78 | #define MII_STAT_JAB 0x0002 | ||
79 | #define MII_STAT_LINK 0x0004 | ||
80 | #define MII_STAT_CAN_AUTO 0x0008 | ||
81 | #define MII_STAT_FAULT 0x0010 | ||
82 | #define MII_STAT_AUTO_DONE 0x0020 | ||
83 | #define MII_STAT_CAN_T 0x0800 | ||
84 | #define MII_STAT_CAN_T_FDX 0x1000 | ||
85 | #define MII_STAT_CAN_TX 0x2000 | ||
86 | #define MII_STAT_CAN_TX_FDX 0x4000 | ||
87 | #define MII_STAT_CAN_T4 0x8000 | ||
88 | |||
89 | |||
90 | #define MII_ID1_OUI_LO 0xFC00 /* low bits of OUI mask */ | ||
91 | #define MII_ID1_MODEL 0x03F0 /* model number */ | ||
92 | #define MII_ID1_REV 0x000F /* model number */ | ||
93 | |||
94 | /* MII NWAY Register Bits ... | ||
95 | valid for the ANAR (Auto-Negotiation Advertisement) and | ||
96 | ANLPAR (Auto-Negotiation Link Partner) registers */ | ||
97 | #define MII_NWAY_NODE_SEL 0x001f | ||
98 | #define MII_NWAY_CSMA_CD 0x0001 | ||
99 | #define MII_NWAY_T 0x0020 | ||
100 | #define MII_NWAY_T_FDX 0x0040 | ||
101 | #define MII_NWAY_TX 0x0080 | ||
102 | #define MII_NWAY_TX_FDX 0x0100 | ||
103 | #define MII_NWAY_T4 0x0200 | ||
104 | #define MII_NWAY_PAUSE 0x0400 | ||
105 | #define MII_NWAY_RF 0x2000 /* Remote Fault */ | ||
106 | #define MII_NWAY_ACK 0x4000 /* Remote Acknowledge */ | ||
107 | #define MII_NWAY_NP 0x8000 /* Next Page (Enable) */ | ||
108 | |||
109 | /* mii stsout register bits */ | ||
110 | #define MII_STSOUT_LINK_FAIL 0x4000 | ||
111 | #define MII_STSOUT_SPD 0x0080 | ||
112 | #define MII_STSOUT_DPLX 0x0040 | ||
113 | |||
114 | /* mii stsics register bits */ | ||
115 | #define MII_STSICS_SPD 0x8000 | ||
116 | #define MII_STSICS_DPLX 0x4000 | ||
117 | #define MII_STSICS_LINKSTS 0x0001 | ||
118 | |||
119 | /* mii stssum register bits */ | ||
120 | #define MII_STSSUM_LINK 0x0008 | ||
121 | #define MII_STSSUM_DPLX 0x0004 | ||
122 | #define MII_STSSUM_AUTO 0x0002 | ||
123 | #define MII_STSSUM_SPD 0x0001 | ||
124 | |||
125 | /* lsi phy status register */ | ||
126 | #define MII_LSI_PHY_STAT_FDX 0x0040 | ||
127 | #define MII_LSI_PHY_STAT_SPD 0x0080 | ||
128 | |||
129 | /* amd phy status register */ | ||
130 | #define MII_AMD_PHY_STAT_FDX 0x0800 | ||
131 | #define MII_AMD_PHY_STAT_SPD 0x0400 | ||
132 | |||
133 | /* intel phy status register */ | ||
134 | #define MII_INTEL_PHY_STAT_FDX 0x0200 | ||
135 | #define MII_INTEL_PHY_STAT_SPD 0x4000 | ||
136 | |||
137 | /* Auxilliary Control/Status Register */ | ||
138 | #define MII_AUX_FDX 0x0001 | ||
139 | #define MII_AUX_100 0x0002 | ||
140 | #define MII_AUX_F100 0x0004 | ||
141 | #define MII_AUX_ANEG 0x0008 | ||
142 | |||
143 | typedef struct mii_phy { | ||
144 | struct mii_phy * next; | ||
145 | struct mii_chip_info * chip_info; | ||
146 | u16 status; | ||
147 | u32 *mii_control_reg; | ||
148 | u32 *mii_data_reg; | ||
149 | } mii_phy_t; | ||
150 | |||
151 | struct phy_ops { | ||
152 | int (*phy_init) (struct net_device *, int); | ||
153 | int (*phy_reset) (struct net_device *, int); | ||
154 | int (*phy_status) (struct net_device *, int, u16 *, u16 *); | ||
155 | }; | ||
156 | |||
157 | /* | 43 | /* |
158 | * Data Buffer Descriptor. Data buffers must be aligned on 32 byte | 44 | * Data Buffer Descriptor. Data buffers must be aligned on 32 byte |
159 | * boundary for both, receive and transmit. | 45 | * boundary for both, receive and transmit. |
@@ -200,7 +86,6 @@ typedef struct mac_reg { | |||
200 | 86 | ||
201 | 87 | ||
202 | struct au1000_private { | 88 | struct au1000_private { |
203 | |||
204 | db_dest_t *pDBfree; | 89 | db_dest_t *pDBfree; |
205 | db_dest_t db[NUM_RX_BUFFS+NUM_TX_BUFFS]; | 90 | db_dest_t db[NUM_RX_BUFFS+NUM_TX_BUFFS]; |
206 | volatile rx_dma_t *rx_dma_ring[NUM_RX_DMA]; | 91 | volatile rx_dma_t *rx_dma_ring[NUM_RX_DMA]; |
@@ -213,8 +98,15 @@ struct au1000_private { | |||
213 | u32 tx_full; | 98 | u32 tx_full; |
214 | 99 | ||
215 | int mac_id; | 100 | int mac_id; |
216 | mii_phy_t *mii; | 101 | |
217 | struct phy_ops *phy_ops; | 102 | int mac_enabled; /* whether MAC is currently enabled and running (req. for mdio) */ |
103 | |||
104 | int old_link; /* used by au1000_adjust_link */ | ||
105 | int old_speed; | ||
106 | int old_duplex; | ||
107 | |||
108 | struct phy_device *phy_dev; | ||
109 | struct mii_bus mii_bus; | ||
218 | 110 | ||
219 | /* These variables are just for quick access to certain regs addresses. */ | 111 | /* These variables are just for quick access to certain regs addresses. */ |
220 | volatile mac_reg_t *mac; /* mac registers */ | 112 | volatile mac_reg_t *mac; /* mac registers */ |
@@ -223,14 +115,6 @@ struct au1000_private { | |||
223 | u32 vaddr; /* virtual address of rx/tx buffers */ | 115 | u32 vaddr; /* virtual address of rx/tx buffers */ |
224 | dma_addr_t dma_addr; /* dma address of rx/tx buffers */ | 116 | dma_addr_t dma_addr; /* dma address of rx/tx buffers */ |
225 | 117 | ||
226 | u8 *hash_table; | ||
227 | u32 hash_mode; | ||
228 | u32 intr_work_done; /* number of Rx and Tx pkts processed in the isr */ | ||
229 | int phy_addr; /* phy address */ | ||
230 | u32 options; /* User-settable misc. driver options. */ | ||
231 | u32 drv_flags; | ||
232 | int want_autoneg; | ||
233 | struct net_device_stats stats; | 118 | struct net_device_stats stats; |
234 | struct timer_list timer; | ||
235 | spinlock_t lock; /* Serialise access to device */ | 119 | spinlock_t lock; /* Serialise access to device */ |
236 | }; | 120 | }; |
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c index 54161aef3cac..702d546567ad 100644 --- a/drivers/net/bnx2.c +++ b/drivers/net/bnx2.c | |||
@@ -32,6 +32,7 @@ | |||
32 | #include <asm/irq.h> | 32 | #include <asm/irq.h> |
33 | #include <linux/delay.h> | 33 | #include <linux/delay.h> |
34 | #include <asm/byteorder.h> | 34 | #include <asm/byteorder.h> |
35 | #include <asm/page.h> | ||
35 | #include <linux/time.h> | 36 | #include <linux/time.h> |
36 | #include <linux/ethtool.h> | 37 | #include <linux/ethtool.h> |
37 | #include <linux/mii.h> | 38 | #include <linux/mii.h> |
@@ -49,14 +50,15 @@ | |||
49 | #include <linux/crc32.h> | 50 | #include <linux/crc32.h> |
50 | #include <linux/prefetch.h> | 51 | #include <linux/prefetch.h> |
51 | #include <linux/cache.h> | 52 | #include <linux/cache.h> |
53 | #include <linux/zlib.h> | ||
52 | 54 | ||
53 | #include "bnx2.h" | 55 | #include "bnx2.h" |
54 | #include "bnx2_fw.h" | 56 | #include "bnx2_fw.h" |
55 | 57 | ||
56 | #define DRV_MODULE_NAME "bnx2" | 58 | #define DRV_MODULE_NAME "bnx2" |
57 | #define PFX DRV_MODULE_NAME ": " | 59 | #define PFX DRV_MODULE_NAME ": " |
58 | #define DRV_MODULE_VERSION "1.4.40" | 60 | #define DRV_MODULE_VERSION "1.4.42" |
59 | #define DRV_MODULE_RELDATE "May 22, 2006" | 61 | #define DRV_MODULE_RELDATE "June 12, 2006" |
60 | 62 | ||
61 | #define RUN_AT(x) (jiffies + (x)) | 63 | #define RUN_AT(x) (jiffies + (x)) |
62 | 64 | ||
@@ -1820,7 +1822,7 @@ reuse_rx: | |||
1820 | skb->protocol = eth_type_trans(skb, bp->dev); | 1822 | skb->protocol = eth_type_trans(skb, bp->dev); |
1821 | 1823 | ||
1822 | if ((len > (bp->dev->mtu + ETH_HLEN)) && | 1824 | if ((len > (bp->dev->mtu + ETH_HLEN)) && |
1823 | (htons(skb->protocol) != 0x8100)) { | 1825 | (ntohs(skb->protocol) != 0x8100)) { |
1824 | 1826 | ||
1825 | dev_kfree_skb_irq(skb); | 1827 | dev_kfree_skb_irq(skb); |
1826 | goto next_rx; | 1828 | goto next_rx; |
@@ -2009,7 +2011,7 @@ bnx2_poll(struct net_device *dev, int *budget) | |||
2009 | return 1; | 2011 | return 1; |
2010 | } | 2012 | } |
2011 | 2013 | ||
2012 | /* Called with rtnl_lock from vlan functions and also dev->xmit_lock | 2014 | /* Called with rtnl_lock from vlan functions and also netif_tx_lock |
2013 | * from set_multicast. | 2015 | * from set_multicast. |
2014 | */ | 2016 | */ |
2015 | static void | 2017 | static void |
@@ -2083,6 +2085,92 @@ bnx2_set_rx_mode(struct net_device *dev) | |||
2083 | spin_unlock_bh(&bp->phy_lock); | 2085 | spin_unlock_bh(&bp->phy_lock); |
2084 | } | 2086 | } |
2085 | 2087 | ||
2088 | #define FW_BUF_SIZE 0x8000 | ||
2089 | |||
2090 | static int | ||
2091 | bnx2_gunzip_init(struct bnx2 *bp) | ||
2092 | { | ||
2093 | if ((bp->gunzip_buf = vmalloc(FW_BUF_SIZE)) == NULL) | ||
2094 | goto gunzip_nomem1; | ||
2095 | |||
2096 | if ((bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL)) == NULL) | ||
2097 | goto gunzip_nomem2; | ||
2098 | |||
2099 | bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL); | ||
2100 | if (bp->strm->workspace == NULL) | ||
2101 | goto gunzip_nomem3; | ||
2102 | |||
2103 | return 0; | ||
2104 | |||
2105 | gunzip_nomem3: | ||
2106 | kfree(bp->strm); | ||
2107 | bp->strm = NULL; | ||
2108 | |||
2109 | gunzip_nomem2: | ||
2110 | vfree(bp->gunzip_buf); | ||
2111 | bp->gunzip_buf = NULL; | ||
2112 | |||
2113 | gunzip_nomem1: | ||
2114 | printk(KERN_ERR PFX "%s: Cannot allocate firmware buffer for " | ||
2115 | "uncompression.\n", bp->dev->name); | ||
2116 | return -ENOMEM; | ||
2117 | } | ||
2118 | |||
2119 | static void | ||
2120 | bnx2_gunzip_end(struct bnx2 *bp) | ||
2121 | { | ||
2122 | kfree(bp->strm->workspace); | ||
2123 | |||
2124 | kfree(bp->strm); | ||
2125 | bp->strm = NULL; | ||
2126 | |||
2127 | if (bp->gunzip_buf) { | ||
2128 | vfree(bp->gunzip_buf); | ||
2129 | bp->gunzip_buf = NULL; | ||
2130 | } | ||
2131 | } | ||
2132 | |||
2133 | static int | ||
2134 | bnx2_gunzip(struct bnx2 *bp, u8 *zbuf, int len, void **outbuf, int *outlen) | ||
2135 | { | ||
2136 | int n, rc; | ||
2137 | |||
2138 | /* check gzip header */ | ||
2139 | if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED)) | ||
2140 | return -EINVAL; | ||
2141 | |||
2142 | n = 10; | ||
2143 | |||
2144 | #define FNAME 0x8 | ||
2145 | if (zbuf[3] & FNAME) | ||
2146 | while ((zbuf[n++] != 0) && (n < len)); | ||
2147 | |||
2148 | bp->strm->next_in = zbuf + n; | ||
2149 | bp->strm->avail_in = len - n; | ||
2150 | bp->strm->next_out = bp->gunzip_buf; | ||
2151 | bp->strm->avail_out = FW_BUF_SIZE; | ||
2152 | |||
2153 | rc = zlib_inflateInit2(bp->strm, -MAX_WBITS); | ||
2154 | if (rc != Z_OK) | ||
2155 | return rc; | ||
2156 | |||
2157 | rc = zlib_inflate(bp->strm, Z_FINISH); | ||
2158 | |||
2159 | *outlen = FW_BUF_SIZE - bp->strm->avail_out; | ||
2160 | *outbuf = bp->gunzip_buf; | ||
2161 | |||
2162 | if ((rc != Z_OK) && (rc != Z_STREAM_END)) | ||
2163 | printk(KERN_ERR PFX "%s: Firmware decompression error: %s\n", | ||
2164 | bp->dev->name, bp->strm->msg); | ||
2165 | |||
2166 | zlib_inflateEnd(bp->strm); | ||
2167 | |||
2168 | if (rc == Z_STREAM_END) | ||
2169 | return 0; | ||
2170 | |||
2171 | return rc; | ||
2172 | } | ||
2173 | |||
2086 | static void | 2174 | static void |
2087 | load_rv2p_fw(struct bnx2 *bp, u32 *rv2p_code, u32 rv2p_code_len, | 2175 | load_rv2p_fw(struct bnx2 *bp, u32 *rv2p_code, u32 rv2p_code_len, |
2088 | u32 rv2p_proc) | 2176 | u32 rv2p_proc) |
@@ -2092,9 +2180,9 @@ load_rv2p_fw(struct bnx2 *bp, u32 *rv2p_code, u32 rv2p_code_len, | |||
2092 | 2180 | ||
2093 | 2181 | ||
2094 | for (i = 0; i < rv2p_code_len; i += 8) { | 2182 | for (i = 0; i < rv2p_code_len; i += 8) { |
2095 | REG_WR(bp, BNX2_RV2P_INSTR_HIGH, *rv2p_code); | 2183 | REG_WR(bp, BNX2_RV2P_INSTR_HIGH, cpu_to_le32(*rv2p_code)); |
2096 | rv2p_code++; | 2184 | rv2p_code++; |
2097 | REG_WR(bp, BNX2_RV2P_INSTR_LOW, *rv2p_code); | 2185 | REG_WR(bp, BNX2_RV2P_INSTR_LOW, cpu_to_le32(*rv2p_code)); |
2098 | rv2p_code++; | 2186 | rv2p_code++; |
2099 | 2187 | ||
2100 | if (rv2p_proc == RV2P_PROC1) { | 2188 | if (rv2p_proc == RV2P_PROC1) { |
@@ -2134,7 +2222,7 @@ load_cpu_fw(struct bnx2 *bp, struct cpu_reg *cpu_reg, struct fw_info *fw) | |||
2134 | int j; | 2222 | int j; |
2135 | 2223 | ||
2136 | for (j = 0; j < (fw->text_len / 4); j++, offset += 4) { | 2224 | for (j = 0; j < (fw->text_len / 4); j++, offset += 4) { |
2137 | REG_WR_IND(bp, offset, fw->text[j]); | 2225 | REG_WR_IND(bp, offset, cpu_to_le32(fw->text[j])); |
2138 | } | 2226 | } |
2139 | } | 2227 | } |
2140 | 2228 | ||
@@ -2190,15 +2278,32 @@ load_cpu_fw(struct bnx2 *bp, struct cpu_reg *cpu_reg, struct fw_info *fw) | |||
2190 | REG_WR_IND(bp, cpu_reg->mode, val); | 2278 | REG_WR_IND(bp, cpu_reg->mode, val); |
2191 | } | 2279 | } |
2192 | 2280 | ||
2193 | static void | 2281 | static int |
2194 | bnx2_init_cpus(struct bnx2 *bp) | 2282 | bnx2_init_cpus(struct bnx2 *bp) |
2195 | { | 2283 | { |
2196 | struct cpu_reg cpu_reg; | 2284 | struct cpu_reg cpu_reg; |
2197 | struct fw_info fw; | 2285 | struct fw_info fw; |
2286 | int rc = 0; | ||
2287 | void *text; | ||
2288 | u32 text_len; | ||
2289 | |||
2290 | if ((rc = bnx2_gunzip_init(bp)) != 0) | ||
2291 | return rc; | ||
2198 | 2292 | ||
2199 | /* Initialize the RV2P processor. */ | 2293 | /* Initialize the RV2P processor. */ |
2200 | load_rv2p_fw(bp, bnx2_rv2p_proc1, sizeof(bnx2_rv2p_proc1), RV2P_PROC1); | 2294 | rc = bnx2_gunzip(bp, bnx2_rv2p_proc1, sizeof(bnx2_rv2p_proc1), &text, |
2201 | load_rv2p_fw(bp, bnx2_rv2p_proc2, sizeof(bnx2_rv2p_proc2), RV2P_PROC2); | 2295 | &text_len); |
2296 | if (rc) | ||
2297 | goto init_cpu_err; | ||
2298 | |||
2299 | load_rv2p_fw(bp, text, text_len, RV2P_PROC1); | ||
2300 | |||
2301 | rc = bnx2_gunzip(bp, bnx2_rv2p_proc2, sizeof(bnx2_rv2p_proc2), &text, | ||
2302 | &text_len); | ||
2303 | if (rc) | ||
2304 | goto init_cpu_err; | ||
2305 | |||
2306 | load_rv2p_fw(bp, text, text_len, RV2P_PROC2); | ||
2202 | 2307 | ||
2203 | /* Initialize the RX Processor. */ | 2308 | /* Initialize the RX Processor. */ |
2204 | cpu_reg.mode = BNX2_RXP_CPU_MODE; | 2309 | cpu_reg.mode = BNX2_RXP_CPU_MODE; |
@@ -2222,7 +2327,13 @@ bnx2_init_cpus(struct bnx2 *bp) | |||
2222 | fw.text_addr = bnx2_RXP_b06FwTextAddr; | 2327 | fw.text_addr = bnx2_RXP_b06FwTextAddr; |
2223 | fw.text_len = bnx2_RXP_b06FwTextLen; | 2328 | fw.text_len = bnx2_RXP_b06FwTextLen; |
2224 | fw.text_index = 0; | 2329 | fw.text_index = 0; |
2225 | fw.text = bnx2_RXP_b06FwText; | 2330 | |
2331 | rc = bnx2_gunzip(bp, bnx2_RXP_b06FwText, sizeof(bnx2_RXP_b06FwText), | ||
2332 | &text, &text_len); | ||
2333 | if (rc) | ||
2334 | goto init_cpu_err; | ||
2335 | |||
2336 | fw.text = text; | ||
2226 | 2337 | ||
2227 | fw.data_addr = bnx2_RXP_b06FwDataAddr; | 2338 | fw.data_addr = bnx2_RXP_b06FwDataAddr; |
2228 | fw.data_len = bnx2_RXP_b06FwDataLen; | 2339 | fw.data_len = bnx2_RXP_b06FwDataLen; |
@@ -2268,7 +2379,13 @@ bnx2_init_cpus(struct bnx2 *bp) | |||
2268 | fw.text_addr = bnx2_TXP_b06FwTextAddr; | 2379 | fw.text_addr = bnx2_TXP_b06FwTextAddr; |
2269 | fw.text_len = bnx2_TXP_b06FwTextLen; | 2380 | fw.text_len = bnx2_TXP_b06FwTextLen; |
2270 | fw.text_index = 0; | 2381 | fw.text_index = 0; |
2271 | fw.text = bnx2_TXP_b06FwText; | 2382 | |
2383 | rc = bnx2_gunzip(bp, bnx2_TXP_b06FwText, sizeof(bnx2_TXP_b06FwText), | ||
2384 | &text, &text_len); | ||
2385 | if (rc) | ||
2386 | goto init_cpu_err; | ||
2387 | |||
2388 | fw.text = text; | ||
2272 | 2389 | ||
2273 | fw.data_addr = bnx2_TXP_b06FwDataAddr; | 2390 | fw.data_addr = bnx2_TXP_b06FwDataAddr; |
2274 | fw.data_len = bnx2_TXP_b06FwDataLen; | 2391 | fw.data_len = bnx2_TXP_b06FwDataLen; |
@@ -2314,7 +2431,13 @@ bnx2_init_cpus(struct bnx2 *bp) | |||
2314 | fw.text_addr = bnx2_TPAT_b06FwTextAddr; | 2431 | fw.text_addr = bnx2_TPAT_b06FwTextAddr; |
2315 | fw.text_len = bnx2_TPAT_b06FwTextLen; | 2432 | fw.text_len = bnx2_TPAT_b06FwTextLen; |
2316 | fw.text_index = 0; | 2433 | fw.text_index = 0; |
2317 | fw.text = bnx2_TPAT_b06FwText; | 2434 | |
2435 | rc = bnx2_gunzip(bp, bnx2_TPAT_b06FwText, sizeof(bnx2_TPAT_b06FwText), | ||
2436 | &text, &text_len); | ||
2437 | if (rc) | ||
2438 | goto init_cpu_err; | ||
2439 | |||
2440 | fw.text = text; | ||
2318 | 2441 | ||
2319 | fw.data_addr = bnx2_TPAT_b06FwDataAddr; | 2442 | fw.data_addr = bnx2_TPAT_b06FwDataAddr; |
2320 | fw.data_len = bnx2_TPAT_b06FwDataLen; | 2443 | fw.data_len = bnx2_TPAT_b06FwDataLen; |
@@ -2360,7 +2483,13 @@ bnx2_init_cpus(struct bnx2 *bp) | |||
2360 | fw.text_addr = bnx2_COM_b06FwTextAddr; | 2483 | fw.text_addr = bnx2_COM_b06FwTextAddr; |
2361 | fw.text_len = bnx2_COM_b06FwTextLen; | 2484 | fw.text_len = bnx2_COM_b06FwTextLen; |
2362 | fw.text_index = 0; | 2485 | fw.text_index = 0; |
2363 | fw.text = bnx2_COM_b06FwText; | 2486 | |
2487 | rc = bnx2_gunzip(bp, bnx2_COM_b06FwText, sizeof(bnx2_COM_b06FwText), | ||
2488 | &text, &text_len); | ||
2489 | if (rc) | ||
2490 | goto init_cpu_err; | ||
2491 | |||
2492 | fw.text = text; | ||
2364 | 2493 | ||
2365 | fw.data_addr = bnx2_COM_b06FwDataAddr; | 2494 | fw.data_addr = bnx2_COM_b06FwDataAddr; |
2366 | fw.data_len = bnx2_COM_b06FwDataLen; | 2495 | fw.data_len = bnx2_COM_b06FwDataLen; |
@@ -2384,6 +2513,9 @@ bnx2_init_cpus(struct bnx2 *bp) | |||
2384 | 2513 | ||
2385 | load_cpu_fw(bp, &cpu_reg, &fw); | 2514 | load_cpu_fw(bp, &cpu_reg, &fw); |
2386 | 2515 | ||
2516 | init_cpu_err: | ||
2517 | bnx2_gunzip_end(bp); | ||
2518 | return rc; | ||
2387 | } | 2519 | } |
2388 | 2520 | ||
2389 | static int | 2521 | static int |
@@ -3256,7 +3388,9 @@ bnx2_init_chip(struct bnx2 *bp) | |||
3256 | * context block must have already been enabled. */ | 3388 | * context block must have already been enabled. */ |
3257 | bnx2_init_context(bp); | 3389 | bnx2_init_context(bp); |
3258 | 3390 | ||
3259 | bnx2_init_cpus(bp); | 3391 | if ((rc = bnx2_init_cpus(bp)) != 0) |
3392 | return rc; | ||
3393 | |||
3260 | bnx2_init_nvram(bp); | 3394 | bnx2_init_nvram(bp); |
3261 | 3395 | ||
3262 | bnx2_set_mac_addr(bp); | 3396 | bnx2_set_mac_addr(bp); |
@@ -3556,7 +3690,9 @@ bnx2_reset_nic(struct bnx2 *bp, u32 reset_code) | |||
3556 | if (rc) | 3690 | if (rc) |
3557 | return rc; | 3691 | return rc; |
3558 | 3692 | ||
3559 | bnx2_init_chip(bp); | 3693 | if ((rc = bnx2_init_chip(bp)) != 0) |
3694 | return rc; | ||
3695 | |||
3560 | bnx2_init_tx_ring(bp); | 3696 | bnx2_init_tx_ring(bp); |
3561 | bnx2_init_rx_ring(bp); | 3697 | bnx2_init_rx_ring(bp); |
3562 | return 0; | 3698 | return 0; |
@@ -4034,6 +4170,8 @@ bnx2_timer(unsigned long data) | |||
4034 | msg = (u32) ++bp->fw_drv_pulse_wr_seq; | 4170 | msg = (u32) ++bp->fw_drv_pulse_wr_seq; |
4035 | REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_PULSE_MB, msg); | 4171 | REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_PULSE_MB, msg); |
4036 | 4172 | ||
4173 | bp->stats_blk->stat_FwRxDrop = REG_RD_IND(bp, BNX2_FW_RX_DROP_COUNT); | ||
4174 | |||
4037 | if ((bp->phy_flags & PHY_SERDES_FLAG) && | 4175 | if ((bp->phy_flags & PHY_SERDES_FLAG) && |
4038 | (CHIP_NUM(bp) == CHIP_NUM_5706)) { | 4176 | (CHIP_NUM(bp) == CHIP_NUM_5706)) { |
4039 | 4177 | ||
@@ -4252,7 +4390,7 @@ bnx2_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid) | |||
4252 | } | 4390 | } |
4253 | #endif | 4391 | #endif |
4254 | 4392 | ||
4255 | /* Called with dev->xmit_lock. | 4393 | /* Called with netif_tx_lock. |
4256 | * hard_start_xmit is pseudo-lockless - a lock is only required when | 4394 | * hard_start_xmit is pseudo-lockless - a lock is only required when |
4257 | * the tx queue is full. This way, we get the benefit of lockless | 4395 | * the tx queue is full. This way, we get the benefit of lockless |
4258 | * operations most of the time without the complexities to handle | 4396 | * operations most of the time without the complexities to handle |
@@ -4310,7 +4448,7 @@ bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
4310 | ip_tcp_len = (skb->nh.iph->ihl << 2) + sizeof(struct tcphdr); | 4448 | ip_tcp_len = (skb->nh.iph->ihl << 2) + sizeof(struct tcphdr); |
4311 | 4449 | ||
4312 | skb->nh.iph->check = 0; | 4450 | skb->nh.iph->check = 0; |
4313 | skb->nh.iph->tot_len = ntohs(mss + ip_tcp_len + tcp_opt_len); | 4451 | skb->nh.iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len); |
4314 | skb->h.th->check = | 4452 | skb->h.th->check = |
4315 | ~csum_tcpudp_magic(skb->nh.iph->saddr, | 4453 | ~csum_tcpudp_magic(skb->nh.iph->saddr, |
4316 | skb->nh.iph->daddr, | 4454 | skb->nh.iph->daddr, |
@@ -4504,6 +4642,10 @@ bnx2_get_stats(struct net_device *dev) | |||
4504 | net_stats->tx_aborted_errors + | 4642 | net_stats->tx_aborted_errors + |
4505 | net_stats->tx_carrier_errors; | 4643 | net_stats->tx_carrier_errors; |
4506 | 4644 | ||
4645 | net_stats->rx_missed_errors = | ||
4646 | (unsigned long) (stats_blk->stat_IfInMBUFDiscards + | ||
4647 | stats_blk->stat_FwRxDrop); | ||
4648 | |||
4507 | return net_stats; | 4649 | return net_stats; |
4508 | } | 4650 | } |
4509 | 4651 | ||
@@ -4986,7 +5128,7 @@ bnx2_set_rx_csum(struct net_device *dev, u32 data) | |||
4986 | return 0; | 5128 | return 0; |
4987 | } | 5129 | } |
4988 | 5130 | ||
4989 | #define BNX2_NUM_STATS 45 | 5131 | #define BNX2_NUM_STATS 46 |
4990 | 5132 | ||
4991 | static struct { | 5133 | static struct { |
4992 | char string[ETH_GSTRING_LEN]; | 5134 | char string[ETH_GSTRING_LEN]; |
@@ -5036,6 +5178,7 @@ static struct { | |||
5036 | { "rx_mac_ctrl_frames" }, | 5178 | { "rx_mac_ctrl_frames" }, |
5037 | { "rx_filtered_packets" }, | 5179 | { "rx_filtered_packets" }, |
5038 | { "rx_discards" }, | 5180 | { "rx_discards" }, |
5181 | { "rx_fw_discards" }, | ||
5039 | }; | 5182 | }; |
5040 | 5183 | ||
5041 | #define STATS_OFFSET32(offset_name) (offsetof(struct statistics_block, offset_name) / 4) | 5184 | #define STATS_OFFSET32(offset_name) (offsetof(struct statistics_block, offset_name) / 4) |
@@ -5086,6 +5229,7 @@ static const unsigned long bnx2_stats_offset_arr[BNX2_NUM_STATS] = { | |||
5086 | STATS_OFFSET32(stat_MacControlFramesReceived), | 5229 | STATS_OFFSET32(stat_MacControlFramesReceived), |
5087 | STATS_OFFSET32(stat_IfInFramesL2FilterDiscards), | 5230 | STATS_OFFSET32(stat_IfInFramesL2FilterDiscards), |
5088 | STATS_OFFSET32(stat_IfInMBUFDiscards), | 5231 | STATS_OFFSET32(stat_IfInMBUFDiscards), |
5232 | STATS_OFFSET32(stat_FwRxDrop), | ||
5089 | }; | 5233 | }; |
5090 | 5234 | ||
5091 | /* stat_IfHCInBadOctets and stat_Dot3StatsCarrierSenseErrors are | 5235 | /* stat_IfHCInBadOctets and stat_Dot3StatsCarrierSenseErrors are |
@@ -5096,7 +5240,7 @@ static u8 bnx2_5706_stats_len_arr[BNX2_NUM_STATS] = { | |||
5096 | 4,0,4,4,4,4,4,4,4,4, | 5240 | 4,0,4,4,4,4,4,4,4,4, |
5097 | 4,4,4,4,4,4,4,4,4,4, | 5241 | 4,4,4,4,4,4,4,4,4,4, |
5098 | 4,4,4,4,4,4,4,4,4,4, | 5242 | 4,4,4,4,4,4,4,4,4,4, |
5099 | 4,4,4,4,4, | 5243 | 4,4,4,4,4,4, |
5100 | }; | 5244 | }; |
5101 | 5245 | ||
5102 | static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = { | 5246 | static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = { |
@@ -5104,7 +5248,7 @@ static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = { | |||
5104 | 4,4,4,4,4,4,4,4,4,4, | 5248 | 4,4,4,4,4,4,4,4,4,4, |
5105 | 4,4,4,4,4,4,4,4,4,4, | 5249 | 4,4,4,4,4,4,4,4,4,4, |
5106 | 4,4,4,4,4,4,4,4,4,4, | 5250 | 4,4,4,4,4,4,4,4,4,4, |
5107 | 4,4,4,4,4, | 5251 | 4,4,4,4,4,4, |
5108 | }; | 5252 | }; |
5109 | 5253 | ||
5110 | #define BNX2_NUM_TESTS 6 | 5254 | #define BNX2_NUM_TESTS 6 |
@@ -5634,7 +5778,9 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev) | |||
5634 | } | 5778 | } |
5635 | } | 5779 | } |
5636 | 5780 | ||
5637 | if (CHIP_NUM(bp) == CHIP_NUM_5708) | 5781 | if ((CHIP_ID(bp) == CHIP_ID_5708_A0) || |
5782 | (CHIP_ID(bp) == CHIP_ID_5708_B0) || | ||
5783 | (CHIP_ID(bp) == CHIP_ID_5708_B1)) | ||
5638 | bp->flags |= NO_WOL_FLAG; | 5784 | bp->flags |= NO_WOL_FLAG; |
5639 | 5785 | ||
5640 | if (CHIP_ID(bp) == CHIP_ID_5706_A0) { | 5786 | if (CHIP_ID(bp) == CHIP_ID_5706_A0) { |
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h index b87925f6a228..5845e334941b 100644 --- a/drivers/net/bnx2.h +++ b/drivers/net/bnx2.h | |||
@@ -231,6 +231,7 @@ struct statistics_block { | |||
231 | u32 stat_GenStat13; | 231 | u32 stat_GenStat13; |
232 | u32 stat_GenStat14; | 232 | u32 stat_GenStat14; |
233 | u32 stat_GenStat15; | 233 | u32 stat_GenStat15; |
234 | u32 stat_FwRxDrop; | ||
234 | }; | 235 | }; |
235 | 236 | ||
236 | 237 | ||
@@ -3481,6 +3482,8 @@ struct l2_fhdr { | |||
3481 | 3482 | ||
3482 | #define BNX2_COM_SCRATCH 0x00120000 | 3483 | #define BNX2_COM_SCRATCH 0x00120000 |
3483 | 3484 | ||
3485 | #define BNX2_FW_RX_DROP_COUNT 0x00120084 | ||
3486 | |||
3484 | 3487 | ||
3485 | /* | 3488 | /* |
3486 | * cp_reg definition | 3489 | * cp_reg definition |
@@ -3747,7 +3750,12 @@ struct l2_fhdr { | |||
3747 | #define DMA_READ_CHANS 5 | 3750 | #define DMA_READ_CHANS 5 |
3748 | #define DMA_WRITE_CHANS 3 | 3751 | #define DMA_WRITE_CHANS 3 |
3749 | 3752 | ||
3750 | #define BCM_PAGE_BITS 12 | 3753 | /* Use CPU native page size up to 16K for the ring sizes. */ |
3754 | #if (PAGE_SHIFT > 14) | ||
3755 | #define BCM_PAGE_BITS 14 | ||
3756 | #else | ||
3757 | #define BCM_PAGE_BITS PAGE_SHIFT | ||
3758 | #endif | ||
3751 | #define BCM_PAGE_SIZE (1 << BCM_PAGE_BITS) | 3759 | #define BCM_PAGE_SIZE (1 << BCM_PAGE_BITS) |
3752 | 3760 | ||
3753 | #define TX_DESC_CNT (BCM_PAGE_SIZE / sizeof(struct tx_bd)) | 3761 | #define TX_DESC_CNT (BCM_PAGE_SIZE / sizeof(struct tx_bd)) |
@@ -3770,7 +3778,7 @@ struct l2_fhdr { | |||
3770 | 3778 | ||
3771 | #define RX_RING_IDX(x) ((x) & bp->rx_max_ring_idx) | 3779 | #define RX_RING_IDX(x) ((x) & bp->rx_max_ring_idx) |
3772 | 3780 | ||
3773 | #define RX_RING(x) (((x) & ~MAX_RX_DESC_CNT) >> 8) | 3781 | #define RX_RING(x) (((x) & ~MAX_RX_DESC_CNT) >> (BCM_PAGE_BITS - 4)) |
3774 | #define RX_IDX(x) ((x) & MAX_RX_DESC_CNT) | 3782 | #define RX_IDX(x) ((x) & MAX_RX_DESC_CNT) |
3775 | 3783 | ||
3776 | /* Context size. */ | 3784 | /* Context size. */ |
@@ -4048,6 +4056,9 @@ struct bnx2 { | |||
4048 | u32 flash_size; | 4056 | u32 flash_size; |
4049 | 4057 | ||
4050 | int status_stats_size; | 4058 | int status_stats_size; |
4059 | |||
4060 | struct z_stream_s *strm; | ||
4061 | void *gunzip_buf; | ||
4051 | }; | 4062 | }; |
4052 | 4063 | ||
4053 | static u32 bnx2_reg_rd_ind(struct bnx2 *bp, u32 offset); | 4064 | static u32 bnx2_reg_rd_ind(struct bnx2 *bp, u32 offset); |
diff --git a/drivers/net/bnx2_fw.h b/drivers/net/bnx2_fw.h index 8158974c35a8..2d753dca0d75 100644 --- a/drivers/net/bnx2_fw.h +++ b/drivers/net/bnx2_fw.h | |||
@@ -7,7 +7,7 @@ | |||
7 | * the Free Software Foundation, except as noted below. | 7 | * the Free Software Foundation, except as noted below. |
8 | * | 8 | * |
9 | * This file contains firmware data derived from proprietary unpublished | 9 | * This file contains firmware data derived from proprietary unpublished |
10 | * source code, Copyright (c) 2004, 2005 Broadcom Corporation. | 10 | * source code, Copyright (c) 2004, 2005, 2006 Broadcom Corporation. |
11 | * | 11 | * |
12 | * Permission is hereby granted for the distribution of this firmware data | 12 | * Permission is hereby granted for the distribution of this firmware data |
13 | * in hexadecimal or equivalent format, provided this copyright notice is | 13 | * in hexadecimal or equivalent format, provided this copyright notice is |
@@ -28,943 +28,641 @@ static const u32 bnx2_COM_b06FwBssAddr = 0x08005860; | |||
28 | static const int bnx2_COM_b06FwBssLen = 0x88; | 28 | static const int bnx2_COM_b06FwBssLen = 0x88; |
29 | static const u32 bnx2_COM_b06FwSbssAddr = 0x08005840; | 29 | static const u32 bnx2_COM_b06FwSbssAddr = 0x08005840; |
30 | static const int bnx2_COM_b06FwSbssLen = 0x1c; | 30 | static const int bnx2_COM_b06FwSbssLen = 0x1c; |
31 | static u32 bnx2_COM_b06FwText[(0x57bc/4) + 1] = { | 31 | static u8 bnx2_COM_b06FwText[] = { |
32 | 0x0a00022d, 0x00000000, 0x00000000, 0x0000000d, 0x636f6d20, 0x322e352e, | 32 | 0x1f, 0x8b, 0x08, 0x08, 0x09, 0x83, 0x41, 0x44, 0x00, 0x03, 0x74, 0x65, |
33 | 0x38000000, 0x02050802, 0x00000000, 0x00000003, 0x00000014, 0x00000032, | 33 | 0x73, 0x74, 0x31, 0x2e, 0x62, 0x69, 0x6e, 0x00, 0xec, 0x5b, 0x7d, 0x6c, |
34 | 0x00000003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 34 | 0x5b, 0xd7, 0x75, 0x3f, 0xef, 0xf1, 0x51, 0x7a, 0x96, 0x68, 0xf9, 0x99, |
35 | 0x00000010, 0x000003e8, 0x0000ea60, 0x00000001, 0x00000000, 0x00000000, | 35 | 0x7e, 0x96, 0x59, 0x4f, 0xb1, 0x49, 0xf1, 0xc9, 0xd2, 0x62, 0x2d, 0x63, |
36 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 36 | 0x34, 0x35, 0xd1, 0x3a, 0x26, 0x66, 0x48, 0xda, 0x71, 0x36, 0x67, 0xa0, |
37 | 0x0000ffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 37 | 0x1d, 0x05, 0x51, 0x51, 0xaf, 0xd0, 0x48, 0xd9, 0xcd, 0xb2, 0x0c, 0x73, |
38 | 0x00000000, 0x00000000, 0x00000002, 0x00000020, 0x00000000, 0x00000000, | 38 | 0x96, 0xb4, 0x70, 0xbc, 0xb4, 0xa1, 0x25, 0x79, 0xf5, 0x06, 0x45, 0xcf, |
39 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 39 | 0xb3, 0x34, 0x39, 0xc0, 0x82, 0x41, 0x10, 0x9d, 0x3a, 0x7f, 0x30, 0xa5, |
40 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 40 | 0xed, 0x7c, 0x19, 0xe8, 0x12, 0x29, 0xb2, 0x93, 0xb5, 0x43, 0xd0, 0xa6, |
41 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 41 | 0x68, 0xff, 0xe8, 0x8a, 0x6e, 0x30, 0x52, 0x0c, 0xf3, 0x3a, 0xa0, 0x30, |
42 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 42 | 0xfa, 0xc7, 0xe6, 0x2d, 0x1f, 0xdc, 0xef, 0xdc, 0x77, 0x1f, 0xf9, 0x48, |
43 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 43 | 0x51, 0x96, 0x1c, 0x34, 0x5d, 0xb7, 0x99, 0x80, 0xf0, 0xde, 0xbd, 0xf7, |
44 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 44 | 0xbc, 0x7b, 0xcf, 0x3d, 0xdf, 0xe7, 0xdc, 0xab, 0x5f, 0x53, 0xa9, 0x85, |
45 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 45 | 0xe4, 0x6f, 0x2d, 0xfe, 0xc2, 0x7f, 0xf4, 0xc7, 0xb9, 0xdb, 0x3e, 0x7d, |
46 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 46 | 0x5b, 0x1f, 0x5e, 0x07, 0x54, 0xdd, 0xaf, 0x72, 0xbf, 0x0f, 0x7f, 0x26, |
47 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 47 | 0xfe, 0xfa, 0xe4, 0x7b, 0xa3, 0x9f, 0x81, 0xbf, 0x2b, 0x18, 0x1c, 0xfe, |
48 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 48 | 0x09, 0x91, 0xb2, 0x0c, 0x8c, 0xf7, 0x57, 0x2e, 0x5f, 0x7f, 0x9c, 0x17, |
49 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 49 | 0x0e, 0xaf, 0x62, 0x9e, 0x9b, 0xbf, 0x9b, 0xbf, 0x9b, 0xbf, 0x9b, 0xbf, |
50 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 50 | 0x9b, 0xbf, 0x9b, 0xbf, 0x9b, 0xbf, 0xff, 0x3f, 0x3f, 0x9f, 0x13, 0x72, |
51 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 51 | 0x88, 0x98, 0x85, 0xff, 0x48, 0x57, 0xe3, 0x89, 0xa1, 0xa4, 0x45, 0xba, |
52 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 52 | 0x2f, 0x7e, 0x65, 0x28, 0x67, 0x11, 0x25, 0x8a, 0xdb, 0xc3, 0x29, 0xfa, |
53 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 53 | 0xb0, 0x9c, 0x37, 0x35, 0xe2, 0xfe, 0x5b, 0xe2, 0x1f, 0x3c, 0xfd, 0xfa, |
54 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 54 | 0x9d, 0x91, 0xab, 0xb3, 0x3e, 0xd2, 0x8d, 0xf8, 0xcb, 0xba, 0xb1, 0x8d, |
55 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 55 | 0xf4, 0x0e, 0x7c, 0xf3, 0x5c, 0xf7, 0x7f, 0xa8, 0xd4, 0xe6, 0xce, 0x75, |
56 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 56 | 0xa5, 0xfc, 0x7a, 0x37, 0xe5, 0x37, 0xc7, 0x75, 0x52, 0xe3, 0x5d, 0x3f, |
57 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 57 | 0x48, 0xfa, 0x8c, 0x61, 0x5f, 0xdc, 0xa0, 0xf9, 0x12, 0x65, 0x0e, 0x4c, |
58 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 58 | 0xf0, 0x1a, 0xb1, 0x75, 0xf7, 0x62, 0x2e, 0x2d, 0x3e, 0x3c, 0xf4, 0x67, |
59 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 59 | 0xd6, 0xd3, 0x65, 0xd5, 0xb2, 0x7a, 0xe6, 0x28, 0x30, 0xf0, 0x7c, 0x3f, |
60 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 60 | 0xc6, 0x8b, 0x91, 0x1e, 0xa2, 0x3b, 0x49, 0xb5, 0xf2, 0x01, 0x9f, 0xa5, |
61 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 61 | 0x53, 0xb2, 0x64, 0x51, 0xaa, 0x44, 0xf4, 0x77, 0x45, 0x85, 0x9e, 0xb7, |
62 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 62 | 0xda, 0x69, 0xae, 0xf7, 0x83, 0x72, 0x02, 0xb8, 0xbc, 0x6d, 0x0d, 0x0f, |
63 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 63 | 0x8d, 0x5b, 0x3c, 0x57, 0x7c, 0x9d, 0x83, 0x6f, 0x6f, 0x5b, 0xce, 0xd2, |
64 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 64 | 0x68, 0xb4, 0xc8, 0x7d, 0xbd, 0x2d, 0xdc, 0xe7, 0x8f, 0x3f, 0x1c, 0x7c, |
65 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 65 | 0xde, 0x0a, 0xc8, 0xbe, 0x1f, 0xa5, 0x92, 0x98, 0x6f, 0xac, 0xc8, 0xb0, |
66 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 66 | 0xcf, 0xde, 0x91, 0xb3, 0x4c, 0xd9, 0x6f, 0xc5, 0x93, 0x56, 0x08, 0xfd, |
67 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 67 | 0x1d, 0x72, 0x2c, 0xbd, 0x2e, 0x67, 0x59, 0x72, 0xac, 0x88, 0x6f, 0x7a, |
68 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 68 | 0x65, 0xff, 0x3b, 0xa9, 0x9c, 0x15, 0x93, 0xfd, 0x57, 0x93, 0x49, 0xab, |
69 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 69 | 0x5f, 0xf6, 0x1f, 0xbe, 0x2b, 0x67, 0xc5, 0x65, 0xff, 0xf7, 0x81, 0x8b, |
70 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 70 | 0x41, 0xc7, 0x8a, 0x61, 0xfc, 0x25, 0x30, 0xfe, 0x9a, 0x41, 0x6d, 0x19, |
71 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 71 | 0x8c, 0x61, 0xef, 0xb6, 0x4e, 0x97, 0x7d, 0x21, 0x7a, 0xbd, 0xfb, 0x32, |
72 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 72 | 0x68, 0x63, 0xd0, 0xd9, 0x12, 0x29, 0x99, 0xee, 0x10, 0x68, 0x62, 0xd2, |
73 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 73 | 0xb9, 0x52, 0x2b, 0xf9, 0x4e, 0xfa, 0xb0, 0xe7, 0xcf, 0x51, 0xd6, 0xd4, |
74 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 74 | 0x69, 0xfd, 0x8c, 0x42, 0x9d, 0x7d, 0x6b, 0x28, 0x61, 0xe4, 0x29, 0xd5, |
75 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 75 | 0x8d, 0x28, 0x6e, 0xd2, 0x24, 0x6d, 0x66, 0x71, 0xbd, 0x8a, 0x1e, 0x95, |
76 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 76 | 0x22, 0xa1, 0x2c, 0x28, 0x3c, 0x72, 0xfa, 0x5d, 0x8e, 0x39, 0xb1, 0x26, |
77 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 77 | 0xff, 0x85, 0x29, 0x35, 0x71, 0x2b, 0x0d, 0x1b, 0x8c, 0x0f, 0x80, 0x05, |
78 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 78 | 0x1f, 0x74, 0x25, 0x79, 0x2a, 0x44, 0xc7, 0xec, 0x80, 0x92, 0x3a, 0x75, |
79 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 79 | 0x37, 0x25, 0x63, 0x64, 0xaa, 0xd4, 0x25, 0xbe, 0x2d, 0x14, 0x43, 0x34, |
80 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 80 | 0x6e, 0x93, 0x92, 0xb4, 0x99, 0x5e, 0xed, 0x18, 0x6f, 0x13, 0xb0, 0xe8, |
81 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 81 | 0xeb, 0xf0, 0x51, 0x97, 0x91, 0x22, 0x9d, 0x71, 0x46, 0x7f, 0x50, 0x49, |
82 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 82 | 0x8b, 0x39, 0x44, 0x7f, 0x78, 0x8c, 0x02, 0x74, 0xba, 0x68, 0x4a, 0xd8, |
83 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 83 | 0x72, 0x39, 0x19, 0x33, 0x00, 0x07, 0xda, 0xd9, 0x26, 0x0d, 0xe3, 0x39, |
84 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 84 | 0x6a, 0xf3, 0xfa, 0x21, 0xc8, 0xcc, 0xb7, 0x87, 0xb2, 0xd3, 0x62, 0xbe, |
85 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 85 | 0xb0, 0x2f, 0xce, 0xf3, 0x75, 0x00, 0xee, 0x1d, 0xe0, 0xa5, 0x90, 0x26, |
86 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 86 | 0x78, 0x95, 0xa0, 0xec, 0x84, 0x02, 0x79, 0xc2, 0x53, 0xd0, 0x2d, 0x0d, |
87 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 87 | 0xfc, 0x35, 0xb2, 0xfa, 0x14, 0xca, 0x59, 0x9b, 0x28, 0x6f, 0xa0, 0x5d, |
88 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 88 | 0xbc, 0xa0, 0x26, 0xed, 0x66, 0x4a, 0x69, 0x61, 0xec, 0x5f, 0xc8, 0x0a, |
89 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 89 | 0x8d, 0xe1, 0x1b, 0xd5, 0x62, 0x98, 0x9f, 0x61, 0xef, 0xc3, 0x82, 0xfe, |
90 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 90 | 0x4d, 0xf1, 0xfd, 0x74, 0x69, 0x22, 0xaf, 0x26, 0x4b, 0xed, 0xe4, 0x9b, |
91 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 91 | 0x89, 0x40, 0x9a, 0xc7, 0xd5, 0xd4, 0x19, 0x8d, 0xfc, 0x93, 0x0a, 0x41, |
92 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 92 | 0x3e, 0x0c, 0x5f, 0xfc, 0xb8, 0xba, 0xb3, 0x74, 0x41, 0x4d, 0x95, 0xf8, |
93 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 93 | 0x1b, 0xc0, 0x16, 0x55, 0xd0, 0x96, 0xdf, 0xb7, 0x83, 0x96, 0x34, 0xac, |
94 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 94 | 0xc6, 0x75, 0x3d, 0x51, 0x64, 0x99, 0xe5, 0x6f, 0xc1, 0x0f, 0xec, 0xe5, |
95 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 95 | 0x9c, 0x0d, 0xfe, 0x08, 0x7e, 0x85, 0xc1, 0xaf, 0x6f, 0x82, 0x5f, 0xfd, |
96 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 96 | 0xe0, 0x53, 0x8c, 0xde, 0x28, 0xf5, 0xd2, 0x6b, 0xa5, 0x1e, 0x7a, 0x15, |
97 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 97 | 0x32, 0xf9, 0x4a, 0x29, 0x4c, 0x2f, 0x97, 0x3a, 0xe8, 0xa5, 0x52, 0x88, |
98 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 98 | 0xce, 0x0b, 0x1e, 0xa6, 0x21, 0xff, 0x82, 0xaf, 0xfa, 0x26, 0xf0, 0xa4, |
99 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 99 | 0x1d, 0x3c, 0x59, 0x0f, 0x79, 0xd9, 0x08, 0xf9, 0x9b, 0xee, 0xd6, 0x69, |
100 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 100 | 0xaa, 0x9b, 0x12, 0x41, 0xf4, 0x6f, 0x89, 0x6b, 0x82, 0x4e, 0x1a, 0xc6, |
101 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 101 | 0xc7, 0x26, 0xfc, 0x94, 0x32, 0x4e, 0xd3, 0x7b, 0x93, 0x1a, 0x8d, 0x95, |
102 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 102 | 0xa6, 0x36, 0x3a, 0x7c, 0xe3, 0xf6, 0x2c, 0x5d, 0x44, 0x5f, 0xca, 0x98, |
103 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 103 | 0xa5, 0x4b, 0xdb, 0x54, 0x1a, 0x9d, 0xfe, 0x1b, 0x4a, 0x9e, 0x39, 0x4d, |
104 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 104 | 0x3f, 0xfe, 0x3a, 0x51, 0x06, 0x34, 0x51, 0xfb, 0x7e, 0x5a, 0x4e, 0x18, |
105 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 105 | 0xa0, 0x45, 0x5f, 0xaf, 0x90, 0x08, 0xb5, 0x8f, 0x79, 0x19, 0x86, 0xae, |
106 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 106 | 0x68, 0x4a, 0xca, 0x7e, 0x01, 0xfa, 0xd2, 0xaa, 0x24, 0xa7, 0x88, 0x72, |
107 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 107 | 0x53, 0x65, 0xca, 0xc5, 0xfc, 0xf4, 0x98, 0x51, 0xa6, 0x74, 0xac, 0x89, |
108 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 108 | 0xbe, 0x68, 0xb4, 0xd3, 0x68, 0xef, 0x6f, 0xf8, 0xdc, 0x5c, 0x65, 0xba, |
109 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 109 | 0xd4, 0x8f, 0x77, 0xee, 0x23, 0x9a, 0x12, 0xef, 0x4e, 0x7f, 0xbe, 0xe4, |
110 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 110 | 0xa7, 0x84, 0x99, 0x0f, 0x69, 0xf4, 0x8e, 0xcf, 0xc1, 0x29, 0xe1, 0x8e, |
111 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 111 | 0x81, 0x57, 0xc3, 0xb0, 0x0f, 0x8e, 0x0c, 0x66, 0x27, 0xd6, 0x5c, 0x4b, |
112 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 112 | 0x88, 0x6e, 0xc0, 0x0b, 0xd9, 0xd3, 0x18, 0x8f, 0x61, 0x25, 0x6e, 0x52, |
113 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 113 | 0xa7, 0xd0, 0x8d, 0x7e, 0xc0, 0x0c, 0x28, 0xfb, 0x4a, 0xcc, 0x6b, 0xbc, |
114 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 114 | 0x17, 0x19, 0xd7, 0xcd, 0x80, 0xd5, 0xf0, 0x4c, 0x48, 0x9c, 0xbd, 0x78, |
115 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 115 | 0xf2, 0x5c, 0x8c, 0x27, 0x3f, 0x7f, 0xcf, 0x83, 0xe7, 0xe7, 0x2b, 0xef, |
116 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 116 | 0x53, 0x9e, 0xf7, 0x7c, 0xe9, 0x4f, 0x03, 0x0e, 0x7e, 0x4c, 0xcf, 0x01, |
117 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 117 | 0x1a, 0x9d, 0x38, 0x2c, 0xd7, 0xc2, 0x7b, 0x91, 0xd7, 0x38, 0x0d, 0x3a, |
118 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 118 | 0x09, 0xc8, 0x15, 0xd6, 0x3a, 0xec, 0x59, 0xeb, 0x49, 0xcf, 0x5a, 0x4f, |
119 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 119 | 0x7a, 0xd6, 0xca, 0x83, 0xb6, 0xb4, 0x4e, 0xb5, 0xfc, 0xd0, 0x51, 0xee, |
120 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 120 | 0x39, 0x8e, 0x39, 0x9f, 0x03, 0x5f, 0xbe, 0x0a, 0x98, 0x38, 0x2d, 0xda, |
121 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 121 | 0xa0, 0xc7, 0x94, 0x46, 0x7b, 0x4d, 0x7e, 0x7f, 0xb1, 0xd5, 0xc1, 0x8b, |
122 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 122 | 0xdf, 0x2f, 0x48, 0x9c, 0x5a, 0x1d, 0xb8, 0xd2, 0x15, 0xa1, 0xff, 0xf3, |
123 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 123 | 0x25, 0xd6, 0x4f, 0x8a, 0xf9, 0x2c, 0x3a, 0x94, 0x8e, 0xb5, 0xd3, 0x98, |
124 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 124 | 0xa1, 0xc4, 0x46, 0x7b, 0x9a, 0x99, 0x8e, 0x09, 0xd5, 0x6a, 0x85, 0x0e, |
125 | 0x10000003, 0x00000000, 0x0000000d, 0x0000000d, 0x3c020800, 0x24425840, | 125 | 0x50, 0x58, 0x65, 0xdb, 0x25, 0xf0, 0x7b, 0x49, 0xe2, 0x61, 0x70, 0x3b, |
126 | 0x3c030800, 0x246358e8, 0xac400000, 0x0043202b, 0x1480fffd, 0x24420004, | 126 | 0xa3, 0x5a, 0xc1, 0xba, 0x7e, 0x96, 0xdf, 0x57, 0xf0, 0xce, 0x32, 0x9c, |
127 | 0x3c1d0800, 0x37bd7ffc, 0x03a0f021, 0x3c100800, 0x261008b4, 0x3c1c0800, | 127 | 0xd4, 0x9c, 0xb5, 0x5f, 0x45, 0x9b, 0xed, 0xce, 0x66, 0xd9, 0x76, 0xc7, |
128 | 0x279c5840, 0x0e0002f7, 0x00000000, 0x0000000d, 0x27bdffe8, 0x3c1a8000, | 128 | 0xff, 0xa0, 0xa9, 0xb6, 0xfd, 0x05, 0xb3, 0xb6, 0xed, 0xea, 0x82, 0xd7, |
129 | 0x3c020008, 0x0342d825, 0x3c036010, 0xafbf0010, 0x8c655000, 0x3c020800, | 129 | 0x66, 0xf1, 0xde, 0xc2, 0xe4, 0xb3, 0x58, 0x8e, 0xfc, 0xc0, 0x35, 0x06, |
130 | 0x24470f30, 0x3c040800, 0x24865860, 0x2402ff7f, 0x00a22824, 0x34a5380c, | 130 | 0x3d, 0x6c, 0x96, 0x38, 0x7c, 0x4b, 0xe2, 0x00, 0x5c, 0x01, 0x37, 0x5a, |
131 | 0xac655000, 0x00002821, 0x24020037, 0x24030c80, 0xaf420008, 0xaf430024, | 131 | 0xe2, 0x6f, 0x04, 0x4b, 0xea, 0xda, 0x4c, 0x43, 0xf7, 0x7d, 0xad, 0x18, |
132 | 0xacc70000, 0x24a50001, 0x2ca20016, 0x1440fffc, 0x24c60004, 0x24845860, | 132 | 0xbf, 0xec, 0xe3, 0x75, 0xdc, 0x27, 0x29, 0x69, 0xe8, 0xc9, 0xd8, 0xb4, |
133 | 0x3c020800, 0x24420f3c, 0x3c030800, 0x24630e2c, 0xac820004, 0x3c020800, | 133 | 0x46, 0xd9, 0xd8, 0x26, 0x21, 0xd7, 0xd9, 0x58, 0xd5, 0x06, 0x8c, 0x4e, |
134 | 0x24420a2c, 0x3c050800, 0x24a51268, 0xac82000c, 0x3c020800, 0x244243dc, | 134 | 0xd4, 0xdb, 0x00, 0xfe, 0x8e, 0x6d, 0x80, 0xa3, 0xfb, 0x63, 0xd3, 0x6c, |
135 | 0xac830008, 0x3c030800, 0x24633698, 0xac820014, 0x3c020800, 0x24423c24, | 135 | 0x0b, 0x1c, 0xdd, 0x3f, 0x36, 0xc1, 0x36, 0x41, 0xcc, 0x09, 0xfd, 0x67, |
136 | 0xac830018, 0xac83001c, 0x3c030800, 0x24630f44, 0xac820024, 0x3c020800, | 136 | 0x3b, 0xe0, 0xda, 0x00, 0xfe, 0x86, 0x6d, 0x80, 0x0f, 0xf2, 0xcd, 0xf3, |
137 | 0x244243ac, 0xac83002c, 0x3c030800, 0x246343cc, 0xac820030, 0x3c020800, | 137 | 0xb9, 0x6b, 0x8f, 0xd7, 0xcd, 0x3b, 0xce, 0xb6, 0x45, 0xd9, 0xd9, 0xcd, |
138 | 0x244242f0, 0xac830034, 0x3c030800, 0x24633d78, 0xac82003c, 0x3c020800, | 138 | 0x30, 0xc7, 0xb1, 0x76, 0x80, 0x0a, 0xd3, 0xcc, 0xc3, 0x48, 0xe8, 0x08, |
139 | 0x24420fd4, 0xac850010, 0xac850020, 0xac830040, 0x0e0010b7, 0xac820050, | 139 | 0x1d, 0x17, 0x36, 0xef, 0xf4, 0x04, 0x25, 0x0e, 0x9e, 0x18, 0xa0, 0x34, |
140 | 0x8fbf0010, 0x03e00008, 0x27bd0018, 0x27bdffe0, 0xafb00010, 0x27500100, | 140 | 0x6c, 0xc0, 0xdc, 0xc4, 0xb5, 0x32, 0xf8, 0x78, 0x47, 0x13, 0x59, 0xb0, |
141 | 0xafbf0018, 0xafb10014, 0x9203000b, 0x24020003, 0x1462005b, 0x96110008, | 141 | 0x75, 0xf0, 0x93, 0xfd, 0x7e, 0xf2, 0xc5, 0xe3, 0x90, 0xb7, 0x98, 0xf0, |
142 | 0x32220001, 0x10400009, 0x27430080, 0x8e020000, 0x96040014, 0x000211c2, | 142 | 0x5d, 0xd5, 0x9f, 0xa6, 0xed, 0xaa, 0x69, 0x37, 0xc1, 0x3f, 0x62, 0xde, |
143 | 0x00021040, 0x00621821, 0xa4640000, 0x0a0002d0, 0x3c020800, 0x3c020800, | 143 | 0xfe, 0x98, 0x90, 0x4d, 0xef, 0x2f, 0x09, 0x1b, 0x94, 0x8c, 0x7d, 0x08, |
144 | 0x8c430020, 0x1060002a, 0x3c030800, 0x0e00148e, 0x00000000, 0x97420108, | 144 | 0xf9, 0x75, 0x69, 0xe4, 0xea, 0x1f, 0xdb, 0xfa, 0x2b, 0x1e, 0x1f, 0xb2, |
145 | 0x8f850018, 0x9743010c, 0x3042003e, 0x00021400, 0x00621825, 0xaca30000, | 145 | 0x05, 0x76, 0xdf, 0x84, 0x3c, 0xb9, 0x76, 0x9f, 0xed, 0x71, 0x88, 0x6d, |
146 | 0x8f840018, 0x8f420100, 0xac820004, 0x97430116, 0x9742010e, 0x8f840018, | 146 | 0x26, 0xf4, 0x8d, 0x6d, 0x70, 0x80, 0xd4, 0x19, 0x4d, 0xda, 0x69, 0x5d, |
147 | 0x00031c00, 0x00431025, 0xac820008, 0x97430110, 0x97440112, 0x8f850018, | 147 | 0xda, 0xe9, 0x00, 0x6c, 0x34, 0xb7, 0x0d, 0xd9, 0x36, 0x45, 0x1b, 0xf6, |
148 | 0x00031c00, 0x00832025, 0xaca4000c, 0x97420114, 0x8f840018, 0x3042ffff, | 148 | 0x1a, 0xf6, 0x70, 0x77, 0x3a, 0x35, 0xc1, 0xfe, 0x10, 0xbe, 0x7b, 0x86, |
149 | 0xac820010, 0x8f830018, 0xac600014, 0x8f820018, 0x3c030800, 0xac400018, | 149 | 0x75, 0xf8, 0xdb, 0x43, 0x23, 0xd3, 0xc2, 0x07, 0xb0, 0xff, 0x80, 0x65, |
150 | 0x946258ce, 0x8f840018, 0x3c032000, 0x00431025, 0xac82001c, 0x0e0014cc, | 150 | 0x66, 0x1b, 0xce, 0xb6, 0x1c, 0xfb, 0x2e, 0x62, 0xdd, 0x8a, 0xad, 0x64, |
151 | 0x24040001, 0x3c030800, 0x8c620040, 0x24420001, 0xac620040, 0x3c020800, | 151 | 0x39, 0xf1, 0xe2, 0xc5, 0x38, 0xad, 0x21, 0xf5, 0xa4, 0x43, 0x6b, 0x35, |
152 | 0x8c430044, 0x32240004, 0x24630001, 0x10800017, 0xac430044, 0x8f4202b8, | 152 | 0xfe, 0xa8, 0x46, 0x2d, 0x4c, 0x63, 0xc6, 0x7f, 0x2b, 0x70, 0xe6, 0x7d, |
153 | 0x04430007, 0x8e020020, 0x3c040800, 0x8c830060, 0x24020001, 0x24630001, | 153 | 0xfd, 0x4f, 0xe0, 0xcc, 0xeb, 0xd6, 0xe3, 0x4d, 0x7a, 0x6b, 0xfc, 0xac, |
154 | 0x0a0002f2, 0xac830060, 0x3c060800, 0x8cc4005c, 0xaf420280, 0x96030016, | 154 | 0xfe, 0xf0, 0x33, 0xa4, 0x37, 0xc7, 0xcf, 0xd2, 0xbf, 0x58, 0x74, 0x9f, |
155 | 0x00001021, 0xa7430284, 0x8e050004, 0x24840001, 0x3c031000, 0xaf450288, | 155 | 0x0e, 0x3f, 0xdb, 0xad, 0xc0, 0xcf, 0x16, 0xa1, 0xef, 0x53, 0x3a, 0x1d, |
156 | 0xaf4302b8, 0x0a0002f2, 0xacc4005c, 0x32220002, 0x0a0002f2, 0x0002102b, | 156 | 0x3c, 0x15, 0xc9, 0xfc, 0x2b, 0x45, 0x61, 0x3f, 0x76, 0xd0, 0xc8, 0x94, |
157 | 0x3c026000, 0xac400808, 0x0000000d, 0x00001021, 0x8fbf0018, 0x8fb10014, | 157 | 0x42, 0x7a, 0x17, 0xb5, 0xc3, 0x7f, 0xf4, 0x37, 0x61, 0xfe, 0x5d, 0x44, |
158 | 0x8fb00010, 0x03e00008, 0x27bd0020, 0x27bdffc8, 0xafbf0034, 0xafbe0030, | 158 | 0x9b, 0x1d, 0xbf, 0xd9, 0x15, 0x1e, 0x05, 0xff, 0xd3, 0x2f, 0x7e, 0x05, |
159 | 0xafb7002c, 0xafb60028, 0xafb50024, 0xafb40020, 0xafb3001c, 0xafb20018, | 159 | 0xdf, 0x3c, 0x4d, 0x07, 0xa7, 0x0e, 0x2b, 0x39, 0xfb, 0x08, 0xe0, 0x97, |
160 | 0xafb10014, 0x0e000244, 0xafb00010, 0x3c170800, 0x3c160800, 0x24110020, | 160 | 0x83, 0xd5, 0x01, 0x9b, 0x07, 0xec, 0x97, 0x31, 0xef, 0xd3, 0xa4, 0xdf, |
161 | 0x24150030, 0x2794000c, 0x27930008, 0x3c124000, 0x3c1e0800, 0x8f820004, | 161 | 0x1e, 0x19, 0x48, 0x28, 0xc0, 0xe3, 0x45, 0x01, 0x2f, 0x7d, 0x71, 0x97, |
162 | 0x3c040800, 0x8c830020, 0x10430005, 0x8ee200a4, 0xaf830004, 0x0e001593, | 162 | 0xb1, 0x53, 0xf0, 0x3f, 0x40, 0xef, 0x15, 0x2f, 0x80, 0xbe, 0xbd, 0xf0, |
163 | 0x00000000, 0x8ee200a4, 0x8ec300a0, 0x10430004, 0x26c400a0, 0x94820002, | 163 | 0x39, 0x91, 0x67, 0x61, 0x93, 0xe1, 0x8f, 0x22, 0x57, 0x31, 0x2d, 0x7c, |
164 | 0xa742009e, 0xaee300a4, 0x8f500000, 0x32020007, 0x1040ffee, 0x32020001, | 164 | 0x11, 0x29, 0x0f, 0x76, 0xa7, 0x41, 0xef, 0x38, 0xfc, 0xd3, 0x00, 0xfc, |
165 | 0x1040002c, 0x32020002, 0x8f420100, 0xaf420020, 0x8f430104, 0xaf4300a8, | 165 | 0x53, 0x0c, 0xbe, 0xa9, 0x07, 0x7e, 0xc9, 0x82, 0x5f, 0x0a, 0x83, 0x1f, |
166 | 0x9342010b, 0x93630000, 0x306300ff, 0x10710005, 0x304400ff, 0x10750006, | 166 | 0x06, 0xcd, 0xc2, 0x47, 0xcd, 0x42, 0xfe, 0xe7, 0x66, 0x48, 0x19, 0x04, |
167 | 0x2c820016, 0x0a000333, 0x00000000, 0xaf940000, 0x0a000334, 0x2c820016, | 167 | 0xad, 0xcf, 0xc1, 0x3f, 0x26, 0x63, 0x77, 0x42, 0xcf, 0x22, 0x17, 0x66, |
168 | 0xaf930000, 0x0a000334, 0x00000000, 0xaf800000, 0x14400005, 0x00041880, | 168 | 0xd5, 0x41, 0xca, 0xc1, 0x9f, 0x77, 0x6e, 0x8b, 0x62, 0xbd, 0x26, 0x4a, |
169 | 0x0e0003cc, 0x00000000, 0x0a000340, 0x00000000, 0x3c020800, 0x24425860, | 169 | 0x84, 0x5c, 0x1d, 0xe5, 0xdf, 0x7e, 0x85, 0xac, 0x7f, 0x06, 0xef, 0x22, |
170 | 0x00621821, 0x8c620000, 0x0040f809, 0x00000000, 0x10400005, 0x3c030800, | 170 | 0x61, 0xa2, 0x3d, 0x94, 0xb5, 0xa3, 0x46, 0xa7, 0xda, 0x03, 0x18, 0x6e, |
171 | 0x8f420104, 0x3c016020, 0xac220014, 0x3c030800, 0x8c620034, 0xaf520138, | 171 | 0x87, 0x95, 0x03, 0x53, 0x11, 0x05, 0xfb, 0x03, 0xcd, 0x27, 0x60, 0xeb, |
172 | 0x24420001, 0xac620034, 0x32020002, 0x1040001a, 0x32020004, 0x8f420140, | 172 | 0xcb, 0x34, 0x1e, 0x63, 0x3d, 0x29, 0xd3, 0xf3, 0xb1, 0xc8, 0x40, 0x9e, |
173 | 0xaf420020, 0x93630000, 0x306300ff, 0x10710005, 0x00000000, 0x10750006, | 173 | 0x5a, 0xe9, 0x98, 0x39, 0x21, 0x7c, 0xbc, 0x16, 0x3f, 0x21, 0x74, 0x2c, |
174 | 0x00000000, 0x0a00035d, 0x00000000, 0xaf940000, 0x0a00035e, 0x00000000, | 174 | 0x67, 0xe1, 0x59, 0xec, 0x54, 0xb2, 0x53, 0xbc, 0x7e, 0x14, 0x5a, 0xee, |
175 | 0xaf930000, 0x0a00035e, 0x00000000, 0xaf800000, 0x0e000c7b, 0x00000000, | 175 | 0xc7, 0x93, 0xe7, 0x07, 0xdd, 0xfa, 0x49, 0x39, 0xd8, 0x9d, 0x87, 0x77, |
176 | 0x3c040800, 0x8c820038, 0xaf520178, 0x24420001, 0xac820038, 0x32020004, | 176 | 0x88, 0x18, 0x8b, 0x58, 0x39, 0x35, 0x11, 0x0d, 0x45, 0x55, 0x8d, 0x86, |
177 | 0x1040ffa4, 0x00000000, 0x8f420180, 0xaf420020, 0x93630000, 0x306300ff, | 177 | 0x35, 0x85, 0x46, 0x61, 0x6f, 0xd2, 0xb1, 0xff, 0x2c, 0x1f, 0x33, 0x79, |
178 | 0x10710005, 0x00000000, 0x10750006, 0x00000000, 0x0a000378, 0x00000000, | 178 | 0xbc, 0x99, 0xbe, 0x2a, 0xfc, 0x0d, 0xd6, 0x2e, 0x4c, 0x63, 0x5d, 0x3f, |
179 | 0xaf940000, 0x0a000379, 0x00000000, 0xaf930000, 0x0a000379, 0x00000000, | 179 | 0xf8, 0xcb, 0xeb, 0xf2, 0x3c, 0x68, 0xc3, 0xf6, 0x6b, 0x56, 0xe4, 0xd9, |
180 | 0xaf800000, 0x8f430180, 0x24020f00, 0x14620005, 0x00000000, 0x8f420188, | 180 | 0x3c, 0xed, 0x00, 0x6d, 0xd9, 0x66, 0xc1, 0x3e, 0x0c, 0x60, 0xed, 0x5e, |
181 | 0xa742009c, 0x0a000387, 0x8fc2003c, 0x93620000, 0x14510004, 0x8fc2003c, | 181 | 0xd8, 0x4f, 0x3c, 0x93, 0xbd, 0x1c, 0x07, 0x05, 0x68, 0xd8, 0x64, 0x79, |
182 | 0x0e000bad, 0x00000000, 0x8fc2003c, 0xaf5201b8, 0x24420001, 0x0a00030b, | 182 | 0xd4, 0xe5, 0x98, 0xe9, 0x19, 0xf3, 0xcb, 0xb1, 0x20, 0xfe, 0xe0, 0x7f, |
183 | 0xafc2003c, 0x27bdffe8, 0xafbf0010, 0x97420108, 0x24033000, 0x30447000, | 183 | 0x4d, 0x96, 0x19, 0x6e, 0x73, 0x4c, 0xc6, 0x34, 0x09, 0xd3, 0xdc, 0x64, |
184 | 0x10830016, 0x28823001, 0x10400007, 0x24024000, 0x1080000b, 0x24022000, | 184 | 0x02, 0x34, 0x8b, 0x9c, 0x4d, 0x10, 0xd3, 0x0c, 0x46, 0x7b, 0x7f, 0x82, |
185 | 0x1082000c, 0x00000000, 0x0a0003b3, 0x00000000, 0x10820010, 0x24025000, | 185 | 0xbe, 0x64, 0xaf, 0xf7, 0x3b, 0xb6, 0xb0, 0x55, 0x49, 0xc1, 0x17, 0xa8, |
186 | 0x10820012, 0x00000000, 0x0a0003b3, 0x00000000, 0x0000000d, 0x0a0003b5, | 186 | 0x56, 0x0b, 0x7c, 0x45, 0x98, 0x5e, 0x15, 0xb0, 0x64, 0xa8, 0xf1, 0x68, |
187 | 0x00001021, 0x0e000442, 0x00000000, 0x0a0003b6, 0x8fbf0010, 0x0e00041a, | 187 | 0xe8, 0x4b, 0x74, 0xab, 0xb0, 0x11, 0x09, 0xc3, 0x4b, 0xe3, 0xff, 0x52, |
188 | 0x00000000, 0x0a0003b5, 0x00001021, 0x0e000669, 0x00000000, 0x0a0003b5, | 188 | 0xc9, 0x72, 0xbf, 0x69, 0xa5, 0xec, 0x20, 0xf3, 0x89, 0xd7, 0x33, 0x68, |
189 | 0x00001021, 0x0e001467, 0x00000000, 0x0a0003b5, 0x00001021, 0x0000000d, | 189 | 0xae, 0xe4, 0xbc, 0xfb, 0x10, 0xa3, 0x16, 0x60, 0x6b, 0xce, 0x4f, 0xaa, |
190 | 0x00001021, 0x8fbf0010, 0x03e00008, 0x27bd0018, 0x93620000, 0x24030020, | 190 | 0xf4, 0xf8, 0x1d, 0xf0, 0x65, 0xb1, 0x6d, 0x58, 0xcb, 0xc4, 0x78, 0x1e, |
191 | 0x304400ff, 0x10830005, 0x24020030, 0x10820007, 0x00000000, 0x0a0003c9, | 191 | 0x6d, 0x15, 0x6d, 0xe8, 0x99, 0x11, 0x02, 0x8f, 0xb9, 0x9f, 0xe1, 0x4c, |
192 | 0x00000000, 0x2782000c, 0xaf820000, 0x03e00008, 0x00000000, 0x27820008, | 192 | 0xfc, 0xbd, 0xcf, 0xb1, 0x75, 0x3e, 0xab, 0xde, 0x4a, 0x14, 0x64, 0x7a, |
193 | 0xaf820000, 0x03e00008, 0x00000000, 0xaf800000, 0x03e00008, 0x00000000, | 193 | 0xc5, 0x40, 0x2b, 0xcb, 0x50, 0xd5, 0x6d, 0xc2, 0x5f, 0x3b, 0xb6, 0xc4, |
194 | 0x0000000d, 0x03e00008, 0x00001021, 0x03e00008, 0x00001021, 0x27440100, | 194 | 0x82, 0x2e, 0xc2, 0xe6, 0xf6, 0x79, 0x75, 0x91, 0xe3, 0x09, 0x57, 0x17, |
195 | 0x94830008, 0x30620004, 0x10400017, 0x30620002, 0x8f4202b8, 0x04430007, | 195 | 0x23, 0xa1, 0x84, 0x0a, 0x5b, 0xdc, 0xa7, 0xd1, 0x09, 0xd1, 0x56, 0x28, |
196 | 0x8c820020, 0x3c040800, 0x8c830060, 0x24020001, 0x24630001, 0x03e00008, | 196 | 0x31, 0x18, 0x09, 0x2d, 0xa8, 0x1c, 0x4b, 0x33, 0x6c, 0x18, 0xf1, 0x4a, |
197 | 0xac830060, 0xaf420280, 0x94830016, 0x3c060800, 0xa7430284, 0x8c850004, | 197 | 0x40, 0xc2, 0x22, 0x9e, 0xb3, 0xdd, 0x98, 0x30, 0x84, 0x7e, 0x53, 0xf4, |
198 | 0x8cc4005c, 0x00001021, 0x3c031000, 0x24840001, 0xaf450288, 0xaf4302b8, | 198 | 0x1f, 0xab, 0xe8, 0xa8, 0x13, 0xff, 0xa9, 0x88, 0x11, 0x0b, 0x88, 0x11, |
199 | 0x03e00008, 0xacc4005c, 0x14400003, 0x3c040800, 0x03e00008, 0x00001021, | 199 | 0x53, 0x42, 0x47, 0x8d, 0x04, 0x72, 0x04, 0xd0, 0xdc, 0xd1, 0xcf, 0x42, |
200 | 0x8c830084, 0x24020001, 0x24630001, 0x03e00008, 0xac830084, 0x27450100, | 200 | 0x91, 0x71, 0xc9, 0xb1, 0x5c, 0x0e, 0x00, 0x99, 0x13, 0x8e, 0x7d, 0xa4, |
201 | 0x3c040800, 0x8c820088, 0x94a3000c, 0x24420001, 0x007a1821, 0xac820088, | 201 | 0x3c, 0xc7, 0x91, 0xa3, 0xea, 0x53, 0x34, 0x5c, 0x60, 0x3f, 0x8e, 0x3f, |
202 | 0x8ca40018, 0x90664000, 0xaf440038, 0x8ca2001c, 0x2403fff8, 0x00063600, | 202 | 0x9b, 0x6d, 0x2d, 0xec, 0xa3, 0xf0, 0xc5, 0x51, 0xf0, 0x39, 0x0f, 0x1a, |
203 | 0x00431024, 0x34420004, 0x3c030005, 0xaf42003c, 0xaf430030, 0x00000000, | 203 | 0xac, 0x97, 0x74, 0xdd, 0x4f, 0x07, 0xec, 0x3d, 0xa0, 0x79, 0x9c, 0x46, |
204 | 0x00000000, 0x00000000, 0xaf460404, 0x00000000, 0x00000000, 0x00000000, | 204 | 0x4e, 0x8d, 0xb0, 0xcc, 0xf6, 0x14, 0x28, 0xd2, 0x73, 0x8c, 0xb6, 0x1b, |
205 | 0x3c020006, 0x34420001, 0xaf420030, 0x00000000, 0x00000000, 0x00000000, | 205 | 0x73, 0x2c, 0xdf, 0x83, 0xe5, 0x1d, 0xe0, 0x85, 0xd0, 0x51, 0xc8, 0x20, |
206 | 0x8f420000, 0x30420010, 0x1040fffd, 0x00001021, 0x03e00008, 0x00000000, | 206 | 0x65, 0x0b, 0x23, 0xf4, 0x58, 0x89, 0xfb, 0xf2, 0xa0, 0x1d, 0xe2, 0xda, |
207 | 0x3c020800, 0x8c430020, 0x27bdffe8, 0xafb00010, 0x27500100, 0x1060001e, | 207 | 0xfe, 0xfd, 0x52, 0xce, 0x31, 0x9f, 0xe6, 0xce, 0x37, 0x22, 0xe7, 0x63, |
208 | 0xafbf0014, 0x0e00148e, 0x00000000, 0x8f830018, 0x8e020018, 0xac620000, | 208 | 0x38, 0x86, 0xe1, 0x6f, 0xaa, 0xf3, 0xee, 0x14, 0x3c, 0x8d, 0x18, 0x5d, |
209 | 0x8f840018, 0x9602000c, 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, | 209 | 0x6a, 0x79, 0x87, 0x1f, 0xe3, 0xcf, 0xf7, 0xf3, 0x3b, 0xe6, 0x81, 0xef, |
210 | 0xac40000c, 0x8f830018, 0xac600010, 0x8f820018, 0xac400014, 0x8f840018, | 210 | 0x6f, 0xb6, 0xf6, 0x00, 0x76, 0x10, 0x73, 0xfa, 0xa9, 0xb3, 0xdd, 0xc5, |
211 | 0x3c026000, 0x8c434448, 0xac830018, 0x96020008, 0x3c030800, 0x946458ce, | 211 | 0x37, 0x81, 0xb5, 0xd9, 0xcf, 0x31, 0x9f, 0x1f, 0xa1, 0xec, 0xa9, 0x7c, |
212 | 0x8f850018, 0x00021400, 0x00441025, 0x24040001, 0x0e0014cc, 0xaca2001c, | 212 | 0x8f, 0x0a, 0x19, 0x9b, 0xcd, 0x28, 0xe4, 0xb7, 0x1e, 0xa6, 0xdc, 0xa9, |
213 | 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x27bdffe8, 0xafb00010, | 213 | 0xa3, 0x6c, 0x37, 0x40, 0xab, 0x3d, 0xb4, 0x6b, 0x22, 0xd2, 0x73, 0x80, |
214 | 0x27500100, 0xafbf0014, 0x92020009, 0x14400003, 0x3c020800, 0x0a00046c, | 214 | 0x34, 0xb1, 0xce, 0x5b, 0x24, 0xe8, 0x1f, 0x9b, 0x15, 0xbe, 0x20, 0x43, |
215 | 0x24020001, 0x8c430020, 0x1060001f, 0x00001021, 0x0e00148e, 0x00000000, | 215 | 0xe9, 0x89, 0xed, 0xa1, 0x4b, 0xe8, 0x1b, 0x1e, 0x8c, 0x84, 0x17, 0xe8, |
216 | 0x8f830018, 0x8e020018, 0xac620000, 0x8f840018, 0x9602000c, 0xac820004, | 216 | 0x09, 0xd0, 0xe5, 0x23, 0xf8, 0x22, 0xab, 0x67, 0x0c, 0x3a, 0x84, 0x9c, |
217 | 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, | 217 | 0x0a, 0xeb, 0x8f, 0x4a, 0xda, 0xe0, 0xbb, 0xcc, 0x51, 0xd0, 0x8f, 0xf2, |
218 | 0x8f820018, 0xac400014, 0x8f840018, 0x3c026000, 0x8c434448, 0xac830018, | 218 | 0x0e, 0x4d, 0x99, 0x9e, 0x4c, 0xcb, 0xaf, 0xc0, 0xf6, 0x1c, 0x11, 0xb1, |
219 | 0x96020008, 0x3c030800, 0x946458ce, 0x8f850018, 0x00021400, 0x00441025, | 219 | 0x4b, 0x56, 0xd0, 0xee, 0xd2, 0x06, 0x47, 0x0e, 0x60, 0x8b, 0x30, 0xef, |
220 | 0x24040001, 0x0e0014cc, 0xaca2001c, 0x00001021, 0x8fbf0014, 0x8fb00010, | 220 | 0xe5, 0x41, 0x85, 0xb6, 0x20, 0x4e, 0x3f, 0x24, 0x78, 0xeb, 0xa3, 0x7d, |
221 | 0x03e00008, 0x27bd0018, 0x3c0b0800, 0x8d6808b0, 0x3c070800, 0x24e700b0, | 221 | 0x66, 0xd4, 0xd8, 0x47, 0xf3, 0x7e, 0x27, 0x56, 0xc0, 0x3c, 0x3d, 0xf7, |
222 | 0x00084900, 0x01271821, 0xac640000, 0x93620005, 0x97660008, 0x00e95021, | 222 | 0x60, 0x0f, 0x90, 0x53, 0xfb, 0xeb, 0xeb, 0xa8, 0x2d, 0x12, 0x4e, 0xa8, |
223 | 0x93630023, 0x9364003f, 0x25080001, 0x00021600, 0x00063400, 0x00461025, | 223 | 0x09, 0xfa, 0x93, 0xd2, 0xdd, 0xe4, 0xe8, 0x77, 0x2b, 0xdb, 0x7e, 0xf0, |
224 | 0x00031a00, 0x00431025, 0x00822025, 0xad440004, 0x9362007e, 0x9366007f, | 224 | 0xb0, 0xd3, 0x69, 0x5b, 0x78, 0x16, 0x3a, 0xb1, 0x1e, 0xe3, 0xfe, 0xac, |
225 | 0x8f630178, 0x9364007a, 0x00021600, 0x00063400, 0x00461025, 0x00031a00, | 225 | 0xc0, 0x7d, 0x84, 0xba, 0xa1, 0x6b, 0x22, 0x8f, 0x39, 0x51, 0x8b, 0x17, |
226 | 0x00431025, 0x00822025, 0xad440008, 0x93620080, 0x9363007d, 0x3108007f, | 226 | 0xf3, 0xbc, 0x9e, 0xcf, 0x5f, 0xc6, 0x3c, 0xdc, 0xcf, 0x70, 0x78, 0x2f, |
227 | 0x01403821, 0xad6808b0, 0x00021600, 0x00031c00, 0x00431025, 0x00451025, | 227 | 0x3c, 0x41, 0x23, 0x90, 0xc7, 0x5c, 0x7f, 0x57, 0x68, 0x0c, 0xdf, 0xa4, |
228 | 0x03e00008, 0xace2000c, 0x27bdffb8, 0xafb3002c, 0x00009821, 0xafbe0040, | 228 | 0x4a, 0x4d, 0x74, 0x54, 0xe3, 0xf1, 0x48, 0x38, 0xaf, 0x1e, 0x42, 0xdc, |
229 | 0x0000f021, 0xafb50034, 0x27550100, 0xafbf0044, 0xafb7003c, 0xafb60038, | 229 | 0xf3, 0xb8, 0xea, 0xb7, 0x7e, 0xe6, 0x67, 0xbf, 0xe3, 0xb7, 0xae, 0x29, |
230 | 0xafb40030, 0xafb20028, 0xafb10024, 0xafb00020, 0xafa00010, 0xafa00014, | 230 | 0xd5, 0xb9, 0x10, 0x87, 0x8a, 0xdc, 0x60, 0x41, 0x19, 0x2c, 0x5d, 0x52, |
231 | 0x96a20008, 0x8f540100, 0x8eb10018, 0x30420001, 0x10400037, 0x02a0b821, | 231 | 0x92, 0x85, 0x6b, 0x4a, 0xaa, 0xc4, 0x30, 0x8e, 0xce, 0x67, 0xcf, 0x74, |
232 | 0x8f630054, 0x2622ffff, 0x00431023, 0x18400006, 0x00000000, 0x0000000d, | 232 | 0x82, 0x4e, 0x1f, 0x89, 0xef, 0xe6, 0x7a, 0x8f, 0x50, 0xea, 0xd4, 0xad, |
233 | 0x00000000, 0x2400015c, 0x0a0004e5, 0x00002021, 0x8f62004c, 0x02221023, | 233 | 0x94, 0x9e, 0xe6, 0xbc, 0x34, 0x02, 0x7c, 0x3f, 0x2a, 0xe7, 0x62, 0x41, |
234 | 0x18400028, 0x00002021, 0x93650120, 0x93640121, 0x3c030800, 0x8c62008c, | 234 | 0xca, 0x9d, 0xe1, 0x31, 0xb6, 0x5f, 0xd6, 0xd5, 0x45, 0x1f, 0xef, 0x9f, |
235 | 0x308400ff, 0x24420001, 0x30a500ff, 0x00803821, 0x1485000b, 0xac62008c, | 235 | 0xf9, 0x6f, 0x52, 0xc1, 0x7e, 0x53, 0xd2, 0x8f, 0xdf, 0x7d, 0x9c, 0x93, |
236 | 0x3c040800, 0x8c830090, 0x24630001, 0xac830090, 0x93620122, 0x30420001, | 236 | 0xe1, 0xf7, 0x6f, 0x86, 0xd3, 0xb7, 0x95, 0x16, 0x36, 0xdc, 0xc8, 0x3e, |
237 | 0x00021023, 0x30420005, 0x0a0004e5, 0x34440004, 0x27660100, 0x00041080, | 237 | 0x57, 0xb3, 0xc7, 0x47, 0x7d, 0x7e, 0x6b, 0x7b, 0x13, 0xb5, 0x84, 0x80, |
238 | 0x00c21021, 0x8c430000, 0x02231823, 0x04600004, 0x24820001, 0x30440007, | 238 | 0xc3, 0x4a, 0x7b, 0x64, 0x98, 0x5f, 0x87, 0x1c, 0xb0, 0x4d, 0xd9, 0x0d, |
239 | 0x1485fff9, 0x00041080, 0x10870007, 0x3c030800, 0xa3640121, 0x8c620094, | 239 | 0x7e, 0x5a, 0x6c, 0xc3, 0x60, 0x93, 0x76, 0x53, 0xae, 0xc4, 0xb2, 0x1d, |
240 | 0x24040005, 0x24420001, 0x0a0004e5, 0xac620094, 0x24040004, 0x00809821, | 240 | 0x35, 0x32, 0x90, 0xb1, 0x34, 0x75, 0xb1, 0x1e, 0xb9, 0xba, 0x07, 0xdb, |
241 | 0x9362003f, 0x304400ff, 0x38830016, 0x2c630001, 0x38820010, 0x2c420001, | 241 | 0x9d, 0x87, 0xed, 0x46, 0x3c, 0x64, 0x53, 0xbe, 0x29, 0xce, 0x36, 0xbc, |
242 | 0x00621825, 0x1460000c, 0x24020001, 0x38830008, 0x2c630001, 0x38820014, | 242 | 0x0b, 0xb2, 0x85, 0xbe, 0x62, 0x55, 0x17, 0x77, 0x2d, 0xc1, 0x5d, 0x5b, |
243 | 0x2c420001, 0x00621825, 0x14600005, 0x24020001, 0x24020012, 0x14820002, | 243 | 0xc2, 0xa3, 0x02, 0xd5, 0xe2, 0x3f, 0x4b, 0x8c, 0xff, 0x5f, 0x00, 0xff, |
244 | 0x00001021, 0x24020001, 0x10400009, 0x00000000, 0x8ea20020, 0x8f630040, | 244 | 0xcf, 0x01, 0x7f, 0xc6, 0xa9, 0x31, 0xfe, 0x3b, 0x2b, 0xf8, 0x33, 0x0c, |
245 | 0x0040b021, 0x00431023, 0x5c400010, 0x8f760040, 0x0a000511, 0x00000000, | 245 | 0xfc, 0x1c, 0x64, 0xf1, 0x0d, 0xe8, 0xe2, 0x6b, 0x36, 0x7c, 0x9d, 0x0d, |
246 | 0x9343010b, 0x24020004, 0x1462000a, 0x8eb60020, 0x8f630040, 0x3c021000, | 246 | 0xff, 0x67, 0xc3, 0xdf, 0xd9, 0xf0, 0x8b, 0x36, 0x7c, 0x1e, 0xf6, 0x74, |
247 | 0x00761823, 0x0043102a, 0x10400004, 0x00000000, 0x0000000d, 0x00000000, | 247 | 0x0e, 0x36, 0xe9, 0xac, 0x9d, 0x34, 0x58, 0x9f, 0x92, 0x31, 0xf6, 0x9d, |
248 | 0x240002fa, 0x9343010b, 0x24020004, 0x5462000b, 0x96a20008, 0x24020001, | 248 | 0xbb, 0x65, 0xde, 0x1d, 0x92, 0x71, 0xf7, 0xa7, 0x64, 0x2c, 0x7b, 0x00, |
249 | 0xafa20010, 0x96a20008, 0x24030001, 0xafa30018, 0x8eb2001c, 0x36730002, | 249 | 0xb1, 0xec, 0x66, 0x1a, 0xed, 0xe1, 0x9c, 0xa4, 0x05, 0xcf, 0x75, 0x78, |
250 | 0x30420020, 0x0a000526, 0xafa20014, 0x36730080, 0x30420002, 0x10400003, | 250 | 0x22, 0x6e, 0xed, 0x49, 0x48, 0xbd, 0xfc, 0x0c, 0x62, 0x5c, 0xd8, 0xff, |
251 | 0xafa00018, 0x0a000526, 0x8eb2001c, 0x8eb20014, 0x2402fffb, 0x02628024, | 251 | 0x1e, 0xe4, 0x37, 0x19, 0xc4, 0x6a, 0x56, 0x1f, 0xc7, 0xe5, 0xb0, 0x65, |
252 | 0x1200002a, 0x3c030800, 0x8c620030, 0x02021024, 0x10400026, 0x3c020800, | 252 | 0xef, 0x37, 0x39, 0x76, 0xfe, 0x2e, 0x19, 0x03, 0xbb, 0xed, 0x56, 0xc0, |
253 | 0x8c430020, 0x10600024, 0x32620004, 0x0e00148e, 0x00000000, 0x8f830018, | 253 | 0xa4, 0xd1, 0xd7, 0x8a, 0x6f, 0x7e, 0x07, 0xb2, 0xdf, 0x86, 0xf6, 0xce, |
254 | 0x8f420100, 0xac620000, 0x8f840018, 0x02401821, 0x32620002, 0xac900004, | 254 | 0x3a, 0x18, 0xe4, 0xb3, 0x56, 0x16, 0x7d, 0x11, 0xc0, 0xb4, 0x61, 0x9d, |
255 | 0x8f840018, 0x54400001, 0x02c01821, 0xac830008, 0x8f830018, 0x8ee20020, | 255 | 0x0e, 0xb4, 0xf7, 0xa0, 0x7d, 0x8b, 0xb3, 0x8e, 0xf1, 0x2b, 0x68, 0xa7, |
256 | 0xac62000c, 0x8f840018, 0x8f620040, 0xac820010, 0x8f830018, 0x8ee20018, | 256 | 0xea, 0xbe, 0xd9, 0x8a, 0xbe, 0x4c, 0x5d, 0xdf, 0x9b, 0xe8, 0x4b, 0xa2, |
257 | 0xac620014, 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, 0x3c020800, | 257 | 0x6f, 0x51, 0x7e, 0x97, 0x47, 0x3b, 0x52, 0x07, 0xb3, 0x88, 0x3e, 0xc6, |
258 | 0xaca30018, 0x944358ce, 0x8f850018, 0x3c024010, 0x00621825, 0x0e0014cc, | 258 | 0xf1, 0x5b, 0x78, 0xde, 0x47, 0xa3, 0x19, 0x8e, 0x03, 0xdc, 0xb1, 0xdc, |
259 | 0xaca3001c, 0x32620004, 0x10400063, 0x00003821, 0x3c029000, 0x34420001, | 259 | 0x7a, 0x6a, 0xe3, 0xdc, 0xf7, 0x43, 0x21, 0x3b, 0xf3, 0xd2, 0x46, 0xa7, |
260 | 0x3c038000, 0x02821025, 0xa360007c, 0xaf420020, 0x8f420020, 0x00431024, | 260 | 0x27, 0xd8, 0x4f, 0x8c, 0x20, 0xee, 0xe1, 0x71, 0xe1, 0x9c, 0x3c, 0xfd, |
261 | 0x1440fffd, 0x00000000, 0x93620023, 0x30420080, 0x10400011, 0x00000000, | 261 | 0x1f, 0x00, 0xf6, 0x61, 0x8c, 0x21, 0x56, 0xb7, 0xcb, 0x4d, 0x8d, 0xc7, |
262 | 0x8f65005c, 0x8f63004c, 0x9764003c, 0x8f620064, 0x00a32823, 0x00852821, | 262 | 0x1f, 0xc5, 0xf8, 0x5f, 0xca, 0x6f, 0x2b, 0x73, 0x03, 0xfe, 0x1b, 0x75, |
263 | 0x00a2102b, 0x54400006, 0x3c023fff, 0x93620023, 0x3042007f, 0xa3620023, | 263 | 0x7d, 0x6a, 0xb0, 0xb6, 0xbd, 0xd6, 0xf3, 0xbe, 0x4d, 0x5f, 0xfa, 0xfd, |
264 | 0xaf710064, 0x3c023fff, 0x0a000580, 0x3442ffff, 0x8f62005c, 0x02221023, | 264 | 0x48, 0x1d, 0xfc, 0xef, 0x6e, 0xa8, 0x6d, 0x3f, 0xc5, 0xdf, 0x20, 0x87, |
265 | 0x04400011, 0x00000000, 0x8f65005c, 0x8f630064, 0x9764003c, 0x3c023fff, | 265 | 0x70, 0xdb, 0x09, 0xc8, 0x1d, 0xdb, 0xa4, 0xfa, 0x79, 0x3e, 0x6b, 0xd4, |
266 | 0x3442ffff, 0xaf710064, 0x00a32823, 0x00852821, 0x0045102b, 0x10400004, | 266 | 0xf6, 0x6d, 0x32, 0x6b, 0xdb, 0x1c, 0x27, 0x31, 0x5c, 0x08, 0xf2, 0xde, |
267 | 0x02251021, 0x3c053fff, 0x34a5ffff, 0x02251021, 0xaf62005c, 0x24070001, | 267 | 0xa1, 0xec, 0xb2, 0x7f, 0x13, 0xe3, 0x61, 0xe5, 0x5e, 0xdb, 0x8b, 0x67, |
268 | 0xaf71004c, 0x8f620054, 0x16220005, 0x00000000, 0x93620023, 0x30420040, | 268 | 0x48, 0xe6, 0x46, 0xe1, 0x4a, 0xcc, 0x3b, 0x5f, 0x0a, 0x40, 0xae, 0x3e, |
269 | 0x10400017, 0x24020001, 0x9762006a, 0x00022880, 0x50a00001, 0x24050001, | 269 | 0x0f, 0x9e, 0x73, 0xdc, 0x53, 0xd5, 0xf1, 0xf7, 0x68, 0x39, 0x1d, 0x67, |
270 | 0x97630068, 0x93640081, 0x3c020800, 0x8c46004c, 0x00652821, 0x00852804, | 270 | 0x1f, 0xc0, 0x31, 0xfe, 0x36, 0x11, 0x1f, 0xfb, 0xe2, 0x4f, 0x70, 0x0c, |
271 | 0x00c5102b, 0x54400001, 0x00a03021, 0x3c020800, 0x8c440050, 0x00c4182b, | 271 | 0xf6, 0xb4, 0xe3, 0x5b, 0x2c, 0xf8, 0x43, 0xb4, 0x4b, 0x7e, 0xc7, 0x6e, |
272 | 0x54600001, 0x00c02021, 0x8f420074, 0x2403fffe, 0x00832824, 0x00a21021, | 272 | 0x22, 0x9f, 0xc8, 0x16, 0xd8, 0x9f, 0xb1, 0x0f, 0x89, 0xc0, 0x4e, 0xb3, |
273 | 0xaf62000c, 0x93620082, 0x30420080, 0x50400001, 0xa3600081, 0x3c028000, | 273 | 0x1f, 0xfd, 0x24, 0x7d, 0xc6, 0x5d, 0xcd, 0x6c, 0xfb, 0x34, 0xeb, 0x05, |
274 | 0x34420001, 0x02821025, 0xaf420020, 0x9363007e, 0x9362007a, 0x10620004, | 274 | 0xc4, 0x0b, 0x1c, 0xe7, 0xb1, 0xed, 0xc6, 0x7b, 0xd1, 0x8d, 0x57, 0xee, |
275 | 0x00000000, 0x0e0013c4, 0x00000000, 0x00403821, 0x54e00001, 0x241e0001, | 275 | 0xd7, 0xc8, 0xaa, 0xfa, 0x11, 0x67, 0x8f, 0x5b, 0x59, 0x37, 0x56, 0xb1, |
276 | 0x8f700040, 0x8f620040, 0x14520003, 0x00521023, 0x0a0005bf, 0x00001021, | 276 | 0xef, 0xc6, 0xb6, 0xed, 0xc7, 0x75, 0xb6, 0xe1, 0xb2, 0xb0, 0x0d, 0x0f, |
277 | 0x28420001, 0x10400041, 0x8fa20010, 0x0e000fae, 0x02402021, 0xaf720040, | 277 | 0x6a, 0x7e, 0xeb, 0xf7, 0x9b, 0x1d, 0x79, 0x6d, 0x6c, 0x1b, 0xee, 0xad, |
278 | 0x9362003e, 0x30420001, 0x1440000b, 0x3c029000, 0x93620022, 0x24420001, | 278 | 0xd8, 0x06, 0x57, 0x5e, 0xbd, 0x79, 0xeb, 0x0f, 0xc0, 0x1b, 0x0b, 0xbc, |
279 | 0xa3620022, 0x93630022, 0x3c020800, 0x8c440098, 0x0064182b, 0x14600027, | 279 | 0xa9, 0xaf, 0xd5, 0x70, 0x8e, 0xe2, 0x87, 0x1f, 0xe2, 0x18, 0x91, 0x73, |
280 | 0x3c020800, 0x3c029000, 0x34420001, 0x02821025, 0xaf420020, 0x3c038000, | 280 | 0xd9, 0x18, 0xe5, 0x62, 0x45, 0xc4, 0x6a, 0x91, 0xd9, 0xd9, 0x4a, 0x8e, |
281 | 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, | 281 | 0xf5, 0x35, 0x69, 0xbb, 0x6b, 0xe2, 0x22, 0x7a, 0xbc, 0x78, 0x09, 0xf8, |
282 | 0x34420001, 0xa362007d, 0x8f640074, 0x34630001, 0x02831825, 0xaf430020, | 282 | 0x73, 0xbc, 0xa5, 0x49, 0x1b, 0xc1, 0xfd, 0xe3, 0x12, 0x47, 0x7e, 0xe7, |
283 | 0x04810006, 0x3c038000, 0x02802021, 0x0e000470, 0x24050273, 0x0a0005f2, | 283 | 0x3a, 0x1e, 0x7c, 0x69, 0xf1, 0x47, 0xe0, 0x15, 0xc7, 0x7d, 0x51, 0x27, |
284 | 0x24050001, 0x8f4201f8, 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, | 284 | 0xde, 0xab, 0x89, 0xa9, 0xd7, 0xf8, 0xc9, 0xe2, 0x78, 0x89, 0x61, 0x74, |
285 | 0xaf5401c0, 0xa34201c4, 0xaf4301f8, 0x24050001, 0x24020001, 0xa7620012, | 285 | 0x19, 0x2f, 0x05, 0x64, 0x5e, 0x63, 0xc8, 0x3c, 0x87, 0x63, 0x6d, 0xae, |
286 | 0xa3600022, 0x0a0005fe, 0x2ca20001, 0x9743007a, 0x9444002a, 0x00002821, | 286 | 0xb1, 0xd6, 0xc7, 0x50, 0x0b, 0x43, 0xc1, 0x6d, 0xcc, 0x13, 0x8e, 0xa1, |
287 | 0x00641821, 0x3063fffe, 0xa7630012, 0x2ca20001, 0x00021023, 0x03c2f024, | 287 | 0xda, 0x28, 0x39, 0xe3, 0xc4, 0x50, 0x4e, 0x9d, 0xcd, 0xcd, 0x71, 0x5c, |
288 | 0x8fa20010, 0x10400004, 0x8fa30014, 0x0e0013c1, 0x00000000, 0x8fa30014, | 288 | 0x5c, 0xd9, 0x0f, 0xef, 0xc0, 0x3e, 0x45, 0x9e, 0x14, 0x74, 0xea, 0x7f, |
289 | 0x10600003, 0x00000000, 0x0e0010eb, 0x00000000, 0x13c0001f, 0x3c029000, | 289 | 0x1a, 0xec, 0xf6, 0x51, 0xf4, 0x8f, 0xba, 0xfd, 0x9e, 0x5c, 0xc3, 0xc5, |
290 | 0x34420001, 0x02821025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, | 290 | 0x85, 0x7d, 0xbd, 0x1b, 0xd3, 0xed, 0x96, 0x31, 0x1d, 0x62, 0x18, 0xdb, |
291 | 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, 0xa362007d, 0x8f640074, | 291 | 0xc9, 0xbb, 0xf6, 0x16, 0x33, 0xe8, 0xe3, 0x75, 0x11, 0x1b, 0x12, 0xc7, |
292 | 0x34630001, 0x02831825, 0xaf430020, 0x04810006, 0x3c038000, 0x02802021, | 292 | 0x49, 0x90, 0xaf, 0xfd, 0x91, 0x50, 0x58, 0xad, 0xc7, 0xab, 0x75, 0xa1, |
293 | 0x0e000470, 0x2405036c, 0x0a00062b, 0x8fa20018, 0x8f4201f8, 0x00431024, | 293 | 0x16, 0xaf, 0x41, 0xf1, 0xdd, 0xf8, 0x92, 0xef, 0x48, 0xc4, 0x92, 0xe3, |
294 | 0x1440fffd, 0x24020002, 0x3c031000, 0xaf5401c0, 0xa34201c4, 0xaf4301f8, | 294 | 0xf6, 0x10, 0xe8, 0xc5, 0xf8, 0xb9, 0xba, 0xe1, 0xc6, 0xc9, 0x8c, 0xd3, |
295 | 0x8fa20018, 0x5040002f, 0x96a20008, 0x8f620048, 0x8f630024, 0x00761821, | 295 | 0x3f, 0x82, 0xc6, 0xbb, 0x15, 0xfe, 0x7e, 0xcc, 0xde, 0x2f, 0xe8, 0x96, |
296 | 0xaf630048, 0x9764003c, 0x00501023, 0x0044102b, 0x10400025, 0x3c029000, | 296 | 0x15, 0xb8, 0x0e, 0x7b, 0x70, 0x1d, 0x91, 0xb8, 0xb2, 0x2e, 0xb0, 0x7e, |
297 | 0x34420001, 0x3c040800, 0x8c830080, 0x8f450100, 0x3c068000, 0x24630001, | 297 | 0x78, 0x6b, 0x9a, 0xa6, 0xd8, 0x1b, 0x70, 0x0e, 0xf3, 0xb9, 0xb9, 0x6a, |
298 | 0x00a21025, 0xac830080, 0xaf420020, 0x8f420020, 0x00461024, 0x1440fffd, | 298 | 0x2d, 0x0c, 0xf9, 0xb6, 0xc1, 0x1f, 0x02, 0xd7, 0xac, 0x88, 0x43, 0x03, |
299 | 0x00000000, 0x9362007d, 0x3c038000, 0x34420004, 0xa362007d, 0x8f640074, | 299 | 0x0b, 0xf5, 0x34, 0x1c, 0xc7, 0x5a, 0x88, 0xdb, 0x81, 0x8f, 0xcb, 0xf3, |
300 | 0x34630001, 0x00a31825, 0xaf430020, 0x04810006, 0x3c038000, 0x00a02021, | 300 | 0x26, 0x89, 0xcf, 0x37, 0xc5, 0xdc, 0x63, 0xa2, 0x06, 0xea, 0xd3, 0x39, |
301 | 0x0e000470, 0x2405038a, 0x0a00065b, 0x96a20008, 0x8f4201f8, 0x00431024, | 301 | 0x77, 0xc9, 0x0a, 0xde, 0x69, 0x92, 0x77, 0x8f, 0x56, 0xf0, 0x73, 0x78, |
302 | 0x1440fffd, 0x24020002, 0x3c031000, 0xaf4501c0, 0xa34201c4, 0xaf4301f8, | 302 | 0x1c, 0x90, 0x74, 0xe5, 0xdc, 0x95, 0x75, 0x5a, 0xf0, 0xa7, 0x9d, 0x73, |
303 | 0x96a20008, 0x8fbf0044, 0x8fbe0040, 0x8fb7003c, 0x8fb60038, 0x8fb50034, | 303 | 0xd3, 0x41, 0x6a, 0x14, 0x23, 0x2f, 0x0c, 0xa9, 0xdb, 0x1c, 0x3a, 0x3a, |
304 | 0x8fb40030, 0x8fb3002c, 0x8fb20028, 0x8fb10024, 0x8fb00020, 0x00021042, | 304 | 0x31, 0xf2, 0xda, 0xba, 0x18, 0xf9, 0xb6, 0x20, 0xc7, 0x5a, 0xc3, 0x50, |
305 | 0x30420001, 0x03e00008, 0x27bd0048, 0x27bdffe0, 0xafbf0018, 0x97420108, | 305 | 0x82, 0x79, 0xf8, 0xba, 0x97, 0x6d, 0xc8, 0x36, 0x70, 0x3d, 0x5f, 0x53, |
306 | 0x24030019, 0x304400ff, 0x10830065, 0x2882001a, 0x1040001a, 0x2882000a, | 306 | 0xbb, 0xec, 0x59, 0xa6, 0xd6, 0x1c, 0x20, 0xdf, 0x0c, 0xfb, 0x0e, 0x0b, |
307 | 0x1040000f, 0x28820008, 0x10400040, 0x24020001, 0x1082003a, 0x28820002, | 307 | 0x79, 0x06, 0x91, 0x36, 0xc9, 0x3a, 0xcb, 0xbe, 0xbd, 0x1a, 0x67, 0xcf, |
308 | 0x50400005, 0x24020006, 0x10800032, 0x3c026000, 0x0a0006fb, 0x00000000, | 308 | 0x51, 0xa3, 0x18, 0xfb, 0x46, 0xfd, 0xfa, 0x79, 0xbf, 0xdf, 0x3a, 0xac, |
309 | 0x1082003d, 0x00000000, 0x0a0006fb, 0x00000000, 0x2402000b, 0x10820044, | 309 | 0x3b, 0x36, 0x73, 0x25, 0xbf, 0xee, 0xc2, 0xed, 0x41, 0x9c, 0xad, 0x50, |
310 | 0x2882000b, 0x1440004b, 0x2402000e, 0x10820045, 0x00000000, 0x0a0006fb, | 310 | 0x93, 0x55, 0xc0, 0xfe, 0xde, 0xf0, 0x37, 0x5b, 0xae, 0x2e, 0x06, 0x68, |
311 | 0x00000000, 0x24020020, 0x10820062, 0x28820021, 0x1040000e, 0x2402001c, | 311 | 0xfd, 0xcc, 0x2d, 0x42, 0x1f, 0x8d, 0xc9, 0xaa, 0x3e, 0x8e, 0x82, 0x37, |
312 | 0x1082004c, 0x2882001d, 0x10400005, 0x2402001b, 0x10820043, 0x00000000, | 312 | 0x19, 0xa7, 0x06, 0x60, 0xae, 0xa7, 0xeb, 0xd7, 0x0b, 0xc6, 0xed, 0x37, |
313 | 0x0a0006fb, 0x00000000, 0x2402001f, 0x10820050, 0x00000000, 0x0a0006fb, | 313 | 0xfd, 0xaa, 0xe5, 0xca, 0xc0, 0xf5, 0xf2, 0x91, 0x4f, 0xd5, 0xd1, 0xba, |
314 | 0x00000000, 0x240200c1, 0x10820042, 0x288200c2, 0x10400005, 0x24020080, | 314 | 0x51, 0x4d, 0xf8, 0x2c, 0xe8, 0x1a, 0x47, 0xde, 0x1d, 0x79, 0x81, 0x10, |
315 | 0x10820021, 0x00000000, 0x0a0006fb, 0x00000000, 0x240200c2, 0x1082003d, | 315 | 0x3b, 0x39, 0x79, 0x78, 0x1a, 0xb9, 0x77, 0xe4, 0x02, 0xe7, 0xe3, 0x6e, |
316 | 0x240200c9, 0x50820049, 0xafa00010, 0x0a0006fb, 0x00000000, 0x0e001163, | 316 | 0x7e, 0xfe, 0x6a, 0x29, 0x72, 0x36, 0x8f, 0x9c, 0x79, 0x1e, 0x39, 0xf9, |
317 | 0xac400808, 0x0a0006fd, 0x8fbf0018, 0x3c026000, 0x8c444448, 0x3c030800, | 317 | 0xcb, 0xc8, 0xc9, 0xcf, 0x97, 0x7a, 0x41, 0xff, 0x1e, 0x99, 0x8f, 0xb3, |
318 | 0xac640064, 0x0e001163, 0x00000000, 0x3c026000, 0x8c444448, 0x3c030800, | 318 | 0x8e, 0x99, 0x74, 0x11, 0xb9, 0xd3, 0x77, 0x67, 0xd8, 0x46, 0x74, 0xd1, |
319 | 0x0a0006fc, 0xac640068, 0x8f440100, 0x0e0006ff, 0x00000000, 0x3c026000, | 319 | 0x3d, 0xc8, 0x35, 0xbe, 0x3f, 0xa9, 0x68, 0x9d, 0x7d, 0x01, 0x5f, 0xc2, |
320 | 0x8c444448, 0x3c030800, 0x0a0006fc, 0xac64006c, 0x0e001191, 0x00000000, | 320 | 0xb8, 0x91, 0x38, 0x71, 0x29, 0x4f, 0x1a, 0xc7, 0x8a, 0x23, 0x4d, 0x7e, |
321 | 0x0a0006fd, 0x8fbf0018, 0x8f440100, 0x0e0011bb, 0x00000000, 0x0a0006fd, | 321 | 0x6b, 0xae, 0x95, 0x5a, 0xf6, 0x2c, 0xcb, 0x93, 0x6a, 0xac, 0xe8, 0xc2, |
322 | 0x8fbf0018, 0x0e001202, 0x00000000, 0x0a0006fd, 0x8fbf0018, 0x0000000d, | 322 | 0x19, 0xd4, 0xd9, 0xf7, 0x87, 0x9c, 0xdb, 0xc4, 0x48, 0xe4, 0xd3, 0xeb, |
323 | 0x0a0006fd, 0x8fbf0018, 0x0e000826, 0x00000000, 0x0a0006fd, 0x8fbf0018, | 323 | 0xe8, 0xed, 0x93, 0x65, 0xda, 0x19, 0xbb, 0x56, 0xbe, 0x68, 0xad, 0xa3, |
324 | 0x8f440100, 0x0e001264, 0x00000000, 0x0a0006fd, 0x8fbf0018, 0x0e00134e, | 324 | 0x6c, 0xef, 0x43, 0x32, 0x97, 0x5c, 0x78, 0x28, 0x69, 0xe5, 0x43, 0x3e, |
325 | 0x00000000, 0x0a0006fd, 0x8fbf0018, 0x0e00087c, 0x27440100, 0x0a0006fd, | 325 | 0xf7, 0x7c, 0x62, 0x42, 0x47, 0x84, 0xc8, 0xbf, 0x20, 0xcd, 0x0d, 0x20, |
326 | 0x8fbf0018, 0x8f640040, 0x0e000fae, 0x00000000, 0x0a0006fd, 0x8fbf0018, | 326 | 0x71, 0x6e, 0xd9, 0xfe, 0x02, 0x1f, 0x10, 0xb1, 0x6d, 0x9c, 0x33, 0x03, |
327 | 0x8f440100, 0x0e001059, 0x00000000, 0x0a0006fd, 0x8fbf0018, 0x0e001417, | 327 | 0xa2, 0xd6, 0xb6, 0xd1, 0xe2, 0x7e, 0x03, 0xfc, 0xbe, 0x8f, 0xe6, 0x90, |
328 | 0x00000000, 0x0a0006fd, 0x8fbf0018, 0xafa00014, 0x8f440100, 0x8f450118, | 328 | 0x43, 0x14, 0x44, 0x1e, 0xde, 0x0e, 0x78, 0x37, 0x0f, 0xbf, 0x1f, 0xb9, |
329 | 0x8f46011c, 0x0e001439, 0x8f470120, 0x0a0006fd, 0x8fbf0018, 0x0000000d, | 329 | 0x01, 0xd3, 0xd8, 0x04, 0xfc, 0x6f, 0x03, 0xc6, 0x6b, 0x43, 0x9f, 0x6b, |
330 | 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x27bdffe8, 0xafbf0010, 0x9742010c, | 330 | 0x22, 0xf1, 0x3d, 0x8f, 0xb7, 0x13, 0xd7, 0x65, 0xab, 0xf3, 0xf2, 0x9c, |
331 | 0x1440005e, 0x00803821, 0x3c029000, 0x34420001, 0x00e21025, 0xaf420020, | 331 | 0x3c, 0xf6, 0x61, 0xf9, 0xf6, 0xbe, 0x3e, 0xcf, 0xdc, 0x6d, 0x9e, 0xb9, |
332 | 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, 0x93620023, | 332 | 0xef, 0xf0, 0xcc, 0xed, 0xc3, 0xb7, 0x2e, 0x3e, 0x41, 0x7c, 0xeb, 0xae, |
333 | 0x30420010, 0x14400026, 0x3c030800, 0x8f630074, 0x3c027fff, 0x3442ffff, | 333 | 0xf1, 0xb7, 0x9e, 0x35, 0x5c, 0xdc, 0xdb, 0x3d, 0xb8, 0xbf, 0x8f, 0xf9, |
334 | 0x00621824, 0xaf630074, 0x93620005, 0x34420001, 0xa3620005, 0x8f63004c, | 334 | 0xb9, 0xcf, 0xf4, 0xf4, 0xf1, 0x9a, 0x1b, 0x68, 0x6e, 0xb0, 0x8d, 0x16, |
335 | 0x8f620054, 0x10620021, 0x24040001, 0x9762006a, 0x00022880, 0x50a00001, | 335 | 0x4f, 0x72, 0x5f, 0xd0, 0x83, 0x0b, 0xe3, 0x17, 0x90, 0x63, 0x6d, 0x74, |
336 | 0x24050001, 0x97630068, 0x93640081, 0x3c020800, 0x8c46004c, 0x00652821, | 336 | 0xf1, 0x64, 0x8b, 0xc0, 0x9b, 0xfd, 0xf9, 0xc6, 0xca, 0x9a, 0x57, 0xb0, |
337 | 0x00852804, 0x00c5102b, 0x54400001, 0x00a03021, 0x3c020800, 0x8c440050, | 337 | 0xa6, 0x3b, 0x97, 0x89, 0x6f, 0x19, 0x96, 0xf1, 0xe3, 0x31, 0xee, 0xe3, |
338 | 0x00c4182b, 0x54600001, 0x00c02021, 0x8f420074, 0x2403fffe, 0x00832824, | 338 | 0xb1, 0x37, 0xcb, 0x5f, 0x33, 0x82, 0xce, 0x9e, 0x0d, 0xc6, 0xcd, 0xfd, |
339 | 0x00a21021, 0xaf62000c, 0x0a00073d, 0x24040001, 0x8c6200a8, 0x00002021, | 339 | 0x56, 0x6b, 0x26, 0x8b, 0xdb, 0x9d, 0x34, 0x1b, 0xd4, 0xc0, 0x37, 0x55, |
340 | 0x24420001, 0xac6200a8, 0x0000000d, 0x00000000, 0x2400044d, 0x3c028000, | 340 | 0xfa, 0x28, 0xae, 0x23, 0xa8, 0x4a, 0xb4, 0x8f, 0xf9, 0xbc, 0x4e, 0xd6, |
341 | 0x34420001, 0x00e21025, 0xaf420020, 0x1080001f, 0x3c029000, 0x34420001, | 341 | 0xaf, 0x5b, 0x30, 0x6f, 0xd8, 0xcd, 0xd1, 0x88, 0xe5, 0x38, 0x27, 0xec, |
342 | 0x00e21025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, | 342 | 0xbe, 0x26, 0xc7, 0xd9, 0xee, 0xb3, 0xdf, 0xc7, 0x53, 0xc8, 0xaa, 0x3c, |
343 | 0x00000000, 0x9362007d, 0x3c038000, 0xa362007d, 0x8f640074, 0x34630001, | 343 | 0xaf, 0x29, 0xed, 0xa0, 0x83, 0x50, 0xcf, 0x8b, 0xb2, 0x9e, 0xb2, 0xe8, |
344 | 0x00e31825, 0xaf430020, 0x04810006, 0x3c038000, 0x00e02021, 0x0e000470, | 344 | 0xad, 0x99, 0x18, 0x4e, 0x1c, 0xe3, 0x9c, 0xed, 0xac, 0x85, 0xfe, 0xe0, |
345 | 0x24050455, 0x0a000761, 0x00000000, 0x8f4201f8, 0x00431024, 0x1440fffd, | 345 | 0xbd, 0x98, 0x00, 0x1e, 0x61, 0x8a, 0xe2, 0xaf, 0x50, 0xca, 0xe3, 0x69, |
346 | 0x24020002, 0x3c031000, 0xaf4701c0, 0xa34201c4, 0xaf4301f8, 0x0e001163, | 346 | 0xe1, 0xa9, 0xe0, 0xc9, 0xf5, 0x0c, 0x1d, 0x4f, 0xe8, 0x18, 0xec, 0x53, |
347 | 0x00000000, 0x8fbf0010, 0x03e00008, 0x27bd0018, 0x27bdffd8, 0xafbf0024, | 347 | 0xb4, 0xef, 0x92, 0x93, 0x3f, 0x41, 0x37, 0xde, 0x9e, 0x74, 0xea, 0x51, |
348 | 0xafb40020, 0xafb3001c, 0xafb20018, 0xafb10014, 0xafb00010, 0x93630005, | 348 | 0x8b, 0xd6, 0x72, 0xf5, 0xa8, 0x3f, 0x67, 0x9e, 0x9c, 0x70, 0xeb, 0x51, |
349 | 0x00809821, 0x24020030, 0x30630030, 0x146200ac, 0x00a0a021, 0x3c020800, | 349 | 0x8b, 0x24, 0xea, 0x51, 0x27, 0x56, 0xa8, 0x47, 0x25, 0x56, 0x5f, 0x8f, |
350 | 0x8c430020, 0x106000a6, 0x00000000, 0x0e00148e, 0x00000000, 0x8f830018, | 350 | 0xe2, 0xf9, 0x35, 0xda, 0xd7, 0x4f, 0xca, 0x17, 0x64, 0x3d, 0xea, 0x3d, |
351 | 0xac730000, 0x936200c4, 0x30420002, 0x10400004, 0x24020001, 0x8f830018, | 351 | 0x72, 0xea, 0x51, 0x17, 0xa9, 0x71, 0x3d, 0xea, 0x78, 0x5d, 0x3d, 0x2a, |
352 | 0x0a000784, 0x00000000, 0x8f830018, 0x24020003, 0xac620004, 0x8f6200dc, | 352 | 0x28, 0xea, 0x51, 0x3c, 0x8f, 0x53, 0x8f, 0x12, 0xed, 0xbe, 0x88, 0xa7, |
353 | 0x8f630040, 0x00431023, 0x18400004, 0x00000000, 0x0000000d, 0x00000000, | 353 | 0xee, 0x42, 0xf4, 0xee, 0x64, 0x07, 0x68, 0x66, 0xd0, 0xf7, 0x1a, 0xda, |
354 | 0x24000509, 0x8f840018, 0x8f6200dc, 0xac820008, 0x8f830018, 0xac60000c, | 354 | 0x34, 0x45, 0xc8, 0xdb, 0x4a, 0x35, 0xd0, 0x07, 0x6e, 0xb8, 0xbe, 0xa2, |
355 | 0x8f820018, 0xac400010, 0x8f830018, 0x8f62004c, 0x3c100800, 0xac620014, | 355 | 0xd0, 0x06, 0xcc, 0x9b, 0xec, 0x7b, 0xd8, 0x53, 0x63, 0x61, 0x9a, 0xff, |
356 | 0x8f850018, 0x3c026000, 0x8c434448, 0x261258c0, 0x00002021, 0xaca30018, | 356 | 0x62, 0xea, 0x2c, 0x07, 0x45, 0x9d, 0xe5, 0x87, 0x6b, 0xbc, 0x75, 0x96, |
357 | 0x9642000e, 0x8f850018, 0x3c034010, 0x00431025, 0x0e0014cc, 0xaca2001c, | 357 | 0x45, 0xba, 0x7e, 0x9d, 0xe5, 0x60, 0x83, 0x3a, 0xcb, 0x5b, 0x54, 0xad, |
358 | 0x8f830018, 0xac730000, 0x9362003e, 0x9363003f, 0x8f840018, 0x00021200, | 358 | 0xb3, 0xbc, 0x45, 0xd5, 0x3a, 0xcb, 0xc1, 0x12, 0xe7, 0xe2, 0x3e, 0x89, |
359 | 0x00621825, 0xac830004, 0x93620081, 0x93630082, 0x8f840018, 0x00021600, | 359 | 0x5f, 0x06, 0xed, 0x41, 0xf1, 0xc7, 0xb5, 0x97, 0xc5, 0xca, 0x1e, 0x7e, |
360 | 0x00031c00, 0x00431025, 0xac820008, 0x8f830018, 0x8f620040, 0xac62000c, | 360 | 0xd9, 0x6a, 0x2f, 0x6c, 0x03, 0x22, 0x17, 0x2e, 0xd7, 0xd4, 0x5e, 0xb8, |
361 | 0x8f840018, 0x8f620048, 0xac820010, 0x8f71004c, 0x8f820018, 0xac510014, | 361 | 0x0d, 0x9d, 0xb1, 0xd7, 0x08, 0x19, 0x99, 0x83, 0x7f, 0x5f, 0x9c, 0x0c, |
362 | 0x8f620050, 0x8f850018, 0x00401821, 0x02221023, 0x5c400001, 0x02201821, | 362 | 0x61, 0xce, 0x0e, 0xf8, 0x8c, 0x0e, 0xe4, 0x06, 0x61, 0xb4, 0x15, 0xda, |
363 | 0x00002021, 0xaca30018, 0x9642000e, 0x8f850018, 0x3c03c00b, 0x00431025, | 363 | 0x64, 0x0d, 0xa1, 0x8f, 0xc7, 0xd9, 0x0e, 0x43, 0xb7, 0x6c, 0x77, 0x7f, |
364 | 0x0e0014cc, 0xaca2001c, 0x8f620054, 0x8f840018, 0x00401821, 0x02221023, | 364 | 0x0f, 0x48, 0x1a, 0x44, 0x68, 0xb8, 0x9d, 0xf4, 0x20, 0xfb, 0x8e, 0xc9, |
365 | 0x5c400001, 0x02201821, 0xac830000, 0x8f840018, 0x8f630058, 0xac830004, | 365 | 0x3d, 0x74, 0xc8, 0xde, 0x22, 0xf6, 0xbd, 0xc1, 0xaa, 0x95, 0xb9, 0xc1, |
366 | 0x93620023, 0x30420010, 0x10400004, 0x00000000, 0x8f830018, 0x0a0007dd, | 366 | 0x1b, 0x90, 0xb9, 0xcc, 0xaa, 0x65, 0x8e, 0xe5, 0xcd, 0x39, 0xf7, 0xdd, |
367 | 0x8f620148, 0x8f830018, 0x8f62005c, 0xac620008, 0x8f830018, 0x8f620060, | 367 | 0x60, 0xf1, 0xfa, 0x1d, 0x02, 0xa7, 0x77, 0x1b, 0xc8, 0xfb, 0x18, 0xec, |
368 | 0xac62000c, 0x8f840018, 0x8f620064, 0xac820010, 0x97630068, 0x9762006a, | 368 | 0x8e, 0x33, 0xbf, 0x2e, 0xd7, 0xab, 0x8f, 0x87, 0x9f, 0x6d, 0x66, 0xff, |
369 | 0x8f840018, 0x00031c00, 0x00431025, 0xac820014, 0x8f850018, 0x00002021, | 369 | 0xbd, 0x72, 0x3d, 0xb1, 0xde, 0x7f, 0xaf, 0xe4, 0x47, 0x15, 0x61, 0x93, |
370 | 0x2402ffff, 0x260358c0, 0xaca20018, 0x9462000e, 0x8f850018, 0x3c03c00c, | 370 | 0xb3, 0x25, 0xae, 0xed, 0x7b, 0xf9, 0x33, 0x8f, 0x9c, 0x00, 0x7d, 0x42, |
371 | 0x00431025, 0x0e0014cc, 0xaca2001c, 0x8f840018, 0x8f630018, 0xac830000, | 371 | 0x0f, 0x98, 0xae, 0x41, 0xf0, 0x01, 0xeb, 0xd8, 0x4f, 0xc9, 0x5a, 0x16, |
372 | 0x936200c4, 0x30420002, 0x10400006, 0x00000000, 0x976200c8, 0x8f830018, | 372 | 0x9e, 0x05, 0x97, 0x7f, 0xad, 0xb0, 0x99, 0xee, 0x18, 0xdb, 0x01, 0x0b, |
373 | 0x3042ffff, 0x0a000803, 0xac620004, 0x8f820018, 0xac400004, 0x8f830018, | 373 | 0xfe, 0x8f, 0xeb, 0x28, 0x7c, 0x8e, 0xca, 0xfd, 0x2e, 0x5f, 0xbb, 0x2e, |
374 | 0x8f62006c, 0xac620008, 0x8f840018, 0x8f6200dc, 0xac82000c, 0x8f830018, | 374 | 0xbc, 0xa7, 0x72, 0xbb, 0x5c, 0xce, 0x8a, 0x7a, 0x2d, 0xa9, 0x9d, 0x7d, |
375 | 0xac600010, 0x93620005, 0x8f830018, 0x00021600, 0x00541025, 0xac620014, | 375 | 0xd3, 0x2d, 0x6c, 0x6b, 0xb6, 0x58, 0xae, 0xcc, 0x26, 0xf0, 0xce, 0x7c, |
376 | 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, 0x260258c0, 0xaca30018, | 376 | 0x7d, 0x17, 0x36, 0x9c, 0xcf, 0xaa, 0xbf, 0x23, 0x6a, 0x04, 0x73, 0x36, |
377 | 0x9443000e, 0x8f850018, 0x3c02400d, 0x00621825, 0x0e0014cc, 0xaca3001c, | 377 | 0xdb, 0x6b, 0x8e, 0x41, 0x7f, 0x0b, 0xb2, 0xc4, 0xef, 0x51, 0x71, 0x2e, |
378 | 0x0e00122e, 0x02602021, 0x8fbf0024, 0x8fb40020, 0x8fb3001c, 0x8fb20018, | 378 | 0x21, 0x6a, 0xf8, 0x83, 0xdc, 0x76, 0xed, 0x4a, 0x94, 0xed, 0x30, 0xf6, |
379 | 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0028, 0x27bdffe0, 0xafb00010, | 379 | 0x5c, 0xa5, 0x31, 0xe2, 0x23, 0xc8, 0x0c, 0xc7, 0xb1, 0x0c, 0xe7, 0xc6, |
380 | 0x27500100, 0xafbf0018, 0xafb10014, 0x9603000c, 0x240200c1, 0x54620024, | 380 | 0x9e, 0x9a, 0xa7, 0x66, 0xab, 0xcb, 0xb8, 0x88, 0x75, 0x39, 0x00, 0x9a, |
381 | 0x8e040000, 0x3c029000, 0x8f450100, 0x34420001, 0x3c038000, 0x00a21025, | 381 | 0xed, 0x10, 0x31, 0xea, 0xb8, 0x5d, 0xa6, 0xea, 0x19, 0x3f, 0xd3, 0xdc, |
382 | 0xaf420020, 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, 0x9362007d, | 382 | 0x39, 0xe7, 0x3f, 0x66, 0x2f, 0x47, 0xfb, 0xcd, 0x37, 0x48, 0x7b, 0x47, |
383 | 0x3c038000, 0x34420004, 0xa362007d, 0x8f640074, 0x34630001, 0x00a31825, | 383 | 0x1f, 0x6b, 0xe9, 0xae, 0x23, 0x7e, 0x71, 0xe9, 0xee, 0xfa, 0xa8, 0x49, |
384 | 0xaf430020, 0x04810006, 0x3c038000, 0x00a02021, 0x0e000470, 0x240505b2, | 384 | 0x49, 0x83, 0xa8, 0xac, 0x2b, 0x7e, 0x5a, 0x9e, 0x29, 0xfd, 0x5f, 0xd8, |
385 | 0x0a000878, 0x8fbf0018, 0x8f4201f8, 0x00431024, 0x1440fffd, 0x24020002, | 385 | 0xaf, 0xe2, 0xd9, 0xaf, 0xab, 0xbb, 0xfb, 0xe4, 0x7e, 0xc3, 0x75, 0xba, |
386 | 0x3c031000, 0xaf4501c0, 0xa34201c4, 0xaf4301f8, 0x0a000878, 0x8fbf0018, | 386 | 0x1b, 0x97, 0x75, 0xb9, 0x5f, 0x84, 0xee, 0xba, 0x7b, 0xe2, 0xb5, 0xb7, |
387 | 0x8f65004c, 0x24060001, 0x0e0012a3, 0x240705be, 0x3c020800, 0x8c430020, | 387 | 0x5c, 0x67, 0xdd, 0x67, 0x48, 0x8d, 0xaf, 0x14, 0x7b, 0xff, 0xb4, 0xf9, |
388 | 0x9611000c, 0x1060001d, 0x8e100000, 0x0e00148e, 0x00000000, 0x8f820018, | 388 | 0xe3, 0xc5, 0xde, 0x1f, 0x87, 0x9e, 0x5e, 0xbd, 0x65, 0x1a, 0xb6, 0x89, |
389 | 0xac500000, 0x8f840018, 0x00111400, 0xac820004, 0x8f830018, 0xac600008, | 389 | 0xb8, 0xc2, 0xd1, 0x1f, 0xd8, 0xe3, 0x82, 0x9f, 0x16, 0x1e, 0xd2, 0xe9, |
390 | 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, 0x8f840018, 0x240205c1, | 390 | 0x9f, 0xee, 0xe4, 0xfa, 0xac, 0x26, 0x73, 0x7c, 0x6e, 0x7f, 0xb1, 0x95, |
391 | 0xac820014, 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, 0x3c020800, | 391 | 0x63, 0xab, 0x4d, 0xd6, 0x77, 0x44, 0x6e, 0x95, 0x57, 0x4d, 0x8f, 0x1f, |
392 | 0xaca30018, 0x944358ce, 0x8f850018, 0x3c024019, 0x00621825, 0x0e0014cc, | 392 | 0x31, 0x30, 0xce, 0x63, 0x61, 0xba, 0x1c, 0xbc, 0x91, 0xb8, 0xbc, 0xcb, |
393 | 0xaca3001c, 0x8fbf0018, 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, | 393 | 0x58, 0xf4, 0xad, 0x26, 0x2e, 0xbf, 0x55, 0xf7, 0x5b, 0x7f, 0xdd, 0x7a, |
394 | 0x27bdffb0, 0xafb5003c, 0x0000a821, 0xafbe0048, 0x0000f021, 0xafb70044, | 394 | 0xbd, 0x3a, 0x47, 0x35, 0x2e, 0xe7, 0x7c, 0x3e, 0xe8, 0xd4, 0x18, 0x4c, |
395 | 0x0000b821, 0xafb30034, 0x00009821, 0xafb60040, 0x0080b021, 0xafbf004c, | 395 | 0x8e, 0xcf, 0xd7, 0x4a, 0x9e, 0xf0, 0x3b, 0x72, 0x11, 0x1b, 0x79, 0x08, |
396 | 0xafb40038, 0xafb20030, 0xafb1002c, 0xafb00028, 0xafa00010, 0x8f620040, | 396 | 0x64, 0xfc, 0x55, 0xc8, 0xca, 0x2b, 0x36, 0xf2, 0x0e, 0x1b, 0xf9, 0x88, |
397 | 0x8ec30014, 0x96d1000c, 0x00431023, 0x04410025, 0x8ed40000, 0x32220401, | 397 | 0x8d, 0xdc, 0xc3, 0x46, 0xee, 0x61, 0xf7, 0xc8, 0x1c, 0x26, 0x23, 0xeb, |
398 | 0x1040030c, 0x3c029000, 0x34420001, 0x02821025, 0xaf420020, 0x3c038000, | 398 | 0x56, 0x7c, 0x46, 0xcb, 0xf9, 0x61, 0x5e, 0xc9, 0xd8, 0xe3, 0x7c, 0x1f, |
399 | 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, | 399 | 0x41, 0x4d, 0xc6, 0x36, 0xca, 0x78, 0xf0, 0x38, 0xdf, 0x77, 0x28, 0xab, |
400 | 0x34420004, 0xa362007d, 0x8f640074, 0x34630001, 0x02831825, 0xaf430020, | 400 | 0x71, 0xae, 0x45, 0x91, 0xaa, 0xc6, 0x6f, 0x87, 0x8f, 0xda, 0x0e, 0xbc, |
401 | 0x04810006, 0x3c038000, 0x02802021, 0x0e000470, 0x24050664, 0x0a000ba2, | 401 | 0x9a, 0x79, 0xdc, 0xa7, 0xc6, 0x5b, 0x99, 0x76, 0x8a, 0x1a, 0x5f, 0x2b, |
402 | 0x8fbf004c, 0x8f4201f8, 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, | 402 | 0xcf, 0x0d, 0x7a, 0x03, 0x0e, 0xfe, 0xdd, 0xdc, 0xd6, 0xd4, 0xf8, 0xdd, |
403 | 0xaf5401c0, 0xa34201c4, 0xaf4301f8, 0x0a000ba2, 0x8fbf004c, 0x32220010, | 403 | 0xec, 0xd3, 0xc2, 0xa4, 0xba, 0xfd, 0xb7, 0x07, 0x98, 0xae, 0xa4, 0xde, |
404 | 0x1040006b, 0x00003021, 0x9362003f, 0x92c6000f, 0x304500ff, 0x24c3fff8, | 404 | 0x16, 0xe0, 0xb8, 0x76, 0xde, 0xf6, 0x8b, 0x3b, 0x05, 0xc9, 0x18, 0xd7, |
405 | 0x2c62000f, 0x10400057, 0x3c020800, 0x244257c0, 0x00031880, 0x00621821, | 405 | 0xcc, 0xb8, 0x5d, 0xa5, 0xab, 0xba, 0x2c, 0x5d, 0xfd, 0x95, 0xfa, 0x3f, |
406 | 0x8c640000, 0x00800008, 0x00000000, 0x38a20012, 0x0a000924, 0x0002a82b, | 406 | 0xd3, 0xd2, 0xc7, 0x70, 0xa2, 0x36, 0xc6, 0x34, 0x75, 0xe7, 0xe3, 0xf3, |
407 | 0x2402000e, 0x14a20004, 0x2402000c, 0x24150001, 0x0a000924, 0x24060010, | 407 | 0x66, 0x5e, 0x47, 0xdc, 0x63, 0xc0, 0xf3, 0x60, 0x33, 0xb5, 0x0d, 0x0e, |
408 | 0x10a20049, 0x38a30010, 0x2c630001, 0x38a20016, 0x2c420001, 0x00621825, | 408 | 0xf9, 0x2d, 0xef, 0xba, 0x6c, 0x43, 0x76, 0x90, 0x37, 0xc7, 0x5a, 0x7e, |
409 | 0x1460004d, 0x0000a821, 0x24020014, 0x10a2004a, 0x00000000, 0x0000000d, | 409 | 0xcd, 0xa8, 0x38, 0x1b, 0x49, 0xf6, 0x47, 0x85, 0xec, 0xb0, 0xac, 0x69, |
410 | 0x00000000, 0x2400069c, 0x0a000924, 0x0000a821, 0x24020016, 0x14a20005, | 410 | 0xe2, 0xce, 0xd5, 0x47, 0xe2, 0x1e, 0x09, 0xcb, 0x19, 0xcb, 0xf2, 0x78, |
411 | 0x2402000c, 0x24150001, 0x24060010, 0x0a000924, 0x3231fffd, 0x10a20032, | 411 | 0x7f, 0x57, 0x58, 0x53, 0x5b, 0xb0, 0x46, 0x98, 0xd2, 0x25, 0x71, 0x56, |
412 | 0x38a30010, 0x2c630001, 0x38a2000e, 0x2c420001, 0x00621825, 0x14600036, | 412 | 0x80, 0x7c, 0xe9, 0xdc, 0x3a, 0x6a, 0xfb, 0x07, 0xbd, 0x9a, 0xc7, 0x46, |
413 | 0x0000a821, 0x24020014, 0x14a20003, 0x24150001, 0x0a000924, 0x24060012, | 413 | 0x9d, 0xb3, 0x7a, 0xbb, 0xde, 0xff, 0x8d, 0x8a, 0x73, 0x65, 0xc7, 0x06, |
414 | 0x0000000d, 0x00000000, 0x240006bc, 0x0a000924, 0x0000a821, 0x2402000e, | 414 | 0xb9, 0xe7, 0xc3, 0xab, 0x3b, 0xff, 0xbe, 0xbe, 0x3e, 0xb5, 0xd4, 0xd7, |
415 | 0x14a20004, 0x24020016, 0x24150001, 0x0a000924, 0x3231fffb, 0x14a20004, | 415 | 0x0d, 0x24, 0x0d, 0x98, 0x36, 0x8d, 0xcf, 0xee, 0xe7, 0x4b, 0x7c, 0xaf, |
416 | 0x24020014, 0x24150001, 0x0a000924, 0x3231fffd, 0x54a20013, 0x92c2000e, | 416 | 0x25, 0x12, 0xe3, 0xdc, 0x6d, 0x44, 0xdc, 0xf9, 0x50, 0x21, 0x85, 0x3a, |
417 | 0x24150001, 0x24060012, 0x0a000924, 0x3231fffd, 0x2402000c, 0x54a2000c, | 417 | 0x8d, 0x19, 0x9c, 0xf3, 0x85, 0x86, 0x7d, 0x71, 0xca, 0x64, 0x27, 0x48, |
418 | 0x92c2000e, 0x92c3000e, 0x2402000a, 0x10620005, 0x24150001, 0x0000000d, | 418 | 0x43, 0xac, 0x98, 0xa9, 0xd6, 0x03, 0x1f, 0x5c, 0x43, 0x96, 0x2b, 0x97, |
419 | 0x00000000, 0x240006e8, 0x24150001, 0x0a000924, 0x24060014, 0x92c2000e, | 419 | 0x51, 0xce, 0x1f, 0x6a, 0xce, 0xed, 0x16, 0xe9, 0xb0, 0x72, 0xa0, 0x74, |
420 | 0x14a20003, 0x00000000, 0x0a000924, 0x24150001, 0x10a6ffc1, 0x24020012, | 420 | 0x84, 0x0e, 0x34, 0x8c, 0x29, 0x1b, 0xd7, 0x03, 0x2f, 0xd6, 0xd5, 0x14, |
421 | 0x10a20005, 0x0000a821, 0x0000000d, 0x00000000, 0x24000704, 0x0000a821, | 421 | 0x16, 0x44, 0x4d, 0x21, 0xb7, 0xc6, 0x6f, 0x3d, 0x19, 0x70, 0xee, 0xb5, |
422 | 0x12a00022, 0x32220004, 0x10400002, 0x24020001, 0xafa20010, 0x32230102, | 422 | 0x34, 0xd6, 0x93, 0x5d, 0x15, 0x3d, 0x71, 0xe1, 0xf8, 0x2c, 0xbe, 0x8d, |
423 | 0x24020002, 0x1462000f, 0x00000000, 0x92c2000a, 0x30420020, 0x1440000b, | 423 | 0x76, 0x8a, 0xb5, 0x0e, 0x2b, 0x59, 0xbb, 0x95, 0x76, 0x1a, 0x0e, 0xd6, |
424 | 0x00000000, 0x8f630048, 0x8f620040, 0x14620004, 0x00000000, 0x8f620048, | 424 | 0xa3, 0x36, 0xe3, 0x75, 0x58, 0x39, 0x68, 0xe7, 0x95, 0xb4, 0xa8, 0x3d, |
425 | 0x24420001, 0xaf620048, 0x8f620040, 0x24420001, 0xaf620040, 0xa366003f, | 425 | 0x70, 0x8c, 0xbf, 0xe6, 0xda, 0x30, 0x95, 0xe9, 0xed, 0x98, 0xfb, 0x3d, |
426 | 0x38c30012, 0x2c630001, 0x38c20010, 0x2c420001, 0x00621825, 0x10600005, | 426 | 0xc3, 0x78, 0x6b, 0x8a, 0x2e, 0x9d, 0xf8, 0x2e, 0x51, 0x58, 0xe6, 0x6f, |
427 | 0x3c030800, 0x8c620074, 0x24420001, 0x0e00140d, 0xac620074, 0x32220040, | 427 | 0xce, 0x7c, 0xb9, 0x29, 0xae, 0x25, 0xde, 0x8f, 0xfd, 0x33, 0xfc, 0x6e, |
428 | 0x32230020, 0xafa30020, 0x32230080, 0xafa30024, 0x32230001, 0xafa30018, | 428 | 0x25, 0x39, 0x55, 0x2e, 0xa7, 0x31, 0x3e, 0xd6, 0x7b, 0xaf, 0xc8, 0x8d, |
429 | 0x32230008, 0xafa3001c, 0x32230100, 0x104000c4, 0xafa30014, 0x8ec60010, | 429 | 0xd4, 0x38, 0x0d, 0x71, 0x8e, 0xac, 0x2d, 0xc9, 0x91, 0xd3, 0xd0, 0x35, |
430 | 0x8f630054, 0x24c2ffff, 0x00431023, 0x18400006, 0x00000000, 0x0000000d, | 430 | 0xc4, 0x20, 0x76, 0x13, 0xbe, 0x75, 0xe3, 0x91, 0xcf, 0xae, 0x75, 0x64, |
431 | 0x00000000, 0x2400015c, 0x0a000989, 0x00009021, 0x8f62004c, 0x00c21023, | 431 | 0xe4, 0xbb, 0x12, 0x0f, 0x1e, 0xff, 0xfb, 0x80, 0x7b, 0x0f, 0x28, 0x77, |
432 | 0x18400028, 0x00009021, 0x93650120, 0x93640121, 0x3c030800, 0x8c62008c, | 432 | 0x2a, 0x8d, 0xfd, 0x37, 0x51, 0xca, 0x74, 0xf2, 0xbb, 0xec, 0x99, 0x23, |
433 | 0x308400ff, 0x24420001, 0x30a500ff, 0x00804021, 0x1485000b, 0xac62008c, | 433 | 0x1b, 0x6a, 0xe1, 0xd1, 0x77, 0xca, 0x85, 0x0f, 0xd6, 0xc1, 0xf3, 0x19, |
434 | 0x3c040800, 0x8c830090, 0x24630001, 0xac830090, 0x93620122, 0x30420001, | 434 | 0xd7, 0x5f, 0xd5, 0xc1, 0x07, 0x3d, 0xf0, 0x66, 0x1d, 0x3c, 0xe2, 0xae, |
435 | 0x00021023, 0x30420005, 0x0a000989, 0x34520004, 0x27670100, 0x00041080, | 435 | 0x33, 0xdf, 0xa8, 0x83, 0x37, 0x3d, 0xf0, 0xed, 0x75, 0xf0, 0xed, 0x80, |
436 | 0x00e21021, 0x8c430000, 0x00c31823, 0x04600004, 0x24820001, 0x30440007, | 436 | 0x7f, 0xa3, 0x0e, 0x1e, 0x7d, 0xa7, 0x90, 0x13, 0x08, 0xda, 0x70, 0x8c, |
437 | 0x1485fff9, 0x00041080, 0x10880007, 0x3c030800, 0xa3640121, 0x8c620094, | 437 | 0x74, 0x48, 0xe6, 0x89, 0x78, 0x2e, 0xb9, 0x1f, 0xc9, 0xf2, 0xd3, 0x01, |
438 | 0x24120005, 0x24420001, 0x0a000989, 0xac620094, 0x24120004, 0x32420001, | 438 | 0x1a, 0x7b, 0xeb, 0xb5, 0x09, 0xd8, 0xa8, 0xaa, 0x4c, 0x39, 0xfa, 0xea, |
439 | 0x10400021, 0x3c020800, 0x8c430020, 0x8ed00000, 0x1060001c, 0x8ed30010, | 439 | 0x95, 0x25, 0x96, 0xbd, 0x3c, 0xe4, 0x15, 0x7a, 0x54, 0x80, 0x3e, 0x15, |
440 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac500000, 0x8f840018, 0x24020001, | 440 | 0x5c, 0x5f, 0xca, 0x77, 0xaa, 0x22, 0xc7, 0x1d, 0x3d, 0x56, 0x68, 0xbd, |
441 | 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, | 441 | 0x35, 0x2f, 0x73, 0x91, 0xab, 0x8c, 0x3b, 0xfc, 0x86, 0xeb, 0x3b, 0xe8, |
442 | 0xac600010, 0x8f820018, 0xac530014, 0x8f850018, 0x3c026000, 0x8c434448, | 442 | 0x84, 0x63, 0x57, 0x58, 0xbf, 0x79, 0x7e, 0x69, 0x5f, 0x4a, 0x2c, 0x87, |
443 | 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, 0x3c024010, | 443 | 0xce, 0x3a, 0xe9, 0x25, 0x32, 0x1b, 0x5e, 0x52, 0x77, 0xf1, 0xd5, 0xd9, |
444 | 0x00621825, 0x0e0014cc, 0xaca3001c, 0x24130001, 0x32420004, 0x10400068, | 444 | 0x77, 0x12, 0xf6, 0x3d, 0xd7, 0xe2, 0xb7, 0x36, 0xac, 0xbd, 0x9e, 0x7d, |
445 | 0x00003821, 0x3c029000, 0x8ec60010, 0x34420001, 0x3c038000, 0x02821025, | 445 | 0xcf, 0x78, 0xec, 0x7b, 0x38, 0x58, 0xf5, 0xf9, 0x8f, 0x09, 0x9f, 0xdf, |
446 | 0xa360007c, 0xaf420020, 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, | 446 | 0xd1, 0xc0, 0x66, 0xac, 0xde, 0xe7, 0xef, 0xfd, 0xd8, 0x3e, 0x7f, 0xb9, |
447 | 0x93620023, 0x30420080, 0x10400011, 0x00000000, 0x8f65005c, 0x8f63004c, | 447 | 0x75, 0x57, 0xe3, 0xf3, 0x1f, 0x69, 0xf9, 0x78, 0x3e, 0x9f, 0xd7, 0xac, |
448 | 0x9764003c, 0x8f620064, 0x00a32823, 0x00852821, 0x00a2102b, 0x54400006, | 448 | 0xaf, 0x65, 0x7a, 0xcf, 0x59, 0x8e, 0xca, 0x18, 0x7b, 0xb7, 0x27, 0xc6, |
449 | 0x3c023fff, 0x93620023, 0x3042007f, 0xa3620023, 0xaf660064, 0x3c023fff, | 449 | 0x66, 0xfc, 0xbe, 0x27, 0xef, 0x02, 0x9e, 0x5e, 0xeb, 0xc8, 0xdb, 0x51, |
450 | 0x0a0009da, 0x3442ffff, 0x8f62005c, 0x00c21023, 0x04400011, 0x00000000, | 450 | 0x19, 0xa7, 0x73, 0xec, 0x8d, 0xf7, 0xc2, 0x23, 0x90, 0xd1, 0x7c, 0x8f, |
451 | 0x8f65005c, 0x8f630064, 0x9764003c, 0x3c023fff, 0x3442ffff, 0xaf660064, | 451 | 0x8f, 0x54, 0x9a, 0x35, 0x9d, 0xb3, 0xed, 0x9f, 0x6f, 0xae, 0x17, 0xa1, |
452 | 0x00a32823, 0x00852821, 0x0045102b, 0x10400004, 0x00c51021, 0x3c053fff, | 452 | 0xcb, 0xc2, 0x9f, 0x24, 0x3e, 0x81, 0x5a, 0xea, 0x49, 0xc8, 0x8f, 0xbb, |
453 | 0x34a5ffff, 0x00c51021, 0xaf62005c, 0x24070001, 0xaf66004c, 0x8fa20010, | 453 | 0xaf, 0x95, 0x6a, 0xa9, 0xf5, 0xe7, 0x1f, 0x7c, 0xee, 0x41, 0xca, 0x03, |
454 | 0x10400003, 0x00000000, 0xaf660050, 0xaf660054, 0x8f620054, 0x14c20005, | 454 | 0x95, 0x73, 0x10, 0xaf, 0x4e, 0xe9, 0x94, 0x9d, 0x21, 0xdd, 0x8c, 0x93, |
455 | 0x00000000, 0x93620023, 0x30420040, 0x10400017, 0x24020001, 0x9762006a, | 455 | 0xb2, 0x8f, 0x71, 0x8e, 0xfd, 0xb0, 0x52, 0x6f, 0x3f, 0x24, 0x6b, 0x30, |
456 | 0x00022880, 0x50a00001, 0x24050001, 0x97630068, 0x93640081, 0x3c020800, | 456 | 0xea, 0xb2, 0x77, 0x82, 0x7e, 0x02, 0x7c, 0x58, 0xaf, 0x9c, 0x1a, 0x8c, |
457 | 0x8c46004c, 0x00652821, 0x00852804, 0x00c5102b, 0x54400001, 0x00a03021, | 457 | 0xea, 0xdc, 0x09, 0x3a, 0xfe, 0xf3, 0xbb, 0x13, 0xc4, 0xf3, 0x6b, 0xb4, |
458 | 0x3c020800, 0x8c440050, 0x00c4182b, 0x54600001, 0x00c02021, 0x8f420074, | 458 | 0xb7, 0xc1, 0x9d, 0x20, 0xdf, 0x2a, 0xef, 0x04, 0xad, 0x17, 0x35, 0x18, |
459 | 0x2403fffe, 0x00832824, 0x00a21021, 0xaf62000c, 0x93620082, 0x30420080, | 459 | 0x9e, 0xc7, 0xa9, 0xc1, 0x70, 0xbb, 0xb3, 0x8f, 0xe5, 0x3a, 0x4c, 0xa3, |
460 | 0x50400001, 0xa3600081, 0x3c028000, 0x34420001, 0x02821025, 0xaf420020, | 460 | 0x93, 0xb7, 0x88, 0x7b, 0xa8, 0x9d, 0x7d, 0xb5, 0xf2, 0xbd, 0xef, 0x13, |
461 | 0x9363007e, 0x9362007a, 0x10620005, 0x00e0b821, 0x0e0013c4, 0x00000000, | 461 | 0x8d, 0xa5, 0x79, 0xbd, 0xa3, 0x0d, 0xef, 0xb6, 0x24, 0x3f, 0xc1, 0x9a, |
462 | 0x00403821, 0x00e0b821, 0x8fa30020, 0x10600009, 0x8fa20010, 0x8ec20018, | 462 | 0xcb, 0x21, 0x51, 0x73, 0xb9, 0xb3, 0xcd, 0x5b, 0x73, 0x51, 0x57, 0xb8, |
463 | 0xaf620018, 0x8ec3001c, 0xaf63001c, 0x8ec20020, 0x24170001, 0xaf620058, | 463 | 0xdb, 0x72, 0xa8, 0x41, 0xcd, 0xc5, 0xef, 0xb9, 0xdb, 0xe2, 0xf7, 0xdc, |
464 | 0x8fa20010, 0x10400057, 0x8fa30024, 0x93620023, 0x30420040, 0x10400053, | 464 | 0x6d, 0x39, 0x24, 0xeb, 0x2b, 0xea, 0x2f, 0xd1, 0xdd, 0x96, 0xe4, 0x8a, |
465 | 0x00000000, 0x16600021, 0x3c120800, 0x8e420020, 0x8f70004c, 0x1040001e, | 465 | 0x77, 0x5b, 0xb6, 0x4a, 0x7d, 0xf5, 0xc2, 0xaf, 0xfe, 0xbc, 0x32, 0x55, |
466 | 0x24130001, 0x0e00148e, 0x00000000, 0x8f820018, 0xac540000, 0x8f840018, | 466 | 0x67, 0xe7, 0x13, 0xc2, 0xce, 0xdf, 0xd5, 0xea, 0xb7, 0x9e, 0x69, 0xbb, |
467 | 0x24020001, 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, | 467 | 0x9e, 0x9d, 0xdf, 0x57, 0xd1, 0x53, 0xbe, 0xa3, 0xcd, 0x77, 0xbe, 0x58, |
468 | 0x8f830018, 0xac600010, 0x8f820018, 0xac500014, 0x8f850018, 0x3c026000, | 468 | 0x16, 0xf9, 0x7c, 0xa6, 0x89, 0x72, 0x03, 0xbf, 0x2a, 0x68, 0xf6, 0x58, |
469 | 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, | 469 | 0x6f, 0xed, 0x99, 0x63, 0xf5, 0x5e, 0xa4, 0xee, 0xb9, 0x17, 0x69, 0xa2, |
470 | 0x3c024010, 0x00621825, 0xaca3001c, 0x0e0014cc, 0x24130001, 0x8e420020, | 470 | 0x5f, 0xaf, 0xab, 0x87, 0x04, 0xe4, 0xdd, 0x7e, 0xf8, 0xc2, 0x19, 0x43, |
471 | 0x1040001c, 0x8ed00000, 0x0e00148e, 0x00000000, 0x8f820018, 0xac500000, | 471 | 0xda, 0x5e, 0xc4, 0x70, 0x98, 0xae, 0x50, 0xe4, 0x3b, 0x95, 0x6d, 0xe4, |
472 | 0x8f830018, 0xac600004, 0x8f820018, 0xac400008, 0x8f830018, 0xac60000c, | 472 | 0x9b, 0x71, 0xce, 0x4b, 0x54, 0x11, 0x63, 0x42, 0x8e, 0x8b, 0x7e, 0xe1, |
473 | 0x8f820018, 0xac400010, 0x8f830018, 0x24020798, 0xac620014, 0x8f850018, | 473 | 0x6f, 0xd4, 0xb8, 0x23, 0xb3, 0xe3, 0xf6, 0x05, 0xe0, 0xbf, 0x21, 0x51, |
474 | 0x3c026000, 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, | 474 | 0x6d, 0x9b, 0x95, 0x5a, 0xce, 0x58, 0xe5, 0x0e, 0xbf, 0x09, 0xfb, 0xe0, |
475 | 0x8f850018, 0x3c024019, 0x00621825, 0x0e0014cc, 0xaca3001c, 0x3c029000, | 475 | 0xdc, 0x07, 0xca, 0x98, 0x7c, 0x67, 0xe4, 0x62, 0x5b, 0xf5, 0x3e, 0xd0, |
476 | 0x34420001, 0x02821025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, | 476 | 0x67, 0xa4, 0x9c, 0x3a, 0xf7, 0x81, 0x48, 0x4d, 0x40, 0x3e, 0x6e, 0xe4, |
477 | 0x1440fffd, 0x24020001, 0xaf62000c, 0x93630023, 0x3c028000, 0x34420001, | 477 | 0x3e, 0x50, 0xd7, 0x92, 0xfb, 0x40, 0x2b, 0xf3, 0x66, 0xe9, 0x7d, 0xa0, |
478 | 0x02821025, 0x306300bf, 0xa3630023, 0xaf420020, 0x8fa30024, 0x10600012, | 478 | 0xc6, 0xfc, 0xe1, 0xfb, 0x40, 0xff, 0xde, 0xe6, 0xdc, 0x43, 0x5d, 0x89, |
479 | 0x8fa30018, 0x9362007c, 0x24420001, 0xa362007c, 0x9363007e, 0x9362007a, | 479 | 0x3f, 0x6e, 0x9c, 0xf4, 0x11, 0xe0, 0xf9, 0x3e, 0x50, 0xe5, 0x1e, 0x90, |
480 | 0x1462000b, 0x8fa30018, 0x9362007c, 0x3c030800, 0x8c640024, 0x0044102b, | 480 | 0xe7, 0x0e, 0x10, 0xdf, 0x25, 0x59, 0xee, 0x0c, 0xce, 0x7b, 0xff, 0xa4, |
481 | 0x14400005, 0x8fa30018, 0x0e0013c4, 0x00000000, 0x02e2b825, 0x8fa30018, | 481 | 0xa7, 0x72, 0xff, 0xe4, 0x7c, 0xc9, 0xf5, 0xed, 0xee, 0xb9, 0x1c, 0xc7, |
482 | 0x3062ffff, 0x10400003, 0x32220200, 0x0a000a94, 0x241e0004, 0x10400003, | 482 | 0x39, 0xbb, 0x44, 0x8e, 0x7a, 0xae, 0x54, 0x5b, 0xc3, 0x60, 0xbe, 0x8f, |
483 | 0x00000000, 0x241e0040, 0x24170001, 0x12a000d0, 0x32220002, 0x104000cf, | 483 | 0x16, 0xcf, 0x81, 0x3e, 0x6f, 0x89, 0xdc, 0x00, 0x7c, 0xde, 0xe2, 0x23, |
484 | 0x8fa2001c, 0x92c2000a, 0x30420002, 0x5040003b, 0x92c2000a, 0x93620023, | 484 | 0xe6, 0x1d, 0x29, 0xa0, 0x8b, 0x38, 0xcb, 0x75, 0xf8, 0xdd, 0x21, 0x64, |
485 | 0x30420008, 0x54400037, 0x92c2000a, 0x3c020800, 0x8c430020, 0x10600023, | 485 | 0xc1, 0x91, 0x8b, 0xdd, 0x9e, 0xf3, 0xd0, 0xaa, 0x1c, 0x38, 0x67, 0xba, |
486 | 0x3c029000, 0x0e00148e, 0x00000000, 0x8f840018, 0x8ec30000, 0xac830000, | 486 | 0x0e, 0xef, 0x6a, 0x65, 0x46, 0x9c, 0xdd, 0x0c, 0xed, 0xb5, 0x9c, 0xf3, |
487 | 0x92c2000a, 0x8f830018, 0x00021600, 0xac620004, 0x8f840018, 0x8f620040, | 487 | 0xc6, 0xa8, 0x38, 0xb7, 0x6d, 0xaf, 0xb3, 0x5b, 0x3a, 0xe4, 0x06, 0x31, |
488 | 0xac820008, 0x8f850018, 0x8f63004c, 0xaca3000c, 0x9362003f, 0x8f840018, | 488 | 0x67, 0x8c, 0xeb, 0xd5, 0x8c, 0xfb, 0x66, 0xc1, 0xe3, 0x46, 0x67, 0x71, |
489 | 0x304200ff, 0xac820010, 0x8f830018, 0x3c026000, 0xac600014, 0x8f850018, | 489 | 0x2b, 0xd7, 0xf1, 0xdc, 0x9a, 0x0a, 0x21, 0x97, 0xd8, 0x9d, 0xce, 0x09, |
490 | 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, | 490 | 0xbb, 0xe9, 0xac, 0xdd, 0x29, 0xd6, 0xde, 0x58, 0x77, 0x96, 0xcd, 0x72, |
491 | 0x3c02401a, 0x00621825, 0x0e0014cc, 0xaca3001c, 0x3c029000, 0x34420001, | 491 | 0xb5, 0x5c, 0x4c, 0x70, 0x3d, 0x9a, 0xde, 0xb3, 0x84, 0xa6, 0xb5, 0xba, |
492 | 0x02821025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, | 492 | 0x84, 0xdc, 0xb5, 0x62, 0xe3, 0x3b, 0x2a, 0xba, 0x34, 0x2e, 0xee, 0x21, |
493 | 0x00000000, 0x93630023, 0x3c028000, 0x34420001, 0x02821025, 0x34630008, | 493 | 0xbb, 0xe7, 0xb5, 0x0e, 0xfd, 0xaa, 0xba, 0xb7, 0x5c, 0x3c, 0x53, 0x4f, |
494 | 0xa3630023, 0xaf420020, 0x92c2000a, 0x30420020, 0x1040008e, 0x8fa2001c, | 494 | 0xbf, 0x4d, 0xff, 0x4b, 0xe8, 0x77, 0x15, 0xf4, 0xe3, 0x77, 0x03, 0xef, |
495 | 0x93620023, 0x30420001, 0x14400035, 0x3c020800, 0x8c430020, 0x10600023, | 495 | 0xef, 0x8a, 0x7a, 0xc0, 0xb9, 0x52, 0xe4, 0x78, 0x9e, 0x38, 0x4e, 0x88, |
496 | 0x3c029000, 0x0e00148e, 0x00000000, 0x8f840018, 0x8ec30000, 0xac830000, | 496 | 0xcc, 0x2e, 0x50, 0x0f, 0xe8, 0xc8, 0xff, 0xeb, 0xe2, 0xde, 0x9d, 0x60, |
497 | 0x92c2000a, 0x8f830018, 0x00021600, 0xac620004, 0x8f840018, 0x8f620040, | 497 | 0xfa, 0xb2, 0x7d, 0x8f, 0xbc, 0x70, 0x99, 0xd8, 0xc6, 0xdf, 0x8d, 0x7d, |
498 | 0xac820008, 0x8f850018, 0x8f63004c, 0xaca3000c, 0x9362003f, 0x8f840018, | 498 | 0x94, 0xcb, 0x2f, 0xc5, 0x5c, 0xfa, 0xb3, 0xee, 0x73, 0x9d, 0xaa, 0x76, |
499 | 0x304200ff, 0xac820010, 0x8f830018, 0x3c026000, 0xac600014, 0x8f850018, | 499 | 0x5f, 0x7b, 0x57, 0xed, 0x53, 0x1d, 0xf9, 0xcc, 0x34, 0x90, 0xcf, 0x8c, |
500 | 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, | 500 | 0xdc, 0xa3, 0x6f, 0xa6, 0x71, 0xbc, 0x9a, 0x9a, 0xfc, 0xef, 0x5e, 0xae, |
501 | 0x3c02401a, 0x00621825, 0x0e0014cc, 0xaca3001c, 0x3c029000, 0x34420001, | 501 | 0x26, 0xb6, 0x8d, 0x22, 0x0a, 0xbf, 0xac, 0xd7, 0x4e, 0xe3, 0xa4, 0x61, |
502 | 0x02821025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, | 502 | 0x93, 0x3a, 0xad, 0x69, 0xd2, 0x60, 0xc7, 0x4b, 0x12, 0x29, 0xa5, 0xa4, |
503 | 0x00000000, 0x93630023, 0x3c028000, 0x34420001, 0x02821025, 0x34630001, | 503 | 0x52, 0x55, 0x45, 0x60, 0xa9, 0x21, 0x4e, 0xda, 0x0a, 0x71, 0x70, 0x0b, |
504 | 0xa3630023, 0xaf420020, 0x93620023, 0x30420040, 0x10400052, 0x8fa2001c, | 504 | 0x48, 0x51, 0xc5, 0x21, 0x4d, 0xd3, 0x7b, 0x85, 0x84, 0x54, 0xa1, 0x8a, |
505 | 0x16600020, 0x3c120800, 0x8e420020, 0x8f70004c, 0x1040003c, 0x3c029000, | 505 | 0x46, 0x4e, 0x02, 0x15, 0x4a, 0xe5, 0x0a, 0x96, 0x72, 0x41, 0xa2, 0xd8, |
506 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac540000, 0x8f840018, 0x24020001, | 506 | 0x8e, 0x02, 0x52, 0x2a, 0xf7, 0xca, 0x85, 0xba, 0xbf, 0x08, 0x89, 0x03, |
507 | 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, | 507 | 0x70, 0x06, 0x29, 0x2a, 0x3f, 0xe2, 0xc0, 0x8d, 0x1b, 0x54, 0x5d, 0xde, |
508 | 0xac600010, 0x8f820018, 0xac500014, 0x8f850018, 0x3c026000, 0x8c434448, | 508 | 0x37, 0xb3, 0x63, 0xaf, 0x77, 0xd7, 0x8e, 0x03, 0x11, 0x07, 0x27, 0xbb, |
509 | 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, 0x3c024010, | 509 | 0xf6, 0xcc, 0xce, 0xec, 0xcc, 0x37, 0x6f, 0xbe, 0xf7, 0x37, 0xfd, 0xbe, |
510 | 0x00621825, 0x0e0014cc, 0xaca3001c, 0x8e420020, 0x1040001e, 0x3c029000, | 510 | 0x78, 0x8d, 0x5a, 0xdb, 0x5b, 0xf3, 0x55, 0xec, 0xe7, 0xaf, 0x37, 0x18, |
511 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac540000, 0x8f840018, 0x3c02008d, | 511 | 0x57, 0xed, 0xba, 0xe4, 0xa9, 0xf5, 0xe3, 0x9a, 0x72, 0xd9, 0x1b, 0xf0, |
512 | 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, | 512 | 0xfe, 0xc7, 0x68, 0x51, 0xd8, 0x86, 0x94, 0xad, 0xee, 0xc5, 0x40, 0x9b, |
513 | 0xac600010, 0x8f840018, 0x240207ee, 0xac820014, 0x8f850018, 0x3c026000, | 513 | 0xd9, 0xff, 0x33, 0x16, 0x03, 0x3e, 0x9b, 0x68, 0xad, 0x6d, 0x8a, 0xed, |
514 | 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, | 514 | 0x71, 0xd9, 0x16, 0xde, 0xda, 0xc2, 0xb6, 0x10, 0x3c, 0x16, 0xfd, 0x9e, |
515 | 0x3c024019, 0x00621825, 0x0e0014cc, 0xaca3001c, 0x3c029000, 0x34420001, | 515 | 0xb1, 0xa8, 0xc9, 0xea, 0xa1, 0x16, 0xed, 0x74, 0x88, 0x21, 0xbf, 0x9d, |
516 | 0x02821025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, | 516 | 0x67, 0x6c, 0x05, 0xca, 0xce, 0x4f, 0x5d, 0x36, 0x3c, 0xe0, 0x73, 0xdc, |
517 | 0x00000000, 0x93630023, 0x3c028000, 0x34420001, 0x02821025, 0x306300bf, | 517 | 0x59, 0xeb, 0xc0, 0x27, 0xb5, 0x9d, 0x1a, 0x51, 0xed, 0x01, 0x8f, 0xc9, |
518 | 0xa3630023, 0xaf420020, 0x8fa2001c, 0x1040000e, 0x8fa20014, 0x92c2000a, | 518 | 0xc5, 0x45, 0x82, 0xbe, 0x86, 0x36, 0xe3, 0x82, 0xe3, 0xfa, 0x39, 0x14, |
519 | 0xa3620082, 0x57c00005, 0x37de0008, 0x8fa30014, 0x10600004, 0x00000000, | 519 | 0x8f, 0xf1, 0xfa, 0x1b, 0x88, 0xe5, 0x70, 0xda, 0x3f, 0xd9, 0x76, 0xae, |
520 | 0x37de0008, 0x0a000b75, 0x24170001, 0x0e0012cf, 0x02802021, 0x8fa20014, | 520 | 0x9c, 0xe5, 0xbd, 0x42, 0xd4, 0x63, 0xbd, 0xef, 0x52, 0xdb, 0x82, 0xa8, |
521 | 0x10400003, 0x00000000, 0x37de0010, 0x24170001, 0x12e00020, 0x3c029000, | 521 | 0x27, 0xe3, 0x20, 0x1c, 0x1d, 0xd0, 0xe1, 0xe2, 0x8d, 0x74, 0x3f, 0xff, |
522 | 0x34420001, 0x02821025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, | 522 | 0x9e, 0x13, 0xcc, 0xdd, 0x7f, 0xdd, 0x1d, 0x36, 0x3f, 0x34, 0x64, 0xae, |
523 | 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, 0x03c21025, 0xa362007d, | 523 | 0xde, 0x56, 0xdc, 0x5d, 0xd9, 0x89, 0x06, 0x85, 0xaf, 0xc1, 0xad, 0x7b, |
524 | 0x8f640074, 0x34630001, 0x02831825, 0xaf430020, 0x04810006, 0x3c038000, | 524 | 0x41, 0x76, 0x5d, 0xe0, 0x3d, 0x7c, 0xa8, 0xba, 0x7f, 0xef, 0x84, 0x7d, |
525 | 0x02802021, 0x0e000470, 0x2405082a, 0x0a000b9b, 0x00000000, 0x8f4201f8, | 525 | 0xe8, 0x99, 0x16, 0x62, 0x1d, 0x44, 0x8e, 0xe5, 0x2b, 0x53, 0xc8, 0x45, |
526 | 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, 0xaf5401c0, 0xa34201c4, | 526 | 0xaa, 0xe6, 0xef, 0x78, 0xf3, 0x3c, 0x20, 0x3f, 0x55, 0x9e, 0x87, 0xca, |
527 | 0xaf4301f8, 0x9363003f, 0x24020012, 0x14620004, 0x8fbf004c, 0x0e00140d, | 527 | 0x23, 0xc5, 0x7b, 0x24, 0x02, 0xf2, 0x3c, 0xdc, 0x32, 0x18, 0xf5, 0xea, |
528 | 0x00000000, 0x8fbf004c, 0x8fbe0048, 0x8fb70044, 0x8fb60040, 0x8fb5003c, | 528 | 0xdf, 0xc3, 0x2d, 0x7f, 0x57, 0x1c, 0xf9, 0x5b, 0xf0, 0xd8, 0xe3, 0x97, |
529 | 0x8fb40038, 0x8fb30034, 0x8fb20030, 0x8fb1002c, 0x8fb00028, 0x03e00008, | 529 | 0xf3, 0x6a, 0x2d, 0x20, 0xe7, 0x43, 0xf1, 0x94, 0xde, 0x00, 0x9e, 0x12, |
530 | 0x27bd0050, 0x27bdffe8, 0xafbf0014, 0xafb00010, 0x8f500180, 0x97420184, | 530 | 0x9c, 0xeb, 0xa1, 0xa5, 0x2f, 0xf2, 0x5e, 0x7e, 0x08, 0x7b, 0xb9, 0x51, |
531 | 0x30420200, 0x14400015, 0x00000000, 0x8f430188, 0x3c02ff00, 0x00621824, | 531 | 0x8b, 0xe9, 0x95, 0x72, 0xf0, 0xdc, 0x3a, 0x64, 0xa2, 0xca, 0xb9, 0x81, |
532 | 0x3c020200, 0x10620031, 0x0043102b, 0x14400007, 0x3c020300, 0x1060000b, | 532 | 0x5c, 0x44, 0x2c, 0x3c, 0xe6, 0xba, 0xe4, 0x60, 0x11, 0xbf, 0xa9, 0x58, |
533 | 0x3c020100, 0x1062000d, 0x00000000, 0x0a000c2c, 0x00000000, 0x10620027, | 533 | 0x52, 0xa5, 0x47, 0xbd, 0x23, 0xf2, 0x0c, 0xbe, 0x1b, 0x3f, 0xcc, 0x1c, |
534 | 0x3c020400, 0x1062003e, 0x02002021, 0x0a000c2c, 0x00000000, 0x0e000c31, | 534 | 0x18, 0xf2, 0x13, 0x76, 0xa6, 0x43, 0x0e, 0x1f, 0xbe, 0xcc, 0xbf, 0x8d, |
535 | 0x02002021, 0x0a000c2e, 0x8fbf0014, 0x93620005, 0x30420020, 0x1440005e, | 535 | 0x39, 0xd7, 0x92, 0x8b, 0xca, 0x6b, 0xa5, 0x4b, 0xfd, 0xd0, 0x41, 0xe6, |
536 | 0x8fbf0014, 0x3c029000, 0x34420001, 0x02021025, 0xaf420020, 0x3c038000, | 536 | 0x6f, 0x0e, 0x2f, 0xad, 0xb3, 0x41, 0xc4, 0x53, 0xda, 0xdb, 0x74, 0xa1, |
537 | 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, 0x93620005, 0x3c038000, | 537 | 0xd8, 0x0c, 0x83, 0xf5, 0xf8, 0x4b, 0x79, 0x38, 0x4f, 0x42, 0x70, 0x9e, |
538 | 0x34630001, 0x02031825, 0x34420020, 0xa3620005, 0xaf430020, 0x93620005, | 538 | 0x9f, 0x3a, 0xc2, 0xe6, 0x44, 0x4f, 0xb3, 0x38, 0x9c, 0x53, 0x55, 0xfc, |
539 | 0x30420020, 0x14400003, 0x02002021, 0x0000000d, 0x02002021, 0x0e000766, | 539 | 0xa9, 0x72, 0xaa, 0x6f, 0x8f, 0x3a, 0x10, 0xa7, 0xe6, 0xc7, 0x04, 0xe6, |
540 | 0x24055854, 0x0a000c2e, 0x8fbf0014, 0x93620005, 0x30420001, 0x1040003f, | 540 | 0x1f, 0xfa, 0x9c, 0x5a, 0x87, 0xd0, 0xeb, 0x10, 0xf3, 0x87, 0x76, 0x8d, |
541 | 0x3c029000, 0x34420001, 0x02021025, 0xaf420020, 0x3c038000, 0x8f420020, | 541 | 0x06, 0x6b, 0xb0, 0x66, 0x13, 0x2f, 0x50, 0x2b, 0xb1, 0x7f, 0xc9, 0xd1, |
542 | 0x00431024, 0x1440fffd, 0x00000000, 0x93620023, 0x34420004, 0xa3620023, | 542 | 0x0a, 0x9d, 0xed, 0x69, 0xa6, 0xf3, 0x9e, 0x08, 0xd4, 0x79, 0x83, 0x72, |
543 | 0x93630005, 0x3c048000, 0x3c020800, 0x306300fe, 0xa3630005, 0x8c430020, | 543 | 0xa4, 0xcc, 0x80, 0x1c, 0x29, 0x37, 0x0e, 0x75, 0x17, 0x0e, 0xe3, 0x2e, |
544 | 0x34840001, 0x02042025, 0x0a000c0a, 0xaf440020, 0x00002821, 0x00003021, | 544 | 0x2e, 0x30, 0xc0, 0xdc, 0xb9, 0x8b, 0xf1, 0x04, 0xee, 0x1c, 0xa5, 0xd0, |
545 | 0x0e000fb1, 0x240708d9, 0x3c020800, 0x8c430020, 0x10600023, 0x8fbf0014, | 545 | 0x07, 0x6e, 0xee, 0xec, 0xf7, 0x13, 0x49, 0x5c, 0xfe, 0xdb, 0xdc, 0xa9, |
546 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac500000, 0x93630082, 0x9362003f, | 546 | 0xa0, 0x7e, 0x27, 0x7c, 0xfd, 0x86, 0x1c, 0x9f, 0x6c, 0xc8, 0x13, 0x82, |
547 | 0x8f840018, 0x00031a00, 0x00431025, 0xac820004, 0x8f830018, 0xac600008, | 547 | 0x38, 0xfe, 0x4e, 0xf7, 0xd3, 0xbb, 0xf6, 0xd1, 0xa6, 0x09, 0xfd, 0x70, |
548 | 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, 0x8f820018, 0xac400014, | 548 | 0x74, 0xb1, 0xba, 0xee, 0x5f, 0xf0, 0xd9, 0xb9, 0xc1, 0x67, 0x43, 0xc2, |
549 | 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, | 549 | 0x27, 0xd7, 0x25, 0xf6, 0x90, 0x9d, 0x93, 0x61, 0x9d, 0x1e, 0x19, 0x66, |
550 | 0x944358ce, 0x8f850018, 0x3c02400a, 0x00621825, 0x0e0014cc, 0xaca3001c, | 550 | 0xf7, 0xd4, 0xec, 0xfc, 0x88, 0x21, 0xec, 0x73, 0x74, 0x0e, 0xb9, 0xef, |
551 | 0x0a000c2e, 0x8fbf0014, 0x0000000d, 0x8fbf0014, 0x8fb00010, 0x03e00008, | 551 | 0x14, 0x1a, 0xc6, 0xa5, 0xe2, 0x3b, 0xe9, 0x1b, 0x38, 0x77, 0x04, 0xb2, |
552 | 0x27bd0018, 0x27bdffe8, 0xafbf0010, 0x8f420188, 0x00803021, 0x93640000, | 552 | 0x1b, 0xf2, 0xfc, 0xf4, 0x6c, 0xd8, 0x34, 0x1c, 0x1f, 0x03, 0xfc, 0x08, |
553 | 0x24030020, 0x00021402, 0x10830008, 0x304500ff, 0x3c036018, 0x8c625000, | 553 | 0xc0, 0xa9, 0x7a, 0x7e, 0x90, 0x0d, 0x3d, 0x68, 0x0e, 0x87, 0x7c, 0x73, |
554 | 0x34420400, 0xac625000, 0x0000000d, 0x00000000, 0x24000955, 0x9363003f, | 554 | 0x28, 0xf1, 0x06, 0x6e, 0x8f, 0x58, 0xbc, 0x83, 0x9e, 0x38, 0xc5, 0x9d, |
555 | 0x24020012, 0x14620023, 0x3c029000, 0x34420001, 0x3c038000, 0x00c21025, | 555 | 0x18, 0x93, 0xee, 0x80, 0x78, 0x41, 0xc4, 0xfa, 0xf9, 0xfa, 0xcb, 0xef, |
556 | 0xaf650178, 0xa365007a, 0xaf420020, 0x8f420020, 0x00431024, 0x1440fffd, | 556 | 0x7c, 0x51, 0xf3, 0xaf, 0xad, 0x49, 0x6d, 0xba, 0x3c, 0xad, 0x4d, 0x15, |
557 | 0x00000000, 0x9362007d, 0x3c038000, 0xa362007d, 0x8f640074, 0x34630001, | 557 | 0x51, 0xee, 0xa2, 0x56, 0xdb, 0x97, 0x36, 0x5d, 0x1c, 0x11, 0x7c, 0x30, |
558 | 0x00c31825, 0xaf430020, 0x04810006, 0x3c038000, 0x00c02021, 0x0e000470, | 558 | 0x79, 0xad, 0x42, 0x78, 0x4f, 0xdb, 0xbe, 0x25, 0xb8, 0xed, 0x80, 0x0f, |
559 | 0x24050963, 0x0a000c79, 0x8fbf0010, 0x8f4201f8, 0x00431024, 0x1440fffd, | 559 | 0xab, 0x8a, 0x73, 0x18, 0x2d, 0xbc, 0x97, 0xb4, 0xbd, 0xb8, 0xb9, 0x8e, |
560 | 0x24020002, 0x3c031000, 0xaf4601c0, 0xa34201c4, 0xaf4301f8, 0x0a000c79, | 560 | 0x5b, 0xbe, 0x3f, 0x1d, 0x20, 0xdf, 0x9b, 0xd9, 0x0a, 0x91, 0xbf, 0x29, |
561 | 0x8fbf0010, 0x9362007e, 0x1445000e, 0x00000000, 0x8f620178, 0x1045000b, | 561 | 0xe2, 0xb2, 0xa9, 0x68, 0x21, 0xde, 0xf1, 0x30, 0xe2, 0x7b, 0xe1, 0xd7, |
562 | 0x00000000, 0x8f820000, 0xaf650178, 0x8f660178, 0x8f440180, 0x8f65004c, | 562 | 0xa8, 0x62, 0xe1, 0x6e, 0x30, 0x16, 0xaa, 0xf6, 0x60, 0x1d, 0xb9, 0xa3, |
563 | 0x8c430000, 0x0060f809, 0x30c600ff, 0x0a000c79, 0x8fbf0010, 0xaf650178, | 563 | 0x2c, 0x8b, 0xc3, 0xe9, 0x5e, 0x0a, 0x99, 0x28, 0xff, 0x6c, 0xe2, 0x3e, |
564 | 0x8fbf0010, 0x03e00008, 0x27bd0018, 0x27bdffe8, 0xafbf0010, 0x93630000, | 564 | 0x1d, 0x73, 0x78, 0x09, 0xfc, 0x3c, 0xb2, 0xde, 0x4c, 0x0b, 0x76, 0xe1, |
565 | 0x24020020, 0x10620005, 0x00000000, 0x93630000, 0x24020030, 0x1462004d, | 565 | 0x60, 0x7f, 0x46, 0x84, 0x65, 0xf3, 0x67, 0xbd, 0xad, 0xf9, 0x33, 0x54, |
566 | 0x8fbf0010, 0x93420148, 0x2444ffff, 0x2c830005, 0x10600047, 0x3c020800, | 566 | 0x39, 0xd4, 0xed, 0xa2, 0x35, 0x0b, 0x71, 0x92, 0xf0, 0x2f, 0x75, 0x77, |
567 | 0x24425800, 0x00041880, 0x00621821, 0x8c640000, 0x00800008, 0x00000000, | 567 | 0xb4, 0x9b, 0x41, 0xf2, 0x4f, 0xc5, 0x7e, 0x82, 0x1f, 0xc9, 0xb9, 0xba, |
568 | 0x8f430144, 0x8f62000c, 0x14620006, 0x24020001, 0xaf62000c, 0x0e000d59, | 568 | 0x41, 0x98, 0x3b, 0x9b, 0xbe, 0x6f, 0x30, 0x57, 0xdb, 0xb1, 0x29, 0x37, |
569 | 0x00000000, 0x0a000cd1, 0x8fbf0010, 0x8f62000c, 0x0a000cca, 0x00000000, | 569 | 0x9f, 0x2b, 0xc3, 0x33, 0x57, 0xd8, 0x8b, 0x9a, 0xcd, 0x95, 0xf2, 0x43, |
570 | 0x97630010, 0x8f420144, 0x14430006, 0x24020001, 0xa7620010, 0x0e00137a, | 570 | 0x2a, 0xdf, 0xdc, 0x51, 0xc8, 0x93, 0x45, 0xf7, 0x5c, 0xed, 0x8c, 0x7f, |
571 | 0x00000000, 0x0a000cd1, 0x8fbf0010, 0x97620010, 0x0a000cca, 0x00000000, | 571 | 0x4e, 0xce, 0xd9, 0x4e, 0xfb, 0xe0, 0x1a, 0x8f, 0x43, 0x34, 0xd0, 0x76, |
572 | 0x97630012, 0x8f420144, 0x14430006, 0x24020001, 0xa7620012, 0x0e001395, | 572 | 0x12, 0x2c, 0x33, 0xfc, 0x6b, 0xeb, 0x86, 0x5c, 0x5b, 0xcc, 0x2b, 0x9e, |
573 | 0x00000000, 0x0a000cd1, 0x8fbf0010, 0x97620012, 0x0a000cca, 0x00000000, | 573 | 0x6f, 0xb8, 0xb6, 0xb0, 0x0f, 0x5c, 0x70, 0xf6, 0x81, 0xd3, 0x3e, 0x7d, |
574 | 0x97630014, 0x8f420144, 0x14430006, 0x24020001, 0xa7620014, 0x0e0013bb, | 574 | 0x51, 0xd9, 0xbc, 0xff, 0xab, 0xed, 0x0d, 0xcf, 0x7d, 0x22, 0xce, 0xe9, |
575 | 0x00000000, 0x0a000cd1, 0x8fbf0010, 0x97620014, 0x0a000cca, 0x00000000, | 575 | 0xc8, 0x91, 0xdc, 0x47, 0xce, 0x37, 0xe4, 0x61, 0x3d, 0xdb, 0x5c, 0xa7, |
576 | 0x97630016, 0x8f420144, 0x14430006, 0x24020001, 0xa7620016, 0x0e0013be, | 576 | 0x6a, 0xee, 0x91, 0x73, 0x01, 0x79, 0x99, 0xa5, 0xf3, 0xf9, 0xc7, 0x06, |
577 | 0x00000000, 0x0a000cd1, 0x8fbf0010, 0x97620016, 0x14400006, 0x8fbf0010, | 577 | 0x75, 0xf7, 0x53, 0xa4, 0x1a, 0xd3, 0x72, 0x40, 0xf0, 0x61, 0xb7, 0xbe, |
578 | 0x3c030800, 0x8c620070, 0x24420001, 0xac620070, 0x8fbf0010, 0x03e00008, | 578 | 0xbc, 0xec, 0xe4, 0x28, 0xe6, 0x5c, 0x63, 0xb0, 0x9c, 0xcf, 0x36, 0x89, |
579 | 0x27bd0018, 0x27bdffe0, 0x3c029000, 0xafbf001c, 0xafb20018, 0xafb10014, | 579 | 0xa7, 0x6f, 0x25, 0x9e, 0x63, 0xc0, 0x23, 0x37, 0xbd, 0x73, 0x35, 0xa1, |
580 | 0xafb00010, 0x8f500140, 0x34420001, 0x3c038000, 0x02021025, 0xaf420020, | 580 | 0x65, 0xf2, 0xa8, 0xb3, 0x87, 0xce, 0xea, 0x9f, 0xf0, 0x18, 0x3d, 0xb1, |
581 | 0x8f420020, 0x00431024, 0x1440fffd, 0x24020012, 0x24030080, 0xa362003f, | 581 | 0x23, 0xe2, 0x9c, 0x11, 0xe0, 0xd2, 0xb6, 0x97, 0xcd, 0x0e, 0x5a, 0x94, |
582 | 0xa3630082, 0x93620023, 0x30420040, 0x10400007, 0x00008821, 0x93620023, | 582 | 0x7e, 0x46, 0x9a, 0xfa, 0xf8, 0x12, 0x15, 0x85, 0x7f, 0x0b, 0xb9, 0x51, |
583 | 0x24110001, 0x304200bf, 0xa3620023, 0x0a000cf0, 0x3c028000, 0x3c028000, | 583 | 0xb0, 0x71, 0xc3, 0x47, 0x87, 0xe7, 0xf0, 0xf7, 0x1b, 0x13, 0x8e, 0xcc, |
584 | 0x34420001, 0x3c039000, 0x34630001, 0x3c048000, 0x02021025, 0x02031825, | 584 | 0xfd, 0x93, 0x31, 0x8c, 0x7a, 0x38, 0x0b, 0x01, 0xeb, 0x9d, 0x34, 0xc9, |
585 | 0xaf420020, 0xaf430020, 0x8f420020, 0x00441024, 0x1440fffd, 0x00000000, | 585 | 0x31, 0xb9, 0x1d, 0x71, 0x4e, 0x80, 0x8c, 0xcd, 0xbb, 0x5d, 0xde, 0x8e, |
586 | 0x9362007d, 0x3c038000, 0x34420020, 0xa362007d, 0x8f640074, 0x34630001, | 586 | 0x4f, 0xa1, 0x55, 0xbd, 0xe4, 0xeb, 0x68, 0xd8, 0xfc, 0x72, 0xcf, 0xf6, |
587 | 0x02031825, 0xaf430020, 0x04810006, 0x3c038000, 0x02002021, 0x0e000470, | 587 | 0x7d, 0x0a, 0x2a, 0x77, 0x5f, 0x71, 0x58, 0x75, 0x2d, 0x73, 0x69, 0xc1, |
588 | 0x24050a63, 0x0a000d13, 0x00000000, 0x8f4201f8, 0x00431024, 0x1440fffd, | 588 | 0x99, 0xe7, 0xd7, 0x55, 0xde, 0x6d, 0x77, 0x40, 0xde, 0x6d, 0x88, 0xe6, |
589 | 0x24020002, 0x3c031000, 0xaf5001c0, 0xa34201c4, 0xaf4301f8, 0x1220003f, | 589 | 0x84, 0xaf, 0x2e, 0x44, 0x39, 0x47, 0x37, 0x93, 0x9c, 0x5a, 0xd9, 0x6a, |
590 | 0x3c120800, 0x8e420020, 0x8f71004c, 0x1040003c, 0x8fbf001c, 0x0e00148e, | 590 | 0x23, 0x4e, 0xfc, 0x29, 0xee, 0xdd, 0x39, 0xf9, 0x7c, 0x5f, 0x04, 0xcf, |
591 | 0x00000000, 0x8f820018, 0xac500000, 0x8f840018, 0x24020001, 0xac820004, | 591 | 0x46, 0x4e, 0xb5, 0x2d, 0x62, 0xf1, 0x33, 0xa2, 0x5c, 0xa7, 0xa7, 0x1c, |
592 | 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, | 592 | 0xdf, 0x17, 0xd5, 0x33, 0x3b, 0xb9, 0x7c, 0x8a, 0x64, 0x0e, 0x7d, 0x27, |
593 | 0x8f820018, 0xac510014, 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, | 593 | 0xcd, 0x15, 0x9b, 0xf5, 0x6b, 0x1f, 0xe2, 0x81, 0xe3, 0xf0, 0x95, 0x0a, |
594 | 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, 0x3c024010, 0x00621825, | 594 | 0xbf, 0x95, 0xa1, 0xfa, 0x80, 0x3e, 0xb5, 0x57, 0xfb, 0x04, 0xf9, 0x14, |
595 | 0x0e0014cc, 0xaca3001c, 0x8e420020, 0x1040001e, 0x8fbf001c, 0x0e00148e, | 595 | 0x12, 0x7e, 0x05, 0xbe, 0x76, 0xda, 0x99, 0x23, 0x77, 0xbf, 0xc2, 0xdc, |
596 | 0x00000000, 0x8f820018, 0xac500000, 0x8f840018, 0x3c02008d, 0xac820004, | 596 | 0x2f, 0x3c, 0xa7, 0xd3, 0x55, 0xb6, 0xd3, 0x55, 0xb6, 0x36, 0x5e, 0x3a, |
597 | 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, | 597 | 0xeb, 0x54, 0x0b, 0xe5, 0x1f, 0x59, 0x2f, 0xfd, 0x56, 0xd8, 0xe6, 0xe6, |
598 | 0x8f840018, 0x24020a6a, 0xac820014, 0x8f850018, 0x3c026000, 0x8c434448, | 598 | 0xb3, 0x06, 0x2d, 0xac, 0xf7, 0xf2, 0x27, 0xc6, 0x1f, 0x94, 0xdb, 0xcb, |
599 | 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, 0x3c024019, | 599 | 0xff, 0xdd, 0x9c, 0xa2, 0x5f, 0xc4, 0x02, 0xb6, 0xce, 0x07, 0x83, 0xf1, |
600 | 0x00621825, 0x0e0014cc, 0xaca3001c, 0x8fbf001c, 0x8fb20018, 0x8fb10014, | 600 | 0x1f, 0xbc, 0x6e, 0x13, 0x01, 0xeb, 0xb6, 0xf9, 0xbe, 0x22, 0xf7, 0x93, |
601 | 0x8fb00010, 0x03e00008, 0x27bd0020, 0x27bdffe8, 0xafbf0010, 0x93620081, | 601 | 0xe4, 0x95, 0x8a, 0x23, 0xaf, 0x36, 0x69, 0xd0, 0x27, 0xa7, 0x82, 0xd6, |
602 | 0x3c030800, 0x8c640048, 0x0044102b, 0x14400005, 0x00000000, 0x0e000cd3, | 602 | 0x29, 0xfa, 0x78, 0xca, 0xe9, 0xe3, 0x9b, 0xa2, 0x3f, 0xe3, 0x54, 0xa8, |
603 | 0x00000000, 0x0a000da4, 0x8fbf0010, 0x93620081, 0x24420001, 0x0e0013c4, | 603 | 0xe6, 0x0d, 0x1f, 0xe1, 0xeb, 0x98, 0xb2, 0xd1, 0x35, 0x90, 0xab, 0xdf, |
604 | 0xa3620081, 0x9763006a, 0x00032880, 0x14a00002, 0x00403821, 0x24050001, | 604 | 0x6c, 0x43, 0xc6, 0x04, 0x71, 0xb2, 0x03, 0x01, 0xfa, 0x80, 0xee, 0xd2, |
605 | 0x97630068, 0x93640081, 0x3c020800, 0x8c46004c, 0x00652821, 0x00852804, | 605 | 0x07, 0xe2, 0x55, 0x7d, 0x60, 0x45, 0xe8, 0x09, 0xbb, 0x1c, 0x1d, 0x34, |
606 | 0x00c5102b, 0x54400001, 0x00a03021, 0x3c020800, 0x8c440050, 0x00c4182b, | 606 | 0xd8, 0x16, 0x97, 0xcb, 0xe3, 0xcc, 0x1b, 0xd8, 0xf8, 0xa4, 0x1d, 0x7d, |
607 | 0x54600001, 0x00c02021, 0x8f420074, 0x2403fffe, 0x00832824, 0x00a21021, | 607 | 0xda, 0xaa, 0x9e, 0x99, 0xc3, 0xba, 0x65, 0x8d, 0x4b, 0xfb, 0xe5, 0x09, |
608 | 0xaf62000c, 0x10e00021, 0x3c029000, 0x8f450140, 0x34420001, 0x3c038000, | 608 | 0xce, 0xac, 0xa8, 0xcc, 0x3e, 0x30, 0xa3, 0xa4, 0xa5, 0x93, 0xf1, 0xa9, |
609 | 0x00a21025, 0xaf420020, 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, | 609 | 0x50, 0x84, 0x16, 0xac, 0x28, 0x15, 0xac, 0x14, 0x73, 0x70, 0xf0, 0xe3, |
610 | 0x9362007d, 0x3c038000, 0x34420004, 0xa362007d, 0x8f640074, 0x34630001, | 610 | 0xd0, 0x80, 0x46, 0x11, 0x96, 0x35, 0x11, 0x2a, 0x95, 0x94, 0x4e, 0x76, |
611 | 0x00a31825, 0xaf430020, 0x04810006, 0x3c038000, 0x00a02021, 0x0e000470, | 611 | 0x86, 0xc8, 0x2c, 0xc6, 0xa4, 0x0d, 0x9b, 0x71, 0x9a, 0x1f, 0x33, 0xe6, |
612 | 0x24050a92, 0x0a000da4, 0x8fbf0010, 0x8f4201f8, 0x00431024, 0x1440fffd, | 612 | 0x49, 0x43, 0xcc, 0x8b, 0x93, 0xa3, 0x0e, 0x0c, 0x8a, 0x38, 0x4b, 0xfd, |
613 | 0x24020002, 0x3c031000, 0xaf4501c0, 0xa34201c4, 0xaf4301f8, 0x8fbf0010, | 613 | 0xe5, 0x91, 0x28, 0xb5, 0xa7, 0xa5, 0xcd, 0x68, 0x86, 0xdb, 0xf8, 0xc2, |
614 | 0x03e00008, 0x27bd0018, 0x27bdffd8, 0xafb3001c, 0x27530100, 0xafbf0024, | 614 | 0x8a, 0xd1, 0x95, 0x7c, 0xd2, 0x38, 0xc1, 0xed, 0x64, 0xac, 0x64, 0x62, |
615 | 0xafb40020, 0xafb20018, 0xafb10014, 0xafb00010, 0x96620008, 0x3c140800, | 615 | 0x92, 0x9f, 0x5d, 0x2c, 0x45, 0x28, 0x67, 0x45, 0xa8, 0x50, 0x4a, 0x19, |
616 | 0x8f520100, 0x30420001, 0x104000da, 0x00000000, 0x8e700018, 0x8f630054, | 616 | 0x43, 0x6d, 0xa2, 0xcd, 0x18, 0xda, 0x7c, 0x49, 0x1f, 0x33, 0x4e, 0x92, |
617 | 0x2602ffff, 0x00431023, 0x18400006, 0x00000000, 0x0000000d, 0x00000000, | 617 | 0xbb, 0xcd, 0xaf, 0x9c, 0x36, 0xbd, 0x6d, 0xfd, 0x61, 0xe3, 0xfe, 0x44, |
618 | 0x2400015c, 0x0a000dea, 0x00008821, 0x8f62004c, 0x02021023, 0x18400028, | 618 | 0xa8, 0x32, 0x7b, 0x9f, 0xf1, 0x92, 0x5b, 0x9d, 0x60, 0xd9, 0x14, 0x13, |
619 | 0x00008821, 0x93650120, 0x93640121, 0x3c030800, 0x8c62008c, 0x308400ff, | 619 | 0x67, 0xdb, 0x68, 0xe9, 0x34, 0xcb, 0x1d, 0x9c, 0x6d, 0x61, 0xd0, 0x62, |
620 | 0x24420001, 0x30a500ff, 0x00803821, 0x1485000b, 0xac62008c, 0x3c040800, | 620 | 0x39, 0x4e, 0xef, 0x57, 0xed, 0x07, 0x12, 0x43, 0x39, 0x91, 0x43, 0x84, |
621 | 0x8c830090, 0x24630001, 0xac830090, 0x93620122, 0x30420001, 0x00021023, | 621 | 0x33, 0x17, 0x2a, 0xb3, 0xbf, 0x9b, 0x5e, 0x7f, 0x3f, 0xeb, 0x5b, 0x1f, |
622 | 0x30420005, 0x0a000dea, 0x34510004, 0x27660100, 0x00041080, 0x00c21021, | 622 | 0xc5, 0x28, 0x72, 0x15, 0x71, 0xdd, 0x36, 0x5d, 0x1b, 0x4f, 0x5e, 0xd9, |
623 | 0x8c430000, 0x02031823, 0x04600004, 0x24820001, 0x30440007, 0x1485fff9, | 623 | 0x14, 0x79, 0x68, 0x09, 0x5a, 0x33, 0xa5, 0x3c, 0xcd, 0x71, 0xf9, 0x15, |
624 | 0x00041080, 0x10870007, 0x3c030800, 0xa3640121, 0x8c620094, 0x24110005, | 624 | 0x94, 0x5b, 0x4b, 0xd0, 0x3d, 0x91, 0x8f, 0xd6, 0x4e, 0x77, 0xf4, 0x18, |
625 | 0x24420001, 0x0a000dea, 0xac620094, 0x24110004, 0x32220001, 0x1040001e, | 625 | 0x85, 0x6e, 0x9a, 0xc6, 0xbc, 0xf0, 0x0b, 0x57, 0x66, 0x87, 0x86, 0x0d, |
626 | 0x8e820020, 0x1040001d, 0x32220004, 0x0e00148e, 0x00000000, 0x8f820018, | 626 | 0xd2, 0xae, 0xa2, 0x1e, 0xff, 0xbf, 0x89, 0xfb, 0x28, 0x61, 0x7e, 0x66, |
627 | 0xac520000, 0x8f840018, 0x24020001, 0xac820004, 0x8f830018, 0xac600008, | 627 | 0xac, 0x31, 0x5e, 0x49, 0xc3, 0xf1, 0x12, 0x64, 0xf3, 0x41, 0x89, 0xa5, |
628 | 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, 0x8f820018, 0xac500014, | 628 | 0x39, 0x23, 0x42, 0xd0, 0x5f, 0x61, 0x7b, 0xeb, 0x35, 0x27, 0x7b, 0xa4, |
629 | 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, | 629 | 0xfe, 0xe4, 0x3b, 0x9b, 0x43, 0x9f, 0x19, 0x71, 0x9f, 0xcf, 0x51, 0x7b, |
630 | 0x944358ce, 0x8f850018, 0x3c024010, 0x00621825, 0x0e0014cc, 0xaca3001c, | 630 | 0x66, 0xc6, 0x92, 0xef, 0xb9, 0x52, 0xee, 0xa5, 0x25, 0x6e, 0x7b, 0x64, |
631 | 0x32220004, 0x10400081, 0x00003821, 0x3c029000, 0x34420001, 0x3c038000, | 631 | 0xf8, 0x8c, 0x73, 0xa6, 0x0f, 0xff, 0xd9, 0x8b, 0x7b, 0x85, 0xb7, 0x7d, |
632 | 0x02421025, 0xa360007c, 0xaf420020, 0x8f420020, 0x00431024, 0x1440fffd, | 632 | 0x7d, 0x14, 0xc5, 0x3d, 0x0d, 0xe8, 0x3c, 0xc7, 0xb0, 0xe9, 0x87, 0xc5, |
633 | 0x00000000, 0x93620023, 0x30420080, 0x10400011, 0x00000000, 0x8f65005c, | 633 | 0xb8, 0xa7, 0xe2, 0x98, 0xcb, 0xb9, 0xb8, 0x3a, 0x97, 0x08, 0x65, 0xba, |
634 | 0x8f63004c, 0x9764003c, 0x8f620064, 0x00a32823, 0x00852821, 0x00a2102b, | 634 | 0xe9, 0x91, 0xd5, 0x45, 0x3f, 0x8b, 0xf3, 0x47, 0xf8, 0xba, 0x84, 0x9c, |
635 | 0x54400006, 0x3c023fff, 0x93620023, 0x3042007f, 0xa3620023, 0xaf700064, | 635 | 0xa3, 0x36, 0xca, 0x64, 0xbb, 0x69, 0xb3, 0x14, 0x66, 0x71, 0x05, 0xec, |
636 | 0x3c023fff, 0x0a000e37, 0x3442ffff, 0x8f62005c, 0x02021023, 0x04400011, | 636 | 0x44, 0xb9, 0x4c, 0x81, 0xa6, 0xd6, 0x5f, 0xeb, 0x83, 0x1f, 0x66, 0x52, |
637 | 0x00000000, 0x8f65005c, 0x8f630064, 0x9764003c, 0x3c023fff, 0x3442ffff, | 637 | 0xab, 0x61, 0xe9, 0x51, 0x00, 0x96, 0x7e, 0xa9, 0xc3, 0xd2, 0xd1, 0xbe, |
638 | 0xaf700064, 0x00a32823, 0x00852821, 0x0045102b, 0x10400004, 0x02051021, | 638 | 0xe6, 0x58, 0xea, 0x77, 0x62, 0xd6, 0xa3, 0x14, 0x71, 0x70, 0xf4, 0x39, |
639 | 0x3c053fff, 0x34a5ffff, 0x02051021, 0xaf62005c, 0x24070001, 0xaf70004c, | 639 | 0xe3, 0xe8, 0x3d, 0xc6, 0xd1, 0xf1, 0x06, 0x38, 0xd2, 0x3c, 0x38, 0x3a, |
640 | 0x8f620054, 0x16020005, 0x00000000, 0x93620023, 0x30420040, 0x10400017, | 640 | 0x51, 0x87, 0xa3, 0x6c, 0x5f, 0x33, 0x1c, 0x1d, 0x0f, 0xa1, 0xff, 0xcd, |
641 | 0x24020001, 0x9762006a, 0x00022880, 0x50a00001, 0x24050001, 0x97630068, | 641 | 0xd6, 0x32, 0xfa, 0xb0, 0x9f, 0x39, 0xbd, 0x49, 0xa5, 0xd5, 0xe4, 0xf8, |
642 | 0x93640081, 0x3c020800, 0x8c46004c, 0x00652821, 0x00852804, 0x00c5102b, | 642 | 0x24, 0x55, 0x90, 0x73, 0x92, 0x58, 0xa2, 0xb4, 0xe0, 0x76, 0x05, 0x81, |
643 | 0x54400001, 0x00a03021, 0x3c020800, 0x8c440050, 0x00c4182b, 0x54600001, | 643 | 0xbf, 0x2c, 0x8f, 0xc9, 0xae, 0x06, 0xe7, 0xaa, 0x24, 0x9c, 0x79, 0x93, |
644 | 0x00c02021, 0x8f420074, 0x2403fffe, 0x00832824, 0x00a21021, 0xaf62000c, | 644 | 0x73, 0x99, 0xc9, 0x57, 0x66, 0x1f, 0x32, 0x36, 0xee, 0x6d, 0xe8, 0x3a, |
645 | 0x93620082, 0x30420080, 0x50400001, 0xa3600081, 0x3c028000, 0x34420001, | 645 | 0x7e, 0x0b, 0xb1, 0x8c, 0xbc, 0xbb, 0x81, 0x73, 0x5b, 0xe2, 0x74, 0xdf, |
646 | 0x02421025, 0xaf420020, 0x9363007e, 0x9362007a, 0x10620004, 0x00000000, | 646 | 0x1a, 0xa0, 0x7b, 0xd6, 0x7e, 0xba, 0x6b, 0x0d, 0xd2, 0x03, 0x0b, 0x6d, |
647 | 0x0e0013c4, 0x00000000, 0x00403821, 0x10e0001f, 0x3c029000, 0x34420001, | 647 | 0x60, 0x0e, 0xf8, 0x5e, 0xcc, 0x81, 0x46, 0x33, 0x31, 0x2e, 0x53, 0xda, |
648 | 0x02421025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, | 648 | 0x4f, 0x95, 0x92, 0xc2, 0x35, 0xb0, 0x03, 0x0c, 0x35, 0xc6, 0x4e, 0xa6, |
649 | 0x00000000, 0x9362007d, 0x3c038000, 0xa362007d, 0x8f640074, 0x34630001, | 649 | 0x0e, 0x3b, 0xb2, 0x0e, 0x30, 0xb3, 0xe4, 0xb7, 0xad, 0xed, 0x32, 0xf8, |
650 | 0x02431825, 0xaf430020, 0x04810006, 0x3c038000, 0x02402021, 0x0e000470, | 650 | 0x5d, 0x0d, 0xc6, 0x56, 0x58, 0xc4, 0x91, 0x24, 0x47, 0x67, 0x42, 0x90, |
651 | 0x24050b3d, 0x0a000e8d, 0x00000000, 0x8f4201f8, 0x00431024, 0x1440fffd, | 651 | 0x59, 0xb7, 0x18, 0x53, 0x3c, 0x17, 0x3c, 0x7e, 0xda, 0xf5, 0x41, 0x96, |
652 | 0x24020002, 0x3c031000, 0xaf5201c0, 0xa34201c4, 0xaf4301f8, 0x9342010b, | 652 | 0x39, 0x4f, 0x09, 0x1b, 0xf4, 0x94, 0xa9, 0xc7, 0x33, 0x64, 0x5f, 0xd6, |
653 | 0x9343010b, 0x8e820020, 0x27500100, 0x38630006, 0x10400029, 0x2c710001, | 653 | 0xcc, 0x31, 0x91, 0xeb, 0xb6, 0x54, 0xf6, 0x9e, 0x31, 0x91, 0xe1, 0xb1, |
654 | 0x0e00148e, 0x00000000, 0x8f830018, 0x8e020000, 0xac620000, 0x8f840018, | 654 | 0x57, 0x78, 0xf4, 0xca, 0xa1, 0x76, 0xaa, 0x38, 0x31, 0x4c, 0x85, 0x55, |
655 | 0x96020008, 0xac820004, 0x8f830018, 0x8e020014, 0xac620008, 0x8f850018, | 655 | 0xdb, 0x7e, 0xc8, 0xfc, 0x7f, 0xcd, 0x84, 0xcc, 0xfe, 0xdb, 0xae, 0xc4, |
656 | 0x3c026000, 0x8c434448, 0xaca3000c, 0x8f840018, 0x96020012, 0xac820010, | 656 | 0x74, 0x5a, 0x36, 0x55, 0xdf, 0xee, 0x08, 0x7c, 0x31, 0x47, 0xa4, 0x77, |
657 | 0x8f850018, 0x8e030020, 0xaca30014, 0x9602000c, 0x9603000e, 0x8f840018, | 657 | 0x37, 0xaa, 0xaf, 0xc4, 0xbf, 0xe3, 0xbb, 0xbf, 0x04, 0x97, 0x59, 0xab, |
658 | 0x00021400, 0x00431025, 0xac820018, 0x12200005, 0x3c020800, 0x944358ce, | 658 | 0x96, 0x85, 0xed, 0xf8, 0xd2, 0xd8, 0xc2, 0x2a, 0xce, 0x7e, 0x7b, 0xfc, |
659 | 0x8f840018, 0x0a000eb8, 0x3c024013, 0x944358ce, 0x8f840018, 0x3c024014, | 659 | 0xea, 0xf9, 0xd5, 0x5c, 0x1f, 0x4b, 0xd8, 0x94, 0x4e, 0x76, 0x68, 0x79, |
660 | 0x00621825, 0xac83001c, 0x0e0014cc, 0x24040001, 0x8e700014, 0x8f620040, | 660 | 0x3c, 0xf7, 0x5c, 0x98, 0x86, 0x19, 0x97, 0x38, 0x83, 0x6b, 0x6c, 0x34, |
661 | 0x14500003, 0x00501023, 0x0a000ec3, 0x00001021, 0x28420001, 0x1040003a, | 661 | 0x2c, 0xce, 0x38, 0xd9, 0xcd, 0x78, 0xc8, 0x0a, 0x3b, 0xfd, 0xd4, 0x91, |
662 | 0x00000000, 0x0e000fae, 0x02002021, 0xaf700040, 0x9362003e, 0x30420001, | 662 | 0x09, 0x9a, 0x2c, 0xa7, 0xf9, 0x53, 0x3f, 0x7e, 0xb5, 0xb9, 0xe3, 0xe1, |
663 | 0x1440000b, 0x3c029000, 0x93620022, 0x24420001, 0xa3620022, 0x93630022, | 663 | 0x48, 0xe3, 0x37, 0x37, 0xff, 0xa8, 0xd5, 0x9d, 0xe6, 0xba, 0x33, 0x5b, |
664 | 0x3c020800, 0x8c440098, 0x0064182b, 0x14600025, 0x3c020800, 0x3c029000, | 664 | 0xd6, 0x55, 0xe7, 0x12, 0xfd, 0x03, 0x69, 0xae, 0x1b, 0xa3, 0xbc, 0x57, |
665 | 0x34420001, 0x02421025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, | 665 | 0x00, 0x00, 0x00 }; |
666 | 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, 0x34420001, 0xa362007d, | ||
667 | 0x8f640074, 0x34630001, 0x02431825, 0xaf430020, 0x04810006, 0x3c038000, | ||
668 | 0x02402021, 0x0e000470, 0x24050273, 0x0a000ef6, 0x24020001, 0x8f4201f8, | ||
669 | 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, 0xaf5201c0, 0xa34201c4, | ||
670 | 0xaf4301f8, 0x24020001, 0xa7620012, 0x0a000efe, 0xa3600022, 0x9743007a, | ||
671 | 0x9444002a, 0x00641821, 0x3063fffe, 0xa7630012, 0x97420108, 0x8fbf0024, | ||
672 | 0x8fb40020, 0x8fb3001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x00021042, | ||
673 | 0x30420001, 0x03e00008, 0x27bd0028, 0x27bdffe0, 0xafb20018, 0x3c120800, | ||
674 | 0x8e420020, 0xafb00010, 0x27500100, 0xafbf001c, 0x10400046, 0xafb10014, | ||
675 | 0x0e00148e, 0x00000000, 0x8f840018, 0x8e020000, 0xac820000, 0x936300b1, | ||
676 | 0x936200c5, 0x8f850018, 0x00031e00, 0x00021400, 0x34420100, 0x00621825, | ||
677 | 0xaca30004, 0x8f840018, 0x8e02001c, 0xac820008, 0x8f830018, 0x8f620048, | ||
678 | 0xac62000c, 0x8f840018, 0x96020012, 0xac820010, 0x8f830018, 0x8f620040, | ||
679 | 0x24040001, 0xac620014, 0x8f850018, 0x3c026000, 0x8c434448, 0x3c020800, | ||
680 | 0x245158c0, 0xaca30018, 0x9623000e, 0x8f850018, 0x3c024016, 0x00621825, | ||
681 | 0x0e0014cc, 0xaca3001c, 0x96030008, 0x30630010, 0x1060001c, 0x8e420020, | ||
682 | 0x1040001a, 0x8e100000, 0x0e00148e, 0x00000000, 0x8f820018, 0xac500000, | ||
683 | 0x8f830018, 0xac600004, 0x8f820018, 0xac400008, 0x8f830018, 0xac60000c, | ||
684 | 0x8f820018, 0xac400010, 0x8f830018, 0xac600014, 0x8f850018, 0x3c036000, | ||
685 | 0x8c634448, 0x24040001, 0xaca30018, 0x9622000e, 0x8f850018, 0x3c034015, | ||
686 | 0x00431025, 0x0e0014cc, 0xaca2001c, 0x00001021, 0x8fbf001c, 0x8fb20018, | ||
687 | 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, 0x27bdffe0, 0xafb20018, | ||
688 | 0x3c120800, 0x8e420020, 0xafb00010, 0x27500100, 0xafbf001c, 0x10400041, | ||
689 | 0xafb10014, 0x0e00148e, 0x00000000, 0x8f830018, 0x8e020000, 0xac620000, | ||
690 | 0x8f840018, 0x24020100, 0xac820004, 0x8f830018, 0x8e02001c, 0xac620008, | ||
691 | 0x8f840018, 0x8e020018, 0xac82000c, 0x8f830018, 0x96020012, 0xac620010, | ||
692 | 0x8f840018, 0x96020008, 0xac820014, 0x8f850018, 0x3c026000, 0x8c434448, | ||
693 | 0x24040001, 0x3c020800, 0x245158c0, 0xaca30018, 0x9623000e, 0x8f850018, | ||
694 | 0x3c024017, 0x00621825, 0x0e0014cc, 0xaca3001c, 0x96030008, 0x30630010, | ||
695 | 0x1060001c, 0x8e420020, 0x1040001a, 0x8e100000, 0x0e00148e, 0x00000000, | ||
696 | 0x8f820018, 0xac500000, 0x8f830018, 0xac600004, 0x8f820018, 0xac400008, | ||
697 | 0x8f830018, 0xac60000c, 0x8f820018, 0xac400010, 0x8f830018, 0xac600014, | ||
698 | 0x8f850018, 0x3c036000, 0x8c634448, 0x24040001, 0xaca30018, 0x9622000e, | ||
699 | 0x8f850018, 0x3c034015, 0x00431025, 0x0e0014cc, 0xaca2001c, 0x00001021, | ||
700 | 0x8fbf001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, | ||
701 | 0x27bdfff0, 0x03e00008, 0x27bd0010, 0x27bdffd0, 0xafb10014, 0x00808821, | ||
702 | 0xafb40020, 0x00c0a021, 0xafbf0028, 0xafb50024, 0xafb3001c, 0xafb20018, | ||
703 | 0xafb00010, 0x93620023, 0x00e0a821, 0x30420040, 0x1040003e, 0x30b3ffff, | ||
704 | 0x3c120800, 0x8e420020, 0x1040003a, 0x8f70004c, 0x0e00148e, 0x00000000, | ||
705 | 0x8f820018, 0xac510000, 0x8f840018, 0x24020001, 0xac820004, 0x8f830018, | ||
706 | 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, 0x8f820018, | ||
707 | 0x24040001, 0xac500014, 0x8f850018, 0x3c026000, 0x8c434448, 0x3c020800, | ||
708 | 0x245058c0, 0xaca30018, 0x9603000e, 0x8f850018, 0x3c024010, 0x00621825, | ||
709 | 0x0e0014cc, 0xaca3001c, 0x8e430020, 0x1060001b, 0x00000000, 0x0e00148e, | ||
710 | 0x00000000, 0x8f820018, 0xac510000, 0x8f840018, 0x3c02008d, 0xac820004, | ||
711 | 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, | ||
712 | 0x8f820018, 0xac550014, 0x8f850018, 0x3c036000, 0x8c634448, 0x24040001, | ||
713 | 0xaca30018, 0x9602000e, 0x8f850018, 0x3c034019, 0x00431025, 0x0e0014cc, | ||
714 | 0xaca2001c, 0x93620023, 0x30420020, 0x14400003, 0x3c120800, 0x1280003f, | ||
715 | 0x3c029000, 0x8e420020, 0x8f70004c, 0x1040003b, 0x3c029000, 0x0e00148e, | ||
716 | 0x00000000, 0x8f820018, 0xac510000, 0x8f840018, 0x24020001, 0xac820004, | ||
717 | 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, | ||
718 | 0x8f820018, 0x24040001, 0xac500014, 0x8f850018, 0x3c026000, 0x8c434448, | ||
719 | 0x3c020800, 0x245058c0, 0xaca30018, 0x9603000e, 0x8f850018, 0x3c024010, | ||
720 | 0x00621825, 0x0e0014cc, 0xaca3001c, 0x8e430020, 0x1060001c, 0x3c029000, | ||
721 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac510000, 0x8f840018, 0x00131400, | ||
722 | 0xac820004, 0x8f830018, 0xac750008, 0x8f820018, 0xac40000c, 0x8f830018, | ||
723 | 0xac600010, 0x8f820018, 0xac400014, 0x8f850018, 0x3c036000, 0x8c634448, | ||
724 | 0x24040001, 0xaca30018, 0x9602000e, 0x8f850018, 0x3c03401b, 0x00431025, | ||
725 | 0x0e0014cc, 0xaca2001c, 0x3c029000, 0x34420001, 0x02221025, 0xaf420020, | ||
726 | 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, 0x93630023, | ||
727 | 0x3c028000, 0x34420001, 0x02221025, 0x8fbf0028, 0x8fb50024, 0x8fb40020, | ||
728 | 0x8fb3001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x3063009f, 0xa3630023, | ||
729 | 0xaf420020, 0x03e00008, 0x27bd0030, 0x27bdffe0, 0xafb10014, 0x27510100, | ||
730 | 0x3c029000, 0x34420001, 0xafb00010, 0x00808021, 0x02021025, 0x3c038000, | ||
731 | 0xafbf0018, 0xaf420020, 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, | ||
732 | 0xa7600008, 0x8f63005c, 0x3c028000, 0x34420001, 0xaf630148, 0x8f640050, | ||
733 | 0x02021025, 0x3c039000, 0xaf64017c, 0xaf420020, 0x8f450100, 0x34630001, | ||
734 | 0x3c048000, 0x00a31825, 0xaf430020, 0x8f420020, 0x00441024, 0x1440fffd, | ||
735 | 0x00000000, 0x9362007d, 0x3c038000, 0x34420001, 0xa362007d, 0x8f640074, | ||
736 | 0x34630001, 0x00a31825, 0xaf430020, 0x04810006, 0x3c038000, 0x00a02021, | ||
737 | 0x0e000470, 0x24050de5, 0x0a001093, 0x3c020800, 0x8f4201f8, 0x00431024, | ||
738 | 0x1440fffd, 0x24020002, 0x3c031000, 0xaf4501c0, 0xa34201c4, 0xaf4301f8, | ||
739 | 0x3c020800, 0x8c430020, 0x1060001e, 0x8fbf0018, 0x0e00148e, 0x00000000, | ||
740 | 0x8f830018, 0xac700000, 0x9622000c, 0x8f840018, 0x00021400, 0xac820004, | ||
741 | 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, | ||
742 | 0x8f820018, 0xac400014, 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, | ||
743 | 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, 0x3c02401f, 0x00621825, | ||
744 | 0x0e0014cc, 0xaca3001c, 0x8fbf0018, 0x8fb10014, 0x8fb00010, 0x03e00008, | ||
745 | 0x27bd0020, 0x3c020800, 0x24424c3c, 0xaf82000c, 0x03e00008, 0x00000000, | ||
746 | 0x27bdffe8, 0xafb00010, 0x27500100, 0xafbf0014, 0x8e02001c, 0x14400003, | ||
747 | 0x3c020800, 0x0000000d, 0x3c020800, 0x8c430020, 0x10600020, 0x00001021, | ||
748 | 0x0e00148e, 0x00000000, 0x8f830018, 0x8e020000, 0xac620000, 0x8f840018, | ||
749 | 0x8e02001c, 0xac820004, 0x8f830018, 0xac600008, 0x8f840018, 0x8e020018, | ||
750 | 0xac82000c, 0x8f850018, 0x96020012, 0xaca20010, 0x8f830018, 0x3c026000, | ||
751 | 0xac600014, 0x8f840018, 0x8c434448, 0x3c020800, 0xac830018, 0x944358ce, | ||
752 | 0x8f840018, 0x3c024012, 0x00621825, 0xac83001c, 0x0e0014cc, 0x24040001, | ||
753 | 0x00001021, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x3c020800, | ||
754 | 0x97430078, 0x9444002e, 0x00001021, 0x00641821, 0x3063fffe, 0x03e00008, | ||
755 | 0xa7630010, 0x27bdfff0, 0x00001021, 0x03e00008, 0x27bd0010, 0x8f420100, | ||
756 | 0x34420001, 0xaf4200a4, 0x03e00008, 0x00001021, 0x27bdffe0, 0xafbf0018, | ||
757 | 0xafb10014, 0xafb00010, 0x9362007e, 0x30d000ff, 0x16020031, 0x00808821, | ||
758 | 0x8f620178, 0x1602002e, 0x00000000, 0x9362007f, 0x1602002b, 0x00000000, | ||
759 | 0x9362007a, 0x16020004, 0x00000000, 0x0000000d, 0x00000000, 0x240009d2, | ||
760 | 0x0e0013e6, 0x00000000, 0x3c039000, 0x34630001, 0x3c048000, 0x02231825, | ||
761 | 0xa370007a, 0xaf430020, 0x8f420020, 0x00441024, 0x1440fffd, 0x00000000, | ||
762 | 0x9362007d, 0x3c038000, 0xa362007d, 0x8f640074, 0x34630001, 0x02231825, | ||
763 | 0xaf430020, 0x04810006, 0x3c038000, 0x02202021, 0x0e000470, 0x240509dd, | ||
764 | 0x0a001138, 0x8fbf0018, 0x8f4201f8, 0x00431024, 0x1440fffd, 0x24020002, | ||
765 | 0x3c031000, 0xaf5101c0, 0xa34201c4, 0xaf4301f8, 0x0a001138, 0x8fbf0018, | ||
766 | 0x0000000d, 0x00000000, 0x240009e2, 0x8fbf0018, 0x8fb10014, 0x8fb00010, | ||
767 | 0x03e00008, 0x27bd0020, 0x27bdffe8, 0x30a500ff, 0x3c029000, 0x34420001, | ||
768 | 0x00803821, 0x00e21025, 0x3c038000, 0xafbf0010, 0xaf420020, 0x8f420020, | ||
769 | 0x00431024, 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, 0x00a21025, | ||
770 | 0xa362007d, 0x8f640074, 0x34630001, 0x00e31825, 0xaf430020, 0x04810006, | ||
771 | 0x3c038000, 0x00e02021, 0x0e000470, 0x00c02821, 0x0a001161, 0x8fbf0010, | ||
772 | 0x8f4201f8, 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, 0xaf4701c0, | ||
773 | 0xa34201c4, 0xaf4301f8, 0x8fbf0010, 0x03e00008, 0x27bd0018, 0x3c020800, | ||
774 | 0x8c430020, 0x27bdffe8, 0xafb00010, 0x27500100, 0x10600024, 0xafbf0014, | ||
775 | 0x0e00148e, 0x00000000, 0x8f830018, 0x8e020000, 0xac620000, 0x8f840018, | ||
776 | 0x8e020004, 0xac820004, 0x8f830018, 0x8e020018, 0xac620008, 0x8f840018, | ||
777 | 0x8e03001c, 0xac83000c, 0x9602000c, 0x9203000a, 0x8f840018, 0x00021400, | ||
778 | 0x00431025, 0xac820010, 0x8f830018, 0x3c026000, 0xac600014, 0x8f840018, | ||
779 | 0x8c434448, 0xac830018, 0x96020008, 0x3c030800, 0x946458ce, 0x8f850018, | ||
780 | 0x00021400, 0x00441025, 0x24040001, 0x0e0014cc, 0xaca2001c, 0x8fbf0014, | ||
781 | 0x8fb00010, 0x03e00008, 0x27bd0018, 0x3c020800, 0x8c430020, 0x27bdffe8, | ||
782 | 0xafb00010, 0x27500100, 0x10600020, 0xafbf0014, 0x0e00148e, 0x00000000, | ||
783 | 0x8f820018, 0xac400000, 0x8f830018, 0xac600004, 0x8f820018, 0xac400008, | ||
784 | 0x8f830018, 0xac60000c, 0x9602000c, 0x9603000e, 0x8f840018, 0x00021400, | ||
785 | 0x00431025, 0xac820010, 0x8f830018, 0x3c026000, 0xac600014, 0x8f840018, | ||
786 | 0x8c434448, 0xac830018, 0x96020008, 0x3c030800, 0x946458ce, 0x8f850018, | ||
787 | 0x00021400, 0x00441025, 0x24040001, 0x0e0014cc, 0xaca2001c, 0x8fbf0014, | ||
788 | 0x8fb00010, 0x03e00008, 0x27bd0018, 0x27bdffe8, 0xafb00010, 0x27500100, | ||
789 | 0xafbf0014, 0x9602000c, 0x10400024, 0x00802821, 0x3c020800, 0x8c430020, | ||
790 | 0x1060003a, 0x8fbf0014, 0x0e00148e, 0x00000000, 0x8f840018, 0x8e030000, | ||
791 | 0xac830000, 0x9602000c, 0x8f840018, 0x00021400, 0xac820004, 0x8f830018, | ||
792 | 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, 0xac600010, 0x8f820018, | ||
793 | 0xac400014, 0x8f850018, 0x3c026000, 0x8c434448, 0x24040001, 0x3c020800, | ||
794 | 0xaca30018, 0x944358ce, 0x8f850018, 0x3c02400b, 0x00621825, 0x0e0014cc, | ||
795 | 0xaca3001c, 0x0a0011ff, 0x8fbf0014, 0x93620005, 0x30420010, 0x14400015, | ||
796 | 0x3c029000, 0x34420001, 0x00a21025, 0xaf420020, 0x3c038000, 0x8f420020, | ||
797 | 0x00431024, 0x1440fffd, 0x00000000, 0x3c038000, 0x93620005, 0x34630001, | ||
798 | 0x00a02021, 0x00a31825, 0x24055852, 0x34420010, 0xa3620005, 0x0e000766, | ||
799 | 0xaf430020, 0x0a0011ff, 0x8fbf0014, 0x0000000d, 0x8fbf0014, 0x8fb00010, | ||
800 | 0x03e00008, 0x27bd0018, 0x3c020800, 0x8c430020, 0x27bdffe8, 0xafb00010, | ||
801 | 0x27500100, 0x10600022, 0xafbf0014, 0x0e00148e, 0x00000000, 0x8f840018, | ||
802 | 0x8e020004, 0xac820000, 0x9603000c, 0x9762002c, 0x8f840018, 0x00031c00, | ||
803 | 0x00431025, 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, | ||
804 | 0x8f830018, 0xac600010, 0x8f820018, 0xac400014, 0x8f850018, 0x3c026000, | ||
805 | 0x8c434448, 0x24040001, 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, | ||
806 | 0x3c02400e, 0x00621825, 0x0e0014cc, 0xaca3001c, 0x0e00122e, 0x8e040000, | ||
807 | 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x3c038000, 0x8f420278, | ||
808 | 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, 0xaf440240, 0xa3420244, | ||
809 | 0x03e00008, 0xaf430278, 0x3c020800, 0x8c430020, 0x27bdffe0, 0xafb10014, | ||
810 | 0x00808821, 0xafb20018, 0x00c09021, 0xafb00010, 0x30b0ffff, 0x1060001c, | ||
811 | 0xafbf001c, 0x0e00148e, 0x00000000, 0x8f820018, 0xac510000, 0x8f840018, | ||
812 | 0x00101400, 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, | ||
813 | 0x8f830018, 0xac600010, 0x8f820018, 0xac520014, 0x8f840018, 0x3c026000, | ||
814 | 0x8c434448, 0x3c020800, 0xac830018, 0x944358ce, 0x8f840018, 0x3c024019, | ||
815 | 0x00621825, 0xac83001c, 0x0e0014cc, 0x24040001, 0x8fbf001c, 0x8fb20018, | ||
816 | 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, 0x27bdffe8, 0x27450100, | ||
817 | 0xafbf0010, 0x94a3000c, 0x240200c1, 0x14620031, 0x00803021, 0x3c029000, | ||
818 | 0x34420001, 0x00c21025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, | ||
819 | 0x1440fffd, 0x3c028000, 0x34420001, 0x3c049000, 0x34840001, 0x3c058000, | ||
820 | 0x24030012, 0x00c21025, 0x00c42025, 0xa363003f, 0xaf420020, 0xaf440020, | ||
821 | 0x8f420020, 0x00451024, 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, | ||
822 | 0x34420020, 0xa362007d, 0x8f640074, 0x34630001, 0x00c31825, 0xaf430020, | ||
823 | 0x04810006, 0x3c038000, 0x00c02021, 0x0e000470, 0x24050906, 0x0a0012a1, | ||
824 | 0x8fbf0010, 0x8f4201f8, 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, | ||
825 | 0xaf4601c0, 0xa34201c4, 0xaf4301f8, 0x0a0012a1, 0x8fbf0010, 0x00c02021, | ||
826 | 0x94a5000c, 0x24060001, 0x0e000fb1, 0x2407090e, 0x8fbf0010, 0x03e00008, | ||
827 | 0x27bd0018, 0x3c020800, 0x8c430020, 0x27bdffe0, 0xafb00010, 0x00808021, | ||
828 | 0xafb20018, 0x00a09021, 0xafb10014, 0x30d100ff, 0x1060001c, 0xafbf001c, | ||
829 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac500000, 0x8f840018, 0x24020001, | ||
830 | 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, | ||
831 | 0xac600010, 0x8f820018, 0xac520014, 0x8f840018, 0x3c026000, 0x8c434448, | ||
832 | 0x3c020800, 0xac830018, 0x944358ce, 0x8f840018, 0x3c024010, 0x00621825, | ||
833 | 0xac83001c, 0x0e0014cc, 0x02202021, 0x8fbf001c, 0x8fb20018, 0x8fb10014, | ||
834 | 0x8fb00010, 0x03e00008, 0x27bd0020, 0x27bdffe8, 0xafbf0014, 0xafb00010, | ||
835 | 0x93620005, 0x30420001, 0x10400036, 0x00808021, 0x3c029000, 0x34420001, | ||
836 | 0x02021025, 0xaf420020, 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, | ||
837 | 0x00000000, 0x93620023, 0x34420004, 0xa3620023, 0x93630005, 0x3c048000, | ||
838 | 0x3c020800, 0x306300fe, 0xa3630005, 0x8c430020, 0x34840001, 0x02042025, | ||
839 | 0xaf440020, 0x10600020, 0x8fbf0014, 0x0e00148e, 0x00000000, 0x8f820018, | ||
840 | 0xac500000, 0x93630082, 0x9362003f, 0x8f840018, 0x00031a00, 0x00431025, | ||
841 | 0xac820004, 0x8f830018, 0xac600008, 0x8f820018, 0xac40000c, 0x8f830018, | ||
842 | 0xac600010, 0x8f820018, 0xac400014, 0x8f840018, 0x3c026000, 0x8c434448, | ||
843 | 0x3c020800, 0xac830018, 0x944358ce, 0x8f840018, 0x3c02400a, 0x00621825, | ||
844 | 0xac83001c, 0x0e0014cc, 0x24040001, 0x8fbf0014, 0x8fb00010, 0x03e00008, | ||
845 | 0x27bd0018, 0x3c020800, 0x8c430020, 0x27bdffe0, 0xafb10014, 0x00808821, | ||
846 | 0xafb20018, 0x00a09021, 0xafb00010, 0x30d000ff, 0x1060002f, 0xafbf001c, | ||
847 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac510000, 0x8f830018, 0xac700004, | ||
848 | 0x8f820018, 0xac520008, 0x8f830018, 0xac60000c, 0x8f820018, 0xac400010, | ||
849 | 0x9763006a, 0x00032880, 0x50a00001, 0x24050001, 0x97630068, 0x93640081, | ||
850 | 0x3c020800, 0x8c46004c, 0x00652821, 0x00852804, 0x00c5102b, 0x54400001, | ||
851 | 0x00a03021, 0x3c020800, 0x8c440050, 0x00c4182b, 0x54600001, 0x00c02021, | ||
852 | 0x8f830018, 0x2402fffe, 0x00822824, 0x3c026000, 0xac650014, 0x8f840018, | ||
853 | 0x8c434448, 0x3c020800, 0xac830018, 0x944358ce, 0x8f840018, 0x3c024011, | ||
854 | 0x00621825, 0xac83001c, 0x0e0014cc, 0x24040001, 0x8fbf001c, 0x8fb20018, | ||
855 | 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, 0x27bdffe8, 0xafbf0014, | ||
856 | 0xafb00010, 0x8f440100, 0x27500100, 0x8f650050, 0x0e0010fc, 0x9206001b, | ||
857 | 0x3c020800, 0x8c430020, 0x1060001d, 0x8e100018, 0x0e00148e, 0x00000000, | ||
858 | 0x8f840018, 0x8f420100, 0xac820000, 0x8f830018, 0xac700004, 0x8f840018, | ||
859 | 0x8f620050, 0xac820008, 0x8f830018, 0xac60000c, 0x8f820018, 0xac400010, | ||
860 | 0x8f830018, 0x3c026000, 0xac600014, 0x8f850018, 0x8c434448, 0x24040001, | ||
861 | 0x3c020800, 0xaca30018, 0x944358ce, 0x8f850018, 0x3c02401c, 0x00621825, | ||
862 | 0x0e0014cc, 0xaca3001c, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, | ||
863 | 0x8f430238, 0x3c020800, 0x04610013, 0x8c44009c, 0x2406fffe, 0x3c050800, | ||
864 | 0x3c038000, 0x2484ffff, 0x14800009, 0x00000000, 0x97420078, 0x8ca3007c, | ||
865 | 0x24420001, 0x00461024, 0x24630001, 0xa7620010, 0x03e00008, 0xaca3007c, | ||
866 | 0x8f420238, 0x00431024, 0x1440fff3, 0x2484ffff, 0x8f420140, 0x3c031000, | ||
867 | 0xaf420200, 0x03e00008, 0xaf430238, 0x27bdffe8, 0x3c029000, 0xafbf0010, | ||
868 | 0x8f450140, 0x34420001, 0x3c038000, 0x00a21025, 0xaf420020, 0x8f420020, | ||
869 | 0x00431024, 0x1440fffd, 0x00000000, 0x9362007d, 0x3c038000, 0x34420001, | ||
870 | 0xa362007d, 0x8f640074, 0x34630001, 0x00a31825, 0xaf430020, 0x04810006, | ||
871 | 0x3c038000, 0x00a02021, 0x0e000470, 0x24050ac7, 0x0a0013b9, 0x8fbf0010, | ||
872 | 0x8f4201f8, 0x00431024, 0x1440fffd, 0x24020002, 0x3c031000, 0xaf4501c0, | ||
873 | 0xa34201c4, 0xaf4301f8, 0x8fbf0010, 0x03e00008, 0x27bd0018, 0x0000000d, | ||
874 | 0x03e00008, 0x00000000, 0x0000000d, 0x03e00008, 0x00000000, 0x24020001, | ||
875 | 0x03e00008, 0xa7620010, 0x9362003f, 0x304400ff, 0x3883000e, 0x2c630001, | ||
876 | 0x38820010, 0x2c420001, 0x00621825, 0x14600003, 0x24020012, 0x14820003, | ||
877 | 0x00000000, 0x03e00008, 0x00001021, 0x9363007e, 0x9362007a, 0x14620006, | ||
878 | 0x00000000, 0x9363007e, 0x24020001, 0x24630001, 0x03e00008, 0xa363007e, | ||
879 | 0x9362007e, 0x8f630178, 0x304200ff, 0x14430006, 0x00000000, 0x9363000b, | ||
880 | 0x24020001, 0x24630001, 0x03e00008, 0xa363000b, 0x03e00008, 0x00001021, | ||
881 | 0x9362000b, 0x10400023, 0x00001021, 0xa360000b, 0x9362003f, 0x304400ff, | ||
882 | 0x3883000e, 0x2c630001, 0x38820010, 0x2c420001, 0x00621825, 0x14600017, | ||
883 | 0x00001821, 0x24020012, 0x10820014, 0x00000000, 0x9363007e, 0x9362007a, | ||
884 | 0x14620007, 0x00000000, 0x9362007e, 0x24030001, 0x24420001, 0xa362007e, | ||
885 | 0x03e00008, 0x00601021, 0x9362007e, 0x8f630178, 0x304200ff, 0x14430005, | ||
886 | 0x00001821, 0x9362000b, 0x24030001, 0x24420001, 0xa362000b, 0x03e00008, | ||
887 | 0x00601021, 0x03e00008, 0x00000000, 0x24040001, 0xaf64000c, 0x8f6300dc, | ||
888 | 0x8f6200cc, 0x50620001, 0xa7640010, 0xa7640012, 0xa7640014, 0x03e00008, | ||
889 | 0xa7640016, 0x3c020800, 0x8c430020, 0x27bdffe8, 0x1060001b, 0xafbf0010, | ||
890 | 0x0e00148e, 0x00000000, 0x8f820018, 0xac400000, 0x8f830018, 0xac600004, | ||
891 | 0x8f820018, 0xac400008, 0x8f830018, 0xac60000c, 0x8f820018, 0xac400010, | ||
892 | 0x8f830018, 0x3c026000, 0xac600014, 0x8f840018, 0x8c434448, 0x3c020800, | ||
893 | 0xac830018, 0x944358ce, 0x8f840018, 0x3c024020, 0x00621825, 0xac83001c, | ||
894 | 0x0e0014cc, 0x24040001, 0x8fbf0010, 0x03e00008, 0x27bd0018, 0x3c020800, | ||
895 | 0x8c430020, 0x27bdffe0, 0xafb00010, 0x00a08021, 0xafb10014, 0x00c08821, | ||
896 | 0xafb20018, 0x00e09021, 0x1060001e, 0xafbf001c, 0x0e00148e, 0x00000000, | ||
897 | 0x8f840018, 0x8f420100, 0xac820000, 0x8f830018, 0xac700004, 0x8f820018, | ||
898 | 0xac510008, 0x8f830018, 0xac72000c, 0x8f840018, 0x8fa20030, 0xac820010, | ||
899 | 0x8f830018, 0x8fa20034, 0xac620014, 0x8f840018, 0x3c026000, 0x8c434448, | ||
900 | 0x3c020800, 0xac830018, 0x944358ce, 0x8f840018, 0x3c0240c9, 0x00621825, | ||
901 | 0xac83001c, 0x0e0014cc, 0x24040001, 0x8fbf001c, 0x8fb20018, 0x8fb10014, | ||
902 | 0x8fb00010, 0x03e00008, 0x27bd0020, 0x3c020800, 0x8c430020, 0x27bdffe8, | ||
903 | 0xafb00010, 0x27500100, 0x1060001d, 0xafbf0014, 0x0e00148e, 0x00000000, | ||
904 | 0x8f830018, 0x8e020004, 0xac620000, 0x8f840018, 0x8e020018, 0xac820004, | ||
905 | 0x8f850018, 0x8e020000, 0xaca20008, 0x8f830018, 0xac60000c, 0x8f820018, | ||
906 | 0xac400010, 0x8f830018, 0xac600014, 0x8f820018, 0xac400018, 0x96030008, | ||
907 | 0x3c020800, 0x944458ce, 0x8f850018, 0x00031c00, 0x00641825, 0x24040001, | ||
908 | 0x0e0014cc, 0xaca3001c, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, | ||
909 | 0x3c060800, 0x24c558c0, 0x3c02000a, 0x03421821, 0x94640006, 0x94a2000a, | ||
910 | 0x00441023, 0x00021400, 0x00021c03, 0x04610006, 0xa4a40006, 0x0000000d, | ||
911 | 0x00000000, 0x2400005a, 0x0a0014a3, 0x24020001, 0x8f820014, 0x0062102b, | ||
912 | 0x14400002, 0x00001021, 0x24020001, 0x304200ff, 0x1040001c, 0x274a0400, | ||
913 | 0x3c07000a, 0x3c020800, 0x244558c0, 0x94a9000a, 0x8f880014, 0x03471021, | ||
914 | 0x94430006, 0x00402021, 0xa4a30006, 0x94820006, 0xa4a20006, 0x01221023, | ||
915 | 0x00021400, 0x00021403, 0x04410006, 0x0048102b, 0x0000000d, 0x00000000, | ||
916 | 0x2400005a, 0x0a0014be, 0x24020001, 0x14400002, 0x00001021, 0x24020001, | ||
917 | 0x304200ff, 0x1440ffec, 0x03471021, 0x24c458c0, 0x8c820010, 0xaf420038, | ||
918 | 0x8c830014, 0x3c020005, 0xaf43003c, 0xaf420030, 0xaf800010, 0xaf8a0018, | ||
919 | 0x03e00008, 0x00000000, 0x27bdffe0, 0x8f820010, 0x8f850018, 0x3c070800, | ||
920 | 0x24e858c0, 0xafbf001c, 0xafb20018, 0xafb10014, 0xafb00010, 0x9503000a, | ||
921 | 0x8d060014, 0x00009021, 0x309000ff, 0x00e08821, 0x24420001, 0x24a50020, | ||
922 | 0x24630001, 0xaf820010, 0xaf850018, 0xa503000a, 0x24c30020, 0x3c028000, | ||
923 | 0x04c10007, 0xad030014, 0x00621024, 0x14400005, 0x262258c0, 0x8d020010, | ||
924 | 0x24420001, 0xad020010, 0x262258c0, 0x9444000a, 0x94450018, 0x0010102b, | ||
925 | 0x00a41826, 0x2c630001, 0x00621825, 0x1060001c, 0x3c030006, 0x8f820010, | ||
926 | 0x24120001, 0x00021140, 0x00431025, 0xaf420030, 0x00000000, 0x00000000, | ||
927 | 0x00000000, 0x27450400, 0x8f420000, 0x30420010, 0x1040fffd, 0x262258c0, | ||
928 | 0x9444000a, 0x94430018, 0xaf800010, 0xaf850018, 0x14830012, 0x262758c0, | ||
929 | 0x0e00155a, 0x00000000, 0x1600000e, 0x262758c0, 0x0e00148e, 0x00000000, | ||
930 | 0x0a001517, 0x262758c0, 0x00041c00, 0x00031c03, 0x00051400, 0x00021403, | ||
931 | 0x00621823, 0x18600002, 0x3c026000, 0xac400808, 0x262758c0, 0x94e2000e, | ||
932 | 0x94e3000c, 0x24420001, 0xa4e2000e, 0x3042ffff, 0x50430001, 0xa4e0000e, | ||
933 | 0x12000005, 0x3c02000a, 0x94e2000a, 0xa74200a2, 0x0a001554, 0x02401021, | ||
934 | 0x03421821, 0x94640006, 0x94e2000a, 0x00441023, 0x00021400, 0x00021c03, | ||
935 | 0x04610006, 0xa4e40006, 0x0000000d, 0x00000000, 0x2400005a, 0x0a001536, | ||
936 | 0x24020001, 0x8f820014, 0x0062102b, 0x14400002, 0x00001021, 0x24020001, | ||
937 | 0x304200ff, 0x1040001b, 0x3c020800, 0x3c06000a, 0x244558c0, 0x94a8000a, | ||
938 | 0x8f870014, 0x03461021, 0x94430006, 0x00402021, 0xa4a30006, 0x94820006, | ||
939 | 0xa4a20006, 0x01021023, 0x00021400, 0x00021403, 0x04410006, 0x0047102b, | ||
940 | 0x0000000d, 0x00000000, 0x2400005a, 0x0a001550, 0x24020001, 0x14400002, | ||
941 | 0x00001021, 0x24020001, 0x304200ff, 0x1440ffec, 0x03461021, 0x02401021, | ||
942 | 0x8fbf001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, | ||
943 | 0x3c020800, 0x244558c0, 0x94a3001a, 0x8ca40024, 0x00403021, 0x000318c0, | ||
944 | 0x00832021, 0xaf44003c, 0x8ca20020, 0xaf420038, 0x3c020050, 0x34420008, | ||
945 | 0xaf420030, 0x00000000, 0x00000000, 0x00000000, 0x8f420000, 0x30420020, | ||
946 | 0x1040fffd, 0x00000000, 0x8f430400, 0x24c658c0, 0xacc30010, 0x8f420404, | ||
947 | 0x3c030020, 0xacc20014, 0xaf430030, 0x94c40018, 0x94c3001c, 0x94c2001a, | ||
948 | 0x94c5001e, 0x00832021, 0x24420001, 0xa4c2001a, 0x3042ffff, 0x14450002, | ||
949 | 0xa4c40018, 0xa4c0001a, 0x03e00008, 0x00000000, 0x8f820010, 0x3c030006, | ||
950 | 0x00021140, 0x00431025, 0xaf420030, 0x00000000, 0x00000000, 0x00000000, | ||
951 | 0x27430400, 0x8f420000, 0x30420010, 0x1040fffd, 0x00000000, 0xaf800010, | ||
952 | 0xaf830018, 0x03e00008, 0x00000000, 0x27bdffe8, 0xafb00010, 0x3c100800, | ||
953 | 0x261058c0, 0x3c05000a, 0x02002021, 0x03452821, 0xafbf0014, 0x0e0015b0, | ||
954 | 0x2406000a, 0x96020002, 0x9603001e, 0x3042000f, 0x24420003, 0x00431804, | ||
955 | 0x24027fff, 0x0043102b, 0xaf830014, 0x10400004, 0x00000000, 0x0000000d, | ||
956 | 0x00000000, 0x24000043, 0x0e00155a, 0x00000000, 0x8fbf0014, 0x8fb00010, | ||
957 | 0x03e00008, 0x27bd0018, 0x10c00007, 0x00000000, 0x8ca20000, 0x24c6ffff, | ||
958 | 0x24a50004, 0xac820000, 0x14c0fffb, 0x24840004, 0x03e00008, 0x00000000, | ||
959 | 0x0a0015c1, 0x00a01021, 0xac860000, 0x00000000, 0x00000000, 0x24840004, | ||
960 | 0x00a01021, 0x1440fffa, 0x24a5ffff, 0x03e00008, 0x00000000, 0x3c036000, | ||
961 | 0x8c642b7c, 0x3c036010, 0x8c6553fc, 0x00041582, 0x00042302, 0x308403ff, | ||
962 | 0x00052d82, 0x00441026, 0x0002102b, 0x0005282b, 0x00451025, 0x1440000d, | ||
963 | 0x3c020050, 0x34420004, 0xaf400038, 0xaf40003c, 0xaf420030, 0x00000000, | ||
964 | 0x00000000, 0x8f420000, 0x30420020, 0x1040fffd, 0x3c020020, 0xaf420030, | ||
965 | 0x0000000d, 0x03e00008, 0x00000000, 0x3c020050, 0x34420004, 0xaf440038, | ||
966 | 0xaf45003c, 0xaf420030, 0x00000000, 0x00000000, 0x8f420000, 0x30420020, | ||
967 | 0x1040fffd, 0x3c020020, 0xaf420030, 0x03e00008, 0x00000000, 0x00000000}; | ||
968 | 666 | ||
969 | static u32 bnx2_COM_b06FwData[(0x0/4) + 1] = { 0x0 }; | 667 | static u32 bnx2_COM_b06FwData[(0x0/4) + 1] = { 0x0 }; |
970 | static u32 bnx2_COM_b06FwRodata[(0x58/4) + 1] = { | 668 | static u32 bnx2_COM_b06FwRodata[(0x58/4) + 1] = { |
@@ -989,952 +687,368 @@ static u32 bnx2_RXP_b06FwBssAddr = 0x08005900; | |||
989 | static int bnx2_RXP_b06FwBssLen = 0x13a4; | 687 | static int bnx2_RXP_b06FwBssLen = 0x13a4; |
990 | static u32 bnx2_RXP_b06FwSbssAddr = 0x080058e0; | 688 | static u32 bnx2_RXP_b06FwSbssAddr = 0x080058e0; |
991 | static int bnx2_RXP_b06FwSbssLen = 0x1c; | 689 | static int bnx2_RXP_b06FwSbssLen = 0x1c; |
992 | static u32 bnx2_RXP_b06FwText[(0x588c/4) + 1] = { | 690 | static u8 bnx2_RXP_b06FwText[] = { |
993 | 0x0a000c61, 0x00000000, 0x00000000, 0x0000000d, 0x72787020, 0x322e362e, | 691 | 0x1f, 0x8b, 0x08, 0x08, 0x07, 0x87, 0x41, 0x44, 0x00, 0x03, 0x74, 0x65, |
994 | 0x31000000, 0x02060103, 0x00000000, 0x0000000d, 0x00000000, 0x00000000, | 692 | 0x73, 0x74, 0x31, 0x2e, 0x62, 0x69, 0x6e, 0x00, 0xed, 0x5c, 0x5d, 0x6c, |
995 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 693 | 0x1c, 0xd7, 0x75, 0x3e, 0xf3, 0x43, 0x71, 0x49, 0x91, 0xd4, 0x70, 0xb9, |
996 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 694 | 0x62, 0x57, 0x12, 0x65, 0xed, 0x8a, 0x43, 0x71, 0x6d, 0x31, 0xce, 0x50, |
997 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 695 | 0x58, 0xdb, 0x82, 0xb1, 0x48, 0xc7, 0xb3, 0xa4, 0xc8, 0x24, 0x02, 0x42, |
998 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 696 | 0x1b, 0x42, 0xab, 0xa4, 0xa9, 0xc1, 0x90, 0x72, 0x91, 0x22, 0x2c, 0xa0, |
999 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 697 | 0x1a, 0x79, 0xf0, 0x43, 0x10, 0x2f, 0x56, 0x3f, 0xa6, 0xd1, 0x8d, 0x96, |
1000 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 698 | 0xb6, 0x1c, 0x53, 0x08, 0x82, 0x82, 0xe5, 0x52, 0x52, 0x0b, 0x2c, 0xb4, |
1001 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 699 | 0x96, 0xed, 0x36, 0x7e, 0xa8, 0x23, 0x9a, 0x92, 0x8d, 0xa6, 0x68, 0x81, |
1002 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 700 | 0x22, 0xad, 0xd1, 0xf4, 0x4d, 0x95, 0x9a, 0x4a, 0x75, 0x5f, 0xd4, 0xa2, |
1003 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 701 | 0x48, 0xda, 0x46, 0xcd, 0xf4, 0xfb, 0xee, 0xcc, 0x88, 0xd4, 0x9a, 0xb2, |
1004 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 702 | 0x2c, 0x3b, 0x0d, 0x62, 0x74, 0x0e, 0x30, 0xd8, 0xb9, 0x7f, 0xe7, 0xef, |
1005 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 703 | 0x9e, 0x73, 0xee, 0x39, 0x77, 0x28, 0x7d, 0xa5, 0x43, 0xda, 0x25, 0x84, |
1006 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 704 | 0x4e, 0x3c, 0x99, 0xc3, 0xcf, 0x3c, 0xfd, 0xe0, 0xc3, 0x0f, 0xee, 0xc1, |
1007 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 705 | 0xeb, 0xb0, 0xa1, 0x6d, 0xd0, 0xa3, 0xfe, 0x18, 0x62, 0x88, 0x21, 0x86, |
1008 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 706 | 0x18, 0x62, 0x88, 0x21, 0x86, 0x18, 0x62, 0x88, 0x21, 0x86, 0x18, 0x62, |
1009 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 707 | 0x88, 0x21, 0x86, 0x18, 0x62, 0x88, 0x21, 0x86, 0x18, 0x62, 0x88, 0x21, |
1010 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 708 | 0x86, 0x18, 0x62, 0x88, 0x21, 0x86, 0x18, 0x62, 0x88, 0x21, 0x86, 0x18, |
1011 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 709 | 0x62, 0x88, 0x21, 0x86, 0x18, 0x62, 0x88, 0x21, 0x86, 0x18, 0x62, 0x88, |
1012 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 710 | 0x21, 0x86, 0x18, 0x62, 0x88, 0x21, 0x86, 0xff, 0xef, 0x60, 0x88, 0x58, |
1013 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 711 | 0xfc, 0xed, 0x0c, 0x1f, 0x49, 0xe8, 0x85, 0xcb, 0x07, 0x3d, 0x5b, 0x12, |
1014 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 712 | 0x46, 0x61, 0x69, 0x66, 0xda, 0x16, 0x71, 0xeb, 0xbb, 0x33, 0x45, 0xf9, |
1015 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 713 | 0x1f, 0xbf, 0x94, 0x32, 0x85, 0xfd, 0xdb, 0x0b, 0x37, 0x9f, 0x7d, 0xf3, |
1016 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 714 | 0x91, 0xec, 0x8d, 0x05, 0x43, 0x12, 0x56, 0xe1, 0xe8, 0xb0, 0xb5, 0x4b, |
1017 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 715 | 0x12, 0x7d, 0x58, 0xf3, 0xdd, 0xc1, 0xcf, 0x59, 0xd2, 0x15, 0xe1, 0xba, |
1018 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 716 | 0xee, 0xbf, 0x39, 0x68, 0xc9, 0x2b, 0x8d, 0x94, 0x5c, 0x68, 0x6c, 0xdf, |
1019 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 717 | 0x24, 0x5d, 0xd9, 0x52, 0x09, 0xfd, 0x6e, 0x8a, 0xe3, 0x96, 0x94, 0xab, |
1020 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 718 | 0x2d, 0xe2, 0x2a, 0xba, 0x7d, 0x5a, 0x71, 0xfe, 0x3e, 0xcd, 0x9b, 0x7f, |
1021 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 719 | 0x9e, 0xff, 0x1e, 0x24, 0xa5, 0xcb, 0x7d, 0x68, 0xf7, 0xa1, 0xcd, 0xf7, |
1022 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 720 | 0x81, 0xf4, 0x94, 0x98, 0x72, 0xa4, 0x91, 0x90, 0xa3, 0xd5, 0x8c, 0xe8, |
1023 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 721 | 0x05, 0x71, 0xbd, 0xbc, 0x9d, 0x2e, 0xa3, 0x6f, 0xea, 0x00, 0xdb, 0x29, |
1024 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 722 | 0xe0, 0xf9, 0x0e, 0xd7, 0x59, 0x5e, 0x5e, 0x4a, 0xb7, 0xc6, 0x14, 0x0d, |
1025 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 723 | 0x8e, 0xb1, 0x0f, 0xbf, 0x58, 0x5f, 0xae, 0x76, 0x00, 0x6f, 0xd6, 0x71, |
1026 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 724 | 0x41, 0xdc, 0x73, 0x2c, 0xd0, 0xf6, 0xfd, 0xdf, 0x75, 0x32, 0xb2, 0xe2, |
1027 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 725 | 0x74, 0x81, 0xa7, 0x16, 0x69, 0xb5, 0xc5, 0xd2, 0x0b, 0xb6, 0xb5, 0x22, |
1028 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 726 | 0x6d, 0x1c, 0xeb, 0x34, 0x0a, 0xbe, 0x3f, 0x9d, 0x97, 0xae, 0xa0, 0x6f, |
1029 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 727 | 0xb7, 0xe2, 0x63, 0x72, 0x42, 0xc3, 0xbc, 0x57, 0x49, 0x0f, 0x3a, 0xe2, |
1030 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 728 | 0x3b, 0x7f, 0xf3, 0x52, 0xac, 0x6c, 0x97, 0xc9, 0x54, 0xf6, 0xa0, 0x1b, |
1031 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 729 | 0xd0, 0x74, 0x3d, 0x67, 0x2b, 0x70, 0x6a, 0xe0, 0x4f, 0xdb, 0x81, 0xf5, |
1032 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 730 | 0xee, 0x0a, 0x68, 0x1a, 0x85, 0xcd, 0x62, 0x6c, 0x66, 0x9f, 0xe8, 0x3b, |
1033 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 731 | 0x87, 0x93, 0xe1, 0x78, 0x97, 0x36, 0x32, 0x6f, 0x88, 0x6e, 0xff, 0x81, |
1034 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 732 | 0xe6, 0xd5, 0x7a, 0xe5, 0xd8, 0xbc, 0x8e, 0x77, 0x5d, 0xae, 0xe6, 0x4b, |
1035 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 733 | 0x9a, 0xdb, 0xa8, 0x68, 0xde, 0xd9, 0x59, 0xad, 0x78, 0xd6, 0x94, 0xa3, |
1036 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 734 | 0xb6, 0x7f, 0xe1, 0xb4, 0x73, 0x42, 0x1b, 0x39, 0x7b, 0x46, 0x1b, 0x3d, |
1037 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 735 | 0xfb, 0x86, 0x36, 0xde, 0xd8, 0xb2, 0x49, 0xda, 0xb3, 0xd0, 0x1e, 0x71, |
1038 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 736 | 0x90, 0xbf, 0x4f, 0x87, 0xba, 0xec, 0xa2, 0xde, 0x4a, 0xe4, 0x7d, 0x9f, |
1039 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 737 | 0xf3, 0x86, 0xe6, 0x55, 0x6d, 0x8b, 0xfb, 0xe6, 0xa6, 0x22, 0x1a, 0xed, |
1040 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 738 | 0x72, 0x74, 0xde, 0x94, 0x63, 0xd5, 0x94, 0x3c, 0x57, 0x2d, 0x29, 0x5a, |
1041 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 739 | 0x86, 0x5d, 0xd2, 0xbc, 0x06, 0xc7, 0x2b, 0xa0, 0x75, 0x42, 0xdb, 0x07, |
1042 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 740 | 0x9a, 0xde, 0x59, 0x29, 0x5d, 0x71, 0xe6, 0x40, 0xaf, 0x03, 0x78, 0xff, |
1043 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 741 | 0x58, 0x1b, 0x6d, 0xf4, 0x6a, 0xde, 0xc9, 0x9b, 0xe2, 0x39, 0x59, 0xeb, |
1044 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 742 | 0x4b, 0x62, 0xba, 0xb0, 0x01, 0xc8, 0x0c, 0xfd, 0x38, 0xd0, 0x49, 0xca, |
1045 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 743 | 0xf7, 0xf5, 0x82, 0xff, 0x2c, 0x74, 0x6f, 0x5d, 0xa1, 0xfc, 0x8d, 0x5e, |
1046 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 744 | 0x29, 0xcf, 0x53, 0xd7, 0xa6, 0x36, 0x52, 0xf5, 0x2f, 0x78, 0x8e, 0xf4, |
1047 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 745 | 0x19, 0xe2, 0xfb, 0x47, 0x9d, 0x81, 0xf4, 0x21, 0x39, 0x03, 0xdc, 0x75, |
1048 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 746 | 0xad, 0xd8, 0xa0, 0xae, 0xc1, 0xdf, 0x2d, 0x39, 0x02, 0xbd, 0x15, 0x9d, |
1049 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 747 | 0x5e, 0x99, 0xb4, 0xb2, 0x2e, 0xf6, 0x68, 0x53, 0x20, 0x57, 0x32, 0xb4, |
1050 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 748 | 0x17, 0xd2, 0xe7, 0xde, 0x67, 0xd3, 0x9e, 0xa1, 0xcb, 0x53, 0x2f, 0x3d, |
1051 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 749 | 0xdf, 0xb3, 0x38, 0xb4, 0x91, 0x32, 0x43, 0xff, 0xf2, 0x45, 0xcf, 0xf6, |
1052 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 750 | 0xb6, 0xb4, 0x48, 0x29, 0x6d, 0x48, 0x16, 0xfb, 0xb4, 0x43, 0x4e, 0x3b, |
1053 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 751 | 0x22, 0x87, 0x2a, 0xd0, 0x8d, 0x6d, 0x5a, 0x8b, 0x62, 0x67, 0xca, 0x32, |
1054 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 752 | 0x50, 0x32, 0x75, 0x74, 0x26, 0x49, 0x97, 0x3a, 0xd2, 0xe5, 0x7a, 0x9e, |
1055 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 753 | 0x7a, 0xa2, 0x3d, 0x7f, 0x28, 0x5d, 0x69, 0xab, 0xba, 0x5a, 0xd5, 0xd3, |
1056 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 754 | 0xf8, 0x2f, 0x5d, 0x4f, 0xd4, 0xc9, 0x72, 0x28, 0xb7, 0x03, 0xdc, 0x8f, |
1057 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 755 | 0x40, 0x5f, 0xe2, 0xea, 0xc3, 0x0f, 0xb1, 0x6f, 0x93, 0x51, 0xb0, 0xd3, |
1058 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 756 | 0x17, 0x61, 0x14, 0x7a, 0x61, 0x37, 0x64, 0x19, 0xa6, 0xee, 0xe0, 0xc3, |
1059 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 757 | 0x1f, 0x49, 0x5e, 0xf9, 0xd5, 0x90, 0x97, 0xfc, 0xdb, 0x32, 0x55, 0x49, |
1060 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 758 | 0x80, 0x06, 0x65, 0xd4, 0xe5, 0xbd, 0x7c, 0x64, 0x1b, 0x7b, 0x20, 0x5f, |
1061 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 759 | 0x5e, 0xa6, 0xbe, 0x45, 0x7f, 0xa2, 0xfd, 0xf3, 0x9d, 0xb2, 0xfe, 0xcc, |
1062 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 760 | 0xbf, 0xee, 0x7c, 0x92, 0xf6, 0x96, 0x7c, 0x27, 0xe4, 0x78, 0x35, 0xc9, |
1063 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 761 | 0x3d, 0xd4, 0x56, 0x54, 0x6c, 0x8a, 0x64, 0x14, 0xdd, 0x28, 0x74, 0x48, |
1064 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 762 | 0x51, 0xed, 0xf7, 0x5e, 0xd0, 0x43, 0x2c, 0xa8, 0xf2, 0xbd, 0xa0, 0x64, |
1065 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 763 | 0x9b, 0xb6, 0xed, 0xcc, 0x11, 0xc9, 0xc2, 0xbe, 0x45, 0x8e, 0xcc, 0x99, |
1066 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 764 | 0x32, 0x6d, 0xff, 0x63, 0xa7, 0xb4, 0x2f, 0xdf, 0x6f, 0xa8, 0xb8, 0xae, |
1067 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 765 | 0xf7, 0x6e, 0x90, 0x4d, 0xe0, 0x77, 0xf9, 0x7e, 0x5d, 0xe4, 0xa6, 0x59, |
1068 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 766 | 0xc8, 0x5a, 0x23, 0x08, 0xf6, 0x46, 0x81, 0xb1, 0x4c, 0x43, 0x2c, 0x93, |
1069 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 767 | 0x44, 0x8b, 0x4d, 0x7d, 0xf9, 0xfe, 0xf8, 0xf0, 0xdd, 0xf5, 0x75, 0x64, |
1070 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 768 | 0x9e, 0xb4, 0xa9, 0x2f, 0xc6, 0xa8, 0x12, 0xf4, 0xc1, 0xf8, 0x74, 0xbb, |
1071 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 769 | 0xae, 0x8a, 0xa1, 0xae, 0x46, 0xfe, 0xef, 0xed, 0xc2, 0xf5, 0xaa, 0xa2, |
1072 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 770 | 0x79, 0xce, 0xbb, 0xa1, 0x2f, 0xd8, 0x32, 0x02, 0x7f, 0x37, 0xec, 0x4f, |
1073 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 771 | 0xcb, 0x91, 0x54, 0x76, 0xc2, 0x95, 0xc0, 0xe6, 0xaf, 0xad, 0xb1, 0xf9, |
1074 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 772 | 0xd1, 0xbb, 0xc8, 0x75, 0x3c, 0x94, 0xcb, 0x0d, 0xe5, 0x1a, 0x85, 0x5c, |
1075 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 773 | 0x63, 0x90, 0x6b, 0xe5, 0x23, 0xc8, 0xb5, 0xf2, 0x91, 0xe5, 0xd2, 0xa4, |
1076 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 774 | 0xec, 0x3c, 0x08, 0x5a, 0xa6, 0xfc, 0xab, 0x13, 0xd8, 0xf2, 0xbf, 0x38, |
1077 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 775 | 0x9f, 0x14, 0x19, 0x7c, 0x7f, 0x70, 0xd8, 0x16, 0xef, 0x5b, 0xe0, 0xd5, |
1078 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 776 | 0x71, 0x40, 0x8b, 0xef, 0xef, 0x97, 0xe1, 0x6e, 0xfe, 0x38, 0x8b, 0x7d, |
1079 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 777 | 0x5d, 0xcf, 0x1f, 0x29, 0x87, 0x3e, 0x7c, 0xef, 0xfe, 0xa8, 0x6b, 0x1f, |
1080 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 778 | 0x55, 0x0e, 0xc6, 0x9c, 0x4f, 0x35, 0x9d, 0xab, 0x1f, 0x56, 0x86, 0xf5, |
1081 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 779 | 0x63, 0xca, 0x2f, 0x4f, 0x86, 0xc7, 0x64, 0x72, 0x33, 0xed, 0xa9, 0xa4, |
1082 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 780 | 0x8d, 0x0c, 0x92, 0xef, 0xb5, 0xfc, 0x4a, 0x26, 0xe0, 0x0d, 0x39, 0xd1, |
1083 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 781 | 0xd2, 0x46, 0x39, 0xb2, 0x60, 0x49, 0x69, 0xe9, 0x4e, 0x71, 0x57, 0x03, |
1084 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 782 | 0x6f, 0xb4, 0x47, 0xf6, 0x7d, 0xd2, 0x7c, 0x2a, 0xc8, 0x2b, 0x2e, 0x54, |
1085 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 783 | 0x91, 0x83, 0x56, 0x13, 0x72, 0xd9, 0x48, 0xcb, 0x9b, 0x83, 0x87, 0xe5, |
1086 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 784 | 0xf3, 0xd5, 0x24, 0xe8, 0x31, 0x9f, 0x2c, 0xe7, 0x10, 0x17, 0xb5, 0xb2, |
1087 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 785 | 0x63, 0x08, 0x79, 0xaf, 0xd9, 0x9c, 0x13, 0xc4, 0x96, 0x72, 0x10, 0x83, |
1088 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 786 | 0x5d, 0x6f, 0x50, 0xe5, 0x14, 0x90, 0x4f, 0x64, 0x0c, 0xb1, 0xb7, 0x66, |
1089 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 787 | 0xb3, 0xcd, 0xfe, 0xa0, 0xef, 0xb3, 0x95, 0x5e, 0xad, 0xc8, 0xbc, 0x64, |
1090 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 788 | 0xf0, 0xa6, 0x4c, 0x3b, 0x41, 0xdf, 0xe7, 0x2a, 0xa3, 0x9b, 0x98, 0x1f, |
1091 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 789 | 0x1a, 0x05, 0xc9, 0x94, 0x9d, 0xf7, 0x7c, 0xd7, 0xba, 0x7d, 0xcd, 0xfa, |
1092 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 790 | 0x78, 0xb2, 0x13, 0x81, 0xce, 0x45, 0xfb, 0xaa, 0xad, 0xf7, 0xb6, 0x4a, |
1093 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 791 | 0x09, 0x27, 0x5d, 0xd6, 0x1a, 0x47, 0xe7, 0xbe, 0x4a, 0x79, 0x5b, 0xab, |
1094 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 792 | 0xdc, 0x34, 0x80, 0x3f, 0x6d, 0x68, 0x62, 0x1e, 0xaa, 0x94, 0xbb, 0xd9, |
1095 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 793 | 0xa6, 0xbe, 0x74, 0x4d, 0x12, 0xa3, 0x15, 0x5f, 0xae, 0x3a, 0x41, 0xee, |
1096 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 794 | 0x63, 0x68, 0x7a, 0x6f, 0x5b, 0xb8, 0x56, 0xd7, 0x76, 0x39, 0x97, 0x44, |
1097 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 795 | 0x3a, 0x0e, 0x55, 0xc4, 0x2a, 0x56, 0x76, 0x39, 0x6f, 0x4b, 0xb9, 0xa7, |
1098 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 796 | 0x6d, 0x75, 0x5d, 0x8a, 0xeb, 0x76, 0x0e, 0xaf, 0x9d, 0xbb, 0xcb, 0xb9, |
1099 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 797 | 0x28, 0xe5, 0x2d, 0x6d, 0xab, 0xb4, 0xd2, 0x58, 0xdb, 0x17, 0xac, 0xe5, |
1100 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 798 | 0xf8, 0x66, 0x71, 0xbb, 0x39, 0x47, 0xef, 0x6d, 0xbf, 0x45, 0x43, 0x32, |
1101 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 799 | 0xc5, 0x4a, 0xb9, 0xa7, 0x7d, 0x15, 0xaf, 0x4d, 0xbc, 0xde, 0x1a, 0xbc, |
1102 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 800 | 0xc4, 0xd9, 0xbe, 0x8a, 0x33, 0x07, 0x9c, 0x43, 0xab, 0x38, 0x39, 0x7e, |
1103 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 801 | 0x58, 0x8a, 0x38, 0xd3, 0x5a, 0x0a, 0x32, 0xbc, 0x54, 0xc9, 0x48, 0x79, |
1104 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 802 | 0x28, 0x01, 0xdd, 0xf7, 0x1f, 0xfc, 0x9a, 0xaa, 0x43, 0xcc, 0x61, 0x0f, |
1105 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 803 | 0xba, 0x32, 0x55, 0x5e, 0x87, 0xd8, 0x08, 0xdb, 0xf8, 0x5a, 0x5d, 0x86, |
1106 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 804 | 0x17, 0xeb, 0xa6, 0x1c, 0x6f, 0x70, 0xbf, 0x98, 0xe3, 0x05, 0x75, 0xc6, |
1107 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 805 | 0x85, 0x46, 0x4e, 0xdb, 0x87, 0xbd, 0x66, 0x9d, 0xb0, 0xaf, 0x61, 0x6a, |
1108 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 806 | 0xa3, 0x3c, 0x1f, 0x80, 0x97, 0x76, 0x7e, 0xac, 0x41, 0xdb, 0x79, 0x03, |
1109 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 807 | 0xb6, 0x41, 0xce, 0xa3, 0x9c, 0xbd, 0x95, 0xb9, 0x53, 0x66, 0xd1, 0x51, |
1110 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 808 | 0x75, 0x88, 0x56, 0xcb, 0x77, 0x20, 0x07, 0x4d, 0xa0, 0xd6, 0x80, 0xcd, |
1111 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 809 | 0xdb, 0x78, 0x6f, 0x70, 0xde, 0x32, 0xe6, 0x6d, 0xe0, 0x3c, 0xec, 0xcd, |
1112 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 810 | 0x25, 0xe5, 0x0f, 0xa6, 0xcd, 0xf1, 0x77, 0xb1, 0xc7, 0x68, 0xd7, 0x59, |
1113 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 811 | 0x57, 0x58, 0x02, 0x5f, 0xc1, 0x3e, 0xa2, 0x6e, 0x48, 0xed, 0x60, 0x7e, |
1114 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 812 | 0x8f, 0xb9, 0x19, 0xcc, 0xcd, 0x66, 0x18, 0xcf, 0x3d, 0xfb, 0x99, 0x0e, |
1115 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 813 | 0xe9, 0x42, 0xbb, 0xce, 0x35, 0xd9, 0x0c, 0x72, 0x5b, 0xdf, 0xcb, 0xb7, |
1116 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 814 | 0xc9, 0x4a, 0xca, 0xbf, 0x60, 0xd8, 0xd1, 0xdc, 0x08, 0x6f, 0xf3, 0x5c, |
1117 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 815 | 0xe6, 0xc5, 0xc4, 0xbd, 0x21, 0xcc, 0x83, 0xc7, 0xc5, 0x6d, 0xfc, 0x49, |
1118 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 816 | 0xb7, 0x74, 0xb9, 0xf8, 0x8d, 0xe6, 0x4c, 0x6f, 0x0e, 0x6a, 0x2e, 0xbe, |
1119 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 817 | 0xb7, 0x50, 0x3e, 0x17, 0xe7, 0xa1, 0x56, 0xac, 0x66, 0x26, 0x59, 0x1f, |
1120 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 818 | 0x15, 0xeb, 0x6c, 0xef, 0x85, 0x3f, 0x04, 0x75, 0xd7, 0x85, 0x5b, 0xbe, |
1121 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 819 | 0x70, 0x19, 0x7a, 0x4b, 0x43, 0x6f, 0x29, 0x39, 0xdf, 0x60, 0x9d, 0xe6, |
1122 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 820 | 0x42, 0x5f, 0x19, 0xf1, 0x1a, 0xe3, 0x58, 0x2b, 0x87, 0x81, 0x03, 0x3a, |
1123 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 821 | 0x17, 0x47, 0x2f, 0x64, 0x65, 0xca, 0xda, 0x1d, 0xf1, 0x00, 0x5c, 0x88, |
1124 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 822 | 0x1f, 0x85, 0x36, 0xf4, 0xf1, 0x1d, 0x9a, 0x53, 0xff, 0x86, 0x7f, 0x94, |
1125 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 823 | 0xed, 0x09, 0xbd, 0x30, 0xd6, 0xd4, 0xbf, 0x6e, 0xfc, 0xa1, 0x1c, 0x68, |
1126 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 824 | 0x33, 0x06, 0x31, 0xfe, 0xe8, 0xa8, 0xf3, 0x18, 0x8b, 0x48, 0xd7, 0x92, |
1127 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 825 | 0x23, 0x4b, 0x23, 0xdc, 0x37, 0x8b, 0xf1, 0xa7, 0x5c, 0xe7, 0x9e, 0x29, |
1128 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 826 | 0x5c, 0xc0, 0x19, 0xad, 0xf1, 0xfd, 0x11, 0x87, 0x6b, 0x7c, 0x99, 0x70, |
1129 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 827 | 0x3a, 0xc4, 0x48, 0x96, 0xb4, 0xc7, 0x07, 0x11, 0x7b, 0x1e, 0xe0, 0x3e, |
1130 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 828 | 0x32, 0x06, 0x6d, 0x17, 0xb0, 0xea, 0xb4, 0x3c, 0x3c, 0xc8, 0x75, 0xa0, |
1131 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 829 | 0xdd, 0x2a, 0x7a, 0x92, 0x34, 0xf3, 0x21, 0x4f, 0x43, 0xdd, 0x81, 0xbe, |
1132 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 830 | 0x06, 0xac, 0x40, 0x7f, 0x9f, 0xe9, 0x5e, 0xd5, 0x1f, 0xd7, 0x35, 0xf3, |
1133 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 831 | 0xcb, 0x18, 0x96, 0x90, 0x81, 0x33, 0x1b, 0x65, 0xe7, 0xa2, 0x25, 0xf6, |
1134 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 832 | 0x99, 0x55, 0xfe, 0x76, 0x9e, 0x5b, 0xcb, 0x5f, 0xf4, 0x7f, 0x15, 0x5c, |
1135 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 833 | 0xd0, 0xc5, 0x8e, 0xfa, 0x1e, 0x4b, 0x05, 0xb8, 0xa3, 0xf6, 0x7b, 0xe1, |
1136 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 834 | 0x5e, 0xf1, 0xfd, 0x99, 0x70, 0x4f, 0xb0, 0x07, 0x88, 0x95, 0xe7, 0x6f, |
1137 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 835 | 0xc5, 0xa9, 0x0c, 0xf6, 0x06, 0xb6, 0xa7, 0xe2, 0x11, 0xe3, 0x18, 0xed, |
1138 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 836 | 0xbb, 0x63, 0xd2, 0x2c, 0xb0, 0x8e, 0xe6, 0x3e, 0xc9, 0x44, 0xb9, 0x22, |
1139 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 837 | 0xa5, 0xad, 0x85, 0x67, 0x7d, 0xd8, 0xcf, 0xa4, 0xa5, 0x6c, 0xaf, 0x63, |
1140 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 838 | 0xaf, 0x97, 0x37, 0xa0, 0x1b, 0x8c, 0xc1, 0x26, 0xf5, 0x42, 0x42, 0x8a, |
1141 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 839 | 0x8d, 0x44, 0xc2, 0x3c, 0x31, 0xf0, 0x23, 0xcf, 0x48, 0x24, 0xf4, 0x13, |
1142 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 840 | 0x81, 0x9d, 0x4d, 0xd6, 0x6f, 0x20, 0x56, 0x6a, 0x72, 0x74, 0xe8, 0x86, |
1143 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 841 | 0xcf, 0x1a, 0xd8, 0xdb, 0x0b, 0x9b, 0x1b, 0x82, 0xcf, 0x80, 0x8f, 0x72, |
1144 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 842 | 0xa3, 0xa3, 0x37, 0xe0, 0xed, 0x2b, 0x11, 0x8f, 0xa6, 0x8e, 0xdc, 0xd3, |
1145 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 843 | 0xcb, 0xfb, 0xbe, 0x51, 0xd8, 0x90, 0x98, 0xce, 0x8f, 0x6f, 0xd1, 0xcf, |
1146 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 844 | 0xed, 0xdf, 0x62, 0x9c, 0x2b, 0x6d, 0x01, 0x3e, 0xdd, 0xcb, 0xe3, 0xf7, |
1147 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 845 | 0x9c, 0xc8, 0x44, 0x15, 0x3a, 0xdf, 0x03, 0x3d, 0x59, 0xf0, 0xc5, 0x3d, |
1148 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 846 | 0xa6, 0xca, 0xd1, 0xf5, 0x3d, 0x2f, 0x6e, 0x0a, 0x70, 0xf0, 0xfd, 0x27, |
1149 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 847 | 0x7e, 0x70, 0x86, 0x5e, 0x0e, 0xfb, 0x7e, 0x3f, 0xdc, 0x87, 0x5f, 0x45, |
1150 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 848 | 0xb9, 0x78, 0x5e, 0x44, 0xb2, 0xad, 0x3d, 0x37, 0xb2, 0xe3, 0x25, 0x9c, |
1151 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 849 | 0x33, 0xa7, 0x1d, 0xdf, 0x7f, 0x07, 0xcf, 0x35, 0xa7, 0xd9, 0x46, 0xde, |
1152 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 850 | 0x7f, 0xf6, 0x31, 0x07, 0xf8, 0x2c, 0xce, 0xbd, 0xd1, 0xa6, 0xb3, 0xff, |
1153 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 851 | 0x5e, 0xcf, 0xbd, 0x7b, 0x3f, 0xfb, 0xc9, 0xf3, 0x1d, 0x7d, 0xef, 0x03, |
1154 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 852 | 0xce, 0xfe, 0x0f, 0x5c, 0x77, 0x0f, 0x3e, 0x1b, 0xd8, 0x6d, 0xb1, 0xd1, |
1155 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 853 | 0x1c, 0x5f, 0xee, 0xd5, 0x7f, 0x7f, 0xad, 0xfb, 0x76, 0xff, 0xb5, 0xbb, |
1156 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 854 | 0x6f, 0xf7, 0xdf, 0xcd, 0xdd, 0xbf, 0x18, 0xff, 0xcd, 0x01, 0x0f, 0x7d, |
1157 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 855 | 0x70, 0xad, 0xff, 0xae, 0xe7, 0x93, 0xd4, 0xf7, 0xf3, 0x3d, 0xe5, 0xa1, |
1158 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 856 | 0xce, 0x30, 0x1f, 0x52, 0xe7, 0xf5, 0x17, 0xa7, 0x6d, 0xef, 0x7e, 0x53, |
1159 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 857 | 0x4a, 0xb9, 0x16, 0xc9, 0xe6, 0x6a, 0xb2, 0x43, 0x8e, 0x3b, 0x22, 0x4b, |
1160 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 858 | 0xaa, 0x16, 0x31, 0x51, 0x8b, 0x0f, 0xa0, 0x3e, 0x0b, 0xf4, 0xba, 0xa4, |
1161 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 859 | 0xf4, 0xf2, 0x02, 0x78, 0x89, 0xf0, 0x74, 0xdd, 0x05, 0x0f, 0x71, 0x10, |
1162 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 860 | 0x17, 0xf1, 0x0c, 0xe2, 0x7c, 0xb7, 0xd7, 0xc1, 0x85, 0x73, 0xea, 0x25, |
1163 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 861 | 0xd4, 0x64, 0xb6, 0xde, 0xa3, 0x07, 0x67, 0xb2, 0x5b, 0x96, 0xdd, 0xe9, |
1164 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 862 | 0xeb, 0xf2, 0x05, 0x9e, 0x59, 0x0a, 0xae, 0xce, 0x21, 0x56, 0x0f, 0x8d, |
1165 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 863 | 0x85, 0x75, 0xd2, 0xdc, 0x41, 0xcf, 0x8e, 0xee, 0x49, 0x78, 0x47, 0x92, |
1166 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 864 | 0x90, 0x92, 0x9a, 0xb5, 0x04, 0x1d, 0x68, 0x72, 0x0d, 0x67, 0xd0, 0xd5, |
1167 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 865 | 0xb9, 0x76, 0xe0, 0x45, 0xee, 0x77, 0x20, 0xbb, 0x57, 0xb4, 0x7e, 0xab, |
1168 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 866 | 0x55, 0x6b, 0x87, 0x2f, 0x65, 0xc4, 0x55, 0x6d, 0x9e, 0xd3, 0xa7, 0x66, |
1169 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 867 | 0x16, 0x2b, 0xc8, 0x03, 0x6d, 0x9c, 0xaf, 0x79, 0xbc, 0xd7, 0x49, 0x43, |
1170 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 868 | 0x93, 0x2b, 0x73, 0xba, 0xfc, 0xd3, 0x9c, 0x21, 0xff, 0x8c, 0x3a, 0xf4, |
1171 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 869 | 0x9a, 0x7d, 0x6a, 0xe6, 0xb4, 0x2d, 0xf7, 0x81, 0xd5, 0xf0, 0x0e, 0x4f, |
1172 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 870 | 0x76, 0x9a, 0x42, 0x5b, 0x1d, 0x48, 0xff, 0x8e, 0x20, 0xff, 0xc1, 0x9a, |
1173 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 871 | 0x2b, 0x73, 0xa4, 0xb5, 0x76, 0x8d, 0xf4, 0x22, 0x1f, 0x83, 0x5d, 0x0f, |
1174 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 872 | 0x30, 0x27, 0xe2, 0x7c, 0xd4, 0xab, 0x03, 0xd6, 0x3e, 0xc5, 0x5b, 0x42, |
1175 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 873 | 0x16, 0xeb, 0x9c, 0x6f, 0x82, 0xb7, 0x2e, 0x9c, 0x31, 0x59, 0x6b, 0x52, |
1176 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 874 | 0xfe, 0xb0, 0x5b, 0xe5, 0xaa, 0x1a, 0xfb, 0x0d, 0xb5, 0xc7, 0xef, 0xef, |
1177 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 875 | 0xe7, 0xde, 0x1b, 0x32, 0x95, 0x62, 0x9b, 0x63, 0x59, 0xd4, 0x9c, 0xc4, |
1178 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 876 | 0x97, 0xdd, 0xeb, 0x0a, 0x79, 0x0e, 0xde, 0xaf, 0x08, 0x65, 0xdb, 0x6d, |
1179 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 877 | 0x5d, 0x97, 0xd7, 0x7d, 0xf7, 0x00, 0xe5, 0x89, 0x72, 0x8b, 0x39, 0x9f, |
1180 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 878 | 0xb1, 0xd8, 0x28, 0xcc, 0xc0, 0x8e, 0xbf, 0x2a, 0xdf, 0x6f, 0x1c, 0x92, |
1181 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 879 | 0xef, 0x35, 0x26, 0xe5, 0xcf, 0x1a, 0x5f, 0x96, 0x3f, 0x6d, 0x1c, 0x94, |
1182 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 880 | 0xd7, 0x1b, 0x07, 0xe4, 0xb5, 0xc6, 0x84, 0xbc, 0xda, 0xd8, 0x0f, 0x1b, |
1183 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 881 | 0x1f, 0x87, 0x8d, 0x9f, 0x9a, 0x99, 0xac, 0xf7, 0xcb, 0xd4, 0x49, 0xc4, |
1184 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 882 | 0x20, 0xe7, 0x1b, 0xba, 0xba, 0xe3, 0xb3, 0xe9, 0xe7, 0x2d, 0x32, 0xad, |
1185 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 883 | 0xee, 0xaf, 0x34, 0xe4, 0x89, 0x2d, 0xbc, 0x2b, 0x7c, 0xc5, 0x33, 0x2e, |
1186 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 884 | 0x87, 0xf1, 0xe8, 0xe1, 0x94, 0xb4, 0x03, 0xbf, 0xca, 0x4b, 0x4d, 0x9e, |
1187 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 885 | 0xdb, 0x62, 0x86, 0xf7, 0x9c, 0x87, 0x24, 0xc9, 0xfb, 0xb0, 0x9c, 0x67, |
1188 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 886 | 0xa0, 0xde, 0x5e, 0xd7, 0x27, 0x73, 0xb4, 0x65, 0xe8, 0xc6, 0x95, 0x43, |
1189 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 887 | 0xb0, 0x53, 0xc3, 0x7e, 0xcb, 0xa5, 0x1e, 0x16, 0x97, 0x28, 0xf7, 0x46, |
1190 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 888 | 0x59, 0x5c, 0xa0, 0x6f, 0xff, 0x1b, 0x64, 0x6c, 0x97, 0xda, 0x82, 0x89, |
1191 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 889 | 0xb9, 0x6e, 0x98, 0xab, 0x6c, 0xa7, 0x3d, 0x00, 0x1f, 0xf1, 0x7e, 0x10, |
1192 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 890 | 0x4e, 0xab, 0x09, 0x27, 0xf1, 0x24, 0x54, 0x0c, 0x08, 0x70, 0x5b, 0x52, |
1193 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 891 | 0x5b, 0x4a, 0xca, 0xc2, 0x42, 0x0f, 0x9e, 0x94, 0x2c, 0xd4, 0x6d, 0x3c, |
1194 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 892 | 0x39, 0x3c, 0x43, 0x78, 0xd2, 0xb0, 0x53, 0xca, 0xc8, 0xd8, 0x12, 0xc9, |
1195 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 893 | 0x88, 0x78, 0x5c, 0xed, 0x0d, 0x6b, 0x2a, 0xf2, 0xa3, 0x85, 0xfc, 0x74, |
1196 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 894 | 0x87, 0x7d, 0x1d, 0x52, 0xab, 0x38, 0x32, 0x55, 0xfd, 0x94, 0x3e, 0xa5, |
1197 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 895 | 0x74, 0x07, 0xfc, 0x95, 0x21, 0xb4, 0xef, 0x0f, 0xdb, 0x8f, 0xca, 0xf4, |
1198 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 896 | 0xbc, 0xc8, 0xca, 0xcb, 0x03, 0x7a, 0x51, 0xb5, 0xf7, 0xa2, 0xad, 0xa3, |
1199 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 897 | 0x9d, 0x0d, 0xdb, 0xcc, 0x8f, 0x0e, 0xe0, 0x71, 0xd5, 0xf3, 0xf5, 0xea, |
1200 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 898 | 0xb8, 0x3c, 0x55, 0xed, 0x77, 0x5e, 0x87, 0xcd, 0xbd, 0x65, 0x46, 0xf7, |
1201 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 899 | 0xd2, 0x04, 0x24, 0x79, 0xf6, 0x56, 0x75, 0xf7, 0xf1, 0x04, 0xe2, 0xad, |
1202 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 900 | 0x9b, 0x34, 0xe5, 0x6f, 0x4f, 0x64, 0xad, 0xa7, 0xf5, 0x5c, 0x52, 0xda, |
1203 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 901 | 0x7d, 0xff, 0x71, 0x3b, 0x3b, 0x3b, 0xa9, 0x77, 0xca, 0xdf, 0xbf, 0x98, |
1204 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 902 | 0x91, 0x85, 0xb3, 0x5b, 0x65, 0xa1, 0x06, 0x99, 0x1a, 0xbf, 0x8e, 0x7d, |
1205 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 903 | 0x35, 0xe5, 0xea, 0x9e, 0x47, 0xb1, 0x27, 0x8c, 0x5d, 0x49, 0xe4, 0x6c, |
1206 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 904 | 0x1b, 0xc4, 0xec, 0x25, 0x5d, 0x49, 0x98, 0x85, 0x9c, 0x1c, 0x81, 0xdf, |
1207 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 905 | 0x4f, 0xdb, 0xb9, 0x1e, 0x69, 0xc7, 0x7b, 0x7d, 0x04, 0x7c, 0x5b, 0x32, |
1208 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 906 | 0xd5, 0x6b, 0xc9, 0x99, 0xc1, 0x68, 0xff, 0xb6, 0x62, 0x6e, 0x46, 0x16, |
1209 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 907 | 0xcf, 0x66, 0xf0, 0x9b, 0x83, 0xfd, 0xec, 0x94, 0x57, 0x6a, 0xfd, 0xb2, |
1210 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 908 | 0x54, 0xdb, 0x2a, 0x8b, 0xb5, 0xe6, 0x7d, 0xe8, 0xec, 0x09, 0xe2, 0x1d, |
1211 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 909 | 0xf1, 0xf4, 0x5b, 0x53, 0xfa, 0x56, 0x71, 0xcd, 0x7e, 0xeb, 0x29, 0xfd, |
1212 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 910 | 0x1f, 0xe4, 0x31, 0x33, 0xa0, 0xa9, 0x17, 0x7e, 0xa4, 0xee, 0x84, 0x26, |
1213 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 911 | 0x79, 0xf6, 0x2a, 0xbc, 0x4f, 0x26, 0x49, 0xfb, 0xf5, 0xc6, 0x07, 0xd1, |
1214 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 912 | 0x59, 0xcb, 0xcf, 0x9d, 0x68, 0x52, 0x06, 0xe2, 0xec, 0xbf, 0x71, 0x52, |
1215 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 913 | 0xef, 0x95, 0xe5, 0x6d, 0x0f, 0x58, 0x4f, 0xea, 0xad, 0x88, 0x01, 0x3f, |
1216 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 914 | 0x97, 0x9f, 0xee, 0xd9, 0x24, 0x3f, 0xfc, 0xcd, 0xec, 0xa9, 0x6f, 0x22, |
1217 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 915 | 0xd9, 0xbf, 0xb2, 0xa7, 0x83, 0x71, 0x01, 0xef, 0xec, 0xcf, 0xde, 0x70, |
1218 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 916 | 0x75, 0xea, 0xe1, 0x2f, 0xa0, 0x87, 0xec, 0x9c, 0xba, 0x9b, 0x56, 0x3c, |
1219 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 917 | 0x90, 0x3e, 0xf5, 0x52, 0x06, 0x6f, 0x18, 0xab, 0xf7, 0x03, 0x57, 0x59, |
1220 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 918 | 0xe9, 0xf9, 0x09, 0x27, 0x7b, 0x03, 0xe9, 0xb0, 0xbf, 0x68, 0xf7, 0xa7, |
1221 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 919 | 0x77, 0xea, 0x3b, 0x64, 0x32, 0xfd, 0x80, 0xf5, 0xb4, 0x6c, 0x21, 0xce, |
1222 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 920 | 0xd9, 0x05, 0xc1, 0xda, 0x79, 0xe2, 0xfb, 0x2b, 0xe0, 0x0b, 0x70, 0x28, |
1223 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 921 | 0xff, 0x51, 0x38, 0x77, 0x59, 0x5f, 0xd7, 0x79, 0xc6, 0x63, 0x0c, 0x71, |
1224 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 922 | 0xe1, 0xe2, 0x10, 0x65, 0x40, 0x82, 0x95, 0xca, 0xa6, 0x5d, 0xfd, 0xc3, |
1225 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 923 | 0xc8, 0x47, 0xfc, 0xfd, 0x56, 0x51, 0x27, 0x0f, 0xe7, 0xc0, 0xcb, 0x4f, |
1226 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 924 | 0xc0, 0x7f, 0x3f, 0x70, 0xa2, 0xf6, 0x48, 0x47, 0x74, 0xff, 0x4e, 0xd1, |
1227 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 925 | 0x7d, 0xad, 0x21, 0xe6, 0x2a, 0x5d, 0xf4, 0xd5, 0x75, 0xc8, 0xdd, 0x07, |
1228 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 926 | 0x7b, 0xb5, 0xf0, 0xcb, 0xbd, 0xe9, 0x0c, 0xf7, 0x98, 0xeb, 0x22, 0xba, |
1229 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 927 | 0x11, 0xbf, 0x5c, 0x73, 0x27, 0x1e, 0xee, 0x75, 0x3e, 0xea, 0xd4, 0x03, |
1230 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 928 | 0x09, 0x79, 0xf7, 0x44, 0xb4, 0x37, 0x07, 0x64, 0xba, 0x0a, 0xdd, 0xed, |
1231 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 929 | 0xea, 0x0f, 0xfc, 0x27, 0x1d, 0xf1, 0x40, 0xde, 0xff, 0x06, 0xbc, 0x07, |
1232 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 930 | 0xb8, 0x5b, 0x0b, 0xcd, 0xba, 0xc3, 0x58, 0x3d, 0xa0, 0x31, 0xb6, 0x0e, |
1233 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 931 | 0x4f, 0x57, 0xf6, 0x44, 0xbe, 0x98, 0x84, 0x5f, 0xed, 0xb6, 0x9e, 0x10, |
1234 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 932 | 0xd6, 0x63, 0xc4, 0x9b, 0x94, 0x1f, 0xbe, 0x0c, 0x1e, 0x92, 0xf4, 0x93, |
1235 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 933 | 0x7f, 0x5f, 0xe3, 0x27, 0x1c, 0xdb, 0x2a, 0x35, 0xd4, 0xd4, 0x5e, 0xde, |
1236 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 934 | 0x94, 0x69, 0x25, 0x03, 0xda, 0x35, 0xfa, 0x77, 0x29, 0xf4, 0xef, 0x47, |
1237 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 935 | 0x80, 0xa3, 0x5d, 0x8c, 0x47, 0x1f, 0xc7, 0x59, 0x9d, 0xcd, 0x2c, 0xeb, |
1238 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 936 | 0xcc, 0x03, 0x76, 0x4b, 0x51, 0xdd, 0x4f, 0xdf, 0x8b, 0xee, 0xa2, 0xd8, |
1239 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 937 | 0x94, 0x96, 0x8b, 0x95, 0x28, 0x2e, 0xa5, 0x71, 0x9e, 0xb4, 0xcb, 0xa5, |
1240 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 938 | 0xb9, 0x28, 0xe6, 0xb5, 0xcb, 0x12, 0xf2, 0x9a, 0x95, 0x97, 0x2c, 0x8c, |
1241 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 939 | 0x25, 0xe5, 0xe2, 0x5c, 0x12, 0x31, 0xab, 0x47, 0x56, 0xe6, 0x7a, 0x30, |
1242 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 940 | 0x96, 0xc2, 0xba, 0x14, 0xe6, 0xdb, 0xb2, 0x52, 0xb1, 0x81, 0x27, 0x87, |
1243 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 941 | 0x76, 0x0e, 0xed, 0x21, 0xb9, 0xa4, 0xbe, 0x17, 0x30, 0x2f, 0x18, 0x42, |
1244 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 942 | 0xdc, 0x62, 0x5e, 0x30, 0x82, 0x18, 0x32, 0x81, 0x27, 0x8a, 0x5d, 0xa7, |
1245 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 943 | 0x66, 0xa6, 0x2a, 0xbc, 0x73, 0x84, 0x0e, 0xac, 0x53, 0x33, 0xd3, 0xb6, |
1246 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 944 | 0x89, 0xba, 0xed, 0x1b, 0xda, 0x54, 0x83, 0x72, 0x41, 0xb7, 0x43, 0x1d, |
1247 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 945 | 0xa2, 0x3f, 0x4a, 0x9b, 0xe4, 0x79, 0x67, 0x20, 0xc6, 0x77, 0x01, 0x9f, |
1248 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 946 | 0x23, 0xfa, 0x6f, 0xd0, 0x17, 0xa0, 0xc3, 0x27, 0xba, 0xe4, 0xd2, 0xcb, |
1249 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 947 | 0x8c, 0x35, 0xae, 0xbc, 0x7a, 0x96, 0x3a, 0x2c, 0xf6, 0xac, 0xea, 0x90, |
1250 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 948 | 0x63, 0x0f, 0xe1, 0x8c, 0xd8, 0x0f, 0x7b, 0x32, 0x33, 0x87, 0x90, 0xcb, |
1251 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 949 | 0x7c, 0x1b, 0xf6, 0x59, 0x66, 0xcd, 0x9d, 0x0e, 0x6a, 0x84, 0x20, 0x06, |
1252 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 950 | 0xa0, 0xdd, 0x47, 0x5d, 0xb1, 0xdd, 0x07, 0xbb, 0xe3, 0x58, 0x9f, 0x1a, |
1253 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 951 | 0x5b, 0x04, 0x8e, 0x60, 0x8c, 0xed, 0xcd, 0xb2, 0xa8, 0xc6, 0x0e, 0xaa, |
1254 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 952 | 0xb1, 0xb2, 0xb2, 0x0f, 0x8e, 0x1d, 0x52, 0xb1, 0xe9, 0x7c, 0x23, 0xea, |
1255 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 953 | 0xdf, 0x88, 0x58, 0xc2, 0x7e, 0xf6, 0xe5, 0x61, 0xeb, 0x7b, 0x71, 0xae, |
1256 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 954 | 0x15, 0x64, 0xa9, 0x81, 0x3a, 0x30, 0xff, 0x7b, 0x98, 0xcb, 0x3d, 0xc8, |
1257 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 955 | 0x9e, 0x2a, 0xe9, 0xe4, 0xf1, 0x20, 0xce, 0x83, 0xfd, 0x21, 0xad, 0xb6, |
1258 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 956 | 0x90, 0xaf, 0x03, 0x61, 0xbb, 0x25, 0xa4, 0x4d, 0x3c, 0x36, 0x70, 0x1c, |
1259 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 957 | 0xc3, 0x5a, 0x17, 0x38, 0x18, 0x63, 0x11, 0x23, 0x52, 0x29, 0xe8, 0x82, |
1260 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 958 | 0x34, 0xdb, 0xa4, 0xac, 0xde, 0xf7, 0xc3, 0x76, 0xb9, 0x16, 0x3a, 0xb4, |
1261 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 959 | 0xa2, 0x75, 0xa5, 0x70, 0xcf, 0x53, 0xea, 0x9c, 0xd1, 0x93, 0x9b, 0xc3, |
1262 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 960 | 0x9c, 0x10, 0x7a, 0x45, 0x9c, 0xd5, 0x93, 0x8c, 0x37, 0xef, 0x84, 0x76, |
1263 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 961 | 0xda, 0x8b, 0xbe, 0x87, 0x44, 0xef, 0x65, 0xdf, 0x51, 0xe0, 0x61, 0xed, |
1264 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 962 | 0x3c, 0x0c, 0x99, 0xd9, 0xe6, 0xfa, 0x6c, 0xd3, 0xfa, 0xc4, 0x3a, 0xeb, |
1265 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 963 | 0x3b, 0x9a, 0xfa, 0x32, 0x52, 0x9b, 0xef, 0x52, 0xf1, 0xf2, 0x7c, 0x18, |
1266 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 964 | 0x2f, 0x17, 0x6b, 0x94, 0x05, 0x7e, 0x96, 0x7f, 0x5b, 0xe9, 0xa2, 0x76, |
1267 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 965 | 0x36, 0xb0, 0xf5, 0xa5, 0x93, 0x3c, 0x17, 0x57, 0xe7, 0xd5, 0xd4, 0xbc, |
1268 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 966 | 0xdf, 0x06, 0xff, 0xba, 0x1c, 0x55, 0x32, 0x70, 0x3e, 0xe6, 0xd5, 0x02, |
1269 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 967 | 0xbf, 0x31, 0x6c, 0xce, 0xa1, 0x8f, 0x44, 0x6b, 0x38, 0xff, 0xe7, 0xa8, |
1270 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 968 | 0x55, 0xbe, 0xac, 0xd6, 0xac, 0xfa, 0x0c, 0xf9, 0x71, 0x42, 0x9e, 0x7b, |
1271 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 969 | 0xc0, 0x5f, 0x67, 0x28, 0x43, 0x7b, 0x28, 0x03, 0xf1, 0xfd, 0x27, 0x70, |
1272 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 970 | 0xb7, 0x61, 0x1e, 0x79, 0xdd, 0x86, 0x3e, 0xbe, 0xff, 0x17, 0xfa, 0x76, |
1273 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 971 | 0x23, 0xff, 0x23, 0x6f, 0x89, 0x26, 0xde, 0xfe, 0x03, 0x63, 0x3d, 0x4a, |
1274 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 972 | 0xb7, 0x35, 0xd4, 0x26, 0x53, 0xbc, 0xef, 0x48, 0xe1, 0x1c, 0x38, 0xb9, |
1275 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 973 | 0x4d, 0xd1, 0xad, 0x9d, 0xbd, 0x86, 0xf1, 0x5e, 0xac, 0x89, 0xda, 0xcd, |
1276 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 974 | 0xb2, 0xe9, 0x58, 0xfb, 0x53, 0x25, 0xcf, 0x62, 0xed, 0x4e, 0xf2, 0x6f, |
1277 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 975 | 0x5b, 0x23, 0x3b, 0xe5, 0x26, 0x4f, 0xe4, 0xa7, 0x1f, 0x4f, 0x2b, 0x72, |
1278 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 976 | 0x21, 0xd8, 0x6d, 0xd2, 0x90, 0xd1, 0x7c, 0x9a, 0xdf, 0xf9, 0x12, 0xbc, |
1279 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 977 | 0x17, 0x1d, 0x19, 0xe4, 0x9e, 0xa1, 0xdd, 0x60, 0x4e, 0x47, 0x7f, 0x4b, |
1280 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 978 | 0xc8, 0x31, 0xd4, 0x24, 0xe5, 0x85, 0x8c, 0x56, 0x3c, 0x99, 0x45, 0x16, |
1281 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 979 | 0xad, 0xbe, 0xd5, 0xc9, 0x8b, 0x4b, 0xb6, 0x7c, 0x1b, 0x7e, 0x7a, 0xb2, |
1282 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 980 | 0x9e, 0x4d, 0x7f, 0x13, 0xf9, 0xc1, 0x91, 0x25, 0xe6, 0x13, 0x3d, 0x29, |
1283 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 981 | 0x65, 0x9b, 0xf3, 0x9a, 0x6c, 0x60, 0x4c, 0x9b, 0x47, 0x7e, 0x6a, 0xdd, |
1284 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 982 | 0x2d, 0x47, 0x82, 0x9f, 0x57, 0xd7, 0xc6, 0x0c, 0xca, 0xb1, 0x36, 0x66, |
1285 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 983 | 0x10, 0x0f, 0x63, 0xc6, 0x4e, 0xec, 0x13, 0x63, 0x06, 0xf6, 0xff, 0x24, |
1286 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 984 | 0x63, 0x86, 0x8d, 0x75, 0x8c, 0x19, 0x79, 0x59, 0xac, 0x32, 0x66, 0xec, |
1287 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 985 | 0x45, 0x9b, 0x31, 0xa3, 0x80, 0x76, 0x10, 0x2f, 0x16, 0x55, 0xbc, 0xc8, |
1288 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 986 | 0x5a, 0xcb, 0xc2, 0x38, 0x81, 0x3c, 0xb1, 0x8a, 0x3c, 0xb1, 0x8a, 0x3c, |
1289 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 987 | 0xb1, 0x8a, 0x3c, 0xb1, 0x8a, 0x3c, 0x11, 0xb6, 0xfe, 0x5a, 0x15, 0x79, |
1290 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 988 | 0x22, 0xfc, 0xe7, 0x3c, 0x72, 0x92, 0xa0, 0xa6, 0x38, 0x8c, 0x9a, 0xc2, |
1291 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 989 | 0xd5, 0xc6, 0xaa, 0xe3, 0xda, 0xbe, 0x2a, 0x6a, 0x43, 0xf5, 0x9d, 0x58, |
1292 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 990 | 0x1f, 0xda, 0x80, 0xba, 0xa8, 0xe6, 0x6c, 0x01, 0x5f, 0xd7, 0xe0, 0x1b, |
1293 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 991 | 0xd4, 0xd3, 0x56, 0x99, 0xca, 0xed, 0x80, 0x7c, 0xd8, 0x7f, 0xfb, 0xfb, |
1294 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 992 | 0xe8, 0x43, 0x3e, 0x9f, 0x63, 0x0d, 0xc2, 0x78, 0xb5, 0x0f, 0x6d, 0x1d, |
1295 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 993 | 0x6d, 0xec, 0xe9, 0x04, 0x7c, 0xc4, 0x7e, 0x90, 0xf9, 0x62, 0x7a, 0x41, |
1296 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 994 | 0x9e, 0xdc, 0x1c, 0xd8, 0xf4, 0x6f, 0x31, 0x27, 0x5e, 0xd3, 0xde, 0x88, |
1297 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 995 | 0x39, 0xf0, 0x17, 0xd8, 0x97, 0x5a, 0x03, 0x5c, 0xba, 0xfd, 0xe7, 0xc4, |
1298 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 996 | 0xd1, 0xb7, 0xe1, 0xd6, 0x1c, 0xda, 0xd5, 0xf7, 0x9a, 0xfa, 0xb2, 0x98, |
1299 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 997 | 0xcf, 0xef, 0xe2, 0x3b, 0xf0, 0xfb, 0x16, 0x7e, 0x61, 0x77, 0xf6, 0x05, |
1300 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 998 | 0xcc, 0xe9, 0xc3, 0xef, 0x77, 0x9a, 0xe6, 0x42, 0x0a, 0xfb, 0x2f, 0xd1, |
1301 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 999 | 0x77, 0x31, 0xa4, 0xc1, 0x6f, 0x89, 0x5f, 0x6a, 0xe2, 0xe3, 0x07, 0xe8, |
1302 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1000 | 0xfb, 0x6b, 0xf4, 0xf9, 0xfe, 0xdb, 0x4e, 0xd4, 0x27, 0xa5, 0x96, 0x70, |
1303 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1001 | 0xef, 0x46, 0xd5, 0xde, 0x69, 0xca, 0xe6, 0x8f, 0x2c, 0xe9, 0xaa, 0x0e, |
1304 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1002 | 0x7a, 0xae, 0x8e, 0xea, 0x08, 0x71, 0xbe, 0xbc, 0x10, 0xd4, 0xad, 0xc7, |
1305 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1003 | 0x51, 0x73, 0x16, 0xab, 0xb4, 0x91, 0x1c, 0xfa, 0x6d, 0x9c, 0x69, 0x32, |
1306 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1004 | 0x69, 0xdc, 0xaa, 0x63, 0x13, 0x89, 0xc9, 0x7a, 0x9b, 0x48, 0x37, 0x69, |
1307 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1005 | 0x32, 0x4f, 0x22, 0x8e, 0xd9, 0x99, 0xe2, 0xc2, 0xec, 0x8c, 0x07, 0x9c, |
1308 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1006 | 0x63, 0x75, 0xae, 0xe5, 0x3c, 0x93, 0xf7, 0x63, 0x4d, 0x74, 0x69, 0x13, |
1309 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1007 | 0x60, 0x06, 0xf4, 0x9e, 0xab, 0x93, 0x7e, 0x40, 0xb3, 0xac, 0x68, 0xda, |
1310 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1008 | 0xe8, 0x8f, 0xea, 0xc7, 0x1c, 0x6a, 0x5d, 0x99, 0x64, 0xed, 0x5c, 0x0c, |
1311 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1009 | 0x69, 0xba, 0x75, 0x49, 0x24, 0x0a, 0xcd, 0xf8, 0x82, 0x8c, 0xf3, 0xb9, |
1312 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1010 | 0xfa, 0xec, 0x8c, 0xfe, 0x42, 0x36, 0xc7, 0x3b, 0x11, 0xd7, 0x9a, 0x9d, |
1313 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1011 | 0x69, 0x1d, 0x48, 0xc8, 0x8f, 0x91, 0xbb, 0x1d, 0x53, 0x34, 0x66, 0x67, |
1314 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1012 | 0x8c, 0x17, 0x02, 0x5b, 0x0c, 0xe8, 0xe0, 0x3c, 0xc9, 0xb7, 0x43, 0x4e, |
1315 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1013 | 0xd2, 0x62, 0x4d, 0x1d, 0x8c, 0x4f, 0xaa, 0x7a, 0xd1, 0x94, 0x2b, 0x15, |
1316 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1014 | 0x45, 0x3b, 0xac, 0xdb, 0xc9, 0xc3, 0xec, 0x8c, 0xfc, 0xd1, 0x2d, 0x1e, |
1317 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1015 | 0xd6, 0x91, 0x87, 0x78, 0x49, 0x27, 0xd0, 0x5b, 0xc0, 0x7f, 0x12, 0xf5, |
1318 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1016 | 0x7b, 0x54, 0xab, 0xfb, 0xfe, 0x8a, 0x93, 0x43, 0x5c, 0xe0, 0x3e, 0xb6, |
1319 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1017 | 0xa8, 0x3c, 0xd7, 0x73, 0x32, 0xbc, 0xef, 0x9b, 0xe3, 0xdf, 0x39, 0x78, |
1320 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1018 | 0xf9, 0x01, 0xd4, 0x4d, 0xbc, 0x1b, 0xa4, 0x7f, 0xe1, 0xf7, 0x36, 0xff, |
1321 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1019 | 0xe2, 0x7c, 0xf6, 0x93, 0xe7, 0x81, 0xf4, 0x55, 0xf0, 0xe7, 0xe5, 0xd1, |
1322 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1020 | 0x87, 0x58, 0x51, 0x6c, 0x44, 0xb8, 0x78, 0xc7, 0xce, 0x39, 0x2a, 0xff, |
1323 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1021 | 0x6e, 0xf2, 0xd1, 0x96, 0xf0, 0xdc, 0xa5, 0x8e, 0xc8, 0x27, 0xf9, 0xe9, |
1324 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1022 | 0x84, 0x4d, 0x90, 0x17, 0xce, 0x8f, 0xee, 0x25, 0xd8, 0xfe, 0xb8, 0x36, |
1325 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1023 | 0x12, 0xdd, 0xa9, 0x7d, 0x9c, 0x3d, 0x8f, 0x74, 0x76, 0x37, 0x7e, 0x88, |
1326 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1024 | 0x83, 0xb4, 0x23, 0xbe, 0x22, 0x9e, 0x88, 0x8f, 0xfc, 0x44, 0xbc, 0x28, |
1327 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1025 | 0x1b, 0x5d, 0x97, 0x9f, 0x60, 0x5d, 0xc0, 0x4f, 0x69, 0x21, 0x0d, 0x9d, |
1328 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1026 | 0x90, 0xa7, 0x11, 0x6d, 0xa4, 0xba, 0xde, 0x1d, 0xc7, 0x0f, 0x5c, 0xc6, |
1329 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1027 | 0xd5, 0xb1, 0x06, 0xef, 0xa1, 0x48, 0x97, 0x7f, 0x3b, 0xb2, 0xa4, 0x8d, |
1330 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1028 | 0x34, 0xf8, 0x9d, 0xa9, 0xae, 0xb9, 0x8d, 0x88, 0xde, 0x5a, 0x9d, 0x46, |
1331 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1029 | 0xbf, 0xbc, 0x2b, 0xff, 0x0c, 0xf6, 0xa9, 0x3b, 0xf8, 0xbb, 0x14, 0x55, |
1332 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1030 | 0x47, 0xb1, 0x6f, 0xb9, 0xd5, 0x73, 0xa2, 0xbf, 0xd3, 0xd9, 0x1f, 0xe6, |
1333 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1031 | 0x43, 0x51, 0x6d, 0x1c, 0xd5, 0x59, 0xea, 0x9e, 0x7d, 0xaf, 0xe7, 0x68, |
1334 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1032 | 0xc8, 0x4f, 0x99, 0x33, 0x05, 0x3a, 0x08, 0xf1, 0xde, 0x91, 0xcf, 0x91, |
1335 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1033 | 0x26, 0x3e, 0x47, 0xc1, 0xe7, 0x3e, 0xf0, 0x39, 0x76, 0x8b, 0xcf, 0x5b, |
1336 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1034 | 0xb6, 0x97, 0x29, 0xc3, 0xf6, 0x46, 0xd6, 0xb5, 0xbd, 0x55, 0x3a, 0xab, |
1337 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1035 | 0x73, 0x83, 0xfb, 0x9a, 0x91, 0x86, 0x2f, 0xc7, 0x9d, 0x8f, 0x53, 0x37, |
1338 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1036 | 0xb7, 0xcb, 0x99, 0x85, 0xbb, 0xd5, 0xb7, 0x11, 0xaf, 0x2a, 0x77, 0x94, |
1339 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1037 | 0x4b, 0xf5, 0x80, 0x9f, 0x1f, 0x2f, 0xb1, 0x3d, 0x12, 0xea, 0x8a, 0x3a, |
1340 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1038 | 0xcb, 0x3a, 0x25, 0xb9, 0x1b, 0x2f, 0xbf, 0xf8, 0x9c, 0x76, 0xa5, 0x12, |
1341 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1039 | 0x9d, 0x4f, 0x5a, 0x78, 0xc6, 0xae, 0xe5, 0x29, 0xfa, 0x6e, 0x32, 0x66, |
1342 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1040 | 0x45, 0xf7, 0x67, 0x22, 0xfc, 0xfe, 0xc0, 0xef, 0x75, 0x6b, 0xbf, 0x13, |
1343 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1041 | 0xf0, 0x7c, 0x8a, 0x78, 0xd7, 0x53, 0x3c, 0x9f, 0xc6, 0x9c, 0x66, 0x19, |
1344 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1042 | 0x5c, 0xd8, 0xa4, 0x9e, 0xe4, 0x98, 0xe7, 0xd0, 0x2f, 0x4c, 0xd0, 0x0c, |
1345 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1043 | 0xee, 0xdd, 0x6a, 0x4b, 0xbe, 0x5c, 0x74, 0x36, 0x06, 0xe7, 0x28, 0x64, |
1346 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1044 | 0xba, 0x6c, 0xf1, 0xfe, 0x0a, 0x31, 0x8c, 0x67, 0x83, 0xb2, 0xb5, 0x16, |
1347 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1045 | 0xf5, 0x5c, 0x39, 0xd0, 0x0e, 0x1d, 0xb3, 0xdd, 0xd6, 0xcb, 0xfb, 0x0a, |
1348 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1046 | 0xca, 0xbc, 0xa0, 0xf6, 0x21, 0xd2, 0x71, 0xf4, 0x7d, 0xae, 0x55, 0x96, |
1349 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1047 | 0xc3, 0xbb, 0xad, 0xc5, 0x8a, 0xef, 0xbf, 0x83, 0x3c, 0xfc, 0x34, 0x74, |
1350 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1048 | 0x5f, 0xae, 0xff, 0xcc, 0x5f, 0x4e, 0xf1, 0x6f, 0xa5, 0x22, 0x9b, 0xd8, |
1351 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1049 | 0xd1, 0xcb, 0x7b, 0x20, 0xf8, 0x96, 0x1c, 0xaf, 0x87, 0x65, 0xbf, 0x70, |
1352 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1050 | 0x9c, 0x7d, 0xff, 0x0d, 0xbe, 0x7d, 0xff, 0xf4, 0xaa, 0x9d, 0x02, 0xfe, |
1353 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1051 | 0x17, 0x33, 0xe1, 0x9b, 0xdd, 0x90, 0x58, 0x00, 0x00, 0x00 }; |
1354 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1355 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1356 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1357 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1358 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1359 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1360 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1361 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1362 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1363 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1364 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1365 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1366 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1367 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1368 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1369 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1370 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1371 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1372 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1373 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1374 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1375 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1376 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1377 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1378 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1379 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1380 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1381 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1382 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1383 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1384 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1385 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1386 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1387 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1388 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1389 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1390 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1391 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1392 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1393 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1394 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1395 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1396 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1397 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1398 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1399 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1400 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1401 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1402 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1403 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1404 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1405 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1406 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1407 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1408 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1409 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1410 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1411 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1412 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1413 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1414 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1415 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1416 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1417 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1418 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1419 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1420 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1421 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1422 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1423 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1424 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1425 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1426 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1427 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1428 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1429 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1430 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1431 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1432 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1433 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1434 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1435 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1436 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1437 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1438 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1439 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1440 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1441 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1442 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1443 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1444 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1445 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1446 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1447 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1448 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1449 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1450 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1451 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1452 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1453 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1454 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1455 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1456 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1457 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1458 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1459 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1460 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1461 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1462 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1463 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1464 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1465 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1466 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1467 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1468 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1469 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1470 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1471 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1472 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1473 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1474 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1475 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1476 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1477 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1478 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1479 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1480 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1481 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1482 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1483 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1484 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1485 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1486 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1487 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1488 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1489 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1490 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1491 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1492 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1493 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1494 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1495 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1496 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1497 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1498 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1499 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1500 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1501 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1502 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1503 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1504 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1505 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1506 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1507 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1508 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1509 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1510 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1511 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1512 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1513 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1514 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1515 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1516 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1517 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1518 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1519 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1520 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1521 | 0x00000000, 0x00000000, 0x10000003, 0x00000000, 0x0000000d, 0x0000000d, | ||
1522 | 0x3c020800, 0x244258e0, 0x3c030800, 0x24636ca4, 0xac400000, 0x0043202b, | ||
1523 | 0x1480fffd, 0x24420004, 0x3c1d0800, 0x37bd7ffc, 0x03a0f021, 0x3c100800, | ||
1524 | 0x26103184, 0x3c1c0800, 0x279c58e0, 0x0e00104a, 0x00000000, 0x0000000d, | ||
1525 | 0x27bdffe8, 0xafb00010, 0xafbf0014, 0x0e000f1d, 0x00808021, 0x1440000d, | ||
1526 | 0x00000000, 0x8f820010, 0x10400005, 0x00000000, 0x9743011c, 0x9742011e, | ||
1527 | 0x0a000c89, 0x00021400, 0x9743011e, 0x9742011c, 0x00021400, 0x00621825, | ||
1528 | 0xaf830004, 0x8f840008, 0x3c020020, 0x34424000, 0x00821824, 0x54620004, | ||
1529 | 0x3c020020, 0x8f820014, 0x0a000c9a, 0x34421000, 0x34428000, 0x00821824, | ||
1530 | 0x14620004, 0x00000000, 0x8f820014, 0x34428000, 0xaf820014, 0x8f820008, | ||
1531 | 0x9743010c, 0x00403021, 0x30421000, 0x10400010, 0x3069ffff, 0x30c20020, | ||
1532 | 0x1440000e, 0x24070005, 0x3c021000, 0x00c21024, 0x10400009, 0x3c030dff, | ||
1533 | 0x3463ffff, 0x3c020e00, 0x00c21024, 0x0062182b, 0x50600004, 0x24070001, | ||
1534 | 0x0a000cb2, 0x3c020800, 0x24070001, 0x3c020800, 0x8c430034, 0x1460001d, | ||
1535 | 0x00405821, 0x8f820014, 0x30424000, 0x1440001a, 0x3c020001, 0x3c021f01, | ||
1536 | 0x00c24024, 0x3c031000, 0x15030015, 0x3c020001, 0x31220200, 0x14400012, | ||
1537 | 0x3c020001, 0x9744010e, 0x24020003, 0xa342018b, 0x97850016, 0x24020002, | ||
1538 | 0x34e30002, 0xaf400180, 0xa742018c, 0xa7430188, 0x24840004, 0x30a5bfff, | ||
1539 | 0xa744018e, 0xa74501a6, 0xaf4801b8, 0x0a000f19, 0x00001021, 0x3c020001, | ||
1540 | 0x00c21024, 0x1040002f, 0x00000000, 0x9742010e, 0x3c038000, 0x3046ffff, | ||
1541 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020003, 0xa342018b, 0x9784000a, | ||
1542 | 0x8f850004, 0x8f870014, 0x24020080, 0x24030002, 0xaf420180, 0x24020003, | ||
1543 | 0xa743018c, 0xa746018e, 0xa7420188, 0x30e28000, 0xa7440190, 0x1040000c, | ||
1544 | 0xaf4501a8, 0x93420116, 0x304200fc, 0x005a1021, 0x24424004, 0x8c430000, | ||
1545 | 0x3063ffff, 0x14600004, 0x3c02ffff, 0x34427fff, 0x00e21024, 0xaf820014, | ||
1546 | 0x97820016, 0x9743010c, 0x8f440104, 0x3042bfff, 0x00031c00, 0x3084ffff, | ||
1547 | 0x00641825, 0xa74201a6, 0xaf4301ac, 0x3c021000, 0xaf4201b8, 0x0a000f19, | ||
1548 | 0x00001021, 0x8f820014, 0x30434000, 0x10600016, 0x00404021, 0x3c020f00, | ||
1549 | 0x00c21024, 0x14400012, 0x00000000, 0x93420116, 0x34424000, 0x03421821, | ||
1550 | 0x94650002, 0x2ca21389, 0x1040000b, 0x3c020800, 0x24425900, 0x00051942, | ||
1551 | 0x00031880, 0x00621821, 0x30a5001f, 0x8c640000, 0x24020001, 0x00a21004, | ||
1552 | 0x00822024, 0x02048025, 0x12000030, 0x3c021000, 0x9742010e, 0x34e80002, | ||
1553 | 0x3c038000, 0x24420004, 0x3046ffff, 0x8f4201b8, 0x00431024, 0x1440fffd, | ||
1554 | 0x24020003, 0xa342018b, 0x9784000a, 0x8f850004, 0x8f870014, 0x24020180, | ||
1555 | 0x24030002, 0xaf420180, 0xa743018c, 0xa746018e, 0xa7480188, 0x30e28000, | ||
1556 | 0xa7440190, 0x1040000c, 0xaf4501a8, 0x93420116, 0x304200fc, 0x005a1021, | ||
1557 | 0x24424004, 0x8c430000, 0x3063ffff, 0x14600004, 0x3c02ffff, 0x34427fff, | ||
1558 | 0x00e21024, 0xaf820014, 0x97820016, 0x9743010c, 0x8f440104, 0x3042bfff, | ||
1559 | 0x00031c00, 0x3084ffff, 0x00641825, 0xa74201a6, 0xaf4301ac, 0x3c021000, | ||
1560 | 0xaf4201b8, 0x0a000f19, 0x00001021, 0x00c21024, 0x104000c0, 0x3c020800, | ||
1561 | 0x8c430030, 0x10600037, 0x31024000, 0x10400035, 0x3c030f00, 0x00c31824, | ||
1562 | 0x3c020100, 0x0043102b, 0x14400031, 0x3c030800, 0x9742010e, 0x34e80002, | ||
1563 | 0x3c038000, 0x24420004, 0x3046ffff, 0x8f4201b8, 0x00431024, 0x1440fffd, | ||
1564 | 0x24020003, 0xa342018b, 0x9784000a, 0x8f850004, 0x8f870014, 0x24020080, | ||
1565 | 0x24030002, 0xaf420180, 0xa743018c, 0xa746018e, 0xa7480188, 0x30e28000, | ||
1566 | 0xa7440190, 0x1040000c, 0xaf4501a8, 0x93420116, 0x304200fc, 0x005a1021, | ||
1567 | 0x24424004, 0x8c430000, 0x3063ffff, 0x14600004, 0x3c02ffff, 0x34427fff, | ||
1568 | 0x00e21024, 0xaf820014, 0x97820016, 0x9743010c, 0x8f440104, 0x3042bfff, | ||
1569 | 0x00031c00, 0x3084ffff, 0x00641825, 0xa74201a6, 0xaf4301ac, 0x3c021000, | ||
1570 | 0xaf4201b8, 0x0a000f19, 0x00001021, 0x3c030800, 0x8c620024, 0x30420008, | ||
1571 | 0x10400035, 0x34ea0002, 0x3c020f00, 0x00c21024, 0x14400032, 0x8d620034, | ||
1572 | 0x31220200, 0x1040002f, 0x8d620034, 0x9742010e, 0x30e8fffb, 0x3c038000, | ||
1573 | 0x24420004, 0x3046ffff, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020003, | ||
1574 | 0xa342018b, 0x9784000a, 0x8f850004, 0x8f870014, 0x24020180, 0x24030002, | ||
1575 | 0xaf420180, 0xa743018c, 0xa746018e, 0xa7480188, 0x30e28000, 0xa7440190, | ||
1576 | 0x1040000c, 0xaf4501a8, 0x93420116, 0x304200fc, 0x005a1021, 0x24424004, | ||
1577 | 0x8c430000, 0x3063ffff, 0x14600004, 0x3c02ffff, 0x34427fff, 0x00e21024, | ||
1578 | 0xaf820014, 0x97820016, 0x9743010c, 0x8f440104, 0x3042bfff, 0x00031c00, | ||
1579 | 0x3084ffff, 0x00641825, 0xa74201a6, 0xaf4301ac, 0x3c021000, 0xaf4201b8, | ||
1580 | 0x8d620034, 0x8f860008, 0x10400012, 0x30c20100, 0x10400010, 0x3c020f00, | ||
1581 | 0x00c21024, 0x3c030200, 0x1043000c, 0x3c020800, 0x8c430038, 0x8f840004, | ||
1582 | 0x3c020800, 0x2442003c, 0x2463ffff, 0x00832024, 0x00822021, 0x90830000, | ||
1583 | 0x24630004, 0x0a000de1, 0x000329c0, 0x00000000, 0x00061602, 0x3042000f, | ||
1584 | 0x000229c0, 0x3c04fc00, 0x00441021, 0x3c030300, 0x0062182b, 0x50600001, | ||
1585 | 0x24050800, 0x9742010e, 0x3148ffff, 0x3c038000, 0x24420004, 0x3046ffff, | ||
1586 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020003, 0xa342018b, 0x9783000a, | ||
1587 | 0x8f840004, 0x8f870014, 0x24020002, 0xaf450180, 0xa742018c, 0xa746018e, | ||
1588 | 0xa7480188, 0x30e28000, 0xa7430190, 0x1040000c, 0xaf4401a8, 0x93420116, | ||
1589 | 0x304200fc, 0x005a1021, 0x24424004, 0x8c430000, 0x3063ffff, 0x14600004, | ||
1590 | 0x3c02ffff, 0x34427fff, 0x00e21024, 0xaf820014, 0x97820016, 0x9743010c, | ||
1591 | 0x8f440104, 0x3042bfff, 0x00031c00, 0x3084ffff, 0x00641825, 0xa74201a6, | ||
1592 | 0xaf4301ac, 0x3c021000, 0xaf4201b8, 0x0a000f19, 0x00001021, 0x8f424000, | ||
1593 | 0x30420100, 0x104000d5, 0x3c020800, 0x8c440024, 0x24030001, 0x1483002f, | ||
1594 | 0x00405021, 0x9742010e, 0x34e70002, 0x3c038000, 0x24420004, 0x3045ffff, | ||
1595 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020003, 0xa342018b, 0x9783000a, | ||
1596 | 0x8f840004, 0x8f860014, 0x24020002, 0xaf400180, 0xa742018c, 0xa745018e, | ||
1597 | 0xa7470188, 0x30c28000, 0xa7430190, 0x1040000c, 0xaf4401a8, 0x93420116, | ||
1598 | 0x304200fc, 0x005a1021, 0x24424004, 0x8c430000, 0x3063ffff, 0x14600004, | ||
1599 | 0x3c02ffff, 0x34427fff, 0x00c21024, 0xaf820014, 0x97820016, 0x9743010c, | ||
1600 | 0x8f440104, 0x3042bfff, 0x00031c00, 0x3084ffff, 0x00641825, 0xa74201a6, | ||
1601 | 0xaf4301ac, 0x3c021000, 0xaf4201b8, 0x0a000f19, 0x00001021, 0x30820001, | ||
1602 | 0x1040002e, 0x30eb0004, 0x9742010e, 0x30e9fffb, 0x3c038000, 0x24420004, | ||
1603 | 0x3045ffff, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020003, 0xa342018b, | ||
1604 | 0x9783000a, 0x8f840004, 0x8f860014, 0x24020002, 0xaf400180, 0xa742018c, | ||
1605 | 0xa745018e, 0xa7470188, 0x30c28000, 0xa7430190, 0x1040000c, 0xaf4401a8, | ||
1606 | 0x93420116, 0x304200fc, 0x005a1021, 0x24424004, 0x8c430000, 0x3063ffff, | ||
1607 | 0x14600004, 0x3c02ffff, 0x34427fff, 0x00c21024, 0xaf820014, 0x97820016, | ||
1608 | 0x9743010c, 0x8f440104, 0x3042bfff, 0x00031c00, 0x3084ffff, 0x00641825, | ||
1609 | 0xa74201a6, 0xaf4301ac, 0x3c021000, 0xaf4201b8, 0x3127ffff, 0x8d420024, | ||
1610 | 0x30420004, 0x10400030, 0x8d420024, 0x9742010e, 0x30e9fffb, 0x3c038000, | ||
1611 | 0x24420004, 0x3046ffff, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020003, | ||
1612 | 0xa342018b, 0x9784000a, 0x8f850004, 0x8f880014, 0x24020100, 0x24030002, | ||
1613 | 0xaf420180, 0xa743018c, 0xa746018e, 0xa7470188, 0x31028000, 0xa7440190, | ||
1614 | 0x1040000c, 0xaf4501a8, 0x93420116, 0x304200fc, 0x005a1021, 0x24424004, | ||
1615 | 0x8c430000, 0x3063ffff, 0x14600004, 0x3c02ffff, 0x34427fff, 0x01021024, | ||
1616 | 0xaf820014, 0x97820016, 0x9743010c, 0x8f440104, 0x3042bfff, 0x00031c00, | ||
1617 | 0x3084ffff, 0x00641825, 0xa74201a6, 0xaf4301ac, 0x3c021000, 0xaf4201b8, | ||
1618 | 0x3127ffff, 0x8d420024, 0x30420008, 0x1040002d, 0x00000000, 0x9742010e, | ||
1619 | 0x3c038000, 0x24420004, 0x3046ffff, 0x8f4201b8, 0x00431024, 0x1440fffd, | ||
1620 | 0x24020003, 0xa342018b, 0x9784000a, 0x8f850004, 0x8f880014, 0x24020180, | ||
1621 | 0x24030002, 0xaf420180, 0xa743018c, 0xa746018e, 0xa7470188, 0x31028000, | ||
1622 | 0xa7440190, 0x1040000c, 0xaf4501a8, 0x93420116, 0x304200fc, 0x005a1021, | ||
1623 | 0x24424004, 0x8c430000, 0x3063ffff, 0x14600004, 0x3c02ffff, 0x34427fff, | ||
1624 | 0x01021024, 0xaf820014, 0x97820016, 0x9743010c, 0x8f440104, 0x3042bfff, | ||
1625 | 0x00031c00, 0x3084ffff, 0x00641825, 0xa74201a6, 0xaf4301ac, 0x3c021000, | ||
1626 | 0xaf4201b8, 0x15600041, 0x00001021, 0x27440180, 0x3c038000, 0x8f4201b8, | ||
1627 | 0x00431024, 0x1440fffd, 0x24022000, 0x24030002, 0xa4820008, 0xa083000b, | ||
1628 | 0xa4800010, 0x3c021000, 0xaf4201b8, 0x0a000f19, 0x00001021, 0x3c030800, | ||
1629 | 0x8c620024, 0x30420001, 0x1040002e, 0x00001021, 0x9742010e, 0x34e70002, | ||
1630 | 0x3c038000, 0x24420004, 0x3045ffff, 0x8f4201b8, 0x00431024, 0x1440fffd, | ||
1631 | 0x24020003, 0xa342018b, 0x9783000a, 0x8f840004, 0x8f860014, 0x24020002, | ||
1632 | 0xaf400180, 0xa742018c, 0xa745018e, 0xa7470188, 0x30c28000, 0xa7430190, | ||
1633 | 0x1040000c, 0xaf4401a8, 0x93420116, 0x304200fc, 0x005a1021, 0x24424004, | ||
1634 | 0x8c430000, 0x3063ffff, 0x14600004, 0x3c02ffff, 0x34427fff, 0x00c21024, | ||
1635 | 0xaf820014, 0x97820016, 0x9743010c, 0x8f440104, 0x3042bfff, 0x00031c00, | ||
1636 | 0x3084ffff, 0x00641825, 0xa74201a6, 0xaf4301ac, 0x3c021000, 0xaf4201b8, | ||
1637 | 0x00001021, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x8f4b0070, | ||
1638 | 0x93420112, 0x8f840008, 0x00022882, 0x30820100, 0x14400003, 0x24a30003, | ||
1639 | 0x03e00008, 0x00001021, 0x30824000, 0x10400010, 0x27424000, 0x00031880, | ||
1640 | 0x00431021, 0x8c470000, 0x24a30004, 0x00031880, 0x27424000, 0x00431021, | ||
1641 | 0x8c490000, 0x93430116, 0x27424000, 0x306300fc, 0x00431021, 0x8c4a0000, | ||
1642 | 0x0a000f45, 0x3c030800, 0x30822000, 0x1040ffea, 0x00031880, 0x27424000, | ||
1643 | 0x00431021, 0x8c470000, 0x24a30004, 0x00031880, 0x27424000, 0x00431021, | ||
1644 | 0x8c490000, 0x00005021, 0x3c030800, 0x24680100, 0x00071602, 0x00021080, | ||
1645 | 0x00481021, 0x8c460000, 0x00071b82, 0x306303fc, 0x01031821, 0x8c640400, | ||
1646 | 0x00071182, 0x304203fc, 0x01021021, 0x8c450800, 0x30e300ff, 0x00031880, | ||
1647 | 0x01031821, 0x00091602, 0x00021080, 0x01021021, 0x00c43026, 0x8c640c00, | ||
1648 | 0x8c431000, 0x00c53026, 0x00091382, 0x304203fc, 0x01021021, 0x8c451400, | ||
1649 | 0x312200ff, 0x00021080, 0x01021021, 0x00c43026, 0x00c33026, 0x00091982, | ||
1650 | 0x306303fc, 0x01031821, 0x8c641800, 0x8c431c00, 0x00c53026, 0x00c43026, | ||
1651 | 0x11400015, 0x00c33026, 0x000a1602, 0x00021080, 0x01021021, 0x8c432000, | ||
1652 | 0x000a1382, 0x304203fc, 0x01021021, 0x8c452400, 0x314200ff, 0x00021080, | ||
1653 | 0x01021021, 0x00c33026, 0x000a1982, 0x306303fc, 0x01031821, 0x8c642800, | ||
1654 | 0x8c432c00, 0x00c53026, 0x00c43026, 0x00c33026, 0x8f430070, 0x3c050800, | ||
1655 | 0x8ca43100, 0x2c820020, 0x10400008, 0x006b5823, 0x3c020800, 0x24423104, | ||
1656 | 0x00041880, 0x00621821, 0x24820001, 0xac6b0000, 0xaca23100, 0xaf860004, | ||
1657 | 0x03e00008, 0x24020001, 0x27bdffe8, 0xafbf0010, 0x8f460128, 0x8f840010, | ||
1658 | 0xaf460020, 0x8f450104, 0x8f420100, 0x24030800, 0xaf850008, 0xaf820014, | ||
1659 | 0xaf4301b8, 0x1080000a, 0x3c020800, 0x8c430034, 0x10600007, 0x30a22000, | ||
1660 | 0x10400005, 0x34a30100, 0x8f82000c, 0xaf830008, 0x24420001, 0xaf82000c, | ||
1661 | 0x3c020800, 0x8c4300c0, 0x10600006, 0x3c030800, 0x8c6200c4, 0x24040001, | ||
1662 | 0x24420001, 0x0a000fd5, 0xac6200c4, 0x8f820008, 0x3c030010, 0x00431024, | ||
1663 | 0x14400009, 0x3c02001f, 0x3c030800, 0x8c620020, 0x00002021, 0x24420001, | ||
1664 | 0x0e000c78, 0xac620020, 0x0a000fd5, 0x00402021, 0x3442ff00, 0x14c20009, | ||
1665 | 0x2403bfff, 0x3c030800, 0x8c620020, 0x24040001, 0x24420001, 0x0e000c78, | ||
1666 | 0xac620020, 0x0a000fd5, 0x00402021, 0x8f820014, 0x00431024, 0x14400006, | ||
1667 | 0x00000000, 0xaf400048, 0x0e0011a9, 0xaf400040, 0x0a000fd5, 0x00402021, | ||
1668 | 0x0e001563, 0x00000000, 0x00402021, 0x10800005, 0x3c024000, 0x8f430124, | ||
1669 | 0x3c026020, 0xac430014, 0x3c024000, 0xaf420138, 0x00000000, 0x8fbf0010, | ||
1670 | 0x03e00008, 0x27bd0018, 0x27bdffe0, 0xafbf0018, 0xafb10014, 0xafb00010, | ||
1671 | 0x8f420140, 0xaf420020, 0x8f430148, 0x3c027000, 0x00621824, 0x3c023000, | ||
1672 | 0x10620021, 0x0043102b, 0x14400006, 0x3c024000, 0x3c022000, 0x10620009, | ||
1673 | 0x3c024000, 0x0a001040, 0x00000000, 0x10620045, 0x3c025000, 0x10620047, | ||
1674 | 0x3c024000, 0x0a001040, 0x00000000, 0x27440180, 0x3c038000, 0x8f4201b8, | ||
1675 | 0x00431024, 0x1440fffd, 0x00000000, 0x8f420148, 0x24030002, 0xa083000b, | ||
1676 | 0x00021402, 0xa4820008, 0x8f430148, 0xa4830010, 0x8f420144, 0x3c031000, | ||
1677 | 0xac820024, 0xaf4301b8, 0x0a001040, 0x3c024000, 0x8f420148, 0x24030002, | ||
1678 | 0x3044ffff, 0x00021402, 0x305000ff, 0x1203000c, 0x27510180, 0x2a020003, | ||
1679 | 0x10400005, 0x24020003, 0x0600001d, 0x36053000, 0x0a001027, 0x3c038000, | ||
1680 | 0x12020007, 0x00000000, 0x0a001034, 0x00000000, 0x0e00112c, 0x00000000, | ||
1681 | 0x0a001025, 0x00402021, 0x0e00113e, 0x00000000, 0x00402021, 0x36053000, | ||
1682 | 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020002, 0xa6250008, | ||
1683 | 0xa222000b, 0xa6240010, 0x8f420144, 0x3c031000, 0xae220024, 0xaf4301b8, | ||
1684 | 0x0a001040, 0x3c024000, 0x0000000d, 0x00000000, 0x240002bf, 0x0a001040, | ||
1685 | 0x3c024000, 0x0e001441, 0x00000000, 0x0a001040, 0x3c024000, 0x0e0015ea, | ||
1686 | 0x00000000, 0x3c024000, 0xaf420178, 0x00000000, 0x8fbf0018, 0x8fb10014, | ||
1687 | 0x8fb00010, 0x03e00008, 0x27bd0020, 0x24020800, 0x03e00008, 0xaf4201b8, | ||
1688 | 0x27bdffe8, 0x3c04600c, 0xafbf0014, 0xafb00010, 0x8c825000, 0x3c1a8000, | ||
1689 | 0x2403ff7f, 0x3c106000, 0x00431024, 0x3442380c, 0x24030003, 0xac825000, | ||
1690 | 0x3c020008, 0xaf430008, 0x8e040808, 0x0342d825, 0x8e020808, 0x3c030800, | ||
1691 | 0xac600020, 0x3084fff0, 0x2c840001, 0x3042fff0, 0x38420010, 0x2c420001, | ||
1692 | 0xaf840010, 0xaf820000, 0x0e00160c, 0x00000000, 0x0e001561, 0x00000000, | ||
1693 | 0x3c020400, 0x3442000c, 0x3c03ffff, 0x34630806, 0xae021948, 0xae03194c, | ||
1694 | 0x8e021980, 0x34420200, 0xae021980, 0x8f500000, 0x32020003, 0x1040fffd, | ||
1695 | 0x32020001, 0x10400004, 0x32020002, 0x0e000f92, 0x00000000, 0x32020002, | ||
1696 | 0x1040fff6, 0x00000000, 0x0e000fe0, 0x00000000, 0x0a001071, 0x00000000, | ||
1697 | 0x27bdffe8, 0x3c04600c, 0xafbf0014, 0xafb00010, 0x8c825000, 0x3c1a8000, | ||
1698 | 0x2403ff7f, 0x3c106000, 0x00431024, 0x3442380c, 0x24030003, 0xac825000, | ||
1699 | 0x3c020008, 0xaf430008, 0x8e040808, 0x0342d825, 0x8e020808, 0x3c030800, | ||
1700 | 0xac600020, 0x3084fff0, 0x2c840001, 0x3042fff0, 0x38420010, 0x2c420001, | ||
1701 | 0xaf840010, 0xaf820000, 0x0e00160c, 0x00000000, 0x0e001561, 0x00000000, | ||
1702 | 0x3c020400, 0x3442000c, 0x3c03ffff, 0x34630806, 0xae021948, 0xae03194c, | ||
1703 | 0x8e021980, 0x8fbf0014, 0x34420200, 0xae021980, 0x8fb00010, 0x03e00008, | ||
1704 | 0x27bd0018, 0x00804821, 0x30a5ffff, 0x30c6ffff, 0x30e7ffff, 0x3c038000, | ||
1705 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020003, 0xa342018b, 0x9783000a, | ||
1706 | 0x8f840004, 0x8f880014, 0xaf490180, 0xa745018c, 0xa746018e, 0xa7470188, | ||
1707 | 0x31028000, 0xa7430190, 0x1040000c, 0xaf4401a8, 0x93420116, 0x304200fc, | ||
1708 | 0x005a1021, 0x24424004, 0x8c430000, 0x3063ffff, 0x14600004, 0x3c02ffff, | ||
1709 | 0x34427fff, 0x01021024, 0xaf820014, 0x97820016, 0x9743010c, 0x8f440104, | ||
1710 | 0x3042bfff, 0x00031c00, 0x3084ffff, 0x00641825, 0xa74201a6, 0xaf4301ac, | ||
1711 | 0x3c021000, 0xaf4201b8, 0x03e00008, 0x00000000, 0x27440180, 0x3c038000, | ||
1712 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24022000, 0x24030002, 0xa4820008, | ||
1713 | 0xa083000b, 0xa4800010, 0x3c021000, 0xaf4201b8, 0x03e00008, 0x00000000, | ||
1714 | 0x27440180, 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, | ||
1715 | 0x8f420148, 0x24030002, 0xa083000b, 0x00021402, 0xa4820008, 0x8f430148, | ||
1716 | 0xa4830010, 0x8f420144, 0x3c031000, 0xac820024, 0x03e00008, 0xaf4301b8, | ||
1717 | 0x27bdffe0, 0xafbf0018, 0xafb10014, 0xafb00010, 0x8f420148, 0x24030002, | ||
1718 | 0x3044ffff, 0x00021402, 0x305000ff, 0x1203000c, 0x27510180, 0x2a020003, | ||
1719 | 0x10400005, 0x24020003, 0x0600001d, 0x36053000, 0x0a001117, 0x3c038000, | ||
1720 | 0x12020007, 0x00000000, 0x0a001124, 0x00000000, 0x0e00112c, 0x00000000, | ||
1721 | 0x0a001115, 0x00402021, 0x0e00113e, 0x00000000, 0x00402021, 0x36053000, | ||
1722 | 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020002, 0xa6250008, | ||
1723 | 0xa222000b, 0xa6240010, 0x8f420144, 0x3c031000, 0xae220024, 0xaf4301b8, | ||
1724 | 0x0a001128, 0x8fbf0018, 0x0000000d, 0x00000000, 0x240002bf, 0x8fbf0018, | ||
1725 | 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, 0x3084ffff, 0x2c821389, | ||
1726 | 0x1040000d, 0x00001021, 0x3c030800, 0x24635900, 0x00042942, 0x00052880, | ||
1727 | 0x00a32821, 0x3086001f, 0x8ca40000, 0x24030001, 0x00c31804, 0x00832025, | ||
1728 | 0x03e00008, 0xaca40000, 0x03e00008, 0x24020091, 0x3084ffff, 0x2c821389, | ||
1729 | 0x1040000e, 0x00001021, 0x3c030800, 0x24635900, 0x00042942, 0x00052880, | ||
1730 | 0x00a32821, 0x3086001f, 0x24030001, 0x8ca40000, 0x00c31804, 0x00031827, | ||
1731 | 0x00832024, 0x03e00008, 0xaca40000, 0x03e00008, 0x24020091, 0x9482000c, | ||
1732 | 0x24870014, 0x00021302, 0x00021080, 0x00824021, 0x00e8182b, 0x1060004f, | ||
1733 | 0x00000000, 0x90e30000, 0x2c620009, 0x10400047, 0x3c020800, 0x24425890, | ||
1734 | 0x00031880, 0x00621821, 0x8c640000, 0x00800008, 0x00000000, 0x0a0011a4, | ||
1735 | 0x24e70001, 0x90e30001, 0x2402000a, 0x54620024, 0x01003821, 0x01071023, | ||
1736 | 0x2c42000a, 0x54400020, 0x01003821, 0x3c050800, 0x8ca26c98, 0x24e70002, | ||
1737 | 0x34420100, 0xaca26c98, 0x90e30000, 0x90e20001, 0x90e40002, 0x90e60003, | ||
1738 | 0x24e70004, 0x24a56c98, 0x00031e00, 0x00021400, 0x00621825, 0x00042200, | ||
1739 | 0x00641825, 0x00661825, 0xaca30004, 0x90e20000, 0x90e30001, 0x90e40002, | ||
1740 | 0x90e60003, 0x24e70004, 0x00021600, 0x00031c00, 0x00431025, 0x00042200, | ||
1741 | 0x00441025, 0x00461025, 0x0a0011a4, 0xaca20008, 0x90e30001, 0x24020004, | ||
1742 | 0x1062000e, 0x00601021, 0x0a00119e, 0x01001021, 0x90e30001, 0x24020003, | ||
1743 | 0x10620008, 0x00601021, 0x0a00119e, 0x01001021, 0x90e30001, 0x24020002, | ||
1744 | 0x14620003, 0x01001021, 0x00601021, 0x00e21021, 0x0a0011a4, 0x00403821, | ||
1745 | 0x90e20001, 0x0a0011a4, 0x00e23821, 0x01003821, 0x00e8102b, 0x5440ffb4, | ||
1746 | 0x90e30000, 0x03e00008, 0x24020001, 0x27bdff90, 0x3c030800, 0xafbf006c, | ||
1747 | 0xafbe0068, 0xafb70064, 0xafb60060, 0xafb5005c, 0xafb40058, 0xafb30054, | ||
1748 | 0xafb20050, 0xafb1004c, 0xafb00048, 0xac606c98, 0x93620023, 0x30420010, | ||
1749 | 0x1440027c, 0x24020001, 0x93420116, 0x93630005, 0x34424000, 0x30630001, | ||
1750 | 0x14600005, 0x0342b021, 0x0e0015e0, 0x00000000, 0x0a001436, 0x8fbf006c, | ||
1751 | 0x93420112, 0x8f430104, 0x3c040020, 0x34424000, 0x00641824, 0x10600012, | ||
1752 | 0x03422821, 0x27450180, 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, | ||
1753 | 0x00000000, 0x8f420128, 0xaca20000, 0x8f640040, 0x24030008, 0x240240c1, | ||
1754 | 0xa4a20008, 0x24020002, 0xa0a2000b, 0x3c021000, 0x0a0011f1, 0xa0a3000a, | ||
1755 | 0x8f420104, 0x3c030040, 0x00431024, 0x1040001d, 0x3c038000, 0x27450180, | ||
1756 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, 0x8f420128, 0xaca20000, | ||
1757 | 0x8f640040, 0x24030010, 0x240240c1, 0xa4a20008, 0x24020002, 0xa0a3000a, | ||
1758 | 0x24030008, 0xa0a2000b, 0x3c021000, 0xa4a30010, 0xa0a00012, 0xa0a00013, | ||
1759 | 0xaca00014, 0xaca00024, 0xaca00028, 0xaca0002c, 0xaca40018, 0x0e0015e0, | ||
1760 | 0xaf4201b8, 0x0a001436, 0x8fbf006c, 0x8f820000, 0x10400016, 0x00000000, | ||
1761 | 0x8f420104, 0x3c030001, 0x00431024, 0x10400011, 0x00000000, 0x8ca3000c, | ||
1762 | 0x8f620030, 0x1462022d, 0x24020001, 0x8ca30010, 0x8f62002c, 0x14620229, | ||
1763 | 0x24020001, 0x9763003a, 0x96c20000, 0x14430225, 0x24020001, 0x97630038, | ||
1764 | 0x96c20002, 0x14430221, 0x24020001, 0xaf400048, 0xaf400054, 0xaf400040, | ||
1765 | 0x8f740040, 0x8f650048, 0x00b43023, 0x04c10004, 0x00000000, 0x0000000d, | ||
1766 | 0x00000000, 0x240001af, 0x9742011a, 0x3052ffff, 0x12400004, 0x8ed30004, | ||
1767 | 0x02721021, 0x0a001228, 0x2451ffff, 0x02608821, 0x92d7000d, 0xa7a00020, | ||
1768 | 0xa3a0001a, 0xafa00028, 0x9362003f, 0x32e30004, 0x1060003a, 0x305000ff, | ||
1769 | 0x24040012, 0x16040006, 0x24020001, 0x3c040800, 0x8c830028, 0x24630001, | ||
1770 | 0x0a001328, 0xac830028, 0x8f620044, 0x16620010, 0x27a60010, 0x27450180, | ||
1771 | 0x3c038000, 0x2402001a, 0xa7a20020, 0x24020020, 0xafb40028, 0xa3b00022, | ||
1772 | 0xa3a40023, 0xa3a2001a, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, | ||
1773 | 0x0a00130d, 0x00000000, 0x8f620044, 0x02621023, 0x0440001a, 0x02651023, | ||
1774 | 0x044100d9, 0x24020001, 0x3c020800, 0x8c4300d8, 0x10600004, 0x24020001, | ||
1775 | 0xa7a20020, 0x0a00125e, 0xafb40028, 0x2402001a, 0xa7a20020, 0x24020020, | ||
1776 | 0xafb40028, 0xa3b00022, 0xa3a40023, 0xa3a2001a, 0x27a60010, 0x27450180, | ||
1777 | 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, 0x0a00130d, | ||
1778 | 0x00000000, 0x0a001328, 0x24020001, 0x0293f023, 0x1bc00016, 0x025e102a, | ||
1779 | 0x54400007, 0x32f700fe, 0x57d2000f, 0x027e9821, 0x32e20001, 0x5440000c, | ||
1780 | 0x027e9821, 0x32f700fe, 0x0240f021, 0x3c040800, 0x8c8300c8, 0x00009021, | ||
1781 | 0x24020001, 0xa7a20020, 0xafb40028, 0x24630001, 0x0a001282, 0xac8300c8, | ||
1782 | 0x025e1023, 0x0a001282, 0x3052ffff, 0x0000f021, 0x24a2ffff, 0x02221823, | ||
1783 | 0x1860001f, 0x0072102a, 0x54400019, 0x00a08821, 0x97a20020, 0x3c040800, | ||
1784 | 0x8c8300cc, 0xafb40028, 0x34420001, 0x24630001, 0xa7a20020, 0x02741026, | ||
1785 | 0x2c420001, 0xac8300cc, 0x2cc30001, 0x00431024, 0x1440000a, 0x02401821, | ||
1786 | 0x27a60010, 0x27450180, 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, | ||
1787 | 0x00000000, 0x0a00130d, 0x00000000, 0x00a08821, 0x02431023, 0x3052ffff, | ||
1788 | 0x0a0012ae, 0x32f700f6, 0x02741023, 0x18400008, 0x97a20020, 0x3c040800, | ||
1789 | 0x8c8300d4, 0xafb30028, 0x34420400, 0x24630001, 0xa7a20020, 0xac8300d4, | ||
1790 | 0x32e20002, 0x1040001c, 0x32e20010, 0x8f620044, 0x1662000d, 0x27a60010, | ||
1791 | 0x97a20020, 0x27450180, 0x3c038000, 0xafb40028, 0x34420001, 0xa7a20020, | ||
1792 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, 0x0a00130d, 0x00000000, | ||
1793 | 0x97a20020, 0x27450180, 0x3c038000, 0xafb40028, 0x34420001, 0xa7a20020, | ||
1794 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, 0x0a00130d, 0x00000000, | ||
1795 | 0x54400003, 0x8ed50008, 0x0a001328, 0x24020001, 0x8f630054, 0x26a2ffff, | ||
1796 | 0x00431023, 0x18400011, 0x27a60010, 0x97a20020, 0x3c040800, 0x8c8300d0, | ||
1797 | 0x27450180, 0x3c078000, 0xafb40028, 0x34420001, 0x24630001, 0xa7a20020, | ||
1798 | 0xac8300d0, 0x8f4201b8, 0x00471024, 0x1440fffd, 0x00000000, 0x0a00130d, | ||
1799 | 0x00000000, 0x32e20020, 0x10400011, 0x00000000, 0x96c20012, 0x0052102b, | ||
1800 | 0x10400008, 0x97a20020, 0x96d20012, 0x12400003, 0x02721021, 0x0a0012f2, | ||
1801 | 0x2451ffff, 0x02608821, 0x97a20020, 0x93a3001a, 0x34420008, 0x34630004, | ||
1802 | 0xa7a20020, 0xa3a3001a, 0x8f420104, 0x3c030080, 0x00431024, 0x10400037, | ||
1803 | 0x3a03000a, 0x0e001151, 0x02c02021, 0x24030002, 0x1443002b, 0x3c030800, | ||
1804 | 0x27a60010, 0x97a20020, 0x27450180, 0x3c038000, 0xafb40028, 0x34420001, | ||
1805 | 0xa7a20020, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, 0x8f420128, | ||
1806 | 0xaca20000, 0x8cc30018, 0x240240c1, 0xa4a20008, 0xaca30018, 0x90c4000a, | ||
1807 | 0x24020002, 0xa0a2000b, 0xa0a4000a, 0x94c20010, 0xa4a20010, 0x90c30012, | ||
1808 | 0xa0a30012, 0x90c20013, 0xa0a20013, 0x8cc30014, 0xaca30014, 0x8cc20024, | ||
1809 | 0xaca20024, 0x8cc30028, 0xaca30028, 0x8cc4002c, 0x24020001, 0x3c031000, | ||
1810 | 0xaca4002c, 0xaf4301b8, 0xaf400044, 0xaf400050, 0x0a001436, 0x8fbf006c, | ||
1811 | 0x8c626c98, 0x30420100, 0x10400003, 0x24636c98, 0x8c620004, 0xaf62017c, | ||
1812 | 0x3a03000a, 0x2c630001, 0x3a02000c, 0x2c420001, 0x00621825, 0x14600003, | ||
1813 | 0x2402000e, 0x56020030, 0x00009021, 0x52400008, 0x96c4000e, 0x12400004, | ||
1814 | 0xa7b20040, 0x02721021, 0x0a001343, 0x2451ffff, 0x02608821, 0x96c4000e, | ||
1815 | 0x93630035, 0x8f62004c, 0x00642004, 0x00952021, 0x00821023, 0x18400015, | ||
1816 | 0x00000000, 0x8f620018, 0x02621023, 0x1c400015, 0x97a20020, 0x8f620018, | ||
1817 | 0x1662001c, 0x00000000, 0x8f62001c, 0x02a21023, 0x1c40000e, 0x97a20020, | ||
1818 | 0x8f62001c, 0x16a20015, 0x00000000, 0x8f620058, 0x00821023, 0x18400011, | ||
1819 | 0x97a20020, 0x0a001364, 0xafb10028, 0x8f620058, 0x00821023, 0x0441000b, | ||
1820 | 0x97a20020, 0xafb10028, 0xafb30034, 0xafb50038, 0xafa4003c, 0x34420020, | ||
1821 | 0x0a00136d, 0xa7a20020, 0x02809821, 0x02608821, 0x8f640058, 0x8f62004c, | ||
1822 | 0x02a21023, 0x18400009, 0x00000000, 0x8f620054, 0x02a21023, 0x1c400005, | ||
1823 | 0x97a20020, 0xafb10028, 0xafb50024, 0x0a001385, 0x34420040, 0x9742011a, | ||
1824 | 0x1440000c, 0x24020014, 0x8f620058, 0x14820009, 0x24020014, 0x8f63004c, | ||
1825 | 0x8f620054, 0x10620004, 0x97a20020, 0xafb10028, 0x34420080, 0xa7a20020, | ||
1826 | 0x24020014, 0x1202000a, 0x2a020015, 0x10400005, 0x2402000c, 0x12020006, | ||
1827 | 0x32e20001, 0x0a0013c6, 0x00000000, 0x24020016, 0x16020035, 0x32e20001, | ||
1828 | 0x8f620084, 0x24420001, 0x16a20031, 0x32e20001, 0x24020014, 0x12020021, | ||
1829 | 0x2a020015, 0x10400005, 0x2402000c, 0x12020008, 0x32e20001, 0x0a0013c6, | ||
1830 | 0x00000000, 0x24020016, 0x1202000c, 0x32e20001, 0x0a0013c6, 0x00000000, | ||
1831 | 0x97a30020, 0x2402000e, 0xafb10028, 0xa3b00022, 0xa3a20023, 0xafb50024, | ||
1832 | 0x34630054, 0x0a0013c5, 0xa7a30020, 0x97a20020, 0x93a4001a, 0x24030010, | ||
1833 | 0xafb10028, 0xa3b00022, 0xa3a30023, 0xafb50024, 0x3442005d, 0x34840002, | ||
1834 | 0xa7a20020, 0x0a0013c5, 0xa3a4001a, 0x97a20020, 0x24030012, 0xa3a30023, | ||
1835 | 0x93a3001a, 0xafb10028, 0xa3b00022, 0xafb50024, 0x3042fffe, 0x3442005c, | ||
1836 | 0x34630002, 0xa7a20020, 0xa3a3001a, 0x32e20001, 0x10400030, 0x2402000c, | ||
1837 | 0x12020013, 0x2a02000d, 0x10400005, 0x2402000a, 0x12020008, 0x97a20020, | ||
1838 | 0x0a0013f8, 0x32e20009, 0x2402000e, 0x1202001b, 0x32e20009, 0x0a0013f9, | ||
1839 | 0x0002102b, 0x93a4001a, 0x24030008, 0xafb10028, 0xa3b00022, 0xa3a30023, | ||
1840 | 0x0a0013f4, 0x34420013, 0x97a30020, 0x30620004, 0x14400005, 0x93a2001a, | ||
1841 | 0x3463001b, 0xa7a30020, 0x0a0013e7, 0x24030016, 0x3463001b, 0xa7a30020, | ||
1842 | 0x24030010, 0xafb10028, 0xa3b00022, 0xa3a30023, 0x34420002, 0x0a0013f7, | ||
1843 | 0xa3a2001a, 0x97a20020, 0x93a4001a, 0x24030010, 0xafb10028, 0xa3b00022, | ||
1844 | 0xa3a30023, 0x3442001b, 0x34840002, 0xa7a20020, 0xa3a4001a, 0x32e20009, | ||
1845 | 0x0002102b, 0x00021023, 0x30420007, 0x12400015, 0x34450003, 0x8f820018, | ||
1846 | 0x24030800, 0x27440180, 0x24420001, 0xaf820018, 0x24020004, 0xaf4301b8, | ||
1847 | 0xa4850008, 0xa082000b, 0x93430120, 0x00003021, 0x3c021000, 0xa492000e, | ||
1848 | 0xac950024, 0xac930028, 0x007e1821, 0xa483000c, 0xaf4201b8, 0x0a001413, | ||
1849 | 0x97a20020, 0x24060001, 0x97a20020, 0x10400020, 0x27450180, 0x3c038000, | ||
1850 | 0x8f4201b8, 0x00431024, 0x1440fffd, 0x00000000, 0x8f420128, 0xaca20000, | ||
1851 | 0x8fa30028, 0x240240c1, 0xa4a20008, 0xaca30018, 0x93a4001a, 0x24020002, | ||
1852 | 0xa0a2000b, 0xa0a4000a, 0x97a20020, 0xa4a20010, 0x93a30022, 0xa0a30012, | ||
1853 | 0x93a20023, 0xa0a20013, 0x8fa30024, 0xaca30014, 0x8fa20034, 0xaca20024, | ||
1854 | 0x8fa30038, 0xaca30028, 0x8fa2003c, 0x3c031000, 0xaca2002c, 0xaf4301b8, | ||
1855 | 0x00c01021, 0x8fbf006c, 0x8fbe0068, 0x8fb70064, 0x8fb60060, 0x8fb5005c, | ||
1856 | 0x8fb40058, 0x8fb30054, 0x8fb20050, 0x8fb1004c, 0x8fb00048, 0x03e00008, | ||
1857 | 0x27bd0070, 0x8f470140, 0x8f460148, 0x3c028000, 0x00c24024, 0x00062c02, | ||
1858 | 0x30a300ff, 0x24020019, 0x106200e7, 0x27440180, 0x2862001a, 0x1040001f, | ||
1859 | 0x24020008, 0x106200be, 0x28620009, 0x1040000d, 0x24020001, 0x10620046, | ||
1860 | 0x28620002, 0x50400005, 0x24020006, 0x1060002e, 0x00a01821, 0x0a00155e, | ||
1861 | 0x00000000, 0x1062005b, 0x00a01821, 0x0a00155e, 0x00000000, 0x2402000b, | ||
1862 | 0x10620084, 0x2862000c, 0x10400005, 0x24020009, 0x106200bc, 0x00061c02, | ||
1863 | 0x0a00155e, 0x00000000, 0x2402000e, 0x106200b7, 0x00061c02, 0x0a00155e, | ||
1864 | 0x00000000, 0x28620021, 0x10400009, 0x2862001f, 0x104000c1, 0x2402001b, | ||
1865 | 0x106200bf, 0x2402001c, 0x1062009a, 0x00061c02, 0x0a00155e, 0x00000000, | ||
1866 | 0x240200c2, 0x106200ca, 0x286200c3, 0x10400005, 0x24020080, 0x1062005a, | ||
1867 | 0x00a01821, 0x0a00155e, 0x00000000, 0x240200c9, 0x106200cd, 0x30c5ffff, | ||
1868 | 0x0a00155e, 0x00000000, 0x3c058000, 0x8f4201b8, 0x00451024, 0x1440fffd, | ||
1869 | 0x24020001, 0xa4830008, 0x24030002, 0xac870000, 0xac800004, 0xa082000a, | ||
1870 | 0xa083000b, 0xa4860010, 0x8f430144, 0x3c021000, 0xac800028, 0xac830024, | ||
1871 | 0x3c036000, 0xaf4201b8, 0x03e00008, 0xac600808, 0x11000009, 0x00a01821, | ||
1872 | 0x3c020800, 0x24030002, 0xa0436c88, 0x24426c88, 0xac470008, 0x8f430144, | ||
1873 | 0x03e00008, 0xac430004, 0x3c058000, 0x8f4201b8, 0x00451024, 0x1440fffd, | ||
1874 | 0x24020002, 0xac800000, 0xac870004, 0xa4830008, 0xa082000a, 0xa082000b, | ||
1875 | 0xa4860010, 0xac800024, 0x8f420144, 0x3c031000, 0xac820028, 0x3c026000, | ||
1876 | 0xaf4301b8, 0x03e00008, 0xac400808, 0x3c080800, 0x3c058000, 0x8f4201b8, | ||
1877 | 0x00451024, 0x1440fffd, 0x00000000, 0xac870000, 0x91026c88, 0x00002821, | ||
1878 | 0x10400002, 0x25076c88, 0x8ce50008, 0xac850004, 0xa4830008, 0x91036c88, | ||
1879 | 0x24020002, 0xa082000b, 0xa4860010, 0x34630001, 0xa083000a, 0x8f420144, | ||
1880 | 0xac820024, 0x91036c88, 0x10600002, 0x00001021, 0x8ce20004, 0xac820028, | ||
1881 | 0x3c021000, 0xaf4201b8, 0x3c026000, 0xa1006c88, 0x03e00008, 0xac400808, | ||
1882 | 0x3c058000, 0x8f4201b8, 0x00451024, 0x1440fffd, 0x24020002, 0xa082000b, | ||
1883 | 0xa4830008, 0xa4860010, 0x8f420144, 0x3c031000, 0xa4820012, 0x03e00008, | ||
1884 | 0xaf4301b8, 0x30c2ffff, 0x14400028, 0x00061c02, 0x93620005, 0x30420004, | ||
1885 | 0x14400020, 0x3c029000, 0x34420001, 0x00e21025, 0xaf420020, 0x3c038000, | ||
1886 | 0x8f420020, 0x00431024, 0x1440fffd, 0x00000000, 0x93620005, 0x3c038000, | ||
1887 | 0x34630001, 0x00e31825, 0x34420004, 0xa3620005, 0xaf430020, 0x93620005, | ||
1888 | 0x30420004, 0x14400003, 0x3c038000, 0x0000000d, 0x3c038000, 0x8f4201b8, | ||
1889 | 0x00431024, 0x1440fffd, 0x24020005, 0x3c031000, 0xac870000, 0xa082000b, | ||
1890 | 0xaf4301b8, 0x0a00150d, 0x00061c02, 0x0000000d, 0x03e00008, 0x00000000, | ||
1891 | 0x00061c02, 0x3c058000, 0x8f4201b8, 0x00451024, 0x1440fffd, 0x24020001, | ||
1892 | 0xa4830008, 0x24030002, 0xac870000, 0xac800004, 0xa082000a, 0xa083000b, | ||
1893 | 0xa4860010, 0x8f430144, 0x3c021000, 0xac800028, 0xac830024, 0x03e00008, | ||
1894 | 0xaf4201b8, 0x3c058000, 0x8f4201b8, 0x00451024, 0x1440fffd, 0x24020002, | ||
1895 | 0xac800000, 0xac870004, 0xa4830008, 0xa082000a, 0xa082000b, 0xa4860010, | ||
1896 | 0xac800024, 0x8f420144, 0x3c031000, 0xac820028, 0x03e00008, 0xaf4301b8, | ||
1897 | 0x00061c02, 0x3c058000, 0x8f4201b8, 0x00451024, 0x1440fffd, 0x24020001, | ||
1898 | 0xa4830008, 0x24030002, 0xa082000a, 0x3c021000, 0xac870000, 0xac800004, | ||
1899 | 0xa083000b, 0xa4860010, 0xac800024, 0xac800028, 0x03e00008, 0xaf4201b8, | ||
1900 | 0x00a01821, 0x3c058000, 0x8f4201b8, 0x00451024, 0x1440fffd, 0x24020002, | ||
1901 | 0xac870000, 0xac800004, 0xa4830008, 0xa080000a, 0x0a001518, 0xa082000b, | ||
1902 | 0x8f440144, 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020002, | ||
1903 | 0x240340c9, 0xaf470180, 0xa342018b, 0x3c021000, 0xa7430188, 0xaf4401a4, | ||
1904 | 0xaf4501a8, 0xaf4001ac, 0x03e00008, 0xaf4201b8, 0x0000000d, 0x03e00008, | ||
1905 | 0x00000000, 0x03e00008, 0x00000000, 0x8f420100, 0x3042003e, 0x14400011, | ||
1906 | 0x24020001, 0xaf400048, 0x8f420100, 0x304207c0, 0x10400005, 0x00000000, | ||
1907 | 0xaf40004c, 0xaf400050, 0x03e00008, 0x24020001, 0xaf400054, 0xaf400040, | ||
1908 | 0x8f420100, 0x30423800, 0x54400001, 0xaf400044, 0x24020001, 0x03e00008, | ||
1909 | 0x00000000, 0x3c038000, 0x8f4201b8, 0x00431024, 0x1440fffd, 0x24020002, | ||
1910 | 0x240340c9, 0xaf440180, 0xa342018b, 0x3c021000, 0xa7430188, 0xaf4501a4, | ||
1911 | 0xaf4601a8, 0xaf4701ac, 0x03e00008, 0xaf4201b8, 0x3c029000, 0x34420001, | ||
1912 | 0x00822025, 0xaf440020, 0x3c038000, 0x8f420020, 0x00431024, 0x1440fffd, | ||
1913 | 0x00000000, 0x03e00008, 0x00000000, 0x3c028000, 0x34420001, 0x00822025, | ||
1914 | 0x03e00008, 0xaf440020, 0x308600ff, 0x27450180, 0x3c038000, 0x8f4201b8, | ||
1915 | 0x00431024, 0x1440fffd, 0x00000000, 0x8f420128, 0xaca20000, 0x8f640040, | ||
1916 | 0x24030008, 0x240240c1, 0xa4a20008, 0x24020002, 0xa0a2000b, 0x3c021000, | ||
1917 | 0xa0a6000a, 0xa4a30010, 0xa0a00012, 0xa0a00013, 0xaca00014, 0xaca00024, | ||
1918 | 0xaca00028, 0xaca0002c, 0xaca40018, 0x03e00008, 0xaf4201b8, 0x24020001, | ||
1919 | 0xacc40000, 0x03e00008, 0xa4e50000, 0x24020001, 0xaf400044, 0x03e00008, | ||
1920 | 0xaf400050, 0x00803021, 0x27450180, 0x3c038000, 0x8f4201b8, 0x00431024, | ||
1921 | 0x1440fffd, 0x00000000, 0x8f420128, 0xaca20000, 0x8cc30018, 0x240240c1, | ||
1922 | 0xa4a20008, 0xaca30018, 0x90c4000a, 0x24020002, 0xa0a2000b, 0xa0a4000a, | ||
1923 | 0x94c20010, 0xa4a20010, 0x90c30012, 0xa0a30012, 0x90c20013, 0xa0a20013, | ||
1924 | 0x8cc30014, 0xaca30014, 0x8cc20024, 0xaca20024, 0x8cc30028, 0xaca30028, | ||
1925 | 0x8cc2002c, 0x3c031000, 0xaca2002c, 0x24020001, 0xaf4301b8, 0xaf400044, | ||
1926 | 0x03e00008, 0xaf400050, 0x27bdffe8, 0xafbf0010, 0x0e001047, 0x00000000, | ||
1927 | 0x00002021, 0x0e000c78, 0xaf400180, 0x8fbf0010, 0x03e00008, 0x27bd0018, | ||
1928 | 0x8f460148, 0x27450180, 0x3c038000, 0x00061402, 0x304700ff, 0x8f4201b8, | ||
1929 | 0x00431024, 0x1440fffd, 0x00000000, 0x8f440140, 0x00061202, 0x304200ff, | ||
1930 | 0x00061c02, 0xaca20004, 0x24020002, 0xa4a30008, 0x30c300ff, 0xa0a2000b, | ||
1931 | 0xaca30024, 0x10e0000a, 0xaca40000, 0x28e20004, 0x14400005, 0x24020001, | ||
1932 | 0x24020005, 0x54e20005, 0xa0a0000a, 0x24020001, 0x0a001609, 0xa0a2000a, | ||
1933 | 0xa0a0000a, 0x3c021000, 0x03e00008, 0xaf4201b8, 0x03e00008, 0x00001021, | ||
1934 | 0x10c00007, 0x00000000, 0x8ca20000, 0x24c6ffff, 0x24a50004, 0xac820000, | ||
1935 | 0x14c0fffb, 0x24840004, 0x03e00008, 0x00000000, 0x0a00161f, 0x00a01021, | ||
1936 | 0xac860000, 0x00000000, 0x00000000, 0x24840004, 0x00a01021, 0x1440fffa, | ||
1937 | 0x24a5ffff, 0x03e00008, 0x00000000, 0x00000000 }; | ||
1938 | 1052 | ||
1939 | static u32 bnx2_RXP_b06FwData[(0x0/4) + 1] = { 0x0 }; | 1053 | static u32 bnx2_RXP_b06FwData[(0x0/4) + 1] = { 0x0 }; |
1940 | static u32 bnx2_RXP_b06FwRodata[(0x28/4) + 1] = { | 1054 | static u32 bnx2_RXP_b06FwRodata[(0x28/4) + 1] = { |
@@ -1943,387 +1057,264 @@ static u32 bnx2_RXP_b06FwRodata[(0x28/4) + 1] = { | |||
1943 | static u32 bnx2_RXP_b06FwBss[(0x13a4/4) + 1] = { 0x0 }; | 1057 | static u32 bnx2_RXP_b06FwBss[(0x13a4/4) + 1] = { 0x0 }; |
1944 | static u32 bnx2_RXP_b06FwSbss[(0x1c/4) + 1] = { 0x0 }; | 1058 | static u32 bnx2_RXP_b06FwSbss[(0x1c/4) + 1] = { 0x0 }; |
1945 | 1059 | ||
1946 | static u32 bnx2_rv2p_proc1[] = { | 1060 | static u8 bnx2_rv2p_proc1[] = { |
1947 | 0x00000008, 0xac000001, 0x0000000c, 0x2f800001, 0x00000010, 0x213f0004, | 1061 | 0x1f, 0x8b, 0x08, 0x08, 0x5e, 0xd0, 0x41, 0x44, 0x00, 0x03, 0x74, 0x65, |
1948 | 0x00000010, 0x20bf002c, 0x00000010, 0x203f0143, 0x00000018, 0x8000fffd, | 1062 | 0x73, 0x74, 0x31, 0x2e, 0x62, 0x69, 0x6e, 0x00, 0xc5, 0x56, 0xcf, 0x6b, |
1949 | 0x00000010, 0xb1b8b017, 0x0000000b, 0x2fdf0002, 0x00000000, 0x03d80000, | 1063 | 0x13, 0x51, 0x10, 0x9e, 0xec, 0x6e, 0xb2, 0xdb, 0x74, 0xbb, 0x1b, 0x2b, |
1950 | 0x00000000, 0x2c380000, 0x00000008, 0x2c800000, 0x00000008, 0x2d000000, | 1064 | 0xda, 0xa0, 0xb1, 0x8d, 0x51, 0x6a, 0x7f, 0xa4, 0xb4, 0x11, 0x0f, 0x82, |
1951 | 0x00000010, 0x91d40000, 0x00000008, 0x2d800108, 0x00000008, 0x02000002, | 1065 | 0x42, 0x25, 0x3d, 0x04, 0x54, 0x44, 0x7a, 0x28, 0x22, 0x82, 0x36, 0x8a, |
1952 | 0x00000010, 0x91de0000, 0x0000000f, 0x42e0001c, 0x00000010, 0x91840a08, | 1066 | 0xfe, 0x1b, 0xa1, 0x3f, 0xd2, 0x4b, 0x10, 0x7a, 0xb0, 0x58, 0xf1, 0x50, |
1953 | 0x00000008, 0x2c8000b0, 0x00000008, 0x2d000008, 0x00000008, 0x2d800150, | 1067 | 0x10, 0x2a, 0x68, 0x0f, 0xc9, 0xa1, 0x20, 0x52, 0x11, 0xda, 0x8b, 0x07, |
1954 | 0x00000000, 0x00000000, 0x00000010, 0x91de0000, 0x00000010, 0x2c620002, | 1068 | 0x2f, 0x42, 0x0f, 0x7a, 0x69, 0xbd, 0xa8, 0xff, 0x82, 0x08, 0x4d, 0x7c, |
1955 | 0x00000018, 0x80000012, 0x0000000b, 0x2fdf0002, 0x0000000c, 0x1f800002, | 1069 | 0x6f, 0x66, 0x9e, 0xee, 0x6e, 0xb2, 0x4d, 0x15, 0xc1, 0x85, 0xf6, 0xe3, |
1956 | 0x00000000, 0x2c070000, 0x00000018, 0x8000ffe6, 0x00000008, 0x02000002, | 1070 | 0xbd, 0x9d, 0x79, 0x33, 0xf3, 0xcd, 0x37, 0xfb, 0x62, 0x01, 0x40, 0x04, |
1957 | 0x0000000f, 0x42e0001c, 0x00000010, 0x91840a08, 0x00000008, 0x2c8000b0, | 1071 | 0x60, 0xcd, 0x46, 0x2c, 0x8d, 0x26, 0x04, 0x1a, 0x30, 0x7e, 0x52, 0x62, |
1958 | 0x00000008, 0x2d000008, 0x00000010, 0x91d40000, 0x00000008, 0x2d800108, | 1072 | 0x16, 0xde, 0xa6, 0x25, 0x4e, 0x44, 0xc6, 0xd3, 0x49, 0x81, 0x7b, 0x0d, |
1959 | 0x00000000, 0x00000000, 0x00000010, 0x91de0000, 0x00000018, 0x80000004, | 1073 | 0x28, 0xc9, 0x75, 0x4f, 0xf5, 0x55, 0xad, 0x53, 0xa0, 0x06, 0xbb, 0xa3, |
1960 | 0x0000000c, 0x1f800002, 0x00000000, 0x00000000, 0x00000018, 0x8000ffd9, | 1074 | 0x80, 0xcf, 0x47, 0x9d, 0xf0, 0x7c, 0xd6, 0x42, 0x2c, 0x31, 0xc2, 0x48, |
1961 | 0x0000000c, 0x29800002, 0x0000000c, 0x1f800002, 0x00000000, 0x2adf0000, | 1075 | 0x02, 0x61, 0x7b, 0x51, 0xae, 0xad, 0x48, 0x69, 0xc4, 0x42, 0x3f, 0xd0, |
1962 | 0x00000008, 0x2a000005, 0x00000018, 0x8000ffd4, 0x00000008, 0x02240030, | 1076 | 0x68, 0x7f, 0x67, 0xd1, 0x15, 0xff, 0x53, 0xf0, 0x39, 0x2f, 0xd7, 0x56, |
1963 | 0x00000018, 0x00040000, 0x00000018, 0x80000015, 0x00000018, 0x80000017, | 1077 | 0x7c, 0x0e, 0xed, 0xaa, 0xec, 0x2f, 0xfe, 0xd0, 0xfe, 0xba, 0xf0, 0x03, |
1964 | 0x00000018, 0x8000001b, 0x00000018, 0x8000004c, 0x00000018, 0x8000008c, | 1078 | 0x7e, 0x94, 0x5f, 0x02, 0xcf, 0x29, 0x66, 0x65, 0x5e, 0xdd, 0x22, 0xa0, |
1965 | 0x00000018, 0x8000000f, 0x00000018, 0x8000000e, 0x00000018, 0x8000000d, | 1079 | 0xca, 0xc7, 0x46, 0x2c, 0xf5, 0x91, 0xb5, 0x89, 0xef, 0xbf, 0x8a, 0xbc, |
1966 | 0x00000018, 0x8000000c, 0x00000018, 0x800000c2, 0x00000018, 0x8000000a, | 1080 | 0x55, 0xdc, 0x76, 0xf1, 0x82, 0xf9, 0x06, 0xe3, 0x26, 0x91, 0x1f, 0x28, |
1967 | 0x00000018, 0x80000009, 0x00000018, 0x80000008, 0x00000018, 0x800000fd, | 1081 | 0xf9, 0xe3, 0x00, 0xc8, 0xfd, 0x4f, 0x8d, 0x5f, 0xfb, 0x83, 0xfe, 0xf7, |
1968 | 0x00000018, 0x80000006, 0x00000018, 0x80000005, 0x00000018, 0x800000ff, | 1082 | 0xbb, 0x43, 0xf2, 0xbc, 0x28, 0xc0, 0x90, 0xb4, 0xdb, 0xe6, 0x7c, 0xc6, |
1969 | 0x00000018, 0x80000104, 0x00000018, 0x80000002, 0x00000018, 0x80000098, | 1083 | 0xe0, 0xb4, 0x96, 0xc4, 0xf7, 0x06, 0xfa, 0x1f, 0x11, 0xe7, 0x4a, 0xec, |
1970 | 0x00000018, 0x80000000, 0x0000000c, 0x1f800001, 0x00000000, 0x00000000, | 1084 | 0x61, 0x3c, 0xce, 0x78, 0x95, 0xb1, 0xc2, 0xe8, 0x32, 0x3a, 0x8c, 0x5d, |
1971 | 0x00000018, 0x8000ffba, 0x00000010, 0x91d40000, 0x0000000c, 0x29800001, | 1085 | 0x8c, 0x36, 0xe3, 0x26, 0x63, 0x9c, 0xb1, 0x83, 0xd1, 0x62, 0xdc, 0x63, |
1972 | 0x0000000c, 0x1f800001, 0x00000008, 0x2a000002, 0x00000018, 0x8000ffb5, | 1086 | 0x8c, 0x31, 0x46, 0x19, 0x1b, 0x8c, 0x46, 0x84, 0x50, 0xe3, 0xf5, 0x63, |
1973 | 0x00000010, 0xb1a0b012, 0x0000000b, 0x2fdf0002, 0x00000000, 0x2c200000, | 1087 | 0x46, 0xe0, 0xba, 0x23, 0x81, 0xba, 0x5f, 0xb3, 0x2e, 0x24, 0x6f, 0xfc, |
1974 | 0x00000008, 0x2c800000, 0x00000008, 0x2d000000, 0x00000010, 0x91d40000, | 1088 | 0x7e, 0x50, 0xd9, 0x31, 0xef, 0x58, 0xf7, 0x3a, 0xdb, 0x75, 0x57, 0x57, |
1975 | 0x00000008, 0x2d80011c, 0x00000000, 0x00000000, 0x00000010, 0x91de0000, | 1089 | 0x02, 0xfa, 0x49, 0xef, 0xab, 0x9b, 0x54, 0x8b, 0x3e, 0xb8, 0x58, 0xcf, |
1976 | 0x0000000f, 0x47600008, 0x0000000f, 0x060e0001, 0x00000010, 0x001f0000, | 1090 | 0x9d, 0x82, 0x8b, 0x71, 0x9c, 0x18, 0xed, 0xab, 0xb4, 0x6e, 0xb8, 0x84, |
1977 | 0x00000000, 0x0f580000, 0x00000000, 0x0a640000, 0x00000000, 0x0ae50000, | 1091 | 0xf7, 0xe2, 0x84, 0x5f, 0x18, 0xef, 0x77, 0x12, 0x4e, 0x77, 0xc9, 0x7c, |
1978 | 0x00000000, 0x0b660000, 0x00000000, 0x0d610000, 0x00000018, 0x80000013, | 1092 | 0x0e, 0x8b, 0x80, 0xea, 0x1c, 0x95, 0x4f, 0xbb, 0x3c, 0xc2, 0xe2, 0xa9, |
1979 | 0x0000000f, 0x47600008, 0x0000000b, 0x2fdf0002, 0x00000008, 0x2c800000, | 1093 | 0xbc, 0xda, 0xc5, 0x25, 0x2c, 0x6a, 0xfe, 0xfa, 0x9f, 0x8c, 0x11, 0x1a, |
1980 | 0x00000008, 0x2d000000, 0x00000010, 0x91d40000, 0x00000008, 0x2d80011c, | 1094 | 0x39, 0x22, 0x75, 0xc9, 0x16, 0x3d, 0x83, 0x46, 0x63, 0xd9, 0x36, 0xe4, |
1981 | 0x0000000f, 0x060e0001, 0x00000010, 0x001f0000, 0x00000000, 0x0f580000, | 1095 | 0xfa, 0xdc, 0xf2, 0x7b, 0xd4, 0xfb, 0xd9, 0xa5, 0x1a, 0xe7, 0xe7, 0x2a, |
1982 | 0x00000010, 0x91de0000, 0x00000000, 0x0a640000, 0x00000000, 0x0ae50000, | 1096 | 0x9e, 0x69, 0x0e, 0x32, 0x40, 0xeb, 0x49, 0xe4, 0x1d, 0x04, 0x5a, 0xb8, |
1983 | 0x00000000, 0x0b660000, 0x00000000, 0x0d610000, 0x00000000, 0x02620000, | 1097 | 0x86, 0x8c, 0xbf, 0x5f, 0xa4, 0x43, 0x9d, 0xfb, 0x31, 0xcb, 0xfd, 0x38, |
1984 | 0x0000000b, 0x2fdf0002, 0x00000000, 0x309a0000, 0x00000000, 0x31040000, | 1098 | 0x11, 0xd2, 0x8f, 0xb0, 0xb9, 0x68, 0x9e, 0xc7, 0xdb, 0xe9, 0x20, 0x6f, |
1985 | 0x00000000, 0x0c961800, 0x00000009, 0x0c99ffff, 0x00000004, 0xcc993400, | 1099 | 0x61, 0xf3, 0xa3, 0xf8, 0xa6, 0xdd, 0x3f, 0xe5, 0xf1, 0x01, 0xf3, 0x58, |
1986 | 0x00000010, 0xb1963202, 0x00000008, 0x0f800000, 0x0000000c, 0x29800001, | 1100 | 0x24, 0x1e, 0x93, 0xdf, 0x5a, 0xf2, 0x94, 0xf6, 0xf0, 0x24, 0xeb, 0xec, |
1987 | 0x00000010, 0x00220002, 0x0000000c, 0x29520001, 0x0000000c, 0x29520000, | 1101 | 0x0d, 0xe9, 0x73, 0x58, 0x7d, 0xd9, 0xbf, 0xee, 0x73, 0x20, 0x3f, 0xb8, |
1988 | 0x00000008, 0x22000001, 0x0000000c, 0x1f800001, 0x00000000, 0x2adf0000, | 1102 | 0x8b, 0xdf, 0x9b, 0x04, 0x14, 0x0b, 0x2a, 0x5f, 0x3f, 0xcf, 0xc7, 0xa8, |
1989 | 0x00000008, 0x2a000003, 0x00000018, 0x8000ff83, 0x00000010, 0xb1a0b01d, | 1103 | 0xdf, 0x30, 0x97, 0x93, 0xfb, 0x62, 0xfe, 0x36, 0x35, 0x5c, 0x1b, 0xf9, |
1990 | 0x0000000b, 0x2fdf0002, 0x00000000, 0x2c200000, 0x00000008, 0x2c8000b0, | 1104 | 0x88, 0x04, 0xab, 0x98, 0x23, 0x7f, 0x47, 0xd3, 0x78, 0x7d, 0x50, 0x5d, |
1991 | 0x00000008, 0x2d000008, 0x00000010, 0x91d40000, 0x00000008, 0x2d800150, | 1105 | 0xa8, 0xbe, 0x4b, 0x8c, 0x41, 0x7e, 0x9a, 0xeb, 0xcc, 0x50, 0x3c, 0xd2, |
1992 | 0x00000000, 0x00000000, 0x00000010, 0x205f0000, 0x00000008, 0x2c800000, | 1106 | 0x81, 0xc1, 0x3a, 0xc8, 0xf3, 0xf7, 0x28, 0xc8, 0x87, 0x55, 0x5d, 0x59, |
1993 | 0x00000008, 0x2d000000, 0x00000008, 0x2d800108, 0x00000000, 0x00000000, | 1107 | 0xf4, 0xce, 0x75, 0x12, 0x8a, 0x39, 0xd2, 0x55, 0x73, 0x5f, 0x59, 0x6f, |
1994 | 0x00000010, 0x91de0000, 0x0000000f, 0x47600008, 0x00000000, 0x060e0000, | 1108 | 0x6b, 0xea, 0xbb, 0x84, 0xdb, 0xd5, 0x92, 0xee, 0xab, 0xf7, 0x12, 0x64, |
1995 | 0x00000010, 0x001f0000, 0x00000000, 0x0f580000, 0x00000010, 0x91de0000, | 1109 | 0xbd, 0x3c, 0x47, 0x5a, 0xe8, 0xa3, 0x5d, 0x1c, 0xdf, 0x79, 0x0e, 0x64, |
1996 | 0x00000000, 0x0a640000, 0x00000000, 0x0ae50000, 0x00000000, 0x0b670000, | 1110 | 0x5b, 0x7d, 0x6f, 0x4c, 0xae, 0xeb, 0x0c, 0xeb, 0xfb, 0x68, 0x93, 0xbe, |
1997 | 0x00000000, 0x0d620000, 0x00000000, 0x0ce71800, 0x00000009, 0x0c99ffff, | 1111 | 0xd5, 0x7d, 0xf5, 0xef, 0x74, 0xce, 0xf5, 0x9b, 0x68, 0x97, 0xda, 0x59, |
1998 | 0x00000004, 0xcc993400, 0x00000010, 0xb1963220, 0x00000008, 0x0f800000, | 1112 | 0xf7, 0xde, 0x4f, 0x71, 0xcf, 0xfd, 0x44, 0x6e, 0xa6, 0xca, 0xbb, 0xcf, |
1999 | 0x00000018, 0x8000001e, 0x0000000f, 0x47600008, 0x0000000b, 0x2fdf0002, | 1113 | 0x7b, 0xaf, 0x1c, 0x0a, 0xe9, 0x83, 0xf7, 0x3e, 0x0a, 0xd6, 0xeb, 0xd7, |
2000 | 0x00000008, 0x2c8000b0, 0x00000008, 0x2d000008, 0x00000010, 0x91d40000, | 1114 | 0x23, 0xf5, 0x35, 0xce, 0xf5, 0x9b, 0x0d, 0xee, 0xc3, 0x54, 0xff, 0x0c, |
2001 | 0x00000008, 0x2d80012c, 0x0000000f, 0x060e0001, 0x00000010, 0x001f0000, | 1115 | 0xe9, 0x3f, 0x53, 0x90, 0xfa, 0x71, 0xc1, 0x31, 0xe9, 0x7c, 0x42, 0x71, |
2002 | 0x00000000, 0x0f580000, 0x00000010, 0x91de0000, 0x00000000, 0x0a640000, | 1116 | 0x8e, 0x66, 0x62, 0xde, 0xf3, 0x1a, 0xad, 0xe7, 0x67, 0xd0, 0x2f, 0x3e, |
2003 | 0x00000000, 0x0ae50000, 0x00000000, 0x0b670000, 0x00000000, 0x0d620000, | 1117 | 0xa7, 0xf6, 0xf3, 0x48, 0xd8, 0xe4, 0x8b, 0x2d, 0xe2, 0xbd, 0xa6, 0xab, |
2004 | 0x00000000, 0x02630000, 0x0000000f, 0x47620010, 0x00000000, 0x0ce71800, | 1118 | 0xb9, 0x70, 0x91, 0xef, 0x01, 0x97, 0xec, 0xcc, 0x2b, 0x8a, 0x2f, 0xb9, |
2005 | 0x0000000b, 0x2fdf0002, 0x00000000, 0x311a0000, 0x00000000, 0x31840000, | 1119 | 0xaf, 0xc3, 0x12, 0xcd, 0xc5, 0xad, 0x47, 0x84, 0x37, 0xe1, 0x32, 0x9d, |
2006 | 0x0000000b, 0xc20000ff, 0x00000002, 0x42040000, 0x00000001, 0x31620800, | 1120 | 0xfb, 0xfb, 0xfb, 0x66, 0x21, 0x42, 0x97, 0x57, 0xc7, 0x51, 0xa1, 0x63, |
2007 | 0x0000000f, 0x020e0010, 0x00000002, 0x31620800, 0x00000009, 0x0c99ffff, | 1121 | 0x9c, 0x63, 0x25, 0x57, 0x78, 0xae, 0x11, 0x9f, 0xf3, 0xa4, 0x73, 0x8d, |
2008 | 0x00000004, 0xcc993400, 0x00000010, 0xb1963202, 0x00000008, 0x0f800000, | 1122 | 0xf3, 0xc3, 0xab, 0x45, 0x3e, 0xab, 0xba, 0xac, 0xf7, 0x9a, 0xd2, 0x1d, |
2009 | 0x0000000c, 0x29800001, 0x0000000c, 0x1f800001, 0x0000000c, 0x61420006, | 1123 | 0x0c, 0x9b, 0x38, 0x3f, 0xa9, 0xca, 0x02, 0x2e, 0x7b, 0x1d, 0x46, 0xbb, |
2010 | 0x00000008, 0x22000008, 0x00000000, 0x2adf0000, 0x00000008, 0x2a000004, | 1124 | 0x4c, 0x18, 0xc3, 0xfc, 0x75, 0x78, 0x58, 0x93, 0x7e, 0x05, 0xbe, 0xdf, |
2011 | 0x00000018, 0x8000ff42, 0x00000008, 0x2c8000b0, 0x00000008, 0x2d000008, | 1125 | 0x7e, 0xb0, 0x5e, 0x74, 0xa8, 0xf0, 0xef, 0x8b, 0x05, 0x7c, 0x3f, 0x01, |
2012 | 0x00000010, 0x91a0b008, 0x00000010, 0x91d40000, 0x0000000c, 0x31620018, | 1126 | 0xcd, 0xf7, 0x1b, 0xc5, 0x29, 0x0f, 0x11, 0xda, 0xa7, 0xb8, 0xaf, 0xc3, |
2013 | 0x00000008, 0x2d800001, 0x00000000, 0x00000000, 0x00000010, 0x91de0000, | 1127 | 0xd2, 0xce, 0x11, 0x7e, 0xdc, 0x3f, 0xec, 0xc3, 0x05, 0x8f, 0x3f, 0x42, |
2014 | 0x00000008, 0xac000001, 0x00000018, 0x8000000e, 0x00000000, 0x0380b000, | 1128 | 0xe5, 0xc3, 0x40, 0x98, 0xbf, 0xb4, 0xff, 0xde, 0xe2, 0x3e, 0xa5, 0xf7, |
2015 | 0x0000000b, 0x2fdf0002, 0x00000000, 0x2c004000, 0x00000010, 0x91d40000, | 1129 | 0x2f, 0xc9, 0x7e, 0xaa, 0xff, 0x19, 0xd7, 0x3f, 0xec, 0xd5, 0xbd, 0x8a, |
2016 | 0x00000008, 0x2d800101, 0x00000000, 0x00000000, 0x00000010, 0x91de0000, | 1130 | 0xf7, 0xae, 0xbe, 0xff, 0x7d, 0xdc, 0xc1, 0x76, 0x5b, 0xfb, 0xd8, 0xd1, |
2017 | 0x0000000c, 0x31620018, 0x00000008, 0x2d800001, 0x00000000, 0x00000000, | 1131 | 0xf1, 0xf9, 0x41, 0xef, 0xfd, 0xfd, 0xa6, 0x4e, 0x3c, 0x6d, 0xd4, 0xd5, |
2018 | 0x00000010, 0x91de0000, 0x0000000b, 0x2fdf0002, 0x00000000, 0x2c000e00, | 1132 | 0x5c, 0x6d, 0x84, 0xcc, 0xd5, 0xc5, 0xff, 0x3a, 0x57, 0x10, 0x98, 0xab, |
2019 | 0x0000000c, 0x29800001, 0x0000000c, 0x1f800001, 0x00000008, 0x2a000007, | 1133 | 0xd5, 0xfa, 0xc1, 0xe6, 0x0a, 0xb8, 0x7e, 0x08, 0x99, 0xab, 0x18, 0xf3, |
2020 | 0x00000018, 0x8000ff27, 0x00000010, 0xb1a0b016, 0x0000000b, 0x2fdf0002, | 1134 | 0xf0, 0x94, 0xcf, 0x33, 0x20, 0xaa, 0xc7, 0xb0, 0x7d, 0xc6, 0x2c, 0xeb, |
2021 | 0x00000000, 0x03d80000, 0x00000000, 0x2c200000, 0x00000008, 0x2c8000b0, | 1135 | 0x92, 0xf4, 0x68, 0x47, 0xcb, 0xa8, 0x3f, 0xc7, 0x2e, 0x93, 0x9d, 0x41, |
2022 | 0x00000008, 0x2d000008, 0x00000010, 0x91d40000, 0x00000008, 0x2d800150, | 1136 | 0xfb, 0x49, 0x85, 0x0b, 0xb3, 0xf4, 0x7b, 0x4a, 0x83, 0x9f, 0x94, 0x15, |
2023 | 0x00000000, 0x00000000, 0x00000010, 0x205f0000, 0x00000008, 0x2c800000, | 1137 | 0x12, 0x3d, 0x80, 0x0b, 0x00, 0x00, 0x00 }; |
2024 | 0x00000008, 0x2d000000, 0x00000008, 0x2d800108, 0x00000008, 0x07000001, | ||
2025 | 0x00000010, 0xb5de1c00, 0x00000010, 0x2c620002, 0x00000018, 0x8000000a, | ||
2026 | 0x0000000b, 0x2fdf0002, 0x00000000, 0x2c070000, 0x0000000c, 0x1f800001, | ||
2027 | 0x00000010, 0x91de0000, 0x00000018, 0x8000ff11, 0x00000008, 0x2c8000b0, | ||
2028 | 0x00000008, 0x2d000008, 0x00000010, 0x91d40000, 0x00000008, 0x2d800108, | ||
2029 | 0x0000000c, 0x29800001, 0x0000000c, 0x1f800001, 0x00000010, 0x91de0000, | ||
2030 | 0x00000000, 0x2adf0000, 0x00000008, 0x2a00000a, 0x00000018, 0x8000ff07, | ||
2031 | 0x00000000, 0x82265600, 0x0000000f, 0x47220008, 0x00000009, 0x070e000f, | ||
2032 | 0x00000008, 0x070e0008, 0x00000008, 0x02800001, 0x00000007, 0x02851c00, | ||
2033 | 0x00000008, 0x82850001, 0x00000000, 0x02840a00, 0x00000007, 0x42851c00, | ||
2034 | 0x00000003, 0xc3aa5200, 0x00000000, 0x03b10e00, 0x00000010, 0x001f0000, | ||
2035 | 0x0000000f, 0x0f280007, 0x00000007, 0x4b071c00, 0x00000000, 0x00000000, | ||
2036 | 0x0000000f, 0x0a960003, 0x00000000, 0x0a955c00, 0x00000000, 0x4a005a00, | ||
2037 | 0x00000000, 0x0c960a00, 0x00000009, 0x0c99ffff, 0x00000008, 0x0d00ffff, | ||
2038 | 0x00000010, 0xb1963202, 0x00000008, 0x0f800005, 0x00000010, 0x00220020, | ||
2039 | 0x00000000, 0x02a70000, 0x00000010, 0xb1850002, 0x00000008, 0x82850200, | ||
2040 | 0x00000000, 0x02000000, 0x00000000, 0x03a60000, 0x00000018, 0x8000004e, | ||
2041 | 0x00000000, 0x072b0000, 0x00000001, 0x878c1c00, 0x00000000, 0x870e1e00, | ||
2042 | 0x00000000, 0x860c1e00, 0x00000000, 0x03061e00, 0x00000010, 0xb18e0003, | ||
2043 | 0x00000018, 0x80000047, 0x00000018, 0x8000fffa, 0x00000010, 0x918c0003, | ||
2044 | 0x00000010, 0xb1870002, 0x00000018, 0x80000043, 0x00000010, 0x91d40000, | ||
2045 | 0x0000000c, 0x29800001, 0x00000000, 0x2a860000, 0x00000000, 0x230c0000, | ||
2046 | 0x00000000, 0x2b070000, 0x00000010, 0xb187000e, 0x00000008, 0x2a000008, | ||
2047 | 0x00000018, 0x8000003b, 0x00000010, 0x91d40000, 0x00000000, 0x28d18c00, | ||
2048 | 0x00000000, 0x2a860000, 0x00000000, 0x230c0000, 0x00000000, 0x2b070000, | ||
2049 | 0x00000018, 0x8000fff8, 0x00000010, 0x91d40000, 0x0000000c, 0x29800001, | ||
2050 | 0x00000000, 0x2aab0000, 0x00000000, 0xa3265600, 0x00000000, 0x2b000000, | ||
2051 | 0x0000000c, 0x1f800001, 0x00000008, 0x2a000008, 0x00000018, 0x8000fec8, | ||
2052 | 0x00000010, 0x91d40000, 0x0000000c, 0x29800001, 0x0000000c, 0x1f800001, | ||
2053 | 0x00000008, 0x2a000009, 0x00000018, 0x8000fec3, 0x00000010, 0x91d40000, | ||
2054 | 0x0000000c, 0x29800001, 0x0000000c, 0x1f800001, 0x00000000, 0x29420000, | ||
2055 | 0x00000008, 0x2a000002, 0x00000018, 0x8000febd, 0x00000018, 0x8000febc, | ||
2056 | 0x00000010, 0xb1bcb016, 0x0000000b, 0x2fdf0002, 0x00000000, 0x03d80000, | ||
2057 | 0x00000000, 0x2c3c0000, 0x00000008, 0x2c8000b0, 0x00000008, 0x2d000008, | ||
2058 | 0x00000010, 0x91d40000, 0x00000008, 0x2d800150, 0x00000000, 0x00000000, | ||
2059 | 0x00000010, 0x205f0000, 0x00000008, 0x2c800000, 0x00000008, 0x2d000000, | ||
2060 | 0x00000008, 0x2d800108, 0x00000008, 0x07000001, 0x00000010, 0xb5de1c00, | ||
2061 | 0x00000010, 0x2c620002, 0x00000018, 0x8000000a, 0x0000000b, 0x2fdf0002, | ||
2062 | 0x00000000, 0x2c070000, 0x0000000c, 0x1f800000, 0x00000010, 0x91de0000, | ||
2063 | 0x00000018, 0x8000fea6, 0x00000008, 0x2c8000b0, 0x00000008, 0x2d000008, | ||
2064 | 0x00000010, 0x91d40000, 0x00000008, 0x2d800108, 0x0000000c, 0x29800000, | ||
2065 | 0x0000000c, 0x1f800000, 0x00000010, 0x91de0000, 0x00000000, 0x2adf0000, | ||
2066 | 0x00000008, 0x2a000006, 0x00000018, 0x8000fe9c, 0x00000008, 0x03050004, | ||
2067 | 0x00000006, 0x83040c00, 0x00000008, 0x02850200, 0x00000000, 0x86050c00, | ||
2068 | 0x00000001, 0x860c0e00, 0x00000008, 0x02040004, 0x00000000, 0x02041800, | ||
2069 | 0x00000000, 0x83871800, 0x00000018, 0x00020000 }; | ||
2070 | 1138 | ||
2071 | static u32 bnx2_rv2p_proc2[] = { | 1139 | static u8 bnx2_rv2p_proc2[] = { |
2072 | 0x00000000, 0x2a000000, 0x00000010, 0xb1d40000, 0x00000008, 0x02540003, | 1140 | 0x1f, 0x8b, 0x08, 0x08, 0x7e, 0xd1, 0x41, 0x44, 0x00, 0x03, 0x74, 0x65, |
2073 | 0x00000018, 0x00040000, 0x00000018, 0x8000000a, 0x00000018, 0x8000000a, | 1141 | 0x73, 0x74, 0x31, 0x2e, 0x62, 0x69, 0x6e, 0x00, 0xcd, 0x58, 0x5b, 0x6c, |
2074 | 0x00000018, 0x8000000e, 0x00000018, 0x80000056, 0x00000018, 0x800001b9, | 1142 | 0x54, 0x55, 0x14, 0x3d, 0xf3, 0xe8, 0xcc, 0x9d, 0xe9, 0xed, 0x9d, 0xf2, |
2075 | 0x00000018, 0x800001e1, 0x00000018, 0x8000019b, 0x00000018, 0x800001f9, | 1143 | 0xb2, 0x03, 0xad, 0x08, 0xe5, 0xd1, 0x56, 0x29, 0xe8, 0x54, 0xab, 0x18, |
2076 | 0x00000018, 0x8000019f, 0x00000018, 0x800001a6, 0x00000018, 0x80000000, | 1144 | 0x15, 0x2c, 0x5a, 0x8c, 0x26, 0x68, 0xf0, 0xf9, 0x63, 0x14, 0x04, 0xda, |
2077 | 0x0000000c, 0x29800001, 0x00000000, 0x2a000000, 0x0000000c, 0x29800000, | 1145 | 0x9a, 0x56, 0x9b, 0x16, 0xfb, 0x81, 0xaf, 0x09, 0x14, 0x6a, 0x4c, 0x25, |
2078 | 0x00000010, 0x20530000, 0x00000018, 0x8000ffee, 0x0000000c, 0x29800001, | 1146 | 0xd6, 0x08, 0xc5, 0x47, 0xa0, 0x11, 0x1f, 0x84, 0xf0, 0xd3, 0x1f, 0x3b, |
2079 | 0x00000010, 0x91de0000, 0x00000010, 0x001f0000, 0x00000000, 0x2f80aa00, | 1147 | 0x8d, 0x7f, 0x0a, 0x24, 0x6a, 0x88, 0xc4, 0xa8, 0x9f, 0x24, 0x68, 0xa0, |
2080 | 0x00000000, 0x2a000000, 0x00000000, 0x0d610000, 0x00000000, 0x03620000, | 1148 | 0x21, 0x0a, 0x58, 0x8b, 0x63, 0x4c, 0xb4, 0xf5, 0xec, 0xbd, 0xf6, 0xb9, |
2081 | 0x00000000, 0x2c400000, 0x00000000, 0x02638c00, 0x00000000, 0x26460000, | 1149 | 0x73, 0xef, 0x6d, 0x8b, 0x1a, 0xf9, 0x70, 0x3e, 0xba, 0x7b, 0xce, 0xd9, |
2082 | 0x00000010, 0x00420002, 0x00000008, 0x02040012, 0x00000010, 0xb9060836, | 1150 | 0x67, 0x3f, 0xd6, 0xde, 0x67, 0x9f, 0x7d, 0xae, 0x52, 0xfc, 0xbb, 0xb6, |
2083 | 0x00000000, 0x0f580000, 0x00000000, 0x0a640000, 0x00000000, 0x0ae50000, | 1151 | 0x94, 0xc9, 0x37, 0x83, 0x96, 0xfe, 0x1b, 0x51, 0x0f, 0x85, 0xd3, 0x3c, |
2084 | 0x00000000, 0x0b660000, 0x00000000, 0x0c000000, 0x00000000, 0x0b800000, | 1152 | 0x8e, 0x2a, 0xa2, 0x49, 0xa5, 0xb2, 0x5e, 0xea, 0x08, 0x7d, 0x44, 0xe8, |
2085 | 0x00000010, 0x00420009, 0x00000008, 0x0cc60012, 0x00000008, 0x0f800003, | 1153 | 0x70, 0x08, 0xf4, 0xb4, 0xd0, 0x77, 0x84, 0xfe, 0x2e, 0xf4, 0x80, 0xd0, |
2086 | 0x00000000, 0x00000000, 0x00000010, 0x009f0000, 0x00000008, 0x27110012, | 1154 | 0x0f, 0x85, 0xea, 0x5f, 0xd6, 0xd6, 0x7f, 0xf4, 0xb0, 0x46, 0x89, 0x7e, |
2087 | 0x00000000, 0x66900000, 0x00000008, 0xa31b0012, 0x00000018, 0x80000008, | 1155 | 0x1b, 0xd3, 0x35, 0xb0, 0xe3, 0xc1, 0x05, 0xc4, 0x77, 0x61, 0xa2, 0xc0, |
2088 | 0x00000000, 0x0cc60000, 0x00000008, 0x0f800003, 0x00000000, 0x00000000, | 1156 | 0x87, 0xf9, 0x53, 0x7d, 0xa0, 0xd7, 0x60, 0xd7, 0xe1, 0xec, 0x0a, 0xb3, |
2089 | 0x00000010, 0x009f0000, 0x00000000, 0x27110000, 0x00000000, 0x66900000, | 1157 | 0x1f, 0x64, 0x43, 0x09, 0xe8, 0xc6, 0x08, 0xe8, 0xea, 0x65, 0x4c, 0x7a, |
2090 | 0x00000000, 0x231b0000, 0x00000010, 0xb197320e, 0x00000000, 0x25960000, | 1158 | 0x9f, 0x0a, 0x63, 0xdc, 0xb8, 0x94, 0xf6, 0x87, 0x55, 0x83, 0x22, 0x3f, |
2091 | 0x00000000, 0x021b0000, 0x00000010, 0x001f0000, 0x00000008, 0x0f800003, | 1159 | 0x67, 0xaa, 0x68, 0x98, 0xc6, 0xf5, 0x56, 0x6c, 0x18, 0xeb, 0x8f, 0xa5, |
2092 | 0x0000000c, 0x29800000, 0x00000010, 0x20530000, 0x00000000, 0x22c50800, | 1160 | 0x40, 0x37, 0x25, 0x41, 0xcf, 0x08, 0xdd, 0x52, 0x2c, 0x7a, 0x6c, 0x31, |
2093 | 0x00000010, 0x009f0000, 0x00000000, 0x27002200, 0x00000000, 0x26802000, | 1161 | 0xbf, 0x98, 0xf6, 0x25, 0x5c, 0x39, 0xc7, 0x6d, 0xe0, 0x96, 0x95, 0xfd, |
2094 | 0x00000000, 0x231b0000, 0x0000000c, 0x69520001, 0x00000018, 0x8000fff3, | 1162 | 0x4a, 0xc1, 0xce, 0x03, 0xb2, 0x3e, 0xa3, 0x0a, 0xb3, 0xaf, 0x6f, 0xc1, |
2095 | 0x00000010, 0x01130002, 0x00000010, 0xb1980003, 0x00000010, 0x001f0000, | 1163 | 0xb8, 0xfc, 0x20, 0xf9, 0xa7, 0xff, 0xcf, 0x62, 0x7e, 0xfa, 0xfd, 0xf8, |
2096 | 0x00000008, 0x0f800004, 0x00000008, 0x22000003, 0x00000008, 0x2c80000c, | 1164 | 0x15, 0xf6, 0x83, 0x96, 0x2f, 0xa2, 0x75, 0x27, 0xd3, 0x3f, 0x88, 0xf1, |
2097 | 0x00000008, 0x2d00000c, 0x00000010, 0x009f0000, 0x00000000, 0x25960000, | 1165 | 0xde, 0x25, 0x32, 0x1f, 0x36, 0xf8, 0x18, 0x79, 0x41, 0x5c, 0x99, 0x58, |
2098 | 0x0000000c, 0x29800000, 0x00000000, 0x32140000, 0x00000000, 0x32950000, | 1166 | 0xc7, 0x2a, 0x7d, 0xf2, 0x2b, 0x15, 0xe4, 0x2f, 0xc8, 0x2e, 0x35, 0xf2, |
2099 | 0x00000000, 0x33160000, 0x00000000, 0x31e32e00, 0x00000008, 0x2d800010, | 1167 | 0x81, 0xfb, 0xfa, 0x16, 0xb2, 0x73, 0x4c, 0xc7, 0x01, 0xb8, 0xcd, 0x0a, |
2100 | 0x00000010, 0x20530000, 0x00000018, 0x8000ffac, 0x00000000, 0x23000000, | 1168 | 0x95, 0xb2, 0xdc, 0x7d, 0x83, 0x5e, 0x3d, 0x51, 0xad, 0x07, 0xfa, 0x54, |
2101 | 0x00000000, 0x25e60000, 0x00000008, 0x2200000b, 0x0000000c, 0x69520000, | 1169 | 0xa5, 0xc5, 0x20, 0x65, 0x97, 0x81, 0xaa, 0x5a, 0xbf, 0x1f, 0x7b, 0x97, |
2102 | 0x0000000c, 0x29800000, 0x00000010, 0x20530000, 0x00000018, 0x8000ffa5, | 1170 | 0x18, 0x7b, 0x30, 0x9e, 0x9d, 0x01, 0xdd, 0x23, 0xf4, 0xaa, 0x3a, 0x26, |
2103 | 0x0000000c, 0x29800001, 0x00000010, 0x91de0000, 0x00000000, 0x2fd50000, | 1171 | 0xcb, 0x7f, 0xb8, 0xc1, 0x62, 0x0c, 0xb2, 0xb5, 0xde, 0x7c, 0x38, 0x32, |
2104 | 0x00000010, 0x001f0000, 0x00000000, 0x02700000, 0x00000000, 0x0d620000, | 1172 | 0x61, 0xf0, 0x52, 0x8b, 0x40, 0xce, 0x2e, 0x21, 0x3e, 0x1d, 0x9c, 0x4a, |
2105 | 0x00000000, 0xbb630800, 0x00000000, 0x2a000000, 0x00000009, 0x076000ff, | 1173 | 0xc8, 0x5d, 0xdf, 0x32, 0x55, 0x1e, 0x7d, 0x30, 0x45, 0x1e, 0x61, 0xff, |
2106 | 0x0000000f, 0x2c0e0007, 0x00000008, 0x2c800000, 0x00000008, 0x2d000064, | 1174 | 0xb7, 0x2b, 0x7c, 0xf9, 0xa4, 0xda, 0x25, 0x4f, 0x36, 0x22, 0x8f, 0xac, |
2107 | 0x00000008, 0x2d80011c, 0x00000009, 0x06420002, 0x0000000c, 0x61420001, | 1175 | 0xa7, 0x3e, 0x91, 0x85, 0x6b, 0x13, 0xfa, 0xcf, 0x84, 0x7a, 0x32, 0x4e, |
2108 | 0x00000000, 0x0f400000, 0x00000000, 0x02d08c00, 0x00000000, 0x23000000, | 1176 | 0x01, 0x8a, 0x2b, 0x87, 0xfd, 0x53, 0xe2, 0xe7, 0x26, 0xed, 0x27, 0xd1, |
2109 | 0x00000004, 0x826da000, 0x00000000, 0x8304a000, 0x00000000, 0x22c50c00, | 1177 | 0x8a, 0x50, 0xb6, 0x36, 0xc1, 0x38, 0x35, 0xc4, 0xa0, 0xaf, 0x61, 0x03, |
2110 | 0x00000000, 0x03760000, 0x00000004, 0x83860a00, 0x00000000, 0x83870c00, | 1178 | 0xb6, 0xaf, 0x46, 0x5c, 0x7b, 0x4f, 0x86, 0x8d, 0xfd, 0x51, 0xfa, 0x3b, |
2111 | 0x00000010, 0x91de0000, 0x00000000, 0x037c0000, 0x00000000, 0x837b0c00, | 1179 | 0xd0, 0xb6, 0x9d, 0x47, 0x03, 0xd1, 0x1d, 0x4c, 0xed, 0x63, 0x95, 0x58, |
2112 | 0x00000001, 0x83060e00, 0x00000000, 0x83870c00, 0x00000000, 0x82850e00, | 1180 | 0xee, 0x8a, 0xf0, 0x7a, 0x72, 0x97, 0xcc, 0xf7, 0xec, 0xf0, 0xdb, 0xfd, |
2113 | 0x00000010, 0xb1860016, 0x0000000f, 0x47610018, 0x00000000, 0x068e0000, | 1181 | 0x02, 0xf2, 0xdb, 0x7e, 0x7e, 0x47, 0x88, 0xa8, 0x13, 0x73, 0xf9, 0x98, |
2114 | 0x0000000f, 0x47670010, 0x0000000f, 0x47e20010, 0x00000000, 0x870e1e00, | 1182 | 0x3a, 0x3b, 0xb7, 0x13, 0xff, 0x55, 0x6a, 0xd7, 0x20, 0x29, 0x4e, 0xab, |
2115 | 0x00000010, 0xb70e1a10, 0x00000010, 0x0ce7000e, 0x00000008, 0x22000009, | 1183 | 0x0d, 0x6b, 0xb1, 0x6f, 0x77, 0x2c, 0xc5, 0xb8, 0x36, 0xad, 0x05, 0xfd, |
2116 | 0x00000000, 0x286d0000, 0x0000000f, 0x65680010, 0x00000003, 0xf66c9400, | 1184 | 0x1e, 0xf3, 0xf3, 0x9d, 0x1e, 0xe2, 0x2f, 0x9d, 0xe7, 0x0c, 0x71, 0x5e, |
2117 | 0x00000010, 0xb972a003, 0x0000000c, 0x73e70019, 0x0000000c, 0x21420004, | 1185 | 0xa9, 0x11, 0xce, 0xc7, 0x04, 0x65, 0x06, 0xff, 0xda, 0xaa, 0xc1, 0xdf, |
2118 | 0x00000018, 0x8000023f, 0x00000000, 0x37ed0000, 0x0000000c, 0x73e7001a, | 1186 | 0xbc, 0x99, 0x15, 0xbf, 0xd9, 0x9a, 0xe7, 0x3c, 0x18, 0xe8, 0x18, 0x26, |
2119 | 0x00000010, 0x20530000, 0x00000008, 0x22000008, 0x0000000c, 0x61420004, | 1187 | 0x3f, 0xe7, 0xaa, 0x91, 0x4e, 0xa2, 0x51, 0xd5, 0xb0, 0x90, 0xf0, 0x5e, |
2120 | 0x00000000, 0x02f60000, 0x00000004, 0x82840a00, 0x00000010, 0xb1840a2b, | 1188 | 0x15, 0x36, 0x71, 0x3a, 0x7f, 0x33, 0xcd, 0xcf, 0xd3, 0xeb, 0x26, 0x1e, |
2121 | 0x00000010, 0x2d67000a, 0x00000010, 0xb96d0804, 0x00000004, 0xb6ed0a00, | 1189 | 0x24, 0xd7, 0x92, 0x78, 0x45, 0x5d, 0x7c, 0xf2, 0x61, 0xf8, 0xdb, 0xcd, |
2122 | 0x00000000, 0x37ed0000, 0x00000018, 0x80000029, 0x0000000c, 0x61420000, | 1190 | 0x76, 0x5f, 0x97, 0xec, 0xe6, 0xfc, 0x4a, 0xaa, 0x26, 0x8e, 0x7f, 0xd4, |
2123 | 0x00000000, 0x37040000, 0x00000000, 0x37850000, 0x0000000c, 0x33e7001a, | 1191 | 0x6a, 0x1b, 0xc6, 0xfa, 0xf9, 0x8f, 0x8d, 0x5c, 0xd2, 0x53, 0x23, 0x75, |
2124 | 0x00000018, 0x80000024, 0x00000010, 0xb96d0809, 0x00000004, 0xb6ed0a00, | 1192 | 0x44, 0xb9, 0x72, 0xa2, 0x37, 0x83, 0xee, 0x34, 0x7a, 0xeb, 0x88, 0x6f, |
2125 | 0x00000000, 0x036d0000, 0x00000004, 0xb76e0c00, 0x00000010, 0x91ee0c1f, | 1193 | 0xb1, 0x42, 0xfe, 0x26, 0x26, 0xc9, 0x69, 0x03, 0xce, 0xf6, 0x33, 0xec, |
2126 | 0x0000000c, 0x73e7001a, 0x00000004, 0xb6ef0c00, 0x00000000, 0x37ed0000, | 1194 | 0xf7, 0x35, 0xf6, 0x85, 0x3e, 0x63, 0x2f, 0xe6, 0x2f, 0xfa, 0xf4, 0x95, |
2127 | 0x00000018, 0x8000001b, 0x0000000c, 0x61420000, 0x00000010, 0xb7ee0a05, | 1195 | 0x7b, 0xf4, 0x11, 0x7f, 0x51, 0xf2, 0x02, 0xef, 0x9b, 0x63, 0x3d, 0x3b, |
2128 | 0x00000010, 0xb96f0815, 0x00000003, 0xb76e0800, 0x00000004, 0xb7ef0a00, | 1196 | 0xcc, 0xb8, 0x58, 0xcf, 0x0c, 0x41, 0xfe, 0xc5, 0x21, 0xe2, 0x9f, 0x23, |
2129 | 0x00000018, 0x80000015, 0x00000010, 0x0ce7000c, 0x00000008, 0x22000009, | 1197 | 0x7a, 0xed, 0xff, 0x88, 0xe7, 0x9c, 0x30, 0xe4, 0x4c, 0x8f, 0x5f, 0xc1, |
2130 | 0x00000000, 0x286d0000, 0x0000000f, 0x65680010, 0x00000003, 0xf66c9400, | 1198 | 0x6f, 0xe3, 0x17, 0xcb, 0xb5, 0x47, 0x73, 0x69, 0xe6, 0x33, 0xf1, 0xe8, |
2131 | 0x00000010, 0xb972a003, 0x0000000c, 0x73e70019, 0x0000000c, 0x21420004, | 1199 | 0x0e, 0x73, 0x02, 0xa6, 0x1b, 0x16, 0xfa, 0x71, 0x33, 0xf6, 0x9c, 0xdf, |
2132 | 0x00000018, 0x80000215, 0x00000010, 0x20530000, 0x00000008, 0x22000008, | 1200 | 0xcc, 0x79, 0x3e, 0xd1, 0x26, 0x75, 0x40, 0x71, 0x9d, 0xb9, 0x5d, 0xe2, |
2133 | 0x0000000c, 0x61420004, 0x00000000, 0x37040000, 0x00000000, 0x37850000, | 1201 | 0xa1, 0xf3, 0x3a, 0x04, 0xff, 0x46, 0x73, 0x2c, 0x3f, 0xd9, 0xc5, 0x79, |
2134 | 0x00000000, 0x036d0000, 0x00000003, 0xb8f10c00, 0x00000018, 0x80000004, | 1202 | 0xb9, 0xd2, 0x8e, 0xe6, 0x38, 0x5e, 0xd6, 0xd9, 0x21, 0x6c, 0x2b, 0xd4, |
2135 | 0x00000000, 0x02840000, 0x00000002, 0x21421800, 0x0000000c, 0x61420000, | 1203 | 0x4f, 0xc8, 0x6b, 0xb6, 0x41, 0x9b, 0xa4, 0x8e, 0x9e, 0x15, 0xda, 0x6d, |
2136 | 0x00000000, 0x286d0000, 0x0000000f, 0x65ed0010, 0x00000009, 0x266dffff, | 1204 | 0x33, 0x3e, 0xba, 0x8e, 0x59, 0x2c, 0x3f, 0x9b, 0x32, 0xf7, 0x0c, 0xd6, |
2137 | 0x00000000, 0x23000000, 0x00000010, 0xb1840a3d, 0x00000010, 0x01420002, | 1205 | 0x9f, 0x16, 0x39, 0x3f, 0x0a, 0x55, 0x22, 0xa7, 0x55, 0xf6, 0x9f, 0xf3, |
2138 | 0x00000004, 0xb8f10a00, 0x00000003, 0x83760a00, 0x00000010, 0xb8040c39, | 1206 | 0xc9, 0x89, 0x04, 0xe4, 0x84, 0x94, 0xc1, 0xcd, 0x9c, 0xef, 0x5d, 0x52, |
2139 | 0x00000010, 0xb7e6080a, 0x00000000, 0x0a640000, 0x00000000, 0x0ae50000, | 1207 | 0xbf, 0xf7, 0xc5, 0xa6, 0xab, 0xb7, 0x7c, 0x0e, 0xdc, 0xba, 0x5a, 0x8e, |
2140 | 0x00000009, 0x0c68ffff, 0x00000009, 0x0b67ffff, 0x00000000, 0x0be60000, | 1208 | 0x3a, 0x53, 0x1f, 0x0d, 0xb3, 0xbf, 0x03, 0xdd, 0x3b, 0x80, 0x53, 0x8f, |
2141 | 0x00000000, 0x0c840000, 0x00000010, 0xb197320c, 0x00000008, 0x0f800002, | 1209 | 0xe0, 0x14, 0x07, 0x4e, 0xf3, 0x0a, 0xf5, 0x59, 0x14, 0xd4, 0x90, 0xfe, |
2142 | 0x00000018, 0x8000000a, 0x00000000, 0x0a6a0000, 0x00000000, 0x0aeb0000, | 1210 | 0x53, 0x21, 0xe3, 0xc7, 0xbe, 0x98, 0xaf, 0xfe, 0xf6, 0x9a, 0xfa, 0x5b, |
2143 | 0x00000000, 0x0c000000, 0x00000009, 0x0b6cffff, 0x00000000, 0x0be90000, | 1211 | 0xa8, 0xd3, 0xc4, 0xff, 0xb3, 0xa9, 0x6f, 0x5a, 0x9f, 0xd1, 0xff, 0x6f, |
2144 | 0x00000000, 0x0c840000, 0x00000010, 0xb1973203, 0x00000008, 0x0f800002, | 1212 | 0xf5, 0x72, 0x9c, 0x92, 0xdd, 0x7d, 0x26, 0xce, 0x98, 0x2e, 0xd4, 0xd9, |
2145 | 0x00000018, 0x80000001, 0x00000010, 0x001f0000, 0x00000000, 0x0c860000, | 1213 | 0x22, 0x22, 0xcb, 0x46, 0x3a, 0x99, 0x5e, 0xdf, 0xbc, 0x15, 0xf3, 0x65, |
2146 | 0x00000000, 0x06980000, 0x00000008, 0x0f800003, 0x00000000, 0x00000000, | 1214 | 0x7c, 0x4e, 0x6e, 0x09, 0x01, 0xaf, 0xa8, 0x3a, 0xde, 0x87, 0xba, 0xae, |
2147 | 0x00000010, 0x009f0000, 0x00000010, 0xb1973210, 0x00000000, 0x231b0000, | 1215 | 0xe2, 0x2c, 0xaf, 0xe2, 0x28, 0xc7, 0x3f, 0xaa, 0xe5, 0x12, 0xdf, 0x67, |
2148 | 0x00000000, 0x02043600, 0x00000003, 0x8384a000, 0x0000000f, 0x65870010, | 1216 | 0xa1, 0x42, 0x3e, 0x7a, 0xfd, 0xd9, 0xad, 0xf3, 0x84, 0xec, 0x88, 0xe9, |
2149 | 0x00000009, 0x2607ffff, 0x00000000, 0x27111a00, 0x00000000, 0x66900000, | 1217 | 0xbc, 0xa5, 0xb1, 0x3e, 0x47, 0xb6, 0xe4, 0xf9, 0x1a, 0xe6, 0xb3, 0xc7, |
2150 | 0x0000000c, 0x29000000, 0x00000018, 0x800001de, 0x00000000, 0x06980000, | 1218 | 0x22, 0x34, 0xff, 0x80, 0xd5, 0xd3, 0x87, 0xf9, 0x9f, 0x1a, 0x69, 0xbc, |
2151 | 0x00000010, 0x20530000, 0x00000000, 0x22c58c00, 0x00000010, 0x001f0000, | 1219 | 0xce, 0x7e, 0x0d, 0xe7, 0xcc, 0x7e, 0x0d, 0xf5, 0xcb, 0x2a, 0x3a, 0x88, |
2152 | 0x00000008, 0x0f800003, 0x00000018, 0x8000fff0, 0x00000000, 0x02043600, | 1220 | 0xba, 0xd6, 0x78, 0x10, 0xf2, 0x71, 0x4f, 0x7b, 0xfd, 0xf2, 0xe2, 0x47, |
2153 | 0x00000000, 0x231b0000, 0x00000003, 0x8384a000, 0x0000000f, 0x65870010, | 1221 | 0xe7, 0xe1, 0xb2, 0x38, 0xd9, 0xcf, 0x09, 0x4e, 0x97, 0x7c, 0xf1, 0x39, |
2154 | 0x00000009, 0x2607ffff, 0x00000000, 0x27111a00, 0x00000000, 0x66900000, | 1222 | 0x6c, 0xe2, 0xd3, 0x1b, 0x93, 0xf3, 0xd2, 0x7c, 0x29, 0xe8, 0x17, 0xf1, |
2155 | 0x0000000c, 0x29000000, 0x00000010, 0x91840a02, 0x00000002, 0x21421800, | 1223 | 0x9d, 0x71, 0xef, 0x9d, 0xae, 0x95, 0xa0, 0xdd, 0x2b, 0xe5, 0x9c, 0xd6, |
2156 | 0x00000000, 0x32140000, 0x00000000, 0x32950000, 0x00000005, 0x73e72c00, | 1224 | 0xf9, 0xf3, 0x6b, 0x3e, 0xea, 0xf2, 0xb8, 0x7b, 0x4f, 0x20, 0xbf, 0xac, |
2157 | 0x00000005, 0x74683000, 0x00000000, 0x33170000, 0x00000018, 0x80000138, | 1225 | 0x9d, 0xf0, 0x4b, 0xbd, 0x28, 0x79, 0x3c, 0x2e, 0xf4, 0x65, 0xc9, 0xdf, |
2158 | 0x00000010, 0x91c60004, 0x00000008, 0x07000004, 0x00000010, 0xb1c41c02, | 1226 | 0x6d, 0xd2, 0xb7, 0x98, 0xfe, 0xe2, 0x0f, 0xcc, 0x3b, 0xfd, 0x6e, 0x5f, |
2159 | 0x00000010, 0x91840a04, 0x00000018, 0x800001c3, 0x00000010, 0x20530000, | 1227 | 0x60, 0xea, 0x36, 0x8d, 0x43, 0xca, 0x89, 0x13, 0x83, 0x36, 0xeb, 0x33, |
2160 | 0x00000000, 0x22c58c00, 0x00000010, 0xb1840a8e, 0x0000000c, 0x21420006, | 1228 | 0x24, 0x4a, 0xcf, 0x1a, 0xe0, 0x35, 0x52, 0x07, 0xbe, 0xdd, 0x91, 0xb0, |
2161 | 0x00000010, 0x0ce7001a, 0x0000000f, 0x43680010, 0x00000000, 0x03f30c00, | 1229 | 0x8c, 0x21, 0x6f, 0xac, 0xda, 0x77, 0x0f, 0xd7, 0x4f, 0xc6, 0x93, 0xe4, |
2162 | 0x00000010, 0x91870850, 0x0000000f, 0x46ec0010, 0x00000010, 0xb68d0c4e, | 1230 | 0xc6, 0xdc, 0xfa, 0x24, 0x79, 0xaf, 0x26, 0x84, 0x96, 0x2f, 0xbe, 0x2c, |
2163 | 0x00000000, 0x838d0c00, 0x00000000, 0xa3050800, 0x00000001, 0xa3460e00, | 1231 | 0xbe, 0x85, 0xfe, 0x64, 0xa9, 0x17, 0xdf, 0x97, 0x34, 0xbe, 0xbc, 0xaf, |
2164 | 0x00000000, 0x02048c00, 0x00000010, 0x91840a02, 0x00000002, 0x21421800, | 1232 | 0xbe, 0xf9, 0x12, 0xa6, 0x4b, 0x6f, 0x05, 0xed, 0xbb, 0x95, 0xe7, 0x17, |
2165 | 0x00000010, 0x001f0000, 0x00000008, 0x22000008, 0x00000003, 0x8384a000, | 1233 | 0xa3, 0xee, 0x11, 0x7e, 0x9c, 0x5f, 0xf5, 0x6f, 0x0c, 0x9a, 0x7e, 0x42, |
2166 | 0x0000000f, 0x65870010, 0x00000009, 0x2607ffff, 0x00000000, 0x27750c00, | 1234 | 0xf0, 0x08, 0xf4, 0x41, 0x65, 0x77, 0x80, 0xbe, 0x29, 0x74, 0xce, 0x2a, |
2167 | 0x00000000, 0x66f40000, 0x0000000c, 0x29000000, 0x00000018, 0x800001aa, | 1235 | 0xd0, 0xbd, 0xab, 0xfc, 0x71, 0x88, 0xa5, 0x7c, 0x71, 0xac, 0x47, 0x1c, |
2168 | 0x00000000, 0x03068c00, 0x00000003, 0xf4680c00, 0x00000010, 0x20530000, | 1236 | 0x8f, 0x4c, 0x04, 0xeb, 0x81, 0xc4, 0x4b, 0xc7, 0x27, 0x70, 0xbf, 0x1b, |
2169 | 0x00000000, 0x22c58c00, 0x00000018, 0x8000ffe5, 0x00000000, 0x39760000, | 1237 | 0xfd, 0xe2, 0xce, 0xdf, 0xc5, 0xed, 0x4a, 0xc7, 0xab, 0x7b, 0x25, 0xee, |
2170 | 0x00000000, 0x39840000, 0x0000000c, 0x33e70019, 0x00000010, 0x001f0000, | 1238 | 0x93, 0x0e, 0xe9, 0x4b, 0xc7, 0xdc, 0xfb, 0xe2, 0x9f, 0xc4, 0x31, 0x7e, |
2171 | 0x00000000, 0x031e0000, 0x00000000, 0x0760fe00, 0x0000000f, 0x0f0e0007, | 1239 | 0x85, 0xe3, 0x78, 0xf7, 0xff, 0x2c, 0x8e, 0x9d, 0x12, 0xc7, 0x22, 0xb9, |
2172 | 0x00000000, 0x83850800, 0x00000000, 0x0a7d0000, 0x00000000, 0x0afe0000, | 1240 | 0x57, 0x4d, 0xbf, 0xd9, 0x2e, 0x7d, 0x18, 0xf5, 0x8d, 0x7e, 0xbd, 0x4f, |
2173 | 0x00000000, 0x0b7f0000, 0x00000000, 0x0d7a0000, 0x00000000, 0x0c000000, | 1241 | 0x70, 0x1f, 0x78, 0xb5, 0x5b, 0x8f, 0xe7, 0x33, 0x7f, 0x4e, 0xf6, 0x95, |
2174 | 0x00000000, 0x0bfc0000, 0x00000000, 0x0c970e00, 0x00000008, 0x0f800003, | 1242 | 0xca, 0xbe, 0x7b, 0x26, 0xed, 0x3b, 0xc5, 0xf5, 0xee, 0xf1, 0xf1, 0xc9, |
2175 | 0x0000000f, 0x47670010, 0x00000008, 0x070e0001, 0x0000000b, 0xc38000ff, | 1243 | 0xef, 0x15, 0x9f, 0x9d, 0x59, 0x95, 0x02, 0xee, 0xa8, 0xe3, 0xb1, 0x29, |
2176 | 0x00000002, 0x43870000, 0x00000001, 0x33e70e00, 0x0000000f, 0x038e0010, | 1244 | 0xde, 0x37, 0x86, 0x1f, 0xf9, 0xb5, 0x36, 0x85, 0xba, 0x05, 0xfe, 0xb9, |
2177 | 0x00000002, 0x33e70e00, 0x00000000, 0x28f30000, 0x00000010, 0x009f0000, | 1245 | 0x9e, 0x7a, 0x4a, 0xe3, 0xfb, 0xc7, 0xa7, 0xef, 0x57, 0x8d, 0x3c, 0xc4, |
2178 | 0x00000000, 0x02043600, 0x00000010, 0x91840a02, 0x00000002, 0x21421800, | 1246 | 0x6d, 0x43, 0xb8, 0x84, 0xf9, 0x4e, 0xb7, 0xf3, 0x7d, 0xe7, 0xfa, 0xb7, |
2179 | 0x00000008, 0x22000006, 0x00000000, 0x231b0000, 0x00000000, 0x23ff0000, | 1247 | 0x9a, 0xfd, 0x3a, 0x2a, 0xfe, 0x55, 0x88, 0x7f, 0x7a, 0xb9, 0x96, 0xeb, |
2180 | 0x00000000, 0x241b0000, 0x00000003, 0x8384a000, 0x0000000f, 0x65870010, | 1248 | 0xbe, 0x75, 0xba, 0xdd, 0xeb, 0xdf, 0x9d, 0x97, 0xd1, 0xf7, 0x4f, 0xfb, |
2181 | 0x00000009, 0x2607ffff, 0x00000000, 0x27110000, 0x00000000, 0x26900000, | 1249 | 0x63, 0xd1, 0x9b, 0x32, 0xfa, 0x49, 0x5e, 0xb9, 0xf4, 0x7d, 0xd4, 0x4f, |
2182 | 0x0000000c, 0x29000000, 0x00000018, 0x8000017e, 0x00000003, 0xf4683600, | 1250 | 0x62, 0x7e, 0x72, 0x9f, 0x41, 0xfa, 0x5b, 0x34, 0x5e, 0x72, 0xdf, 0x70, |
2183 | 0x00000000, 0x3a100000, 0x00000000, 0x3a910000, 0x00000003, 0xf66c2400, | 1251 | 0x3e, 0x47, 0xac, 0xa3, 0x6c, 0x57, 0x5e, 0xf9, 0x71, 0x39, 0x23, 0x7c, |
2184 | 0x00000010, 0x001f0000, 0x00000010, 0xb1923604, 0x00000008, 0x0f800004, | 1252 | 0x53, 0xc5, 0x8d, 0xd6, 0x8b, 0x64, 0x7d, 0x2a, 0xbf, 0xc5, 0x4e, 0x37, |
2185 | 0x00000000, 0x00000000, 0x00000010, 0x009f0000, 0x00000000, 0x3e170000, | 1253 | 0x1f, 0x64, 0x1f, 0xf3, 0x35, 0x0b, 0x5f, 0x34, 0x34, 0x39, 0xfe, 0x18, |
2186 | 0x00000000, 0x3e940000, 0x00000000, 0x3f150000, 0x00000000, 0x3f960000, | 1254 | 0xe5, 0xab, 0x38, 0xaf, 0xf7, 0x6f, 0xcb, 0x11, 0x9f, 0x76, 0x9e, 0xf3, |
2187 | 0x00000010, 0x001f0000, 0x00000000, 0x0f060000, 0x00000010, 0x20530000, | 1255 | 0xf0, 0xfb, 0x80, 0x7d, 0xe9, 0x2b, 0x80, 0x23, 0xf1, 0xcd, 0x50, 0x4d, |
2188 | 0x00000000, 0x22c53600, 0x00000018, 0x8000ffac, 0x00000010, 0x001f0000, | 1256 | 0xce, 0x74, 0x78, 0xe1, 0xdd, 0x30, 0x9a, 0x33, 0x78, 0xdb, 0xec, 0xe7, |
2189 | 0x00000000, 0x031e0000, 0x00000000, 0x83850800, 0x00000009, 0x076000ff, | 1257 | 0x48, 0x27, 0xe9, 0x5f, 0x1d, 0xc0, 0x31, 0x2c, 0x38, 0x9e, 0x50, 0x7f, |
2190 | 0x0000000f, 0x0f0e0007, 0x00000000, 0x0c000000, 0x00000000, 0x0a7d0000, | 1258 | 0x9f, 0xf7, 0xc6, 0x0f, 0x6f, 0x5e, 0x8c, 0xff, 0x19, 0xcc, 0xe3, 0x87, |
2191 | 0x00000000, 0x0afe0000, 0x00000000, 0x0b7f0000, 0x00000000, 0x0d7a0000, | 1259 | 0xe5, 0x5d, 0xdd, 0x18, 0x03, 0xfd, 0x2e, 0x62, 0xec, 0x46, 0x5e, 0xdf, |
2192 | 0x00000000, 0x0bfc0000, 0x00000000, 0x0c970e00, 0x00000008, 0x0f800003, | 1260 | 0xc3, 0xe7, 0xb5, 0x4a, 0xf5, 0xf2, 0xbb, 0xc3, 0x52, 0x0d, 0x6b, 0xc9, |
2193 | 0x0000000f, 0x47670010, 0x00000008, 0x070e0001, 0x0000000b, 0xc38000ff, | 1261 | 0xee, 0x94, 0xae, 0x7f, 0xc8, 0x77, 0x27, 0xee, 0xbd, 0xb7, 0x75, 0x0d, |
2194 | 0x00000002, 0x43870000, 0x00000001, 0x33e70e00, 0x0000000f, 0x038e0010, | 1262 | 0x4c, 0xc4, 0x69, 0x58, 0x31, 0x33, 0xc1, 0x82, 0xde, 0xf8, 0xe2, 0x4b, |
2195 | 0x00000002, 0x33e70e00, 0x00000000, 0x39840000, 0x00000003, 0xb9720800, | 1263 | 0x5e, 0x7e, 0xaf, 0xbf, 0x18, 0xf3, 0x65, 0xf7, 0x91, 0x9c, 0x88, 0xda, |
2196 | 0x00000000, 0x28f30000, 0x0000000f, 0x65680010, 0x00000010, 0x009f0000, | 1264 | 0x8b, 0xba, 0xfb, 0xee, 0x1e, 0xd0, 0xb7, 0xd5, 0xbd, 0xd8, 0x3f, 0x73, |
2197 | 0x00000000, 0x02043600, 0x00000010, 0x91840a02, 0x00000002, 0x21421800, | 1265 | 0x3b, 0xd7, 0x51, 0xab, 0x4c, 0xf2, 0x2b, 0x0d, 0x5c, 0xd3, 0xa8, 0xc3, |
2198 | 0x00000008, 0x22000007, 0x00000000, 0x231b0000, 0x00000000, 0x23ff0000, | 1266 | 0x13, 0x13, 0xaa, 0x04, 0xf7, 0x9a, 0x79, 0x07, 0xab, 0x1a, 0xd1, 0x8b, |
2199 | 0x00000000, 0x241b0000, 0x00000003, 0x8384a000, 0x0000000f, 0x65870010, | 1267 | 0xfa, 0x68, 0x17, 0xde, 0xc1, 0x44, 0x8b, 0x83, 0x7d, 0x9f, 0x55, 0xe8, |
2200 | 0x00000009, 0x2607ffff, 0x00000000, 0x27110000, 0x00000000, 0x26900000, | 1268 | 0xaf, 0x08, 0x8f, 0xf7, 0x5d, 0x1c, 0xd3, 0xe1, 0x60, 0x5d, 0xf2, 0xfa, |
2201 | 0x0000000c, 0x29000000, 0x00000018, 0x80000145, 0x00000003, 0xf4683600, | 1269 | 0x15, 0x93, 0x73, 0xfd, 0xab, 0xfb, 0x6e, 0xee, 0xe1, 0x7e, 0x2a, 0x19, |
2202 | 0x00000000, 0x3a100000, 0x00000000, 0x3a910000, 0x00000003, 0xf66c2400, | 1270 | 0xac, 0xcb, 0x01, 0xf9, 0xfb, 0x24, 0x7e, 0x49, 0x89, 0x5f, 0x54, 0xc7, |
2203 | 0x00000010, 0x001f0000, 0x00000010, 0xb1923604, 0x00000008, 0x0f800004, | 1271 | 0x0f, 0xef, 0xed, 0x4f, 0x7d, 0xef, 0x7a, 0xaa, 0x1b, 0xde, 0xbc, 0xfb, |
2204 | 0x00000000, 0x00000000, 0x00000010, 0x009f0000, 0x00000000, 0x3e170000, | 1272 | 0xfc, 0x4f, 0x63, 0xd7, 0xf6, 0x98, 0xb7, 0x0e, 0x57, 0xbb, 0xe7, 0xae, |
2205 | 0x00000000, 0x3e940000, 0x00000000, 0x3f150000, 0x00000000, 0x3f960000, | 1273 | 0x43, 0xde, 0x8b, 0x5d, 0x87, 0x30, 0xce, 0x73, 0xbf, 0xbc, 0x38, 0xd3, |
2206 | 0x00000010, 0x001f0000, 0x00000000, 0x0f060000, 0x00000010, 0x20530000, | 1274 | 0x21, 0x79, 0x74, 0x57, 0x44, 0xf2, 0x41, 0xec, 0xfb, 0x22, 0x62, 0xee, |
2207 | 0x00000000, 0x22c53600, 0x00000018, 0x8000ff73, 0x00000010, 0x0ce70005, | 1275 | 0x1b, 0x8c, 0xbf, 0x92, 0xfb, 0xee, 0x97, 0x2a, 0xf4, 0xd9, 0x17, 0x87, |
2208 | 0x00000008, 0x2c80000c, 0x00000008, 0x2d000070, 0x00000008, 0x2d800010, | 1276 | 0xcc, 0xfb, 0xc4, 0xbc, 0x57, 0xb0, 0xbe, 0x3e, 0xae, 0x04, 0x67, 0xbe, |
2209 | 0x00000000, 0x00000000, 0x00000010, 0x205f0000, 0x00000018, 0x8000011d, | 1277 | 0xff, 0xb5, 0x3f, 0x9c, 0xaf, 0x99, 0x8e, 0x61, 0x1f, 0x5e, 0x2a, 0x16, |
2210 | 0x00000000, 0x2c1e0000, 0x00000008, 0x2c8000b8, 0x00000008, 0x2d000010, | 1278 | 0x78, 0xbf, 0xc4, 0xe5, 0xfb, 0x45, 0xbf, 0xe0, 0xe1, 0xf0, 0xf9, 0x29, |
2211 | 0x00000008, 0x2d800048, 0x00000000, 0x00000000, 0x00000010, 0x91de0000, | 1279 | 0xd5, 0xf6, 0x13, 0x4d, 0x65, 0x3a, 0x73, 0xb0, 0xa7, 0xd5, 0xed, 0x23, |
2212 | 0x00000018, 0x8000fe5d, 0x0000000c, 0x29800001, 0x00000000, 0x2a000000, | 1280 | 0xc1, 0x27, 0xd4, 0x79, 0x4b, 0xde, 0xc1, 0xf2, 0x5e, 0xd6, 0xef, 0x61, |
2213 | 0x00000010, 0x001f0000, 0x00000000, 0x0f008000, 0x00000008, 0x0f800007, | 1281 | 0xf4, 0x73, 0xad, 0x79, 0x8c, 0xc7, 0xd0, 0xb7, 0x39, 0xbf, 0xca, 0xbd, |
2214 | 0x00000018, 0x80000006, 0x0000000c, 0x29800001, 0x00000000, 0x2a000000, | 1282 | 0xb5, 0x75, 0x9b, 0xe9, 0x4b, 0xa7, 0xde, 0x67, 0xee, 0xb9, 0xb6, 0x6a, |
2215 | 0x00000010, 0x001f0000, 0x0000000f, 0x0f470007, 0x00000008, 0x0f800008, | 1283 | 0xd0, 0x16, 0xee, 0x5b, 0x1f, 0xb2, 0xf3, 0x92, 0x1f, 0x85, 0x77, 0x89, |
2216 | 0x00000018, 0x80000119, 0x00000010, 0x20530000, 0x00000018, 0x8000fe4f, | 1284 | 0xff, 0x3d, 0x62, 0xfa, 0x85, 0x73, 0xc5, 0xb8, 0x67, 0xf3, 0xbd, 0x34, |
2217 | 0x0000000c, 0x29800001, 0x00000010, 0x91de0000, 0x00000000, 0x2fd50000, | 1285 | 0xa1, 0xdf, 0x23, 0x09, 0x6f, 0x9e, 0x25, 0x32, 0x65, 0x82, 0xfb, 0xec, |
2218 | 0x00000000, 0x2a000000, 0x00000009, 0x0261ffff, 0x0000000d, 0x70e10001, | 1286 | 0x9b, 0x40, 0xf7, 0xdc, 0x84, 0xbe, 0xbc, 0xb5, 0x4b, 0x70, 0xb8, 0x91, |
2219 | 0x00000018, 0x80000101, 0x00000000, 0x2c400000, 0x00000008, 0x2c8000c4, | 1287 | 0x71, 0x5b, 0x3e, 0x9a, 0x0b, 0x7e, 0x67, 0x21, 0x5c, 0x7f, 0x73, 0xfb, |
2220 | 0x00000008, 0x2d00001c, 0x00000008, 0x2d800001, 0x00000005, 0x70e10800, | 1288 | 0xd1, 0x73, 0x6c, 0xd7, 0xbc, 0x81, 0x3c, 0xf3, 0xcd, 0x55, 0xb3, 0xf8, |
2221 | 0x00000010, 0x91de0000, 0x00000018, 0x8000fe41, 0x0000000c, 0x29800001, | 1289 | 0xfc, 0xa6, 0x9d, 0x51, 0xd8, 0x99, 0xe9, 0x17, 0xbf, 0xda, 0x6f, 0x01, |
2222 | 0x00000010, 0x91de0000, 0x00000000, 0x2fd50000, 0x00000010, 0x001f0000, | 1290 | 0xed, 0x92, 0x3a, 0x73, 0xd2, 0x7d, 0x97, 0xc3, 0x4e, 0x53, 0x4f, 0x26, |
2223 | 0x00000000, 0x02700000, 0x00000000, 0x0d620000, 0x00000000, 0xbb630800, | 1291 | 0xbf, 0x13, 0x30, 0x9e, 0x5b, 0xc7, 0x63, 0xd5, 0xbc, 0x95, 0xe4, 0x97, |
2224 | 0x00000000, 0x2a000000, 0x00000000, 0x0f400000, 0x00000000, 0x2c400000, | 1292 | 0x4c, 0x7a, 0xcf, 0x16, 0xe2, 0x6e, 0xf2, 0xc1, 0xe4, 0x8f, 0xf7, 0x1d, |
2225 | 0x0000000c, 0x73e7001b, 0x00000010, 0x0ce7000e, 0x00000000, 0x286d0000, | 1293 | 0x7b, 0x9b, 0xa7, 0x5e, 0xfa, 0xe3, 0xef, 0x70, 0xbe, 0x84, 0x65, 0x3d, |
2226 | 0x0000000f, 0x65ed0010, 0x00000009, 0x266dffff, 0x00000018, 0x80000069, | 1294 | 0x96, 0xe9, 0xef, 0xbb, 0x3c, 0x3e, 0x6f, 0x01, 0x9f, 0x8c, 0xd8, 0x6d, |
2227 | 0x00000008, 0x02000004, 0x00000010, 0x91c40803, 0x00000018, 0x800000f6, | 1295 | 0xb7, 0xf0, 0x3b, 0x74, 0x96, 0xda, 0x25, 0xf1, 0x39, 0x57, 0x2d, 0x75, |
2228 | 0x00000010, 0x20530000, 0x00000018, 0x800000e5, 0x00000008, 0x2c8000b8, | 1296 | 0x50, 0xec, 0xfb, 0x49, 0xfa, 0x1f, 0xc4, 0x31, 0x6e, 0x6f, 0xc9, 0x49, |
2229 | 0x00000008, 0x2d000010, 0x00000008, 0x2d800048, 0x00000018, 0x80000005, | 1297 | 0xdc, 0x24, 0x8f, 0x9e, 0x16, 0xbf, 0x7f, 0x84, 0xdf, 0xb6, 0xf1, 0xbb, |
2230 | 0x00000008, 0x2c8000c4, 0x00000008, 0x2d00001c, 0x00000008, 0x2d800001, | 1298 | 0xc5, 0xf5, 0xdb, 0xd4, 0x59, 0xaf, 0x9c, 0x99, 0x3a, 0x1f, 0xb8, 0x5e, |
2231 | 0x00000000, 0x00000000, 0x00000010, 0x205f0000, 0x00000008, 0x2c800048, | 1299 | 0xdb, 0x27, 0xf9, 0xdd, 0x53, 0x24, 0xe7, 0xa1, 0x42, 0xbe, 0x3b, 0x38, |
2232 | 0x00000008, 0x2d000068, 0x00000008, 0x2d800104, 0x00000000, 0x00000000, | 1300 | 0xe2, 0x4f, 0x89, 0x6a, 0x5a, 0xee, 0xdd, 0x57, 0x2c, 0xfb, 0x92, 0x7a, |
2233 | 0x00000010, 0x91de0000, 0x00000000, 0x27f60000, 0x00000010, 0xb87a9e04, | 1301 | 0x1f, 0xe6, 0x71, 0xfe, 0xec, 0x29, 0xf0, 0x34, 0xdf, 0x11, 0x8c, 0xdc, |
2234 | 0x00000008, 0x2200000d, 0x00000018, 0x800000e2, 0x00000010, 0x20530000, | 1302 | 0xe0, 0x39, 0xf2, 0xe2, 0xc7, 0x37, 0x13, 0xff, 0x50, 0x07, 0x74, 0x9c, |
2235 | 0x00000018, 0x8000fe18, 0x0000000c, 0x29800001, 0x00000010, 0x91de0000, | 1303 | 0x6a, 0xcd, 0xf7, 0x07, 0xcc, 0xe3, 0xfc, 0x26, 0xf7, 0xb7, 0xa1, 0xaf, |
2236 | 0x00000000, 0x2fd50000, 0x00000010, 0x001f0000, 0x00000000, 0x02700000, | 1304 | 0xdc, 0xdf, 0x76, 0x48, 0xfa, 0x08, 0xc1, 0xe5, 0x81, 0x21, 0xb2, 0x43, |
2237 | 0x00000000, 0x0d620000, 0x00000000, 0xbb630800, 0x00000000, 0x2a000000, | 1305 | 0xc7, 0xae, 0xd2, 0x7f, 0xfe, 0x61, 0x47, 0x54, 0xec, 0x28, 0xf7, 0xd8, |
2238 | 0x00000010, 0x0e670011, 0x00000000, 0x286d0000, 0x0000000f, 0x65ed0010, | 1306 | 0x11, 0xd0, 0x7b, 0x1d, 0xcd, 0xaf, 0x50, 0x5f, 0x73, 0x1e, 0x2e, 0x57, |
2239 | 0x00000009, 0x266dffff, 0x00000004, 0xb8f1a000, 0x00000000, 0x0f400000, | 1307 | 0xeb, 0x29, 0x47, 0xf4, 0xbd, 0xb0, 0xae, 0x88, 0xc6, 0xcb, 0xd4, 0xab, |
2240 | 0x0000000c, 0x73e7001c, 0x00000018, 0x80000040, 0x00000008, 0x02000004, | 1308 | 0xf0, 0xb7, 0x37, 0x59, 0x84, 0x3a, 0x96, 0xdc, 0x49, 0xf3, 0x35, 0xea, |
2241 | 0x00000010, 0x91c40802, 0x00000018, 0x800000cd, 0x00000000, 0x2c1e0000, | 1309 | 0xd5, 0x3e, 0x0e, 0xc4, 0x2b, 0xea, 0x18, 0xea, 0x73, 0xe3, 0x41, 0xb6, |
2242 | 0x00000008, 0x2c8000b8, 0x00000008, 0x2d000010, 0x00000008, 0x2d800048, | 1310 | 0x47, 0x1d, 0x1f, 0x34, 0xf5, 0x7a, 0xca, 0xef, 0x98, 0xbd, 0xeb, 0xa4, |
2243 | 0x00000010, 0x20530000, 0x00000010, 0x91de0000, 0x00000018, 0x8000fdfe, | 1311 | 0x5e, 0x9c, 0xc0, 0x77, 0x51, 0xfd, 0x5e, 0x23, 0xfe, 0xd9, 0xe6, 0x3d, |
2244 | 0x0000000c, 0x29800001, 0x00000000, 0x03550000, 0x00000000, 0x06460000, | 1312 | 0xb8, 0xfb, 0x98, 0xa1, 0x8b, 0x7c, 0xe3, 0xfd, 0x27, 0x96, 0x0a, 0xad, |
2245 | 0x00000000, 0x03d60000, 0x00000000, 0x2a000000, 0x0000000f, 0x0f480007, | 1313 | 0xf2, 0x8d, 0x07, 0xd6, 0x55, 0x09, 0xad, 0x36, 0xe3, 0xe9, 0xbe, 0x2b, |
2246 | 0x00000010, 0xb18c0027, 0x0000000f, 0x47420008, 0x00000009, 0x070e000f, | 1314 | 0x5e, 0x29, 0xf9, 0x62, 0xf7, 0x7b, 0xe2, 0xcf, 0x47, 0xe2, 0xcf, 0x59, |
2247 | 0x00000008, 0x070e0008, 0x00000010, 0x001f0000, 0x00000008, 0x09000001, | 1315 | 0xe0, 0x9f, 0xdc, 0x28, 0x78, 0x2c, 0x0a, 0xea, 0x17, 0xbb, 0xdc, 0x73, |
2248 | 0x00000007, 0x09121c00, 0x00000003, 0xcbca9200, 0x00000000, 0x0b97a200, | 1316 | 0x63, 0xd6, 0x11, 0x8f, 0x47, 0xd5, 0x5f, 0x3f, 0x97, 0x8f, 0x31, 0xd8, |
2249 | 0x00000007, 0x4b171c00, 0x0000000f, 0x0a960003, 0x00000000, 0x0a959c00, | 1317 | 0x17, 0x00, 0x00, 0x00 }; |
2250 | 0x00000000, 0x4a009a00, 0x00000008, 0x82120001, 0x00000001, 0x0c170800, | ||
2251 | 0x00000000, 0x02180000, 0x00000000, 0x0c971800, 0x00000008, 0x0d00ffff, | ||
2252 | 0x00000008, 0x0f800006, 0x0000000c, 0x29000000, 0x00000008, 0x22000001, | ||
2253 | 0x00000000, 0x22c50c00, 0x00000010, 0x009f0000, 0x00000010, 0xb197320b, | ||
2254 | 0x00000000, 0x231b0000, 0x00000000, 0x27110800, 0x00000000, 0x66900000, | ||
2255 | 0x00000018, 0x800000a4, 0x00000000, 0x02180000, 0x00000010, 0x20530000, | ||
2256 | 0x00000000, 0x22c53600, 0x00000010, 0x001f0000, 0x00000008, 0x0f800006, | ||
2257 | 0x00000018, 0x8000fff5, 0x00000010, 0x91870002, 0x00000008, 0x2200000a, | ||
2258 | 0x00000000, 0x231b0000, 0x00000000, 0x27110800, 0x00000000, 0x66900000, | ||
2259 | 0x00000018, 0x80000098, 0x00000008, 0x0200000a, 0x00000010, 0x91c40804, | ||
2260 | 0x00000010, 0x02c20003, 0x00000010, 0x001f0000, 0x00000008, 0x0f800008, | ||
2261 | 0x00000010, 0x20530000, 0x00000018, 0x8000fdc9, 0x00000000, 0x06820000, | ||
2262 | 0x00000010, 0x001f0000, 0x00000010, 0x0ce70028, 0x00000000, 0x03720000, | ||
2263 | 0x00000000, 0xa8760c00, 0x00000000, 0x0cf60000, 0x00000010, 0xb8723224, | ||
2264 | 0x00000000, 0x03440000, 0x00000008, 0x22000010, 0x00000000, 0x03ca0000, | ||
2265 | 0x0000000f, 0x65680010, 0x00000000, 0x0bcf0000, 0x00000000, 0x27f20000, | ||
2266 | 0x00000010, 0xb7ef3203, 0x0000000c, 0x21420004, 0x0000000c, 0x73e70019, | ||
2267 | 0x00000000, 0x07520000, 0x00000000, 0x29000000, 0x00000018, 0x8000007e, | ||
2268 | 0x00000004, 0xb9723200, 0x00000010, 0x20530000, 0x00000000, 0x22060000, | ||
2269 | 0x0000000c, 0x61420004, 0x00000000, 0x25070000, 0x00000000, 0x27970000, | ||
2270 | 0x00000000, 0x290e0000, 0x00000010, 0x0ce70010, 0x00000010, 0xb873320f, | ||
2271 | 0x0000000f, 0x436c0010, 0x00000000, 0x03f30c00, 0x00000000, 0x03f30000, | ||
2272 | 0x00000000, 0x83990e00, 0x00000001, 0x83860e00, 0x00000000, 0x83060e00, | ||
2273 | 0x00000003, 0xf66c0c00, 0x00000000, 0x39f30e00, 0x00000000, 0x3af50e00, | ||
2274 | 0x00000000, 0x7a740000, 0x0000000f, 0x43680010, 0x00000001, 0x83860e00, | ||
2275 | 0x00000000, 0x83060e00, 0x00000003, 0xf4680c00, 0x00000000, 0x286d0000, | ||
2276 | 0x00000000, 0x03690000, 0x00000010, 0xb1f60c54, 0x00000000, 0x0a6a0000, | ||
2277 | 0x00000000, 0x0aeb0000, 0x00000009, 0x0b6cffff, 0x00000000, 0x0c000000, | ||
2278 | 0x00000000, 0x0be90000, 0x00000003, 0x8cf6a000, 0x0000000c, 0x09800002, | ||
2279 | 0x00000010, 0x009f0000, 0x00000010, 0xb8173209, 0x00000000, 0x35140000, | ||
2280 | 0x00000000, 0x35950000, 0x00000005, 0x766c2c00, 0x00000000, 0x34970000, | ||
2281 | 0x00000004, 0xb8f12e00, 0x00000010, 0x001f0000, 0x00000008, 0x0f800004, | ||
2282 | 0x00000018, 0x8000fff7, 0x00000000, 0x03e90000, 0x00000010, 0xb8f6a01a, | ||
2283 | 0x00000010, 0x20130019, 0x00000010, 0xb1f10e18, 0x00000000, 0x83973200, | ||
2284 | 0x00000000, 0x38700e00, 0x00000000, 0xbb760e00, 0x00000000, 0x37d00000, | ||
2285 | 0x0000000c, 0x73e7001a, 0x00000003, 0xb8f1a000, 0x00000000, 0x32140000, | ||
2286 | 0x00000000, 0x32950000, 0x00000005, 0x73e72c00, 0x00000000, 0x33190000, | ||
2287 | 0x00000005, 0x74680000, 0x00000010, 0x0ce7000d, 0x00000008, 0x22000009, | ||
2288 | 0x00000000, 0x07520000, 0x00000000, 0x29000000, 0x0000000c, 0x73e70019, | ||
2289 | 0x0000000f, 0x65680010, 0x0000000c, 0x21420004, 0x00000018, 0x8000003c, | ||
2290 | 0x00000010, 0x20530000, 0x0000000c, 0x61420004, 0x00000000, 0x290e0000, | ||
2291 | 0x00000018, 0x80000002, 0x00000010, 0x91973206, 0x00000000, 0x35140000, | ||
2292 | 0x00000000, 0x35950000, 0x00000005, 0x766c2c00, 0x00000000, 0x34990000, | ||
2293 | 0x00000004, 0xb8f13200, 0x00000000, 0x83690c00, 0x00000010, 0xb1860013, | ||
2294 | 0x00000000, 0x28e90000, 0x00000008, 0x22000004, 0x00000000, 0x23ec0000, | ||
2295 | 0x00000000, 0x03690000, 0x00000010, 0xb8660c07, 0x00000009, 0x036cffff, | ||
2296 | 0x00000000, 0x326a0000, 0x00000000, 0x32eb0000, 0x00000005, 0x73e70c00, | ||
2297 | 0x00000000, 0x33690000, 0x00000005, 0x74680000, 0x0000000c, 0x73e7001c, | ||
2298 | 0x00000000, 0x03690000, 0x00000010, 0xb1f60c12, 0x00000010, 0xb1d00c11, | ||
2299 | 0x0000000c, 0x21420005, 0x0000000c, 0x33e7001c, 0x00000018, 0x8000000e, | ||
2300 | 0x00000010, 0x2e67000d, 0x00000000, 0x03690000, 0x00000010, 0xb1f60c0b, | ||
2301 | 0x00000010, 0xb1d00c0a, 0x00000000, 0x03440000, 0x00000008, 0x2200000c, | ||
2302 | 0x00000000, 0x07520000, 0x00000000, 0x29000000, 0x00000018, 0x80000015, | ||
2303 | 0x0000000c, 0x33e7001c, 0x00000010, 0x20530000, 0x00000000, 0x22060000, | ||
2304 | 0x00000000, 0x290e0000, 0x00000018, 0x000d0000, 0x00000000, 0x06820000, | ||
2305 | 0x00000010, 0x2de7000d, 0x00000010, 0x0ce7000c, 0x00000000, 0x27f20000, | ||
2306 | 0x00000010, 0xb96d9e0a, 0x00000000, 0xa86d9e00, 0x00000009, 0x0361ffff, | ||
2307 | 0x00000010, 0xb7500c07, 0x00000008, 0x2200000f, 0x0000000f, 0x65680010, | ||
2308 | 0x00000000, 0x29000000, 0x00000018, 0x80000004, 0x0000000c, 0x33e7001b, | ||
2309 | 0x00000010, 0x20530000, 0x00000018, 0x000d0000, 0x00000000, 0x2b820000, | ||
2310 | 0x00000010, 0x20d2002f, 0x00000010, 0x0052002e, 0x00000009, 0x054e0007, | ||
2311 | 0x00000010, 0xb18a002c, 0x00000000, 0x050a8c00, 0x00000008, 0x850a0008, | ||
2312 | 0x00000010, 0x918a0029, 0x00000003, 0xc5008800, 0x00000008, 0xa3460001, | ||
2313 | 0x00000010, 0xb1c60007, 0x00000008, 0x22000001, 0x0000000c, 0x29800000, | ||
2314 | 0x00000010, 0x20530000, 0x00000000, 0x274e8c00, 0x00000000, 0x66cd0000, | ||
2315 | 0x00000000, 0x22c58c00, 0x00000008, 0x22000014, 0x00000003, 0x22c58e00, | ||
2316 | 0x00000003, 0x23c58e00, 0x00000003, 0x22c58e00, 0x00000003, 0x26cd9e00, | ||
2317 | 0x00000003, 0x27cd9e00, 0x00000003, 0x26cd9e00, 0x00000003, 0x274ea000, | ||
2318 | 0x00000003, 0x284ea000, 0x00000003, 0x274ea000, 0x0000000c, 0x69520000, | ||
2319 | 0x0000000c, 0x29800000, 0x00000010, 0x20530000, 0x00000003, 0x22c58e00, | ||
2320 | 0x00000003, 0x23c58e00, 0x00000003, 0x22c58e00, 0x00000003, 0x26cd9e00, | ||
2321 | 0x00000003, 0x27cd9e00, 0x00000003, 0x26cd9e00, 0x00000003, 0x274ea000, | ||
2322 | 0x00000003, 0x284ea000, 0x00000003, 0x274ea000, 0x00000000, 0xa2c58c00, | ||
2323 | 0x00000000, 0xa74e8c00, 0x00000000, 0xe6cd0000, 0x0000000f, 0x620a0010, | ||
2324 | 0x00000008, 0x23460001, 0x0000000c, 0x29800000, 0x00000010, 0x20530000, | ||
2325 | 0x0000000c, 0x29520000, 0x00000018, 0x80000002, 0x0000000c, 0x29800000, | ||
2326 | 0x00000018, 0x00570000 }; | ||
2327 | 1318 | ||
2328 | static const int bnx2_TPAT_b06FwReleaseMajor = 0x1; | 1319 | static const int bnx2_TPAT_b06FwReleaseMajor = 0x1; |
2329 | static const int bnx2_TPAT_b06FwReleaseMinor = 0x0; | 1320 | static const int bnx2_TPAT_b06FwReleaseMinor = 0x0; |
@@ -2339,201 +1330,199 @@ static const u32 bnx2_TPAT_b06FwBssAddr = 0x08001aa0; | |||
2339 | static const int bnx2_TPAT_b06FwBssLen = 0x250; | 1330 | static const int bnx2_TPAT_b06FwBssLen = 0x250; |
2340 | static const u32 bnx2_TPAT_b06FwSbssAddr = 0x08001a60; | 1331 | static const u32 bnx2_TPAT_b06FwSbssAddr = 0x08001a60; |
2341 | static const int bnx2_TPAT_b06FwSbssLen = 0x34; | 1332 | static const int bnx2_TPAT_b06FwSbssLen = 0x34; |
2342 | static u32 bnx2_TPAT_b06FwText[(0x122c/4) + 1] = { | 1333 | static u8 bnx2_TPAT_b06FwText[] = { |
2343 | 0x0a000218, 0x00000000, 0x00000000, 0x0000000d, 0x74706174, 0x20322e35, | 1334 | 0x1f, 0x8b, 0x08, 0x08, 0x47, 0xd2, 0x41, 0x44, 0x00, 0x03, 0x74, 0x65, |
2344 | 0x2e313100, 0x02050b01, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1335 | 0x73, 0x74, 0x31, 0x2e, 0x62, 0x69, 0x6e, 0x00, 0xc5, 0x57, 0x4d, 0x68, |
2345 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1336 | 0x1c, 0xe7, 0x19, 0x7e, 0xe7, 0x77, 0x47, 0x62, 0x25, 0x8d, 0x93, 0x3d, |
2346 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1337 | 0xac, 0x5d, 0xa5, 0x99, 0x91, 0x46, 0x3f, 0x54, 0x26, 0x9e, 0x84, 0xa5, |
2347 | 0x00000000, 0x10000003, 0x00000000, 0x0000000d, 0x0000000d, 0x3c020800, | 1338 | 0x56, 0x61, 0x20, 0xe3, 0x99, 0x95, 0x2c, 0x0c, 0x05, 0x07, 0x42, 0x08, |
2348 | 0x24421a60, 0x3c030800, 0x24631cf0, 0xac400000, 0x0043202b, 0x1480fffd, | 1339 | 0xe4, 0xb2, 0x1d, 0x49, 0x36, 0x85, 0x1e, 0x5a, 0x9a, 0x43, 0xa0, 0x05, |
2349 | 0x24420004, 0x3c1d0800, 0x37bd2ffc, 0x03a0f021, 0x3c100800, 0x26100860, | 1340 | 0x0f, 0x33, 0xeb, 0x34, 0x87, 0xc5, 0xdb, 0xaa, 0xc5, 0xbe, 0x94, 0xd6, |
2350 | 0x3c1c0800, 0x279c1a60, 0x0e000546, 0x00000000, 0x0000000d, 0x8f820010, | 1341 | 0x95, 0xea, 0xe8, 0xb2, 0x68, 0xe2, 0x53, 0x0f, 0xc5, 0xd8, 0xb4, 0x54, |
2351 | 0x8c450008, 0x24030800, 0xaf430178, 0x97430104, 0x3c020008, 0xaf420140, | 1342 | 0xd0, 0x53, 0x7b, 0x0a, 0x85, 0x5c, 0x4c, 0x69, 0x20, 0x85, 0x12, 0x44, |
2352 | 0x8f820024, 0x30420001, 0x10400007, 0x3069ffff, 0x24020002, 0x2523fffe, | 1343 | 0x0f, 0x21, 0xd4, 0xad, 0xa7, 0xcf, 0xfb, 0xcd, 0x8c, 0xbc, 0xbb, 0x95, |
2353 | 0xa7420146, 0xa7430148, 0x0a000242, 0x3c020800, 0xa7400146, 0x3c020800, | 1344 | 0x5b, 0x1f, 0x02, 0x15, 0xac, 0x66, 0xe6, 0xfb, 0xde, 0xf7, 0xfb, 0x79, |
2354 | 0x8c43083c, 0x1460000e, 0x24020f00, 0x8f820024, 0x30430020, 0x0003182b, | 1345 | 0x9f, 0xe7, 0x79, 0xbf, 0xf7, 0x6b, 0xca, 0x34, 0x49, 0xe5, 0xdf, 0x14, |
2355 | 0x00031823, 0x30650009, 0x30420c00, 0x24030400, 0x14430002, 0x34a40001, | 1346 | 0x7e, 0x6f, 0x7f, 0xe3, 0xdb, 0x6f, 0x7f, 0xf5, 0xa5, 0x57, 0x2c, 0xa2, |
2356 | 0x34a40005, 0xa744014a, 0x0a000264, 0x3c020800, 0x8f830014, 0x14620008, | 1347 | 0x57, 0x5e, 0x92, 0x64, 0x5d, 0xa6, 0x2f, 0xe0, 0x4f, 0x21, 0x32, 0xab, |
2357 | 0x00000000, 0x8f820024, 0x30420020, 0x0002102b, 0x00021023, 0x3042000d, | 1348 | 0xf1, 0xf9, 0x47, 0x86, 0xec, 0x75, 0xce, 0x04, 0x0e, 0x19, 0x8a, 0x77, |
2358 | 0x0a000262, 0x34420005, 0x8f820024, 0x30420020, 0x0002102b, 0x00021023, | 1349 | 0x34, 0xbb, 0xe9, 0x10, 0xf9, 0x83, 0x15, 0x2b, 0xa4, 0x7f, 0xe5, 0x71, |
2359 | 0x30420009, 0x34420001, 0xa742014a, 0x3c020800, 0x8c430820, 0x8f840024, | 1350 | 0x43, 0x25, 0x6e, 0x7f, 0xc1, 0xfb, 0xe7, 0xb9, 0x7b, 0xe7, 0xed, 0xa3, |
2360 | 0x3c020048, 0x00621825, 0x30840006, 0x24020002, 0x1082000d, 0x2c820003, | 1351 | 0xdb, 0x0a, 0x19, 0xa6, 0xd7, 0x31, 0xcc, 0x45, 0x32, 0x66, 0xe1, 0xf3, |
2361 | 0x50400005, 0x24020004, 0x10800012, 0x3c020001, 0x0a000284, 0x00000000, | 1352 | 0xd3, 0xa5, 0x75, 0x8d, 0xa6, 0xab, 0xb1, 0x4c, 0x4a, 0xfa, 0x06, 0xad, |
2362 | 0x10820007, 0x24020006, 0x1482000f, 0x3c020111, 0x0a00027c, 0x00621025, | 1353 | 0xf5, 0x30, 0x8e, 0xf3, 0x8e, 0x14, 0x66, 0xaa, 0x14, 0xde, 0x32, 0x48, |
2363 | 0x0a00027b, 0x3c020101, 0x3c020011, 0x00621025, 0x24030001, 0xaf421000, | 1354 | 0xf6, 0x7c, 0x29, 0xc8, 0x1c, 0xf4, 0x49, 0x14, 0xb8, 0x35, 0xf2, 0xcd, |
2364 | 0xaf830020, 0x0a000284, 0x00000000, 0x00621025, 0xaf421000, 0xaf800020, | 1355 | 0x3c, 0xff, 0xa6, 0x2b, 0x93, 0xec, 0x3c, 0xce, 0xe7, 0x17, 0xd6, 0xa5, |
2365 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8f830020, 0x1060003f, | 1356 | 0x60, 0x7f, 0x43, 0x0a, 0xf7, 0x03, 0xde, 0x37, 0xd6, 0xb1, 0x2e, 0xf9, |
2366 | 0x3c048000, 0x8f421000, 0x00441024, 0x1040fffd, 0x00000000, 0x10600039, | 1357 | 0xfb, 0xfc, 0xf4, 0x8c, 0xb0, 0x37, 0x4d, 0x9d, 0x06, 0xcd, 0xc8, 0x0e, |
2367 | 0x00000000, 0x8f421000, 0x3c030020, 0x00431024, 0x10400034, 0x00000000, | 1358 | 0xfb, 0x5a, 0x14, 0xba, 0x2b, 0x4d, 0x85, 0xe6, 0xf1, 0x9b, 0xa0, 0x6d, |
2368 | 0x97421014, 0x14400031, 0x00000000, 0x97421008, 0x8f840010, 0x24420006, | 1359 | 0x97, 0xea, 0x81, 0x4b, 0xaa, 0xe2, 0xc8, 0x14, 0x36, 0x24, 0xfa, 0x65, |
2369 | 0x00024082, 0x00081880, 0x00643821, 0x8ce50000, 0x30430003, 0x30420001, | 1360 | 0x4b, 0xc3, 0xef, 0x92, 0xd4, 0xde, 0xdf, 0x2a, 0xc7, 0x69, 0x50, 0x8a, |
2370 | 0x10400004, 0x00000000, 0x0000000d, 0x0a0002c3, 0x00081080, 0x5460000f, | 1361 | 0xb5, 0x44, 0x0d, 0x5e, 0x5b, 0xe1, 0x1f, 0xb8, 0x2b, 0xa6, 0x4c, 0xf3, |
2371 | 0x30a5ffff, 0x3c06ffff, 0x00a62824, 0x0005182b, 0x00a61026, 0x0002102b, | 1362 | 0xf8, 0x4d, 0xe1, 0x3d, 0x82, 0x9d, 0x46, 0x41, 0x6b, 0xbc, 0x6f, 0x02, |
2372 | 0x00621824, 0x10600004, 0x00000000, 0x0000000d, 0x00000000, 0x240001fb, | 1363 | 0xef, 0x58, 0x27, 0xc6, 0x0a, 0xc4, 0x3a, 0x2c, 0xac, 0xc3, 0xa1, 0x6e, |
2373 | 0x8ce20000, 0x0a0002c2, 0x00462825, 0x0005182b, 0x38a2ffff, 0x0002102b, | 1364 | 0x7f, 0x03, 0xfb, 0x58, 0x68, 0x46, 0xa4, 0x53, 0x57, 0xac, 0x7d, 0x8a, |
2374 | 0x00621824, 0x10600004, 0x00000000, 0x0000000d, 0x00000000, 0x24000205, | 1365 | 0x12, 0x53, 0xa1, 0xe4, 0xac, 0x46, 0xfe, 0x65, 0x15, 0xdf, 0xcf, 0x51, |
2375 | 0x8ce20000, 0x3445ffff, 0x00081080, 0x00441021, 0x3c030800, 0xac450000, | 1366 | 0x6c, 0x4a, 0xb0, 0xe9, 0x96, 0xf8, 0xd5, 0xd0, 0xaf, 0xa3, 0x7d, 0x86, |
2376 | 0x8c620830, 0x24420001, 0xac620830, 0x8f840018, 0x01202821, 0x24820008, | 1367 | 0x92, 0xc6, 0x29, 0x49, 0xf6, 0xbe, 0x8f, 0xf6, 0x05, 0x33, 0xa2, 0xef, |
2377 | 0x30421fff, 0x24434000, 0x0343d821, 0x30a30007, 0xaf84000c, 0xaf820018, | 1368 | 0xe1, 0x29, 0xe1, 0xfb, 0x14, 0x8f, 0x87, 0x6f, 0x89, 0x14, 0x87, 0xcc, |
2378 | 0xaf420084, 0x10600002, 0x24a20007, 0x3045fff8, 0x8f820030, 0x8f840000, | 1369 | 0x20, 0xb3, 0x28, 0xcd, 0x2a, 0x5f, 0x6e, 0x2f, 0xda, 0xe2, 0x6c, 0x1c, |
2379 | 0x00451821, 0xaf82001c, 0x0064102b, 0xaf830030, 0x14400002, 0x00641023, | 1370 | 0x3b, 0xd8, 0xf5, 0x5f, 0xa5, 0x8e, 0x49, 0xb1, 0xea, 0xc1, 0xa6, 0xef, |
2380 | 0xaf820030, 0x8f840030, 0x34028000, 0x00821021, 0x03421821, 0x3c021000, | 1371 | 0x98, 0x6d, 0xe0, 0xe4, 0x0b, 0x3c, 0xbf, 0xc6, 0xed, 0xfc, 0x87, 0x76, |
2381 | 0xaf830010, 0xaf440080, 0x03e00008, 0xaf420178, 0x8f830024, 0x27bdffe0, | 1372 | 0x8b, 0x14, 0xcf, 0x31, 0x43, 0x6a, 0x51, 0xd1, 0xd7, 0x30, 0x83, 0x5b, |
2382 | 0xafbf0018, 0xafb10014, 0x30620200, 0x14400004, 0xafb00010, 0x0000000d, | 1373 | 0x2f, 0x93, 0x2f, 0xe2, 0x61, 0xe0, 0xdd, 0xc4, 0x9e, 0x74, 0x60, 0x9b, |
2383 | 0x00000000, 0x24000242, 0x00031a82, 0x30630003, 0x000310c0, 0x00431021, | 1374 | 0xf8, 0x32, 0xc5, 0x4d, 0x83, 0xec, 0xd5, 0x2d, 0xf4, 0x7c, 0xdc, 0x53, |
2384 | 0x00021080, 0x00431021, 0x00021080, 0x3c030800, 0x24631aa0, 0x00438821, | 1375 | 0x10, 0x67, 0xc6, 0x49, 0x2d, 0xfd, 0x18, 0xd7, 0xdf, 0x62, 0x5d, 0xb1, |
2385 | 0x8e240000, 0x10800004, 0x00000000, 0x0000000d, 0x00000000, 0x2400024d, | 1376 | 0x69, 0xd0, 0x0c, 0x75, 0x5e, 0xcf, 0xf3, 0x3b, 0x6e, 0x9e, 0xeb, 0x9e, |
2386 | 0x8f850010, 0x24020001, 0xae220000, 0x8ca70008, 0xa2200007, 0x8f620004, | 1377 | 0xb3, 0xfc, 0x3e, 0xad, 0x34, 0x35, 0x5a, 0x34, 0xf1, 0x44, 0xdc, 0x1c, |
2387 | 0x26300014, 0x02002021, 0x00021402, 0xa2220004, 0x304600ff, 0x24c60005, | 1378 | 0xc4, 0x46, 0x2d, 0xe7, 0x9f, 0x2a, 0xd7, 0xfa, 0x48, 0x42, 0xe8, 0xe9, |
2388 | 0x0e000673, 0x00063082, 0x8f620004, 0xa6220008, 0x8f430108, 0x3c021000, | 1379 | 0xcf, 0xbd, 0xdf, 0xf0, 0xde, 0x97, 0xd7, 0x85, 0x7d, 0x9e, 0xef, 0xae, |
2389 | 0x00621824, 0x10600008, 0x00000000, 0x97420104, 0x92230007, 0x2442ffec, | 1380 | 0x3e, 0xcd, 0x5e, 0x93, 0x0b, 0xfb, 0x3c, 0x5f, 0x6b, 0xf1, 0x7c, 0x36, |
2390 | 0x3045ffff, 0x34630002, 0x0a000321, 0xa2230007, 0x97420104, 0x2442fff0, | 1381 | 0xf6, 0xc6, 0x9c, 0x24, 0x5a, 0x1b, 0xb8, 0x46, 0xd4, 0xc3, 0xba, 0x1c, |
2391 | 0x3045ffff, 0x8f620004, 0x3042ffff, 0x2c420013, 0x54400005, 0x92230007, | 1382 | 0x3c, 0x07, 0x4d, 0xac, 0xdd, 0x5e, 0xb6, 0x24, 0x83, 0x12, 0x27, 0x7f, |
2392 | 0x92220007, 0x34420001, 0xa2220007, 0x92230007, 0x24020001, 0x10620009, | 1383 | 0x11, 0x3c, 0xf0, 0x43, 0xc7, 0xfe, 0x53, 0xa8, 0xd4, 0x68, 0xcf, 0xad, |
2393 | 0x28620002, 0x14400014, 0x24020002, 0x10620012, 0x24020003, 0x1062000a, | 1384 | 0x53, 0x37, 0x6b, 0x52, 0x92, 0x75, 0x29, 0xc8, 0x64, 0x8c, 0x5f, 0xa3, |
2394 | 0x00000000, 0x0a000342, 0x00000000, 0x8f820010, 0x8c43000c, 0x3c04ffff, | 1385 | 0x5d, 0xe7, 0xf3, 0x7c, 0xcd, 0x75, 0x81, 0x33, 0xb1, 0x5f, 0x73, 0x8d, |
2395 | 0x00641824, 0x00651825, 0x0a000342, 0xac43000c, 0x8f820010, 0x8c430010, | 1386 | 0x66, 0xd1, 0xbf, 0x62, 0x6e, 0x91, 0x8b, 0x98, 0xcb, 0x88, 0xc9, 0xbc, |
2396 | 0x3c04ffff, 0x00641824, 0x00651825, 0xac430010, 0x8f620004, 0x3042ffff, | 1387 | 0x78, 0x4f, 0x32, 0x17, 0xfd, 0x14, 0xcb, 0x2d, 0xdb, 0x4c, 0xc8, 0x6e, |
2397 | 0x24420002, 0x00021083, 0xa2220005, 0x304500ff, 0x8f820010, 0x3c04ffff, | 1388 | 0x06, 0x0a, 0x99, 0xb2, 0x67, 0xc2, 0x26, 0xa6, 0x76, 0x66, 0xd0, 0x43, |
2398 | 0x00052880, 0x00a22821, 0x8ca70000, 0x96220008, 0x97430104, 0x00e42024, | 1389 | 0xe5, 0x1d, 0xc1, 0xe3, 0xb4, 0xff, 0x30, 0xbf, 0xb7, 0xd4, 0xa4, 0xfb, |
2399 | 0x24420002, 0x00621823, 0x00833825, 0xaca70000, 0x92240005, 0x00041080, | 1390 | 0x59, 0x83, 0xee, 0x66, 0x24, 0x47, 0x1c, 0xab, 0x86, 0x49, 0x1f, 0x64, |
2400 | 0x02021021, 0x90430000, 0x3c05fff6, 0x34a5ffff, 0x3063000f, 0x00832021, | 1391 | 0xd5, 0x3e, 0xc0, 0x65, 0x27, 0x39, 0xa3, 0x40, 0x67, 0x9b, 0xee, 0x03, |
2401 | 0xa2240006, 0x308200ff, 0x24420003, 0x00021080, 0x02021021, 0x8c460000, | 1392 | 0xb0, 0xc4, 0x06, 0x0e, 0x31, 0xf6, 0x5c, 0x3d, 0x79, 0x4f, 0xb7, 0xcf, |
2402 | 0x308300ff, 0x8f820010, 0x3c04ff3f, 0x00031880, 0x00c53824, 0x00621821, | 1393 | 0x6c, 0x3a, 0xf6, 0x7b, 0x21, 0xb3, 0xf3, 0x86, 0x8a, 0xd6, 0xe1, 0x38, |
2403 | 0xae26000c, 0xac67000c, 0x8e22000c, 0x92230006, 0x3484ffff, 0x00441024, | 1394 | 0x7c, 0x1d, 0xfe, 0x26, 0x5d, 0x87, 0x5e, 0x64, 0xc4, 0x63, 0xee, 0xc0, |
2404 | 0x24630003, 0x00031880, 0x02031821, 0x00e42024, 0xae22000c, 0xac640000, | 1395 | 0xa0, 0xfd, 0x5e, 0x8d, 0xac, 0x5d, 0x95, 0xa2, 0x7e, 0x83, 0xdc, 0x45, |
2405 | 0x92220006, 0x24420004, 0x00021080, 0x02021021, 0x94470002, 0xac470000, | 1396 | 0xdb, 0x22, 0x59, 0x6e, 0xc8, 0x88, 0xdf, 0xdc, 0x6e, 0x4e, 0xeb, 0xae, |
2406 | 0x92230006, 0x8f820010, 0x00031880, 0x00621821, 0x24020010, 0xac670010, | 1397 | 0x46, 0x87, 0xce, 0x77, 0x75, 0x9a, 0x4e, 0x5c, 0x9d, 0xd8, 0xc6, 0xa0, |
2407 | 0x24030002, 0xa7420140, 0xa7400142, 0xa7400144, 0xa7430146, 0x97420104, | 1398 | 0xb9, 0xf7, 0x0d, 0x29, 0xec, 0xf3, 0xfa, 0x39, 0xce, 0x46, 0x19, 0x67, |
2408 | 0x24030001, 0x2442fffe, 0xa7420148, 0xa743014a, 0x8f820024, 0x24030002, | 1399 | 0x55, 0x0a, 0x6e, 0xd5, 0x68, 0x7e, 0xe7, 0x6f, 0x79, 0xe0, 0x20, 0xc6, |
2409 | 0x30440006, 0x1083000d, 0x2c820003, 0x10400005, 0x24020004, 0x10800011, | 1400 | 0xe0, 0xf1, 0x66, 0xcb, 0x56, 0x68, 0x12, 0x6d, 0xbb, 0xdc, 0x77, 0x54, |
2410 | 0x3c020009, 0x0a0003a5, 0x00000000, 0x10820007, 0x24020006, 0x1482000d, | 1401 | 0xb6, 0xf3, 0x18, 0x79, 0x1e, 0xb8, 0xcf, 0x53, 0xc0, 0xfc, 0x7e, 0x9d, |
2411 | 0x3c020119, 0x0a00039f, 0x24030001, 0x0a00039e, 0x3c020109, 0x3c020019, | 1402 | 0x7d, 0x6a, 0x34, 0xb7, 0xc3, 0xba, 0xc0, 0x73, 0x97, 0xbf, 0x79, 0x6d, |
2412 | 0x24030001, 0xaf421000, 0xaf830020, 0x0a0003a5, 0x00000000, 0xaf421000, | 1403 | 0x13, 0x14, 0x61, 0x37, 0xd1, 0x72, 0x03, 0xfb, 0x97, 0x85, 0x06, 0x22, |
2413 | 0xaf800020, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x92220004, | 1404 | 0xec, 0x56, 0x76, 0x26, 0xf1, 0x14, 0x71, 0x50, 0x0a, 0x3e, 0x73, 0x5e, |
2414 | 0x24030008, 0x8f840020, 0x24420002, 0x30420007, 0x00621823, 0x30630007, | 1405 | 0xa8, 0x53, 0x08, 0x5c, 0x55, 0xac, 0x67, 0x8b, 0x16, 0x9a, 0xdb, 0xa2, |
2415 | 0x10800006, 0xae230010, 0x3c038000, 0x8f421000, 0x00431024, 0x1040fffd, | 1406 | 0x0f, 0x6d, 0x03, 0xee, 0x33, 0xc7, 0xfa, 0xf0, 0x3d, 0xa8, 0xd6, 0x20, |
2416 | 0x00000000, 0x8f820018, 0xaf82000c, 0x24420010, 0x30421fff, 0xaf820018, | 1407 | 0x03, 0xf3, 0x14, 0xb3, 0x68, 0x62, 0xaf, 0x6b, 0x2e, 0xdb, 0xb3, 0x6d, |
2417 | 0xaf420084, 0x97430104, 0x24424000, 0x0342d821, 0x3063ffff, 0x30620007, | 1408 | 0xbc, 0xac, 0x91, 0xbd, 0xbc, 0x8b, 0xd1, 0xf7, 0x7b, 0xd8, 0xef, 0x4d, |
2418 | 0x10400002, 0x24620007, 0x3043fff8, 0x8f820030, 0x8f840000, 0x00431821, | 1409 | 0xce, 0x35, 0x8e, 0xf5, 0x17, 0x62, 0xfb, 0x79, 0xec, 0x79, 0x61, 0x35, |
2419 | 0xaf82001c, 0x0064102b, 0xaf830030, 0x14400002, 0x00641023, 0xaf820030, | 1410 | 0xe5, 0xbe, 0x81, 0x46, 0xce, 0x4e, 0x6c, 0xaa, 0x88, 0xbd, 0x8c, 0xc0, |
2420 | 0x8f840030, 0x34028000, 0x8fbf0018, 0x8fb10014, 0x8fb00010, 0x00821021, | 1411 | 0x87, 0x3f, 0xfc, 0x2c, 0xd7, 0x3c, 0x70, 0xb8, 0x35, 0x03, 0x6c, 0x6c, |
2421 | 0x03421821, 0x3c021000, 0xaf830010, 0xaf440080, 0xaf420178, 0x03e00008, | 1412 | 0x2b, 0x85, 0x9e, 0x1d, 0x8c, 0x9b, 0xb8, 0x0a, 0xfc, 0x0a, 0x8c, 0xd8, |
2422 | 0x27bd0020, 0x8f830024, 0x27bdffe0, 0xafbf0018, 0xafb10014, 0x30620200, | 1413 | 0x6e, 0xbd, 0x97, 0x53, 0x2a, 0xe6, 0xba, 0xc6, 0x73, 0x21, 0xe7, 0x38, |
2423 | 0x14400004, 0xafb00010, 0x0000000d, 0x00000000, 0x240002e4, 0x00031a82, | 1414 | 0xab, 0xbf, 0x03, 0x27, 0x22, 0xaa, 0xd3, 0xe2, 0x41, 0x9d, 0xae, 0x0e, |
2424 | 0x30630003, 0x000310c0, 0x00431021, 0x00021080, 0x00431021, 0x00021080, | 1415 | 0xea, 0x34, 0x77, 0x43, 0x47, 0x1c, 0xf2, 0xbc, 0xdb, 0x62, 0x0d, 0x02, |
2425 | 0x3c030800, 0x24631aa0, 0x00438021, 0x8e040000, 0x14800004, 0x00000000, | 1416 | 0x6b, 0x87, 0xed, 0xec, 0xa6, 0x22, 0xf3, 0x3a, 0xd0, 0x7f, 0x40, 0xb4, |
2426 | 0x0000000d, 0x00000000, 0x240002e9, 0x8f620004, 0x04410008, 0x26050014, | 1417 | 0x35, 0xd0, 0x11, 0x37, 0x75, 0x68, 0x6c, 0x99, 0x2e, 0xfe, 0x84, 0xe8, |
2427 | 0x92020006, 0x8e03000c, 0x24420003, 0x00021080, 0x00a21021, 0xac430000, | 1418 | 0xe2, 0x80, 0x7d, 0x79, 0xfc, 0xc2, 0x27, 0xc2, 0x9e, 0x65, 0x60, 0x7e, |
2428 | 0xae000000, 0x92020005, 0x24420001, 0x00021080, 0x00a21021, 0x8c430000, | 1419 | 0x75, 0x20, 0x23, 0x1f, 0x20, 0x5f, 0xee, 0x07, 0xc8, 0x83, 0x6d, 0xfc, |
2429 | 0x3c040001, 0x00641821, 0xac430000, 0x92060004, 0x27710008, 0x02202021, | 1420 | 0xd6, 0x91, 0x1b, 0x19, 0x1b, 0xce, 0x13, 0x8f, 0x81, 0xcf, 0x06, 0xfa, |
2430 | 0x24c60005, 0x0e000673, 0x00063082, 0x92040006, 0x3c057fff, 0x8f620004, | 1421 | 0x2e, 0xa1, 0x8d, 0xf3, 0x16, 0xdb, 0xea, 0xd4, 0x76, 0xa7, 0x28, 0xad, |
2431 | 0x00042080, 0x00912021, 0x8c830004, 0x34a5ffff, 0x00451024, 0x00621821, | 1422 | 0x72, 0x91, 0xc9, 0xb9, 0xe8, 0x14, 0xf8, 0x34, 0x81, 0xfc, 0x72, 0x47, |
2432 | 0xac830004, 0x92050005, 0x3c07ffff, 0x92040004, 0x00052880, 0x00b12821, | 1423 | 0x19, 0xcd, 0x45, 0xc8, 0x59, 0x8d, 0xd3, 0xc8, 0x3d, 0x3f, 0x47, 0x3b, |
2433 | 0x8ca30000, 0x97420104, 0x96060008, 0x00671824, 0x00441021, 0x00461023, | 1424 | 0x8f, 0xf7, 0x33, 0x3c, 0x27, 0xf0, 0x7d, 0x1a, 0xb6, 0xc3, 0x79, 0xa8, |
2434 | 0x3042ffff, 0x00621825, 0xaca30000, 0x92030007, 0x24020001, 0x1062000a, | 1425 | 0xf2, 0x7b, 0x5a, 0x0e, 0x02, 0xef, 0x76, 0x0c, 0xd8, 0x5b, 0xd0, 0x0b, |
2435 | 0x28620002, 0x1440001d, 0x2402000a, 0x24020002, 0x10620019, 0x24020003, | 1426 | 0xc7, 0xbb, 0x86, 0x7c, 0xc1, 0x31, 0xaf, 0x21, 0xa6, 0x3a, 0xe6, 0x36, |
2436 | 0x1062000e, 0x2402000a, 0x0a000447, 0x00000000, 0x92020004, 0x97430104, | 1427 | 0x69, 0xfe, 0x80, 0x62, 0xa5, 0xcc, 0x4f, 0xe1, 0x71, 0x7e, 0x6a, 0x0a, |
2437 | 0x8e24000c, 0x00621821, 0x2463fff2, 0x3063ffff, 0x00872024, 0x00832025, | 1428 | 0x1e, 0x24, 0x99, 0x09, 0x1f, 0xd6, 0x6d, 0xa5, 0x53, 0xc6, 0x8e, 0xfc, |
2438 | 0xae24000c, 0x0a000447, 0x2402000a, 0x92020004, 0x97430104, 0x8e240010, | 1429 | 0x00, 0x1a, 0x0e, 0x94, 0x3c, 0xdf, 0xc4, 0x19, 0x11, 0x01, 0x77, 0x1f, |
2439 | 0x00621821, 0x2463ffee, 0x3063ffff, 0x00872024, 0x00832025, 0xae240010, | 1430 | 0xda, 0x8d, 0xa0, 0xdd, 0x70, 0x48, 0xbb, 0xe1, 0xff, 0xd4, 0x2e, 0x74, |
2440 | 0x2402000a, 0xa7420140, 0x96030012, 0x8f840024, 0xa7430142, 0x92020004, | 1431 | 0x09, 0x8d, 0xdc, 0x05, 0xa7, 0x3e, 0xe8, 0x9f, 0xa4, 0x63, 0xd6, 0x30, |
2441 | 0xa7420144, 0xa7400146, 0x97430104, 0x30840006, 0x24020001, 0xa7430148, | 1432 | 0x6b, 0xd9, 0xa2, 0x7b, 0x4b, 0xcf, 0xa2, 0xe5, 0xbf, 0x3e, 0xab, 0x96, |
2442 | 0xa742014a, 0x24020002, 0x1082000d, 0x2c820003, 0x10400005, 0x24020004, | 1433 | 0x63, 0xd6, 0xb2, 0xca, 0x5a, 0x6e, 0x0c, 0x6b, 0xf9, 0x53, 0xf8, 0x17, |
2443 | 0x10800011, 0x3c020041, 0x0a00046c, 0x00000000, 0x10820007, 0x24020006, | 1434 | 0x9a, 0xbc, 0xa0, 0x36, 0x48, 0x5b, 0x04, 0x0e, 0x3b, 0x75, 0x52, 0x6e, |
2444 | 0x1482000d, 0x3c020151, 0x0a000466, 0x24030001, 0x0a000465, 0x3c020141, | 1435 | 0x3c, 0xe1, 0x1b, 0x73, 0x38, 0x1c, 0xe0, 0xdf, 0x81, 0x86, 0x3e, 0x69, |
2445 | 0x3c020051, 0x24030001, 0xaf421000, 0xaf830020, 0x0a00046c, 0x00000000, | 1436 | 0xb4, 0x1d, 0x39, 0x4f, 0xf5, 0xec, 0xe6, 0x96, 0xb0, 0x51, 0x49, 0x47, |
2446 | 0xaf421000, 0xaf800020, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1437 | 0xdc, 0xbf, 0xb3, 0x64, 0x5b, 0x96, 0x3c, 0xac, 0x79, 0xa8, 0x7e, 0x27, |
2447 | 0x8f820020, 0x8f840018, 0x10400006, 0x92030004, 0x3c058000, 0x8f421000, | 1438 | 0xbf, 0xa6, 0x79, 0x3c, 0x4f, 0x6c, 0x81, 0xeb, 0xd6, 0x8f, 0x80, 0x51, |
2448 | 0x00451024, 0x1040fffd, 0x00000000, 0x2463000a, 0x30620007, 0x10400002, | 1439 | 0xda, 0x63, 0x9e, 0x3b, 0xe6, 0x9a, 0xe0, 0x17, 0xbe, 0xa1, 0x05, 0x0d, |
2449 | 0x24620007, 0x304303f8, 0x00831021, 0x30421fff, 0xaf84000c, 0xaf820018, | 1440 | 0x7c, 0xad, 0xc1, 0x4e, 0xdd, 0x29, 0xf4, 0x73, 0x17, 0xe3, 0xee, 0xf5, |
2450 | 0xaf420084, 0x97430104, 0x24424000, 0x0342d821, 0x3063ffff, 0x30620007, | 1441 | 0x98, 0x5f, 0x06, 0xe9, 0x37, 0x9d, 0xe6, 0x55, 0x91, 0x73, 0xe7, 0xcd, |
2451 | 0x10400002, 0x24620007, 0x3043fff8, 0x8f820030, 0x8f840000, 0x00431821, | 1442 | 0x75, 0x62, 0xed, 0xf1, 0x79, 0x87, 0xfe, 0x41, 0x8d, 0x14, 0xa1, 0xf7, |
2452 | 0xaf82001c, 0x0064102b, 0xaf830030, 0x14400002, 0x00641023, 0xaf820030, | 1443 | 0xc9, 0x52, 0xef, 0x2f, 0x20, 0x46, 0x93, 0xf8, 0x66, 0xcd, 0x9f, 0x2e, |
2453 | 0x8f840030, 0x34028000, 0x8fbf0018, 0x8fb10014, 0x8fb00010, 0x00821021, | 1444 | 0x35, 0x3f, 0x8d, 0x27, 0xb7, 0x5d, 0x54, 0x0b, 0xee, 0x80, 0x87, 0x3b, |
2454 | 0x03421821, 0x3c021000, 0xaf830010, 0xaf440080, 0xaf420178, 0x03e00008, | 1445 | 0x8c, 0x6b, 0x1d, 0xf9, 0x8d, 0xe7, 0xff, 0x7b, 0xbe, 0xe9, 0x30, 0xb6, |
2455 | 0x27bd0020, 0x8f620000, 0x97430104, 0x3c048000, 0x3045ffff, 0x3066ffff, | 1446 | 0x8e, 0xf5, 0x03, 0x5a, 0x80, 0xee, 0xd0, 0x7e, 0xc0, 0xb6, 0xec, 0x53, |
2456 | 0x8f420178, 0x00441024, 0x1440fffd, 0x2402000a, 0x30a30007, 0xa7420140, | 1447 | 0xd9, 0x9a, 0xa5, 0xed, 0xa7, 0x63, 0xb6, 0x68, 0x3f, 0x60, 0x3b, 0xd6, |
2457 | 0x24020008, 0x00431023, 0x30420007, 0x24a3fffe, 0xa7420142, 0xa7430144, | 1448 | 0xc5, 0x73, 0xa4, 0xdc, 0xe4, 0xf3, 0x38, 0x60, 0x5d, 0xc0, 0xaf, 0x8d, |
2458 | 0xa7400146, 0xa7460148, 0x8f420108, 0x8f830024, 0x30420020, 0x0002102b, | 1449 | 0x36, 0xae, 0x19, 0xd8, 0x9f, 0xcf, 0x66, 0x5e, 0x27, 0xd7, 0x13, 0x7c, |
2459 | 0x00021023, 0x30420009, 0x34420001, 0x30630006, 0xa742014a, 0x24020002, | 1450 | 0x7e, 0x8f, 0x9d, 0xd3, 0xc7, 0xda, 0xb8, 0x00, 0xbe, 0x7f, 0x4b, 0xfd, |
2460 | 0x1062000d, 0x2c620003, 0x10400005, 0x24020004, 0x10600011, 0x3c020041, | 1451 | 0x4f, 0x6d, 0xbc, 0x06, 0x2d, 0x5c, 0x51, 0x0b, 0x6d, 0x6c, 0xe3, 0x79, |
2461 | 0x0a0004d6, 0x00000000, 0x10620007, 0x24020006, 0x1462000d, 0x3c020151, | 1452 | 0x01, 0xdf, 0xaf, 0x8d, 0x69, 0xa3, 0xf2, 0x7b, 0xfa, 0xf9, 0x9c, 0xf4, |
2462 | 0x0a0004d0, 0x24030001, 0x0a0004cf, 0x3c020141, 0x3c020051, 0x24030001, | 1453 | 0x9b, 0xe2, 0x6c, 0xe5, 0xf9, 0x94, 0x1d, 0x8a, 0xb5, 0x52, 0x07, 0x6b, |
2463 | 0xaf421000, 0xaf830020, 0x0a0004d6, 0x00000000, 0xaf421000, 0xaf800020, | 1454 | 0xc7, 0x3a, 0x98, 0x44, 0xae, 0x18, 0xe1, 0xb8, 0x12, 0xba, 0xb6, 0x99, |
2464 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8f820020, 0x24a30008, | 1455 | 0x12, 0x6b, 0x62, 0xf8, 0xfc, 0xfa, 0x7f, 0xe9, 0x82, 0xc0, 0x23, 0x31, |
2465 | 0x8f850018, 0x10400006, 0x30c6ffff, 0x3c048000, 0x8f421000, 0x00441024, | 1456 | 0x37, 0x6a, 0x0c, 0x3e, 0x0f, 0xf2, 0xfc, 0x8a, 0x8b, 0xfe, 0xaa, 0xd6, |
2466 | 0x1040fffd, 0x00000000, 0x3063ffff, 0x30620007, 0x10400002, 0x24620007, | 1457 | 0x10, 0xd8, 0xf3, 0x59, 0xcb, 0x78, 0xa0, 0xbe, 0x73, 0xe6, 0xa1, 0x05, |
2467 | 0x3043fff8, 0x00a31021, 0x30421fff, 0x24434000, 0x0343d821, 0x00c02021, | 1458 | 0xce, 0x01, 0x8f, 0xf3, 0x3d, 0x27, 0x40, 0x5b, 0x1b, 0xf1, 0x67, 0x4c, |
2468 | 0x30830007, 0xaf85000c, 0xaf820018, 0xaf420084, 0x10600002, 0x24820007, | 1459 | 0x36, 0xa4, 0xf5, 0x7d, 0x83, 0xfd, 0xa0, 0xb3, 0x93, 0x6a, 0x2c, 0x1d, |
2469 | 0x3044fff8, 0x8f820030, 0x8f850000, 0x00441821, 0xaf82001c, 0x0065102b, | 1460 | 0x9a, 0x7a, 0x82, 0x13, 0xf3, 0x28, 0x1a, 0xc2, 0xa9, 0x23, 0x70, 0xfa, |
2470 | 0xaf830030, 0x14400002, 0x00651023, 0xaf820030, 0x8f840030, 0x34028000, | 1461 | 0xf0, 0x18, 0xa7, 0xa8, 0xc4, 0x29, 0x12, 0x38, 0xfd, 0xb1, 0xc4, 0xe9, |
2471 | 0x3c030800, 0x8c650834, 0x00821021, 0x03421821, 0xaf830010, 0xaf440080, | 1462 | 0x0f, 0x4f, 0xc1, 0xe9, 0xc3, 0x67, 0xc0, 0xc9, 0xa0, 0x3d, 0xa7, 0x89, |
2472 | 0x10a00006, 0x2402000e, 0x9383002f, 0x14620004, 0x3c021000, 0x2402043f, | 1463 | 0x73, 0x56, 0x17, 0x35, 0xe9, 0xa1, 0x7b, 0x52, 0x4d, 0x75, 0x52, 0xdc, |
2473 | 0xa7420148, 0x3c021000, 0x03e00008, 0xaf420178, 0x8f820024, 0x30424000, | 1464 | 0x6d, 0x73, 0x8f, 0x86, 0xeb, 0x0e, 0xdb, 0x7a, 0x80, 0xf5, 0xa5, 0xc0, |
2474 | 0x10400005, 0x24020800, 0x0000000d, 0x00000000, 0x2400040e, 0x24020800, | 1465 | 0xee, 0xfa, 0x58, 0xed, 0x91, 0xc0, 0xbe, 0x5d, 0xe2, 0x74, 0x1d, 0x38, |
2475 | 0xaf420178, 0x97440104, 0x3c030008, 0xaf430140, 0x8f820024, 0x30420001, | 1466 | 0xb5, 0x4b, 0x9c, 0xb6, 0x87, 0x70, 0xda, 0x1e, 0xc1, 0x89, 0xf3, 0x49, |
2476 | 0x10400006, 0x3085ffff, 0x24020002, 0x24a3fffe, 0xa7420146, 0x0a000526, | 1467 | 0xcb, 0xd8, 0xee, 0x55, 0x18, 0x55, 0xf8, 0xe8, 0x74, 0xdb, 0x9c, 0xc6, |
2477 | 0xa7430148, 0xa7400146, 0x8f840018, 0x2402000d, 0xa742014a, 0x24830008, | 1468 | 0xfe, 0xcf, 0x51, 0xfa, 0x63, 0x95, 0xeb, 0x5a, 0x60, 0xf7, 0xaa, 0x2a, |
2478 | 0x30631fff, 0x24624000, 0x0342d821, 0x30a20007, 0xaf84000c, 0xaf830018, | 1469 | 0x8b, 0xf3, 0x80, 0xdf, 0x9f, 0xd4, 0x27, 0x98, 0xcb, 0x0f, 0x5c, 0x8e, |
2479 | 0xaf430084, 0x10400002, 0x24a20007, 0x3045fff8, 0x8f820030, 0x8f840000, | 1470 | 0x23, 0xea, 0x57, 0xa7, 0xca, 0x43, 0xcf, 0xab, 0xa8, 0xad, 0xf0, 0xcd, |
2480 | 0x00451821, 0xaf82001c, 0x0064102b, 0xaf830030, 0x14400002, 0x00641023, | 1471 | 0x36, 0xaa, 0xd4, 0x86, 0xde, 0x15, 0xd4, 0xe5, 0xe1, 0x71, 0x5d, 0x5e, |
2481 | 0xaf820030, 0x8f840030, 0x34028000, 0x00821021, 0x03421821, 0x3c021000, | 1472 | 0xc4, 0xe0, 0x7a, 0x59, 0x97, 0xef, 0x39, 0x5c, 0x97, 0x2f, 0x6a, 0x34, |
2482 | 0xaf830010, 0xaf440080, 0x03e00008, 0xaf420178, 0x27bdffe8, 0x3c046008, | 1473 | 0xb9, 0x51, 0x62, 0xc9, 0x9c, 0x9e, 0x42, 0xdf, 0x25, 0x81, 0x79, 0x8a, |
2483 | 0xafbf0014, 0xafb00010, 0x8c825000, 0x3c1a8000, 0x2403ff7f, 0x375b4000, | 1474 | 0xfc, 0xbd, 0x89, 0xfd, 0x47, 0x82, 0x9b, 0xa8, 0xb1, 0x4a, 0xde, 0xa2, |
2484 | 0x00431024, 0x3442380c, 0xac825000, 0x8f430008, 0x3c100800, 0x37428000, | 1475 | 0x86, 0xa5, 0x30, 0x2b, 0x62, 0xf5, 0xc5, 0xd6, 0x5d, 0x9f, 0x20, 0x4f, |
2485 | 0x34630001, 0xaf430008, 0xaf820010, 0x3c02601c, 0xaf800018, 0xaf400080, | 1476 | 0x1b, 0x1d, 0x15, 0x75, 0xfd, 0xfd, 0x8c, 0xf3, 0x33, 0x5d, 0x4e, 0x7a, |
2486 | 0xaf400084, 0x8c450008, 0x3c036000, 0x8c620808, 0x3c040800, 0x3c030080, | 1477 | 0x14, 0x9f, 0xf1, 0xae, 0xe5, 0xc0, 0xdc, 0x7f, 0xeb, 0x3c, 0x9f, 0x33, |
2487 | 0xac830820, 0x3042fff0, 0x38420010, 0x2c420001, 0xaf850000, 0xaf820004, | 1478 | 0xf5, 0xd5, 0xa0, 0x85, 0xf6, 0x81, 0x41, 0xa8, 0x7d, 0x70, 0x4f, 0xa1, |
2488 | 0x0e000658, 0x00000000, 0x8f420000, 0x30420001, 0x1040fffb, 0x00000000, | 1479 | 0x38, 0x38, 0x2f, 0xa1, 0xc6, 0xc1, 0x37, 0x7c, 0x92, 0x6c, 0xb6, 0x23, |
2489 | 0x8f430108, 0x8f440100, 0x30622000, 0xaf830024, 0xaf840014, 0x10400004, | 1480 | 0x7b, 0x4d, 0x70, 0x21, 0x26, 0x1f, 0xeb, 0xf4, 0x33, 0x71, 0x57, 0xe9, |
2490 | 0x8e02082c, 0x24420001, 0x0a0005c6, 0xae02082c, 0x30620200, 0x14400003, | 1481 | 0x28, 0x9e, 0x81, 0xda, 0x92, 0x0c, 0x9c, 0xf3, 0x88, 0x89, 0x65, 0xa4, |
2491 | 0x24020f00, 0x14820027, 0x24020d00, 0x97420104, 0x1040001c, 0x30624000, | 1482 | 0x03, 0xd4, 0x41, 0x38, 0xfb, 0x83, 0x55, 0xc4, 0xe5, 0x2c, 0x70, 0xcb, |
2492 | 0x14400005, 0x00000000, 0x0e00022f, 0x00000000, 0x0a0005bb, 0x00000000, | 1483 | 0x54, 0xf8, 0xbe, 0xa9, 0x17, 0xf7, 0x1c, 0x54, 0x35, 0x22, 0x5e, 0x8f, |
2493 | 0x8f620008, 0x8f630000, 0x24020030, 0x00031e02, 0x306300f0, 0x10620007, | 1484 | 0x4a, 0x7e, 0x88, 0x3a, 0x4b, 0x6a, 0xf7, 0xc9, 0x8a, 0x5c, 0xf0, 0x1c, |
2494 | 0x28620031, 0x1440002f, 0x24020040, 0x10620007, 0x00000000, 0x0a0005bb, | 1485 | 0xe7, 0x48, 0x37, 0xe3, 0xda, 0xf9, 0xac, 0x21, 0xdf, 0xe0, 0x5c, 0x7e, |
2495 | 0x00000000, 0x0e0002e8, 0x00000000, 0x0a0005bb, 0x00000000, 0x0e0003db, | 1486 | 0x88, 0x18, 0xe2, 0xfd, 0x80, 0xcf, 0x16, 0x85, 0xeb, 0x6f, 0xdc, 0x67, |
2496 | 0x00000000, 0x0a0005bb, 0x00000000, 0x30620040, 0x1440002b, 0x00000000, | 1487 | 0x96, 0x90, 0x6b, 0x68, 0x0a, 0x79, 0x0f, 0x79, 0x77, 0x96, 0x71, 0xf2, |
2497 | 0x0000000d, 0x00000000, 0x240004b2, 0x0a0005c6, 0x00000000, 0x1482000f, | 1488 | 0x23, 0xc6, 0x4b, 0x9c, 0x1b, 0xe7, 0xe4, 0x62, 0x9e, 0x5f, 0x6b, 0x05, |
2498 | 0x30620006, 0x97420104, 0x10400005, 0x30620040, 0x0e000510, 0x00000000, | 1489 | 0x7f, 0x71, 0x87, 0x41, 0xfc, 0x36, 0xfb, 0x2e, 0xe7, 0xdb, 0x2f, 0x2b, |
2499 | 0x0a0005bb, 0x00000000, 0x1440001b, 0x00000000, 0x0000000d, 0x00000000, | 1490 | 0x74, 0x44, 0x82, 0x8f, 0xe6, 0xcb, 0xc8, 0xc3, 0xe7, 0xe0, 0xe3, 0x0b, |
2500 | 0x240004c4, 0x0a0005c6, 0x00000000, 0x1040000e, 0x30621000, 0x10400005, | 1491 | 0x2d, 0x16, 0xf5, 0x56, 0xe5, 0xf3, 0xc9, 0xd8, 0x18, 0x1f, 0x29, 0xa3, |
2501 | 0x00000000, 0x0e000688, 0x00000000, 0x0a0005bb, 0x00000000, 0x0e0004a1, | 1492 | 0xdf, 0x3e, 0xf8, 0xbc, 0x52, 0xce, 0x57, 0xf1, 0xe3, 0x57, 0xe0, 0xc7, |
2502 | 0x00000000, 0x8f82002c, 0x24420001, 0xaf82002c, 0x0a0005c6, 0x00000000, | 1493 | 0x61, 0xd9, 0xcf, 0x77, 0x16, 0x1d, 0x36, 0xbc, 0x3e, 0xe6, 0x11, 0xdb, |
2503 | 0x30620040, 0x14400004, 0x00000000, 0x0000000d, 0x00000000, 0x240004db, | 1494 | 0x9b, 0xda, 0xe8, 0x18, 0x5f, 0x1a, 0xf3, 0xff, 0xfd, 0x90, 0xff, 0x34, |
2504 | 0x8f420138, 0x3c034000, 0x00431025, 0xaf420138, 0x0a000566, 0x00000000, | 1495 | 0xef, 0xc9, 0x8c, 0x0a, 0x0e, 0xe2, 0xef, 0x3d, 0x7d, 0xd4, 0xf7, 0x17, |
2505 | 0x3c046008, 0x8c835000, 0x3c1a8000, 0x2402ff7f, 0x375b4000, 0x00621824, | 1496 | 0x6a, 0xf1, 0x7d, 0xb6, 0xe0, 0x9e, 0x83, 0x67, 0x76, 0x38, 0xb4, 0x36, |
2506 | 0x3463380c, 0xac835000, 0x8f420008, 0x3c056000, 0x3c03601c, 0x34420001, | 1497 | 0x75, 0x6c, 0xec, 0x87, 0x18, 0x7b, 0x15, 0x79, 0x84, 0x7c, 0x05, 0x77, |
2507 | 0xaf420008, 0x37428000, 0xaf800018, 0xaf820010, 0xaf400080, 0xaf400084, | 1498 | 0xa6, 0x90, 0xf0, 0x9e, 0x5d, 0xa9, 0xe2, 0x03, 0x4e, 0xd0, 0xe5, 0xb4, |
2508 | 0x8c660008, 0x8ca20808, 0x3c040800, 0x3c030080, 0xac830820, 0x3042fff0, | 1499 | 0xe4, 0x82, 0x5c, 0x70, 0x81, 0xeb, 0xb4, 0xd5, 0x4d, 0x70, 0x21, 0x05, |
2509 | 0x38420010, 0x2c420001, 0xaf860000, 0xaf820004, 0x03e00008, 0x00000000, | 1500 | 0x17, 0xe0, 0xd7, 0xd1, 0xbc, 0x59, 0xe0, 0xcc, 0x39, 0x07, 0xdf, 0x19, |
2510 | 0x3084ffff, 0x30820007, 0x10400002, 0x24820007, 0x3044fff8, 0x8f820018, | 1501 | 0xf3, 0x82, 0x79, 0xc0, 0x9c, 0x78, 0xc2, 0x85, 0x2b, 0x3d, 0xc3, 0xd8, |
2511 | 0x00441821, 0x30631fff, 0x24644000, 0x0344d821, 0xaf82000c, 0xaf830018, | 1502 | 0xfd, 0x2f, 0x3c, 0x78, 0x57, 0xf0, 0x80, 0xf9, 0x58, 0xe4, 0x85, 0x2e, |
2512 | 0x03e00008, 0xaf430084, 0x3084ffff, 0x30820007, 0x10400002, 0x24820007, | 1503 | 0x70, 0x48, 0xca, 0xbc, 0x50, 0xe8, 0x9c, 0xeb, 0x1b, 0xd6, 0x78, 0xa1, |
2513 | 0x3044fff8, 0x8f820030, 0x8f830000, 0x00442021, 0xaf82001c, 0x0083102b, | 1504 | 0x8d, 0x2d, 0x68, 0xa3, 0xad, 0x70, 0xbd, 0xc3, 0xba, 0x60, 0x3f, 0xd6, |
2514 | 0xaf840030, 0x14400002, 0x00831023, 0xaf820030, 0x8f820030, 0x34038000, | 1505 | 0xc6, 0x49, 0x7e, 0x85, 0x46, 0xd2, 0xbe, 0x6d, 0x55, 0xf9, 0x21, 0x85, |
2515 | 0x00431821, 0x03432021, 0xaf840010, 0x03e00008, 0xaf420080, 0x8f830024, | 1506 | 0x2e, 0xba, 0xa5, 0x46, 0xd2, 0x52, 0x23, 0xb0, 0x89, 0x95, 0x16, 0xe7, |
2516 | 0x24020002, 0x30630006, 0x1062000d, 0x2c620003, 0x50400005, 0x24020004, | 1507 | 0x7a, 0xdb, 0x0a, 0x91, 0x17, 0xba, 0x62, 0xcc, 0x98, 0x8a, 0x3b, 0x09, |
2517 | 0x10600012, 0x3c020001, 0x0a00062a, 0x00000000, 0x10620007, 0x24020006, | 1508 | 0xeb, 0x96, 0xf3, 0xe9, 0x50, 0x1e, 0x2d, 0xef, 0xa5, 0x1d, 0x71, 0x2f, |
2518 | 0x1462000f, 0x3c020111, 0x0a000622, 0x00821025, 0x0a000621, 0x3c020101, | 1509 | 0xfd, 0x8a, 0x3e, 0x9a, 0x47, 0x67, 0x90, 0x43, 0xf8, 0x5e, 0x3a, 0xa7, |
2519 | 0x3c020011, 0x00821025, 0x24030001, 0xaf421000, 0xaf830020, 0x0a00062a, | 1510 | 0xf3, 0xbd, 0x14, 0xba, 0xd3, 0x87, 0xef, 0xa5, 0xc9, 0xc8, 0xbd, 0xb4, |
2520 | 0x00000000, 0x00821025, 0xaf421000, 0xaf800020, 0x00000000, 0x00000000, | 1511 | 0xf2, 0xe5, 0xf6, 0x93, 0xf2, 0x69, 0x15, 0x13, 0xce, 0xa9, 0x02, 0xf3, |
2521 | 0x00000000, 0x03e00008, 0x00000000, 0x8f820020, 0x10400005, 0x3c038000, | 1512 | 0x13, 0x6a, 0xbf, 0xca, 0x86, 0xf3, 0x0d, 0x6b, 0xb9, 0xcc, 0x51, 0xa8, |
2522 | 0x8f421000, 0x00431024, 0x1040fffd, 0x00000000, 0x03e00008, 0x00000000, | 1513 | 0xb5, 0xee, 0x67, 0x15, 0xe7, 0xdf, 0xc0, 0x3c, 0xf8, 0xee, 0x9f, 0xc4, |
2523 | 0x8f820024, 0x27bdffe8, 0x30424000, 0x14400005, 0xafbf0010, 0x0e00022f, | 1514 | 0x79, 0xa3, 0xe4, 0xfc, 0x54, 0xe1, 0xd3, 0x1f, 0xe6, 0xfd, 0x1b, 0xfa, |
2524 | 0x00000000, 0x0a000656, 0x8fbf0010, 0x8f620008, 0x8f630000, 0x24020030, | 1515 | 0x28, 0xef, 0xab, 0x71, 0x2a, 0xde, 0x17, 0x63, 0x3e, 0x54, 0x9a, 0x38, |
2525 | 0x00031e02, 0x306300f0, 0x10620008, 0x28620031, 0x1440000d, 0x8fbf0010, | 1516 | 0xdb, 0x96, 0x91, 0x6b, 0x66, 0xf8, 0xbe, 0x85, 0x5c, 0xe0, 0xd5, 0x71, |
2526 | 0x24020040, 0x10620007, 0x00000000, 0x0a000656, 0x00000000, 0x0e0002e8, | 1517 | 0xef, 0x98, 0xe1, 0xb1, 0xd3, 0x0c, 0xe7, 0x4d, 0x03, 0xbc, 0x17, 0x9c, |
2527 | 0x00000000, 0x0a000656, 0x8fbf0010, 0x0e0003db, 0x00000000, 0x8fbf0010, | 1518 | 0x3d, 0x12, 0xf7, 0x01, 0xac, 0x7b, 0x86, 0xab, 0xab, 0x51, 0x2e, 0xbe, |
2528 | 0x03e00008, 0x27bd0018, 0x8f840028, 0x1080000f, 0x3c026000, 0x8c430c3c, | 1519 | 0x88, 0x0b, 0x45, 0xb5, 0x97, 0xaa, 0xcd, 0x19, 0x6a, 0x5b, 0x2e, 0xb1, |
2529 | 0x30630fff, 0xaf830008, 0x14600011, 0x3082000f, 0x10400005, 0x308200f0, | 1520 | 0x2e, 0x62, 0xfd, 0xa0, 0xb8, 0x8f, 0xd3, 0x2e, 0x6a, 0xb1, 0x43, 0xd4, |
2530 | 0x10400003, 0x30820f00, 0x14400006, 0x00000000, 0x0000000d, 0x00000000, | 1521 | 0x39, 0x77, 0x70, 0x9f, 0x4b, 0x06, 0x8f, 0xf2, 0x07, 0x0d, 0x95, 0xba, |
2531 | 0x2400051a, 0x03e00008, 0x00000000, 0x0000000d, 0x00000000, 0x2400051f, | 1522 | 0xc7, 0x3e, 0x5d, 0xac, 0xd7, 0x36, 0x6f, 0xe3, 0xed, 0xdd, 0x41, 0x15, |
2532 | 0x03e00008, 0x00000000, 0xaf830028, 0x03e00008, 0x00000000, 0x10c00007, | 1523 | 0x53, 0xee, 0xe7, 0xb6, 0x7f, 0xe0, 0xbc, 0x45, 0x1d, 0x37, 0x32, 0x67, |
2533 | 0x00000000, 0x8ca20000, 0x24c6ffff, 0x24a50004, 0xac820000, 0x14c0fffb, | 1524 | 0xf5, 0xce, 0x7f, 0xff, 0x06, 0x63, 0xe1, 0x4b, 0x7b, 0x30, 0x12, 0x00, |
2534 | 0x24840004, 0x03e00008, 0x00000000, 0x0a000684, 0x00a01021, 0xac860000, | 1525 | 0x00, 0x00 }; |
2535 | 0x00000000, 0x00000000, 0x24840004, 0x00a01021, 0x1440fffa, 0x24a5ffff, | ||
2536 | 0x03e00008, 0x00000000, 0x0000000d, 0x03e00008, 0x00000000, 0x00000000}; | ||
2537 | 1526 | ||
2538 | static u32 bnx2_TPAT_b06FwData[(0x0/4) + 1] = { 0x0 }; | 1527 | static u32 bnx2_TPAT_b06FwData[(0x0/4) + 1] = { 0x0 }; |
2539 | static u32 bnx2_TPAT_b06FwRodata[(0x0/4) + 1] = { 0x0 }; | 1528 | static u32 bnx2_TPAT_b06FwRodata[(0x0/4) + 1] = { 0x0 }; |
@@ -2554,939 +1543,422 @@ static const u32 bnx2_TXP_b06FwBssAddr = 0x080057a0; | |||
2554 | static const int bnx2_TXP_b06FwBssLen = 0x1c4; | 1543 | static const int bnx2_TXP_b06FwBssLen = 0x1c4; |
2555 | static const u32 bnx2_TXP_b06FwSbssAddr = 0x08005760; | 1544 | static const u32 bnx2_TXP_b06FwSbssAddr = 0x08005760; |
2556 | static const int bnx2_TXP_b06FwSbssLen = 0x38; | 1545 | static const int bnx2_TXP_b06FwSbssLen = 0x38; |
2557 | static u32 bnx2_TXP_b06FwText[(0x5748/4) + 1] = { | 1546 | static u8 bnx2_TXP_b06FwText[] = { |
2558 | 0x0a000d2c, 0x00000000, 0x00000000, 0x0000000d, 0x74787020, 0x322e352e, | 1547 | 0x1f, 0x8b, 0x08, 0x08, 0x21, 0xd3, 0x41, 0x44, 0x00, 0x03, 0x74, 0x65, |
2559 | 0x38000000, 0x02050800, 0x0000000a, 0x000003e8, 0x0000ea60, 0x00000000, | 1548 | 0x73, 0x74, 0x31, 0x2e, 0x62, 0x69, 0x6e, 0x00, 0xed, 0x5c, 0x6d, 0x6c, |
2560 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1549 | 0x1b, 0xf7, 0x79, 0x7f, 0xee, 0x85, 0xd2, 0x51, 0x96, 0xe9, 0x93, 0xc2, |
2561 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1550 | 0x78, 0x6c, 0xc0, 0xa6, 0x77, 0xd6, 0x51, 0x66, 0x20, 0xb5, 0xa0, 0x05, |
2562 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1551 | 0x36, 0x55, 0x87, 0x43, 0x73, 0x3e, 0x52, 0x2f, 0x4e, 0x5c, 0x57, 0x71, |
2563 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1552 | 0x94, 0x86, 0x6e, 0x0d, 0x8c, 0xa0, 0xec, 0xd8, 0xeb, 0x5a, 0x2c, 0x1f, |
2564 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1553 | 0x8c, 0xd5, 0x68, 0xd1, 0x99, 0xa1, 0x68, 0xc7, 0xc9, 0x68, 0x51, 0xa9, |
2565 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1554 | 0xe5, 0xa8, 0x43, 0x57, 0x80, 0x95, 0x64, 0xcb, 0x29, 0x4e, 0x3a, 0x65, |
2566 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1555 | 0xcb, 0x16, 0x0c, 0x58, 0x16, 0xcd, 0x2f, 0x5d, 0x3f, 0x74, 0x80, 0x3f, |
2567 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1556 | 0xec, 0x43, 0x3a, 0xec, 0x83, 0x91, 0x14, 0xad, 0x11, 0x6c, 0x59, 0xb0, |
2568 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1557 | 0x2f, 0x33, 0xd6, 0x26, 0xb7, 0xdf, 0x73, 0x77, 0x94, 0x95, 0xc4, 0x4e, |
2569 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1558 | 0xab, 0x7d, 0xbe, 0x07, 0x20, 0xee, 0x7f, 0xff, 0xd7, 0xe7, 0xfd, 0xe5, |
2570 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1559 | 0x7f, 0x90, 0x06, 0xb7, 0x53, 0x17, 0x85, 0xb0, 0x1d, 0x3f, 0xed, 0x99, |
2571 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1560 | 0x93, 0x27, 0x3e, 0xf7, 0xf9, 0xcf, 0x0d, 0xa1, 0x39, 0x4c, 0x4a, 0x4c, |
2572 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1561 | 0xe4, 0xc1, 0x5b, 0x12, 0x51, 0xf9, 0x1d, 0x8a, 0x20, 0x82, 0x08, 0x22, |
2573 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1562 | 0x88, 0x20, 0x82, 0x08, 0x22, 0x88, 0x20, 0x82, 0x08, 0x22, 0x88, 0x20, |
2574 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1563 | 0x82, 0x08, 0x22, 0x88, 0x20, 0x82, 0x08, 0x22, 0x88, 0x20, 0x82, 0x08, |
2575 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1564 | 0x22, 0x88, 0x20, 0x82, 0x08, 0x22, 0x88, 0x20, 0x82, 0x08, 0x22, 0x88, |
2576 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1565 | 0x20, 0x82, 0x08, 0x22, 0x88, 0x20, 0x82, 0x08, 0x22, 0x88, 0x20, 0x82, |
2577 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1566 | 0x08, 0x22, 0x88, 0x20, 0x82, 0x08, 0x22, 0x88, 0x20, 0x82, 0x08, 0x22, |
2578 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1567 | 0xf8, 0x9d, 0x20, 0x11, 0xa9, 0xfc, 0xdc, 0x1e, 0xfe, 0x48, 0x11, 0xcd, |
2579 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1568 | 0xf2, 0x53, 0xb6, 0x41, 0x8a, 0x64, 0x1e, 0x39, 0x34, 0x65, 0x10, 0x59, |
2580 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1569 | 0xce, 0x80, 0x56, 0xa0, 0xf7, 0xbd, 0x6a, 0x52, 0x26, 0xee, 0xff, 0xb4, |
2581 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1570 | 0xf9, 0xdb, 0x53, 0xaf, 0x7f, 0x41, 0x7f, 0xaf, 0x25, 0x91, 0xa2, 0x9a, |
2582 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1571 | 0x6b, 0x79, 0xb5, 0x9f, 0x94, 0x34, 0xd6, 0xfc, 0xd5, 0xee, 0xaf, 0xef, |
2583 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1572 | 0xa0, 0x44, 0x7b, 0xaf, 0x24, 0xd5, 0x9b, 0xb7, 0xbc, 0xd7, 0x77, 0x27, |
2584 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1573 | 0xe9, 0x15, 0x57, 0xa5, 0x35, 0x57, 0x16, 0x46, 0x9b, 0x0a, 0x4d, 0x37, |
2585 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1574 | 0x1d, 0x3a, 0xdd, 0xa8, 0x52, 0xc1, 0xbd, 0x4c, 0xb5, 0x39, 0x35, 0x61, |
2586 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1575 | 0x2f, 0xff, 0x84, 0xa6, 0xe7, 0x7a, 0x13, 0x85, 0x65, 0x87, 0x6a, 0x8d, |
2587 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1576 | 0x54, 0xc2, 0x76, 0xd5, 0x44, 0x61, 0x3e, 0x89, 0xf7, 0xde, 0x84, 0x3d, |
2588 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1577 | 0xaf, 0x57, 0x89, 0x76, 0x62, 0x4e, 0x2a, 0x51, 0x68, 0xea, 0x65, 0xa2, |
2589 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1578 | 0xbe, 0xdc, 0x75, 0x4a, 0x27, 0x0a, 0xee, 0x82, 0xb0, 0xae, 0x0a, 0x54, |
2590 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1579 | 0xfb, 0x2c, 0xa9, 0x09, 0xf3, 0xb6, 0xf7, 0x29, 0x43, 0xa5, 0x1e, 0x83, |
2591 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1580 | 0x76, 0xec, 0x30, 0xe8, 0xd9, 0x94, 0xa9, 0x50, 0xe5, 0x7c, 0x9c, 0x2c, |
2592 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1581 | 0x9f, 0x26, 0x95, 0x2a, 0xf3, 0x03, 0xea, 0x15, 0x8a, 0x91, 0x95, 0x6c, |
2593 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1582 | 0xbf, 0x7b, 0x9e, 0x9d, 0xfb, 0x16, 0xff, 0x9d, 0x16, 0xce, 0xa2, 0xc4, |
2594 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1583 | 0xa8, 0x4b, 0x64, 0x03, 0x2f, 0x3b, 0xf7, 0xbe, 0x17, 0xac, 0x51, 0x70, |
2595 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1584 | 0xae, 0x9c, 0x18, 0x69, 0x7a, 0x5e, 0x31, 0x87, 0x33, 0x72, 0xed, 0xb5, |
2596 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1585 | 0x31, 0x6a, 0x25, 0xad, 0xd6, 0x74, 0x2e, 0xbf, 0x23, 0xf8, 0x1b, 0x2f, |
2597 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1586 | 0xa6, 0x91, 0xdf, 0x2d, 0x12, 0x8d, 0xaf, 0x50, 0x25, 0x49, 0xad, 0x5a, |
2598 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1587 | 0xee, 0x61, 0x7a, 0x21, 0xd7, 0x4d, 0x67, 0xb1, 0xdf, 0xf3, 0x39, 0xf0, |
2599 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1588 | 0xd1, 0x38, 0x29, 0xd8, 0xae, 0x9e, 0x22, 0xe1, 0x05, 0xb2, 0xe7, 0xfb, |
2600 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1589 | 0xd4, 0x02, 0xe1, 0x6c, 0xc3, 0xfb, 0x8c, 0x9d, 0xc3, 0x79, 0x83, 0xff, |
2601 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1590 | 0xeb, 0x59, 0x49, 0xbd, 0xdc, 0xa2, 0x14, 0xd5, 0x9a, 0x7d, 0xb9, 0x9f, |
2602 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1591 | 0x93, 0x40, 0x9d, 0x06, 0xf3, 0xc7, 0xa3, 0xc7, 0x70, 0xae, 0x6d, 0xa0, |
2603 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1592 | 0xdf, 0x25, 0x4b, 0xcc, 0xc4, 0xe8, 0x4f, 0x55, 0x5d, 0xb3, 0xa5, 0x5e, |
2604 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1593 | 0xaa, 0x9d, 0xef, 0x04, 0x9e, 0x56, 0xaf, 0x88, 0xb9, 0x63, 0x79, 0x4a, |
2605 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1594 | 0x6e, 0x23, 0x12, 0x24, 0x33, 0x83, 0x7d, 0x89, 0x6a, 0x4e, 0x0a, 0x6b, |
2606 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1595 | 0x33, 0xc3, 0xef, 0xd0, 0x0e, 0xd2, 0x7a, 0x64, 0x9a, 0x76, 0xba, 0xc0, |
2607 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1596 | 0xc7, 0x6e, 0xc8, 0x20, 0x33, 0xfc, 0x2e, 0x84, 0x22, 0x1a, 0x99, 0xd4, |
2608 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1597 | 0x49, 0x2a, 0x0b, 0x05, 0xb7, 0x83, 0xa6, 0x33, 0x0a, 0xd5, 0x81, 0x47, |
2609 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1598 | 0x3d, 0xf7, 0x35, 0xc1, 0x5e, 0x2e, 0x09, 0x85, 0x65, 0xcc, 0x73, 0x5f, |
2610 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1599 | 0x0b, 0xff, 0x76, 0xad, 0x1b, 0xfb, 0x88, 0x54, 0xcb, 0x94, 0x30, 0xa6, |
2611 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1600 | 0xd0, 0x14, 0xe6, 0x4d, 0x81, 0xa6, 0x69, 0x77, 0x07, 0xad, 0x4f, 0x26, |
2612 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1601 | 0x13, 0xcc, 0xab, 0x1a, 0xc6, 0xbf, 0x32, 0x21, 0x90, 0x6a, 0x58, 0xf4, |
2613 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1602 | 0xeb, 0x3c, 0x64, 0x38, 0xdf, 0xcb, 0x32, 0xa3, 0xd3, 0x4d, 0x4a, 0x8a, |
2614 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1603 | 0x94, 0x49, 0x55, 0xe8, 0x32, 0x2d, 0x3a, 0x2c, 0x7f, 0xc8, 0x13, 0xf2, |
2615 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1604 | 0xae, 0x39, 0xbc, 0x0e, 0x72, 0x6b, 0x16, 0xc1, 0x8f, 0x71, 0xe0, 0x70, |
2616 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1605 | 0x50, 0x78, 0x6c, 0x71, 0x52, 0x18, 0x73, 0x7f, 0x93, 0xa0, 0xae, 0x93, |
2617 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1606 | 0xc2, 0x01, 0xf7, 0xa8, 0x10, 0xf2, 0x1e, 0xb2, 0x53, 0xc8, 0x9a, 0x50, |
2618 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1607 | 0xe8, 0x92, 0x1b, 0xc8, 0x6e, 0x01, 0xfa, 0x69, 0xa9, 0x16, 0xe4, 0x70, |
2619 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1608 | 0x78, 0x63, 0x0e, 0x8f, 0xd5, 0x97, 0x65, 0x3a, 0xed, 0xf2, 0xfc, 0x3f, |
2620 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1609 | 0x82, 0x7c, 0x14, 0x72, 0x76, 0x77, 0x53, 0x19, 0xfd, 0xb5, 0x79, 0xb2, |
2621 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1610 | 0xec, 0x9c, 0x88, 0x35, 0x09, 0x92, 0x8c, 0x9d, 0xf8, 0x75, 0xd1, 0xd4, |
2622 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1611 | 0x62, 0xa7, 0x25, 0x19, 0x49, 0x9a, 0x72, 0x99, 0x87, 0x78, 0x36, 0xdb, |
2623 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1612 | 0x7c, 0x64, 0x5c, 0xb9, 0x9f, 0xd7, 0x71, 0xbf, 0x8a, 0xfe, 0xcd, 0x7d, |
2624 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1613 | 0xac, 0x17, 0x09, 0xe0, 0xa3, 0x67, 0x59, 0x9f, 0x2b, 0xcd, 0x8c, 0x7a, |
2625 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1614 | 0x80, 0x9f, 0x2e, 0xf3, 0xb6, 0xcd, 0x53, 0x19, 0x73, 0x45, 0xaa, 0x2c, |
2626 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1615 | 0xe2, 0x9c, 0xf3, 0xbf, 0xf5, 0x62, 0x79, 0xbc, 0x1b, 0x1d, 0xa0, 0x8b, |
2627 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1616 | 0xcf, 0x95, 0x81, 0x93, 0x48, 0xe5, 0x45, 0xde, 0x8b, 0xc7, 0x09, 0xb2, |
2628 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1617 | 0xaf, 0xf5, 0x88, 0x94, 0x85, 0x7c, 0x75, 0x9c, 0x13, 0xc7, 0x9c, 0x6e, |
2629 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1618 | 0xf0, 0x0f, 0xb4, 0x2e, 0xa3, 0x0d, 0xda, 0x45, 0x43, 0xc4, 0xfa, 0x4e, |
2630 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1619 | 0x9a, 0xca, 0xb1, 0xbe, 0x30, 0x9e, 0xdb, 0xb0, 0x77, 0x9c, 0x8e, 0x9c, |
2631 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1620 | 0x67, 0x7e, 0xc8, 0xf4, 0x3c, 0x70, 0x9c, 0x9e, 0xd7, 0xd5, 0x22, 0xe9, |
2632 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1621 | 0xe0, 0x8d, 0x85, 0x79, 0x9d, 0x54, 0x56, 0x3d, 0x6f, 0x24, 0x37, 0xa0, |
2633 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1622 | 0xbe, 0xec, 0xeb, 0xf9, 0x80, 0x9a, 0x11, 0xa8, 0xda, 0x61, 0xfe, 0x21, |
2634 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1623 | 0x70, 0xd0, 0x4b, 0x44, 0xfc, 0xfe, 0xcf, 0x64, 0x4d, 0xb2, 0xfd, 0x24, |
2635 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1624 | 0xf9, 0x2c, 0xd8, 0xd3, 0x4e, 0xe0, 0xcf, 0x36, 0x97, 0x86, 0x5c, 0x52, |
2636 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1625 | 0xbe, 0x1d, 0x8c, 0xdc, 0xd5, 0x0e, 0xf4, 0xf1, 0x16, 0x6c, 0xa6, 0xb6, |
2637 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1626 | 0x2c, 0xb3, 0xfd, 0xe5, 0xa0, 0x6e, 0xb4, 0xcd, 0x80, 0x6e, 0xf9, 0xb2, |
2638 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1627 | 0xd9, 0x8f, 0xfd, 0x3d, 0xef, 0xcb, 0xb9, 0x00, 0xa7, 0xda, 0xbc, 0x85, |
2639 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1628 | 0xb5, 0x32, 0xf8, 0xae, 0x1f, 0xd7, 0xfc, 0xf3, 0xf7, 0x87, 0xe7, 0xab, |
2640 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1629 | 0x34, 0x05, 0xbc, 0x6b, 0x4d, 0x89, 0x0a, 0x2a, 0xef, 0xf1, 0x2e, 0xf7, |
2641 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1630 | 0x97, 0x83, 0xbd, 0xa0, 0xb7, 0xe7, 0xfa, 0xd4, 0x7d, 0xb0, 0x25, 0xb6, |
2642 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1631 | 0xb1, 0xda, 0x0a, 0xf3, 0x18, 0xfb, 0xe4, 0x99, 0xc7, 0xaa, 0x8f, 0xa3, |
2643 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1632 | 0x3d, 0xcf, 0x7a, 0x44, 0x69, 0x89, 0x58, 0xcf, 0x2f, 0xb3, 0x2e, 0x41, |
2644 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1633 | 0x3f, 0x03, 0xbd, 0xaa, 0x38, 0x2c, 0xff, 0x2f, 0x85, 0xf6, 0x29, 0x52, |
2645 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1634 | 0x7f, 0x86, 0xf5, 0xfd, 0x05, 0x2a, 0xc0, 0xc6, 0xa7, 0x70, 0xd2, 0x22, |
2646 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1635 | 0x68, 0x5a, 0x68, 0xf6, 0x81, 0x57, 0x6d, 0xbb, 0x83, 0x7c, 0x07, 0xff, |
2647 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1636 | 0xc7, 0x0b, 0xe6, 0x77, 0x03, 0x27, 0xb6, 0x99, 0x9a, 0x2a, 0x52, 0x15, |
2648 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1637 | 0x3f, 0xe8, 0x8d, 0xa1, 0x67, 0x6d, 0x49, 0x9f, 0x28, 0x03, 0x37, 0xe8, |
2649 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1638 | 0x3d, 0xd9, 0x7b, 0x58, 0x9f, 0x31, 0xc7, 0xa5, 0xa1, 0xb6, 0x9d, 0x2d, |
2650 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1639 | 0x38, 0x2c, 0xa7, 0x2e, 0x9c, 0xdb, 0xc6, 0x49, 0x46, 0x1f, 0xef, 0xa3, |
2651 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1640 | 0x40, 0xe7, 0xdb, 0x3a, 0xc3, 0xfa, 0xa7, 0x5b, 0xeb, 0xd4, 0x41, 0xd9, |
2652 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1641 | 0x0c, 0x7c, 0xd9, 0xbc, 0x08, 0xf9, 0xa5, 0xe1, 0x53, 0x64, 0x7a, 0xba, |
2653 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1642 | 0x99, 0xa4, 0x63, 0x4d, 0xc6, 0xaf, 0x08, 0xbb, 0x83, 0x6f, 0x9b, 0x1f, |
2654 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1643 | 0x85, 0x9d, 0x8d, 0x0b, 0x23, 0xb0, 0x89, 0x47, 0x17, 0x19, 0x27, 0x8f, |
2655 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1644 | 0xd8, 0x2e, 0x8b, 0xcb, 0x65, 0x61, 0xd4, 0x2d, 0x09, 0xe3, 0xcb, 0x6c, |
2656 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1645 | 0x27, 0x6c, 0x23, 0xba, 0xfa, 0x38, 0x31, 0x0d, 0x98, 0xe3, 0xfe, 0x22, |
2657 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1646 | 0xc1, 0xb6, 0x5a, 0x3b, 0x17, 0x07, 0x1e, 0xdb, 0x80, 0x4f, 0x37, 0x6c, |
2658 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1647 | 0x0f, 0xfa, 0x65, 0xe8, 0x13, 0xac, 0x33, 0xc5, 0x8c, 0xa1, 0xfd, 0x25, |
2659 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1648 | 0x7d, 0x9c, 0x0f, 0x23, 0x1b, 0x7c, 0x18, 0x00, 0x4f, 0x3e, 0xcc, 0x87, |
2660 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1649 | 0xfa, 0xc7, 0xf9, 0x60, 0x55, 0xc1, 0x87, 0x3a, 0xfc, 0x50, 0xdd, 0x65, |
2661 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1650 | 0x9a, 0x3d, 0x12, 0xf7, 0x10, 0xb4, 0x93, 0xf6, 0x8a, 0x26, 0xeb, 0x28, |
2662 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1651 | 0xdb, 0x49, 0x46, 0x9b, 0xc6, 0x0e, 0x4b, 0x4e, 0xb7, 0x6f, 0x1b, 0xa3, |
2663 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1652 | 0x3e, 0x2f, 0x7e, 0x17, 0xbd, 0x4c, 0xdf, 0x1d, 0x9a, 0xc7, 0x17, 0xd9, |
2664 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1653 | 0xdf, 0x40, 0xcf, 0x33, 0x86, 0x7a, 0x88, 0xee, 0xd0, 0xbd, 0xef, 0x0e, |
2665 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1654 | 0xdd, 0x38, 0xa7, 0xed, 0x83, 0x98, 0xe6, 0xb6, 0x3f, 0x66, 0x5d, 0x79, |
2666 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1655 | 0xc3, 0x93, 0x0c, 0x03, 0x32, 0x60, 0x7d, 0x61, 0x1c, 0x74, 0xf5, 0xcb, |
2667 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1656 | 0xa0, 0xa7, 0x02, 0xbf, 0xc0, 0xb6, 0x54, 0xf6, 0xe7, 0x75, 0x50, 0xb9, |
2668 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1657 | 0x27, 0x98, 0x3f, 0xd5, 0xf4, 0xfe, 0x4b, 0x34, 0x3f, 0xf0, 0xec, 0xbc, |
2669 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1658 | 0x11, 0xda, 0xb8, 0x42, 0x7f, 0xb2, 0xa8, 0x97, 0x35, 0xa1, 0x9b, 0xaa, |
2670 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1659 | 0xf7, 0xc3, 0xaf, 0x34, 0xd9, 0x3e, 0x76, 0xde, 0xc3, 0x97, 0xa5, 0x43, |
2671 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1660 | 0x5f, 0xf6, 0x3e, 0x78, 0xcf, 0xb1, 0xe7, 0xe8, 0x07, 0xeb, 0x49, 0x7e, |
2672 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1661 | 0x66, 0xd4, 0x09, 0x2a, 0x71, 0xbc, 0xd9, 0x21, 0xfa, 0xfe, 0xbb, 0x8f, |
2673 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1662 | 0x63, 0x41, 0x55, 0x36, 0xe3, 0x54, 0xed, 0xa1, 0xaa, 0x64, 0xb2, 0x1d, |
2674 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1663 | 0xb1, 0x6d, 0xb4, 0xf1, 0xde, 0x1e, 0xc6, 0xdd, 0x41, 0x89, 0x0c, 0x1e, |
2675 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1664 | 0x47, 0x8c, 0x68, 0x32, 0x0d, 0xef, 0x87, 0xf2, 0x60, 0x7f, 0x4a, 0xb1, |
2676 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1665 | 0x40, 0xdf, 0xf6, 0xc3, 0x5f, 0x32, 0x3f, 0x37, 0xeb, 0x0a, 0xfb, 0x51, |
2677 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1666 | 0xd2, 0x44, 0x83, 0xfd, 0x28, 0xa9, 0x92, 0x79, 0x50, 0xb0, 0x16, 0xbf, |
2678 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1667 | 0x26, 0x58, 0xe0, 0x9b, 0x05, 0xbe, 0x59, 0xe0, 0x9b, 0x0d, 0xbe, 0x15, |
2679 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1668 | 0x5c, 0xc6, 0x85, 0xf1, 0x08, 0xf6, 0x2f, 0x06, 0xfb, 0x03, 0xc7, 0x9d, |
2680 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1669 | 0x54, 0xf1, 0xed, 0x9b, 0x69, 0x85, 0x3f, 0xf6, 0x7d, 0xc1, 0xa8, 0x10, |
2681 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1670 | 0xf8, 0x02, 0xde, 0x6f, 0x1c, 0xeb, 0x1f, 0x47, 0x8c, 0xb3, 0x44, 0xd1, |
2682 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1671 | 0xb8, 0xc3, 0x8f, 0xfa, 0x26, 0x7e, 0x4c, 0x3b, 0xcc, 0x1f, 0x9e, 0xcf, |
2683 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1672 | 0x76, 0xec, 0x40, 0xe6, 0x6d, 0x9e, 0xec, 0x07, 0x0e, 0x9d, 0x4c, 0x77, |
2684 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1673 | 0x48, 0x07, 0xef, 0xdf, 0x1b, 0xee, 0x7f, 0x00, 0x7b, 0xb2, 0xdd, 0xde, |
2685 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1674 | 0xed, 0x5c, 0x3e, 0x93, 0xe3, 0xe8, 0x27, 0xd1, 0x83, 0x3c, 0x02, 0x7e, |
2686 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1675 | 0x66, 0x0d, 0x76, 0x76, 0x53, 0x4a, 0xd1, 0xeb, 0xbb, 0x6f, 0x20, 0xb7, |
2687 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1676 | 0xa0, 0xea, 0x03, 0xa6, 0xa7, 0xc9, 0xe6, 0xfb, 0x5e, 0x3d, 0x0f, 0xdf, |
2688 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1677 | 0x69, 0xea, 0x29, 0x5b, 0x1a, 0xa4, 0x37, 0xdc, 0x2c, 0xfd, 0x9d, 0x6b, |
2689 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1678 | 0xd0, 0xdf, 0xba, 0x1a, 0xbd, 0xea, 0xa6, 0xe9, 0x6f, 0xdc, 0x14, 0xfd, |
2690 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1679 | 0xb5, 0xdb, 0xce, 0x43, 0x92, 0xac, 0x47, 0x89, 0xa2, 0x7b, 0xb7, 0x5c, |
2691 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1680 | 0x08, 0x3a, 0x8e, 0xbd, 0xec, 0xbc, 0x5c, 0x96, 0x4d, 0x3f, 0x3f, 0x98, |
2692 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1681 | 0x98, 0x6e, 0x90, 0xb2, 0xd3, 0xa0, 0xed, 0xf7, 0x23, 0xef, 0x49, 0x9a, |
2693 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1682 | 0xb4, 0xe3, 0x3e, 0x3c, 0x7b, 0x4d, 0xb2, 0x7a, 0xcc, 0x53, 0x9e, 0x68, |
2694 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1683 | 0xb0, 0x1e, 0x75, 0x0f, 0x4f, 0xe5, 0xe3, 0x8c, 0xfb, 0xc4, 0x34, 0xfc, |
2695 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1684 | 0x91, 0x8d, 0xb3, 0xaa, 0xd0, 0xc5, 0xaa, 0x7b, 0xe8, 0xfe, 0x20, 0x17, |
2696 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1685 | 0x7a, 0x2f, 0xcc, 0x89, 0x38, 0xaf, 0x5a, 0x7f, 0x6a, 0xc2, 0x60, 0x3f, |
2697 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1686 | 0x2b, 0x6c, 0xf2, 0xb3, 0x24, 0x14, 0x41, 0x53, 0x1d, 0xb8, 0x16, 0x41, |
2698 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1687 | 0xe7, 0x57, 0x5d, 0x45, 0x28, 0x9c, 0xef, 0xa5, 0xe9, 0x45, 0x8e, 0x55, |
2699 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1688 | 0x3c, 0x4f, 0x09, 0x73, 0x19, 0x7e, 0xef, 0xc0, 0x3b, 0x21, 0x7e, 0x14, |
2700 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1689 | 0xb6, 0x53, 0x42, 0x7f, 0x73, 0x82, 0x9c, 0x30, 0x17, 0x89, 0xd1, 0x05, |
2701 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1690 | 0x5f, 0x77, 0xb8, 0xdf, 0x2a, 0xfd, 0xb0, 0xff, 0x4e, 0xff, 0xf9, 0x8d, |
2702 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1691 | 0xfe, 0x72, 0xe9, 0xeb, 0x1b, 0xfd, 0xef, 0xa8, 0x01, 0x4e, 0xc3, 0xc2, |
2703 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1692 | 0xe3, 0xee, 0xf3, 0x61, 0xdf, 0x6d, 0xf0, 0xd3, 0xf3, 0xea, 0x88, 0x27, |
2704 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1693 | 0x35, 0xe3, 0x36, 0x72, 0x1f, 0xf6, 0x29, 0x5b, 0xf1, 0x21, 0x1f, 0xf2, |
2705 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1694 | 0x1f, 0xaa, 0x2d, 0xb1, 0x9c, 0x14, 0x0a, 0xf6, 0xe4, 0xf1, 0x4e, 0xf8, |
2706 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1695 | 0x92, 0xdb, 0x68, 0x73, 0xec, 0x6a, 0xfb, 0x31, 0x9e, 0xc3, 0xeb, 0x6f, |
2707 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1696 | 0xdd, 0x43, 0x96, 0x2a, 0x64, 0xb9, 0x35, 0x79, 0xd5, 0x1a, 0xa7, 0x42, |
2708 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1697 | 0x9f, 0xd0, 0x3d, 0x6c, 0x43, 0x2e, 0x12, 0xe4, 0x52, 0x83, 0x5c, 0x0a, |
2709 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1698 | 0xf7, 0x94, 0x0b, 0xce, 0xd8, 0xd0, 0x29, 0xc6, 0xa3, 0x2b, 0x3c, 0x9b, |
2710 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1699 | 0x14, 0xd9, 0xac, 0x96, 0xea, 0xc6, 0xa7, 0x28, 0x66, 0x30, 0x1e, 0x06, |
2711 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1700 | 0xf0, 0x38, 0x8a, 0xb5, 0x1c, 0xc3, 0x48, 0x89, 0x99, 0x2c, 0xcf, 0xdc, |
2712 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1701 | 0x13, 0xb6, 0x71, 0xab, 0xb4, 0xe0, 0xdc, 0x2a, 0x5d, 0x34, 0xf8, 0xfd, |
2713 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1702 | 0xf6, 0x64, 0x90, 0x37, 0x77, 0x3f, 0x89, 0xbc, 0x19, 0xeb, 0xd9, 0x1f, |
2714 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1703 | 0x72, 0xff, 0x30, 0xe6, 0x71, 0x7c, 0xa0, 0x43, 0x35, 0xfc, 0xea, 0xfe, |
2715 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1704 | 0xdc, 0x6b, 0x4f, 0xf0, 0xdc, 0x4e, 0x53, 0x9e, 0xfc, 0x35, 0x9e, 0x1d, |
2716 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1705 | 0xa6, 0xf6, 0xe4, 0x4f, 0x0d, 0xde, 0x77, 0x78, 0xf2, 0xa2, 0xbf, 0x07, |
2717 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1706 | 0x62, 0xa6, 0xbf, 0x36, 0xfb, 0x24, 0xaf, 0x7d, 0x0e, 0x3e, 0xf6, 0x0c, |
2718 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1707 | 0xe2, 0xcb, 0x69, 0x47, 0x3b, 0x54, 0xc1, 0x6f, 0x8a, 0x71, 0x6a, 0xf2, |
2719 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1708 | 0xb8, 0x85, 0x71, 0x19, 0xb1, 0x90, 0xdb, 0x0a, 0x1d, 0xc3, 0xbc, 0xa7, |
2720 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1709 | 0x31, 0xef, 0xa8, 0x33, 0x8e, 0xbc, 0xbd, 0x4d, 0xd7, 0xbf, 0xc5, 0x0b, |
2721 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1710 | 0xf3, 0xec, 0xcf, 0x91, 0xed, 0xaf, 0xfc, 0x7b, 0xdc, 0x86, 0x5f, 0x16, |
2722 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1711 | 0x57, 0x6e, 0xc6, 0x0b, 0xa0, 0x5b, 0x5a, 0xf9, 0x45, 0xbc, 0x08, 0x3d, |
2723 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1712 | 0x13, 0x0d, 0x09, 0x7e, 0xf9, 0x33, 0x54, 0x53, 0x3d, 0x7a, 0x19, 0xf1, |
2724 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1713 | 0xab, 0x96, 0x85, 0xbf, 0x82, 0x34, 0x45, 0x03, 0x7e, 0x4c, 0x25, 0xa5, |
2725 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1714 | 0xcb, 0x3c, 0xa9, 0x52, 0x57, 0x3e, 0x6e, 0x23, 0xde, 0xd4, 0x54, 0x09, |
2726 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1715 | 0xfd, 0xfd, 0x78, 0x6e, 0xee, 0xff, 0x65, 0x1c, 0x7e, 0x0b, 0x3e, 0x82, |
2727 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1716 | 0x14, 0x3b, 0xdf, 0x8d, 0xfd, 0xbf, 0x8d, 0x7e, 0x4c, 0xc8, 0x6c, 0xf4, |
2728 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1717 | 0x3f, 0x1b, 0xf4, 0xdf, 0x02, 0x2e, 0xbc, 0x8e, 0xe3, 0x27, 0x29, 0x53, |
2729 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1718 | 0x79, 0x15, 0x38, 0xf0, 0xdc, 0xa4, 0x3f, 0xb7, 0x38, 0xcf, 0x3c, 0xa8, |
2730 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1719 | 0x96, 0x16, 0x8c, 0x34, 0x15, 0xe6, 0x92, 0x34, 0x3a, 0xa7, 0xd2, 0xd8, |
2731 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1720 | 0x9c, 0x3e, 0xd1, 0x62, 0xfb, 0x01, 0xcd, 0x84, 0x1c, 0x41, 0x5c, 0x21, |
2732 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1721 | 0x50, 0xac, 0xa7, 0x9e, 0xa6, 0xbe, 0xd4, 0x31, 0xfa, 0x6f, 0x0f, 0xb1, |
2733 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1722 | 0x08, 0x71, 0xa8, 0x9b, 0x64, 0x7f, 0x9f, 0x54, 0xfb, 0x4c, 0x96, 0xd1, |
2734 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1723 | 0x87, 0xce, 0x2d, 0xce, 0xdf, 0x6b, 0x5f, 0x28, 0xf1, 0x4a, 0xea, 0x23, |
2735 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1724 | 0xfb, 0xbe, 0x1b, 0xee, 0xab, 0x62, 0xdf, 0x34, 0xf6, 0x64, 0x1a, 0xf5, |
2736 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1725 | 0xf8, 0xc8, 0x79, 0xb2, 0x3a, 0x81, 0x5f, 0x31, 0x83, 0x98, 0x8f, 0x7d, |
2737 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1726 | 0xce, 0xcc, 0xb1, 0xde, 0xd3, 0x4e, 0xfc, 0x06, 0x63, 0x94, 0xc9, 0x2e, |
2738 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1727 | 0x23, 0x27, 0x18, 0xf1, 0xf7, 0x08, 0xf2, 0x05, 0x71, 0x65, 0x10, 0xf9, |
2739 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1728 | 0xda, 0x3b, 0xc0, 0x87, 0xe3, 0x18, 0xd3, 0x2c, 0x83, 0xde, 0x41, 0xe4, |
2740 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1729 | 0x09, 0x9c, 0xe3, 0x7b, 0xa7, 0xec, 0x1c, 0xda, 0xcb, 0x5a, 0xbc, 0x00, |
2741 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1730 | 0xdb, 0x16, 0x4d, 0x7a, 0x50, 0xf2, 0x7d, 0x2c, 0xcb, 0x65, 0x10, 0x72, |
2742 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1731 | 0x62, 0xbc, 0x73, 0x90, 0x13, 0xf3, 0x68, 0x38, 0x5e, 0x6c, 0x32, 0x8f, |
2743 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1732 | 0x08, 0xf8, 0x68, 0xb0, 0x27, 0xd9, 0xcf, 0xf3, 0xc5, 0x15, 0x0b, 0xf3, |
2744 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1733 | 0x7e, 0xac, 0x72, 0x2e, 0x66, 0x1b, 0xdc, 0x86, 0xed, 0xac, 0x8c, 0x63, |
2745 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1734 | 0x2e, 0xb7, 0x1f, 0xc6, 0xbe, 0x7d, 0xb9, 0x1a, 0x75, 0xe4, 0x9e, 0x86, |
2746 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1735 | 0xdd, 0x8a, 0xf9, 0x01, 0xc4, 0x68, 0x01, 0xb9, 0xa0, 0xe7, 0x75, 0xe4, |
2747 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1736 | 0xbf, 0x00, 0x7a, 0x98, 0x0e, 0xe8, 0xf5, 0x2c, 0xf3, 0x95, 0xfe, 0x40, |
2748 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1737 | 0xe4, 0x5c, 0x2d, 0xdf, 0xce, 0x6b, 0x38, 0x9e, 0xf3, 0xf9, 0x88, 0x23, |
2749 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1738 | 0x8d, 0x3d, 0x88, 0xa5, 0xfe, 0xd9, 0xd0, 0xb1, 0x71, 0x2a, 0x34, 0x3e, |
2750 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1739 | 0x8b, 0x9c, 0x93, 0x6d, 0x67, 0x9b, 0x60, 0x9f, 0x67, 0x1a, 0x09, 0xb1, |
2751 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1740 | 0x66, 0x8d, 0x2a, 0x0d, 0x39, 0x6c, 0xbf, 0x8a, 0xb6, 0x12, 0xb6, 0xd7, |
2752 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1741 | 0xd1, 0xee, 0x0e, 0xdb, 0xd7, 0xd0, 0x56, 0xc3, 0xf6, 0xcf, 0xd0, 0x4e, |
2753 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1742 | 0x86, 0xed, 0x9f, 0xa3, 0x9d, 0x0a, 0xdb, 0x37, 0xd1, 0x4e, 0x87, 0xed, |
2754 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1743 | 0x5b, 0x68, 0x6b, 0x61, 0xfb, 0x3d, 0xb4, 0x13, 0xb0, 0x73, 0x03, 0xef, |
2755 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1744 | 0x37, 0x50, 0x2b, 0x66, 0xf1, 0xfc, 0x57, 0xe0, 0x36, 0x08, 0xde, 0x64, |
2756 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1745 | 0xc1, 0x8f, 0x5e, 0x8c, 0xe5, 0xd0, 0x87, 0x1c, 0xb1, 0x91, 0xc7, 0xd3, |
2757 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1746 | 0xc1, 0x18, 0x95, 0x61, 0x7b, 0x18, 0x1f, 0x2f, 0x16, 0x1a, 0x26, 0x9e, |
2758 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1747 | 0x6c, 0x0f, 0xba, 0x4a, 0xc2, 0x65, 0xd8, 0xb9, 0xef, 0x63, 0x72, 0xb6, |
2759 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1748 | 0x34, 0x09, 0xdb, 0x9e, 0xa0, 0x7f, 0x74, 0xf7, 0xd3, 0x6b, 0xee, 0x38, |
2760 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1749 | 0xe2, 0x46, 0x11, 0x71, 0xc3, 0x42, 0xdc, 0x30, 0x11, 0x37, 0x86, 0x11, |
2761 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1750 | 0x37, 0xf2, 0x88, 0x1b, 0x39, 0xc4, 0x0d, 0xa2, 0x33, 0x7e, 0x8c, 0x4a, |
2762 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1751 | 0x2a, 0xa8, 0x51, 0x15, 0xcb, 0x2d, 0x82, 0xbf, 0x13, 0x90, 0xcd, 0x24, |
2763 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1752 | 0x78, 0x7d, 0x38, 0x3e, 0xd2, 0xcc, 0xc3, 0x9f, 0x69, 0xf0, 0x11, 0x69, |
2764 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1753 | 0xf8, 0xf2, 0x1c, 0x6a, 0x13, 0xa2, 0x2b, 0xb3, 0x1a, 0xfc, 0x8f, 0x47, |
2765 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1754 | 0x45, 0xc4, 0xfe, 0x69, 0x15, 0xb8, 0x19, 0xbb, 0x7c, 0x9b, 0x91, 0xcc, |
2766 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1755 | 0x2f, 0xf6, 0x50, 0xd7, 0x20, 0xe8, 0x39, 0x8b, 0xbe, 0x14, 0xf6, 0x63, |
2767 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1756 | 0xbe, 0xde, 0x2a, 0xd9, 0x86, 0x46, 0x0b, 0x6e, 0x1c, 0xfe, 0x9f, 0xdf, |
2768 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1757 | 0xe3, 0xcc, 0xe3, 0x43, 0x4f, 0x19, 0x4c, 0x03, 0xea, 0x3c, 0x23, 0xad, |
2769 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1758 | 0x14, 0x1c, 0x81, 0x24, 0x93, 0x9f, 0xed, 0x1c, 0xe2, 0xcf, 0x90, 0x43, |
2770 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1759 | 0x74, 0x41, 0x06, 0x55, 0xc4, 0x05, 0x9d, 0xf3, 0x0b, 0xe8, 0xf2, 0x27, |
2771 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1760 | 0xcd, 0xff, 0x1e, 0xe6, 0xef, 0xc5, 0xd9, 0x3c, 0x8f, 0xcf, 0x39, 0x85, |
2772 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1761 | 0xfa, 0xc1, 0xea, 0x91, 0x68, 0x3d, 0x25, 0xa1, 0x9e, 0x28, 0xd0, 0x59, |
2773 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1762 | 0x2a, 0x00, 0x9f, 0x82, 0xdb, 0xbe, 0x07, 0xb0, 0x0e, 0x05, 0xfe, 0x6c, |
2774 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1763 | 0xe2, 0xd0, 0xb7, 0x0d, 0x0b, 0xeb, 0x18, 0x3f, 0xd6, 0x5b, 0xe0, 0xbe, |
2775 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1764 | 0xb1, 0xe7, 0x05, 0xec, 0xf9, 0x4f, 0x49, 0xea, 0x9a, 0x0c, 0xfc, 0x91, |
2776 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1765 | 0x5f, 0xf3, 0xca, 0xc2, 0x48, 0xf3, 0x2c, 0xf8, 0xd3, 0x87, 0x1a, 0x05, |
2777 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1766 | 0x7e, 0xa4, 0xd4, 0x02, 0x9f, 0xda, 0xf3, 0x5f, 0xc1, 0x7c, 0x7e, 0xf7, |
2778 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1767 | 0xef, 0x0e, 0x4a, 0xd2, 0xea, 0x12, 0xe6, 0x69, 0xac, 0x3f, 0x25, 0xb9, |
2779 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1768 | 0xff, 0x86, 0xf7, 0xa2, 0x91, 0xa7, 0x5d, 0xab, 0xbc, 0x2e, 0x4b, 0x7d, |
2780 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1769 | 0xab, 0x37, 0xbc, 0x9a, 0xa3, 0xd1, 0x62, 0x93, 0xc0, 0xab, 0xf8, 0x6d, |
2781 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1770 | 0x8b, 0xf4, 0x35, 0x12, 0xf5, 0x59, 0x0b, 0x7a, 0x5a, 0x1c, 0x12, 0xc9, |
2782 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1771 | 0x1e, 0xea, 0x84, 0x8f, 0x32, 0x68, 0x09, 0x7c, 0xdf, 0x35, 0x63, 0xd1, |
2783 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1772 | 0x13, 0x43, 0xed, 0x7c, 0x10, 0x51, 0x0f, 0xb8, 0xee, 0x5a, 0xd5, 0x30, |
2784 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1773 | 0x87, 0x73, 0x71, 0xa6, 0x45, 0x03, 0x2f, 0x85, 0x60, 0x8d, 0x1f, 0xb3, |
2785 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1774 | 0xb8, 0x8e, 0x05, 0xdf, 0xdc, 0xb5, 0xd2, 0xd5, 0x19, 0xd4, 0x1a, 0x90, |
2786 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1775 | 0xf3, 0xae, 0x19, 0xae, 0x85, 0xb6, 0x81, 0x2f, 0x31, 0xd8, 0x06, 0xe7, |
2787 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1776 | 0xf1, 0x08, 0xf4, 0xf0, 0x87, 0x27, 0xe0, 0xf1, 0x6b, 0xcd, 0x13, 0xd0, |
2788 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1777 | 0xfb, 0x2e, 0x2a, 0xcb, 0x3e, 0x11, 0x9f, 0xc0, 0xe3, 0xff, 0xe4, 0xbc, |
2789 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1778 | 0x0e, 0xf3, 0xbf, 0x4b, 0xc5, 0xd9, 0x2e, 0xec, 0xb5, 0x9b, 0xa6, 0x93, |
2790 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1779 | 0x8c, 0x9b, 0x3e, 0x8c, 0x41, 0x2d, 0x06, 0x7e, 0xc6, 0xcd, 0x8f, 0xe6, |
2791 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1780 | 0x7d, 0x6b, 0xa5, 0x2b, 0x33, 0x6b, 0xa5, 0x6b, 0xa0, 0xbf, 0x6e, 0x70, |
2792 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1781 | 0x8d, 0x0c, 0x5d, 0x6a, 0x70, 0x6d, 0xcf, 0x79, 0xd1, 0x18, 0x74, 0x64, |
2793 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1782 | 0xbf, 0x5f, 0x33, 0xdb, 0x8b, 0x39, 0xea, 0x3b, 0x47, 0xaa, 0x68, 0x96, |
2794 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1783 | 0x84, 0x31, 0xe4, 0x45, 0x23, 0xee, 0x49, 0x7f, 0xee, 0x99, 0x06, 0xd7, |
2795 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1784 | 0x2b, 0x18, 0x5b, 0x61, 0x5d, 0x18, 0x03, 0x3e, 0x49, 0xba, 0xe8, 0xb2, |
2796 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1785 | 0x4f, 0x0a, 0xec, 0x78, 0x0c, 0xfc, 0x5a, 0xf0, 0xe9, 0x4a, 0x71, 0x1c, |
2797 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1786 | 0x47, 0xbe, 0xc1, 0xf2, 0xf9, 0x21, 0xc7, 0x41, 0xa1, 0xd3, 0x6c, 0xfb, |
2798 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1787 | 0xdb, 0x89, 0x5e, 0xe6, 0x59, 0xa1, 0x01, 0xdf, 0x3f, 0x34, 0x11, 0xe6, |
2799 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1788 | 0x1c, 0x7f, 0x8f, 0x39, 0x8c, 0x3b, 0xcd, 0x4a, 0x26, 0xce, 0xc8, 0x33, |
2800 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1789 | 0xcf, 0x38, 0xa7, 0xe4, 0x7d, 0xc1, 0x5b, 0xf0, 0x7d, 0x53, 0x6e, 0xe9, |
2801 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1790 | 0xc3, 0x74, 0x33, 0x46, 0x95, 0x59, 0xf0, 0x2e, 0x8f, 0x27, 0x9c, 0x6b, |
2802 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1791 | 0x1d, 0x7c, 0x03, 0x2d, 0xd5, 0x20, 0x9f, 0x3d, 0xc1, 0x31, 0x0d, 0xfe, |
2803 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1792 | 0x06, 0x36, 0xcd, 0x31, 0x6b, 0xe3, 0xde, 0xc9, 0xf7, 0x25, 0x32, 0x19, |
2804 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1793 | 0x41, 0xce, 0x2a, 0xe2, 0x2c, 0x3b, 0xcf, 0x7e, 0x10, 0xf8, 0xb8, 0xdf, |
2805 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1794 | 0xa5, 0xfa, 0x2c, 0xd3, 0x05, 0x1b, 0x4f, 0xb2, 0x2e, 0xfe, 0x7f, 0xf9, |
2806 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1795 | 0x38, 0xba, 0x45, 0x3e, 0x8e, 0x6e, 0x99, 0x8f, 0x12, 0xf8, 0x58, 0xd9, |
2807 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1796 | 0xe0, 0xa3, 0x82, 0x3d, 0xf8, 0x3e, 0xe1, 0xab, 0x64, 0x4d, 0x3c, 0x02, |
2808 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1797 | 0x3f, 0x0c, 0xff, 0xd1, 0x3c, 0x05, 0x9f, 0x70, 0x52, 0xb8, 0xda, 0xf0, |
2809 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1798 | 0x68, 0x1c, 0xb5, 0xb2, 0x74, 0xff, 0x66, 0xfa, 0x33, 0xa0, 0xff, 0xcf, |
2810 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1799 | 0x31, 0x5e, 0xa5, 0x6b, 0xb3, 0x94, 0x56, 0xa8, 0x7d, 0x2e, 0xed, 0x92, |
2811 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1800 | 0xe9, 0x3b, 0x74, 0x75, 0xb6, 0x8b, 0xae, 0xcf, 0x66, 0xc0, 0xeb, 0x2c, |
2812 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1801 | 0xc5, 0x7a, 0x32, 0xc3, 0x15, 0x18, 0xf1, 0xcf, 0x5a, 0xba, 0xc5, 0xba, |
2813 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1802 | 0xf8, 0xfb, 0xf3, 0x82, 0xf9, 0x70, 0xd0, 0xe7, 0xc3, 0xd8, 0x47, 0xf8, |
2814 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1803 | 0x30, 0x7e, 0x4f, 0x3e, 0x1c, 0xfc, 0x18, 0x1f, 0xc6, 0x3f, 0xc6, 0x07, |
2815 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1804 | 0xe6, 0x01, 0xf3, 0xe2, 0xd1, 0xde, 0xf0, 0xff, 0x1f, 0x7d, 0x82, 0x7d, |
2816 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1805 | 0x7c, 0x09, 0x74, 0x22, 0xa7, 0xd8, 0x19, 0xe4, 0x50, 0x9c, 0x63, 0xd5, |
2817 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1806 | 0x0c, 0xe6, 0x57, 0x60, 0xbf, 0x32, 0x72, 0xea, 0x23, 0xa1, 0xfd, 0x16, |
2818 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1807 | 0x1c, 0xe8, 0x65, 0x23, 0xe6, 0xdb, 0xaf, 0x64, 0xe6, 0xe1, 0x03, 0xaa, |
2819 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1808 | 0xa5, 0x96, 0xc3, 0xfe, 0x07, 0x6d, 0x87, 0x79, 0xda, 0x0b, 0x5a, 0x12, |
2820 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1809 | 0x54, 0x99, 0x54, 0x10, 0x5f, 0x87, 0xa1, 0xb7, 0x71, 0xdf, 0x07, 0x4a, |
2821 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1810 | 0x26, 0xeb, 0xe1, 0x7e, 0xcc, 0x3f, 0x1c, 0xe6, 0x45, 0x88, 0x73, 0x38, |
2822 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1811 | 0xa3, 0xd6, 0x38, 0x0d, 0xfc, 0xf8, 0x9c, 0x6a, 0xa9, 0xec, 0xf0, 0x9a, |
2823 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1812 | 0x34, 0x62, 0x21, 0x3f, 0x37, 0xeb, 0xb7, 0xaf, 0xef, 0xf7, 0xd2, 0x71, |
2824 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1813 | 0xe8, 0x26, 0xeb, 0xb4, 0x82, 0xdc, 0x78, 0x02, 0xf1, 0xc5, 0xd7, 0xd3, |
2825 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1814 | 0xec, 0x02, 0xb1, 0xdf, 0x7f, 0x06, 0x75, 0xd1, 0x61, 0xfc, 0x34, 0x1a, |
2826 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1815 | 0x71, 0x03, 0x9b, 0x5a, 0xf2, 0xcf, 0xfc, 0xb0, 0x4f, 0xaa, 0x39, 0xeb, |
2827 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1816 | 0xc8, 0xdf, 0x0d, 0xec, 0xcb, 0xe7, 0x56, 0xc1, 0x1b, 0x09, 0xe7, 0x72, |
2828 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1817 | 0x5f, 0x37, 0xe2, 0x00, 0xf8, 0xe4, 0xfe, 0x07, 0xfa, 0x97, 0xe0, 0x1f, |
2829 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1818 | 0x39, 0x2f, 0x68, 0xe3, 0x8e, 0x1c, 0xc2, 0xe1, 0x78, 0x9d, 0x07, 0xcd, |
2830 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1819 | 0x9c, 0x63, 0x73, 0x2e, 0x81, 0xfc, 0x63, 0xe9, 0x4d, 0xf4, 0x0d, 0xd3, |
2831 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1820 | 0xe9, 0xa1, 0x2c, 0xe4, 0xc3, 0x7d, 0x0f, 0x84, 0x7d, 0x3c, 0x8f, 0x94, |
2832 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1821 | 0x07, 0x4d, 0xfd, 0x07, 0x55, 0xdf, 0xaf, 0x43, 0x0f, 0x51, 0xf7, 0xd5, |
2833 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1822 | 0x96, 0x90, 0x63, 0x00, 0xa7, 0xca, 0x6a, 0x16, 0xb9, 0x3c, 0xdf, 0xab, |
2834 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1823 | 0xe9, 0x97, 0x91, 0x07, 0x83, 0x27, 0x0a, 0xf5, 0x1a, 0xa5, 0xd0, 0x0f, |
2835 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1824 | 0xe7, 0x40, 0x1f, 0xdf, 0x3d, 0xf5, 0x21, 0xf7, 0x91, 0xc0, 0x08, 0xd8, |
2836 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1825 | 0xe9, 0xaa, 0x44, 0x7b, 0xe5, 0x01, 0xb5, 0x46, 0xff, 0x80, 0xb9, 0x32, |
2837 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1826 | 0x95, 0x57, 0x39, 0x87, 0x90, 0xe9, 0xc8, 0x2a, 0xd1, 0x5b, 0x33, 0xec, |
2838 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1827 | 0x97, 0x19, 0xd8, 0x2f, 0xb3, 0x7f, 0x7d, 0xd0, 0x1f, 0x7b, 0x6b, 0x06, |
2839 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1828 | 0x35, 0xf8, 0xcc, 0x00, 0xc7, 0xb0, 0x75, 0x11, 0xbc, 0x44, 0xee, 0xc3, |
2840 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1829 | 0xf9, 0xf9, 0x5d, 0xee, 0x98, 0xda, 0xf7, 0x4b, 0x0a, 0x55, 0x66, 0xf8, |
2841 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1830 | 0x6e, 0x49, 0xc6, 0xf9, 0x5c, 0x5b, 0x6c, 0x03, 0x7e, 0x02, 0xa1, 0xee, |
2842 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1831 | 0x12, 0x38, 0xa6, 0x09, 0xd0, 0xa1, 0x5d, 0x90, 0x3d, 0xf8, 0x1f, 0xb6, |
2843 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1832 | 0xdb, 0xfa, 0xf4, 0x2f, 0xd0, 0x27, 0x9e, 0x27, 0x6f, 0xc2, 0x25, 0x33, |
2844 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1833 | 0x6b, 0x8b, 0x1c, 0x1f, 0x3e, 0x0d, 0xdb, 0xb3, 0xe2, 0x63, 0xcd, 0x0e, |
2845 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1834 | 0x6a, 0xf5, 0xb2, 0x3d, 0xb0, 0x5e, 0x5c, 0x66, 0x9d, 0xc0, 0x19, 0xd0, |
2846 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1835 | 0xa1, 0x19, 0xae, 0xe7, 0x65, 0xcc, 0xbb, 0x2f, 0x9c, 0xc7, 0xfc, 0xfe, |
2847 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1836 | 0x1e, 0x4d, 0x0f, 0xa9, 0x42, 0x59, 0x0d, 0xe2, 0x45, 0x6d, 0xa8, 0x03, |
2848 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1837 | 0x63, 0x22, 0x1d, 0x7c, 0x38, 0x8f, 0xb5, 0x9c, 0x53, 0xc5, 0x85, 0xc0, |
2849 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1838 | 0x6f, 0x71, 0x1f, 0xdf, 0xd7, 0xa9, 0x54, 0xbe, 0xd4, 0x4b, 0x95, 0x4b, |
2850 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1839 | 0x0a, 0xf8, 0x02, 0x44, 0x17, 0x82, 0x7d, 0xd8, 0x17, 0x1c, 0x87, 0xdc, |
2851 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1840 | 0xc4, 0x73, 0x0a, 0xc5, 0xce, 0x21, 0x87, 0xbc, 0xd0, 0x45, 0x1d, 0x17, |
2852 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1841 | 0xfa, 0x49, 0xba, 0xa0, 0x73, 0x7e, 0xa8, 0x9d, 0x81, 0x0c, 0x8f, 0x50, |
2853 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1842 | 0x9e, 0x9e, 0x73, 0x07, 0x39, 0xc7, 0xc3, 0x39, 0x5c, 0xe7, 0x25, 0x49, |
2854 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1843 | 0x42, 0xf2, 0x2f, 0xbe, 0x68, 0xd1, 0x8b, 0x43, 0xc0, 0x2b, 0x8f, 0xf6, |
2855 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1844 | 0x8f, 0x91, 0xc7, 0xbb, 0x23, 0xf7, 0x71, 0xcc, 0x96, 0xcd, 0x3e, 0xc8, |
2856 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1845 | 0x16, 0x74, 0xe5, 0x1e, 0xf2, 0xef, 0x44, 0x5f, 0x1c, 0x62, 0x7a, 0x34, |
2857 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1846 | 0xd0, 0x52, 0x87, 0xae, 0xf3, 0x3d, 0x57, 0x17, 0xd9, 0x32, 0xeb, 0x32, |
2858 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1847 | 0xf2, 0xaa, 0x0b, 0x75, 0x9a, 0x6a, 0xe8, 0x90, 0x59, 0x1f, 0xf4, 0x02, |
2859 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1848 | 0x32, 0x4b, 0x73, 0x3f, 0xef, 0x2d, 0x84, 0xfb, 0xde, 0xd1, 0xf7, 0x17, |
2860 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1849 | 0xef, 0xad, 0xef, 0x3e, 0xd4, 0x9b, 0x8f, 0xc0, 0x67, 0xa3, 0x2e, 0x32, |
2861 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1850 | 0xe0, 0xd3, 0x55, 0xe4, 0x72, 0x06, 0xbf, 0x07, 0x77, 0x95, 0x15, 0xe4, |
2862 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1851 | 0x85, 0xfc, 0x5e, 0x6b, 0xdd, 0xcd, 0x77, 0x07, 0xf6, 0x7d, 0x06, 0x3c, |
2863 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1852 | 0xba, 0x32, 0xf7, 0x00, 0x5d, 0x9d, 0x53, 0xe8, 0x5a, 0x43, 0xcf, 0x16, |
2864 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1853 | 0xa8, 0x83, 0xaa, 0xc9, 0x34, 0x5d, 0x5f, 0x6a, 0xe7, 0x93, 0x22, 0xf4, |
2865 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1854 | 0xc4, 0x22, 0xce, 0xcd, 0xaf, 0x2c, 0x55, 0x4b, 0x37, 0x76, 0xa7, 0x49, |
2866 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1855 | 0x7e, 0x09, 0xb6, 0xfd, 0x92, 0xae, 0xd5, 0xc0, 0xe7, 0xba, 0xe1, 0xa2, |
2867 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1856 | 0x56, 0xe3, 0x3a, 0x32, 0x05, 0xbb, 0xd3, 0x53, 0x2d, 0xca, 0x90, 0xb4, |
2868 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1857 | 0xa0, 0xd0, 0xaf, 0x66, 0x74, 0x8d, 0x75, 0xee, 0xa2, 0x81, 0x7e, 0x37, |
2869 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1858 | 0x7e, 0x7b, 0x3d, 0xd0, 0x43, 0xf4, 0xf5, 0xa3, 0xbe, 0xd5, 0xb3, 0x9a, |
2870 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1859 | 0xd8, 0x4d, 0x6f, 0x43, 0x27, 0xca, 0x7e, 0xdf, 0x47, 0xf7, 0xbc, 0x1e, |
2871 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1860 | 0xee, 0x59, 0x2d, 0x5d, 0xe1, 0x3a, 0x68, 0x86, 0x75, 0xbe, 0x17, 0xfe, |
2872 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1861 | 0x03, 0xef, 0x6e, 0x07, 0x95, 0x27, 0x11, 0xa3, 0x66, 0x1e, 0xa5, 0xc2, |
2873 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1862 | 0x90, 0x18, 0xd0, 0xed, 0xf3, 0x82, 0xfb, 0xf8, 0x7e, 0xb2, 0x76, 0x1f, |
2874 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1863 | 0xdb, 0xb2, 0xb8, 0x0a, 0xbd, 0x3a, 0xc8, 0x7a, 0x80, 0xdc, 0x0e, 0x39, |
2875 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1864 | 0x04, 0xfb, 0x4e, 0x09, 0x39, 0x44, 0xc1, 0x0d, 0x74, 0xa3, 0x75, 0x30, |
2876 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1865 | 0x49, 0xc7, 0x5e, 0x62, 0x19, 0x61, 0x6c, 0x43, 0xef, 0x36, 0xee, 0xc4, |
2877 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1866 | 0x31, 0x66, 0xd0, 0xf1, 0xef, 0xb7, 0x73, 0x4a, 0xb6, 0xbd, 0x34, 0xe4, |
2878 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1867 | 0xa1, 0xa3, 0xf6, 0xe8, 0x53, 0x2b, 0xbe, 0x4f, 0x81, 0x4e, 0xa4, 0x02, |
2879 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1868 | 0x19, 0xd4, 0x30, 0x36, 0xed, 0x4e, 0xc2, 0x27, 0xc6, 0xe8, 0xe6, 0xa4, |
2880 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1869 | 0x05, 0x9d, 0x68, 0x01, 0x87, 0xc3, 0x71, 0xbe, 0x4b, 0xb8, 0x39, 0x59, |
2881 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1870 | 0xc4, 0xfb, 0x61, 0x3f, 0xf7, 0x97, 0xf6, 0x40, 0x97, 0xdc, 0x07, 0xc2, |
2882 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1871 | 0xfc, 0x9c, 0xcf, 0xd3, 0x84, 0xda, 0xac, 0x2e, 0x4c, 0xcf, 0x7a, 0x34, |
2883 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1872 | 0x9a, 0xeb, 0x4b, 0x5d, 0xa5, 0x4e, 0xff, 0xce, 0xd8, 0xf7, 0x9b, 0xfe, |
2884 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1873 | 0x9c, 0x5d, 0x18, 0xff, 0x00, 0x3a, 0x85, 0x27, 0xe2, 0xf5, 0xe9, 0x66, |
2885 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1874 | 0x35, 0xd5, 0x41, 0xac, 0x53, 0x24, 0x2c, 0x18, 0xec, 0x3b, 0x04, 0xba, |
2886 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1875 | 0xea, 0xdf, 0x47, 0x13, 0x15, 0x9d, 0xd7, 0x99, 0x6e, 0x61, 0xb1, 0xc5, |
2887 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1876 | 0x6b, 0x58, 0xce, 0xbc, 0x46, 0xa2, 0x9b, 0x49, 0xd8, 0xe5, 0x9e, 0x3d, |
2888 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1877 | 0x7e, 0xbd, 0xf8, 0xf8, 0x10, 0xe3, 0xda, 0x0d, 0x99, 0x42, 0xbf, 0x50, |
2889 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1878 | 0xdb, 0x94, 0x83, 0xbe, 0x59, 0xae, 0x4d, 0xa7, 0xf9, 0xde, 0x23, 0xef, |
2890 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1879 | 0xeb, 0x5a, 0xa8, 0x1f, 0x1f, 0xd7, 0xb5, 0xe7, 0xb0, 0xf6, 0x2d, 0xf6, |
2891 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1880 | 0xab, 0x90, 0x75, 0xe0, 0x23, 0xbe, 0x41, 0x6f, 0xcd, 0x55, 0xb3, 0xfc, |
2892 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1881 | 0xcd, 0xa3, 0x35, 0x21, 0xa0, 0x16, 0x3f, 0x4e, 0x6f, 0xcf, 0x3d, 0x4b, |
2893 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1882 | 0xbf, 0x9c, 0x65, 0xdd, 0x31, 0x68, 0x14, 0xfa, 0x74, 0x94, 0xe4, 0xec, |
2894 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1883 | 0x69, 0x1a, 0x50, 0xaf, 0xfb, 0xb5, 0x8d, 0x9e, 0xf3, 0x6b, 0x3a, 0x33, |
2895 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1884 | 0x4b, 0xc5, 0xc6, 0x40, 0xea, 0x1a, 0xfa, 0xca, 0x93, 0xba, 0xb6, 0x8e, |
2896 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1885 | 0xdc, 0xa3, 0xd0, 0xfc, 0x80, 0xef, 0x6c, 0xb2, 0x35, 0xd8, 0xde, 0x22, |
2897 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1886 | 0x6a, 0x9b, 0xb7, 0x9d, 0xbb, 0xe9, 0x2c, 0xd7, 0x56, 0x81, 0xff, 0x5e, |
2898 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1887 | 0x33, 0x50, 0x63, 0xac, 0xaa, 0xa1, 0x0e, 0x31, 0x70, 0x9d, 0xc1, 0xf1, |
2899 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1888 | 0x07, 0x4f, 0x37, 0x06, 0x9f, 0xb2, 0x1f, 0x7c, 0x67, 0xd9, 0x42, 0xfe, |
2900 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1889 | 0xab, 0xfc, 0x8d, 0x0a, 0xf2, 0x5f, 0x5d, 0xfe, 0x40, 0xeb, 0x65, 0x3f, |
2901 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1890 | 0x6b, 0x80, 0x96, 0x41, 0x3a, 0x33, 0xcf, 0xf2, 0x47, 0xec, 0xf5, 0xed, |
2902 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1891 | 0x34, 0x0d, 0xfe, 0x72, 0x7c, 0x19, 0xa4, 0x5f, 0x2d, 0x15, 0xfd, 0xfb, |
2903 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1892 | 0x6b, 0x1b, 0xb9, 0xd6, 0x11, 0x67, 0x12, 0xf5, 0xfa, 0x77, 0x40, 0x2f, |
2904 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1893 | 0xce, 0x1e, 0xda, 0x8d, 0xa7, 0x0a, 0x9b, 0xdc, 0x72, 0x9e, 0x23, 0x07, |
2905 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1894 | 0x79, 0xce, 0xde, 0x2d, 0xe6, 0x39, 0x7b, 0xb7, 0x92, 0xe7, 0xc8, 0x9d, |
2906 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1895 | 0xe0, 0xab, 0xd6, 0xbb, 0x65, 0xdc, 0xa4, 0x00, 0xb7, 0x03, 0x5b, 0xc4, |
2907 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1896 | 0xed, 0xc0, 0x56, 0x70, 0x93, 0x3a, 0xcd, 0xbf, 0x40, 0x8c, 0x35, 0x10, |
2908 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1897 | 0xdb, 0xe0, 0xd7, 0x86, 0xfa, 0x59, 0x7f, 0x80, 0xa3, 0x8f, 0xeb, 0xef, |
2909 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1898 | 0x8b, 0xa7, 0x18, 0xe0, 0xf9, 0xd8, 0x16, 0xf1, 0x7c, 0x6c, 0x2b, 0x78, |
2910 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1899 | 0x8a, 0x9d, 0x26, 0xe3, 0x28, 0xc3, 0xd7, 0x70, 0x6d, 0x83, 0xd8, 0x3c, |
2911 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1900 | 0x24, 0x87, 0xba, 0x2e, 0x87, 0x75, 0x0e, 0x03, 0x7c, 0x50, 0xaf, 0x46, |
2912 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1901 | 0x4b, 0x4c, 0xcb, 0x46, 0xdf, 0x9d, 0x3a, 0x4b, 0x32, 0x5b, 0xa5, 0x4a, |
2913 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1902 | 0x83, 0xef, 0x95, 0xfb, 0xb0, 0x0f, 0xf7, 0xf1, 0x37, 0x2a, 0x8b, 0x64, |
2914 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1903 | 0xc4, 0xf7, 0xe7, 0x9a, 0x77, 0xa7, 0xf5, 0x2a, 0x68, 0x9d, 0x0a, 0x69, |
2915 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1904 | 0xad, 0xf8, 0xb9, 0xe0, 0xbe, 0x4d, 0xb9, 0x60, 0x40, 0xe3, 0x08, 0x68, |
2916 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1905 | 0x2c, 0x86, 0x34, 0x3e, 0xdd, 0x60, 0xda, 0xf6, 0xf9, 0xb4, 0x2d, 0x6d, |
2917 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1906 | 0xa2, 0x6d, 0xe4, 0x9e, 0xf9, 0x1f, 0xe3, 0x81, 0x5a, 0x1a, 0xb9, 0xd7, |
2918 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1907 | 0x6b, 0x4d, 0xd4, 0xd2, 0x4d, 0xd4, 0xd2, 0xd0, 0xf7, 0x57, 0x9b, 0xa8, |
2919 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1908 | 0xa5, 0x9b, 0xa8, 0xa5, 0x61, 0x07, 0xaf, 0xc0, 0x56, 0x82, 0x3b, 0xdc, |
2920 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1909 | 0x12, 0x71, 0x0d, 0xee, 0xd7, 0xe3, 0x14, 0xe4, 0x39, 0x05, 0xc4, 0xf0, |
2921 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1910 | 0xa3, 0xc8, 0xf1, 0xd8, 0x6e, 0x4f, 0x13, 0xc7, 0x04, 0x3d, 0x87, 0x9a, |
2922 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1911 | 0x2f, 0x5b, 0x25, 0x33, 0x5e, 0x9c, 0x1f, 0x50, 0x97, 0x02, 0xfb, 0xd6, |
2923 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1912 | 0x5a, 0xc4, 0x71, 0x70, 0x20, 0x85, 0x08, 0xa9, 0xb2, 0x5f, 0xb0, 0x73, |
2924 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1913 | 0x4c, 0xe7, 0x76, 0xf0, 0x10, 0xbe, 0xdb, 0x60, 0x1f, 0xc6, 0xbe, 0xb4, |
2925 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1914 | 0x4e, 0x0b, 0x8d, 0xf0, 0x1b, 0x9a, 0xcc, 0xfd, 0xfc, 0xce, 0x31, 0xb7, |
2926 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1915 | 0xcf, 0xf7, 0x69, 0x76, 0xb6, 0x0f, 0x71, 0x80, 0xfb, 0x15, 0xf8, 0x35, |
2927 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1916 | 0xe8, 0xca, 0x52, 0x1b, 0x17, 0x19, 0xeb, 0x55, 0xaa, 0xcf, 0x07, 0x31, |
2928 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1917 | 0x7c, 0xca, 0xe0, 0x38, 0x87, 0xf8, 0xbe, 0xc4, 0xdf, 0xb0, 0x10, 0xeb, |
2929 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1918 | 0x97, 0xae, 0x68, 0x32, 0x6a, 0xc7, 0x3a, 0x7f, 0xa3, 0x1d, 0xec, 0xc3, |
2930 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1919 | 0xf9, 0x1d, 0xfe, 0x1d, 0xed, 0x51, 0xff, 0xae, 0xcd, 0xa0, 0x23, 0xad, |
2931 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1920 | 0x80, 0x16, 0xdb, 0xc8, 0xd0, 0xc8, 0x2c, 0xdf, 0x35, 0x51, 0x8f, 0x68, |
2932 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1921 | 0xca, 0x54, 0x75, 0xf8, 0x7e, 0x68, 0xe3, 0xbb, 0x49, 0x76, 0x91, 0xeb, |
2933 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1922 | 0x4f, 0x23, 0xb8, 0xff, 0x3c, 0xed, 0xbc, 0xc9, 0xf7, 0x9f, 0xe1, 0x3a, |
2934 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1923 | 0x8d, 0xde, 0x70, 0x33, 0x34, 0x8e, 0xf8, 0x5a, 0x6c, 0x68, 0xf0, 0x6f, |
2935 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1924 | 0xbe, 0x3c, 0x39, 0xa7, 0xad, 0xc6, 0x42, 0x99, 0x8e, 0x84, 0x32, 0xad, |
2936 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1925 | 0x34, 0xd6, 0x80, 0xdf, 0x0d, 0xef, 0x8f, 0x43, 0x99, 0xee, 0x3a, 0x47, |
2937 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1926 | 0xda, 0xd5, 0x1c, 0xcb, 0x95, 0x65, 0x19, 0xc8, 0x75, 0x7c, 0xb1, 0x24, |
2938 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1927 | 0x14, 0x21, 0xd3, 0x51, 0x5f, 0xa6, 0x32, 0xc7, 0x05, 0xec, 0x95, 0x83, |
2939 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1928 | 0xfc, 0xd9, 0x8f, 0xe1, 0xe9, 0xb0, 0x8c, 0xb9, 0xde, 0xe0, 0x58, 0x98, |
2940 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1929 | 0xa4, 0x4b, 0x9b, 0xe4, 0x5c, 0xbc, 0xa7, 0x0e, 0xe7, 0xa9, 0xff, 0x9c, |
2941 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1930 | 0x16, 0xde, 0x9b, 0x66, 0x21, 0xc7, 0x76, 0x2e, 0xf6, 0x23, 0x81, 0x8c, |
2942 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1931 | 0xf6, 0x9d, 0x6e, 0xbb, 0xef, 0xe5, 0x4d, 0x7d, 0xed, 0x67, 0x9b, 0x56, |
2943 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1932 | 0xc4, 0xb7, 0x0d, 0xde, 0xf3, 0x1d, 0xe4, 0x9d, 0x7e, 0xc9, 0x1f, 0x53, |
2944 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1933 | 0x31, 0xd6, 0x4b, 0x85, 0x25, 0x83, 0xac, 0x16, 0xcf, 0x91, 0x49, 0x34, |
2945 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1934 | 0xda, 0x72, 0xea, 0xa4, 0xf5, 0x30, 0xc6, 0x2d, 0x34, 0x3c, 0xef, 0xa7, |
2946 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1935 | 0xd0, 0x9d, 0x8b, 0x5c, 0x77, 0x3b, 0xbf, 0xf1, 0xd6, 0x93, 0xc8, 0x21, |
2947 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1936 | 0x37, 0xce, 0xfc, 0xe6, 0xfd, 0xd4, 0xa5, 0xab, 0x88, 0x09, 0x74, 0xc6, |
2948 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1937 | 0x09, 0x51, 0x22, 0x1e, 0xe7, 0x3e, 0xfe, 0x06, 0xef, 0x79, 0x17, 0x8d, |
2949 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1938 | 0x3b, 0x78, 0x75, 0x99, 0xc7, 0x69, 0xdf, 0x39, 0xf6, 0xff, 0x3f, 0xd0, |
2950 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1939 | 0x2e, 0x1a, 0xd6, 0x9e, 0x38, 0xf2, 0xe7, 0xeb, 0xc4, 0xb1, 0x4f, 0x4e, |
2951 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1940 | 0x14, 0x9b, 0xba, 0x7a, 0x09, 0x6b, 0x8b, 0x8e, 0xc2, 0xdf, 0xd6, 0xf9, |
2952 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1941 | 0xfb, 0xa8, 0x76, 0x89, 0xda, 0xf7, 0x65, 0x90, 0xa7, 0xa3, 0xf2, 0x77, |
2953 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1942 | 0x52, 0xb5, 0x8a, 0xd8, 0x52, 0x70, 0x92, 0x98, 0xaf, 0x62, 0x2e, 0xc7, |
2954 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1943 | 0x05, 0x8f, 0x14, 0xd8, 0x50, 0xc1, 0x49, 0x27, 0xc6, 0x9a, 0x9e, 0xa7, |
2955 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1944 | 0x7c, 0x5e, 0xa0, 0x87, 0x32, 0x29, 0x1a, 0x73, 0xf8, 0xfe, 0xf7, 0x9b, |
2956 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1945 | 0xf4, 0x36, 0xec, 0xac, 0x78, 0x9e, 0x6b, 0x26, 0xf6, 0x29, 0x78, 0x77, |
2957 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1946 | 0xf8, 0xbe, 0xea, 0x14, 0x3d, 0xb4, 0x47, 0xcf, 0x5e, 0x22, 0xe0, 0xb3, |
2958 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1947 | 0x42, 0xfd, 0x48, 0x72, 0x53, 0xc7, 0xfd, 0xef, 0x6d, 0x8c, 0x6b, 0x9a, |
2959 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1948 | 0x96, 0xc0, 0x1b, 0xa7, 0x99, 0xa4, 0x95, 0x66, 0x8a, 0x56, 0xa1, 0x1f, |
2960 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1949 | 0xdb, 0xcc, 0x32, 0x7d, 0x03, 0x78, 0x2b, 0x66, 0x95, 0x94, 0x8c, 0xb5, |
2961 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1950 | 0xaf, 0x0b, 0x78, 0x67, 0x05, 0x3d, 0x15, 0x17, 0x18, 0x77, 0x5d, 0x2d, |
2962 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1951 | 0x03, 0x6f, 0xd6, 0xd1, 0x51, 0xa7, 0x9b, 0x8e, 0x61, 0xed, 0x7e, 0xe4, |
2963 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1952 | 0x1f, 0xdf, 0x72, 0xa8, 0x2c, 0x99, 0x29, 0x3a, 0x80, 0xf3, 0x8e, 0x36, |
2964 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1953 | 0x38, 0x57, 0x3b, 0x02, 0x5f, 0x23, 0xd0, 0xa3, 0x19, 0x8f, 0x1e, 0xdd, |
2965 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1954 | 0xa3, 0x5b, 0x71, 0x01, 0x7b, 0xae, 0xb0, 0x9e, 0xa0, 0xdf, 0x09, 0xce, |
2966 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1955 | 0x8d, 0xad, 0xf8, 0xba, 0x08, 0x7f, 0xfa, 0x0c, 0x65, 0xce, 0xad, 0xe5, |
2967 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1956 | 0xa6, 0x90, 0x9f, 0x8f, 0x36, 0xe9, 0x8b, 0x31, 0x9c, 0xf7, 0x36, 0xf8, |
2968 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1957 | 0x34, 0xea, 0xc8, 0x02, 0xf3, 0xe9, 0x58, 0xc0, 0x27, 0x8c, 0xf1, 0xb7, |
2969 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1958 | 0x23, 0xce, 0xd1, 0xf8, 0xec, 0x13, 0x74, 0xb6, 0xc1, 0x77, 0xdd, 0x27, |
2970 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1959 | 0xe8, 0x4a, 0xe3, 0x11, 0xba, 0x98, 0xe3, 0x5c, 0x07, 0xfb, 0xf8, 0x67, |
2971 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1960 | 0xa0, 0xcf, 0x3f, 0xa3, 0x9b, 0x8e, 0xfb, 0x72, 0xfa, 0x3f, 0xc3, 0x06, |
2972 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | 1961 | 0xd0, 0x70, 0x4c, 0x57, 0x00, 0x00, 0x00 }; |
2973 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2974 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2975 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2976 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2977 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2978 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2979 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2980 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2981 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2982 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2983 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2984 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2985 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2986 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2987 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2988 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2989 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2990 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2991 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2992 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2993 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2994 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2995 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2996 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2997 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2998 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
2999 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3000 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3001 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3002 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3003 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3004 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3005 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3006 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3007 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3008 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3009 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3010 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3011 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3012 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3013 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3014 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3015 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3016 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3017 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3018 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3019 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3020 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3021 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3022 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3023 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3024 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3025 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3026 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3027 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3028 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3029 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3030 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3031 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3032 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3033 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3034 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3035 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3036 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3037 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3038 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3039 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3040 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3041 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3042 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3043 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3044 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3045 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3046 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3047 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3048 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3049 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3050 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3051 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3052 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3053 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3054 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3055 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3056 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3057 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3058 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3059 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3060 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3061 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3062 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3063 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3064 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3065 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3066 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3067 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3068 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3069 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3070 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3071 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3072 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3073 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3074 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3075 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3076 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3077 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3078 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3079 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3080 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3081 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3082 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3083 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3084 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3085 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3086 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3087 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3088 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3089 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3090 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3091 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3092 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3093 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3094 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3095 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3096 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3097 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3098 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3099 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3100 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3101 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3102 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3103 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3104 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3105 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3106 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3107 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3108 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3109 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3110 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3111 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3112 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3113 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3114 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3115 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3116 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3117 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3118 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3119 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
3120 | 0x00000000, 0x10000003, 0x00000000, 0x0000000d, 0x0000000d, 0x3c020800, | ||
3121 | 0x24425760, 0x3c030800, 0x24635964, 0xac400000, 0x0043202b, 0x1480fffd, | ||
3122 | 0x24420004, 0x3c1d0800, 0x37bd7ffc, 0x03a0f021, 0x3c100800, 0x261034b0, | ||
3123 | 0x3c1c0800, 0x279c5760, 0x0e000f5b, 0x00000000, 0x0000000d, 0x8f840014, | ||
3124 | 0x27bdffe8, 0xafb10014, 0xafb00010, 0x8f460104, 0x8f830008, 0x8c8500ac, | ||
3125 | 0xaf430080, 0x948200a8, 0xa7420e10, 0x948300aa, 0xa7430e12, 0x8c8200ac, | ||
3126 | 0xaf420e18, 0x97430e10, 0xa7430e14, 0x97420e12, 0x00008021, 0xa7420e16, | ||
3127 | 0x8f430e18, 0x00006021, 0x00c53023, 0xaf430e1c, 0x10c001a2, 0x2d820001, | ||
3128 | 0x3c0e1000, 0x2419fff8, 0x24110010, 0x240f0f00, 0x3c188100, 0x93620008, | ||
3129 | 0x10400009, 0x00000000, 0x97620010, 0x00c2102b, 0x14400005, 0x00000000, | ||
3130 | 0x97620010, 0x3042ffff, 0x0a000d6d, 0xaf420e00, 0xaf460e00, 0x8f420000, | ||
3131 | 0x30420008, 0x1040fffd, 0x00000000, 0x97420e08, 0x8f450e04, 0x3044ffff, | ||
3132 | 0x30820001, 0x14400005, 0x00000000, 0x14a00005, 0x3083a040, 0x0a000f34, | ||
3133 | 0x00000000, 0x0000000d, 0x3083a040, 0x24020040, 0x1462004f, 0x3082a000, | ||
3134 | 0x308a0036, 0x8f88000c, 0x30890008, 0x24020800, 0xaf420178, 0x01001821, | ||
3135 | 0x9742008a, 0x00431023, 0x2442ffff, 0x30421fff, 0x2c420008, 0x1440fffa, | ||
3136 | 0x00a06021, 0x8f820018, 0x00cc3023, 0x24070001, 0x8f830008, 0x304b00ff, | ||
3137 | 0x24420001, 0xaf820018, 0x25024000, 0x106f0005, 0x03422021, 0x93820012, | ||
3138 | 0x30420007, 0x00021240, 0x34470001, 0x000b1400, 0x3c030100, 0x00431025, | ||
3139 | 0xac820000, 0x8f830018, 0x00ea3825, 0x1120000f, 0xac830004, 0x97430e0a, | ||
3140 | 0x8f84000c, 0x00ee3825, 0x2402000e, 0x00781825, 0xaf430160, 0x25830006, | ||
3141 | 0x24840008, 0x30841fff, 0xa742015a, 0xa7430158, 0xaf84000c, 0x0a000db7, | ||
3142 | 0x00000000, 0x8f83000c, 0x25820002, 0xa7420158, 0x24630008, 0x30631fff, | ||
3143 | 0xaf83000c, 0x54c0000f, 0x8f420e14, 0x8f820008, 0x504f0002, 0x24100001, | ||
3144 | 0x34e70040, 0x97420e10, 0x97430e12, 0x8f850014, 0x00021400, 0x00621825, | ||
3145 | 0xaca300a8, 0x8f840014, 0x8f420e18, 0xac8200ac, 0x8f420e14, 0x8f430e1c, | ||
3146 | 0xaf420144, 0xaf430148, 0xa34b0152, 0xaf470154, 0x0a000efb, 0xaf4e0178, | ||
3147 | 0x10400165, 0x00000000, 0x93620008, 0x50400008, 0xafa60008, 0x97620010, | ||
3148 | 0x00a2102b, 0x10400003, 0x30820040, 0x1040015c, 0x00000000, 0xafa60008, | ||
3149 | 0xa7840010, 0xaf850004, 0x93620008, 0x1440005f, 0x27ac0008, 0xaf60000c, | ||
3150 | 0x97820010, 0x30424000, 0x10400002, 0x2403000e, 0x24030016, 0xa363000a, | ||
3151 | 0x24034007, 0xaf630014, 0x93820012, 0x8f630014, 0x30420007, 0x00021240, | ||
3152 | 0x00621825, 0xaf630014, 0x97820010, 0x8f630014, 0x30420010, 0x00621825, | ||
3153 | 0xaf630014, 0x97820010, 0x30420008, 0x5040000e, 0x00002821, 0x8f620014, | ||
3154 | 0x004e1025, 0xaf620014, 0x97430e0a, 0x2402000e, 0x00781825, 0xaf630004, | ||
3155 | 0xa3620002, 0x9363000a, 0x3405fffc, 0x24630004, 0x0a000e06, 0xa363000a, | ||
3156 | 0xaf600004, 0xa3600002, 0x97820010, 0x9363000a, 0x30421f00, 0x00021182, | ||
3157 | 0x24420028, 0x00621821, 0xa3630009, 0x97420e0c, 0xa7620010, 0x93630009, | ||
3158 | 0x24020008, 0x24630002, 0x30630007, 0x00431023, 0x30420007, 0xa362000b, | ||
3159 | 0x93640009, 0x97620010, 0x8f890004, 0x97830010, 0x00441021, 0x00a21021, | ||
3160 | 0x30630040, 0x10600007, 0x3045ffff, 0x00a9102b, 0x14400005, 0x0125102b, | ||
3161 | 0x3c068000, 0x0a000e3a, 0x00005821, 0x0125102b, 0x544000c7, 0x00006021, | ||
3162 | 0x97420e14, 0xa7420e10, 0x97430e16, 0xa7430e12, 0x8f420e1c, 0xaf420e18, | ||
3163 | 0xaf450e00, 0x8f420000, 0x30420008, 0x1040fffd, 0x00000000, 0x97420e08, | ||
3164 | 0x00a04821, 0xa7820010, 0x8f430e04, 0x00003021, 0x240b0001, 0xaf830004, | ||
3165 | 0x97620010, 0x0a000e4c, 0x304dffff, 0x8f890004, 0x97820010, 0x30420040, | ||
3166 | 0x10400004, 0x01206821, 0x3c068000, 0x0a000e4c, 0x00005821, 0x97630010, | ||
3167 | 0x8f820004, 0x10430003, 0x00003021, 0x0a000eee, 0x00006021, 0x240b0001, | ||
3168 | 0x8d820000, 0x00491023, 0x1440000d, 0xad820000, 0x8f620014, 0x34420040, | ||
3169 | 0xaf620014, 0x97430e10, 0x97420e12, 0x8f840014, 0x00031c00, 0x00431025, | ||
3170 | 0xac8200a8, 0x8f830014, 0x8f420e18, 0xac6200ac, 0x93620008, 0x1440003e, | ||
3171 | 0x00000000, 0x25260002, 0x8f84000c, 0x9743008a, 0x3063ffff, 0xafa30000, | ||
3172 | 0x8fa20000, 0x00441023, 0x2442ffff, 0x30421fff, 0x2c420010, 0x1440fff7, | ||
3173 | 0x00000000, 0x8f82000c, 0x8f830018, 0x00021082, 0x00021080, 0x24424000, | ||
3174 | 0x03422821, 0x00605021, 0x24630001, 0x314200ff, 0x00021400, 0xaf830018, | ||
3175 | 0x3c033200, 0x00431025, 0xaca20000, 0x93630009, 0x9362000a, 0x00031c00, | ||
3176 | 0x00431025, 0xaca20004, 0x8f830018, 0xaca30008, 0x97820010, 0x30420008, | ||
3177 | 0x10400002, 0x00c04021, 0x25280006, 0x97430e14, 0x93640002, 0x8f450e1c, | ||
3178 | 0x8f660004, 0x8f670014, 0x3063ffff, 0xa7430144, 0x97420e16, 0xa7420146, | ||
3179 | 0xaf450148, 0xa34a0152, 0x8f82000c, 0x308400ff, 0xa744015a, 0xaf460160, | ||
3180 | 0xa7480158, 0xaf470154, 0xaf4e0178, 0x00511021, 0x30421fff, 0xaf82000c, | ||
3181 | 0x0a000ed9, 0x8d820000, 0x93620009, 0x9363000b, 0x8f85000c, 0x2463000a, | ||
3182 | 0x00435021, 0x25440007, 0x00992024, 0x9743008a, 0x3063ffff, 0xafa30000, | ||
3183 | 0x8fa20000, 0x00451023, 0x2442ffff, 0x30421fff, 0x0044102b, 0x1440fff7, | ||
3184 | 0x00000000, 0x8f82000c, 0x8f840018, 0x00021082, 0x00021080, 0x24424000, | ||
3185 | 0x03422821, 0x00804021, 0x24840001, 0xaf840018, 0x93630009, 0x310200ff, | ||
3186 | 0x00022400, 0x3c024100, 0x24630002, 0x00621825, 0x00832025, 0xaca40000, | ||
3187 | 0x8f62000c, 0x00461025, 0xaca20004, 0x97430e14, 0x93640002, 0x8f450e1c, | ||
3188 | 0x8f660004, 0x8f670014, 0x3063ffff, 0xa7430144, 0x97420e16, 0x308400ff, | ||
3189 | 0xa7420146, 0xaf450148, 0xa3480152, 0x8f83000c, 0x25420007, 0x00591024, | ||
3190 | 0xa744015a, 0xaf460160, 0xa7490158, 0xaf470154, 0xaf4e0178, 0x00621821, | ||
3191 | 0x30631fff, 0xaf83000c, 0x8d820000, 0x14400005, 0x00000000, 0x8f620014, | ||
3192 | 0x2403ffbf, 0x00431024, 0xaf620014, 0x8f62000c, 0x004d1021, 0xaf62000c, | ||
3193 | 0x93630008, 0x14600008, 0x00000000, 0x11600006, 0x00000000, 0x8f630014, | ||
3194 | 0x3c02efff, 0x3442fffe, 0x00621824, 0xaf630014, 0xa36b0008, 0x01206021, | ||
3195 | 0x1580000c, 0x8fa60008, 0x97420e14, 0x97430e16, 0x8f850014, 0x00021400, | ||
3196 | 0x00621825, 0xaca300a8, 0x8f840014, 0x8f420e1c, 0xac8200ac, 0x0a000efd, | ||
3197 | 0x2d820001, 0x14c0fe65, 0x2d820001, 0x00501025, 0x10400058, 0x24020f00, | ||
3198 | 0x8f830008, 0x14620023, 0x3c048000, 0x11800009, 0x3c038000, 0x97420e08, | ||
3199 | 0x30420040, 0x14400005, 0x00000000, 0x0000000d, 0x00000000, 0x2400032c, | ||
3200 | 0x3c038000, 0x8f420178, 0x00431024, 0x1440fffd, 0x00000000, 0x97420e10, | ||
3201 | 0x3c030500, 0x00431025, 0xaf42014c, 0x97430e14, 0xa7430144, 0x97420e16, | ||
3202 | 0xa7420146, 0x8f430e1c, 0x24022000, 0xaf430148, 0x3c031000, 0xa3400152, | ||
3203 | 0xa740015a, 0xaf400160, 0xa7400158, 0xaf420154, 0xaf430178, 0x8f830008, | ||
3204 | 0x3c048000, 0x8f420178, 0x00441024, 0x1440fffd, 0x24020f00, 0x10620016, | ||
3205 | 0x00000000, 0x97420e14, 0xa7420144, 0x97430e16, 0xa7430146, 0x8f420e1c, | ||
3206 | 0x3c031000, 0xaf420148, 0x0a000f51, 0x24020240, 0x97420e14, 0x97430e16, | ||
3207 | 0x8f840014, 0x00021400, 0x00621825, 0xac8300a8, 0x8f850014, 0x8f420e1c, | ||
3208 | 0x00006021, 0xaca200ac, 0x0a000efd, 0x2d820001, 0xaf40014c, 0x11800007, | ||
3209 | 0x00000000, 0x97420e10, 0xa7420144, 0x97430e12, 0xa7430146, 0x0a000f4e, | ||
3210 | 0x8f420e18, 0x97420e14, 0xa7420144, 0x97430e16, 0xa7430146, 0x8f420e1c, | ||
3211 | 0xaf420148, 0x24020040, 0x3c031000, 0xa3400152, 0xa740015a, 0xaf400160, | ||
3212 | 0xa7400158, 0xaf420154, 0xaf430178, 0x8fb10014, 0x8fb00010, 0x03e00008, | ||
3213 | 0x27bd0018, 0x27bdffd0, 0x3c1a8000, 0x3c0420ff, 0x3484fffd, 0x3c020008, | ||
3214 | 0x03421821, 0xafbf002c, 0xafb60028, 0xafb50024, 0xafb40020, 0xafb3001c, | ||
3215 | 0xafb20018, 0xafb10014, 0xafb00010, 0xaf830014, 0xaf440e00, 0x00000000, | ||
3216 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x3c0200ff, 0x3442fffd, | ||
3217 | 0x3c046004, 0xaf420e00, 0x8c835000, 0x24160800, 0x24150d00, 0x3c140800, | ||
3218 | 0x24130f00, 0x3c120800, 0x3c114000, 0x2402ff7f, 0x00621824, 0x3463380c, | ||
3219 | 0x24020009, 0xac835000, 0xaf420008, 0xaf800018, 0xaf80000c, 0x0e001559, | ||
3220 | 0x00000000, 0x0e000ff0, 0x00000000, 0x3c020800, 0x245057c0, 0x8f420000, | ||
3221 | 0x30420001, 0x1040fffd, 0x00000000, 0x8f440100, 0xaf840008, 0xaf440020, | ||
3222 | 0xaf560178, 0x93430108, 0xa3830012, 0x93820012, 0x30420001, 0x10400008, | ||
3223 | 0x00000000, 0x93820012, 0x30420006, 0x00021100, 0x0e000d43, 0x0050d821, | ||
3224 | 0x0a000fac, 0x00000000, 0x14950005, 0x00000000, 0x0e000d43, 0x269b5840, | ||
3225 | 0x0a000fac, 0x00000000, 0x14930005, 0x00000000, 0x0e000d43, 0x265b5860, | ||
3226 | 0x0a000fac, 0x00000000, 0x0e0010ea, 0x00000000, 0xaf510138, 0x0a000f89, | ||
3227 | 0x00000000, 0x27bdfff8, 0x3084ffff, 0x24820007, 0x3044fff8, 0x8f85000c, | ||
3228 | 0x9743008a, 0x3063ffff, 0xafa30000, 0x8fa20000, 0x00451023, 0x2442ffff, | ||
3229 | 0x30421fff, 0x0044102b, 0x1440fff7, 0x00000000, 0x8f82000c, 0x00021082, | ||
3230 | 0x00021080, 0x24424000, 0x03421021, 0x03e00008, 0x27bd0008, 0x3084ffff, | ||
3231 | 0x8f82000c, 0x24840007, 0x3084fff8, 0x00441021, 0x30421fff, 0xaf82000c, | ||
3232 | 0x03e00008, 0x00000000, 0x27bdffe8, 0x3c1a8000, 0x3c0420ff, 0x3484fffd, | ||
3233 | 0x3c020008, 0x03421821, 0xafbf0010, 0xaf830014, 0xaf440e00, 0x00000000, | ||
3234 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x3c0200ff, 0x3442fffd, | ||
3235 | 0x3c046004, 0xaf420e00, 0x8c825000, 0x2403ff7f, 0x00431024, 0x3442380c, | ||
3236 | 0x24030009, 0xac825000, 0xaf430008, 0xaf800018, 0xaf80000c, 0x0e001559, | ||
3237 | 0x00000000, 0x0e000ff0, 0x00000000, 0x8fbf0010, 0x03e00008, 0x27bd0018, | ||
3238 | 0x27bdffe8, 0x3c02000a, 0x03421821, 0x3c040800, 0x24845880, 0x24050019, | ||
3239 | 0xafbf0010, 0xaf830024, 0x0e001565, 0x00003021, 0x3c050800, 0x3c020800, | ||
3240 | 0x24425330, 0xaca258e8, 0x24a558e8, 0x3c020800, 0x244254f8, 0x3c030800, | ||
3241 | 0x2463550c, 0x3c040800, 0xaca20004, 0x3c020800, 0x24425338, 0xaca30008, | ||
3242 | 0xac825900, 0x24845900, 0x3c020800, 0x244253c4, 0x3c070800, 0x24e75404, | ||
3243 | 0x3c060800, 0x24c65520, 0x3c050800, 0x24a55438, 0x3c030800, 0xac820004, | ||
3244 | 0x3c020800, 0x24425528, 0xac870008, 0xac86000c, 0xac850010, 0xac625920, | ||
3245 | 0x24635920, 0x8fbf0010, 0x3c020800, 0x24425540, 0xac620004, 0x3c020800, | ||
3246 | 0xac670008, 0xac66000c, 0xac650010, 0xac400048, 0x03e00008, 0x27bd0018, | ||
3247 | 0x974309da, 0x00804021, 0xad030000, 0x8f4209dc, 0xad020004, 0x8f4309e0, | ||
3248 | 0xad030008, 0x934409d9, 0x24020001, 0x30840003, 0x1082001f, 0x30a900ff, | ||
3249 | 0x28820002, 0x10400005, 0x24020002, 0x10800009, 0x3c0a0800, 0x0a001078, | ||
3250 | 0x93420934, 0x1082000b, 0x24020003, 0x10820026, 0x3c0a0800, 0x0a001078, | ||
3251 | 0x93420934, 0x974209e4, 0x00021400, 0x34420800, 0xad02000c, 0x0a001077, | ||
3252 | 0x25080010, 0x974209e4, 0x00021400, 0x34428100, 0xad02000c, 0x974309e8, | ||
3253 | 0x3c0a0800, 0x00031c00, 0x34630800, 0xad030010, 0x0a001077, 0x25080014, | ||
3254 | 0x974409e4, 0x3c050800, 0x24a25880, 0x9443001c, 0x94460014, 0x94470010, | ||
3255 | 0x00a05021, 0x24020800, 0xad000010, 0xad020014, 0x00042400, 0x00661821, | ||
3256 | 0x00671823, 0x2463fff2, 0x00832025, 0xad04000c, 0x0a001077, 0x25080018, | ||
3257 | 0x974209e4, 0x3c050800, 0x00021400, 0x34428100, 0xad02000c, 0x974409e8, | ||
3258 | 0x24a25880, 0x9443001c, 0x94460014, 0x94470010, 0x00a05021, 0x24020800, | ||
3259 | 0xad000014, 0xad020018, 0x00042400, 0x00661821, 0x00671823, 0x2463ffee, | ||
3260 | 0x00832025, 0xad040010, 0x2508001c, 0x93420934, 0x93450921, 0x3c074000, | ||
3261 | 0x25445880, 0x94830018, 0x94860014, 0x00021082, 0x00021600, 0x00052c00, | ||
3262 | 0x00a72825, 0x00451025, 0x00661821, 0x00431025, 0xad020000, 0x9783002c, | ||
3263 | 0x974209ea, 0x00621821, 0x00031c00, 0xad030004, 0x9782002c, 0x24420001, | ||
3264 | 0x30427fff, 0xa782002c, 0x93430920, 0x3c020006, 0x00031e00, 0x00621825, | ||
3265 | 0xad030008, 0x8f42092c, 0xad02000c, 0x8f430930, 0xad030010, 0x8f440938, | ||
3266 | 0x25080014, 0xad040000, 0x8f820020, 0x11200004, 0xad020004, 0x8f420940, | ||
3267 | 0x0a0010a1, 0x2442ffff, 0x8f420940, 0xad020008, 0x8f440948, 0x8f420940, | ||
3268 | 0x93430936, 0x00823023, 0x00663006, 0x3402ffff, 0x0046102b, 0x54400001, | ||
3269 | 0x3406ffff, 0x93420937, 0x25445880, 0x90830024, 0xad000010, 0x00021700, | ||
3270 | 0x34630010, 0x00031c00, 0x00431025, 0x00461025, 0xad02000c, 0x8c830008, | ||
3271 | 0x14600031, 0x25080014, 0x3c020800, 0x8c430048, 0x1060002d, 0x00000000, | ||
3272 | 0x9342010b, 0xad020000, 0x8f830000, 0x8c6200b0, 0xad020004, 0x8f830000, | ||
3273 | 0x8c6200b4, 0xad020008, 0x8f830000, 0x8c6200c0, 0xad02000c, 0x8f830000, | ||
3274 | 0x8c6200c4, 0xad020010, 0x8f830000, 0x8c6200c8, 0xad020014, 0x8f830000, | ||
3275 | 0x8c6200cc, 0xad020018, 0x8f830000, 0x8c6200e0, 0xad02001c, 0x8f830000, | ||
3276 | 0x8c6200e8, 0xad020020, 0x8f830000, 0x8c6200f0, 0x3c04600e, 0xad020024, | ||
3277 | 0x8c8200d0, 0xad020028, 0x8c8300d4, 0xad03002c, 0x8f820028, 0x3c046012, | ||
3278 | 0xad020030, 0x8c8200a8, 0xad020034, 0x8c8300ac, 0x3c026000, 0xad030038, | ||
3279 | 0x8c434448, 0xad03003c, 0x03e00008, 0x01001021, 0x27bdffa8, 0x3c020008, | ||
3280 | 0x03423021, 0xafbf0054, 0xafbe0050, 0xafb7004c, 0xafb60048, 0xafb50044, | ||
3281 | 0xafb40040, 0xafb3003c, 0xafb20038, 0xafb10034, 0xafb00030, 0xaf860000, | ||
3282 | 0x24020040, 0xaf420814, 0xaf400810, 0x8f420944, 0x8f430950, 0x8f440954, | ||
3283 | 0x8f45095c, 0xaf820034, 0xaf830020, 0xaf84001c, 0xaf850030, 0x90c20000, | ||
3284 | 0x24030020, 0x304400ff, 0x10830005, 0x24020030, 0x10820022, 0x3c030800, | ||
3285 | 0x0a001139, 0x8c62002c, 0x24020088, 0xaf420818, 0x3c020800, 0x244258e8, | ||
3286 | 0xafa20020, 0x93430109, 0x3c020800, 0x10600009, 0x24575900, 0x3c026000, | ||
3287 | 0x24030100, 0xac43081c, 0x3c030001, 0xac43081c, 0x0000000d, 0x00000000, | ||
3288 | 0x24000376, 0x9342010a, 0x30420080, 0x14400021, 0x24020800, 0x3c026000, | ||
3289 | 0x24030100, 0xac43081c, 0x3c030001, 0xac43081c, 0x0000000d, 0x00000000, | ||
3290 | 0x2400037d, 0x0a001141, 0x24020800, 0x93430109, 0x3063007f, 0x00031140, | ||
3291 | 0x000318c0, 0x00431021, 0x24430088, 0xaf430818, 0x0000000d, 0x3c020800, | ||
3292 | 0x24425940, 0x3c030800, 0x24775950, 0x0a001140, 0xafa20020, 0x24420001, | ||
3293 | 0xac62002c, 0x0000000d, 0x00000000, 0x24000395, 0x0a0014c1, 0x8fbf0054, | ||
3294 | 0x24020800, 0xaf420178, 0x8f450104, 0x8f420988, 0x00a21023, 0x58400005, | ||
3295 | 0x8f4309a0, 0x0000000d, 0x00000000, 0x240003b1, 0x8f4309a0, 0x3c100800, | ||
3296 | 0xae0358b0, 0x8f4209a4, 0x8f830020, 0x260458b0, 0x2491ffd0, 0xae220034, | ||
3297 | 0x00a21023, 0xae230028, 0xac82ffd0, 0x8fa30020, 0x8c620000, 0x0040f809, | ||
3298 | 0x0200b021, 0x00409021, 0x32440010, 0x32420002, 0x10400007, 0xafa40024, | ||
3299 | 0x8e220020, 0x32530040, 0x2403ffbf, 0x00431024, 0x0a001493, 0xae220020, | ||
3300 | 0x32420020, 0x10400002, 0x3c020800, 0x24575920, 0x32420001, 0x14400007, | ||
3301 | 0x00000000, 0x8f820008, 0xaf420080, 0x8ec358b0, 0xaf430e10, 0x8e220034, | ||
3302 | 0xaf420e18, 0x9343010b, 0x93420905, 0x30420008, 0x1040003c, 0x307400ff, | ||
3303 | 0x8f820000, 0x8c430074, 0x0460000a, 0x00000000, 0x3c026000, 0x24030100, | ||
3304 | 0xac43081c, 0x3c030001, 0xac43081c, 0x0000000d, 0x00000000, 0x240003ed, | ||
3305 | 0x8f820000, 0x9044007b, 0x9343010a, 0x14830027, 0x32530040, 0x00003821, | ||
3306 | 0x24052000, 0x3c090800, 0x3c038000, 0x8f420178, 0x00431024, 0x1440fffd, | ||
3307 | 0x8ec258b0, 0x26c458b0, 0x2484ffd0, 0xaf420144, 0x8c820034, 0x3c030100, | ||
3308 | 0xaf420148, 0x24020047, 0xaf43014c, 0xa3420152, 0x8d230030, 0x3c021000, | ||
3309 | 0xa7470158, 0xaf450154, 0xaf420178, 0x8c860034, 0x24630001, 0xad230030, | ||
3310 | 0x9342010a, 0x3c030047, 0xafa50014, 0x00021600, 0x00431025, 0x00471025, | ||
3311 | 0xafa20010, 0x9343010b, 0xafa30018, 0x8f440100, 0x8f450104, 0x0e00159b, | ||
3312 | 0x3c070100, 0x3c050800, 0x24a25880, 0x0a001250, 0x8c430020, 0x32820002, | ||
3313 | 0x10400050, 0x00000000, 0x0e0015b9, 0x32530040, 0x3c039000, 0x34630001, | ||
3314 | 0x8f820008, 0x3c048000, 0x00431025, 0xaf420020, 0x8f420020, 0x00441024, | ||
3315 | 0x1440fffd, 0x00000000, 0x8f830000, 0x90620005, 0x34420008, 0xa0620005, | ||
3316 | 0x8f840000, 0x8c820074, 0x3c038000, 0x00431025, 0xac820074, 0x90830000, | ||
3317 | 0x24020020, 0x10620004, 0x00000000, 0x0000000d, 0x00000000, 0x2400040b, | ||
3318 | 0x8f830008, 0x3c028000, 0x34420001, 0x00621825, 0xaf430020, 0x9084007b, | ||
3319 | 0x9342010a, 0x14820028, 0x3c030800, 0x00003821, 0x24052000, 0x3c090800, | ||
3320 | 0x3c038000, 0x8f420178, 0x00431024, 0x1440fffd, 0x8ec258b0, 0x26c458b0, | ||
3321 | 0x2484ffd0, 0xaf420144, 0x8c820034, 0x3c030100, 0xaf420148, 0x24020046, | ||
3322 | 0xaf43014c, 0xa3420152, 0x8d230030, 0x3c021000, 0xa7470158, 0xaf450154, | ||
3323 | 0xaf420178, 0x8c860034, 0x24630001, 0xad230030, 0x9342010a, 0x3c030046, | ||
3324 | 0xafa50014, 0x00021600, 0x00431025, 0x00471025, 0xafa20010, 0x9343010b, | ||
3325 | 0xafa30018, 0x8f440100, 0x8f450104, 0x0e00159b, 0x3c070100, 0x3c030800, | ||
3326 | 0x24625880, 0x0a001250, 0x8c430020, 0x93420108, 0x30420010, 0x50400056, | ||
3327 | 0x9343093f, 0x8f860000, 0x90c2007f, 0x8cc30178, 0x304800ff, 0x15030004, | ||
3328 | 0x00000000, 0x0000000d, 0x00000000, 0x24000425, 0x90c2007e, 0x90c40080, | ||
3329 | 0x00081c00, 0x00021600, 0x00431025, 0x00042200, 0x90c3007a, 0x90c5000a, | ||
3330 | 0x00441025, 0x11050028, 0x00623825, 0xa0c8000a, 0x00004021, 0x24056000, | ||
3331 | 0x3c090800, 0x3c038000, 0x8f420178, 0x00431024, 0x1440fffd, 0x8ec258b0, | ||
3332 | 0x26c458b0, 0x2484ffd0, 0xaf420144, 0x8c820034, 0xaf420148, 0x24020052, | ||
3333 | 0xaf47014c, 0xa3420152, 0x8d230030, 0x3c021000, 0xa7480158, 0xaf450154, | ||
3334 | 0xaf420178, 0x8c860034, 0x24630001, 0xad230030, 0x9342010a, 0x3c030052, | ||
3335 | 0xafa50014, 0x00021600, 0x00431025, 0x00481025, 0xafa20010, 0x9343010b, | ||
3336 | 0xafa30018, 0x8f440100, 0x0e00159b, 0x8f450104, 0x0a00124a, 0x00000000, | ||
3337 | 0x3c026000, 0x24030100, 0xac43081c, 0x3c030001, 0xac43081c, 0x0000000d, | ||
3338 | 0x00000000, 0x2400043e, 0x16800009, 0x3c050800, 0x3c040800, 0x24825880, | ||
3339 | 0x8c430020, 0x32530040, 0x2404ffbf, 0x00641824, 0x0a001493, 0xac430020, | ||
3340 | 0x8ca25880, 0x10400005, 0x3c030800, 0x8c620034, 0xaca05880, 0x24420001, | ||
3341 | 0xac620034, 0x9343093f, 0x24020012, 0x5462000e, 0x97420908, 0x32820038, | ||
3342 | 0x14400009, 0x3c030800, 0x8f830000, 0x8c62004c, 0xac62005c, 0x3c020800, | ||
3343 | 0x24445880, 0x8c820020, 0x0a001285, 0x32530040, 0xac605880, 0x97420908, | ||
3344 | 0x5440001c, 0x97420908, 0x3c039000, 0x34630001, 0x8f820008, 0x32530040, | ||
3345 | 0x3c048000, 0x00431025, 0xaf420020, 0x8f420020, 0x00441024, 0x1440fffd, | ||
3346 | 0x3c028000, 0x8f840000, 0x8f850008, 0x8c830050, 0x34420001, 0x00a22825, | ||
3347 | 0xaf830020, 0xac830070, 0xac83005c, 0xaf450020, 0x3c050800, 0x24a45880, | ||
3348 | 0x8c820020, 0x2403ffbf, 0x00431024, 0x0a001493, 0xac820020, 0x000211c0, | ||
3349 | 0xaf420024, 0x97420908, 0x3c030080, 0x34630003, 0x000211c0, 0xaf42080c, | ||
3350 | 0xaf43081c, 0x974209ec, 0x8f4309a4, 0xa782002c, 0x3c020800, 0x24445880, | ||
3351 | 0xac83002c, 0x93420937, 0x93430934, 0x00021080, 0x00621821, 0xa4830018, | ||
3352 | 0x934209d8, 0x32850038, 0xafa50028, 0x00621821, 0xa483001a, 0x934209d8, | ||
3353 | 0x93430934, 0x3c1e0800, 0x00809821, 0x00431021, 0x24420010, 0xa4820016, | ||
3354 | 0x24020006, 0xae620020, 0x8fa20028, 0x10400003, 0x0000a821, 0x0a0012f0, | ||
3355 | 0x24120008, 0x8f420958, 0x8f830020, 0x8f840030, 0x00431023, 0x00832023, | ||
3356 | 0x04800003, 0xae620004, 0x04410003, 0x0082102b, 0x0a0012bc, 0xae600004, | ||
3357 | 0x54400001, 0xae640004, 0x8ee20000, 0x0040f809, 0x00000000, 0x00409021, | ||
3358 | 0x32420001, 0x5440001e, 0x8ee20004, 0x8e630008, 0x1060002b, 0x3c02c000, | ||
3359 | 0x00621025, 0xaf420e00, 0x8f420000, 0x30420008, 0x1040fffd, 0x00000000, | ||
3360 | 0x97420e08, 0xa7820010, 0x8f430e04, 0x8e620008, 0xaf830004, 0x8f840004, | ||
3361 | 0x0044102b, 0x1040000b, 0x24150001, 0x24020100, 0x3c016000, 0xac22081c, | ||
3362 | 0x3c020001, 0x3c016000, 0xac22081c, 0x0000000d, 0x00000000, 0x240004cd, | ||
3363 | 0x24150001, 0x8ee20004, 0x0040f809, 0x00000000, 0x02429025, 0x32420002, | ||
3364 | 0x5040001d, 0x8f470940, 0x12a00006, 0x8ec258b0, 0x8f830000, 0xac6200a8, | ||
3365 | 0x8f840000, 0x8e620034, 0xac8200ac, 0x32420004, 0x50400013, 0x8f470940, | ||
3366 | 0x3c020800, 0x3283007d, 0x10600110, 0x24575920, 0x32820001, 0x50400006, | ||
3367 | 0x36520002, 0x8f830034, 0x8f420940, 0x10620109, 0x00000000, 0x36520002, | ||
3368 | 0x24020008, 0xa6600010, 0xa6620012, 0xae600008, 0xa2600024, 0x8f470940, | ||
3369 | 0x3c030800, 0x24685880, 0x8d02002c, 0x8d050008, 0x95040010, 0x9506000a, | ||
3370 | 0x95030026, 0x00451021, 0x00862021, 0x00641821, 0xaf870034, 0xad02002c, | ||
3371 | 0x32820030, 0x10400008, 0xa5030014, 0x91020024, 0x32910040, 0x34420004, | ||
3372 | 0xa1020024, 0xaf400048, 0x0a001345, 0x3c040800, 0x93420923, 0x30420002, | ||
3373 | 0x10400029, 0x32910040, 0x8f830000, 0x8f840020, 0x8c620084, 0x00441023, | ||
3374 | 0x0442000a, 0x3c039000, 0x95020014, 0x8c630084, 0x00821021, 0x00621823, | ||
3375 | 0x1c600004, 0x3c039000, 0x91020024, 0x34420001, 0xa1020024, 0x34630001, | ||
3376 | 0x8f820008, 0x32910040, 0x3c048000, 0x00431025, 0xaf420020, 0x8f420020, | ||
3377 | 0x00441024, 0x1440fffd, 0x00000000, 0x8f840000, 0x9083003f, 0x2402000a, | ||
3378 | 0x10620005, 0x2402000c, 0x9083003f, 0x24020008, 0x14620002, 0x24020014, | ||
3379 | 0xa082003f, 0x8f830008, 0x3c028000, 0x34420001, 0x00621825, 0xaf430020, | ||
3380 | 0x3c040800, 0x24865880, 0x94c20010, 0x94c3001a, 0x8cc40008, 0x00432821, | ||
3381 | 0x14800006, 0xa4c5001c, 0x3c020800, 0x8c430048, 0x10600002, 0x24a20040, | ||
3382 | 0xa4c2001c, 0x27d05880, 0x9604001c, 0x96020012, 0x00822021, 0x24840002, | ||
3383 | 0x0e000faf, 0x3084ffff, 0x8f850018, 0x00a01821, 0xa2030025, 0x8ee60008, | ||
3384 | 0x00402021, 0x24a50001, 0xaf850018, 0x00c0f809, 0x00000000, 0x00402021, | ||
3385 | 0x0e001026, 0x02202821, 0x8ee3000c, 0x0060f809, 0x00402021, 0x9604001c, | ||
3386 | 0x96020012, 0x00822021, 0x24840002, 0x0e000fc5, 0x3084ffff, 0x8fc25880, | ||
3387 | 0x8e030008, 0x00431023, 0x14400012, 0xafc25880, 0x54600006, 0x8e020020, | ||
3388 | 0x3243004a, 0x24020002, 0x14620005, 0x00000000, 0x8e020020, 0x34420040, | ||
3389 | 0x0a001382, 0xae020020, 0x52a00006, 0x36520002, 0x8e020030, 0xaf420e10, | ||
3390 | 0x8e030034, 0xaf430e18, 0x36520002, 0x52a00008, 0x96670014, 0x8f830000, | ||
3391 | 0x8f420e10, 0xac6200a8, 0x8f840000, 0x8f420e18, 0xac8200ac, 0x96670014, | ||
3392 | 0x92680024, 0x24020040, 0xaf420814, 0x8f830020, 0x8f82001c, 0x00671821, | ||
3393 | 0x00621023, 0xaf830020, 0x18400008, 0x00000000, 0x8f820000, 0xaf83001c, | ||
3394 | 0xac430054, 0x54e00005, 0xaf400040, 0x0a0013a0, 0x8f42095c, 0x54e00001, | ||
3395 | 0xaf400044, 0x8f42095c, 0x31030008, 0xaf820030, 0x1060001a, 0x00000000, | ||
3396 | 0x8f840000, 0x90820120, 0x90830121, 0x304600ff, 0x00c31823, 0x30630007, | ||
3397 | 0x24020007, 0x1062000e, 0x00000000, 0x90820122, 0x304200fe, 0xa0820122, | ||
3398 | 0x8f850000, 0x00061880, 0x8f840020, 0x24a20100, 0x00431021, 0x24c30001, | ||
3399 | 0x30630007, 0xac440000, 0x0a0013bd, 0xa0a30120, 0x90820122, 0x34420001, | ||
3400 | 0xa0820122, 0x14e00003, 0x31020001, 0x10400031, 0x32510002, 0x8f820000, | ||
3401 | 0x8c43000c, 0x30630001, 0x1060002c, 0x32510002, 0x3c029000, 0x8f830008, | ||
3402 | 0x34420001, 0x3c048000, 0x00621825, 0xaf430020, 0x8f420020, 0x00441024, | ||
3403 | 0x1440fffd, 0x00000000, 0x8f870000, 0x8ce2000c, 0x30420001, 0x10400018, | ||
3404 | 0x00000000, 0x94e2006a, 0x00022880, 0x50a00001, 0x24050001, 0x94e30068, | ||
3405 | 0x90e40081, 0x3c020800, 0x8c460024, 0x00652821, 0x00852804, 0x00c5102b, | ||
3406 | 0x54400001, 0x00a03021, 0x3c020800, 0x8c440028, 0x00c4182b, 0x54600001, | ||
3407 | 0x00c02021, 0x8f430074, 0x2402fffe, 0x00822824, 0x00a31821, 0xace3000c, | ||
3408 | 0x8f830008, 0x3c028000, 0x34420001, 0x00621825, 0xaf430020, 0x8f820020, | ||
3409 | 0x3c050800, 0x24b05880, 0xae020028, 0x8ee30010, 0x0060f809, 0x00000000, | ||
3410 | 0x8f820028, 0x24420001, 0xaf820028, 0x12a00005, 0xaf40004c, 0x8f420e10, | ||
3411 | 0xae020030, 0x8f430e18, 0xae030034, 0x1220fea7, 0x24020006, 0x8f870024, | ||
3412 | 0x9786002c, 0x8f830000, 0x8f820034, 0x8f840020, 0x8f85001c, 0x32530040, | ||
3413 | 0xa4e6002c, 0xac620044, 0x32420008, 0xac640050, 0xac650054, 0x1040007a, | ||
3414 | 0x32820020, 0x10400027, 0x32910010, 0x00003821, 0x24052000, 0x3c090800, | ||
3415 | 0x3c038000, 0x8f420178, 0x00431024, 0x1440fffd, 0x8ec258b0, 0x26c458b0, | ||
3416 | 0x2484ffd0, 0xaf420144, 0x8c820034, 0x3c030400, 0xaf420148, 0x24020041, | ||
3417 | 0xaf43014c, 0xa3420152, 0x8d230030, 0x3c021000, 0xa7470158, 0xaf450154, | ||
3418 | 0xaf420178, 0x8c860034, 0x24630001, 0xad230030, 0x9342010a, 0x3c030041, | ||
3419 | 0xafa50014, 0x00021600, 0x00431025, 0x00471025, 0xafa20010, 0x9343010b, | ||
3420 | 0xafa30018, 0x8f440100, 0x8f450104, 0x0e00159b, 0x3c070400, 0x12200028, | ||
3421 | 0x00003821, 0x24052000, 0x3c090800, 0x3c038000, 0x8f420178, 0x00431024, | ||
3422 | 0x1440fffd, 0x8ec258b0, 0x26c458b0, 0x2484ffd0, 0xaf420144, 0x8c820034, | ||
3423 | 0x3c030300, 0xaf420148, 0x2402004e, 0xaf43014c, 0xa3420152, 0x8d230030, | ||
3424 | 0x3c021000, 0xa7470158, 0xaf450154, 0xaf420178, 0x8c860034, 0x24630001, | ||
3425 | 0xad230030, 0x9342010a, 0x3c03004e, 0xafa50014, 0x00021600, 0x00431025, | ||
3426 | 0x00471025, 0xafa20010, 0x9343010b, 0xafa30018, 0x8f440100, 0x8f450104, | ||
3427 | 0x0e00159b, 0x3c070300, 0x0a00148b, 0x8fa20024, 0x32820008, 0x10400026, | ||
3428 | 0x24052000, 0x00003821, 0x3c090800, 0x3c038000, 0x8f420178, 0x00431024, | ||
3429 | 0x1440fffd, 0x8ec258b0, 0x26c458b0, 0x2484ffd0, 0xaf420144, 0x8c820034, | ||
3430 | 0x3c030200, 0xaf420148, 0x2402004b, 0xaf43014c, 0xa3420152, 0x8d230030, | ||
3431 | 0x3c021000, 0xa7470158, 0xaf450154, 0xaf420178, 0x8c860034, 0x24630001, | ||
3432 | 0xad230030, 0x9342010a, 0x3c03004b, 0xafa50014, 0x00021600, 0x00431025, | ||
3433 | 0x00471025, 0xafa20010, 0x9343010b, 0xafa30018, 0x8f440100, 0x8f450104, | ||
3434 | 0x0e00159b, 0x3c070200, 0x8fa20024, 0x14400004, 0x8fa30020, 0x32420010, | ||
3435 | 0x10400004, 0x00000000, 0x8c620004, 0x0040f809, 0x00000000, 0x12600006, | ||
3436 | 0x8fa40020, 0x8c820008, 0x0040f809, 0x00000000, 0x0a0014c1, 0x8fbf0054, | ||
3437 | 0x3c030800, 0x8c6258a0, 0x30420040, 0x14400023, 0x8fbf0054, 0x00002821, | ||
3438 | 0x24040040, 0x8f870020, 0x3c038000, 0x8f420178, 0x00431024, 0x1440fffd, | ||
3439 | 0x8ec258b0, 0x26c358b0, 0x2463ffd0, 0xaf420144, 0x8c620034, 0xaf420148, | ||
3440 | 0x24020049, 0xaf47014c, 0xa3420152, 0x3c021000, 0xa7450158, 0xaf440154, | ||
3441 | 0xaf420178, 0x8c660034, 0x9342010a, 0x3c030049, 0xafa40014, 0x00021600, | ||
3442 | 0x00431025, 0x00451025, 0xafa20010, 0x9343010b, 0xafa30018, 0x8f440100, | ||
3443 | 0x0e00159b, 0x8f450104, 0x8fbf0054, 0x8fbe0050, 0x8fb7004c, 0x8fb60048, | ||
3444 | 0x8fb50044, 0x8fb40040, 0x8fb3003c, 0x8fb20038, 0x8fb10034, 0x8fb00030, | ||
3445 | 0x03e00008, 0x27bd0058, 0x03e00008, 0x00001021, 0x3c020800, 0x24435880, | ||
3446 | 0x8c650004, 0x8c445880, 0x0085182b, 0x10600002, 0x00403021, 0x00802821, | ||
3447 | 0x9744093c, 0x00a4102b, 0x54400001, 0x00a02021, 0x93420923, 0x0004182b, | ||
3448 | 0x00021042, 0x30420001, 0x00431024, 0x1040000d, 0x24c25880, 0x8f850000, | ||
3449 | 0x8f830020, 0x8ca20084, 0x00431023, 0x04420007, 0x24c25880, 0x8ca20084, | ||
3450 | 0x00641821, 0x00431023, 0x28420001, 0x00822023, 0x24c25880, 0xac440008, | ||
3451 | 0xa4400026, 0x03e00008, 0x00001021, 0x8f850004, 0x97840010, 0x3c030800, | ||
3452 | 0x24635880, 0x24020008, 0xa4620012, 0x8f820004, 0xa4600010, 0x000420c2, | ||
3453 | 0x30840008, 0x2c420001, 0x00021023, 0x30420006, 0xac650008, 0x03e00008, | ||
3454 | 0xa0640024, 0x3c020800, 0x24425880, 0x90450025, 0x9443001c, 0x3c021100, | ||
3455 | 0xac800004, 0x00052c00, 0x24630002, 0x00621825, 0x00a32825, 0x24820008, | ||
3456 | 0x03e00008, 0xac850000, 0x27bdffd8, 0x3c020800, 0x24425880, 0xafbf0020, | ||
3457 | 0x90480025, 0x8c440008, 0x8c460020, 0x8f870020, 0x3c030800, 0x3c058000, | ||
3458 | 0x8f420178, 0x00451024, 0x1440fffd, 0x8c6258b0, 0x246358b0, 0x2469ffd0, | ||
3459 | 0xaf420144, 0x8d220034, 0x30c32000, 0xaf420148, 0x3c021000, 0xaf47014c, | ||
3460 | 0xa3480152, 0xa7440158, 0xaf460154, 0xaf420178, 0x10600004, 0x3c030800, | ||
3461 | 0x8c620030, 0x24420001, 0xac620030, 0x9342010a, 0x00081c00, 0x3084ffff, | ||
3462 | 0xafa60014, 0x00021600, 0x00431025, 0x00441025, 0xafa20010, 0x9343010b, | ||
3463 | 0xafa30018, 0x8f440100, 0x8f450104, 0x0e00159b, 0x8d260034, 0x8fbf0020, | ||
3464 | 0x03e00008, 0x27bd0028, 0x0000000d, 0x00000000, 0x2400019d, 0x03e00008, | ||
3465 | 0x00000000, 0x0000000d, 0x00000000, 0x240001a9, 0x03e00008, 0x00000000, | ||
3466 | 0x03e00008, 0x00000000, 0x3c020800, 0x24425880, 0xac400008, 0xa4400026, | ||
3467 | 0x03e00008, 0x24020001, 0x3c020800, 0x24425880, 0x24030008, 0xac400008, | ||
3468 | 0xa4400010, 0xa4430012, 0xa0400024, 0x03e00008, 0x24020004, 0x03e00008, | ||
3469 | 0x00001021, 0x10c00007, 0x00000000, 0x8ca20000, 0x24c6ffff, 0x24a50004, | ||
3470 | 0xac820000, 0x14c0fffb, 0x24840004, 0x03e00008, 0x00000000, 0x0a00156c, | ||
3471 | 0x00a01021, 0xac860000, 0x00000000, 0x00000000, 0x24840004, 0x00a01021, | ||
3472 | 0x1440fffa, 0x24a5ffff, 0x03e00008, 0x00000000, 0x3c0a0800, 0x8d490068, | ||
3473 | 0x3c050800, 0x24a52098, 0x00093140, 0x00c51021, 0xac440000, 0x8f440e04, | ||
3474 | 0x00a61021, 0xac440004, 0x97430e08, 0x97420e0c, 0x00a62021, 0x00031c00, | ||
3475 | 0x00431025, 0xac820008, 0x8f430e10, 0x00801021, 0xac43000c, 0x8f440e14, | ||
3476 | 0xac440010, 0x8f430e18, 0x3c0800ff, 0xac430014, 0x8f470e1c, 0x3508ffff, | ||
3477 | 0x25290001, 0xac470018, 0x3c070800, 0x8ce3006c, 0x9344010a, 0x3c026000, | ||
3478 | 0x24630001, 0xace3006c, 0x8c434448, 0x3129007f, 0x00a62821, 0xad490068, | ||
3479 | 0x00042600, 0x00681824, 0x00832025, 0x03e00008, 0xaca4001c, 0x8fac0010, | ||
3480 | 0x8fad0014, 0x8fae0018, 0x3c0b0800, 0x8d6a0060, 0x3c080800, 0x25080080, | ||
3481 | 0x000a4940, 0x01281021, 0x01091821, 0xac440000, 0x00601021, 0xac650004, | ||
3482 | 0xac460008, 0xac67000c, 0xac4c0010, 0xac6d0014, 0x3c036000, 0xac4e0018, | ||
3483 | 0x8c654448, 0x3c040800, 0x8c820064, 0x254a0001, 0x314a00ff, 0x01094021, | ||
3484 | 0xad6a0060, 0x24420001, 0xac820064, 0x03e00008, 0xad05001c, 0x3c030800, | ||
3485 | 0x3c090800, 0x8d250070, 0x246330b0, 0x8f460100, 0x00053900, 0x00e31021, | ||
3486 | 0xac460000, 0x8f440104, 0x00671021, 0xac440004, 0x8f460108, 0x8f840014, | ||
3487 | 0x24a50001, 0xac460008, 0x8c880074, 0x3c060800, 0x8cc20074, 0x30a5003f, | ||
3488 | 0x00671821, 0xad250070, 0x24420001, 0xacc20074, 0x03e00008, 0xac68000c, | ||
3489 | 0x00000000 }; | ||
3490 | 1962 | ||
3491 | static u32 bnx2_TXP_b06FwData[(0x0/4) + 1] = { 0x0 }; | 1963 | static u32 bnx2_TXP_b06FwData[(0x0/4) + 1] = { 0x0 }; |
3492 | static u32 bnx2_TXP_b06FwRodata[(0x0/4) + 1] = { 0x0 }; | 1964 | static u32 bnx2_TXP_b06FwRodata[(0x0/4) + 1] = { 0x0 }; |
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c index 55d236726d11..8171cae06688 100644 --- a/drivers/net/bonding/bond_main.c +++ b/drivers/net/bonding/bond_main.c | |||
@@ -1199,8 +1199,7 @@ int bond_sethwaddr(struct net_device *bond_dev, struct net_device *slave_dev) | |||
1199 | } | 1199 | } |
1200 | 1200 | ||
1201 | #define BOND_INTERSECT_FEATURES \ | 1201 | #define BOND_INTERSECT_FEATURES \ |
1202 | (NETIF_F_SG|NETIF_F_IP_CSUM|NETIF_F_NO_CSUM|NETIF_F_HW_CSUM|\ | 1202 | (NETIF_F_SG | NETIF_F_ALL_CSUM | NETIF_F_TSO | NETIF_F_UFO) |
1203 | NETIF_F_TSO|NETIF_F_UFO) | ||
1204 | 1203 | ||
1205 | /* | 1204 | /* |
1206 | * Compute the common dev->feature set available to all slaves. Some | 1205 | * Compute the common dev->feature set available to all slaves. Some |
@@ -1218,9 +1217,7 @@ static int bond_compute_features(struct bonding *bond) | |||
1218 | features &= (slave->dev->features & BOND_INTERSECT_FEATURES); | 1217 | features &= (slave->dev->features & BOND_INTERSECT_FEATURES); |
1219 | 1218 | ||
1220 | if ((features & NETIF_F_SG) && | 1219 | if ((features & NETIF_F_SG) && |
1221 | !(features & (NETIF_F_IP_CSUM | | 1220 | !(features & NETIF_F_ALL_CSUM)) |
1222 | NETIF_F_NO_CSUM | | ||
1223 | NETIF_F_HW_CSUM))) | ||
1224 | features &= ~NETIF_F_SG; | 1221 | features &= ~NETIF_F_SG; |
1225 | 1222 | ||
1226 | /* | 1223 | /* |
@@ -4191,7 +4188,7 @@ static int bond_init(struct net_device *bond_dev, struct bond_params *params) | |||
4191 | */ | 4188 | */ |
4192 | bond_dev->features |= NETIF_F_VLAN_CHALLENGED; | 4189 | bond_dev->features |= NETIF_F_VLAN_CHALLENGED; |
4193 | 4190 | ||
4194 | /* don't acquire bond device's xmit_lock when | 4191 | /* don't acquire bond device's netif_tx_lock when |
4195 | * transmitting */ | 4192 | * transmitting */ |
4196 | bond_dev->features |= NETIF_F_LLTX; | 4193 | bond_dev->features |= NETIF_F_LLTX; |
4197 | 4194 | ||
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c index 5669b95162b3..04a53f1dfdbd 100644 --- a/drivers/net/forcedeth.c +++ b/drivers/net/forcedeth.c | |||
@@ -108,6 +108,7 @@ | |||
108 | * 0.53: 19 Mar 2006: Fix init from low power mode and add hw reset. | 108 | * 0.53: 19 Mar 2006: Fix init from low power mode and add hw reset. |
109 | * 0.54: 21 Mar 2006: Fix spin locks for multi irqs and cleanup. | 109 | * 0.54: 21 Mar 2006: Fix spin locks for multi irqs and cleanup. |
110 | * 0.55: 22 Mar 2006: Add flow control (pause frame). | 110 | * 0.55: 22 Mar 2006: Add flow control (pause frame). |
111 | * 0.56: 22 Mar 2006: Additional ethtool config and moduleparam support. | ||
111 | * | 112 | * |
112 | * Known bugs: | 113 | * Known bugs: |
113 | * We suspect that on some hardware no TX done interrupts are generated. | 114 | * We suspect that on some hardware no TX done interrupts are generated. |
@@ -119,7 +120,7 @@ | |||
119 | * DEV_NEED_TIMERIRQ will not harm you on sane hardware, only generating a few | 120 | * DEV_NEED_TIMERIRQ will not harm you on sane hardware, only generating a few |
120 | * superfluous timer interrupts from the nic. | 121 | * superfluous timer interrupts from the nic. |
121 | */ | 122 | */ |
122 | #define FORCEDETH_VERSION "0.55" | 123 | #define FORCEDETH_VERSION "0.56" |
123 | #define DRV_NAME "forcedeth" | 124 | #define DRV_NAME "forcedeth" |
124 | 125 | ||
125 | #include <linux/module.h> | 126 | #include <linux/module.h> |
@@ -165,6 +166,8 @@ | |||
165 | #define DEV_HAS_MSI_X 0x0080 /* device supports MSI-X */ | 166 | #define DEV_HAS_MSI_X 0x0080 /* device supports MSI-X */ |
166 | #define DEV_HAS_POWER_CNTRL 0x0100 /* device supports power savings */ | 167 | #define DEV_HAS_POWER_CNTRL 0x0100 /* device supports power savings */ |
167 | #define DEV_HAS_PAUSEFRAME_TX 0x0200 /* device supports tx pause frames */ | 168 | #define DEV_HAS_PAUSEFRAME_TX 0x0200 /* device supports tx pause frames */ |
169 | #define DEV_HAS_STATISTICS 0x0400 /* device supports hw statistics */ | ||
170 | #define DEV_HAS_TEST_EXTENDED 0x0800 /* device supports extended diagnostic test */ | ||
168 | 171 | ||
169 | enum { | 172 | enum { |
170 | NvRegIrqStatus = 0x000, | 173 | NvRegIrqStatus = 0x000, |
@@ -221,6 +224,7 @@ enum { | |||
221 | #define NVREG_PFF_ALWAYS 0x7F0000 | 224 | #define NVREG_PFF_ALWAYS 0x7F0000 |
222 | #define NVREG_PFF_PROMISC 0x80 | 225 | #define NVREG_PFF_PROMISC 0x80 |
223 | #define NVREG_PFF_MYADDR 0x20 | 226 | #define NVREG_PFF_MYADDR 0x20 |
227 | #define NVREG_PFF_LOOPBACK 0x10 | ||
224 | 228 | ||
225 | NvRegOffloadConfig = 0x90, | 229 | NvRegOffloadConfig = 0x90, |
226 | #define NVREG_OFFLOAD_HOMEPHY 0x601 | 230 | #define NVREG_OFFLOAD_HOMEPHY 0x601 |
@@ -333,6 +337,33 @@ enum { | |||
333 | #define NVREG_POWERSTATE_D1 0x0001 | 337 | #define NVREG_POWERSTATE_D1 0x0001 |
334 | #define NVREG_POWERSTATE_D2 0x0002 | 338 | #define NVREG_POWERSTATE_D2 0x0002 |
335 | #define NVREG_POWERSTATE_D3 0x0003 | 339 | #define NVREG_POWERSTATE_D3 0x0003 |
340 | NvRegTxCnt = 0x280, | ||
341 | NvRegTxZeroReXmt = 0x284, | ||
342 | NvRegTxOneReXmt = 0x288, | ||
343 | NvRegTxManyReXmt = 0x28c, | ||
344 | NvRegTxLateCol = 0x290, | ||
345 | NvRegTxUnderflow = 0x294, | ||
346 | NvRegTxLossCarrier = 0x298, | ||
347 | NvRegTxExcessDef = 0x29c, | ||
348 | NvRegTxRetryErr = 0x2a0, | ||
349 | NvRegRxFrameErr = 0x2a4, | ||
350 | NvRegRxExtraByte = 0x2a8, | ||
351 | NvRegRxLateCol = 0x2ac, | ||
352 | NvRegRxRunt = 0x2b0, | ||
353 | NvRegRxFrameTooLong = 0x2b4, | ||
354 | NvRegRxOverflow = 0x2b8, | ||
355 | NvRegRxFCSErr = 0x2bc, | ||
356 | NvRegRxFrameAlignErr = 0x2c0, | ||
357 | NvRegRxLenErr = 0x2c4, | ||
358 | NvRegRxUnicast = 0x2c8, | ||
359 | NvRegRxMulticast = 0x2cc, | ||
360 | NvRegRxBroadcast = 0x2d0, | ||
361 | NvRegTxDef = 0x2d4, | ||
362 | NvRegTxFrame = 0x2d8, | ||
363 | NvRegRxCnt = 0x2dc, | ||
364 | NvRegTxPause = 0x2e0, | ||
365 | NvRegRxPause = 0x2e4, | ||
366 | NvRegRxDropFrame = 0x2e8, | ||
336 | NvRegVlanControl = 0x300, | 367 | NvRegVlanControl = 0x300, |
337 | #define NVREG_VLANCONTROL_ENABLE 0x2000 | 368 | #define NVREG_VLANCONTROL_ENABLE 0x2000 |
338 | NvRegMSIXMap0 = 0x3e0, | 369 | NvRegMSIXMap0 = 0x3e0, |
@@ -456,16 +487,18 @@ typedef union _ring_type { | |||
456 | /* General driver defaults */ | 487 | /* General driver defaults */ |
457 | #define NV_WATCHDOG_TIMEO (5*HZ) | 488 | #define NV_WATCHDOG_TIMEO (5*HZ) |
458 | 489 | ||
459 | #define RX_RING 128 | 490 | #define RX_RING_DEFAULT 128 |
460 | #define TX_RING 256 | 491 | #define TX_RING_DEFAULT 256 |
492 | #define RX_RING_MIN 128 | ||
493 | #define TX_RING_MIN 64 | ||
494 | #define RING_MAX_DESC_VER_1 1024 | ||
495 | #define RING_MAX_DESC_VER_2_3 16384 | ||
461 | /* | 496 | /* |
462 | * If your nic mysteriously hangs then try to reduce the limits | 497 | * Difference between the get and put pointers for the tx ring. |
463 | * to 1/0: It might be required to set NV_TX_LASTPACKET in the | 498 | * This is used to throttle the amount of data outstanding in the |
464 | * last valid ring entry. But this would be impossible to | 499 | * tx ring. |
465 | * implement - probably a disassembly error. | ||
466 | */ | 500 | */ |
467 | #define TX_LIMIT_STOP 255 | 501 | #define TX_LIMIT_DIFFERENCE 1 |
468 | #define TX_LIMIT_START 254 | ||
469 | 502 | ||
470 | /* rx/tx mac addr + type + vlan + align + slack*/ | 503 | /* rx/tx mac addr + type + vlan + align + slack*/ |
471 | #define NV_RX_HEADERS (64) | 504 | #define NV_RX_HEADERS (64) |
@@ -479,6 +512,7 @@ typedef union _ring_type { | |||
479 | #define OOM_REFILL (1+HZ/20) | 512 | #define OOM_REFILL (1+HZ/20) |
480 | #define POLL_WAIT (1+HZ/100) | 513 | #define POLL_WAIT (1+HZ/100) |
481 | #define LINK_TIMEOUT (3*HZ) | 514 | #define LINK_TIMEOUT (3*HZ) |
515 | #define STATS_INTERVAL (10*HZ) | ||
482 | 516 | ||
483 | /* | 517 | /* |
484 | * desc_ver values: | 518 | * desc_ver values: |
@@ -517,6 +551,9 @@ typedef union _ring_type { | |||
517 | #define NV_PAUSEFRAME_TX_CAPABLE 0x0002 | 551 | #define NV_PAUSEFRAME_TX_CAPABLE 0x0002 |
518 | #define NV_PAUSEFRAME_RX_ENABLE 0x0004 | 552 | #define NV_PAUSEFRAME_RX_ENABLE 0x0004 |
519 | #define NV_PAUSEFRAME_TX_ENABLE 0x0008 | 553 | #define NV_PAUSEFRAME_TX_ENABLE 0x0008 |
554 | #define NV_PAUSEFRAME_RX_REQ 0x0010 | ||
555 | #define NV_PAUSEFRAME_TX_REQ 0x0020 | ||
556 | #define NV_PAUSEFRAME_AUTONEG 0x0040 | ||
520 | 557 | ||
521 | /* MSI/MSI-X defines */ | 558 | /* MSI/MSI-X defines */ |
522 | #define NV_MSI_X_MAX_VECTORS 8 | 559 | #define NV_MSI_X_MAX_VECTORS 8 |
@@ -531,15 +568,110 @@ typedef union _ring_type { | |||
531 | #define NV_MSI_X_VECTOR_TX 0x1 | 568 | #define NV_MSI_X_VECTOR_TX 0x1 |
532 | #define NV_MSI_X_VECTOR_OTHER 0x2 | 569 | #define NV_MSI_X_VECTOR_OTHER 0x2 |
533 | 570 | ||
571 | /* statistics */ | ||
572 | struct nv_ethtool_str { | ||
573 | char name[ETH_GSTRING_LEN]; | ||
574 | }; | ||
575 | |||
576 | static const struct nv_ethtool_str nv_estats_str[] = { | ||
577 | { "tx_bytes" }, | ||
578 | { "tx_zero_rexmt" }, | ||
579 | { "tx_one_rexmt" }, | ||
580 | { "tx_many_rexmt" }, | ||
581 | { "tx_late_collision" }, | ||
582 | { "tx_fifo_errors" }, | ||
583 | { "tx_carrier_errors" }, | ||
584 | { "tx_excess_deferral" }, | ||
585 | { "tx_retry_error" }, | ||
586 | { "tx_deferral" }, | ||
587 | { "tx_packets" }, | ||
588 | { "tx_pause" }, | ||
589 | { "rx_frame_error" }, | ||
590 | { "rx_extra_byte" }, | ||
591 | { "rx_late_collision" }, | ||
592 | { "rx_runt" }, | ||
593 | { "rx_frame_too_long" }, | ||
594 | { "rx_over_errors" }, | ||
595 | { "rx_crc_errors" }, | ||
596 | { "rx_frame_align_error" }, | ||
597 | { "rx_length_error" }, | ||
598 | { "rx_unicast" }, | ||
599 | { "rx_multicast" }, | ||
600 | { "rx_broadcast" }, | ||
601 | { "rx_bytes" }, | ||
602 | { "rx_pause" }, | ||
603 | { "rx_drop_frame" }, | ||
604 | { "rx_packets" }, | ||
605 | { "rx_errors_total" } | ||
606 | }; | ||
607 | |||
608 | struct nv_ethtool_stats { | ||
609 | u64 tx_bytes; | ||
610 | u64 tx_zero_rexmt; | ||
611 | u64 tx_one_rexmt; | ||
612 | u64 tx_many_rexmt; | ||
613 | u64 tx_late_collision; | ||
614 | u64 tx_fifo_errors; | ||
615 | u64 tx_carrier_errors; | ||
616 | u64 tx_excess_deferral; | ||
617 | u64 tx_retry_error; | ||
618 | u64 tx_deferral; | ||
619 | u64 tx_packets; | ||
620 | u64 tx_pause; | ||
621 | u64 rx_frame_error; | ||
622 | u64 rx_extra_byte; | ||
623 | u64 rx_late_collision; | ||
624 | u64 rx_runt; | ||
625 | u64 rx_frame_too_long; | ||
626 | u64 rx_over_errors; | ||
627 | u64 rx_crc_errors; | ||
628 | u64 rx_frame_align_error; | ||
629 | u64 rx_length_error; | ||
630 | u64 rx_unicast; | ||
631 | u64 rx_multicast; | ||
632 | u64 rx_broadcast; | ||
633 | u64 rx_bytes; | ||
634 | u64 rx_pause; | ||
635 | u64 rx_drop_frame; | ||
636 | u64 rx_packets; | ||
637 | u64 rx_errors_total; | ||
638 | }; | ||
639 | |||
640 | /* diagnostics */ | ||
641 | #define NV_TEST_COUNT_BASE 3 | ||
642 | #define NV_TEST_COUNT_EXTENDED 4 | ||
643 | |||
644 | static const struct nv_ethtool_str nv_etests_str[] = { | ||
645 | { "link (online/offline)" }, | ||
646 | { "register (offline) " }, | ||
647 | { "interrupt (offline) " }, | ||
648 | { "loopback (offline) " } | ||
649 | }; | ||
650 | |||
651 | struct register_test { | ||
652 | u32 reg; | ||
653 | u32 mask; | ||
654 | }; | ||
655 | |||
656 | static const struct register_test nv_registers_test[] = { | ||
657 | { NvRegUnknownSetupReg6, 0x01 }, | ||
658 | { NvRegMisc1, 0x03c }, | ||
659 | { NvRegOffloadConfig, 0x03ff }, | ||
660 | { NvRegMulticastAddrA, 0xffffffff }, | ||
661 | { NvRegUnknownSetupReg3, 0x0ff }, | ||
662 | { NvRegWakeUpFlags, 0x07777 }, | ||
663 | { 0,0 } | ||
664 | }; | ||
665 | |||
534 | /* | 666 | /* |
535 | * SMP locking: | 667 | * SMP locking: |
536 | * All hardware access under dev->priv->lock, except the performance | 668 | * All hardware access under dev->priv->lock, except the performance |
537 | * critical parts: | 669 | * critical parts: |
538 | * - rx is (pseudo-) lockless: it relies on the single-threading provided | 670 | * - rx is (pseudo-) lockless: it relies on the single-threading provided |
539 | * by the arch code for interrupts. | 671 | * by the arch code for interrupts. |
540 | * - tx setup is lockless: it relies on dev->xmit_lock. Actual submission | 672 | * - tx setup is lockless: it relies on netif_tx_lock. Actual submission |
541 | * needs dev->priv->lock :-( | 673 | * needs dev->priv->lock :-( |
542 | * - set_multicast_list: preparation lockless, relies on dev->xmit_lock. | 674 | * - set_multicast_list: preparation lockless, relies on netif_tx_lock. |
543 | */ | 675 | */ |
544 | 676 | ||
545 | /* in dev: base, irq */ | 677 | /* in dev: base, irq */ |
@@ -549,6 +681,7 @@ struct fe_priv { | |||
549 | /* General data: | 681 | /* General data: |
550 | * Locking: spin_lock(&np->lock); */ | 682 | * Locking: spin_lock(&np->lock); */ |
551 | struct net_device_stats stats; | 683 | struct net_device_stats stats; |
684 | struct nv_ethtool_stats estats; | ||
552 | int in_shutdown; | 685 | int in_shutdown; |
553 | u32 linkspeed; | 686 | u32 linkspeed; |
554 | int duplex; | 687 | int duplex; |
@@ -558,6 +691,7 @@ struct fe_priv { | |||
558 | int wolenabled; | 691 | int wolenabled; |
559 | unsigned int phy_oui; | 692 | unsigned int phy_oui; |
560 | u16 gigabit; | 693 | u16 gigabit; |
694 | int intr_test; | ||
561 | 695 | ||
562 | /* General data: RO fields */ | 696 | /* General data: RO fields */ |
563 | dma_addr_t ring_addr; | 697 | dma_addr_t ring_addr; |
@@ -577,13 +711,15 @@ struct fe_priv { | |||
577 | */ | 711 | */ |
578 | ring_type rx_ring; | 712 | ring_type rx_ring; |
579 | unsigned int cur_rx, refill_rx; | 713 | unsigned int cur_rx, refill_rx; |
580 | struct sk_buff *rx_skbuff[RX_RING]; | 714 | struct sk_buff **rx_skbuff; |
581 | dma_addr_t rx_dma[RX_RING]; | 715 | dma_addr_t *rx_dma; |
582 | unsigned int rx_buf_sz; | 716 | unsigned int rx_buf_sz; |
583 | unsigned int pkt_limit; | 717 | unsigned int pkt_limit; |
584 | struct timer_list oom_kick; | 718 | struct timer_list oom_kick; |
585 | struct timer_list nic_poll; | 719 | struct timer_list nic_poll; |
720 | struct timer_list stats_poll; | ||
586 | u32 nic_poll_irq; | 721 | u32 nic_poll_irq; |
722 | int rx_ring_size; | ||
587 | 723 | ||
588 | /* media detection workaround. | 724 | /* media detection workaround. |
589 | * Locking: Within irq hander or disable_irq+spin_lock(&np->lock); | 725 | * Locking: Within irq hander or disable_irq+spin_lock(&np->lock); |
@@ -595,10 +731,13 @@ struct fe_priv { | |||
595 | */ | 731 | */ |
596 | ring_type tx_ring; | 732 | ring_type tx_ring; |
597 | unsigned int next_tx, nic_tx; | 733 | unsigned int next_tx, nic_tx; |
598 | struct sk_buff *tx_skbuff[TX_RING]; | 734 | struct sk_buff **tx_skbuff; |
599 | dma_addr_t tx_dma[TX_RING]; | 735 | dma_addr_t *tx_dma; |
600 | unsigned int tx_dma_len[TX_RING]; | 736 | unsigned int *tx_dma_len; |
601 | u32 tx_flags; | 737 | u32 tx_flags; |
738 | int tx_ring_size; | ||
739 | int tx_limit_start; | ||
740 | int tx_limit_stop; | ||
602 | 741 | ||
603 | /* vlan fields */ | 742 | /* vlan fields */ |
604 | struct vlan_group *vlangrp; | 743 | struct vlan_group *vlangrp; |
@@ -623,8 +762,10 @@ static int max_interrupt_work = 5; | |||
623 | * Throughput Mode: Every tx and rx packet will generate an interrupt. | 762 | * Throughput Mode: Every tx and rx packet will generate an interrupt. |
624 | * CPU Mode: Interrupts are controlled by a timer. | 763 | * CPU Mode: Interrupts are controlled by a timer. |
625 | */ | 764 | */ |
626 | #define NV_OPTIMIZATION_MODE_THROUGHPUT 0 | 765 | enum { |
627 | #define NV_OPTIMIZATION_MODE_CPU 1 | 766 | NV_OPTIMIZATION_MODE_THROUGHPUT, |
767 | NV_OPTIMIZATION_MODE_CPU | ||
768 | }; | ||
628 | static int optimization_mode = NV_OPTIMIZATION_MODE_THROUGHPUT; | 769 | static int optimization_mode = NV_OPTIMIZATION_MODE_THROUGHPUT; |
629 | 770 | ||
630 | /* | 771 | /* |
@@ -637,14 +778,31 @@ static int optimization_mode = NV_OPTIMIZATION_MODE_THROUGHPUT; | |||
637 | static int poll_interval = -1; | 778 | static int poll_interval = -1; |
638 | 779 | ||
639 | /* | 780 | /* |
640 | * Disable MSI interrupts | 781 | * MSI interrupts |
782 | */ | ||
783 | enum { | ||
784 | NV_MSI_INT_DISABLED, | ||
785 | NV_MSI_INT_ENABLED | ||
786 | }; | ||
787 | static int msi = NV_MSI_INT_ENABLED; | ||
788 | |||
789 | /* | ||
790 | * MSIX interrupts | ||
641 | */ | 791 | */ |
642 | static int disable_msi = 0; | 792 | enum { |
793 | NV_MSIX_INT_DISABLED, | ||
794 | NV_MSIX_INT_ENABLED | ||
795 | }; | ||
796 | static int msix = NV_MSIX_INT_ENABLED; | ||
643 | 797 | ||
644 | /* | 798 | /* |
645 | * Disable MSIX interrupts | 799 | * DMA 64bit |
646 | */ | 800 | */ |
647 | static int disable_msix = 0; | 801 | enum { |
802 | NV_DMA_64BIT_DISABLED, | ||
803 | NV_DMA_64BIT_ENABLED | ||
804 | }; | ||
805 | static int dma_64bit = NV_DMA_64BIT_ENABLED; | ||
648 | 806 | ||
649 | static inline struct fe_priv *get_nvpriv(struct net_device *dev) | 807 | static inline struct fe_priv *get_nvpriv(struct net_device *dev) |
650 | { | 808 | { |
@@ -704,7 +862,7 @@ static void setup_hw_rings(struct net_device *dev, int rxtx_flags) | |||
704 | writel((u32) cpu_to_le64(np->ring_addr), base + NvRegRxRingPhysAddr); | 862 | writel((u32) cpu_to_le64(np->ring_addr), base + NvRegRxRingPhysAddr); |
705 | } | 863 | } |
706 | if (rxtx_flags & NV_SETUP_TX_RING) { | 864 | if (rxtx_flags & NV_SETUP_TX_RING) { |
707 | writel((u32) cpu_to_le64(np->ring_addr + RX_RING*sizeof(struct ring_desc)), base + NvRegTxRingPhysAddr); | 865 | writel((u32) cpu_to_le64(np->ring_addr + np->rx_ring_size*sizeof(struct ring_desc)), base + NvRegTxRingPhysAddr); |
708 | } | 866 | } |
709 | } else { | 867 | } else { |
710 | if (rxtx_flags & NV_SETUP_RX_RING) { | 868 | if (rxtx_flags & NV_SETUP_RX_RING) { |
@@ -712,12 +870,37 @@ static void setup_hw_rings(struct net_device *dev, int rxtx_flags) | |||
712 | writel((u32) (cpu_to_le64(np->ring_addr) >> 32), base + NvRegRxRingPhysAddrHigh); | 870 | writel((u32) (cpu_to_le64(np->ring_addr) >> 32), base + NvRegRxRingPhysAddrHigh); |
713 | } | 871 | } |
714 | if (rxtx_flags & NV_SETUP_TX_RING) { | 872 | if (rxtx_flags & NV_SETUP_TX_RING) { |
715 | writel((u32) cpu_to_le64(np->ring_addr + RX_RING*sizeof(struct ring_desc_ex)), base + NvRegTxRingPhysAddr); | 873 | writel((u32) cpu_to_le64(np->ring_addr + np->rx_ring_size*sizeof(struct ring_desc_ex)), base + NvRegTxRingPhysAddr); |
716 | writel((u32) (cpu_to_le64(np->ring_addr + RX_RING*sizeof(struct ring_desc_ex)) >> 32), base + NvRegTxRingPhysAddrHigh); | 874 | writel((u32) (cpu_to_le64(np->ring_addr + np->rx_ring_size*sizeof(struct ring_desc_ex)) >> 32), base + NvRegTxRingPhysAddrHigh); |
717 | } | 875 | } |
718 | } | 876 | } |
719 | } | 877 | } |
720 | 878 | ||
879 | static void free_rings(struct net_device *dev) | ||
880 | { | ||
881 | struct fe_priv *np = get_nvpriv(dev); | ||
882 | |||
883 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | ||
884 | if(np->rx_ring.orig) | ||
885 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc) * (np->rx_ring_size + np->tx_ring_size), | ||
886 | np->rx_ring.orig, np->ring_addr); | ||
887 | } else { | ||
888 | if (np->rx_ring.ex) | ||
889 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc_ex) * (np->rx_ring_size + np->tx_ring_size), | ||
890 | np->rx_ring.ex, np->ring_addr); | ||
891 | } | ||
892 | if (np->rx_skbuff) | ||
893 | kfree(np->rx_skbuff); | ||
894 | if (np->rx_dma) | ||
895 | kfree(np->rx_dma); | ||
896 | if (np->tx_skbuff) | ||
897 | kfree(np->tx_skbuff); | ||
898 | if (np->tx_dma) | ||
899 | kfree(np->tx_dma); | ||
900 | if (np->tx_dma_len) | ||
901 | kfree(np->tx_dma_len); | ||
902 | } | ||
903 | |||
721 | static int using_multi_irqs(struct net_device *dev) | 904 | static int using_multi_irqs(struct net_device *dev) |
722 | { | 905 | { |
723 | struct fe_priv *np = get_nvpriv(dev); | 906 | struct fe_priv *np = get_nvpriv(dev); |
@@ -1056,7 +1239,7 @@ static int nv_alloc_rx(struct net_device *dev) | |||
1056 | while (np->cur_rx != refill_rx) { | 1239 | while (np->cur_rx != refill_rx) { |
1057 | struct sk_buff *skb; | 1240 | struct sk_buff *skb; |
1058 | 1241 | ||
1059 | nr = refill_rx % RX_RING; | 1242 | nr = refill_rx % np->rx_ring_size; |
1060 | if (np->rx_skbuff[nr] == NULL) { | 1243 | if (np->rx_skbuff[nr] == NULL) { |
1061 | 1244 | ||
1062 | skb = dev_alloc_skb(np->rx_buf_sz + NV_RX_ALLOC_PAD); | 1245 | skb = dev_alloc_skb(np->rx_buf_sz + NV_RX_ALLOC_PAD); |
@@ -1085,7 +1268,7 @@ static int nv_alloc_rx(struct net_device *dev) | |||
1085 | refill_rx++; | 1268 | refill_rx++; |
1086 | } | 1269 | } |
1087 | np->refill_rx = refill_rx; | 1270 | np->refill_rx = refill_rx; |
1088 | if (np->cur_rx - refill_rx == RX_RING) | 1271 | if (np->cur_rx - refill_rx == np->rx_ring_size) |
1089 | return 1; | 1272 | return 1; |
1090 | return 0; | 1273 | return 0; |
1091 | } | 1274 | } |
@@ -1124,9 +1307,9 @@ static void nv_init_rx(struct net_device *dev) | |||
1124 | struct fe_priv *np = netdev_priv(dev); | 1307 | struct fe_priv *np = netdev_priv(dev); |
1125 | int i; | 1308 | int i; |
1126 | 1309 | ||
1127 | np->cur_rx = RX_RING; | 1310 | np->cur_rx = np->rx_ring_size; |
1128 | np->refill_rx = 0; | 1311 | np->refill_rx = 0; |
1129 | for (i = 0; i < RX_RING; i++) | 1312 | for (i = 0; i < np->rx_ring_size; i++) |
1130 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) | 1313 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) |
1131 | np->rx_ring.orig[i].FlagLen = 0; | 1314 | np->rx_ring.orig[i].FlagLen = 0; |
1132 | else | 1315 | else |
@@ -1139,7 +1322,7 @@ static void nv_init_tx(struct net_device *dev) | |||
1139 | int i; | 1322 | int i; |
1140 | 1323 | ||
1141 | np->next_tx = np->nic_tx = 0; | 1324 | np->next_tx = np->nic_tx = 0; |
1142 | for (i = 0; i < TX_RING; i++) { | 1325 | for (i = 0; i < np->tx_ring_size; i++) { |
1143 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) | 1326 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) |
1144 | np->tx_ring.orig[i].FlagLen = 0; | 1327 | np->tx_ring.orig[i].FlagLen = 0; |
1145 | else | 1328 | else |
@@ -1184,7 +1367,7 @@ static void nv_drain_tx(struct net_device *dev) | |||
1184 | struct fe_priv *np = netdev_priv(dev); | 1367 | struct fe_priv *np = netdev_priv(dev); |
1185 | unsigned int i; | 1368 | unsigned int i; |
1186 | 1369 | ||
1187 | for (i = 0; i < TX_RING; i++) { | 1370 | for (i = 0; i < np->tx_ring_size; i++) { |
1188 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) | 1371 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) |
1189 | np->tx_ring.orig[i].FlagLen = 0; | 1372 | np->tx_ring.orig[i].FlagLen = 0; |
1190 | else | 1373 | else |
@@ -1198,7 +1381,7 @@ static void nv_drain_rx(struct net_device *dev) | |||
1198 | { | 1381 | { |
1199 | struct fe_priv *np = netdev_priv(dev); | 1382 | struct fe_priv *np = netdev_priv(dev); |
1200 | int i; | 1383 | int i; |
1201 | for (i = 0; i < RX_RING; i++) { | 1384 | for (i = 0; i < np->rx_ring_size; i++) { |
1202 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) | 1385 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) |
1203 | np->rx_ring.orig[i].FlagLen = 0; | 1386 | np->rx_ring.orig[i].FlagLen = 0; |
1204 | else | 1387 | else |
@@ -1222,7 +1405,7 @@ static void drain_ring(struct net_device *dev) | |||
1222 | 1405 | ||
1223 | /* | 1406 | /* |
1224 | * nv_start_xmit: dev->hard_start_xmit function | 1407 | * nv_start_xmit: dev->hard_start_xmit function |
1225 | * Called with dev->xmit_lock held. | 1408 | * Called with netif_tx_lock held. |
1226 | */ | 1409 | */ |
1227 | static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev) | 1410 | static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev) |
1228 | { | 1411 | { |
@@ -1230,8 +1413,8 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1230 | u32 tx_flags = 0; | 1413 | u32 tx_flags = 0; |
1231 | u32 tx_flags_extra = (np->desc_ver == DESC_VER_1 ? NV_TX_LASTPACKET : NV_TX2_LASTPACKET); | 1414 | u32 tx_flags_extra = (np->desc_ver == DESC_VER_1 ? NV_TX_LASTPACKET : NV_TX2_LASTPACKET); |
1232 | unsigned int fragments = skb_shinfo(skb)->nr_frags; | 1415 | unsigned int fragments = skb_shinfo(skb)->nr_frags; |
1233 | unsigned int nr = (np->next_tx - 1) % TX_RING; | 1416 | unsigned int nr = (np->next_tx - 1) % np->tx_ring_size; |
1234 | unsigned int start_nr = np->next_tx % TX_RING; | 1417 | unsigned int start_nr = np->next_tx % np->tx_ring_size; |
1235 | unsigned int i; | 1418 | unsigned int i; |
1236 | u32 offset = 0; | 1419 | u32 offset = 0; |
1237 | u32 bcnt; | 1420 | u32 bcnt; |
@@ -1247,7 +1430,7 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1247 | 1430 | ||
1248 | spin_lock_irq(&np->lock); | 1431 | spin_lock_irq(&np->lock); |
1249 | 1432 | ||
1250 | if ((np->next_tx - np->nic_tx + entries - 1) > TX_LIMIT_STOP) { | 1433 | if ((np->next_tx - np->nic_tx + entries - 1) > np->tx_limit_stop) { |
1251 | spin_unlock_irq(&np->lock); | 1434 | spin_unlock_irq(&np->lock); |
1252 | netif_stop_queue(dev); | 1435 | netif_stop_queue(dev); |
1253 | return NETDEV_TX_BUSY; | 1436 | return NETDEV_TX_BUSY; |
@@ -1256,7 +1439,7 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1256 | /* setup the header buffer */ | 1439 | /* setup the header buffer */ |
1257 | do { | 1440 | do { |
1258 | bcnt = (size > NV_TX2_TSO_MAX_SIZE) ? NV_TX2_TSO_MAX_SIZE : size; | 1441 | bcnt = (size > NV_TX2_TSO_MAX_SIZE) ? NV_TX2_TSO_MAX_SIZE : size; |
1259 | nr = (nr + 1) % TX_RING; | 1442 | nr = (nr + 1) % np->tx_ring_size; |
1260 | 1443 | ||
1261 | np->tx_dma[nr] = pci_map_single(np->pci_dev, skb->data + offset, bcnt, | 1444 | np->tx_dma[nr] = pci_map_single(np->pci_dev, skb->data + offset, bcnt, |
1262 | PCI_DMA_TODEVICE); | 1445 | PCI_DMA_TODEVICE); |
@@ -1283,7 +1466,7 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1283 | 1466 | ||
1284 | do { | 1467 | do { |
1285 | bcnt = (size > NV_TX2_TSO_MAX_SIZE) ? NV_TX2_TSO_MAX_SIZE : size; | 1468 | bcnt = (size > NV_TX2_TSO_MAX_SIZE) ? NV_TX2_TSO_MAX_SIZE : size; |
1286 | nr = (nr + 1) % TX_RING; | 1469 | nr = (nr + 1) % np->tx_ring_size; |
1287 | 1470 | ||
1288 | np->tx_dma[nr] = pci_map_page(np->pci_dev, frag->page, frag->page_offset+offset, bcnt, | 1471 | np->tx_dma[nr] = pci_map_page(np->pci_dev, frag->page, frag->page_offset+offset, bcnt, |
1289 | PCI_DMA_TODEVICE); | 1472 | PCI_DMA_TODEVICE); |
@@ -1365,7 +1548,7 @@ static void nv_tx_done(struct net_device *dev) | |||
1365 | struct sk_buff *skb; | 1548 | struct sk_buff *skb; |
1366 | 1549 | ||
1367 | while (np->nic_tx != np->next_tx) { | 1550 | while (np->nic_tx != np->next_tx) { |
1368 | i = np->nic_tx % TX_RING; | 1551 | i = np->nic_tx % np->tx_ring_size; |
1369 | 1552 | ||
1370 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) | 1553 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) |
1371 | Flags = le32_to_cpu(np->tx_ring.orig[i].FlagLen); | 1554 | Flags = le32_to_cpu(np->tx_ring.orig[i].FlagLen); |
@@ -1410,13 +1593,13 @@ static void nv_tx_done(struct net_device *dev) | |||
1410 | nv_release_txskb(dev, i); | 1593 | nv_release_txskb(dev, i); |
1411 | np->nic_tx++; | 1594 | np->nic_tx++; |
1412 | } | 1595 | } |
1413 | if (np->next_tx - np->nic_tx < TX_LIMIT_START) | 1596 | if (np->next_tx - np->nic_tx < np->tx_limit_start) |
1414 | netif_wake_queue(dev); | 1597 | netif_wake_queue(dev); |
1415 | } | 1598 | } |
1416 | 1599 | ||
1417 | /* | 1600 | /* |
1418 | * nv_tx_timeout: dev->tx_timeout function | 1601 | * nv_tx_timeout: dev->tx_timeout function |
1419 | * Called with dev->xmit_lock held. | 1602 | * Called with netif_tx_lock held. |
1420 | */ | 1603 | */ |
1421 | static void nv_tx_timeout(struct net_device *dev) | 1604 | static void nv_tx_timeout(struct net_device *dev) |
1422 | { | 1605 | { |
@@ -1447,7 +1630,7 @@ static void nv_tx_timeout(struct net_device *dev) | |||
1447 | readl(base + i + 24), readl(base + i + 28)); | 1630 | readl(base + i + 24), readl(base + i + 28)); |
1448 | } | 1631 | } |
1449 | printk(KERN_INFO "%s: Dumping tx ring\n", dev->name); | 1632 | printk(KERN_INFO "%s: Dumping tx ring\n", dev->name); |
1450 | for (i=0;i<TX_RING;i+= 4) { | 1633 | for (i=0;i<np->tx_ring_size;i+= 4) { |
1451 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | 1634 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { |
1452 | printk(KERN_INFO "%03x: %08x %08x // %08x %08x // %08x %08x // %08x %08x\n", | 1635 | printk(KERN_INFO "%03x: %08x %08x // %08x %08x // %08x %08x // %08x %08x\n", |
1453 | i, | 1636 | i, |
@@ -1563,10 +1746,10 @@ static void nv_rx_process(struct net_device *dev) | |||
1563 | struct sk_buff *skb; | 1746 | struct sk_buff *skb; |
1564 | int len; | 1747 | int len; |
1565 | int i; | 1748 | int i; |
1566 | if (np->cur_rx - np->refill_rx >= RX_RING) | 1749 | if (np->cur_rx - np->refill_rx >= np->rx_ring_size) |
1567 | break; /* we scanned the whole ring - do not continue */ | 1750 | break; /* we scanned the whole ring - do not continue */ |
1568 | 1751 | ||
1569 | i = np->cur_rx % RX_RING; | 1752 | i = np->cur_rx % np->rx_ring_size; |
1570 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | 1753 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { |
1571 | Flags = le32_to_cpu(np->rx_ring.orig[i].FlagLen); | 1754 | Flags = le32_to_cpu(np->rx_ring.orig[i].FlagLen); |
1572 | len = nv_descr_getlength(&np->rx_ring.orig[i], np->desc_ver); | 1755 | len = nv_descr_getlength(&np->rx_ring.orig[i], np->desc_ver); |
@@ -1673,14 +1856,16 @@ static void nv_rx_process(struct net_device *dev) | |||
1673 | } | 1856 | } |
1674 | } | 1857 | } |
1675 | } | 1858 | } |
1676 | Flags &= NV_RX2_CHECKSUMMASK; | 1859 | if (np->txrxctl_bits & NVREG_TXRXCTL_RXCHECK) { |
1677 | if (Flags == NV_RX2_CHECKSUMOK1 || | 1860 | Flags &= NV_RX2_CHECKSUMMASK; |
1678 | Flags == NV_RX2_CHECKSUMOK2 || | 1861 | if (Flags == NV_RX2_CHECKSUMOK1 || |
1679 | Flags == NV_RX2_CHECKSUMOK3) { | 1862 | Flags == NV_RX2_CHECKSUMOK2 || |
1680 | dprintk(KERN_DEBUG "%s: hw checksum hit!.\n", dev->name); | 1863 | Flags == NV_RX2_CHECKSUMOK3) { |
1681 | np->rx_skbuff[i]->ip_summed = CHECKSUM_UNNECESSARY; | 1864 | dprintk(KERN_DEBUG "%s: hw checksum hit!.\n", dev->name); |
1682 | } else { | 1865 | np->rx_skbuff[i]->ip_summed = CHECKSUM_UNNECESSARY; |
1683 | dprintk(KERN_DEBUG "%s: hwchecksum miss!.\n", dev->name); | 1866 | } else { |
1867 | dprintk(KERN_DEBUG "%s: hwchecksum miss!.\n", dev->name); | ||
1868 | } | ||
1684 | } | 1869 | } |
1685 | } | 1870 | } |
1686 | /* got a valid packet - forward it to the network core */ | 1871 | /* got a valid packet - forward it to the network core */ |
@@ -1745,7 +1930,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu) | |||
1745 | * Changing the MTU is a rare event, it shouldn't matter. | 1930 | * Changing the MTU is a rare event, it shouldn't matter. |
1746 | */ | 1931 | */ |
1747 | nv_disable_irq(dev); | 1932 | nv_disable_irq(dev); |
1748 | spin_lock_bh(&dev->xmit_lock); | 1933 | netif_tx_lock_bh(dev); |
1749 | spin_lock(&np->lock); | 1934 | spin_lock(&np->lock); |
1750 | /* stop engines */ | 1935 | /* stop engines */ |
1751 | nv_stop_rx(dev); | 1936 | nv_stop_rx(dev); |
@@ -1755,18 +1940,15 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu) | |||
1755 | nv_drain_rx(dev); | 1940 | nv_drain_rx(dev); |
1756 | nv_drain_tx(dev); | 1941 | nv_drain_tx(dev); |
1757 | /* reinit driver view of the rx queue */ | 1942 | /* reinit driver view of the rx queue */ |
1758 | nv_init_rx(dev); | ||
1759 | nv_init_tx(dev); | ||
1760 | /* alloc new rx buffers */ | ||
1761 | set_bufsize(dev); | 1943 | set_bufsize(dev); |
1762 | if (nv_alloc_rx(dev)) { | 1944 | if (nv_init_ring(dev)) { |
1763 | if (!np->in_shutdown) | 1945 | if (!np->in_shutdown) |
1764 | mod_timer(&np->oom_kick, jiffies + OOM_REFILL); | 1946 | mod_timer(&np->oom_kick, jiffies + OOM_REFILL); |
1765 | } | 1947 | } |
1766 | /* reinit nic view of the rx queue */ | 1948 | /* reinit nic view of the rx queue */ |
1767 | writel(np->rx_buf_sz, base + NvRegOffloadConfig); | 1949 | writel(np->rx_buf_sz, base + NvRegOffloadConfig); |
1768 | setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING); | 1950 | setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING); |
1769 | writel( ((RX_RING-1) << NVREG_RINGSZ_RXSHIFT) + ((TX_RING-1) << NVREG_RINGSZ_TXSHIFT), | 1951 | writel( ((np->rx_ring_size-1) << NVREG_RINGSZ_RXSHIFT) + ((np->tx_ring_size-1) << NVREG_RINGSZ_TXSHIFT), |
1770 | base + NvRegRingSizes); | 1952 | base + NvRegRingSizes); |
1771 | pci_push(base); | 1953 | pci_push(base); |
1772 | writel(NVREG_TXRXCTL_KICK|np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl); | 1954 | writel(NVREG_TXRXCTL_KICK|np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl); |
@@ -1776,7 +1958,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu) | |||
1776 | nv_start_rx(dev); | 1958 | nv_start_rx(dev); |
1777 | nv_start_tx(dev); | 1959 | nv_start_tx(dev); |
1778 | spin_unlock(&np->lock); | 1960 | spin_unlock(&np->lock); |
1779 | spin_unlock_bh(&dev->xmit_lock); | 1961 | netif_tx_unlock_bh(dev); |
1780 | nv_enable_irq(dev); | 1962 | nv_enable_irq(dev); |
1781 | } | 1963 | } |
1782 | return 0; | 1964 | return 0; |
@@ -1811,7 +1993,7 @@ static int nv_set_mac_address(struct net_device *dev, void *addr) | |||
1811 | memcpy(dev->dev_addr, macaddr->sa_data, ETH_ALEN); | 1993 | memcpy(dev->dev_addr, macaddr->sa_data, ETH_ALEN); |
1812 | 1994 | ||
1813 | if (netif_running(dev)) { | 1995 | if (netif_running(dev)) { |
1814 | spin_lock_bh(&dev->xmit_lock); | 1996 | netif_tx_lock_bh(dev); |
1815 | spin_lock_irq(&np->lock); | 1997 | spin_lock_irq(&np->lock); |
1816 | 1998 | ||
1817 | /* stop rx engine */ | 1999 | /* stop rx engine */ |
@@ -1823,7 +2005,7 @@ static int nv_set_mac_address(struct net_device *dev, void *addr) | |||
1823 | /* restart rx engine */ | 2005 | /* restart rx engine */ |
1824 | nv_start_rx(dev); | 2006 | nv_start_rx(dev); |
1825 | spin_unlock_irq(&np->lock); | 2007 | spin_unlock_irq(&np->lock); |
1826 | spin_unlock_bh(&dev->xmit_lock); | 2008 | netif_tx_unlock_bh(dev); |
1827 | } else { | 2009 | } else { |
1828 | nv_copy_mac_to_hw(dev); | 2010 | nv_copy_mac_to_hw(dev); |
1829 | } | 2011 | } |
@@ -1832,7 +2014,7 @@ static int nv_set_mac_address(struct net_device *dev, void *addr) | |||
1832 | 2014 | ||
1833 | /* | 2015 | /* |
1834 | * nv_set_multicast: dev->set_multicast function | 2016 | * nv_set_multicast: dev->set_multicast function |
1835 | * Called with dev->xmit_lock held. | 2017 | * Called with netif_tx_lock held. |
1836 | */ | 2018 | */ |
1837 | static void nv_set_multicast(struct net_device *dev) | 2019 | static void nv_set_multicast(struct net_device *dev) |
1838 | { | 2020 | { |
@@ -1840,16 +2022,16 @@ static void nv_set_multicast(struct net_device *dev) | |||
1840 | u8 __iomem *base = get_hwbase(dev); | 2022 | u8 __iomem *base = get_hwbase(dev); |
1841 | u32 addr[2]; | 2023 | u32 addr[2]; |
1842 | u32 mask[2]; | 2024 | u32 mask[2]; |
1843 | u32 pff; | 2025 | u32 pff = readl(base + NvRegPacketFilterFlags) & NVREG_PFF_PAUSE_RX; |
1844 | 2026 | ||
1845 | memset(addr, 0, sizeof(addr)); | 2027 | memset(addr, 0, sizeof(addr)); |
1846 | memset(mask, 0, sizeof(mask)); | 2028 | memset(mask, 0, sizeof(mask)); |
1847 | 2029 | ||
1848 | if (dev->flags & IFF_PROMISC) { | 2030 | if (dev->flags & IFF_PROMISC) { |
1849 | printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); | 2031 | printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); |
1850 | pff = NVREG_PFF_PROMISC; | 2032 | pff |= NVREG_PFF_PROMISC; |
1851 | } else { | 2033 | } else { |
1852 | pff = NVREG_PFF_MYADDR; | 2034 | pff |= NVREG_PFF_MYADDR; |
1853 | 2035 | ||
1854 | if (dev->flags & IFF_ALLMULTI || dev->mc_list) { | 2036 | if (dev->flags & IFF_ALLMULTI || dev->mc_list) { |
1855 | u32 alwaysOff[2]; | 2037 | u32 alwaysOff[2]; |
@@ -1894,6 +2076,35 @@ static void nv_set_multicast(struct net_device *dev) | |||
1894 | spin_unlock_irq(&np->lock); | 2076 | spin_unlock_irq(&np->lock); |
1895 | } | 2077 | } |
1896 | 2078 | ||
2079 | void nv_update_pause(struct net_device *dev, u32 pause_flags) | ||
2080 | { | ||
2081 | struct fe_priv *np = netdev_priv(dev); | ||
2082 | u8 __iomem *base = get_hwbase(dev); | ||
2083 | |||
2084 | np->pause_flags &= ~(NV_PAUSEFRAME_TX_ENABLE | NV_PAUSEFRAME_RX_ENABLE); | ||
2085 | |||
2086 | if (np->pause_flags & NV_PAUSEFRAME_RX_CAPABLE) { | ||
2087 | u32 pff = readl(base + NvRegPacketFilterFlags) & ~NVREG_PFF_PAUSE_RX; | ||
2088 | if (pause_flags & NV_PAUSEFRAME_RX_ENABLE) { | ||
2089 | writel(pff|NVREG_PFF_PAUSE_RX, base + NvRegPacketFilterFlags); | ||
2090 | np->pause_flags |= NV_PAUSEFRAME_RX_ENABLE; | ||
2091 | } else { | ||
2092 | writel(pff, base + NvRegPacketFilterFlags); | ||
2093 | } | ||
2094 | } | ||
2095 | if (np->pause_flags & NV_PAUSEFRAME_TX_CAPABLE) { | ||
2096 | u32 regmisc = readl(base + NvRegMisc1) & ~NVREG_MISC1_PAUSE_TX; | ||
2097 | if (pause_flags & NV_PAUSEFRAME_TX_ENABLE) { | ||
2098 | writel(NVREG_TX_PAUSEFRAME_ENABLE, base + NvRegTxPauseFrame); | ||
2099 | writel(regmisc|NVREG_MISC1_PAUSE_TX, base + NvRegMisc1); | ||
2100 | np->pause_flags |= NV_PAUSEFRAME_TX_ENABLE; | ||
2101 | } else { | ||
2102 | writel(NVREG_TX_PAUSEFRAME_DISABLE, base + NvRegTxPauseFrame); | ||
2103 | writel(regmisc, base + NvRegMisc1); | ||
2104 | } | ||
2105 | } | ||
2106 | } | ||
2107 | |||
1897 | /** | 2108 | /** |
1898 | * nv_update_linkspeed: Setup the MAC according to the link partner | 2109 | * nv_update_linkspeed: Setup the MAC according to the link partner |
1899 | * @dev: Network device to be configured | 2110 | * @dev: Network device to be configured |
@@ -1916,7 +2127,7 @@ static int nv_update_linkspeed(struct net_device *dev) | |||
1916 | int newdup = np->duplex; | 2127 | int newdup = np->duplex; |
1917 | int mii_status; | 2128 | int mii_status; |
1918 | int retval = 0; | 2129 | int retval = 0; |
1919 | u32 control_1000, status_1000, phyreg; | 2130 | u32 control_1000, status_1000, phyreg, pause_flags; |
1920 | 2131 | ||
1921 | /* BMSR_LSTATUS is latched, read it twice: | 2132 | /* BMSR_LSTATUS is latched, read it twice: |
1922 | * we want the current value. | 2133 | * we want the current value. |
@@ -1962,6 +2173,11 @@ static int nv_update_linkspeed(struct net_device *dev) | |||
1962 | goto set_speed; | 2173 | goto set_speed; |
1963 | } | 2174 | } |
1964 | 2175 | ||
2176 | adv = mii_rw(dev, np->phyaddr, MII_ADVERTISE, MII_READ); | ||
2177 | lpa = mii_rw(dev, np->phyaddr, MII_LPA, MII_READ); | ||
2178 | dprintk(KERN_DEBUG "%s: nv_update_linkspeed: PHY advertises 0x%04x, lpa 0x%04x.\n", | ||
2179 | dev->name, adv, lpa); | ||
2180 | |||
1965 | retval = 1; | 2181 | retval = 1; |
1966 | if (np->gigabit == PHY_GIGABIT) { | 2182 | if (np->gigabit == PHY_GIGABIT) { |
1967 | control_1000 = mii_rw(dev, np->phyaddr, MII_CTRL1000, MII_READ); | 2183 | control_1000 = mii_rw(dev, np->phyaddr, MII_CTRL1000, MII_READ); |
@@ -1977,11 +2193,6 @@ static int nv_update_linkspeed(struct net_device *dev) | |||
1977 | } | 2193 | } |
1978 | } | 2194 | } |
1979 | 2195 | ||
1980 | adv = mii_rw(dev, np->phyaddr, MII_ADVERTISE, MII_READ); | ||
1981 | lpa = mii_rw(dev, np->phyaddr, MII_LPA, MII_READ); | ||
1982 | dprintk(KERN_DEBUG "%s: nv_update_linkspeed: PHY advertises 0x%04x, lpa 0x%04x.\n", | ||
1983 | dev->name, adv, lpa); | ||
1984 | |||
1985 | /* FIXME: handle parallel detection properly */ | 2196 | /* FIXME: handle parallel detection properly */ |
1986 | adv_lpa = lpa & adv; | 2197 | adv_lpa = lpa & adv; |
1987 | if (adv_lpa & LPA_100FULL) { | 2198 | if (adv_lpa & LPA_100FULL) { |
@@ -2040,55 +2251,45 @@ set_speed: | |||
2040 | writel(np->linkspeed, base + NvRegLinkSpeed); | 2251 | writel(np->linkspeed, base + NvRegLinkSpeed); |
2041 | pci_push(base); | 2252 | pci_push(base); |
2042 | 2253 | ||
2043 | /* setup pause frame based on advertisement and link partner */ | 2254 | pause_flags = 0; |
2044 | np->pause_flags &= ~(NV_PAUSEFRAME_TX_ENABLE | NV_PAUSEFRAME_RX_ENABLE); | 2255 | /* setup pause frame */ |
2045 | |||
2046 | if (np->duplex != 0) { | 2256 | if (np->duplex != 0) { |
2047 | adv_pause = adv & (ADVERTISE_PAUSE_CAP| ADVERTISE_PAUSE_ASYM); | 2257 | if (np->autoneg && np->pause_flags & NV_PAUSEFRAME_AUTONEG) { |
2048 | lpa_pause = lpa & (LPA_PAUSE_CAP| LPA_PAUSE_ASYM); | 2258 | adv_pause = adv & (ADVERTISE_PAUSE_CAP| ADVERTISE_PAUSE_ASYM); |
2049 | 2259 | lpa_pause = lpa & (LPA_PAUSE_CAP| LPA_PAUSE_ASYM); | |
2050 | switch (adv_pause) { | 2260 | |
2051 | case (ADVERTISE_PAUSE_CAP): | 2261 | switch (adv_pause) { |
2052 | if (lpa_pause & LPA_PAUSE_CAP) { | 2262 | case (ADVERTISE_PAUSE_CAP): |
2053 | np->pause_flags |= NV_PAUSEFRAME_TX_ENABLE | NV_PAUSEFRAME_RX_ENABLE; | 2263 | if (lpa_pause & LPA_PAUSE_CAP) { |
2054 | } | 2264 | pause_flags |= NV_PAUSEFRAME_RX_ENABLE; |
2055 | break; | 2265 | if (np->pause_flags & NV_PAUSEFRAME_TX_REQ) |
2056 | case (ADVERTISE_PAUSE_ASYM): | 2266 | pause_flags |= NV_PAUSEFRAME_TX_ENABLE; |
2057 | if (lpa_pause == (LPA_PAUSE_CAP| LPA_PAUSE_ASYM)) | 2267 | } |
2058 | { | 2268 | break; |
2059 | np->pause_flags |= NV_PAUSEFRAME_TX_ENABLE; | 2269 | case (ADVERTISE_PAUSE_ASYM): |
2060 | } | 2270 | if (lpa_pause == (LPA_PAUSE_CAP| LPA_PAUSE_ASYM)) |
2061 | break; | 2271 | { |
2062 | case (ADVERTISE_PAUSE_CAP| ADVERTISE_PAUSE_ASYM): | 2272 | pause_flags |= NV_PAUSEFRAME_TX_ENABLE; |
2063 | if (lpa_pause & LPA_PAUSE_CAP) | 2273 | } |
2064 | { | 2274 | break; |
2065 | np->pause_flags |= NV_PAUSEFRAME_TX_ENABLE | NV_PAUSEFRAME_RX_ENABLE; | 2275 | case (ADVERTISE_PAUSE_CAP| ADVERTISE_PAUSE_ASYM): |
2066 | } | 2276 | if (lpa_pause & LPA_PAUSE_CAP) |
2067 | if (lpa_pause == LPA_PAUSE_ASYM) | 2277 | { |
2068 | { | 2278 | pause_flags |= NV_PAUSEFRAME_RX_ENABLE; |
2069 | np->pause_flags |= NV_PAUSEFRAME_RX_ENABLE; | 2279 | if (np->pause_flags & NV_PAUSEFRAME_TX_REQ) |
2280 | pause_flags |= NV_PAUSEFRAME_TX_ENABLE; | ||
2281 | } | ||
2282 | if (lpa_pause == LPA_PAUSE_ASYM) | ||
2283 | { | ||
2284 | pause_flags |= NV_PAUSEFRAME_RX_ENABLE; | ||
2285 | } | ||
2286 | break; | ||
2070 | } | 2287 | } |
2071 | break; | ||
2072 | } | ||
2073 | } | ||
2074 | |||
2075 | if (np->pause_flags & NV_PAUSEFRAME_RX_CAPABLE) { | ||
2076 | u32 pff = readl(base + NvRegPacketFilterFlags) & ~NVREG_PFF_PAUSE_RX; | ||
2077 | if (np->pause_flags & NV_PAUSEFRAME_RX_ENABLE) | ||
2078 | writel(pff|NVREG_PFF_PAUSE_RX, base + NvRegPacketFilterFlags); | ||
2079 | else | ||
2080 | writel(pff, base + NvRegPacketFilterFlags); | ||
2081 | } | ||
2082 | if (np->pause_flags & NV_PAUSEFRAME_TX_CAPABLE) { | ||
2083 | u32 regmisc = readl(base + NvRegMisc1) & ~NVREG_MISC1_PAUSE_TX; | ||
2084 | if (np->pause_flags & NV_PAUSEFRAME_TX_ENABLE) { | ||
2085 | writel(NVREG_TX_PAUSEFRAME_ENABLE, base + NvRegTxPauseFrame); | ||
2086 | writel(regmisc|NVREG_MISC1_PAUSE_TX, base + NvRegMisc1); | ||
2087 | } else { | 2288 | } else { |
2088 | writel(NVREG_TX_PAUSEFRAME_DISABLE, base + NvRegTxPauseFrame); | 2289 | pause_flags = np->pause_flags; |
2089 | writel(regmisc, base + NvRegMisc1); | ||
2090 | } | 2290 | } |
2091 | } | 2291 | } |
2292 | nv_update_pause(dev, pause_flags); | ||
2092 | 2293 | ||
2093 | return retval; | 2294 | return retval; |
2094 | } | 2295 | } |
@@ -2350,6 +2551,175 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data, struct pt_regs *regs) | |||
2350 | return IRQ_RETVAL(i); | 2551 | return IRQ_RETVAL(i); |
2351 | } | 2552 | } |
2352 | 2553 | ||
2554 | static irqreturn_t nv_nic_irq_test(int foo, void *data, struct pt_regs *regs) | ||
2555 | { | ||
2556 | struct net_device *dev = (struct net_device *) data; | ||
2557 | struct fe_priv *np = netdev_priv(dev); | ||
2558 | u8 __iomem *base = get_hwbase(dev); | ||
2559 | u32 events; | ||
2560 | |||
2561 | dprintk(KERN_DEBUG "%s: nv_nic_irq_test\n", dev->name); | ||
2562 | |||
2563 | if (!(np->msi_flags & NV_MSI_X_ENABLED)) { | ||
2564 | events = readl(base + NvRegIrqStatus) & NVREG_IRQSTAT_MASK; | ||
2565 | writel(NVREG_IRQ_TIMER, base + NvRegIrqStatus); | ||
2566 | } else { | ||
2567 | events = readl(base + NvRegMSIXIrqStatus) & NVREG_IRQSTAT_MASK; | ||
2568 | writel(NVREG_IRQ_TIMER, base + NvRegMSIXIrqStatus); | ||
2569 | } | ||
2570 | pci_push(base); | ||
2571 | dprintk(KERN_DEBUG "%s: irq: %08x\n", dev->name, events); | ||
2572 | if (!(events & NVREG_IRQ_TIMER)) | ||
2573 | return IRQ_RETVAL(0); | ||
2574 | |||
2575 | spin_lock(&np->lock); | ||
2576 | np->intr_test = 1; | ||
2577 | spin_unlock(&np->lock); | ||
2578 | |||
2579 | dprintk(KERN_DEBUG "%s: nv_nic_irq_test completed\n", dev->name); | ||
2580 | |||
2581 | return IRQ_RETVAL(1); | ||
2582 | } | ||
2583 | |||
2584 | static void set_msix_vector_map(struct net_device *dev, u32 vector, u32 irqmask) | ||
2585 | { | ||
2586 | u8 __iomem *base = get_hwbase(dev); | ||
2587 | int i; | ||
2588 | u32 msixmap = 0; | ||
2589 | |||
2590 | /* Each interrupt bit can be mapped to a MSIX vector (4 bits). | ||
2591 | * MSIXMap0 represents the first 8 interrupts and MSIXMap1 represents | ||
2592 | * the remaining 8 interrupts. | ||
2593 | */ | ||
2594 | for (i = 0; i < 8; i++) { | ||
2595 | if ((irqmask >> i) & 0x1) { | ||
2596 | msixmap |= vector << (i << 2); | ||
2597 | } | ||
2598 | } | ||
2599 | writel(readl(base + NvRegMSIXMap0) | msixmap, base + NvRegMSIXMap0); | ||
2600 | |||
2601 | msixmap = 0; | ||
2602 | for (i = 0; i < 8; i++) { | ||
2603 | if ((irqmask >> (i + 8)) & 0x1) { | ||
2604 | msixmap |= vector << (i << 2); | ||
2605 | } | ||
2606 | } | ||
2607 | writel(readl(base + NvRegMSIXMap1) | msixmap, base + NvRegMSIXMap1); | ||
2608 | } | ||
2609 | |||
2610 | static int nv_request_irq(struct net_device *dev, int intr_test) | ||
2611 | { | ||
2612 | struct fe_priv *np = get_nvpriv(dev); | ||
2613 | u8 __iomem *base = get_hwbase(dev); | ||
2614 | int ret = 1; | ||
2615 | int i; | ||
2616 | |||
2617 | if (np->msi_flags & NV_MSI_X_CAPABLE) { | ||
2618 | for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) { | ||
2619 | np->msi_x_entry[i].entry = i; | ||
2620 | } | ||
2621 | if ((ret = pci_enable_msix(np->pci_dev, np->msi_x_entry, (np->msi_flags & NV_MSI_X_VECTORS_MASK))) == 0) { | ||
2622 | np->msi_flags |= NV_MSI_X_ENABLED; | ||
2623 | if (optimization_mode == NV_OPTIMIZATION_MODE_THROUGHPUT && !intr_test) { | ||
2624 | /* Request irq for rx handling */ | ||
2625 | if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, &nv_nic_irq_rx, SA_SHIRQ, dev->name, dev) != 0) { | ||
2626 | printk(KERN_INFO "forcedeth: request_irq failed for rx %d\n", ret); | ||
2627 | pci_disable_msix(np->pci_dev); | ||
2628 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2629 | goto out_err; | ||
2630 | } | ||
2631 | /* Request irq for tx handling */ | ||
2632 | if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, &nv_nic_irq_tx, SA_SHIRQ, dev->name, dev) != 0) { | ||
2633 | printk(KERN_INFO "forcedeth: request_irq failed for tx %d\n", ret); | ||
2634 | pci_disable_msix(np->pci_dev); | ||
2635 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2636 | goto out_free_rx; | ||
2637 | } | ||
2638 | /* Request irq for link and timer handling */ | ||
2639 | if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector, &nv_nic_irq_other, SA_SHIRQ, dev->name, dev) != 0) { | ||
2640 | printk(KERN_INFO "forcedeth: request_irq failed for link %d\n", ret); | ||
2641 | pci_disable_msix(np->pci_dev); | ||
2642 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2643 | goto out_free_tx; | ||
2644 | } | ||
2645 | /* map interrupts to their respective vector */ | ||
2646 | writel(0, base + NvRegMSIXMap0); | ||
2647 | writel(0, base + NvRegMSIXMap1); | ||
2648 | set_msix_vector_map(dev, NV_MSI_X_VECTOR_RX, NVREG_IRQ_RX_ALL); | ||
2649 | set_msix_vector_map(dev, NV_MSI_X_VECTOR_TX, NVREG_IRQ_TX_ALL); | ||
2650 | set_msix_vector_map(dev, NV_MSI_X_VECTOR_OTHER, NVREG_IRQ_OTHER); | ||
2651 | } else { | ||
2652 | /* Request irq for all interrupts */ | ||
2653 | if ((!intr_test && | ||
2654 | request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) || | ||
2655 | (intr_test && | ||
2656 | request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector, &nv_nic_irq_test, SA_SHIRQ, dev->name, dev) != 0)) { | ||
2657 | printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret); | ||
2658 | pci_disable_msix(np->pci_dev); | ||
2659 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2660 | goto out_err; | ||
2661 | } | ||
2662 | |||
2663 | /* map interrupts to vector 0 */ | ||
2664 | writel(0, base + NvRegMSIXMap0); | ||
2665 | writel(0, base + NvRegMSIXMap1); | ||
2666 | } | ||
2667 | } | ||
2668 | } | ||
2669 | if (ret != 0 && np->msi_flags & NV_MSI_CAPABLE) { | ||
2670 | if ((ret = pci_enable_msi(np->pci_dev)) == 0) { | ||
2671 | np->msi_flags |= NV_MSI_ENABLED; | ||
2672 | if ((!intr_test && request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) || | ||
2673 | (intr_test && request_irq(np->pci_dev->irq, &nv_nic_irq_test, SA_SHIRQ, dev->name, dev) != 0)) { | ||
2674 | printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret); | ||
2675 | pci_disable_msi(np->pci_dev); | ||
2676 | np->msi_flags &= ~NV_MSI_ENABLED; | ||
2677 | goto out_err; | ||
2678 | } | ||
2679 | |||
2680 | /* map interrupts to vector 0 */ | ||
2681 | writel(0, base + NvRegMSIMap0); | ||
2682 | writel(0, base + NvRegMSIMap1); | ||
2683 | /* enable msi vector 0 */ | ||
2684 | writel(NVREG_MSI_VECTOR_0_ENABLED, base + NvRegMSIIrqMask); | ||
2685 | } | ||
2686 | } | ||
2687 | if (ret != 0) { | ||
2688 | if ((!intr_test && request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) || | ||
2689 | (intr_test && request_irq(np->pci_dev->irq, &nv_nic_irq_test, SA_SHIRQ, dev->name, dev) != 0)) | ||
2690 | goto out_err; | ||
2691 | |||
2692 | } | ||
2693 | |||
2694 | return 0; | ||
2695 | out_free_tx: | ||
2696 | free_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, dev); | ||
2697 | out_free_rx: | ||
2698 | free_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, dev); | ||
2699 | out_err: | ||
2700 | return 1; | ||
2701 | } | ||
2702 | |||
2703 | static void nv_free_irq(struct net_device *dev) | ||
2704 | { | ||
2705 | struct fe_priv *np = get_nvpriv(dev); | ||
2706 | int i; | ||
2707 | |||
2708 | if (np->msi_flags & NV_MSI_X_ENABLED) { | ||
2709 | for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) { | ||
2710 | free_irq(np->msi_x_entry[i].vector, dev); | ||
2711 | } | ||
2712 | pci_disable_msix(np->pci_dev); | ||
2713 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2714 | } else { | ||
2715 | free_irq(np->pci_dev->irq, dev); | ||
2716 | if (np->msi_flags & NV_MSI_ENABLED) { | ||
2717 | pci_disable_msi(np->pci_dev); | ||
2718 | np->msi_flags &= ~NV_MSI_ENABLED; | ||
2719 | } | ||
2720 | } | ||
2721 | } | ||
2722 | |||
2353 | static void nv_do_nic_poll(unsigned long data) | 2723 | static void nv_do_nic_poll(unsigned long data) |
2354 | { | 2724 | { |
2355 | struct net_device *dev = (struct net_device *) data; | 2725 | struct net_device *dev = (struct net_device *) data; |
@@ -2419,6 +2789,56 @@ static void nv_poll_controller(struct net_device *dev) | |||
2419 | } | 2789 | } |
2420 | #endif | 2790 | #endif |
2421 | 2791 | ||
2792 | static void nv_do_stats_poll(unsigned long data) | ||
2793 | { | ||
2794 | struct net_device *dev = (struct net_device *) data; | ||
2795 | struct fe_priv *np = netdev_priv(dev); | ||
2796 | u8 __iomem *base = get_hwbase(dev); | ||
2797 | |||
2798 | np->estats.tx_bytes += readl(base + NvRegTxCnt); | ||
2799 | np->estats.tx_zero_rexmt += readl(base + NvRegTxZeroReXmt); | ||
2800 | np->estats.tx_one_rexmt += readl(base + NvRegTxOneReXmt); | ||
2801 | np->estats.tx_many_rexmt += readl(base + NvRegTxManyReXmt); | ||
2802 | np->estats.tx_late_collision += readl(base + NvRegTxLateCol); | ||
2803 | np->estats.tx_fifo_errors += readl(base + NvRegTxUnderflow); | ||
2804 | np->estats.tx_carrier_errors += readl(base + NvRegTxLossCarrier); | ||
2805 | np->estats.tx_excess_deferral += readl(base + NvRegTxExcessDef); | ||
2806 | np->estats.tx_retry_error += readl(base + NvRegTxRetryErr); | ||
2807 | np->estats.tx_deferral += readl(base + NvRegTxDef); | ||
2808 | np->estats.tx_packets += readl(base + NvRegTxFrame); | ||
2809 | np->estats.tx_pause += readl(base + NvRegTxPause); | ||
2810 | np->estats.rx_frame_error += readl(base + NvRegRxFrameErr); | ||
2811 | np->estats.rx_extra_byte += readl(base + NvRegRxExtraByte); | ||
2812 | np->estats.rx_late_collision += readl(base + NvRegRxLateCol); | ||
2813 | np->estats.rx_runt += readl(base + NvRegRxRunt); | ||
2814 | np->estats.rx_frame_too_long += readl(base + NvRegRxFrameTooLong); | ||
2815 | np->estats.rx_over_errors += readl(base + NvRegRxOverflow); | ||
2816 | np->estats.rx_crc_errors += readl(base + NvRegRxFCSErr); | ||
2817 | np->estats.rx_frame_align_error += readl(base + NvRegRxFrameAlignErr); | ||
2818 | np->estats.rx_length_error += readl(base + NvRegRxLenErr); | ||
2819 | np->estats.rx_unicast += readl(base + NvRegRxUnicast); | ||
2820 | np->estats.rx_multicast += readl(base + NvRegRxMulticast); | ||
2821 | np->estats.rx_broadcast += readl(base + NvRegRxBroadcast); | ||
2822 | np->estats.rx_bytes += readl(base + NvRegRxCnt); | ||
2823 | np->estats.rx_pause += readl(base + NvRegRxPause); | ||
2824 | np->estats.rx_drop_frame += readl(base + NvRegRxDropFrame); | ||
2825 | np->estats.rx_packets = | ||
2826 | np->estats.rx_unicast + | ||
2827 | np->estats.rx_multicast + | ||
2828 | np->estats.rx_broadcast; | ||
2829 | np->estats.rx_errors_total = | ||
2830 | np->estats.rx_crc_errors + | ||
2831 | np->estats.rx_over_errors + | ||
2832 | np->estats.rx_frame_error + | ||
2833 | (np->estats.rx_frame_align_error - np->estats.rx_extra_byte) + | ||
2834 | np->estats.rx_late_collision + | ||
2835 | np->estats.rx_runt + | ||
2836 | np->estats.rx_frame_too_long; | ||
2837 | |||
2838 | if (!np->in_shutdown) | ||
2839 | mod_timer(&np->stats_poll, jiffies + STATS_INTERVAL); | ||
2840 | } | ||
2841 | |||
2422 | static void nv_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) | 2842 | static void nv_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) |
2423 | { | 2843 | { |
2424 | struct fe_priv *np = netdev_priv(dev); | 2844 | struct fe_priv *np = netdev_priv(dev); |
@@ -2442,17 +2862,19 @@ static int nv_set_wol(struct net_device *dev, struct ethtool_wolinfo *wolinfo) | |||
2442 | { | 2862 | { |
2443 | struct fe_priv *np = netdev_priv(dev); | 2863 | struct fe_priv *np = netdev_priv(dev); |
2444 | u8 __iomem *base = get_hwbase(dev); | 2864 | u8 __iomem *base = get_hwbase(dev); |
2865 | u32 flags = 0; | ||
2445 | 2866 | ||
2446 | spin_lock_irq(&np->lock); | ||
2447 | if (wolinfo->wolopts == 0) { | 2867 | if (wolinfo->wolopts == 0) { |
2448 | writel(0, base + NvRegWakeUpFlags); | ||
2449 | np->wolenabled = 0; | 2868 | np->wolenabled = 0; |
2450 | } | 2869 | } else if (wolinfo->wolopts & WAKE_MAGIC) { |
2451 | if (wolinfo->wolopts & WAKE_MAGIC) { | ||
2452 | writel(NVREG_WAKEUPFLAGS_ENABLE, base + NvRegWakeUpFlags); | ||
2453 | np->wolenabled = 1; | 2870 | np->wolenabled = 1; |
2871 | flags = NVREG_WAKEUPFLAGS_ENABLE; | ||
2872 | } | ||
2873 | if (netif_running(dev)) { | ||
2874 | spin_lock_irq(&np->lock); | ||
2875 | writel(flags, base + NvRegWakeUpFlags); | ||
2876 | spin_unlock_irq(&np->lock); | ||
2454 | } | 2877 | } |
2455 | spin_unlock_irq(&np->lock); | ||
2456 | return 0; | 2878 | return 0; |
2457 | } | 2879 | } |
2458 | 2880 | ||
@@ -2466,9 +2888,17 @@ static int nv_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2466 | if (!netif_running(dev)) { | 2888 | if (!netif_running(dev)) { |
2467 | /* We do not track link speed / duplex setting if the | 2889 | /* We do not track link speed / duplex setting if the |
2468 | * interface is disabled. Force a link check */ | 2890 | * interface is disabled. Force a link check */ |
2469 | nv_update_linkspeed(dev); | 2891 | if (nv_update_linkspeed(dev)) { |
2892 | if (!netif_carrier_ok(dev)) | ||
2893 | netif_carrier_on(dev); | ||
2894 | } else { | ||
2895 | if (netif_carrier_ok(dev)) | ||
2896 | netif_carrier_off(dev); | ||
2897 | } | ||
2470 | } | 2898 | } |
2471 | switch(np->linkspeed & (NVREG_LINKSPEED_MASK)) { | 2899 | |
2900 | if (netif_carrier_ok(dev)) { | ||
2901 | switch(np->linkspeed & (NVREG_LINKSPEED_MASK)) { | ||
2472 | case NVREG_LINKSPEED_10: | 2902 | case NVREG_LINKSPEED_10: |
2473 | ecmd->speed = SPEED_10; | 2903 | ecmd->speed = SPEED_10; |
2474 | break; | 2904 | break; |
@@ -2478,10 +2908,14 @@ static int nv_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2478 | case NVREG_LINKSPEED_1000: | 2908 | case NVREG_LINKSPEED_1000: |
2479 | ecmd->speed = SPEED_1000; | 2909 | ecmd->speed = SPEED_1000; |
2480 | break; | 2910 | break; |
2911 | } | ||
2912 | ecmd->duplex = DUPLEX_HALF; | ||
2913 | if (np->duplex) | ||
2914 | ecmd->duplex = DUPLEX_FULL; | ||
2915 | } else { | ||
2916 | ecmd->speed = -1; | ||
2917 | ecmd->duplex = -1; | ||
2481 | } | 2918 | } |
2482 | ecmd->duplex = DUPLEX_HALF; | ||
2483 | if (np->duplex) | ||
2484 | ecmd->duplex = DUPLEX_FULL; | ||
2485 | 2919 | ||
2486 | ecmd->autoneg = np->autoneg; | 2920 | ecmd->autoneg = np->autoneg; |
2487 | 2921 | ||
@@ -2489,23 +2923,20 @@ static int nv_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2489 | if (np->autoneg) { | 2923 | if (np->autoneg) { |
2490 | ecmd->advertising |= ADVERTISED_Autoneg; | 2924 | ecmd->advertising |= ADVERTISED_Autoneg; |
2491 | adv = mii_rw(dev, np->phyaddr, MII_ADVERTISE, MII_READ); | 2925 | adv = mii_rw(dev, np->phyaddr, MII_ADVERTISE, MII_READ); |
2492 | } else { | 2926 | if (adv & ADVERTISE_10HALF) |
2493 | adv = np->fixed_mode; | 2927 | ecmd->advertising |= ADVERTISED_10baseT_Half; |
2494 | } | 2928 | if (adv & ADVERTISE_10FULL) |
2495 | if (adv & ADVERTISE_10HALF) | 2929 | ecmd->advertising |= ADVERTISED_10baseT_Full; |
2496 | ecmd->advertising |= ADVERTISED_10baseT_Half; | 2930 | if (adv & ADVERTISE_100HALF) |
2497 | if (adv & ADVERTISE_10FULL) | 2931 | ecmd->advertising |= ADVERTISED_100baseT_Half; |
2498 | ecmd->advertising |= ADVERTISED_10baseT_Full; | 2932 | if (adv & ADVERTISE_100FULL) |
2499 | if (adv & ADVERTISE_100HALF) | 2933 | ecmd->advertising |= ADVERTISED_100baseT_Full; |
2500 | ecmd->advertising |= ADVERTISED_100baseT_Half; | 2934 | if (np->gigabit == PHY_GIGABIT) { |
2501 | if (adv & ADVERTISE_100FULL) | 2935 | adv = mii_rw(dev, np->phyaddr, MII_CTRL1000, MII_READ); |
2502 | ecmd->advertising |= ADVERTISED_100baseT_Full; | 2936 | if (adv & ADVERTISE_1000FULL) |
2503 | if (np->autoneg && np->gigabit == PHY_GIGABIT) { | 2937 | ecmd->advertising |= ADVERTISED_1000baseT_Full; |
2504 | adv = mii_rw(dev, np->phyaddr, MII_CTRL1000, MII_READ); | 2938 | } |
2505 | if (adv & ADVERTISE_1000FULL) | ||
2506 | ecmd->advertising |= ADVERTISED_1000baseT_Full; | ||
2507 | } | 2939 | } |
2508 | |||
2509 | ecmd->supported = (SUPPORTED_Autoneg | | 2940 | ecmd->supported = (SUPPORTED_Autoneg | |
2510 | SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | | 2941 | SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | |
2511 | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | | 2942 | SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | |
@@ -2557,7 +2988,18 @@ static int nv_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2557 | return -EINVAL; | 2988 | return -EINVAL; |
2558 | } | 2989 | } |
2559 | 2990 | ||
2560 | spin_lock_irq(&np->lock); | 2991 | netif_carrier_off(dev); |
2992 | if (netif_running(dev)) { | ||
2993 | nv_disable_irq(dev); | ||
2994 | spin_lock_bh(&dev->xmit_lock); | ||
2995 | spin_lock(&np->lock); | ||
2996 | /* stop engines */ | ||
2997 | nv_stop_rx(dev); | ||
2998 | nv_stop_tx(dev); | ||
2999 | spin_unlock(&np->lock); | ||
3000 | spin_unlock_bh(&dev->xmit_lock); | ||
3001 | } | ||
3002 | |||
2561 | if (ecmd->autoneg == AUTONEG_ENABLE) { | 3003 | if (ecmd->autoneg == AUTONEG_ENABLE) { |
2562 | int adv, bmcr; | 3004 | int adv, bmcr; |
2563 | 3005 | ||
@@ -2569,11 +3011,15 @@ static int nv_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2569 | if (ecmd->advertising & ADVERTISED_10baseT_Half) | 3011 | if (ecmd->advertising & ADVERTISED_10baseT_Half) |
2570 | adv |= ADVERTISE_10HALF; | 3012 | adv |= ADVERTISE_10HALF; |
2571 | if (ecmd->advertising & ADVERTISED_10baseT_Full) | 3013 | if (ecmd->advertising & ADVERTISED_10baseT_Full) |
2572 | adv |= ADVERTISE_10FULL | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; | 3014 | adv |= ADVERTISE_10FULL; |
2573 | if (ecmd->advertising & ADVERTISED_100baseT_Half) | 3015 | if (ecmd->advertising & ADVERTISED_100baseT_Half) |
2574 | adv |= ADVERTISE_100HALF; | 3016 | adv |= ADVERTISE_100HALF; |
2575 | if (ecmd->advertising & ADVERTISED_100baseT_Full) | 3017 | if (ecmd->advertising & ADVERTISED_100baseT_Full) |
2576 | adv |= ADVERTISE_100FULL | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; | 3018 | adv |= ADVERTISE_100FULL; |
3019 | if (np->pause_flags & NV_PAUSEFRAME_RX_REQ) /* for rx we set both advertisments but disable tx pause */ | ||
3020 | adv |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; | ||
3021 | if (np->pause_flags & NV_PAUSEFRAME_TX_REQ) | ||
3022 | adv |= ADVERTISE_PAUSE_ASYM; | ||
2577 | mii_rw(dev, np->phyaddr, MII_ADVERTISE, adv); | 3023 | mii_rw(dev, np->phyaddr, MII_ADVERTISE, adv); |
2578 | 3024 | ||
2579 | if (np->gigabit == PHY_GIGABIT) { | 3025 | if (np->gigabit == PHY_GIGABIT) { |
@@ -2584,6 +3030,8 @@ static int nv_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2584 | mii_rw(dev, np->phyaddr, MII_CTRL1000, adv); | 3030 | mii_rw(dev, np->phyaddr, MII_CTRL1000, adv); |
2585 | } | 3031 | } |
2586 | 3032 | ||
3033 | if (netif_running(dev)) | ||
3034 | printk(KERN_INFO "%s: link down.\n", dev->name); | ||
2587 | bmcr = mii_rw(dev, np->phyaddr, MII_BMCR, MII_READ); | 3035 | bmcr = mii_rw(dev, np->phyaddr, MII_BMCR, MII_READ); |
2588 | bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART); | 3036 | bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART); |
2589 | mii_rw(dev, np->phyaddr, MII_BMCR, bmcr); | 3037 | mii_rw(dev, np->phyaddr, MII_BMCR, bmcr); |
@@ -2598,11 +3046,20 @@ static int nv_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2598 | if (ecmd->speed == SPEED_10 && ecmd->duplex == DUPLEX_HALF) | 3046 | if (ecmd->speed == SPEED_10 && ecmd->duplex == DUPLEX_HALF) |
2599 | adv |= ADVERTISE_10HALF; | 3047 | adv |= ADVERTISE_10HALF; |
2600 | if (ecmd->speed == SPEED_10 && ecmd->duplex == DUPLEX_FULL) | 3048 | if (ecmd->speed == SPEED_10 && ecmd->duplex == DUPLEX_FULL) |
2601 | adv |= ADVERTISE_10FULL | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; | 3049 | adv |= ADVERTISE_10FULL; |
2602 | if (ecmd->speed == SPEED_100 && ecmd->duplex == DUPLEX_HALF) | 3050 | if (ecmd->speed == SPEED_100 && ecmd->duplex == DUPLEX_HALF) |
2603 | adv |= ADVERTISE_100HALF; | 3051 | adv |= ADVERTISE_100HALF; |
2604 | if (ecmd->speed == SPEED_100 && ecmd->duplex == DUPLEX_FULL) | 3052 | if (ecmd->speed == SPEED_100 && ecmd->duplex == DUPLEX_FULL) |
2605 | adv |= ADVERTISE_100FULL | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; | 3053 | adv |= ADVERTISE_100FULL; |
3054 | np->pause_flags &= ~(NV_PAUSEFRAME_AUTONEG|NV_PAUSEFRAME_RX_ENABLE|NV_PAUSEFRAME_TX_ENABLE); | ||
3055 | if (np->pause_flags & NV_PAUSEFRAME_RX_REQ) {/* for rx we set both advertisments but disable tx pause */ | ||
3056 | adv |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; | ||
3057 | np->pause_flags |= NV_PAUSEFRAME_RX_ENABLE; | ||
3058 | } | ||
3059 | if (np->pause_flags & NV_PAUSEFRAME_TX_REQ) { | ||
3060 | adv |= ADVERTISE_PAUSE_ASYM; | ||
3061 | np->pause_flags |= NV_PAUSEFRAME_TX_ENABLE; | ||
3062 | } | ||
2606 | mii_rw(dev, np->phyaddr, MII_ADVERTISE, adv); | 3063 | mii_rw(dev, np->phyaddr, MII_ADVERTISE, adv); |
2607 | np->fixed_mode = adv; | 3064 | np->fixed_mode = adv; |
2608 | 3065 | ||
@@ -2613,20 +3070,30 @@ static int nv_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | |||
2613 | } | 3070 | } |
2614 | 3071 | ||
2615 | bmcr = mii_rw(dev, np->phyaddr, MII_BMCR, MII_READ); | 3072 | bmcr = mii_rw(dev, np->phyaddr, MII_BMCR, MII_READ); |
2616 | bmcr |= ~(BMCR_ANENABLE|BMCR_SPEED100|BMCR_FULLDPLX); | 3073 | bmcr &= ~(BMCR_ANENABLE|BMCR_SPEED100|BMCR_SPEED1000|BMCR_FULLDPLX); |
2617 | if (adv & (ADVERTISE_10FULL|ADVERTISE_100FULL)) | 3074 | if (np->fixed_mode & (ADVERTISE_10FULL|ADVERTISE_100FULL)) |
2618 | bmcr |= BMCR_FULLDPLX; | 3075 | bmcr |= BMCR_FULLDPLX; |
2619 | if (adv & (ADVERTISE_100HALF|ADVERTISE_100FULL)) | 3076 | if (np->fixed_mode & (ADVERTISE_100HALF|ADVERTISE_100FULL)) |
2620 | bmcr |= BMCR_SPEED100; | 3077 | bmcr |= BMCR_SPEED100; |
2621 | mii_rw(dev, np->phyaddr, MII_BMCR, bmcr); | 3078 | mii_rw(dev, np->phyaddr, MII_BMCR, bmcr); |
2622 | 3079 | if (np->phy_oui == PHY_OUI_MARVELL) { | |
2623 | if (netif_running(dev)) { | 3080 | /* reset the phy */ |
3081 | if (phy_reset(dev)) { | ||
3082 | printk(KERN_INFO "%s: phy reset failed\n", dev->name); | ||
3083 | return -EINVAL; | ||
3084 | } | ||
3085 | } else if (netif_running(dev)) { | ||
2624 | /* Wait a bit and then reconfigure the nic. */ | 3086 | /* Wait a bit and then reconfigure the nic. */ |
2625 | udelay(10); | 3087 | udelay(10); |
2626 | nv_linkchange(dev); | 3088 | nv_linkchange(dev); |
2627 | } | 3089 | } |
2628 | } | 3090 | } |
2629 | spin_unlock_irq(&np->lock); | 3091 | |
3092 | if (netif_running(dev)) { | ||
3093 | nv_start_rx(dev); | ||
3094 | nv_start_tx(dev); | ||
3095 | nv_enable_irq(dev); | ||
3096 | } | ||
2630 | 3097 | ||
2631 | return 0; | 3098 | return 0; |
2632 | } | 3099 | } |
@@ -2658,24 +3125,39 @@ static int nv_nway_reset(struct net_device *dev) | |||
2658 | struct fe_priv *np = netdev_priv(dev); | 3125 | struct fe_priv *np = netdev_priv(dev); |
2659 | int ret; | 3126 | int ret; |
2660 | 3127 | ||
2661 | spin_lock_irq(&np->lock); | ||
2662 | if (np->autoneg) { | 3128 | if (np->autoneg) { |
2663 | int bmcr; | 3129 | int bmcr; |
2664 | 3130 | ||
3131 | netif_carrier_off(dev); | ||
3132 | if (netif_running(dev)) { | ||
3133 | nv_disable_irq(dev); | ||
3134 | spin_lock_bh(&dev->xmit_lock); | ||
3135 | spin_lock(&np->lock); | ||
3136 | /* stop engines */ | ||
3137 | nv_stop_rx(dev); | ||
3138 | nv_stop_tx(dev); | ||
3139 | spin_unlock(&np->lock); | ||
3140 | spin_unlock_bh(&dev->xmit_lock); | ||
3141 | printk(KERN_INFO "%s: link down.\n", dev->name); | ||
3142 | } | ||
3143 | |||
2665 | bmcr = mii_rw(dev, np->phyaddr, MII_BMCR, MII_READ); | 3144 | bmcr = mii_rw(dev, np->phyaddr, MII_BMCR, MII_READ); |
2666 | bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART); | 3145 | bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART); |
2667 | mii_rw(dev, np->phyaddr, MII_BMCR, bmcr); | 3146 | mii_rw(dev, np->phyaddr, MII_BMCR, bmcr); |
2668 | 3147 | ||
3148 | if (netif_running(dev)) { | ||
3149 | nv_start_rx(dev); | ||
3150 | nv_start_tx(dev); | ||
3151 | nv_enable_irq(dev); | ||
3152 | } | ||
2669 | ret = 0; | 3153 | ret = 0; |
2670 | } else { | 3154 | } else { |
2671 | ret = -EINVAL; | 3155 | ret = -EINVAL; |
2672 | } | 3156 | } |
2673 | spin_unlock_irq(&np->lock); | ||
2674 | 3157 | ||
2675 | return ret; | 3158 | return ret; |
2676 | } | 3159 | } |
2677 | 3160 | ||
2678 | #ifdef NETIF_F_TSO | ||
2679 | static int nv_set_tso(struct net_device *dev, u32 value) | 3161 | static int nv_set_tso(struct net_device *dev, u32 value) |
2680 | { | 3162 | { |
2681 | struct fe_priv *np = netdev_priv(dev); | 3163 | struct fe_priv *np = netdev_priv(dev); |
@@ -2683,187 +3165,702 @@ static int nv_set_tso(struct net_device *dev, u32 value) | |||
2683 | if ((np->driver_data & DEV_HAS_CHECKSUM)) | 3165 | if ((np->driver_data & DEV_HAS_CHECKSUM)) |
2684 | return ethtool_op_set_tso(dev, value); | 3166 | return ethtool_op_set_tso(dev, value); |
2685 | else | 3167 | else |
2686 | return value ? -EOPNOTSUPP : 0; | 3168 | return -EOPNOTSUPP; |
2687 | } | 3169 | } |
2688 | #endif | ||
2689 | 3170 | ||
2690 | static struct ethtool_ops ops = { | 3171 | static void nv_get_ringparam(struct net_device *dev, struct ethtool_ringparam* ring) |
2691 | .get_drvinfo = nv_get_drvinfo, | 3172 | { |
2692 | .get_link = ethtool_op_get_link, | 3173 | struct fe_priv *np = netdev_priv(dev); |
2693 | .get_wol = nv_get_wol, | ||
2694 | .set_wol = nv_set_wol, | ||
2695 | .get_settings = nv_get_settings, | ||
2696 | .set_settings = nv_set_settings, | ||
2697 | .get_regs_len = nv_get_regs_len, | ||
2698 | .get_regs = nv_get_regs, | ||
2699 | .nway_reset = nv_nway_reset, | ||
2700 | .get_perm_addr = ethtool_op_get_perm_addr, | ||
2701 | #ifdef NETIF_F_TSO | ||
2702 | .get_tso = ethtool_op_get_tso, | ||
2703 | .set_tso = nv_set_tso | ||
2704 | #endif | ||
2705 | }; | ||
2706 | 3174 | ||
2707 | static void nv_vlan_rx_register(struct net_device *dev, struct vlan_group *grp) | 3175 | ring->rx_max_pending = (np->desc_ver == DESC_VER_1) ? RING_MAX_DESC_VER_1 : RING_MAX_DESC_VER_2_3; |
3176 | ring->rx_mini_max_pending = 0; | ||
3177 | ring->rx_jumbo_max_pending = 0; | ||
3178 | ring->tx_max_pending = (np->desc_ver == DESC_VER_1) ? RING_MAX_DESC_VER_1 : RING_MAX_DESC_VER_2_3; | ||
3179 | |||
3180 | ring->rx_pending = np->rx_ring_size; | ||
3181 | ring->rx_mini_pending = 0; | ||
3182 | ring->rx_jumbo_pending = 0; | ||
3183 | ring->tx_pending = np->tx_ring_size; | ||
3184 | } | ||
3185 | |||
3186 | static int nv_set_ringparam(struct net_device *dev, struct ethtool_ringparam* ring) | ||
2708 | { | 3187 | { |
2709 | struct fe_priv *np = get_nvpriv(dev); | 3188 | struct fe_priv *np = netdev_priv(dev); |
3189 | u8 __iomem *base = get_hwbase(dev); | ||
3190 | u8 *rxtx_ring, *rx_skbuff, *tx_skbuff, *rx_dma, *tx_dma, *tx_dma_len; | ||
3191 | dma_addr_t ring_addr; | ||
2710 | 3192 | ||
2711 | spin_lock_irq(&np->lock); | 3193 | if (ring->rx_pending < RX_RING_MIN || |
3194 | ring->tx_pending < TX_RING_MIN || | ||
3195 | ring->rx_mini_pending != 0 || | ||
3196 | ring->rx_jumbo_pending != 0 || | ||
3197 | (np->desc_ver == DESC_VER_1 && | ||
3198 | (ring->rx_pending > RING_MAX_DESC_VER_1 || | ||
3199 | ring->tx_pending > RING_MAX_DESC_VER_1)) || | ||
3200 | (np->desc_ver != DESC_VER_1 && | ||
3201 | (ring->rx_pending > RING_MAX_DESC_VER_2_3 || | ||
3202 | ring->tx_pending > RING_MAX_DESC_VER_2_3))) { | ||
3203 | return -EINVAL; | ||
3204 | } | ||
2712 | 3205 | ||
2713 | /* save vlan group */ | 3206 | /* allocate new rings */ |
2714 | np->vlangrp = grp; | 3207 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { |
3208 | rxtx_ring = pci_alloc_consistent(np->pci_dev, | ||
3209 | sizeof(struct ring_desc) * (ring->rx_pending + ring->tx_pending), | ||
3210 | &ring_addr); | ||
3211 | } else { | ||
3212 | rxtx_ring = pci_alloc_consistent(np->pci_dev, | ||
3213 | sizeof(struct ring_desc_ex) * (ring->rx_pending + ring->tx_pending), | ||
3214 | &ring_addr); | ||
3215 | } | ||
3216 | rx_skbuff = kmalloc(sizeof(struct sk_buff*) * ring->rx_pending, GFP_KERNEL); | ||
3217 | rx_dma = kmalloc(sizeof(dma_addr_t) * ring->rx_pending, GFP_KERNEL); | ||
3218 | tx_skbuff = kmalloc(sizeof(struct sk_buff*) * ring->tx_pending, GFP_KERNEL); | ||
3219 | tx_dma = kmalloc(sizeof(dma_addr_t) * ring->tx_pending, GFP_KERNEL); | ||
3220 | tx_dma_len = kmalloc(sizeof(unsigned int) * ring->tx_pending, GFP_KERNEL); | ||
3221 | if (!rxtx_ring || !rx_skbuff || !rx_dma || !tx_skbuff || !tx_dma || !tx_dma_len) { | ||
3222 | /* fall back to old rings */ | ||
3223 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | ||
3224 | if(rxtx_ring) | ||
3225 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc) * (ring->rx_pending + ring->tx_pending), | ||
3226 | rxtx_ring, ring_addr); | ||
3227 | } else { | ||
3228 | if (rxtx_ring) | ||
3229 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc_ex) * (ring->rx_pending + ring->tx_pending), | ||
3230 | rxtx_ring, ring_addr); | ||
3231 | } | ||
3232 | if (rx_skbuff) | ||
3233 | kfree(rx_skbuff); | ||
3234 | if (rx_dma) | ||
3235 | kfree(rx_dma); | ||
3236 | if (tx_skbuff) | ||
3237 | kfree(tx_skbuff); | ||
3238 | if (tx_dma) | ||
3239 | kfree(tx_dma); | ||
3240 | if (tx_dma_len) | ||
3241 | kfree(tx_dma_len); | ||
3242 | goto exit; | ||
3243 | } | ||
2715 | 3244 | ||
2716 | if (grp) { | 3245 | if (netif_running(dev)) { |
2717 | /* enable vlan on MAC */ | 3246 | nv_disable_irq(dev); |
2718 | np->txrxctl_bits |= NVREG_TXRXCTL_VLANSTRIP | NVREG_TXRXCTL_VLANINS; | 3247 | spin_lock_bh(&dev->xmit_lock); |
3248 | spin_lock(&np->lock); | ||
3249 | /* stop engines */ | ||
3250 | nv_stop_rx(dev); | ||
3251 | nv_stop_tx(dev); | ||
3252 | nv_txrx_reset(dev); | ||
3253 | /* drain queues */ | ||
3254 | nv_drain_rx(dev); | ||
3255 | nv_drain_tx(dev); | ||
3256 | /* delete queues */ | ||
3257 | free_rings(dev); | ||
3258 | } | ||
3259 | |||
3260 | /* set new values */ | ||
3261 | np->rx_ring_size = ring->rx_pending; | ||
3262 | np->tx_ring_size = ring->tx_pending; | ||
3263 | np->tx_limit_stop = ring->tx_pending - TX_LIMIT_DIFFERENCE; | ||
3264 | np->tx_limit_start = ring->tx_pending - TX_LIMIT_DIFFERENCE - 1; | ||
3265 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | ||
3266 | np->rx_ring.orig = (struct ring_desc*)rxtx_ring; | ||
3267 | np->tx_ring.orig = &np->rx_ring.orig[np->rx_ring_size]; | ||
2719 | } else { | 3268 | } else { |
2720 | /* disable vlan on MAC */ | 3269 | np->rx_ring.ex = (struct ring_desc_ex*)rxtx_ring; |
2721 | np->txrxctl_bits &= ~NVREG_TXRXCTL_VLANSTRIP; | 3270 | np->tx_ring.ex = &np->rx_ring.ex[np->rx_ring_size]; |
2722 | np->txrxctl_bits &= ~NVREG_TXRXCTL_VLANINS; | ||
2723 | } | 3271 | } |
3272 | np->rx_skbuff = (struct sk_buff**)rx_skbuff; | ||
3273 | np->rx_dma = (dma_addr_t*)rx_dma; | ||
3274 | np->tx_skbuff = (struct sk_buff**)tx_skbuff; | ||
3275 | np->tx_dma = (dma_addr_t*)tx_dma; | ||
3276 | np->tx_dma_len = (unsigned int*)tx_dma_len; | ||
3277 | np->ring_addr = ring_addr; | ||
3278 | |||
3279 | memset(np->rx_skbuff, 0, sizeof(struct sk_buff*) * np->rx_ring_size); | ||
3280 | memset(np->rx_dma, 0, sizeof(dma_addr_t) * np->rx_ring_size); | ||
3281 | memset(np->tx_skbuff, 0, sizeof(struct sk_buff*) * np->tx_ring_size); | ||
3282 | memset(np->tx_dma, 0, sizeof(dma_addr_t) * np->tx_ring_size); | ||
3283 | memset(np->tx_dma_len, 0, sizeof(unsigned int) * np->tx_ring_size); | ||
2724 | 3284 | ||
2725 | writel(np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl); | 3285 | if (netif_running(dev)) { |
3286 | /* reinit driver view of the queues */ | ||
3287 | set_bufsize(dev); | ||
3288 | if (nv_init_ring(dev)) { | ||
3289 | if (!np->in_shutdown) | ||
3290 | mod_timer(&np->oom_kick, jiffies + OOM_REFILL); | ||
3291 | } | ||
2726 | 3292 | ||
2727 | spin_unlock_irq(&np->lock); | 3293 | /* reinit nic view of the queues */ |
2728 | }; | 3294 | writel(np->rx_buf_sz, base + NvRegOffloadConfig); |
3295 | setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING); | ||
3296 | writel( ((np->rx_ring_size-1) << NVREG_RINGSZ_RXSHIFT) + ((np->tx_ring_size-1) << NVREG_RINGSZ_TXSHIFT), | ||
3297 | base + NvRegRingSizes); | ||
3298 | pci_push(base); | ||
3299 | writel(NVREG_TXRXCTL_KICK|np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl); | ||
3300 | pci_push(base); | ||
2729 | 3301 | ||
2730 | static void nv_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid) | 3302 | /* restart engines */ |
3303 | nv_start_rx(dev); | ||
3304 | nv_start_tx(dev); | ||
3305 | spin_unlock(&np->lock); | ||
3306 | spin_unlock_bh(&dev->xmit_lock); | ||
3307 | nv_enable_irq(dev); | ||
3308 | } | ||
3309 | return 0; | ||
3310 | exit: | ||
3311 | return -ENOMEM; | ||
3312 | } | ||
3313 | |||
3314 | static void nv_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam* pause) | ||
2731 | { | 3315 | { |
2732 | /* nothing to do */ | 3316 | struct fe_priv *np = netdev_priv(dev); |
2733 | }; | ||
2734 | 3317 | ||
2735 | static void set_msix_vector_map(struct net_device *dev, u32 vector, u32 irqmask) | 3318 | pause->autoneg = (np->pause_flags & NV_PAUSEFRAME_AUTONEG) != 0; |
3319 | pause->rx_pause = (np->pause_flags & NV_PAUSEFRAME_RX_ENABLE) != 0; | ||
3320 | pause->tx_pause = (np->pause_flags & NV_PAUSEFRAME_TX_ENABLE) != 0; | ||
3321 | } | ||
3322 | |||
3323 | static int nv_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam* pause) | ||
3324 | { | ||
3325 | struct fe_priv *np = netdev_priv(dev); | ||
3326 | int adv, bmcr; | ||
3327 | |||
3328 | if ((!np->autoneg && np->duplex == 0) || | ||
3329 | (np->autoneg && !pause->autoneg && np->duplex == 0)) { | ||
3330 | printk(KERN_INFO "%s: can not set pause settings when forced link is in half duplex.\n", | ||
3331 | dev->name); | ||
3332 | return -EINVAL; | ||
3333 | } | ||
3334 | if (pause->tx_pause && !(np->pause_flags & NV_PAUSEFRAME_TX_CAPABLE)) { | ||
3335 | printk(KERN_INFO "%s: hardware does not support tx pause frames.\n", dev->name); | ||
3336 | return -EINVAL; | ||
3337 | } | ||
3338 | |||
3339 | netif_carrier_off(dev); | ||
3340 | if (netif_running(dev)) { | ||
3341 | nv_disable_irq(dev); | ||
3342 | spin_lock_bh(&dev->xmit_lock); | ||
3343 | spin_lock(&np->lock); | ||
3344 | /* stop engines */ | ||
3345 | nv_stop_rx(dev); | ||
3346 | nv_stop_tx(dev); | ||
3347 | spin_unlock(&np->lock); | ||
3348 | spin_unlock_bh(&dev->xmit_lock); | ||
3349 | } | ||
3350 | |||
3351 | np->pause_flags &= ~(NV_PAUSEFRAME_RX_REQ|NV_PAUSEFRAME_TX_REQ); | ||
3352 | if (pause->rx_pause) | ||
3353 | np->pause_flags |= NV_PAUSEFRAME_RX_REQ; | ||
3354 | if (pause->tx_pause) | ||
3355 | np->pause_flags |= NV_PAUSEFRAME_TX_REQ; | ||
3356 | |||
3357 | if (np->autoneg && pause->autoneg) { | ||
3358 | np->pause_flags |= NV_PAUSEFRAME_AUTONEG; | ||
3359 | |||
3360 | adv = mii_rw(dev, np->phyaddr, MII_ADVERTISE, MII_READ); | ||
3361 | adv &= ~(ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM); | ||
3362 | if (np->pause_flags & NV_PAUSEFRAME_RX_REQ) /* for rx we set both advertisments but disable tx pause */ | ||
3363 | adv |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; | ||
3364 | if (np->pause_flags & NV_PAUSEFRAME_TX_REQ) | ||
3365 | adv |= ADVERTISE_PAUSE_ASYM; | ||
3366 | mii_rw(dev, np->phyaddr, MII_ADVERTISE, adv); | ||
3367 | |||
3368 | if (netif_running(dev)) | ||
3369 | printk(KERN_INFO "%s: link down.\n", dev->name); | ||
3370 | bmcr = mii_rw(dev, np->phyaddr, MII_BMCR, MII_READ); | ||
3371 | bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART); | ||
3372 | mii_rw(dev, np->phyaddr, MII_BMCR, bmcr); | ||
3373 | } else { | ||
3374 | np->pause_flags &= ~(NV_PAUSEFRAME_AUTONEG|NV_PAUSEFRAME_RX_ENABLE|NV_PAUSEFRAME_TX_ENABLE); | ||
3375 | if (pause->rx_pause) | ||
3376 | np->pause_flags |= NV_PAUSEFRAME_RX_ENABLE; | ||
3377 | if (pause->tx_pause) | ||
3378 | np->pause_flags |= NV_PAUSEFRAME_TX_ENABLE; | ||
3379 | |||
3380 | if (!netif_running(dev)) | ||
3381 | nv_update_linkspeed(dev); | ||
3382 | else | ||
3383 | nv_update_pause(dev, np->pause_flags); | ||
3384 | } | ||
3385 | |||
3386 | if (netif_running(dev)) { | ||
3387 | nv_start_rx(dev); | ||
3388 | nv_start_tx(dev); | ||
3389 | nv_enable_irq(dev); | ||
3390 | } | ||
3391 | return 0; | ||
3392 | } | ||
3393 | |||
3394 | static u32 nv_get_rx_csum(struct net_device *dev) | ||
3395 | { | ||
3396 | struct fe_priv *np = netdev_priv(dev); | ||
3397 | return (np->txrxctl_bits & NVREG_TXRXCTL_RXCHECK) != 0; | ||
3398 | } | ||
3399 | |||
3400 | static int nv_set_rx_csum(struct net_device *dev, u32 data) | ||
2736 | { | 3401 | { |
3402 | struct fe_priv *np = netdev_priv(dev); | ||
2737 | u8 __iomem *base = get_hwbase(dev); | 3403 | u8 __iomem *base = get_hwbase(dev); |
2738 | int i; | 3404 | int retcode = 0; |
2739 | u32 msixmap = 0; | ||
2740 | 3405 | ||
2741 | /* Each interrupt bit can be mapped to a MSIX vector (4 bits). | 3406 | if (np->driver_data & DEV_HAS_CHECKSUM) { |
2742 | * MSIXMap0 represents the first 8 interrupts and MSIXMap1 represents | 3407 | |
2743 | * the remaining 8 interrupts. | 3408 | if (((np->txrxctl_bits & NVREG_TXRXCTL_RXCHECK) && data) || |
2744 | */ | 3409 | (!(np->txrxctl_bits & NVREG_TXRXCTL_RXCHECK) && !data)) { |
2745 | for (i = 0; i < 8; i++) { | 3410 | /* already set or unset */ |
2746 | if ((irqmask >> i) & 0x1) { | 3411 | return 0; |
2747 | msixmap |= vector << (i << 2); | ||
2748 | } | 3412 | } |
2749 | } | ||
2750 | writel(readl(base + NvRegMSIXMap0) | msixmap, base + NvRegMSIXMap0); | ||
2751 | 3413 | ||
2752 | msixmap = 0; | 3414 | if (data) { |
2753 | for (i = 0; i < 8; i++) { | 3415 | np->txrxctl_bits |= NVREG_TXRXCTL_RXCHECK; |
2754 | if ((irqmask >> (i + 8)) & 0x1) { | 3416 | } else if (!(np->vlanctl_bits & NVREG_VLANCONTROL_ENABLE)) { |
2755 | msixmap |= vector << (i << 2); | 3417 | np->txrxctl_bits &= ~NVREG_TXRXCTL_RXCHECK; |
3418 | } else { | ||
3419 | printk(KERN_INFO "Can not disable rx checksum if vlan is enabled\n"); | ||
3420 | return -EINVAL; | ||
2756 | } | 3421 | } |
3422 | |||
3423 | if (netif_running(dev)) { | ||
3424 | spin_lock_irq(&np->lock); | ||
3425 | writel(np->txrxctl_bits, base + NvRegTxRxControl); | ||
3426 | spin_unlock_irq(&np->lock); | ||
3427 | } | ||
3428 | } else { | ||
3429 | return -EINVAL; | ||
2757 | } | 3430 | } |
2758 | writel(readl(base + NvRegMSIXMap1) | msixmap, base + NvRegMSIXMap1); | 3431 | |
3432 | return retcode; | ||
2759 | } | 3433 | } |
2760 | 3434 | ||
2761 | static int nv_request_irq(struct net_device *dev) | 3435 | static int nv_set_tx_csum(struct net_device *dev, u32 data) |
3436 | { | ||
3437 | struct fe_priv *np = netdev_priv(dev); | ||
3438 | |||
3439 | if (np->driver_data & DEV_HAS_CHECKSUM) | ||
3440 | return ethtool_op_set_tx_hw_csum(dev, data); | ||
3441 | else | ||
3442 | return -EOPNOTSUPP; | ||
3443 | } | ||
3444 | |||
3445 | static int nv_set_sg(struct net_device *dev, u32 data) | ||
3446 | { | ||
3447 | struct fe_priv *np = netdev_priv(dev); | ||
3448 | |||
3449 | if (np->driver_data & DEV_HAS_CHECKSUM) | ||
3450 | return ethtool_op_set_sg(dev, data); | ||
3451 | else | ||
3452 | return -EOPNOTSUPP; | ||
3453 | } | ||
3454 | |||
3455 | static int nv_get_stats_count(struct net_device *dev) | ||
3456 | { | ||
3457 | struct fe_priv *np = netdev_priv(dev); | ||
3458 | |||
3459 | if (np->driver_data & DEV_HAS_STATISTICS) | ||
3460 | return (sizeof(struct nv_ethtool_stats)/sizeof(u64)); | ||
3461 | else | ||
3462 | return 0; | ||
3463 | } | ||
3464 | |||
3465 | static void nv_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *estats, u64 *buffer) | ||
3466 | { | ||
3467 | struct fe_priv *np = netdev_priv(dev); | ||
3468 | |||
3469 | /* update stats */ | ||
3470 | nv_do_stats_poll((unsigned long)dev); | ||
3471 | |||
3472 | memcpy(buffer, &np->estats, nv_get_stats_count(dev)*sizeof(u64)); | ||
3473 | } | ||
3474 | |||
3475 | static int nv_self_test_count(struct net_device *dev) | ||
3476 | { | ||
3477 | struct fe_priv *np = netdev_priv(dev); | ||
3478 | |||
3479 | if (np->driver_data & DEV_HAS_TEST_EXTENDED) | ||
3480 | return NV_TEST_COUNT_EXTENDED; | ||
3481 | else | ||
3482 | return NV_TEST_COUNT_BASE; | ||
3483 | } | ||
3484 | |||
3485 | static int nv_link_test(struct net_device *dev) | ||
3486 | { | ||
3487 | struct fe_priv *np = netdev_priv(dev); | ||
3488 | int mii_status; | ||
3489 | |||
3490 | mii_rw(dev, np->phyaddr, MII_BMSR, MII_READ); | ||
3491 | mii_status = mii_rw(dev, np->phyaddr, MII_BMSR, MII_READ); | ||
3492 | |||
3493 | /* check phy link status */ | ||
3494 | if (!(mii_status & BMSR_LSTATUS)) | ||
3495 | return 0; | ||
3496 | else | ||
3497 | return 1; | ||
3498 | } | ||
3499 | |||
3500 | static int nv_register_test(struct net_device *dev) | ||
2762 | { | 3501 | { |
2763 | struct fe_priv *np = get_nvpriv(dev); | 3502 | u8 __iomem *base = get_hwbase(dev); |
3503 | int i = 0; | ||
3504 | u32 orig_read, new_read; | ||
3505 | |||
3506 | do { | ||
3507 | orig_read = readl(base + nv_registers_test[i].reg); | ||
3508 | |||
3509 | /* xor with mask to toggle bits */ | ||
3510 | orig_read ^= nv_registers_test[i].mask; | ||
3511 | |||
3512 | writel(orig_read, base + nv_registers_test[i].reg); | ||
3513 | |||
3514 | new_read = readl(base + nv_registers_test[i].reg); | ||
3515 | |||
3516 | if ((new_read & nv_registers_test[i].mask) != (orig_read & nv_registers_test[i].mask)) | ||
3517 | return 0; | ||
3518 | |||
3519 | /* restore original value */ | ||
3520 | orig_read ^= nv_registers_test[i].mask; | ||
3521 | writel(orig_read, base + nv_registers_test[i].reg); | ||
3522 | |||
3523 | } while (nv_registers_test[++i].reg != 0); | ||
3524 | |||
3525 | return 1; | ||
3526 | } | ||
3527 | |||
3528 | static int nv_interrupt_test(struct net_device *dev) | ||
3529 | { | ||
3530 | struct fe_priv *np = netdev_priv(dev); | ||
2764 | u8 __iomem *base = get_hwbase(dev); | 3531 | u8 __iomem *base = get_hwbase(dev); |
2765 | int ret = 1; | 3532 | int ret = 1; |
2766 | int i; | 3533 | int testcnt; |
3534 | u32 save_msi_flags, save_poll_interval = 0; | ||
2767 | 3535 | ||
2768 | if (np->msi_flags & NV_MSI_X_CAPABLE) { | 3536 | if (netif_running(dev)) { |
2769 | for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) { | 3537 | /* free current irq */ |
2770 | np->msi_x_entry[i].entry = i; | 3538 | nv_free_irq(dev); |
3539 | save_poll_interval = readl(base+NvRegPollingInterval); | ||
3540 | } | ||
3541 | |||
3542 | /* flag to test interrupt handler */ | ||
3543 | np->intr_test = 0; | ||
3544 | |||
3545 | /* setup test irq */ | ||
3546 | save_msi_flags = np->msi_flags; | ||
3547 | np->msi_flags &= ~NV_MSI_X_VECTORS_MASK; | ||
3548 | np->msi_flags |= 0x001; /* setup 1 vector */ | ||
3549 | if (nv_request_irq(dev, 1)) | ||
3550 | return 0; | ||
3551 | |||
3552 | /* setup timer interrupt */ | ||
3553 | writel(NVREG_POLL_DEFAULT_CPU, base + NvRegPollingInterval); | ||
3554 | writel(NVREG_UNKSETUP6_VAL, base + NvRegUnknownSetupReg6); | ||
3555 | |||
3556 | nv_enable_hw_interrupts(dev, NVREG_IRQ_TIMER); | ||
3557 | |||
3558 | /* wait for at least one interrupt */ | ||
3559 | msleep(100); | ||
3560 | |||
3561 | spin_lock_irq(&np->lock); | ||
3562 | |||
3563 | /* flag should be set within ISR */ | ||
3564 | testcnt = np->intr_test; | ||
3565 | if (!testcnt) | ||
3566 | ret = 2; | ||
3567 | |||
3568 | nv_disable_hw_interrupts(dev, NVREG_IRQ_TIMER); | ||
3569 | if (!(np->msi_flags & NV_MSI_X_ENABLED)) | ||
3570 | writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus); | ||
3571 | else | ||
3572 | writel(NVREG_IRQSTAT_MASK, base + NvRegMSIXIrqStatus); | ||
3573 | |||
3574 | spin_unlock_irq(&np->lock); | ||
3575 | |||
3576 | nv_free_irq(dev); | ||
3577 | |||
3578 | np->msi_flags = save_msi_flags; | ||
3579 | |||
3580 | if (netif_running(dev)) { | ||
3581 | writel(save_poll_interval, base + NvRegPollingInterval); | ||
3582 | writel(NVREG_UNKSETUP6_VAL, base + NvRegUnknownSetupReg6); | ||
3583 | /* restore original irq */ | ||
3584 | if (nv_request_irq(dev, 0)) | ||
3585 | return 0; | ||
3586 | } | ||
3587 | |||
3588 | return ret; | ||
3589 | } | ||
3590 | |||
3591 | static int nv_loopback_test(struct net_device *dev) | ||
3592 | { | ||
3593 | struct fe_priv *np = netdev_priv(dev); | ||
3594 | u8 __iomem *base = get_hwbase(dev); | ||
3595 | struct sk_buff *tx_skb, *rx_skb; | ||
3596 | dma_addr_t test_dma_addr; | ||
3597 | u32 tx_flags_extra = (np->desc_ver == DESC_VER_1 ? NV_TX_LASTPACKET : NV_TX2_LASTPACKET); | ||
3598 | u32 Flags; | ||
3599 | int len, i, pkt_len; | ||
3600 | u8 *pkt_data; | ||
3601 | u32 filter_flags = 0; | ||
3602 | u32 misc1_flags = 0; | ||
3603 | int ret = 1; | ||
3604 | |||
3605 | if (netif_running(dev)) { | ||
3606 | nv_disable_irq(dev); | ||
3607 | filter_flags = readl(base + NvRegPacketFilterFlags); | ||
3608 | misc1_flags = readl(base + NvRegMisc1); | ||
3609 | } else { | ||
3610 | nv_txrx_reset(dev); | ||
3611 | } | ||
3612 | |||
3613 | /* reinit driver view of the rx queue */ | ||
3614 | set_bufsize(dev); | ||
3615 | nv_init_ring(dev); | ||
3616 | |||
3617 | /* setup hardware for loopback */ | ||
3618 | writel(NVREG_MISC1_FORCE, base + NvRegMisc1); | ||
3619 | writel(NVREG_PFF_ALWAYS | NVREG_PFF_LOOPBACK, base + NvRegPacketFilterFlags); | ||
3620 | |||
3621 | /* reinit nic view of the rx queue */ | ||
3622 | writel(np->rx_buf_sz, base + NvRegOffloadConfig); | ||
3623 | setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING); | ||
3624 | writel( ((np->rx_ring_size-1) << NVREG_RINGSZ_RXSHIFT) + ((np->tx_ring_size-1) << NVREG_RINGSZ_TXSHIFT), | ||
3625 | base + NvRegRingSizes); | ||
3626 | pci_push(base); | ||
3627 | |||
3628 | /* restart rx engine */ | ||
3629 | nv_start_rx(dev); | ||
3630 | nv_start_tx(dev); | ||
3631 | |||
3632 | /* setup packet for tx */ | ||
3633 | pkt_len = ETH_DATA_LEN; | ||
3634 | tx_skb = dev_alloc_skb(pkt_len); | ||
3635 | pkt_data = skb_put(tx_skb, pkt_len); | ||
3636 | for (i = 0; i < pkt_len; i++) | ||
3637 | pkt_data[i] = (u8)(i & 0xff); | ||
3638 | test_dma_addr = pci_map_single(np->pci_dev, tx_skb->data, | ||
3639 | tx_skb->end-tx_skb->data, PCI_DMA_FROMDEVICE); | ||
3640 | |||
3641 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | ||
3642 | np->tx_ring.orig[0].PacketBuffer = cpu_to_le32(test_dma_addr); | ||
3643 | np->tx_ring.orig[0].FlagLen = cpu_to_le32((pkt_len-1) | np->tx_flags | tx_flags_extra); | ||
3644 | } else { | ||
3645 | np->tx_ring.ex[0].PacketBufferHigh = cpu_to_le64(test_dma_addr) >> 32; | ||
3646 | np->tx_ring.ex[0].PacketBufferLow = cpu_to_le64(test_dma_addr) & 0x0FFFFFFFF; | ||
3647 | np->tx_ring.ex[0].FlagLen = cpu_to_le32((pkt_len-1) | np->tx_flags | tx_flags_extra); | ||
3648 | } | ||
3649 | writel(NVREG_TXRXCTL_KICK|np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl); | ||
3650 | pci_push(get_hwbase(dev)); | ||
3651 | |||
3652 | msleep(500); | ||
3653 | |||
3654 | /* check for rx of the packet */ | ||
3655 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | ||
3656 | Flags = le32_to_cpu(np->rx_ring.orig[0].FlagLen); | ||
3657 | len = nv_descr_getlength(&np->rx_ring.orig[0], np->desc_ver); | ||
3658 | |||
3659 | } else { | ||
3660 | Flags = le32_to_cpu(np->rx_ring.ex[0].FlagLen); | ||
3661 | len = nv_descr_getlength_ex(&np->rx_ring.ex[0], np->desc_ver); | ||
3662 | } | ||
3663 | |||
3664 | if (Flags & NV_RX_AVAIL) { | ||
3665 | ret = 0; | ||
3666 | } else if (np->desc_ver == DESC_VER_1) { | ||
3667 | if (Flags & NV_RX_ERROR) | ||
3668 | ret = 0; | ||
3669 | } else { | ||
3670 | if (Flags & NV_RX2_ERROR) { | ||
3671 | ret = 0; | ||
2771 | } | 3672 | } |
2772 | if ((ret = pci_enable_msix(np->pci_dev, np->msi_x_entry, (np->msi_flags & NV_MSI_X_VECTORS_MASK))) == 0) { | 3673 | } |
2773 | np->msi_flags |= NV_MSI_X_ENABLED; | ||
2774 | if (optimization_mode == NV_OPTIMIZATION_MODE_THROUGHPUT) { | ||
2775 | /* Request irq for rx handling */ | ||
2776 | if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, &nv_nic_irq_rx, SA_SHIRQ, dev->name, dev) != 0) { | ||
2777 | printk(KERN_INFO "forcedeth: request_irq failed for rx %d\n", ret); | ||
2778 | pci_disable_msix(np->pci_dev); | ||
2779 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2780 | goto out_err; | ||
2781 | } | ||
2782 | /* Request irq for tx handling */ | ||
2783 | if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, &nv_nic_irq_tx, SA_SHIRQ, dev->name, dev) != 0) { | ||
2784 | printk(KERN_INFO "forcedeth: request_irq failed for tx %d\n", ret); | ||
2785 | pci_disable_msix(np->pci_dev); | ||
2786 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2787 | goto out_free_rx; | ||
2788 | } | ||
2789 | /* Request irq for link and timer handling */ | ||
2790 | if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector, &nv_nic_irq_other, SA_SHIRQ, dev->name, dev) != 0) { | ||
2791 | printk(KERN_INFO "forcedeth: request_irq failed for link %d\n", ret); | ||
2792 | pci_disable_msix(np->pci_dev); | ||
2793 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2794 | goto out_free_tx; | ||
2795 | } | ||
2796 | /* map interrupts to their respective vector */ | ||
2797 | writel(0, base + NvRegMSIXMap0); | ||
2798 | writel(0, base + NvRegMSIXMap1); | ||
2799 | set_msix_vector_map(dev, NV_MSI_X_VECTOR_RX, NVREG_IRQ_RX_ALL); | ||
2800 | set_msix_vector_map(dev, NV_MSI_X_VECTOR_TX, NVREG_IRQ_TX_ALL); | ||
2801 | set_msix_vector_map(dev, NV_MSI_X_VECTOR_OTHER, NVREG_IRQ_OTHER); | ||
2802 | } else { | ||
2803 | /* Request irq for all interrupts */ | ||
2804 | if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) { | ||
2805 | printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret); | ||
2806 | pci_disable_msix(np->pci_dev); | ||
2807 | np->msi_flags &= ~NV_MSI_X_ENABLED; | ||
2808 | goto out_err; | ||
2809 | } | ||
2810 | 3674 | ||
2811 | /* map interrupts to vector 0 */ | 3675 | if (ret) { |
2812 | writel(0, base + NvRegMSIXMap0); | 3676 | if (len != pkt_len) { |
2813 | writel(0, base + NvRegMSIXMap1); | 3677 | ret = 0; |
3678 | dprintk(KERN_DEBUG "%s: loopback len mismatch %d vs %d\n", | ||
3679 | dev->name, len, pkt_len); | ||
3680 | } else { | ||
3681 | rx_skb = np->rx_skbuff[0]; | ||
3682 | for (i = 0; i < pkt_len; i++) { | ||
3683 | if (rx_skb->data[i] != (u8)(i & 0xff)) { | ||
3684 | ret = 0; | ||
3685 | dprintk(KERN_DEBUG "%s: loopback pattern check failed on byte %d\n", | ||
3686 | dev->name, i); | ||
3687 | break; | ||
3688 | } | ||
2814 | } | 3689 | } |
2815 | } | 3690 | } |
3691 | } else { | ||
3692 | dprintk(KERN_DEBUG "%s: loopback - did not receive test packet\n", dev->name); | ||
2816 | } | 3693 | } |
2817 | if (ret != 0 && np->msi_flags & NV_MSI_CAPABLE) { | 3694 | |
2818 | if ((ret = pci_enable_msi(np->pci_dev)) == 0) { | 3695 | pci_unmap_page(np->pci_dev, test_dma_addr, |
2819 | np->msi_flags |= NV_MSI_ENABLED; | 3696 | tx_skb->end-tx_skb->data, |
2820 | if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) { | 3697 | PCI_DMA_TODEVICE); |
2821 | printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret); | 3698 | dev_kfree_skb_any(tx_skb); |
2822 | pci_disable_msi(np->pci_dev); | 3699 | |
2823 | np->msi_flags &= ~NV_MSI_ENABLED; | 3700 | /* stop engines */ |
2824 | goto out_err; | 3701 | nv_stop_rx(dev); |
3702 | nv_stop_tx(dev); | ||
3703 | nv_txrx_reset(dev); | ||
3704 | /* drain rx queue */ | ||
3705 | nv_drain_rx(dev); | ||
3706 | nv_drain_tx(dev); | ||
3707 | |||
3708 | if (netif_running(dev)) { | ||
3709 | writel(misc1_flags, base + NvRegMisc1); | ||
3710 | writel(filter_flags, base + NvRegPacketFilterFlags); | ||
3711 | nv_enable_irq(dev); | ||
3712 | } | ||
3713 | |||
3714 | return ret; | ||
3715 | } | ||
3716 | |||
3717 | static void nv_self_test(struct net_device *dev, struct ethtool_test *test, u64 *buffer) | ||
3718 | { | ||
3719 | struct fe_priv *np = netdev_priv(dev); | ||
3720 | u8 __iomem *base = get_hwbase(dev); | ||
3721 | int result; | ||
3722 | memset(buffer, 0, nv_self_test_count(dev)*sizeof(u64)); | ||
3723 | |||
3724 | if (!nv_link_test(dev)) { | ||
3725 | test->flags |= ETH_TEST_FL_FAILED; | ||
3726 | buffer[0] = 1; | ||
3727 | } | ||
3728 | |||
3729 | if (test->flags & ETH_TEST_FL_OFFLINE) { | ||
3730 | if (netif_running(dev)) { | ||
3731 | netif_stop_queue(dev); | ||
3732 | spin_lock_bh(&dev->xmit_lock); | ||
3733 | spin_lock_irq(&np->lock); | ||
3734 | nv_disable_hw_interrupts(dev, np->irqmask); | ||
3735 | if (!(np->msi_flags & NV_MSI_X_ENABLED)) { | ||
3736 | writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus); | ||
3737 | } else { | ||
3738 | writel(NVREG_IRQSTAT_MASK, base + NvRegMSIXIrqStatus); | ||
2825 | } | 3739 | } |
3740 | /* stop engines */ | ||
3741 | nv_stop_rx(dev); | ||
3742 | nv_stop_tx(dev); | ||
3743 | nv_txrx_reset(dev); | ||
3744 | /* drain rx queue */ | ||
3745 | nv_drain_rx(dev); | ||
3746 | nv_drain_tx(dev); | ||
3747 | spin_unlock_irq(&np->lock); | ||
3748 | spin_unlock_bh(&dev->xmit_lock); | ||
3749 | } | ||
2826 | 3750 | ||
2827 | /* map interrupts to vector 0 */ | 3751 | if (!nv_register_test(dev)) { |
2828 | writel(0, base + NvRegMSIMap0); | 3752 | test->flags |= ETH_TEST_FL_FAILED; |
2829 | writel(0, base + NvRegMSIMap1); | 3753 | buffer[1] = 1; |
2830 | /* enable msi vector 0 */ | 3754 | } |
2831 | writel(NVREG_MSI_VECTOR_0_ENABLED, base + NvRegMSIIrqMask); | 3755 | |
3756 | result = nv_interrupt_test(dev); | ||
3757 | if (result != 1) { | ||
3758 | test->flags |= ETH_TEST_FL_FAILED; | ||
3759 | buffer[2] = 1; | ||
3760 | } | ||
3761 | if (result == 0) { | ||
3762 | /* bail out */ | ||
3763 | return; | ||
3764 | } | ||
3765 | |||
3766 | if (!nv_loopback_test(dev)) { | ||
3767 | test->flags |= ETH_TEST_FL_FAILED; | ||
3768 | buffer[3] = 1; | ||
3769 | } | ||
3770 | |||
3771 | if (netif_running(dev)) { | ||
3772 | /* reinit driver view of the rx queue */ | ||
3773 | set_bufsize(dev); | ||
3774 | if (nv_init_ring(dev)) { | ||
3775 | if (!np->in_shutdown) | ||
3776 | mod_timer(&np->oom_kick, jiffies + OOM_REFILL); | ||
3777 | } | ||
3778 | /* reinit nic view of the rx queue */ | ||
3779 | writel(np->rx_buf_sz, base + NvRegOffloadConfig); | ||
3780 | setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING); | ||
3781 | writel( ((np->rx_ring_size-1) << NVREG_RINGSZ_RXSHIFT) + ((np->tx_ring_size-1) << NVREG_RINGSZ_TXSHIFT), | ||
3782 | base + NvRegRingSizes); | ||
3783 | pci_push(base); | ||
3784 | writel(NVREG_TXRXCTL_KICK|np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl); | ||
3785 | pci_push(base); | ||
3786 | /* restart rx engine */ | ||
3787 | nv_start_rx(dev); | ||
3788 | nv_start_tx(dev); | ||
3789 | netif_start_queue(dev); | ||
3790 | nv_enable_hw_interrupts(dev, np->irqmask); | ||
2832 | } | 3791 | } |
2833 | } | 3792 | } |
2834 | if (ret != 0) { | 3793 | } |
2835 | if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) | ||
2836 | goto out_err; | ||
2837 | } | ||
2838 | 3794 | ||
2839 | return 0; | 3795 | static void nv_get_strings(struct net_device *dev, u32 stringset, u8 *buffer) |
2840 | out_free_tx: | 3796 | { |
2841 | free_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, dev); | 3797 | switch (stringset) { |
2842 | out_free_rx: | 3798 | case ETH_SS_STATS: |
2843 | free_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, dev); | 3799 | memcpy(buffer, &nv_estats_str, nv_get_stats_count(dev)*sizeof(struct nv_ethtool_str)); |
2844 | out_err: | 3800 | break; |
2845 | return 1; | 3801 | case ETH_SS_TEST: |
3802 | memcpy(buffer, &nv_etests_str, nv_self_test_count(dev)*sizeof(struct nv_ethtool_str)); | ||
3803 | break; | ||
3804 | } | ||
2846 | } | 3805 | } |
2847 | 3806 | ||
2848 | static void nv_free_irq(struct net_device *dev) | 3807 | static struct ethtool_ops ops = { |
3808 | .get_drvinfo = nv_get_drvinfo, | ||
3809 | .get_link = ethtool_op_get_link, | ||
3810 | .get_wol = nv_get_wol, | ||
3811 | .set_wol = nv_set_wol, | ||
3812 | .get_settings = nv_get_settings, | ||
3813 | .set_settings = nv_set_settings, | ||
3814 | .get_regs_len = nv_get_regs_len, | ||
3815 | .get_regs = nv_get_regs, | ||
3816 | .nway_reset = nv_nway_reset, | ||
3817 | .get_perm_addr = ethtool_op_get_perm_addr, | ||
3818 | .get_tso = ethtool_op_get_tso, | ||
3819 | .set_tso = nv_set_tso, | ||
3820 | .get_ringparam = nv_get_ringparam, | ||
3821 | .set_ringparam = nv_set_ringparam, | ||
3822 | .get_pauseparam = nv_get_pauseparam, | ||
3823 | .set_pauseparam = nv_set_pauseparam, | ||
3824 | .get_rx_csum = nv_get_rx_csum, | ||
3825 | .set_rx_csum = nv_set_rx_csum, | ||
3826 | .get_tx_csum = ethtool_op_get_tx_csum, | ||
3827 | .set_tx_csum = nv_set_tx_csum, | ||
3828 | .get_sg = ethtool_op_get_sg, | ||
3829 | .set_sg = nv_set_sg, | ||
3830 | .get_strings = nv_get_strings, | ||
3831 | .get_stats_count = nv_get_stats_count, | ||
3832 | .get_ethtool_stats = nv_get_ethtool_stats, | ||
3833 | .self_test_count = nv_self_test_count, | ||
3834 | .self_test = nv_self_test, | ||
3835 | }; | ||
3836 | |||
3837 | static void nv_vlan_rx_register(struct net_device *dev, struct vlan_group *grp) | ||
2849 | { | 3838 | { |
2850 | struct fe_priv *np = get_nvpriv(dev); | 3839 | struct fe_priv *np = get_nvpriv(dev); |
2851 | int i; | ||
2852 | 3840 | ||
2853 | if (np->msi_flags & NV_MSI_X_ENABLED) { | 3841 | spin_lock_irq(&np->lock); |
2854 | for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) { | 3842 | |
2855 | free_irq(np->msi_x_entry[i].vector, dev); | 3843 | /* save vlan group */ |
2856 | } | 3844 | np->vlangrp = grp; |
2857 | pci_disable_msix(np->pci_dev); | 3845 | |
2858 | np->msi_flags &= ~NV_MSI_X_ENABLED; | 3846 | if (grp) { |
3847 | /* enable vlan on MAC */ | ||
3848 | np->txrxctl_bits |= NVREG_TXRXCTL_VLANSTRIP | NVREG_TXRXCTL_VLANINS; | ||
2859 | } else { | 3849 | } else { |
2860 | free_irq(np->pci_dev->irq, dev); | 3850 | /* disable vlan on MAC */ |
2861 | if (np->msi_flags & NV_MSI_ENABLED) { | 3851 | np->txrxctl_bits &= ~NVREG_TXRXCTL_VLANSTRIP; |
2862 | pci_disable_msi(np->pci_dev); | 3852 | np->txrxctl_bits &= ~NVREG_TXRXCTL_VLANINS; |
2863 | np->msi_flags &= ~NV_MSI_ENABLED; | ||
2864 | } | ||
2865 | } | 3853 | } |
2866 | } | 3854 | |
3855 | writel(np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl); | ||
3856 | |||
3857 | spin_unlock_irq(&np->lock); | ||
3858 | }; | ||
3859 | |||
3860 | static void nv_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid) | ||
3861 | { | ||
3862 | /* nothing to do */ | ||
3863 | }; | ||
2867 | 3864 | ||
2868 | static int nv_open(struct net_device *dev) | 3865 | static int nv_open(struct net_device *dev) |
2869 | { | 3866 | { |
@@ -2908,7 +3905,7 @@ static int nv_open(struct net_device *dev) | |||
2908 | 3905 | ||
2909 | /* 4) give hw rings */ | 3906 | /* 4) give hw rings */ |
2910 | setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING); | 3907 | setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING); |
2911 | writel( ((RX_RING-1) << NVREG_RINGSZ_RXSHIFT) + ((TX_RING-1) << NVREG_RINGSZ_TXSHIFT), | 3908 | writel( ((np->rx_ring_size-1) << NVREG_RINGSZ_RXSHIFT) + ((np->tx_ring_size-1) << NVREG_RINGSZ_TXSHIFT), |
2912 | base + NvRegRingSizes); | 3909 | base + NvRegRingSizes); |
2913 | 3910 | ||
2914 | /* 5) continue setup */ | 3911 | /* 5) continue setup */ |
@@ -2950,7 +3947,8 @@ static int nv_open(struct net_device *dev) | |||
2950 | base + NvRegAdapterControl); | 3947 | base + NvRegAdapterControl); |
2951 | writel(NVREG_MIISPEED_BIT8|NVREG_MIIDELAY, base + NvRegMIISpeed); | 3948 | writel(NVREG_MIISPEED_BIT8|NVREG_MIIDELAY, base + NvRegMIISpeed); |
2952 | writel(NVREG_UNKSETUP4_VAL, base + NvRegUnknownSetupReg4); | 3949 | writel(NVREG_UNKSETUP4_VAL, base + NvRegUnknownSetupReg4); |
2953 | writel(NVREG_WAKEUPFLAGS_VAL, base + NvRegWakeUpFlags); | 3950 | if (np->wolenabled) |
3951 | writel(NVREG_WAKEUPFLAGS_ENABLE , base + NvRegWakeUpFlags); | ||
2954 | 3952 | ||
2955 | i = readl(base + NvRegPowerState); | 3953 | i = readl(base + NvRegPowerState); |
2956 | if ( (i & NVREG_POWERSTATE_POWEREDUP) == 0) | 3954 | if ( (i & NVREG_POWERSTATE_POWEREDUP) == 0) |
@@ -2966,7 +3964,7 @@ static int nv_open(struct net_device *dev) | |||
2966 | writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus); | 3964 | writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus); |
2967 | pci_push(base); | 3965 | pci_push(base); |
2968 | 3966 | ||
2969 | if (nv_request_irq(dev)) { | 3967 | if (nv_request_irq(dev, 0)) { |
2970 | goto out_drain; | 3968 | goto out_drain; |
2971 | } | 3969 | } |
2972 | 3970 | ||
@@ -3003,6 +4001,11 @@ static int nv_open(struct net_device *dev) | |||
3003 | } | 4001 | } |
3004 | if (oom) | 4002 | if (oom) |
3005 | mod_timer(&np->oom_kick, jiffies + OOM_REFILL); | 4003 | mod_timer(&np->oom_kick, jiffies + OOM_REFILL); |
4004 | |||
4005 | /* start statistics timer */ | ||
4006 | if (np->driver_data & DEV_HAS_STATISTICS) | ||
4007 | mod_timer(&np->stats_poll, jiffies + STATS_INTERVAL); | ||
4008 | |||
3006 | spin_unlock_irq(&np->lock); | 4009 | spin_unlock_irq(&np->lock); |
3007 | 4010 | ||
3008 | return 0; | 4011 | return 0; |
@@ -3023,6 +4026,7 @@ static int nv_close(struct net_device *dev) | |||
3023 | 4026 | ||
3024 | del_timer_sync(&np->oom_kick); | 4027 | del_timer_sync(&np->oom_kick); |
3025 | del_timer_sync(&np->nic_poll); | 4028 | del_timer_sync(&np->nic_poll); |
4029 | del_timer_sync(&np->stats_poll); | ||
3026 | 4030 | ||
3027 | netif_stop_queue(dev); | 4031 | netif_stop_queue(dev); |
3028 | spin_lock_irq(&np->lock); | 4032 | spin_lock_irq(&np->lock); |
@@ -3082,6 +4086,9 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3082 | init_timer(&np->nic_poll); | 4086 | init_timer(&np->nic_poll); |
3083 | np->nic_poll.data = (unsigned long) dev; | 4087 | np->nic_poll.data = (unsigned long) dev; |
3084 | np->nic_poll.function = &nv_do_nic_poll; /* timer handler */ | 4088 | np->nic_poll.function = &nv_do_nic_poll; /* timer handler */ |
4089 | init_timer(&np->stats_poll); | ||
4090 | np->stats_poll.data = (unsigned long) dev; | ||
4091 | np->stats_poll.function = &nv_do_stats_poll; /* timer handler */ | ||
3085 | 4092 | ||
3086 | err = pci_enable_device(pci_dev); | 4093 | err = pci_enable_device(pci_dev); |
3087 | if (err) { | 4094 | if (err) { |
@@ -3096,7 +4103,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3096 | if (err < 0) | 4103 | if (err < 0) |
3097 | goto out_disable; | 4104 | goto out_disable; |
3098 | 4105 | ||
3099 | if (id->driver_data & (DEV_HAS_VLAN|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL)) | 4106 | if (id->driver_data & (DEV_HAS_VLAN|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_STATISTICS)) |
3100 | np->register_size = NV_PCI_REGSZ_VER2; | 4107 | np->register_size = NV_PCI_REGSZ_VER2; |
3101 | else | 4108 | else |
3102 | np->register_size = NV_PCI_REGSZ_VER1; | 4109 | np->register_size = NV_PCI_REGSZ_VER1; |
@@ -3128,16 +4135,18 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3128 | /* packet format 3: supports 40-bit addressing */ | 4135 | /* packet format 3: supports 40-bit addressing */ |
3129 | np->desc_ver = DESC_VER_3; | 4136 | np->desc_ver = DESC_VER_3; |
3130 | np->txrxctl_bits = NVREG_TXRXCTL_DESC_3; | 4137 | np->txrxctl_bits = NVREG_TXRXCTL_DESC_3; |
3131 | if (pci_set_dma_mask(pci_dev, DMA_39BIT_MASK)) { | 4138 | if (dma_64bit) { |
3132 | printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n", | 4139 | if (pci_set_dma_mask(pci_dev, DMA_39BIT_MASK)) { |
3133 | pci_name(pci_dev)); | 4140 | printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n", |
3134 | } else { | 4141 | pci_name(pci_dev)); |
3135 | dev->features |= NETIF_F_HIGHDMA; | 4142 | } else { |
3136 | printk(KERN_INFO "forcedeth: using HIGHDMA\n"); | 4143 | dev->features |= NETIF_F_HIGHDMA; |
3137 | } | 4144 | printk(KERN_INFO "forcedeth: using HIGHDMA\n"); |
3138 | if (pci_set_consistent_dma_mask(pci_dev, 0x0000007fffffffffULL)) { | 4145 | } |
3139 | printk(KERN_INFO "forcedeth: 64-bit DMA (consistent) failed for device %s.\n", | 4146 | if (pci_set_consistent_dma_mask(pci_dev, DMA_39BIT_MASK)) { |
3140 | pci_name(pci_dev)); | 4147 | printk(KERN_INFO "forcedeth: 64-bit DMA (consistent) failed, using 32-bit ring buffers for device %s.\n", |
4148 | pci_name(pci_dev)); | ||
4149 | } | ||
3141 | } | 4150 | } |
3142 | } else if (id->driver_data & DEV_HAS_LARGEDESC) { | 4151 | } else if (id->driver_data & DEV_HAS_LARGEDESC) { |
3143 | /* packet format 2: supports jumbo frames */ | 4152 | /* packet format 2: supports jumbo frames */ |
@@ -3170,16 +4179,16 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3170 | } | 4179 | } |
3171 | 4180 | ||
3172 | np->msi_flags = 0; | 4181 | np->msi_flags = 0; |
3173 | if ((id->driver_data & DEV_HAS_MSI) && !disable_msi) { | 4182 | if ((id->driver_data & DEV_HAS_MSI) && msi) { |
3174 | np->msi_flags |= NV_MSI_CAPABLE; | 4183 | np->msi_flags |= NV_MSI_CAPABLE; |
3175 | } | 4184 | } |
3176 | if ((id->driver_data & DEV_HAS_MSI_X) && !disable_msix) { | 4185 | if ((id->driver_data & DEV_HAS_MSI_X) && msix) { |
3177 | np->msi_flags |= NV_MSI_X_CAPABLE; | 4186 | np->msi_flags |= NV_MSI_X_CAPABLE; |
3178 | } | 4187 | } |
3179 | 4188 | ||
3180 | np->pause_flags = NV_PAUSEFRAME_RX_CAPABLE; | 4189 | np->pause_flags = NV_PAUSEFRAME_RX_CAPABLE | NV_PAUSEFRAME_RX_REQ | NV_PAUSEFRAME_AUTONEG; |
3181 | if (id->driver_data & DEV_HAS_PAUSEFRAME_TX) { | 4190 | if (id->driver_data & DEV_HAS_PAUSEFRAME_TX) { |
3182 | np->pause_flags |= NV_PAUSEFRAME_TX_CAPABLE; | 4191 | np->pause_flags |= NV_PAUSEFRAME_TX_CAPABLE | NV_PAUSEFRAME_TX_REQ; |
3183 | } | 4192 | } |
3184 | 4193 | ||
3185 | 4194 | ||
@@ -3191,21 +4200,38 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3191 | 4200 | ||
3192 | dev->irq = pci_dev->irq; | 4201 | dev->irq = pci_dev->irq; |
3193 | 4202 | ||
4203 | np->rx_ring_size = RX_RING_DEFAULT; | ||
4204 | np->tx_ring_size = TX_RING_DEFAULT; | ||
4205 | np->tx_limit_stop = np->tx_ring_size - TX_LIMIT_DIFFERENCE; | ||
4206 | np->tx_limit_start = np->tx_ring_size - TX_LIMIT_DIFFERENCE - 1; | ||
4207 | |||
3194 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { | 4208 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { |
3195 | np->rx_ring.orig = pci_alloc_consistent(pci_dev, | 4209 | np->rx_ring.orig = pci_alloc_consistent(pci_dev, |
3196 | sizeof(struct ring_desc) * (RX_RING + TX_RING), | 4210 | sizeof(struct ring_desc) * (np->rx_ring_size + np->tx_ring_size), |
3197 | &np->ring_addr); | 4211 | &np->ring_addr); |
3198 | if (!np->rx_ring.orig) | 4212 | if (!np->rx_ring.orig) |
3199 | goto out_unmap; | 4213 | goto out_unmap; |
3200 | np->tx_ring.orig = &np->rx_ring.orig[RX_RING]; | 4214 | np->tx_ring.orig = &np->rx_ring.orig[np->rx_ring_size]; |
3201 | } else { | 4215 | } else { |
3202 | np->rx_ring.ex = pci_alloc_consistent(pci_dev, | 4216 | np->rx_ring.ex = pci_alloc_consistent(pci_dev, |
3203 | sizeof(struct ring_desc_ex) * (RX_RING + TX_RING), | 4217 | sizeof(struct ring_desc_ex) * (np->rx_ring_size + np->tx_ring_size), |
3204 | &np->ring_addr); | 4218 | &np->ring_addr); |
3205 | if (!np->rx_ring.ex) | 4219 | if (!np->rx_ring.ex) |
3206 | goto out_unmap; | 4220 | goto out_unmap; |
3207 | np->tx_ring.ex = &np->rx_ring.ex[RX_RING]; | 4221 | np->tx_ring.ex = &np->rx_ring.ex[np->rx_ring_size]; |
3208 | } | 4222 | } |
4223 | np->rx_skbuff = kmalloc(sizeof(struct sk_buff*) * np->rx_ring_size, GFP_KERNEL); | ||
4224 | np->rx_dma = kmalloc(sizeof(dma_addr_t) * np->rx_ring_size, GFP_KERNEL); | ||
4225 | np->tx_skbuff = kmalloc(sizeof(struct sk_buff*) * np->tx_ring_size, GFP_KERNEL); | ||
4226 | np->tx_dma = kmalloc(sizeof(dma_addr_t) * np->tx_ring_size, GFP_KERNEL); | ||
4227 | np->tx_dma_len = kmalloc(sizeof(unsigned int) * np->tx_ring_size, GFP_KERNEL); | ||
4228 | if (!np->rx_skbuff || !np->rx_dma || !np->tx_skbuff || !np->tx_dma || !np->tx_dma_len) | ||
4229 | goto out_freering; | ||
4230 | memset(np->rx_skbuff, 0, sizeof(struct sk_buff*) * np->rx_ring_size); | ||
4231 | memset(np->rx_dma, 0, sizeof(dma_addr_t) * np->rx_ring_size); | ||
4232 | memset(np->tx_skbuff, 0, sizeof(struct sk_buff*) * np->tx_ring_size); | ||
4233 | memset(np->tx_dma, 0, sizeof(dma_addr_t) * np->tx_ring_size); | ||
4234 | memset(np->tx_dma_len, 0, sizeof(unsigned int) * np->tx_ring_size); | ||
3209 | 4235 | ||
3210 | dev->open = nv_open; | 4236 | dev->open = nv_open; |
3211 | dev->stop = nv_close; | 4237 | dev->stop = nv_close; |
@@ -3327,7 +4353,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3327 | if (i == 33) { | 4353 | if (i == 33) { |
3328 | printk(KERN_INFO "%s: open: Could not find a valid PHY.\n", | 4354 | printk(KERN_INFO "%s: open: Could not find a valid PHY.\n", |
3329 | pci_name(pci_dev)); | 4355 | pci_name(pci_dev)); |
3330 | goto out_freering; | 4356 | goto out_error; |
3331 | } | 4357 | } |
3332 | 4358 | ||
3333 | /* reset it */ | 4359 | /* reset it */ |
@@ -3341,7 +4367,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3341 | err = register_netdev(dev); | 4367 | err = register_netdev(dev); |
3342 | if (err) { | 4368 | if (err) { |
3343 | printk(KERN_INFO "forcedeth: unable to register netdev: %d\n", err); | 4369 | printk(KERN_INFO "forcedeth: unable to register netdev: %d\n", err); |
3344 | goto out_freering; | 4370 | goto out_error; |
3345 | } | 4371 | } |
3346 | printk(KERN_INFO "%s: forcedeth.c: subsystem: %05x:%04x bound to %s\n", | 4372 | printk(KERN_INFO "%s: forcedeth.c: subsystem: %05x:%04x bound to %s\n", |
3347 | dev->name, pci_dev->subsystem_vendor, pci_dev->subsystem_device, | 4373 | dev->name, pci_dev->subsystem_vendor, pci_dev->subsystem_device, |
@@ -3349,14 +4375,10 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i | |||
3349 | 4375 | ||
3350 | return 0; | 4376 | return 0; |
3351 | 4377 | ||
3352 | out_freering: | 4378 | out_error: |
3353 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) | ||
3354 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc) * (RX_RING + TX_RING), | ||
3355 | np->rx_ring.orig, np->ring_addr); | ||
3356 | else | ||
3357 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc_ex) * (RX_RING + TX_RING), | ||
3358 | np->rx_ring.ex, np->ring_addr); | ||
3359 | pci_set_drvdata(pci_dev, NULL); | 4379 | pci_set_drvdata(pci_dev, NULL); |
4380 | out_freering: | ||
4381 | free_rings(dev); | ||
3360 | out_unmap: | 4382 | out_unmap: |
3361 | iounmap(get_hwbase(dev)); | 4383 | iounmap(get_hwbase(dev)); |
3362 | out_relreg: | 4384 | out_relreg: |
@@ -3372,15 +4394,11 @@ out: | |||
3372 | static void __devexit nv_remove(struct pci_dev *pci_dev) | 4394 | static void __devexit nv_remove(struct pci_dev *pci_dev) |
3373 | { | 4395 | { |
3374 | struct net_device *dev = pci_get_drvdata(pci_dev); | 4396 | struct net_device *dev = pci_get_drvdata(pci_dev); |
3375 | struct fe_priv *np = netdev_priv(dev); | ||
3376 | 4397 | ||
3377 | unregister_netdev(dev); | 4398 | unregister_netdev(dev); |
3378 | 4399 | ||
3379 | /* free all structures */ | 4400 | /* free all structures */ |
3380 | if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) | 4401 | free_rings(dev); |
3381 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc) * (RX_RING + TX_RING), np->rx_ring.orig, np->ring_addr); | ||
3382 | else | ||
3383 | pci_free_consistent(np->pci_dev, sizeof(struct ring_desc_ex) * (RX_RING + TX_RING), np->rx_ring.ex, np->ring_addr); | ||
3384 | iounmap(get_hwbase(dev)); | 4402 | iounmap(get_hwbase(dev)); |
3385 | pci_release_regions(pci_dev); | 4403 | pci_release_regions(pci_dev); |
3386 | pci_disable_device(pci_dev); | 4404 | pci_disable_device(pci_dev); |
@@ -3443,11 +4461,43 @@ static struct pci_device_id pci_tbl[] = { | |||
3443 | }, | 4461 | }, |
3444 | { /* MCP55 Ethernet Controller */ | 4462 | { /* MCP55 Ethernet Controller */ |
3445 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_14), | 4463 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_14), |
3446 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX, | 4464 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, |
3447 | }, | 4465 | }, |
3448 | { /* MCP55 Ethernet Controller */ | 4466 | { /* MCP55 Ethernet Controller */ |
3449 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_15), | 4467 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_15), |
3450 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX, | 4468 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, |
4469 | }, | ||
4470 | { /* MCP61 Ethernet Controller */ | ||
4471 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_16), | ||
4472 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
4473 | }, | ||
4474 | { /* MCP61 Ethernet Controller */ | ||
4475 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_17), | ||
4476 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
4477 | }, | ||
4478 | { /* MCP61 Ethernet Controller */ | ||
4479 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_18), | ||
4480 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
4481 | }, | ||
4482 | { /* MCP61 Ethernet Controller */ | ||
4483 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_19), | ||
4484 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
4485 | }, | ||
4486 | { /* MCP65 Ethernet Controller */ | ||
4487 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_20), | ||
4488 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
4489 | }, | ||
4490 | { /* MCP65 Ethernet Controller */ | ||
4491 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_21), | ||
4492 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
4493 | }, | ||
4494 | { /* MCP65 Ethernet Controller */ | ||
4495 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_22), | ||
4496 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
4497 | }, | ||
4498 | { /* MCP65 Ethernet Controller */ | ||
4499 | PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_23), | ||
4500 | .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS|DEV_HAS_TEST_EXTENDED, | ||
3451 | }, | 4501 | }, |
3452 | {0,}, | 4502 | {0,}, |
3453 | }; | 4503 | }; |
@@ -3477,10 +4527,12 @@ module_param(optimization_mode, int, 0); | |||
3477 | MODULE_PARM_DESC(optimization_mode, "In throughput mode (0), every tx & rx packet will generate an interrupt. In CPU mode (1), interrupts are controlled by a timer."); | 4527 | MODULE_PARM_DESC(optimization_mode, "In throughput mode (0), every tx & rx packet will generate an interrupt. In CPU mode (1), interrupts are controlled by a timer."); |
3478 | module_param(poll_interval, int, 0); | 4528 | module_param(poll_interval, int, 0); |
3479 | MODULE_PARM_DESC(poll_interval, "Interval determines how frequent timer interrupt is generated by [(time_in_micro_secs * 100) / (2^10)]. Min is 0 and Max is 65535."); | 4529 | MODULE_PARM_DESC(poll_interval, "Interval determines how frequent timer interrupt is generated by [(time_in_micro_secs * 100) / (2^10)]. Min is 0 and Max is 65535."); |
3480 | module_param(disable_msi, int, 0); | 4530 | module_param(msi, int, 0); |
3481 | MODULE_PARM_DESC(disable_msi, "Disable MSI interrupts by setting to 1."); | 4531 | MODULE_PARM_DESC(msi, "MSI interrupts are enabled by setting to 1 and disabled by setting to 0."); |
3482 | module_param(disable_msix, int, 0); | 4532 | module_param(msix, int, 0); |
3483 | MODULE_PARM_DESC(disable_msix, "Disable MSIX interrupts by setting to 1."); | 4533 | MODULE_PARM_DESC(msix, "MSIX interrupts are enabled by setting to 1 and disabled by setting to 0."); |
4534 | module_param(dma_64bit, int, 0); | ||
4535 | MODULE_PARM_DESC(dma_64bit, "High DMA is enabled by setting to 1 and disabled by setting to 0."); | ||
3484 | 4536 | ||
3485 | MODULE_AUTHOR("Manfred Spraul <manfred@colorfullife.com>"); | 4537 | MODULE_AUTHOR("Manfred Spraul <manfred@colorfullife.com>"); |
3486 | MODULE_DESCRIPTION("Reverse Engineered nForce ethernet driver"); | 4538 | MODULE_DESCRIPTION("Reverse Engineered nForce ethernet driver"); |
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c index 102c1f0b90da..d12605f0ac7c 100644 --- a/drivers/net/hamradio/6pack.c +++ b/drivers/net/hamradio/6pack.c | |||
@@ -308,9 +308,9 @@ static int sp_set_mac_address(struct net_device *dev, void *addr) | |||
308 | { | 308 | { |
309 | struct sockaddr_ax25 *sa = addr; | 309 | struct sockaddr_ax25 *sa = addr; |
310 | 310 | ||
311 | spin_lock_irq(&dev->xmit_lock); | 311 | netif_tx_lock_bh(dev); |
312 | memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN); | 312 | memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN); |
313 | spin_unlock_irq(&dev->xmit_lock); | 313 | netif_tx_unlock_bh(dev); |
314 | 314 | ||
315 | return 0; | 315 | return 0; |
316 | } | 316 | } |
@@ -767,9 +767,9 @@ static int sixpack_ioctl(struct tty_struct *tty, struct file *file, | |||
767 | break; | 767 | break; |
768 | } | 768 | } |
769 | 769 | ||
770 | spin_lock_irq(&dev->xmit_lock); | 770 | netif_tx_lock_bh(dev); |
771 | memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN); | 771 | memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN); |
772 | spin_unlock_irq(&dev->xmit_lock); | 772 | netif_tx_unlock_bh(dev); |
773 | 773 | ||
774 | err = 0; | 774 | err = 0; |
775 | break; | 775 | break; |
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c index d81a8e1eeb8d..3ebbbe56b6e9 100644 --- a/drivers/net/hamradio/mkiss.c +++ b/drivers/net/hamradio/mkiss.c | |||
@@ -357,9 +357,9 @@ static int ax_set_mac_address(struct net_device *dev, void *addr) | |||
357 | { | 357 | { |
358 | struct sockaddr_ax25 *sa = addr; | 358 | struct sockaddr_ax25 *sa = addr; |
359 | 359 | ||
360 | spin_lock_irq(&dev->xmit_lock); | 360 | netif_tx_lock_bh(dev); |
361 | memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN); | 361 | memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN); |
362 | spin_unlock_irq(&dev->xmit_lock); | 362 | netif_tx_unlock_bh(dev); |
363 | 363 | ||
364 | return 0; | 364 | return 0; |
365 | } | 365 | } |
@@ -886,9 +886,9 @@ static int mkiss_ioctl(struct tty_struct *tty, struct file *file, | |||
886 | break; | 886 | break; |
887 | } | 887 | } |
888 | 888 | ||
889 | spin_lock_irq(&dev->xmit_lock); | 889 | netif_tx_lock_bh(dev); |
890 | memcpy(dev->dev_addr, addr, AX25_ADDR_LEN); | 890 | memcpy(dev->dev_addr, addr, AX25_ADDR_LEN); |
891 | spin_unlock_irq(&dev->xmit_lock); | 891 | netif_tx_unlock_bh(dev); |
892 | 892 | ||
893 | err = 0; | 893 | err = 0; |
894 | break; | 894 | break; |
diff --git a/drivers/net/hp-plus.c b/drivers/net/hp-plus.c index 0d7a6250e346..e26a3e407d70 100644 --- a/drivers/net/hp-plus.c +++ b/drivers/net/hp-plus.c | |||
@@ -446,7 +446,7 @@ MODULE_LICENSE("GPL"); | |||
446 | 446 | ||
447 | /* This is set up so that only a single autoprobe takes place per call. | 447 | /* This is set up so that only a single autoprobe takes place per call. |
448 | ISA device autoprobes on a running machine are not recommended. */ | 448 | ISA device autoprobes on a running machine are not recommended. */ |
449 | int | 449 | int __init |
450 | init_module(void) | 450 | init_module(void) |
451 | { | 451 | { |
452 | struct net_device *dev; | 452 | struct net_device *dev; |
diff --git a/drivers/net/hp.c b/drivers/net/hp.c index cf9fb3698a6b..551a71b3c5fd 100644 --- a/drivers/net/hp.c +++ b/drivers/net/hp.c | |||
@@ -384,7 +384,7 @@ hp_block_output(struct net_device *dev, int count, | |||
384 | } | 384 | } |
385 | 385 | ||
386 | /* This function resets the ethercard if something screws up. */ | 386 | /* This function resets the ethercard if something screws up. */ |
387 | static void | 387 | static void __init |
388 | hp_init_card(struct net_device *dev) | 388 | hp_init_card(struct net_device *dev) |
389 | { | 389 | { |
390 | int irq = dev->irq; | 390 | int irq = dev->irq; |
@@ -409,7 +409,7 @@ MODULE_LICENSE("GPL"); | |||
409 | 409 | ||
410 | /* This is set up so that only a single autoprobe takes place per call. | 410 | /* This is set up so that only a single autoprobe takes place per call. |
411 | ISA device autoprobes on a running machine are not recommended. */ | 411 | ISA device autoprobes on a running machine are not recommended. */ |
412 | int | 412 | int __init |
413 | init_module(void) | 413 | init_module(void) |
414 | { | 414 | { |
415 | struct net_device *dev; | 415 | struct net_device *dev; |
diff --git a/drivers/net/ifb.c b/drivers/net/ifb.c index 31fb2d75dc44..2e222ef91e22 100644 --- a/drivers/net/ifb.c +++ b/drivers/net/ifb.c | |||
@@ -76,13 +76,13 @@ static void ri_tasklet(unsigned long dev) | |||
76 | dp->st_task_enter++; | 76 | dp->st_task_enter++; |
77 | if ((skb = skb_peek(&dp->tq)) == NULL) { | 77 | if ((skb = skb_peek(&dp->tq)) == NULL) { |
78 | dp->st_txq_refl_try++; | 78 | dp->st_txq_refl_try++; |
79 | if (spin_trylock(&_dev->xmit_lock)) { | 79 | if (netif_tx_trylock(_dev)) { |
80 | dp->st_rxq_enter++; | 80 | dp->st_rxq_enter++; |
81 | while ((skb = skb_dequeue(&dp->rq)) != NULL) { | 81 | while ((skb = skb_dequeue(&dp->rq)) != NULL) { |
82 | skb_queue_tail(&dp->tq, skb); | 82 | skb_queue_tail(&dp->tq, skb); |
83 | dp->st_rx2tx_tran++; | 83 | dp->st_rx2tx_tran++; |
84 | } | 84 | } |
85 | spin_unlock(&_dev->xmit_lock); | 85 | netif_tx_unlock(_dev); |
86 | } else { | 86 | } else { |
87 | /* reschedule */ | 87 | /* reschedule */ |
88 | dp->st_rxq_notenter++; | 88 | dp->st_rxq_notenter++; |
@@ -110,7 +110,7 @@ static void ri_tasklet(unsigned long dev) | |||
110 | } | 110 | } |
111 | } | 111 | } |
112 | 112 | ||
113 | if (spin_trylock(&_dev->xmit_lock)) { | 113 | if (netif_tx_trylock(_dev)) { |
114 | dp->st_rxq_check++; | 114 | dp->st_rxq_check++; |
115 | if ((skb = skb_peek(&dp->rq)) == NULL) { | 115 | if ((skb = skb_peek(&dp->rq)) == NULL) { |
116 | dp->tasklet_pending = 0; | 116 | dp->tasklet_pending = 0; |
@@ -118,10 +118,10 @@ static void ri_tasklet(unsigned long dev) | |||
118 | netif_wake_queue(_dev); | 118 | netif_wake_queue(_dev); |
119 | } else { | 119 | } else { |
120 | dp->st_rxq_rsch++; | 120 | dp->st_rxq_rsch++; |
121 | spin_unlock(&_dev->xmit_lock); | 121 | netif_tx_unlock(_dev); |
122 | goto resched; | 122 | goto resched; |
123 | } | 123 | } |
124 | spin_unlock(&_dev->xmit_lock); | 124 | netif_tx_unlock(_dev); |
125 | } else { | 125 | } else { |
126 | resched: | 126 | resched: |
127 | dp->tasklet_pending = 1; | 127 | dp->tasklet_pending = 1; |
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig index cff8598aa800..d2ce4896abff 100644 --- a/drivers/net/irda/Kconfig +++ b/drivers/net/irda/Kconfig | |||
@@ -417,5 +417,20 @@ config PXA_FICP | |||
417 | available capabilities may vary from one PXA2xx target to | 417 | available capabilities may vary from one PXA2xx target to |
418 | another. | 418 | another. |
419 | 419 | ||
420 | config MCS_FIR | ||
421 | tristate "MosChip MCS7780 IrDA-USB dongle" | ||
422 | depends on IRDA && USB && EXPERIMENTAL | ||
423 | help | ||
424 | Say Y or M here if you want to build support for the MosChip | ||
425 | MCS7780 IrDA-USB bridge device driver. | ||
426 | |||
427 | USB bridge based on the MosChip MCS7780 don't conform to the | ||
428 | IrDA-USB device class specification, and therefore need their | ||
429 | own specific driver. Those dongles support SIR and FIR (4Mbps) | ||
430 | speeds. | ||
431 | |||
432 | To compile it as a module, choose M here: the module will be called | ||
433 | mcs7780. | ||
434 | |||
420 | endmenu | 435 | endmenu |
421 | 436 | ||
diff --git a/drivers/net/irda/Makefile b/drivers/net/irda/Makefile index c1ce2398efea..5be09f1b9ee2 100644 --- a/drivers/net/irda/Makefile +++ b/drivers/net/irda/Makefile | |||
@@ -19,6 +19,7 @@ obj-$(CONFIG_ALI_FIR) += ali-ircc.o | |||
19 | obj-$(CONFIG_VLSI_FIR) += vlsi_ir.o | 19 | obj-$(CONFIG_VLSI_FIR) += vlsi_ir.o |
20 | obj-$(CONFIG_VIA_FIR) += via-ircc.o | 20 | obj-$(CONFIG_VIA_FIR) += via-ircc.o |
21 | obj-$(CONFIG_PXA_FICP) += pxaficp_ir.o | 21 | obj-$(CONFIG_PXA_FICP) += pxaficp_ir.o |
22 | obj-$(CONFIG_MCS_FIR) += mcs7780.o | ||
22 | # Old dongle drivers for old SIR drivers | 23 | # Old dongle drivers for old SIR drivers |
23 | obj-$(CONFIG_ESI_DONGLE_OLD) += esi.o | 24 | obj-$(CONFIG_ESI_DONGLE_OLD) += esi.o |
24 | obj-$(CONFIG_TEKRAM_DONGLE_OLD) += tekram.o | 25 | obj-$(CONFIG_TEKRAM_DONGLE_OLD) += tekram.o |
diff --git a/drivers/net/irda/ali-ircc.c b/drivers/net/irda/ali-ircc.c index 2e7882eb7d6f..bf1fca5a3fa0 100644 --- a/drivers/net/irda/ali-ircc.c +++ b/drivers/net/irda/ali-ircc.c | |||
@@ -34,14 +34,12 @@ | |||
34 | #include <linux/rtnetlink.h> | 34 | #include <linux/rtnetlink.h> |
35 | #include <linux/serial_reg.h> | 35 | #include <linux/serial_reg.h> |
36 | #include <linux/dma-mapping.h> | 36 | #include <linux/dma-mapping.h> |
37 | #include <linux/platform_device.h> | ||
37 | 38 | ||
38 | #include <asm/io.h> | 39 | #include <asm/io.h> |
39 | #include <asm/dma.h> | 40 | #include <asm/dma.h> |
40 | #include <asm/byteorder.h> | 41 | #include <asm/byteorder.h> |
41 | 42 | ||
42 | #include <linux/pm.h> | ||
43 | #include <linux/pm_legacy.h> | ||
44 | |||
45 | #include <net/irda/wrapper.h> | 43 | #include <net/irda/wrapper.h> |
46 | #include <net/irda/irda.h> | 44 | #include <net/irda/irda.h> |
47 | #include <net/irda/irda_device.h> | 45 | #include <net/irda/irda_device.h> |
@@ -51,7 +49,19 @@ | |||
51 | #define CHIP_IO_EXTENT 8 | 49 | #define CHIP_IO_EXTENT 8 |
52 | #define BROKEN_DONGLE_ID | 50 | #define BROKEN_DONGLE_ID |
53 | 51 | ||
54 | static char *driver_name = "ali-ircc"; | 52 | #define ALI_IRCC_DRIVER_NAME "ali-ircc" |
53 | |||
54 | /* Power Management */ | ||
55 | static int ali_ircc_suspend(struct platform_device *dev, pm_message_t state); | ||
56 | static int ali_ircc_resume(struct platform_device *dev); | ||
57 | |||
58 | static struct platform_driver ali_ircc_driver = { | ||
59 | .suspend = ali_ircc_suspend, | ||
60 | .resume = ali_ircc_resume, | ||
61 | .driver = { | ||
62 | .name = ALI_IRCC_DRIVER_NAME, | ||
63 | }, | ||
64 | }; | ||
55 | 65 | ||
56 | /* Module parameters */ | 66 | /* Module parameters */ |
57 | static int qos_mtt_bits = 0x07; /* 1 ms or more */ | 67 | static int qos_mtt_bits = 0x07; /* 1 ms or more */ |
@@ -97,10 +107,7 @@ static int ali_ircc_is_receiving(struct ali_ircc_cb *self); | |||
97 | static int ali_ircc_net_open(struct net_device *dev); | 107 | static int ali_ircc_net_open(struct net_device *dev); |
98 | static int ali_ircc_net_close(struct net_device *dev); | 108 | static int ali_ircc_net_close(struct net_device *dev); |
99 | static int ali_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); | 109 | static int ali_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); |
100 | static int ali_ircc_pmproc(struct pm_dev *dev, pm_request_t rqst, void *data); | ||
101 | static void ali_ircc_change_speed(struct ali_ircc_cb *self, __u32 baud); | 110 | static void ali_ircc_change_speed(struct ali_ircc_cb *self, __u32 baud); |
102 | static void ali_ircc_suspend(struct ali_ircc_cb *self); | ||
103 | static void ali_ircc_wakeup(struct ali_ircc_cb *self); | ||
104 | static struct net_device_stats *ali_ircc_net_get_stats(struct net_device *dev); | 111 | static struct net_device_stats *ali_ircc_net_get_stats(struct net_device *dev); |
105 | 112 | ||
106 | /* SIR function */ | 113 | /* SIR function */ |
@@ -145,6 +152,14 @@ static int __init ali_ircc_init(void) | |||
145 | int i = 0; | 152 | int i = 0; |
146 | 153 | ||
147 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); | 154 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); |
155 | |||
156 | ret = platform_driver_register(&ali_ircc_driver); | ||
157 | if (ret) { | ||
158 | IRDA_ERROR("%s, Can't register driver!\n", | ||
159 | ALI_IRCC_DRIVER_NAME); | ||
160 | return ret; | ||
161 | } | ||
162 | |||
148 | 163 | ||
149 | /* Probe for all the ALi chipsets we know about */ | 164 | /* Probe for all the ALi chipsets we know about */ |
150 | for (chip= chips; chip->name; chip++, i++) | 165 | for (chip= chips; chip->name; chip++, i++) |
@@ -214,6 +229,10 @@ static int __init ali_ircc_init(void) | |||
214 | } | 229 | } |
215 | 230 | ||
216 | IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); | 231 | IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); |
232 | |||
233 | if (ret) | ||
234 | platform_driver_unregister(&ali_ircc_driver); | ||
235 | |||
217 | return ret; | 236 | return ret; |
218 | } | 237 | } |
219 | 238 | ||
@@ -228,14 +247,14 @@ static void __exit ali_ircc_cleanup(void) | |||
228 | int i; | 247 | int i; |
229 | 248 | ||
230 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); | 249 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); |
231 | |||
232 | pm_unregister_all(ali_ircc_pmproc); | ||
233 | 250 | ||
234 | for (i=0; i < 4; i++) { | 251 | for (i=0; i < 4; i++) { |
235 | if (dev_self[i]) | 252 | if (dev_self[i]) |
236 | ali_ircc_close(dev_self[i]); | 253 | ali_ircc_close(dev_self[i]); |
237 | } | 254 | } |
238 | 255 | ||
256 | platform_driver_unregister(&ali_ircc_driver); | ||
257 | |||
239 | IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); | 258 | IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); |
240 | } | 259 | } |
241 | 260 | ||
@@ -249,7 +268,6 @@ static int ali_ircc_open(int i, chipio_t *info) | |||
249 | { | 268 | { |
250 | struct net_device *dev; | 269 | struct net_device *dev; |
251 | struct ali_ircc_cb *self; | 270 | struct ali_ircc_cb *self; |
252 | struct pm_dev *pmdev; | ||
253 | int dongle_id; | 271 | int dongle_id; |
254 | int err; | 272 | int err; |
255 | 273 | ||
@@ -284,7 +302,8 @@ static int ali_ircc_open(int i, chipio_t *info) | |||
284 | self->io.fifo_size = 16; /* SIR: 16, FIR: 32 Benjamin 2000/11/1 */ | 302 | self->io.fifo_size = 16; /* SIR: 16, FIR: 32 Benjamin 2000/11/1 */ |
285 | 303 | ||
286 | /* Reserve the ioports that we need */ | 304 | /* Reserve the ioports that we need */ |
287 | if (!request_region(self->io.fir_base, self->io.fir_ext, driver_name)) { | 305 | if (!request_region(self->io.fir_base, self->io.fir_ext, |
306 | ALI_IRCC_DRIVER_NAME)) { | ||
288 | IRDA_WARNING("%s(), can't get iobase of 0x%03x\n", __FUNCTION__, | 307 | IRDA_WARNING("%s(), can't get iobase of 0x%03x\n", __FUNCTION__, |
289 | self->io.fir_base); | 308 | self->io.fir_base); |
290 | err = -ENODEV; | 309 | err = -ENODEV; |
@@ -354,13 +373,10 @@ static int ali_ircc_open(int i, chipio_t *info) | |||
354 | 373 | ||
355 | /* Check dongle id */ | 374 | /* Check dongle id */ |
356 | dongle_id = ali_ircc_read_dongle_id(i, info); | 375 | dongle_id = ali_ircc_read_dongle_id(i, info); |
357 | IRDA_MESSAGE("%s(), %s, Found dongle: %s\n", __FUNCTION__, driver_name, dongle_types[dongle_id]); | 376 | IRDA_MESSAGE("%s(), %s, Found dongle: %s\n", __FUNCTION__, |
377 | ALI_IRCC_DRIVER_NAME, dongle_types[dongle_id]); | ||
358 | 378 | ||
359 | self->io.dongle_id = dongle_id; | 379 | self->io.dongle_id = dongle_id; |
360 | |||
361 | pmdev = pm_register(PM_SYS_DEV, PM_SYS_IRDA, ali_ircc_pmproc); | ||
362 | if (pmdev) | ||
363 | pmdev->data = self; | ||
364 | 380 | ||
365 | IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); | 381 | IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); |
366 | 382 | ||
@@ -548,12 +564,11 @@ static int ali_ircc_setup(chipio_t *info) | |||
548 | /* Should be 0x00 in the M1535/M1535D */ | 564 | /* Should be 0x00 in the M1535/M1535D */ |
549 | if(version != 0x00) | 565 | if(version != 0x00) |
550 | { | 566 | { |
551 | IRDA_ERROR("%s, Wrong chip version %02x\n", driver_name, version); | 567 | IRDA_ERROR("%s, Wrong chip version %02x\n", |
568 | ALI_IRCC_DRIVER_NAME, version); | ||
552 | return -1; | 569 | return -1; |
553 | } | 570 | } |
554 | 571 | ||
555 | // IRDA_MESSAGE("%s, Found chip at base=0x%03x\n", driver_name, info->cfg_base); | ||
556 | |||
557 | /* Set FIR FIFO Threshold Register */ | 572 | /* Set FIR FIFO Threshold Register */ |
558 | switch_bank(iobase, BANK1); | 573 | switch_bank(iobase, BANK1); |
559 | outb(RX_FIFO_Threshold, iobase+FIR_FIFO_TR); | 574 | outb(RX_FIFO_Threshold, iobase+FIR_FIFO_TR); |
@@ -583,7 +598,8 @@ static int ali_ircc_setup(chipio_t *info) | |||
583 | /* Switch to SIR space */ | 598 | /* Switch to SIR space */ |
584 | FIR2SIR(iobase); | 599 | FIR2SIR(iobase); |
585 | 600 | ||
586 | IRDA_MESSAGE("%s, driver loaded (Benjamin Kong)\n", driver_name); | 601 | IRDA_MESSAGE("%s, driver loaded (Benjamin Kong)\n", |
602 | ALI_IRCC_DRIVER_NAME); | ||
587 | 603 | ||
588 | /* Enable receive interrupts */ | 604 | /* Enable receive interrupts */ |
589 | // outb(UART_IER_RDI, iobase+UART_IER); //benjamin 2000/11/23 01:25PM | 605 | // outb(UART_IER_RDI, iobase+UART_IER); //benjamin 2000/11/23 01:25PM |
@@ -647,7 +663,8 @@ static irqreturn_t ali_ircc_interrupt(int irq, void *dev_id, | |||
647 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); | 663 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); |
648 | 664 | ||
649 | if (!dev) { | 665 | if (!dev) { |
650 | IRDA_WARNING("%s: irq %d for unknown device.\n", driver_name, irq); | 666 | IRDA_WARNING("%s: irq %d for unknown device.\n", |
667 | ALI_IRCC_DRIVER_NAME, irq); | ||
651 | return IRQ_NONE; | 668 | return IRQ_NONE; |
652 | } | 669 | } |
653 | 670 | ||
@@ -1328,7 +1345,8 @@ static int ali_ircc_net_open(struct net_device *dev) | |||
1328 | /* Request IRQ and install Interrupt Handler */ | 1345 | /* Request IRQ and install Interrupt Handler */ |
1329 | if (request_irq(self->io.irq, ali_ircc_interrupt, 0, dev->name, dev)) | 1346 | if (request_irq(self->io.irq, ali_ircc_interrupt, 0, dev->name, dev)) |
1330 | { | 1347 | { |
1331 | IRDA_WARNING("%s, unable to allocate irq=%d\n", driver_name, | 1348 | IRDA_WARNING("%s, unable to allocate irq=%d\n", |
1349 | ALI_IRCC_DRIVER_NAME, | ||
1332 | self->io.irq); | 1350 | self->io.irq); |
1333 | return -EAGAIN; | 1351 | return -EAGAIN; |
1334 | } | 1352 | } |
@@ -1338,7 +1356,8 @@ static int ali_ircc_net_open(struct net_device *dev) | |||
1338 | * failure. | 1356 | * failure. |
1339 | */ | 1357 | */ |
1340 | if (request_dma(self->io.dma, dev->name)) { | 1358 | if (request_dma(self->io.dma, dev->name)) { |
1341 | IRDA_WARNING("%s, unable to allocate dma=%d\n", driver_name, | 1359 | IRDA_WARNING("%s, unable to allocate dma=%d\n", |
1360 | ALI_IRCC_DRIVER_NAME, | ||
1342 | self->io.dma); | 1361 | self->io.dma); |
1343 | free_irq(self->io.irq, self); | 1362 | free_irq(self->io.irq, self); |
1344 | return -EAGAIN; | 1363 | return -EAGAIN; |
@@ -2108,61 +2127,38 @@ static struct net_device_stats *ali_ircc_net_get_stats(struct net_device *dev) | |||
2108 | return &self->stats; | 2127 | return &self->stats; |
2109 | } | 2128 | } |
2110 | 2129 | ||
2111 | static void ali_ircc_suspend(struct ali_ircc_cb *self) | 2130 | static int ali_ircc_suspend(struct platform_device *dev, pm_message_t state) |
2112 | { | 2131 | { |
2113 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); | 2132 | struct ali_ircc_cb *self = platform_get_drvdata(dev); |
2114 | 2133 | ||
2115 | IRDA_MESSAGE("%s, Suspending\n", driver_name); | 2134 | IRDA_MESSAGE("%s, Suspending\n", ALI_IRCC_DRIVER_NAME); |
2116 | 2135 | ||
2117 | if (self->io.suspended) | 2136 | if (self->io.suspended) |
2118 | return; | 2137 | return 0; |
2119 | 2138 | ||
2120 | ali_ircc_net_close(self->netdev); | 2139 | ali_ircc_net_close(self->netdev); |
2121 | 2140 | ||
2122 | self->io.suspended = 1; | 2141 | self->io.suspended = 1; |
2123 | 2142 | ||
2124 | IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); | 2143 | return 0; |
2125 | } | 2144 | } |
2126 | 2145 | ||
2127 | static void ali_ircc_wakeup(struct ali_ircc_cb *self) | 2146 | static int ali_ircc_resume(struct platform_device *dev) |
2128 | { | 2147 | { |
2129 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); | 2148 | struct ali_ircc_cb *self = platform_get_drvdata(dev); |
2130 | 2149 | ||
2131 | if (!self->io.suspended) | 2150 | if (!self->io.suspended) |
2132 | return; | 2151 | return 0; |
2133 | 2152 | ||
2134 | ali_ircc_net_open(self->netdev); | 2153 | ali_ircc_net_open(self->netdev); |
2135 | 2154 | ||
2136 | IRDA_MESSAGE("%s, Waking up\n", driver_name); | 2155 | IRDA_MESSAGE("%s, Waking up\n", ALI_IRCC_DRIVER_NAME); |
2137 | 2156 | ||
2138 | self->io.suspended = 0; | 2157 | self->io.suspended = 0; |
2139 | |||
2140 | IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); | ||
2141 | } | ||
2142 | 2158 | ||
2143 | static int ali_ircc_pmproc(struct pm_dev *dev, pm_request_t rqst, void *data) | ||
2144 | { | ||
2145 | struct ali_ircc_cb *self = (struct ali_ircc_cb*) dev->data; | ||
2146 | |||
2147 | IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); | ||
2148 | |||
2149 | if (self) { | ||
2150 | switch (rqst) { | ||
2151 | case PM_SUSPEND: | ||
2152 | ali_ircc_suspend(self); | ||
2153 | break; | ||
2154 | case PM_RESUME: | ||
2155 | ali_ircc_wakeup(self); | ||
2156 | break; | ||
2157 | } | ||
2158 | } | ||
2159 | |||
2160 | IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); | ||
2161 | |||
2162 | return 0; | 2159 | return 0; |
2163 | } | 2160 | } |
2164 | 2161 | ||
2165 | |||
2166 | /* ALi Chip Function */ | 2162 | /* ALi Chip Function */ |
2167 | 2163 | ||
2168 | static void SetCOMInterrupts(struct ali_ircc_cb *self , unsigned char enable) | 2164 | static void SetCOMInterrupts(struct ali_ircc_cb *self , unsigned char enable) |
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c index cd87593e4e8a..844fa74ac9ec 100644 --- a/drivers/net/irda/irda-usb.c +++ b/drivers/net/irda/irda-usb.c | |||
@@ -83,9 +83,9 @@ static struct usb_device_id dongles[] = { | |||
83 | /* Extended Systems, Inc., XTNDAccess IrDA USB (ESI-9685) */ | 83 | /* Extended Systems, Inc., XTNDAccess IrDA USB (ESI-9685) */ |
84 | { USB_DEVICE(0x8e9, 0x100), .driver_info = IUC_SPEED_BUG | IUC_NO_WINDOW }, | 84 | { USB_DEVICE(0x8e9, 0x100), .driver_info = IUC_SPEED_BUG | IUC_NO_WINDOW }, |
85 | /* SigmaTel STIR4210/4220/4116 USB IrDA (VFIR) Bridge */ | 85 | /* SigmaTel STIR4210/4220/4116 USB IrDA (VFIR) Bridge */ |
86 | { USB_DEVICE(0x66f, 0x4210), .driver_info = IUC_STIR_4210 | IUC_SPEED_BUG }, | 86 | { USB_DEVICE(0x66f, 0x4210), .driver_info = IUC_STIR421X | IUC_SPEED_BUG }, |
87 | { USB_DEVICE(0x66f, 0x4220), .driver_info = IUC_STIR_4210 | IUC_SPEED_BUG }, | 87 | { USB_DEVICE(0x66f, 0x4220), .driver_info = IUC_STIR421X | IUC_SPEED_BUG }, |
88 | { USB_DEVICE(0x66f, 0x4116), .driver_info = IUC_STIR_4210 | IUC_SPEED_BUG }, | 88 | { USB_DEVICE(0x66f, 0x4116), .driver_info = IUC_STIR421X | IUC_SPEED_BUG }, |
89 | { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | | 89 | { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | |
90 | USB_DEVICE_ID_MATCH_INT_SUBCLASS, | 90 | USB_DEVICE_ID_MATCH_INT_SUBCLASS, |
91 | .bInterfaceClass = USB_CLASS_APP_SPEC, | 91 | .bInterfaceClass = USB_CLASS_APP_SPEC, |
@@ -154,7 +154,7 @@ static void irda_usb_build_header(struct irda_usb_cb *self, | |||
154 | * and if either speed or xbofs (or both) needs | 154 | * and if either speed or xbofs (or both) needs |
155 | * to be changed. | 155 | * to be changed. |
156 | */ | 156 | */ |
157 | if (self->capability & IUC_STIR_4210 && | 157 | if (self->capability & IUC_STIR421X && |
158 | ((self->new_speed != -1) || (self->new_xbofs != -1))) { | 158 | ((self->new_speed != -1) || (self->new_xbofs != -1))) { |
159 | 159 | ||
160 | /* With STIR421x, speed and xBOFs must be set at the same | 160 | /* With STIR421x, speed and xBOFs must be set at the same |
@@ -318,7 +318,7 @@ static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self) | |||
318 | /* Set the new speed and xbofs in this fake frame */ | 318 | /* Set the new speed and xbofs in this fake frame */ |
319 | irda_usb_build_header(self, frame, 1); | 319 | irda_usb_build_header(self, frame, 1); |
320 | 320 | ||
321 | if ( self->capability & IUC_STIR_4210 ) { | 321 | if (self->capability & IUC_STIR421X) { |
322 | if (frame[0] == 0) return ; // do nothing if no change | 322 | if (frame[0] == 0) return ; // do nothing if no change |
323 | frame[1] = 0; // other parameters don't change here | 323 | frame[1] = 0; // other parameters don't change here |
324 | frame[2] = 0; | 324 | frame[2] = 0; |
@@ -455,7 +455,7 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev) | |||
455 | 455 | ||
456 | /* Change setting for next frame */ | 456 | /* Change setting for next frame */ |
457 | 457 | ||
458 | if ( self->capability & IUC_STIR_4210 ) { | 458 | if (self->capability & IUC_STIR421X) { |
459 | __u8 turnaround_time; | 459 | __u8 turnaround_time; |
460 | __u8* frame; | 460 | __u8* frame; |
461 | turnaround_time = get_turnaround_time( skb ); | 461 | turnaround_time = get_turnaround_time( skb ); |
@@ -897,10 +897,13 @@ static void irda_usb_receive(struct urb *urb, struct pt_regs *regs) | |||
897 | docopy = (urb->actual_length < IRDA_RX_COPY_THRESHOLD); | 897 | docopy = (urb->actual_length < IRDA_RX_COPY_THRESHOLD); |
898 | 898 | ||
899 | /* Allocate a new skb */ | 899 | /* Allocate a new skb */ |
900 | if ( self->capability & IUC_STIR_4210 ) | 900 | if (self->capability & IUC_STIR421X) |
901 | newskb = dev_alloc_skb(docopy ? urb->actual_length : IRDA_SKB_MAX_MTU + USB_IRDA_SIGMATEL_HEADER); | 901 | newskb = dev_alloc_skb(docopy ? urb->actual_length : |
902 | IRDA_SKB_MAX_MTU + | ||
903 | USB_IRDA_STIR421X_HEADER); | ||
902 | else | 904 | else |
903 | newskb = dev_alloc_skb(docopy ? urb->actual_length : IRDA_SKB_MAX_MTU); | 905 | newskb = dev_alloc_skb(docopy ? urb->actual_length : |
906 | IRDA_SKB_MAX_MTU); | ||
904 | 907 | ||
905 | if (!newskb) { | 908 | if (!newskb) { |
906 | self->stats.rx_dropped++; | 909 | self->stats.rx_dropped++; |
@@ -1022,188 +1025,140 @@ static int irda_usb_is_receiving(struct irda_usb_cb *self) | |||
1022 | return 0; /* For now */ | 1025 | return 0; /* For now */ |
1023 | } | 1026 | } |
1024 | 1027 | ||
1025 | 1028 | #define STIR421X_PATCH_PRODUCT_VER "Product Version: " | |
1026 | #define STIR421X_PATCH_PRODUCT_VERSION_STR "Product Version: " | 1029 | #define STIR421X_PATCH_STMP_TAG "STMP" |
1027 | #define STIR421X_PATCH_COMPONENT_VERSION_STR "Component Version: " | 1030 | #define STIR421X_PATCH_CODE_OFFSET 512 /* patch image starts before here */ |
1028 | #define STIR421X_PATCH_DATA_TAG_STR "STMP" | 1031 | /* marks end of patch file header (PC DOS text file EOF character) */ |
1029 | #define STIR421X_PATCH_FILE_VERSION_MAX_OFFSET 512 /* version info is before here */ | 1032 | #define STIR421X_PATCH_END_OF_HDR_TAG 0x1A |
1030 | #define STIR421X_PATCH_FILE_IMAGE_MAX_OFFSET 512 /* patch image starts before here */ | 1033 | #define STIR421X_PATCH_BLOCK_SIZE 1023 |
1031 | #define STIR421X_PATCH_FILE_END_OF_HEADER_TAG 0x1A /* marks end of patch file header (PC DOS text file EOF character) */ | ||
1032 | 1034 | ||
1033 | /* | 1035 | /* |
1034 | * Known firmware patches for STIR421x dongles | 1036 | * Function stir421x_fwupload (struct irda_usb_cb *self, |
1037 | * unsigned char *patch, | ||
1038 | * const unsigned int patch_len) | ||
1039 | * | ||
1040 | * Upload firmware code to SigmaTel 421X IRDA-USB dongle | ||
1035 | */ | 1041 | */ |
1036 | static char * stir421x_patches[] = { | 1042 | static int stir421x_fw_upload(struct irda_usb_cb *self, |
1037 | "42101001.sb", | 1043 | unsigned char *patch, |
1038 | "42101002.sb", | 1044 | const unsigned int patch_len) |
1039 | }; | ||
1040 | |||
1041 | static int stir421x_get_patch_version(unsigned char * patch, const unsigned long patch_len) | ||
1042 | { | 1045 | { |
1043 | unsigned int version_offset; | 1046 | int ret = -ENOMEM; |
1044 | unsigned long version_major, version_minor, version_build; | 1047 | int actual_len = 0; |
1045 | unsigned char * version_start; | 1048 | unsigned int i; |
1046 | int version_found = 0; | 1049 | unsigned int block_size = 0; |
1047 | 1050 | unsigned char *patch_block; | |
1048 | for (version_offset = 0; | 1051 | |
1049 | version_offset < STIR421X_PATCH_FILE_END_OF_HEADER_TAG; | 1052 | patch_block = kzalloc(STIR421X_PATCH_BLOCK_SIZE, GFP_KERNEL); |
1050 | version_offset++) { | 1053 | if (patch_block == NULL) |
1051 | if (!memcmp(patch + version_offset, | 1054 | return -ENOMEM; |
1052 | STIR421X_PATCH_PRODUCT_VERSION_STR, | 1055 | |
1053 | sizeof(STIR421X_PATCH_PRODUCT_VERSION_STR) - 1)) { | 1056 | /* break up patch into 1023-byte sections */ |
1054 | version_found = 1; | 1057 | for (i = 0; i < patch_len; i += block_size) { |
1055 | version_start = patch + | 1058 | block_size = patch_len - i; |
1056 | version_offset + | 1059 | |
1057 | sizeof(STIR421X_PATCH_PRODUCT_VERSION_STR) - 1; | 1060 | if (block_size > STIR421X_PATCH_BLOCK_SIZE) |
1058 | break; | 1061 | block_size = STIR421X_PATCH_BLOCK_SIZE; |
1059 | } | 1062 | |
1063 | /* upload the patch section */ | ||
1064 | memcpy(patch_block, patch + i, block_size); | ||
1065 | |||
1066 | ret = usb_bulk_msg(self->usbdev, | ||
1067 | usb_sndbulkpipe(self->usbdev, | ||
1068 | self->bulk_out_ep), | ||
1069 | patch_block, block_size, | ||
1070 | &actual_len, msecs_to_jiffies(500)); | ||
1071 | IRDA_DEBUG(3,"%s(): Bulk send %u bytes, ret=%d\n", | ||
1072 | __FUNCTION__, actual_len, ret); | ||
1073 | |||
1074 | if (ret < 0) | ||
1075 | break; | ||
1060 | } | 1076 | } |
1061 | 1077 | ||
1062 | /* We couldn't find a product version on this patch */ | 1078 | kfree(patch_block); |
1063 | if (!version_found) | ||
1064 | return -EINVAL; | ||
1065 | |||
1066 | /* Let's check if the product version is dotted */ | ||
1067 | if (version_start[3] != '.' || | ||
1068 | version_start[7] != '.') | ||
1069 | return -EINVAL; | ||
1070 | |||
1071 | version_major = simple_strtoul(version_start, NULL, 10); | ||
1072 | version_minor = simple_strtoul(version_start + 4, NULL, 10); | ||
1073 | version_build = simple_strtoul(version_start + 8, NULL, 10); | ||
1074 | |||
1075 | IRDA_DEBUG(2, "%s(), Major: %ld Minor: %ld Build: %ld\n", | ||
1076 | __FUNCTION__, | ||
1077 | version_major, version_minor, version_build); | ||
1078 | |||
1079 | return (((version_major) << 12) + | ||
1080 | ((version_minor) << 8) + | ||
1081 | ((version_build / 10) << 4) + | ||
1082 | (version_build % 10)); | ||
1083 | |||
1084 | } | ||
1085 | |||
1086 | |||
1087 | static int stir421x_upload_patch (struct irda_usb_cb *self, | ||
1088 | unsigned char * patch, | ||
1089 | const unsigned int patch_len) | ||
1090 | { | ||
1091 | int retval = 0; | ||
1092 | int actual_len; | ||
1093 | unsigned int i = 0, download_amount = 0; | ||
1094 | unsigned char * patch_chunk; | ||
1095 | |||
1096 | IRDA_DEBUG (2, "%s(), Uploading STIR421x Patch\n", __FUNCTION__); | ||
1097 | |||
1098 | patch_chunk = kzalloc(STIR421X_MAX_PATCH_DOWNLOAD_SIZE, GFP_KERNEL); | ||
1099 | if (patch_chunk == NULL) | ||
1100 | return -ENOMEM; | ||
1101 | |||
1102 | /* break up patch into 1023-byte sections */ | ||
1103 | for (i = 0; retval >= 0 && i < patch_len; i += download_amount) { | ||
1104 | download_amount = patch_len - i; | ||
1105 | if (download_amount > STIR421X_MAX_PATCH_DOWNLOAD_SIZE) | ||
1106 | download_amount = STIR421X_MAX_PATCH_DOWNLOAD_SIZE; | ||
1107 | |||
1108 | /* download the patch section */ | ||
1109 | memcpy(patch_chunk, patch + i, download_amount); | ||
1110 | |||
1111 | retval = usb_bulk_msg (self->usbdev, | ||
1112 | usb_sndbulkpipe (self->usbdev, | ||
1113 | self->bulk_out_ep), | ||
1114 | patch_chunk, download_amount, | ||
1115 | &actual_len, msecs_to_jiffies (500)); | ||
1116 | IRDA_DEBUG (2, "%s(), Sent %u bytes\n", __FUNCTION__, | ||
1117 | actual_len); | ||
1118 | if (retval == 0) | ||
1119 | mdelay(10); | ||
1120 | } | ||
1121 | |||
1122 | kfree(patch_chunk); | ||
1123 | |||
1124 | if (i != patch_len) { | ||
1125 | IRDA_ERROR ("%s(), Pushed %d bytes (!= patch_len (%d))\n", | ||
1126 | __FUNCTION__, i, patch_len); | ||
1127 | retval = -EIO; | ||
1128 | } | ||
1129 | |||
1130 | if (retval < 0) | ||
1131 | /* todo - mark device as not ready */ | ||
1132 | IRDA_ERROR ("%s(), STIR421x patch upload failed (%d)\n", | ||
1133 | __FUNCTION__, retval); | ||
1134 | |||
1135 | return retval; | ||
1136 | } | ||
1137 | 1079 | ||
1080 | return ret; | ||
1081 | } | ||
1138 | 1082 | ||
1083 | /* | ||
1084 | * Function stir421x_patch_device(struct irda_usb_cb *self) | ||
1085 | * | ||
1086 | * Get a firmware code from userspase using hotplug request_firmware() call | ||
1087 | */ | ||
1139 | static int stir421x_patch_device(struct irda_usb_cb *self) | 1088 | static int stir421x_patch_device(struct irda_usb_cb *self) |
1140 | { | 1089 | { |
1141 | unsigned int i, patch_found = 0, data_found = 0, data_offset; | 1090 | unsigned int i; |
1142 | int patch_version, ret = 0; | 1091 | int ret; |
1143 | const struct firmware *fw_entry; | 1092 | char stir421x_fw_name[11]; |
1144 | 1093 | const struct firmware *fw; | |
1145 | for (i = 0; i < ARRAY_SIZE(stir421x_patches); i++) { | 1094 | unsigned char *fw_version_ptr; /* pointer to version string */ |
1146 | if(request_firmware(&fw_entry, stir421x_patches[i], &self->usbdev->dev) != 0) { | 1095 | unsigned long fw_version = 0; |
1147 | IRDA_ERROR( "%s(), Patch %s is not available\n", __FUNCTION__, stir421x_patches[i]); | 1096 | |
1148 | continue; | 1097 | /* |
1149 | } | 1098 | * Known firmware patch file names for STIR421x dongles |
1150 | 1099 | * are "42101001.sb" or "42101002.sb" | |
1151 | /* We found a patch from userspace */ | 1100 | */ |
1152 | patch_version = stir421x_get_patch_version (fw_entry->data, fw_entry->size); | 1101 | sprintf(stir421x_fw_name, "4210%4X.sb", |
1153 | 1102 | self->usbdev->descriptor.bcdDevice); | |
1154 | if (patch_version < 0) { | 1103 | ret = request_firmware(&fw, stir421x_fw_name, &self->usbdev->dev); |
1155 | /* Couldn't fetch a version, let's move on to the next file */ | 1104 | if (ret < 0) |
1156 | IRDA_ERROR("%s(), version parsing failed\n", __FUNCTION__); | 1105 | return ret; |
1157 | ret = patch_version; | 1106 | |
1158 | release_firmware(fw_entry); | 1107 | /* We get a patch from userspace */ |
1159 | continue; | 1108 | IRDA_MESSAGE("%s(): Received firmware %s (%u bytes)\n", |
1160 | } | 1109 | __FUNCTION__, stir421x_fw_name, fw->size); |
1161 | 1110 | ||
1162 | if (patch_version != self->usbdev->descriptor.bcdDevice) { | 1111 | ret = -EINVAL; |
1163 | /* Patch version and device don't match */ | 1112 | |
1164 | IRDA_ERROR ("%s(), wrong patch version (%d <-> %d)\n", | 1113 | /* Get the bcd product version */ |
1165 | __FUNCTION__, | 1114 | if (!memcmp(fw->data, STIR421X_PATCH_PRODUCT_VER, |
1166 | patch_version, self->usbdev->descriptor.bcdDevice); | 1115 | sizeof(STIR421X_PATCH_PRODUCT_VER) - 1)) { |
1167 | ret = -EINVAL; | 1116 | fw_version_ptr = fw->data + |
1168 | release_firmware(fw_entry); | 1117 | sizeof(STIR421X_PATCH_PRODUCT_VER) - 1; |
1169 | continue; | 1118 | |
1170 | } | 1119 | /* Let's check if the product version is dotted */ |
1171 | 1120 | if (fw_version_ptr[3] == '.' && | |
1172 | /* If we're here, we've found a correct patch */ | 1121 | fw_version_ptr[7] == '.') { |
1173 | patch_found = 1; | 1122 | unsigned long major, minor, build; |
1174 | break; | 1123 | major = simple_strtoul(fw_version_ptr, NULL, 10); |
1175 | 1124 | minor = simple_strtoul(fw_version_ptr + 4, NULL, 10); | |
1176 | } | 1125 | build = simple_strtoul(fw_version_ptr + 8, NULL, 10); |
1177 | 1126 | ||
1178 | /* We couldn't find a valid firmware, let's leave */ | 1127 | fw_version = (major << 12) |
1179 | if (!patch_found) | 1128 | + (minor << 8) |
1180 | return ret; | 1129 | + ((build / 10) << 4) |
1181 | 1130 | + (build % 10); | |
1182 | /* The actual image starts after the "STMP" keyword */ | 1131 | |
1183 | for (data_offset = 0; data_offset < STIR421X_PATCH_FILE_IMAGE_MAX_OFFSET; data_offset++) { | 1132 | IRDA_DEBUG(3, "%s(): Firmware Product version %ld\n", |
1184 | if (!memcmp(fw_entry->data + data_offset, | 1133 | __FUNCTION__, fw_version); |
1185 | STIR421X_PATCH_DATA_TAG_STR, | 1134 | } |
1186 | sizeof(STIR421X_PATCH_FILE_IMAGE_MAX_OFFSET))) { | 1135 | } |
1187 | IRDA_DEBUG(2, "%s(), found patch data for STIR421x at offset %d\n", | 1136 | |
1188 | __FUNCTION__, data_offset); | 1137 | if (self->usbdev->descriptor.bcdDevice == fw_version) { |
1189 | data_found = 1; | 1138 | /* |
1190 | break; | 1139 | * If we're here, we've found a correct patch |
1191 | } | 1140 | * The actual image starts after the "STMP" keyword |
1192 | } | 1141 | * so forward to the firmware header tag |
1193 | 1142 | */ | |
1194 | /* We couldn't find "STMP" from the header */ | 1143 | for (i = 0; (fw->data[i] != STIR421X_PATCH_END_OF_HDR_TAG) |
1195 | if (!data_found) | 1144 | && (i < fw->size); i++) ; |
1196 | return -EINVAL; | 1145 | /* here we check for the out of buffer case */ |
1197 | 1146 | if ((STIR421X_PATCH_END_OF_HDR_TAG == fw->data[i]) | |
1198 | /* Let's upload the patch to the target */ | 1147 | && (i < STIR421X_PATCH_CODE_OFFSET)) { |
1199 | ret = stir421x_upload_patch(self, | 1148 | if (!memcmp(fw->data + i + 1, STIR421X_PATCH_STMP_TAG, |
1200 | &fw_entry->data[data_offset + sizeof(STIR421X_PATCH_FILE_IMAGE_MAX_OFFSET)], | 1149 | sizeof(STIR421X_PATCH_STMP_TAG) - 1)) { |
1201 | fw_entry->size - (data_offset + sizeof(STIR421X_PATCH_FILE_IMAGE_MAX_OFFSET))); | 1150 | |
1202 | 1151 | /* We can upload the patch to the target */ | |
1203 | release_firmware(fw_entry); | 1152 | i += sizeof(STIR421X_PATCH_STMP_TAG); |
1204 | 1153 | ret = stir421x_fw_upload(self, &fw->data[i], | |
1205 | return ret; | 1154 | fw->size - i); |
1206 | 1155 | } | |
1156 | } | ||
1157 | } | ||
1158 | |||
1159 | release_firmware(fw); | ||
1160 | |||
1161 | return ret; | ||
1207 | } | 1162 | } |
1208 | 1163 | ||
1209 | 1164 | ||
@@ -1702,12 +1657,12 @@ static int irda_usb_probe(struct usb_interface *intf, | |||
1702 | init_timer(&self->rx_defer_timer); | 1657 | init_timer(&self->rx_defer_timer); |
1703 | 1658 | ||
1704 | self->capability = id->driver_info; | 1659 | self->capability = id->driver_info; |
1705 | self->needspatch = ((self->capability & IUC_STIR_4210) != 0) ; | 1660 | self->needspatch = ((self->capability & IUC_STIR421X) != 0); |
1706 | 1661 | ||
1707 | /* Create all of the needed urbs */ | 1662 | /* Create all of the needed urbs */ |
1708 | if (self->capability & IUC_STIR_4210) { | 1663 | if (self->capability & IUC_STIR421X) { |
1709 | self->max_rx_urb = IU_SIGMATEL_MAX_RX_URBS; | 1664 | self->max_rx_urb = IU_SIGMATEL_MAX_RX_URBS; |
1710 | self->header_length = USB_IRDA_SIGMATEL_HEADER; | 1665 | self->header_length = USB_IRDA_STIR421X_HEADER; |
1711 | } else { | 1666 | } else { |
1712 | self->max_rx_urb = IU_MAX_RX_URBS; | 1667 | self->max_rx_urb = IU_MAX_RX_URBS; |
1713 | self->header_length = USB_IRDA_HEADER; | 1668 | self->header_length = USB_IRDA_HEADER; |
@@ -1813,8 +1768,8 @@ static int irda_usb_probe(struct usb_interface *intf, | |||
1813 | /* Now we fetch and upload the firmware patch */ | 1768 | /* Now we fetch and upload the firmware patch */ |
1814 | ret = stir421x_patch_device(self); | 1769 | ret = stir421x_patch_device(self); |
1815 | self->needspatch = (ret < 0); | 1770 | self->needspatch = (ret < 0); |
1816 | if (ret < 0) { | 1771 | if (self->needspatch) { |
1817 | printk("patch_device failed\n"); | 1772 | IRDA_ERROR("STIR421X: Couldn't upload patch\n"); |
1818 | goto err_out_5; | 1773 | goto err_out_5; |
1819 | } | 1774 | } |
1820 | 1775 | ||
diff --git a/drivers/net/irda/irda-usb.h b/drivers/net/irda/irda-usb.h index d833db52cebf..6b2271f18e77 100644 --- a/drivers/net/irda/irda-usb.h +++ b/drivers/net/irda/irda-usb.h | |||
@@ -34,9 +34,6 @@ | |||
34 | #include <net/irda/irda.h> | 34 | #include <net/irda/irda.h> |
35 | #include <net/irda/irda_device.h> /* struct irlap_cb */ | 35 | #include <net/irda/irda_device.h> /* struct irlap_cb */ |
36 | 36 | ||
37 | #define PATCH_FILE_SIZE_MAX 65536 | ||
38 | #define PATCH_FILE_SIZE_MIN 80 | ||
39 | |||
40 | #define RX_COPY_THRESHOLD 200 | 37 | #define RX_COPY_THRESHOLD 200 |
41 | #define IRDA_USB_MAX_MTU 2051 | 38 | #define IRDA_USB_MAX_MTU 2051 |
42 | #define IRDA_USB_SPEED_MTU 64 /* Weird, but work like this */ | 39 | #define IRDA_USB_SPEED_MTU 64 /* Weird, but work like this */ |
@@ -107,14 +104,15 @@ | |||
107 | #define IUC_SMALL_PKT 0x10 /* Device doesn't behave with big Rx packets */ | 104 | #define IUC_SMALL_PKT 0x10 /* Device doesn't behave with big Rx packets */ |
108 | #define IUC_MAX_WINDOW 0x20 /* Device underestimate the Rx window */ | 105 | #define IUC_MAX_WINDOW 0x20 /* Device underestimate the Rx window */ |
109 | #define IUC_MAX_XBOFS 0x40 /* Device need more xbofs than advertised */ | 106 | #define IUC_MAX_XBOFS 0x40 /* Device need more xbofs than advertised */ |
110 | #define IUC_STIR_4210 0x80 /* SigmaTel 4210/4220/4116 VFIR */ | 107 | #define IUC_STIR421X 0x80 /* SigmaTel 4210/4220/4116 VFIR */ |
111 | 108 | ||
112 | /* USB class definitions */ | 109 | /* USB class definitions */ |
113 | #define USB_IRDA_HEADER 0x01 | 110 | #define USB_IRDA_HEADER 0x01 |
114 | #define USB_CLASS_IRDA 0x02 /* USB_CLASS_APP_SPEC subclass */ | 111 | #define USB_CLASS_IRDA 0x02 /* USB_CLASS_APP_SPEC subclass */ |
115 | #define USB_DT_IRDA 0x21 | 112 | #define USB_DT_IRDA 0x21 |
116 | #define USB_IRDA_SIGMATEL_HEADER 0x03 | 113 | #define USB_IRDA_STIR421X_HEADER 0x03 |
117 | #define IU_SIGMATEL_MAX_RX_URBS (IU_MAX_ACTIVE_RX_URBS + USB_IRDA_SIGMATEL_HEADER) | 114 | #define IU_SIGMATEL_MAX_RX_URBS (IU_MAX_ACTIVE_RX_URBS + \ |
115 | USB_IRDA_STIR421X_HEADER) | ||
118 | 116 | ||
119 | struct irda_class_desc { | 117 | struct irda_class_desc { |
120 | __u8 bLength; | 118 | __u8 bLength; |
diff --git a/drivers/net/irda/mcs7780.c b/drivers/net/irda/mcs7780.c new file mode 100644 index 000000000000..754297fc8f22 --- /dev/null +++ b/drivers/net/irda/mcs7780.c | |||
@@ -0,0 +1,1009 @@ | |||
1 | /***************************************************************************** | ||
2 | * | ||
3 | * Filename: mcs7780.c | ||
4 | * Version: 0.4-alpha | ||
5 | * Description: Irda MosChip USB Dongle Driver | ||
6 | * Authors: Lukasz Stelmach <stlman@poczta.fm> | ||
7 | * Brian Pugh <bpugh@cs.pdx.edu> | ||
8 | * Judy Fischbach <jfisch@cs.pdx.edu> | ||
9 | * | ||
10 | * Based on stir4200 driver, but some things done differently. | ||
11 | * Based on earlier driver by Paul Stewart <stewart@parc.com> | ||
12 | * | ||
13 | * Copyright (C) 2000, Roman Weissgaerber <weissg@vienna.at> | ||
14 | * Copyright (C) 2001, Dag Brattli <dag@brattli.net> | ||
15 | * Copyright (C) 2001, Jean Tourrilhes <jt@hpl.hp.com> | ||
16 | * Copyright (C) 2004, Stephen Hemminger <shemminger@osdl.org> | ||
17 | * Copyright (C) 2005, Lukasz Stelmach <stlman@poczta.fm> | ||
18 | * Copyright (C) 2005, Brian Pugh <bpugh@cs.pdx.edu> | ||
19 | * Copyright (C) 2005, Judy Fischbach <jfisch@cs.pdx.edu> | ||
20 | * | ||
21 | * This program is free software; you can redistribute it and/or modify | ||
22 | * it under the terms of the GNU General Public License as published by | ||
23 | * the Free Software Foundation; either version 2 of the License, or | ||
24 | * (at your option) any later version. | ||
25 | * | ||
26 | * This program is distributed in the hope that it will be useful, | ||
27 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
28 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
29 | * GNU General Public License for more details. | ||
30 | * | ||
31 | * You should have received a copy of the GNU General Public License | ||
32 | * along with this program; if not, write to the Free Software | ||
33 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
34 | * | ||
35 | *****************************************************************************/ | ||
36 | |||
37 | /* | ||
38 | * MCS7780 is a simple USB to IrDA bridge by MosChip. It is neither | ||
39 | * compatibile with irda-usb nor with stir4200. Although it is quite | ||
40 | * similar to the later as far as general idea of operation is concerned. | ||
41 | * That is it requires the software to do all the framing job at SIR speeds. | ||
42 | * The hardware does take care of the framing at MIR and FIR speeds. | ||
43 | * It supports all speeds from 2400 through 4Mbps | ||
44 | */ | ||
45 | |||
46 | #include <linux/module.h> | ||
47 | #include <linux/moduleparam.h> | ||
48 | #include <linux/config.h> | ||
49 | #include <linux/kernel.h> | ||
50 | #include <linux/types.h> | ||
51 | #include <linux/errno.h> | ||
52 | #include <linux/init.h> | ||
53 | #include <linux/slab.h> | ||
54 | #include <linux/module.h> | ||
55 | #include <linux/kref.h> | ||
56 | #include <linux/usb.h> | ||
57 | #include <linux/device.h> | ||
58 | #include <linux/crc32.h> | ||
59 | |||
60 | #include <asm/unaligned.h> | ||
61 | #include <asm/byteorder.h> | ||
62 | #include <asm/uaccess.h> | ||
63 | |||
64 | #include <net/irda/irda.h> | ||
65 | #include <net/irda/wrapper.h> | ||
66 | #include <net/irda/crc.h> | ||
67 | |||
68 | #include "mcs7780.h" | ||
69 | |||
70 | #define MCS_VENDOR_ID 0x9710 | ||
71 | #define MCS_PRODUCT_ID 0x7780 | ||
72 | |||
73 | static struct usb_device_id mcs_table[] = { | ||
74 | /* MosChip Corp., MCS7780 FIR-USB Adapter */ | ||
75 | {USB_DEVICE(MCS_VENDOR_ID, MCS_PRODUCT_ID)}, | ||
76 | {}, | ||
77 | }; | ||
78 | |||
79 | MODULE_AUTHOR("Brian Pugh <bpugh@cs.pdx.edu>"); | ||
80 | MODULE_DESCRIPTION("IrDA-USB Dongle Driver for MosChip MCS7780"); | ||
81 | MODULE_VERSION("0.3alpha"); | ||
82 | MODULE_LICENSE("GPL"); | ||
83 | |||
84 | MODULE_DEVICE_TABLE(usb, mcs_table); | ||
85 | |||
86 | static int qos_mtt_bits = 0x07 /* > 1ms */ ; | ||
87 | module_param(qos_mtt_bits, int, 0); | ||
88 | MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time"); | ||
89 | |||
90 | static int receive_mode = 0x1; | ||
91 | module_param(receive_mode, int, 0); | ||
92 | MODULE_PARM_DESC(receive_mode, | ||
93 | "Receive mode of the device (1:fast, 0:slow, default:1)"); | ||
94 | |||
95 | static int sir_tweak = 1; | ||
96 | module_param(sir_tweak, int, 0444); | ||
97 | MODULE_PARM_DESC(sir_tweak, | ||
98 | "Default pulse width (1:1.6us, 0:3/16 bit, default:1)."); | ||
99 | |||
100 | static int transceiver_type = MCS_TSC_VISHAY; | ||
101 | module_param(transceiver_type, int, 0444); | ||
102 | MODULE_PARM_DESC(transceiver_type, "IR transceiver type, see mcs7780.h."); | ||
103 | |||
104 | struct usb_driver mcs_driver = { | ||
105 | .name = "mcs7780", | ||
106 | .probe = mcs_probe, | ||
107 | .disconnect = mcs_disconnect, | ||
108 | .id_table = mcs_table, | ||
109 | }; | ||
110 | |||
111 | /* speed flag selection by direct addressing. | ||
112 | addr = (speed >> 8) & 0x0f | ||
113 | |||
114 | 0x1 57600 0x2 115200 0x4 1152000 0x5 9600 | ||
115 | 0x6 38400 0x9 2400 0xa 576000 0xb 19200 | ||
116 | |||
117 | 4Mbps (or 2400) must be checked separately. Since it also has | ||
118 | to be programmed in a different manner that is not a big problem. | ||
119 | */ | ||
120 | static __u16 mcs_speed_set[16] = { 0, | ||
121 | MCS_SPEED_57600, | ||
122 | MCS_SPEED_115200, | ||
123 | 0, | ||
124 | MCS_SPEED_1152000, | ||
125 | MCS_SPEED_9600, | ||
126 | MCS_SPEED_38400, | ||
127 | 0, 0, | ||
128 | MCS_SPEED_2400, | ||
129 | MCS_SPEED_576000, | ||
130 | MCS_SPEED_19200, | ||
131 | 0, 0, 0, | ||
132 | }; | ||
133 | |||
134 | /* Set given 16 bit register with a 16 bit value. Send control message | ||
135 | * to set dongle register. */ | ||
136 | static int mcs_set_reg(struct mcs_cb *mcs, __u16 reg, __u16 val) | ||
137 | { | ||
138 | struct usb_device *dev = mcs->usbdev; | ||
139 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, | ||
140 | MCS_WR_RTYPE, val, reg, NULL, 0, | ||
141 | msecs_to_jiffies(MCS_CTRL_TIMEOUT)); | ||
142 | } | ||
143 | |||
144 | /* Get 16 bit register value. Send contol message to read dongle register. */ | ||
145 | static int mcs_get_reg(struct mcs_cb *mcs, __u16 reg, __u16 * val) | ||
146 | { | ||
147 | struct usb_device *dev = mcs->usbdev; | ||
148 | int ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ, | ||
149 | MCS_RD_RTYPE, 0, reg, val, 2, | ||
150 | msecs_to_jiffies(MCS_CTRL_TIMEOUT)); | ||
151 | |||
152 | return ret; | ||
153 | } | ||
154 | |||
155 | /* Setup a communication between mcs7780 and TFDU chips. It is described | ||
156 | * in more detail in the data sheet. The setup sequence puts the the | ||
157 | * vishay tranceiver into high speed mode. It will also receive SIR speed | ||
158 | * packets but at reduced sensitivity. | ||
159 | */ | ||
160 | |||
161 | /* 0: OK 1:ERROR */ | ||
162 | static inline int mcs_setup_transceiver_vishay(struct mcs_cb *mcs) | ||
163 | { | ||
164 | int ret = 0; | ||
165 | __u16 rval; | ||
166 | |||
167 | /* mcs_get_reg should read exactly two bytes from the dongle */ | ||
168 | ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval); | ||
169 | if (unlikely(ret != 2)) { | ||
170 | ret = -EIO; | ||
171 | goto error; | ||
172 | } | ||
173 | |||
174 | /* The MCS_XCVR_CONF bit puts the transceiver into configuration | ||
175 | * mode. The MCS_MODE0 bit must start out high (1) and then | ||
176 | * transition to low and the MCS_STFIR and MCS_MODE1 bits must | ||
177 | * be low. | ||
178 | */ | ||
179 | rval |= (MCS_MODE0 | MCS_XCVR_CONF); | ||
180 | rval &= ~MCS_STFIR; | ||
181 | rval &= ~MCS_MODE1; | ||
182 | ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval); | ||
183 | if (unlikely(ret)) | ||
184 | goto error; | ||
185 | |||
186 | rval &= ~MCS_MODE0; | ||
187 | ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval); | ||
188 | if (unlikely(ret)) | ||
189 | goto error; | ||
190 | |||
191 | rval &= ~MCS_XCVR_CONF; | ||
192 | ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval); | ||
193 | if (unlikely(ret)) | ||
194 | goto error; | ||
195 | |||
196 | ret = 0; | ||
197 | error: | ||
198 | return ret; | ||
199 | } | ||
200 | |||
201 | /* Setup a communication between mcs7780 and agilent chip. */ | ||
202 | static inline int mcs_setup_transceiver_agilent(struct mcs_cb *mcs) | ||
203 | { | ||
204 | IRDA_WARNING("This transceiver type is not supported yet."); | ||
205 | return 1; | ||
206 | } | ||
207 | |||
208 | /* Setup a communication between mcs7780 and sharp chip. */ | ||
209 | static inline int mcs_setup_transceiver_sharp(struct mcs_cb *mcs) | ||
210 | { | ||
211 | IRDA_WARNING("This transceiver type is not supported yet."); | ||
212 | return 1; | ||
213 | } | ||
214 | |||
215 | /* Common setup for all transceivers */ | ||
216 | static inline int mcs_setup_transceiver(struct mcs_cb *mcs) | ||
217 | { | ||
218 | int ret = 0; | ||
219 | __u16 rval; | ||
220 | char *msg; | ||
221 | |||
222 | msg = "Basic transceiver setup error."; | ||
223 | |||
224 | /* read value of MODE Register, set the DRIVER and RESET bits | ||
225 | * and write value back out to MODE Register | ||
226 | */ | ||
227 | ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval); | ||
228 | if(unlikely(ret != 2)) | ||
229 | goto error; | ||
230 | rval |= MCS_DRIVER; /* put the mcs7780 into configuration mode. */ | ||
231 | ret = mcs_set_reg(mcs, MCS_MODE_REG, rval); | ||
232 | if(unlikely(ret)) | ||
233 | goto error; | ||
234 | |||
235 | rval = 0; /* set min pulse width to 0 initially. */ | ||
236 | ret = mcs_set_reg(mcs, MCS_MINRXPW_REG, rval); | ||
237 | if(unlikely(ret)) | ||
238 | goto error; | ||
239 | |||
240 | ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval); | ||
241 | if(unlikely(ret != 2)) | ||
242 | goto error; | ||
243 | |||
244 | rval &= ~MCS_FIR; /* turn off fir mode. */ | ||
245 | if(mcs->sir_tweak) | ||
246 | rval |= MCS_SIR16US; /* 1.6us pulse width */ | ||
247 | else | ||
248 | rval &= ~MCS_SIR16US; /* 3/16 bit time pulse width */ | ||
249 | |||
250 | /* make sure ask mode and back to back packets are off. */ | ||
251 | rval &= ~(MCS_BBTG | MCS_ASK); | ||
252 | |||
253 | rval &= ~MCS_SPEED_MASK; | ||
254 | rval |= MCS_SPEED_9600; /* make sure initial speed is 9600. */ | ||
255 | mcs->speed = 9600; | ||
256 | mcs->new_speed = 0; /* new_speed is set to 0 */ | ||
257 | rval &= ~MCS_PLLPWDN; /* disable power down. */ | ||
258 | |||
259 | /* make sure device determines direction and that the auto send sip | ||
260 | * pulse are on. | ||
261 | */ | ||
262 | rval |= MCS_DTD | MCS_SIPEN; | ||
263 | |||
264 | ret = mcs_set_reg(mcs, MCS_MODE_REG, rval); | ||
265 | if(unlikely(ret)) | ||
266 | goto error; | ||
267 | |||
268 | msg = "transceiver model specific setup error."; | ||
269 | switch (mcs->transceiver_type) { | ||
270 | case MCS_TSC_VISHAY: | ||
271 | ret = mcs_setup_transceiver_vishay(mcs); | ||
272 | break; | ||
273 | |||
274 | case MCS_TSC_SHARP: | ||
275 | ret = mcs_setup_transceiver_sharp(mcs); | ||
276 | break; | ||
277 | |||
278 | case MCS_TSC_AGILENT: | ||
279 | ret = mcs_setup_transceiver_agilent(mcs); | ||
280 | break; | ||
281 | |||
282 | default: | ||
283 | IRDA_WARNING("Unknown transceiver type: %d", | ||
284 | mcs->transceiver_type); | ||
285 | ret = 1; | ||
286 | } | ||
287 | if (unlikely(ret)) | ||
288 | goto error; | ||
289 | |||
290 | /* If transceiver is not SHARP, then if receive mode set | ||
291 | * on the RXFAST bit in the XCVR Register otherwise unset it | ||
292 | */ | ||
293 | if (mcs->transceiver_type != MCS_TSC_SHARP) { | ||
294 | |||
295 | ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval); | ||
296 | if (unlikely(ret != 2)) | ||
297 | goto error; | ||
298 | if (mcs->receive_mode) | ||
299 | rval |= MCS_RXFAST; | ||
300 | else | ||
301 | rval &= ~MCS_RXFAST; | ||
302 | ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval); | ||
303 | if (unlikely(ret)) | ||
304 | goto error; | ||
305 | } | ||
306 | |||
307 | msg = "transceiver reset."; | ||
308 | |||
309 | ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval); | ||
310 | if (unlikely(ret != 2)) | ||
311 | goto error; | ||
312 | |||
313 | /* reset the mcs7780 so all changes take effect. */ | ||
314 | rval &= ~MCS_RESET; | ||
315 | ret = mcs_set_reg(mcs, MCS_MODE_REG, rval); | ||
316 | if (unlikely(ret)) | ||
317 | goto error; | ||
318 | else | ||
319 | return ret; | ||
320 | |||
321 | error: | ||
322 | IRDA_ERROR("%s", msg); | ||
323 | return ret; | ||
324 | } | ||
325 | |||
326 | /* Wraps the data in format for SIR */ | ||
327 | static inline int mcs_wrap_sir_skb(struct sk_buff *skb, __u8 * buf) | ||
328 | { | ||
329 | int wraplen; | ||
330 | |||
331 | /* 2: full frame length, including "the length" */ | ||
332 | wraplen = async_wrap_skb(skb, buf + 2, 4094); | ||
333 | |||
334 | wraplen += 2; | ||
335 | buf[0] = wraplen & 0xff; | ||
336 | buf[1] = (wraplen >> 8) & 0xff; | ||
337 | |||
338 | return wraplen; | ||
339 | } | ||
340 | |||
341 | /* Wraps the data in format for FIR */ | ||
342 | static unsigned mcs_wrap_fir_skb(const struct sk_buff *skb, __u8 *buf) | ||
343 | { | ||
344 | unsigned int len = 0; | ||
345 | __u32 fcs = ~(crc32_le(~0, skb->data, skb->len)); | ||
346 | |||
347 | /* add 2 bytes for length value and 4 bytes for fcs. */ | ||
348 | len = skb->len + 6; | ||
349 | |||
350 | /* The mcs7780 requires that the first two bytes are the packet | ||
351 | * length in little endian order. Note: the length value includes | ||
352 | * the two bytes for the length value itself. | ||
353 | */ | ||
354 | buf[0] = len & 0xff; | ||
355 | buf[1] = (len >> 8) & 0xff; | ||
356 | /* copy the data into the tx buffer. */ | ||
357 | memcpy(buf+2, skb->data, skb->len); | ||
358 | /* put the fcs in the last four bytes in little endian order. */ | ||
359 | buf[len - 4] = fcs & 0xff; | ||
360 | buf[len - 3] = (fcs >> 8) & 0xff; | ||
361 | buf[len - 2] = (fcs >> 16) & 0xff; | ||
362 | buf[len - 1] = (fcs >> 24) & 0xff; | ||
363 | |||
364 | return len; | ||
365 | } | ||
366 | |||
367 | /* Wraps the data in format for MIR */ | ||
368 | static unsigned mcs_wrap_mir_skb(const struct sk_buff *skb, __u8 *buf) | ||
369 | { | ||
370 | __u16 fcs = 0; | ||
371 | int len = skb->len + 4; | ||
372 | |||
373 | fcs = ~(irda_calc_crc16(~fcs, skb->data, skb->len)); | ||
374 | /* put the total packet length in first. Note: packet length | ||
375 | * value includes the two bytes that hold the packet length | ||
376 | * itself. | ||
377 | */ | ||
378 | buf[0] = len & 0xff; | ||
379 | buf[1] = (len >> 8) & 0xff; | ||
380 | /* copy the data */ | ||
381 | memcpy(buf+2, skb->data, skb->len); | ||
382 | /* put the fcs in last two bytes in little endian order. */ | ||
383 | buf[len - 2] = fcs & 0xff; | ||
384 | buf[len - 1] = (fcs >> 8) & 0xff; | ||
385 | |||
386 | return len; | ||
387 | } | ||
388 | |||
389 | /* Unwrap received packets at MIR speed. A 16 bit crc_ccitt checksum is | ||
390 | * used for the fcs. When performed over the entire packet the result | ||
391 | * should be GOOD_FCS = 0xf0b8. Hands the unwrapped data off to the IrDA | ||
392 | * layer via a sk_buff. | ||
393 | */ | ||
394 | static void mcs_unwrap_mir(struct mcs_cb *mcs, __u8 *buf, int len) | ||
395 | { | ||
396 | __u16 fcs; | ||
397 | int new_len; | ||
398 | struct sk_buff *skb; | ||
399 | |||
400 | /* Assume that the frames are going to fill a single packet | ||
401 | * rather than span multiple packets. | ||
402 | */ | ||
403 | |||
404 | new_len = len - 2; | ||
405 | if(unlikely(new_len <= 0)) { | ||
406 | IRDA_ERROR("%s short frame length %d\n", | ||
407 | mcs->netdev->name, new_len); | ||
408 | ++mcs->stats.rx_errors; | ||
409 | ++mcs->stats.rx_length_errors; | ||
410 | return; | ||
411 | } | ||
412 | fcs = 0; | ||
413 | fcs = irda_calc_crc16(~fcs, buf, len); | ||
414 | |||
415 | if(fcs != GOOD_FCS) { | ||
416 | IRDA_ERROR("crc error calc 0x%x len %d\n", | ||
417 | fcs, new_len); | ||
418 | mcs->stats.rx_errors++; | ||
419 | mcs->stats.rx_crc_errors++; | ||
420 | return; | ||
421 | } | ||
422 | |||
423 | skb = dev_alloc_skb(new_len + 1); | ||
424 | if(unlikely(!skb)) { | ||
425 | ++mcs->stats.rx_dropped; | ||
426 | return; | ||
427 | } | ||
428 | |||
429 | skb_reserve(skb, 1); | ||
430 | memcpy(skb->data, buf, new_len); | ||
431 | skb_put(skb, new_len); | ||
432 | skb->mac.raw = skb->data; | ||
433 | skb->protocol = htons(ETH_P_IRDA); | ||
434 | skb->dev = mcs->netdev; | ||
435 | |||
436 | netif_rx(skb); | ||
437 | |||
438 | mcs->stats.rx_packets++; | ||
439 | mcs->stats.rx_bytes += new_len; | ||
440 | |||
441 | return; | ||
442 | } | ||
443 | |||
444 | /* Unwrap received packets at FIR speed. A 32 bit crc_ccitt checksum is | ||
445 | * used for the fcs. Hands the unwrapped data off to the IrDA | ||
446 | * layer via a sk_buff. | ||
447 | */ | ||
448 | static void mcs_unwrap_fir(struct mcs_cb *mcs, __u8 *buf, int len) | ||
449 | { | ||
450 | __u32 fcs; | ||
451 | int new_len; | ||
452 | struct sk_buff *skb; | ||
453 | |||
454 | /* Assume that the frames are going to fill a single packet | ||
455 | * rather than span multiple packets. This is most likely a false | ||
456 | * assumption. | ||
457 | */ | ||
458 | |||
459 | new_len = len - 4; | ||
460 | if(unlikely(new_len <= 0)) { | ||
461 | IRDA_ERROR("%s short frame length %d\n", | ||
462 | mcs->netdev->name, new_len); | ||
463 | ++mcs->stats.rx_errors; | ||
464 | ++mcs->stats.rx_length_errors; | ||
465 | return; | ||
466 | } | ||
467 | |||
468 | fcs = ~(crc32_le(~0, buf, new_len)); | ||
469 | if(fcs != le32_to_cpu(get_unaligned((u32 *)(buf+new_len)))) { | ||
470 | IRDA_ERROR("crc error calc 0x%x len %d\n", fcs, new_len); | ||
471 | mcs->stats.rx_errors++; | ||
472 | mcs->stats.rx_crc_errors++; | ||
473 | return; | ||
474 | } | ||
475 | |||
476 | skb = dev_alloc_skb(new_len + 1); | ||
477 | if(unlikely(!skb)) { | ||
478 | ++mcs->stats.rx_dropped; | ||
479 | return; | ||
480 | } | ||
481 | |||
482 | skb_reserve(skb, 1); | ||
483 | memcpy(skb->data, buf, new_len); | ||
484 | skb_put(skb, new_len); | ||
485 | skb->mac.raw = skb->data; | ||
486 | skb->protocol = htons(ETH_P_IRDA); | ||
487 | skb->dev = mcs->netdev; | ||
488 | |||
489 | netif_rx(skb); | ||
490 | |||
491 | mcs->stats.rx_packets++; | ||
492 | mcs->stats.rx_bytes += new_len; | ||
493 | |||
494 | return; | ||
495 | } | ||
496 | |||
497 | |||
498 | /* Allocates urbs for both receive and transmit. | ||
499 | * If alloc fails return error code 0 (fail) otherwise | ||
500 | * return error code 1 (success). | ||
501 | */ | ||
502 | static inline int mcs_setup_urbs(struct mcs_cb *mcs) | ||
503 | { | ||
504 | mcs->rx_urb = NULL; | ||
505 | |||
506 | mcs->tx_urb = usb_alloc_urb(0, GFP_KERNEL); | ||
507 | if (!mcs->tx_urb) | ||
508 | return 0; | ||
509 | |||
510 | mcs->rx_urb = usb_alloc_urb(0, GFP_KERNEL); | ||
511 | if (!mcs->rx_urb) | ||
512 | return 0; | ||
513 | |||
514 | return 1; | ||
515 | } | ||
516 | |||
517 | /* Sets up state to be initially outside frame, gets receive urb, | ||
518 | * sets status to successful and then submits the urb to start | ||
519 | * receiving the data. | ||
520 | */ | ||
521 | static inline int mcs_receive_start(struct mcs_cb *mcs) | ||
522 | { | ||
523 | mcs->rx_buff.in_frame = FALSE; | ||
524 | mcs->rx_buff.state = OUTSIDE_FRAME; | ||
525 | |||
526 | usb_fill_bulk_urb(mcs->rx_urb, mcs->usbdev, | ||
527 | usb_rcvbulkpipe(mcs->usbdev, mcs->ep_in), | ||
528 | mcs->in_buf, 4096, mcs_receive_irq, mcs); | ||
529 | |||
530 | mcs->rx_urb->status = 0; | ||
531 | return usb_submit_urb(mcs->rx_urb, GFP_KERNEL); | ||
532 | } | ||
533 | |||
534 | /* Finds the in and out endpoints for the mcs control block */ | ||
535 | static inline int mcs_find_endpoints(struct mcs_cb *mcs, | ||
536 | struct usb_host_endpoint *ep, int epnum) | ||
537 | { | ||
538 | int i; | ||
539 | int ret = 0; | ||
540 | |||
541 | /* If no place to store the endpoints just return */ | ||
542 | if (!ep) | ||
543 | return ret; | ||
544 | |||
545 | /* cycle through all endpoints, find the first two that are DIR_IN */ | ||
546 | for (i = 0; i < epnum; i++) { | ||
547 | if (ep[i].desc.bEndpointAddress & USB_DIR_IN) | ||
548 | mcs->ep_in = ep[i].desc.bEndpointAddress; | ||
549 | else | ||
550 | mcs->ep_out = ep[i].desc.bEndpointAddress; | ||
551 | |||
552 | /* MosChip says that the chip has only two bulk | ||
553 | * endpoints. Find one for each direction and move on. | ||
554 | */ | ||
555 | if ((mcs->ep_in != 0) && (mcs->ep_out != 0)) { | ||
556 | ret = 1; | ||
557 | break; | ||
558 | } | ||
559 | } | ||
560 | |||
561 | return ret; | ||
562 | } | ||
563 | |||
564 | static void mcs_speed_work(void *arg) | ||
565 | { | ||
566 | struct mcs_cb *mcs = arg; | ||
567 | struct net_device *netdev = mcs->netdev; | ||
568 | |||
569 | mcs_speed_change(mcs); | ||
570 | netif_wake_queue(netdev); | ||
571 | } | ||
572 | |||
573 | /* Function to change the speed of the mcs7780. Fully supports SIR, | ||
574 | * MIR, and FIR speeds. | ||
575 | */ | ||
576 | static int mcs_speed_change(struct mcs_cb *mcs) | ||
577 | { | ||
578 | int ret = 0; | ||
579 | int rst = 0; | ||
580 | int cnt = 0; | ||
581 | __u16 nspeed; | ||
582 | __u16 rval; | ||
583 | |||
584 | nspeed = mcs_speed_set[(mcs->new_speed >> 8) & 0x0f]; | ||
585 | |||
586 | do { | ||
587 | mcs_get_reg(mcs, MCS_RESV_REG, &rval); | ||
588 | } while(cnt++ < 100 && (rval & MCS_IRINTX)); | ||
589 | |||
590 | if(cnt >= 100) { | ||
591 | IRDA_ERROR("unable to change speed"); | ||
592 | ret = -EIO; | ||
593 | goto error; | ||
594 | } | ||
595 | |||
596 | mcs_get_reg(mcs, MCS_MODE_REG, &rval); | ||
597 | |||
598 | /* MINRXPW values recomended by MosChip */ | ||
599 | if (mcs->new_speed <= 115200) { | ||
600 | rval &= ~MCS_FIR; | ||
601 | |||
602 | if ((rst = (mcs->speed > 115200))) | ||
603 | mcs_set_reg(mcs, MCS_MINRXPW_REG, 0); | ||
604 | |||
605 | } else if (mcs->new_speed <= 1152000) { | ||
606 | rval &= ~MCS_FIR; | ||
607 | |||
608 | if ((rst = !(mcs->speed == 576000 || mcs->speed == 1152000))) | ||
609 | mcs_set_reg(mcs, MCS_MINRXPW_REG, 5); | ||
610 | |||
611 | } else { | ||
612 | rval |= MCS_FIR; | ||
613 | |||
614 | if ((rst = (mcs->speed != 4000000))) | ||
615 | mcs_set_reg(mcs, MCS_MINRXPW_REG, 5); | ||
616 | |||
617 | } | ||
618 | |||
619 | rval &= ~MCS_SPEED_MASK; | ||
620 | rval |= nspeed; | ||
621 | |||
622 | ret = mcs_set_reg(mcs, MCS_MODE_REG, rval); | ||
623 | if (unlikely(ret)) | ||
624 | goto error; | ||
625 | |||
626 | if (rst) | ||
627 | switch (mcs->transceiver_type) { | ||
628 | case MCS_TSC_VISHAY: | ||
629 | ret = mcs_setup_transceiver_vishay(mcs); | ||
630 | break; | ||
631 | |||
632 | case MCS_TSC_SHARP: | ||
633 | ret = mcs_setup_transceiver_sharp(mcs); | ||
634 | break; | ||
635 | |||
636 | case MCS_TSC_AGILENT: | ||
637 | ret = mcs_setup_transceiver_agilent(mcs); | ||
638 | break; | ||
639 | |||
640 | default: | ||
641 | ret = 1; | ||
642 | IRDA_WARNING("Unknown transceiver type: %d", | ||
643 | mcs->transceiver_type); | ||
644 | } | ||
645 | if (unlikely(ret)) | ||
646 | goto error; | ||
647 | |||
648 | mcs_get_reg(mcs, MCS_MODE_REG, &rval); | ||
649 | rval &= ~MCS_RESET; | ||
650 | ret = mcs_set_reg(mcs, MCS_MODE_REG, rval); | ||
651 | |||
652 | mcs->speed = mcs->new_speed; | ||
653 | error: | ||
654 | mcs->new_speed = 0; | ||
655 | return ret; | ||
656 | } | ||
657 | |||
658 | /* Ioctl calls not supported at this time. Can be an area of future work. */ | ||
659 | static int mcs_net_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd) | ||
660 | { | ||
661 | /* struct if_irda_req *irq = (struct if_irda_req *)rq; */ | ||
662 | /* struct mcs_cb *mcs = netdev_priv(netdev); */ | ||
663 | int ret = 0; | ||
664 | |||
665 | switch (cmd) { | ||
666 | default: | ||
667 | ret = -EOPNOTSUPP; | ||
668 | } | ||
669 | |||
670 | return ret; | ||
671 | } | ||
672 | |||
673 | /* Network device is taken down, done by "ifconfig irda0 down" */ | ||
674 | static int mcs_net_close(struct net_device *netdev) | ||
675 | { | ||
676 | int ret = 0; | ||
677 | struct mcs_cb *mcs = netdev_priv(netdev); | ||
678 | |||
679 | /* Stop transmit processing */ | ||
680 | netif_stop_queue(netdev); | ||
681 | |||
682 | /* kill and free the receive and transmit URBs */ | ||
683 | usb_kill_urb(mcs->rx_urb); | ||
684 | usb_free_urb(mcs->rx_urb); | ||
685 | usb_kill_urb(mcs->tx_urb); | ||
686 | usb_free_urb(mcs->tx_urb); | ||
687 | |||
688 | /* Stop and remove instance of IrLAP */ | ||
689 | if (mcs->irlap) | ||
690 | irlap_close(mcs->irlap); | ||
691 | |||
692 | mcs->irlap = NULL; | ||
693 | return ret; | ||
694 | } | ||
695 | |||
696 | /* Network device is taken up, done by "ifconfig irda0 up" */ | ||
697 | static int mcs_net_open(struct net_device *netdev) | ||
698 | { | ||
699 | struct mcs_cb *mcs = netdev_priv(netdev); | ||
700 | char hwname[16]; | ||
701 | int ret = 0; | ||
702 | |||
703 | ret = usb_clear_halt(mcs->usbdev, | ||
704 | usb_sndbulkpipe(mcs->usbdev, mcs->ep_in)); | ||
705 | if (ret) | ||
706 | goto error1; | ||
707 | ret = usb_clear_halt(mcs->usbdev, | ||
708 | usb_rcvbulkpipe(mcs->usbdev, mcs->ep_out)); | ||
709 | if (ret) | ||
710 | goto error1; | ||
711 | |||
712 | ret = mcs_setup_transceiver(mcs); | ||
713 | if (ret) | ||
714 | goto error1; | ||
715 | |||
716 | ret = -ENOMEM; | ||
717 | |||
718 | /* Initialize for SIR/FIR to copy data directly into skb. */ | ||
719 | mcs->receiving = 0; | ||
720 | mcs->rx_buff.truesize = IRDA_SKB_MAX_MTU; | ||
721 | mcs->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU); | ||
722 | if (!mcs->rx_buff.skb) | ||
723 | goto error1; | ||
724 | |||
725 | skb_reserve(mcs->rx_buff.skb, 1); | ||
726 | mcs->rx_buff.head = mcs->rx_buff.skb->data; | ||
727 | do_gettimeofday(&mcs->rx_time); | ||
728 | |||
729 | /* | ||
730 | * Now that everything should be initialized properly, | ||
731 | * Open new IrLAP layer instance to take care of us... | ||
732 | * Note : will send immediately a speed change... | ||
733 | */ | ||
734 | sprintf(hwname, "usb#%d", mcs->usbdev->devnum); | ||
735 | mcs->irlap = irlap_open(netdev, &mcs->qos, hwname); | ||
736 | if (!mcs->irlap) { | ||
737 | IRDA_ERROR("mcs7780: irlap_open failed"); | ||
738 | goto error2; | ||
739 | } | ||
740 | |||
741 | if (!mcs_setup_urbs(mcs)) | ||
742 | goto error3; | ||
743 | |||
744 | ret = mcs_receive_start(mcs); | ||
745 | if (ret) | ||
746 | goto error3; | ||
747 | |||
748 | netif_start_queue(netdev); | ||
749 | return 0; | ||
750 | |||
751 | error3: | ||
752 | irlap_close(mcs->irlap); | ||
753 | error2: | ||
754 | kfree_skb(mcs->rx_buff.skb); | ||
755 | error1: | ||
756 | return ret; | ||
757 | } | ||
758 | |||
759 | |||
760 | /* Get device stats for /proc/net/dev and ifconfig */ | ||
761 | static struct net_device_stats *mcs_net_get_stats(struct net_device *netdev) | ||
762 | { | ||
763 | struct mcs_cb *mcs = netdev_priv(netdev); | ||
764 | return &mcs->stats; | ||
765 | } | ||
766 | |||
767 | /* Receive callback function. */ | ||
768 | static void mcs_receive_irq(struct urb *urb, struct pt_regs *regs) | ||
769 | { | ||
770 | __u8 *bytes; | ||
771 | struct mcs_cb *mcs = urb->context; | ||
772 | int i; | ||
773 | int ret; | ||
774 | |||
775 | if (!netif_running(mcs->netdev)) | ||
776 | return; | ||
777 | |||
778 | if (urb->status) | ||
779 | return; | ||
780 | |||
781 | if (urb->actual_length > 0) { | ||
782 | bytes = urb->transfer_buffer; | ||
783 | |||
784 | /* MCS returns frames without BOF and EOF | ||
785 | * I assume it returns whole frames. | ||
786 | */ | ||
787 | /* SIR speed */ | ||
788 | if(mcs->speed < 576000) { | ||
789 | async_unwrap_char(mcs->netdev, &mcs->stats, | ||
790 | &mcs->rx_buff, 0xc0); | ||
791 | |||
792 | for (i = 0; i < urb->actual_length; i++) | ||
793 | async_unwrap_char(mcs->netdev, &mcs->stats, | ||
794 | &mcs->rx_buff, bytes[i]); | ||
795 | |||
796 | async_unwrap_char(mcs->netdev, &mcs->stats, | ||
797 | &mcs->rx_buff, 0xc1); | ||
798 | } | ||
799 | /* MIR speed */ | ||
800 | else if(mcs->speed == 576000 || mcs->speed == 1152000) { | ||
801 | mcs_unwrap_mir(mcs, urb->transfer_buffer, | ||
802 | urb->actual_length); | ||
803 | } | ||
804 | /* FIR speed */ | ||
805 | else { | ||
806 | mcs_unwrap_fir(mcs, urb->transfer_buffer, | ||
807 | urb->actual_length); | ||
808 | } | ||
809 | mcs->netdev->last_rx = jiffies; | ||
810 | do_gettimeofday(&mcs->rx_time); | ||
811 | } | ||
812 | |||
813 | ret = usb_submit_urb(urb, GFP_ATOMIC); | ||
814 | } | ||
815 | |||
816 | /* Transmit callback funtion. */ | ||
817 | static void mcs_send_irq(struct urb *urb, struct pt_regs *regs) | ||
818 | { | ||
819 | struct mcs_cb *mcs = urb->context; | ||
820 | struct net_device *ndev = mcs->netdev; | ||
821 | |||
822 | if (unlikely(mcs->new_speed)) | ||
823 | schedule_work(&mcs->work); | ||
824 | else | ||
825 | netif_wake_queue(ndev); | ||
826 | } | ||
827 | |||
828 | /* Transmit callback funtion. */ | ||
829 | static int mcs_hard_xmit(struct sk_buff *skb, struct net_device *ndev) | ||
830 | { | ||
831 | unsigned long flags; | ||
832 | struct mcs_cb *mcs; | ||
833 | int wraplen; | ||
834 | int ret = 0; | ||
835 | |||
836 | |||
837 | if (skb == NULL || ndev == NULL) | ||
838 | return -EINVAL; | ||
839 | |||
840 | netif_stop_queue(ndev); | ||
841 | mcs = netdev_priv(ndev); | ||
842 | |||
843 | spin_lock_irqsave(&mcs->lock, flags); | ||
844 | |||
845 | mcs->new_speed = irda_get_next_speed(skb); | ||
846 | if (likely(mcs->new_speed == mcs->speed)) | ||
847 | mcs->new_speed = 0; | ||
848 | |||
849 | /* SIR speed */ | ||
850 | if(mcs->speed < 576000) { | ||
851 | wraplen = mcs_wrap_sir_skb(skb, mcs->out_buf); | ||
852 | } | ||
853 | /* MIR speed */ | ||
854 | else if(mcs->speed == 576000 || mcs->speed == 1152000) { | ||
855 | wraplen = mcs_wrap_mir_skb(skb, mcs->out_buf); | ||
856 | } | ||
857 | /* FIR speed */ | ||
858 | else { | ||
859 | wraplen = mcs_wrap_fir_skb(skb, mcs->out_buf); | ||
860 | } | ||
861 | usb_fill_bulk_urb(mcs->tx_urb, mcs->usbdev, | ||
862 | usb_sndbulkpipe(mcs->usbdev, mcs->ep_out), | ||
863 | mcs->out_buf, wraplen, mcs_send_irq, mcs); | ||
864 | |||
865 | if ((ret = usb_submit_urb(mcs->tx_urb, GFP_ATOMIC))) { | ||
866 | IRDA_ERROR("failed tx_urb: %d", ret); | ||
867 | switch (ret) { | ||
868 | case -ENODEV: | ||
869 | case -EPIPE: | ||
870 | break; | ||
871 | default: | ||
872 | mcs->stats.tx_errors++; | ||
873 | netif_start_queue(ndev); | ||
874 | } | ||
875 | } else { | ||
876 | mcs->stats.tx_packets++; | ||
877 | mcs->stats.tx_bytes += skb->len; | ||
878 | } | ||
879 | |||
880 | dev_kfree_skb(skb); | ||
881 | spin_unlock_irqrestore(&mcs->lock, flags); | ||
882 | return ret; | ||
883 | } | ||
884 | |||
885 | /* | ||
886 | * This function is called by the USB subsystem for each new device in the | ||
887 | * system. Need to verify the device and if it is, then start handling it. | ||
888 | */ | ||
889 | static int mcs_probe(struct usb_interface *intf, | ||
890 | const struct usb_device_id *id) | ||
891 | { | ||
892 | struct usb_device *udev = interface_to_usbdev(intf); | ||
893 | struct net_device *ndev = NULL; | ||
894 | struct mcs_cb *mcs; | ||
895 | int ret = -ENOMEM; | ||
896 | |||
897 | ndev = alloc_irdadev(sizeof(*mcs)); | ||
898 | if (!ndev) | ||
899 | goto error1; | ||
900 | |||
901 | IRDA_DEBUG(1, "MCS7780 USB-IrDA bridge found at %d.", udev->devnum); | ||
902 | |||
903 | /* what is it realy for? */ | ||
904 | SET_MODULE_OWNER(ndev); | ||
905 | SET_NETDEV_DEV(ndev, &intf->dev); | ||
906 | |||
907 | ret = usb_reset_configuration(udev); | ||
908 | if (ret != 0) { | ||
909 | IRDA_ERROR("mcs7780: usb reset configuration failed"); | ||
910 | goto error2; | ||
911 | } | ||
912 | |||
913 | mcs = netdev_priv(ndev); | ||
914 | mcs->usbdev = udev; | ||
915 | mcs->netdev = ndev; | ||
916 | spin_lock_init(&mcs->lock); | ||
917 | |||
918 | /* Initialize QoS for this device */ | ||
919 | irda_init_max_qos_capabilies(&mcs->qos); | ||
920 | |||
921 | /* That's the Rx capability. */ | ||
922 | mcs->qos.baud_rate.bits &= | ||
923 | IR_2400 | IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200 | ||
924 | | IR_576000 | IR_1152000 | (IR_4000000 << 8); | ||
925 | |||
926 | |||
927 | mcs->qos.min_turn_time.bits &= qos_mtt_bits; | ||
928 | irda_qos_bits_to_value(&mcs->qos); | ||
929 | |||
930 | /* Speed change work initialisation*/ | ||
931 | INIT_WORK(&mcs->work, mcs_speed_work, mcs); | ||
932 | |||
933 | /* Override the network functions we need to use */ | ||
934 | ndev->hard_start_xmit = mcs_hard_xmit; | ||
935 | ndev->open = mcs_net_open; | ||
936 | ndev->stop = mcs_net_close; | ||
937 | ndev->get_stats = mcs_net_get_stats; | ||
938 | ndev->do_ioctl = mcs_net_ioctl; | ||
939 | |||
940 | if (!intf->cur_altsetting) | ||
941 | goto error2; | ||
942 | |||
943 | ret = mcs_find_endpoints(mcs, intf->cur_altsetting->endpoint, | ||
944 | intf->cur_altsetting->desc.bNumEndpoints); | ||
945 | if (!ret) { | ||
946 | ret = -ENODEV; | ||
947 | goto error2; | ||
948 | } | ||
949 | |||
950 | ret = register_netdev(ndev); | ||
951 | if (ret != 0) | ||
952 | goto error2; | ||
953 | |||
954 | IRDA_DEBUG(1, "IrDA: Registered MosChip MCS7780 device as %s", | ||
955 | ndev->name); | ||
956 | |||
957 | mcs->transceiver_type = transceiver_type; | ||
958 | mcs->sir_tweak = sir_tweak; | ||
959 | mcs->receive_mode = receive_mode; | ||
960 | |||
961 | usb_set_intfdata(intf, mcs); | ||
962 | return 0; | ||
963 | |||
964 | error2: | ||
965 | free_netdev(ndev); | ||
966 | |||
967 | error1: | ||
968 | return ret; | ||
969 | } | ||
970 | |||
971 | /* The current device is removed, the USB layer tells us to shut down. */ | ||
972 | static void mcs_disconnect(struct usb_interface *intf) | ||
973 | { | ||
974 | struct mcs_cb *mcs = usb_get_intfdata(intf); | ||
975 | |||
976 | if (!mcs) | ||
977 | return; | ||
978 | |||
979 | flush_scheduled_work(); | ||
980 | |||
981 | unregister_netdev(mcs->netdev); | ||
982 | free_netdev(mcs->netdev); | ||
983 | |||
984 | usb_set_intfdata(intf, NULL); | ||
985 | IRDA_DEBUG(0, "MCS7780 now disconnected."); | ||
986 | } | ||
987 | |||
988 | /* Module insertion */ | ||
989 | static int __init mcs_init(void) | ||
990 | { | ||
991 | int result; | ||
992 | |||
993 | /* register this driver with the USB subsystem */ | ||
994 | result = usb_register(&mcs_driver); | ||
995 | if (result) | ||
996 | IRDA_ERROR("usb_register failed. Error number %d", result); | ||
997 | |||
998 | return result; | ||
999 | } | ||
1000 | module_init(mcs_init); | ||
1001 | |||
1002 | /* Module removal */ | ||
1003 | static void __exit mcs_exit(void) | ||
1004 | { | ||
1005 | /* deregister this driver with the USB subsystem */ | ||
1006 | usb_deregister(&mcs_driver); | ||
1007 | } | ||
1008 | module_exit(mcs_exit); | ||
1009 | |||
diff --git a/drivers/net/irda/mcs7780.h b/drivers/net/irda/mcs7780.h new file mode 100644 index 000000000000..1a723d725c2a --- /dev/null +++ b/drivers/net/irda/mcs7780.h | |||
@@ -0,0 +1,167 @@ | |||
1 | /***************************************************************************** | ||
2 | * | ||
3 | * Filename: mcs7780.h | ||
4 | * Version: 0.2-alpha | ||
5 | * Description: Irda MosChip USB Dongle | ||
6 | * Status: Experimental | ||
7 | * Authors: Lukasz Stelmach <stlman@poczta.fm> | ||
8 | * Brian Pugh <bpugh@cs.pdx.edu> | ||
9 | * | ||
10 | * Copyright (C) 2005, Lukasz Stelmach <stlman@poczta.fm> | ||
11 | * Copyright (C) 2005, Brian Pugh <bpugh@cs.pdx.edu> | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or modify | ||
14 | * it under the terms of the GNU General Public License as published by | ||
15 | * the Free Software Foundation; either version 2 of the License, or | ||
16 | * (at your option) any later version. | ||
17 | * | ||
18 | * This program is distributed in the hope that it will be useful, | ||
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
21 | * GNU General Public License for more details. | ||
22 | * | ||
23 | * You should have received a copy of the GNU General Public License | ||
24 | * along with this program; if not, write to the Free Software | ||
25 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
26 | * | ||
27 | *****************************************************************************/ | ||
28 | #ifndef _MCS7780_H | ||
29 | #define _MCS7780_H | ||
30 | |||
31 | #define MCS_MODE_SIR 0 | ||
32 | #define MCS_MODE_MIR 1 | ||
33 | #define MCS_MODE_FIR 2 | ||
34 | |||
35 | #define MCS_CTRL_TIMEOUT 500 | ||
36 | #define MCS_XMIT_TIMEOUT 500 | ||
37 | /* Possible transceiver types */ | ||
38 | #define MCS_TSC_VISHAY 0 /* Vishay TFD, default choice */ | ||
39 | #define MCS_TSC_AGILENT 1 /* Agilent 3602/3600 */ | ||
40 | #define MCS_TSC_SHARP 2 /* Sharp GP2W1000YP */ | ||
41 | |||
42 | /* Requests */ | ||
43 | #define MCS_RD_RTYPE 0xC0 | ||
44 | #define MCS_WR_RTYPE 0x40 | ||
45 | #define MCS_RDREQ 0x0F | ||
46 | #define MCS_WRREQ 0x0E | ||
47 | |||
48 | /* Register 0x00 */ | ||
49 | #define MCS_MODE_REG 0 | ||
50 | #define MCS_FIR ((__u16)0x0001) | ||
51 | #define MCS_SIR16US ((__u16)0x0002) | ||
52 | #define MCS_BBTG ((__u16)0x0004) | ||
53 | #define MCS_ASK ((__u16)0x0008) | ||
54 | #define MCS_PARITY ((__u16)0x0010) | ||
55 | |||
56 | /* SIR/MIR speed constants */ | ||
57 | #define MCS_SPEED_SHIFT 5 | ||
58 | #define MCS_SPEED_MASK ((__u16)0x00E0) | ||
59 | #define MCS_SPEED(x) ((x & MCS_SPEED_MASK) >> MCS_SPEED_SHIFT) | ||
60 | #define MCS_SPEED_2400 ((0 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
61 | #define MCS_SPEED_9600 ((1 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
62 | #define MCS_SPEED_19200 ((2 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
63 | #define MCS_SPEED_38400 ((3 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
64 | #define MCS_SPEED_57600 ((4 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
65 | #define MCS_SPEED_115200 ((5 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
66 | #define MCS_SPEED_576000 ((6 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
67 | #define MCS_SPEED_1152000 ((7 << MCS_SPEED_SHIFT) & MCS_SPEED_MASK) | ||
68 | |||
69 | #define MCS_PLLPWDN ((__u16)0x0100) | ||
70 | #define MCS_DRIVER ((__u16)0x0200) | ||
71 | #define MCS_DTD ((__u16)0x0400) | ||
72 | #define MCS_DIR ((__u16)0x0800) | ||
73 | #define MCS_SIPEN ((__u16)0x1000) | ||
74 | #define MCS_SENDSIP ((__u16)0x2000) | ||
75 | #define MCS_CHGDIR ((__u16)0x4000) | ||
76 | #define MCS_RESET ((__u16)0x8000) | ||
77 | |||
78 | /* Register 0x02 */ | ||
79 | #define MCS_XCVR_REG 2 | ||
80 | #define MCS_MODE0 ((__u16)0x0001) | ||
81 | #define MCS_STFIR ((__u16)0x0002) | ||
82 | #define MCS_XCVR_CONF ((__u16)0x0004) | ||
83 | #define MCS_RXFAST ((__u16)0x0008) | ||
84 | /* TXCUR [6:4] */ | ||
85 | #define MCS_TXCUR_SHIFT 4 | ||
86 | #define MCS_TXCUR_MASK ((__u16)0x0070) | ||
87 | #define MCS_TXCUR(x) ((x & MCS_TXCUR_MASK) >> MCS_TXCUR_SHIFT) | ||
88 | #define MCS_SETTXCUR(x,y) \ | ||
89 | ((x & ~MCS_TXCUR_MASK) | (y << MCS_TXCUR_SHIFT) & MCS_TXCUR_MASK) | ||
90 | |||
91 | #define MCS_MODE1 ((__u16)0x0080) | ||
92 | #define MCS_SMODE0 ((__u16)0x0100) | ||
93 | #define MCS_SMODE1 ((__u16)0x0200) | ||
94 | #define MCS_INVTX ((__u16)0x0400) | ||
95 | #define MCS_INVRX ((__u16)0x0800) | ||
96 | |||
97 | #define MCS_MINRXPW_REG 4 | ||
98 | |||
99 | #define MCS_RESV_REG 7 | ||
100 | #define MCS_IRINTX ((__u16)0x0001) | ||
101 | #define MCS_IRINRX ((__u16)0x0002) | ||
102 | |||
103 | struct mcs_cb { | ||
104 | struct usb_device *usbdev; /* init: probe_irda */ | ||
105 | struct net_device *netdev; /* network layer */ | ||
106 | struct irlap_cb *irlap; /* The link layer we are binded to */ | ||
107 | struct net_device_stats stats; /* network statistics */ | ||
108 | struct qos_info qos; | ||
109 | unsigned int speed; /* Current speed */ | ||
110 | unsigned int new_speed; /* new speed */ | ||
111 | |||
112 | struct work_struct work; /* Change speed work */ | ||
113 | |||
114 | struct sk_buff *tx_pending; | ||
115 | char in_buf[4096]; /* transmit/receive buffer */ | ||
116 | char out_buf[4096]; /* transmit/receive buffer */ | ||
117 | __u8 *fifo_status; | ||
118 | |||
119 | iobuff_t rx_buff; /* receive unwrap state machine */ | ||
120 | struct timeval rx_time; | ||
121 | spinlock_t lock; | ||
122 | int receiving; | ||
123 | |||
124 | __u8 ep_in; | ||
125 | __u8 ep_out; | ||
126 | |||
127 | struct urb *rx_urb; | ||
128 | struct urb *tx_urb; | ||
129 | |||
130 | int transceiver_type; | ||
131 | int sir_tweak; | ||
132 | int receive_mode; | ||
133 | }; | ||
134 | |||
135 | static int mcs_set_reg(struct mcs_cb *mcs, __u16 reg, __u16 val); | ||
136 | static int mcs_get_reg(struct mcs_cb *mcs, __u16 reg, __u16 * val); | ||
137 | |||
138 | static inline int mcs_setup_transceiver_vishay(struct mcs_cb *mcs); | ||
139 | static inline int mcs_setup_transceiver_agilent(struct mcs_cb *mcs); | ||
140 | static inline int mcs_setup_transceiver_sharp(struct mcs_cb *mcs); | ||
141 | static inline int mcs_setup_transceiver(struct mcs_cb *mcs); | ||
142 | static inline int mcs_wrap_sir_skb(struct sk_buff *skb, __u8 * buf); | ||
143 | static unsigned mcs_wrap_fir_skb(const struct sk_buff *skb, __u8 *buf); | ||
144 | static unsigned mcs_wrap_mir_skb(const struct sk_buff *skb, __u8 *buf); | ||
145 | static void mcs_unwrap_mir(struct mcs_cb *mcs, __u8 *buf, int len); | ||
146 | static void mcs_unwrap_fir(struct mcs_cb *mcs, __u8 *buf, int len); | ||
147 | static inline int mcs_setup_urbs(struct mcs_cb *mcs); | ||
148 | static inline int mcs_receive_start(struct mcs_cb *mcs); | ||
149 | static inline int mcs_find_endpoints(struct mcs_cb *mcs, | ||
150 | struct usb_host_endpoint *ep, int epnum); | ||
151 | |||
152 | static int mcs_speed_change(struct mcs_cb *mcs); | ||
153 | |||
154 | static int mcs_net_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd); | ||
155 | static int mcs_net_close(struct net_device *netdev); | ||
156 | static int mcs_net_open(struct net_device *netdev); | ||
157 | static struct net_device_stats *mcs_net_get_stats(struct net_device *netdev); | ||
158 | |||
159 | static void mcs_receive_irq(struct urb *urb, struct pt_regs *regs); | ||
160 | static void mcs_send_irq(struct urb *urb, struct pt_regs *regs); | ||
161 | static int mcs_hard_xmit(struct sk_buff *skb, struct net_device *netdev); | ||
162 | |||
163 | static int mcs_probe(struct usb_interface *intf, | ||
164 | const struct usb_device_id *id); | ||
165 | static void mcs_disconnect(struct usb_interface *intf); | ||
166 | |||
167 | #endif /* _MCS7780_H */ | ||
diff --git a/drivers/net/irda/stir4200.c b/drivers/net/irda/stir4200.c index 31867e4b891b..d61b208b52a2 100644 --- a/drivers/net/irda/stir4200.c +++ b/drivers/net/irda/stir4200.c | |||
@@ -50,6 +50,7 @@ | |||
50 | #include <linux/delay.h> | 50 | #include <linux/delay.h> |
51 | #include <linux/usb.h> | 51 | #include <linux/usb.h> |
52 | #include <linux/crc32.h> | 52 | #include <linux/crc32.h> |
53 | #include <linux/kthread.h> | ||
53 | #include <net/irda/irda.h> | 54 | #include <net/irda/irda.h> |
54 | #include <net/irda/irlap.h> | 55 | #include <net/irda/irlap.h> |
55 | #include <net/irda/irda_device.h> | 56 | #include <net/irda/irda_device.h> |
@@ -173,9 +174,7 @@ struct stir_cb { | |||
173 | struct qos_info qos; | 174 | struct qos_info qos; |
174 | unsigned speed; /* Current speed */ | 175 | unsigned speed; /* Current speed */ |
175 | 176 | ||
176 | wait_queue_head_t thr_wait; /* transmit thread wakeup */ | 177 | struct task_struct *thread; /* transmit thread */ |
177 | struct completion thr_exited; | ||
178 | pid_t thr_pid; | ||
179 | 178 | ||
180 | struct sk_buff *tx_pending; | 179 | struct sk_buff *tx_pending; |
181 | void *io_buf; /* transmit/receive buffer */ | 180 | void *io_buf; /* transmit/receive buffer */ |
@@ -577,7 +576,7 @@ static int stir_hard_xmit(struct sk_buff *skb, struct net_device *netdev) | |||
577 | SKB_LINEAR_ASSERT(skb); | 576 | SKB_LINEAR_ASSERT(skb); |
578 | 577 | ||
579 | skb = xchg(&stir->tx_pending, skb); | 578 | skb = xchg(&stir->tx_pending, skb); |
580 | wake_up(&stir->thr_wait); | 579 | wake_up_process(stir->thread); |
581 | 580 | ||
582 | /* this should never happen unless stop/wakeup problem */ | 581 | /* this should never happen unless stop/wakeup problem */ |
583 | if (unlikely(skb)) { | 582 | if (unlikely(skb)) { |
@@ -753,13 +752,7 @@ static int stir_transmit_thread(void *arg) | |||
753 | struct net_device *dev = stir->netdev; | 752 | struct net_device *dev = stir->netdev; |
754 | struct sk_buff *skb; | 753 | struct sk_buff *skb; |
755 | 754 | ||
756 | daemonize("%s", dev->name); | 755 | while (!kthread_should_stop()) { |
757 | allow_signal(SIGTERM); | ||
758 | |||
759 | while (netif_running(dev) | ||
760 | && netif_device_present(dev) | ||
761 | && !signal_pending(current)) | ||
762 | { | ||
763 | #ifdef CONFIG_PM | 756 | #ifdef CONFIG_PM |
764 | /* if suspending, then power off and wait */ | 757 | /* if suspending, then power off and wait */ |
765 | if (unlikely(freezing(current))) { | 758 | if (unlikely(freezing(current))) { |
@@ -813,10 +806,11 @@ static int stir_transmit_thread(void *arg) | |||
813 | } | 806 | } |
814 | 807 | ||
815 | /* sleep if nothing to send */ | 808 | /* sleep if nothing to send */ |
816 | wait_event_interruptible(stir->thr_wait, stir->tx_pending); | 809 | set_current_state(TASK_INTERRUPTIBLE); |
817 | } | 810 | schedule(); |
818 | 811 | ||
819 | complete_and_exit (&stir->thr_exited, 0); | 812 | } |
813 | return 0; | ||
820 | } | 814 | } |
821 | 815 | ||
822 | 816 | ||
@@ -859,7 +853,7 @@ static void stir_rcv_irq(struct urb *urb, struct pt_regs *regs) | |||
859 | warn("%s: usb receive submit error: %d", | 853 | warn("%s: usb receive submit error: %d", |
860 | stir->netdev->name, err); | 854 | stir->netdev->name, err); |
861 | stir->receiving = 0; | 855 | stir->receiving = 0; |
862 | wake_up(&stir->thr_wait); | 856 | wake_up_process(stir->thread); |
863 | } | 857 | } |
864 | } | 858 | } |
865 | 859 | ||
@@ -928,10 +922,10 @@ static int stir_net_open(struct net_device *netdev) | |||
928 | } | 922 | } |
929 | 923 | ||
930 | /** Start kernel thread for transmit. */ | 924 | /** Start kernel thread for transmit. */ |
931 | stir->thr_pid = kernel_thread(stir_transmit_thread, stir, | 925 | stir->thread = kthread_run(stir_transmit_thread, stir, |
932 | CLONE_FS|CLONE_FILES); | 926 | "%s", stir->netdev->name); |
933 | if (stir->thr_pid < 0) { | 927 | if (IS_ERR(stir->thread)) { |
934 | err = stir->thr_pid; | 928 | err = PTR_ERR(stir->thread); |
935 | err("stir4200: unable to start kernel thread"); | 929 | err("stir4200: unable to start kernel thread"); |
936 | goto err_out6; | 930 | goto err_out6; |
937 | } | 931 | } |
@@ -968,8 +962,7 @@ static int stir_net_close(struct net_device *netdev) | |||
968 | netif_stop_queue(netdev); | 962 | netif_stop_queue(netdev); |
969 | 963 | ||
970 | /* Kill transmit thread */ | 964 | /* Kill transmit thread */ |
971 | kill_proc(stir->thr_pid, SIGTERM, 1); | 965 | kthread_stop(stir->thread); |
972 | wait_for_completion(&stir->thr_exited); | ||
973 | kfree(stir->fifo_status); | 966 | kfree(stir->fifo_status); |
974 | 967 | ||
975 | /* Mop up receive urb's */ | 968 | /* Mop up receive urb's */ |
@@ -1084,9 +1077,6 @@ static int stir_probe(struct usb_interface *intf, | |||
1084 | stir->qos.min_turn_time.bits &= qos_mtt_bits; | 1077 | stir->qos.min_turn_time.bits &= qos_mtt_bits; |
1085 | irda_qos_bits_to_value(&stir->qos); | 1078 | irda_qos_bits_to_value(&stir->qos); |
1086 | 1079 | ||
1087 | init_completion (&stir->thr_exited); | ||
1088 | init_waitqueue_head (&stir->thr_wait); | ||
1089 | |||
1090 | /* Override the network functions we need to use */ | 1080 | /* Override the network functions we need to use */ |
1091 | net->hard_start_xmit = stir_hard_xmit; | 1081 | net->hard_start_xmit = stir_hard_xmit; |
1092 | net->open = stir_net_open; | 1082 | net->open = stir_net_open; |
diff --git a/drivers/net/irda/vlsi_ir.c b/drivers/net/irda/vlsi_ir.c index 97a49e0be76b..d70b9e8d6e60 100644 --- a/drivers/net/irda/vlsi_ir.c +++ b/drivers/net/irda/vlsi_ir.c | |||
@@ -959,7 +959,7 @@ static int vlsi_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev) | |||
959 | || (now.tv_sec==ready.tv_sec && now.tv_usec>=ready.tv_usec)) | 959 | || (now.tv_sec==ready.tv_sec && now.tv_usec>=ready.tv_usec)) |
960 | break; | 960 | break; |
961 | udelay(100); | 961 | udelay(100); |
962 | /* must not sleep here - we are called under xmit_lock! */ | 962 | /* must not sleep here - called under netif_tx_lock! */ |
963 | } | 963 | } |
964 | } | 964 | } |
965 | 965 | ||
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c index 411f4d809c47..625ff61c9988 100644 --- a/drivers/net/mv643xx_eth.c +++ b/drivers/net/mv643xx_eth.c | |||
@@ -1200,7 +1200,7 @@ static int mv643xx_eth_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1200 | } | 1200 | } |
1201 | 1201 | ||
1202 | if (has_tiny_unaligned_frags(skb)) { | 1202 | if (has_tiny_unaligned_frags(skb)) { |
1203 | if ((skb_linearize(skb, GFP_ATOMIC) != 0)) { | 1203 | if (__skb_linearize(skb)) { |
1204 | stats->tx_dropped++; | 1204 | stats->tx_dropped++; |
1205 | printk(KERN_DEBUG "%s: failed to linearize tiny " | 1205 | printk(KERN_DEBUG "%s: failed to linearize tiny " |
1206 | "unaligned fragment\n", dev->name); | 1206 | "unaligned fragment\n", dev->name); |
diff --git a/drivers/net/natsemi.c b/drivers/net/natsemi.c index 90627756d6fa..2e4ecedba057 100644 --- a/drivers/net/natsemi.c +++ b/drivers/net/natsemi.c | |||
@@ -318,12 +318,12 @@ performance critical codepaths: | |||
318 | The rx process only runs in the interrupt handler. Access from outside | 318 | The rx process only runs in the interrupt handler. Access from outside |
319 | the interrupt handler is only permitted after disable_irq(). | 319 | the interrupt handler is only permitted after disable_irq(). |
320 | 320 | ||
321 | The rx process usually runs under the dev->xmit_lock. If np->intr_tx_reap | 321 | The rx process usually runs under the netif_tx_lock. If np->intr_tx_reap |
322 | is set, then access is permitted under spin_lock_irq(&np->lock). | 322 | is set, then access is permitted under spin_lock_irq(&np->lock). |
323 | 323 | ||
324 | Thus configuration functions that want to access everything must call | 324 | Thus configuration functions that want to access everything must call |
325 | disable_irq(dev->irq); | 325 | disable_irq(dev->irq); |
326 | spin_lock_bh(dev->xmit_lock); | 326 | netif_tx_lock_bh(dev); |
327 | spin_lock_irq(&np->lock); | 327 | spin_lock_irq(&np->lock); |
328 | 328 | ||
329 | IV. Notes | 329 | IV. Notes |
diff --git a/drivers/net/ne.c b/drivers/net/ne.c index b32765215f75..963a11fa9fe2 100644 --- a/drivers/net/ne.c +++ b/drivers/net/ne.c | |||
@@ -829,7 +829,7 @@ that the ne2k probe is the last 8390 based probe to take place (as it | |||
829 | is at boot) and so the probe will get confused by any other 8390 cards. | 829 | is at boot) and so the probe will get confused by any other 8390 cards. |
830 | ISA device autoprobes on a running machine are not recommended anyway. */ | 830 | ISA device autoprobes on a running machine are not recommended anyway. */ |
831 | 831 | ||
832 | int init_module(void) | 832 | int __init init_module(void) |
833 | { | 833 | { |
834 | int this_dev, found = 0; | 834 | int this_dev, found = 0; |
835 | 835 | ||
diff --git a/drivers/net/ne2.c b/drivers/net/ne2.c index 2aa7b77f84f8..eebf5f02b476 100644 --- a/drivers/net/ne2.c +++ b/drivers/net/ne2.c | |||
@@ -780,7 +780,7 @@ MODULE_PARM_DESC(bad, "(ignored)"); | |||
780 | 780 | ||
781 | /* Module code fixed by David Weinehall */ | 781 | /* Module code fixed by David Weinehall */ |
782 | 782 | ||
783 | int init_module(void) | 783 | int __init init_module(void) |
784 | { | 784 | { |
785 | struct net_device *dev; | 785 | struct net_device *dev; |
786 | int this_dev, found = 0; | 786 | int this_dev, found = 0; |
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c index b2073fce8216..01cd8ec751ea 100644 --- a/drivers/net/ppp_generic.c +++ b/drivers/net/ppp_generic.c | |||
@@ -1609,8 +1609,6 @@ ppp_receive_nonmp_frame(struct ppp *ppp, struct sk_buff *skb) | |||
1609 | kfree_skb(skb); | 1609 | kfree_skb(skb); |
1610 | skb = ns; | 1610 | skb = ns; |
1611 | } | 1611 | } |
1612 | else if (!pskb_may_pull(skb, skb->len)) | ||
1613 | goto err; | ||
1614 | else | 1612 | else |
1615 | skb->ip_summed = CHECKSUM_NONE; | 1613 | skb->ip_summed = CHECKSUM_NONE; |
1616 | 1614 | ||
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c index cac9fdd2e1d5..11daed495b97 100644 --- a/drivers/net/s2io.c +++ b/drivers/net/s2io.c | |||
@@ -2627,6 +2627,50 @@ no_rx: | |||
2627 | #endif | 2627 | #endif |
2628 | 2628 | ||
2629 | /** | 2629 | /** |
2630 | * s2io_netpoll - Rx interrupt service handler for netpoll support | ||
2631 | * @dev : pointer to the device structure. | ||
2632 | * Description: | ||
2633 | * Polling 'interrupt' - used by things like netconsole to send skbs | ||
2634 | * without having to re-enable interrupts. It's not called while | ||
2635 | * the interrupt routine is executing. | ||
2636 | */ | ||
2637 | |||
2638 | #ifdef CONFIG_NET_POLL_CONTROLLER | ||
2639 | static void s2io_netpoll(struct net_device *dev) | ||
2640 | { | ||
2641 | nic_t *nic = dev->priv; | ||
2642 | mac_info_t *mac_control; | ||
2643 | struct config_param *config; | ||
2644 | XENA_dev_config_t __iomem *bar0 = nic->bar0; | ||
2645 | u64 val64; | ||
2646 | int i; | ||
2647 | |||
2648 | disable_irq(dev->irq); | ||
2649 | |||
2650 | atomic_inc(&nic->isr_cnt); | ||
2651 | mac_control = &nic->mac_control; | ||
2652 | config = &nic->config; | ||
2653 | |||
2654 | val64 = readq(&bar0->rx_traffic_int); | ||
2655 | writeq(val64, &bar0->rx_traffic_int); | ||
2656 | |||
2657 | for (i = 0; i < config->rx_ring_num; i++) | ||
2658 | rx_intr_handler(&mac_control->rings[i]); | ||
2659 | |||
2660 | for (i = 0; i < config->rx_ring_num; i++) { | ||
2661 | if (fill_rx_buffers(nic, i) == -ENOMEM) { | ||
2662 | DBG_PRINT(ERR_DBG, "%s:Out of memory", dev->name); | ||
2663 | DBG_PRINT(ERR_DBG, " in Rx Netpoll!!\n"); | ||
2664 | break; | ||
2665 | } | ||
2666 | } | ||
2667 | atomic_dec(&nic->isr_cnt); | ||
2668 | enable_irq(dev->irq); | ||
2669 | return; | ||
2670 | } | ||
2671 | #endif | ||
2672 | |||
2673 | /** | ||
2630 | * rx_intr_handler - Rx interrupt handler | 2674 | * rx_intr_handler - Rx interrupt handler |
2631 | * @nic: device private variable. | 2675 | * @nic: device private variable. |
2632 | * Description: | 2676 | * Description: |
@@ -6967,6 +7011,10 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre) | |||
6967 | dev->weight = 32; | 7011 | dev->weight = 32; |
6968 | #endif | 7012 | #endif |
6969 | 7013 | ||
7014 | #ifdef CONFIG_NET_POLL_CONTROLLER | ||
7015 | dev->poll_controller = s2io_netpoll; | ||
7016 | #endif | ||
7017 | |||
6970 | dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; | 7018 | dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; |
6971 | if (sp->high_dma_flag == TRUE) | 7019 | if (sp->high_dma_flag == TRUE) |
6972 | dev->features |= NETIF_F_HIGHDMA; | 7020 | dev->features |= NETIF_F_HIGHDMA; |
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c index 959109609d85..fba1e4d4d83d 100644 --- a/drivers/net/sky2.c +++ b/drivers/net/sky2.c | |||
@@ -187,12 +187,11 @@ static u16 gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg) | |||
187 | return v; | 187 | return v; |
188 | } | 188 | } |
189 | 189 | ||
190 | static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state) | 190 | static void sky2_set_power_state(struct sky2_hw *hw, pci_power_t state) |
191 | { | 191 | { |
192 | u16 power_control; | 192 | u16 power_control; |
193 | u32 reg1; | 193 | u32 reg1; |
194 | int vaux; | 194 | int vaux; |
195 | int ret = 0; | ||
196 | 195 | ||
197 | pr_debug("sky2_set_power_state %d\n", state); | 196 | pr_debug("sky2_set_power_state %d\n", state); |
198 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); | 197 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); |
@@ -275,12 +274,10 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state) | |||
275 | break; | 274 | break; |
276 | default: | 275 | default: |
277 | printk(KERN_ERR PFX "Unknown power state %d\n", state); | 276 | printk(KERN_ERR PFX "Unknown power state %d\n", state); |
278 | ret = -1; | ||
279 | } | 277 | } |
280 | 278 | ||
281 | sky2_pci_write16(hw, hw->pm_cap + PCI_PM_CTRL, power_control); | 279 | sky2_pci_write16(hw, hw->pm_cap + PCI_PM_CTRL, power_control); |
282 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); | 280 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); |
283 | return ret; | ||
284 | } | 281 | } |
285 | 282 | ||
286 | static void sky2_phy_reset(struct sky2_hw *hw, unsigned port) | 283 | static void sky2_phy_reset(struct sky2_hw *hw, unsigned port) |
@@ -2164,6 +2161,13 @@ static void sky2_descriptor_error(struct sky2_hw *hw, unsigned port, | |||
2164 | /* If idle then force a fake soft NAPI poll once a second | 2161 | /* If idle then force a fake soft NAPI poll once a second |
2165 | * to work around cases where sharing an edge triggered interrupt. | 2162 | * to work around cases where sharing an edge triggered interrupt. |
2166 | */ | 2163 | */ |
2164 | static inline void sky2_idle_start(struct sky2_hw *hw) | ||
2165 | { | ||
2166 | if (idle_timeout > 0) | ||
2167 | mod_timer(&hw->idle_timer, | ||
2168 | jiffies + msecs_to_jiffies(idle_timeout)); | ||
2169 | } | ||
2170 | |||
2167 | static void sky2_idle(unsigned long arg) | 2171 | static void sky2_idle(unsigned long arg) |
2168 | { | 2172 | { |
2169 | struct sky2_hw *hw = (struct sky2_hw *) arg; | 2173 | struct sky2_hw *hw = (struct sky2_hw *) arg; |
@@ -2183,6 +2187,9 @@ static int sky2_poll(struct net_device *dev0, int *budget) | |||
2183 | int work_done = 0; | 2187 | int work_done = 0; |
2184 | u32 status = sky2_read32(hw, B0_Y2_SP_EISR); | 2188 | u32 status = sky2_read32(hw, B0_Y2_SP_EISR); |
2185 | 2189 | ||
2190 | if (!~status) | ||
2191 | goto out; | ||
2192 | |||
2186 | if (status & Y2_IS_HW_ERR) | 2193 | if (status & Y2_IS_HW_ERR) |
2187 | sky2_hw_intr(hw); | 2194 | sky2_hw_intr(hw); |
2188 | 2195 | ||
@@ -2219,7 +2226,7 @@ static int sky2_poll(struct net_device *dev0, int *budget) | |||
2219 | 2226 | ||
2220 | if (sky2_more_work(hw)) | 2227 | if (sky2_more_work(hw)) |
2221 | return 1; | 2228 | return 1; |
2222 | 2229 | out: | |
2223 | netif_rx_complete(dev0); | 2230 | netif_rx_complete(dev0); |
2224 | 2231 | ||
2225 | sky2_read32(hw, B0_Y2_SP_LISR); | 2232 | sky2_read32(hw, B0_Y2_SP_LISR); |
@@ -2248,8 +2255,10 @@ static irqreturn_t sky2_intr(int irq, void *dev_id, struct pt_regs *regs) | |||
2248 | static void sky2_netpoll(struct net_device *dev) | 2255 | static void sky2_netpoll(struct net_device *dev) |
2249 | { | 2256 | { |
2250 | struct sky2_port *sky2 = netdev_priv(dev); | 2257 | struct sky2_port *sky2 = netdev_priv(dev); |
2258 | struct net_device *dev0 = sky2->hw->dev[0]; | ||
2251 | 2259 | ||
2252 | sky2_intr(sky2->hw->pdev->irq, sky2->hw, NULL); | 2260 | if (netif_running(dev) && __netif_rx_schedule_prep(dev0)) |
2261 | __netif_rx_schedule(dev0); | ||
2253 | } | 2262 | } |
2254 | #endif | 2263 | #endif |
2255 | 2264 | ||
@@ -3350,9 +3359,7 @@ static int __devinit sky2_probe(struct pci_dev *pdev, | |||
3350 | sky2_write32(hw, B0_IMSK, Y2_IS_BASE); | 3359 | sky2_write32(hw, B0_IMSK, Y2_IS_BASE); |
3351 | 3360 | ||
3352 | setup_timer(&hw->idle_timer, sky2_idle, (unsigned long) hw); | 3361 | setup_timer(&hw->idle_timer, sky2_idle, (unsigned long) hw); |
3353 | if (idle_timeout > 0) | 3362 | sky2_idle_start(hw); |
3354 | mod_timer(&hw->idle_timer, | ||
3355 | jiffies + msecs_to_jiffies(idle_timeout)); | ||
3356 | 3363 | ||
3357 | pci_set_drvdata(pdev, hw); | 3364 | pci_set_drvdata(pdev, hw); |
3358 | 3365 | ||
@@ -3425,8 +3432,14 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state) | |||
3425 | { | 3432 | { |
3426 | struct sky2_hw *hw = pci_get_drvdata(pdev); | 3433 | struct sky2_hw *hw = pci_get_drvdata(pdev); |
3427 | int i; | 3434 | int i; |
3435 | pci_power_t pstate = pci_choose_state(pdev, state); | ||
3436 | |||
3437 | if (!(pstate == PCI_D3hot || pstate == PCI_D3cold)) | ||
3438 | return -EINVAL; | ||
3439 | |||
3440 | del_timer_sync(&hw->idle_timer); | ||
3428 | 3441 | ||
3429 | for (i = 0; i < 2; i++) { | 3442 | for (i = 0; i < hw->ports; i++) { |
3430 | struct net_device *dev = hw->dev[i]; | 3443 | struct net_device *dev = hw->dev[i]; |
3431 | 3444 | ||
3432 | if (dev) { | 3445 | if (dev) { |
@@ -3435,10 +3448,14 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state) | |||
3435 | 3448 | ||
3436 | sky2_down(dev); | 3449 | sky2_down(dev); |
3437 | netif_device_detach(dev); | 3450 | netif_device_detach(dev); |
3451 | netif_poll_disable(dev); | ||
3438 | } | 3452 | } |
3439 | } | 3453 | } |
3440 | 3454 | ||
3441 | return sky2_set_power_state(hw, pci_choose_state(pdev, state)); | 3455 | sky2_write32(hw, B0_IMSK, 0); |
3456 | pci_save_state(pdev); | ||
3457 | sky2_set_power_state(hw, pstate); | ||
3458 | return 0; | ||
3442 | } | 3459 | } |
3443 | 3460 | ||
3444 | static int sky2_resume(struct pci_dev *pdev) | 3461 | static int sky2_resume(struct pci_dev *pdev) |
@@ -3448,27 +3465,31 @@ static int sky2_resume(struct pci_dev *pdev) | |||
3448 | 3465 | ||
3449 | pci_restore_state(pdev); | 3466 | pci_restore_state(pdev); |
3450 | pci_enable_wake(pdev, PCI_D0, 0); | 3467 | pci_enable_wake(pdev, PCI_D0, 0); |
3451 | err = sky2_set_power_state(hw, PCI_D0); | 3468 | sky2_set_power_state(hw, PCI_D0); |
3452 | if (err) | ||
3453 | goto out; | ||
3454 | 3469 | ||
3455 | err = sky2_reset(hw); | 3470 | err = sky2_reset(hw); |
3456 | if (err) | 3471 | if (err) |
3457 | goto out; | 3472 | goto out; |
3458 | 3473 | ||
3459 | for (i = 0; i < 2; i++) { | 3474 | sky2_write32(hw, B0_IMSK, Y2_IS_BASE); |
3475 | |||
3476 | for (i = 0; i < hw->ports; i++) { | ||
3460 | struct net_device *dev = hw->dev[i]; | 3477 | struct net_device *dev = hw->dev[i]; |
3461 | if (dev && netif_running(dev)) { | 3478 | if (dev && netif_running(dev)) { |
3462 | netif_device_attach(dev); | 3479 | netif_device_attach(dev); |
3480 | netif_poll_enable(dev); | ||
3481 | |||
3463 | err = sky2_up(dev); | 3482 | err = sky2_up(dev); |
3464 | if (err) { | 3483 | if (err) { |
3465 | printk(KERN_ERR PFX "%s: could not up: %d\n", | 3484 | printk(KERN_ERR PFX "%s: could not up: %d\n", |
3466 | dev->name, err); | 3485 | dev->name, err); |
3467 | dev_close(dev); | 3486 | dev_close(dev); |
3468 | break; | 3487 | goto out; |
3469 | } | 3488 | } |
3470 | } | 3489 | } |
3471 | } | 3490 | } |
3491 | |||
3492 | sky2_idle_start(hw); | ||
3472 | out: | 3493 | out: |
3473 | return err; | 3494 | return err; |
3474 | } | 3495 | } |
diff --git a/drivers/net/smc-ultra.c b/drivers/net/smc-ultra.c index 3db30cd0625e..5b4e8529d4ab 100644 --- a/drivers/net/smc-ultra.c +++ b/drivers/net/smc-ultra.c | |||
@@ -553,7 +553,7 @@ MODULE_LICENSE("GPL"); | |||
553 | 553 | ||
554 | /* This is set up so that only a single autoprobe takes place per call. | 554 | /* This is set up so that only a single autoprobe takes place per call. |
555 | ISA device autoprobes on a running machine are not recommended. */ | 555 | ISA device autoprobes on a running machine are not recommended. */ |
556 | int | 556 | int __init |
557 | init_module(void) | 557 | init_module(void) |
558 | { | 558 | { |
559 | struct net_device *dev; | 559 | struct net_device *dev; |
diff --git a/drivers/net/smc-ultra32.c b/drivers/net/smc-ultra32.c index b3e397d7ca85..ff9bd97746dc 100644 --- a/drivers/net/smc-ultra32.c +++ b/drivers/net/smc-ultra32.c | |||
@@ -421,7 +421,7 @@ static struct net_device *dev_ultra[MAX_ULTRA32_CARDS]; | |||
421 | MODULE_DESCRIPTION("SMC Ultra32 EISA ethernet driver"); | 421 | MODULE_DESCRIPTION("SMC Ultra32 EISA ethernet driver"); |
422 | MODULE_LICENSE("GPL"); | 422 | MODULE_LICENSE("GPL"); |
423 | 423 | ||
424 | int init_module(void) | 424 | int __init init_module(void) |
425 | { | 425 | { |
426 | int this_dev, found = 0; | 426 | int this_dev, found = 0; |
427 | 427 | ||
diff --git a/drivers/net/smc9194.c b/drivers/net/smc9194.c index f86697da04d6..6cf16f322ad5 100644 --- a/drivers/net/smc9194.c +++ b/drivers/net/smc9194.c | |||
@@ -732,12 +732,9 @@ static int ifport; | |||
732 | struct net_device * __init smc_init(int unit) | 732 | struct net_device * __init smc_init(int unit) |
733 | { | 733 | { |
734 | struct net_device *dev = alloc_etherdev(sizeof(struct smc_local)); | 734 | struct net_device *dev = alloc_etherdev(sizeof(struct smc_local)); |
735 | static struct devlist *smcdev = smc_devlist; | 735 | struct devlist *smcdev = smc_devlist; |
736 | int err = 0; | 736 | int err = 0; |
737 | 737 | ||
738 | #ifndef NO_AUTOPROBE | ||
739 | smcdev = smc_devlist; | ||
740 | #endif | ||
741 | if (!dev) | 738 | if (!dev) |
742 | return ERR_PTR(-ENODEV); | 739 | return ERR_PTR(-ENODEV); |
743 | 740 | ||
@@ -1607,7 +1604,7 @@ MODULE_PARM_DESC(io, "SMC 99194 I/O base address"); | |||
1607 | MODULE_PARM_DESC(irq, "SMC 99194 IRQ number"); | 1604 | MODULE_PARM_DESC(irq, "SMC 99194 IRQ number"); |
1608 | MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)"); | 1605 | MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)"); |
1609 | 1606 | ||
1610 | int init_module(void) | 1607 | int __init init_module(void) |
1611 | { | 1608 | { |
1612 | if (io == 0) | 1609 | if (io == 0) |
1613 | printk(KERN_WARNING | 1610 | printk(KERN_WARNING |
diff --git a/drivers/net/sundance.c b/drivers/net/sundance.c index 61eec46cb111..f13b2a195c70 100644 --- a/drivers/net/sundance.c +++ b/drivers/net/sundance.c | |||
@@ -94,11 +94,13 @@ | |||
94 | Version LK1.10 (Philippe De Muyter phdm@macqel.be): | 94 | Version LK1.10 (Philippe De Muyter phdm@macqel.be): |
95 | - Make 'unblock interface after Tx underrun' work | 95 | - Make 'unblock interface after Tx underrun' work |
96 | 96 | ||
97 | Version LK1.11 (Pedro Alejandro Lopez-Valencia palopezv at gmail.com): | ||
98 | - Add support for IC Plus Corporation IP100A chipset | ||
97 | */ | 99 | */ |
98 | 100 | ||
99 | #define DRV_NAME "sundance" | 101 | #define DRV_NAME "sundance" |
100 | #define DRV_VERSION "1.01+LK1.10" | 102 | #define DRV_VERSION "1.01+LK1.11" |
101 | #define DRV_RELDATE "28-Oct-2005" | 103 | #define DRV_RELDATE "14-Jun-2006" |
102 | 104 | ||
103 | 105 | ||
104 | /* The user-configurable values. | 106 | /* The user-configurable values. |
@@ -287,6 +289,7 @@ static struct pci_device_id sundance_pci_tbl[] = { | |||
287 | {0x1186, 0x1002, 0x1186, 0x1040, 0, 0, 3}, | 289 | {0x1186, 0x1002, 0x1186, 0x1040, 0, 0, 3}, |
288 | {0x1186, 0x1002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4}, | 290 | {0x1186, 0x1002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4}, |
289 | {0x13F0, 0x0201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5}, | 291 | {0x13F0, 0x0201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5}, |
292 | {0x13F0, 0x0200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6}, | ||
290 | {0,} | 293 | {0,} |
291 | }; | 294 | }; |
292 | MODULE_DEVICE_TABLE(pci, sundance_pci_tbl); | 295 | MODULE_DEVICE_TABLE(pci, sundance_pci_tbl); |
@@ -305,6 +308,7 @@ static const struct pci_id_info pci_id_tbl[] = { | |||
305 | {"D-Link DFE-530TXS FAST Ethernet Adapter"}, | 308 | {"D-Link DFE-530TXS FAST Ethernet Adapter"}, |
306 | {"D-Link DL10050-based FAST Ethernet Adapter"}, | 309 | {"D-Link DL10050-based FAST Ethernet Adapter"}, |
307 | {"Sundance Technology Alta"}, | 310 | {"Sundance Technology Alta"}, |
311 | {"IC Plus Corporation IP100A FAST Ethernet Adapter"}, | ||
308 | {NULL,}, /* 0 terminated list. */ | 312 | {NULL,}, /* 0 terminated list. */ |
309 | }; | 313 | }; |
310 | 314 | ||
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c index 49ad60b72657..b2ddd4522a87 100644 --- a/drivers/net/tg3.c +++ b/drivers/net/tg3.c | |||
@@ -69,8 +69,8 @@ | |||
69 | 69 | ||
70 | #define DRV_MODULE_NAME "tg3" | 70 | #define DRV_MODULE_NAME "tg3" |
71 | #define PFX DRV_MODULE_NAME ": " | 71 | #define PFX DRV_MODULE_NAME ": " |
72 | #define DRV_MODULE_VERSION "3.58" | 72 | #define DRV_MODULE_VERSION "3.60" |
73 | #define DRV_MODULE_RELDATE "May 22, 2006" | 73 | #define DRV_MODULE_RELDATE "June 17, 2006" |
74 | 74 | ||
75 | #define TG3_DEF_MAC_MODE 0 | 75 | #define TG3_DEF_MAC_MODE 0 |
76 | #define TG3_DEF_RX_MODE 0 | 76 | #define TG3_DEF_RX_MODE 0 |
@@ -229,6 +229,8 @@ static struct pci_device_id tg3_pci_tbl[] = { | |||
229 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, | 229 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, |
230 | { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755M, | 230 | { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755M, |
231 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, | 231 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, |
232 | { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5786, | ||
233 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, | ||
232 | { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787, | 234 | { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787, |
233 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, | 235 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, |
234 | { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787M, | 236 | { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787M, |
@@ -2965,6 +2967,27 @@ static int tg3_setup_phy(struct tg3 *tp, int force_reset) | |||
2965 | return err; | 2967 | return err; |
2966 | } | 2968 | } |
2967 | 2969 | ||
2970 | /* This is called whenever we suspect that the system chipset is re- | ||
2971 | * ordering the sequence of MMIO to the tx send mailbox. The symptom | ||
2972 | * is bogus tx completions. We try to recover by setting the | ||
2973 | * TG3_FLAG_MBOX_WRITE_REORDER flag and resetting the chip later | ||
2974 | * in the workqueue. | ||
2975 | */ | ||
2976 | static void tg3_tx_recover(struct tg3 *tp) | ||
2977 | { | ||
2978 | BUG_ON((tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER) || | ||
2979 | tp->write32_tx_mbox == tg3_write_indirect_mbox); | ||
2980 | |||
2981 | printk(KERN_WARNING PFX "%s: The system may be re-ordering memory-" | ||
2982 | "mapped I/O cycles to the network device, attempting to " | ||
2983 | "recover. Please report the problem to the driver maintainer " | ||
2984 | "and include system chipset information.\n", tp->dev->name); | ||
2985 | |||
2986 | spin_lock(&tp->lock); | ||
2987 | tp->tg3_flags |= TG3_FLAG_TX_RECOVERY_PENDING; | ||
2988 | spin_unlock(&tp->lock); | ||
2989 | } | ||
2990 | |||
2968 | /* Tigon3 never reports partial packet sends. So we do not | 2991 | /* Tigon3 never reports partial packet sends. So we do not |
2969 | * need special logic to handle SKBs that have not had all | 2992 | * need special logic to handle SKBs that have not had all |
2970 | * of their frags sent yet, like SunGEM does. | 2993 | * of their frags sent yet, like SunGEM does. |
@@ -2977,9 +3000,13 @@ static void tg3_tx(struct tg3 *tp) | |||
2977 | while (sw_idx != hw_idx) { | 3000 | while (sw_idx != hw_idx) { |
2978 | struct tx_ring_info *ri = &tp->tx_buffers[sw_idx]; | 3001 | struct tx_ring_info *ri = &tp->tx_buffers[sw_idx]; |
2979 | struct sk_buff *skb = ri->skb; | 3002 | struct sk_buff *skb = ri->skb; |
2980 | int i; | 3003 | int i, tx_bug = 0; |
3004 | |||
3005 | if (unlikely(skb == NULL)) { | ||
3006 | tg3_tx_recover(tp); | ||
3007 | return; | ||
3008 | } | ||
2981 | 3009 | ||
2982 | BUG_ON(skb == NULL); | ||
2983 | pci_unmap_single(tp->pdev, | 3010 | pci_unmap_single(tp->pdev, |
2984 | pci_unmap_addr(ri, mapping), | 3011 | pci_unmap_addr(ri, mapping), |
2985 | skb_headlen(skb), | 3012 | skb_headlen(skb), |
@@ -2990,10 +3017,9 @@ static void tg3_tx(struct tg3 *tp) | |||
2990 | sw_idx = NEXT_TX(sw_idx); | 3017 | sw_idx = NEXT_TX(sw_idx); |
2991 | 3018 | ||
2992 | for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { | 3019 | for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { |
2993 | BUG_ON(sw_idx == hw_idx); | ||
2994 | |||
2995 | ri = &tp->tx_buffers[sw_idx]; | 3020 | ri = &tp->tx_buffers[sw_idx]; |
2996 | BUG_ON(ri->skb != NULL); | 3021 | if (unlikely(ri->skb != NULL || sw_idx == hw_idx)) |
3022 | tx_bug = 1; | ||
2997 | 3023 | ||
2998 | pci_unmap_page(tp->pdev, | 3024 | pci_unmap_page(tp->pdev, |
2999 | pci_unmap_addr(ri, mapping), | 3025 | pci_unmap_addr(ri, mapping), |
@@ -3004,6 +3030,11 @@ static void tg3_tx(struct tg3 *tp) | |||
3004 | } | 3030 | } |
3005 | 3031 | ||
3006 | dev_kfree_skb(skb); | 3032 | dev_kfree_skb(skb); |
3033 | |||
3034 | if (unlikely(tx_bug)) { | ||
3035 | tg3_tx_recover(tp); | ||
3036 | return; | ||
3037 | } | ||
3007 | } | 3038 | } |
3008 | 3039 | ||
3009 | tp->tx_cons = sw_idx; | 3040 | tp->tx_cons = sw_idx; |
@@ -3331,6 +3362,11 @@ static int tg3_poll(struct net_device *netdev, int *budget) | |||
3331 | /* run TX completion thread */ | 3362 | /* run TX completion thread */ |
3332 | if (sblk->idx[0].tx_consumer != tp->tx_cons) { | 3363 | if (sblk->idx[0].tx_consumer != tp->tx_cons) { |
3333 | tg3_tx(tp); | 3364 | tg3_tx(tp); |
3365 | if (unlikely(tp->tg3_flags & TG3_FLAG_TX_RECOVERY_PENDING)) { | ||
3366 | netif_rx_complete(netdev); | ||
3367 | schedule_work(&tp->reset_task); | ||
3368 | return 0; | ||
3369 | } | ||
3334 | } | 3370 | } |
3335 | 3371 | ||
3336 | /* run RX thread, within the bounds set by NAPI. | 3372 | /* run RX thread, within the bounds set by NAPI. |
@@ -3391,12 +3427,10 @@ static inline void tg3_full_lock(struct tg3 *tp, int irq_sync) | |||
3391 | if (irq_sync) | 3427 | if (irq_sync) |
3392 | tg3_irq_quiesce(tp); | 3428 | tg3_irq_quiesce(tp); |
3393 | spin_lock_bh(&tp->lock); | 3429 | spin_lock_bh(&tp->lock); |
3394 | spin_lock(&tp->tx_lock); | ||
3395 | } | 3430 | } |
3396 | 3431 | ||
3397 | static inline void tg3_full_unlock(struct tg3 *tp) | 3432 | static inline void tg3_full_unlock(struct tg3 *tp) |
3398 | { | 3433 | { |
3399 | spin_unlock(&tp->tx_lock); | ||
3400 | spin_unlock_bh(&tp->lock); | 3434 | spin_unlock_bh(&tp->lock); |
3401 | } | 3435 | } |
3402 | 3436 | ||
@@ -3579,6 +3613,13 @@ static void tg3_reset_task(void *_data) | |||
3579 | restart_timer = tp->tg3_flags2 & TG3_FLG2_RESTART_TIMER; | 3613 | restart_timer = tp->tg3_flags2 & TG3_FLG2_RESTART_TIMER; |
3580 | tp->tg3_flags2 &= ~TG3_FLG2_RESTART_TIMER; | 3614 | tp->tg3_flags2 &= ~TG3_FLG2_RESTART_TIMER; |
3581 | 3615 | ||
3616 | if (tp->tg3_flags & TG3_FLAG_TX_RECOVERY_PENDING) { | ||
3617 | tp->write32_tx_mbox = tg3_write32_tx_mbox; | ||
3618 | tp->write32_rx_mbox = tg3_write_flush_reg32; | ||
3619 | tp->tg3_flags |= TG3_FLAG_MBOX_WRITE_REORDER; | ||
3620 | tp->tg3_flags &= ~TG3_FLAG_TX_RECOVERY_PENDING; | ||
3621 | } | ||
3622 | |||
3582 | tg3_halt(tp, RESET_KIND_SHUTDOWN, 0); | 3623 | tg3_halt(tp, RESET_KIND_SHUTDOWN, 0); |
3583 | tg3_init_hw(tp, 1); | 3624 | tg3_init_hw(tp, 1); |
3584 | 3625 | ||
@@ -3718,14 +3759,11 @@ static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
3718 | 3759 | ||
3719 | len = skb_headlen(skb); | 3760 | len = skb_headlen(skb); |
3720 | 3761 | ||
3721 | /* No BH disabling for tx_lock here. We are running in BH disabled | 3762 | /* We are running in BH disabled context with netif_tx_lock |
3722 | * context and TX reclaim runs via tp->poll inside of a software | 3763 | * and TX reclaim runs via tp->poll inside of a software |
3723 | * interrupt. Furthermore, IRQ processing runs lockless so we have | 3764 | * interrupt. Furthermore, IRQ processing runs lockless so we have |
3724 | * no IRQ context deadlocks to worry about either. Rejoice! | 3765 | * no IRQ context deadlocks to worry about either. Rejoice! |
3725 | */ | 3766 | */ |
3726 | if (!spin_trylock(&tp->tx_lock)) | ||
3727 | return NETDEV_TX_LOCKED; | ||
3728 | |||
3729 | if (unlikely(TX_BUFFS_AVAIL(tp) <= (skb_shinfo(skb)->nr_frags + 1))) { | 3767 | if (unlikely(TX_BUFFS_AVAIL(tp) <= (skb_shinfo(skb)->nr_frags + 1))) { |
3730 | if (!netif_queue_stopped(dev)) { | 3768 | if (!netif_queue_stopped(dev)) { |
3731 | netif_stop_queue(dev); | 3769 | netif_stop_queue(dev); |
@@ -3734,7 +3772,6 @@ static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
3734 | printk(KERN_ERR PFX "%s: BUG! Tx Ring full when " | 3772 | printk(KERN_ERR PFX "%s: BUG! Tx Ring full when " |
3735 | "queue awake!\n", dev->name); | 3773 | "queue awake!\n", dev->name); |
3736 | } | 3774 | } |
3737 | spin_unlock(&tp->tx_lock); | ||
3738 | return NETDEV_TX_BUSY; | 3775 | return NETDEV_TX_BUSY; |
3739 | } | 3776 | } |
3740 | 3777 | ||
@@ -3817,15 +3854,16 @@ static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
3817 | tw32_tx_mbox((MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW), entry); | 3854 | tw32_tx_mbox((MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW), entry); |
3818 | 3855 | ||
3819 | tp->tx_prod = entry; | 3856 | tp->tx_prod = entry; |
3820 | if (TX_BUFFS_AVAIL(tp) <= (MAX_SKB_FRAGS + 1)) { | 3857 | if (unlikely(TX_BUFFS_AVAIL(tp) <= (MAX_SKB_FRAGS + 1))) { |
3858 | spin_lock(&tp->tx_lock); | ||
3821 | netif_stop_queue(dev); | 3859 | netif_stop_queue(dev); |
3822 | if (TX_BUFFS_AVAIL(tp) > TG3_TX_WAKEUP_THRESH) | 3860 | if (TX_BUFFS_AVAIL(tp) > TG3_TX_WAKEUP_THRESH) |
3823 | netif_wake_queue(tp->dev); | 3861 | netif_wake_queue(tp->dev); |
3862 | spin_unlock(&tp->tx_lock); | ||
3824 | } | 3863 | } |
3825 | 3864 | ||
3826 | out_unlock: | 3865 | out_unlock: |
3827 | mmiowb(); | 3866 | mmiowb(); |
3828 | spin_unlock(&tp->tx_lock); | ||
3829 | 3867 | ||
3830 | dev->trans_start = jiffies; | 3868 | dev->trans_start = jiffies; |
3831 | 3869 | ||
@@ -3844,14 +3882,11 @@ static int tg3_start_xmit_dma_bug(struct sk_buff *skb, struct net_device *dev) | |||
3844 | 3882 | ||
3845 | len = skb_headlen(skb); | 3883 | len = skb_headlen(skb); |
3846 | 3884 | ||
3847 | /* No BH disabling for tx_lock here. We are running in BH disabled | 3885 | /* We are running in BH disabled context with netif_tx_lock |
3848 | * context and TX reclaim runs via tp->poll inside of a software | 3886 | * and TX reclaim runs via tp->poll inside of a software |
3849 | * interrupt. Furthermore, IRQ processing runs lockless so we have | 3887 | * interrupt. Furthermore, IRQ processing runs lockless so we have |
3850 | * no IRQ context deadlocks to worry about either. Rejoice! | 3888 | * no IRQ context deadlocks to worry about either. Rejoice! |
3851 | */ | 3889 | */ |
3852 | if (!spin_trylock(&tp->tx_lock)) | ||
3853 | return NETDEV_TX_LOCKED; | ||
3854 | |||
3855 | if (unlikely(TX_BUFFS_AVAIL(tp) <= (skb_shinfo(skb)->nr_frags + 1))) { | 3890 | if (unlikely(TX_BUFFS_AVAIL(tp) <= (skb_shinfo(skb)->nr_frags + 1))) { |
3856 | if (!netif_queue_stopped(dev)) { | 3891 | if (!netif_queue_stopped(dev)) { |
3857 | netif_stop_queue(dev); | 3892 | netif_stop_queue(dev); |
@@ -3860,7 +3895,6 @@ static int tg3_start_xmit_dma_bug(struct sk_buff *skb, struct net_device *dev) | |||
3860 | printk(KERN_ERR PFX "%s: BUG! Tx Ring full when " | 3895 | printk(KERN_ERR PFX "%s: BUG! Tx Ring full when " |
3861 | "queue awake!\n", dev->name); | 3896 | "queue awake!\n", dev->name); |
3862 | } | 3897 | } |
3863 | spin_unlock(&tp->tx_lock); | ||
3864 | return NETDEV_TX_BUSY; | 3898 | return NETDEV_TX_BUSY; |
3865 | } | 3899 | } |
3866 | 3900 | ||
@@ -3998,15 +4032,16 @@ static int tg3_start_xmit_dma_bug(struct sk_buff *skb, struct net_device *dev) | |||
3998 | tw32_tx_mbox((MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW), entry); | 4032 | tw32_tx_mbox((MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW), entry); |
3999 | 4033 | ||
4000 | tp->tx_prod = entry; | 4034 | tp->tx_prod = entry; |
4001 | if (TX_BUFFS_AVAIL(tp) <= (MAX_SKB_FRAGS + 1)) { | 4035 | if (unlikely(TX_BUFFS_AVAIL(tp) <= (MAX_SKB_FRAGS + 1))) { |
4036 | spin_lock(&tp->tx_lock); | ||
4002 | netif_stop_queue(dev); | 4037 | netif_stop_queue(dev); |
4003 | if (TX_BUFFS_AVAIL(tp) > TG3_TX_WAKEUP_THRESH) | 4038 | if (TX_BUFFS_AVAIL(tp) > TG3_TX_WAKEUP_THRESH) |
4004 | netif_wake_queue(tp->dev); | 4039 | netif_wake_queue(tp->dev); |
4040 | spin_unlock(&tp->tx_lock); | ||
4005 | } | 4041 | } |
4006 | 4042 | ||
4007 | out_unlock: | 4043 | out_unlock: |
4008 | mmiowb(); | 4044 | mmiowb(); |
4009 | spin_unlock(&tp->tx_lock); | ||
4010 | 4045 | ||
4011 | dev->trans_start = jiffies; | 4046 | dev->trans_start = jiffies; |
4012 | 4047 | ||
@@ -4485,9 +4520,8 @@ static void tg3_disable_nvram_access(struct tg3 *tp) | |||
4485 | /* tp->lock is held. */ | 4520 | /* tp->lock is held. */ |
4486 | static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind) | 4521 | static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind) |
4487 | { | 4522 | { |
4488 | if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X)) | 4523 | tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX, |
4489 | tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX, | 4524 | NIC_SRAM_FIRMWARE_MBOX_MAGIC1); |
4490 | NIC_SRAM_FIRMWARE_MBOX_MAGIC1); | ||
4491 | 4525 | ||
4492 | if (tp->tg3_flags2 & TG3_FLG2_ASF_NEW_HANDSHAKE) { | 4526 | if (tp->tg3_flags2 & TG3_FLG2_ASF_NEW_HANDSHAKE) { |
4493 | switch (kind) { | 4527 | switch (kind) { |
@@ -4568,13 +4602,12 @@ static int tg3_chip_reset(struct tg3 *tp) | |||
4568 | void (*write_op)(struct tg3 *, u32, u32); | 4602 | void (*write_op)(struct tg3 *, u32, u32); |
4569 | int i; | 4603 | int i; |
4570 | 4604 | ||
4571 | if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X)) { | 4605 | tg3_nvram_lock(tp); |
4572 | tg3_nvram_lock(tp); | 4606 | |
4573 | /* No matching tg3_nvram_unlock() after this because | 4607 | /* No matching tg3_nvram_unlock() after this because |
4574 | * chip reset below will undo the nvram lock. | 4608 | * chip reset below will undo the nvram lock. |
4575 | */ | 4609 | */ |
4576 | tp->nvram_lock_cnt = 0; | 4610 | tp->nvram_lock_cnt = 0; |
4577 | } | ||
4578 | 4611 | ||
4579 | if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 || | 4612 | if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 || |
4580 | GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 || | 4613 | GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 || |
@@ -4727,20 +4760,25 @@ static int tg3_chip_reset(struct tg3 *tp) | |||
4727 | tw32_f(MAC_MODE, 0); | 4760 | tw32_f(MAC_MODE, 0); |
4728 | udelay(40); | 4761 | udelay(40); |
4729 | 4762 | ||
4730 | if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X)) { | 4763 | /* Wait for firmware initialization to complete. */ |
4731 | /* Wait for firmware initialization to complete. */ | 4764 | for (i = 0; i < 100000; i++) { |
4732 | for (i = 0; i < 100000; i++) { | 4765 | tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val); |
4733 | tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val); | 4766 | if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1) |
4734 | if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1) | 4767 | break; |
4735 | break; | 4768 | udelay(10); |
4736 | udelay(10); | 4769 | } |
4737 | } | 4770 | |
4738 | if (i >= 100000) { | 4771 | /* Chip might not be fitted with firmare. Some Sun onboard |
4739 | printk(KERN_ERR PFX "tg3_reset_hw timed out for %s, " | 4772 | * parts are configured like that. So don't signal the timeout |
4740 | "firmware will not restart magic=%08x\n", | 4773 | * of the above loop as an error, but do report the lack of |
4741 | tp->dev->name, val); | 4774 | * running firmware once. |
4742 | return -ENODEV; | 4775 | */ |
4743 | } | 4776 | if (i >= 100000 && |
4777 | !(tp->tg3_flags2 & TG3_FLG2_NO_FWARE_REPORTED)) { | ||
4778 | tp->tg3_flags2 |= TG3_FLG2_NO_FWARE_REPORTED; | ||
4779 | |||
4780 | printk(KERN_INFO PFX "%s: No firmware running.\n", | ||
4781 | tp->dev->name); | ||
4744 | } | 4782 | } |
4745 | 4783 | ||
4746 | if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) && | 4784 | if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) && |
@@ -9075,9 +9113,6 @@ static void __devinit tg3_nvram_init(struct tg3 *tp) | |||
9075 | { | 9113 | { |
9076 | int j; | 9114 | int j; |
9077 | 9115 | ||
9078 | if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) | ||
9079 | return; | ||
9080 | |||
9081 | tw32_f(GRC_EEPROM_ADDR, | 9116 | tw32_f(GRC_EEPROM_ADDR, |
9082 | (EEPROM_ADDR_FSM_RESET | | 9117 | (EEPROM_ADDR_FSM_RESET | |
9083 | (EEPROM_DEFAULT_CLOCK_PERIOD << | 9118 | (EEPROM_DEFAULT_CLOCK_PERIOD << |
@@ -9210,11 +9245,6 @@ static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val) | |||
9210 | { | 9245 | { |
9211 | int ret; | 9246 | int ret; |
9212 | 9247 | ||
9213 | if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) { | ||
9214 | printk(KERN_ERR PFX "Attempt to do nvram_read on Sun 570X\n"); | ||
9215 | return -EINVAL; | ||
9216 | } | ||
9217 | |||
9218 | if (!(tp->tg3_flags & TG3_FLAG_NVRAM)) | 9248 | if (!(tp->tg3_flags & TG3_FLAG_NVRAM)) |
9219 | return tg3_nvram_read_using_eeprom(tp, offset, val); | 9249 | return tg3_nvram_read_using_eeprom(tp, offset, val); |
9220 | 9250 | ||
@@ -9447,11 +9477,6 @@ static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf) | |||
9447 | { | 9477 | { |
9448 | int ret; | 9478 | int ret; |
9449 | 9479 | ||
9450 | if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) { | ||
9451 | printk(KERN_ERR PFX "Attempt to do nvram_write on Sun 570X\n"); | ||
9452 | return -EINVAL; | ||
9453 | } | ||
9454 | |||
9455 | if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) { | 9480 | if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) { |
9456 | tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl & | 9481 | tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl & |
9457 | ~GRC_LCLCTRL_GPIO_OUTPUT1); | 9482 | ~GRC_LCLCTRL_GPIO_OUTPUT1); |
@@ -9578,15 +9603,19 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp) | |||
9578 | pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL, | 9603 | pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL, |
9579 | tp->misc_host_ctrl); | 9604 | tp->misc_host_ctrl); |
9580 | 9605 | ||
9606 | /* The memory arbiter has to be enabled in order for SRAM accesses | ||
9607 | * to succeed. Normally on powerup the tg3 chip firmware will make | ||
9608 | * sure it is enabled, but other entities such as system netboot | ||
9609 | * code might disable it. | ||
9610 | */ | ||
9611 | val = tr32(MEMARB_MODE); | ||
9612 | tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE); | ||
9613 | |||
9581 | tp->phy_id = PHY_ID_INVALID; | 9614 | tp->phy_id = PHY_ID_INVALID; |
9582 | tp->led_ctrl = LED_CTRL_MODE_PHY_1; | 9615 | tp->led_ctrl = LED_CTRL_MODE_PHY_1; |
9583 | 9616 | ||
9584 | /* Do not even try poking around in here on Sun parts. */ | 9617 | /* Assume an onboard device by default. */ |
9585 | if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) { | 9618 | tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT; |
9586 | /* All SUN chips are built-in LOMs. */ | ||
9587 | tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT; | ||
9588 | return; | ||
9589 | } | ||
9590 | 9619 | ||
9591 | tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val); | 9620 | tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val); |
9592 | if (val == NIC_SRAM_DATA_SIG_MAGIC) { | 9621 | if (val == NIC_SRAM_DATA_SIG_MAGIC) { |
@@ -9686,6 +9715,8 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp) | |||
9686 | 9715 | ||
9687 | if (nic_cfg & NIC_SRAM_DATA_CFG_EEPROM_WP) | 9716 | if (nic_cfg & NIC_SRAM_DATA_CFG_EEPROM_WP) |
9688 | tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT; | 9717 | tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT; |
9718 | else | ||
9719 | tp->tg3_flags &= ~TG3_FLAG_EEPROM_WRITE_PROT; | ||
9689 | 9720 | ||
9690 | if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) { | 9721 | if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) { |
9691 | tp->tg3_flags |= TG3_FLAG_ENABLE_ASF; | 9722 | tp->tg3_flags |= TG3_FLAG_ENABLE_ASF; |
@@ -9834,16 +9865,8 @@ static void __devinit tg3_read_partno(struct tg3 *tp) | |||
9834 | int i; | 9865 | int i; |
9835 | u32 magic; | 9866 | u32 magic; |
9836 | 9867 | ||
9837 | if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) { | ||
9838 | /* Sun decided not to put the necessary bits in the | ||
9839 | * NVRAM of their onboard tg3 parts :( | ||
9840 | */ | ||
9841 | strcpy(tp->board_part_number, "Sun 570X"); | ||
9842 | return; | ||
9843 | } | ||
9844 | |||
9845 | if (tg3_nvram_read_swab(tp, 0x0, &magic)) | 9868 | if (tg3_nvram_read_swab(tp, 0x0, &magic)) |
9846 | return; | 9869 | goto out_not_found; |
9847 | 9870 | ||
9848 | if (magic == TG3_EEPROM_MAGIC) { | 9871 | if (magic == TG3_EEPROM_MAGIC) { |
9849 | for (i = 0; i < 256; i += 4) { | 9872 | for (i = 0; i < 256; i += 4) { |
@@ -9874,6 +9897,9 @@ static void __devinit tg3_read_partno(struct tg3 *tp) | |||
9874 | break; | 9897 | break; |
9875 | msleep(1); | 9898 | msleep(1); |
9876 | } | 9899 | } |
9900 | if (!(tmp16 & 0x8000)) | ||
9901 | goto out_not_found; | ||
9902 | |||
9877 | pci_read_config_dword(tp->pdev, vpd_cap + PCI_VPD_DATA, | 9903 | pci_read_config_dword(tp->pdev, vpd_cap + PCI_VPD_DATA, |
9878 | &tmp); | 9904 | &tmp); |
9879 | tmp = cpu_to_le32(tmp); | 9905 | tmp = cpu_to_le32(tmp); |
@@ -9965,37 +9991,6 @@ static void __devinit tg3_read_fw_ver(struct tg3 *tp) | |||
9965 | } | 9991 | } |
9966 | } | 9992 | } |
9967 | 9993 | ||
9968 | #ifdef CONFIG_SPARC64 | ||
9969 | static int __devinit tg3_is_sun_570X(struct tg3 *tp) | ||
9970 | { | ||
9971 | struct pci_dev *pdev = tp->pdev; | ||
9972 | struct pcidev_cookie *pcp = pdev->sysdata; | ||
9973 | |||
9974 | if (pcp != NULL) { | ||
9975 | int node = pcp->prom_node; | ||
9976 | u32 venid; | ||
9977 | int err; | ||
9978 | |||
9979 | err = prom_getproperty(node, "subsystem-vendor-id", | ||
9980 | (char *) &venid, sizeof(venid)); | ||
9981 | if (err == 0 || err == -1) | ||
9982 | return 0; | ||
9983 | if (venid == PCI_VENDOR_ID_SUN) | ||
9984 | return 1; | ||
9985 | |||
9986 | /* TG3 chips onboard the SunBlade-2500 don't have the | ||
9987 | * subsystem-vendor-id set to PCI_VENDOR_ID_SUN but they | ||
9988 | * are distinguishable from non-Sun variants by being | ||
9989 | * named "network" by the firmware. Non-Sun cards will | ||
9990 | * show up as being named "ethernet". | ||
9991 | */ | ||
9992 | if (!strcmp(pcp->prom_name, "network")) | ||
9993 | return 1; | ||
9994 | } | ||
9995 | return 0; | ||
9996 | } | ||
9997 | #endif | ||
9998 | |||
9999 | static int __devinit tg3_get_invariants(struct tg3 *tp) | 9994 | static int __devinit tg3_get_invariants(struct tg3 *tp) |
10000 | { | 9995 | { |
10001 | static struct pci_device_id write_reorder_chipsets[] = { | 9996 | static struct pci_device_id write_reorder_chipsets[] = { |
@@ -10012,11 +10007,6 @@ static int __devinit tg3_get_invariants(struct tg3 *tp) | |||
10012 | u16 pci_cmd; | 10007 | u16 pci_cmd; |
10013 | int err; | 10008 | int err; |
10014 | 10009 | ||
10015 | #ifdef CONFIG_SPARC64 | ||
10016 | if (tg3_is_sun_570X(tp)) | ||
10017 | tp->tg3_flags2 |= TG3_FLG2_SUN_570X; | ||
10018 | #endif | ||
10019 | |||
10020 | /* Force memory write invalidate off. If we leave it on, | 10010 | /* Force memory write invalidate off. If we leave it on, |
10021 | * then on 5700_BX chips we have to enable a workaround. | 10011 | * then on 5700_BX chips we have to enable a workaround. |
10022 | * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary | 10012 | * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary |
@@ -10312,8 +10302,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp) | |||
10312 | if (tp->write32 == tg3_write_indirect_reg32 || | 10302 | if (tp->write32 == tg3_write_indirect_reg32 || |
10313 | ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) && | 10303 | ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) && |
10314 | (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 || | 10304 | (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 || |
10315 | GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) || | 10305 | GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701))) |
10316 | (tp->tg3_flags2 & TG3_FLG2_SUN_570X)) | ||
10317 | tp->tg3_flags |= TG3_FLAG_SRAM_USE_CONFIG; | 10306 | tp->tg3_flags |= TG3_FLAG_SRAM_USE_CONFIG; |
10318 | 10307 | ||
10319 | /* Get eeprom hw config before calling tg3_set_power_state(). | 10308 | /* Get eeprom hw config before calling tg3_set_power_state(). |
@@ -10594,8 +10583,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp) | |||
10594 | #endif | 10583 | #endif |
10595 | 10584 | ||
10596 | mac_offset = 0x7c; | 10585 | mac_offset = 0x7c; |
10597 | if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 && | 10586 | if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) || |
10598 | !(tp->tg3_flags & TG3_FLG2_SUN_570X)) || | ||
10599 | (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) { | 10587 | (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) { |
10600 | if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID) | 10588 | if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID) |
10601 | mac_offset = 0xcc; | 10589 | mac_offset = 0xcc; |
@@ -10622,8 +10610,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp) | |||
10622 | } | 10610 | } |
10623 | if (!addr_ok) { | 10611 | if (!addr_ok) { |
10624 | /* Next, try NVRAM. */ | 10612 | /* Next, try NVRAM. */ |
10625 | if (!(tp->tg3_flags & TG3_FLG2_SUN_570X) && | 10613 | if (!tg3_nvram_read(tp, mac_offset + 0, &hi) && |
10626 | !tg3_nvram_read(tp, mac_offset + 0, &hi) && | ||
10627 | !tg3_nvram_read(tp, mac_offset + 4, &lo)) { | 10614 | !tg3_nvram_read(tp, mac_offset + 4, &lo)) { |
10628 | dev->dev_addr[0] = ((hi >> 16) & 0xff); | 10615 | dev->dev_addr[0] = ((hi >> 16) & 0xff); |
10629 | dev->dev_addr[1] = ((hi >> 24) & 0xff); | 10616 | dev->dev_addr[1] = ((hi >> 24) & 0xff); |
@@ -11291,7 +11278,6 @@ static int __devinit tg3_init_one(struct pci_dev *pdev, | |||
11291 | SET_MODULE_OWNER(dev); | 11278 | SET_MODULE_OWNER(dev); |
11292 | SET_NETDEV_DEV(dev, &pdev->dev); | 11279 | SET_NETDEV_DEV(dev, &pdev->dev); |
11293 | 11280 | ||
11294 | dev->features |= NETIF_F_LLTX; | ||
11295 | #if TG3_VLAN_TAG_USED | 11281 | #if TG3_VLAN_TAG_USED |
11296 | dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; | 11282 | dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; |
11297 | dev->vlan_rx_register = tg3_vlan_rx_register; | 11283 | dev->vlan_rx_register = tg3_vlan_rx_register; |
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h index 0e29b885d449..8209da5dd15f 100644 --- a/drivers/net/tg3.h +++ b/drivers/net/tg3.h | |||
@@ -2074,12 +2074,22 @@ struct tg3 { | |||
2074 | 2074 | ||
2075 | /* SMP locking strategy: | 2075 | /* SMP locking strategy: |
2076 | * | 2076 | * |
2077 | * lock: Held during all operations except TX packet | 2077 | * lock: Held during reset, PHY access, timer, and when |
2078 | * processing. | 2078 | * updating tg3_flags and tg3_flags2. |
2079 | * | 2079 | * |
2080 | * tx_lock: Held during tg3_start_xmit and tg3_tx | 2080 | * tx_lock: Held during tg3_start_xmit and tg3_tx only |
2081 | * when calling netif_[start|stop]_queue. | ||
2082 | * tg3_start_xmit is protected by netif_tx_lock. | ||
2081 | * | 2083 | * |
2082 | * Both of these locks are to be held with BH safety. | 2084 | * Both of these locks are to be held with BH safety. |
2085 | * | ||
2086 | * Because the IRQ handler, tg3_poll, and tg3_start_xmit | ||
2087 | * are running lockless, it is necessary to completely | ||
2088 | * quiesce the chip with tg3_netif_stop and tg3_full_lock | ||
2089 | * before reconfiguring the device. | ||
2090 | * | ||
2091 | * indirect_lock: Held when accessing registers indirectly | ||
2092 | * with IRQ disabling. | ||
2083 | */ | 2093 | */ |
2084 | spinlock_t lock; | 2094 | spinlock_t lock; |
2085 | spinlock_t indirect_lock; | 2095 | spinlock_t indirect_lock; |
@@ -2155,11 +2165,7 @@ struct tg3 { | |||
2155 | #define TG3_FLAG_ENABLE_ASF 0x00000020 | 2165 | #define TG3_FLAG_ENABLE_ASF 0x00000020 |
2156 | #define TG3_FLAG_5701_REG_WRITE_BUG 0x00000040 | 2166 | #define TG3_FLAG_5701_REG_WRITE_BUG 0x00000040 |
2157 | #define TG3_FLAG_POLL_SERDES 0x00000080 | 2167 | #define TG3_FLAG_POLL_SERDES 0x00000080 |
2158 | #if defined(CONFIG_X86) | ||
2159 | #define TG3_FLAG_MBOX_WRITE_REORDER 0x00000100 | 2168 | #define TG3_FLAG_MBOX_WRITE_REORDER 0x00000100 |
2160 | #else | ||
2161 | #define TG3_FLAG_MBOX_WRITE_REORDER 0 /* disables code too */ | ||
2162 | #endif | ||
2163 | #define TG3_FLAG_PCIX_TARGET_HWBUG 0x00000200 | 2169 | #define TG3_FLAG_PCIX_TARGET_HWBUG 0x00000200 |
2164 | #define TG3_FLAG_WOL_SPEED_100MB 0x00000400 | 2170 | #define TG3_FLAG_WOL_SPEED_100MB 0x00000400 |
2165 | #define TG3_FLAG_WOL_ENABLE 0x00000800 | 2171 | #define TG3_FLAG_WOL_ENABLE 0x00000800 |
@@ -2172,6 +2178,7 @@ struct tg3 { | |||
2172 | #define TG3_FLAG_PCI_HIGH_SPEED 0x00040000 | 2178 | #define TG3_FLAG_PCI_HIGH_SPEED 0x00040000 |
2173 | #define TG3_FLAG_PCI_32BIT 0x00080000 | 2179 | #define TG3_FLAG_PCI_32BIT 0x00080000 |
2174 | #define TG3_FLAG_SRAM_USE_CONFIG 0x00100000 | 2180 | #define TG3_FLAG_SRAM_USE_CONFIG 0x00100000 |
2181 | #define TG3_FLAG_TX_RECOVERY_PENDING 0x00200000 | ||
2175 | #define TG3_FLAG_SERDES_WOL_CAP 0x00400000 | 2182 | #define TG3_FLAG_SERDES_WOL_CAP 0x00400000 |
2176 | #define TG3_FLAG_JUMBO_RING_ENABLE 0x00800000 | 2183 | #define TG3_FLAG_JUMBO_RING_ENABLE 0x00800000 |
2177 | #define TG3_FLAG_10_100_ONLY 0x01000000 | 2184 | #define TG3_FLAG_10_100_ONLY 0x01000000 |
@@ -2184,7 +2191,7 @@ struct tg3 { | |||
2184 | #define TG3_FLAG_INIT_COMPLETE 0x80000000 | 2191 | #define TG3_FLAG_INIT_COMPLETE 0x80000000 |
2185 | u32 tg3_flags2; | 2192 | u32 tg3_flags2; |
2186 | #define TG3_FLG2_RESTART_TIMER 0x00000001 | 2193 | #define TG3_FLG2_RESTART_TIMER 0x00000001 |
2187 | #define TG3_FLG2_SUN_570X 0x00000002 | 2194 | /* 0x00000002 available */ |
2188 | #define TG3_FLG2_NO_ETH_WIRE_SPEED 0x00000004 | 2195 | #define TG3_FLG2_NO_ETH_WIRE_SPEED 0x00000004 |
2189 | #define TG3_FLG2_IS_5788 0x00000008 | 2196 | #define TG3_FLG2_IS_5788 0x00000008 |
2190 | #define TG3_FLG2_MAX_RXPEND_64 0x00000010 | 2197 | #define TG3_FLG2_MAX_RXPEND_64 0x00000010 |
@@ -2216,6 +2223,7 @@ struct tg3 { | |||
2216 | #define TG3_FLG2_HW_TSO (TG3_FLG2_HW_TSO_1 | TG3_FLG2_HW_TSO_2) | 2223 | #define TG3_FLG2_HW_TSO (TG3_FLG2_HW_TSO_1 | TG3_FLG2_HW_TSO_2) |
2217 | #define TG3_FLG2_1SHOT_MSI 0x10000000 | 2224 | #define TG3_FLG2_1SHOT_MSI 0x10000000 |
2218 | #define TG3_FLG2_PHY_JITTER_BUG 0x20000000 | 2225 | #define TG3_FLG2_PHY_JITTER_BUG 0x20000000 |
2226 | #define TG3_FLG2_NO_FWARE_REPORTED 0x40000000 | ||
2219 | 2227 | ||
2220 | u32 split_mode_max_reqs; | 2228 | u32 split_mode_max_reqs; |
2221 | #define SPLIT_MODE_5704_MAX_REQ 3 | 2229 | #define SPLIT_MODE_5704_MAX_REQ 3 |
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c index b3cf11d32e24..cabdf894e21e 100644 --- a/drivers/net/tulip/tulip_core.c +++ b/drivers/net/tulip/tulip_core.c | |||
@@ -1483,14 +1483,6 @@ static int __devinit tulip_init_one (struct pci_dev *pdev, | |||
1483 | sa_offset = 2; /* Grrr, damn Matrox boards. */ | 1483 | sa_offset = 2; /* Grrr, damn Matrox boards. */ |
1484 | multiport_cnt = 4; | 1484 | multiport_cnt = 4; |
1485 | } | 1485 | } |
1486 | #ifdef CONFIG_DDB5476 | ||
1487 | if ((pdev->bus->number == 0) && (PCI_SLOT(pdev->devfn) == 6)) { | ||
1488 | /* DDB5476 MAC address in first EEPROM locations. */ | ||
1489 | sa_offset = 0; | ||
1490 | /* No media table either */ | ||
1491 | tp->flags &= ~HAS_MEDIA_TABLE; | ||
1492 | } | ||
1493 | #endif | ||
1494 | #ifdef CONFIG_DDB5477 | 1486 | #ifdef CONFIG_DDB5477 |
1495 | if ((pdev->bus->number == 0) && (PCI_SLOT(pdev->devfn) == 4)) { | 1487 | if ((pdev->bus->number == 0) && (PCI_SLOT(pdev->devfn) == 4)) { |
1496 | /* DDB5477 MAC address in first EEPROM locations. */ | 1488 | /* DDB5477 MAC address in first EEPROM locations. */ |
diff --git a/drivers/net/tulip/winbond-840.c b/drivers/net/tulip/winbond-840.c index 64ecf929d2ac..8fea2aa455d4 100644 --- a/drivers/net/tulip/winbond-840.c +++ b/drivers/net/tulip/winbond-840.c | |||
@@ -1605,11 +1605,11 @@ static void __devexit w840_remove1 (struct pci_dev *pdev) | |||
1605 | * - get_stats: | 1605 | * - get_stats: |
1606 | * spin_lock_irq(np->lock), doesn't touch hw if not present | 1606 | * spin_lock_irq(np->lock), doesn't touch hw if not present |
1607 | * - hard_start_xmit: | 1607 | * - hard_start_xmit: |
1608 | * netif_stop_queue + spin_unlock_wait(&dev->xmit_lock); | 1608 | * synchronize_irq + netif_tx_disable; |
1609 | * - tx_timeout: | 1609 | * - tx_timeout: |
1610 | * netif_device_detach + spin_unlock_wait(&dev->xmit_lock); | 1610 | * netif_device_detach + netif_tx_disable; |
1611 | * - set_multicast_list | 1611 | * - set_multicast_list |
1612 | * netif_device_detach + spin_unlock_wait(&dev->xmit_lock); | 1612 | * netif_device_detach + netif_tx_disable; |
1613 | * - interrupt handler | 1613 | * - interrupt handler |
1614 | * doesn't touch hw if not present, synchronize_irq waits for | 1614 | * doesn't touch hw if not present, synchronize_irq waits for |
1615 | * running instances of the interrupt handler. | 1615 | * running instances of the interrupt handler. |
@@ -1635,12 +1635,11 @@ static int w840_suspend (struct pci_dev *pdev, pm_message_t state) | |||
1635 | netif_device_detach(dev); | 1635 | netif_device_detach(dev); |
1636 | update_csr6(dev, 0); | 1636 | update_csr6(dev, 0); |
1637 | iowrite32(0, ioaddr + IntrEnable); | 1637 | iowrite32(0, ioaddr + IntrEnable); |
1638 | netif_stop_queue(dev); | ||
1639 | spin_unlock_irq(&np->lock); | 1638 | spin_unlock_irq(&np->lock); |
1640 | 1639 | ||
1641 | spin_unlock_wait(&dev->xmit_lock); | ||
1642 | synchronize_irq(dev->irq); | 1640 | synchronize_irq(dev->irq); |
1643 | 1641 | netif_tx_disable(dev); | |
1642 | |||
1644 | np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff; | 1643 | np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff; |
1645 | 1644 | ||
1646 | /* no more hardware accesses behind this line. */ | 1645 | /* no more hardware accesses behind this line. */ |
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c index ed1f837c8fda..2eb6b5f9ba0d 100644 --- a/drivers/net/via-velocity.c +++ b/drivers/net/via-velocity.c | |||
@@ -1899,6 +1899,13 @@ static int velocity_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1899 | 1899 | ||
1900 | int pktlen = skb->len; | 1900 | int pktlen = skb->len; |
1901 | 1901 | ||
1902 | #ifdef VELOCITY_ZERO_COPY_SUPPORT | ||
1903 | if (skb_shinfo(skb)->nr_frags > 6 && __skb_linearize(skb)) { | ||
1904 | kfree_skb(skb); | ||
1905 | return 0; | ||
1906 | } | ||
1907 | #endif | ||
1908 | |||
1902 | spin_lock_irqsave(&vptr->lock, flags); | 1909 | spin_lock_irqsave(&vptr->lock, flags); |
1903 | 1910 | ||
1904 | index = vptr->td_curr[qnum]; | 1911 | index = vptr->td_curr[qnum]; |
@@ -1914,8 +1921,6 @@ static int velocity_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1914 | */ | 1921 | */ |
1915 | if (pktlen < ETH_ZLEN) { | 1922 | if (pktlen < ETH_ZLEN) { |
1916 | /* Cannot occur until ZC support */ | 1923 | /* Cannot occur until ZC support */ |
1917 | if(skb_linearize(skb, GFP_ATOMIC)) | ||
1918 | return 0; | ||
1919 | pktlen = ETH_ZLEN; | 1924 | pktlen = ETH_ZLEN; |
1920 | memcpy(tdinfo->buf, skb->data, skb->len); | 1925 | memcpy(tdinfo->buf, skb->data, skb->len); |
1921 | memset(tdinfo->buf + skb->len, 0, ETH_ZLEN - skb->len); | 1926 | memset(tdinfo->buf + skb->len, 0, ETH_ZLEN - skb->len); |
@@ -1933,7 +1938,6 @@ static int velocity_xmit(struct sk_buff *skb, struct net_device *dev) | |||
1933 | int nfrags = skb_shinfo(skb)->nr_frags; | 1938 | int nfrags = skb_shinfo(skb)->nr_frags; |
1934 | tdinfo->skb = skb; | 1939 | tdinfo->skb = skb; |
1935 | if (nfrags > 6) { | 1940 | if (nfrags > 6) { |
1936 | skb_linearize(skb, GFP_ATOMIC); | ||
1937 | memcpy(tdinfo->buf, skb->data, skb->len); | 1941 | memcpy(tdinfo->buf, skb->data, skb->len); |
1938 | tdinfo->skb_dma[0] = tdinfo->buf_dma; | 1942 | tdinfo->skb_dma[0] = tdinfo->buf_dma; |
1939 | td_ptr->tdesc0.pktsize = | 1943 | td_ptr->tdesc0.pktsize = |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx.h b/drivers/net/wireless/bcm43xx/bcm43xx.h index e66fdb1f3cfd..d8f917c21ea4 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx.h +++ b/drivers/net/wireless/bcm43xx/bcm43xx.h | |||
@@ -636,6 +636,17 @@ struct bcm43xx_key { | |||
636 | u8 algorithm; | 636 | u8 algorithm; |
637 | }; | 637 | }; |
638 | 638 | ||
639 | /* Driver initialization status. */ | ||
640 | enum { | ||
641 | BCM43xx_STAT_UNINIT, /* Uninitialized. */ | ||
642 | BCM43xx_STAT_INITIALIZING, /* init_board() in progress. */ | ||
643 | BCM43xx_STAT_INITIALIZED, /* Fully operational. */ | ||
644 | BCM43xx_STAT_SHUTTINGDOWN, /* free_board() in progress. */ | ||
645 | BCM43xx_STAT_RESTARTING, /* controller_restart() called. */ | ||
646 | }; | ||
647 | #define bcm43xx_status(bcm) atomic_read(&(bcm)->init_status) | ||
648 | #define bcm43xx_set_status(bcm, stat) atomic_set(&(bcm)->init_status, (stat)) | ||
649 | |||
639 | struct bcm43xx_private { | 650 | struct bcm43xx_private { |
640 | struct ieee80211_device *ieee; | 651 | struct ieee80211_device *ieee; |
641 | struct ieee80211softmac_device *softmac; | 652 | struct ieee80211softmac_device *softmac; |
@@ -646,18 +657,17 @@ struct bcm43xx_private { | |||
646 | 657 | ||
647 | void __iomem *mmio_addr; | 658 | void __iomem *mmio_addr; |
648 | 659 | ||
649 | /* Do not use the lock directly. Use the bcm43xx_lock* helper | 660 | /* Locking, see "theory of locking" text below. */ |
650 | * functions, to be MMIO-safe. */ | 661 | spinlock_t irq_lock; |
651 | spinlock_t _lock; | 662 | struct mutex mutex; |
652 | 663 | ||
653 | /* Driver status flags. */ | 664 | /* Driver initialization status BCM43xx_STAT_*** */ |
654 | u32 initialized:1, /* init_board() succeed */ | 665 | atomic_t init_status; |
655 | was_initialized:1, /* for PCI suspend/resume. */ | 666 | |
656 | shutting_down:1, /* free_board() in progress */ | 667 | u16 was_initialized:1, /* for PCI suspend/resume. */ |
657 | __using_pio:1, /* Internal, use bcm43xx_using_pio(). */ | 668 | __using_pio:1, /* Internal, use bcm43xx_using_pio(). */ |
658 | bad_frames_preempt:1, /* Use "Bad Frames Preemption" (default off) */ | 669 | bad_frames_preempt:1, /* Use "Bad Frames Preemption" (default off) */ |
659 | reg124_set_0x4:1, /* Some variable to keep track of IRQ stuff. */ | 670 | reg124_set_0x4:1, /* Some variable to keep track of IRQ stuff. */ |
660 | powersaving:1, /* TRUE if we are in PowerSaving mode. FALSE otherwise. */ | ||
661 | short_preamble:1, /* TRUE, if short preamble is enabled. */ | 671 | short_preamble:1, /* TRUE, if short preamble is enabled. */ |
662 | firmware_norelease:1; /* Do not release the firmware. Used on suspend. */ | 672 | firmware_norelease:1; /* Do not release the firmware. Used on suspend. */ |
663 | 673 | ||
@@ -721,7 +731,7 @@ struct bcm43xx_private { | |||
721 | struct tasklet_struct isr_tasklet; | 731 | struct tasklet_struct isr_tasklet; |
722 | 732 | ||
723 | /* Periodic tasks */ | 733 | /* Periodic tasks */ |
724 | struct timer_list periodic_tasks; | 734 | struct work_struct periodic_work; |
725 | unsigned int periodic_state; | 735 | unsigned int periodic_state; |
726 | 736 | ||
727 | struct work_struct restart_work; | 737 | struct work_struct restart_work; |
@@ -746,21 +756,55 @@ struct bcm43xx_private { | |||
746 | #endif | 756 | #endif |
747 | }; | 757 | }; |
748 | 758 | ||
749 | /* bcm43xx_(un)lock() protect struct bcm43xx_private. | 759 | |
750 | * Note that _NO_ MMIO writes are allowed. If you want to | 760 | /* *** THEORY OF LOCKING *** |
751 | * write to the device through MMIO in the critical section, use | 761 | * |
752 | * the *_mmio lock functions. | 762 | * We have two different locks in the bcm43xx driver. |
753 | * MMIO read-access is allowed, though. | 763 | * => bcm->mutex: General sleeping mutex. Protects struct bcm43xx_private |
754 | */ | 764 | * and the device registers. |
755 | #define bcm43xx_lock(bcm, flags) spin_lock_irqsave(&(bcm)->_lock, flags) | 765 | * => bcm->irq_lock: IRQ spinlock. Protects against IRQ handler concurrency. |
756 | #define bcm43xx_unlock(bcm, flags) spin_unlock_irqrestore(&(bcm)->_lock, flags) | 766 | * |
757 | /* bcm43xx_(un)lock_mmio() protect struct bcm43xx_private and MMIO. | 767 | * We have three types of helper function pairs to utilize these locks. |
758 | * MMIO write-access to the device is allowed. | 768 | * (Always use the helper functions.) |
759 | * All MMIO writes are flushed on unlock, so it is guaranteed to not | 769 | * 1) bcm43xx_{un}lock_noirq(): |
760 | * interfere with other threads writing MMIO registers. | 770 | * Takes bcm->mutex. Does _not_ protect against IRQ concurrency, |
771 | * so it is almost always unsafe, if device IRQs are enabled. | ||
772 | * So only use this, if device IRQs are masked. | ||
773 | * Locking may sleep. | ||
774 | * You can sleep within the critical section. | ||
775 | * 2) bcm43xx_{un}lock_irqonly(): | ||
776 | * Takes bcm->irq_lock. Does _not_ protect against | ||
777 | * bcm43xx_lock_noirq() critical sections. | ||
778 | * Does only protect against the IRQ handler path and other | ||
779 | * irqonly() critical sections. | ||
780 | * Locking does not sleep. | ||
781 | * You must not sleep within the critical section. | ||
782 | * 3) bcm43xx_{un}lock_irqsafe(): | ||
783 | * This is the cummulative lock and takes both, mutex and irq_lock. | ||
784 | * Protects against noirq() and irqonly() critical sections (and | ||
785 | * the IRQ handler path). | ||
786 | * Locking may sleep. | ||
787 | * You must not sleep within the critical section. | ||
761 | */ | 788 | */ |
762 | #define bcm43xx_lock_mmio(bcm, flags) bcm43xx_lock(bcm, flags) | 789 | |
763 | #define bcm43xx_unlock_mmio(bcm, flags) do { mmiowb(); bcm43xx_unlock(bcm, flags); } while (0) | 790 | /* Lock type 1 */ |
791 | #define bcm43xx_lock_noirq(bcm) mutex_lock(&(bcm)->mutex) | ||
792 | #define bcm43xx_unlock_noirq(bcm) mutex_unlock(&(bcm)->mutex) | ||
793 | /* Lock type 2 */ | ||
794 | #define bcm43xx_lock_irqonly(bcm, flags) \ | ||
795 | spin_lock_irqsave(&(bcm)->irq_lock, flags) | ||
796 | #define bcm43xx_unlock_irqonly(bcm, flags) \ | ||
797 | spin_unlock_irqrestore(&(bcm)->irq_lock, flags) | ||
798 | /* Lock type 3 */ | ||
799 | #define bcm43xx_lock_irqsafe(bcm, flags) do { \ | ||
800 | bcm43xx_lock_noirq(bcm); \ | ||
801 | bcm43xx_lock_irqonly(bcm, flags); \ | ||
802 | } while (0) | ||
803 | #define bcm43xx_unlock_irqsafe(bcm, flags) do { \ | ||
804 | bcm43xx_unlock_irqonly(bcm, flags); \ | ||
805 | bcm43xx_unlock_noirq(bcm); \ | ||
806 | } while (0) | ||
807 | |||
764 | 808 | ||
765 | static inline | 809 | static inline |
766 | struct bcm43xx_private * bcm43xx_priv(struct net_device *dev) | 810 | struct bcm43xx_private * bcm43xx_priv(struct net_device *dev) |
@@ -843,16 +887,6 @@ struct bcm43xx_radioinfo * bcm43xx_current_radio(struct bcm43xx_private *bcm) | |||
843 | return &(bcm->core_80211_ext[bcm->current_80211_core_idx].radio); | 887 | return &(bcm->core_80211_ext[bcm->current_80211_core_idx].radio); |
844 | } | 888 | } |
845 | 889 | ||
846 | /* Are we running in init_board() context? */ | ||
847 | static inline | ||
848 | int bcm43xx_is_initializing(struct bcm43xx_private *bcm) | ||
849 | { | ||
850 | if (bcm->initialized) | ||
851 | return 0; | ||
852 | if (bcm->shutting_down) | ||
853 | return 0; | ||
854 | return 1; | ||
855 | } | ||
856 | 890 | ||
857 | static inline | 891 | static inline |
858 | struct bcm43xx_lopair * bcm43xx_get_lopair(struct bcm43xx_phyinfo *phy, | 892 | struct bcm43xx_lopair * bcm43xx_get_lopair(struct bcm43xx_phyinfo *phy, |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c b/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c index 7497fb16076e..ce2e40b29b4f 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c +++ b/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c | |||
@@ -77,8 +77,8 @@ static ssize_t devinfo_read_file(struct file *file, char __user *userbuf, | |||
77 | 77 | ||
78 | down(&big_buffer_sem); | 78 | down(&big_buffer_sem); |
79 | 79 | ||
80 | bcm43xx_lock_mmio(bcm, flags); | 80 | bcm43xx_lock_irqsafe(bcm, flags); |
81 | if (!bcm->initialized) { | 81 | if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED) { |
82 | fappend("Board not initialized.\n"); | 82 | fappend("Board not initialized.\n"); |
83 | goto out; | 83 | goto out; |
84 | } | 84 | } |
@@ -121,7 +121,7 @@ static ssize_t devinfo_read_file(struct file *file, char __user *userbuf, | |||
121 | fappend("\n"); | 121 | fappend("\n"); |
122 | 122 | ||
123 | out: | 123 | out: |
124 | bcm43xx_unlock_mmio(bcm, flags); | 124 | bcm43xx_unlock_irqsafe(bcm, flags); |
125 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); | 125 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
126 | up(&big_buffer_sem); | 126 | up(&big_buffer_sem); |
127 | return res; | 127 | return res; |
@@ -159,8 +159,8 @@ static ssize_t spromdump_read_file(struct file *file, char __user *userbuf, | |||
159 | unsigned long flags; | 159 | unsigned long flags; |
160 | 160 | ||
161 | down(&big_buffer_sem); | 161 | down(&big_buffer_sem); |
162 | bcm43xx_lock_mmio(bcm, flags); | 162 | bcm43xx_lock_irqsafe(bcm, flags); |
163 | if (!bcm->initialized) { | 163 | if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED) { |
164 | fappend("Board not initialized.\n"); | 164 | fappend("Board not initialized.\n"); |
165 | goto out; | 165 | goto out; |
166 | } | 166 | } |
@@ -169,7 +169,7 @@ static ssize_t spromdump_read_file(struct file *file, char __user *userbuf, | |||
169 | fappend("boardflags: 0x%04x\n", bcm->sprom.boardflags); | 169 | fappend("boardflags: 0x%04x\n", bcm->sprom.boardflags); |
170 | 170 | ||
171 | out: | 171 | out: |
172 | bcm43xx_unlock_mmio(bcm, flags); | 172 | bcm43xx_unlock_irqsafe(bcm, flags); |
173 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); | 173 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
174 | up(&big_buffer_sem); | 174 | up(&big_buffer_sem); |
175 | return res; | 175 | return res; |
@@ -188,8 +188,8 @@ static ssize_t tsf_read_file(struct file *file, char __user *userbuf, | |||
188 | u64 tsf; | 188 | u64 tsf; |
189 | 189 | ||
190 | down(&big_buffer_sem); | 190 | down(&big_buffer_sem); |
191 | bcm43xx_lock_mmio(bcm, flags); | 191 | bcm43xx_lock_irqsafe(bcm, flags); |
192 | if (!bcm->initialized) { | 192 | if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED) { |
193 | fappend("Board not initialized.\n"); | 193 | fappend("Board not initialized.\n"); |
194 | goto out; | 194 | goto out; |
195 | } | 195 | } |
@@ -199,7 +199,7 @@ static ssize_t tsf_read_file(struct file *file, char __user *userbuf, | |||
199 | (unsigned int)(tsf & 0xFFFFFFFFULL)); | 199 | (unsigned int)(tsf & 0xFFFFFFFFULL)); |
200 | 200 | ||
201 | out: | 201 | out: |
202 | bcm43xx_unlock_mmio(bcm, flags); | 202 | bcm43xx_unlock_irqsafe(bcm, flags); |
203 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); | 203 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
204 | up(&big_buffer_sem); | 204 | up(&big_buffer_sem); |
205 | return res; | 205 | return res; |
@@ -221,8 +221,8 @@ static ssize_t tsf_write_file(struct file *file, const char __user *user_buf, | |||
221 | res = -EFAULT; | 221 | res = -EFAULT; |
222 | goto out_up; | 222 | goto out_up; |
223 | } | 223 | } |
224 | bcm43xx_lock_mmio(bcm, flags); | 224 | bcm43xx_lock_irqsafe(bcm, flags); |
225 | if (!bcm->initialized) { | 225 | if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED) { |
226 | printk(KERN_INFO PFX "debugfs: Board not initialized.\n"); | 226 | printk(KERN_INFO PFX "debugfs: Board not initialized.\n"); |
227 | res = -EFAULT; | 227 | res = -EFAULT; |
228 | goto out_unlock; | 228 | goto out_unlock; |
@@ -233,10 +233,11 @@ static ssize_t tsf_write_file(struct file *file, const char __user *user_buf, | |||
233 | goto out_unlock; | 233 | goto out_unlock; |
234 | } | 234 | } |
235 | bcm43xx_tsf_write(bcm, tsf); | 235 | bcm43xx_tsf_write(bcm, tsf); |
236 | mmiowb(); | ||
236 | res = buf_size; | 237 | res = buf_size; |
237 | 238 | ||
238 | out_unlock: | 239 | out_unlock: |
239 | bcm43xx_unlock_mmio(bcm, flags); | 240 | bcm43xx_unlock_irqsafe(bcm, flags); |
240 | out_up: | 241 | out_up: |
241 | up(&big_buffer_sem); | 242 | up(&big_buffer_sem); |
242 | return res; | 243 | return res; |
@@ -257,7 +258,7 @@ static ssize_t txstat_read_file(struct file *file, char __user *userbuf, | |||
257 | int i, cnt, j = 0; | 258 | int i, cnt, j = 0; |
258 | 259 | ||
259 | down(&big_buffer_sem); | 260 | down(&big_buffer_sem); |
260 | bcm43xx_lock(bcm, flags); | 261 | bcm43xx_lock_irqsafe(bcm, flags); |
261 | 262 | ||
262 | fappend("Last %d logged xmitstatus blobs (Latest first):\n\n", | 263 | fappend("Last %d logged xmitstatus blobs (Latest first):\n\n", |
263 | BCM43xx_NR_LOGGED_XMITSTATUS); | 264 | BCM43xx_NR_LOGGED_XMITSTATUS); |
@@ -293,14 +294,14 @@ static ssize_t txstat_read_file(struct file *file, char __user *userbuf, | |||
293 | i = BCM43xx_NR_LOGGED_XMITSTATUS - 1; | 294 | i = BCM43xx_NR_LOGGED_XMITSTATUS - 1; |
294 | } | 295 | } |
295 | 296 | ||
296 | bcm43xx_unlock(bcm, flags); | 297 | bcm43xx_unlock_irqsafe(bcm, flags); |
297 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); | 298 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
298 | bcm43xx_lock(bcm, flags); | 299 | bcm43xx_lock_irqsafe(bcm, flags); |
299 | if (*ppos == pos) { | 300 | if (*ppos == pos) { |
300 | /* Done. Drop the copied data. */ | 301 | /* Done. Drop the copied data. */ |
301 | e->xmitstatus_printing = 0; | 302 | e->xmitstatus_printing = 0; |
302 | } | 303 | } |
303 | bcm43xx_unlock(bcm, flags); | 304 | bcm43xx_unlock_irqsafe(bcm, flags); |
304 | up(&big_buffer_sem); | 305 | up(&big_buffer_sem); |
305 | return res; | 306 | return res; |
306 | } | 307 | } |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_leds.c b/drivers/net/wireless/bcm43xx/bcm43xx_leds.c index 4b2c02c0b31e..ec80692d638a 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_leds.c +++ b/drivers/net/wireless/bcm43xx/bcm43xx_leds.c | |||
@@ -51,12 +51,12 @@ static void bcm43xx_led_blink(unsigned long d) | |||
51 | struct bcm43xx_private *bcm = led->bcm; | 51 | struct bcm43xx_private *bcm = led->bcm; |
52 | unsigned long flags; | 52 | unsigned long flags; |
53 | 53 | ||
54 | bcm43xx_lock_mmio(bcm, flags); | 54 | bcm43xx_lock_irqonly(bcm, flags); |
55 | if (led->blink_interval) { | 55 | if (led->blink_interval) { |
56 | bcm43xx_led_changestate(led); | 56 | bcm43xx_led_changestate(led); |
57 | mod_timer(&led->blink_timer, jiffies + led->blink_interval); | 57 | mod_timer(&led->blink_timer, jiffies + led->blink_interval); |
58 | } | 58 | } |
59 | bcm43xx_unlock_mmio(bcm, flags); | 59 | bcm43xx_unlock_irqonly(bcm, flags); |
60 | } | 60 | } |
61 | 61 | ||
62 | static void bcm43xx_led_blink_start(struct bcm43xx_led *led, | 62 | static void bcm43xx_led_blink_start(struct bcm43xx_led *led, |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_main.c b/drivers/net/wireless/bcm43xx/bcm43xx_main.c index 736dde96c4a3..085d7857fe31 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_main.c +++ b/drivers/net/wireless/bcm43xx/bcm43xx_main.c | |||
@@ -498,20 +498,31 @@ static inline u32 bcm43xx_interrupt_disable(struct bcm43xx_private *bcm, u32 mas | |||
498 | return old_mask; | 498 | return old_mask; |
499 | } | 499 | } |
500 | 500 | ||
501 | /* Synchronize IRQ top- and bottom-half. | ||
502 | * IRQs must be masked before calling this. | ||
503 | * This must not be called with the irq_lock held. | ||
504 | */ | ||
505 | static void bcm43xx_synchronize_irq(struct bcm43xx_private *bcm) | ||
506 | { | ||
507 | synchronize_irq(bcm->irq); | ||
508 | tasklet_disable(&bcm->isr_tasklet); | ||
509 | } | ||
510 | |||
501 | /* Make sure we don't receive more data from the device. */ | 511 | /* Make sure we don't receive more data from the device. */ |
502 | static int bcm43xx_disable_interrupts_sync(struct bcm43xx_private *bcm, u32 *oldstate) | 512 | static int bcm43xx_disable_interrupts_sync(struct bcm43xx_private *bcm, u32 *oldstate) |
503 | { | 513 | { |
504 | u32 old; | ||
505 | unsigned long flags; | 514 | unsigned long flags; |
515 | u32 old; | ||
506 | 516 | ||
507 | bcm43xx_lock_mmio(bcm, flags); | 517 | bcm43xx_lock_irqonly(bcm, flags); |
508 | if (bcm43xx_is_initializing(bcm) || bcm->shutting_down) { | 518 | if (unlikely(bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED)) { |
509 | bcm43xx_unlock_mmio(bcm, flags); | 519 | bcm43xx_unlock_irqonly(bcm, flags); |
510 | return -EBUSY; | 520 | return -EBUSY; |
511 | } | 521 | } |
512 | old = bcm43xx_interrupt_disable(bcm, BCM43xx_IRQ_ALL); | 522 | old = bcm43xx_interrupt_disable(bcm, BCM43xx_IRQ_ALL); |
513 | tasklet_disable(&bcm->isr_tasklet); | 523 | bcm43xx_unlock_irqonly(bcm, flags); |
514 | bcm43xx_unlock_mmio(bcm, flags); | 524 | bcm43xx_synchronize_irq(bcm); |
525 | |||
515 | if (oldstate) | 526 | if (oldstate) |
516 | *oldstate = old; | 527 | *oldstate = old; |
517 | 528 | ||
@@ -1389,7 +1400,7 @@ void bcm43xx_wireless_core_reset(struct bcm43xx_private *bcm, int connect_phy) | |||
1389 | bcm43xx_dmacontroller_rx_reset(bcm, BCM43xx_MMIO_DMA4_BASE); | 1400 | bcm43xx_dmacontroller_rx_reset(bcm, BCM43xx_MMIO_DMA4_BASE); |
1390 | #endif | 1401 | #endif |
1391 | } | 1402 | } |
1392 | if (bcm->shutting_down) { | 1403 | if (bcm43xx_status(bcm) == BCM43xx_STAT_SHUTTINGDOWN) { |
1393 | bcm43xx_write32(bcm, BCM43xx_MMIO_STATUS_BITFIELD, | 1404 | bcm43xx_write32(bcm, BCM43xx_MMIO_STATUS_BITFIELD, |
1394 | bcm43xx_read32(bcm, BCM43xx_MMIO_STATUS_BITFIELD) | 1405 | bcm43xx_read32(bcm, BCM43xx_MMIO_STATUS_BITFIELD) |
1395 | & ~(BCM43xx_SBF_MAC_ENABLED | 0x00000002)); | 1406 | & ~(BCM43xx_SBF_MAC_ENABLED | 0x00000002)); |
@@ -1709,7 +1720,7 @@ static void bcm43xx_interrupt_tasklet(struct bcm43xx_private *bcm) | |||
1709 | # define bcmirq_handled(irq) do { /* nothing */ } while (0) | 1720 | # define bcmirq_handled(irq) do { /* nothing */ } while (0) |
1710 | #endif /* CONFIG_BCM43XX_DEBUG*/ | 1721 | #endif /* CONFIG_BCM43XX_DEBUG*/ |
1711 | 1722 | ||
1712 | bcm43xx_lock_mmio(bcm, flags); | 1723 | bcm43xx_lock_irqonly(bcm, flags); |
1713 | reason = bcm->irq_reason; | 1724 | reason = bcm->irq_reason; |
1714 | dma_reason[0] = bcm->dma_reason[0]; | 1725 | dma_reason[0] = bcm->dma_reason[0]; |
1715 | dma_reason[1] = bcm->dma_reason[1]; | 1726 | dma_reason[1] = bcm->dma_reason[1]; |
@@ -1734,7 +1745,8 @@ static void bcm43xx_interrupt_tasklet(struct bcm43xx_private *bcm) | |||
1734 | dma_reason[0], dma_reason[1], | 1745 | dma_reason[0], dma_reason[1], |
1735 | dma_reason[2], dma_reason[3]); | 1746 | dma_reason[2], dma_reason[3]); |
1736 | bcm43xx_controller_restart(bcm, "DMA error"); | 1747 | bcm43xx_controller_restart(bcm, "DMA error"); |
1737 | bcm43xx_unlock_mmio(bcm, flags); | 1748 | mmiowb(); |
1749 | bcm43xx_unlock_irqonly(bcm, flags); | ||
1738 | return; | 1750 | return; |
1739 | } | 1751 | } |
1740 | if (unlikely((dma_reason[0] & BCM43xx_DMAIRQ_NONFATALMASK) | | 1752 | if (unlikely((dma_reason[0] & BCM43xx_DMAIRQ_NONFATALMASK) | |
@@ -1821,7 +1833,8 @@ static void bcm43xx_interrupt_tasklet(struct bcm43xx_private *bcm) | |||
1821 | if (!modparam_noleds) | 1833 | if (!modparam_noleds) |
1822 | bcm43xx_leds_update(bcm, activity); | 1834 | bcm43xx_leds_update(bcm, activity); |
1823 | bcm43xx_interrupt_enable(bcm, bcm->irq_savedstate); | 1835 | bcm43xx_interrupt_enable(bcm, bcm->irq_savedstate); |
1824 | bcm43xx_unlock_mmio(bcm, flags); | 1836 | mmiowb(); |
1837 | bcm43xx_unlock_irqonly(bcm, flags); | ||
1825 | } | 1838 | } |
1826 | 1839 | ||
1827 | static void pio_irq_workaround(struct bcm43xx_private *bcm, | 1840 | static void pio_irq_workaround(struct bcm43xx_private *bcm, |
@@ -1870,7 +1883,7 @@ static irqreturn_t bcm43xx_interrupt_handler(int irq, void *dev_id, struct pt_re | |||
1870 | if (!bcm) | 1883 | if (!bcm) |
1871 | return IRQ_NONE; | 1884 | return IRQ_NONE; |
1872 | 1885 | ||
1873 | spin_lock(&bcm->_lock); | 1886 | spin_lock(&bcm->irq_lock); |
1874 | 1887 | ||
1875 | reason = bcm43xx_read32(bcm, BCM43xx_MMIO_GEN_IRQ_REASON); | 1888 | reason = bcm43xx_read32(bcm, BCM43xx_MMIO_GEN_IRQ_REASON); |
1876 | if (reason == 0xffffffff) { | 1889 | if (reason == 0xffffffff) { |
@@ -1899,7 +1912,7 @@ static irqreturn_t bcm43xx_interrupt_handler(int irq, void *dev_id, struct pt_re | |||
1899 | * completely, but some careful work is needed to fix this. I think it | 1912 | * completely, but some careful work is needed to fix this. I think it |
1900 | * is best to stay with this cheap workaround for now... . | 1913 | * is best to stay with this cheap workaround for now... . |
1901 | */ | 1914 | */ |
1902 | if (likely(bcm->initialized)) { | 1915 | if (likely(bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED)) { |
1903 | /* disable all IRQs. They are enabled again in the bottom half. */ | 1916 | /* disable all IRQs. They are enabled again in the bottom half. */ |
1904 | bcm->irq_savedstate = bcm43xx_interrupt_disable(bcm, BCM43xx_IRQ_ALL); | 1917 | bcm->irq_savedstate = bcm43xx_interrupt_disable(bcm, BCM43xx_IRQ_ALL); |
1905 | /* save the reason code and call our bottom half. */ | 1918 | /* save the reason code and call our bottom half. */ |
@@ -1909,7 +1922,7 @@ static irqreturn_t bcm43xx_interrupt_handler(int irq, void *dev_id, struct pt_re | |||
1909 | 1922 | ||
1910 | out: | 1923 | out: |
1911 | mmiowb(); | 1924 | mmiowb(); |
1912 | spin_unlock(&bcm->_lock); | 1925 | spin_unlock(&bcm->irq_lock); |
1913 | 1926 | ||
1914 | return ret; | 1927 | return ret; |
1915 | } | 1928 | } |
@@ -2133,6 +2146,13 @@ out: | |||
2133 | return err; | 2146 | return err; |
2134 | } | 2147 | } |
2135 | 2148 | ||
2149 | #ifdef CONFIG_BCM947XX | ||
2150 | static struct pci_device_id bcm43xx_47xx_ids[] = { | ||
2151 | { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4324) }, | ||
2152 | { 0 } | ||
2153 | }; | ||
2154 | #endif | ||
2155 | |||
2136 | static int bcm43xx_initialize_irq(struct bcm43xx_private *bcm) | 2156 | static int bcm43xx_initialize_irq(struct bcm43xx_private *bcm) |
2137 | { | 2157 | { |
2138 | int res; | 2158 | int res; |
@@ -2142,11 +2162,15 @@ static int bcm43xx_initialize_irq(struct bcm43xx_private *bcm) | |||
2142 | bcm->irq = bcm->pci_dev->irq; | 2162 | bcm->irq = bcm->pci_dev->irq; |
2143 | #ifdef CONFIG_BCM947XX | 2163 | #ifdef CONFIG_BCM947XX |
2144 | if (bcm->pci_dev->bus->number == 0) { | 2164 | if (bcm->pci_dev->bus->number == 0) { |
2145 | struct pci_dev *d = NULL; | 2165 | struct pci_dev *d; |
2146 | /* FIXME: we will probably need more device IDs here... */ | 2166 | struct pci_device_id *id; |
2147 | d = pci_find_device(PCI_VENDOR_ID_BROADCOM, 0x4324, NULL); | 2167 | for (id = bcm43xx_47xx_ids; id->vendor; id++) { |
2148 | if (d != NULL) { | 2168 | d = pci_get_device(id->vendor, id->device, NULL); |
2149 | bcm->irq = d->irq; | 2169 | if (d != NULL) { |
2170 | bcm->irq = d->irq; | ||
2171 | pci_dev_put(d); | ||
2172 | break; | ||
2173 | } | ||
2150 | } | 2174 | } |
2151 | } | 2175 | } |
2152 | #endif | 2176 | #endif |
@@ -3106,15 +3130,10 @@ static void bcm43xx_periodic_every15sec(struct bcm43xx_private *bcm) | |||
3106 | //TODO for APHY (temperature?) | 3130 | //TODO for APHY (temperature?) |
3107 | } | 3131 | } |
3108 | 3132 | ||
3109 | static void bcm43xx_periodic_task_handler(unsigned long d) | 3133 | static void do_periodic_work(struct bcm43xx_private *bcm) |
3110 | { | 3134 | { |
3111 | struct bcm43xx_private *bcm = (struct bcm43xx_private *)d; | ||
3112 | unsigned long flags; | ||
3113 | unsigned int state; | 3135 | unsigned int state; |
3114 | 3136 | ||
3115 | bcm43xx_lock_mmio(bcm, flags); | ||
3116 | |||
3117 | assert(bcm->initialized); | ||
3118 | state = bcm->periodic_state; | 3137 | state = bcm->periodic_state; |
3119 | if (state % 8 == 0) | 3138 | if (state % 8 == 0) |
3120 | bcm43xx_periodic_every120sec(bcm); | 3139 | bcm43xx_periodic_every120sec(bcm); |
@@ -3122,29 +3141,93 @@ static void bcm43xx_periodic_task_handler(unsigned long d) | |||
3122 | bcm43xx_periodic_every60sec(bcm); | 3141 | bcm43xx_periodic_every60sec(bcm); |
3123 | if (state % 2 == 0) | 3142 | if (state % 2 == 0) |
3124 | bcm43xx_periodic_every30sec(bcm); | 3143 | bcm43xx_periodic_every30sec(bcm); |
3125 | bcm43xx_periodic_every15sec(bcm); | 3144 | if (state % 1 == 0) |
3145 | bcm43xx_periodic_every15sec(bcm); | ||
3126 | bcm->periodic_state = state + 1; | 3146 | bcm->periodic_state = state + 1; |
3127 | 3147 | ||
3128 | mod_timer(&bcm->periodic_tasks, jiffies + (HZ * 15)); | 3148 | schedule_delayed_work(&bcm->periodic_work, HZ * 15); |
3149 | } | ||
3150 | |||
3151 | /* Estimate a "Badness" value based on the periodic work | ||
3152 | * state-machine state. "Badness" is worse (bigger), if the | ||
3153 | * periodic work will take longer. | ||
3154 | */ | ||
3155 | static int estimate_periodic_work_badness(unsigned int state) | ||
3156 | { | ||
3157 | int badness = 0; | ||
3158 | |||
3159 | if (state % 8 == 0) /* every 120 sec */ | ||
3160 | badness += 10; | ||
3161 | if (state % 4 == 0) /* every 60 sec */ | ||
3162 | badness += 5; | ||
3163 | if (state % 2 == 0) /* every 30 sec */ | ||
3164 | badness += 1; | ||
3165 | if (state % 1 == 0) /* every 15 sec */ | ||
3166 | badness += 1; | ||
3129 | 3167 | ||
3130 | bcm43xx_unlock_mmio(bcm, flags); | 3168 | #define BADNESS_LIMIT 4 |
3169 | return badness; | ||
3170 | } | ||
3171 | |||
3172 | static void bcm43xx_periodic_work_handler(void *d) | ||
3173 | { | ||
3174 | struct bcm43xx_private *bcm = d; | ||
3175 | unsigned long flags; | ||
3176 | u32 savedirqs = 0; | ||
3177 | int badness; | ||
3178 | |||
3179 | badness = estimate_periodic_work_badness(bcm->periodic_state); | ||
3180 | if (badness > BADNESS_LIMIT) { | ||
3181 | /* Periodic work will take a long time, so we want it to | ||
3182 | * be preemtible. | ||
3183 | */ | ||
3184 | bcm43xx_lock_irqonly(bcm, flags); | ||
3185 | netif_stop_queue(bcm->net_dev); | ||
3186 | if (bcm43xx_using_pio(bcm)) | ||
3187 | bcm43xx_pio_freeze_txqueues(bcm); | ||
3188 | savedirqs = bcm43xx_interrupt_disable(bcm, BCM43xx_IRQ_ALL); | ||
3189 | bcm43xx_unlock_irqonly(bcm, flags); | ||
3190 | bcm43xx_lock_noirq(bcm); | ||
3191 | bcm43xx_synchronize_irq(bcm); | ||
3192 | } else { | ||
3193 | /* Periodic work should take short time, so we want low | ||
3194 | * locking overhead. | ||
3195 | */ | ||
3196 | bcm43xx_lock_irqsafe(bcm, flags); | ||
3197 | } | ||
3198 | |||
3199 | do_periodic_work(bcm); | ||
3200 | |||
3201 | if (badness > BADNESS_LIMIT) { | ||
3202 | bcm43xx_lock_irqonly(bcm, flags); | ||
3203 | if (likely(bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED)) { | ||
3204 | tasklet_enable(&bcm->isr_tasklet); | ||
3205 | bcm43xx_interrupt_enable(bcm, savedirqs); | ||
3206 | if (bcm43xx_using_pio(bcm)) | ||
3207 | bcm43xx_pio_thaw_txqueues(bcm); | ||
3208 | } | ||
3209 | netif_wake_queue(bcm->net_dev); | ||
3210 | mmiowb(); | ||
3211 | bcm43xx_unlock_irqonly(bcm, flags); | ||
3212 | bcm43xx_unlock_noirq(bcm); | ||
3213 | } else { | ||
3214 | mmiowb(); | ||
3215 | bcm43xx_unlock_irqsafe(bcm, flags); | ||
3216 | } | ||
3131 | } | 3217 | } |
3132 | 3218 | ||
3133 | static void bcm43xx_periodic_tasks_delete(struct bcm43xx_private *bcm) | 3219 | static void bcm43xx_periodic_tasks_delete(struct bcm43xx_private *bcm) |
3134 | { | 3220 | { |
3135 | del_timer_sync(&bcm->periodic_tasks); | 3221 | cancel_rearming_delayed_work(&bcm->periodic_work); |
3136 | } | 3222 | } |
3137 | 3223 | ||
3138 | static void bcm43xx_periodic_tasks_setup(struct bcm43xx_private *bcm) | 3224 | static void bcm43xx_periodic_tasks_setup(struct bcm43xx_private *bcm) |
3139 | { | 3225 | { |
3140 | struct timer_list *timer = &(bcm->periodic_tasks); | 3226 | struct work_struct *work = &(bcm->periodic_work); |
3141 | 3227 | ||
3142 | assert(bcm->initialized); | 3228 | assert(bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED); |
3143 | setup_timer(timer, | 3229 | INIT_WORK(work, bcm43xx_periodic_work_handler, bcm); |
3144 | bcm43xx_periodic_task_handler, | 3230 | schedule_work(work); |
3145 | (unsigned long)bcm); | ||
3146 | timer->expires = jiffies; | ||
3147 | add_timer(timer); | ||
3148 | } | 3231 | } |
3149 | 3232 | ||
3150 | static void bcm43xx_security_init(struct bcm43xx_private *bcm) | 3233 | static void bcm43xx_security_init(struct bcm43xx_private *bcm) |
@@ -3158,16 +3241,12 @@ static void bcm43xx_security_init(struct bcm43xx_private *bcm) | |||
3158 | static void bcm43xx_free_board(struct bcm43xx_private *bcm) | 3241 | static void bcm43xx_free_board(struct bcm43xx_private *bcm) |
3159 | { | 3242 | { |
3160 | int i, err; | 3243 | int i, err; |
3161 | unsigned long flags; | ||
3162 | 3244 | ||
3245 | bcm43xx_lock_noirq(bcm); | ||
3163 | bcm43xx_sysfs_unregister(bcm); | 3246 | bcm43xx_sysfs_unregister(bcm); |
3164 | |||
3165 | bcm43xx_periodic_tasks_delete(bcm); | 3247 | bcm43xx_periodic_tasks_delete(bcm); |
3166 | 3248 | ||
3167 | bcm43xx_lock(bcm, flags); | 3249 | bcm43xx_set_status(bcm, BCM43xx_STAT_SHUTTINGDOWN); |
3168 | bcm->initialized = 0; | ||
3169 | bcm->shutting_down = 1; | ||
3170 | bcm43xx_unlock(bcm, flags); | ||
3171 | 3250 | ||
3172 | for (i = 0; i < BCM43xx_MAX_80211_CORES; i++) { | 3251 | for (i = 0; i < BCM43xx_MAX_80211_CORES; i++) { |
3173 | if (!bcm->core_80211[i].available) | 3252 | if (!bcm->core_80211[i].available) |
@@ -3182,23 +3261,19 @@ static void bcm43xx_free_board(struct bcm43xx_private *bcm) | |||
3182 | 3261 | ||
3183 | bcm43xx_pctl_set_crystal(bcm, 0); | 3262 | bcm43xx_pctl_set_crystal(bcm, 0); |
3184 | 3263 | ||
3185 | bcm43xx_lock(bcm, flags); | 3264 | bcm43xx_set_status(bcm, BCM43xx_STAT_UNINIT); |
3186 | bcm->shutting_down = 0; | 3265 | bcm43xx_unlock_noirq(bcm); |
3187 | bcm43xx_unlock(bcm, flags); | ||
3188 | } | 3266 | } |
3189 | 3267 | ||
3190 | static int bcm43xx_init_board(struct bcm43xx_private *bcm) | 3268 | static int bcm43xx_init_board(struct bcm43xx_private *bcm) |
3191 | { | 3269 | { |
3192 | int i, err; | 3270 | int i, err; |
3193 | int connect_phy; | 3271 | int connect_phy; |
3194 | unsigned long flags; | ||
3195 | 3272 | ||
3196 | might_sleep(); | 3273 | might_sleep(); |
3197 | 3274 | ||
3198 | bcm43xx_lock(bcm, flags); | 3275 | bcm43xx_lock_noirq(bcm); |
3199 | bcm->initialized = 0; | 3276 | bcm43xx_set_status(bcm, BCM43xx_STAT_INITIALIZING); |
3200 | bcm->shutting_down = 0; | ||
3201 | bcm43xx_unlock(bcm, flags); | ||
3202 | 3277 | ||
3203 | err = bcm43xx_pctl_set_crystal(bcm, 1); | 3278 | err = bcm43xx_pctl_set_crystal(bcm, 1); |
3204 | if (err) | 3279 | if (err) |
@@ -3265,9 +3340,7 @@ static int bcm43xx_init_board(struct bcm43xx_private *bcm) | |||
3265 | } | 3340 | } |
3266 | 3341 | ||
3267 | /* Initialization of the board is done. Flag it as such. */ | 3342 | /* Initialization of the board is done. Flag it as such. */ |
3268 | bcm43xx_lock(bcm, flags); | 3343 | bcm43xx_set_status(bcm, BCM43xx_STAT_INITIALIZED); |
3269 | bcm->initialized = 1; | ||
3270 | bcm43xx_unlock(bcm, flags); | ||
3271 | 3344 | ||
3272 | bcm43xx_periodic_tasks_setup(bcm); | 3345 | bcm43xx_periodic_tasks_setup(bcm); |
3273 | bcm43xx_sysfs_register(bcm); | 3346 | bcm43xx_sysfs_register(bcm); |
@@ -3278,6 +3351,8 @@ static int bcm43xx_init_board(struct bcm43xx_private *bcm) | |||
3278 | 3351 | ||
3279 | assert(err == 0); | 3352 | assert(err == 0); |
3280 | out: | 3353 | out: |
3354 | bcm43xx_unlock_noirq(bcm); | ||
3355 | |||
3281 | return err; | 3356 | return err; |
3282 | 3357 | ||
3283 | err_80211_unwind: | 3358 | err_80211_unwind: |
@@ -3534,8 +3609,8 @@ static void bcm43xx_ieee80211_set_chan(struct net_device *net_dev, | |||
3534 | struct bcm43xx_radioinfo *radio; | 3609 | struct bcm43xx_radioinfo *radio; |
3535 | unsigned long flags; | 3610 | unsigned long flags; |
3536 | 3611 | ||
3537 | bcm43xx_lock_mmio(bcm, flags); | 3612 | bcm43xx_lock_irqsafe(bcm, flags); |
3538 | if (bcm->initialized) { | 3613 | if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) { |
3539 | bcm43xx_mac_suspend(bcm); | 3614 | bcm43xx_mac_suspend(bcm); |
3540 | bcm43xx_radio_selectchannel(bcm, channel, 0); | 3615 | bcm43xx_radio_selectchannel(bcm, channel, 0); |
3541 | bcm43xx_mac_enable(bcm); | 3616 | bcm43xx_mac_enable(bcm); |
@@ -3543,7 +3618,7 @@ static void bcm43xx_ieee80211_set_chan(struct net_device *net_dev, | |||
3543 | radio = bcm43xx_current_radio(bcm); | 3618 | radio = bcm43xx_current_radio(bcm); |
3544 | radio->initial_channel = channel; | 3619 | radio->initial_channel = channel; |
3545 | } | 3620 | } |
3546 | bcm43xx_unlock_mmio(bcm, flags); | 3621 | bcm43xx_unlock_irqsafe(bcm, flags); |
3547 | } | 3622 | } |
3548 | 3623 | ||
3549 | /* set_security() callback in struct ieee80211_device */ | 3624 | /* set_security() callback in struct ieee80211_device */ |
@@ -3557,7 +3632,7 @@ static void bcm43xx_ieee80211_set_security(struct net_device *net_dev, | |||
3557 | 3632 | ||
3558 | dprintk(KERN_INFO PFX "set security called"); | 3633 | dprintk(KERN_INFO PFX "set security called"); |
3559 | 3634 | ||
3560 | bcm43xx_lock_mmio(bcm, flags); | 3635 | bcm43xx_lock_irqsafe(bcm, flags); |
3561 | 3636 | ||
3562 | for (keyidx = 0; keyidx<WEP_KEYS; keyidx++) | 3637 | for (keyidx = 0; keyidx<WEP_KEYS; keyidx++) |
3563 | if (sec->flags & (1<<keyidx)) { | 3638 | if (sec->flags & (1<<keyidx)) { |
@@ -3587,7 +3662,8 @@ static void bcm43xx_ieee80211_set_security(struct net_device *net_dev, | |||
3587 | dprintk(", .encrypt = %d", sec->encrypt); | 3662 | dprintk(", .encrypt = %d", sec->encrypt); |
3588 | } | 3663 | } |
3589 | dprintk("\n"); | 3664 | dprintk("\n"); |
3590 | if (bcm->initialized && !bcm->ieee->host_encrypt) { | 3665 | if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED && |
3666 | !bcm->ieee->host_encrypt) { | ||
3591 | if (secinfo->enabled) { | 3667 | if (secinfo->enabled) { |
3592 | /* upload WEP keys to hardware */ | 3668 | /* upload WEP keys to hardware */ |
3593 | char null_address[6] = { 0 }; | 3669 | char null_address[6] = { 0 }; |
@@ -3621,7 +3697,7 @@ static void bcm43xx_ieee80211_set_security(struct net_device *net_dev, | |||
3621 | } else | 3697 | } else |
3622 | bcm43xx_clear_keys(bcm); | 3698 | bcm43xx_clear_keys(bcm); |
3623 | } | 3699 | } |
3624 | bcm43xx_unlock_mmio(bcm, flags); | 3700 | bcm43xx_unlock_irqsafe(bcm, flags); |
3625 | } | 3701 | } |
3626 | 3702 | ||
3627 | /* hard_start_xmit() callback in struct ieee80211_device */ | 3703 | /* hard_start_xmit() callback in struct ieee80211_device */ |
@@ -3633,10 +3709,10 @@ static int bcm43xx_ieee80211_hard_start_xmit(struct ieee80211_txb *txb, | |||
3633 | int err = -ENODEV; | 3709 | int err = -ENODEV; |
3634 | unsigned long flags; | 3710 | unsigned long flags; |
3635 | 3711 | ||
3636 | bcm43xx_lock_mmio(bcm, flags); | 3712 | bcm43xx_lock_irqonly(bcm, flags); |
3637 | if (likely(bcm->initialized)) | 3713 | if (likely(bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED)) |
3638 | err = bcm43xx_tx(bcm, txb); | 3714 | err = bcm43xx_tx(bcm, txb); |
3639 | bcm43xx_unlock_mmio(bcm, flags); | 3715 | bcm43xx_unlock_irqonly(bcm, flags); |
3640 | 3716 | ||
3641 | return err; | 3717 | return err; |
3642 | } | 3718 | } |
@@ -3651,9 +3727,9 @@ static void bcm43xx_net_tx_timeout(struct net_device *net_dev) | |||
3651 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 3727 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
3652 | unsigned long flags; | 3728 | unsigned long flags; |
3653 | 3729 | ||
3654 | bcm43xx_lock_mmio(bcm, flags); | 3730 | bcm43xx_lock_irqonly(bcm, flags); |
3655 | bcm43xx_controller_restart(bcm, "TX timeout"); | 3731 | bcm43xx_controller_restart(bcm, "TX timeout"); |
3656 | bcm43xx_unlock_mmio(bcm, flags); | 3732 | bcm43xx_unlock_irqonly(bcm, flags); |
3657 | } | 3733 | } |
3658 | 3734 | ||
3659 | #ifdef CONFIG_NET_POLL_CONTROLLER | 3735 | #ifdef CONFIG_NET_POLL_CONTROLLER |
@@ -3678,9 +3754,11 @@ static int bcm43xx_net_open(struct net_device *net_dev) | |||
3678 | static int bcm43xx_net_stop(struct net_device *net_dev) | 3754 | static int bcm43xx_net_stop(struct net_device *net_dev) |
3679 | { | 3755 | { |
3680 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 3756 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
3757 | int err; | ||
3681 | 3758 | ||
3682 | ieee80211softmac_stop(net_dev); | 3759 | ieee80211softmac_stop(net_dev); |
3683 | bcm43xx_disable_interrupts_sync(bcm, NULL); | 3760 | err = bcm43xx_disable_interrupts_sync(bcm, NULL); |
3761 | assert(!err); | ||
3684 | bcm43xx_free_board(bcm); | 3762 | bcm43xx_free_board(bcm); |
3685 | 3763 | ||
3686 | return 0; | 3764 | return 0; |
@@ -3692,6 +3770,7 @@ static int bcm43xx_init_private(struct bcm43xx_private *bcm, | |||
3692 | { | 3770 | { |
3693 | int err; | 3771 | int err; |
3694 | 3772 | ||
3773 | bcm43xx_set_status(bcm, BCM43xx_STAT_UNINIT); | ||
3695 | bcm->ieee = netdev_priv(net_dev); | 3774 | bcm->ieee = netdev_priv(net_dev); |
3696 | bcm->softmac = ieee80211_priv(net_dev); | 3775 | bcm->softmac = ieee80211_priv(net_dev); |
3697 | bcm->softmac->set_channel = bcm43xx_ieee80211_set_chan; | 3776 | bcm->softmac->set_channel = bcm43xx_ieee80211_set_chan; |
@@ -3700,7 +3779,8 @@ static int bcm43xx_init_private(struct bcm43xx_private *bcm, | |||
3700 | bcm->pci_dev = pci_dev; | 3779 | bcm->pci_dev = pci_dev; |
3701 | bcm->net_dev = net_dev; | 3780 | bcm->net_dev = net_dev; |
3702 | bcm->bad_frames_preempt = modparam_bad_frames_preempt; | 3781 | bcm->bad_frames_preempt = modparam_bad_frames_preempt; |
3703 | spin_lock_init(&bcm->_lock); | 3782 | spin_lock_init(&bcm->irq_lock); |
3783 | mutex_init(&bcm->mutex); | ||
3704 | tasklet_init(&bcm->isr_tasklet, | 3784 | tasklet_init(&bcm->isr_tasklet, |
3705 | (void (*)(unsigned long))bcm43xx_interrupt_tasklet, | 3785 | (void (*)(unsigned long))bcm43xx_interrupt_tasklet, |
3706 | (unsigned long)bcm); | 3786 | (unsigned long)bcm); |
@@ -3831,7 +3911,7 @@ static void bcm43xx_chip_reset(void *_bcm) | |||
3831 | struct net_device *net_dev = bcm->net_dev; | 3911 | struct net_device *net_dev = bcm->net_dev; |
3832 | struct pci_dev *pci_dev = bcm->pci_dev; | 3912 | struct pci_dev *pci_dev = bcm->pci_dev; |
3833 | int err; | 3913 | int err; |
3834 | int was_initialized = bcm->initialized; | 3914 | int was_initialized = (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED); |
3835 | 3915 | ||
3836 | netif_stop_queue(bcm->net_dev); | 3916 | netif_stop_queue(bcm->net_dev); |
3837 | tasklet_disable(&bcm->isr_tasklet); | 3917 | tasklet_disable(&bcm->isr_tasklet); |
@@ -3866,6 +3946,7 @@ failure: | |||
3866 | */ | 3946 | */ |
3867 | void bcm43xx_controller_restart(struct bcm43xx_private *bcm, const char *reason) | 3947 | void bcm43xx_controller_restart(struct bcm43xx_private *bcm, const char *reason) |
3868 | { | 3948 | { |
3949 | bcm43xx_set_status(bcm, BCM43xx_STAT_RESTARTING); | ||
3869 | bcm43xx_interrupt_disable(bcm, BCM43xx_IRQ_ALL); | 3950 | bcm43xx_interrupt_disable(bcm, BCM43xx_IRQ_ALL); |
3870 | bcm43xx_read32(bcm, BCM43xx_MMIO_STATUS_BITFIELD); /* dummy read */ | 3951 | bcm43xx_read32(bcm, BCM43xx_MMIO_STATUS_BITFIELD); /* dummy read */ |
3871 | printk(KERN_ERR PFX "Controller RESET (%s) ...\n", reason); | 3952 | printk(KERN_ERR PFX "Controller RESET (%s) ...\n", reason); |
@@ -3884,11 +3965,11 @@ static int bcm43xx_suspend(struct pci_dev *pdev, pm_message_t state) | |||
3884 | 3965 | ||
3885 | dprintk(KERN_INFO PFX "Suspending...\n"); | 3966 | dprintk(KERN_INFO PFX "Suspending...\n"); |
3886 | 3967 | ||
3887 | bcm43xx_lock(bcm, flags); | 3968 | bcm43xx_lock_irqsafe(bcm, flags); |
3888 | bcm->was_initialized = bcm->initialized; | 3969 | bcm->was_initialized = (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED); |
3889 | if (bcm->initialized) | 3970 | if (bcm->was_initialized) |
3890 | try_to_shutdown = 1; | 3971 | try_to_shutdown = 1; |
3891 | bcm43xx_unlock(bcm, flags); | 3972 | bcm43xx_unlock_irqsafe(bcm, flags); |
3892 | 3973 | ||
3893 | netif_device_detach(net_dev); | 3974 | netif_device_detach(net_dev); |
3894 | if (try_to_shutdown) { | 3975 | if (try_to_shutdown) { |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_phy.c b/drivers/net/wireless/bcm43xx/bcm43xx_phy.c index b0abac515530..f8200deecc8a 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_phy.c +++ b/drivers/net/wireless/bcm43xx/bcm43xx_phy.c | |||
@@ -1410,7 +1410,10 @@ static inline | |||
1410 | u16 bcm43xx_phy_lo_g_deviation_subval(struct bcm43xx_private *bcm, u16 control) | 1410 | u16 bcm43xx_phy_lo_g_deviation_subval(struct bcm43xx_private *bcm, u16 control) |
1411 | { | 1411 | { |
1412 | struct bcm43xx_phyinfo *phy = bcm43xx_current_phy(bcm); | 1412 | struct bcm43xx_phyinfo *phy = bcm43xx_current_phy(bcm); |
1413 | u16 ret; | ||
1414 | unsigned long flags; | ||
1413 | 1415 | ||
1416 | local_irq_save(flags); | ||
1414 | if (phy->connected) { | 1417 | if (phy->connected) { |
1415 | bcm43xx_phy_write(bcm, 0x15, 0xE300); | 1418 | bcm43xx_phy_write(bcm, 0x15, 0xE300); |
1416 | control <<= 8; | 1419 | control <<= 8; |
@@ -1430,8 +1433,10 @@ u16 bcm43xx_phy_lo_g_deviation_subval(struct bcm43xx_private *bcm, u16 control) | |||
1430 | bcm43xx_phy_write(bcm, 0x0015, control | 0xFFE0); | 1433 | bcm43xx_phy_write(bcm, 0x0015, control | 0xFFE0); |
1431 | udelay(8); | 1434 | udelay(8); |
1432 | } | 1435 | } |
1436 | ret = bcm43xx_phy_read(bcm, 0x002D); | ||
1437 | local_irq_restore(flags); | ||
1433 | 1438 | ||
1434 | return bcm43xx_phy_read(bcm, 0x002D); | 1439 | return ret; |
1435 | } | 1440 | } |
1436 | 1441 | ||
1437 | static u32 bcm43xx_phy_lo_g_singledeviation(struct bcm43xx_private *bcm, u16 control) | 1442 | static u32 bcm43xx_phy_lo_g_singledeviation(struct bcm43xx_private *bcm, u16 control) |
@@ -1648,7 +1653,7 @@ void bcm43xx_phy_set_baseband_attenuation(struct bcm43xx_private *bcm, | |||
1648 | void bcm43xx_phy_lo_g_measure(struct bcm43xx_private *bcm) | 1653 | void bcm43xx_phy_lo_g_measure(struct bcm43xx_private *bcm) |
1649 | { | 1654 | { |
1650 | static const u8 pairorder[10] = { 3, 1, 5, 7, 9, 2, 0, 4, 6, 8 }; | 1655 | static const u8 pairorder[10] = { 3, 1, 5, 7, 9, 2, 0, 4, 6, 8 }; |
1651 | const int is_initializing = bcm43xx_is_initializing(bcm); | 1656 | const int is_initializing = (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZING); |
1652 | struct bcm43xx_phyinfo *phy = bcm43xx_current_phy(bcm); | 1657 | struct bcm43xx_phyinfo *phy = bcm43xx_current_phy(bcm); |
1653 | struct bcm43xx_radioinfo *radio = bcm43xx_current_radio(bcm); | 1658 | struct bcm43xx_radioinfo *radio = bcm43xx_current_radio(bcm); |
1654 | u16 h, i, oldi = 0, j; | 1659 | u16 h, i, oldi = 0, j; |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_pio.c b/drivers/net/wireless/bcm43xx/bcm43xx_pio.c index 0aa1bd269a25..574085c46152 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_pio.c +++ b/drivers/net/wireless/bcm43xx/bcm43xx_pio.c | |||
@@ -262,8 +262,10 @@ static void tx_tasklet(unsigned long d) | |||
262 | int err; | 262 | int err; |
263 | u16 txctl; | 263 | u16 txctl; |
264 | 264 | ||
265 | bcm43xx_lock_mmio(bcm, flags); | 265 | bcm43xx_lock_irqonly(bcm, flags); |
266 | 266 | ||
267 | if (queue->tx_frozen) | ||
268 | goto out_unlock; | ||
267 | txctl = bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL); | 269 | txctl = bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL); |
268 | if (txctl & BCM43xx_PIO_TXCTL_SUSPEND) | 270 | if (txctl & BCM43xx_PIO_TXCTL_SUSPEND) |
269 | goto out_unlock; | 271 | goto out_unlock; |
@@ -298,7 +300,7 @@ static void tx_tasklet(unsigned long d) | |||
298 | continue; | 300 | continue; |
299 | } | 301 | } |
300 | out_unlock: | 302 | out_unlock: |
301 | bcm43xx_unlock_mmio(bcm, flags); | 303 | bcm43xx_unlock_irqonly(bcm, flags); |
302 | } | 304 | } |
303 | 305 | ||
304 | static void setup_txqueues(struct bcm43xx_pioqueue *queue) | 306 | static void setup_txqueues(struct bcm43xx_pioqueue *queue) |
@@ -374,7 +376,6 @@ static void cancel_transfers(struct bcm43xx_pioqueue *queue) | |||
374 | struct bcm43xx_pio_txpacket *packet, *tmp_packet; | 376 | struct bcm43xx_pio_txpacket *packet, *tmp_packet; |
375 | 377 | ||
376 | netif_tx_disable(queue->bcm->net_dev); | 378 | netif_tx_disable(queue->bcm->net_dev); |
377 | assert(queue->bcm->shutting_down); | ||
378 | tasklet_disable(&queue->txtask); | 379 | tasklet_disable(&queue->txtask); |
379 | 380 | ||
380 | list_for_each_entry_safe(packet, tmp_packet, &queue->txrunning, list) | 381 | list_for_each_entry_safe(packet, tmp_packet, &queue->txrunning, list) |
@@ -634,5 +635,40 @@ void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue) | |||
634 | bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL) | 635 | bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL) |
635 | & ~BCM43xx_PIO_TXCTL_SUSPEND); | 636 | & ~BCM43xx_PIO_TXCTL_SUSPEND); |
636 | bcm43xx_power_saving_ctl_bits(queue->bcm, -1, -1); | 637 | bcm43xx_power_saving_ctl_bits(queue->bcm, -1, -1); |
637 | tasklet_schedule(&queue->txtask); | 638 | if (!list_empty(&queue->txqueue)) |
639 | tasklet_schedule(&queue->txtask); | ||
640 | } | ||
641 | |||
642 | void bcm43xx_pio_freeze_txqueues(struct bcm43xx_private *bcm) | ||
643 | { | ||
644 | struct bcm43xx_pio *pio; | ||
645 | |||
646 | assert(bcm43xx_using_pio(bcm)); | ||
647 | pio = bcm43xx_current_pio(bcm); | ||
648 | pio->queue0->tx_frozen = 1; | ||
649 | pio->queue1->tx_frozen = 1; | ||
650 | pio->queue2->tx_frozen = 1; | ||
651 | pio->queue3->tx_frozen = 1; | ||
638 | } | 652 | } |
653 | |||
654 | void bcm43xx_pio_thaw_txqueues(struct bcm43xx_private *bcm) | ||
655 | { | ||
656 | struct bcm43xx_pio *pio; | ||
657 | |||
658 | assert(bcm43xx_using_pio(bcm)); | ||
659 | pio = bcm43xx_current_pio(bcm); | ||
660 | pio->queue0->tx_frozen = 0; | ||
661 | pio->queue1->tx_frozen = 0; | ||
662 | pio->queue2->tx_frozen = 0; | ||
663 | pio->queue3->tx_frozen = 0; | ||
664 | if (!list_empty(&pio->queue0->txqueue)) | ||
665 | tasklet_schedule(&pio->queue0->txtask); | ||
666 | if (!list_empty(&pio->queue1->txqueue)) | ||
667 | tasklet_schedule(&pio->queue1->txtask); | ||
668 | if (!list_empty(&pio->queue2->txqueue)) | ||
669 | tasklet_schedule(&pio->queue2->txtask); | ||
670 | if (!list_empty(&pio->queue3->txqueue)) | ||
671 | tasklet_schedule(&pio->queue3->txtask); | ||
672 | } | ||
673 | |||
674 | |||
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_pio.h b/drivers/net/wireless/bcm43xx/bcm43xx_pio.h index dfc78209e3a3..bc78a3c2cafb 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_pio.h +++ b/drivers/net/wireless/bcm43xx/bcm43xx_pio.h | |||
@@ -54,6 +54,7 @@ struct bcm43xx_pioqueue { | |||
54 | u16 mmio_base; | 54 | u16 mmio_base; |
55 | 55 | ||
56 | u8 tx_suspended:1, | 56 | u8 tx_suspended:1, |
57 | tx_frozen:1, | ||
57 | need_workarounds:1; /* Workarounds needed for core.rev < 3 */ | 58 | need_workarounds:1; /* Workarounds needed for core.rev < 3 */ |
58 | 59 | ||
59 | /* Adjusted size of the device internal TX buffer. */ | 60 | /* Adjusted size of the device internal TX buffer. */ |
@@ -108,8 +109,12 @@ void bcm43xx_pio_handle_xmitstatus(struct bcm43xx_private *bcm, | |||
108 | struct bcm43xx_xmitstatus *status); | 109 | struct bcm43xx_xmitstatus *status); |
109 | void bcm43xx_pio_rx(struct bcm43xx_pioqueue *queue); | 110 | void bcm43xx_pio_rx(struct bcm43xx_pioqueue *queue); |
110 | 111 | ||
112 | /* Suspend a TX queue on hardware level. */ | ||
111 | void bcm43xx_pio_tx_suspend(struct bcm43xx_pioqueue *queue); | 113 | void bcm43xx_pio_tx_suspend(struct bcm43xx_pioqueue *queue); |
112 | void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue); | 114 | void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue); |
115 | /* Suspend (freeze) the TX tasklet (software level). */ | ||
116 | void bcm43xx_pio_freeze_txqueues(struct bcm43xx_private *bcm); | ||
117 | void bcm43xx_pio_thaw_txqueues(struct bcm43xx_private *bcm); | ||
113 | 118 | ||
114 | #else /* CONFIG_BCM43XX_PIO */ | 119 | #else /* CONFIG_BCM43XX_PIO */ |
115 | 120 | ||
@@ -145,6 +150,14 @@ static inline | |||
145 | void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue) | 150 | void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue) |
146 | { | 151 | { |
147 | } | 152 | } |
153 | static inline | ||
154 | void bcm43xx_pio_freeze_txqueues(struct bcm43xx_private *bcm) | ||
155 | { | ||
156 | } | ||
157 | static inline | ||
158 | void bcm43xx_pio_thaw_txqueues(struct bcm43xx_private *bcm) | ||
159 | { | ||
160 | } | ||
148 | 161 | ||
149 | #endif /* CONFIG_BCM43XX_PIO */ | 162 | #endif /* CONFIG_BCM43XX_PIO */ |
150 | #endif /* BCM43xx_PIO_H_ */ | 163 | #endif /* BCM43xx_PIO_H_ */ |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c b/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c index b438f48e891d..6a23bdc75412 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c +++ b/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c | |||
@@ -120,12 +120,12 @@ static ssize_t bcm43xx_attr_sprom_show(struct device *dev, | |||
120 | GFP_KERNEL); | 120 | GFP_KERNEL); |
121 | if (!sprom) | 121 | if (!sprom) |
122 | return -ENOMEM; | 122 | return -ENOMEM; |
123 | bcm43xx_lock_mmio(bcm, flags); | 123 | bcm43xx_lock_irqsafe(bcm, flags); |
124 | assert(bcm->initialized); | ||
125 | err = bcm43xx_sprom_read(bcm, sprom); | 124 | err = bcm43xx_sprom_read(bcm, sprom); |
126 | if (!err) | 125 | if (!err) |
127 | err = sprom2hex(sprom, buf, PAGE_SIZE); | 126 | err = sprom2hex(sprom, buf, PAGE_SIZE); |
128 | bcm43xx_unlock_mmio(bcm, flags); | 127 | mmiowb(); |
128 | bcm43xx_unlock_irqsafe(bcm, flags); | ||
129 | kfree(sprom); | 129 | kfree(sprom); |
130 | 130 | ||
131 | return err; | 131 | return err; |
@@ -150,10 +150,10 @@ static ssize_t bcm43xx_attr_sprom_store(struct device *dev, | |||
150 | err = hex2sprom(sprom, buf, count); | 150 | err = hex2sprom(sprom, buf, count); |
151 | if (err) | 151 | if (err) |
152 | goto out_kfree; | 152 | goto out_kfree; |
153 | bcm43xx_lock_mmio(bcm, flags); | 153 | bcm43xx_lock_irqsafe(bcm, flags); |
154 | assert(bcm->initialized); | ||
155 | err = bcm43xx_sprom_write(bcm, sprom); | 154 | err = bcm43xx_sprom_write(bcm, sprom); |
156 | bcm43xx_unlock_mmio(bcm, flags); | 155 | mmiowb(); |
156 | bcm43xx_unlock_irqsafe(bcm, flags); | ||
157 | out_kfree: | 157 | out_kfree: |
158 | kfree(sprom); | 158 | kfree(sprom); |
159 | 159 | ||
@@ -170,15 +170,13 @@ static ssize_t bcm43xx_attr_interfmode_show(struct device *dev, | |||
170 | char *buf) | 170 | char *buf) |
171 | { | 171 | { |
172 | struct bcm43xx_private *bcm = dev_to_bcm(dev); | 172 | struct bcm43xx_private *bcm = dev_to_bcm(dev); |
173 | unsigned long flags; | ||
174 | int err; | 173 | int err; |
175 | ssize_t count = 0; | 174 | ssize_t count = 0; |
176 | 175 | ||
177 | if (!capable(CAP_NET_ADMIN)) | 176 | if (!capable(CAP_NET_ADMIN)) |
178 | return -EPERM; | 177 | return -EPERM; |
179 | 178 | ||
180 | bcm43xx_lock(bcm, flags); | 179 | bcm43xx_lock_noirq(bcm); |
181 | assert(bcm->initialized); | ||
182 | 180 | ||
183 | switch (bcm43xx_current_radio(bcm)->interfmode) { | 181 | switch (bcm43xx_current_radio(bcm)->interfmode) { |
184 | case BCM43xx_RADIO_INTERFMODE_NONE: | 182 | case BCM43xx_RADIO_INTERFMODE_NONE: |
@@ -195,7 +193,7 @@ static ssize_t bcm43xx_attr_interfmode_show(struct device *dev, | |||
195 | } | 193 | } |
196 | err = 0; | 194 | err = 0; |
197 | 195 | ||
198 | bcm43xx_unlock(bcm, flags); | 196 | bcm43xx_unlock_noirq(bcm); |
199 | 197 | ||
200 | return err ? err : count; | 198 | return err ? err : count; |
201 | 199 | ||
@@ -231,16 +229,15 @@ static ssize_t bcm43xx_attr_interfmode_store(struct device *dev, | |||
231 | return -EINVAL; | 229 | return -EINVAL; |
232 | } | 230 | } |
233 | 231 | ||
234 | bcm43xx_lock_mmio(bcm, flags); | 232 | bcm43xx_lock_irqsafe(bcm, flags); |
235 | assert(bcm->initialized); | ||
236 | 233 | ||
237 | err = bcm43xx_radio_set_interference_mitigation(bcm, mode); | 234 | err = bcm43xx_radio_set_interference_mitigation(bcm, mode); |
238 | if (err) { | 235 | if (err) { |
239 | printk(KERN_ERR PFX "Interference Mitigation not " | 236 | printk(KERN_ERR PFX "Interference Mitigation not " |
240 | "supported by device\n"); | 237 | "supported by device\n"); |
241 | } | 238 | } |
242 | 239 | mmiowb(); | |
243 | bcm43xx_unlock_mmio(bcm, flags); | 240 | bcm43xx_unlock_irqsafe(bcm, flags); |
244 | 241 | ||
245 | return err ? err : count; | 242 | return err ? err : count; |
246 | } | 243 | } |
@@ -254,15 +251,13 @@ static ssize_t bcm43xx_attr_preamble_show(struct device *dev, | |||
254 | char *buf) | 251 | char *buf) |
255 | { | 252 | { |
256 | struct bcm43xx_private *bcm = dev_to_bcm(dev); | 253 | struct bcm43xx_private *bcm = dev_to_bcm(dev); |
257 | unsigned long flags; | ||
258 | int err; | 254 | int err; |
259 | ssize_t count; | 255 | ssize_t count; |
260 | 256 | ||
261 | if (!capable(CAP_NET_ADMIN)) | 257 | if (!capable(CAP_NET_ADMIN)) |
262 | return -EPERM; | 258 | return -EPERM; |
263 | 259 | ||
264 | bcm43xx_lock(bcm, flags); | 260 | bcm43xx_lock_noirq(bcm); |
265 | assert(bcm->initialized); | ||
266 | 261 | ||
267 | if (bcm->short_preamble) | 262 | if (bcm->short_preamble) |
268 | count = snprintf(buf, PAGE_SIZE, "1 (Short Preamble enabled)\n"); | 263 | count = snprintf(buf, PAGE_SIZE, "1 (Short Preamble enabled)\n"); |
@@ -270,7 +265,7 @@ static ssize_t bcm43xx_attr_preamble_show(struct device *dev, | |||
270 | count = snprintf(buf, PAGE_SIZE, "0 (Short Preamble disabled)\n"); | 265 | count = snprintf(buf, PAGE_SIZE, "0 (Short Preamble disabled)\n"); |
271 | 266 | ||
272 | err = 0; | 267 | err = 0; |
273 | bcm43xx_unlock(bcm, flags); | 268 | bcm43xx_unlock_noirq(bcm); |
274 | 269 | ||
275 | return err ? err : count; | 270 | return err ? err : count; |
276 | } | 271 | } |
@@ -290,13 +285,12 @@ static ssize_t bcm43xx_attr_preamble_store(struct device *dev, | |||
290 | value = get_boolean(buf, count); | 285 | value = get_boolean(buf, count); |
291 | if (value < 0) | 286 | if (value < 0) |
292 | return value; | 287 | return value; |
293 | bcm43xx_lock(bcm, flags); | 288 | bcm43xx_lock_irqsafe(bcm, flags); |
294 | assert(bcm->initialized); | ||
295 | 289 | ||
296 | bcm->short_preamble = !!value; | 290 | bcm->short_preamble = !!value; |
297 | 291 | ||
298 | err = 0; | 292 | err = 0; |
299 | bcm43xx_unlock(bcm, flags); | 293 | bcm43xx_unlock_irqsafe(bcm, flags); |
300 | 294 | ||
301 | return err ? err : count; | 295 | return err ? err : count; |
302 | } | 296 | } |
@@ -310,7 +304,7 @@ int bcm43xx_sysfs_register(struct bcm43xx_private *bcm) | |||
310 | struct device *dev = &bcm->pci_dev->dev; | 304 | struct device *dev = &bcm->pci_dev->dev; |
311 | int err; | 305 | int err; |
312 | 306 | ||
313 | assert(bcm->initialized); | 307 | assert(bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED); |
314 | 308 | ||
315 | err = device_create_file(dev, &dev_attr_sprom); | 309 | err = device_create_file(dev, &dev_attr_sprom); |
316 | if (err) | 310 | if (err) |
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_wx.c b/drivers/net/wireless/bcm43xx/bcm43xx_wx.c index b45063974ae9..c35cb3a0777e 100644 --- a/drivers/net/wireless/bcm43xx/bcm43xx_wx.c +++ b/drivers/net/wireless/bcm43xx/bcm43xx_wx.c | |||
@@ -55,13 +55,13 @@ static int bcm43xx_wx_get_name(struct net_device *net_dev, | |||
55 | char *extra) | 55 | char *extra) |
56 | { | 56 | { |
57 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 57 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
58 | unsigned long flags; | ||
59 | int i; | 58 | int i; |
59 | unsigned long flags; | ||
60 | struct bcm43xx_phyinfo *phy; | 60 | struct bcm43xx_phyinfo *phy; |
61 | char suffix[7] = { 0 }; | 61 | char suffix[7] = { 0 }; |
62 | int have_a = 0, have_b = 0, have_g = 0; | 62 | int have_a = 0, have_b = 0, have_g = 0; |
63 | 63 | ||
64 | bcm43xx_lock(bcm, flags); | 64 | bcm43xx_lock_irqsafe(bcm, flags); |
65 | for (i = 0; i < bcm->nr_80211_available; i++) { | 65 | for (i = 0; i < bcm->nr_80211_available; i++) { |
66 | phy = &(bcm->core_80211_ext[i].phy); | 66 | phy = &(bcm->core_80211_ext[i].phy); |
67 | switch (phy->type) { | 67 | switch (phy->type) { |
@@ -77,7 +77,7 @@ static int bcm43xx_wx_get_name(struct net_device *net_dev, | |||
77 | assert(0); | 77 | assert(0); |
78 | } | 78 | } |
79 | } | 79 | } |
80 | bcm43xx_unlock(bcm, flags); | 80 | bcm43xx_unlock_irqsafe(bcm, flags); |
81 | 81 | ||
82 | i = 0; | 82 | i = 0; |
83 | if (have_a) { | 83 | if (have_a) { |
@@ -111,7 +111,7 @@ static int bcm43xx_wx_set_channelfreq(struct net_device *net_dev, | |||
111 | int freq; | 111 | int freq; |
112 | int err = -EINVAL; | 112 | int err = -EINVAL; |
113 | 113 | ||
114 | bcm43xx_lock_mmio(bcm, flags); | 114 | bcm43xx_lock_irqsafe(bcm, flags); |
115 | if ((data->freq.m >= 0) && (data->freq.m <= 1000)) { | 115 | if ((data->freq.m >= 0) && (data->freq.m <= 1000)) { |
116 | channel = data->freq.m; | 116 | channel = data->freq.m; |
117 | freq = bcm43xx_channel_to_freq(bcm, channel); | 117 | freq = bcm43xx_channel_to_freq(bcm, channel); |
@@ -121,7 +121,7 @@ static int bcm43xx_wx_set_channelfreq(struct net_device *net_dev, | |||
121 | } | 121 | } |
122 | if (!bcm43xx_is_valid_channel(bcm, channel)) | 122 | if (!bcm43xx_is_valid_channel(bcm, channel)) |
123 | goto out_unlock; | 123 | goto out_unlock; |
124 | if (bcm->initialized) { | 124 | if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) { |
125 | //ieee80211softmac_disassoc(softmac, $REASON); | 125 | //ieee80211softmac_disassoc(softmac, $REASON); |
126 | bcm43xx_mac_suspend(bcm); | 126 | bcm43xx_mac_suspend(bcm); |
127 | err = bcm43xx_radio_selectchannel(bcm, channel, 0); | 127 | err = bcm43xx_radio_selectchannel(bcm, channel, 0); |
@@ -131,7 +131,7 @@ static int bcm43xx_wx_set_channelfreq(struct net_device *net_dev, | |||
131 | err = 0; | 131 | err = 0; |
132 | } | 132 | } |
133 | out_unlock: | 133 | out_unlock: |
134 | bcm43xx_unlock_mmio(bcm, flags); | 134 | bcm43xx_unlock_irqsafe(bcm, flags); |
135 | 135 | ||
136 | return err; | 136 | return err; |
137 | } | 137 | } |
@@ -147,11 +147,10 @@ static int bcm43xx_wx_get_channelfreq(struct net_device *net_dev, | |||
147 | int err = -ENODEV; | 147 | int err = -ENODEV; |
148 | u16 channel; | 148 | u16 channel; |
149 | 149 | ||
150 | bcm43xx_lock(bcm, flags); | 150 | bcm43xx_lock_irqsafe(bcm, flags); |
151 | radio = bcm43xx_current_radio(bcm); | 151 | radio = bcm43xx_current_radio(bcm); |
152 | channel = radio->channel; | 152 | channel = radio->channel; |
153 | if (channel == 0xFF) { | 153 | if (channel == 0xFF) { |
154 | assert(!bcm->initialized); | ||
155 | channel = radio->initial_channel; | 154 | channel = radio->initial_channel; |
156 | if (channel == 0xFF) | 155 | if (channel == 0xFF) |
157 | goto out_unlock; | 156 | goto out_unlock; |
@@ -163,7 +162,7 @@ static int bcm43xx_wx_get_channelfreq(struct net_device *net_dev, | |||
163 | 162 | ||
164 | err = 0; | 163 | err = 0; |
165 | out_unlock: | 164 | out_unlock: |
166 | bcm43xx_unlock(bcm, flags); | 165 | bcm43xx_unlock_irqsafe(bcm, flags); |
167 | 166 | ||
168 | return err; | 167 | return err; |
169 | } | 168 | } |
@@ -181,13 +180,13 @@ static int bcm43xx_wx_set_mode(struct net_device *net_dev, | |||
181 | if (mode == IW_MODE_AUTO) | 180 | if (mode == IW_MODE_AUTO) |
182 | mode = BCM43xx_INITIAL_IWMODE; | 181 | mode = BCM43xx_INITIAL_IWMODE; |
183 | 182 | ||
184 | bcm43xx_lock_mmio(bcm, flags); | 183 | bcm43xx_lock_irqsafe(bcm, flags); |
185 | if (bcm->initialized) { | 184 | if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) { |
186 | if (bcm->ieee->iw_mode != mode) | 185 | if (bcm->ieee->iw_mode != mode) |
187 | bcm43xx_set_iwmode(bcm, mode); | 186 | bcm43xx_set_iwmode(bcm, mode); |
188 | } else | 187 | } else |
189 | bcm->ieee->iw_mode = mode; | 188 | bcm->ieee->iw_mode = mode; |
190 | bcm43xx_unlock_mmio(bcm, flags); | 189 | bcm43xx_unlock_irqsafe(bcm, flags); |
191 | 190 | ||
192 | return 0; | 191 | return 0; |
193 | } | 192 | } |
@@ -200,9 +199,9 @@ static int bcm43xx_wx_get_mode(struct net_device *net_dev, | |||
200 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 199 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
201 | unsigned long flags; | 200 | unsigned long flags; |
202 | 201 | ||
203 | bcm43xx_lock(bcm, flags); | 202 | bcm43xx_lock_irqsafe(bcm, flags); |
204 | data->mode = bcm->ieee->iw_mode; | 203 | data->mode = bcm->ieee->iw_mode; |
205 | bcm43xx_unlock(bcm, flags); | 204 | bcm43xx_unlock_irqsafe(bcm, flags); |
206 | 205 | ||
207 | return 0; | 206 | return 0; |
208 | } | 207 | } |
@@ -255,7 +254,7 @@ static int bcm43xx_wx_get_rangeparams(struct net_device *net_dev, | |||
255 | IW_ENC_CAPA_CIPHER_TKIP | | 254 | IW_ENC_CAPA_CIPHER_TKIP | |
256 | IW_ENC_CAPA_CIPHER_CCMP; | 255 | IW_ENC_CAPA_CIPHER_CCMP; |
257 | 256 | ||
258 | bcm43xx_lock(bcm, flags); | 257 | bcm43xx_lock_irqsafe(bcm, flags); |
259 | phy = bcm43xx_current_phy(bcm); | 258 | phy = bcm43xx_current_phy(bcm); |
260 | 259 | ||
261 | range->num_bitrates = 0; | 260 | range->num_bitrates = 0; |
@@ -302,7 +301,7 @@ static int bcm43xx_wx_get_rangeparams(struct net_device *net_dev, | |||
302 | } | 301 | } |
303 | range->num_frequency = j; | 302 | range->num_frequency = j; |
304 | 303 | ||
305 | bcm43xx_unlock(bcm, flags); | 304 | bcm43xx_unlock_irqsafe(bcm, flags); |
306 | 305 | ||
307 | return 0; | 306 | return 0; |
308 | } | 307 | } |
@@ -313,14 +312,13 @@ static int bcm43xx_wx_set_nick(struct net_device *net_dev, | |||
313 | char *extra) | 312 | char *extra) |
314 | { | 313 | { |
315 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 314 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
316 | unsigned long flags; | ||
317 | size_t len; | 315 | size_t len; |
318 | 316 | ||
319 | bcm43xx_lock(bcm, flags); | 317 | bcm43xx_lock_noirq(bcm); |
320 | len = min((size_t)data->data.length, (size_t)IW_ESSID_MAX_SIZE); | 318 | len = min((size_t)data->data.length, (size_t)IW_ESSID_MAX_SIZE); |
321 | memcpy(bcm->nick, extra, len); | 319 | memcpy(bcm->nick, extra, len); |
322 | bcm->nick[len] = '\0'; | 320 | bcm->nick[len] = '\0'; |
323 | bcm43xx_unlock(bcm, flags); | 321 | bcm43xx_unlock_noirq(bcm); |
324 | 322 | ||
325 | return 0; | 323 | return 0; |
326 | } | 324 | } |
@@ -331,15 +329,14 @@ static int bcm43xx_wx_get_nick(struct net_device *net_dev, | |||
331 | char *extra) | 329 | char *extra) |
332 | { | 330 | { |
333 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 331 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
334 | unsigned long flags; | ||
335 | size_t len; | 332 | size_t len; |
336 | 333 | ||
337 | bcm43xx_lock(bcm, flags); | 334 | bcm43xx_lock_noirq(bcm); |
338 | len = strlen(bcm->nick) + 1; | 335 | len = strlen(bcm->nick) + 1; |
339 | memcpy(extra, bcm->nick, len); | 336 | memcpy(extra, bcm->nick, len); |
340 | data->data.length = (__u16)len; | 337 | data->data.length = (__u16)len; |
341 | data->data.flags = 1; | 338 | data->data.flags = 1; |
342 | bcm43xx_unlock(bcm, flags); | 339 | bcm43xx_unlock_noirq(bcm); |
343 | 340 | ||
344 | return 0; | 341 | return 0; |
345 | } | 342 | } |
@@ -353,7 +350,7 @@ static int bcm43xx_wx_set_rts(struct net_device *net_dev, | |||
353 | unsigned long flags; | 350 | unsigned long flags; |
354 | int err = -EINVAL; | 351 | int err = -EINVAL; |
355 | 352 | ||
356 | bcm43xx_lock(bcm, flags); | 353 | bcm43xx_lock_irqsafe(bcm, flags); |
357 | if (data->rts.disabled) { | 354 | if (data->rts.disabled) { |
358 | bcm->rts_threshold = BCM43xx_MAX_RTS_THRESHOLD; | 355 | bcm->rts_threshold = BCM43xx_MAX_RTS_THRESHOLD; |
359 | err = 0; | 356 | err = 0; |
@@ -364,7 +361,7 @@ static int bcm43xx_wx_set_rts(struct net_device *net_dev, | |||
364 | err = 0; | 361 | err = 0; |
365 | } | 362 | } |
366 | } | 363 | } |
367 | bcm43xx_unlock(bcm, flags); | 364 | bcm43xx_unlock_irqsafe(bcm, flags); |
368 | 365 | ||
369 | return err; | 366 | return err; |
370 | } | 367 | } |
@@ -377,11 +374,11 @@ static int bcm43xx_wx_get_rts(struct net_device *net_dev, | |||
377 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 374 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
378 | unsigned long flags; | 375 | unsigned long flags; |
379 | 376 | ||
380 | bcm43xx_lock(bcm, flags); | 377 | bcm43xx_lock_irqsafe(bcm, flags); |
381 | data->rts.value = bcm->rts_threshold; | 378 | data->rts.value = bcm->rts_threshold; |
382 | data->rts.fixed = 0; | 379 | data->rts.fixed = 0; |
383 | data->rts.disabled = (bcm->rts_threshold == BCM43xx_MAX_RTS_THRESHOLD); | 380 | data->rts.disabled = (bcm->rts_threshold == BCM43xx_MAX_RTS_THRESHOLD); |
384 | bcm43xx_unlock(bcm, flags); | 381 | bcm43xx_unlock_irqsafe(bcm, flags); |
385 | 382 | ||
386 | return 0; | 383 | return 0; |
387 | } | 384 | } |
@@ -395,7 +392,7 @@ static int bcm43xx_wx_set_frag(struct net_device *net_dev, | |||
395 | unsigned long flags; | 392 | unsigned long flags; |
396 | int err = -EINVAL; | 393 | int err = -EINVAL; |
397 | 394 | ||
398 | bcm43xx_lock(bcm, flags); | 395 | bcm43xx_lock_irqsafe(bcm, flags); |
399 | if (data->frag.disabled) { | 396 | if (data->frag.disabled) { |
400 | bcm->ieee->fts = MAX_FRAG_THRESHOLD; | 397 | bcm->ieee->fts = MAX_FRAG_THRESHOLD; |
401 | err = 0; | 398 | err = 0; |
@@ -406,7 +403,7 @@ static int bcm43xx_wx_set_frag(struct net_device *net_dev, | |||
406 | err = 0; | 403 | err = 0; |
407 | } | 404 | } |
408 | } | 405 | } |
409 | bcm43xx_unlock(bcm, flags); | 406 | bcm43xx_unlock_irqsafe(bcm, flags); |
410 | 407 | ||
411 | return err; | 408 | return err; |
412 | } | 409 | } |
@@ -419,11 +416,11 @@ static int bcm43xx_wx_get_frag(struct net_device *net_dev, | |||
419 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); | 416 | struct bcm43xx_private *bcm = bcm43xx_priv(net_dev); |
420 | unsigned long flags; | 417 | unsigned long flags; |
421 | 418 | ||
422 | bcm43xx_lock(bcm, flags); | 419 | bcm43xx_lock_irqsafe(bcm, flags); |
423 | data->frag.value = bcm->ieee->fts; | 420 | data->frag.value = bcm->ieee->fts; |
424 | data->frag.fixed = 0; | 421 | data->frag.fixed = 0; |
425 | data->frag.disabled = (bcm->ieee->fts == MAX_FRAG_THRESHOLD); | 422 | data->frag.disabled = (bcm->ieee->fts == MAX_FRAG_THRESHOLD); |
426 | bcm43xx_unlock(bcm, flags); | 423 | bcm43xx_unlock_irqsafe(bcm, flags); |
427 | 424 | ||
428 | return 0; | 425 | return 0; |
429 | } | 426 | } |
@@ -445,8 +442,8 @@ static int bcm43xx_wx_set_xmitpower(struct net_device *net_dev, | |||
445 | return -EOPNOTSUPP; | 442 | return -EOPNOTSUPP; |
446 | } | 443 | } |
447 | 444 | ||
448 | bcm43xx_lock_mmio(bcm, flags); | 445 | bcm43xx_lock_irqsafe(bcm, flags); |
449 | if (!bcm->initialized) | 446 | if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED) |
450 | goto out_unlock; | 447 | goto out_unlock; |
451 | radio = bcm43xx_current_radio(bcm); | 448 | radio = bcm43xx_current_radio(bcm); |
452 | phy = bcm43xx_current_phy(bcm); | 449 | phy = bcm43xx_current_phy(bcm); |
@@ -469,7 +466,7 @@ static int bcm43xx_wx_set_xmitpower(struct net_device *net_dev, | |||
469 | err = 0; | 466 | err = 0; |
470 | 467 | ||
471 | out_unlock: | 468 | out_unlock: |
472 | bcm43xx_unlock_mmio(bcm, flags); | 469 | bcm43xx_unlock_irqsafe(bcm, flags); |
473 | 470 | ||
474 | return err; | 471 | return err; |
475 | } | 472 | } |
@@ -484,8 +481,8 @@ static int bcm43xx_wx_get_xmitpower(struct net_device *net_dev, | |||
484 | unsigned long flags; | 481 | unsigned long flags; |
485 | int err = -ENODEV; | 482 | int err = -ENODEV; |
486 | 483 | ||
487 | bcm43xx_lock(bcm, flags); | 484 | bcm43xx_lock_irqsafe(bcm, flags); |
488 | if (!bcm->initialized) | 485 | if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED) |
489 | goto out_unlock; | 486 | goto out_unlock; |
490 | radio = bcm43xx_current_radio(bcm); | 487 | radio = bcm43xx_current_radio(bcm); |
491 | /* desired dBm value is in Q5.2 */ | 488 | /* desired dBm value is in Q5.2 */ |
@@ -496,7 +493,7 @@ static int bcm43xx_wx_get_xmitpower(struct net_device *net_dev, | |||
496 | 493 | ||
497 | err = 0; | 494 | err = 0; |
498 | out_unlock: | 495 | out_unlock: |
499 | bcm43xx_unlock(bcm, flags); | 496 | bcm43xx_unlock_irqsafe(bcm, flags); |
500 | 497 | ||
501 | return err; | 498 | return err; |
502 | } | 499 | } |
@@ -583,8 +580,8 @@ static int bcm43xx_wx_set_interfmode(struct net_device *net_dev, | |||
583 | return -EINVAL; | 580 | return -EINVAL; |
584 | } | 581 | } |
585 | 582 | ||
586 | bcm43xx_lock_mmio(bcm, flags); | 583 | bcm43xx_lock_irqsafe(bcm, flags); |
587 | if (bcm->initialized) { | 584 | if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) { |
588 | err = bcm43xx_radio_set_interference_mitigation(bcm, mode); | 585 | err = bcm43xx_radio_set_interference_mitigation(bcm, mode); |
589 | if (err) { | 586 | if (err) { |
590 | printk(KERN_ERR PFX "Interference Mitigation not " | 587 | printk(KERN_ERR PFX "Interference Mitigation not " |
@@ -598,7 +595,7 @@ static int bcm43xx_wx_set_interfmode(struct net_device *net_dev, | |||
598 | } else | 595 | } else |
599 | bcm43xx_current_radio(bcm)->interfmode = mode; | 596 | bcm43xx_current_radio(bcm)->interfmode = mode; |
600 | } | 597 | } |
601 | bcm43xx_unlock_mmio(bcm, flags); | 598 | bcm43xx_unlock_irqsafe(bcm, flags); |
602 | 599 | ||
603 | return err; | 600 | return err; |
604 | } | 601 | } |
@@ -612,9 +609,9 @@ static int bcm43xx_wx_get_interfmode(struct net_device *net_dev, | |||
612 | unsigned long flags; | 609 | unsigned long flags; |
613 | int mode; | 610 | int mode; |
614 | 611 | ||
615 | bcm43xx_lock(bcm, flags); | 612 | bcm43xx_lock_irqsafe(bcm, flags); |
616 | mode = bcm43xx_current_radio(bcm)->interfmode; | 613 | mode = bcm43xx_current_radio(bcm)->interfmode; |
617 | bcm43xx_unlock(bcm, flags); | 614 | bcm43xx_unlock_irqsafe(bcm, flags); |
618 | 615 | ||
619 | switch (mode) { | 616 | switch (mode) { |
620 | case BCM43xx_RADIO_INTERFMODE_NONE: | 617 | case BCM43xx_RADIO_INTERFMODE_NONE: |
@@ -644,9 +641,9 @@ static int bcm43xx_wx_set_shortpreamble(struct net_device *net_dev, | |||
644 | int on; | 641 | int on; |
645 | 642 | ||
646 | on = *((int *)extra); | 643 | on = *((int *)extra); |
647 | bcm43xx_lock(bcm, flags); | 644 | bcm43xx_lock_irqsafe(bcm, flags); |
648 | bcm->short_preamble = !!on; | 645 | bcm->short_preamble = !!on; |
649 | bcm43xx_unlock(bcm, flags); | 646 | bcm43xx_unlock_irqsafe(bcm, flags); |
650 | 647 | ||
651 | return 0; | 648 | return 0; |
652 | } | 649 | } |
@@ -660,9 +657,9 @@ static int bcm43xx_wx_get_shortpreamble(struct net_device *net_dev, | |||
660 | unsigned long flags; | 657 | unsigned long flags; |
661 | int on; | 658 | int on; |
662 | 659 | ||
663 | bcm43xx_lock(bcm, flags); | 660 | bcm43xx_lock_irqsafe(bcm, flags); |
664 | on = bcm->short_preamble; | 661 | on = bcm->short_preamble; |
665 | bcm43xx_unlock(bcm, flags); | 662 | bcm43xx_unlock_irqsafe(bcm, flags); |
666 | 663 | ||
667 | if (on) | 664 | if (on) |
668 | strncpy(extra, "1 (Short Preamble enabled)", MAX_WX_STRING); | 665 | strncpy(extra, "1 (Short Preamble enabled)", MAX_WX_STRING); |
@@ -684,11 +681,11 @@ static int bcm43xx_wx_set_swencryption(struct net_device *net_dev, | |||
684 | 681 | ||
685 | on = *((int *)extra); | 682 | on = *((int *)extra); |
686 | 683 | ||
687 | bcm43xx_lock(bcm, flags); | 684 | bcm43xx_lock_irqsafe(bcm, flags); |
688 | bcm->ieee->host_encrypt = !!on; | 685 | bcm->ieee->host_encrypt = !!on; |
689 | bcm->ieee->host_decrypt = !!on; | 686 | bcm->ieee->host_decrypt = !!on; |
690 | bcm->ieee->host_build_iv = !on; | 687 | bcm->ieee->host_build_iv = !on; |
691 | bcm43xx_unlock(bcm, flags); | 688 | bcm43xx_unlock_irqsafe(bcm, flags); |
692 | 689 | ||
693 | return 0; | 690 | return 0; |
694 | } | 691 | } |
@@ -702,9 +699,9 @@ static int bcm43xx_wx_get_swencryption(struct net_device *net_dev, | |||
702 | unsigned long flags; | 699 | unsigned long flags; |
703 | int on; | 700 | int on; |
704 | 701 | ||
705 | bcm43xx_lock(bcm, flags); | 702 | bcm43xx_lock_irqsafe(bcm, flags); |
706 | on = bcm->ieee->host_encrypt; | 703 | on = bcm->ieee->host_encrypt; |
707 | bcm43xx_unlock(bcm, flags); | 704 | bcm43xx_unlock_irqsafe(bcm, flags); |
708 | 705 | ||
709 | if (on) | 706 | if (on) |
710 | strncpy(extra, "1 (SW encryption enabled) ", MAX_WX_STRING); | 707 | strncpy(extra, "1 (SW encryption enabled) ", MAX_WX_STRING); |
@@ -767,11 +764,11 @@ static int bcm43xx_wx_sprom_read(struct net_device *net_dev, | |||
767 | if (!sprom) | 764 | if (!sprom) |
768 | goto out; | 765 | goto out; |
769 | 766 | ||
770 | bcm43xx_lock_mmio(bcm, flags); | 767 | bcm43xx_lock_irqsafe(bcm, flags); |
771 | err = -ENODEV; | 768 | err = -ENODEV; |
772 | if (bcm->initialized) | 769 | if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) |
773 | err = bcm43xx_sprom_read(bcm, sprom); | 770 | err = bcm43xx_sprom_read(bcm, sprom); |
774 | bcm43xx_unlock_mmio(bcm, flags); | 771 | bcm43xx_unlock_irqsafe(bcm, flags); |
775 | if (!err) | 772 | if (!err) |
776 | data->data.length = sprom2hex(sprom, extra); | 773 | data->data.length = sprom2hex(sprom, extra); |
777 | kfree(sprom); | 774 | kfree(sprom); |
@@ -812,11 +809,11 @@ static int bcm43xx_wx_sprom_write(struct net_device *net_dev, | |||
812 | if (err) | 809 | if (err) |
813 | goto out_kfree; | 810 | goto out_kfree; |
814 | 811 | ||
815 | bcm43xx_lock_mmio(bcm, flags); | 812 | bcm43xx_lock_irqsafe(bcm, flags); |
816 | err = -ENODEV; | 813 | err = -ENODEV; |
817 | if (bcm->initialized) | 814 | if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) |
818 | err = bcm43xx_sprom_write(bcm, sprom); | 815 | err = bcm43xx_sprom_write(bcm, sprom); |
819 | bcm43xx_unlock_mmio(bcm, flags); | 816 | bcm43xx_unlock_irqsafe(bcm, flags); |
820 | out_kfree: | 817 | out_kfree: |
821 | kfree(sprom); | 818 | kfree(sprom); |
822 | out: | 819 | out: |
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c index 39f82f219749..081a8999666e 100644 --- a/drivers/net/wireless/ipw2200.c +++ b/drivers/net/wireless/ipw2200.c | |||
@@ -533,7 +533,7 @@ static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask) | |||
533 | ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask); | 533 | ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask); |
534 | } | 534 | } |
535 | 535 | ||
536 | static inline void ipw_enable_interrupts(struct ipw_priv *priv) | 536 | static inline void __ipw_enable_interrupts(struct ipw_priv *priv) |
537 | { | 537 | { |
538 | if (priv->status & STATUS_INT_ENABLED) | 538 | if (priv->status & STATUS_INT_ENABLED) |
539 | return; | 539 | return; |
@@ -541,7 +541,7 @@ static inline void ipw_enable_interrupts(struct ipw_priv *priv) | |||
541 | ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL); | 541 | ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL); |
542 | } | 542 | } |
543 | 543 | ||
544 | static inline void ipw_disable_interrupts(struct ipw_priv *priv) | 544 | static inline void __ipw_disable_interrupts(struct ipw_priv *priv) |
545 | { | 545 | { |
546 | if (!(priv->status & STATUS_INT_ENABLED)) | 546 | if (!(priv->status & STATUS_INT_ENABLED)) |
547 | return; | 547 | return; |
@@ -549,6 +549,24 @@ static inline void ipw_disable_interrupts(struct ipw_priv *priv) | |||
549 | ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL); | 549 | ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL); |
550 | } | 550 | } |
551 | 551 | ||
552 | static inline void ipw_enable_interrupts(struct ipw_priv *priv) | ||
553 | { | ||
554 | unsigned long flags; | ||
555 | |||
556 | spin_lock_irqsave(&priv->irq_lock, flags); | ||
557 | __ipw_enable_interrupts(priv); | ||
558 | spin_unlock_irqrestore(&priv->irq_lock, flags); | ||
559 | } | ||
560 | |||
561 | static inline void ipw_disable_interrupts(struct ipw_priv *priv) | ||
562 | { | ||
563 | unsigned long flags; | ||
564 | |||
565 | spin_lock_irqsave(&priv->irq_lock, flags); | ||
566 | __ipw_disable_interrupts(priv); | ||
567 | spin_unlock_irqrestore(&priv->irq_lock, flags); | ||
568 | } | ||
569 | |||
552 | #ifdef CONFIG_IPW2200_DEBUG | 570 | #ifdef CONFIG_IPW2200_DEBUG |
553 | static char *ipw_error_desc(u32 val) | 571 | static char *ipw_error_desc(u32 val) |
554 | { | 572 | { |
@@ -1856,7 +1874,7 @@ static void ipw_irq_tasklet(struct ipw_priv *priv) | |||
1856 | unsigned long flags; | 1874 | unsigned long flags; |
1857 | int rc = 0; | 1875 | int rc = 0; |
1858 | 1876 | ||
1859 | spin_lock_irqsave(&priv->lock, flags); | 1877 | spin_lock_irqsave(&priv->irq_lock, flags); |
1860 | 1878 | ||
1861 | inta = ipw_read32(priv, IPW_INTA_RW); | 1879 | inta = ipw_read32(priv, IPW_INTA_RW); |
1862 | inta_mask = ipw_read32(priv, IPW_INTA_MASK_R); | 1880 | inta_mask = ipw_read32(priv, IPW_INTA_MASK_R); |
@@ -1865,6 +1883,10 @@ static void ipw_irq_tasklet(struct ipw_priv *priv) | |||
1865 | /* Add any cached INTA values that need to be handled */ | 1883 | /* Add any cached INTA values that need to be handled */ |
1866 | inta |= priv->isr_inta; | 1884 | inta |= priv->isr_inta; |
1867 | 1885 | ||
1886 | spin_unlock_irqrestore(&priv->irq_lock, flags); | ||
1887 | |||
1888 | spin_lock_irqsave(&priv->lock, flags); | ||
1889 | |||
1868 | /* handle all the justifications for the interrupt */ | 1890 | /* handle all the justifications for the interrupt */ |
1869 | if (inta & IPW_INTA_BIT_RX_TRANSFER) { | 1891 | if (inta & IPW_INTA_BIT_RX_TRANSFER) { |
1870 | ipw_rx(priv); | 1892 | ipw_rx(priv); |
@@ -1993,10 +2015,10 @@ static void ipw_irq_tasklet(struct ipw_priv *priv) | |||
1993 | IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled); | 2015 | IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled); |
1994 | } | 2016 | } |
1995 | 2017 | ||
2018 | spin_unlock_irqrestore(&priv->lock, flags); | ||
2019 | |||
1996 | /* enable all interrupts */ | 2020 | /* enable all interrupts */ |
1997 | ipw_enable_interrupts(priv); | 2021 | ipw_enable_interrupts(priv); |
1998 | |||
1999 | spin_unlock_irqrestore(&priv->lock, flags); | ||
2000 | } | 2022 | } |
2001 | 2023 | ||
2002 | #define IPW_CMD(x) case IPW_CMD_ ## x : return #x | 2024 | #define IPW_CMD(x) case IPW_CMD_ ## x : return #x |
@@ -10460,7 +10482,7 @@ static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs) | |||
10460 | if (!priv) | 10482 | if (!priv) |
10461 | return IRQ_NONE; | 10483 | return IRQ_NONE; |
10462 | 10484 | ||
10463 | spin_lock(&priv->lock); | 10485 | spin_lock(&priv->irq_lock); |
10464 | 10486 | ||
10465 | if (!(priv->status & STATUS_INT_ENABLED)) { | 10487 | if (!(priv->status & STATUS_INT_ENABLED)) { |
10466 | /* Shared IRQ */ | 10488 | /* Shared IRQ */ |
@@ -10482,7 +10504,7 @@ static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs) | |||
10482 | } | 10504 | } |
10483 | 10505 | ||
10484 | /* tell the device to stop sending interrupts */ | 10506 | /* tell the device to stop sending interrupts */ |
10485 | ipw_disable_interrupts(priv); | 10507 | __ipw_disable_interrupts(priv); |
10486 | 10508 | ||
10487 | /* ack current interrupts */ | 10509 | /* ack current interrupts */ |
10488 | inta &= (IPW_INTA_MASK_ALL & inta_mask); | 10510 | inta &= (IPW_INTA_MASK_ALL & inta_mask); |
@@ -10493,11 +10515,11 @@ static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs) | |||
10493 | 10515 | ||
10494 | tasklet_schedule(&priv->irq_tasklet); | 10516 | tasklet_schedule(&priv->irq_tasklet); |
10495 | 10517 | ||
10496 | spin_unlock(&priv->lock); | 10518 | spin_unlock(&priv->irq_lock); |
10497 | 10519 | ||
10498 | return IRQ_HANDLED; | 10520 | return IRQ_HANDLED; |
10499 | none: | 10521 | none: |
10500 | spin_unlock(&priv->lock); | 10522 | spin_unlock(&priv->irq_lock); |
10501 | return IRQ_NONE; | 10523 | return IRQ_NONE; |
10502 | } | 10524 | } |
10503 | 10525 | ||
@@ -11477,6 +11499,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) | |||
11477 | #ifdef CONFIG_IPW2200_DEBUG | 11499 | #ifdef CONFIG_IPW2200_DEBUG |
11478 | ipw_debug_level = debug; | 11500 | ipw_debug_level = debug; |
11479 | #endif | 11501 | #endif |
11502 | spin_lock_init(&priv->irq_lock); | ||
11480 | spin_lock_init(&priv->lock); | 11503 | spin_lock_init(&priv->lock); |
11481 | for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) | 11504 | for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) |
11482 | INIT_LIST_HEAD(&priv->ibss_mac_hash[i]); | 11505 | INIT_LIST_HEAD(&priv->ibss_mac_hash[i]); |
diff --git a/drivers/net/wireless/ipw2200.h b/drivers/net/wireless/ipw2200.h index 6044c0be2c80..ea12ad66b8e8 100644 --- a/drivers/net/wireless/ipw2200.h +++ b/drivers/net/wireless/ipw2200.h | |||
@@ -1173,6 +1173,7 @@ struct ipw_priv { | |||
1173 | struct ieee80211_device *ieee; | 1173 | struct ieee80211_device *ieee; |
1174 | 1174 | ||
1175 | spinlock_t lock; | 1175 | spinlock_t lock; |
1176 | spinlock_t irq_lock; | ||
1176 | struct mutex mutex; | 1177 | struct mutex mutex; |
1177 | 1178 | ||
1178 | /* basic pci-network driver stuff */ | 1179 | /* basic pci-network driver stuff */ |
diff --git a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c index b563decf599e..8a31b591a901 100644 --- a/drivers/net/wireless/orinoco.c +++ b/drivers/net/wireless/orinoco.c | |||
@@ -1787,7 +1787,9 @@ static int __orinoco_program_rids(struct net_device *dev) | |||
1787 | /* Set promiscuity / multicast*/ | 1787 | /* Set promiscuity / multicast*/ |
1788 | priv->promiscuous = 0; | 1788 | priv->promiscuous = 0; |
1789 | priv->mc_count = 0; | 1789 | priv->mc_count = 0; |
1790 | __orinoco_set_multicast_list(dev); /* FIXME: what about the xmit_lock */ | 1790 | |
1791 | /* FIXME: what about netif_tx_lock */ | ||
1792 | __orinoco_set_multicast_list(dev); | ||
1791 | 1793 | ||
1792 | return 0; | 1794 | return 0; |
1793 | } | 1795 | } |
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c index 1456759936c5..10e1a905c144 100644 --- a/drivers/pci/pci-driver.c +++ b/drivers/pci/pci-driver.c | |||
@@ -285,9 +285,9 @@ static int pci_device_suspend(struct device * dev, pm_message_t state) | |||
285 | * Default resume method for devices that have no driver provided resume, | 285 | * Default resume method for devices that have no driver provided resume, |
286 | * or not even a driver at all. | 286 | * or not even a driver at all. |
287 | */ | 287 | */ |
288 | static void pci_default_resume(struct pci_dev *pci_dev) | 288 | static int pci_default_resume(struct pci_dev *pci_dev) |
289 | { | 289 | { |
290 | int retval; | 290 | int retval = 0; |
291 | 291 | ||
292 | /* restore the PCI config space */ | 292 | /* restore the PCI config space */ |
293 | pci_restore_state(pci_dev); | 293 | pci_restore_state(pci_dev); |
@@ -297,18 +297,21 @@ static void pci_default_resume(struct pci_dev *pci_dev) | |||
297 | /* if the device was busmaster before the suspend, make it busmaster again */ | 297 | /* if the device was busmaster before the suspend, make it busmaster again */ |
298 | if (pci_dev->is_busmaster) | 298 | if (pci_dev->is_busmaster) |
299 | pci_set_master(pci_dev); | 299 | pci_set_master(pci_dev); |
300 | |||
301 | return retval; | ||
300 | } | 302 | } |
301 | 303 | ||
302 | static int pci_device_resume(struct device * dev) | 304 | static int pci_device_resume(struct device * dev) |
303 | { | 305 | { |
306 | int error; | ||
304 | struct pci_dev * pci_dev = to_pci_dev(dev); | 307 | struct pci_dev * pci_dev = to_pci_dev(dev); |
305 | struct pci_driver * drv = pci_dev->driver; | 308 | struct pci_driver * drv = pci_dev->driver; |
306 | 309 | ||
307 | if (drv && drv->resume) | 310 | if (drv && drv->resume) |
308 | drv->resume(pci_dev); | 311 | error = drv->resume(pci_dev); |
309 | else | 312 | else |
310 | pci_default_resume(pci_dev); | 313 | error = pci_default_resume(pci_dev); |
311 | return 0; | 314 | return error; |
312 | } | 315 | } |
313 | 316 | ||
314 | static void pci_device_shutdown(struct device *dev) | 317 | static void pci_device_shutdown(struct device *dev) |
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c index 8d107c6c2c70..fde41cc14734 100644 --- a/drivers/pci/pci.c +++ b/drivers/pci/pci.c | |||
@@ -460,9 +460,23 @@ int | |||
460 | pci_restore_state(struct pci_dev *dev) | 460 | pci_restore_state(struct pci_dev *dev) |
461 | { | 461 | { |
462 | int i; | 462 | int i; |
463 | int val; | ||
463 | 464 | ||
464 | for (i = 0; i < 16; i++) | 465 | /* |
465 | pci_write_config_dword(dev,i * 4, dev->saved_config_space[i]); | 466 | * The Base Address register should be programmed before the command |
467 | * register(s) | ||
468 | */ | ||
469 | for (i = 15; i >= 0; i--) { | ||
470 | pci_read_config_dword(dev, i * 4, &val); | ||
471 | if (val != dev->saved_config_space[i]) { | ||
472 | printk(KERN_DEBUG "PM: Writing back config space on " | ||
473 | "device %s at offset %x (was %x, writing %x)\n", | ||
474 | pci_name(dev), i, | ||
475 | val, (int)dev->saved_config_space[i]); | ||
476 | pci_write_config_dword(dev,i * 4, | ||
477 | dev->saved_config_space[i]); | ||
478 | } | ||
479 | } | ||
466 | pci_restore_msi_state(dev); | 480 | pci_restore_msi_state(dev); |
467 | pci_restore_msix_state(dev); | 481 | pci_restore_msix_state(dev); |
468 | return 0; | 482 | return 0; |
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c index b046ffa22101..de9ba7890b5a 100644 --- a/drivers/scsi/libata-core.c +++ b/drivers/scsi/libata-core.c | |||
@@ -4297,6 +4297,7 @@ static int ata_start_drive(struct ata_port *ap, struct ata_device *dev) | |||
4297 | int ata_device_resume(struct ata_port *ap, struct ata_device *dev) | 4297 | int ata_device_resume(struct ata_port *ap, struct ata_device *dev) |
4298 | { | 4298 | { |
4299 | if (ap->flags & ATA_FLAG_SUSPENDED) { | 4299 | if (ap->flags & ATA_FLAG_SUSPENDED) { |
4300 | ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT); | ||
4300 | ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 200000); | 4301 | ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 200000); |
4301 | ap->flags &= ~ATA_FLAG_SUSPENDED; | 4302 | ap->flags &= ~ATA_FLAG_SUSPENDED; |
4302 | ata_set_mode(ap); | 4303 | ata_set_mode(ap); |
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c index 9b8bca1ac1f0..f16f92a6ec0f 100644 --- a/drivers/scsi/sata_mv.c +++ b/drivers/scsi/sata_mv.c | |||
@@ -2035,6 +2035,7 @@ static void mv_phy_reset(struct ata_port *ap) | |||
2035 | static void mv_eng_timeout(struct ata_port *ap) | 2035 | static void mv_eng_timeout(struct ata_port *ap) |
2036 | { | 2036 | { |
2037 | struct ata_queued_cmd *qc; | 2037 | struct ata_queued_cmd *qc; |
2038 | unsigned long flags; | ||
2038 | 2039 | ||
2039 | printk(KERN_ERR "ata%u: Entering mv_eng_timeout\n",ap->id); | 2040 | printk(KERN_ERR "ata%u: Entering mv_eng_timeout\n",ap->id); |
2040 | DPRINTK("All regs @ start of eng_timeout\n"); | 2041 | DPRINTK("All regs @ start of eng_timeout\n"); |
@@ -2046,8 +2047,10 @@ static void mv_eng_timeout(struct ata_port *ap) | |||
2046 | ap->host_set->mmio_base, ap, qc, qc->scsicmd, | 2047 | ap->host_set->mmio_base, ap, qc, qc->scsicmd, |
2047 | &qc->scsicmd->cmnd); | 2048 | &qc->scsicmd->cmnd); |
2048 | 2049 | ||
2050 | spin_lock_irqsave(&ap->host_set->lock, flags); | ||
2049 | mv_err_intr(ap, 0); | 2051 | mv_err_intr(ap, 0); |
2050 | mv_stop_and_reset(ap); | 2052 | mv_stop_and_reset(ap); |
2053 | spin_unlock_irqrestore(&ap->host_set->lock, flags); | ||
2051 | 2054 | ||
2052 | WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE)); | 2055 | WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE)); |
2053 | if (qc->flags & ATA_QCFLAG_ACTIVE) { | 2056 | if (qc->flags & ATA_QCFLAG_ACTIVE) { |
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c index acde8868da21..fafe7c1265b3 100644 --- a/drivers/usb/host/ohci-pxa27x.c +++ b/drivers/usb/host/ohci-pxa27x.c | |||
@@ -185,6 +185,9 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device | |||
185 | /* Select Power Management Mode */ | 185 | /* Select Power Management Mode */ |
186 | pxa27x_ohci_select_pmm(inf->port_mode); | 186 | pxa27x_ohci_select_pmm(inf->port_mode); |
187 | 187 | ||
188 | if (inf->power_budget) | ||
189 | hcd->power_budget = inf->power_budget; | ||
190 | |||
188 | ohci_hcd_init(hcd_to_ohci(hcd)); | 191 | ohci_hcd_init(hcd_to_ohci(hcd)); |
189 | 192 | ||
190 | retval = usb_add_hcd(hcd, pdev->resource[1].start, SA_INTERRUPT); | 193 | retval = usb_add_hcd(hcd, pdev->resource[1].start, SA_INTERRUPT); |
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig index 4587087d777a..5641498725d0 100644 --- a/drivers/video/Kconfig +++ b/drivers/video/Kconfig | |||
@@ -743,7 +743,7 @@ config FB_I810_I2C | |||
743 | 743 | ||
744 | config FB_INTEL | 744 | config FB_INTEL |
745 | tristate "Intel 830M/845G/852GM/855GM/865G support (EXPERIMENTAL)" | 745 | tristate "Intel 830M/845G/852GM/855GM/865G support (EXPERIMENTAL)" |
746 | depends on FB && EXPERIMENTAL && PCI && X86_32 | 746 | depends on FB && EXPERIMENTAL && PCI && X86 |
747 | select AGP | 747 | select AGP |
748 | select AGP_INTEL | 748 | select AGP_INTEL |
749 | select FB_MODE_HELPERS | 749 | select FB_MODE_HELPERS |
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c index 953eb8c171d6..47ba1a79adcd 100644 --- a/drivers/video/console/fbcon.c +++ b/drivers/video/console/fbcon.c | |||
@@ -1745,7 +1745,7 @@ static int fbcon_scroll(struct vc_data *vc, int t, int b, int dir, | |||
1745 | fbcon_redraw_move(vc, p, 0, t, count); | 1745 | fbcon_redraw_move(vc, p, 0, t, count); |
1746 | ypan_up_redraw(vc, t, count); | 1746 | ypan_up_redraw(vc, t, count); |
1747 | if (vc->vc_rows - b > 0) | 1747 | if (vc->vc_rows - b > 0) |
1748 | fbcon_redraw_move(vc, p, b - count, | 1748 | fbcon_redraw_move(vc, p, b, |
1749 | vc->vc_rows - b, b); | 1749 | vc->vc_rows - b, b); |
1750 | } else | 1750 | } else |
1751 | fbcon_redraw_move(vc, p, t + count, b - t - count, t); | 1751 | fbcon_redraw_move(vc, p, t + count, b - t - count, t); |
diff --git a/drivers/video/intelfb/intelfb.h b/drivers/video/intelfb/intelfb.h index da29d007f215..469b06c29180 100644 --- a/drivers/video/intelfb/intelfb.h +++ b/drivers/video/intelfb/intelfb.h | |||
@@ -8,9 +8,9 @@ | |||
8 | 8 | ||
9 | 9 | ||
10 | /*** Version/name ***/ | 10 | /*** Version/name ***/ |
11 | #define INTELFB_VERSION "0.9.2" | 11 | #define INTELFB_VERSION "0.9.4" |
12 | #define INTELFB_MODULE_NAME "intelfb" | 12 | #define INTELFB_MODULE_NAME "intelfb" |
13 | #define SUPPORTED_CHIPSETS "830M/845G/852GM/855GM/865G/915G/915GM" | 13 | #define SUPPORTED_CHIPSETS "830M/845G/852GM/855GM/865G/915G/915GM/945G/945GM" |
14 | 14 | ||
15 | 15 | ||
16 | /*** Debug/feature defines ***/ | 16 | /*** Debug/feature defines ***/ |
@@ -52,11 +52,14 @@ | |||
52 | #define PCI_DEVICE_ID_INTEL_865G 0x2572 | 52 | #define PCI_DEVICE_ID_INTEL_865G 0x2572 |
53 | #define PCI_DEVICE_ID_INTEL_915G 0x2582 | 53 | #define PCI_DEVICE_ID_INTEL_915G 0x2582 |
54 | #define PCI_DEVICE_ID_INTEL_915GM 0x2592 | 54 | #define PCI_DEVICE_ID_INTEL_915GM 0x2592 |
55 | #define PCI_DEVICE_ID_INTEL_945G 0x2772 | ||
56 | #define PCI_DEVICE_ID_INTEL_945GM 0x27A2 | ||
55 | 57 | ||
56 | /* Size of MMIO region */ | 58 | /* Size of MMIO region */ |
57 | #define INTEL_REG_SIZE 0x80000 | 59 | #define INTEL_REG_SIZE 0x80000 |
58 | 60 | ||
59 | #define STRIDE_ALIGNMENT 16 | 61 | #define STRIDE_ALIGNMENT 16 |
62 | #define STRIDE_ALIGNMENT_I9XX 64 | ||
60 | 63 | ||
61 | #define PALETTE_8_ENTRIES 256 | 64 | #define PALETTE_8_ENTRIES 256 |
62 | 65 | ||
@@ -125,7 +128,9 @@ enum intel_chips { | |||
125 | INTEL_855GME, | 128 | INTEL_855GME, |
126 | INTEL_865G, | 129 | INTEL_865G, |
127 | INTEL_915G, | 130 | INTEL_915G, |
128 | INTEL_915GM | 131 | INTEL_915GM, |
132 | INTEL_945G, | ||
133 | INTEL_945GM, | ||
129 | }; | 134 | }; |
130 | 135 | ||
131 | struct intelfb_hwstate { | 136 | struct intelfb_hwstate { |
@@ -277,8 +282,13 @@ struct intelfb_info { | |||
277 | 282 | ||
278 | /* driver registered */ | 283 | /* driver registered */ |
279 | int registered; | 284 | int registered; |
285 | |||
286 | /* index into plls */ | ||
287 | int pll_index; | ||
280 | }; | 288 | }; |
281 | 289 | ||
290 | #define IS_I9XX(dinfo) (((dinfo)->chipset == INTEL_915G)||(dinfo->chipset == INTEL_915GM)||((dinfo)->chipset == INTEL_945G)||(dinfo->chipset==INTEL_945GM)) | ||
291 | |||
282 | /*** function prototypes ***/ | 292 | /*** function prototypes ***/ |
283 | 293 | ||
284 | extern int intelfb_var_to_depth(const struct fb_var_screeninfo *var); | 294 | extern int intelfb_var_to_depth(const struct fb_var_screeninfo *var); |
diff --git a/drivers/video/intelfb/intelfbdrv.c b/drivers/video/intelfb/intelfbdrv.c index 995b47c165a7..076fa56be192 100644 --- a/drivers/video/intelfb/intelfbdrv.c +++ b/drivers/video/intelfb/intelfbdrv.c | |||
@@ -1,11 +1,12 @@ | |||
1 | /* | 1 | /* |
2 | * intelfb | 2 | * intelfb |
3 | * | 3 | * |
4 | * Linux framebuffer driver for Intel(R) 830M/845G/852GM/855GM/865G/915G/915GM | 4 | * Linux framebuffer driver for Intel(R) 830M/845G/852GM/855GM/865G/915G/915GM/ |
5 | * integrated graphics chips. | 5 | * 945G/945GM integrated graphics chips. |
6 | * | 6 | * |
7 | * Copyright © 2002, 2003 David Dawes <dawes@xfree86.org> | 7 | * Copyright © 2002, 2003 David Dawes <dawes@xfree86.org> |
8 | * 2004 Sylvain Meyer | 8 | * 2004 Sylvain Meyer |
9 | * 2006 David Airlie | ||
9 | * | 10 | * |
10 | * This driver consists of two parts. The first part (intelfbdrv.c) provides | 11 | * This driver consists of two parts. The first part (intelfbdrv.c) provides |
11 | * the basic fbdev interfaces, is derived in part from the radeonfb and | 12 | * the basic fbdev interfaces, is derived in part from the radeonfb and |
@@ -131,6 +132,7 @@ | |||
131 | 132 | ||
132 | #include "intelfb.h" | 133 | #include "intelfb.h" |
133 | #include "intelfbhw.h" | 134 | #include "intelfbhw.h" |
135 | #include "../edid.h" | ||
134 | 136 | ||
135 | static void __devinit get_initial_mode(struct intelfb_info *dinfo); | 137 | static void __devinit get_initial_mode(struct intelfb_info *dinfo); |
136 | static void update_dinfo(struct intelfb_info *dinfo, | 138 | static void update_dinfo(struct intelfb_info *dinfo, |
@@ -182,6 +184,8 @@ static struct pci_device_id intelfb_pci_table[] __devinitdata = { | |||
182 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_865G, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_865G }, | 184 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_865G, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_865G }, |
183 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_915G, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_915G }, | 185 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_915G, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_915G }, |
184 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_915GM, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_915GM }, | 186 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_915GM, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_915GM }, |
187 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_945G, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_945G }, | ||
188 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_945GM, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_945GM }, | ||
185 | { 0, } | 189 | { 0, } |
186 | }; | 190 | }; |
187 | 191 | ||
@@ -261,7 +265,7 @@ MODULE_PARM_DESC(mode, | |||
261 | 265 | ||
262 | #ifndef MODULE | 266 | #ifndef MODULE |
263 | #define OPT_EQUAL(opt, name) (!strncmp(opt, name, strlen(name))) | 267 | #define OPT_EQUAL(opt, name) (!strncmp(opt, name, strlen(name))) |
264 | #define OPT_INTVAL(opt, name) simple_strtoul(opt + strlen(name), NULL, 0) | 268 | #define OPT_INTVAL(opt, name) simple_strtoul(opt + strlen(name) + 1, NULL, 0) |
265 | #define OPT_STRVAL(opt, name) (opt + strlen(name)) | 269 | #define OPT_STRVAL(opt, name) (opt + strlen(name)) |
266 | 270 | ||
267 | static __inline__ char * | 271 | static __inline__ char * |
@@ -546,11 +550,11 @@ intelfb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) | |||
546 | 550 | ||
547 | /* Set base addresses. */ | 551 | /* Set base addresses. */ |
548 | if ((ent->device == PCI_DEVICE_ID_INTEL_915G) || | 552 | if ((ent->device == PCI_DEVICE_ID_INTEL_915G) || |
549 | (ent->device == PCI_DEVICE_ID_INTEL_915GM)) { | 553 | (ent->device == PCI_DEVICE_ID_INTEL_915GM) || |
554 | (ent->device == PCI_DEVICE_ID_INTEL_945G) || | ||
555 | (ent->device == PCI_DEVICE_ID_INTEL_945GM)) { | ||
550 | aperture_bar = 2; | 556 | aperture_bar = 2; |
551 | mmio_bar = 0; | 557 | mmio_bar = 0; |
552 | /* Disable HW cursor on 915G/M (not implemented yet) */ | ||
553 | hwcursor = 0; | ||
554 | } | 558 | } |
555 | dinfo->aperture.physical = pci_resource_start(pdev, aperture_bar); | 559 | dinfo->aperture.physical = pci_resource_start(pdev, aperture_bar); |
556 | dinfo->aperture.size = pci_resource_len(pdev, aperture_bar); | 560 | dinfo->aperture.size = pci_resource_len(pdev, aperture_bar); |
@@ -584,8 +588,7 @@ intelfb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) | |||
584 | /* Get the chipset info. */ | 588 | /* Get the chipset info. */ |
585 | dinfo->pci_chipset = pdev->device; | 589 | dinfo->pci_chipset = pdev->device; |
586 | 590 | ||
587 | if (intelfbhw_get_chipset(pdev, &dinfo->name, &dinfo->chipset, | 591 | if (intelfbhw_get_chipset(pdev, dinfo)) { |
588 | &dinfo->mobile)) { | ||
589 | cleanup(dinfo); | 592 | cleanup(dinfo); |
590 | return -ENODEV; | 593 | return -ENODEV; |
591 | } | 594 | } |
@@ -1029,17 +1032,44 @@ intelfb_init_var(struct intelfb_info *dinfo) | |||
1029 | sizeof(struct fb_var_screeninfo)); | 1032 | sizeof(struct fb_var_screeninfo)); |
1030 | msrc = 5; | 1033 | msrc = 5; |
1031 | } else { | 1034 | } else { |
1035 | const u8 *edid_s = fb_firmware_edid(&dinfo->pdev->dev); | ||
1036 | u8 *edid_d = NULL; | ||
1037 | |||
1038 | if (edid_s) { | ||
1039 | edid_d = kmalloc(EDID_LENGTH, GFP_KERNEL); | ||
1040 | |||
1041 | if (edid_d) { | ||
1042 | memcpy(edid_d, edid_s, EDID_LENGTH); | ||
1043 | fb_edid_to_monspecs(edid_d, | ||
1044 | &dinfo->info->monspecs); | ||
1045 | kfree(edid_d); | ||
1046 | } | ||
1047 | } | ||
1048 | |||
1032 | if (mode) { | 1049 | if (mode) { |
1050 | printk("intelfb: Looking for mode in private " | ||
1051 | "database\n"); | ||
1033 | msrc = fb_find_mode(var, dinfo->info, mode, | 1052 | msrc = fb_find_mode(var, dinfo->info, mode, |
1034 | vesa_modes, VESA_MODEDB_SIZE, | 1053 | dinfo->info->monspecs.modedb, |
1054 | dinfo->info->monspecs.modedb_len, | ||
1035 | NULL, 0); | 1055 | NULL, 0); |
1036 | if (msrc) | 1056 | |
1037 | msrc |= 8; | 1057 | if (msrc && msrc > 1) { |
1058 | printk("intelfb: No mode in private database, " | ||
1059 | "intelfb: looking for mode in global " | ||
1060 | "database "); | ||
1061 | msrc = fb_find_mode(var, dinfo->info, mode, | ||
1062 | NULL, 0, NULL, 0); | ||
1063 | |||
1064 | if (msrc) | ||
1065 | msrc |= 8; | ||
1066 | } | ||
1067 | |||
1038 | } | 1068 | } |
1069 | |||
1039 | if (!msrc) { | 1070 | if (!msrc) { |
1040 | msrc = fb_find_mode(var, dinfo->info, PREFERRED_MODE, | 1071 | msrc = fb_find_mode(var, dinfo->info, PREFERRED_MODE, |
1041 | vesa_modes, VESA_MODEDB_SIZE, | 1072 | NULL, 0, NULL, 0); |
1042 | NULL, 0); | ||
1043 | } | 1073 | } |
1044 | } | 1074 | } |
1045 | 1075 | ||
@@ -1139,7 +1169,10 @@ update_dinfo(struct intelfb_info *dinfo, struct fb_var_screeninfo *var) | |||
1139 | } | 1169 | } |
1140 | 1170 | ||
1141 | /* Make sure the line length is a aligned correctly. */ | 1171 | /* Make sure the line length is a aligned correctly. */ |
1142 | dinfo->pitch = ROUND_UP_TO(dinfo->pitch, STRIDE_ALIGNMENT); | 1172 | if (IS_I9XX(dinfo)) |
1173 | dinfo->pitch = ROUND_UP_TO(dinfo->pitch, STRIDE_ALIGNMENT_I9XX); | ||
1174 | else | ||
1175 | dinfo->pitch = ROUND_UP_TO(dinfo->pitch, STRIDE_ALIGNMENT); | ||
1143 | 1176 | ||
1144 | if (FIXED_MODE(dinfo)) | 1177 | if (FIXED_MODE(dinfo)) |
1145 | dinfo->pitch = dinfo->initial_pitch; | 1178 | dinfo->pitch = dinfo->initial_pitch; |
@@ -1162,16 +1195,33 @@ intelfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) | |||
1162 | struct fb_var_screeninfo v; | 1195 | struct fb_var_screeninfo v; |
1163 | struct intelfb_info *dinfo; | 1196 | struct intelfb_info *dinfo; |
1164 | static int first = 1; | 1197 | static int first = 1; |
1198 | int i; | ||
1199 | /* Good pitches to allow tiling. Don't care about pitches < 1024. */ | ||
1200 | static const int pitches[] = { | ||
1201 | 128 * 8, | ||
1202 | 128 * 16, | ||
1203 | 128 * 32, | ||
1204 | 128 * 64, | ||
1205 | 0 | ||
1206 | }; | ||
1165 | 1207 | ||
1166 | DBG_MSG("intelfb_check_var: accel_flags is %d\n", var->accel_flags); | 1208 | DBG_MSG("intelfb_check_var: accel_flags is %d\n", var->accel_flags); |
1167 | 1209 | ||
1168 | dinfo = GET_DINFO(info); | 1210 | dinfo = GET_DINFO(info); |
1169 | 1211 | ||
1212 | /* update the pitch */ | ||
1170 | if (intelfbhw_validate_mode(dinfo, var) != 0) | 1213 | if (intelfbhw_validate_mode(dinfo, var) != 0) |
1171 | return -EINVAL; | 1214 | return -EINVAL; |
1172 | 1215 | ||
1173 | v = *var; | 1216 | v = *var; |
1174 | 1217 | ||
1218 | for (i = 0; pitches[i] != 0; i++) { | ||
1219 | if (pitches[i] >= v.xres_virtual) { | ||
1220 | v.xres_virtual = pitches[i]; | ||
1221 | break; | ||
1222 | } | ||
1223 | } | ||
1224 | |||
1175 | /* Check for a supported bpp. */ | 1225 | /* Check for a supported bpp. */ |
1176 | if (v.bits_per_pixel <= 8) { | 1226 | if (v.bits_per_pixel <= 8) { |
1177 | v.bits_per_pixel = 8; | 1227 | v.bits_per_pixel = 8; |
@@ -1467,7 +1517,7 @@ static int | |||
1467 | intelfb_cursor(struct fb_info *info, struct fb_cursor *cursor) | 1517 | intelfb_cursor(struct fb_info *info, struct fb_cursor *cursor) |
1468 | { | 1518 | { |
1469 | struct intelfb_info *dinfo = GET_DINFO(info); | 1519 | struct intelfb_info *dinfo = GET_DINFO(info); |
1470 | 1520 | u32 physical; | |
1471 | #if VERBOSE > 0 | 1521 | #if VERBOSE > 0 |
1472 | DBG_MSG("intelfb_cursor\n"); | 1522 | DBG_MSG("intelfb_cursor\n"); |
1473 | #endif | 1523 | #endif |
@@ -1478,7 +1528,10 @@ intelfb_cursor(struct fb_info *info, struct fb_cursor *cursor) | |||
1478 | intelfbhw_cursor_hide(dinfo); | 1528 | intelfbhw_cursor_hide(dinfo); |
1479 | 1529 | ||
1480 | /* If XFree killed the cursor - restore it */ | 1530 | /* If XFree killed the cursor - restore it */ |
1481 | if (INREG(CURSOR_A_BASEADDR) != dinfo->cursor.offset << 12) { | 1531 | physical = (dinfo->mobile || IS_I9XX(dinfo)) ? dinfo->cursor.physical : |
1532 | (dinfo->cursor.offset << 12); | ||
1533 | |||
1534 | if (INREG(CURSOR_A_BASEADDR) != physical) { | ||
1482 | u32 fg, bg; | 1535 | u32 fg, bg; |
1483 | 1536 | ||
1484 | DBG_MSG("the cursor was killed - restore it !!\n"); | 1537 | DBG_MSG("the cursor was killed - restore it !!\n"); |
diff --git a/drivers/video/intelfb/intelfbhw.c b/drivers/video/intelfb/intelfbhw.c index 624c4bc96f0d..426b7430b125 100644 --- a/drivers/video/intelfb/intelfbhw.c +++ b/drivers/video/intelfb/intelfbhw.c | |||
@@ -40,68 +40,110 @@ | |||
40 | #include "intelfb.h" | 40 | #include "intelfb.h" |
41 | #include "intelfbhw.h" | 41 | #include "intelfbhw.h" |
42 | 42 | ||
43 | struct pll_min_max { | ||
44 | int min_m, max_m, min_m1, max_m1; | ||
45 | int min_m2, max_m2, min_n, max_n; | ||
46 | int min_p, max_p, min_p1, max_p1; | ||
47 | int min_vco, max_vco, p_transition_clk, ref_clk; | ||
48 | int p_inc_lo, p_inc_hi; | ||
49 | }; | ||
50 | |||
51 | #define PLLS_I8xx 0 | ||
52 | #define PLLS_I9xx 1 | ||
53 | #define PLLS_MAX 2 | ||
54 | |||
55 | static struct pll_min_max plls[PLLS_MAX] = { | ||
56 | { 108, 140, 18, 26, | ||
57 | 6, 16, 3, 16, | ||
58 | 4, 128, 0, 31, | ||
59 | 930000, 1400000, 165000, 48000, | ||
60 | 4, 2 }, //I8xx | ||
61 | |||
62 | { 75, 120, 10, 20, | ||
63 | 5, 9, 4, 7, | ||
64 | 5, 80, 1, 8, | ||
65 | 1400000, 2800000, 200000, 96000, | ||
66 | 10, 5 } //I9xx | ||
67 | }; | ||
68 | |||
43 | int | 69 | int |
44 | intelfbhw_get_chipset(struct pci_dev *pdev, const char **name, int *chipset, | 70 | intelfbhw_get_chipset(struct pci_dev *pdev, struct intelfb_info *dinfo) |
45 | int *mobile) | ||
46 | { | 71 | { |
47 | u32 tmp; | 72 | u32 tmp; |
48 | 73 | if (!pdev || !dinfo) | |
49 | if (!pdev || !name || !chipset || !mobile) | ||
50 | return 1; | 74 | return 1; |
51 | 75 | ||
52 | switch (pdev->device) { | 76 | switch (pdev->device) { |
53 | case PCI_DEVICE_ID_INTEL_830M: | 77 | case PCI_DEVICE_ID_INTEL_830M: |
54 | *name = "Intel(R) 830M"; | 78 | dinfo->name = "Intel(R) 830M"; |
55 | *chipset = INTEL_830M; | 79 | dinfo->chipset = INTEL_830M; |
56 | *mobile = 1; | 80 | dinfo->mobile = 1; |
81 | dinfo->pll_index = PLLS_I8xx; | ||
57 | return 0; | 82 | return 0; |
58 | case PCI_DEVICE_ID_INTEL_845G: | 83 | case PCI_DEVICE_ID_INTEL_845G: |
59 | *name = "Intel(R) 845G"; | 84 | dinfo->name = "Intel(R) 845G"; |
60 | *chipset = INTEL_845G; | 85 | dinfo->chipset = INTEL_845G; |
61 | *mobile = 0; | 86 | dinfo->mobile = 0; |
87 | dinfo->pll_index = PLLS_I8xx; | ||
62 | return 0; | 88 | return 0; |
63 | case PCI_DEVICE_ID_INTEL_85XGM: | 89 | case PCI_DEVICE_ID_INTEL_85XGM: |
64 | tmp = 0; | 90 | tmp = 0; |
65 | *mobile = 1; | 91 | dinfo->mobile = 1; |
92 | dinfo->pll_index = PLLS_I8xx; | ||
66 | pci_read_config_dword(pdev, INTEL_85X_CAPID, &tmp); | 93 | pci_read_config_dword(pdev, INTEL_85X_CAPID, &tmp); |
67 | switch ((tmp >> INTEL_85X_VARIANT_SHIFT) & | 94 | switch ((tmp >> INTEL_85X_VARIANT_SHIFT) & |
68 | INTEL_85X_VARIANT_MASK) { | 95 | INTEL_85X_VARIANT_MASK) { |
69 | case INTEL_VAR_855GME: | 96 | case INTEL_VAR_855GME: |
70 | *name = "Intel(R) 855GME"; | 97 | dinfo->name = "Intel(R) 855GME"; |
71 | *chipset = INTEL_855GME; | 98 | dinfo->chipset = INTEL_855GME; |
72 | return 0; | 99 | return 0; |
73 | case INTEL_VAR_855GM: | 100 | case INTEL_VAR_855GM: |
74 | *name = "Intel(R) 855GM"; | 101 | dinfo->name = "Intel(R) 855GM"; |
75 | *chipset = INTEL_855GM; | 102 | dinfo->chipset = INTEL_855GM; |
76 | return 0; | 103 | return 0; |
77 | case INTEL_VAR_852GME: | 104 | case INTEL_VAR_852GME: |
78 | *name = "Intel(R) 852GME"; | 105 | dinfo->name = "Intel(R) 852GME"; |
79 | *chipset = INTEL_852GME; | 106 | dinfo->chipset = INTEL_852GME; |
80 | return 0; | 107 | return 0; |
81 | case INTEL_VAR_852GM: | 108 | case INTEL_VAR_852GM: |
82 | *name = "Intel(R) 852GM"; | 109 | dinfo->name = "Intel(R) 852GM"; |
83 | *chipset = INTEL_852GM; | 110 | dinfo->chipset = INTEL_852GM; |
84 | return 0; | 111 | return 0; |
85 | default: | 112 | default: |
86 | *name = "Intel(R) 852GM/855GM"; | 113 | dinfo->name = "Intel(R) 852GM/855GM"; |
87 | *chipset = INTEL_85XGM; | 114 | dinfo->chipset = INTEL_85XGM; |
88 | return 0; | 115 | return 0; |
89 | } | 116 | } |
90 | break; | 117 | break; |
91 | case PCI_DEVICE_ID_INTEL_865G: | 118 | case PCI_DEVICE_ID_INTEL_865G: |
92 | *name = "Intel(R) 865G"; | 119 | dinfo->name = "Intel(R) 865G"; |
93 | *chipset = INTEL_865G; | 120 | dinfo->chipset = INTEL_865G; |
94 | *mobile = 0; | 121 | dinfo->mobile = 0; |
122 | dinfo->pll_index = PLLS_I8xx; | ||
95 | return 0; | 123 | return 0; |
96 | case PCI_DEVICE_ID_INTEL_915G: | 124 | case PCI_DEVICE_ID_INTEL_915G: |
97 | *name = "Intel(R) 915G"; | 125 | dinfo->name = "Intel(R) 915G"; |
98 | *chipset = INTEL_915G; | 126 | dinfo->chipset = INTEL_915G; |
99 | *mobile = 0; | 127 | dinfo->mobile = 0; |
128 | dinfo->pll_index = PLLS_I9xx; | ||
100 | return 0; | 129 | return 0; |
101 | case PCI_DEVICE_ID_INTEL_915GM: | 130 | case PCI_DEVICE_ID_INTEL_915GM: |
102 | *name = "Intel(R) 915GM"; | 131 | dinfo->name = "Intel(R) 915GM"; |
103 | *chipset = INTEL_915GM; | 132 | dinfo->chipset = INTEL_915GM; |
104 | *mobile = 1; | 133 | dinfo->mobile = 1; |
134 | dinfo->pll_index = PLLS_I9xx; | ||
135 | return 0; | ||
136 | case PCI_DEVICE_ID_INTEL_945G: | ||
137 | dinfo->name = "Intel(R) 945G"; | ||
138 | dinfo->chipset = INTEL_945G; | ||
139 | dinfo->mobile = 0; | ||
140 | dinfo->pll_index = PLLS_I9xx; | ||
141 | return 0; | ||
142 | case PCI_DEVICE_ID_INTEL_945GM: | ||
143 | dinfo->name = "Intel(R) 945GM"; | ||
144 | dinfo->chipset = INTEL_945GM; | ||
145 | dinfo->mobile = 1; | ||
146 | dinfo->pll_index = PLLS_I9xx; | ||
105 | return 0; | 147 | return 0; |
106 | default: | 148 | default: |
107 | return 1; | 149 | return 1; |
@@ -114,6 +156,7 @@ intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size, | |||
114 | { | 156 | { |
115 | struct pci_dev *bridge_dev; | 157 | struct pci_dev *bridge_dev; |
116 | u16 tmp; | 158 | u16 tmp; |
159 | int stolen_overhead; | ||
117 | 160 | ||
118 | if (!pdev || !aperture_size || !stolen_size) | 161 | if (!pdev || !aperture_size || !stolen_size) |
119 | return 1; | 162 | return 1; |
@@ -128,21 +171,41 @@ intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size, | |||
128 | tmp = 0; | 171 | tmp = 0; |
129 | pci_read_config_word(bridge_dev, INTEL_GMCH_CTRL, &tmp); | 172 | pci_read_config_word(bridge_dev, INTEL_GMCH_CTRL, &tmp); |
130 | switch (pdev->device) { | 173 | switch (pdev->device) { |
131 | case PCI_DEVICE_ID_INTEL_830M: | 174 | case PCI_DEVICE_ID_INTEL_915G: |
132 | case PCI_DEVICE_ID_INTEL_845G: | 175 | case PCI_DEVICE_ID_INTEL_915GM: |
176 | case PCI_DEVICE_ID_INTEL_945G: | ||
177 | case PCI_DEVICE_ID_INTEL_945GM: | ||
178 | /* 915 and 945 chipsets support a 256MB aperture. | ||
179 | Aperture size is determined by inspected the | ||
180 | base address of the aperture. */ | ||
181 | if (pci_resource_start(pdev, 2) & 0x08000000) | ||
182 | *aperture_size = MB(128); | ||
183 | else | ||
184 | *aperture_size = MB(256); | ||
185 | break; | ||
186 | default: | ||
133 | if ((tmp & INTEL_GMCH_MEM_MASK) == INTEL_GMCH_MEM_64M) | 187 | if ((tmp & INTEL_GMCH_MEM_MASK) == INTEL_GMCH_MEM_64M) |
134 | *aperture_size = MB(64); | 188 | *aperture_size = MB(64); |
135 | else | 189 | else |
136 | *aperture_size = MB(128); | 190 | *aperture_size = MB(128); |
191 | break; | ||
192 | } | ||
193 | |||
194 | /* Stolen memory size is reduced by the GTT and the popup. | ||
195 | GTT is 1K per MB of aperture size, and popup is 4K. */ | ||
196 | stolen_overhead = (*aperture_size / MB(1)) + 4; | ||
197 | switch(pdev->device) { | ||
198 | case PCI_DEVICE_ID_INTEL_830M: | ||
199 | case PCI_DEVICE_ID_INTEL_845G: | ||
137 | switch (tmp & INTEL_830_GMCH_GMS_MASK) { | 200 | switch (tmp & INTEL_830_GMCH_GMS_MASK) { |
138 | case INTEL_830_GMCH_GMS_STOLEN_512: | 201 | case INTEL_830_GMCH_GMS_STOLEN_512: |
139 | *stolen_size = KB(512) - KB(132); | 202 | *stolen_size = KB(512) - KB(stolen_overhead); |
140 | return 0; | 203 | return 0; |
141 | case INTEL_830_GMCH_GMS_STOLEN_1024: | 204 | case INTEL_830_GMCH_GMS_STOLEN_1024: |
142 | *stolen_size = MB(1) - KB(132); | 205 | *stolen_size = MB(1) - KB(stolen_overhead); |
143 | return 0; | 206 | return 0; |
144 | case INTEL_830_GMCH_GMS_STOLEN_8192: | 207 | case INTEL_830_GMCH_GMS_STOLEN_8192: |
145 | *stolen_size = MB(8) - KB(132); | 208 | *stolen_size = MB(8) - KB(stolen_overhead); |
146 | return 0; | 209 | return 0; |
147 | case INTEL_830_GMCH_GMS_LOCAL: | 210 | case INTEL_830_GMCH_GMS_LOCAL: |
148 | ERR_MSG("only local memory found\n"); | 211 | ERR_MSG("only local memory found\n"); |
@@ -157,28 +220,27 @@ intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size, | |||
157 | } | 220 | } |
158 | break; | 221 | break; |
159 | default: | 222 | default: |
160 | *aperture_size = MB(128); | ||
161 | switch (tmp & INTEL_855_GMCH_GMS_MASK) { | 223 | switch (tmp & INTEL_855_GMCH_GMS_MASK) { |
162 | case INTEL_855_GMCH_GMS_STOLEN_1M: | 224 | case INTEL_855_GMCH_GMS_STOLEN_1M: |
163 | *stolen_size = MB(1) - KB(132); | 225 | *stolen_size = MB(1) - KB(stolen_overhead); |
164 | return 0; | 226 | return 0; |
165 | case INTEL_855_GMCH_GMS_STOLEN_4M: | 227 | case INTEL_855_GMCH_GMS_STOLEN_4M: |
166 | *stolen_size = MB(4) - KB(132); | 228 | *stolen_size = MB(4) - KB(stolen_overhead); |
167 | return 0; | 229 | return 0; |
168 | case INTEL_855_GMCH_GMS_STOLEN_8M: | 230 | case INTEL_855_GMCH_GMS_STOLEN_8M: |
169 | *stolen_size = MB(8) - KB(132); | 231 | *stolen_size = MB(8) - KB(stolen_overhead); |
170 | return 0; | 232 | return 0; |
171 | case INTEL_855_GMCH_GMS_STOLEN_16M: | 233 | case INTEL_855_GMCH_GMS_STOLEN_16M: |
172 | *stolen_size = MB(16) - KB(132); | 234 | *stolen_size = MB(16) - KB(stolen_overhead); |
173 | return 0; | 235 | return 0; |
174 | case INTEL_855_GMCH_GMS_STOLEN_32M: | 236 | case INTEL_855_GMCH_GMS_STOLEN_32M: |
175 | *stolen_size = MB(32) - KB(132); | 237 | *stolen_size = MB(32) - KB(stolen_overhead); |
176 | return 0; | 238 | return 0; |
177 | case INTEL_915G_GMCH_GMS_STOLEN_48M: | 239 | case INTEL_915G_GMCH_GMS_STOLEN_48M: |
178 | *stolen_size = MB(48) - KB(132); | 240 | *stolen_size = MB(48) - KB(stolen_overhead); |
179 | return 0; | 241 | return 0; |
180 | case INTEL_915G_GMCH_GMS_STOLEN_64M: | 242 | case INTEL_915G_GMCH_GMS_STOLEN_64M: |
181 | *stolen_size = MB(64) - KB(132); | 243 | *stolen_size = MB(64) - KB(stolen_overhead); |
182 | return 0; | 244 | return 0; |
183 | case INTEL_855_GMCH_GMS_DISABLED: | 245 | case INTEL_855_GMCH_GMS_DISABLED: |
184 | ERR_MSG("video memory is disabled\n"); | 246 | ERR_MSG("video memory is disabled\n"); |
@@ -529,12 +591,63 @@ intelfbhw_read_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, | |||
529 | } | 591 | } |
530 | 592 | ||
531 | 593 | ||
594 | static int calc_vclock3(int index, int m, int n, int p) | ||
595 | { | ||
596 | if (p == 0 || n == 0) | ||
597 | return 0; | ||
598 | return plls[index].ref_clk * m / n / p; | ||
599 | } | ||
600 | |||
601 | static int calc_vclock(int index, int m1, int m2, int n, int p1, int p2, int lvds) | ||
602 | { | ||
603 | struct pll_min_max *pll = &plls[index]; | ||
604 | u32 m, vco, p; | ||
605 | |||
606 | m = (5 * (m1 + 2)) + (m2 + 2); | ||
607 | n += 2; | ||
608 | vco = pll->ref_clk * m / n; | ||
609 | |||
610 | if (index == PLLS_I8xx) { | ||
611 | p = ((p1 + 2) * (1 << (p2 + 1))); | ||
612 | } else { | ||
613 | p = ((p1) * (p2 ? 5 : 10)); | ||
614 | } | ||
615 | return vco / p; | ||
616 | } | ||
617 | |||
618 | static void | ||
619 | intelfbhw_get_p1p2(struct intelfb_info *dinfo, int dpll, int *o_p1, int *o_p2) | ||
620 | { | ||
621 | int p1, p2; | ||
622 | |||
623 | if (IS_I9XX(dinfo)) { | ||
624 | if (dpll & DPLL_P1_FORCE_DIV2) | ||
625 | p1 = 1; | ||
626 | else | ||
627 | p1 = (dpll >> DPLL_P1_SHIFT) & 0xff; | ||
628 | |||
629 | p1 = ffs(p1); | ||
630 | |||
631 | p2 = (dpll >> DPLL_I9XX_P2_SHIFT) & DPLL_P2_MASK; | ||
632 | } else { | ||
633 | if (dpll & DPLL_P1_FORCE_DIV2) | ||
634 | p1 = 0; | ||
635 | else | ||
636 | p1 = (dpll >> DPLL_P1_SHIFT) & DPLL_P1_MASK; | ||
637 | p2 = (dpll >> DPLL_P2_SHIFT) & DPLL_P2_MASK; | ||
638 | } | ||
639 | |||
640 | *o_p1 = p1; | ||
641 | *o_p2 = p2; | ||
642 | } | ||
643 | |||
644 | |||
532 | void | 645 | void |
533 | intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw) | 646 | intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw) |
534 | { | 647 | { |
535 | #if REGDUMP | 648 | #if REGDUMP |
536 | int i, m1, m2, n, p1, p2; | 649 | int i, m1, m2, n, p1, p2; |
537 | 650 | int index = dinfo->pll_index; | |
538 | DBG_MSG("intelfbhw_print_hw_state\n"); | 651 | DBG_MSG("intelfbhw_print_hw_state\n"); |
539 | 652 | ||
540 | if (!hw || !dinfo) | 653 | if (!hw || !dinfo) |
@@ -547,26 +660,22 @@ intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw) | |||
547 | n = (hw->vga0_divisor >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 660 | n = (hw->vga0_divisor >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
548 | m1 = (hw->vga0_divisor >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 661 | m1 = (hw->vga0_divisor >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
549 | m2 = (hw->vga0_divisor >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 662 | m2 = (hw->vga0_divisor >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
550 | if (hw->vga_pd & VGAPD_0_P1_FORCE_DIV2) | 663 | |
551 | p1 = 0; | 664 | intelfbhw_get_p1p2(dinfo, hw->vga_pd, &p1, &p2); |
552 | else | 665 | |
553 | p1 = (hw->vga_pd >> VGAPD_0_P1_SHIFT) & DPLL_P1_MASK; | ||
554 | p2 = (hw->vga_pd >> VGAPD_0_P2_SHIFT) & DPLL_P2_MASK; | ||
555 | printk(" VGA0: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", | 666 | printk(" VGA0: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", |
556 | m1, m2, n, p1, p2); | 667 | m1, m2, n, p1, p2); |
557 | printk(" VGA0: clock is %d\n", CALC_VCLOCK(m1, m2, n, p1, p2)); | 668 | printk(" VGA0: clock is %d\n", |
669 | calc_vclock(index, m1, m2, n, p1, p2, 0)); | ||
558 | 670 | ||
559 | n = (hw->vga1_divisor >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 671 | n = (hw->vga1_divisor >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
560 | m1 = (hw->vga1_divisor >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 672 | m1 = (hw->vga1_divisor >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
561 | m2 = (hw->vga1_divisor >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 673 | m2 = (hw->vga1_divisor >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
562 | if (hw->vga_pd & VGAPD_1_P1_FORCE_DIV2) | 674 | |
563 | p1 = 0; | 675 | intelfbhw_get_p1p2(dinfo, hw->vga_pd, &p1, &p2); |
564 | else | ||
565 | p1 = (hw->vga_pd >> VGAPD_1_P1_SHIFT) & DPLL_P1_MASK; | ||
566 | p2 = (hw->vga_pd >> VGAPD_1_P2_SHIFT) & DPLL_P2_MASK; | ||
567 | printk(" VGA1: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", | 676 | printk(" VGA1: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", |
568 | m1, m2, n, p1, p2); | 677 | m1, m2, n, p1, p2); |
569 | printk(" VGA1: clock is %d\n", CALC_VCLOCK(m1, m2, n, p1, p2)); | 678 | printk(" VGA1: clock is %d\n", calc_vclock(index, m1, m2, n, p1, p2, 0)); |
570 | 679 | ||
571 | printk(" DPLL_A: 0x%08x\n", hw->dpll_a); | 680 | printk(" DPLL_A: 0x%08x\n", hw->dpll_a); |
572 | printk(" DPLL_B: 0x%08x\n", hw->dpll_b); | 681 | printk(" DPLL_B: 0x%08x\n", hw->dpll_b); |
@@ -578,34 +687,30 @@ intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw) | |||
578 | n = (hw->fpa0 >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 687 | n = (hw->fpa0 >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
579 | m1 = (hw->fpa0 >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 688 | m1 = (hw->fpa0 >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
580 | m2 = (hw->fpa0 >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 689 | m2 = (hw->fpa0 >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
581 | if (hw->dpll_a & DPLL_P1_FORCE_DIV2) | 690 | |
582 | p1 = 0; | 691 | intelfbhw_get_p1p2(dinfo, hw->dpll_a, &p1, &p2); |
583 | else | 692 | |
584 | p1 = (hw->dpll_a >> DPLL_P1_SHIFT) & DPLL_P1_MASK; | ||
585 | p2 = (hw->dpll_a >> DPLL_P2_SHIFT) & DPLL_P2_MASK; | ||
586 | printk(" PLLA0: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", | 693 | printk(" PLLA0: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", |
587 | m1, m2, n, p1, p2); | 694 | m1, m2, n, p1, p2); |
588 | printk(" PLLA0: clock is %d\n", CALC_VCLOCK(m1, m2, n, p1, p2)); | 695 | printk(" PLLA0: clock is %d\n", calc_vclock(index, m1, m2, n, p1, p2, 0)); |
589 | 696 | ||
590 | n = (hw->fpa1 >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 697 | n = (hw->fpa1 >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
591 | m1 = (hw->fpa1 >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 698 | m1 = (hw->fpa1 >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
592 | m2 = (hw->fpa1 >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; | 699 | m2 = (hw->fpa1 >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; |
593 | if (hw->dpll_a & DPLL_P1_FORCE_DIV2) | 700 | |
594 | p1 = 0; | 701 | intelfbhw_get_p1p2(dinfo, hw->dpll_a, &p1, &p2); |
595 | else | 702 | |
596 | p1 = (hw->dpll_a >> DPLL_P1_SHIFT) & DPLL_P1_MASK; | ||
597 | p2 = (hw->dpll_a >> DPLL_P2_SHIFT) & DPLL_P2_MASK; | ||
598 | printk(" PLLA1: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", | 703 | printk(" PLLA1: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", |
599 | m1, m2, n, p1, p2); | 704 | m1, m2, n, p1, p2); |
600 | printk(" PLLA1: clock is %d\n", CALC_VCLOCK(m1, m2, n, p1, p2)); | 705 | printk(" PLLA1: clock is %d\n", calc_vclock(index, m1, m2, n, p1, p2, 0)); |
601 | 706 | ||
602 | #if 0 | 707 | #if 0 |
603 | printk(" PALETTE_A:\n"); | 708 | printk(" PALETTE_A:\n"); |
604 | for (i = 0; i < PALETTE_8_ENTRIES) | 709 | for (i = 0; i < PALETTE_8_ENTRIES) |
605 | printk(" %3d: 0x%08x\n", i, hw->palette_a[i]; | 710 | printk(" %3d: 0x%08x\n", i, hw->palette_a[i]); |
606 | printk(" PALETTE_B:\n"); | 711 | printk(" PALETTE_B:\n"); |
607 | for (i = 0; i < PALETTE_8_ENTRIES) | 712 | for (i = 0; i < PALETTE_8_ENTRIES) |
608 | printk(" %3d: 0x%08x\n", i, hw->palette_b[i]; | 713 | printk(" %3d: 0x%08x\n", i, hw->palette_b[i]); |
609 | #endif | 714 | #endif |
610 | 715 | ||
611 | printk(" HTOTAL_A: 0x%08x\n", hw->htotal_a); | 716 | printk(" HTOTAL_A: 0x%08x\n", hw->htotal_a); |
@@ -680,11 +785,11 @@ intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw) | |||
680 | } | 785 | } |
681 | for (i = 0; i < 3; i++) { | 786 | for (i = 0; i < 3; i++) { |
682 | printk(" SWF3%d 0x%08x\n", i, | 787 | printk(" SWF3%d 0x%08x\n", i, |
683 | hw->swf3x[i]); | 788 | hw->swf3x[i]); |
684 | } | 789 | } |
685 | for (i = 0; i < 8; i++) | 790 | for (i = 0; i < 8; i++) |
686 | printk(" FENCE%d 0x%08x\n", i, | 791 | printk(" FENCE%d 0x%08x\n", i, |
687 | hw->fence[i]); | 792 | hw->fence[i]); |
688 | 793 | ||
689 | printk(" INSTPM 0x%08x\n", hw->instpm); | 794 | printk(" INSTPM 0x%08x\n", hw->instpm); |
690 | printk(" MEM_MODE 0x%08x\n", hw->mem_mode); | 795 | printk(" MEM_MODE 0x%08x\n", hw->mem_mode); |
@@ -695,43 +800,58 @@ intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw) | |||
695 | #endif | 800 | #endif |
696 | } | 801 | } |
697 | 802 | ||
803 | |||
804 | |||
698 | /* Split the M parameter into M1 and M2. */ | 805 | /* Split the M parameter into M1 and M2. */ |
699 | static int | 806 | static int |
700 | splitm(unsigned int m, unsigned int *retm1, unsigned int *retm2) | 807 | splitm(int index, unsigned int m, unsigned int *retm1, unsigned int *retm2) |
701 | { | 808 | { |
702 | int m1, m2; | 809 | int m1, m2; |
703 | 810 | int testm; | |
704 | m1 = (m - 2 - (MIN_M2 + MAX_M2) / 2) / 5 - 2; | 811 | struct pll_min_max *pll = &plls[index]; |
705 | if (m1 < MIN_M1) | 812 | |
706 | m1 = MIN_M1; | 813 | /* no point optimising too much - brute force m */ |
707 | if (m1 > MAX_M1) | 814 | for (m1 = pll->min_m1; m1 < pll->max_m1 + 1; m1++) { |
708 | m1 = MAX_M1; | 815 | for (m2 = pll->min_m2; m2 < pll->max_m2 + 1; m2++) { |
709 | m2 = m - 5 * (m1 + 2) - 2; | 816 | testm = (5 * (m1 + 2)) + (m2 + 2); |
710 | if (m2 < MIN_M2 || m2 > MAX_M2 || m2 >= m1) { | 817 | if (testm == m) { |
711 | return 1; | 818 | *retm1 = (unsigned int)m1; |
712 | } else { | 819 | *retm2 = (unsigned int)m2; |
713 | *retm1 = (unsigned int)m1; | 820 | return 0; |
714 | *retm2 = (unsigned int)m2; | 821 | } |
715 | return 0; | 822 | } |
716 | } | 823 | } |
824 | return 1; | ||
717 | } | 825 | } |
718 | 826 | ||
719 | /* Split the P parameter into P1 and P2. */ | 827 | /* Split the P parameter into P1 and P2. */ |
720 | static int | 828 | static int |
721 | splitp(unsigned int p, unsigned int *retp1, unsigned int *retp2) | 829 | splitp(int index, unsigned int p, unsigned int *retp1, unsigned int *retp2) |
722 | { | 830 | { |
723 | int p1, p2; | 831 | int p1, p2; |
832 | struct pll_min_max *pll = &plls[index]; | ||
833 | |||
834 | if (index == PLLS_I9xx) { | ||
835 | p2 = (p % 10) ? 1 : 0; | ||
836 | |||
837 | p1 = p / (p2 ? 5 : 10); | ||
838 | |||
839 | *retp1 = (unsigned int)p1; | ||
840 | *retp2 = (unsigned int)p2; | ||
841 | return 0; | ||
842 | } | ||
724 | 843 | ||
725 | if (p % 4 == 0) | 844 | if (p % 4 == 0) |
726 | p2 = 1; | 845 | p2 = 1; |
727 | else | 846 | else |
728 | p2 = 0; | 847 | p2 = 0; |
729 | p1 = (p / (1 << (p2 + 1))) - 2; | 848 | p1 = (p / (1 << (p2 + 1))) - 2; |
730 | if (p % 4 == 0 && p1 < MIN_P1) { | 849 | if (p % 4 == 0 && p1 < pll->min_p1) { |
731 | p2 = 0; | 850 | p2 = 0; |
732 | p1 = (p / (1 << (p2 + 1))) - 2; | 851 | p1 = (p / (1 << (p2 + 1))) - 2; |
733 | } | 852 | } |
734 | if (p1 < MIN_P1 || p1 > MAX_P1 || (p1 + 2) * (1 << (p2 + 1)) != p) { | 853 | if (p1 < pll->min_p1 || p1 > pll->max_p1 || |
854 | (p1 + 2) * (1 << (p2 + 1)) != p) { | ||
735 | return 1; | 855 | return 1; |
736 | } else { | 856 | } else { |
737 | *retp1 = (unsigned int)p1; | 857 | *retp1 = (unsigned int)p1; |
@@ -741,14 +861,15 @@ splitp(unsigned int p, unsigned int *retp1, unsigned int *retp2) | |||
741 | } | 861 | } |
742 | 862 | ||
743 | static int | 863 | static int |
744 | calc_pll_params(int clock, u32 *retm1, u32 *retm2, u32 *retn, u32 *retp1, | 864 | calc_pll_params(int index, int clock, u32 *retm1, u32 *retm2, u32 *retn, u32 *retp1, |
745 | u32 *retp2, u32 *retclock) | 865 | u32 *retp2, u32 *retclock) |
746 | { | 866 | { |
747 | u32 m1, m2, n, p1, p2, n1; | 867 | u32 m1, m2, n, p1, p2, n1, testm; |
748 | u32 f_vco, p, p_best = 0, m, f_out; | 868 | u32 f_vco, p, p_best = 0, m, f_out = 0; |
749 | u32 err_max, err_target, err_best = 10000000; | 869 | u32 err_max, err_target, err_best = 10000000; |
750 | u32 n_best = 0, m_best = 0, f_best, f_err; | 870 | u32 n_best = 0, m_best = 0, f_best, f_err; |
751 | u32 p_min, p_max, p_inc, div_min, div_max; | 871 | u32 p_min, p_max, p_inc, div_max; |
872 | struct pll_min_max *pll = &plls[index]; | ||
752 | 873 | ||
753 | /* Accept 0.5% difference, but aim for 0.1% */ | 874 | /* Accept 0.5% difference, but aim for 0.1% */ |
754 | err_max = 5 * clock / 1000; | 875 | err_max = 5 * clock / 1000; |
@@ -756,58 +877,56 @@ calc_pll_params(int clock, u32 *retm1, u32 *retm2, u32 *retn, u32 *retp1, | |||
756 | 877 | ||
757 | DBG_MSG("Clock is %d\n", clock); | 878 | DBG_MSG("Clock is %d\n", clock); |
758 | 879 | ||
759 | div_max = MAX_VCO_FREQ / clock; | 880 | div_max = pll->max_vco / clock; |
760 | div_min = ROUND_UP_TO(MIN_VCO_FREQ, clock) / clock; | ||
761 | 881 | ||
762 | if (clock <= P_TRANSITION_CLOCK) | 882 | p_inc = (clock <= pll->p_transition_clk) ? pll->p_inc_lo : pll->p_inc_hi; |
763 | p_inc = 4; | 883 | p_min = p_inc; |
764 | else | ||
765 | p_inc = 2; | ||
766 | p_min = ROUND_UP_TO(div_min, p_inc); | ||
767 | p_max = ROUND_DOWN_TO(div_max, p_inc); | 884 | p_max = ROUND_DOWN_TO(div_max, p_inc); |
768 | if (p_min < MIN_P) | 885 | if (p_min < pll->min_p) |
769 | p_min = 4; | 886 | p_min = pll->min_p; |
770 | if (p_max > MAX_P) | 887 | if (p_max > pll->max_p) |
771 | p_max = 128; | 888 | p_max = pll->max_p; |
772 | 889 | ||
773 | DBG_MSG("p range is %d-%d (%d)\n", p_min, p_max, p_inc); | 890 | DBG_MSG("p range is %d-%d (%d)\n", p_min, p_max, p_inc); |
774 | 891 | ||
775 | p = p_min; | 892 | p = p_min; |
776 | do { | 893 | do { |
777 | if (splitp(p, &p1, &p2)) { | 894 | if (splitp(index, p, &p1, &p2)) { |
778 | WRN_MSG("cannot split p = %d\n", p); | 895 | WRN_MSG("cannot split p = %d\n", p); |
779 | p += p_inc; | 896 | p += p_inc; |
780 | continue; | 897 | continue; |
781 | } | 898 | } |
782 | n = MIN_N; | 899 | n = pll->min_n; |
783 | f_vco = clock * p; | 900 | f_vco = clock * p; |
784 | 901 | ||
785 | do { | 902 | do { |
786 | m = ROUND_UP_TO(f_vco * n, PLL_REFCLK) / PLL_REFCLK; | 903 | m = ROUND_UP_TO(f_vco * n, pll->ref_clk) / pll->ref_clk; |
787 | if (m < MIN_M) | 904 | if (m < pll->min_m) |
788 | m = MIN_M; | 905 | m = pll->min_m + 1; |
789 | if (m > MAX_M) | 906 | if (m > pll->max_m) |
790 | m = MAX_M; | 907 | m = pll->max_m - 1; |
791 | f_out = CALC_VCLOCK3(m, n, p); | 908 | for (testm = m - 1; testm <= m; testm++) { |
792 | if (splitm(m, &m1, &m2)) { | 909 | f_out = calc_vclock3(index, m, n, p); |
793 | WRN_MSG("cannot split m = %d\n", m); | 910 | if (splitm(index, testm, &m1, &m2)) { |
794 | n++; | 911 | WRN_MSG("cannot split m = %d\n", m); |
795 | continue; | 912 | n++; |
796 | } | 913 | continue; |
797 | if (clock > f_out) | 914 | } |
798 | f_err = clock - f_out; | 915 | if (clock > f_out) |
799 | else | 916 | f_err = clock - f_out; |
800 | f_err = f_out - clock; | 917 | else/* slightly bias the error for bigger clocks */ |
801 | 918 | f_err = f_out - clock + 1; | |
802 | if (f_err < err_best) { | 919 | |
803 | m_best = m; | 920 | if (f_err < err_best) { |
804 | n_best = n; | 921 | m_best = testm; |
805 | p_best = p; | 922 | n_best = n; |
806 | f_best = f_out; | 923 | p_best = p; |
807 | err_best = f_err; | 924 | f_best = f_out; |
925 | err_best = f_err; | ||
926 | } | ||
808 | } | 927 | } |
809 | n++; | 928 | n++; |
810 | } while ((n <= MAX_N) && (f_out >= clock)); | 929 | } while ((n <= pll->max_n) && (f_out >= clock)); |
811 | p += p_inc; | 930 | p += p_inc; |
812 | } while ((p <= p_max)); | 931 | } while ((p <= p_max)); |
813 | 932 | ||
@@ -818,21 +937,22 @@ calc_pll_params(int clock, u32 *retm1, u32 *retm2, u32 *retn, u32 *retp1, | |||
818 | m = m_best; | 937 | m = m_best; |
819 | n = n_best; | 938 | n = n_best; |
820 | p = p_best; | 939 | p = p_best; |
821 | splitm(m, &m1, &m2); | 940 | splitm(index, m, &m1, &m2); |
822 | splitp(p, &p1, &p2); | 941 | splitp(index, p, &p1, &p2); |
823 | n1 = n - 2; | 942 | n1 = n - 2; |
824 | 943 | ||
825 | DBG_MSG("m, n, p: %d (%d,%d), %d (%d), %d (%d,%d), " | 944 | DBG_MSG("m, n, p: %d (%d,%d), %d (%d), %d (%d,%d), " |
826 | "f: %d (%d), VCO: %d\n", | 945 | "f: %d (%d), VCO: %d\n", |
827 | m, m1, m2, n, n1, p, p1, p2, | 946 | m, m1, m2, n, n1, p, p1, p2, |
828 | CALC_VCLOCK3(m, n, p), CALC_VCLOCK(m1, m2, n1, p1, p2), | 947 | calc_vclock3(index, m, n, p), |
829 | CALC_VCLOCK3(m, n, p) * p); | 948 | calc_vclock(index, m1, m2, n1, p1, p2, 0), |
949 | calc_vclock3(index, m, n, p) * p); | ||
830 | *retm1 = m1; | 950 | *retm1 = m1; |
831 | *retm2 = m2; | 951 | *retm2 = m2; |
832 | *retn = n1; | 952 | *retn = n1; |
833 | *retp1 = p1; | 953 | *retp1 = p1; |
834 | *retp2 = p2; | 954 | *retp2 = p2; |
835 | *retclock = CALC_VCLOCK(m1, m2, n1, p1, p2); | 955 | *retclock = calc_vclock(index, m1, m2, n1, p1, p2, 0); |
836 | 956 | ||
837 | return 0; | 957 | return 0; |
838 | } | 958 | } |
@@ -860,6 +980,7 @@ intelfbhw_mode_to_hw(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, | |||
860 | u32 vsync_start, vsync_end, vblank_start, vblank_end, vtotal, vactive; | 980 | u32 vsync_start, vsync_end, vblank_start, vblank_end, vtotal, vactive; |
861 | u32 vsync_pol, hsync_pol; | 981 | u32 vsync_pol, hsync_pol; |
862 | u32 *vs, *vb, *vt, *hs, *hb, *ht, *ss, *pipe_conf; | 982 | u32 *vs, *vb, *vt, *hs, *hb, *ht, *ss, *pipe_conf; |
983 | u32 stride_alignment; | ||
863 | 984 | ||
864 | DBG_MSG("intelfbhw_mode_to_hw\n"); | 985 | DBG_MSG("intelfbhw_mode_to_hw\n"); |
865 | 986 | ||
@@ -929,7 +1050,8 @@ intelfbhw_mode_to_hw(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, | |||
929 | /* Desired clock in kHz */ | 1050 | /* Desired clock in kHz */ |
930 | clock_target = 1000000000 / var->pixclock; | 1051 | clock_target = 1000000000 / var->pixclock; |
931 | 1052 | ||
932 | if (calc_pll_params(clock_target, &m1, &m2, &n, &p1, &p2, &clock)) { | 1053 | if (calc_pll_params(dinfo->pll_index, clock_target, &m1, &m2, |
1054 | &n, &p1, &p2, &clock)) { | ||
933 | WRN_MSG("calc_pll_params failed\n"); | 1055 | WRN_MSG("calc_pll_params failed\n"); |
934 | return 1; | 1056 | return 1; |
935 | } | 1057 | } |
@@ -949,7 +1071,14 @@ intelfbhw_mode_to_hw(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, | |||
949 | *dpll &= ~DPLL_P1_FORCE_DIV2; | 1071 | *dpll &= ~DPLL_P1_FORCE_DIV2; |
950 | *dpll &= ~((DPLL_P2_MASK << DPLL_P2_SHIFT) | | 1072 | *dpll &= ~((DPLL_P2_MASK << DPLL_P2_SHIFT) | |
951 | (DPLL_P1_MASK << DPLL_P1_SHIFT)); | 1073 | (DPLL_P1_MASK << DPLL_P1_SHIFT)); |
952 | *dpll |= (p2 << DPLL_P2_SHIFT) | (p1 << DPLL_P1_SHIFT); | 1074 | |
1075 | if (IS_I9XX(dinfo)) { | ||
1076 | *dpll |= (p2 << DPLL_I9XX_P2_SHIFT); | ||
1077 | *dpll |= (1 << (p1 - 1)) << DPLL_P1_SHIFT; | ||
1078 | } else { | ||
1079 | *dpll |= (p2 << DPLL_P2_SHIFT) | (p1 << DPLL_P1_SHIFT); | ||
1080 | } | ||
1081 | |||
953 | *fp0 = (n << FP_N_DIVISOR_SHIFT) | | 1082 | *fp0 = (n << FP_N_DIVISOR_SHIFT) | |
954 | (m1 << FP_M1_DIVISOR_SHIFT) | | 1083 | (m1 << FP_M1_DIVISOR_SHIFT) | |
955 | (m2 << FP_M2_DIVISOR_SHIFT); | 1084 | (m2 << FP_M2_DIVISOR_SHIFT); |
@@ -1054,7 +1183,7 @@ intelfbhw_mode_to_hw(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, | |||
1054 | *ss = (hactive << SRC_SIZE_HORIZ_SHIFT) | | 1183 | *ss = (hactive << SRC_SIZE_HORIZ_SHIFT) | |
1055 | (vactive << SRC_SIZE_VERT_SHIFT); | 1184 | (vactive << SRC_SIZE_VERT_SHIFT); |
1056 | 1185 | ||
1057 | hw->disp_a_stride = var->xres_virtual * var->bits_per_pixel / 8; | 1186 | hw->disp_a_stride = dinfo->pitch; |
1058 | DBG_MSG("pitch is %d\n", hw->disp_a_stride); | 1187 | DBG_MSG("pitch is %d\n", hw->disp_a_stride); |
1059 | 1188 | ||
1060 | hw->disp_a_base = hw->disp_a_stride * var->yoffset + | 1189 | hw->disp_a_base = hw->disp_a_stride * var->yoffset + |
@@ -1063,9 +1192,11 @@ intelfbhw_mode_to_hw(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, | |||
1063 | hw->disp_a_base += dinfo->fb.offset << 12; | 1192 | hw->disp_a_base += dinfo->fb.offset << 12; |
1064 | 1193 | ||
1065 | /* Check stride alignment. */ | 1194 | /* Check stride alignment. */ |
1066 | if (hw->disp_a_stride % STRIDE_ALIGNMENT != 0) { | 1195 | stride_alignment = IS_I9XX(dinfo) ? STRIDE_ALIGNMENT_I9XX : |
1196 | STRIDE_ALIGNMENT; | ||
1197 | if (hw->disp_a_stride % stride_alignment != 0) { | ||
1067 | WRN_MSG("display stride %d has bad alignment %d\n", | 1198 | WRN_MSG("display stride %d has bad alignment %d\n", |
1068 | hw->disp_a_stride, STRIDE_ALIGNMENT); | 1199 | hw->disp_a_stride, stride_alignment); |
1069 | return 1; | 1200 | return 1; |
1070 | } | 1201 | } |
1071 | 1202 | ||
@@ -1087,6 +1218,7 @@ intelfbhw_program_mode(struct intelfb_info *dinfo, | |||
1087 | u32 hsync_reg, htotal_reg, hblank_reg; | 1218 | u32 hsync_reg, htotal_reg, hblank_reg; |
1088 | u32 vsync_reg, vtotal_reg, vblank_reg; | 1219 | u32 vsync_reg, vtotal_reg, vblank_reg; |
1089 | u32 src_size_reg; | 1220 | u32 src_size_reg; |
1221 | u32 count, tmp_val[3]; | ||
1090 | 1222 | ||
1091 | /* Assume single pipe, display plane A, analog CRT. */ | 1223 | /* Assume single pipe, display plane A, analog CRT. */ |
1092 | 1224 | ||
@@ -1155,6 +1287,27 @@ intelfbhw_program_mode(struct intelfb_info *dinfo, | |||
1155 | src_size_reg = SRC_SIZE_A; | 1287 | src_size_reg = SRC_SIZE_A; |
1156 | } | 1288 | } |
1157 | 1289 | ||
1290 | /* turn off pipe */ | ||
1291 | tmp = INREG(pipe_conf_reg); | ||
1292 | tmp &= ~PIPECONF_ENABLE; | ||
1293 | OUTREG(pipe_conf_reg, tmp); | ||
1294 | |||
1295 | count = 0; | ||
1296 | do { | ||
1297 | tmp_val[count%3] = INREG(0x70000); | ||
1298 | if ((tmp_val[0] == tmp_val[1]) && (tmp_val[1]==tmp_val[2])) | ||
1299 | break; | ||
1300 | count++; | ||
1301 | udelay(1); | ||
1302 | if (count % 200 == 0) { | ||
1303 | tmp = INREG(pipe_conf_reg); | ||
1304 | tmp &= ~PIPECONF_ENABLE; | ||
1305 | OUTREG(pipe_conf_reg, tmp); | ||
1306 | } | ||
1307 | } while(count < 2000); | ||
1308 | |||
1309 | OUTREG(ADPA, INREG(ADPA) & ~ADPA_DAC_ENABLE); | ||
1310 | |||
1158 | /* Disable planes A and B. */ | 1311 | /* Disable planes A and B. */ |
1159 | tmp = INREG(DSPACNTR); | 1312 | tmp = INREG(DSPACNTR); |
1160 | tmp &= ~DISPPLANE_PLANE_ENABLE; | 1313 | tmp &= ~DISPPLANE_PLANE_ENABLE; |
@@ -1163,19 +1316,21 @@ intelfbhw_program_mode(struct intelfb_info *dinfo, | |||
1163 | tmp &= ~DISPPLANE_PLANE_ENABLE; | 1316 | tmp &= ~DISPPLANE_PLANE_ENABLE; |
1164 | OUTREG(DSPBCNTR, tmp); | 1317 | OUTREG(DSPBCNTR, tmp); |
1165 | 1318 | ||
1166 | /* Wait for vblank. For now, just wait for a 50Hz cycle (20ms)) */ | 1319 | /* Wait for vblank. For now, just wait for a 50Hz cycle (20ms)) */ |
1167 | mdelay(20); | 1320 | mdelay(20); |
1168 | 1321 | ||
1322 | OUTREG(DVOB, INREG(DVOB) & ~PORT_ENABLE); | ||
1323 | OUTREG(DVOC, INREG(DVOC) & ~PORT_ENABLE); | ||
1324 | OUTREG(ADPA, INREG(ADPA) & ~ADPA_DAC_ENABLE); | ||
1325 | |||
1169 | /* Disable Sync */ | 1326 | /* Disable Sync */ |
1170 | tmp = INREG(ADPA); | 1327 | tmp = INREG(ADPA); |
1171 | tmp &= ~ADPA_DPMS_CONTROL_MASK; | 1328 | tmp &= ~ADPA_DPMS_CONTROL_MASK; |
1172 | tmp |= ADPA_DPMS_D3; | 1329 | tmp |= ADPA_DPMS_D3; |
1173 | OUTREG(ADPA, tmp); | 1330 | OUTREG(ADPA, tmp); |
1174 | 1331 | ||
1175 | /* turn off pipe */ | 1332 | /* do some funky magic - xyzzy */ |
1176 | tmp = INREG(pipe_conf_reg); | 1333 | OUTREG(0x61204, 0xabcd0000); |
1177 | tmp &= ~PIPECONF_ENABLE; | ||
1178 | OUTREG(pipe_conf_reg, tmp); | ||
1179 | 1334 | ||
1180 | /* turn off PLL */ | 1335 | /* turn off PLL */ |
1181 | tmp = INREG(dpll_reg); | 1336 | tmp = INREG(dpll_reg); |
@@ -1183,30 +1338,31 @@ intelfbhw_program_mode(struct intelfb_info *dinfo, | |||
1183 | OUTREG(dpll_reg, tmp); | 1338 | OUTREG(dpll_reg, tmp); |
1184 | 1339 | ||
1185 | /* Set PLL parameters */ | 1340 | /* Set PLL parameters */ |
1186 | OUTREG(dpll_reg, *dpll & ~DPLL_VCO_ENABLE); | ||
1187 | OUTREG(fp0_reg, *fp0); | 1341 | OUTREG(fp0_reg, *fp0); |
1188 | OUTREG(fp1_reg, *fp1); | 1342 | OUTREG(fp1_reg, *fp1); |
1189 | 1343 | ||
1190 | /* Set pipe parameters */ | 1344 | /* Enable PLL */ |
1191 | OUTREG(hsync_reg, *hs); | 1345 | OUTREG(dpll_reg, *dpll); |
1192 | OUTREG(hblank_reg, *hb); | ||
1193 | OUTREG(htotal_reg, *ht); | ||
1194 | OUTREG(vsync_reg, *vs); | ||
1195 | OUTREG(vblank_reg, *vb); | ||
1196 | OUTREG(vtotal_reg, *vt); | ||
1197 | OUTREG(src_size_reg, *ss); | ||
1198 | 1346 | ||
1199 | /* Set DVOs B/C */ | 1347 | /* Set DVOs B/C */ |
1200 | OUTREG(DVOB, hw->dvob); | 1348 | OUTREG(DVOB, hw->dvob); |
1201 | OUTREG(DVOC, hw->dvoc); | 1349 | OUTREG(DVOC, hw->dvoc); |
1202 | 1350 | ||
1351 | /* undo funky magic */ | ||
1352 | OUTREG(0x61204, 0x00000000); | ||
1353 | |||
1203 | /* Set ADPA */ | 1354 | /* Set ADPA */ |
1355 | OUTREG(ADPA, INREG(ADPA) | ADPA_DAC_ENABLE); | ||
1204 | OUTREG(ADPA, (hw->adpa & ~(ADPA_DPMS_CONTROL_MASK)) | ADPA_DPMS_D3); | 1356 | OUTREG(ADPA, (hw->adpa & ~(ADPA_DPMS_CONTROL_MASK)) | ADPA_DPMS_D3); |
1205 | 1357 | ||
1206 | /* Enable PLL */ | 1358 | /* Set pipe parameters */ |
1207 | tmp = INREG(dpll_reg); | 1359 | OUTREG(hsync_reg, *hs); |
1208 | tmp |= DPLL_VCO_ENABLE; | 1360 | OUTREG(hblank_reg, *hb); |
1209 | OUTREG(dpll_reg, tmp); | 1361 | OUTREG(htotal_reg, *ht); |
1362 | OUTREG(vsync_reg, *vs); | ||
1363 | OUTREG(vblank_reg, *vb); | ||
1364 | OUTREG(vtotal_reg, *vt); | ||
1365 | OUTREG(src_size_reg, *ss); | ||
1210 | 1366 | ||
1211 | /* Enable pipe */ | 1367 | /* Enable pipe */ |
1212 | OUTREG(pipe_conf_reg, *pipe_conf | PIPECONF_ENABLE); | 1368 | OUTREG(pipe_conf_reg, *pipe_conf | PIPECONF_ENABLE); |
@@ -1231,7 +1387,7 @@ intelfbhw_program_mode(struct intelfb_info *dinfo, | |||
1231 | OUTREG(DSPACNTR, | 1387 | OUTREG(DSPACNTR, |
1232 | hw->disp_a_ctrl|DISPPLANE_PLANE_ENABLE); | 1388 | hw->disp_a_ctrl|DISPPLANE_PLANE_ENABLE); |
1233 | mdelay(1); | 1389 | mdelay(1); |
1234 | } | 1390 | } |
1235 | } | 1391 | } |
1236 | 1392 | ||
1237 | OUTREG(DSPACNTR, hw->disp_a_ctrl & ~DISPPLANE_PLANE_ENABLE); | 1393 | OUTREG(DSPACNTR, hw->disp_a_ctrl & ~DISPPLANE_PLANE_ENABLE); |
@@ -1616,7 +1772,7 @@ intelfbhw_cursor_init(struct intelfb_info *dinfo) | |||
1616 | DBG_MSG("intelfbhw_cursor_init\n"); | 1772 | DBG_MSG("intelfbhw_cursor_init\n"); |
1617 | #endif | 1773 | #endif |
1618 | 1774 | ||
1619 | if (dinfo->mobile) { | 1775 | if (dinfo->mobile || IS_I9XX(dinfo)) { |
1620 | if (!dinfo->cursor.physical) | 1776 | if (!dinfo->cursor.physical) |
1621 | return; | 1777 | return; |
1622 | tmp = INREG(CURSOR_A_CONTROL); | 1778 | tmp = INREG(CURSOR_A_CONTROL); |
@@ -1649,7 +1805,7 @@ intelfbhw_cursor_hide(struct intelfb_info *dinfo) | |||
1649 | #endif | 1805 | #endif |
1650 | 1806 | ||
1651 | dinfo->cursor_on = 0; | 1807 | dinfo->cursor_on = 0; |
1652 | if (dinfo->mobile) { | 1808 | if (dinfo->mobile || IS_I9XX(dinfo)) { |
1653 | if (!dinfo->cursor.physical) | 1809 | if (!dinfo->cursor.physical) |
1654 | return; | 1810 | return; |
1655 | tmp = INREG(CURSOR_A_CONTROL); | 1811 | tmp = INREG(CURSOR_A_CONTROL); |
@@ -1679,7 +1835,7 @@ intelfbhw_cursor_show(struct intelfb_info *dinfo) | |||
1679 | if (dinfo->cursor_blanked) | 1835 | if (dinfo->cursor_blanked) |
1680 | return; | 1836 | return; |
1681 | 1837 | ||
1682 | if (dinfo->mobile) { | 1838 | if (dinfo->mobile || IS_I9XX(dinfo)) { |
1683 | if (!dinfo->cursor.physical) | 1839 | if (!dinfo->cursor.physical) |
1684 | return; | 1840 | return; |
1685 | tmp = INREG(CURSOR_A_CONTROL); | 1841 | tmp = INREG(CURSOR_A_CONTROL); |
@@ -1705,14 +1861,18 @@ intelfbhw_cursor_setpos(struct intelfb_info *dinfo, int x, int y) | |||
1705 | #endif | 1861 | #endif |
1706 | 1862 | ||
1707 | /* | 1863 | /* |
1708 | * Sets the position. The coordinates are assumed to already | 1864 | * Sets the position. The coordinates are assumed to already |
1709 | * have any offset adjusted. Assume that the cursor is never | 1865 | * have any offset adjusted. Assume that the cursor is never |
1710 | * completely off-screen, and that x, y are always >= 0. | 1866 | * completely off-screen, and that x, y are always >= 0. |
1711 | */ | 1867 | */ |
1712 | 1868 | ||
1713 | tmp = ((x & CURSOR_POS_MASK) << CURSOR_X_SHIFT) | | 1869 | tmp = ((x & CURSOR_POS_MASK) << CURSOR_X_SHIFT) | |
1714 | ((y & CURSOR_POS_MASK) << CURSOR_Y_SHIFT); | 1870 | ((y & CURSOR_POS_MASK) << CURSOR_Y_SHIFT); |
1715 | OUTREG(CURSOR_A_POSITION, tmp); | 1871 | OUTREG(CURSOR_A_POSITION, tmp); |
1872 | |||
1873 | if (IS_I9XX(dinfo)) { | ||
1874 | OUTREG(CURSOR_A_BASEADDR, dinfo->cursor.physical); | ||
1875 | } | ||
1716 | } | 1876 | } |
1717 | 1877 | ||
1718 | void | 1878 | void |
diff --git a/drivers/video/intelfb/intelfbhw.h b/drivers/video/intelfb/intelfbhw.h index ba1920159f52..10acda098b71 100644 --- a/drivers/video/intelfb/intelfbhw.h +++ b/drivers/video/intelfb/intelfbhw.h | |||
@@ -133,6 +133,7 @@ | |||
133 | #define DPLL_VGA_MODE_DISABLE (1 << 28) | 133 | #define DPLL_VGA_MODE_DISABLE (1 << 28) |
134 | #define DPLL_P2_MASK 1 | 134 | #define DPLL_P2_MASK 1 |
135 | #define DPLL_P2_SHIFT 23 | 135 | #define DPLL_P2_SHIFT 23 |
136 | #define DPLL_I9XX_P2_SHIFT 24 | ||
136 | #define DPLL_P1_FORCE_DIV2 (1 << 21) | 137 | #define DPLL_P1_FORCE_DIV2 (1 << 21) |
137 | #define DPLL_P1_MASK 0x1f | 138 | #define DPLL_P1_MASK 0x1f |
138 | #define DPLL_P1_SHIFT 16 | 139 | #define DPLL_P1_SHIFT 16 |
@@ -155,29 +156,8 @@ | |||
155 | /* PLL parameters (these are for 852GM/855GM/865G, check earlier chips). */ | 156 | /* PLL parameters (these are for 852GM/855GM/865G, check earlier chips). */ |
156 | /* Clock values are in units of kHz */ | 157 | /* Clock values are in units of kHz */ |
157 | #define PLL_REFCLK 48000 | 158 | #define PLL_REFCLK 48000 |
158 | #define MIN_VCO_FREQ 930000 | ||
159 | #define MAX_VCO_FREQ 1400000 | ||
160 | #define MIN_CLOCK 25000 | 159 | #define MIN_CLOCK 25000 |
161 | #define MAX_CLOCK 350000 | 160 | #define MAX_CLOCK 350000 |
162 | #define P_TRANSITION_CLOCK 165000 | ||
163 | #define MIN_M 108 | ||
164 | #define MAX_M 140 | ||
165 | #define MIN_M1 18 | ||
166 | #define MAX_M1 26 | ||
167 | #define MIN_M2 6 | ||
168 | #define MAX_M2 16 | ||
169 | #define MIN_P 4 | ||
170 | #define MAX_P 128 | ||
171 | #define MIN_P1 0 | ||
172 | #define MAX_P1 31 | ||
173 | #define MIN_N 3 | ||
174 | #define MAX_N 16 | ||
175 | |||
176 | #define CALC_VCLOCK(m1, m2, n, p1, p2) \ | ||
177 | ((PLL_REFCLK * (5 * ((m1) + 2) + ((m2) + 2)) / ((n) + 2)) / \ | ||
178 | (((p1) + 2) * (1 << (p2 + 1)))) | ||
179 | |||
180 | #define CALC_VCLOCK3(m, n, p) ((PLL_REFCLK * (m) / (n)) / (p)) | ||
181 | 161 | ||
182 | /* Two pipes */ | 162 | /* Two pipes */ |
183 | #define PIPE_A 0 | 163 | #define PIPE_A 0 |
@@ -522,8 +502,7 @@ | |||
522 | 502 | ||
523 | 503 | ||
524 | /* function protoypes */ | 504 | /* function protoypes */ |
525 | extern int intelfbhw_get_chipset(struct pci_dev *pdev, const char **name, | 505 | extern int intelfbhw_get_chipset(struct pci_dev *pdev, struct intelfb_info *dinfo); |
526 | int *chipset, int *mobile); | ||
527 | extern int intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size, | 506 | extern int intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size, |
528 | int *stolen_size); | 507 | int *stolen_size); |
529 | extern int intelfbhw_check_non_crt(struct intelfb_info *dinfo); | 508 | extern int intelfbhw_check_non_crt(struct intelfb_info *dinfo); |