/Ethereal-msm8939-beta9/arch/mips/bcm63xx/irq.c

https://bitbucket.org/MilosStamenkovic95/etherealos · C · 560 lines · 462 code · 76 blank · 22 comment · 43 complexity · 44daf8b98198b5bed017ae133050fd75 MD5 · raw file

  1. /*
  2. * This file is subject to the terms and conditions of the GNU General Public
  3. * License. See the file "COPYING" in the main directory of this archive
  4. * for more details.
  5. *
  6. * Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr>
  7. * Copyright (C) 2008 Nicolas Schichan <nschichan@freebox.fr>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/init.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/module.h>
  13. #include <linux/irq.h>
  14. #include <asm/irq_cpu.h>
  15. #include <asm/mipsregs.h>
  16. #include <bcm63xx_cpu.h>
  17. #include <bcm63xx_regs.h>
  18. #include <bcm63xx_io.h>
  19. #include <bcm63xx_irq.h>
  20. static void __dispatch_internal(void) __maybe_unused;
  21. static void __dispatch_internal_64(void) __maybe_unused;
  22. static void __internal_irq_mask_32(unsigned int irq) __maybe_unused;
  23. static void __internal_irq_mask_64(unsigned int irq) __maybe_unused;
  24. static void __internal_irq_unmask_32(unsigned int irq) __maybe_unused;
  25. static void __internal_irq_unmask_64(unsigned int irq) __maybe_unused;
  26. #ifndef BCMCPU_RUNTIME_DETECT
  27. #ifdef CONFIG_BCM63XX_CPU_6328
  28. #define irq_stat_reg PERF_IRQSTAT_6328_REG
  29. #define irq_mask_reg PERF_IRQMASK_6328_REG
  30. #define irq_bits 64
  31. #define is_ext_irq_cascaded 1
  32. #define ext_irq_start (BCM_6328_EXT_IRQ0 - IRQ_INTERNAL_BASE)
  33. #define ext_irq_end (BCM_6328_EXT_IRQ3 - IRQ_INTERNAL_BASE)
  34. #define ext_irq_count 4
  35. #define ext_irq_cfg_reg1 PERF_EXTIRQ_CFG_REG_6328
  36. #define ext_irq_cfg_reg2 0
  37. #endif
  38. #ifdef CONFIG_BCM63XX_CPU_6338
  39. #define irq_stat_reg PERF_IRQSTAT_6338_REG
  40. #define irq_mask_reg PERF_IRQMASK_6338_REG
  41. #define irq_bits 32
  42. #define is_ext_irq_cascaded 0
  43. #define ext_irq_start 0
  44. #define ext_irq_end 0
  45. #define ext_irq_count 4
  46. #define ext_irq_cfg_reg1 PERF_EXTIRQ_CFG_REG_6338
  47. #define ext_irq_cfg_reg2 0
  48. #endif
  49. #ifdef CONFIG_BCM63XX_CPU_6345
  50. #define irq_stat_reg PERF_IRQSTAT_6345_REG
  51. #define irq_mask_reg PERF_IRQMASK_6345_REG
  52. #define irq_bits 32
  53. #define is_ext_irq_cascaded 0
  54. #define ext_irq_start 0
  55. #define ext_irq_end 0
  56. #define ext_irq_count 4
  57. #define ext_irq_cfg_reg1 PERF_EXTIRQ_CFG_REG_6345
  58. #define ext_irq_cfg_reg2 0
  59. #endif
  60. #ifdef CONFIG_BCM63XX_CPU_6348
  61. #define irq_stat_reg PERF_IRQSTAT_6348_REG
  62. #define irq_mask_reg PERF_IRQMASK_6348_REG
  63. #define irq_bits 32
  64. #define is_ext_irq_cascaded 0
  65. #define ext_irq_start 0
  66. #define ext_irq_end 0
  67. #define ext_irq_count 4
  68. #define ext_irq_cfg_reg1 PERF_EXTIRQ_CFG_REG_6348
  69. #define ext_irq_cfg_reg2 0
  70. #endif
  71. #ifdef CONFIG_BCM63XX_CPU_6358
  72. #define irq_stat_reg PERF_IRQSTAT_6358_REG
  73. #define irq_mask_reg PERF_IRQMASK_6358_REG
  74. #define irq_bits 32
  75. #define is_ext_irq_cascaded 1
  76. #define ext_irq_start (BCM_6358_EXT_IRQ0 - IRQ_INTERNAL_BASE)
  77. #define ext_irq_end (BCM_6358_EXT_IRQ3 - IRQ_INTERNAL_BASE)
  78. #define ext_irq_count 4
  79. #define ext_irq_cfg_reg1 PERF_EXTIRQ_CFG_REG_6358
  80. #define ext_irq_cfg_reg2 0
  81. #endif
  82. #ifdef CONFIG_BCM63XX_CPU_6362
  83. #define irq_stat_reg PERF_IRQSTAT_6362_REG
  84. #define irq_mask_reg PERF_IRQMASK_6362_REG
  85. #define irq_bits 64
  86. #define is_ext_irq_cascaded 1
  87. #define ext_irq_start (BCM_6362_EXT_IRQ0 - IRQ_INTERNAL_BASE)
  88. #define ext_irq_end (BCM_6362_EXT_IRQ3 - IRQ_INTERNAL_BASE)
  89. #define ext_irq_count 4
  90. #define ext_irq_cfg_reg1 PERF_EXTIRQ_CFG_REG_6362
  91. #define ext_irq_cfg_reg2 0
  92. #endif
  93. #ifdef CONFIG_BCM63XX_CPU_6368
  94. #define irq_stat_reg PERF_IRQSTAT_6368_REG
  95. #define irq_mask_reg PERF_IRQMASK_6368_REG
  96. #define irq_bits 64
  97. #define is_ext_irq_cascaded 1
  98. #define ext_irq_start (BCM_6368_EXT_IRQ0 - IRQ_INTERNAL_BASE)
  99. #define ext_irq_end (BCM_6368_EXT_IRQ5 - IRQ_INTERNAL_BASE)
  100. #define ext_irq_count 6
  101. #define ext_irq_cfg_reg1 PERF_EXTIRQ_CFG_REG_6368
  102. #define ext_irq_cfg_reg2 PERF_EXTIRQ_CFG_REG2_6368
  103. #endif
  104. #if irq_bits == 32
  105. #define dispatch_internal __dispatch_internal
  106. #define internal_irq_mask __internal_irq_mask_32
  107. #define internal_irq_unmask __internal_irq_unmask_32
  108. #else
  109. #define dispatch_internal __dispatch_internal_64
  110. #define internal_irq_mask __internal_irq_mask_64
  111. #define internal_irq_unmask __internal_irq_unmask_64
  112. #endif
  113. #define irq_stat_addr (bcm63xx_regset_address(RSET_PERF) + irq_stat_reg)
  114. #define irq_mask_addr (bcm63xx_regset_address(RSET_PERF) + irq_mask_reg)
  115. static inline void bcm63xx_init_irq(void)
  116. {
  117. }
  118. #else /* ! BCMCPU_RUNTIME_DETECT */
  119. static u32 irq_stat_addr, irq_mask_addr;
  120. static void (*dispatch_internal)(void);
  121. static int is_ext_irq_cascaded;
  122. static unsigned int ext_irq_count;
  123. static unsigned int ext_irq_start, ext_irq_end;
  124. static unsigned int ext_irq_cfg_reg1, ext_irq_cfg_reg2;
  125. static void (*internal_irq_mask)(unsigned int irq);
  126. static void (*internal_irq_unmask)(unsigned int irq);
  127. static void bcm63xx_init_irq(void)
  128. {
  129. int irq_bits;
  130. irq_stat_addr = bcm63xx_regset_address(RSET_PERF);
  131. irq_mask_addr = bcm63xx_regset_address(RSET_PERF);
  132. switch (bcm63xx_get_cpu_id()) {
  133. case BCM6328_CPU_ID:
  134. irq_stat_addr += PERF_IRQSTAT_6328_REG;
  135. irq_mask_addr += PERF_IRQMASK_6328_REG;
  136. irq_bits = 64;
  137. ext_irq_count = 4;
  138. is_ext_irq_cascaded = 1;
  139. ext_irq_start = BCM_6328_EXT_IRQ0 - IRQ_INTERNAL_BASE;
  140. ext_irq_end = BCM_6328_EXT_IRQ3 - IRQ_INTERNAL_BASE;
  141. ext_irq_cfg_reg1 = PERF_EXTIRQ_CFG_REG_6328;
  142. break;
  143. case BCM6338_CPU_ID:
  144. irq_stat_addr += PERF_IRQSTAT_6338_REG;
  145. irq_mask_addr += PERF_IRQMASK_6338_REG;
  146. irq_bits = 32;
  147. ext_irq_count = 4;
  148. ext_irq_cfg_reg1 = PERF_EXTIRQ_CFG_REG_6338;
  149. break;
  150. case BCM6345_CPU_ID:
  151. irq_stat_addr += PERF_IRQSTAT_6345_REG;
  152. irq_mask_addr += PERF_IRQMASK_6345_REG;
  153. irq_bits = 32;
  154. ext_irq_count = 4;
  155. ext_irq_cfg_reg1 = PERF_EXTIRQ_CFG_REG_6345;
  156. break;
  157. case BCM6348_CPU_ID:
  158. irq_stat_addr += PERF_IRQSTAT_6348_REG;
  159. irq_mask_addr += PERF_IRQMASK_6348_REG;
  160. irq_bits = 32;
  161. ext_irq_count = 4;
  162. ext_irq_cfg_reg1 = PERF_EXTIRQ_CFG_REG_6348;
  163. break;
  164. case BCM6358_CPU_ID:
  165. irq_stat_addr += PERF_IRQSTAT_6358_REG;
  166. irq_mask_addr += PERF_IRQMASK_6358_REG;
  167. irq_bits = 32;
  168. ext_irq_count = 4;
  169. is_ext_irq_cascaded = 1;
  170. ext_irq_start = BCM_6358_EXT_IRQ0 - IRQ_INTERNAL_BASE;
  171. ext_irq_end = BCM_6358_EXT_IRQ3 - IRQ_INTERNAL_BASE;
  172. ext_irq_cfg_reg1 = PERF_EXTIRQ_CFG_REG_6358;
  173. break;
  174. case BCM6362_CPU_ID:
  175. irq_stat_addr += PERF_IRQSTAT_6362_REG;
  176. irq_mask_addr += PERF_IRQMASK_6362_REG;
  177. irq_bits = 64;
  178. ext_irq_count = 4;
  179. is_ext_irq_cascaded = 1;
  180. ext_irq_start = BCM_6362_EXT_IRQ0 - IRQ_INTERNAL_BASE;
  181. ext_irq_end = BCM_6362_EXT_IRQ3 - IRQ_INTERNAL_BASE;
  182. ext_irq_cfg_reg1 = PERF_EXTIRQ_CFG_REG_6362;
  183. break;
  184. case BCM6368_CPU_ID:
  185. irq_stat_addr += PERF_IRQSTAT_6368_REG;
  186. irq_mask_addr += PERF_IRQMASK_6368_REG;
  187. irq_bits = 64;
  188. ext_irq_count = 6;
  189. is_ext_irq_cascaded = 1;
  190. ext_irq_start = BCM_6368_EXT_IRQ0 - IRQ_INTERNAL_BASE;
  191. ext_irq_end = BCM_6368_EXT_IRQ5 - IRQ_INTERNAL_BASE;
  192. ext_irq_cfg_reg1 = PERF_EXTIRQ_CFG_REG_6368;
  193. ext_irq_cfg_reg2 = PERF_EXTIRQ_CFG_REG2_6368;
  194. break;
  195. default:
  196. BUG();
  197. }
  198. if (irq_bits == 32) {
  199. dispatch_internal = __dispatch_internal;
  200. internal_irq_mask = __internal_irq_mask_32;
  201. internal_irq_unmask = __internal_irq_unmask_32;
  202. } else {
  203. dispatch_internal = __dispatch_internal_64;
  204. internal_irq_mask = __internal_irq_mask_64;
  205. internal_irq_unmask = __internal_irq_unmask_64;
  206. }
  207. }
  208. #endif /* ! BCMCPU_RUNTIME_DETECT */
  209. static inline u32 get_ext_irq_perf_reg(int irq)
  210. {
  211. if (irq < 4)
  212. return ext_irq_cfg_reg1;
  213. return ext_irq_cfg_reg2;
  214. }
  215. static inline void handle_internal(int intbit)
  216. {
  217. if (is_ext_irq_cascaded &&
  218. intbit >= ext_irq_start && intbit <= ext_irq_end)
  219. do_IRQ(intbit - ext_irq_start + IRQ_EXTERNAL_BASE);
  220. else
  221. do_IRQ(intbit + IRQ_INTERNAL_BASE);
  222. }
  223. /*
  224. * dispatch internal devices IRQ (uart, enet, watchdog, ...). do not
  225. * prioritize any interrupt relatively to another. the static counter
  226. * will resume the loop where it ended the last time we left this
  227. * function.
  228. */
  229. static void __dispatch_internal(void)
  230. {
  231. u32 pending;
  232. static int i;
  233. pending = bcm_readl(irq_stat_addr) & bcm_readl(irq_mask_addr);
  234. if (!pending)
  235. return ;
  236. while (1) {
  237. int to_call = i;
  238. i = (i + 1) & 0x1f;
  239. if (pending & (1 << to_call)) {
  240. handle_internal(to_call);
  241. break;
  242. }
  243. }
  244. }
  245. static void __dispatch_internal_64(void)
  246. {
  247. u64 pending;
  248. static int i;
  249. pending = bcm_readq(irq_stat_addr) & bcm_readq(irq_mask_addr);
  250. if (!pending)
  251. return ;
  252. while (1) {
  253. int to_call = i;
  254. i = (i + 1) & 0x3f;
  255. if (pending & (1ull << to_call)) {
  256. handle_internal(to_call);
  257. break;
  258. }
  259. }
  260. }
  261. asmlinkage void plat_irq_dispatch(void)
  262. {
  263. u32 cause;
  264. do {
  265. cause = read_c0_cause() & read_c0_status() & ST0_IM;
  266. if (!cause)
  267. break;
  268. if (cause & CAUSEF_IP7)
  269. do_IRQ(7);
  270. if (cause & CAUSEF_IP2)
  271. dispatch_internal();
  272. if (!is_ext_irq_cascaded) {
  273. if (cause & CAUSEF_IP3)
  274. do_IRQ(IRQ_EXT_0);
  275. if (cause & CAUSEF_IP4)
  276. do_IRQ(IRQ_EXT_1);
  277. if (cause & CAUSEF_IP5)
  278. do_IRQ(IRQ_EXT_2);
  279. if (cause & CAUSEF_IP6)
  280. do_IRQ(IRQ_EXT_3);
  281. }
  282. } while (1);
  283. }
  284. /*
  285. * internal IRQs operations: only mask/unmask on PERF irq mask
  286. * register.
  287. */
  288. static void __internal_irq_mask_32(unsigned int irq)
  289. {
  290. u32 mask;
  291. mask = bcm_readl(irq_mask_addr);
  292. mask &= ~(1 << irq);
  293. bcm_writel(mask, irq_mask_addr);
  294. }
  295. static void __internal_irq_mask_64(unsigned int irq)
  296. {
  297. u64 mask;
  298. mask = bcm_readq(irq_mask_addr);
  299. mask &= ~(1ull << irq);
  300. bcm_writeq(mask, irq_mask_addr);
  301. }
  302. static void __internal_irq_unmask_32(unsigned int irq)
  303. {
  304. u32 mask;
  305. mask = bcm_readl(irq_mask_addr);
  306. mask |= (1 << irq);
  307. bcm_writel(mask, irq_mask_addr);
  308. }
  309. static void __internal_irq_unmask_64(unsigned int irq)
  310. {
  311. u64 mask;
  312. mask = bcm_readq(irq_mask_addr);
  313. mask |= (1ull << irq);
  314. bcm_writeq(mask, irq_mask_addr);
  315. }
  316. static void bcm63xx_internal_irq_mask(struct irq_data *d)
  317. {
  318. internal_irq_mask(d->irq - IRQ_INTERNAL_BASE);
  319. }
  320. static void bcm63xx_internal_irq_unmask(struct irq_data *d)
  321. {
  322. internal_irq_unmask(d->irq - IRQ_INTERNAL_BASE);
  323. }
  324. /*
  325. * external IRQs operations: mask/unmask and clear on PERF external
  326. * irq control register.
  327. */
  328. static void bcm63xx_external_irq_mask(struct irq_data *d)
  329. {
  330. unsigned int irq = d->irq - IRQ_EXTERNAL_BASE;
  331. u32 reg, regaddr;
  332. regaddr = get_ext_irq_perf_reg(irq);
  333. reg = bcm_perf_readl(regaddr);
  334. if (BCMCPU_IS_6348())
  335. reg &= ~EXTIRQ_CFG_MASK_6348(irq % 4);
  336. else
  337. reg &= ~EXTIRQ_CFG_MASK(irq % 4);
  338. bcm_perf_writel(reg, regaddr);
  339. if (is_ext_irq_cascaded)
  340. internal_irq_mask(irq + ext_irq_start);
  341. }
  342. static void bcm63xx_external_irq_unmask(struct irq_data *d)
  343. {
  344. unsigned int irq = d->irq - IRQ_EXTERNAL_BASE;
  345. u32 reg, regaddr;
  346. regaddr = get_ext_irq_perf_reg(irq);
  347. reg = bcm_perf_readl(regaddr);
  348. if (BCMCPU_IS_6348())
  349. reg |= EXTIRQ_CFG_MASK_6348(irq % 4);
  350. else
  351. reg |= EXTIRQ_CFG_MASK(irq % 4);
  352. bcm_perf_writel(reg, regaddr);
  353. if (is_ext_irq_cascaded)
  354. internal_irq_unmask(irq + ext_irq_start);
  355. }
  356. static void bcm63xx_external_irq_clear(struct irq_data *d)
  357. {
  358. unsigned int irq = d->irq - IRQ_EXTERNAL_BASE;
  359. u32 reg, regaddr;
  360. regaddr = get_ext_irq_perf_reg(irq);
  361. reg = bcm_perf_readl(regaddr);
  362. if (BCMCPU_IS_6348())
  363. reg |= EXTIRQ_CFG_CLEAR_6348(irq % 4);
  364. else
  365. reg |= EXTIRQ_CFG_CLEAR(irq % 4);
  366. bcm_perf_writel(reg, regaddr);
  367. }
  368. static int bcm63xx_external_irq_set_type(struct irq_data *d,
  369. unsigned int flow_type)
  370. {
  371. unsigned int irq = d->irq - IRQ_EXTERNAL_BASE;
  372. u32 reg, regaddr;
  373. int levelsense, sense, bothedge;
  374. flow_type &= IRQ_TYPE_SENSE_MASK;
  375. if (flow_type == IRQ_TYPE_NONE)
  376. flow_type = IRQ_TYPE_LEVEL_LOW;
  377. levelsense = sense = bothedge = 0;
  378. switch (flow_type) {
  379. case IRQ_TYPE_EDGE_BOTH:
  380. bothedge = 1;
  381. break;
  382. case IRQ_TYPE_EDGE_RISING:
  383. sense = 1;
  384. break;
  385. case IRQ_TYPE_EDGE_FALLING:
  386. break;
  387. case IRQ_TYPE_LEVEL_HIGH:
  388. levelsense = 1;
  389. sense = 1;
  390. break;
  391. case IRQ_TYPE_LEVEL_LOW:
  392. levelsense = 1;
  393. break;
  394. default:
  395. printk(KERN_ERR "bogus flow type combination given !\n");
  396. return -EINVAL;
  397. }
  398. regaddr = get_ext_irq_perf_reg(irq);
  399. reg = bcm_perf_readl(regaddr);
  400. irq %= 4;
  401. switch (bcm63xx_get_cpu_id()) {
  402. case BCM6348_CPU_ID:
  403. if (levelsense)
  404. reg |= EXTIRQ_CFG_LEVELSENSE_6348(irq);
  405. else
  406. reg &= ~EXTIRQ_CFG_LEVELSENSE_6348(irq);
  407. if (sense)
  408. reg |= EXTIRQ_CFG_SENSE_6348(irq);
  409. else
  410. reg &= ~EXTIRQ_CFG_SENSE_6348(irq);
  411. if (bothedge)
  412. reg |= EXTIRQ_CFG_BOTHEDGE_6348(irq);
  413. else
  414. reg &= ~EXTIRQ_CFG_BOTHEDGE_6348(irq);
  415. break;
  416. case BCM6328_CPU_ID:
  417. case BCM6338_CPU_ID:
  418. case BCM6345_CPU_ID:
  419. case BCM6358_CPU_ID:
  420. case BCM6362_CPU_ID:
  421. case BCM6368_CPU_ID:
  422. if (levelsense)
  423. reg |= EXTIRQ_CFG_LEVELSENSE(irq);
  424. else
  425. reg &= ~EXTIRQ_CFG_LEVELSENSE(irq);
  426. if (sense)
  427. reg |= EXTIRQ_CFG_SENSE(irq);
  428. else
  429. reg &= ~EXTIRQ_CFG_SENSE(irq);
  430. if (bothedge)
  431. reg |= EXTIRQ_CFG_BOTHEDGE(irq);
  432. else
  433. reg &= ~EXTIRQ_CFG_BOTHEDGE(irq);
  434. break;
  435. default:
  436. BUG();
  437. }
  438. bcm_perf_writel(reg, regaddr);
  439. irqd_set_trigger_type(d, flow_type);
  440. if (flow_type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
  441. __irq_set_handler_locked(d->irq, handle_level_irq);
  442. else
  443. __irq_set_handler_locked(d->irq, handle_edge_irq);
  444. return IRQ_SET_MASK_OK_NOCOPY;
  445. }
  446. static struct irq_chip bcm63xx_internal_irq_chip = {
  447. .name = "bcm63xx_ipic",
  448. .irq_mask = bcm63xx_internal_irq_mask,
  449. .irq_unmask = bcm63xx_internal_irq_unmask,
  450. };
  451. static struct irq_chip bcm63xx_external_irq_chip = {
  452. .name = "bcm63xx_epic",
  453. .irq_ack = bcm63xx_external_irq_clear,
  454. .irq_mask = bcm63xx_external_irq_mask,
  455. .irq_unmask = bcm63xx_external_irq_unmask,
  456. .irq_set_type = bcm63xx_external_irq_set_type,
  457. };
  458. static struct irqaction cpu_ip2_cascade_action = {
  459. .handler = no_action,
  460. .name = "cascade_ip2",
  461. .flags = IRQF_NO_THREAD,
  462. };
  463. static struct irqaction cpu_ext_cascade_action = {
  464. .handler = no_action,
  465. .name = "cascade_extirq",
  466. .flags = IRQF_NO_THREAD,
  467. };
  468. void __init arch_init_irq(void)
  469. {
  470. int i;
  471. bcm63xx_init_irq();
  472. mips_cpu_irq_init();
  473. for (i = IRQ_INTERNAL_BASE; i < NR_IRQS; ++i)
  474. irq_set_chip_and_handler(i, &bcm63xx_internal_irq_chip,
  475. handle_level_irq);
  476. for (i = IRQ_EXTERNAL_BASE; i < IRQ_EXTERNAL_BASE + ext_irq_count; ++i)
  477. irq_set_chip_and_handler(i, &bcm63xx_external_irq_chip,
  478. handle_edge_irq);
  479. if (!is_ext_irq_cascaded) {
  480. for (i = 3; i < 3 + ext_irq_count; ++i)
  481. setup_irq(MIPS_CPU_IRQ_BASE + i, &cpu_ext_cascade_action);
  482. }
  483. setup_irq(MIPS_CPU_IRQ_BASE + 2, &cpu_ip2_cascade_action);
  484. }