]> git.sur5r.net Git - u-boot/blob - board/esd/cpci750/mpsc.c
board/[d-e]*: Remove obsolete references to CONFIG_COMMANDS
[u-boot] / board / esd / cpci750 / mpsc.c
1 /*
2  * (C) Copyright 2001
3  * John Clemens <clemens@mclx.com>, Mission Critical Linux, Inc.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 /*************************************************************************
25  * changes for Marvell DB64360 eval board 2003 by Ingo Assmus <ingo.assmus@keymile.com>
26  *
27   ************************************************************************/
28
29 /*
30  * mpsc.c - driver for console over the MPSC.
31  */
32
33
34 #include <common.h>
35 #include <config.h>
36 #include <asm/cache.h>
37
38 #include <malloc.h>
39 #include "mpsc.h"
40
41 #include "mv_regs.h"
42
43 #include "../../Marvell/include/memory.h"
44
45 DECLARE_GLOBAL_DATA_PTR;
46
47 /* Define this if you wish to use the MPSC as a register based UART.
48  * This will force the serial port to not use the SDMA engine at all.
49  */
50
51 #undef CONFIG_MPSC_DEBUG_PORT
52
53
54 int (*mpsc_putchar) (char ch) = mpsc_putchar_early;
55 char (*mpsc_getchar) (void) = mpsc_getchar_debug;
56 int (*mpsc_test_char) (void) = mpsc_test_char_debug;
57
58
59 static volatile unsigned int *rx_desc_base = NULL;
60 static unsigned int rx_desc_index = 0;
61 static volatile unsigned int *tx_desc_base = NULL;
62 static unsigned int tx_desc_index = 0;
63
64 /* local function declarations */
65 static int galmpsc_connect (int channel, int connect);
66 static int galmpsc_route_rx_clock (int channel, int brg);
67 static int galmpsc_route_tx_clock (int channel, int brg);
68 static int galmpsc_write_config_regs (int mpsc, int mode);
69 static int galmpsc_config_channel_regs (int mpsc);
70 static int galmpsc_set_char_length (int mpsc, int value);
71 static int galmpsc_set_stop_bit_length (int mpsc, int value);
72 static int galmpsc_set_parity (int mpsc, int value);
73 static int galmpsc_enter_hunt (int mpsc);
74 static int galmpsc_set_brkcnt (int mpsc, int value);
75 static int galmpsc_set_tcschar (int mpsc, int value);
76 static int galmpsc_set_snoop (int mpsc, int value);
77 static int galmpsc_shutdown (int mpsc);
78
79 static int galsdma_set_RFT (int channel);
80 static int galsdma_set_SFM (int channel);
81 static int galsdma_set_rxle (int channel);
82 static int galsdma_set_txle (int channel);
83 static int galsdma_set_burstsize (int channel, unsigned int value);
84 static int galsdma_set_RC (int channel, unsigned int value);
85
86 static int galbrg_set_CDV (int channel, int value);
87 static int galbrg_enable (int channel);
88 static int galbrg_disable (int channel);
89 static int galbrg_set_clksrc (int channel, int value);
90 static int galbrg_set_CUV (int channel, int value);
91
92 static void galsdma_enable_rx (void);
93 static int galsdma_set_mem_space (unsigned int memSpace,
94                                   unsigned int memSpaceTarget,
95                                   unsigned int memSpaceAttr,
96                                   unsigned int baseAddress,
97                                   unsigned int size);
98
99
100 #define SOFTWARE_CACHE_MANAGEMENT
101
102 #ifdef SOFTWARE_CACHE_MANAGEMENT
103 #define FLUSH_DCACHE(a,b)                if(dcache_status()){clean_dcache_range((u32)(a),(u32)(b));}
104 #define FLUSH_AND_INVALIDATE_DCACHE(a,b) if(dcache_status()){flush_dcache_range((u32)(a),(u32)(b));}
105 #define INVALIDATE_DCACHE(a,b)           if(dcache_status()){invalidate_dcache_range((u32)(a),(u32)(b));}
106 #else
107 #define FLUSH_DCACHE(a,b)
108 #define FLUSH_AND_INVALIDATE_DCACHE(a,b)
109 #define INVALIDATE_DCACHE(a,b)
110 #endif
111
112 #ifdef CONFIG_MPSC_DEBUG_PORT
113 static void mpsc_debug_init (void)
114 {
115
116         volatile unsigned int temp;
117
118         /* Clear the CFR  (CHR4) */
119         /* Write random 'Z' bit (bit 29) of CHR4 to enable debug uart *UNDOCUMENTED FEATURE* */
120         temp = GTREGREAD (GALMPSC_CHANNELREG_4 + (CHANNEL * GALMPSC_REG_GAP));
121         temp &= 0xffffff00;
122         temp |= BIT29;
123         GT_REG_WRITE (GALMPSC_CHANNELREG_4 + (CHANNEL * GALMPSC_REG_GAP),
124                       temp);
125
126         /* Set the Valid bit 'V' (bit 12) and int generation bit 'INT' (bit 15) */
127         temp = GTREGREAD (GALMPSC_CHANNELREG_5 + (CHANNEL * GALMPSC_REG_GAP));
128         temp |= (BIT12 | BIT15);
129         GT_REG_WRITE (GALMPSC_CHANNELREG_5 + (CHANNEL * GALMPSC_REG_GAP),
130                       temp);
131
132         /* Set int mask */
133         temp = GTREGREAD (GALMPSC_0_INT_MASK);
134         temp |= BIT6;
135         GT_REG_WRITE (GALMPSC_0_INT_MASK, temp);
136 }
137 #endif
138
139 char mpsc_getchar_debug (void)
140 {
141         volatile int temp;
142         volatile unsigned int cause;
143
144         cause = GTREGREAD (GALMPSC_0_INT_CAUSE);
145         while ((cause & BIT6) == 0) {
146                 cause = GTREGREAD (GALMPSC_0_INT_CAUSE);
147         }
148
149         temp = GTREGREAD (GALMPSC_CHANNELREG_10 +
150                           (CHANNEL * GALMPSC_REG_GAP));
151         /* By writing 1's to the set bits, the register is cleared */
152         GT_REG_WRITE (GALMPSC_CHANNELREG_10 + (CHANNEL * GALMPSC_REG_GAP),
153                       temp);
154         GT_REG_WRITE (GALMPSC_0_INT_CAUSE, cause & ~BIT6);
155         return (temp >> 16) & 0xff;
156 }
157
158 /* special function for running out of flash.  doesn't modify any
159  * global variables [josh] */
160 int mpsc_putchar_early (char ch)
161 {
162         int mpsc = CHANNEL;
163         int temp =
164                 GTREGREAD (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP));
165         galmpsc_set_tcschar (mpsc, ch);
166         GT_REG_WRITE (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP),
167                       temp | 0x200);
168
169 #define MAGIC_FACTOR    (10*1000000)
170
171         udelay (MAGIC_FACTOR / gd->baudrate);
172         return 0;
173 }
174
175 /* This is used after relocation, see serial.c and mpsc_init2 */
176 static int mpsc_putchar_sdma (char ch)
177 {
178         volatile unsigned int *p;
179         unsigned int temp;
180
181
182         /* align the descriptor */
183         p = tx_desc_base;
184         memset ((void *) p, 0, 8 * sizeof (unsigned int));
185
186         /* fill one 64 bit buffer */
187         /* word swap, pad with 0 */
188         p[4] = 0;               /* x */
189         p[5] = (unsigned int) ch;       /* x */
190
191         /* CHANGED completely according to GT64260A dox - NTL */
192         p[0] = 0x00010001;      /* 0 */
193         p[1] = DESC_OWNER_BIT | DESC_FIRST | DESC_LAST; /* 4 */
194         p[2] = 0;               /* 8 */
195         p[3] = (unsigned int) &p[4];    /* c */
196
197 #if 0
198         p[9] = DESC_FIRST | DESC_LAST;
199         p[10] = (unsigned int) &p[0];
200         p[11] = (unsigned int) &p[12];
201 #endif
202
203         FLUSH_DCACHE (&p[0], &p[8]);
204
205         GT_REG_WRITE (GALSDMA_0_CUR_TX_PTR + (CHANNEL * GALSDMA_REG_DIFF),
206                       (unsigned int) &p[0]);
207         GT_REG_WRITE (GALSDMA_0_FIR_TX_PTR + (CHANNEL * GALSDMA_REG_DIFF),
208                       (unsigned int) &p[0]);
209
210         temp = GTREGREAD (GALSDMA_0_COM_REG + (CHANNEL * GALSDMA_REG_DIFF));
211         temp |= (TX_DEMAND | TX_STOP);
212         GT_REG_WRITE (GALSDMA_0_COM_REG + (CHANNEL * GALSDMA_REG_DIFF), temp);
213
214         INVALIDATE_DCACHE (&p[1], &p[2]);
215
216         while (p[1] & DESC_OWNER_BIT) {
217                 udelay (100);
218                 INVALIDATE_DCACHE (&p[1], &p[2]);
219         }
220         return 0;
221 }
222
223 char mpsc_getchar_sdma (void)
224 {
225         static unsigned int done = 0;
226         volatile char ch;
227         unsigned int len = 0, idx = 0, temp;
228
229         volatile unsigned int *p;
230
231
232         do {
233                 p = &rx_desc_base[rx_desc_index * 8];
234
235                 INVALIDATE_DCACHE (&p[0], &p[1]);
236                 /* Wait for character */
237                 while (p[1] & DESC_OWNER_BIT) {
238                         udelay (100);
239                         INVALIDATE_DCACHE (&p[0], &p[1]);
240                 }
241
242                 /* Handle error case */
243                 if (p[1] & (1 << 15)) {
244                         printf ("oops, error: %08x\n", p[1]);
245
246                         temp = GTREGREAD (GALMPSC_CHANNELREG_2 +
247                                           (CHANNEL * GALMPSC_REG_GAP));
248                         temp |= (1 << 23);
249                         GT_REG_WRITE (GALMPSC_CHANNELREG_2 +
250                                       (CHANNEL * GALMPSC_REG_GAP), temp);
251
252                         /* Can't poll on abort bit, so we just wait. */
253                         udelay (100);
254
255                         galsdma_enable_rx ();
256                 }
257
258                 /* Number of bytes left in this descriptor */
259                 len = p[0] & 0xffff;
260
261                 if (len) {
262                         /* Where to look */
263                         idx = 5;
264                         if (done > 3)
265                                 idx = 4;
266                         if (done > 7)
267                                 idx = 7;
268                         if (done > 11)
269                                 idx = 6;
270
271                         INVALIDATE_DCACHE (&p[idx], &p[idx + 1]);
272                         ch = p[idx] & 0xff;
273                         done++;
274                 }
275
276                 if (done < len) {
277                         /* this descriptor has more bytes still
278                          * shift down the char we just read, and leave the
279                          * buffer in place for the next time around
280                          */
281                         p[idx] = p[idx] >> 8;
282                         FLUSH_DCACHE (&p[idx], &p[idx + 1]);
283                 }
284
285                 if (done == len) {
286                         /* nothing left in this descriptor.
287                          * go to next one
288                          */
289                         p[1] = DESC_OWNER_BIT | DESC_FIRST | DESC_LAST;
290                         p[0] = 0x00100000;
291                         FLUSH_DCACHE (&p[0], &p[1]);
292                         /* Next descriptor */
293                         rx_desc_index = (rx_desc_index + 1) % RX_DESC;
294                         done = 0;
295                 }
296         } while (len == 0);     /* galileo bug.. len might be zero */
297
298         return ch;
299 }
300
301
302 int mpsc_test_char_debug (void)
303 {
304         if ((GTREGREAD (GALMPSC_0_INT_CAUSE) & BIT6) == 0)
305                 return 0;
306         else {
307                 return 1;
308         }
309 }
310
311
312 int mpsc_test_char_sdma (void)
313 {
314         volatile unsigned int *p = &rx_desc_base[rx_desc_index * 8];
315
316         INVALIDATE_DCACHE (&p[1], &p[2]);
317
318         if (p[1] & DESC_OWNER_BIT)
319                 return 0;
320         else
321                 return 1;
322 }
323
324 int mpsc_init (int baud)
325 {
326         /* BRG CONFIG */
327         galbrg_set_baudrate (CHANNEL, baud);
328         galbrg_set_clksrc (CHANNEL, 8); /* set source=Tclk */
329         galbrg_set_CUV (CHANNEL, 0);    /* set up CountUpValue */
330         galbrg_enable (CHANNEL);        /* Enable BRG */
331
332         /* Set up clock routing */
333         galmpsc_connect (CHANNEL, GALMPSC_CONNECT);     /* connect it */
334
335         galmpsc_route_rx_clock (CHANNEL, CHANNEL);      /* chosse BRG0 for Rx */
336         galmpsc_route_tx_clock (CHANNEL, CHANNEL);      /* chose BRG0 for Tx */
337
338         /* reset MPSC state */
339         galmpsc_shutdown (CHANNEL);
340
341         /* SDMA CONFIG */
342         galsdma_set_burstsize (CHANNEL, L1_CACHE_BYTES / 8);    /* in 64 bit words (8 bytes) */
343         galsdma_set_txle (CHANNEL);
344         galsdma_set_rxle (CHANNEL);
345         galsdma_set_RC (CHANNEL, 0xf);
346         galsdma_set_SFM (CHANNEL);
347         galsdma_set_RFT (CHANNEL);
348
349         /* MPSC CONFIG */
350         galmpsc_write_config_regs (CHANNEL, GALMPSC_UART);
351         galmpsc_config_channel_regs (CHANNEL);
352         galmpsc_set_char_length (CHANNEL, GALMPSC_CHAR_LENGTH_8);       /* 8 */
353         galmpsc_set_parity (CHANNEL, GALMPSC_PARITY_NONE);      /* N */
354         galmpsc_set_stop_bit_length (CHANNEL, GALMPSC_STOP_BITS_1);     /* 1 */
355
356 #ifdef CONFIG_MPSC_DEBUG_PORT
357         mpsc_debug_init ();
358 #endif
359
360         /* COMM_MPSC CONFIG */
361 #ifdef SOFTWARE_CACHE_MANAGEMENT
362         galmpsc_set_snoop (CHANNEL, 0); /* disable snoop */
363 #else
364         galmpsc_set_snoop (CHANNEL, 1); /* enable snoop */
365 #endif
366
367         return 0;
368 }
369
370
371 void mpsc_sdma_init (void)
372 {
373 /* Setup SDMA channel0 SDMA_CONFIG_REG*/
374         GT_REG_WRITE (SDMA_CONFIG_REG (0), 0x000020ff);
375
376 /*  Enable MPSC-Window0 for DRAM Bank0   */
377         if (galsdma_set_mem_space (MV64360_CUNIT_BASE_ADDR_WIN_0_BIT,
378                                    MV64360_SDMA_DRAM_CS_0_TARGET,
379                                    0,
380                                    memoryGetBankBaseAddress
381                                    (CS_0_LOW_DECODE_ADDRESS),
382                                    memoryGetBankSize (BANK0)) != true)
383                 printf ("%s: SDMA_Window0 memory setup failed !!! \n",
384                         __FUNCTION__);
385
386
387 /*  Disable MPSC-Window1    */
388         if (galsdma_set_mem_space (MV64360_CUNIT_BASE_ADDR_WIN_1_BIT,
389                                    MV64360_SDMA_DRAM_CS_0_TARGET,
390                                    0,
391                                    memoryGetBankBaseAddress
392                                    (CS_1_LOW_DECODE_ADDRESS),
393                                    memoryGetBankSize (BANK3)) != true)
394                 printf ("%s: SDMA_Window1 memory setup failed !!! \n",
395                         __FUNCTION__);
396
397
398 /*  Disable MPSC-Window2 */
399         if (galsdma_set_mem_space (MV64360_CUNIT_BASE_ADDR_WIN_2_BIT,
400                                    MV64360_SDMA_DRAM_CS_0_TARGET,
401                                    0,
402                                    memoryGetBankBaseAddress
403                                    (CS_2_LOW_DECODE_ADDRESS),
404                                    memoryGetBankSize (BANK3)) != true)
405                 printf ("%s: SDMA_Window2 memory setup failed !!! \n",
406                         __FUNCTION__);
407
408
409 /*  Disable MPSC-Window3 */
410         if (galsdma_set_mem_space (MV64360_CUNIT_BASE_ADDR_WIN_3_BIT,
411                                    MV64360_SDMA_DRAM_CS_0_TARGET,
412                                    0,
413                                    memoryGetBankBaseAddress
414                                    (CS_3_LOW_DECODE_ADDRESS),
415                                    memoryGetBankSize (BANK3)) != true)
416                 printf ("%s: SDMA_Window3 memory setup failed !!! \n",
417                         __FUNCTION__);
418
419 /*  Setup MPSC0 access mode Window0 full access */
420         GT_SET_REG_BITS (MPSC0_ACCESS_PROTECTION_REG,
421                          (MV64360_SDMA_WIN_ACCESS_FULL <<
422                           (MV64360_CUNIT_BASE_ADDR_WIN_0_BIT * 2)));
423
424 /*  Setup MPSC1 access mode Window1 full access */
425         GT_SET_REG_BITS (MPSC1_ACCESS_PROTECTION_REG,
426                          (MV64360_SDMA_WIN_ACCESS_FULL <<
427                           (MV64360_CUNIT_BASE_ADDR_WIN_0_BIT * 2)));
428
429 /* Setup MPSC internal address space base address       */
430         GT_REG_WRITE (CUNIT_INTERNAL_SPACE_BASE_ADDR_REG, CFG_GT_REGS);
431
432 /* no high address remap*/
433         GT_REG_WRITE (CUNIT_HIGH_ADDR_REMAP_REG0, 0x00);
434         GT_REG_WRITE (CUNIT_HIGH_ADDR_REMAP_REG1, 0x00);
435
436 /* clear interrupt cause register for MPSC (fault register)*/
437         GT_REG_WRITE (CUNIT_INTERRUPT_CAUSE_REG, 0x00);
438 }
439
440
441 void mpsc_init2 (void)
442 {
443         int i;
444
445 #ifndef CONFIG_MPSC_DEBUG_PORT
446         mpsc_putchar = mpsc_putchar_sdma;
447         mpsc_getchar = mpsc_getchar_sdma;
448         mpsc_test_char = mpsc_test_char_sdma;
449 #endif
450         /* RX descriptors */
451         rx_desc_base = (unsigned int *) malloc (((RX_DESC + 1) * 8) *
452                                                 sizeof (unsigned int));
453
454         /* align descriptors */
455         rx_desc_base = (unsigned int *)
456                 (((unsigned int) rx_desc_base + 32) & 0xFFFFFFF0);
457
458         rx_desc_index = 0;
459
460         memset ((void *) rx_desc_base, 0,
461                 (RX_DESC * 8) * sizeof (unsigned int));
462
463         for (i = 0; i < RX_DESC; i++) {
464                 rx_desc_base[i * 8 + 3] = (unsigned int) &rx_desc_base[i * 8 + 4];      /* Buffer */
465                 rx_desc_base[i * 8 + 2] = (unsigned int) &rx_desc_base[(i + 1) * 8];    /* Next descriptor */
466                 rx_desc_base[i * 8 + 1] = DESC_OWNER_BIT | DESC_FIRST | DESC_LAST;      /* Command & control */
467                 rx_desc_base[i * 8] = 0x00100000;
468         }
469         rx_desc_base[(i - 1) * 8 + 2] = (unsigned int) &rx_desc_base[0];
470
471         FLUSH_DCACHE (&rx_desc_base[0], &rx_desc_base[RX_DESC * 8]);
472         GT_REG_WRITE (GALSDMA_0_CUR_RX_PTR + (CHANNEL * GALSDMA_REG_DIFF),
473                       (unsigned int) &rx_desc_base[0]);
474
475         /* TX descriptors */
476         tx_desc_base = (unsigned int *) malloc (((TX_DESC + 1) * 8) *
477                                                 sizeof (unsigned int));
478
479         /* align descriptors */
480         tx_desc_base = (unsigned int *)
481                 (((unsigned int) tx_desc_base + 32) & 0xFFFFFFF0);
482
483         tx_desc_index = -1;
484
485         memset ((void *) tx_desc_base, 0,
486                 (TX_DESC * 8) * sizeof (unsigned int));
487
488         for (i = 0; i < TX_DESC; i++) {
489                 tx_desc_base[i * 8 + 5] = (unsigned int) 0x23232323;
490                 tx_desc_base[i * 8 + 4] = (unsigned int) 0x23232323;
491                 tx_desc_base[i * 8 + 3] =
492                         (unsigned int) &tx_desc_base[i * 8 + 4];
493                 tx_desc_base[i * 8 + 2] =
494                         (unsigned int) &tx_desc_base[(i + 1) * 8];
495                 tx_desc_base[i * 8 + 1] =
496                         DESC_OWNER_BIT | DESC_FIRST | DESC_LAST;
497
498                 /* set sbytecnt and shadow byte cnt to 1 */
499                 tx_desc_base[i * 8] = 0x00010001;
500         }
501         tx_desc_base[(i - 1) * 8 + 2] = (unsigned int) &tx_desc_base[0];
502
503         FLUSH_DCACHE (&tx_desc_base[0], &tx_desc_base[TX_DESC * 8]);
504
505         udelay (100);
506
507         galsdma_enable_rx ();
508
509         return;
510 }
511
512 int galbrg_set_baudrate (int channel, int rate)
513 {
514         int clock;
515
516         galbrg_disable (channel);       /*ok */
517
518 #ifdef ZUMA_NTL
519         /* from tclk */
520         clock = (CFG_TCLK / (16 * rate)) - 1;
521 #else
522         clock = (CFG_TCLK / (16 * rate)) - 1;
523 #endif
524
525         galbrg_set_CDV (channel, clock);        /* set timer Reg. for BRG */
526
527         galbrg_enable (channel);
528
529         gd->baudrate = rate;
530
531         return 0;
532 }
533
534 /* ------------------------------------------------------------------ */
535
536 /* Below are all the private functions that no one else needs */
537
538 static int galbrg_set_CDV (int channel, int value)
539 {
540         unsigned int temp;
541
542         temp = GTREGREAD (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP));
543         temp &= 0xFFFF0000;
544         temp |= (value & 0x0000FFFF);
545         GT_REG_WRITE (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP), temp);
546
547         return 0;
548 }
549
550 static int galbrg_enable (int channel)
551 {
552         unsigned int temp;
553
554         temp = GTREGREAD (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP));
555         temp |= 0x00010000;
556         GT_REG_WRITE (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP), temp);
557
558         return 0;
559 }
560
561 static int galbrg_disable (int channel)
562 {
563         unsigned int temp;
564
565         temp = GTREGREAD (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP));
566         temp &= 0xFFFEFFFF;
567         GT_REG_WRITE (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP), temp);
568
569         return 0;
570 }
571
572 static int galbrg_set_clksrc (int channel, int value)
573 {
574         unsigned int temp;
575
576         temp = GTREGREAD (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP));
577         temp &= 0xFFC3FFFF;     /* Bit 18 - 21 (MV 64260 18-22) */
578         temp |= (value << 18);
579         GT_REG_WRITE (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP), temp);
580         return 0;
581 }
582
583 static int galbrg_set_CUV (int channel, int value)
584 {
585         /* set CountUpValue */
586         GT_REG_WRITE (GALBRG_0_BTREG + (channel * GALBRG_REG_GAP), value);
587
588         return 0;
589 }
590
591 #if 0
592 static int galbrg_reset (int channel)
593 {
594         unsigned int temp;
595
596         temp = GTREGREAD (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP));
597         temp |= 0x20000;
598         GT_REG_WRITE (GALBRG_0_CONFREG + (channel * GALBRG_REG_GAP), temp);
599
600         return 0;
601 }
602 #endif
603
604 static int galsdma_set_RFT (int channel)
605 {
606         unsigned int temp;
607
608         temp = GTREGREAD (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF));
609         temp |= 0x00000001;
610         GT_REG_WRITE (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF),
611                       temp);
612
613         return 0;
614 }
615
616 static int galsdma_set_SFM (int channel)
617 {
618         unsigned int temp;
619
620         temp = GTREGREAD (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF));
621         temp |= 0x00000002;
622         GT_REG_WRITE (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF),
623                       temp);
624
625         return 0;
626 }
627
628 static int galsdma_set_rxle (int channel)
629 {
630         unsigned int temp;
631
632         temp = GTREGREAD (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF));
633         temp |= 0x00000040;
634         GT_REG_WRITE (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF),
635                       temp);
636
637         return 0;
638 }
639
640 static int galsdma_set_txle (int channel)
641 {
642         unsigned int temp;
643
644         temp = GTREGREAD (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF));
645         temp |= 0x00000080;
646         GT_REG_WRITE (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF),
647                       temp);
648
649         return 0;
650 }
651
652 static int galsdma_set_RC (int channel, unsigned int value)
653 {
654         unsigned int temp;
655
656         temp = GTREGREAD (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF));
657         temp &= ~0x0000003c;
658         temp |= (value << 2);
659         GT_REG_WRITE (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF),
660                       temp);
661
662         return 0;
663 }
664
665 static int galsdma_set_burstsize (int channel, unsigned int value)
666 {
667         unsigned int temp;
668
669         temp = GTREGREAD (GALSDMA_0_CONF_REG + (channel * GALSDMA_REG_DIFF));
670         temp &= 0xFFFFCFFF;
671         switch (value) {
672         case 8:
673                 GT_REG_WRITE (GALSDMA_0_CONF_REG +
674                               (channel * GALSDMA_REG_DIFF),
675                               (temp | (0x3 << 12)));
676                 break;
677
678         case 4:
679                 GT_REG_WRITE (GALSDMA_0_CONF_REG +
680                               (channel * GALSDMA_REG_DIFF),
681                               (temp | (0x2 << 12)));
682                 break;
683
684         case 2:
685                 GT_REG_WRITE (GALSDMA_0_CONF_REG +
686                               (channel * GALSDMA_REG_DIFF),
687                               (temp | (0x1 << 12)));
688                 break;
689
690         case 1:
691                 GT_REG_WRITE (GALSDMA_0_CONF_REG +
692                               (channel * GALSDMA_REG_DIFF),
693                               (temp | (0x0 << 12)));
694                 break;
695
696         default:
697                 return -1;
698                 break;
699         }
700
701         return 0;
702 }
703
704 static int galmpsc_connect (int channel, int connect)
705 {
706         unsigned int temp;
707
708         temp = GTREGREAD (GALMPSC_ROUTING_REGISTER);
709
710         if ((channel == 0) && connect)
711                 temp &= ~0x00000007;
712         else if ((channel == 1) && connect)
713                 temp &= ~(0x00000007 << 6);
714         else if ((channel == 0) && !connect)
715                 temp |= 0x00000007;
716         else
717                 temp |= (0x00000007 << 6);
718
719         /* Just in case... */
720         temp &= 0x3fffffff;
721
722         GT_REG_WRITE (GALMPSC_ROUTING_REGISTER, temp);
723
724         return 0;
725 }
726
727 static int galmpsc_route_rx_clock (int channel, int brg)
728 {
729         unsigned int temp;
730
731         temp = GTREGREAD (GALMPSC_RxC_ROUTE);
732
733         if (channel == 0) {
734                 temp &= ~0x0000000F;
735                 temp |= brg;
736         } else {
737                 temp &= ~0x00000F00;
738                 temp |= (brg << 8);
739         }
740
741         GT_REG_WRITE (GALMPSC_RxC_ROUTE, temp);
742
743         return 0;
744 }
745
746 static int galmpsc_route_tx_clock (int channel, int brg)
747 {
748         unsigned int temp;
749
750         temp = GTREGREAD (GALMPSC_TxC_ROUTE);
751
752         if (channel == 0) {
753                 temp &= ~0x0000000F;
754                 temp |= brg;
755         } else {
756                 temp &= ~0x00000F00;
757                 temp |= (brg << 8);
758         }
759
760         GT_REG_WRITE (GALMPSC_TxC_ROUTE, temp);
761
762         return 0;
763 }
764
765 static int galmpsc_write_config_regs (int mpsc, int mode)
766 {
767         if (mode == GALMPSC_UART) {
768                 /* Main config reg Low (Null modem, Enable Tx/Rx, UART mode) */
769                 GT_REG_WRITE (GALMPSC_MCONF_LOW + (mpsc * GALMPSC_REG_GAP),
770                               0x000004c4);
771
772                 /* Main config reg High (32x Rx/Tx clock mode, width=8bits */
773                 GT_REG_WRITE (GALMPSC_MCONF_HIGH + (mpsc * GALMPSC_REG_GAP),
774                               0x024003f8);
775                 /*        22 2222 1111 */
776                 /*        54 3210 9876 */
777                 /* 0000 0010 0000 0000 */
778                 /*       1 */
779                 /*       098 7654 3210 */
780                 /* 0000 0011 1111 1000 */
781         } else
782                 return -1;
783
784         return 0;
785 }
786
787 static int galmpsc_config_channel_regs (int mpsc)
788 {
789         GT_REG_WRITE (GALMPSC_CHANNELREG_1 + (mpsc * GALMPSC_REG_GAP), 0);
790         GT_REG_WRITE (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP), 0);
791         GT_REG_WRITE (GALMPSC_CHANNELREG_3 + (mpsc * GALMPSC_REG_GAP), 1);
792         GT_REG_WRITE (GALMPSC_CHANNELREG_4 + (mpsc * GALMPSC_REG_GAP), 0);
793         GT_REG_WRITE (GALMPSC_CHANNELREG_5 + (mpsc * GALMPSC_REG_GAP), 0);
794         GT_REG_WRITE (GALMPSC_CHANNELREG_6 + (mpsc * GALMPSC_REG_GAP), 0);
795         GT_REG_WRITE (GALMPSC_CHANNELREG_7 + (mpsc * GALMPSC_REG_GAP), 0);
796         GT_REG_WRITE (GALMPSC_CHANNELREG_8 + (mpsc * GALMPSC_REG_GAP), 0);
797         GT_REG_WRITE (GALMPSC_CHANNELREG_9 + (mpsc * GALMPSC_REG_GAP), 0);
798         GT_REG_WRITE (GALMPSC_CHANNELREG_10 + (mpsc * GALMPSC_REG_GAP), 0);
799
800         galmpsc_set_brkcnt (mpsc, 0x3);
801         galmpsc_set_tcschar (mpsc, 0xab);
802
803         return 0;
804 }
805
806 static int galmpsc_set_brkcnt (int mpsc, int value)
807 {
808         unsigned int temp;
809
810         temp = GTREGREAD (GALMPSC_CHANNELREG_1 + (mpsc * GALMPSC_REG_GAP));
811         temp &= 0x0000FFFF;
812         temp |= (value << 16);
813         GT_REG_WRITE (GALMPSC_CHANNELREG_1 + (mpsc * GALMPSC_REG_GAP), temp);
814
815         return 0;
816 }
817
818 static int galmpsc_set_tcschar (int mpsc, int value)
819 {
820         unsigned int temp;
821
822         temp = GTREGREAD (GALMPSC_CHANNELREG_1 + (mpsc * GALMPSC_REG_GAP));
823         temp &= 0xFFFF0000;
824         temp |= value;
825         GT_REG_WRITE (GALMPSC_CHANNELREG_1 + (mpsc * GALMPSC_REG_GAP), temp);
826
827         return 0;
828 }
829
830 static int galmpsc_set_char_length (int mpsc, int value)
831 {
832         unsigned int temp;
833
834         temp = GTREGREAD (GALMPSC_PROTOCONF_REG + (mpsc * GALMPSC_REG_GAP));
835         temp &= 0xFFFFCFFF;
836         temp |= (value << 12);
837         GT_REG_WRITE (GALMPSC_PROTOCONF_REG + (mpsc * GALMPSC_REG_GAP), temp);
838
839         return 0;
840 }
841
842 static int galmpsc_set_stop_bit_length (int mpsc, int value)
843 {
844         unsigned int temp;
845
846         temp = GTREGREAD (GALMPSC_PROTOCONF_REG + (mpsc * GALMPSC_REG_GAP));
847         temp &= 0xFFFFBFFF;
848         temp |= (value << 14);
849         GT_REG_WRITE (GALMPSC_PROTOCONF_REG + (mpsc * GALMPSC_REG_GAP), temp);
850
851         return 0;
852 }
853
854 static int galmpsc_set_parity (int mpsc, int value)
855 {
856         unsigned int temp;
857
858         temp = GTREGREAD (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP));
859         if (value != -1) {
860                 temp &= 0xFFF3FFF3;
861                 temp |= ((value << 18) | (value << 2));
862                 temp |= ((value << 17) | (value << 1));
863         } else {
864                 temp &= 0xFFF1FFF1;
865         }
866
867         GT_REG_WRITE (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP), temp);
868
869         return 0;
870 }
871
872 static int galmpsc_enter_hunt (int mpsc)
873 {
874         int temp;
875
876         temp = GTREGREAD (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP));
877         temp |= 0x80000000;
878         GT_REG_WRITE (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP), temp);
879
880         while (GTREGREAD (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP)) &
881                MPSC_ENTER_HUNT) {
882                 udelay (1);
883         }
884         return 0;
885 }
886
887
888 static int galmpsc_shutdown (int mpsc)
889 {
890         unsigned int temp;
891
892         /* cause RX abort (clears RX) */
893         temp = GTREGREAD (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP));
894         temp |= MPSC_RX_ABORT | MPSC_TX_ABORT;
895         temp &= ~MPSC_ENTER_HUNT;
896         GT_REG_WRITE (GALMPSC_CHANNELREG_2 + (mpsc * GALMPSC_REG_GAP), temp);
897
898         GT_REG_WRITE (GALSDMA_0_COM_REG, 0);
899         GT_REG_WRITE (GALSDMA_0_COM_REG, SDMA_TX_ABORT | SDMA_RX_ABORT);
900
901         /* shut down the MPSC */
902         GT_REG_WRITE (GALMPSC_MCONF_LOW, 0);
903         GT_REG_WRITE (GALMPSC_MCONF_HIGH, 0);
904         GT_REG_WRITE (GALMPSC_PROTOCONF_REG + (mpsc * GALMPSC_REG_GAP), 0);
905
906         udelay (100);
907
908         /* shut down the sdma engines. */
909         /* reset config to default */
910         GT_REG_WRITE (GALSDMA_0_CONF_REG, 0x000000fc);
911
912         udelay (100);
913
914         /* clear the SDMA current and first TX and RX pointers */
915         GT_REG_WRITE (GALSDMA_0_CUR_RX_PTR, 0);
916         GT_REG_WRITE (GALSDMA_0_CUR_TX_PTR, 0);
917         GT_REG_WRITE (GALSDMA_0_FIR_TX_PTR, 0);
918
919         udelay (100);
920
921         return 0;
922 }
923
924 static void galsdma_enable_rx (void)
925 {
926         int temp;
927
928         /* Enable RX processing */
929         temp = GTREGREAD (GALSDMA_0_COM_REG + (CHANNEL * GALSDMA_REG_DIFF));
930         temp |= RX_ENABLE;
931         GT_REG_WRITE (GALSDMA_0_COM_REG + (CHANNEL * GALSDMA_REG_DIFF), temp);
932
933         galmpsc_enter_hunt (CHANNEL);
934 }
935
936 static int galmpsc_set_snoop (int mpsc, int value)
937 {
938         int reg =
939                 mpsc ? MPSC_1_ADDRESS_CONTROL_LOW :
940                 MPSC_0_ADDRESS_CONTROL_LOW;
941         int temp = GTREGREAD (reg);
942
943         if (value)
944                 temp |= (1 << 6) | (1 << 14) | (1 << 22) | (1 << 30);
945         else
946                 temp &= ~((1 << 6) | (1 << 14) | (1 << 22) | (1 << 30));
947         GT_REG_WRITE (reg, temp);
948         return 0;
949 }
950
951 /*******************************************************************************
952 * galsdma_set_mem_space - Set MV64360 IDMA memory decoding map.
953 *
954 * DESCRIPTION:
955 *       the MV64360 SDMA has its own address decoding map that is de-coupled
956 *       from the CPU interface address decoding windows. The SDMA channels
957 *       share four address windows. Each region can be individually configured
958 *       by this function by associating it to a target interface and setting
959 *       base and size values.
960 *
961 *      NOTE!!!
962 *       The size must be in 64Kbyte granularity.
963 *       The base address must be aligned to the size.
964 *       The size must be a series of 1s followed by a series of zeros
965 *
966 * OUTPUT:
967 *       None.
968 *
969 * RETURN:
970 *       True for success, false otherwise.
971 *
972 *******************************************************************************/
973
974 static int galsdma_set_mem_space (unsigned int memSpace,
975                                   unsigned int memSpaceTarget,
976                                   unsigned int memSpaceAttr,
977                                   unsigned int baseAddress, unsigned int size)
978 {
979         unsigned int temp;
980
981         if (size == 0) {
982                 GT_RESET_REG_BITS (MV64360_CUNIT_BASE_ADDR_ENABLE_REG,
983                                    1 << memSpace);
984                 return true;
985         }
986
987         /* The base address must be aligned to the size.  */
988         if (baseAddress % size != 0) {
989                 return false;
990         }
991         if (size < 0x10000) {
992                 return false;
993         }
994
995         /* Align size and base to 64K */
996         baseAddress &= 0xffff0000;
997         size &= 0xffff0000;
998         temp = size >> 16;
999
1000         /* Checking that the size is a sequence of '1' followed by a
1001            sequence of '0' starting from LSB to MSB. */
1002         while ((temp > 0) && (temp & 0x1)) {
1003                 temp = temp >> 1;
1004         }
1005
1006         if (temp != 0) {
1007                 GT_REG_WRITE (MV64360_CUNIT_BASE_ADDR_REG0 + memSpace * 8,
1008                               (baseAddress | memSpaceTarget | memSpaceAttr));
1009                 GT_REG_WRITE ((MV64360_CUNIT_SIZE0 + memSpace * 8),
1010                               (size - 1) & 0xffff0000);
1011                 GT_RESET_REG_BITS (MV64360_CUNIT_BASE_ADDR_ENABLE_REG,
1012                                    1 << memSpace);
1013         } else {
1014                 /* An invalid size was specified */
1015                 return false;
1016         }
1017         return true;
1018 }