315727b7ff40f4170cc05e5d432bd4542dd1102f
[muen/linux.git] / arch / m68k / platform / 68360 / commproc.c
1 /*
2  * General Purpose functions for the global management of the
3  * Communication Processor Module.
4  *
5  * Copyright (c) 2000 Michael Leslie <mleslie@lineo.com>
6  * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
7  *
8  * In addition to the individual control of the communication
9  * channels, there are a few functions that globally affect the
10  * communication processor.
11  *
12  * Buffer descriptors must be allocated from the dual ported memory
13  * space.  The allocator for that is here.  When the communication
14  * process is reset, we reclaim the memory available.  There is
15  * currently no deallocator for this memory.
16  * The amount of space available is platform dependent.  On the
17  * MBX, the EPPC software loads additional microcode into the
18  * communication processor, and uses some of the DP ram for this
19  * purpose.  Current, the first 512 bytes and the last 256 bytes of
20  * memory are used.  Right now I am conservative and only use the
21  * memory that can never be used for microcode.  If there are
22  * applications that require more DP ram, we can expand the boundaries
23  * but then we have to be careful of any downloaded microcode.
24  *
25  */
26
27 /*
28  * Michael Leslie <mleslie@lineo.com>
29  * adapted Dan Malek's ppc8xx drivers to M68360
30  *
31  */
32
33 #include <linux/errno.h>
34 #include <linux/init.h>
35 #include <linux/sched.h>
36 #include <linux/kernel.h>
37 #include <linux/param.h>
38 #include <linux/string.h>
39 #include <linux/mm.h>
40 #include <linux/interrupt.h>
41 #include <asm/irq.h>
42 #include <asm/m68360.h>
43 #include <asm/commproc.h>
44
45 /* #include <asm/page.h> */
46 /* #include <asm/pgtable.h> */
47 extern void *_quicc_base;
48 extern unsigned int system_clock;
49
50
51 static uint dp_alloc_base;      /* Starting offset in DP ram */
52 static uint dp_alloc_top;       /* Max offset + 1 */
53
54 #if 0
55 static  void    *host_buffer;   /* One page of host buffer */
56 static  void    *host_end;          /* end + 1 */
57 #endif
58
59 /* struct  cpm360_t *cpmp; */         /* Pointer to comm processor space */
60
61 QUICC  *pquicc;
62 /* QUICC  *quicc_dpram; */ /* mleslie - temporary; use extern pquicc elsewhere instead */
63
64
65 /* CPM interrupt vector functions. */
66 struct  cpm_action {
67         void    (*handler)(void *);
68         void    *dev_id;
69 };
70 static  struct  cpm_action cpm_vecs[CPMVEC_NR];
71 static  void    cpm_interrupt(int irq, void * dev, struct pt_regs * regs);
72 static  void    cpm_error_interrupt(void *);
73
74 /* prototypes: */
75 void cpm_install_handler(int vec, void (*handler)(), void *dev_id);
76 void m360_cpm_reset(void);
77
78
79
80
81 void __init m360_cpm_reset()
82 {
83 /*      pte_t              *pte; */
84
85         pquicc = (struct quicc *)(_quicc_base); /* initialized in crt0_rXm.S */
86
87         /* Perform a CPM reset. */
88         pquicc->cp_cr = (SOFTWARE_RESET | CMD_FLAG);
89
90         /* Wait for CPM to become ready (should be 2 clocks). */
91         while (pquicc->cp_cr & CMD_FLAG);
92
93         /* On the recommendation of the 68360 manual, p. 7-60
94          * - Set sdma interrupt service mask to 7
95          * - Set sdma arbitration ID to 4
96          */
97         pquicc->sdma_sdcr = 0x0740;
98
99
100         /* Claim the DP memory for our use.
101          */
102         dp_alloc_base = CPM_DATAONLY_BASE;
103         dp_alloc_top = dp_alloc_base + CPM_DATAONLY_SIZE;
104
105
106         /* Set the host page for allocation.
107          */
108         /*      host_buffer = host_page_addr; */
109         /*      host_end = host_page_addr + PAGE_SIZE; */
110
111         /*      pte = find_pte(&init_mm, host_page_addr); */
112         /*      pte_val(*pte) |= _PAGE_NO_CACHE; */
113         /*      flush_tlb_page(current->mm->mmap, host_buffer); */
114
115         /* Tell everyone where the comm processor resides.
116         */
117 /*      cpmp = (cpm360_t *)commproc; */
118 }
119
120
121 /* This is called during init_IRQ.  We used to do it above, but this
122  * was too early since init_IRQ was not yet called.
123  */
124 void
125 cpm_interrupt_init(void)
126 {
127         /* Initialize the CPM interrupt controller.
128          * NOTE THAT pquicc had better have been initialized!
129          * reference: MC68360UM p. 7-377
130          */
131         pquicc->intr_cicr =
132                 (CICR_SCD_SCC4 | CICR_SCC_SCC3 | CICR_SCB_SCC2 | CICR_SCA_SCC1) |
133                 (CPM_INTERRUPT << 13) |
134                 CICR_HP_MASK |
135                 (CPM_VECTOR_BASE << 5) |
136                 CICR_SPS;
137
138         /* mask all CPM interrupts from reaching the cpu32 core: */
139         pquicc->intr_cimr = 0;
140
141
142         /* mles - If I understand correctly, the 360 just pops over to the CPM
143          * specific vector, obviating the necessity to vector through the IRQ
144          * whose priority the CPM is set to. This needs a closer look, though.
145          */
146
147         /* Set our interrupt handler with the core CPU. */
148 /*      if (request_irq(CPM_INTERRUPT, cpm_interrupt, 0, "cpm", NULL) != 0) */
149 /*              panic("Could not allocate CPM IRQ!"); */
150
151         /* Install our own error handler.
152          */
153         /* I think we want to hold off on this one for the moment - mles */
154         /* cpm_install_handler(CPMVEC_ERROR, cpm_error_interrupt, NULL); */
155
156         /* master CPM interrupt enable */
157         /* pquicc->intr_cicr |= CICR_IEN; */ /* no such animal for 360 */
158 }
159
160
161
162 /* CPM interrupt controller interrupt.
163 */
164 static  void
165 cpm_interrupt(int irq, void * dev, struct pt_regs * regs)
166 {
167         /* uint vec; */
168
169         /* mles: Note that this stuff is currently being performed by
170          * M68360_do_irq(int vec, struct pt_regs *fp), in ../ints.c  */
171
172         /* figure out the vector */
173         /* call that vector's handler */
174         /* clear the irq's bit in the service register */
175
176 #if 0 /* old 860 stuff: */
177         /* Get the vector by setting the ACK bit and then reading
178          * the register.
179          */
180         ((volatile immap_t *)IMAP_ADDR)->im_cpic.cpic_civr = 1;
181         vec = ((volatile immap_t *)IMAP_ADDR)->im_cpic.cpic_civr;
182         vec >>= 11;
183
184
185         if (cpm_vecs[vec].handler != 0)
186                 (*cpm_vecs[vec].handler)(cpm_vecs[vec].dev_id);
187         else
188                 ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr &= ~(1 << vec);
189
190         /* After servicing the interrupt, we have to remove the status
191          * indicator.
192          */
193         ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cisr |= (1 << vec);
194 #endif
195
196 }
197
198 /* The CPM can generate the error interrupt when there is a race condition
199  * between generating and masking interrupts.  All we have to do is ACK it
200  * and return.  This is a no-op function so we don't need any special
201  * tests in the interrupt handler.
202  */
203 static  void
204 cpm_error_interrupt(void *dev)
205 {
206 }
207
208 /* Install a CPM interrupt handler.
209 */
210 void
211 cpm_install_handler(int vec, void (*handler)(), void *dev_id)
212 {
213
214         request_irq(vec, handler, 0, "timer", dev_id);
215
216 /*      if (cpm_vecs[vec].handler != 0) */
217 /*              printk(KERN_INFO "CPM interrupt %x replacing %x\n", */
218 /*                      (uint)handler, (uint)cpm_vecs[vec].handler); */
219 /*      cpm_vecs[vec].handler = handler; */
220 /*      cpm_vecs[vec].dev_id = dev_id; */
221
222         /*              ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr |= (1 << vec); */
223 /*      pquicc->intr_cimr |= (1 << vec); */
224
225 }
226
227 /* Free a CPM interrupt handler.
228 */
229 void
230 cpm_free_handler(int vec)
231 {
232         cpm_vecs[vec].handler = NULL;
233         cpm_vecs[vec].dev_id = NULL;
234         /* ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr &= ~(1 << vec); */
235         pquicc->intr_cimr &= ~(1 << vec);
236 }
237
238
239
240
241 /* Allocate some memory from the dual ported ram.  We may want to
242  * enforce alignment restrictions, but right now everyone is a good
243  * citizen.
244  */
245 uint
246 m360_cpm_dpalloc(uint size)
247 {
248         uint    retloc;
249
250         if ((dp_alloc_base + size) >= dp_alloc_top)
251                 return(CPM_DP_NOSPACE);
252
253         retloc = dp_alloc_base;
254         dp_alloc_base += size;
255
256         return(retloc);
257 }
258
259
260 #if 0 /* mleslie - for now these are simply kmalloc'd */
261 /* We also own one page of host buffer space for the allocation of
262  * UART "fifos" and the like.
263  */
264 uint
265 m360_cpm_hostalloc(uint size)
266 {
267         uint    retloc;
268
269         if ((host_buffer + size) >= host_end)
270                 return(0);
271
272         retloc = host_buffer;
273         host_buffer += size;
274
275         return(retloc);
276 }
277 #endif
278
279
280 /* Set a baud rate generator.  This needs lots of work.  There are
281  * four BRGs, any of which can be wired to any channel.
282  * The internal baud rate clock is the system clock divided by 16.
283  * This assumes the baudrate is 16x oversampled by the uart.
284  */
285 /* #define BRG_INT_CLK  (((bd_t *)__res)->bi_intfreq * 1000000) */
286 #define BRG_INT_CLK             system_clock
287 #define BRG_UART_CLK    (BRG_INT_CLK/16)
288
289 void
290 m360_cpm_setbrg(uint brg, uint rate)
291 {
292         volatile uint   *bp;
293
294         /* This is good enough to get SMCs running.....
295          */
296         /* bp = (uint *)&cpmp->cp_brgc1; */
297         bp = (volatile uint *)(&pquicc->brgc[0].l);
298         bp += brg;
299         *bp = ((BRG_UART_CLK / rate - 1) << 1) | CPM_BRG_EN;
300 }
301
302
303 /*
304  * Local variables:
305  *  c-indent-level: 4
306  *  c-basic-offset: 4
307  *  tab-width: 4
308  * End:
309  */