← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to arch/powerpc/sysdev/mpic.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/powerpc/sysdev/mpic.c
147
147
 
148
148
#endif /* CONFIG_MPIC_WEIRD */
149
149
 
 
150
static inline unsigned int mpic_processor_id(struct mpic *mpic)
 
151
{
 
152
        unsigned int cpu = 0;
 
153
 
 
154
        if (mpic->flags & MPIC_PRIMARY)
 
155
                cpu = hard_smp_processor_id();
 
156
 
 
157
        return cpu;
 
158
}
 
159
 
150
160
/*
151
161
 * Register accessor functions
152
162
 */
210
220
 
211
221
static inline u32 _mpic_cpu_read(struct mpic *mpic, unsigned int reg)
212
222
{
213
 
        unsigned int cpu = 0;
 
223
        unsigned int cpu = mpic_processor_id(mpic);
214
224
 
215
 
        if (mpic->flags & MPIC_PRIMARY)
216
 
                cpu = hard_smp_processor_id();
217
225
        return _mpic_read(mpic->reg_type, &mpic->cpuregs[cpu], reg);
218
226
}
219
227
 
220
228
static inline void _mpic_cpu_write(struct mpic *mpic, unsigned int reg, u32 value)
221
229
{
222
 
        unsigned int cpu = 0;
223
 
 
224
 
        if (mpic->flags & MPIC_PRIMARY)
225
 
                cpu = hard_smp_processor_id();
 
230
        unsigned int cpu = mpic_processor_id(mpic);
226
231
 
227
232
        _mpic_write(mpic->reg_type, &mpic->cpuregs[cpu], reg, value);
228
233
}
356
361
}
357
362
 
358
363
static void mpic_startup_ht_interrupt(struct mpic *mpic, unsigned int source,
359
 
                                      unsigned int irqflags)
 
364
                                      bool level)
360
365
{
361
366
        struct mpic_irq_fixup *fixup = &mpic->fixups[source];
362
367
        unsigned long flags;
365
370
        if (fixup->base == NULL)
366
371
                return;
367
372
 
368
 
        DBG("startup_ht_interrupt(0x%x, 0x%x) index: %d\n",
369
 
            source, irqflags, fixup->index);
 
373
        DBG("startup_ht_interrupt(0x%x) index: %d\n",
 
374
            source, fixup->index);
370
375
        raw_spin_lock_irqsave(&mpic->fixup_lock, flags);
371
376
        /* Enable and configure */
372
377
        writeb(0x10 + 2 * fixup->index, fixup->base + 2);
373
378
        tmp = readl(fixup->base + 4);
374
379
        tmp &= ~(0x23U);
375
 
        if (irqflags & IRQ_LEVEL)
 
380
        if (level)
376
381
                tmp |= 0x22;
377
382
        writel(tmp, fixup->base + 4);
378
383
        raw_spin_unlock_irqrestore(&mpic->fixup_lock, flags);
384
389
#endif
385
390
}
386
391
 
387
 
static void mpic_shutdown_ht_interrupt(struct mpic *mpic, unsigned int source,
388
 
                                       unsigned int irqflags)
 
392
static void mpic_shutdown_ht_interrupt(struct mpic *mpic, unsigned int source)
389
393
{
390
394
        struct mpic_irq_fixup *fixup = &mpic->fixups[source];
391
395
        unsigned long flags;
394
398
        if (fixup->base == NULL)
395
399
                return;
396
400
 
397
 
        DBG("shutdown_ht_interrupt(0x%x, 0x%x)\n", source, irqflags);
 
401
        DBG("shutdown_ht_interrupt(0x%x)\n", source);
398
402
 
399
403
        /* Disable */
400
404
        raw_spin_lock_irqsave(&mpic->fixup_lock, flags);
611
615
        if (irq < NUM_ISA_INTERRUPTS)
612
616
                return NULL;
613
617
 
614
 
        return irq_to_desc(irq)->chip_data;
 
618
        return irq_get_chip_data(irq);
615
619
}
616
620
 
617
621
/* Determine if the linux irq is an IPI */
636
640
 
