[PATCH] gfp_t: sound
[linux-2.6.git] / arch / ppc / 8xx_io / commproc.c
1 /*
2  * General Purpose functions for the global management of the
3  * Communication Processor Module.
4  * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
5  *
6  * In addition to the individual control of the communication
7  * channels, there are a few functions that globally affect the
8  * communication processor.
9  *
10  * Buffer descriptors must be allocated from the dual ported memory
11  * space.  The allocator for that is here.  When the communication
12  * process is reset, we reclaim the memory available.  There is
13  * currently no deallocator for this memory.
14  * The amount of space available is platform dependent.  On the
15  * MBX, the EPPC software loads additional microcode into the
16  * communication processor, and uses some of the DP ram for this
17  * purpose.  Current, the first 512 bytes and the last 256 bytes of
18  * memory are used.  Right now I am conservative and only use the
19  * memory that can never be used for microcode.  If there are
20  * applications that require more DP ram, we can expand the boundaries
21  * but then we have to be careful of any downloaded microcode.
22  */
23 #include <linux/errno.h>
24 #include <linux/sched.h>
25 #include <linux/kernel.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/param.h>
28 #include <linux/string.h>
29 #include <linux/mm.h>
30 #include <linux/interrupt.h>
31 #include <linux/irq.h>
32 #include <linux/module.h>
33 #include <asm/mpc8xx.h>
34 #include <asm/page.h>
35 #include <asm/pgtable.h>
36 #include <asm/8xx_immap.h>
37 #include <asm/commproc.h>
38 #include <asm/io.h>
39 #include <asm/tlbflush.h>
40 #include <asm/rheap.h>
41
42 static void m8xx_cpm_dpinit(void);
43 static  uint    host_buffer;    /* One page of host buffer */
44 static  uint    host_end;       /* end + 1 */
45 cpm8xx_t        *cpmp;          /* Pointer to comm processor space */
46
47 /* CPM interrupt vector functions.
48 */
49 struct  cpm_action {
50         void    (*handler)(void *, struct pt_regs * regs);
51         void    *dev_id;
52 };
53 static  struct  cpm_action cpm_vecs[CPMVEC_NR];
54 static  irqreturn_t cpm_interrupt(int irq, void * dev, struct pt_regs * regs);
55 static  irqreturn_t cpm_error_interrupt(int irq, void *dev, struct pt_regs * regs);
56 static  void    alloc_host_memory(void);
57 /* Define a table of names to identify CPM interrupt handlers in
58  * /proc/interrupts.
59  */
60 const char *cpm_int_name[] =
61         { "error",      "PC4",          "PC5",          "SMC2",
62           "SMC1",       "SPI",          "PC6",          "Timer 4",
63           "",           "PC7",          "PC8",          "PC9",
64           "Timer 3",    "",             "PC10",         "PC11",
65           "I2C",        "RISC Timer",   "Timer 2",      "",
66           "IDMA2",      "IDMA1",        "SDMA error",   "PC12",
67           "PC13",       "Timer 1",      "PC14",         "SCC4",
68           "SCC3",       "SCC2",         "SCC1",         "PC15"
69         };
70
71 static void
72 cpm_mask_irq(unsigned int irq)
73 {
74         int cpm_vec = irq - CPM_IRQ_OFFSET;
75
76         ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr &= ~(1 << cpm_vec);
77 }
78
79 static void
80 cpm_unmask_irq(unsigned int irq)
81 {
82         int cpm_vec = irq - CPM_IRQ_OFFSET;
83
84         ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr |= (1 << cpm_vec);
85 }
86
87 static void
88 cpm_ack(unsigned int irq)
89 {
90         /* We do not need to do anything here. */
91 }
92
93 static void
94 cpm_eoi(unsigned int irq)
95 {
96         int cpm_vec = irq - CPM_IRQ_OFFSET;
97
98         ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cisr = (1 << cpm_vec);
99 }
100
101 struct hw_interrupt_type cpm_pic = {
102         .typename       = " CPM      ",
103         .enable         = cpm_unmask_irq,
104         .disable        = cpm_mask_irq,
105         .ack            = cpm_ack,
106         .end            = cpm_eoi,
107 };
108
109 void
110 m8xx_cpm_reset(void)
111 {
112         volatile immap_t         *imp;
113         volatile cpm8xx_t       *commproc;
114
115         imp = (immap_t *)IMAP_ADDR;
116         commproc = (cpm8xx_t *)&imp->im_cpm;
117
118 #ifdef CONFIG_UCODE_PATCH
119         /* Perform a reset.
120         */
121         commproc->cp_cpcr = (CPM_CR_RST | CPM_CR_FLG);
122
123         /* Wait for it.
124         */
125         while (commproc->cp_cpcr & CPM_CR_FLG);
126
127         cpm_load_patch(imp);
128 #endif
129
130         /* Set SDMA Bus Request priority 5.
131          * On 860T, this also enables FEC priority 6.  I am not sure
132          * this is what we realy want for some applications, but the
133          * manual recommends it.
134          * Bit 25, FAM can also be set to use FEC aggressive mode (860T).
135          */
136         imp->im_siu_conf.sc_sdcr = 1;
137
138         /* Reclaim the DP memory for our use. */
139         m8xx_cpm_dpinit();
140
141         /* Tell everyone where the comm processor resides.
142         */
143         cpmp = (cpm8xx_t *)commproc;
144 }
145
146 /* We used to do this earlier, but have to postpone as long as possible
147  * to ensure the kernel VM is now running.
148  */
149 static void
150 alloc_host_memory(void)
151 {
152         dma_addr_t      physaddr;
153
154         /* Set the host page for allocation.
155         */
156         host_buffer = (uint)dma_alloc_coherent(NULL, PAGE_SIZE, &physaddr,
157                         GFP_KERNEL);
158         host_end = host_buffer + PAGE_SIZE;
159 }
160
161 /* This is called during init_IRQ.  We used to do it above, but this
162  * was too early since init_IRQ was not yet called.
163  */
164 static struct irqaction cpm_error_irqaction = {
165         .handler = cpm_error_interrupt,
166         .mask = CPU_MASK_NONE,
167 };
168 static struct irqaction cpm_interrupt_irqaction = {
169         .handler = cpm_interrupt,
170         .mask = CPU_MASK_NONE,
171         .name = "CPM cascade",
172 };
173
174 void
175 cpm_interrupt_init(void)
176 {
177         int i;
178
179         /* Initialize the CPM interrupt controller.
180         */
181         ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cicr =
182             (CICR_SCD_SCC4 | CICR_SCC_SCC3 | CICR_SCB_SCC2 | CICR_SCA_SCC1) |
183                 ((CPM_INTERRUPT/2) << 13) | CICR_HP_MASK;
184         ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr = 0;
185
186         /* install the CPM interrupt controller routines for the CPM
187          * interrupt vectors
188          */
189         for ( i = CPM_IRQ_OFFSET ; i < CPM_IRQ_OFFSET + NR_CPM_INTS ; i++ )
190                 irq_desc[i].handler = &cpm_pic;
191
192         /* Set our interrupt handler with the core CPU. */
193         if (setup_irq(CPM_INTERRUPT, &cpm_interrupt_irqaction))
194                 panic("Could not allocate CPM IRQ!");
195
196         /* Install our own error handler. */
197         cpm_error_irqaction.name = cpm_int_name[CPMVEC_ERROR];
198         if (setup_irq(CPM_IRQ_OFFSET + CPMVEC_ERROR, &cpm_error_irqaction))
199                 panic("Could not allocate CPM error IRQ!");
200
201         ((immap_t *)IMAP_ADDR)->im_cpic.cpic_cicr |= CICR_IEN;
202 }
203
204 /*
205  * Get the CPM interrupt vector.
206  */
207 int
208 cpm_get_irq(struct pt_regs *regs)
209 {
210         int cpm_vec;
211
212         /* Get the vector by setting the ACK bit and then reading
213          * the register.
214          */
215         ((volatile immap_t *)IMAP_ADDR)->im_cpic.cpic_civr = 1;
216         cpm_vec = ((volatile immap_t *)IMAP_ADDR)->im_cpic.cpic_civr;
217         cpm_vec >>= 11;
218
219         return cpm_vec;
220 }
221
222 /* CPM interrupt controller cascade interrupt.
223 */
224 static  irqreturn_t
225 cpm_interrupt(int irq, void * dev, struct pt_regs * regs)
226 {
227         /* This interrupt handler never actually gets called.  It is
228          * installed only to unmask the CPM cascade interrupt in the SIU
229          * and to make the CPM cascade interrupt visible in /proc/interrupts.
230          */
231         return IRQ_HANDLED;
232 }
233
234 /* The CPM can generate the error interrupt when there is a race condition
235  * between generating and masking interrupts.  All we have to do is ACK it
236  * and return.  This is a no-op function so we don't need any special
237  * tests in the interrupt handler.
238  */
239 static  irqreturn_t
240 cpm_error_interrupt(int irq, void *dev, struct pt_regs *regs)
241 {
242         return IRQ_HANDLED;
243 }
244
245 /* A helper function to translate the handler prototype required by
246  * request_irq() to the handler prototype required by cpm_install_handler().
247  */
248 static irqreturn_t
249 cpm_handler_helper(int irq, void *dev_id, struct pt_regs *regs)
250 {
251         int cpm_vec = irq - CPM_IRQ_OFFSET;
252
253         (*cpm_vecs[cpm_vec].handler)(dev_id, regs);
254
255         return IRQ_HANDLED;
256 }
257
258 /* Install a CPM interrupt handler.
259  * This routine accepts a CPM interrupt vector in the range 0 to 31.
260  * This routine is retained for backward compatibility.  Rather than using
261  * this routine to install a CPM interrupt handler, you can now use
262  * request_irq() with an IRQ in the range CPM_IRQ_OFFSET to
263  * CPM_IRQ_OFFSET + NR_CPM_INTS - 1 (16 to 47).
264  *
265  * Notice that the prototype of the interrupt handler function must be
266  * different depending on whether you install the handler with
267  * request_irq() or cpm_install_handler().
268  */
269 void
270 cpm_install_handler(int cpm_vec, void (*handler)(void *, struct pt_regs *regs),
271                     void *dev_id)
272 {
273         int err;
274
275         /* If null handler, assume we are trying to free the IRQ.
276         */
277         if (!handler) {
278                 free_irq(CPM_IRQ_OFFSET + cpm_vec, dev_id);
279                 return;
280         }
281
282         if (cpm_vecs[cpm_vec].handler != 0)
283                 printk(KERN_INFO "CPM interrupt %x replacing %x\n",
284                         (uint)handler, (uint)cpm_vecs[cpm_vec].handler);
285         cpm_vecs[cpm_vec].handler = handler;
286         cpm_vecs[cpm_vec].dev_id = dev_id;
287
288         if ((err = request_irq(CPM_IRQ_OFFSET + cpm_vec, cpm_handler_helper,
289                                         0, cpm_int_name[cpm_vec], dev_id)))
290                 printk(KERN_ERR "request_irq() returned %d for CPM vector %d\n",
291                                 err, cpm_vec);
292 }
293
294 /* Free a CPM interrupt handler.
295  * This routine accepts a CPM interrupt vector in the range 0 to 31.
296  * This routine is retained for backward compatibility.
297  */
298 void
299 cpm_free_handler(int cpm_vec)
300 {
301         request_irq(CPM_IRQ_OFFSET + cpm_vec, NULL, 0, 0,
302                 cpm_vecs[cpm_vec].dev_id);
303
304         cpm_vecs[cpm_vec].handler = NULL;
305         cpm_vecs[cpm_vec].dev_id = NULL;
306 }
307
308 /* We also own one page of host buffer space for the allocation of
309  * UART "fifos" and the like.
310  */
311 uint
312 m8xx_cpm_hostalloc(uint size)
313 {
314         uint    retloc;
315
316         if (host_buffer == 0)
317                 alloc_host_memory();
318
319         if ((host_buffer + size) >= host_end)
320                 return(0);
321
322         retloc = host_buffer;
323         host_buffer += size;
324
325         return(retloc);
326 }
327
328 /* Set a baud rate generator.  This needs lots of work.  There are
329  * four BRGs, any of which can be wired to any channel.
330  * The internal baud rate clock is the system clock divided by 16.
331  * This assumes the baudrate is 16x oversampled by the uart.
332  */
333 #define BRG_INT_CLK             (((bd_t *)__res)->bi_intfreq)
334 #define BRG_UART_CLK            (BRG_INT_CLK/16)
335 #define BRG_UART_CLK_DIV16      (BRG_UART_CLK/16)
336
337 void
338 cpm_setbrg(uint brg, uint rate)
339 {
340         volatile uint   *bp;
341
342         /* This is good enough to get SMCs running.....
343         */
344         bp = (uint *)&cpmp->cp_brgc1;
345         bp += brg;
346         /* The BRG has a 12-bit counter.  For really slow baud rates (or
347          * really fast processors), we may have to further divide by 16.
348          */
349         if (((BRG_UART_CLK / rate) - 1) < 4096)
350                 *bp = (((BRG_UART_CLK / rate) - 1) << 1) | CPM_BRG_EN;
351         else
352                 *bp = (((BRG_UART_CLK_DIV16 / rate) - 1) << 1) |
353                                                 CPM_BRG_EN | CPM_BRG_DIV16;
354 }
355
356 /*
357  * dpalloc / dpfree bits.
358  */
359 static spinlock_t cpm_dpmem_lock;
360 /*
361  * 16 blocks should be enough to satisfy all requests
362  * until the memory subsystem goes up...
363  */
364 static rh_block_t cpm_boot_dpmem_rh_block[16];
365 static rh_info_t cpm_dpmem_info;
366
367 #define CPM_DPMEM_ALIGNMENT     8
368
369 void m8xx_cpm_dpinit(void)
370 {
371         spin_lock_init(&cpm_dpmem_lock);
372
373         /* Initialize the info header */
374         rh_init(&cpm_dpmem_info, CPM_DPMEM_ALIGNMENT,
375                         sizeof(cpm_boot_dpmem_rh_block) /
376                         sizeof(cpm_boot_dpmem_rh_block[0]),
377                         cpm_boot_dpmem_rh_block);
378
379         /*
380          * Attach the usable dpmem area.
381          * XXX: This is actually crap.  CPM_DATAONLY_BASE and
382          * CPM_DATAONLY_SIZE are a subset of the available dparm.  It varies
383          * with the processor and the microcode patches applied / activated.
384          * But the following should be at least safe.
385          */
386         rh_attach_region(&cpm_dpmem_info, (void *)CPM_DATAONLY_BASE, CPM_DATAONLY_SIZE);
387 }
388
389 /*
390  * Allocate the requested size worth of DP memory.
391  * This function used to return an index into the DPRAM area.
392  * Now it returns the actuall physical address of that area.
393  * use m8xx_cpm_dpram_offset() to get the index
394  */
395 uint cpm_dpalloc(uint size, uint align)
396 {
397         void *start;
398         unsigned long flags;
399
400         spin_lock_irqsave(&cpm_dpmem_lock, flags);
401         cpm_dpmem_info.alignment = align;
402         start = rh_alloc(&cpm_dpmem_info, size, "commproc");
403         spin_unlock_irqrestore(&cpm_dpmem_lock, flags);
404
405         return (uint)start;
406 }
407 EXPORT_SYMBOL(cpm_dpalloc);
408
409 int cpm_dpfree(uint offset)
410 {
411         int ret;
412         unsigned long flags;
413
414         spin_lock_irqsave(&cpm_dpmem_lock, flags);
415         ret = rh_free(&cpm_dpmem_info, (void *)offset);
416         spin_unlock_irqrestore(&cpm_dpmem_lock, flags);
417
418         return ret;
419 }
420 EXPORT_SYMBOL(cpm_dpfree);
421
422 uint cpm_dpalloc_fixed(uint offset, uint size, uint align)
423 {
424         void *start;
425         unsigned long flags;
426
427         spin_lock_irqsave(&cpm_dpmem_lock, flags);
428         cpm_dpmem_info.alignment = align;
429         start = rh_alloc_fixed(&cpm_dpmem_info, (void *)offset, size, "commproc");
430         spin_unlock_irqrestore(&cpm_dpmem_lock, flags);
431
432         return (uint)start;
433 }
434 EXPORT_SYMBOL(cpm_dpalloc_fixed);
435
436 void cpm_dpdump(void)
437 {
438         rh_dump(&cpm_dpmem_info);
439 }
440 EXPORT_SYMBOL(cpm_dpdump);
441
442 void *cpm_dpram_addr(uint offset)
443 {
444         return ((immap_t *)IMAP_ADDR)->im_cpm.cp_dpmem + offset;
445 }
446 EXPORT_SYMBOL(cpm_dpram_addr);