开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
open_pic.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：21k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

open_pic.c：源码内容
  1. /*
  2.  *  arch/ppc/kernel/open_pic.c -- OpenPIC Interrupt Handling
  3.  *
  4.  *  Copyright (C) 1997 Geert Uytterhoeven
  5.  *
  6.  *  This file is subject to the terms and conditions of the GNU General Public
  7.  *  License.  See the file COPYING in the main directory of this archive
  8.  *  for more details.
  9.  */
  11. #include <linux/config.h>
  12. #include <linux/types.h>
  13. #include <linux/kernel.h>
  14. #include <linux/sched.h>
  15. #include <linux/init.h>
  16. #include <linux/irq.h>
  17. #include <asm/ptrace.h>
  18. #include <asm/signal.h>
  19. #include <asm/io.h>
  20. #include <asm/pgtable.h>
  21. #include <asm/irq.h>
  22. #include <asm/prom.h>
  24. #include <asm/machdep.h>
  26. #include "local_irq.h"
  27. #include "open_pic.h"
  28. #include "open_pic_defs.h"
  29. #include "i8259.h"
  30. #include <asm/ppcdebug.h>
  32. void* OpenPIC_Addr;
  33. static volatile struct OpenPIC *OpenPIC = NULL;
  34. u_int OpenPIC_NumInitSenses __initdata = 0;
  35. u_char *OpenPIC_InitSenses __initdata = NULL;
  37. void find_ISUs(void);
  39. static u_int NumProcessors;
  40. static u_int NumSources;
  41. static int NumISUs;
  42. static int open_pic_irq_offset;
  43. static volatile unsigned char* chrp_int_ack_special;
  44. static int broken_ipi_registers;
  46. OpenPIC_SourcePtr ISU[OPENPIC_MAX_ISU];
  48. static void openpic_end_irq(unsigned int irq_nr);
  49. static void openpic_set_affinity(unsigned int irq_nr, unsigned long cpumask);
  51. struct hw_interrupt_type open_pic = {
  52. " OpenPIC  ",
  53. NULL,
  54. NULL,
  55. openpic_enable_irq,
  56. openpic_disable_irq,
  57. NULL,
  58. openpic_end_irq,
  59. openpic_set_affinity
  60. };
  62. #ifdef CONFIG_SMP
  63. static void openpic_end_ipi(unsigned int irq_nr);
  64. static void openpic_enable_ipi(unsigned int irq_nr);
  65. static void openpic_disable_ipi(unsigned int irq_nr);
  67. struct hw_interrupt_type open_pic_ipi = {
  68. " OpenPIC  ",
  69. NULL,
  70. NULL,
  71. openpic_enable_ipi,
  72. openpic_disable_ipi,
  73. NULL,
  74. openpic_end_ipi,
  75. NULL
  76. };
  77. #endif /* CONFIG_SMP */
  79. unsigned int openpic_vec_ipi;
  80. unsigned int openpic_vec_timer;
  81. unsigned int openpic_vec_spurious;
  83. /*
  84.  *  Accesses to the current processor's openpic registers
  85.  */
  86. #ifdef CONFIG_SMP
  87. #define THIS_CPU Processor[cpu]
  88. #define DECL_THIS_CPU int cpu = hard_smp_processor_id()
  89. #define CHECK_THIS_CPU check_arg_cpu(cpu)
  90. #else
  91. #define THIS_CPU Processor[hard_smp_processor_id()]
  92. #define DECL_THIS_CPU
  93. #define CHECK_THIS_CPU
  94. #endif /* CONFIG_SMP */
  96. #if 1
  97. #define check_arg_ipi(ipi) 
  98.     if (ipi < 0 || ipi >= OPENPIC_NUM_IPI) 
  99. printk(KERN_ERR "open_pic.c:%d: illegal ipi %dn", __LINE__, ipi);
  100. #define check_arg_timer(timer) 
  101.     if (timer < 0 || timer >= OPENPIC_NUM_TIMERS) 
  102. printk(KERN_ERR "open_pic.c:%d: illegal timer %dn", __LINE__, timer);
  103. #define check_arg_vec(vec) 
  104.     if (vec < 0 || vec >= OPENPIC_NUM_VECTORS) 
  105. printk(KERN_ERR "open_pic.c:%d: illegal vector %dn", __LINE__, vec);
  106. #define check_arg_pri(pri) 
  107.     if (pri < 0 || pri >= OPENPIC_NUM_PRI) 
  108. printk(KERN_ERR "open_pic.c:%d: illegal priority %dn", __LINE__, pri);
  109. /*
  110.  * Print out a backtrace if it's out of range, since if it's larger than NR_IRQ's
  111.  * data has probably been corrupted and we're going to panic or deadlock later
  112.  * anyway --Troy
  113.  */
  114. extern unsigned long* _get_SP(void);
  115. #define check_arg_irq(irq) 
  116.     if (irq < open_pic_irq_offset || irq >= (NumSources+open_pic_irq_offset)){ 
  117.       printk(KERN_ERR "open_pic.c:%d: illegal irq %dn", __LINE__, irq); 
  118.       print_backtrace(_get_SP()); }
  119. #define check_arg_cpu(cpu) 
  120.     if (cpu < 0 || cpu >= OPENPIC_MAX_PROCESSORS){ 
  121. printk(KERN_ERR "open_pic.c:%d: illegal cpu %dn", __LINE__, cpu); 
  122. print_backtrace(_get_SP()); }
  123. #else
  124. #define check_arg_ipi(ipi) do {} while (0)
  125. #define check_arg_timer(timer) do {} while (0)
  126. #define check_arg_vec(vec) do {} while (0)
  127. #define check_arg_pri(pri) do {} while (0)
  128. #define check_arg_irq(irq) do {} while (0)
  129. #define check_arg_cpu(cpu) do {} while (0)
  130. #endif
  132. #define GET_ISU(source) ISU[(source) >> 4][(source) & 0xf]
  134. void __init openpic_init_IRQ(void)
  135. {
  136.         struct device_node *np;
  137.         int i;
  138.         unsigned int *addrp;
  139.         unsigned char* chrp_int_ack_special = 0;
  140.         unsigned char init_senses[NR_IRQS - NUM_8259_INTERRUPTS];
  141.         int nmi_irq = -1;
  142. #if defined(CONFIG_VT) && defined(CONFIG_ADB_KEYBOARD) && defined(XMON)
  143.         struct device_node *kbd;
  144. #endif
  146.         if (!(np = find_devices("pci"))
  147.             || !(addrp = (unsigned int *)
  148.                  get_property(np, "8259-interrupt-acknowledge", NULL)))
  149.                 printk(KERN_ERR "Cannot find pci to get ack addressn");
  150.         else
  151. chrp_int_ack_special = (unsigned char *)
  152. __ioremap(addrp[prom_n_addr_cells(np)-1], 1, _PAGE_NO_CACHE);
  153.         /* hydra still sets OpenPIC_InitSenses to a static set of values */
  154.         if (OpenPIC_InitSenses == NULL) {
  155.                 prom_get_irq_senses(init_senses, NUM_8259_INTERRUPTS, NR_IRQS);
  156.                 OpenPIC_InitSenses = init_senses;
  157.                 OpenPIC_NumInitSenses = NR_IRQS - NUM_8259_INTERRUPTS;
  158.         }
  159.         openpic_init(1, NUM_8259_INTERRUPTS, chrp_int_ack_special, nmi_irq);
  160.         for ( i = 0 ; i < NUM_8259_INTERRUPTS  ; i++ )
  161.                 irq_desc[i].handler = &i8259_pic;
  162.         i8259_init();
  163. }
  165. static inline u_int openpic_read(volatile u_int *addr)
  166. {
  167. u_int val;
  169. val = in_le32(addr);
  170. return val;
  171. }
  173. static inline void openpic_write(volatile u_int *addr, u_int val)
  174. {
  175. out_le32(addr, val);
  176. }
  178. static inline u_int openpic_readfield(volatile u_int *addr, u_int mask)
  179. {
  180. u_int val = openpic_read(addr);
  181. return val & mask;
  182. }
  184. static inline void openpic_writefield(volatile u_int *addr, u_int mask,
  185.        u_int field)
  186. {
  187. u_int val = openpic_read(addr);
  188. openpic_write(addr, (val & ~mask) | (field & mask));
  189. }
  191. static inline void openpic_clearfield(volatile u_int *addr, u_int mask)
  192. {
  193. openpic_writefield(addr, mask, 0);
  194. }
  196. static inline void openpic_setfield(volatile u_int *addr, u_int mask)
  197. {
  198. openpic_writefield(addr, mask, mask);
  199. }
  201. static void openpic_safe_writefield(volatile u_int *addr, u_int mask,
  202.     u_int field)
  203. {
  204. unsigned int loops = 100000;
  206. openpic_setfield(addr, OPENPIC_MASK);
  207. while (openpic_read(addr) & OPENPIC_ACTIVITY) {
  208. if (!loops--) {
  209. printk(KERN_ERR "openpic_safe_writefield timeoutn");
  210. break;
  211. }
  212. }
  213. openpic_writefield(addr, mask | OPENPIC_MASK, field | OPENPIC_MASK);
  214. }
  216. #ifdef CONFIG_SMP
  217. static u_int openpic_read_IPI(volatile u_int* addr)
  218. {
  219.         u_int val = 0;
  221. if (broken_ipi_registers)
  222. /* yes this is right ... bug, feature, you decide! -- tgall */
  223. val = in_be32(addr);
  224. else
  225. val = in_le32(addr);
  227.         return val;
  228. }
  230. static void openpic_test_broken_IPI(void)
  231. {
  232. u_int t;
  234. openpic_write(&OpenPIC->Global.IPI_Vector_Priority(0), OPENPIC_MASK);
  235. t = openpic_read(&OpenPIC->Global.IPI_Vector_Priority(0));
  236. if (t == le32_to_cpu(OPENPIC_MASK)) {
  237. printk(KERN_INFO "OpenPIC reversed IPI registers detectedn");
  238. broken_ipi_registers = 1;
  239. }
  240. }
  242. /* because of the power3 be / le above, this is needed */
  243. static inline void openpic_writefield_IPI(volatile u_int* addr, u_int mask, u_int field)
  244. {
  245.         u_int  val = openpic_read_IPI(addr);
  246.         openpic_write(addr, (val & ~mask) | (field & mask));
  247. }
  249. static inline void openpic_clearfield_IPI(volatile u_int *addr, u_int mask)
  250. {
  251.         openpic_writefield_IPI(addr, mask, 0);
  252. }
  254. static inline void openpic_setfield_IPI(volatile u_int *addr, u_int mask)
  255. {
  256.         openpic_writefield_IPI(addr, mask, mask);
  257. }
  259. static void openpic_safe_writefield_IPI(volatile u_int *addr, u_int mask, u_int field)
  260. {
  261. unsigned int loops = 100000;
  263.         openpic_setfield_IPI(addr, OPENPIC_MASK);
  265.         /* wait until it's not in use */
  266.         /* BenH: Is this code really enough ? I would rather check the result
  267.          *       and eventually retry ...
  268.          */
  269.         while(openpic_read_IPI(addr) & OPENPIC_ACTIVITY) {
  270. if (!loops--) {
  271. printk(KERN_ERR "openpic_safe_writefield timeoutn");
  272. break;
  273. }
  274. }
  276.         openpic_writefield_IPI(addr, mask, field | OPENPIC_MASK);
  277. }
  278. #endif /* CONFIG_SMP */
  280. void __init openpic_init(int main_pic, int offset, unsigned char* chrp_ack,
  281.  int programmer_switch_irq)
  282. {
  283. u_int t, i;
  284. u_int timerfreq;
  285. const char *version;
  287. if (!OpenPIC_Addr) {
  288. printk(KERN_INFO "No OpenPIC found !n");
  289. return;
  290. }
  291. OpenPIC = (volatile struct OpenPIC *)OpenPIC_Addr;
  293. ppc64_boot_msg(0x20, "OpenPic Init");
  295. t = openpic_read(&OpenPIC->Global.Feature_Reporting0);
  296. switch (t & OPENPIC_FEATURE_VERSION_MASK) {
  297. case 1:
  298. version = "1.0";
  299. break;
  300. case 2:
  301. version = "1.2";
  302. break;
  303. case 3:
  304. version = "1.3";
  305. break;
  306. default:
  307. version = "?";
  308. break;
  309. }
  310. NumProcessors = ((t & OPENPIC_FEATURE_LAST_PROCESSOR_MASK) >>
  311.  OPENPIC_FEATURE_LAST_PROCESSOR_SHIFT) + 1;
  312. NumSources = ((t & OPENPIC_FEATURE_LAST_SOURCE_MASK) >>
  313.       OPENPIC_FEATURE_LAST_SOURCE_SHIFT) + 1;
  314. printk(KERN_INFO "OpenPIC Version %s (%d CPUs and %d IRQ sources) at %pn",
  315.        version, NumProcessors, NumSources, OpenPIC);
  316. timerfreq = openpic_read(&OpenPIC->Global.Timer_Frequency);
  317. if (timerfreq)
  318. printk(KERN_INFO "OpenPIC timer frequency is %d.%06d MHzn",
  319.        timerfreq / 1000000, timerfreq % 1000000);
  321. if (!main_pic)
  322. return;
  324. open_pic_irq_offset = offset;
  325. chrp_int_ack_special = (volatile unsigned char*)chrp_ack;
  327. find_ISUs();
  329. /* Initialize timer interrupts */
  330. ppc64_boot_msg(0x21, "OpenPic Timer");
  331. for (i = 0; i < OPENPIC_NUM_TIMERS; i++) {
  332. /* Disabled, Priority 0 */
  333. openpic_inittimer(i, 0, openpic_vec_timer+i);
  334. /* No processor */
  335. openpic_maptimer(i, 0);
  336. }
  338. #ifdef CONFIG_SMP
  339. /* Initialize IPI interrupts */
  340. ppc64_boot_msg(0x22, "OpenPic IPI");
  341. openpic_test_broken_IPI();
  342. for (i = 0; i < OPENPIC_NUM_IPI; i++) {
  343. /* Disabled, Priority 10..13 */
  344. openpic_initipi(i, 10+i, openpic_vec_ipi+i);
  345. /* IPIs are per-CPU */
  346. irq_desc[openpic_vec_ipi+i].status |= IRQ_PER_CPU;
  347. irq_desc[openpic_vec_ipi+i].handler = &open_pic_ipi;
  348. }
  349. #endif
  351. /* Initialize external interrupts */
  352. ppc64_boot_msg(0x23, "OpenPic Ext");
  354. openpic_set_priority(0xf);
  356. /* SIOint (8259 cascade) is special */
  357. if (offset) {
  358. openpic_initirq(0, 8, offset, 1, 1);
  359. openpic_mapirq(0, 1<<get_hard_smp_processor_id(0));
  360. }
  362. /* Init all external sources */
  363. for (i = 1; i < NumSources; i++) {
  364. int pri, sense;
  366. /* the bootloader may have left it enabled (bad !) */
  367. openpic_disable_irq(i+offset);
  369. pri = (i == programmer_switch_irq)? 9: 8;
  370. sense = (i < OpenPIC_NumInitSenses)? OpenPIC_InitSenses[i]: 1;
  371. if (sense)
  372. irq_desc[i+offset].status = IRQ_LEVEL;
  374. /* Enabled, Priority 8 or 9 */
  375. openpic_initirq(i, pri, i+offset, !sense, sense);
  376. /* Processor 0 */
  377. openpic_mapirq(i, 1<<get_hard_smp_processor_id(0));
  378. }
  380. /* Init descriptors */
  381. for (i = offset; i < NumSources + offset; i++)
  382. irq_desc[i].handler = &open_pic;
  384. /* Initialize the spurious interrupt */
  385. ppc64_boot_msg(0x24, "OpenPic Spurious");
  386. openpic_set_spurious(openpic_vec_spurious);
  388. /* Initialize the cascade */
  389. if (offset) {
  390. if (request_irq(offset, no_action, SA_INTERRUPT,
  391. "82c59 cascade", NULL))
  392. printk(KERN_ERR "Unable to get OpenPIC IRQ 0 for cascaden");
  393. }
  394. openpic_set_priority(0);
  395. openpic_disable_8259_pass_through();
  397. ppc64_boot_msg(0x25, "OpenPic Done");
  398. }
  400. void openpic_setup_ISU(int isu_num, unsigned long addr)
  401. {
  402. if (isu_num >= OPENPIC_MAX_ISU)
  403. return;
  404. ISU[isu_num] = (OpenPIC_SourcePtr) __ioremap(addr, 0x400, _PAGE_NO_CACHE);
  405. if (isu_num >= NumISUs)
  406. NumISUs = isu_num + 1;
  407. }
  409. void find_ISUs(void)
  410. {
  411.         /* Use /interrupt-controller/reg and
  412.          * /interrupt-controller/interrupt-ranges from OF device tree
  413.  * the ISU array is setup in chrp_pci.c in ibm_add_bridges
  414.  * as a result
  415.  * -- tgall
  416.          */
  418. /* basically each ISU is a bus, and this assumes that
  419.  * open_pic_isu_count interrupts per bus are possible 
  420.  * ISU == Interrupt Source
  421.  */
  422. NumSources = NumISUs * 0x10;
  423. openpic_vec_ipi = NumSources + open_pic_irq_offset;
  424. openpic_vec_timer = openpic_vec_ipi + OPENPIC_NUM_IPI; 
  425. openpic_vec_spurious = openpic_vec_timer + OPENPIC_NUM_TIMERS;
  426. }
  428. static inline void openpic_reset(void)
  429. {
  430. openpic_setfield(&OpenPIC->Global.Global_Configuration0,
  431.  OPENPIC_CONFIG_RESET);
  432. }
  434. static inline void openpic_enable_8259_pass_through(void)
  435. {
  436. openpic_clearfield(&OpenPIC->Global.Global_Configuration0,
  437.    OPENPIC_CONFIG_8259_PASSTHROUGH_DISABLE);
  438. }
  440. static void openpic_disable_8259_pass_through(void)
  441. {
  442. openpic_setfield(&OpenPIC->Global.Global_Configuration0,
  443.  OPENPIC_CONFIG_8259_PASSTHROUGH_DISABLE);
  444. }
  446. /*
  447.  *  Find out the current interrupt
  448.  */
  449. static u_int openpic_irq(void)
  450. {
  451. u_int vec;
  452. DECL_THIS_CPU;
  454. CHECK_THIS_CPU;
  455. vec = openpic_readfield(&OpenPIC->THIS_CPU.Interrupt_Acknowledge,
  456. OPENPIC_VECTOR_MASK);
  457. return vec;
  458. }
  460. static void openpic_eoi(void)
  461. {
  462. DECL_THIS_CPU;
  464. CHECK_THIS_CPU;
  465. openpic_write(&OpenPIC->THIS_CPU.EOI, 0);
  466. /* Handle PCI write posting */
  467. (void)openpic_read(&OpenPIC->THIS_CPU.EOI);
  468. }
  471. static inline u_int openpic_get_priority(void)
  472. {
  473. DECL_THIS_CPU;
  475. CHECK_THIS_CPU;
  476. return openpic_readfield(&OpenPIC->THIS_CPU.Current_Task_Priority,
  477.  OPENPIC_CURRENT_TASK_PRIORITY_MASK);
  478. }
  480. static void openpic_set_priority(u_int pri)
  481. {
  482. DECL_THIS_CPU;
  484. CHECK_THIS_CPU;
  485. check_arg_pri(pri);
  486. openpic_writefield(&OpenPIC->THIS_CPU.Current_Task_Priority,
  487.    OPENPIC_CURRENT_TASK_PRIORITY_MASK, pri);
  488. }
  490. /*
  491.  *  Get/set the spurious vector
  492.  */
  493. static inline u_int openpic_get_spurious(void)
  494. {
  495. return openpic_readfield(&OpenPIC->Global.Spurious_Vector,
  496.  OPENPIC_VECTOR_MASK);
  497. }
  499. static void openpic_set_spurious(u_int vec)
  500. {
  501. check_arg_vec(vec);
  502. openpic_writefield(&OpenPIC->Global.Spurious_Vector, OPENPIC_VECTOR_MASK,
  503.    vec);
  504. }
  506. /*
  507.  * Convert a cpu mask from logical to physical cpu numbers.
  508.  */
  509. static inline u32 physmask(u32 cpumask)
  510. {
  511. int i;
  512. u32 mask = 0;
  514. for (i = 0; i < smp_num_cpus; ++i, cpumask >>= 1)
  515. mask |= (cpumask & 1) << get_hard_smp_processor_id(i);
  516. return mask;
  517. }
  519. void openpic_init_processor(u_int cpumask)
  520. {
  521. openpic_write(&OpenPIC->Global.Processor_Initialization,
  522.       physmask(cpumask));
  523. }
  525. #ifdef CONFIG_SMP
  526. /*
  527.  *  Initialize an interprocessor interrupt (and disable it)
  528.  *
  529.  *  ipi: OpenPIC interprocessor interrupt number
  530.  *  pri: interrupt source priority
  531.  *  vec: the vector it will produce
  532.  */
  533. static void __init openpic_initipi(u_int ipi, u_int pri, u_int vec)
  534. {
  535. check_arg_ipi(ipi);
  536. check_arg_pri(pri);
  537. check_arg_vec(vec);
  538. openpic_safe_writefield_IPI(&OpenPIC->Global.IPI_Vector_Priority(ipi),
  539. OPENPIC_PRIORITY_MASK | OPENPIC_VECTOR_MASK,
  540. (pri << OPENPIC_PRIORITY_SHIFT) | vec);
  541. }
  543. /*
  544.  *  Send an IPI to one or more CPUs
  545.  *  
  546.  *  Externally called, however, it takes an IPI number (0...OPENPIC_NUM_IPI)
  547.  *  and not a system-wide interrupt number
  548.  */
  549. void openpic_cause_IPI(u_int ipi, u_int cpumask)
  550. {
  551. DECL_THIS_CPU;
  553. CHECK_THIS_CPU;
  554. check_arg_ipi(ipi);
  555. openpic_write(&OpenPIC->THIS_CPU.IPI_Dispatch(ipi),
  556.       physmask(cpumask));
  557. }
  559. void openpic_request_IPIs(void)
  560. {
  561. int i;
  563. /*
  564.  * Make sure this matches what is defined in smp.c for 
  565.  * smp_message_{pass|recv}() or what shows up in 
  566.  * /proc/interrupts will be wrong!!! --Troy */
  568. if (OpenPIC == NULL)
  569. return;
  571. request_irq(openpic_vec_ipi,
  572.     openpic_ipi_action, 0, "IPI0 (call function)", 0);
  573. request_irq(openpic_vec_ipi+1,
  574.     openpic_ipi_action, 0, "IPI1 (reschedule)", 0);
  575. request_irq(openpic_vec_ipi+2,
  576.     openpic_ipi_action, 0, "IPI2 (invalidate tlb)", 0);
  577. request_irq(openpic_vec_ipi+3,
  578.     openpic_ipi_action, 0, "IPI3 (xmon break)", 0);
  580. for ( i = 0; i < OPENPIC_NUM_IPI ; i++ )
  581. openpic_enable_ipi(openpic_vec_ipi+i);
  582. }
  584. /*
  585.  * Do per-cpu setup for SMP systems.
  586.  *
  587.  * Get IPI's working and start taking interrupts.
  588.  *   -- Cort
  589.  */
  590. static spinlock_t openpic_setup_lock __initdata = SPIN_LOCK_UNLOCKED;
  592. void __init do_openpic_setup_cpu(void)
  593. {
  594. #ifdef CONFIG_IRQ_ALL_CPUS
  595.   int i;
  596. u32 msk = 1 << hard_smp_processor_id();
  597. #endif
  599. spin_lock(&openpic_setup_lock);
  601. #ifdef CONFIG_IRQ_ALL_CPUS
  602.   /* let the openpic know we want intrs. default affinity
  603.    * is 0xffffffff until changed via /proc
  604.    * That's how it's done on x86. If we want it differently, then
  605.    * we should make sure we also change the default values of irq_affinity
  606.    * in irq.c.
  607.    */
  608.   for (i = 0; i < NumSources ; i++)
  609. openpic_mapirq(i, openpic_read(&GET_ISU(i).Destination) | msk);
  610. #endif /* CONFIG_IRQ_ALL_CPUS */
  611.   openpic_set_priority(0);
  613. spin_unlock(&openpic_setup_lock);
  614. }
  615. #endif /* CONFIG_SMP */
  617. /*
  618.  *  Initialize a timer interrupt (and disable it)
  619.  *
  620.  *  timer: OpenPIC timer number
  621.  *  pri: interrupt source priority
  622.  *  vec: the vector it will produce
  623.  */
  624. static void __init openpic_inittimer(u_int timer, u_int pri, u_int vec)
  625. {
  626. check_arg_timer(timer);
  627. check_arg_pri(pri);
  628. check_arg_vec(vec);
  629. openpic_safe_writefield(&OpenPIC->Global.Timer[timer].Vector_Priority,
  630. OPENPIC_PRIORITY_MASK | OPENPIC_VECTOR_MASK,
  631. (pri << OPENPIC_PRIORITY_SHIFT) | vec);
  632. }
  634. /*
  635.  *  Map a timer interrupt to one or more CPUs
  636.  */
  637. static void __init openpic_maptimer(u_int timer, u_int cpumask)
  638. {
  639. check_arg_timer(timer);
  640. openpic_write(&OpenPIC->Global.Timer[timer].Destination,
  641.       physmask(cpumask));
  642. }
  645. /*
  646.  *
  647.  * All functions below take an offset'ed irq argument
  648.  *
  649.  */
  652. /*
  653.  *  Enable/disable an external interrupt source
  654.  *
  655.  *  Externally called, irq is an offseted system-wide interrupt number
  656.  */
  657. static void openpic_enable_irq(u_int irq)
  658. {
  659. unsigned int loops = 100000;
  660. check_arg_irq(irq);
  662. openpic_clearfield(&GET_ISU(irq - open_pic_irq_offset).Vector_Priority, OPENPIC_MASK);
  663. /* make sure mask gets to controller before we return to user */
  664. do {
  665. if (!loops--) {
  666. printk(KERN_ERR "openpic_enable_irq timeoutn");
  667. break;
  668. }
  670. mb(); /* sync is probably useless here */
  671. } while(openpic_readfield(&GET_ISU(irq - open_pic_irq_offset).Vector_Priority,
  672. OPENPIC_MASK));
  673. }
  675. static void openpic_disable_irq(u_int irq)
  676. {
  677. u32 vp;
  678. unsigned int loops = 100000;
  680. check_arg_irq(irq);
  682. openpic_setfield(&GET_ISU(irq - open_pic_irq_offset).Vector_Priority, OPENPIC_MASK);
  683. /* make sure mask gets to controller before we return to user */
  684. do {
  685. if (!loops--) {
  686. printk(KERN_ERR "openpic_disable_irq timeoutn");
  687. break;
  688. }
  690. mb();  /* sync is probably useless here */
  691. vp = openpic_readfield(&GET_ISU(irq - open_pic_irq_offset).Vector_Priority,
  692.      OPENPIC_MASK | OPENPIC_ACTIVITY);
  693. } while((vp & OPENPIC_ACTIVITY) && !(vp & OPENPIC_MASK));
  694. }
  696. #ifdef CONFIG_SMP
  697. /*
  698.  *  Enable/disable an IPI interrupt source
  699.  *  
  700.  *  Externally called, irq is an offseted system-wide interrupt number
  701.  */
  702. void openpic_enable_ipi(u_int irq)
  703. {
  704. irq -= openpic_vec_ipi;
  705. check_arg_ipi(irq);
  706. openpic_clearfield_IPI(&OpenPIC->Global.IPI_Vector_Priority(irq), OPENPIC_MASK);
  708. }
  709. void openpic_disable_ipi(u_int irq)
  710. {
  711.    /* NEVER disable an IPI... that's just plain wrong! */
  712. }
  714. #endif
  716. /*
  717.  *  Initialize an interrupt source (and disable it!)
  718.  *
  719.  *  irq: OpenPIC interrupt number
  720.  *  pri: interrupt source priority
  721.  *  vec: the vector it will produce
  722.  *  pol: polarity (1 for positive, 0 for negative)
  723.  *  sense: 1 for level, 0 for edge
  724.  */
  725. static void openpic_initirq(u_int irq, u_int pri, u_int vec, int pol, int sense)
  726. {
  727. openpic_safe_writefield(&GET_ISU(irq).Vector_Priority,
  728. OPENPIC_PRIORITY_MASK | OPENPIC_VECTOR_MASK |
  729. OPENPIC_SENSE_MASK | OPENPIC_POLARITY_MASK,
  730. (pri << OPENPIC_PRIORITY_SHIFT) | vec |
  731. (pol ? OPENPIC_POLARITY_POSITIVE :
  732.      OPENPIC_POLARITY_NEGATIVE) |
  733. (sense ? OPENPIC_SENSE_LEVEL : OPENPIC_SENSE_EDGE));
  734. }
  736. /*
  737.  *  Map an interrupt source to one or more CPUs
  738.  */
  739. static void openpic_mapirq(u_int irq, u_int physmask)
  740. {
  741. openpic_write(&GET_ISU(irq).Destination, physmask);
  742. }
  744. /*
  745.  *  Set the sense for an interrupt source (and disable it!)
  746.  *
  747.  *  sense: 1 for level, 0 for edge
  748.  */
  749. static inline void openpic_set_sense(u_int irq, int sense)
  750. {
  751. openpic_safe_writefield(&GET_ISU(irq).Vector_Priority,
  752. OPENPIC_SENSE_LEVEL,
  753. (sense ? OPENPIC_SENSE_LEVEL : 0));
  754. }
  756. static void openpic_end_irq(unsigned int irq_nr)
  757. {
  758. if ((irq_desc[irq_nr].status & IRQ_LEVEL) != 0)
  759. openpic_eoi();
  760. }
  762. static void openpic_set_affinity(unsigned int irq_nr, unsigned long cpumask)
  763. {
  764. openpic_mapirq(irq_nr - open_pic_irq_offset, physmask(cpumask));
  765. }
  767. #ifdef CONFIG_SMP
  768. static void openpic_end_ipi(unsigned int irq_nr)
  769. {
  770. /* IPIs are marked IRQ_PER_CPU. This has the side effect of
  771.  * preventing the IRQ_PENDING/IRQ_INPROGRESS logic from
  772.  * applying to them. We EOI them late to avoid re-entering.
  773.  * however, I'm wondering if we could simply let them have the
  774.  * SA_INTERRUPT flag and let them execute with all interrupts OFF.
  775.  * This would have the side effect of either running cross-CPU
  776.  * functions with interrupts off, or we can re-enable them explicitely
  777.  * with a __sti() in smp_call_function_interrupt(), since
  778.  * smp_call_function() is protected by a spinlock.
  779.  * Or maybe we shouldn't set the IRQ_PER_CPU flag on cross-CPU
  780.  * function calls IPI at all but that would make a special case.
  781.  */
  782. openpic_eoi();
  783. }
  785. static void openpic_ipi_action(int cpl, void *dev_id, struct pt_regs *regs)
  786. {
  787. smp_message_recv(cpl-openpic_vec_ipi, regs);
  788. }
  790. #endif /* CONFIG_SMP */
  792. int openpic_get_irq(struct pt_regs *regs)
  793. {
  794. extern int i8259_irq(int cpu);
  796. int irq = openpic_irq();
  798. /* Management of the cascade should be moved out of here */
  799.         if (open_pic_irq_offset && irq == open_pic_irq_offset)
  800.         {
  801.                 /*
  802.                  * This magic address generates a PCI IACK cycle.
  803.                  */
  804. if ( chrp_int_ack_special )
  805. irq = *chrp_int_ack_special;
  806. else
  807. irq = i8259_irq( smp_processor_id() );
  808. openpic_eoi();
  809.         }
  810. if (irq == openpic_vec_spurious)
  811. irq = -1;
  812. return irq;
  813. }