637
641
#ifdef CONFIG_SMP
638
642
/* Get the mpic structure from the IPI number */
639
 
static inline struct mpic * mpic_from_ipi(unsigned int ipi)
 
643
static inline struct mpic * mpic_from_ipi(struct irq_data *d)
640
644
{
641
 
        return irq_to_desc(ipi)->chip_data;
 
645
        return irq_data_get_irq_chip_data(d);
642
646
}
643
647
#endif
644
648
 
645
649
/* Get the mpic structure from the irq number */
646
650
static inline struct mpic * mpic_from_irq(unsigned int irq)
647
651
{
648
 
        return irq_to_desc(irq)->chip_data;
 
652
        return irq_get_chip_data(irq);
 
653
}
 
654
 
 
655
/* Get the mpic structure from the irq data */
 
656
static inline struct mpic * mpic_from_irq_data(struct irq_data *d)
 
657
{
 
658
        return irq_data_get_irq_chip_data(d);
649
659
}
650
660
 
651
661
/* Send an EOI */
660
670
 */
661
671
 
662
672
 
663
 
void mpic_unmask_irq(unsigned int irq)
 
673
void mpic_unmask_irq(struct irq_data *d)
664
674
{
665
675
        unsigned int loops = 100000;
666
 
        struct mpic *mpic = mpic_from_irq(irq);
667
 
        unsigned int src = mpic_irq_to_hw(irq);
 
676
        struct mpic *mpic = mpic_from_irq_data(d);
 
677
        unsigned int src = mpic_irq_to_hw(d->irq);
668
678
 
669
 
        DBG("%p: %s: enable_irq: %d (src %d)\n", mpic, mpic->name, irq, src);
 
679
        DBG("%p: %s: enable_irq: %d (src %d)\n", mpic, mpic->name, d->irq, src);
670
680
 
671
681
        mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI),
672
682
                       mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) &
681
691
        } while(mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) & MPIC_VECPRI_MASK);
682
692
}
683
693
 
684
 
void mpic_mask_irq(unsigned int irq)
 
694
void mpic_mask_irq(struct irq_data *d)
685
695
{
686
696
        unsigned int loops = 100000;
687
 
        struct mpic *mpic = mpic_from_irq(irq);
688
 
        unsigned int src = mpic_irq_to_hw(irq);
 
697
        struct mpic *mpic = mpic_from_irq_data(d);
 
698
        unsigned int src = mpic_irq_to_hw(d->irq);
689
699
 
690
 
        DBG("%s: disable_irq: %d (src %d)\n", mpic->name, irq, src);
 
700
        DBG("%s: disable_irq: %d (src %d)\n", mpic->name, d->irq, src);
691
701
 
692
702
        mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI),
693
703
                       mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) |
703
713
        } while(!(mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) & MPIC_VECPRI_MASK));
704
714
}
705
715
 
706
 
void mpic_end_irq(unsigned int irq)
 
