arch/powerpc/cpu/mpc8xx/serial.c

   1 /*
   2  * (C) Copyright 2000
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <commproc.h>
  10 #include <command.h>
  11 #include <serial.h>
  12 #include <watchdog.h>
  13 #include <linux/compiler.h>
  14
  15 DECLARE_GLOBAL_DATA_PTR;
  16
  17 #if !defined(CONFIG_8xx_CONS_NONE)      /* No Console at all */
  18
  19 #if defined(CONFIG_8xx_CONS_SMC1)       /* Console on SMC1 */
  20 #define SMC_INDEX       0
  21 #define PROFF_SMC       PROFF_SMC1
  22 #define CPM_CR_CH_SMC   CPM_CR_CH_SMC1
  23
  24 #elif defined(CONFIG_8xx_CONS_SMC2)     /* Console on SMC2 */
  25 #define SMC_INDEX       1
  26 #define PROFF_SMC       PROFF_SMC2
  27 #define CPM_CR_CH_SMC   CPM_CR_CH_SMC2
  28
  29 #endif /* CONFIG_8xx_CONS_SMCx */
  30
  31 #if defined(CONFIG_8xx_CONS_SCC1)       /* Console on SCC1 */
  32 #define SCC_INDEX       0
  33 #define PROFF_SCC       PROFF_SCC1
  34 #define CPM_CR_CH_SCC   CPM_CR_CH_SCC1
  35
  36 #elif defined(CONFIG_8xx_CONS_SCC2)     /* Console on SCC2 */
  37 #define SCC_INDEX       1
  38 #define PROFF_SCC       PROFF_SCC2
  39 #define CPM_CR_CH_SCC   CPM_CR_CH_SCC2
  40
  41 #elif defined(CONFIG_8xx_CONS_SCC3)     /* Console on SCC3 */
  42 #define SCC_INDEX       2
  43 #define PROFF_SCC       PROFF_SCC3
  44 #define CPM_CR_CH_SCC   CPM_CR_CH_SCC3
  45
  46 #elif defined(CONFIG_8xx_CONS_SCC4)     /* Console on SCC4 */
  47 #define SCC_INDEX       3
  48 #define PROFF_SCC       PROFF_SCC4
  49 #define CPM_CR_CH_SCC   CPM_CR_CH_SCC4
  50
  51 #endif /* CONFIG_8xx_CONS_SCCx */
  52
  53 #if !defined(CONFIG_SYS_SMC_RXBUFLEN)
  54 #define CONFIG_SYS_SMC_RXBUFLEN 1
  55 #define CONFIG_SYS_MAXIDLE      0
  56 #else
  57 #if !defined(CONFIG_SYS_MAXIDLE)
  58 #error "you must define CONFIG_SYS_MAXIDLE"
  59 #endif
  60 #endif
  61
  62 typedef volatile struct serialbuffer {
  63         cbd_t   rxbd;           /* Rx BD */
  64         cbd_t   txbd;           /* Tx BD */
  65         uint    rxindex;        /* index for next character to read */
  66         volatile uchar  rxbuf[CONFIG_SYS_SMC_RXBUFLEN];/* rx buffers */
  67         volatile uchar  txbuf;  /* tx buffers */
  68 } serialbuffer_t;
  69
  70 static void serial_setdivisor(volatile cpm8xx_t *cp)
  71 {
  72         int divisor=(gd->cpu_clk + 8*gd->baudrate)/16/gd->baudrate;
  73
  74         if(divisor/16>0x1000) {
  75                 /* bad divisor, assume 50MHz clock and 9600 baud */
  76                 divisor=(50*1000*1000 + 8*9600)/16/9600;
  77         }
  78
  79 #ifdef CONFIG_SYS_BRGCLK_PRESCALE
  80         divisor /= CONFIG_SYS_BRGCLK_PRESCALE;
  81 #endif
  82
  83         if(divisor<=0x1000) {
  84                 cp->cp_brgc1=((divisor-1)<<1) | CPM_BRG_EN;
  85         } else {
  86                 cp->cp_brgc1=((divisor/16-1)<<1) | CPM_BRG_EN | CPM_BRG_DIV16;
  87         }
  88 }
  89
  90 #if (defined (CONFIG_8xx_CONS_SMC1) || defined (CONFIG_8xx_CONS_SMC2))
  91
  92 /*
  93  * Minimal serial functions needed to use one of the SMC ports
  94  * as serial console interface.
  95  */
  96
  97 static void smc_setbrg (void)
  98 {
  99         volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
 100         volatile cpm8xx_t *cp = &(im->im_cpm);
 101
 102         /* Set up the baud rate generator.
 103          * See 8xx_io/commproc.c for details.
 104          *
 105          * Wire BRG1 to SMCx
 106          */
 107
 108         cp->cp_simode = 0x00000000;
 109
 110         serial_setdivisor(cp);
 111 }
 112
 113 static int smc_init (void)
 114 {
 115         volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
 116         volatile smc_t *sp;
 117         volatile smc_uart_t *up;
 118         volatile cpm8xx_t *cp = &(im->im_cpm);
 119 #if (!defined(CONFIG_8xx_CONS_SMC1)) && (defined(CONFIG_MPC823) || defined(CONFIG_MPC850))
 120         volatile iop8xx_t *ip = (iop8xx_t *)&(im->im_ioport);
 121 #endif
 122         uint    dpaddr;
 123         volatile serialbuffer_t *rtx;
 124
 125         /* initialize pointers to SMC */
 126
 127         sp = (smc_t *) &(cp->cp_smc[SMC_INDEX]);
 128         up = (smc_uart_t *) &cp->cp_dparam[PROFF_SMC];
 129 #ifdef CONFIG_SYS_SMC_UCODE_PATCH
 130         up = (smc_uart_t *) &cp->cp_dpmem[up->smc_rpbase];
 131 #else
 132         /* Disable relocation */
 133         up->smc_rpbase = 0;
 134 #endif
 135
 136         /* Disable transmitter/receiver. */
 137         sp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
 138
 139         /* Enable SDMA. */
 140         im->im_siu_conf.sc_sdcr = 1;
 141
 142         /* clear error conditions */
 143 #ifdef  CONFIG_SYS_SDSR
 144         im->im_sdma.sdma_sdsr = CONFIG_SYS_SDSR;
 145 #else
 146         im->im_sdma.sdma_sdsr = 0x83;
 147 #endif
 148
 149         /* clear SDMA interrupt mask */
 150 #ifdef  CONFIG_SYS_SDMR
 151         im->im_sdma.sdma_sdmr = CONFIG_SYS_SDMR;
 152 #else
 153         im->im_sdma.sdma_sdmr = 0x00;
 154 #endif
 155
 156 #if defined(CONFIG_8xx_CONS_SMC1)
 157         /* Use Port B for SMC1 instead of other functions. */
 158         cp->cp_pbpar |=  0x000000c0;
 159         cp->cp_pbdir &= ~0x000000c0;
 160         cp->cp_pbodr &= ~0x000000c0;
 161 #else   /* CONFIG_8xx_CONS_SMC2 */
 162 # if defined(CONFIG_MPC823) || defined(CONFIG_MPC850)
 163         /* Use Port A for SMC2 instead of other functions. */
 164         ip->iop_papar |=  0x00c0;
 165         ip->iop_padir &= ~0x00c0;
 166         ip->iop_paodr &= ~0x00c0;
 167 # else  /* must be a 860 then */
 168         /* Use Port B for SMC2 instead of other functions.
 169          */
 170         cp->cp_pbpar |=  0x00000c00;
 171         cp->cp_pbdir &= ~0x00000c00;
 172         cp->cp_pbodr &= ~0x00000c00;
 173 # endif
 174 #endif
 175
 176 #if defined(CONFIG_FADS) || defined(CONFIG_ADS)
 177         /* Enable RS232 */
 178 #if defined(CONFIG_8xx_CONS_SMC1)
 179         *((uint *) BCSR1) &= ~BCSR1_RS232EN_1;
 180 #else
 181         *((uint *) BCSR1) &= ~BCSR1_RS232EN_2;
 182 #endif
 183 #endif  /* CONFIG_FADS */
 184
 185 #if defined(CONFIG_RPXLITE) || defined(CONFIG_RPXCLASSIC)
 186         /* Enable Monitor Port Transceiver */
 187         *((uchar *) BCSR0) |= BCSR0_ENMONXCVR ;
 188 #endif /* CONFIG_RPXLITE */
 189
 190         /* Set the physical address of the host memory buffers in
 191          * the buffer descriptors.
 192          */
 193
 194 #ifdef CONFIG_SYS_ALLOC_DPRAM
 195         /* allocate
 196          * size of struct serialbuffer with bd rx/tx, buffer rx/tx and rx index
 197          */
 198         dpaddr = dpram_alloc_align((sizeof(serialbuffer_t)), 8);
 199 #else
 200         dpaddr = CPM_SERIAL_BASE ;
 201 #endif
 202
 203         rtx = (serialbuffer_t *)&cp->cp_dpmem[dpaddr];
 204         /* Allocate space for two buffer descriptors in the DP ram.
 205          * For now, this address seems OK, but it may have to
 206          * change with newer versions of the firmware.
 207          * damm: allocating space after the two buffers for rx/tx data
 208          */
 209
 210         rtx->rxbd.cbd_bufaddr = (uint) &rtx->rxbuf;
 211         rtx->rxbd.cbd_sc      = 0;
 212
 213         rtx->txbd.cbd_bufaddr = (uint) &rtx->txbuf;
 214         rtx->txbd.cbd_sc      = 0;
 215
 216         /* Set up the uart parameters in the parameter ram. */
 217         up->smc_rbase = dpaddr;
 218         up->smc_tbase = dpaddr+sizeof(cbd_t);
 219         up->smc_rfcr = SMC_EB;
 220         up->smc_tfcr = SMC_EB;
 221 #if defined (CONFIG_SYS_SMC_UCODE_PATCH)
 222         up->smc_rbptr = up->smc_rbase;
 223         up->smc_tbptr = up->smc_tbase;
 224         up->smc_rstate = 0;
 225         up->smc_tstate = 0;
 226 #endif
 227
 228 #if defined(CONFIG_MBX)
 229         board_serial_init();
 230 #endif  /* CONFIG_MBX */
 231
 232         /* Set UART mode, 8 bit, no parity, one stop.
 233          * Enable receive and transmit.
 234          */
 235         sp->smc_smcmr = smcr_mk_clen(9) |  SMCMR_SM_UART;
 236
 237         /* Mask all interrupts and remove anything pending.
 238         */
 239         sp->smc_smcm = 0;
 240         sp->smc_smce = 0xff;
 241
 242 #ifdef CONFIG_SYS_SPC1920_SMC1_CLK4
 243         /* clock source is PLD */
 244
 245         /* set freq to 19200 Baud */
 246         *((volatile uchar *) CONFIG_SYS_SPC1920_PLD_BASE+6) = 0x3;
 247         /* configure clk4 as input */
 248         im->im_ioport.iop_pdpar |= 0x800;
 249         im->im_ioport.iop_pddir &= ~0x800;
 250
 251         cp->cp_simode = ((cp->cp_simode & ~0xf000) | 0x7000);
 252 #else
 253         /* Set up the baud rate generator */
 254         smc_setbrg ();
 255 #endif
 256
 257         /* Make the first buffer the only buffer. */
 258         rtx->txbd.cbd_sc |= BD_SC_WRAP;
 259         rtx->rxbd.cbd_sc |= BD_SC_EMPTY | BD_SC_WRAP;
 260
 261         /* single/multi character receive. */
 262         up->smc_mrblr = CONFIG_SYS_SMC_RXBUFLEN;
 263         up->smc_maxidl = CONFIG_SYS_MAXIDLE;
 264         rtx->rxindex = 0;
 265
 266         /* Initialize Tx/Rx parameters. */
 267         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 268           ;
 269
 270         cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC, CPM_CR_INIT_TRX) | CPM_CR_FLG;
 271
 272         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 273           ;
 274
 275         /* Enable transmitter/receiver. */
 276         sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
 277
 278         return (0);
 279 }
 280
 281 static void
 282 smc_putc(const char c)
 283 {
 284         volatile smc_uart_t     *up;
 285         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 286         volatile cpm8xx_t       *cpmp = &(im->im_cpm);
 287         volatile serialbuffer_t *rtx;
 288
 289 #ifdef CONFIG_MODEM_SUPPORT
 290         if (gd->be_quiet)
 291                 return;
 292 #endif
 293
 294         if (c == '\n')
 295                 smc_putc ('\r');
 296
 297         up = (smc_uart_t *)&cpmp->cp_dparam[PROFF_SMC];
 298 #ifdef CONFIG_SYS_SMC_UCODE_PATCH
 299         up = (smc_uart_t *) &cpmp->cp_dpmem[up->smc_rpbase];
 300 #endif
 301
 302         rtx = (serialbuffer_t *)&cpmp->cp_dpmem[up->smc_rbase];
 303
 304         /* Wait for last character to go. */
 305         rtx->txbuf = c;
 306         rtx->txbd.cbd_datlen = 1;
 307         rtx->txbd.cbd_sc |= BD_SC_READY;
 308         __asm__("eieio");
 309
 310         while (rtx->txbd.cbd_sc & BD_SC_READY) {
 311                 WATCHDOG_RESET ();
 312                 __asm__("eieio");
 313         }
 314 }
 315
 316 static void
 317 smc_puts (const char *s)
 318 {
 319         while (*s) {
 320                 smc_putc (*s++);
 321         }
 322 }
 323
 324 static int
 325 smc_getc(void)
 326 {
 327         volatile smc_uart_t     *up;
 328         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 329         volatile cpm8xx_t       *cpmp = &(im->im_cpm);
 330         volatile serialbuffer_t *rtx;
 331         unsigned char  c;
 332
 333         up = (smc_uart_t *)&cpmp->cp_dparam[PROFF_SMC];
 334 #ifdef CONFIG_SYS_SMC_UCODE_PATCH
 335         up = (smc_uart_t *) &cpmp->cp_dpmem[up->smc_rpbase];
 336 #endif
 337         rtx = (serialbuffer_t *)&cpmp->cp_dpmem[up->smc_rbase];
 338
 339         /* Wait for character to show up. */
 340         while (rtx->rxbd.cbd_sc & BD_SC_EMPTY)
 341                 WATCHDOG_RESET ();
 342
 343         /* the characters are read one by one,
 344          * use the rxindex to know the next char to deliver
 345          */
 346         c = *(unsigned char *) (rtx->rxbd.cbd_bufaddr+rtx->rxindex);
 347         rtx->rxindex++;
 348
 349         /* check if all char are readout, then make prepare for next receive */
 350         if (rtx->rxindex >= rtx->rxbd.cbd_datlen) {
 351                 rtx->rxindex = 0;
 352                 rtx->rxbd.cbd_sc |= BD_SC_EMPTY;
 353         }
 354         return(c);
 355 }
 356
 357 static int
 358 smc_tstc(void)
 359 {
 360         volatile smc_uart_t     *up;
 361         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 362         volatile cpm8xx_t       *cpmp = &(im->im_cpm);
 363         volatile serialbuffer_t *rtx;
 364
 365         up = (smc_uart_t *)&cpmp->cp_dparam[PROFF_SMC];
 366 #ifdef CONFIG_SYS_SMC_UCODE_PATCH
 367         up = (smc_uart_t *) &cpmp->cp_dpmem[up->smc_rpbase];
 368 #endif
 369
 370         rtx = (serialbuffer_t *)&cpmp->cp_dpmem[up->smc_rbase];
 371
 372         return !(rtx->rxbd.cbd_sc & BD_SC_EMPTY);
 373 }
 374
 375 struct serial_device serial_smc_device =
 376 {
 377         .name   = "serial_smc",
 378         .start  = smc_init,
 379         .stop   = NULL,
 380         .setbrg = smc_setbrg,
 381         .getc   = smc_getc,
 382         .tstc   = smc_tstc,
 383         .putc   = smc_putc,
 384         .puts   = smc_puts,
 385 };
 386
 387 #endif /* CONFIG_8xx_CONS_SMC1 || CONFIG_8xx_CONS_SMC2 */
 388
 389 #if defined(CONFIG_8xx_CONS_SCC1) || defined(CONFIG_8xx_CONS_SCC2) || \
 390     defined(CONFIG_8xx_CONS_SCC3) || defined(CONFIG_8xx_CONS_SCC4)
 391
 392 static void
 393 scc_setbrg (void)
 394 {
 395         volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
 396         volatile cpm8xx_t *cp = &(im->im_cpm);
 397
 398         /* Set up the baud rate generator.
 399          * See 8xx_io/commproc.c for details.
 400          *
 401          * Wire BRG1 to SCCx
 402          */
 403
 404         cp->cp_sicr &= ~(0x000000FF << (8 * SCC_INDEX));
 405
 406         serial_setdivisor(cp);
 407 }
 408
 409 static int scc_init (void)
 410 {
 411         volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
 412         volatile scc_t *sp;
 413         volatile scc_uart_t *up;
 414         volatile cbd_t *tbdf, *rbdf;
 415         volatile cpm8xx_t *cp = &(im->im_cpm);
 416         uint     dpaddr;
 417 #if (SCC_INDEX != 2) || !defined(CONFIG_MPC850)
 418         volatile iop8xx_t *ip = (iop8xx_t *)&(im->im_ioport);
 419 #endif
 420
 421         /* initialize pointers to SCC */
 422
 423         sp = (scc_t *) &(cp->cp_scc[SCC_INDEX]);
 424         up = (scc_uart_t *) &cp->cp_dparam[PROFF_SCC];
 425
 426 #if defined(CONFIG_LWMON) && defined(CONFIG_8xx_CONS_SCC2)
 427     {   /* Disable Ethernet, enable Serial */
 428         uchar c;
 429
 430         c = pic_read  (0x61);
 431         c &= ~0x40;     /* enable COM3 */
 432         c |=  0x80;     /* disable Ethernet */
 433         pic_write (0x61, c);
 434
 435         /* enable RTS2 */
 436         cp->cp_pbpar |=  0x2000;
 437         cp->cp_pbdat |=  0x2000;
 438         cp->cp_pbdir |=  0x2000;
 439     }
 440 #endif  /* CONFIG_LWMON */
 441
 442         /* Disable transmitter/receiver. */
 443         sp->scc_gsmrl &= ~(SCC_GSMRL_ENR | SCC_GSMRL_ENT);
 444
 445 #if (SCC_INDEX == 2) && defined(CONFIG_MPC850)
 446         /*
 447          * The MPC850 has SCC3 on Port B
 448          */
 449         cp->cp_pbpar |=  0x06;
 450         cp->cp_pbdir &= ~0x06;
 451         cp->cp_pbodr &= ~0x06;
 452
 453 #elif (SCC_INDEX < 2) || !defined(CONFIG_IP860)
 454         /*
 455          * Standard configuration for SCC's is on Part A
 456          */
 457         ip->iop_papar |=  ((3 << (2 * SCC_INDEX)));
 458         ip->iop_padir &= ~((3 << (2 * SCC_INDEX)));
 459         ip->iop_paodr &= ~((3 << (2 * SCC_INDEX)));
 460 #else
 461         /*
 462          * The IP860 has SCC3 and SCC4 on Port D
 463          */
 464         ip->iop_pdpar |=  ((3 << (2 * SCC_INDEX)));
 465 #endif
 466
 467         /* Allocate space for two buffer descriptors in the DP ram. */
 468
 469 #ifdef CONFIG_SYS_ALLOC_DPRAM
 470         dpaddr = dpram_alloc_align (sizeof(cbd_t)*2 + 2, 8) ;
 471 #else
 472         dpaddr = CPM_SERIAL2_BASE ;
 473 #endif
 474
 475         /* Enable SDMA. */
 476         im->im_siu_conf.sc_sdcr = 0x0001;
 477
 478         /* Set the physical address of the host memory buffers in
 479          * the buffer descriptors.
 480          */
 481
 482         rbdf = (cbd_t *)&cp->cp_dpmem[dpaddr];
 483         rbdf->cbd_bufaddr = (uint) (rbdf+2);
 484         rbdf->cbd_sc = 0;
 485         tbdf = rbdf + 1;
 486         tbdf->cbd_bufaddr = ((uint) (rbdf+2)) + 1;
 487         tbdf->cbd_sc = 0;
 488
 489         /* Set up the baud rate generator. */
 490         scc_setbrg ();
 491
 492         /* Set up the uart parameters in the parameter ram. */
 493         up->scc_genscc.scc_rbase = dpaddr;
 494         up->scc_genscc.scc_tbase = dpaddr+sizeof(cbd_t);
 495
 496         /* Initialize Tx/Rx parameters. */
 497         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 498                 ;
 499         cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SCC, CPM_CR_INIT_TRX) | CPM_CR_FLG;
 500
 501         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 502                 ;
 503
 504         up->scc_genscc.scc_rfcr  = SCC_EB | 0x05;
 505         up->scc_genscc.scc_tfcr  = SCC_EB | 0x05;
 506
 507         up->scc_genscc.scc_mrblr = 1;   /* Single character receive */
 508         up->scc_maxidl = 0;             /* disable max idle */
 509         up->scc_brkcr  = 1;             /* send one break character on stop TX */
 510         up->scc_parec  = 0;
 511         up->scc_frmec  = 0;
 512         up->scc_nosec  = 0;
 513         up->scc_brkec  = 0;
 514         up->scc_uaddr1 = 0;
 515         up->scc_uaddr2 = 0;
 516         up->scc_toseq  = 0;
 517         up->scc_char1  = 0x8000;
 518         up->scc_char2  = 0x8000;
 519         up->scc_char3  = 0x8000;
 520         up->scc_char4  = 0x8000;
 521         up->scc_char5  = 0x8000;
 522         up->scc_char6  = 0x8000;
 523         up->scc_char7  = 0x8000;
 524         up->scc_char8  = 0x8000;
 525         up->scc_rccm   = 0xc0ff;
 526
 527         /* Set low latency / small fifo. */
 528         sp->scc_gsmrh = SCC_GSMRH_RFW;
 529
 530         /* Set SCC(x) clock mode to 16x
 531          * See 8xx_io/commproc.c for details.
 532          *
 533          * Wire BRG1 to SCCn
 534          */
 535
 536         /* Set UART mode, clock divider 16 on Tx and Rx */
 537         sp->scc_gsmrl &= ~0xF;
 538         sp->scc_gsmrl |=
 539                 (SCC_GSMRL_MODE_UART | SCC_GSMRL_TDCR_16 | SCC_GSMRL_RDCR_16);
 540
 541         sp->scc_psmr  = 0;
 542         sp->scc_psmr  |= SCU_PSMR_CL;
 543
 544         /* Mask all interrupts and remove anything pending. */
 545         sp->scc_sccm = 0;
 546         sp->scc_scce = 0xffff;
 547         sp->scc_dsr  = 0x7e7e;
 548         sp->scc_psmr = 0x3000;
 549
 550         /* Make the first buffer the only buffer. */
 551         tbdf->cbd_sc |= BD_SC_WRAP;
 552         rbdf->cbd_sc |= BD_SC_EMPTY | BD_SC_WRAP;
 553
 554         /* Enable transmitter/receiver. */
 555         sp->scc_gsmrl |= (SCC_GSMRL_ENR | SCC_GSMRL_ENT);
 556
 557         return (0);
 558 }
 559
 560 static void
 561 scc_putc(const char c)
 562 {
 563         volatile cbd_t          *tbdf;
 564         volatile char           *buf;
 565         volatile scc_uart_t     *up;
 566         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 567         volatile cpm8xx_t       *cpmp = &(im->im_cpm);
 568
 569 #ifdef CONFIG_MODEM_SUPPORT
 570         if (gd->be_quiet)
 571                 return;
 572 #endif
 573
 574         if (c == '\n')
 575                 scc_putc ('\r');
 576
 577         up = (scc_uart_t *)&cpmp->cp_dparam[PROFF_SCC];
 578
 579         tbdf = (cbd_t *)&cpmp->cp_dpmem[up->scc_genscc.scc_tbase];
 580
 581         /* Wait for last character to go. */
 582
 583         buf = (char *)tbdf->cbd_bufaddr;
 584
 585         *buf = c;
 586         tbdf->cbd_datlen = 1;
 587         tbdf->cbd_sc |= BD_SC_READY;
 588         __asm__("eieio");
 589
 590         while (tbdf->cbd_sc & BD_SC_READY) {
 591                 __asm__("eieio");
 592                 WATCHDOG_RESET ();
 593         }
 594 }
 595
 596 static void
 597 scc_puts (const char *s)
 598 {
 599         while (*s) {
 600                 scc_putc (*s++);
 601         }
 602 }
 603
 604 static int
 605 scc_getc(void)
 606 {
 607         volatile cbd_t          *rbdf;
 608         volatile unsigned char  *buf;
 609         volatile scc_uart_t     *up;
 610         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 611         volatile cpm8xx_t       *cpmp = &(im->im_cpm);
 612         unsigned char           c;
 613
 614         up = (scc_uart_t *)&cpmp->cp_dparam[PROFF_SCC];
 615
 616         rbdf = (cbd_t *)&cpmp->cp_dpmem[up->scc_genscc.scc_rbase];
 617
 618         /* Wait for character to show up. */
 619         buf = (unsigned char *)rbdf->cbd_bufaddr;
 620
 621         while (rbdf->cbd_sc & BD_SC_EMPTY)
 622                 WATCHDOG_RESET ();
 623
 624         c = *buf;
 625         rbdf->cbd_sc |= BD_SC_EMPTY;
 626
 627         return(c);
 628 }
 629
 630 static int
 631 scc_tstc(void)
 632 {
 633         volatile cbd_t          *rbdf;
 634         volatile scc_uart_t     *up;
 635         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 636         volatile cpm8xx_t       *cpmp = &(im->im_cpm);
 637
 638         up = (scc_uart_t *)&cpmp->cp_dparam[PROFF_SCC];
 639
 640         rbdf = (cbd_t *)&cpmp->cp_dpmem[up->scc_genscc.scc_rbase];
 641
 642         return(!(rbdf->cbd_sc & BD_SC_EMPTY));
 643 }
 644
 645 struct serial_device serial_scc_device =
 646 {
 647         .name   = "serial_scc",
 648         .start  = scc_init,
 649         .stop   = NULL,
 650         .setbrg = scc_setbrg,
 651         .getc   = scc_getc,
 652         .tstc   = scc_tstc,
 653         .putc   = scc_putc,
 654         .puts   = scc_puts,
 655 };
 656
 657 #endif  /* CONFIG_8xx_CONS_SCCx */
 658
 659 __weak struct serial_device *default_serial_console(void)
 660 {
 661 #if defined(CONFIG_8xx_CONS_SMC1) || defined(CONFIG_8xx_CONS_SMC2)
 662         return &serial_smc_device;
 663 #else
 664         return &serial_scc_device;
 665 #endif
 666 }
 667
 668 void mpc8xx_serial_initialize(void)
 669 {
 670 #if defined(CONFIG_8xx_CONS_SMC1) || defined(CONFIG_8xx_CONS_SMC2)
 671         serial_register(&serial_smc_device);
 672 #endif
 673 #if     defined(CONFIG_8xx_CONS_SCC1) || defined(CONFIG_8xx_CONS_SCC2) || \
 674         defined(CONFIG_8xx_CONS_SCC3) || defined(CONFIG_8xx_CONS_SCC4)
 675         serial_register(&serial_scc_device);
 676 #endif
 677 }
 678
 679 #ifdef CONFIG_MODEM_SUPPORT
 680 void disable_putc(void)
 681 {
 682         gd->be_quiet = 1;
 683 }
 684
 685 void enable_putc(void)
 686 {
 687         gd->be_quiet = 0;
 688 }
 689 #endif
 690
 691 #if defined(CONFIG_CMD_KGDB)
 692
 693 void
 694 kgdb_serial_init(void)
 695 {
 696         int i = -1;
 697
 698         if (strcmp(default_serial_console()->name, "serial_smc") == 0)
 699         {
 700 #if defined(CONFIG_8xx_CONS_SMC1)
 701                 i = 1;
 702 #elif defined(CONFIG_8xx_CONS_SMC2)
 703                 i = 2;
 704 #endif
 705         }
 706         else if (strcmp(default_serial_console()->name, "serial_scc") == 0)
 707         {
 708 #if defined(CONFIG_8xx_CONS_SCC1)
 709                 i = 1;
 710 #elif defined(CONFIG_8xx_CONS_SCC2)
 711                 i = 2;
 712 #elif defined(CONFIG_8xx_CONS_SCC3)
 713                 i = 3;
 714 #elif defined(CONFIG_8xx_CONS_SCC4)
 715                 i = 4;
 716 #endif
 717         }
 718
 719         if (i >= 0)
 720         {
 721                 serial_printf("[on %s%d] ", default_serial_console()->name, i);
 722         }
 723 }
 724
 725 void
 726 putDebugChar (int c)
 727 {
 728         serial_putc (c);
 729 }
 730
 731 void
 732 putDebugStr (const char *str)
 733 {
 734         serial_puts (str);
 735 }
 736
 737 int
 738 getDebugChar (void)
 739 {
 740         return serial_getc();
 741 }
 742
 743 void
 744 kgdb_interruptible (int yes)
 745 {
 746         return;
 747 }
 748 #endif
 749
 750 #endif  /* CONFIG_8xx_CONS_NONE */