Merge branch 'devel' of master.kernel.org:/home/rmk/linux-2.6-serial
[linux-2.6] / arch / m68k / mac / debug.c
1 /*
2  * linux/arch/m68k/mac/debug.c
3  *
4  * Shamelessly stolen (SCC code and general framework) from:
5  *
6  * linux/arch/m68k/atari/debug.c
7  *
8  * Atari debugging and serial console stuff
9  *
10  * Assembled of parts of former atari/config.c 97-12-18 by Roman Hodek
11  *
12  * This file is subject to the terms and conditions of the GNU General Public
13  * License.  See the file COPYING in the main directory of this archive
14  * for more details.
15  */
16
17 #include <linux/types.h>
18 #include <linux/sched.h>
19 #include <linux/tty.h>
20 #include <linux/console.h>
21 #include <linux/init.h>
22 #include <linux/delay.h>
23
24 #define BOOTINFO_COMPAT_1_0
25 #include <asm/setup.h>
26 #include <asm/bootinfo.h>
27 #include <asm/machw.h>
28 #include <asm/macints.h>
29
30 extern char m68k_debug_device[];
31
32 extern struct compat_bootinfo compat_boot_info;
33
34 extern unsigned long mac_videobase;
35 extern unsigned long mac_videodepth;
36 extern unsigned long mac_rowbytes;
37
38 extern void mac_serial_print(const char *);
39
40 #define DEBUG_HEADS
41 #undef DEBUG_SCREEN
42 #define DEBUG_SERIAL
43
44 /*
45  * These two auxiliary debug functions should go away ASAP. Only usage:
46  * before the console output is up (after head.S come some other crucial
47  * setup routines :-) it permits writing 'data' to the screen as bit patterns
48  * (good luck reading those). Helped to figure that the bootinfo contained
49  * garbage data on the amount and size of memory chunks ...
50  *
51  * The 'pos' argument now simply means 'linefeed after print' ...
52  */
53
54 #ifdef DEBUG_SCREEN
55 static int peng=0, line=0;
56 #endif
57
58 void mac_debugging_short(int pos, short num)
59 {
60 #ifdef DEBUG_SCREEN
61         unsigned char *pengoffset;
62         unsigned char *pptr;
63         int i;
64 #endif
65
66 #ifdef DEBUG_SERIAL
67         printk("debug: %d !\n", num);
68 #endif
69
70 #ifdef DEBUG_SCREEN
71         if (!MACH_IS_MAC) {
72                 /* printk("debug: %d !\n", num); */
73                 return;
74         }
75
76         /* calculate current offset */
77         pengoffset=(unsigned char *)(mac_videobase+(150+line*2)*mac_rowbytes)
78                     +80*peng;
79
80         pptr=pengoffset;
81
82         for(i=0;i<8*sizeof(short);i++) /* # of bits */
83         {
84                 /*        value        mask for bit i, reverse order */
85                 *pptr++ = (num & ( 1 << (8*sizeof(short)-i-1) ) ? 0xFF : 0x00);
86         }
87
88         peng++;
89
90         if (pos) {
91                 line++;
92                 peng = 0;
93         }
94 #endif
95 }
96
97 void mac_debugging_long(int pos, long addr)
98 {
99 #ifdef DEBUG_SCREEN
100         unsigned char *pengoffset;
101         unsigned char *pptr;
102         int i;
103 #endif
104
105 #ifdef DEBUG_SERIAL
106         printk("debug: #%ld !\n", addr);
107 #endif
108
109 #ifdef DEBUG_SCREEN
110         if (!MACH_IS_MAC) {
111                 /* printk("debug: #%ld !\n", addr); */
112                 return;
113         }
114
115         pengoffset=(unsigned char *)(mac_videobase+(150+line*2)*mac_rowbytes)
116                     +80*peng;
117
118         pptr=pengoffset;
119
120         for(i=0;i<8*sizeof(long);i++) /* # of bits */
121         {
122                 *pptr++ = (addr & ( 1 << (8*sizeof(long)-i-1) ) ? 0xFF : 0x00);
123         }
124
125         peng++;
126
127         if (pos) {
128                 line++;
129                 peng = 0;
130         }
131 #endif
132 }
133
134 #ifdef DEBUG_SERIAL
135 /*
136  * TODO: serial debug code
137  */
138
139 struct mac_SCC
140  {
141   u_char cha_b_ctrl;
142   u_char char_dummy1;
143   u_char cha_a_ctrl;
144   u_char char_dummy2;
145   u_char cha_b_data;
146   u_char char_dummy3;
147   u_char cha_a_data;
148  };
149
150 # define scc (*((volatile struct mac_SCC*)mac_bi_data.sccbase))
151
152 /* Flag that serial port is already initialized and used */
153 int mac_SCC_init_done;
154 /* Can be set somewhere, if a SCC master reset has already be done and should
155  * not be repeated; used by kgdb */
156 int mac_SCC_reset_done;
157
158 static int scc_port = -1;
159
160 static struct console mac_console_driver = {
161         .name =         "debug",
162         .flags =        CON_PRINTBUFFER,
163         .index =        -1,
164 };
165
166 /*
167  * Crude hack to get console output to the screen before the framebuffer
168  * is initialized (happens a lot later in 2.1!).
169  * We just use the console routines declared in head.S, this will interfere
170  * with regular framebuffer console output and should be used exclusively
171  * to debug kernel problems manifesting before framebuffer init (aka WSOD)
172  *
173  * To keep this hack from interfering with the regular console driver, either
174  * deregister this driver before/on framebuffer console init, or silence this
175  * function after the fbcon driver is running (will lose console messages!?).
176  * To debug real early bugs, need to write a 'mac_register_console_hack()'
177  * that is called from start_kernel() before setup_arch() and just registers
178  * this driver if Mac.
179  */
180
181 void mac_debug_console_write (struct console *co, const char *str,
182                               unsigned int count)
183 {
184         mac_serial_print(str);
185 }
186
187
188
189 /* Mac: loops_per_jiffy min. 19000 ^= .5 us; MFPDELAY was 0.6 us*/
190
191 #define uSEC 1
192
193 static inline void mac_sccb_out (char c)
194 {
195     int i;
196     do {
197         for( i = uSEC; i > 0; --i )
198                 barrier();
199     } while (!(scc.cha_b_ctrl & 0x04)); /* wait for tx buf empty */
200     for( i = uSEC; i > 0; --i )
201         barrier();
202     scc.cha_b_data = c;
203 }
204
205 static inline void mac_scca_out (char c)
206 {
207     int i;
208     do {
209         for( i = uSEC; i > 0; --i )
210                 barrier();
211     } while (!(scc.cha_a_ctrl & 0x04)); /* wait for tx buf empty */
212     for( i = uSEC; i > 0; --i )
213         barrier();
214     scc.cha_a_data = c;
215 }
216
217 void mac_sccb_console_write (struct console *co, const char *str,
218                               unsigned int count)
219 {
220     while (count--) {
221         if (*str == '\n')
222             mac_sccb_out( '\r' );
223         mac_sccb_out( *str++ );
224     }
225 }
226
227 void mac_scca_console_write (struct console *co, const char *str,
228                               unsigned int count)
229 {
230     while (count--) {
231         if (*str == '\n')
232             mac_scca_out( '\r' );
233         mac_scca_out( *str++ );
234     }
235 }
236
237
238 /* The following two functions do a quick'n'dirty initialization of the MFP or
239  * SCC serial ports. They're used by the debugging interface, kgdb, and the
240  * serial console code. */
241 #define SCCB_WRITE(reg,val)                             \
242     do {                                                \
243         int i;                                          \
244         scc.cha_b_ctrl = (reg);                         \
245         for( i = uSEC; i > 0; --i )                     \
246                 barrier();                              \
247         scc.cha_b_ctrl = (val);                         \
248         for( i = uSEC; i > 0; --i )                     \
249                 barrier();                              \
250     } while(0)
251
252 #define SCCA_WRITE(reg,val)                             \
253     do {                                                \
254         int i;                                          \
255         scc.cha_a_ctrl = (reg);                         \
256         for( i = uSEC; i > 0; --i )                     \
257                 barrier();                              \
258         scc.cha_a_ctrl = (val);                         \
259         for( i = uSEC; i > 0; --i )                     \
260                 barrier();                              \
261     } while(0)
262
263 /* loops_per_jiffy isn't initialized yet, so we can't use udelay(). This does a
264  * delay of ~ 60us. */
265 /* Mac: loops_per_jiffy min. 19000 ^= .5 us; MFPDELAY was 0.6 us*/
266 #define LONG_DELAY()                            \
267     do {                                        \
268         int i;                                  \
269         for( i = 60*uSEC; i > 0; --i )          \
270             barrier();                          \
271     } while(0)
272
273 #ifndef CONFIG_SERIAL_CONSOLE
274 static void __init mac_init_scc_port( int cflag, int port )
275 #else
276 void mac_init_scc_port( int cflag, int port )
277 #endif
278 {
279         extern int mac_SCC_reset_done;
280
281         /*
282          * baud rates: 1200, 1800, 2400, 4800, 9600, 19.2k, 38.4k, 57.6k, 115.2k
283          */
284
285         static int clksrc_table[9] =
286                 /* reg 11: 0x50 = BRG, 0x00 = RTxC, 0x28 = TRxC */
287                 { 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x00, 0x00 };
288         static int clkmode_table[9] =
289                 /* reg 4: 0x40 = x16, 0x80 = x32, 0xc0 = x64 */
290                 { 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0xc0, 0x80 };
291         static int div_table[9] =
292                 /* reg12 (BRG low) */
293                 { 94, 62, 46, 22, 10, 4, 1, 0, 0 };
294
295     int baud = cflag & CBAUD;
296     int clksrc, clkmode, div, reg3, reg5;
297
298     if (cflag & CBAUDEX)
299         baud += B38400;
300     if (baud < B1200 || baud > B38400+2)
301         baud = B9600; /* use default 9600bps for non-implemented rates */
302     baud -= B1200; /* tables starts at 1200bps */
303
304     clksrc  = clksrc_table[baud];
305     clkmode = clkmode_table[baud];
306     div     = div_table[baud];
307
308     reg3 = (((cflag & CSIZE) == CS8) ? 0xc0 : 0x40);
309     reg5 = (((cflag & CSIZE) == CS8) ? 0x60 : 0x20) | 0x82 /* assert DTR/RTS */;
310
311     if (port == 1) {
312             (void)scc.cha_b_ctrl;       /* reset reg pointer */
313             SCCB_WRITE( 9, 0xc0 );      /* reset */
314             LONG_DELAY();               /* extra delay after WR9 access */
315             SCCB_WRITE( 4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) : 0 |
316                           0x04 /* 1 stopbit */ |
317                           clkmode );
318             SCCB_WRITE( 3, reg3 );
319             SCCB_WRITE( 5, reg5 );
320             SCCB_WRITE( 9, 0 );         /* no interrupts */
321             LONG_DELAY();               /* extra delay after WR9 access */
322             SCCB_WRITE( 10, 0 );        /* NRZ mode */
323             SCCB_WRITE( 11, clksrc );   /* main clock source */
324             SCCB_WRITE( 12, div );      /* BRG value */
325             SCCB_WRITE( 13, 0 );                /* BRG high byte */
326             SCCB_WRITE( 14, 1 );
327             SCCB_WRITE( 3, reg3 | 1 );
328             SCCB_WRITE( 5, reg5 | 8 );
329     } else if (port == 0) {
330             (void)scc.cha_a_ctrl;       /* reset reg pointer */
331             SCCA_WRITE( 9, 0xc0 );      /* reset */
332             LONG_DELAY();               /* extra delay after WR9 access */
333             SCCA_WRITE( 4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) : 0 |
334                           0x04 /* 1 stopbit */ |
335                           clkmode );
336             SCCA_WRITE( 3, reg3 );
337             SCCA_WRITE( 5, reg5 );
338             SCCA_WRITE( 9, 0 );         /* no interrupts */
339             LONG_DELAY();               /* extra delay after WR9 access */
340             SCCA_WRITE( 10, 0 );        /* NRZ mode */
341             SCCA_WRITE( 11, clksrc );   /* main clock source */
342             SCCA_WRITE( 12, div );      /* BRG value */
343             SCCA_WRITE( 13, 0 );                /* BRG high byte */
344             SCCA_WRITE( 14, 1 );
345             SCCA_WRITE( 3, reg3 | 1 );
346             SCCA_WRITE( 5, reg5 | 8 );
347     }
348
349     mac_SCC_reset_done = 1;
350     mac_SCC_init_done = 1;
351 }
352 #endif /* DEBUG_SERIAL */
353
354 void mac_init_scca_port( int cflag )
355 {
356         mac_init_scc_port(cflag, 0);
357 }
358
359 void mac_init_sccb_port( int cflag )
360 {
361         mac_init_scc_port(cflag, 1);
362 }
363
364 void __init mac_debug_init(void)
365 {
366 #ifdef DEBUG_SERIAL
367     if (   !strcmp( m68k_debug_device, "ser"  )
368         || !strcmp( m68k_debug_device, "ser1" )) {
369         /* Mac modem port */
370         mac_init_scc_port( B9600|CS8, 0 );
371         mac_console_driver.write = mac_scca_console_write;
372         scc_port = 0;
373     }
374     else if (!strcmp( m68k_debug_device, "ser2" )) {
375         /* Mac printer port */
376         mac_init_scc_port( B9600|CS8, 1 );
377         mac_console_driver.write = mac_sccb_console_write;
378         scc_port = 1;
379     }
380 #endif
381 #ifdef DEBUG_HEADS
382     if (   !strcmp( m68k_debug_device, "scn"  )
383         || !strcmp( m68k_debug_device, "con" )) {
384         /* display, using head.S console routines */
385         mac_console_driver.write = mac_debug_console_write;
386     }
387 #endif
388     if (mac_console_driver.write)
389         register_console(&mac_console_driver);
390 }
391
392 /*
393  * Local variables:
394  *  c-indent-level: 4
395  *  tab-width: 8
396  * End:
397  */