firmware/drivers/serial.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Alan Korr & Nick Robinson
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdarg.h>
  24 #include "button.h"
  25 #include "config.h"
  26 #include "cpu.h"
  27 #include "system.h"
  28 #include "kernel.h"
  29 #include "lcd.h"
  30 #include "serial.h"
  31 #include "iap.h"
  32
  33 #if CONFIG_CPU == IMX31L
  34 #include "serial-imx31.h"
  35 #endif
  36
  37 #if CONFIG_CPU == SH7034
  38
  39 /* FIX: this doesn't work on iRiver or iPod yet */
  40 /* iFP7xx has no remote */
  41
  42 /* Received byte identifiers */
  43 #define PLAY  0xC1
  44 #define STOP  0xC2
  45 #define PREV  0xC4
  46 #define NEXT  0xC8
  47 #define VOLUP 0xD0
  48 #define VOLDN 0xE0
  49
  50 void serial_setup (void)
  51 {
  52     /* Set PB10 function to serial Rx */
  53     PBCR1 = (PBCR1 & 0xffcf) | 0x0020;
  54
  55     SMR1 = 0x00;
  56     SCR1 = 0;
  57     BRR1 = (FREQ/(32*9600))-1;
  58     and_b(0, &SSR1); /* The status bits must be read before they are cleared,
  59                         so we do an AND operation */
  60
  61     /* Let the hardware settle. The serial port needs to wait "at least
  62        the interval required to transmit or receive one bit" before it
  63        can be used. */
  64     sleep(1);
  65
  66     SCR1 = 0x10; /* Enable the receiver, no interrupt */
  67 }
  68
  69 int tx_rdy(void)
  70 {
  71     /* a dummy */
  72     return 1;
  73 }
  74
  75 int rx_rdy(void)
  76 {
  77     if(SSR1 & SCI_RDRF)
  78         return 1;
  79     else
  80         return 0;
  81 }
  82
  83 void tx_writec(unsigned char c)
  84 {
  85     /* a dummy */
  86     (void)c;
  87 }
  88
  89 unsigned char rx_readc(void)
  90 {
  91     char tmp;
  92     /* Read byte and clear the Rx Full bit */
  93     tmp = RDR1;
  94     and_b(~SCI_RDRF, &SSR1);
  95     return tmp;
  96 }
  97
  98
  99 /* This function returns the received remote control code only if it is
 100    received without errors before or after the reception.
 101    It therefore returns the received code on the second call after the
 102    code has been received. */
 103 int remote_control_rx(void)
 104 {
 105     static int last_valid_button = BUTTON_NONE;
 106     static int last_was_error = false;
 107     int btn;
 108     int ret = BUTTON_NONE;
 109
 110     /* Errors? Just clear'em. The receiver stops if we don't */
 111     if(SSR1 & (SCI_ORER | SCI_FER | SCI_PER)) {
 112         and_b(~(SCI_ORER | SCI_FER | SCI_PER), &SSR1);
 113         last_valid_button = BUTTON_NONE;
 114         last_was_error = true;
 115         return BUTTON_NONE;
 116     }
 117
 118     if(rx_rdy()) {
 119         btn = rx_readc();
 120
 121         if(last_was_error)
 122         {
 123             last_valid_button = BUTTON_NONE;
 124             ret = BUTTON_NONE;
 125         }
 126         else
 127         {
 128             switch (btn)
 129             {
 130                 case STOP:
 131                     last_valid_button = BUTTON_RC_STOP;
 132                     break;
 133
 134                 case PLAY:
 135                     last_valid_button = BUTTON_RC_PLAY;
 136                     break;
 137
 138                 case VOLUP:
 139                     last_valid_button = BUTTON_RC_VOL_UP;
 140                     break;
 141
 142                 case VOLDN:
 143                     last_valid_button = BUTTON_RC_VOL_DOWN;
 144                     break;
 145
 146                 case PREV:
 147                     last_valid_button = BUTTON_RC_LEFT;
 148                     break;
 149
 150                 case NEXT:
 151                     last_valid_button = BUTTON_RC_RIGHT;
 152                     break;
 153
 154                 default:
 155                     last_valid_button = BUTTON_NONE;
 156                     break;
 157             }
 158         }
 159     }
 160     else
 161     {
 162         /* This means that a valid remote control character was received
 163            the last time we were called, with no receiver errors either before
 164            or after. Then we can assume that there really is a remote control
 165            attached, and return the button code. */
 166         ret = last_valid_button;
 167         last_valid_button = BUTTON_NONE;
 168     }
 169
 170     last_was_error = false;
 171
 172     return ret;
 173 }
 174
 175 #elif defined(CPU_COLDFIRE)
 176
 177 void serial_setup (void)
 178 {
 179     UCR0 = 0x30; /* Reset transmitter */
 180     UCSR0 = 0xdd; /* Timer mode */
 181
 182     UCR0 = 0x10;  /* Reset pointer */
 183     UMR0 = 0x13; /* No parity, 8 bits */
 184     UMR0 = 0x07; /* 1 stop bit */
 185
 186     UCR0 = 0x04; /* Tx enable */
 187 }
 188
 189 int tx_rdy(void)
 190 {
 191     if(USR0 & 0x04)
 192         return 1;
 193     else
 194         return 0;
 195 }
 196
 197 int rx_rdy(void)
 198 {
 199     /* a dummy */
 200     return 0;
 201 }
 202
 203 void tx_writec(unsigned char c)
 204 {
 205     UTB0 = c;
 206 }
 207
 208 #elif (CONFIG_CPU == IMX31L)
 209
 210 void serial_setup(void)
 211 {
 212 #ifdef UART_INT /*enable UART Interrupts */
 213     UCR1_1 |= (EUARTUCR1_TRDYEN | EUARTUCR1_RRDYEN | EUARTUCR1_TXMPTYEN);
 214     UCR4_1 |= (EUARTUCR4_TCEN);
 215 #else /*disable UART Interrupts*/
 216     UCR1_1 &= ~(EUARTUCR1_TRDYEN | EUARTUCR1_RRDYEN | EUARTUCR1_TXMPTYEN);
 217     UCR4_1 &= ~(EUARTUCR4_TCEN);
 218 #endif
 219     UCR1_1 |= EUARTUCR1_UARTEN;
 220     UCR2_1 |= (EUARTUCR2_TXEN  | EUARTUCR2_RXEN | EUARTUCR2_IRTS);
 221
 222     /* Tx,Rx Interrupt Trigger levels, Disable for now*/
 223     /*UFCR1 |= (UFCR1_TXTL_32 | UFCR1_RXTL_32);*/
 224 }
 225
 226 int tx_rdy(void)
 227 {
 228     if((UTS1 & EUARTUTS_TXEMPTY))
 229         return 1;
 230     else
 231         return 0;
 232 }
 233
 234 /*Not ready...After first Rx, UTS1 & UTS1_RXEMPTY
 235   keeps returning true*/
 236 int rx_rdy(void)
 237 {
 238     if(!(UTS1 & EUARTUTS_RXEMPTY))
 239         return 1;
 240     else
 241         return 0;
 242 }
 243
 244 void tx_writec(unsigned char c)
 245 {
 246     UTXD1=(int) c;
 247 }
 248
 249 #elif defined(IPOD_ACCESSORY_PROTOCOL)
 250 static int autobaud = 0;
 251 void serial_setup (void)
 252 {
 253     int tmp;
 254
 255 #if (MODEL_NUMBER == 3) || (MODEL_NUMBER == 8)
 256
 257     /* Route the Tx/Rx pins.  4G Ipod??? */
 258     outl(0x70000018, inl(0x70000018) & ~0xc00);
 259 #elif (MODEL_NUMBER == 4) || (MODEL_NUMBER == 5)
 260
 261     /* Route the Tx/Rx pins.  5G Ipod */
 262     (*(volatile unsigned long *)(0x7000008C)) &= ~0x0C;
 263     GPO32_ENABLE &= ~0x0C;
 264 #endif
 265
 266     DEV_EN = DEV_EN | DEV_SER0;
 267     CPU_HI_INT_DIS = SER0_MASK;
 268
 269     DEV_RS |= DEV_SER0;
 270     sleep(1);
 271     DEV_RS &= ~DEV_SER0;
 272
 273     SER0_LCR = 0x80; /* Divisor latch enable */
 274     SER0_DLM = 0x00;
 275     SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 276     SER0_IER = 0x01;
 277
 278     SER0_FCR = 0x07; /* Tx+Rx FIFO reset and FIFO enable */
 279
 280     CPU_INT_EN |= HI_MASK;
 281     CPU_HI_INT_EN |= SER0_MASK;
 282     tmp = SER0_RBR;
 283
 284     serial_bitrate(0);
 285 }
 286
 287 void serial_bitrate(int rate)
 288 {
 289     if(rate == 0)
 290     {
 291         autobaud = 2;
 292         SER0_LCR = 0x80; /* Divisor latch enable */
 293         SER0_DLL = 0x0D; /* 24000000/13/16 = 115384 baud */
 294         SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 295         return;
 296     }
 297
 298     autobaud = 0;
 299     SER0_LCR = 0x80; /* Divisor latch enable */
 300     SER0_DLL = 24000000L / rate / 16;
 301     SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 302 }
 303
 304 int tx_rdy(void)
 305 {
 306     if((SER0_LSR & 0x20))
 307         return 1;
 308     else
 309         return 0;
 310 }
 311
 312 int rx_rdy(void)
 313 {
 314     if((SER0_LSR & 0x1))
 315         return 1;
 316     else
 317         return 0;
 318 }
 319
 320 void tx_writec(unsigned char c)
 321 {
 322     SER0_THR =(int) c;
 323 }
 324
 325 unsigned char rx_readc(void)
 326 {
 327     return (SER0_RBR & 0xFF);
 328 }
 329
 330 void SERIAL0(void)
 331 {
 332     static int badbaud = 0;
 333     static bool newpkt = true;
 334     char temp;
 335
 336     while(rx_rdy())
 337     {
 338         temp = rx_readc();
 339         if (newpkt && autobaud > 0)
 340         {
 341             if (autobaud == 1)
 342             {
 343                 switch (temp)
 344                 {
 345                     case 0xFF:
 346                     case 0x55:
 347                         break;
 348                     case 0xFC:
 349                         SER0_LCR = 0x80; /* Divisor latch enable */
 350                         SER0_DLL = 0x4E; /* 24000000/78/16 = 19230 baud */
 351                         SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 352                         temp = 0xFF;
 353                         break;
 354                     case 0xE0:
 355                         SER0_LCR = 0x80; /* Divisor latch enable */
 356                         SER0_DLL = 0x9C; /* 24000000/156/16 = 9615 baud */
 357                         SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 358                         temp = 0xFF;
 359                         break;
 360                     default:
 361                         badbaud++;
 362                         if (badbaud >= 6) /* Switch baud detection mode */
 363                         {
 364                             autobaud = 2;
 365                             SER0_LCR = 0x80; /* Divisor latch enable */
 366                             SER0_DLL = 0x0D; /* 24000000/13/16 = 115384 baud */
 367                             SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 368                             badbaud = 0;
 369                         } else {
 370                             SER0_LCR = 0x80; /* Divisor latch enable */
 371                             SER0_DLL = 0x1A; /* 24000000/26/16 = 57692 baud */
 372                             SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 373                         }
 374                         continue;
 375                 }
 376             } else {
 377                 switch (temp)
 378                 {
 379                     case 0xFF:
 380                     case 0x55:
 381                         break;
 382                     case 0xFE:
 383                         SER0_LCR = 0x80; /* Divisor latch enable */
 384                         SER0_DLL = 0x1A; /* 24000000/26/16 = 57692 baud */
 385                         SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 386                         temp = 0xFF;
 387                         break;
 388                     case 0xFC:
 389                             SER0_LCR = 0x80; /* Divisor latch enable */
 390                         SER0_DLL = 0x27; /* 24000000/39/16 = 38461 baud */
 391                         SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 392                         temp = 0xFF;
 393                         break;
 394                     case 0xE0:
 395                         SER0_LCR = 0x80; /* Divisor latch enable */
 396                         SER0_DLL = 0x4E; /* 24000000/78/16 = 19230 baud */
 397                         SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 398                         temp = 0xFF;
 399                         break;
 400                     default:
 401                         badbaud++;
 402                         if (badbaud >= 6) /* Switch baud detection */
 403                         {
 404                             autobaud = 1;
 405                             SER0_LCR = 0x80; /* Divisor latch enable */
 406                             SER0_DLL = 0x1A; /* 24000000/26/16 = 57692 baud */
 407                             SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 408                             badbaud = 0;
 409                         } else {
 410                             SER0_LCR = 0x80; /* Divisor latch enable */
 411                             SER0_DLL = 0x0D; /* 24000000/13/16 = 115384 baud */
 412                             SER0_LCR = 0x03; /* Divisor latch disable, 8-N-1 */
 413                         }
 414                         continue;
 415                 }
 416             }
 417         }
 418         bool pkt = iap_getc(temp);
 419         if(newpkt == true && pkt == false)
 420             autobaud = 0; /* Found good baud */
 421         newpkt = pkt;
 422     }
 423 }
 424
 425 #endif
 426
 427 void dprintf(const char * str, ... )
 428 {
 429     char dprintfbuff[256];
 430     char * ptr;
 431
 432     va_list ap;
 433     va_start(ap, str);
 434
 435     ptr = dprintfbuff;
 436     vsnprintf(ptr,sizeof(dprintfbuff),str,ap);
 437     va_end(ap);
 438
 439     serial_tx((unsigned char *)ptr);
 440 }
 441
 442 void serial_tx(const unsigned char * buf)
 443 {
 444     /*Tx*/
 445     for(;;) {
 446         if(tx_rdy()) {
 447             if(*buf == '\0')
 448                 return;
 449             if(*buf == '\n')
 450                 tx_writec('\r');
 451             tx_writec(*buf);
 452             buf++;
 453         }
 454     }
 455 }