tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge master.kernel.org:/home/rmk/linux-2.6-arm

Linus Torvalds 64c4813d babf68de

+102 -92
+12 -12
arch/arm/common/locomo.c
··· 177 177 d = irq_desc + irq; 178 178 for (i = 0; i <= 3; i++, d++, irq++) { 179 179 if (req & (0x0100 << i)) { 180 - d->handle(irq, d, regs); 180 + desc_handle_irq(irq, d, regs); 181 181 } 182 182 183 183 } ··· 220 220 221 221 if (locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC) & 0x0001) { 222 222 d = irq_desc + LOCOMO_IRQ_KEY_START; 223 - d->handle(LOCOMO_IRQ_KEY_START, d, regs); 223 + desc_handle_irq(LOCOMO_IRQ_KEY_START, d, regs); 224 224 } 225 225 } 226 226 ··· 273 273 d = irq_desc + LOCOMO_IRQ_GPIO_START; 274 274 for (i = 0; i <= 15; i++, irq++, d++) { 275 275 if (req & (0x0001 << i)) { 276 - d->handle(irq, d, regs); 276 + desc_handle_irq(irq, d, regs); 277 277 } 278 278 } 279 279 } ··· 328 328 329 329 if (locomo_readl(mapbase + LOCOMO_LTINT) & 0x0001) { 330 330 d = irq_desc + LOCOMO_IRQ_LT_START; 331 - d->handle(LOCOMO_IRQ_LT_START, d, regs); 331 + desc_handle_irq(LOCOMO_IRQ_LT_START, d, regs); 332 332 } 333 333 } 334 334 ··· 379 379 380 380 for (i = 0; i <= 3; i++, irq++, d++) { 381 381 if (req & (0x0001 << i)) { 382 - d->handle(irq, d, regs); 382 + desc_handle_irq(irq, d, regs); 383 383 } 384 384 } 385 385 } ··· 651 651 return ret; 652 652 } 653 653 654 + static int locomo_remove_child(struct device *dev, void *data) 655 + { 656 + device_unregister(dev); 657 + return 0; 658 + } 659 + 654 660 static void __locomo_remove(struct locomo *lchip) 655 661 { 656 - struct list_head *l, *n; 657 - 658 - list_for_each_safe(l, n, &lchip->dev->children) { 659 - struct device *d = list_to_dev(l); 660 - 661 - device_unregister(d); 662 - } 662 + device_for_each_child(lchip->dev, NULL, locomo_remove_child); 663 663 664 664 if (lchip->irq != NO_IRQ) { 665 665 set_irq_chained_handler(lchip->irq, NULL);
+4 -4
arch/arm/common/sa1111.c
··· 268 268 .mask = sa1111_mask_lowirq, 269 269 .unmask = sa1111_unmask_lowirq, 270 270 .retrigger = sa1111_retrigger_lowirq, 271 - .type = sa1111_type_lowirq, 272 - .wake = sa1111_wake_lowirq, 271 + .set_type = sa1111_type_lowirq, 272 + .set_wake = sa1111_wake_lowirq, 273 273 }; 274 274 275 275 static void sa1111_mask_highirq(unsigned int irq) ··· 364 364 .mask = sa1111_mask_highirq, 365 365 .unmask = sa1111_unmask_highirq, 366 366 .retrigger = sa1111_retrigger_highirq, 367 - .type = sa1111_type_highirq, 368 - .wake = sa1111_wake_highirq, 367 + .set_type = sa1111_type_highirq, 368 + .set_wake = sa1111_wake_highirq, 369 369 }; 370 370 371 371 static void sa1111_setup_irq(struct sa1111 *sachip)
+2 -2
arch/arm/kernel/ecard.c
··· 585 585 586 586 if (pending) { 587 587 struct irqdesc *d = irq_desc + ec->irq; 588 - d->handle(ec->irq, d, regs); 588 + desc_handle_irq(ec->irq, d, regs); 589 589 called ++; 590 590 } 591 591 } ··· 632 632 * Serial cards should go in 0/1, ethernet/scsi in 2/3 633 633 * otherwise you will lose serial data at high speeds! 634 634 */ 635 - d->handle(ec->irq, d, regs); 635 + desc_handle_irq(ec->irq, d, regs); 636 636 } else { 637 637 printk(KERN_WARNING "card%d: interrupt from unclaimed " 638 638 "card???\n", slot);
+10 -10
arch/arm/kernel/irq.c
··· 207 207 unsigned long flags; 208 208 209 209 spin_lock_irqsave(&irq_controller_lock, flags); 210 - if (desc->chip->wake) 211 - desc->chip->wake(irq, 1); 210 + if (desc->chip->set_wake) 211 + desc->chip->set_wake(irq, 1); 212 212 spin_unlock_irqrestore(&irq_controller_lock, flags); 213 213 } 214 214 EXPORT_SYMBOL(enable_irq_wake); ··· 219 219 unsigned long flags; 220 220 221 221 spin_lock_irqsave(&irq_controller_lock, flags); 222 - if (desc->chip->wake) 223 - desc->chip->wake(irq, 0); 222 + if (desc->chip->set_wake) 223 + desc->chip->set_wake(irq, 0); 224 224 spin_unlock_irqrestore(&irq_controller_lock, flags); 225 225 } 226 226 EXPORT_SYMBOL(disable_irq_wake); ··· 517 517 list_for_each_safe(l, n, &head) { 518 518 desc = list_entry(l, struct irqdesc, pend); 519 519 list_del_init(&desc->pend); 520 - desc->handle(desc - irq_desc, desc, regs); 520 + desc_handle_irq(desc - irq_desc, desc, regs); 521 521 } 522 522 523 523 /* ··· 545 545 546 546 irq_enter(); 547 547 spin_lock(&irq_controller_lock); 548 - desc->handle(irq, desc, regs); 548 + desc_handle_irq(irq, desc, regs); 549 549 550 550 /* 551 551 * Now re-run any pending interrupts. ··· 624 624 } 625 625 626 626 desc = irq_desc + irq; 627 - if (desc->chip->type) { 627 + if (desc->chip->set_type) { 628 628 spin_lock_irqsave(&irq_controller_lock, flags); 629 - ret = desc->chip->type(irq, type); 629 + ret = desc->chip->set_type(irq, type); 630 630 spin_unlock_irqrestore(&irq_controller_lock, flags); 631 631 } 632 632 ··· 846 846 847 847 irq_desc[i].probing = 1; 848 848 irq_desc[i].triggered = 0; 849 - if (irq_desc[i].chip->type) 850 - irq_desc[i].chip->type(i, IRQT_PROBE); 849 + if (irq_desc[i].chip->set_type) 850 + irq_desc[i].chip->set_type(i, IRQT_PROBE); 851 851 irq_desc[i].chip->unmask(i); 852 852 irqs += 1; 853 853 }
+1 -1
arch/arm/kernel/smp.c
··· 110 110 * We need to tell the secondary core where to find 111 111 * its stack and the page tables. 112 112 */ 113 - secondary_data.stack = (void *)idle->thread_info + THREAD_SIZE - 8; 113 + secondary_data.stack = (void *)idle->thread_info + THREAD_START_SP; 114 114 secondary_data.pgdir = virt_to_phys(pgd); 115 115 wmb(); 116 116
+1 -1
arch/arm/mach-footbridge/isa-irq.c
··· 95 95 } 96 96 97 97 desc = irq_desc + isa_irq; 98 - desc->handle(isa_irq, desc, regs); 98 + desc_handle_irq(isa_irq, desc, regs); 99 99 } 100 100 101 101 static struct irqaction irq_cascade = { .handler = no_action, .name = "cascade", };
+1 -1
arch/arm/mach-h720x/common.c
··· 108 108 while (mask) { 109 109 if (mask & 1) { 110 110 IRQDBG("handling irq %d\n", irq); 111 - desc->handle(irq, desc, regs); 111 + desc_handle_irq(irq, desc, regs); 112 112 } 113 113 irq++; 114 114 desc++;
+1 -1
arch/arm/mach-h720x/cpu-h7202.c
··· 126 126 desc = irq_desc + irq; 127 127 while (mask) { 128 128 if (mask & 1) 129 - desc->handle(irq, desc, regs); 129 + desc_handle_irq(irq, desc, regs); 130 130 irq++; 131 131 desc++; 132 132 mask >>= 1;
+2 -2
arch/arm/mach-imx/irq.c
··· 152 152 while (mask) { 153 153 if (mask & 1) { 154 154 DEBUG_IRQ("handling irq %d\n", irq); 155 - desc->handle(irq, desc, regs); 155 + desc_handle_irq(irq, desc, regs); 156 156 } 157 157 irq++; 158 158 desc++; ··· 214 214 .ack = imx_gpio_ack_irq, 215 215 .mask = imx_gpio_mask_irq, 216 216 .unmask = imx_gpio_unmask_irq, 217 - .type = imx_gpio_irq_type, 217 + .set_type = imx_gpio_irq_type, 218 218 }; 219 219 220 220 void __init
+1 -1
arch/arm/mach-integrator/integrator_cp.c
··· 170 170 irq += IRQ_SIC_START; 171 171 172 172 desc = irq_desc + irq; 173 - desc->handle(irq, desc, regs); 173 + desc_handle_irq(irq, desc, regs); 174 174 } while (status); 175 175 } 176 176
+5 -5
arch/arm/mach-ixp2000/core.c
··· 317 317 for (i = 0; i <= 7; i++) { 318 318 if (status & (1<<i)) { 319 319 desc = irq_desc + i + IRQ_IXP2000_GPIO0; 320 - desc->handle(i + IRQ_IXP2000_GPIO0, desc, regs); 320 + desc_handle_irq(i + IRQ_IXP2000_GPIO0, desc, regs); 321 321 } 322 322 } 323 323 } ··· 380 380 } 381 381 382 382 static struct irqchip ixp2000_GPIO_irq_chip = { 383 - .type = ixp2000_GPIO_irq_type, 384 - .ack = ixp2000_GPIO_irq_mask_ack, 385 - .mask = ixp2000_GPIO_irq_mask, 386 - .unmask = ixp2000_GPIO_irq_unmask 383 + .ack = ixp2000_GPIO_irq_mask_ack, 384 + .mask = ixp2000_GPIO_irq_mask, 385 + .unmask = ixp2000_GPIO_irq_unmask 386 + .set_type = ixp2000_GPIO_irq_type, 387 387 }; 388 388 389 389 static void ixp2000_pci_irq_mask(unsigned int irq)
+1 -1
arch/arm/mach-ixp2000/ixdp2x00.c
··· 133 133 struct irqdesc *cpld_desc; 134 134 int cpld_irq = IXP2000_BOARD_IRQ(0) + i; 135 135 cpld_desc = irq_desc + cpld_irq; 136 - cpld_desc->handle(cpld_irq, cpld_desc, regs); 136 + desc_handle_irq(cpld_irq, cpld_desc, regs); 137 137 } 138 138 } 139 139
+1 -1
arch/arm/mach-ixp2000/ixdp2x01.c
··· 82 82 struct irqdesc *cpld_desc; 83 83 int cpld_irq = IXP2000_BOARD_IRQ(0) + i; 84 84 cpld_desc = irq_desc + cpld_irq; 85 - cpld_desc->handle(cpld_irq, cpld_desc, regs); 85 + desc_handle_irq(cpld_irq, cpld_desc, regs); 86 86 } 87 87 } 88 88
+1 -1
arch/arm/mach-lh7a40x/common.h
··· 13 13 extern void lh7a400_init_irq (void); 14 14 extern void lh7a404_init_irq (void); 15 15 16 - #define IRQ_DISPATCH(irq) irq_desc[irq].handle ((irq), &irq_desc[irq], regs) 16 + #define IRQ_DISPATCH(irq) desc_handle_irq((irq),(irq_desc + irq), regs)
+1 -1
arch/arm/mach-omap1/fpga.c
··· 102 102 fpga_irq++, stat >>= 1) { 103 103 if (stat & 1) { 104 104 d = irq_desc + fpga_irq; 105 - d->handle(fpga_irq, d, regs); 105 + desc_handle_irq(fpga_irq, d, regs); 106 106 } 107 107 } 108 108 }
+6 -6
arch/arm/mach-pxa/irq.c
··· 133 133 .ack = pxa_ack_low_gpio, 134 134 .mask = pxa_mask_low_irq, 135 135 .unmask = pxa_unmask_low_irq, 136 - .type = pxa_gpio_irq_type, 136 + .set_type = pxa_gpio_irq_type, 137 137 }; 138 138 139 139 /* ··· 157 157 mask >>= 2; 158 158 do { 159 159 if (mask & 1) 160 - desc->handle(irq, desc, regs); 160 + desc_handle_irq(irq, desc, regs); 161 161 irq++; 162 162 desc++; 163 163 mask >>= 1; ··· 172 172 desc = irq_desc + irq; 173 173 do { 174 174 if (mask & 1) 175 - desc->handle(irq, desc, regs); 175 + desc_handle_irq(irq, desc, regs); 176 176 irq++; 177 177 desc++; 178 178 mask >>= 1; ··· 187 187 desc = irq_desc + irq; 188 188 do { 189 189 if (mask & 1) 190 - desc->handle(irq, desc, regs); 190 + desc_handle_irq(irq, desc, regs); 191 191 irq++; 192 192 desc++; 193 193 mask >>= 1; ··· 203 203 desc = irq_desc + irq; 204 204 do { 205 205 if (mask & 1) 206 - desc->handle(irq, desc, regs); 206 + desc_handle_irq(irq, desc, regs); 207 207 irq++; 208 208 desc++; 209 209 mask >>= 1; ··· 241 241 .ack = pxa_ack_muxed_gpio, 242 242 .mask = pxa_mask_muxed_gpio, 243 243 .unmask = pxa_unmask_muxed_gpio, 244 - .type = pxa_gpio_irq_type, 244 + .set_type = pxa_gpio_irq_type, 245 245 }; 246 246 247 247
+1 -1
arch/arm/mach-pxa/lubbock.c
··· 84 84 if (likely(pending)) { 85 85 irq = LUBBOCK_IRQ(0) + __ffs(pending); 86 86 desc = irq_desc + irq; 87 - desc->handle(irq, desc, regs); 87 + desc_handle_irq(irq, desc, regs); 88 88 } 89 89 pending = LUB_IRQ_SET_CLR & lubbock_irq_enabled; 90 90 } while (pending);
+1 -1
arch/arm/mach-pxa/mainstone.c
··· 72 72 if (likely(pending)) { 73 73 irq = MAINSTONE_IRQ(0) + __ffs(pending); 74 74 desc = irq_desc + irq; 75 - desc->handle(irq, desc, regs); 75 + desc_handle_irq(irq, desc, regs); 76 76 } 77 77 pending = MST_INTSETCLR & mainstone_irq_enabled; 78 78 } while (pending);
+1 -1
arch/arm/mach-s3c2410/bast-irq.c
··· 124 124 irqno = bast_pc104_irqs[i]; 125 125 desc = irq_desc + irqno; 126 126 127 - desc->handle(irqno, desc, regs); 127 + desc_handle_irq(irqno, desc, regs); 128 128 } 129 129 130 130 stat >>= 1;
+11 -11
arch/arm/mach-s3c2410/irq.c
··· 184 184 .ack = s3c_irq_maskack, 185 185 .mask = s3c_irq_mask, 186 186 .unmask = s3c_irq_unmask, 187 - .wake = s3c_irq_wake 187 + .set_wake = s3c_irq_wake 188 188 }; 189 189 190 190 static struct irqchip s3c_irq_chip = { 191 191 .ack = s3c_irq_ack, 192 192 .mask = s3c_irq_mask, 193 193 .unmask = s3c_irq_unmask, 194 - .wake = s3c_irq_wake 194 + .set_wake = s3c_irq_wake 195 195 }; 196 196 197 197 /* S3C2410_EINTMASK ··· 350 350 .mask = s3c_irqext_mask, 351 351 .unmask = s3c_irqext_unmask, 352 352 .ack = s3c_irqext_ack, 353 - .type = s3c_irqext_type, 354 - .wake = s3c_irqext_wake 353 + .set_type = s3c_irqext_type, 354 + .set_wake = s3c_irqext_wake 355 355 }; 356 356 357 357 static struct irqchip s3c_irq_eint0t4 = { 358 358 .ack = s3c_irq_ack, 359 359 .mask = s3c_irq_mask, 360 360 .unmask = s3c_irq_unmask, 361 - .wake = s3c_irq_wake, 362 - .type = s3c_irqext_type, 361 + .set_wake = s3c_irq_wake, 362 + .set_type = s3c_irqext_type, 363 363 }; 364 364 365 365 /* mask values for the parent registers for each of the interrupt types */ ··· 496 496 if (subsrc != 0) { 497 497 if (subsrc & 1) { 498 498 mydesc = irq_desc + IRQ_TC; 499 - mydesc->handle( IRQ_TC, mydesc, regs); 499 + desc_handle_irq(IRQ_TC, mydesc, regs); 500 500 } 501 501 if (subsrc & 2) { 502 502 mydesc = irq_desc + IRQ_ADC; 503 - mydesc->handle(IRQ_ADC, mydesc, regs); 503 + desc_handle_irq(IRQ_ADC, mydesc, regs); 504 504 } 505 505 } 506 506 } ··· 529 529 desc = irq_desc + start; 530 530 531 531 if (subsrc & 1) 532 - desc->handle(start, desc, regs); 532 + desc_handle_irq(start, desc, regs); 533 533 534 534 desc++; 535 535 536 536 if (subsrc & 2) 537 - desc->handle(start+1, desc, regs); 537 + desc_handle_irq(start+1, desc, regs); 538 538 539 539 desc++; 540 540 541 541 if (subsrc & 4) 542 - desc->handle(start+2, desc, regs); 542 + desc_handle_irq(start+2, desc, regs); 543 543 } 544 544 } 545 545
+4 -2
arch/arm/mach-s3c2410/pm.c
··· 585 585 586 586 s3c2410_pm_check_store(); 587 587 588 - // need to make some form of time-delta 589 - 590 588 /* send the cpu to sleep... */ 591 589 592 590 __raw_writel(0x00, S3C2410_CLKCON); /* turn off clocks over sleep */ 593 591 594 592 s3c2410_cpu_suspend(regs_save); 593 + 594 + /* restore the cpu state */ 595 + 596 + cpu_init(); 595 597 596 598 /* unset the return-from-sleep flag, to ensure reset */ 597 599
+4 -4
arch/arm/mach-s3c2410/s3c2440-irq.c
··· 64 64 if (subsrc != 0) { 65 65 if (subsrc & 1) { 66 66 mydesc = irq_desc + IRQ_S3C2440_WDT; 67 - mydesc->handle( IRQ_S3C2440_WDT, mydesc, regs); 67 + desc_handle_irq(IRQ_S3C2440_WDT, mydesc, regs); 68 68 } 69 69 if (subsrc & 2) { 70 70 mydesc = irq_desc + IRQ_S3C2440_AC97; 71 - mydesc->handle(IRQ_S3C2440_AC97, mydesc, regs); 71 + desc_handle_irq(IRQ_S3C2440_AC97, mydesc, regs); 72 72 } 73 73 } 74 74 } ··· 122 122 if (subsrc != 0) { 123 123 if (subsrc & 1) { 124 124 mydesc = irq_desc + IRQ_S3C2440_CAM_C; 125 - mydesc->handle( IRQ_S3C2440_WDT, mydesc, regs); 125 + desc_handle_irq(IRQ_S3C2440_CAM_C, mydesc, regs); 126 126 } 127 127 if (subsrc & 2) { 128 128 mydesc = irq_desc + IRQ_S3C2440_CAM_P; 129 - mydesc->handle(IRQ_S3C2440_AC97, mydesc, regs); 129 + desc_handle_irq(IRQ_S3C2440_CAM_P, mydesc, regs); 130 130 } 131 131 } 132 132 }
+5 -5
arch/arm/mach-sa1100/irq.c
··· 98 98 .ack = sa1100_low_gpio_ack, 99 99 .mask = sa1100_low_gpio_mask, 100 100 .unmask = sa1100_low_gpio_unmask, 101 - .type = sa1100_gpio_type, 102 - .wake = sa1100_low_gpio_wake, 101 + .set_type = sa1100_gpio_type, 102 + .set_wake = sa1100_low_gpio_wake, 103 103 }; 104 104 105 105 /* ··· 126 126 mask >>= 11; 127 127 do { 128 128 if (mask & 1) 129 - desc->handle(irq, desc, regs); 129 + desc_handle_irq(irq, desc, regs); 130 130 mask >>= 1; 131 131 irq++; 132 132 desc++; ··· 181 181 .ack = sa1100_high_gpio_ack, 182 182 .mask = sa1100_high_gpio_mask, 183 183 .unmask = sa1100_high_gpio_unmask, 184 - .type = sa1100_gpio_type, 185 - .wake = sa1100_high_gpio_wake, 184 + .set_type = sa1100_gpio_type, 185 + .set_wake = sa1100_high_gpio_wake, 186 186 }; 187 187 188 188 /*
+3 -3
arch/arm/mach-sa1100/neponset.c
··· 61 61 62 62 if (irr & IRR_ETHERNET) { 63 63 d = irq_desc + IRQ_NEPONSET_SMC9196; 64 - d->handle(IRQ_NEPONSET_SMC9196, d, regs); 64 + desc_handle_irq(IRQ_NEPONSET_SMC9196, d, regs); 65 65 } 66 66 67 67 if (irr & IRR_USAR) { 68 68 d = irq_desc + IRQ_NEPONSET_USAR; 69 - d->handle(IRQ_NEPONSET_USAR, d, regs); 69 + desc_handle_irq(IRQ_NEPONSET_USAR, d, regs); 70 70 } 71 71 72 72 desc->chip->unmask(irq); ··· 74 74 75 75 if (irr & IRR_SA1111) { 76 76 d = irq_desc + IRQ_NEPONSET_SA1111; 77 - d->handle(IRQ_NEPONSET_SA1111, d, regs); 77 + desc_handle_irq(IRQ_NEPONSET_SA1111, d, regs); 78 78 } 79 79 } 80 80 }
+1 -1
arch/arm/mach-versatile/core.c
··· 108 108 irq += IRQ_SIC_START; 109 109 110 110 desc = irq_desc + irq; 111 - desc->handle(irq, desc, regs); 111 + desc_handle_irq(irq, desc, regs); 112 112 } while (status); 113 113 } 114 114
+4 -4
arch/arm/mm/proc-arm6_7.S
··· 38 38 mrc p15, 0, r1, c5, c0, 0 @ get FSR 39 39 mrc p15, 0, r0, c6, c0, 0 @ get FAR 40 40 ldr r8, [r0] @ read arm instruction 41 - tst r8, #1 << 20 @ L = 1 -> write? 42 - orreq r1, r1, #1 << 8 @ yes. 41 + tst r8, #1 << 20 @ L = 0 -> write? 42 + orreq r1, r1, #1 << 11 @ yes. 43 43 and r7, r8, #15 << 24 44 44 add pc, pc, r7, lsr #22 @ Now branch to the relevant processing routine 45 45 nop ··· 71 71 mrc p15, 0, r1, c5, c0, 0 @ get FSR 72 72 mrc p15, 0, r0, c6, c0, 0 @ get FAR 73 73 ldr r8, [r2] @ read arm instruction 74 - tst r8, #1 << 20 @ L = 1 -> write? 75 - orreq r1, r1, #1 << 8 @ yes. 74 + tst r8, #1 << 20 @ L = 0 -> write? 75 + orreq r1, r1, #1 << 11 @ yes. 76 76 and r7, r8, #14 << 24 77 77 teq r7, #8 << 24 @ was it ldm/stm 78 78 movne pc, lr
+1 -1
arch/arm/plat-omap/gpio.c
··· 590 590 if (!(isr & 1)) 591 591 continue; 592 592 d = irq_desc + gpio_irq; 593 - d->handle(gpio_irq, d, regs); 593 + desc_handle_irq(gpio_irq, d, regs); 594 594 } 595 595 } 596 596
+1 -1
drivers/pcmcia/pxa2xx_base.c
··· 246 246 driver_unregister(&pxa2xx_pcmcia_driver); 247 247 } 248 248 249 - module_init(pxa2xx_pcmcia_init); 249 + fs_initcall(pxa2xx_pcmcia_init); 250 250 module_exit(pxa2xx_pcmcia_exit); 251 251 252 252 MODULE_AUTHOR("Stefan Eletzhofer <stefan.eletzhofer@inquant.de> and Ian Molton <spyro@f2s.com>");
+1 -1
drivers/pcmcia/pxa2xx_mainstone.c
··· 196 196 platform_device_unregister(mst_pcmcia_device); 197 197 } 198 198 199 - module_init(mst_pcmcia_init); 199 + fs_initcall(mst_pcmcia_init); 200 200 module_exit(mst_pcmcia_exit); 201 201 202 202 MODULE_LICENSE("GPL");
+1 -1
drivers/pcmcia/pxa2xx_sharpsl.c
··· 257 257 platform_device_unregister(sharpsl_pcmcia_device); 258 258 } 259 259 260 - module_init(sharpsl_pcmcia_init); 260 + fs_initcall(sharpsl_pcmcia_init); 261 261 module_exit(sharpsl_pcmcia_exit); 262 262 263 263 MODULE_DESCRIPTION("Sharp SL Series PCMCIA Support");
+1 -1
drivers/pcmcia/sa1100_generic.c
··· 126 126 MODULE_DESCRIPTION("Linux PCMCIA Card Services: SA-11x0 Socket Controller"); 127 127 MODULE_LICENSE("Dual MPL/GPL"); 128 128 129 - module_init(sa11x0_pcmcia_init); 129 + fs_initcall(sa11x0_pcmcia_init); 130 130 module_exit(sa11x0_pcmcia_exit);
+1 -1
drivers/pcmcia/sa1111_generic.c
··· 189 189 sa1111_driver_unregister(&pcmcia_driver); 190 190 } 191 191 192 - module_init(sa1111_drv_pcmcia_init); 192 + fs_initcall(sa1111_drv_pcmcia_init); 193 193 module_exit(sa1111_drv_pcmcia_exit); 194 194 195 195 MODULE_DESCRIPTION("SA1111 PCMCIA card socket driver");
+1 -1
drivers/pcmcia/sa11xx_base.c
··· 189 189 { 190 190 return 0; 191 191 } 192 - module_init(sa11xx_pcmcia_init); 192 + fs_initcall(sa11xx_pcmcia_init); 193 193 194 194 static void __exit sa11xx_pcmcia_exit(void) {} 195 195
+10 -2
include/asm-arm/mach/irq.h
··· 42 42 /* 43 43 * Set the type of the IRQ. 44 44 */ 45 - int (*type)(unsigned int, unsigned int); 45 + int (*set_type)(unsigned int, unsigned int); 46 46 /* 47 47 * Set wakeup-enable on the selected IRQ 48 48 */ 49 - int (*wake)(unsigned int, unsigned int); 49 + int (*set_wake)(unsigned int, unsigned int); 50 50 51 51 #ifdef CONFIG_SMP 52 52 /* ··· 90 90 }; 91 91 92 92 extern struct irqdesc irq_desc[]; 93 + 94 + /* 95 + * Helpful inline function for calling irq descriptor handlers. 96 + */ 97 + static inline void desc_handle_irq(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs) 98 + { 99 + desc->handle(irq, desc, regs); 100 + } 93 101 94 102 /* 95 103 * This is internal. Do not use it.