git.sur5r.net Git - u-boot/blob - arch/powerpc/cpu/mpc8260/serial_smc.c

   1 /*
   2  * (C) Copyright 2000, 2001, 2002
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   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  * Hacked for MPC8260 by Murray.Jensen@cmst.csiro.au, 19-Oct-00, with
  24  * changes based on the file arch/powerpc/mbxboot/m8260_tty.c from the
  25  * Linux/PPC sources (m8260_tty.c had no copyright info in it).
  26  */
  27
  28 /*
  29  * Minimal serial functions needed to use one of the SMC ports
  30  * as serial console interface.
  31  */
  32
  33 #include <common.h>
  34 #include <mpc8260.h>
  35 #include <asm/cpm_8260.h>
  36 #include <serial.h>
  37 #include <linux/compiler.h>
  38
  39 DECLARE_GLOBAL_DATA_PTR;
  40
  41 #if defined(CONFIG_CONS_ON_SMC)
  42
  43 #if CONFIG_CONS_INDEX == 1      /* Console on SMC1 */
  44
  45 #define SMC_INDEX               0
  46 #define PROFF_SMC_BASE          PROFF_SMC1_BASE
  47 #define PROFF_SMC               PROFF_SMC1
  48 #define CPM_CR_SMC_PAGE         CPM_CR_SMC1_PAGE
  49 #define CPM_CR_SMC_SBLOCK       CPM_CR_SMC1_SBLOCK
  50 #define CMXSMR_MASK             (CMXSMR_SMC1|CMXSMR_SMC1CS_MSK)
  51 #define CMXSMR_VALUE            CMXSMR_SMC1CS_BRG7
  52
  53 #elif CONFIG_CONS_INDEX == 2    /* Console on SMC2 */
  54
  55 #define SMC_INDEX               1
  56 #define PROFF_SMC_BASE          PROFF_SMC2_BASE
  57 #define PROFF_SMC               PROFF_SMC2
  58 #define CPM_CR_SMC_PAGE         CPM_CR_SMC2_PAGE
  59 #define CPM_CR_SMC_SBLOCK       CPM_CR_SMC2_SBLOCK
  60 #define CMXSMR_MASK             (CMXSMR_SMC2|CMXSMR_SMC2CS_MSK)
  61 #define CMXSMR_VALUE            CMXSMR_SMC2CS_BRG8
  62
  63 #else
  64
  65 #error "console not correctly defined"
  66
  67 #endif
  68
  69 #if !defined(CONFIG_SYS_SMC_RXBUFLEN)
  70 #define CONFIG_SYS_SMC_RXBUFLEN 1
  71 #define CONFIG_SYS_MAXIDLE      0
  72 #else
  73 #if !defined(CONFIG_SYS_MAXIDLE)
  74 #error "you must define CONFIG_SYS_MAXIDLE"
  75 #endif
  76 #endif
  77
  78 typedef volatile struct serialbuffer {
  79         cbd_t   rxbd;           /* Rx BD */
  80         cbd_t   txbd;           /* Tx BD */
  81         uint    rxindex;        /* index for next character to read */
  82         volatile uchar  rxbuf[CONFIG_SYS_SMC_RXBUFLEN];/* rx buffers */
  83         volatile uchar  txbuf;  /* tx buffers */
  84 } serialbuffer_t;
  85
  86 /* map rs_table index to baud rate generator index */
  87 static unsigned char brg_map[] = {
  88         6,      /* BRG7 for SMC1 */
  89         7,      /* BRG8 for SMC2 */
  90         0,      /* BRG1 for SCC1 */
  91         1,      /* BRG1 for SCC2 */
  92         2,      /* BRG1 for SCC3 */
  93         3,      /* BRG1 for SCC4 */
  94 };
  95
  96 static int mpc8260_smc_serial_init(void)
  97 {
  98         volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
  99         volatile smc_t *sp;
 100         volatile smc_uart_t *up;
 101         volatile cpm8260_t *cp = &(im->im_cpm);
 102         uint    dpaddr;
 103         volatile serialbuffer_t *rtx;
 104
 105         /* initialize pointers to SMC */
 106
 107         sp = (smc_t *) &(im->im_smc[SMC_INDEX]);
 108         *(ushort *)(&im->im_dprambase[PROFF_SMC_BASE]) = PROFF_SMC;
 109         up = (smc_uart_t *)&im->im_dprambase[PROFF_SMC];
 110
 111         /* Disable transmitter/receiver. */
 112         sp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
 113
 114         /* NOTE: I/O port pins are set up via the iop_conf_tab[] table */
 115
 116         /* Allocate space for two buffer descriptors in the DP ram.
 117          * damm: allocating space after the two buffers for rx/tx data
 118          */
 119
 120         /* allocate size of struct serialbuffer with bd rx/tx,
 121          * buffer rx/tx and rx index
 122          */
 123         dpaddr = m8260_cpm_dpalloc((sizeof(serialbuffer_t)), 16);
 124
 125         rtx = (serialbuffer_t *)&im->im_dprambase[dpaddr];
 126
 127         /* Set the physical address of the host memory buffers in
 128          * the buffer descriptors.
 129          */
 130         rtx->rxbd.cbd_bufaddr = (uint) &rtx->rxbuf;
 131         rtx->rxbd.cbd_sc      = 0;
 132
 133         rtx->txbd.cbd_bufaddr = (uint) &rtx->txbuf;
 134         rtx->txbd.cbd_sc      = 0;
 135
 136         /* Set up the uart parameters in the parameter ram. */
 137         up->smc_rbase = dpaddr;
 138         up->smc_tbase = dpaddr+sizeof(cbd_t);
 139         up->smc_rfcr = CPMFCR_EB;
 140         up->smc_tfcr = CPMFCR_EB;
 141         up->smc_brklen = 0;
 142         up->smc_brkec = 0;
 143         up->smc_brkcr = 0;
 144
 145         /* Set UART mode, 8 bit, no parity, one stop.
 146          * Enable receive and transmit.
 147          */
 148         sp->smc_smcmr = smcr_mk_clen(9) |  SMCMR_SM_UART;
 149
 150         /* Mask all interrupts and remove anything pending. */
 151         sp->smc_smcm = 0;
 152         sp->smc_smce = 0xff;
 153
 154         /* put the SMC channel into NMSI (non multiplexd serial interface)
 155          * mode and wire either BRG7 to SMC1 or BRG8 to SMC2 (15-17).
 156          */
 157         im->im_cpmux.cmx_smr = (im->im_cpmux.cmx_smr&~CMXSMR_MASK)|CMXSMR_VALUE;
 158
 159         /* Set up the baud rate generator. */
 160         serial_setbrg ();
 161
 162         /* Make the first buffer the only buffer. */
 163         rtx->txbd.cbd_sc |= BD_SC_WRAP;
 164         rtx->rxbd.cbd_sc |= BD_SC_EMPTY | BD_SC_WRAP;
 165
 166         /* single/multi character receive. */
 167         up->smc_mrblr = CONFIG_SYS_SMC_RXBUFLEN;
 168         up->smc_maxidl = CONFIG_SYS_MAXIDLE;
 169         rtx->rxindex = 0;
 170
 171         /* Initialize Tx/Rx parameters. */
 172
 173         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 174           ;
 175
 176         cp->cp_cpcr = mk_cr_cmd(CPM_CR_SMC_PAGE, CPM_CR_SMC_SBLOCK,
 177                                         0, CPM_CR_INIT_TRX) | CPM_CR_FLG;
 178
 179         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 180           ;
 181
 182         /* Enable transmitter/receiver. */
 183         sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
 184
 185         return (0);
 186 }
 187
 188 static void mpc8260_smc_serial_setbrg(void)
 189 {
 190 #if defined(CONFIG_CONS_USE_EXTC)
 191         m8260_cpm_extcbrg(brg_map[SMC_INDEX], gd->baudrate,
 192                 CONFIG_CONS_EXTC_RATE, CONFIG_CONS_EXTC_PINSEL);
 193 #else
 194         m8260_cpm_setbrg(brg_map[SMC_INDEX], gd->baudrate);
 195 #endif
 196 }
 197
 198 static void mpc8260_smc_serial_putc(const char c)
 199 {
 200         volatile smc_uart_t     *up;
 201         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 202         volatile serialbuffer_t *rtx;
 203
 204         if (c == '\n')
 205                 serial_putc ('\r');
 206
 207         up = (smc_uart_t *)&(im->im_dprambase[PROFF_SMC]);
 208
 209         rtx = (serialbuffer_t *)&im->im_dprambase[up->smc_rbase];
 210
 211         /* Wait for last character to go. */
 212         while (rtx->txbd.cbd_sc & BD_SC_READY & BD_SC_READY)
 213                 ;
 214         rtx->txbuf = c;
 215         rtx->txbd.cbd_datlen = 1;
 216         rtx->txbd.cbd_sc |= BD_SC_READY;
 217 }
 218
 219 static void mpc8260_smc_serial_puts(const char *s)
 220 {
 221         while (*s) {
 222                 serial_putc (*s++);
 223         }
 224 }
 225
 226 static int mpc8260_smc_serial_getc(void)
 227 {
 228         volatile smc_uart_t     *up;
 229         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 230         volatile serialbuffer_t *rtx;
 231         unsigned char  c;
 232
 233         up = (smc_uart_t *)&(im->im_dprambase[PROFF_SMC]);
 234
 235         rtx = (serialbuffer_t *)&im->im_dprambase[up->smc_rbase];
 236
 237         /* Wait for character to show up. */
 238         while (rtx->rxbd.cbd_sc & BD_SC_EMPTY)
 239                 ;
 240
 241         /* the characters are read one by one,
 242          * use the rxindex to know the next char to deliver
 243          */
 244         c = *(unsigned char *) (rtx->rxbd.cbd_bufaddr + rtx->rxindex);
 245         rtx->rxindex++;
 246
 247         /* check if all char are readout, then make prepare for next receive */
 248         if (rtx->rxindex >= rtx->rxbd.cbd_datlen) {
 249                 rtx->rxindex = 0;
 250                 rtx->rxbd.cbd_sc |= BD_SC_EMPTY;
 251         }
 252         return(c);
 253 }
 254
 255 static int mpc8260_smc_serial_tstc(void)
 256 {
 257         volatile smc_uart_t     *up;
 258         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 259         volatile serialbuffer_t *rtx;
 260
 261         up = (smc_uart_t *)&(im->im_dprambase[PROFF_SMC]);
 262         rtx = (serialbuffer_t *)&im->im_dprambase[up->smc_rbase];
 263
 264         return !(rtx->rxbd.cbd_sc & BD_SC_EMPTY);
 265 }
 266
 267 #ifdef CONFIG_SERIAL_MULTI
 268 static struct serial_device mpc8260_smc_serial_drv = {
 269         .name   = "mpc8260_smc_uart",
 270         .start  = mpc8260_smc_serial_init,
 271         .stop   = NULL,
 272         .setbrg = mpc8260_smc_serial_setbrg,
 273         .putc   = mpc8260_smc_serial_putc,
 274         .puts   = mpc8260_smc_serial_puts,
 275         .getc   = mpc8260_smc_serial_getc,
 276         .tstc   = mpc8260_smc_serial_tstc,
 277 };
 278
 279 void mpc8260_smc_serial_initialize(void)
 280 {
 281         serial_register(&mpc8260_smc_serial_drv);
 282 }
 283
 284 __weak struct serial_device *default_serial_console(void)
 285 {
 286         return &mpc8260_smc_serial_drv;
 287 }
 288 #else
 289 int serial_init(void)
 290 {
 291         return mpc8260_smc_serial_init();
 292 }
 293
 294 void serial_setbrg(void)
 295 {
 296         mpc8260_smc_serial_setbrg();
 297 }
 298
 299 void serial_putc(const char c)
 300 {
 301         mpc8260_smc_serial_putc(c);
 302 }
 303
 304 void serial_puts(const char *s)
 305 {
 306         mpc8260_smc_serial_puts(s);
 307 }
 308
 309 int serial_getc(void)
 310 {
 311         return mpc8260_smc_serial_getc();
 312 }
 313
 314 int serial_tstc(void)
 315 {
 316         return mpc8260_smc_serial_tstc();
 317 }
 318 #endif
 319 #endif  /* CONFIG_CONS_ON_SMC */
 320
 321 #if defined(CONFIG_KGDB_ON_SMC)
 322
 323 #if defined(CONFIG_CONS_ON_SMC) && CONFIG_KGDB_INDEX == CONFIG_CONS_INDEX
 324 #error Whoops! serial console and kgdb are on the same smc serial port
 325 #endif
 326
 327 #if CONFIG_KGDB_INDEX == 1      /* KGDB Port on SMC1 */
 328
 329 #define KGDB_SMC_INDEX          0
 330 #define KGDB_PROFF_SMC_BASE     PROFF_SMC1_BASE
 331 #define KGDB_PROFF_SMC          PROFF_SMC1
 332 #define KGDB_CPM_CR_SMC_PAGE    CPM_CR_SMC1_PAGE
 333 #define KGDB_CPM_CR_SMC_SBLOCK  CPM_CR_SMC1_SBLOCK
 334 #define KGDB_CMXSMR_MASK        (CMXSMR_SMC1|CMXSMR_SMC1CS_MSK)
 335 #define KGDB_CMXSMR_VALUE       CMXSMR_SMC1CS_BRG7
 336
 337 #elif CONFIG_KGDB_INDEX == 2    /* KGDB Port on SMC2 */
 338
 339 #define KGDB_SMC_INDEX          1
 340 #define KGDB_PROFF_SMC_BASE     PROFF_SMC2_BASE
 341 #define KGDB_PROFF_SMC          PROFF_SMC2
 342 #define KGDB_CPM_CR_SMC_PAGE    CPM_CR_SMC2_PAGE
 343 #define KGDB_CPM_CR_SMC_SBLOCK  CPM_CR_SMC2_SBLOCK
 344 #define KGDB_CMXSMR_MASK        (CMXSMR_SMC2|CMXSMR_SMC2CS_MSK)
 345 #define KGDB_CMXSMR_VALUE       CMXSMR_SMC2CS_BRG8
 346
 347 #else
 348
 349 #error "console not correctly defined"
 350
 351 #endif
 352
 353 void
 354 kgdb_serial_init (void)
 355 {
 356         volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
 357         volatile smc_t *sp;
 358         volatile smc_uart_t *up;
 359         volatile cbd_t *tbdf, *rbdf;
 360         volatile cpm8260_t *cp = &(im->im_cpm);
 361         uint dpaddr, speed = CONFIG_KGDB_BAUDRATE;
 362         char *s, *e;
 363
 364         if ((s = getenv("kgdbrate")) != NULL && *s != '\0') {
 365                 ulong rate = simple_strtoul(s, &e, 10);
 366                 if (e > s && *e == '\0')
 367                         speed = rate;
 368         }
 369
 370         /* initialize pointers to SMC */
 371
 372         sp = (smc_t *) &(im->im_smc[KGDB_SMC_INDEX]);
 373         *(ushort *)(&im->im_dprambase[KGDB_PROFF_SMC_BASE]) = KGDB_PROFF_SMC;
 374         up = (smc_uart_t *)&im->im_dprambase[KGDB_PROFF_SMC];
 375
 376         /* Disable transmitter/receiver. */
 377         sp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
 378
 379         /* NOTE: I/O port pins are set up via the iop_conf_tab[] table */
 380
 381         /* Allocate space for two buffer descriptors in the DP ram.
 382          * damm: allocating space after the two buffers for rx/tx data
 383          */
 384
 385         dpaddr = m8260_cpm_dpalloc((2 * sizeof (cbd_t)) + 2, 16);
 386
 387         /* Set the physical address of the host memory buffers in
 388          * the buffer descriptors.
 389          */
 390         rbdf = (cbd_t *)&im->im_dprambase[dpaddr];
 391         rbdf->cbd_bufaddr = (uint) (rbdf+2);
 392         rbdf->cbd_sc = 0;
 393         tbdf = rbdf + 1;
 394         tbdf->cbd_bufaddr = ((uint) (rbdf+2)) + 1;
 395         tbdf->cbd_sc = 0;
 396
 397         /* Set up the uart parameters in the parameter ram. */
 398         up->smc_rbase = dpaddr;
 399         up->smc_tbase = dpaddr+sizeof(cbd_t);
 400         up->smc_rfcr = CPMFCR_EB;
 401         up->smc_tfcr = CPMFCR_EB;
 402         up->smc_brklen = 0;
 403         up->smc_brkec = 0;
 404         up->smc_brkcr = 0;
 405
 406         /* Set UART mode, 8 bit, no parity, one stop.
 407          * Enable receive and transmit.
 408          */
 409         sp->smc_smcmr = smcr_mk_clen(9) |  SMCMR_SM_UART;
 410
 411         /* Mask all interrupts and remove anything pending. */
 412         sp->smc_smcm = 0;
 413         sp->smc_smce = 0xff;
 414
 415         /* put the SMC channel into NMSI (non multiplexd serial interface)
 416          * mode and wire either BRG7 to SMC1 or BRG8 to SMC2 (15-17).
 417          */
 418         im->im_cpmux.cmx_smr =
 419                 (im->im_cpmux.cmx_smr & ~KGDB_CMXSMR_MASK) | KGDB_CMXSMR_VALUE;
 420
 421         /* Set up the baud rate generator. */
 422 #if defined(CONFIG_KGDB_USE_EXTC)
 423         m8260_cpm_extcbrg(brg_map[KGDB_SMC_INDEX], speed,
 424                 CONFIG_KGDB_EXTC_RATE, CONFIG_KGDB_EXTC_PINSEL);
 425 #else
 426         m8260_cpm_setbrg(brg_map[KGDB_SMC_INDEX], speed);
 427 #endif
 428
 429         /* Make the first buffer the only buffer. */
 430         tbdf->cbd_sc |= BD_SC_WRAP;
 431         rbdf->cbd_sc |= BD_SC_EMPTY | BD_SC_WRAP;
 432
 433         /* Single character receive. */
 434         up->smc_mrblr = 1;
 435         up->smc_maxidl = 0;
 436
 437         /* Initialize Tx/Rx parameters. */
 438
 439         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 440           ;
 441
 442         cp->cp_cpcr = mk_cr_cmd(KGDB_CPM_CR_SMC_PAGE, KGDB_CPM_CR_SMC_SBLOCK,
 443                                         0, CPM_CR_INIT_TRX) | CPM_CR_FLG;
 444
 445         while (cp->cp_cpcr & CPM_CR_FLG)  /* wait if cp is busy */
 446           ;
 447
 448         /* Enable transmitter/receiver. */
 449         sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
 450
 451         printf("SMC%d at %dbps ", CONFIG_KGDB_INDEX, speed);
 452 }
 453
 454 void
 455 putDebugChar(const char c)
 456 {
 457         volatile cbd_t          *tbdf;
 458         volatile char           *buf;
 459         volatile smc_uart_t     *up;
 460         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 461
 462         if (c == '\n')
 463                 putDebugChar ('\r');
 464
 465         up = (smc_uart_t *)&(im->im_dprambase[KGDB_PROFF_SMC]);
 466
 467         tbdf = (cbd_t *)&im->im_dprambase[up->smc_tbase];
 468
 469         /* Wait for last character to go. */
 470         buf = (char *)tbdf->cbd_bufaddr;
 471         while (tbdf->cbd_sc & BD_SC_READY)
 472                 ;
 473
 474         *buf = c;
 475         tbdf->cbd_datlen = 1;
 476         tbdf->cbd_sc |= BD_SC_READY;
 477 }
 478
 479 void
 480 putDebugStr (const char *s)
 481 {
 482         while (*s) {
 483                 putDebugChar (*s++);
 484         }
 485 }
 486
 487 int
 488 getDebugChar(void)
 489 {
 490         volatile cbd_t          *rbdf;
 491         volatile unsigned char  *buf;
 492         volatile smc_uart_t     *up;
 493         volatile immap_t        *im = (immap_t *)CONFIG_SYS_IMMR;
 494         unsigned char           c;
 495
 496         up = (smc_uart_t *)&(im->im_dprambase[KGDB_PROFF_SMC]);
 497
 498         rbdf = (cbd_t *)&im->im_dprambase[up->smc_rbase];
 499
 500         /* Wait for character to show up. */
 501         buf = (unsigned char *)rbdf->cbd_bufaddr;
 502         while (rbdf->cbd_sc & BD_SC_EMPTY)
 503                 ;
 504         c = *buf;
 505         rbdf->cbd_sc |= BD_SC_EMPTY;
 506
 507         return(c);
 508 }
 509
 510 void
 511 kgdb_interruptible(int yes)
 512 {
 513         return;
 514 }
 515
 516 #endif  /* CONFIG_KGDB_ON_SMC */