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

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

嵌入式Linux

开发平台：

Unix_Linux

irq.c：源码内容
  1. /*
  2.  * Copyright (C) 2002 MIZI Research, Inc.
  3.  *
  4.  * machine dependent irq handling routine
  5.  *
  6.  * Author: Nandy Lyu <nandy@mizi.com>
  7.  * Date  : $Date: 2002/05/14 02:19:42 $ 
  8.  *
  9.  * $Revision: 1.1.2.4 $
  11.    Tue May 21 2002 Nandy Lyu <nandy@mizi.com>
  12.    - initial
  13.    - BUG:
  14. 1) set_EINT_IRQ_edge 颊毫具 凳
  15. 2) INTSUBMSK绰 阿 device driver俊辑 力绢窍档废 秦具 窃.
  17.    Wed Aug 14 2002 Yong-iL Joh <tolkien@mizi.com>
  18.    - new irq scheme阑 利侩, 困俊 攫鞭等 bug 绊魔
  20.  *
  21.  * This file is subject to the terms and conditions of the GNU General Public
  22.  * License.  See the file COPYING in the main directory of this archive
  23.  * for more details.
  24.  */
  26. #include <linux/config.h>
  27. #include <linux/kernel.h>
  28. #include <linux/module.h>
  29. #include <linux/init.h>
  30. #include <linux/sched.h>
  31. #include <linux/ioport.h>
  32. #include <linux/interrupt.h>
  34. #include <asm/hardware.h>
  35. #include <asm/irq.h>
  36. #include <asm/mach/irq.h>
  38. #define ClearPending(x) {
  39.   SRCPND = (1 << (x));
  40.   INTPND = (1 << (x));
  41. }
  43. #define EINT_OFFSET(x) ((x) - NORMAL_IRQ_OFFSET + 4)
  44. #define SUBIRQ_OFFSET(x) ((x) - EXT_IRQ_OFFSET)
  46. #define EXTINT_MASK 0x7
  48. #if 0
  50. /*
  51.  * set_GPIO_IRQ_edge - set interrupt signal for External Interrupts
  52.  *
  53.  * parameters:
  54.  * irq number of external interrupt (IRQ_EINT0 ~ IRQ_EINT23)
  55.  * edge signal method
  56.  */
  57. #define EXTINT_OFFSET 0x4
  58. #define EXTINT_MASK 0x7
  59. int set_EXT_IRQ_mode(int irq, int edge) {
  60. unsigned long flags;
  61. int shift_value;
  63. if (!(((IRQ_EINT4 <= irq) && (irq <= IRQ_EINT23)) ||
  64.       ((IRQ_EINT0 <= irq) && (irq <= IRQ_EINT3))))
  65.   return -EINVAL;
  67. local_irq_save(flags);
  68. if (irq < IRQ_EINT4) { /* IRQ_EINT0 ~ IRQ_EINT3 */
  69.   shift_value = (irq % 8) * EXTINT_OFFSET;
  70.   EXTINT0 &= ~(EXTINT_MASK << shift_value);
  71.   EXTINT0 |= (edge << shift_value);
  72.   ClearPending(irq);
  73. } else {
  74.   shift_value = ((irq + 4) % 8) * EXTINT_OFFSET;
  75.   if (irq < IRQ_EINT8) { /* IRQ_EINT4 ~ IRQ_EINT7 */
  76.     EXTINT0 &= ~(EXTINT_MASK << shift_value);
  77.     EXTINT0 |= (edge << shift_value);
  78.     EINTPEND = (1 << shift_value);
  79.     ClearPending(IRQ_EINT4_7);
  80.   } else if (irq < IRQ_EINT16) { /* IRQ_EINT8 ~ IRQ_EINT15 */
  81.     EXTINT1 &= ~(EXTINT_MASK << shift_value);
  82.     EXTINT1 |= (edge << shift_value);
  83.     EINTPEND = (1 << shift_value);
  84.     ClearPending(IRQ_EINT8_23);
  85.   } else { /* IRQ_EINT16 ~ IRQ_EINT23 */
  86.     EXTINT2 &= ~(EXTINT_MASK << shift_value);
  87.     EXTINT2 |= (edge << shift_value);
  88.     EINTPEND = (1 << shift_value);
  89.     ClearPending(IRQ_EINT8_23);
  90.   }
  91. }
  92. irq_desc[irq].valid = 1;
  94. restore_flags(flags);
  95. return 0;
  96. }
  97. EXPORT_SYMBOL(set_EXT_IRQ_mode);
  98. #endif
  100. /*
  101.  * External IRQ甫 力寇茄 IRQ甸阑 request_irq()肺 殿废窍扁 傈俊
  102.  * 购啊 秦林绢具 瞪 老甸捞 乐阑鳖夸? 力 积阿俊绰 绝促绊 壕聪促.
  103.  * IRQ甸 吝俊辑 External IRQ(伙己俊辑 林厘窍绰 侩绢)父捞 GPIO甫
  104.  * 固府 汲沥窍绊 甸绢啊具 邓聪促. 弊贰辑 窍唱狼 窃荐俊辑
  105.  * 葛电 巴阑 秦搬秦 滚府绰 巴篮 绢冻鳖 酵焙夸.
  106.  *
  107.  * 2002.09.03 厘绕.
  108.  */
  110. static int inline
  111. fixup_irq_num(int irq)
  112. {
  113. if (irq < IRQ_EINT4) return irq;
  114. else return ((irq + 4) - NORMAL_IRQ_OFFSET);
  115. }
  117. static void inline
  118. set_gpios(int irq, int pullup)
  119. {
  120. int shift;
  121. if (irq < 8) {
  122. shift = 2*irq;
  123. GPFCON &= ~(0x3 << shift);
  124. GPFCON |= (0x2 << shift);
  125. GPFUP &= ~(GRAB_PULLUP(pullup) << irq);
  126. GPFUP |= (GRAB_PULLUP(pullup) << irq);
  127. } else {
  128. shift = 2*(irq - 8);
  129. GPGCON &= ~(0x3 << shift);
  130. GPGCON |= (0x2 << shift);
  131. GPGUP &= ~(GRAB_PULLUP(pullup) << (irq - 8));
  132. GPGUP |= (GRAB_PULLUP(pullup) << (irq - 8));
  133. } 
  134. }
  136. int 
  137. set_external_irq(int irq, int edge, int pullup)
  138. {
  139. unsigned long flags;
  140. int real_irq, reg_ofs, shift;
  141. volatile u32 *extint = (volatile u32 *)io_p2v(0x56000088);
  143. //printk(__FUNCTION__" calledn");
  144. if (((irq < IRQ_EINT0) && (irq > IRQ_EINT23)) ||
  145.     ((irq > IRQ_EINT3) && (irq < IRQ_EINT4)))
  146. return -EINVAL;
  148. real_irq = fixup_irq_num(irq);
  149. //printk(__FUNCTION__"(): real_irq = %dn", real_irq);
  151. set_gpios(real_irq, pullup);
  153. local_irq_save(flags);
  155. reg_ofs = (real_irq / 8);
  156. //printk(__FUNCTION__"(): regs_ofs = %dn", reg_ofs);
  157. shift = 4 * (real_irq - 8 * reg_ofs);
  158. extint += reg_ofs;
  160. *extint &= ~(EXTINT_MASK << shift);
  161. *extint |= (edge << shift);
  163. if (irq < 4) {
  164. SRCPND |= (1 << real_irq);
  165. INTPND |= (1 << real_irq);
  166. } else {
  167. EINTPEND |= (1 << real_irq);
  168. }
  170. irq_desc[irq].valid = 1;
  172. restore_flags(flags);
  174. return 0;
  175. }
  176. EXPORT_SYMBOL(set_external_irq);
  179. /*
  180.  * Defined irq handlers
  181.  */
  182. static void s3c2410_mask_ack_irq(unsigned int irq)
  183. {
  184. INTMSK |= (1 << irq);
  185. SRCPND = (1 << irq);
  186. INTPND = (1 << irq);
  187. }
  189. static void s3c2410_mask_irq(unsigned int irq)
  190. {
  191. INTMSK |= (1 << irq);
  192. }
  194. static void s3c2410_unmask_irq(unsigned int irq)
  195. {
  196. INTMSK &= ~(1 << irq);
  197. }
  199. /* for EINT? */
  200. static void EINT4_23mask_ack_irq(unsigned int irq)
  201. {
  202. irq = EINT_OFFSET(irq);
  203. EINTMASK |= (1 << irq);
  204. EINTPEND = (1 << irq);
  206. if (irq < EINT_OFFSET(IRQ_EINT8)) {
  207. //   INTMSK |= (1 << SHIFT_EINT4_7);
  208.   ClearPending(SHIFT_EINT4_7);
  209. } else {
  210. //   INTMSK |= (1 << SHIFT_EINT8_23);
  211.   ClearPending(SHIFT_EINT8_23);
  212. }
  213. }
  215. static void EINT4_23mask_irq(unsigned int irq)
  216. {
  217. #if 0
  218. if (irq < IRQ_EINT8) {
  219.   INTMSK |= (1 << SHIFT_EINT4_7);
  220. } else {
  221.   INTMSK |= (1 << SHIFT_EINT8_23);
  222. }
  223. #endif
  224. irq = EINT_OFFSET(irq);
  225. EINTMASK |= (1 << irq);
  226. }
  228. static void EINT4_23unmask_irq(unsigned int irq)
  229. {
  230. EINTMASK &= ~(1 << EINT_OFFSET(irq));
  232. if (irq < IRQ_EINT8) {
  233.   INTMSK &= ~(1 << SHIFT_EINT4_7);
  234. } else {
  235.   INTMSK &= ~(1 << SHIFT_EINT8_23);
  236. }
  237. }
  240. /* for sub_IRQ */
  241. static void SUB_mask_ack_irq(unsigned int irq)
  242. {
  243. INTSUBMSK |= (1 << SUBIRQ_OFFSET(irq));
  244. SUBSRCPND = (1 << SUBIRQ_OFFSET(irq));
  246. if (irq <= IRQ_ERR0) {
  247.   ClearPending(SHIFT_UART0);
  248.         } else if (irq <= IRQ_ERR1) {
  249.   ClearPending(SHIFT_UART1);
  250. } else if (irq <= IRQ_ERR2){
  251.   ClearPending(SHIFT_UART2);
  252.         } else { /* if ( irq <= IRQ_ADC_DONE ) { */
  253.   ClearPending(SHIFT_ADCTC);
  254. }
  255. }
  257. static void SUB_mask_irq(unsigned int irq)
  258. {
  259. INTSUBMSK |= (1 << SUBIRQ_OFFSET(irq));
  260. }
  262. static void SUB_unmask_irq(unsigned int irq)
  263. {
  264. INTSUBMSK &= ~(1 << SUBIRQ_OFFSET(irq));
  266. if (irq <= IRQ_ERR0) {
  267. INTMSK &= ~(1 << SHIFT_UART0); 
  268.         } else if (irq <= IRQ_ERR1) {
  269. INTMSK &= ~(1 << SHIFT_UART1);
  270. } else if (irq <= IRQ_ERR2){
  271.      INTMSK &= ~(1 << SHIFT_UART2);
  272.         } else { /* if ( irq <= IRQ_ADC_DONE ) { */
  273. INTMSK &= ~(1 << SHIFT_ADCTC);
  274.         }
  275. }
  277. /*
  278.  *  fixup_irq() for do_IRQ() in kernel/irq.c
  279.  */
  280. inline unsigned int get_subIRQ(int irq, int begin, int end, int fail_irq) {
  281. int i;
  283. for(i=begin; i <= end; i++) {
  284.   if (irq & (1 << i))
  285.     return (EXT_IRQ_OFFSET + i);
  286. }
  287. return fail_irq;
  288. }
  290. inline unsigned int get_extIRQ(int irq, int begin, int end, int fail_irq) {
  291. int i;
  293. for(i=begin; i <= end; i++) {
  294.   if (irq & (1 << i))
  295.     return (NORMAL_IRQ_OFFSET - 4 + i);
  296. }
  297. return fail_irq;
  298. }
  300. unsigned int fixup_irq(int irq) {
  301.     unsigned int ret;
  302.     unsigned long sub_mask, ext_mask;
  304.     if (irq == OS_TIMER)
  305.       return irq;
  307.     switch (irq) {
  308.     case IRQ_UART0:
  309.       sub_mask = SUBSRCPND & ~INTSUBMSK;
  310.       ret = get_subIRQ(sub_mask, 0, 2, irq);
  311.       break;
  312.     case IRQ_UART1:
  313.       sub_mask = SUBSRCPND & ~INTSUBMSK;
  314.       ret = get_subIRQ(sub_mask, 3, 5, irq);
  315.       break;
  316.     case IRQ_UART2:
  317.       sub_mask = SUBSRCPND & ~INTSUBMSK;
  318.       ret = get_subIRQ(sub_mask, 6, 8, irq);
  319.       break;
  320.     case IRQ_ADCTC:
  321.       sub_mask = SUBSRCPND & ~INTSUBMSK;
  322.       ret = get_subIRQ(sub_mask, 9, 10, irq);
  323.       break;
  324.     case IRQ_EINT4_7:
  325.       ext_mask = EINTPEND & ~EINTMASK;
  326.       ret = get_extIRQ(ext_mask, 4, 7, irq);
  327.       break;
  328.     case IRQ_EINT8_23:
  329.       ext_mask = EINTPEND & ~EINTMASK;
  330.       ret = get_extIRQ(ext_mask, 8, 23, irq);
  331.       break;
  332.     default:
  333.       ret = irq;
  334.     }
  336.     return ret;
  337. }
  339. static struct resource irq_resource = {
  340. name: "irqs",
  341. start: 0x4a000000,
  342. end: 0x4a00001f,
  343. };
  345. static struct resource eint_resource = {
  346. name: "ext irqs",
  347. start: 0x56000088,
  348. end: 0x560000ab,
  349. };
  351. void __init s3c2410_init_irq(void) {
  352.     int irq;
  354.     request_resource(&iomem_resource, &irq_resource);
  355.     request_resource(&iomem_resource, &eint_resource);
  357.     /* disable all IRQs */
  358.     INTMSK = 0xffffffff;
  359.     INTSUBMSK = 0x7ff;
  360.     EINTMASK = 0x00fffff0;
  362.     /* all IRQs are IRQ, not FIQ
  363.        0 : IRQ mode
  364.        1 : FIQ mode
  365.     */
  366.     INTMOD = 0x00000000;
  368.     /* clear Source/Interrupt Pending Register */
  369.     SRCPND = 0xffffffff;
  370.     INTPND = 0xffffffff;
  371.     SUBSRCPND = 0x7ff;
  372.     EINTPEND = 0x00fffff0;
  374.     /* Define irq handler */
  375.     for (irq=0; irq < NORMAL_IRQ_OFFSET; irq++) {
  376.       irq_desc[irq].valid = 1;
  377.       irq_desc[irq].probe_ok = 1;
  378.       irq_desc[irq].mask_ack = s3c2410_mask_ack_irq;
  379.       irq_desc[irq].mask = s3c2410_mask_irq;
  380.       irq_desc[irq].unmask = s3c2410_unmask_irq;
  381.     }
  383.       irq_desc[IRQ_RESERVED6].valid = 0;
  384.       irq_desc[IRQ_RESERVED24].valid = 0;
  386.       irq_desc[IRQ_EINT4_7].valid = 0;
  387.       irq_desc[IRQ_EINT8_23].valid = 0;
  389.       irq_desc[IRQ_EINT0].valid = 0;
  390.       irq_desc[IRQ_EINT1].valid = 0;
  391.       irq_desc[IRQ_EINT2].valid = 0;
  392.       irq_desc[IRQ_EINT3].valid = 0;
  394.     for (irq=NORMAL_IRQ_OFFSET; irq < EXT_IRQ_OFFSET; irq++) {
  395.       irq_desc[irq].valid = 0;
  396.       irq_desc[irq].probe_ok = 1;
  397.       irq_desc[irq].mask_ack = EINT4_23mask_ack_irq;
  398.       irq_desc[irq].mask = EINT4_23mask_irq;
  399.       irq_desc[irq].unmask = EINT4_23unmask_irq;
  400.     }
  402.     for (irq=EXT_IRQ_OFFSET; irq < SUB_IRQ_OFFSET; irq++) {
  403.       irq_desc[irq].valid = 1;
  404.       irq_desc[irq].probe_ok = 1;
  405.       irq_desc[irq].mask_ack = SUB_mask_ack_irq;
  406.       irq_desc[irq].mask = SUB_mask_irq;
  407.       irq_desc[irq].unmask = SUB_unmask_irq;
  408.     }  
  409. }
  410. /*
  411.  | $Id: event.c,v 1.1.2.4 2002/05/14 02:19:42 tolkien Exp $
  412.  |
  413.  | Local Variables:
  414.  | mode: c
  415.  | mode: font-lock
  416.  | version-control: t
  417.  | delete-old-versions: t
  418.  | End:
  419.  |
  420.  | -*- End-Of-File -*-
  421.  */