common.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223
  1. /*
  2. * linux/arch/arm/mach-footbridge/common.c
  3. *
  4. * Copyright (C) 1998-2000 Russell King, Dave Gilbert.
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. */
  10. #include <linux/module.h>
  11. #include <linux/types.h>
  12. #include <linux/mm.h>
  13. #include <linux/ioport.h>
  14. #include <linux/list.h>
  15. #include <linux/init.h>
  16. #include <linux/io.h>
  17. #include <linux/spinlock.h>
  18. #include <asm/pgtable.h>
  19. #include <asm/page.h>
  20. #include <asm/irq.h>
  21. #include <asm/mach-types.h>
  22. #include <asm/setup.h>
  23. #include <asm/hardware/dec21285.h>
  24. #include <asm/mach/irq.h>
  25. #include <asm/mach/map.h>
  26. #include "common.h"
  27. extern void __init isa_init_irq(unsigned int irq);
  28. unsigned int mem_fclk_21285 = 50000000;
  29. EXPORT_SYMBOL(mem_fclk_21285);
  30. static int __init parse_tag_memclk(const struct tag *tag)
  31. {
  32. mem_fclk_21285 = tag->u.memclk.fmemclk;
  33. return 0;
  34. }
  35. __tagtable(ATAG_MEMCLK, parse_tag_memclk);
  36. /*
  37. * Footbridge IRQ translation table
  38. * Converts from our IRQ numbers into FootBridge masks
  39. */
  40. static const int fb_irq_mask[] = {
  41. IRQ_MASK_UART_RX, /* 0 */
  42. IRQ_MASK_UART_TX, /* 1 */
  43. IRQ_MASK_TIMER1, /* 2 */
  44. IRQ_MASK_TIMER2, /* 3 */
  45. IRQ_MASK_TIMER3, /* 4 */
  46. IRQ_MASK_IN0, /* 5 */
  47. IRQ_MASK_IN1, /* 6 */
  48. IRQ_MASK_IN2, /* 7 */
  49. IRQ_MASK_IN3, /* 8 */
  50. IRQ_MASK_DOORBELLHOST, /* 9 */
  51. IRQ_MASK_DMA1, /* 10 */
  52. IRQ_MASK_DMA2, /* 11 */
  53. IRQ_MASK_PCI, /* 12 */
  54. IRQ_MASK_SDRAMPARITY, /* 13 */
  55. IRQ_MASK_I2OINPOST, /* 14 */
  56. IRQ_MASK_PCI_ABORT, /* 15 */
  57. IRQ_MASK_PCI_SERR, /* 16 */
  58. IRQ_MASK_DISCARD_TIMER, /* 17 */
  59. IRQ_MASK_PCI_DPERR, /* 18 */
  60. IRQ_MASK_PCI_PERR, /* 19 */
  61. };
  62. static void fb_mask_irq(unsigned int irq)
  63. {
  64. *CSR_IRQ_DISABLE = fb_irq_mask[_DC21285_INR(irq)];
  65. }
  66. static void fb_unmask_irq(unsigned int irq)
  67. {
  68. *CSR_IRQ_ENABLE = fb_irq_mask[_DC21285_INR(irq)];
  69. }
  70. static struct irq_chip fb_chip = {
  71. .ack = fb_mask_irq,
  72. .mask = fb_mask_irq,
  73. .unmask = fb_unmask_irq,
  74. };
  75. static void __init __fb_init_irq(void)
  76. {
  77. unsigned int irq;
  78. /*
  79. * setup DC21285 IRQs
  80. */
  81. *CSR_IRQ_DISABLE = -1;
  82. *CSR_FIQ_DISABLE = -1;
  83. for (irq = _DC21285_IRQ(0); irq < _DC21285_IRQ(20); irq++) {
  84. set_irq_chip(irq, &fb_chip);
  85. set_irq_handler(irq, handle_level_irq);
  86. set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
  87. }
  88. }
  89. void __init footbridge_init_irq(void)
  90. {
  91. __fb_init_irq();
  92. if (!footbridge_cfn_mode())
  93. return;
  94. if (machine_is_ebsa285())
  95. /* The following is dependent on which slot
  96. * you plug the Southbridge card into. We
  97. * currently assume that you plug it into
  98. * the right-hand most slot.
  99. */
  100. isa_init_irq(IRQ_PCI);
  101. if (machine_is_cats())
  102. isa_init_irq(IRQ_IN2);
  103. if (machine_is_netwinder())
  104. isa_init_irq(IRQ_IN3);
  105. }
  106. /*
  107. * Common mapping for all systems. Note that the outbound write flush is
  108. * commented out since there is a "No Fix" problem with it. Not mapping
  109. * it means that we have extra bullet protection on our feet.
  110. */
  111. static struct map_desc fb_common_io_desc[] __initdata = {
  112. {
  113. .virtual = ARMCSR_BASE,
  114. .pfn = __phys_to_pfn(DC21285_ARMCSR_BASE),
  115. .length = ARMCSR_SIZE,
  116. .type = MT_DEVICE,
  117. }, {
  118. .virtual = XBUS_BASE,
  119. .pfn = __phys_to_pfn(0x40000000),
  120. .length = XBUS_SIZE,
  121. .type = MT_DEVICE,
  122. }
  123. };
  124. /*
  125. * The mapping when the footbridge is in host mode. We don't map any of
  126. * this when we are in add-in mode.
  127. */
  128. static struct map_desc ebsa285_host_io_desc[] __initdata = {
  129. #if defined(CONFIG_ARCH_FOOTBRIDGE) && defined(CONFIG_FOOTBRIDGE_HOST)
  130. {
  131. .virtual = PCIMEM_BASE,
  132. .pfn = __phys_to_pfn(DC21285_PCI_MEM),
  133. .length = PCIMEM_SIZE,
  134. .type = MT_DEVICE,
  135. }, {
  136. .virtual = PCICFG0_BASE,
  137. .pfn = __phys_to_pfn(DC21285_PCI_TYPE_0_CONFIG),
  138. .length = PCICFG0_SIZE,
  139. .type = MT_DEVICE,
  140. }, {
  141. .virtual = PCICFG1_BASE,
  142. .pfn = __phys_to_pfn(DC21285_PCI_TYPE_1_CONFIG),
  143. .length = PCICFG1_SIZE,
  144. .type = MT_DEVICE,
  145. }, {
  146. .virtual = PCIIACK_BASE,
  147. .pfn = __phys_to_pfn(DC21285_PCI_IACK),
  148. .length = PCIIACK_SIZE,
  149. .type = MT_DEVICE,
  150. }, {
  151. .virtual = PCIO_BASE,
  152. .pfn = __phys_to_pfn(DC21285_PCI_IO),
  153. .length = PCIO_SIZE,
  154. .type = MT_DEVICE,
  155. },
  156. #endif
  157. };
  158. void __init footbridge_map_io(void)
  159. {
  160. /*
  161. * Set up the common mapping first; we need this to
  162. * determine whether we're in host mode or not.
  163. */
  164. iotable_init(fb_common_io_desc, ARRAY_SIZE(fb_common_io_desc));
  165. /*
  166. * Now, work out what we've got to map in addition on this
  167. * platform.
  168. */
  169. if (footbridge_cfn_mode())
  170. iotable_init(ebsa285_host_io_desc, ARRAY_SIZE(ebsa285_host_io_desc));
  171. }
  172. #ifdef CONFIG_FOOTBRIDGE_ADDIN
  173. /*
  174. * These two functions convert virtual addresses to PCI addresses and PCI
  175. * addresses to virtual addresses. Note that it is only legal to use these
  176. * on memory obtained via get_zeroed_page or kmalloc.
  177. */
  178. unsigned long __virt_to_bus(unsigned long res)
  179. {
  180. WARN_ON(res < PAGE_OFFSET || res >= (unsigned long)high_memory);
  181. return (res - PAGE_OFFSET) + (*CSR_PCISDRAMBASE & 0xfffffff0);
  182. }
  183. EXPORT_SYMBOL(__virt_to_bus);
  184. unsigned long __bus_to_virt(unsigned long res)
  185. {
  186. res -= (*CSR_PCISDRAMBASE & 0xfffffff0);
  187. res += PAGE_OFFSET;
  188. WARN_ON(res < PAGE_OFFSET || res >= (unsigned long)high_memory);
  189. return res;
  190. }
  191. EXPORT_SYMBOL(__bus_to_virt);
  192. #endif