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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
irq.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：11k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

irq.c：源码内容
  1. /*
  2.  * BRIEF MODULE DESCRIPTION
  3.  * Au1000 interrupt routines.
  4.  *
  5.  * Copyright 2001 MontaVista Software Inc.
  6.  * Author: MontaVista Software, Inc.
  7.  * ppopov@mvista.com or source@mvista.com
  8.  *
  9.  *  This program is free software; you can redistribute  it and/or modify it
  10.  *  under  the terms of  the GNU General  Public License as published by the
  11.  *  Free Software Foundation;  either version 2 of the License, or (at your
  12.  *  option) any later version.
  13.  *
  14.  *  THIS  SOFTWARE  IS PROVIDED   ``AS IS'' AND   ANY EXPRESS OR IMPLIED
  15.  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
  16.  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  17.  *  NO EVENT  SHALL   THE AUTHOR  BE  LIABLE FOR ANY   DIRECT, INDIRECT,
  18.  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19.  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS OR SERVICES; LOSS OF
  20.  *  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  21.  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
  22.  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23.  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24.  *
  25.  *  You should have received a copy of the  GNU General Public License along
  26.  *  with this program; if not, write  to the Free Software Foundation, Inc.,
  27.  *  675 Mass Ave, Cambridge, MA 02139, USA.
  28.  */
  29. #include <linux/errno.h>
  30. #include <linux/init.h>
  31. #include <linux/kernel_stat.h>
  32. #include <linux/module.h>
  33. #include <linux/signal.h>
  34. #include <linux/sched.h>
  35. #include <linux/types.h>
  36. #include <linux/interrupt.h>
  37. #include <linux/ioport.h>
  38. #include <linux/timex.h>
  39. #include <linux/slab.h>
  40. #include <linux/random.h>
  41. #include <linux/delay.h>
  43. #include <asm/bitops.h>
  44. #include <asm/bootinfo.h>
  45. #include <asm/io.h>
  46. #include <asm/mipsregs.h>
  47. #include <asm/system.h>
  48. #include <asm/au1000.h>
  50. #define ALLINTS (IE_IRQ0 | IE_IRQ1 | IE_IRQ2 | IE_IRQ3 | IE_IRQ4 | IE_IRQ5)
  52. #undef DEBUG_IRQ
  53. #ifdef DEBUG_IRQ
  54. /* note: prints function name for you */
  55. #define DPRINTK(fmt, args...) printk("%s: " fmt, __FUNCTION__ , ## args)
  56. #else
  57. #define DPRINTK(fmt, args...)
  58. #endif
  60. #define EXT_INTC0_REQ0 2 /* IP 2 */
  61. #define EXT_INTC0_REQ1 3 /* IP 3 */
  62. #define EXT_INTC1_REQ0 4 /* IP 4 */
  63. #define EXT_INTC1_REQ1 5 /* IP 5 */
  64. #define MIPS_TIMER_IP  7 /* IP 7 */
  66. #ifdef CONFIG_REMOTE_DEBUG
  67. extern void breakpoint(void);
  68. #endif
  70. extern asmlinkage void au1000_IRQ(void);
  72. extern void set_debug_traps(void);
  73. extern irq_cpustat_t irq_stat [];
  74. extern irq_desc_t irq_desc[NR_IRQS];
  76. unsigned int local_bh_count[NR_CPUS];
  77. unsigned int local_irq_count[NR_CPUS];
  79. static void setup_local_irq(unsigned int irq, int type, int int_req);
  80. static unsigned int startup_irq(unsigned int irq);
  81. static void end_irq(unsigned int irq_nr);
  82. static inline void mask_and_ack_level_irq(unsigned int irq_nr);
  83. static inline void mask_and_ack_rise_edge_irq(unsigned int irq_nr);
  84. static inline void mask_and_ack_fall_edge_irq(unsigned int irq_nr);
  85. static inline void local_enable_irq(unsigned int irq_nr);
  86. static inline void local_disable_irq(unsigned int irq_nr);
  88. unsigned long spurious_interrupts;
  89. extern unsigned int do_IRQ(int irq, struct pt_regs *regs);
  90. extern void __init init_generic_irq(void);
  92. static inline void sync(void)
  93. {
  94. __asm volatile ("sync");
  95. }
  98. /* Function for careful CP0 interrupt mask access */
  99. static inline void modify_cp0_intmask(unsigned clr_mask, unsigned set_mask)
  100. {
  101. unsigned long status = read_32bit_cp0_register(CP0_STATUS);
  102. status &= ~((clr_mask & 0xFF) << 8);
  103. status |=   (set_mask & 0xFF) << 8;
  104. write_32bit_cp0_register(CP0_STATUS, status);
  105. }
  108. static inline void mask_cpu_irq_input(unsigned int irq_nr)
  109. {
  110. modify_cp0_intmask(irq_nr, 0);
  111. }
  114. static inline void unmask_cpu_irq_input(unsigned int irq_nr)
  115. {
  116. modify_cp0_intmask(0, irq_nr);
  117. }
  120. static void disable_cpu_irq_input(unsigned int irq_nr)
  121. {
  122. unsigned long flags;
  124. save_and_cli(flags);
  125. mask_cpu_irq_input(irq_nr);
  126. restore_flags(flags);
  127. }
  130. static void enable_cpu_irq_input(unsigned int irq_nr)
  131. {
  132. unsigned long flags;
  134. save_and_cli(flags);
  135. unmask_cpu_irq_input(irq_nr);
  136. restore_flags(flags);
  137. }
  140. static void setup_local_irq(unsigned int irq_nr, int type, int int_req)
  141. {
  142. /* Config2[n], Config1[n], Config0[n] */
  143. if (irq_nr > AU1000_LAST_INTC0_INT) {
  144. switch (type) {
  145. case INTC_INT_RISE_EDGE: /* 0:0:1 */
  146. outl(1<<irq_nr,INTC1_CONFIG2_CLEAR);
  147. outl(1<<irq_nr, INTC1_CONFIG1_CLEAR);
  148. outl(1<<irq_nr, INTC1_CONFIG0_SET);
  149. break;
  150. case INTC_INT_FALL_EDGE: /* 0:1:0 */
  151. outl(1<<irq_nr, INTC1_CONFIG2_CLEAR);
  152. outl(1<<irq_nr, INTC1_CONFIG1_SET);
  153. outl(1<<irq_nr, INTC1_CONFIG0_CLEAR);
  154. break;
  155. case INTC_INT_HIGH_LEVEL: /* 1:0:1 */
  156. outl(1<<irq_nr, INTC1_CONFIG2_SET);
  157. outl(1<<irq_nr, INTC1_CONFIG1_CLEAR);
  158. outl(1<<irq_nr, INTC1_CONFIG0_SET);
  159. break;
  160. case INTC_INT_LOW_LEVEL: /* 1:1:0 */
  161. outl(1<<irq_nr, INTC1_CONFIG2_SET);
  162. outl(1<<irq_nr, INTC1_CONFIG1_SET);
  163. outl(1<<irq_nr, INTC1_CONFIG0_CLEAR);
  164. break;
  165. case INTC_INT_DISABLED: /* 0:0:0 */
  166. outl(1<<irq_nr, INTC1_CONFIG0_CLEAR);
  167. outl(1<<irq_nr, INTC1_CONFIG1_CLEAR);
  168. outl(1<<irq_nr, INTC1_CONFIG2_CLEAR);
  169. break;
  170. default: /* disable the interrupt */
  171. printk("unexpected int type %d (irq %d)n", type, irq_nr);
  172. outl(1<<irq_nr, INTC1_CONFIG0_CLEAR);
  173. outl(1<<irq_nr, INTC1_CONFIG1_CLEAR);
  174. outl(1<<irq_nr, INTC1_CONFIG2_CLEAR);
  175. return;
  176. }
  177. if (int_req) /* assign to interrupt request 1 */
  178. outl(1<<irq_nr, INTC1_ASSIGN_REQ_CLEAR);
  179. else      /* assign to interrupt request 0 */
  180. outl(1<<irq_nr, INTC1_ASSIGN_REQ_SET);
  181. outl(1<<irq_nr, INTC1_SOURCE_SET);
  182. outl(1<<irq_nr, INTC1_MASK_CLEAR);
  183. }
  184. else {
  185. switch (type) {
  186. case INTC_INT_RISE_EDGE: /* 0:0:1 */
  187. outl(1<<irq_nr,INTC0_CONFIG2_CLEAR);
  188. outl(1<<irq_nr, INTC0_CONFIG1_CLEAR);
  189. outl(1<<irq_nr, INTC0_CONFIG0_SET);
  190. break;
  191. case INTC_INT_FALL_EDGE: /* 0:1:0 */
  192. outl(1<<irq_nr, INTC0_CONFIG2_CLEAR);
  193. outl(1<<irq_nr, INTC0_CONFIG1_SET);
  194. outl(1<<irq_nr, INTC0_CONFIG0_CLEAR);
  195. break;
  196. case INTC_INT_HIGH_LEVEL: /* 1:0:1 */
  197. outl(1<<irq_nr, INTC0_CONFIG2_SET);
  198. outl(1<<irq_nr, INTC0_CONFIG1_CLEAR);
  199. outl(1<<irq_nr, INTC0_CONFIG0_SET);
  200. break;
  201. case INTC_INT_LOW_LEVEL: /* 1:1:0 */
  202. outl(1<<irq_nr, INTC0_CONFIG2_SET);
  203. outl(1<<irq_nr, INTC0_CONFIG1_SET);
  204. outl(1<<irq_nr, INTC0_CONFIG0_CLEAR);
  205. break;
  206. case INTC_INT_DISABLED: /* 0:0:0 */
  207. outl(1<<irq_nr, INTC0_CONFIG0_CLEAR);
  208. outl(1<<irq_nr, INTC0_CONFIG1_CLEAR);
  209. outl(1<<irq_nr, INTC0_CONFIG2_CLEAR);
  210. break;
  211. default: /* disable the interrupt */
  212. printk("unexpected int type %d (irq %d)n", type, irq_nr);
  213. outl(1<<irq_nr, INTC0_CONFIG0_CLEAR);
  214. outl(1<<irq_nr, INTC0_CONFIG1_CLEAR);
  215. outl(1<<irq_nr, INTC0_CONFIG2_CLEAR);
  216. return;
  217. }
  218. if (int_req) /* assign to interrupt request 1 */
  219. outl(1<<irq_nr, INTC0_ASSIGN_REQ_CLEAR);
  220. else      /* assign to interrupt request 0 */
  221. outl(1<<irq_nr, INTC0_ASSIGN_REQ_SET);
  222. outl(1<<irq_nr, INTC0_SOURCE_SET);
  223. outl(1<<irq_nr, INTC0_MASK_CLEAR);
  224. }
  225. sync();
  226. }
  229. static unsigned int startup_irq(unsigned int irq_nr)
  230. {
  231. local_enable_irq(irq_nr);
  232. return 0; 
  233. }
  236. static void shutdown_irq(unsigned int irq_nr)
  237. {
  238. local_disable_irq(irq_nr);
  239. return;
  240. }
  243. static inline void local_enable_irq(unsigned int irq_nr)
  244. {
  245. if (irq_nr > AU1000_LAST_INTC0_INT) {
  246. outl(1<<irq_nr, INTC1_MASK_SET);
  247. }
  248. else {
  249. outl(1<<irq_nr, INTC0_MASK_SET);
  250. }
  251. sync();
  252. }
  255. static inline void local_disable_irq(unsigned int irq_nr)
  256. {
  257. if (irq_nr > AU1000_LAST_INTC0_INT) {
  258. outl(1<<irq_nr, INTC1_MASK_CLEAR);
  259. }
  260. else {
  261. outl(1<<irq_nr, INTC0_MASK_CLEAR);
  262. }
  263. sync();
  264. }
  267. static inline void mask_and_ack_rise_edge_irq(unsigned int irq_nr)
  268. {
  269. if (irq_nr > AU1000_LAST_INTC0_INT) {
  270. outl(1<<irq_nr, INTC1_R_EDGE_DETECT_CLEAR);
  271. outl(1<<irq_nr, INTC1_MASK_CLEAR);
  272. }
  273. else {
  274. outl(1<<irq_nr, INTC0_R_EDGE_DETECT_CLEAR);
  275. outl(1<<irq_nr, INTC0_MASK_CLEAR);
  276. }
  277. sync();
  278. }
  281. static inline void mask_and_ack_fall_edge_irq(unsigned int irq_nr)
  282. {
  283. if (irq_nr > AU1000_LAST_INTC0_INT) {
  284. outl(1<<irq_nr, INTC1_F_EDGE_DETECT_CLEAR);
  285. outl(1<<irq_nr, INTC1_MASK_CLEAR);
  286. }
  287. else {
  288. outl(1<<irq_nr, INTC0_F_EDGE_DETECT_CLEAR);
  289. outl(1<<irq_nr, INTC0_MASK_CLEAR);
  290. }
  291. }
  294. static inline void mask_and_ack_level_irq(unsigned int irq_nr)
  295. {
  296. local_disable_irq(irq_nr);
  297. sync();
  298. return;
  299. }
  302. static void end_irq(unsigned int irq_nr)
  303. {
  304. if (!(irq_desc[irq_nr].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
  305. local_enable_irq(irq_nr);
  306. else
  307. printk("warning: end_irq %d did not enablen", irq_nr);
  308. }
  311. static struct hw_interrupt_type rise_edge_irq_type = {
  312. "Au1000 Rise Edge",
  313. startup_irq,
  314. shutdown_irq,
  315. local_enable_irq,
  316. local_disable_irq,
  317. mask_and_ack_rise_edge_irq,
  318. end_irq,
  319. NULL
  320. };
  323. static struct hw_interrupt_type fall_edge_irq_type = {
  324. "Au1000 Fall Edge",
  325. startup_irq,
  326. shutdown_irq,
  327. local_enable_irq,
  328. local_disable_irq,
  329. mask_and_ack_fall_edge_irq,
  330. end_irq,
  331. NULL
  332. };
  335. static struct hw_interrupt_type level_irq_type = {
  336. "Au1000 Level",
  337. startup_irq,
  338. shutdown_irq,
  339. local_enable_irq,
  340. local_disable_irq,
  341. mask_and_ack_level_irq,
  342. end_irq,
  343. NULL
  344. };
  347. void enable_cpu_timer(void)
  348. {
  349. enable_cpu_irq_input(1<<MIPS_TIMER_IP); /* timer interrupt */
  350. }
  353. void __init init_IRQ(void)
  354. {
  355. int i;
  356. unsigned long cp0_status;
  358. cp0_status = read_32bit_cp0_register(CP0_STATUS);
  359. memset(irq_desc, 0, sizeof(irq_desc));
  360. set_except_vector(0, au1000_IRQ);
  362. init_generic_irq();
  364. /* 
  365.  * Setup high priority interrupts on int_request0; low priority on
  366.  * int_request1
  367.  */
  368. for (i = 0; i <= NR_IRQS; i++) {
  369. switch (i) {
  370. case AU1000_MAC0_DMA_INT:
  371. case AU1000_MAC1_DMA_INT:
  372. setup_local_irq(i, INTC_INT_HIGH_LEVEL, 0);
  373. irq_desc[i].handler = &level_irq_type;
  374. break;
  375. default: /* active high, level interrupt */
  376. setup_local_irq(i, INTC_INT_HIGH_LEVEL, 1);
  377. irq_desc[i].handler = &level_irq_type;
  378. break;
  379. }
  380. }
  382. set_cp0_status(ALLINTS);
  383. #ifdef CONFIG_REMOTE_DEBUG
  384. /* If local serial I/O used for debug port, enter kgdb at once */
  385. puts("Waiting for kgdb to connect...");
  386. set_debug_traps();
  387. breakpoint(); 
  388. #endif
  389. }
  392. void mips_spurious_interrupt(struct pt_regs *regs)
  393. {
  394. spurious_interrupts++;
  395. }
  398. void intc0_req0_irqdispatch(struct pt_regs *regs)
  399. {
  400. int irq = 0, i;
  401. unsigned long int_request;
  403. int_request = inl(INTC0_REQ0_INT);
  405. if (!int_request) return;
  407. for (i=0; i<32; i++) {
  408. if ((int_request & 0x1)) {
  409. do_IRQ(irq, regs);
  410. }
  411. irq++;
  412. int_request >>= 1;
  413. }
  414. }
  417. void intc0_req1_irqdispatch(struct pt_regs *regs)
  418. {
  419. int irq = 0, i;
  420. unsigned long int_request;
  422. int_request = inl(INTC0_REQ1_INT);
  424. if (!int_request) return;
  426. for (i=0; i<32; i++) {
  427. if ((int_request & 0x1)) {
  428. do_IRQ(irq, regs);
  429. }
  430. irq++;
  431. int_request >>= 1;
  432. }
  433. }
  436. void intc1_req0_irqdispatch(struct pt_regs *regs)
  437. {
  438. int irq = 0, i;
  439. unsigned long int_request;
  441. int_request = inl(INTC1_REQ0_INT);
  443. if (!int_request) return;
  445. for (i=0; i<32; i++) {
  446. if ((int_request & 0x1)) {
  447. do_IRQ(irq, regs);
  448. }
  449. irq++;
  450. int_request >>= 1;
  451. }
  452. }
  455. void intc1_req1_irqdispatch(struct pt_regs *regs)
  456. {
  457. int irq = 0, i;
  458. unsigned long int_request;
  460. int_request = inl(INTC1_REQ1_INT);
  462. if (!int_request) return;
  464. for (i=0; i<32; i++) {
  465. if ((int_request & 0x1)) {
  466. do_IRQ(irq, regs);
  467. }
  468. irq++;
  469. int_request >>= 1;
  470. }
  471. }