716
void mpic_end_irq(struct irq_data *d)
707
717
{
708
 
        struct mpic *mpic = mpic_from_irq(irq);
 
718
        struct mpic *mpic = mpic_from_irq_data(d);
709
719
 
710
720
#ifdef DEBUG_IRQ
711
 
        DBG("%s: end_irq: %d\n", mpic->name, irq);
 
721
        DBG("%s: end_irq: %d\n", mpic->name, d->irq);
712
722
#endif
713
723
        /* We always EOI on end_irq() even for edge interrupts since that
714
724
         * should only lower the priority, the MPIC should have properly
720
730
 
721
731
#ifdef CONFIG_MPIC_U3_HT_IRQS
722
732
 
723
 
static void mpic_unmask_ht_irq(unsigned int irq)
 
733
static void mpic_unmask_ht_irq(struct irq_data *d)
724
734
{
725
 
        struct mpic *mpic = mpic_from_irq(irq);
726
 
        unsigned int src = mpic_irq_to_hw(irq);
727
 
 
728
 
        mpic_unmask_irq(irq);
729
 
 
730
 
        if (irq_to_desc(irq)->status & IRQ_LEVEL)
 
735
        struct mpic *mpic = mpic_from_irq_data(d);
 
736
        unsigned int src = mpic_irq_to_hw(d->irq);
 
737
 
 
738
        mpic_unmask_irq(d);
 
739
 
 
740
        if (irqd_is_level_type(d))
731
741
                mpic_ht_end_irq(mpic, src);
732
742
}
733
743
 
734
 
static unsigned int mpic_startup_ht_irq(unsigned int irq)
 
744
static unsigned int mpic_startup_ht_irq(struct irq_data *d)
735
745
{
736
 
        struct mpic *mpic = mpic_from_irq(irq);
737
 
        unsigned int src = mpic_irq_to_hw(irq);
 
746
        struct mpic *mpic = mpic_from_irq_data(d);
 
747
        unsigned int src = mpic_irq_to_hw(d->irq);
738
748
 
739
 
        mpic_unmask_irq(irq);
740
 
        mpic_startup_ht_interrupt(mpic, src, irq_to_desc(irq)->status);
 
749
        mpic_unmask_irq(d);
 
750
        mpic_startup_ht_interrupt(mpic, src, irqd_is_level_type(d));
741
751
 
742
752
        return 0;
743
753
}
744
754
 
745
 
static void mpic_shutdown_ht_irq(unsigned int irq)
 
755
static void mpic_shutdown_ht_irq(struct irq_data *d)
746
756
{
747
 
        struct mpic *mpic = mpic_from_irq(irq);
748
 
        unsigned int src = mpic_irq_to_hw(irq);
 
757
        struct mpic *mpic = mpic_from_irq_data(d);
 
758
        unsigned int src = mpic_irq_to_hw(d->irq);
749
759
 
750
 
        mpic_shutdown_ht_interrupt(mpic, src, irq_to_desc(irq)->status);
751
 
        mpic_mask_irq(irq);
 
760
        mpic_shutdown_ht_interrupt(mpic, src);
 
761
        mpic_mask_irq(d);
752
762
}
753
763
 
754
 
static void mpic_end_ht_irq(unsigned int irq)
 
764
static void mpic_end_ht_irq(struct irq_data *d)
755
765
{
756
 
        struct mpic *mpic = mpic_from_irq(irq);
757
 
        unsigned int src = mpic_irq_to_hw(irq);
 
766
        struct mpic *mpic = mpic_from_irq_data(d);
 
767
        unsigned int src = mpic_irq_to_hw(d->irq);
758
768
 
759
769
#ifdef DEBUG_IRQ
760
 
        DBG("%s: end_irq: %d\n", mpic->name, irq);
 
770
        DBG("%s: end_irq: %d\n", mpic->name, d->irq);
761
771
#endif
762
772
        /* We always EOI on end_irq() even for edge interrupts since that
763
773
         * should only lower the priority, the MPIC should have properly
764
774
         * latched another edge interrupt coming in anyway
765
775
         */
766
776
 
767
 
        if (irq_to_desc(irq)->status & IRQ_LEVEL)
 
777
        if (irqd_is_level_type(d))
768
778
                mpic_ht_end_irq(mpic, src);
769
779
        mpic_eoi(mpic);
770
780
}
772
782
 
773
783
#ifdef CONFIG_SMP
774
784
 
775
 
static void mpic_unmask_ipi(unsigned int irq)
 
785
static void mpic_unmask_ipi(struct irq_data *d)
776
786
{
777
 
        struct mpic *mpic = mpic_from_ipi(irq);
778
 
        unsigned int src = mpic_irq_to_hw(irq) - mpic->ipi_vecs[0];
 
787
        struct mpic *mpic = mpic_from_ipi(d);
 
788
        unsigned int src = mpic_irq_to_hw(d->irq) - mpic->ipi_vecs[0];
779
789
 
780
 
        DBG("%s: enable_ipi: %d (ipi %d)\n", mpic->name, irq, src);
 
790
        DBG("%s: enable_ipi: %d (ipi %d)\n", mpic->name, d->irq, src);
781
791
        mpic_ipi_write(src, mpic_ipi_read(src) & ~MPIC_VECPRI_MASK);
782
792
}
783
793
 
784
 
static void mpic_mask_ipi(unsigned int irq)
 
