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

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

Linux/Unix编程

开发平台：

Unix_Linux

xics.c：源码内容
  1. /* 
  2.  * arch/ppc/kernel/xics.c
  3.  *
  4.  * Copyright 2000 IBM Corporation.
  5.  *
  6.  *  This program is free software; you can redistribute it and/or
  7.  *  modify it under the terms of the GNU General Public License
  8.  *  as published by the Free Software Foundation; either version
  9.  *  2 of the License, or (at your option) any later version.
  10.  */
  11. #include <linux/config.h>
  12. #include <linux/types.h>
  13. #include <linux/threads.h>
  14. #include <linux/kernel.h>
  15. #include <linux/sched.h>
  16. #include <asm/prom.h>
  17. #include <asm/io.h>
  18. #include <asm/pgtable.h>
  19. #include <asm/smp.h>
  20. #include <asm/naca.h>
  21. #include <asm/rtas.h>
  22. #include "i8259.h"
  23. #include "xics.h"
  24. #include <asm/ppcdebug.h>
  26. void xics_enable_irq(u_int irq);
  27. void xics_disable_irq(u_int irq);
  28. void xics_mask_and_ack_irq(u_int irq);
  29. void xics_end_irq(u_int irq);
  30. void xics_set_affinity(unsigned int irq_nr, unsigned long cpumask);
  32. struct hw_interrupt_type xics_pic = {
  33. " XICS     ",
  34. NULL,
  35. NULL,
  36. xics_enable_irq,
  37. xics_disable_irq,
  38. xics_mask_and_ack_irq,
  39. xics_end_irq,
  40. xics_set_affinity
  41. };
  43. struct hw_interrupt_type xics_8259_pic = {
  44. " XICS/8259",
  45. NULL,
  46. NULL,
  47. NULL,
  48. NULL,
  49. xics_mask_and_ack_irq,
  50. NULL
  51. };
  53. #define XICS_IPI 2
  54. #define XICS_IRQ_OFFSET 0x10
  55. #define XICS_IRQ_SPURIOUS 0
  57. /* Want a priority other than 0.  Various HW issues require this. */
  58. #define DEFAULT_PRIORITY 5
  60. struct xics_ipl {
  61. union {
  62. u32 word;
  63. u8 bytes[4];
  64. } xirr_poll;
  65. union {
  66. u32 word;
  67. u8 bytes[4];
  68. } xirr;
  69. u32 dummy;
  70. union {
  71. u32 word;
  72. u8 bytes[4];
  73. } qirr;
  74. };
  76. struct xics_info {
  77. volatile struct xics_ipl * per_cpu[NR_CPUS];
  78. };
  80. struct xics_info xics_info;
  82. unsigned long long intr_base = 0;
  83. int xics_irq_8259_cascade = 0;
  84. int xics_irq_8259_cascade_real = 0;
  85. unsigned int default_server = 0xFF;
  86. unsigned int default_distrib_server = 0;
  88. /* RTAS service tokens */
  89. int ibm_get_xive;
  90. int ibm_set_xive;
  91. int ibm_int_off;
  93. struct xics_interrupt_node {
  94. unsigned long long addr;
  95. unsigned long long size;
  96. } inodes[NR_CPUS*2];  
  98. typedef struct {
  99. int (*xirr_info_get)(int cpu);
  100. void (*xirr_info_set)(int cpu, int val);
  101. void (*cppr_info)(int cpu, u8 val);
  102. void (*qirr_info)(int cpu, u8 val);
  103. } xics_ops;
  106. static int pSeries_xirr_info_get(int n_cpu)
  107. {
  108. return (xics_info.per_cpu[n_cpu]->xirr.word);
  109. }
  111. static void pSeries_xirr_info_set(int n_cpu, int value)
  112. {
  113. xics_info.per_cpu[n_cpu]->xirr.word = value;
  114. }
  116. static void pSeries_cppr_info(int n_cpu, u8 value)
  117. {
  118. xics_info.per_cpu[n_cpu]->xirr.bytes[0] = value;
  119. }
  121. static void pSeries_qirr_info(int n_cpu , u8 value)
  122. {
  123. xics_info.per_cpu[n_cpu]->qirr.bytes[0] = value;
  124. }
  126. static xics_ops pSeries_ops = {
  127. pSeries_xirr_info_get,
  128. pSeries_xirr_info_set,
  129. pSeries_cppr_info,
  130. pSeries_qirr_info
  131. };
  133. static xics_ops *ops = &pSeries_ops;
  134. extern xics_ops pSeriesLP_ops;
  137. void
  138. xics_enable_irq(
  139. u_int virq
  140. )
  141. {
  142. u_int irq;
  143. unsigned long status;
  144. long         call_status;
  146. virq -= XICS_IRQ_OFFSET;
  147. irq = virt_irq_to_real(virq);
  148. if (irq == XICS_IPI)
  149. return;
  150. #ifdef CONFIG_IRQ_ALL_CPUS
  151. call_status = rtas_call(ibm_set_xive, 3, 1, (unsigned long*)&status,
  152. irq, smp_threads_ready ? default_distrib_server : default_server, DEFAULT_PRIORITY);
  153. #else
  154. call_status = rtas_call(ibm_set_xive, 3, 1, (unsigned long*)&status,
  155. irq, default_server, DEFAULT_PRIORITY);
  156. #endif
  157. if( call_status != 0 ) {
  158. printk("xics_enable_irq: irq=%x: rtas_call failed; retn=%lx, status=%lxn",
  159.        irq, call_status, status);
  160. return;
  161. }
  162. }
  164. void
  165. xics_disable_irq(
  166. u_int virq
  167. )
  168. {
  169. u_int irq;
  170. unsigned long  status;
  171. long          call_status;
  173. virq -= XICS_IRQ_OFFSET;
  174. irq = virt_irq_to_real(virq);
  175. call_status = rtas_call(ibm_int_off, 1, 1, (unsigned long*)&status, 
  176. irq);
  177. if( call_status != 0 ) {
  178. printk("xics_disable_irq: irq=%x: rtas_call failed, retn=%lxn",
  179.        irq, call_status);
  180. return;
  181. }
  182. }
  184. void
  185. xics_end_irq(
  186. u_int irq
  187. )
  188. {
  189. int cpu = smp_processor_id();
  191. ops->cppr_info(cpu, 0); /* actually the value overwritten by ack */
  192. iosync();
  193. ops->xirr_info_set(cpu, ((0xff<<24) | (virt_irq_to_real(irq-XICS_IRQ_OFFSET))));
  194. iosync();
  195. }
  197. void
  198. xics_mask_and_ack_irq(u_int irq)
  199. {
  200. int cpu = smp_processor_id();
  202. if( irq < XICS_IRQ_OFFSET ) {
  203. i8259_pic.ack(irq);
  204. iosync();
  205. ops->xirr_info_set(cpu, ((0xff<<24) | xics_irq_8259_cascade_real));
  206. iosync();
  207. }
  208. else {
  209. ops->cppr_info(cpu, 0xff);
  210. iosync();
  211. }
  212. }
  214. int
  215. xics_get_irq(struct pt_regs *regs)
  216. {
  217. u_int cpu = smp_processor_id();
  218. u_int vec;
  219. int irq;
  221. vec = ops->xirr_info_get(cpu);
  222. /*  (vec >> 24) == old priority */
  223. vec &= 0x00ffffff;
  224. /* for sanity, this had better be < NR_IRQS - 16 */
  225. if( vec == xics_irq_8259_cascade_real ) {
  226. irq = i8259_irq(cpu);
  227. if(irq == -1) {
  228. /* Spurious cascaded interrupt.  Still must ack xics */
  229.                         xics_end_irq(XICS_IRQ_OFFSET + xics_irq_8259_cascade);
  230. irq = -1;
  231. }
  232. } else if( vec == XICS_IRQ_SPURIOUS ) {
  233. irq = -1;
  234. } else {
  235. irq = real_irq_to_virt(vec) + XICS_IRQ_OFFSET;
  236. }
  237. return irq;
  238. }
  241. #ifdef CONFIG_SMP
  242. void xics_ipi_action(int irq, void *dev_id, struct pt_regs *regs)
  243. {
  244. extern volatile unsigned long xics_ipi_message[];
  245. int cpu = smp_processor_id();
  247. ops->qirr_info(cpu, 0xff);
  248. while (xics_ipi_message[cpu]) {
  249. if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION, &xics_ipi_message[cpu])) {
  250. mb();
  251. smp_message_recv(PPC_MSG_CALL_FUNCTION, regs);
  252. }
  253. if (test_and_clear_bit(PPC_MSG_RESCHEDULE, &xics_ipi_message[cpu])) {
  254. mb();
  255. smp_message_recv(PPC_MSG_RESCHEDULE, regs);
  256. }
  257. #ifdef CONFIG_XMON
  258. if (test_and_clear_bit(PPC_MSG_XMON_BREAK, &xics_ipi_message[cpu])) {
  259. mb();
  260. smp_message_recv(PPC_MSG_XMON_BREAK, regs);
  261. }
  262. #endif
  263. }
  264. }
  266. void xics_cause_IPI(int cpu)
  267. {
  268. ops->qirr_info(cpu,0) ;
  269. }
  271. void xics_setup_cpu(void)
  272. {
  273. int cpu = smp_processor_id();
  275. ops->cppr_info(cpu, 0xff);
  276. iosync();
  277. }
  278. #endif /* CONFIG_SMP */
  280. void
  281. xics_init_IRQ( void )
  282. {
  283. int i;
  284. unsigned long intr_size = 0;
  285. struct device_node *np;
  286. uint *ireg, ilen, indx=0;
  288. ppc64_boot_msg(0x20, "XICS Init");
  290. ibm_get_xive = rtas_token("ibm,get-xive");
  291. ibm_set_xive = rtas_token("ibm,set-xive");
  292. ibm_int_off = rtas_token("ibm,int-off");
  294. np = find_type_devices("PowerPC-External-Interrupt-Presentation");
  295. if (!np) {
  296. printk(KERN_WARNING "Can't find Interrupt Presentationn");
  297. udbg_printf("Can't find Interrupt Presentationn");
  298. while (1);
  299. }
  300. nextnode:
  301. ireg = (uint *)get_property(np, "ibm,interrupt-server-ranges", 0);
  302. if (ireg) {
  303. /*
  304.  * set node starting index for this node
  305.  */
  306. indx = *ireg;
  307. }
  309. ireg = (uint *)get_property(np, "reg", &ilen);
  310. if (!ireg) {
  311. printk(KERN_WARNING "Can't find Interrupt Reg Propertyn");
  312. udbg_printf("Can't find Interrupt Reg Propertyn");
  313. while (1);
  314. }
  316. while (ilen) {
  317. inodes[indx].addr = (unsigned long long)*ireg++ << 32;
  318. ilen -= sizeof(uint);
  319. inodes[indx].addr |= *ireg++;
  320. ilen -= sizeof(uint);
  321. inodes[indx].size = (unsigned long long)*ireg++ << 32;
  322. ilen -= sizeof(uint);
  323. inodes[indx].size |= *ireg++;
  324. ilen -= sizeof(uint);
  325. indx++;
  326. if (indx >= NR_CPUS) break;
  327. }
  329. np = np->next;
  330. if ((indx < NR_CPUS) && np) goto nextnode;
  332. /* Find the server numbers for the boot cpu. */
  333. for (np = find_type_devices("cpu"); np; np = np->next) {
  334. ireg = (uint *)get_property(np, "reg", &ilen);
  335. if (ireg && ireg[0] == hard_smp_processor_id()) {
  336. ireg = (uint *)get_property(np, "ibm,ppc-interrupt-gserver#s", &ilen);
  337. i = ilen / sizeof(int);
  338. if (ireg && i > 0) {
  339. default_server = ireg[0];
  340. default_distrib_server = ireg[i-1]; /* take last element */
  341. }
  342. break;
  343. }
  344. }
  346. intr_base = inodes[0].addr;
  347. intr_size = (ulong)inodes[0].size;
  349. np = find_type_devices("interrupt-controller");
  350. if (!np) {
  351. printk(KERN_WARNING "xics:  no ISA Interrupt Controllern");
  352. xics_irq_8259_cascade_real = -1;
  353. xics_irq_8259_cascade = -1;
  354. } else {
  355. ireg = (uint *) get_property(np, "interrupts", 0);
  356. if (!ireg) {
  357. printk(KERN_WARNING "Can't find ISA Interrupts Propertyn");
  358. udbg_printf("Can't find ISA Interrupts Propertyn");
  359. while (1);
  360. }
  361. xics_irq_8259_cascade_real = *ireg;
  362. xics_irq_8259_cascade = virt_irq_create_mapping(xics_irq_8259_cascade_real);
  363. }
  365. if (naca->platform == PLATFORM_PSERIES) {
  366. #ifdef CONFIG_SMP
  367. for (i = 0; i < naca->processorCount; ++i) {
  368. xics_info.per_cpu[i] =
  369.   __ioremap((ulong)inodes[get_hard_smp_processor_id(i)].addr, 
  370.   (ulong)inodes[get_hard_smp_processor_id(i)].size, _PAGE_NO_CACHE);
  371. }
  372. #else
  373. xics_info.per_cpu[0] = __ioremap((ulong)intr_base, intr_size, _PAGE_NO_CACHE);
  374. #endif /* CONFIG_SMP */
  375. #ifdef CONFIG_PPC_PSERIES
  376. /* actually iSeries does not use any of xics...but it has link dependencies
  377.  * for now, except this new one...
  378.  */
  379. } else if (naca->platform == PLATFORM_PSERIES_LPAR) {
  380. ops = &pSeriesLP_ops;
  381. #endif
  382. }
  384. xics_8259_pic.enable = i8259_pic.enable;
  385. xics_8259_pic.disable = i8259_pic.disable;
  386. for (i = 0; i < 16; ++i)
  387. irq_desc[i].handler = &xics_8259_pic;
  388. for (; i < NR_IRQS; ++i)
  389. irq_desc[i].handler = &xics_pic;
  391. ops->cppr_info(0, 0xff);
  392. iosync();
  393. if (xics_irq_8259_cascade != -1) {
  394. if (request_irq(xics_irq_8259_cascade + XICS_IRQ_OFFSET, no_action,
  395. 0, "8259 cascade", 0))
  396. printk(KERN_ERR "xics_init_IRQ: couldn't get 8259 cascaden");
  397. i8259_init();
  398. }
  400. #ifdef CONFIG_SMP
  401. real_irq_to_virt_map[XICS_IPI] = virt_irq_to_real_map[XICS_IPI] = XICS_IPI;
  402. request_irq(XICS_IPI + XICS_IRQ_OFFSET, xics_ipi_action, 0, "IPI", 0);
  403. irq_desc[XICS_IPI+XICS_IRQ_OFFSET].status |= IRQ_PER_CPU;
  404. #endif
  405. ppc64_boot_msg(0x21, "XICS Done");
  406. }
  408. void xics_isa_init(void)
  409. {
  410. return;
  411. if (request_irq(xics_irq_8259_cascade + XICS_IRQ_OFFSET, no_action,
  412. 0, "8259 cascade", 0))
  413. printk(KERN_ERR "xics_init_IRQ: couldn't get 8259 cascaden");
  414. i8259_init();
  415. }
  417. /*
  418.  * Find first logical cpu and return its physical cpu number
  419.  */
  420. static inline u32 physmask(u32 cpumask)
  421. {
  422. int i;
  424. for (i = 0; i < smp_num_cpus; ++i, cpumask >>= 1) {
  425. if (cpumask & 1)
  426. return get_hard_smp_processor_id(i);
  427. }
  429. printk(KERN_ERR "xics_set_affinity: invalid irq maskn");
  431. return default_distrib_server;
  432. }
  434. void xics_set_affinity(unsigned int virq, unsigned long cpumask)
  435. {
  436.         irq_desc_t *desc = irq_desc + virq;
  437. unsigned int irq;
  438. unsigned long flags;
  439. long status;
  440. unsigned long xics_status[2];
  441. u32 newmask;
  443. virq -= XICS_IRQ_OFFSET;
  444. irq = virt_irq_to_real(virq);
  445. if (irq == XICS_IPI)
  446. return;
  448.         spin_lock_irqsave(&desc->lock, flags);
  450. status = rtas_call(ibm_get_xive, 1, 3, (void *)&xics_status, irq);
  452. if (status) {
  453. printk("xics_set_affinity: irq=%d ibm,get-xive returns %ldn",
  454. irq, status);
  455. goto out;
  456. }
  458. /* For the moment only implement delivery to all cpus or one cpu */
  459. if (cpumask == 0xffffffff)
  460. newmask = default_distrib_server;
  461. else
  462. newmask = physmask(cpumask);
  464. status = rtas_call(ibm_set_xive, 3, 1, NULL,
  465. irq, newmask, xics_status[1]);
  467. if (status) {
  468. printk("xics_set_affinity irq=%d ibm,set-xive returns %ldn",
  469. irq, status);
  470. goto out;
  471. }
  473. out:
  474.         spin_unlock_irqrestore(&desc->lock, flags);
  475. }