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

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

Linux/Unix编程

开发平台：

Unix_Linux

setup.c：源码内容
  1. /*
  2.  * Setup the interrupt stuff.
  3.  *
  4.  * This file is subject to the terms and conditions of the GNU General Public
  5.  * License.  See the file "COPYING" in the main directory of this archive
  6.  * for more details.
  7.  *
  8.  * Copyright (C) 1998 Harald Koerfgen
  9.  * Copyright (C) 2000, 2001, 2002  Maciej W. Rozycki
  10.  */
  11. #include <linux/config.h>
  12. #include <linux/sched.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/mc146818rtc.h>
  15. #include <linux/param.h>
  16. #include <linux/console.h>
  17. #include <linux/init.h>
  18. #include <linux/module.h>
  19. #include <linux/types.h>
  21. #include <asm/cpu.h>
  22. #include <asm/bootinfo.h>
  23. #include <asm/irq.h>
  24. #include <asm/irq_cpu.h>
  25. #include <asm/mipsregs.h>
  26. #include <asm/reboot.h>
  27. #include <asm/traps.h>
  28. #include <asm/wbflush.h>
  30. #include <asm/dec/interrupts.h>
  31. #include <asm/dec/kn01.h>
  32. #include <asm/dec/kn02.h>
  33. #include <asm/dec/kn02ba.h>
  34. #include <asm/dec/kn02ca.h>
  35. #include <asm/dec/kn03.h>
  36. #include <asm/dec/kn230.h>
  37. #include <asm/dec/ioasic.h>
  38. #include <asm/dec/ioasic_addrs.h>
  39. #include <asm/dec/ioasic_ints.h>
  42. extern void dec_machine_restart(char *command);
  43. extern void dec_machine_halt(void);
  44. extern void dec_machine_power_off(void);
  45. extern void dec_intr_halt(int irq, void *dev_id, struct pt_regs *regs);
  47. extern asmlinkage void decstation_handle_int(void);
  49. volatile u32 *ioasic_base;
  50. unsigned long dec_kn_slot_size;
  52. /*
  53.  * IRQ routing and priority tables.  Priorites are set as follows:
  54.  *
  55.  *  KN01 KN230 KN02 KN02-BA KN02-CA KN03
  56.  *
  57.  * MEMORY CPU CPU CPU ASIC CPU CPU
  58.  * RTC CPU CPU CPU ASIC CPU CPU
  59.  * DMA - - - ASIC ASIC ASIC
  60.  * SERIAL0 CPU CPU CSR ASIC ASIC ASIC
  61.  * SERIAL1 - - - ASIC - ASIC
  62.  * SCSI CPU CPU CSR ASIC ASIC ASIC
  63.  * ETHERNET CPU * CSR ASIC ASIC ASIC
  64.  * other - - - ASIC - -
  65.  * TC2 - - CSR CPU ASIC ASIC
  66.  * TC1 - - CSR CPU ASIC ASIC
  67.  * TC0 - - CSR CPU ASIC ASIC
  68.  * other - CPU - CPU ASIC ASIC
  69.  * other - - - - CPU CPU
  70.  *
  71.  * * -- shared with SCSI
  72.  */
  74. int dec_interrupt[DEC_NR_INTS] = {
  75. [0 ... DEC_NR_INTS - 1] = -1
  76. };
  77. int_ptr cpu_mask_nr_tbl[DEC_MAX_CPU_INTS][2] = {
  78. { { i: ~0 }, { p: dec_intr_unimplemented } },
  79. };
  80. int_ptr asic_mask_nr_tbl[DEC_MAX_ASIC_INTS][2] = {
  81. { { i: ~0 }, { p: asic_intr_unimplemented } },
  82. };
  83. int cpu_fpu_mask = DEC_CPU_IRQ_MASK(DEC_CPU_INR_FPU);
  85. static struct irqaction ioirq = {NULL, 0, 0, "cascade", NULL, NULL};
  86. static struct irqaction fpuirq = {NULL, 0, 0, "fpu", NULL, NULL};
  88. static struct irqaction haltirq = {dec_intr_halt, 0, 0, "halt", NULL, NULL};
  91. void (*board_time_init) (struct irqaction * irq);
  94. /*
  95.  * enable the periodic interrupts
  96.  */
  97. static void __init dec_time_init(struct irqaction *irq)
  98. {
  99. /*
  100. * Here we go, enable periodic rtc interrupts.
  101. */
  103. #ifndef LOG_2_HZ
  104. #  define LOG_2_HZ 7
  105. #endif
  107. CMOS_WRITE(RTC_REF_CLCK_32KHZ | (16 - LOG_2_HZ), RTC_REG_A);
  108. CMOS_WRITE(CMOS_READ(RTC_REG_B) | RTC_PIE, RTC_REG_B);
  109. setup_irq(dec_interrupt[DEC_IRQ_RTC], irq);
  110. }
  113. /*
  114.  * Bus error (DBE/IBE exceptions and memory interrupts) handling
  115.  * setup.  Nothing for now.
  116.  */
  117. void __init bus_error_init(void)
  118. {
  119. }
  122. void __init decstation_setup(void)
  123. {
  124. board_time_init = dec_time_init;
  126. wbflush_setup();
  128. _machine_restart = dec_machine_restart;
  129. _machine_halt = dec_machine_halt;
  130. _machine_power_off = dec_machine_power_off;
  132. #ifdef CONFIG_FB
  133. conswitchp = &dummy_con;
  134. #endif
  136. rtc_ops = &dec_rtc_ops;
  137. }
  140. /*
  141.  * Machine-specific initialisation for KN01, aka DS2100 (aka Pmin)
  142.  * or DS3100 (aka Pmax).
  143.  */
  144. static int kn01_interrupt[DEC_NR_INTS] __initdata = {
  145. [DEC_IRQ_CASCADE] = -1,
  146. [DEC_IRQ_AB_RECV] = -1,
  147. [DEC_IRQ_AB_XMIT] = -1,
  148. [DEC_IRQ_DZ11] = DEC_CPU_IRQ_NR(KN01_CPU_INR_DZ11),
  149. [DEC_IRQ_ASC] = -1,
  150. [DEC_IRQ_FLOPPY] = -1,
  151. [DEC_IRQ_FPU] = DEC_CPU_IRQ_NR(DEC_CPU_INR_FPU),
  152. [DEC_IRQ_HALT] = -1,
  153. [DEC_IRQ_ISDN] = -1,
  154. [DEC_IRQ_LANCE] = DEC_CPU_IRQ_NR(KN01_CPU_INR_LANCE),
  155. [DEC_IRQ_MEMORY] = DEC_CPU_IRQ_NR(KN01_CPU_INR_MEMORY),
  156. [DEC_IRQ_PSU] = -1,
  157. [DEC_IRQ_RTC] = DEC_CPU_IRQ_NR(KN01_CPU_INR_RTC),
  158. [DEC_IRQ_SCC0] = -1,
  159. [DEC_IRQ_SCC1] = -1,
  160. [DEC_IRQ_SII] = DEC_CPU_IRQ_NR(KN01_CPU_INR_SII),
  161. [DEC_IRQ_TC0] = -1,
  162. [DEC_IRQ_TC1] = -1,
  163. [DEC_IRQ_TC2] = -1,
  164. [DEC_IRQ_TIMER] = -1,
  165. [DEC_IRQ_VIDEO] = DEC_CPU_IRQ_NR(KN01_CPU_INR_VIDEO),
  166. [DEC_IRQ_ASC_MERR] = -1,
  167. [DEC_IRQ_ASC_ERR] = -1,
  168. [DEC_IRQ_ASC_DMA] = -1,
  169. [DEC_IRQ_FLOPPY_ERR] = -1,
  170. [DEC_IRQ_ISDN_ERR] = -1,
  171. [DEC_IRQ_ISDN_RXDMA] = -1,
  172. [DEC_IRQ_ISDN_TXDMA] = -1,
  173. [DEC_IRQ_LANCE_MERR] = -1,
  174. [DEC_IRQ_SCC0A_RXERR] = -1,
  175. [DEC_IRQ_SCC0A_RXDMA] = -1,
  176. [DEC_IRQ_SCC0A_TXERR] = -1,
  177. [DEC_IRQ_SCC0A_TXDMA] = -1,
  178. [DEC_IRQ_SCC0B_RXERR] = -1,
  179. [DEC_IRQ_SCC0B_RXDMA] = -1,
  180. [DEC_IRQ_SCC0B_TXERR] = -1,
  181. [DEC_IRQ_SCC0B_TXDMA] = -1,
  182. [DEC_IRQ_SCC1A_RXERR] = -1,
  183. [DEC_IRQ_SCC1A_RXDMA] = -1,
  184. [DEC_IRQ_SCC1A_TXERR] = -1,
  185. [DEC_IRQ_SCC1A_TXDMA] = -1,
  186. };
  188. static int_ptr kn01_cpu_mask_nr_tbl[][2] __initdata = {
  189. { { i: DEC_CPU_IRQ_MASK(KN01_CPU_INR_MEMORY) },
  190. { i: DEC_CPU_IRQ_NR(KN01_CPU_INR_MEMORY) } },
  191. { { i: DEC_CPU_IRQ_MASK(KN01_CPU_INR_RTC) },
  192. { i: DEC_CPU_IRQ_NR(KN01_CPU_INR_RTC) } },
  193. { { i: DEC_CPU_IRQ_MASK(KN01_CPU_INR_DZ11) },
  194. { i: DEC_CPU_IRQ_NR(KN01_CPU_INR_DZ11) } },
  195. { { i: DEC_CPU_IRQ_MASK(KN01_CPU_INR_SII) },
  196. { i: DEC_CPU_IRQ_NR(KN01_CPU_INR_SII) } },
  197. { { i: DEC_CPU_IRQ_MASK(KN01_CPU_INR_LANCE) },
  198. { i: DEC_CPU_IRQ_NR(KN01_CPU_INR_LANCE) } },
  199. { { i: DEC_CPU_IRQ_ALL },
  200. { p: cpu_all_int } },
  201. };
  203. void __init dec_init_kn01(void)
  204. {
  205. /* Setup some memory addresses. */
  206. dec_rtc_base = (void *)KN01_RTC_BASE;
  207. dec_kn_slot_size = KN01_SLOT_SIZE;
  209. /* IRQ routing. */
  210. memcpy(&dec_interrupt, &kn01_interrupt,
  211. sizeof(kn01_interrupt));
  213. /* CPU IRQ priorities. */
  214. memcpy(&cpu_mask_nr_tbl, &kn01_cpu_mask_nr_tbl,
  215. sizeof(kn01_cpu_mask_nr_tbl));
  217. mips_cpu_irq_init(DEC_CPU_IRQ_BASE);
  219. } /* dec_init_kn01 */
  222. /*
  223.  * Machine-specific initialisation for KN230, aka DS5100, aka MIPSmate.
  224.  */
  225. static int kn230_interrupt[DEC_NR_INTS] __initdata = {
  226. [DEC_IRQ_CASCADE] = -1,
  227. [DEC_IRQ_AB_RECV] = -1,
  228. [DEC_IRQ_AB_XMIT] = -1,
  229. [DEC_IRQ_DZ11] = DEC_CPU_IRQ_NR(KN230_CPU_INR_DZ11),
  230. [DEC_IRQ_ASC] = -1,
  231. [DEC_IRQ_FLOPPY] = -1,
  232. [DEC_IRQ_FPU] = DEC_CPU_IRQ_NR(DEC_CPU_INR_FPU),
  233. [DEC_IRQ_HALT] = DEC_CPU_IRQ_NR(KN230_CPU_INR_HALT),
  234. [DEC_IRQ_ISDN] = -1,
  235. [DEC_IRQ_LANCE] = DEC_CPU_IRQ_NR(KN230_CPU_INR_LANCE),
  236. [DEC_IRQ_MEMORY] = DEC_CPU_IRQ_NR(KN230_CPU_INR_MEMORY),
  237. [DEC_IRQ_PSU] = -1,
  238. [DEC_IRQ_RTC] = DEC_CPU_IRQ_NR(KN230_CPU_INR_RTC),
  239. [DEC_IRQ_SCC0] = -1,
  240. [DEC_IRQ_SCC1] = -1,
  241. [DEC_IRQ_SII] = DEC_CPU_IRQ_NR(KN230_CPU_INR_SII),
  242. [DEC_IRQ_TC0] = -1,
  243. [DEC_IRQ_TC1] = -1,
  244. [DEC_IRQ_TC2] = -1,
  245. [DEC_IRQ_TIMER] = -1,
  246. [DEC_IRQ_VIDEO] = -1,
  247. [DEC_IRQ_ASC_MERR] = -1,
  248. [DEC_IRQ_ASC_ERR] = -1,
  249. [DEC_IRQ_ASC_DMA] = -1,
  250. [DEC_IRQ_FLOPPY_ERR] = -1,
  251. [DEC_IRQ_ISDN_ERR] = -1,
  252. [DEC_IRQ_ISDN_RXDMA] = -1,
  253. [DEC_IRQ_ISDN_TXDMA] = -1,
  254. [DEC_IRQ_LANCE_MERR] = -1,
  255. [DEC_IRQ_SCC0A_RXERR] = -1,
  256. [DEC_IRQ_SCC0A_RXDMA] = -1,
  257. [DEC_IRQ_SCC0A_TXERR] = -1,
  258. [DEC_IRQ_SCC0A_TXDMA] = -1,
  259. [DEC_IRQ_SCC0B_RXERR] = -1,
  260. [DEC_IRQ_SCC0B_RXDMA] = -1,
  261. [DEC_IRQ_SCC0B_TXERR] = -1,
  262. [DEC_IRQ_SCC0B_TXDMA] = -1,
  263. [DEC_IRQ_SCC1A_RXERR] = -1,
  264. [DEC_IRQ_SCC1A_RXDMA] = -1,
  265. [DEC_IRQ_SCC1A_TXERR] = -1,
  266. [DEC_IRQ_SCC1A_TXDMA] = -1,
  267. };
  269. static int_ptr kn230_cpu_mask_nr_tbl[][2] __initdata = {
  270. { { i: DEC_CPU_IRQ_MASK(KN230_CPU_INR_MEMORY) },
  271. { i: DEC_CPU_IRQ_NR(KN230_CPU_INR_MEMORY) } },
  272. { { i: DEC_CPU_IRQ_MASK(KN230_CPU_INR_RTC) },
  273. { i: DEC_CPU_IRQ_NR(KN230_CPU_INR_RTC) } },
  274. { { i: DEC_CPU_IRQ_MASK(KN230_CPU_INR_DZ11) },
  275. { i: DEC_CPU_IRQ_NR(KN230_CPU_INR_DZ11) } },
  276. { { i: DEC_CPU_IRQ_MASK(KN230_CPU_INR_SII) },
  277. { i: DEC_CPU_IRQ_NR(KN230_CPU_INR_SII) } },
  278. { { i: DEC_CPU_IRQ_ALL },
  279. { p: cpu_all_int } },
  280. };
  282. void __init dec_init_kn230(void)
  283. {
  284. /* Setup some memory addresses. */
  285. dec_rtc_base = (void *)KN01_RTC_BASE;
  286. dec_kn_slot_size = KN01_SLOT_SIZE;
  288. /* IRQ routing. */
  289. memcpy(&dec_interrupt, &kn230_interrupt,
  290. sizeof(kn230_interrupt));
  292. /* CPU IRQ priorities. */
  293. memcpy(&cpu_mask_nr_tbl, &kn230_cpu_mask_nr_tbl,
  294. sizeof(kn230_cpu_mask_nr_tbl));
  296. mips_cpu_irq_init(DEC_CPU_IRQ_BASE);
  298. } /* dec_init_kn230 */
  301. /*
  302.  * Machine-specific initialisation for KN02, aka DS5000/200, aka 3max.
  303.  */
  304. static int kn02_interrupt[DEC_NR_INTS] __initdata = {
  305. [DEC_IRQ_CASCADE] = DEC_CPU_IRQ_NR(KN02_CPU_INR_CASCADE),
  306. [DEC_IRQ_AB_RECV] = -1,
  307. [DEC_IRQ_AB_XMIT] = -1,
  308. [DEC_IRQ_DZ11] = KN02_IRQ_NR(KN02_CSR_INR_DZ11),
  309. [DEC_IRQ_ASC] = KN02_IRQ_NR(KN02_CSR_INR_ASC),
  310. [DEC_IRQ_FLOPPY] = -1,
  311. [DEC_IRQ_FPU] = DEC_CPU_IRQ_NR(DEC_CPU_INR_FPU),
  312. [DEC_IRQ_HALT] = -1,
  313. [DEC_IRQ_ISDN] = -1,
  314. [DEC_IRQ_LANCE] = KN02_IRQ_NR(KN02_CSR_INR_LANCE),
  315. [DEC_IRQ_MEMORY] = DEC_CPU_IRQ_NR(KN02_CPU_INR_MEMORY),
  316. [DEC_IRQ_PSU] = -1,
  317. [DEC_IRQ_RTC] = DEC_CPU_IRQ_NR(KN02_CPU_INR_RTC),
  318. [DEC_IRQ_SCC0] = -1,
  319. [DEC_IRQ_SCC1] = -1,
  320. [DEC_IRQ_SII] = -1,
  321. [DEC_IRQ_TC0] = KN02_IRQ_NR(KN02_CSR_INR_TC0),
  322. [DEC_IRQ_TC1] = KN02_IRQ_NR(KN02_CSR_INR_TC1),
  323. [DEC_IRQ_TC2] = KN02_IRQ_NR(KN02_CSR_INR_TC2),
  324. [DEC_IRQ_TIMER] = -1,
  325. [DEC_IRQ_VIDEO] = -1,
  326. [DEC_IRQ_ASC_MERR] = -1,
  327. [DEC_IRQ_ASC_ERR] = -1,
  328. [DEC_IRQ_ASC_DMA] = -1,
  329. [DEC_IRQ_FLOPPY_ERR] = -1,
  330. [DEC_IRQ_ISDN_ERR] = -1,
  331. [DEC_IRQ_ISDN_RXDMA] = -1,
  332. [DEC_IRQ_ISDN_TXDMA] = -1,
  333. [DEC_IRQ_LANCE_MERR] = -1,
  334. [DEC_IRQ_SCC0A_RXERR] = -1,
  335. [DEC_IRQ_SCC0A_RXDMA] = -1,
  336. [DEC_IRQ_SCC0A_TXERR] = -1,
  337. [DEC_IRQ_SCC0A_TXDMA] = -1,
  338. [DEC_IRQ_SCC0B_RXERR] = -1,
  339. [DEC_IRQ_SCC0B_RXDMA] = -1,
  340. [DEC_IRQ_SCC0B_TXERR] = -1,
  341. [DEC_IRQ_SCC0B_TXDMA] = -1,
  342. [DEC_IRQ_SCC1A_RXERR] = -1,
  343. [DEC_IRQ_SCC1A_RXDMA] = -1,
  344. [DEC_IRQ_SCC1A_TXERR] = -1,
  345. [DEC_IRQ_SCC1A_TXDMA] = -1,
  346. };
  348. static int_ptr kn02_cpu_mask_nr_tbl[][2] __initdata = {
  349. { { i: DEC_CPU_IRQ_MASK(KN02_CPU_INR_MEMORY) },
  350. { i: DEC_CPU_IRQ_NR(KN02_CPU_INR_MEMORY) } },
  351. { { i: DEC_CPU_IRQ_MASK(KN02_CPU_INR_RTC) },
  352. { i: DEC_CPU_IRQ_NR(KN02_CPU_INR_RTC) } },
  353. { { i: DEC_CPU_IRQ_MASK(KN02_CPU_INR_CASCADE) },
  354. { p: kn02_io_int } },
  355. { { i: DEC_CPU_IRQ_ALL },
  356. { p: cpu_all_int } },
  357. };
  359. static int_ptr kn02_asic_mask_nr_tbl[][2] __initdata = {
  360. { { i: KN02_IRQ_MASK(KN02_CSR_INR_DZ11) },
  361. { i: KN02_IRQ_NR(KN02_CSR_INR_DZ11) } },
  362. { { i: KN02_IRQ_MASK(KN02_CSR_INR_ASC) },
  363. { i: KN02_IRQ_NR(KN02_CSR_INR_ASC) } },
  364. { { i: KN02_IRQ_MASK(KN02_CSR_INR_LANCE) },
  365. { i: KN02_IRQ_NR(KN02_CSR_INR_LANCE) } },
  366. { { i: KN02_IRQ_MASK(KN02_CSR_INR_TC2) },
  367. { i: KN02_IRQ_NR(KN02_CSR_INR_TC2) } },
  368. { { i: KN02_IRQ_MASK(KN02_CSR_INR_TC1) },
  369. { i: KN02_IRQ_NR(KN02_CSR_INR_TC1) } },
  370. { { i: KN02_IRQ_MASK(KN02_CSR_INR_TC0) },
  371. { i: KN02_IRQ_NR(KN02_CSR_INR_TC0) } },
  372. { { i: KN02_IRQ_ALL },
  373. { p: kn02_all_int } },
  374. };
  376. void __init dec_init_kn02(void)
  377. {
  378. /* Setup some memory addresses. */
  379. dec_rtc_base = (void *)KN02_RTC_BASE;
  380. dec_kn_slot_size = KN02_SLOT_SIZE;
  382. /* IRQ routing. */
  383. memcpy(&dec_interrupt, &kn02_interrupt,
  384. sizeof(kn02_interrupt));
  386. /* CPU IRQ priorities. */
  387. memcpy(&cpu_mask_nr_tbl, &kn02_cpu_mask_nr_tbl,
  388. sizeof(kn02_cpu_mask_nr_tbl));
  390. /* KN02 CSR IRQ priorities. */
  391. memcpy(&asic_mask_nr_tbl, &kn02_asic_mask_nr_tbl,
  392. sizeof(kn02_asic_mask_nr_tbl));
  394. mips_cpu_irq_init(DEC_CPU_IRQ_BASE);
  395. init_kn02_irqs(KN02_IRQ_BASE);
  397. } /* dec_init_kn02 */
  400. /*
  401.  * Machine-specific initialisation for KN02-BA, aka DS5000/1xx
  402.  * (xx = 20, 25, 33), aka 3min.  Also applies to KN04(-BA), aka
  403.  * DS5000/150, aka 4min.
  404.  */
  405. static int kn02ba_interrupt[DEC_NR_INTS] __initdata = {
  406. [DEC_IRQ_CASCADE] = DEC_CPU_IRQ_NR(KN02BA_CPU_INR_CASCADE),
  407. [DEC_IRQ_AB_RECV] = -1,
  408. [DEC_IRQ_AB_XMIT] = -1,
  409. [DEC_IRQ_DZ11] = -1,
  410. [DEC_IRQ_ASC] = IO_IRQ_NR(KN02BA_IO_INR_ASC),
  411. [DEC_IRQ_FLOPPY] = -1,
  412. [DEC_IRQ_FPU] = DEC_CPU_IRQ_NR(DEC_CPU_INR_FPU),
  413. [DEC_IRQ_HALT] = DEC_CPU_IRQ_NR(KN02BA_CPU_INR_HALT),
  414. [DEC_IRQ_ISDN] = -1,
  415. [DEC_IRQ_LANCE] = IO_IRQ_NR(KN02BA_IO_INR_LANCE),
  416. [DEC_IRQ_MEMORY] = IO_IRQ_NR(KN02BA_IO_INR_MEMORY),
  417. [DEC_IRQ_PSU] = IO_IRQ_NR(KN02BA_IO_INR_PSU),
  418. [DEC_IRQ_RTC] = IO_IRQ_NR(KN02BA_IO_INR_RTC),
  419. [DEC_IRQ_SCC0] = IO_IRQ_NR(KN02BA_IO_INR_SCC0),
  420. [DEC_IRQ_SCC1] = IO_IRQ_NR(KN02BA_IO_INR_SCC1),
  421. [DEC_IRQ_SII] = -1,
  422. [DEC_IRQ_TC0] = DEC_CPU_IRQ_NR(KN02BA_CPU_INR_TC0),
  423. [DEC_IRQ_TC1] = DEC_CPU_IRQ_NR(KN02BA_CPU_INR_TC1),
  424. [DEC_IRQ_TC2] = DEC_CPU_IRQ_NR(KN02BA_CPU_INR_TC2),
  425. [DEC_IRQ_TIMER] = -1,
  426. [DEC_IRQ_VIDEO] = -1,
  427. [DEC_IRQ_ASC_MERR] = IO_IRQ_NR(IO_INR_ASC_MERR),
  428. [DEC_IRQ_ASC_ERR] = IO_IRQ_NR(IO_INR_ASC_ERR),
  429. [DEC_IRQ_ASC_DMA] = IO_IRQ_NR(IO_INR_ASC_DMA),
  430. [DEC_IRQ_FLOPPY_ERR] = -1,
  431. [DEC_IRQ_ISDN_ERR] = -1,
  432. [DEC_IRQ_ISDN_RXDMA] = -1,
  433. [DEC_IRQ_ISDN_TXDMA] = -1,
  434. [DEC_IRQ_LANCE_MERR] = IO_IRQ_NR(IO_INR_LANCE_MERR),
  435. [DEC_IRQ_SCC0A_RXERR] = IO_IRQ_NR(IO_INR_SCC0A_RXERR),
  436. [DEC_IRQ_SCC0A_RXDMA] = IO_IRQ_NR(IO_INR_SCC0A_RXDMA),
  437. [DEC_IRQ_SCC0A_TXERR] = IO_IRQ_NR(IO_INR_SCC0A_TXERR),
  438. [DEC_IRQ_SCC0A_TXDMA] = IO_IRQ_NR(IO_INR_SCC0A_TXDMA),
  439. [DEC_IRQ_SCC0B_RXERR] = -1,
  440. [DEC_IRQ_SCC0B_RXDMA] = -1,
  441. [DEC_IRQ_SCC0B_TXERR] = -1,
  442. [DEC_IRQ_SCC0B_TXDMA] = -1,
  443. [DEC_IRQ_SCC1A_RXERR] = IO_IRQ_NR(IO_INR_SCC1A_RXERR),
  444. [DEC_IRQ_SCC1A_RXDMA] = IO_IRQ_NR(IO_INR_SCC1A_RXDMA),
  445. [DEC_IRQ_SCC1A_TXERR] = IO_IRQ_NR(IO_INR_SCC1A_TXERR),
  446. [DEC_IRQ_SCC1A_TXDMA] = IO_IRQ_NR(IO_INR_SCC1A_TXDMA),
  447. };
  449. static int_ptr kn02ba_cpu_mask_nr_tbl[][2] __initdata = {
  450. { { i: DEC_CPU_IRQ_MASK(KN02BA_CPU_INR_CASCADE) },
  451. { p: kn02xa_io_int } },
  452. { { i: DEC_CPU_IRQ_MASK(KN02BA_CPU_INR_TC2) },
  453. { i: DEC_CPU_IRQ_NR(KN02BA_CPU_INR_TC2) } },
  454. { { i: DEC_CPU_IRQ_MASK(KN02BA_CPU_INR_TC1) },
  455. { i: DEC_CPU_IRQ_NR(KN02BA_CPU_INR_TC1) } },
  456. { { i: DEC_CPU_IRQ_MASK(KN02BA_CPU_INR_TC0) },
  457. { i: DEC_CPU_IRQ_NR(KN02BA_CPU_INR_TC0) } },
  458. { { i: DEC_CPU_IRQ_ALL },
  459. { p: cpu_all_int } },
  460. };
  462. static int_ptr kn02ba_asic_mask_nr_tbl[][2] __initdata = {
  463. { { i: IO_IRQ_MASK(KN02BA_IO_INR_MEMORY) },
  464. { i: IO_IRQ_NR(KN02BA_IO_INR_MEMORY) } },
  465. { { i: IO_IRQ_MASK(KN02BA_IO_INR_RTC) },
  466. { i: IO_IRQ_NR(KN02BA_IO_INR_RTC) } },
  467. { { i: IO_IRQ_DMA },
  468. { p: asic_dma_int } },
  469. { { i: IO_IRQ_MASK(KN02BA_IO_INR_SCC0) },
  470. { i: IO_IRQ_NR(KN02BA_IO_INR_SCC0) } },
  471. { { i: IO_IRQ_MASK(KN02BA_IO_INR_SCC1) },
  472. { i: IO_IRQ_NR(KN02BA_IO_INR_SCC1) } },
  473. { { i: IO_IRQ_MASK(KN02BA_IO_INR_ASC) },
  474. { i: IO_IRQ_NR(KN02BA_IO_INR_ASC) } },
  475. { { i: IO_IRQ_MASK(KN02BA_IO_INR_LANCE) },
  476. { i: IO_IRQ_NR(KN02BA_IO_INR_LANCE) } },
  477. { { i: IO_IRQ_ALL },
  478. { p: asic_all_int } },
  479. };
  481. void __init dec_init_kn02ba(void)
  482. {
  483. /* Setup some memory addresses. */
  484. ioasic_base = (void *)KN02BA_IOASIC_BASE;
  485. dec_rtc_base = (void *)KN02BA_RTC_BASE;
  486. dec_kn_slot_size = IOASIC_SLOT_SIZE;
  488. /* IRQ routing. */
  489. memcpy(&dec_interrupt, &kn02ba_interrupt,
  490. sizeof(kn02ba_interrupt));
  492. /* CPU IRQ priorities. */
  493. memcpy(&cpu_mask_nr_tbl, &kn02ba_cpu_mask_nr_tbl,
  494. sizeof(kn02ba_cpu_mask_nr_tbl));
  496. /* I/O ASIC IRQ priorities. */
  497. memcpy(&asic_mask_nr_tbl, &kn02ba_asic_mask_nr_tbl,
  498. sizeof(kn02ba_asic_mask_nr_tbl));
  500. mips_cpu_irq_init(DEC_CPU_IRQ_BASE);
  501. init_ioasic_irqs(IO_IRQ_BASE);
  503. } /* dec_init_kn02ba */
  506. /*
  507.  * Machine-specific initialisation for KN02-CA, aka DS5000/xx,
  508.  * (xx = 20, 25, 33), aka MAXine.  Also applies to KN04(-CA), aka
  509.  * DS5000/50, aka 4MAXine.
  510.  */
  511. static int kn02ca_interrupt[DEC_NR_INTS] __initdata = {
  512. [DEC_IRQ_CASCADE] = DEC_CPU_IRQ_NR(KN02CA_CPU_INR_CASCADE),
  513. [DEC_IRQ_AB_RECV] = IO_IRQ_NR(KN02CA_IO_INR_AB_RECV),
  514. [DEC_IRQ_AB_XMIT] = IO_IRQ_NR(KN02CA_IO_INR_AB_XMIT),
  515. [DEC_IRQ_DZ11] = -1,
  516. [DEC_IRQ_ASC] = IO_IRQ_NR(KN02CA_IO_INR_ASC),
  517. [DEC_IRQ_FLOPPY] = IO_IRQ_NR(KN02CA_IO_INR_FLOPPY),
  518. [DEC_IRQ_FPU] = DEC_CPU_IRQ_NR(DEC_CPU_INR_FPU),
  519. [DEC_IRQ_HALT] = DEC_CPU_IRQ_NR(KN02CA_CPU_INR_HALT),
  520. [DEC_IRQ_ISDN] = IO_IRQ_NR(KN02CA_IO_INR_ISDN),
  521. [DEC_IRQ_LANCE] = IO_IRQ_NR(KN02CA_IO_INR_LANCE),
  522. [DEC_IRQ_MEMORY] = DEC_CPU_IRQ_NR(KN02CA_CPU_INR_MEMORY),
  523. [DEC_IRQ_PSU] = -1,
  524. [DEC_IRQ_RTC] = DEC_CPU_IRQ_NR(KN02CA_CPU_INR_RTC),
  525. [DEC_IRQ_SCC0] = IO_IRQ_NR(KN02CA_IO_INR_SCC0),
  526. [DEC_IRQ_SCC1] = -1,
  527. [DEC_IRQ_SII] = -1,
  528. [DEC_IRQ_TC0] = IO_IRQ_NR(KN02CA_IO_INR_TC0),
  529. [DEC_IRQ_TC1] = IO_IRQ_NR(KN02CA_IO_INR_TC1),
  530. [DEC_IRQ_TC2] = -1,
  531. [DEC_IRQ_TIMER] = DEC_CPU_IRQ_NR(KN02CA_CPU_INR_TIMER),
  532. [DEC_IRQ_VIDEO] = IO_IRQ_NR(KN02CA_IO_INR_VIDEO),
  533. [DEC_IRQ_ASC_MERR] = IO_IRQ_NR(IO_INR_ASC_MERR),
  534. [DEC_IRQ_ASC_ERR] = IO_IRQ_NR(IO_INR_ASC_ERR),
  535. [DEC_IRQ_ASC_DMA] = IO_IRQ_NR(IO_INR_ASC_DMA),
  536. [DEC_IRQ_FLOPPY_ERR] = IO_IRQ_NR(IO_INR_FLOPPY_ERR),
  537. [DEC_IRQ_ISDN_ERR] = IO_IRQ_NR(IO_INR_ISDN_ERR),
  538. [DEC_IRQ_ISDN_RXDMA] = IO_IRQ_NR(IO_INR_ISDN_RXDMA),
  539. [DEC_IRQ_ISDN_TXDMA] = IO_IRQ_NR(IO_INR_ISDN_TXDMA),
  540. [DEC_IRQ_LANCE_MERR] = IO_IRQ_NR(IO_INR_LANCE_MERR),
  541. [DEC_IRQ_SCC0A_RXERR] = IO_IRQ_NR(IO_INR_SCC0A_RXERR),
  542. [DEC_IRQ_SCC0A_RXDMA] = IO_IRQ_NR(IO_INR_SCC0A_RXDMA),
  543. [DEC_IRQ_SCC0A_TXERR] = IO_IRQ_NR(IO_INR_SCC0A_TXERR),
  544. [DEC_IRQ_SCC0A_TXDMA] = IO_IRQ_NR(IO_INR_SCC0A_TXDMA),
  545. [DEC_IRQ_SCC0B_RXERR] = IO_IRQ_NR(IO_INR_SCC0B_RXERR),
  546. [DEC_IRQ_SCC0B_RXDMA] = IO_IRQ_NR(IO_INR_SCC0B_RXDMA),
  547. [DEC_IRQ_SCC0B_TXERR] = IO_IRQ_NR(IO_INR_SCC0B_TXERR),
  548. [DEC_IRQ_SCC0B_TXDMA] = IO_IRQ_NR(IO_INR_SCC0B_TXDMA),
  549. [DEC_IRQ_SCC1A_RXERR] = -1,
  550. [DEC_IRQ_SCC1A_RXDMA] = -1,
  551. [DEC_IRQ_SCC1A_TXERR] = -1,
  552. [DEC_IRQ_SCC1A_TXDMA] = -1,
  553. };
  555. static int_ptr kn02ca_cpu_mask_nr_tbl[][2] __initdata = {
  556. { { i: DEC_CPU_IRQ_MASK(KN02CA_CPU_INR_MEMORY) },
  557. { i: DEC_CPU_IRQ_NR(KN02CA_CPU_INR_MEMORY) } },
  558. { { i: DEC_CPU_IRQ_MASK(KN02CA_CPU_INR_RTC) },
  559. { i: DEC_CPU_IRQ_NR(KN02CA_CPU_INR_RTC) } },
  560. { { i: DEC_CPU_IRQ_MASK(KN02CA_CPU_INR_CASCADE) },
  561. { p: kn02xa_io_int } },
  562. { { i: DEC_CPU_IRQ_ALL },
  563. { p: cpu_all_int } },
  564. };
  566. static int_ptr kn02ca_asic_mask_nr_tbl[][2] __initdata = {
  567. { { i: IO_IRQ_DMA },
  568. { p: asic_dma_int } },
  569. { { i: IO_IRQ_MASK(KN02CA_IO_INR_SCC0) },
  570. { i: IO_IRQ_NR(KN02CA_IO_INR_SCC0) } },
  571. { { i: IO_IRQ_MASK(KN02CA_IO_INR_ASC) },
  572. { i: IO_IRQ_NR(KN02CA_IO_INR_ASC) } },
  573. { { i: IO_IRQ_MASK(KN02CA_IO_INR_LANCE) },
  574. { i: IO_IRQ_NR(KN02CA_IO_INR_LANCE) } },
  575. { { i: IO_IRQ_MASK(KN02CA_IO_INR_TC1) },
  576. { i: IO_IRQ_NR(KN02CA_IO_INR_TC1) } },
  577. { { i: IO_IRQ_MASK(KN02CA_IO_INR_TC0) },
  578. { i: IO_IRQ_NR(KN02CA_IO_INR_TC0) } },
  579. { { i: IO_IRQ_ALL },
  580. { p: asic_all_int } },
  581. };
  583. void __init dec_init_kn02ca(void)
  584. {
  585. /* Setup some memory addresses. */
  586. ioasic_base = (void *)KN02CA_IOASIC_BASE;
  587. dec_rtc_base = (void *)KN02CA_RTC_BASE;
  588. dec_kn_slot_size = IOASIC_SLOT_SIZE;
  590. /* IRQ routing. */
  591. memcpy(&dec_interrupt, &kn02ca_interrupt,
  592. sizeof(kn02ca_interrupt));
  594. /* CPU IRQ priorities. */
  595. memcpy(&cpu_mask_nr_tbl, &kn02ca_cpu_mask_nr_tbl,
  596. sizeof(kn02ca_cpu_mask_nr_tbl));
  598. /* I/O ASIC IRQ priorities. */
  599. memcpy(&asic_mask_nr_tbl, &kn02ca_asic_mask_nr_tbl,
  600. sizeof(kn02ca_asic_mask_nr_tbl));
  602. mips_cpu_irq_init(DEC_CPU_IRQ_BASE);
  603. init_ioasic_irqs(IO_IRQ_BASE);
  605. } /* dec_init_kn02ca */
  608. /*
  609.  * Machine-specific initialisation for KN03, aka DS5000/240,
  610.  * aka 3max+ and DS5900, aka BIGmax.  Also applies to KN05, aka
  611.  * DS5000/260, aka 4max+ and DS5900-260.
  612.  */
  613. static int kn03_interrupt[DEC_NR_INTS] __initdata = {
  614. [DEC_IRQ_CASCADE] = DEC_CPU_IRQ_NR(KN03_CPU_INR_CASCADE),
  615. [DEC_IRQ_AB_RECV] = -1,
  616. [DEC_IRQ_AB_XMIT] = -1,
  617. [DEC_IRQ_DZ11] = -1,
  618. [DEC_IRQ_ASC] = IO_IRQ_NR(KN03_IO_INR_ASC),
  619. [DEC_IRQ_FLOPPY] = -1,
  620. [DEC_IRQ_FPU] = DEC_CPU_IRQ_NR(DEC_CPU_INR_FPU),
  621. [DEC_IRQ_HALT] = DEC_CPU_IRQ_NR(KN03_CPU_INR_HALT),
  622. [DEC_IRQ_ISDN] = -1,
  623. [DEC_IRQ_LANCE] = IO_IRQ_NR(KN03_IO_INR_LANCE),
  624. [DEC_IRQ_MEMORY] = DEC_CPU_IRQ_NR(KN03_CPU_INR_MEMORY),
  625. [DEC_IRQ_PSU] = IO_IRQ_NR(KN03_IO_INR_PSU),
  626. [DEC_IRQ_RTC] = DEC_CPU_IRQ_NR(KN03_CPU_INR_RTC),
  627. [DEC_IRQ_SCC0] = IO_IRQ_NR(KN03_IO_INR_SCC0),
  628. [DEC_IRQ_SCC1] = IO_IRQ_NR(KN03_IO_INR_SCC1),
  629. [DEC_IRQ_SII] = -1,
  630. [DEC_IRQ_TC0] = IO_IRQ_NR(KN03_IO_INR_TC0),
  631. [DEC_IRQ_TC1] = IO_IRQ_NR(KN03_IO_INR_TC1),
  632. [DEC_IRQ_TC2] = IO_IRQ_NR(KN03_IO_INR_TC2),
  633. [DEC_IRQ_TIMER] = -1,
  634. [DEC_IRQ_VIDEO] = -1,
  635. [DEC_IRQ_ASC_MERR] = IO_IRQ_NR(IO_INR_ASC_MERR),
  636. [DEC_IRQ_ASC_ERR] = IO_IRQ_NR(IO_INR_ASC_ERR),
  637. [DEC_IRQ_ASC_DMA] = IO_IRQ_NR(IO_INR_ASC_DMA),
  638. [DEC_IRQ_FLOPPY_ERR] = -1,
  639. [DEC_IRQ_ISDN_ERR] = -1,
  640. [DEC_IRQ_ISDN_RXDMA] = -1,
  641. [DEC_IRQ_ISDN_TXDMA] = -1,
  642. [DEC_IRQ_LANCE_MERR] = IO_IRQ_NR(IO_INR_LANCE_MERR),
  643. [DEC_IRQ_SCC0A_RXERR] = IO_IRQ_NR(IO_INR_SCC0A_RXERR),
  644. [DEC_IRQ_SCC0A_RXDMA] = IO_IRQ_NR(IO_INR_SCC0A_RXDMA),
  645. [DEC_IRQ_SCC0A_TXERR] = IO_IRQ_NR(IO_INR_SCC0A_TXERR),
  646. [DEC_IRQ_SCC0A_TXDMA] = IO_IRQ_NR(IO_INR_SCC0A_TXDMA),
  647. [DEC_IRQ_SCC0B_RXERR] = -1,
  648. [DEC_IRQ_SCC0B_RXDMA] = -1,
  649. [DEC_IRQ_SCC0B_TXERR] = -1,
  650. [DEC_IRQ_SCC0B_TXDMA] = -1,
  651. [DEC_IRQ_SCC1A_RXERR] = IO_IRQ_NR(IO_INR_SCC1A_RXERR),
  652. [DEC_IRQ_SCC1A_RXDMA] = IO_IRQ_NR(IO_INR_SCC1A_RXDMA),
  653. [DEC_IRQ_SCC1A_TXERR] = IO_IRQ_NR(IO_INR_SCC1A_TXERR),
  654. [DEC_IRQ_SCC1A_TXDMA] = IO_IRQ_NR(IO_INR_SCC1A_TXDMA),
  655. };
  657. static int_ptr kn03_cpu_mask_nr_tbl[][2] __initdata = {
  658. { { i: DEC_CPU_IRQ_MASK(KN03_CPU_INR_MEMORY) },
  659. { i: DEC_CPU_IRQ_NR(KN03_CPU_INR_MEMORY) } },
  660. { { i: DEC_CPU_IRQ_MASK(KN03_CPU_INR_RTC) },
  661. { i: DEC_CPU_IRQ_NR(KN03_CPU_INR_RTC) } },
  662. { { i: DEC_CPU_IRQ_MASK(KN03_CPU_INR_CASCADE) },
  663. { p: kn03_io_int } },
  664. { { i: DEC_CPU_IRQ_ALL },
  665. { p: cpu_all_int } },
  666. };
  668. static int_ptr kn03_asic_mask_nr_tbl[][2] __initdata = {
  669. { { i: IO_IRQ_DMA },
  670. { p: asic_dma_int } },
  671. { { i: IO_IRQ_MASK(KN03_IO_INR_SCC0) },
  672. { i: IO_IRQ_NR(KN03_IO_INR_SCC0) } },
  673. { { i: IO_IRQ_MASK(KN03_IO_INR_SCC1) },
  674. { i: IO_IRQ_NR(KN03_IO_INR_SCC1) } },
  675. { { i: IO_IRQ_MASK(KN03_IO_INR_ASC) },
  676. { i: IO_IRQ_NR(KN03_IO_INR_ASC) } },
  677. { { i: IO_IRQ_MASK(KN03_IO_INR_LANCE) },
  678. { i: IO_IRQ_NR(KN03_IO_INR_LANCE) } },
  679. { { i: IO_IRQ_MASK(KN03_IO_INR_TC2) },
  680. { i: IO_IRQ_NR(KN03_IO_INR_TC2) } },
  681. { { i: IO_IRQ_MASK(KN03_IO_INR_TC1) },
  682. { i: IO_IRQ_NR(KN03_IO_INR_TC1) } },
  683. { { i: IO_IRQ_MASK(KN03_IO_INR_TC0) },
  684. { i: IO_IRQ_NR(KN03_IO_INR_TC0) } },
  685. { { i: IO_IRQ_ALL },
  686. { p: asic_all_int } },
  687. };
  689. void __init dec_init_kn03(void)
  690. {
  691. /* Setup some memory addresses.  */
  692. ioasic_base = (void *)KN03_IOASIC_BASE;
  693. dec_rtc_base = (void *)KN03_RTC_BASE;
  694. dec_kn_slot_size = IOASIC_SLOT_SIZE;
  696. /* IRQ routing. */
  697. memcpy(&dec_interrupt, &kn03_interrupt,
  698. sizeof(kn03_interrupt));
  700. /* CPU IRQ priorities. */
  701. memcpy(&cpu_mask_nr_tbl, &kn03_cpu_mask_nr_tbl,
  702. sizeof(kn03_cpu_mask_nr_tbl));
  704. /* I/O ASIC IRQ priorities. */
  705. memcpy(&asic_mask_nr_tbl, &kn03_asic_mask_nr_tbl,
  706. sizeof(kn03_asic_mask_nr_tbl));
  708. mips_cpu_irq_init(DEC_CPU_IRQ_BASE);
  709. init_ioasic_irqs(IO_IRQ_BASE);
  711. } /* dec_init_kn03 */
  714. void __init init_IRQ(void)
  715. {
  716. switch (mips_machtype) {
  717. case MACH_DS23100: /* DS2100/DS3100 Pmin/Pmax */
  718. dec_init_kn01();
  719. break;
  720. case MACH_DS5100: /* DS5100 MIPSmate */
  721. dec_init_kn230();
  722. break;
  723. case MACH_DS5000_200: /* DS5000/200 3max */
  724. dec_init_kn02();
  725. break;
  726. case MACH_DS5000_1XX: /* DS5000/1xx 3min */
  727. dec_init_kn02ba();
  728. break;
  729. case MACH_DS5000_2X0: /* DS5000/240 3max+ */
  730. dec_init_kn03();
  731. break;
  732. case MACH_DS5000_XX: /* Personal DS5000/xx */
  733. dec_init_kn02ca();
  734. break;
  735. case MACH_DS5800: /* DS5800 Isis */
  736. panic("Don't know how to set this up!");
  737. break;
  738. case MACH_DS5400: /* DS5400 MIPSfair */
  739. panic("Don't know how to set this up!");
  740. break;
  741. case MACH_DS5500: /* DS5500 MIPSfair-2 */
  742. panic("Don't know how to set this up!");
  743. break;
  744. }
  745. set_except_vector(0, decstation_handle_int);
  747. /* Free the FPU interrupt if the exception is present. */
  748. if (!(mips_cpu.options & MIPS_CPU_NOFPUEX)) {
  749. cpu_fpu_mask = 0;
  750. dec_interrupt[DEC_IRQ_FPU] = -1;
  751. }
  753. /* Register board interrupts: FPU and cascade. */
  754. if (dec_interrupt[DEC_IRQ_FPU] >= 0)
  755. setup_irq(dec_interrupt[DEC_IRQ_FPU], &fpuirq);
  756. if (dec_interrupt[DEC_IRQ_CASCADE] >= 0)
  757. setup_irq(dec_interrupt[DEC_IRQ_CASCADE], &ioirq);
  759. /* Register the HALT interrupt. */
  760. if (dec_interrupt[DEC_IRQ_HALT] >= 0)
  761. setup_irq(dec_interrupt[DEC_IRQ_HALT], &haltirq);
  762. }
  764. EXPORT_SYMBOL(ioasic_base);
  765. EXPORT_SYMBOL(dec_rtc_base);
  766. EXPORT_SYMBOL(dec_kn_slot_size);
  767. EXPORT_SYMBOL(dec_interrupt);