794
static void mpic_mask_ipi(struct irq_data *d)
785
795
{
786
796
        /* NEVER disable an IPI... that's just plain wrong! */
787
797
}
788
798
 
789
 
static void mpic_end_ipi(unsigned int irq)
 
799
static void mpic_end_ipi(struct irq_data *d)
790
800
{
791
 
        struct mpic *mpic = mpic_from_ipi(irq);
 
801
        struct mpic *mpic = mpic_from_ipi(d);
792
802
 
793
803
        /*
794
804
         * IPIs are marked IRQ_PER_CPU. This has the side effect of
802
812
 
803
813
#endif /* CONFIG_SMP */
804
814
 
805
 
int mpic_set_affinity(unsigned int irq, const struct cpumask *cpumask)
 
815
int mpic_set_affinity(struct irq_data *d, const struct cpumask *cpumask,
 
816
                      bool force)
806
817
{
807
 
        struct mpic *mpic = mpic_from_irq(irq);
808
 
        unsigned int src = mpic_irq_to_hw(irq);
 
818
        struct mpic *mpic = mpic_from_irq_data(d);
 
819
        unsigned int src = mpic_irq_to_hw(d->irq);
809
820
 
810
821
        if (mpic->flags & MPIC_SINGLE_DEST_CPU) {
811
822
                int cpuid = irq_choose_cpu(cpumask);
848
859
        }
849
860
}
850
861
 
851
 
int mpic_set_irq_type(unsigned int virq, unsigned int flow_type)
 
862
int mpic_set_irq_type(struct irq_data *d, unsigned int flow_type)
852
863
{
853
 
        struct mpic *mpic = mpic_from_irq(virq);
854
 
        unsigned int src = mpic_irq_to_hw(virq);
855
 
        struct irq_desc *desc = irq_to_desc(virq);
 
864
        struct mpic *mpic = mpic_from_irq_data(d);
 
865
        unsigned int src = mpic_irq_to_hw(d->irq);
856
866
        unsigned int vecpri, vold, vnew;
857
867
 
858
868
        DBG("mpic: set_irq_type(mpic:@%p,virq:%d,src:0x%x,type:0x%x)\n",
859
 
            mpic, virq, src, flow_type);
 
869
            mpic, d->irq, src, flow_type);
860
870
 
861
871
        if (src >= mpic->irq_count)
862
872
                return -EINVAL;
867
877
        if (flow_type == IRQ_TYPE_NONE)
868
878
                flow_type = IRQ_TYPE_LEVEL_LOW;
869
879
 
870
 
        desc->status &= ~(IRQ_TYPE_SENSE_MASK | IRQ_LEVEL);
871
 
        desc->status |= flow_type & IRQ_TYPE_SENSE_MASK;
872
 
        if (flow_type & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
873
 
                desc->status |= IRQ_LEVEL;
 
880
        irqd_set_trigger_type(d, flow_type);
874
881
 
875
882
        if (mpic_is_ht_interrupt(mpic, src))
876
883
                vecpri = MPIC_VECPRI_POLARITY_POSITIVE |
885
892
        if (vold != vnew)
886
893
                mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI), vnew);
887
894
 
888
 
        return 0;
 
895
        return IRQ_SET_MASK_OK_NOCOPY;;
889
896
}
890
897
 
891
898
void mpic_set_vector(unsigned int virq, unsigned int vector)
906
913
        mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI), vecpri);
907
914
}
908
915
 
 
916
void mpic_set_destination(unsigned int virq, unsigned int cpuid)
 
917
{
 
918
        struct mpic *mpic = mpic_from_irq(virq);
 
919
        unsigned int src = mpic_irq_to_hw(virq);
 
920
 
 
921
        DBG("mpic: set_destination(mpic:@%p,virq:%d,src:%d,cpuid:0x%x)\n",
 
922
            mpic, virq, src, cpuid);
 
923
 
 
924
        if (src >= mpic->irq_count)
 
925
                return;
 
926
 
 
927
        mpic_irq_write(src, MPIC_INFO(IRQ_DESTINATION), 1 << cpuid);
 
928
}
 
929
 
