osfmk/console/ppc/serial_console.c

   1 /*
   2  * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_COPYRIGHT@
  30  */
  31 /*
  32  * @APPLE_FREE_COPYRIGHT@
  33  */
  34
  35 #include <mach_kdb.h>
  36 #include <platforms.h>
  37 #include <serial_console_default.h>
  38
  39 #include <kern/spl.h>
  40 #include <machine/machparam.h>          /* spl definitions */
  41 #include <types.h>
  42 #include <console/video_console.h>
  43 #include <console/serial_protos.h>
  44 #include <kern/kalloc.h>
  45 #include <kern/thread.h>
  46 #include <ppc/misc_protos.h>
  47 #include <ppc/serial_io.h>
  48 #include <kern/cpu_number.h>
  49 #include <ppc/Firmware.h>
  50 #include <ppc/proc_reg.h>
  51 #include <ppc/cpu_internal.h>
  52 #include <ppc/exception.h>
  53 #include <pexpert/pexpert.h>
  54
  55 /*
  56  * A machine MUST have a console.  In our case
  57  * things are a little complicated by the graphic
  58  * display: people expect it to be their "console",
  59  * but we'd like to be able to live without it.
  60  * This is not to be confused with the "rconsole" thing:
  61  * that just duplicates the console I/O to
  62  * another place (for debugging/logging purposes).
  63  */
  64
  65 const int console_unit = 0;
  66 const uint32_t console_chan_default = CONSOLE_PORT;
  67 #define console_chan (console_chan_default) /* ^ cpu_number()) */
  68
  69 #define MP_SAFE_CONSOLE 1       /* Set this to 1 to allow more than 1 processor to print at once */
  70 #if MP_SAFE_CONSOLE
  71 struct ppcbfr {                                                                                                 /* Controls multiple processor output */
  72         unsigned int    pos;                                                                            /* Current position in buffer */
  73         unsigned int    noprompt;                                                                       /* Set if we skip the prompt */
  74         unsigned int    echo;                                                                           /* Control character echoing */
  75         char                    buffer[256];                                                            /* Fairly big buffer */
  76 };
  77 typedef struct ppcbfr ppcbfr_t;
  78
  79 ppcbfr_t cbfr_boot_cpu;                                                                                 /* Get one for boot cpu */
  80 volatile unsigned int cbfpend;                                                                  /* A buffer is pending output */
  81 volatile unsigned int sconowner=-1;                                                             /* Mark who's actually writing */
  82 #endif /* MP_SAFE_CONSOLE */
  83
  84 struct console_ops cons_ops[] = {
  85         {
  86                 .putc = scc_putc,
  87                 .getc = scc_getc,
  88         },
  89         {
  90                 .putc = vcputc,
  91                 .getc = vcgetc,
  92         },
  93 };
  94
  95 uint32_t nconsops = (sizeof cons_ops / sizeof cons_ops[0]);
  96
  97 uint32_t cons_ops_index = VC_CONS_OPS;
  98
  99 unsigned int killprint = 0;
 100 unsigned int debcnputc = 0;
 101 extern unsigned int     mappingdeb0;
 102 extern int debugger_cpu;
 103
 104 void *console_per_proc_alloc(boolean_t boot_processor)
 105 {
 106         ppcbfr_t  *cbfr_cpu;
 107
 108         if (boot_processor)
 109                 cbfr_cpu = &cbfr_boot_cpu;
 110         else {
 111                 cbfr_cpu = (ppcbfr_t *)kalloc(sizeof(ppcbfr_t));
 112                 if (cbfr_cpu == (ppcbfr_t *)NULL)
 113                         return (void *)NULL;
 114         }
 115         bzero((char *)cbfr_cpu, sizeof(ppcbfr_t));
 116         return (void *)cbfr_cpu;
 117 }
 118
 119 void console_per_proc_free(void *per_proc_cbfr)
 120 {
 121         if (per_proc_cbfr == (void *)&cbfr_boot_cpu)
 122                 return;
 123         else
 124                 kfree(per_proc_cbfr, sizeof(ppcbfr_t));
 125 }
 126
 127
 128 static void _cnputc(char c)
 129 {
 130         cons_ops[cons_ops_index].putc(console_unit, console_chan, c);
 131 }
 132
 133 void cnputcusr(char c) {                                                                                /* Echo input character directly */
 134         struct per_proc_info    *procinfo;
 135         spl_t                                   s;
 136
 137         s=splhigh();
 138         procinfo = getPerProc();
 139
 140         (void)hw_atomic_add(&(procinfo->debugger_holdoff), 1); /* Don't allow debugger entry just now (this is a HACK) */
 141
 142         _cnputc( c);                                                                                            /* Echo the character */
 143         if(c=='\n') _cnputc( '\r');                                                                     /* Add a return if we had a new line */
 144
 145         (void)hw_atomic_sub(&(procinfo->debugger_holdoff), 1); /* Don't allow debugger entry just now (this is a HACK) */
 146         splx(s);
 147         return;
 148 }
 149
 150 void
 151 cnputc(char c)
 152 {
 153         unsigned int                            oldpend, i, cpu, ourbit, sccpu;
 154         struct per_proc_info            *procinfo;
 155         ppcbfr_t                                        *cbfr, *cbfr_cpu;
 156         spl_t                                           s;
 157
 158 #if MP_SAFE_CONSOLE
 159
 160 /*
 161  *              Handle multiple CPU console output.
 162  *              Note: this thing has gotten god-awful complicated.  We need a better way.
 163  */
 164
 165
 166         if(killprint) {
 167                 return;                                                                                                 /* If printing is disabled, bail... */
 168         }
 169
 170         s=splhigh();                                                                                            /* Don't bother me */
 171         procinfo = getPerProc();
 172         cpu = procinfo->cpu_number;
 173         cbfr = procinfo->pp_cbfr;
 174
 175         (void)hw_atomic_add(&(procinfo->debugger_holdoff), 1); /* Don't allow debugger entry just now (this is a HACK) */
 176
 177         ourbit = 1 << cpu;                                                                                      /* Make a mask for just us */
 178         if(debugger_cpu != -1) {                                                                        /* Are we in the debugger with empty buffers? */
 179
 180                 while(sconowner != cpu) {                                                               /* Anyone but us? */
 181                         hw_compare_and_store(-1, cpu, &sconowner);      /* Try to mark it for us if idle */
 182                 }
 183
 184                 _cnputc( c);                                                                                    /* Yeah, just write it */
 185                 if(c=='\n')                                                                                             /* Did we just write a new line? */
 186                         _cnputc( '\r');                                                                         /* Yeah, just add a return */
 187
 188                 sconowner=-1;                                                                                   /* Mark it idle */
 189                 (void)hw_atomic_sub(&(procinfo->debugger_holdoff), 1); /* Don't allow debugger entry just now (this is a HACK) */
 190
 191                 splx(s);
 192                 return;                                                                                                 /* Leave... */
 193         }
 194
 195
 196         while(ourbit&cbfpend);                                                                          /* We aren't "double buffered," so we'll just wait until the buffers are written */
 197         isync();                                                                                                        /* Just in case we had to wait */
 198
 199         if(c) {                                                                                                         /* If the character is not null */
 200                 cbfr->buffer[cbfr->pos]=c;                                                      /* Fill in the buffer for our CPU */
 201                 cbfr->pos++;                                                                            /* Up the count */
 202                 if(cbfr->pos > 253) {                                                           /* Is the buffer full? */
 203                         cbfr->buffer[254]='\n';                                                 /* Yeah, set the second to last as a LF */
 204                         cbfr->buffer[255]='\r';                                                 /* And the last to a CR */
 205                         cbfr->pos=256;                                                                  /* Push the buffer to the end */
 206                         c='\r';                                                                                         /* Set character to a CR */
 207                 }
 208         }
 209
 210         if(c == '\n') {                                                                                         /* Are we finishing a line? */
 211                 cbfr->buffer[cbfr->pos]='\r';                                                   /* And the last to a CR */
 212                 cbfr->pos++;                                                                                    /* Up the count */
 213                 c='\r';                                                                                                 /* Set character to a CR */
 214         }
 215
 216 #if 1
 217         if(cbfr->echo == 1) {                                                                           /* Did we hit an escape last time? */
 218                 if(c == 'K') {                                                                                  /* Is it a partial clear? */
 219                         cbfr->echo = 2;                                                                         /* Yes, enter echo mode */
 220                 }
 221                 else cbfr->echo = 0;                                                                    /* Otherwise reset escape */
 222         }
 223         else if(cbfr->echo == 0) {                                                                      /* Not in escape sequence, see if we should enter */
 224                 cbfr->echo = 1;                                                                                 /* Set that we are in escape sequence */
 225         }
 226 #endif
 227
 228         if((c == 0x00) || (c == '\r') || (cbfr->echo == 2)) {           /* Try to push out all buffers if we see CR or null */
 229
 230                 while(1) {                                                                                              /* Loop until we see who's doing this */
 231                         oldpend=cbfpend;                                                                        /* Get the currentest pending buffer flags */
 232                         if(hw_compare_and_store(oldpend, oldpend|ourbit, &cbfpend))     /* Swap ours on if no change */
 233                                 break;                                                                                  /* Bail the loop if it worked */
 234                 }
 235
 236                 if(!hw_compare_and_store(-1, cpu, &sconowner)) {        /* See if someone else has this, and take it if not */
 237                         procinfo->debugger_holdoff = 0;                                         /* Allow debugger entry (this is a HACK) */
 238                         splx(s);                                                                                        /* Let's take some 'rupts now */
 239                         return;                                                                                         /* We leave here, 'cause another processor is already writing the buffers */
 240                 }
 241
 242                 while(1) {                                                                                              /* Loop to dump out all of the finished buffers */
 243                         oldpend=cbfpend;                                                                        /* Get the most current finished buffers */
 244                         for(sccpu=0; sccpu<real_ncpus; sccpu++) {                               /* Cycle through all CPUs buffers */
 245                                 if ((PerProcTable[sccpu].ppe_vaddr == 0)
 246                                     || (PerProcTable[sccpu].ppe_vaddr->pp_cbfr == 0))
 247                                         continue;
 248
 249                                 cbfr_cpu = PerProcTable[sccpu].ppe_vaddr->pp_cbfr;
 250
 251                                 if(oldpend&(1<<sccpu)) {                                                /* Does this guy have a buffer to do? */
 252
 253 #if 0
 254                                         if(!cbfr_cpu->noprompt) {                                       /* Don't prompt if there was not CR before */
 255                                                 _cnputc( '{');  /* Mark CPU number */
 256                                                 _cnputc( '0'+sccpu);    /* Mark CPU number */
 257                                                 _cnputc( '.');  /* (TEST/DEBUG) */
 258                                                 _cnputc( '0'+cpu);      /* (TEST/DEBUG) */
 259                                                 _cnputc( '}');  /* Mark CPU number */
 260                                                 _cnputc( ' ');  /* Mark CPU number */
 261                                         }
 262 #endif
 263
 264                                         for(i=0; i<cbfr_cpu->pos; i++) {                                /* Do the whole buffer */
 265                                                 _cnputc(cbfr_cpu->buffer[i]);                           /* Write it */
 266                                         }
 267
 268                                         if(cbfr_cpu->buffer[cbfr_cpu->pos-1]!='\r') {   /* Was the last character a return? */
 269                                                 cbfr_cpu->noprompt = 1;                                         /* Remember not to prompt */
 270                                         }
 271                                         else {                                                                                  /* Last was a return */
 272                                                 cbfr_cpu->noprompt = 0;                                         /* Otherwise remember to prompt */
 273                                                 cbfr_cpu->echo = 0;                                                     /* And clear echo */
 274                                         }
 275
 276                                         cbfr_cpu->pos=0;                                                                /* Reset the buffer pointer */
 277
 278                                         while(!hw_compare_and_store(cbfpend, cbfpend&~(1<<sccpu), &cbfpend));   /* Swap it off */
 279                                 }
 280                         }
 281                         sconowner=-1;                                                                           /* Set the writer to idle */
 282                         sync();                                                                                         /* Insure that everything's done */
 283                         if(hw_compare_and_store(0, 0, &cbfpend)) break; /* If there are no new buffers, we are done... */
 284                         if(!hw_compare_and_store(-1, cpu, &sconowner)) break;   /* If this isn't idle anymore, we're done */
 285
 286                 }
 287         }
 288         (void)hw_atomic_sub(&(procinfo->debugger_holdoff), 1); /* Don't allow debugger entry just now (this is a HACK) */
 289         splx(s);                                                                                                        /* Let's take some 'rupts now */
 290
 291 #else  /* MP_SAFE_CONSOLE */
 292         _cnputc( c);
 293         if (c == '\n')
 294                 _cnputc('\r');
 295 #endif  /* MP_SAFE_CONSOLE */
 296
 297 }
 298
 299 int
 300 cngetc(void)
 301 {
 302         return cons_ops[cons_ops_index].getc(console_unit, console_chan,
 303                                              TRUE, FALSE);
 304 }
 305
 306 int
 307 cnmaygetc(void)
 308 {
 309         return cons_ops[cons_ops_index].getc(console_unit, console_chan,
 310                                              FALSE, FALSE);
 311 }
 312
 313
 314 int
 315 vcgetc(__unused int l,
 316        __unused int u,
 317        __unused boolean_t wait,
 318        __unused boolean_t raw)
 319 {
 320         char c;
 321
 322         if( 0 == (*PE_poll_input)( 0, &c))
 323                 return( c);
 324         else
 325                 return( 0);
 326 }