909
930
static struct irq_chip mpic_irq_chip = {
910
 
        .mask           = mpic_mask_irq,
911
 
        .unmask         = mpic_unmask_irq,
912
 
        .eoi            = mpic_end_irq,
913
 
        .set_type       = mpic_set_irq_type,
 
931
        .irq_mask       = mpic_mask_irq,
 
932
        .irq_unmask     = mpic_unmask_irq,
 
933
        .irq_eoi        = mpic_end_irq,
 
934
        .irq_set_type   = mpic_set_irq_type,
914
935
};
915
936
 
916
937
#ifdef CONFIG_SMP
917
938
static struct irq_chip mpic_ipi_chip = {
918
 
        .mask           = mpic_mask_ipi,
919
 
        .unmask         = mpic_unmask_ipi,
920
 
        .eoi            = mpic_end_ipi,
 
939
        .irq_mask       = mpic_mask_ipi,
 
940
        .irq_unmask     = mpic_unmask_ipi,
 
941
        .irq_eoi        = mpic_end_ipi,
921
942
};
922
943
#endif /* CONFIG_SMP */
923
944
 
924
945
#ifdef CONFIG_MPIC_U3_HT_IRQS
925
946
static struct irq_chip mpic_irq_ht_chip = {
926
 
        .startup        = mpic_startup_ht_irq,
927
 
        .shutdown       = mpic_shutdown_ht_irq,
928
 
        .mask           = mpic_mask_irq,
929
 
        .unmask         = mpic_unmask_ht_irq,
930
 
        .eoi            = mpic_end_ht_irq,
931
 
        .set_type       = mpic_set_irq_type,
 
947
        .irq_startup    = mpic_startup_ht_irq,
 
948
        .irq_shutdown   = mpic_shutdown_ht_irq,
 
949
        .irq_mask       = mpic_mask_irq,
 
950
        .irq_unmask     = mpic_unmask_ht_irq,
 
951
        .irq_eoi        = mpic_end_ht_irq,
 
952
        .irq_set_type   = mpic_set_irq_type,
932
953
};
933
954
#endif /* CONFIG_MPIC_U3_HT_IRQS */
934
955
 
957
978
                WARN_ON(!(mpic->flags & MPIC_PRIMARY));
958
979
 
959
980
                DBG("mpic: mapping as IPI\n");
960
 
                set_irq_chip_data(virq, mpic);
961
 
                set_irq_chip_and_handler(virq, &mpic->hc_ipi,
 
981
                irq_set_chip_data(virq, mpic);
 
982
                irq_set_chip_and_handler(virq, &mpic->hc_ipi,
962
983
                                         handle_percpu_irq);
963
984
                return 0;
964
985
        }
980
1001
 
981
1002
        DBG("mpic: mapping to irq chip @%p\n", chip);
982
1003
 
983
 
        set_irq_chip_data(virq, mpic);
984
 
        set_irq_chip_and_handler(virq, chip, handle_fasteoi_irq);
 
1004
        irq_set_chip_data(virq, mpic);
 
1005
        irq_set_chip_and_handler(virq, chip, handle_fasteoi_irq);
985
1006
 
986
1007
        /* Set default irq type */
987
 
        set_irq_type(virq, IRQ_TYPE_NONE);
 
1008
        irq_set_irq_type(virq, IRQ_TYPE_NONE);
 
1009
 
 
1010
        /* If the MPIC was reset, then all vectors have already been
 
1011
         * initialized.  Otherwise, a per source lazy initialization
 
1012
         * is done here.
 
1013
         */
 
1014
        if (!mpic_is_ipi(mpic, hw) && (mpic->flags & MPIC_NO_RESET)) {
 
1015
                mpic_set_vector(virq, hw);
 
1016
                mpic_set_destination(virq, mpic_processor_id(mpic));
 
1017
                mpic_irq_set_priority(virq, 8);
 
1018
        }
988
1019
 
989
1020
        return 0;
990
1021
}
1033
1064
        .xlate = mpic_host_xlate,
1034
1065
};
1035
1066
 
 
1067
static int mpic_reset_prohibited(struct device_node *node)
 
1068
{
 
1069
        return node && of_get_property(node, "pic-no-reset", NULL);
 
1070
}
 
1071
 
1036
1072
/*
1037
1073
 * Exported functions
1038
1074
 */
1060
1096
        mpic->hc_irq = mpic_irq_chip;
1061
1097
        mpic->hc_irq.name = name;
1062
1098
        if (flags & MPIC_PRIMARY)
1063
 
                mpic->hc_irq.set_affinity = mpic_set_affinity;
 
1099
                mpic->hc_irq.irq_set_affinity = mpic_set_affinity;
1064
1100
#ifdef CONFIG_MPIC_U3_HT_IRQS
1065
1101
        mpic->hc_ht_irq = mpic_irq_ht_chip;
1066
1102
        mpic->hc_ht_irq.name = name;
1067
1103
        if (flags & MPIC_PRIMARY)
1068
 
                mpic->hc_ht_irq.set_affinity = mpic_set_affinity;
 
1104
                mpic->hc_ht_irq.irq_set_affinity = mpic_set_affinity;
1069
1105
#endif /* CONFIG_MPIC_U3_HT_IRQS */
1070
1106
 
1071
1107
#ifdef CONFIG_SMP
1153
1189
        mpic_map(mpic, node, paddr, &mpic->tmregs, MPIC_INFO(TIMER_BASE), 0x1000);
1154
1190
 
1155
1191
        /* Reset */
1156
 
        if (flags & MPIC_WANTS_RESET) {
 
1192
 
 
1193
        /* When using a device-node, reset requests are only honored if the MPIC
 
1194
         * is allowed to reset.
 
1195
         */
 
1196
        if (mpic_reset_prohibited(node))
 
1197
                mpic->flags |= MPIC_NO_RESET;
 
1198
 
 
1199
        if ((flags & MPIC_WANTS_RESET) && !(mpic->flags & MPIC_NO_RESET)) {
 
1200
                printk(KERN_DEBUG "mpic: Resetting\n");
1157
1201
                mpic_write(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0),
1158
1202
                           mpic_read(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0))
1159
1203
                           | MPIC_GREG_GCONF_RESET);
1313
1357
 
1314
1358
        mpic_pasemi_msi_init(mpic);
1315
1359
 
1316
 
        if (mpic->flags & MPIC_PRIMARY)
1317
 
                cpu = hard_smp_processor_id();
1318
 
        else
1319
 
                cpu = 0;
 
1360
        cpu = mpic_processor_id(mpic);
1320
1361
 
1321
 
        for (i = 0; i < mpic->num_sources; i++) {
1322
 
                /* start with vector = source number, and masked */
1323
 
                u32 vecpri = MPIC_VECPRI_MASK | i |
1324
 
                        (8 << MPIC_VECPRI_PRIORITY_SHIFT);
 
1362
        if (!(mpic->flags & MPIC_NO_RESET)) {
 
1363
                for (i = 0; i < mpic->num_sources; i++) {
 
1364
                        /* start with vector = source number, and masked */
 
1365
                        u32 vecpri = MPIC_VECPRI_MASK | i |
 
1366
                                (8 << MPIC_VECPRI_PRIORITY_SHIFT);
1325
1367
                
1326
 
                /* check if protected */
1327
 
                if (mpic->protected && test_bit(i, mpic->protected))
1328
 
                        continue;
1329
 
                /* init hw */
1330
 
                mpic_irq_write(i, MPIC_INFO(IRQ_VECTOR_PRI), vecpri);
1331
 
                mpic_irq_write(i, MPIC_INFO(IRQ_DESTINATION), 1 << cpu);
 
1368
                        /* check if protected */
 
1369
                        if (mpic->protected && test_bit(i, mpic->protected))
 
1370
                                continue;
 
1371
                        /* init hw */
 
1372
                        mpic_irq_write(i, MPIC_INFO(IRQ_VECTOR_PRI), vecpri);
 
1373
                        mpic_irq_write(i, MPIC_INFO(IRQ_DESTINATION), 1 << cpu);
 
1374
                }
1332
1375
        }
1333
1376
        
1334
1377
        /* Init spurious vector */