drv/ser_dsp56k.c

   1 /*!
   2  * \file
   3  * <!--
   4  * Copyright 2003, 2004 Develer S.r.l. (http://www.develer.com/)
   5  * This file is part of DevLib - See README.devlib for information.
   6  * -->
   7  *
   8  * \version $Id$
   9  *
  10  * \author Stefano Fedrigo <aleph@develer.com>
  11  * \author Giovanni Bajo <rasky@develer.com>
  12  *
  13  * \brief DSP5680x CPU specific serial I/O driver
  14  */
  15
  16 /*#*
  17  *#* $Log$
  18  *#* Revision 1.13  2005/11/04 16:20:02  bernie
  19  *#* Fix reference to README.devlib in header.
  20  *#*
  21  *#* Revision 1.12  2005/04/11 19:10:27  bernie
  22  *#* Include top-level headers from cfg/ subdir.
  23  *#*
  24  *#* Revision 1.11  2005/01/25 07:42:04  bernie
  25  *#* Simplify.
  26  *#*
  27  *#* Revision 1.10  2005/01/14 00:48:33  aleph
  28  *#* Rename callbacks; SerialHardwareVT.txSending: New callback.
  29  *#*
  30  *#* Revision 1.9  2004/12/08 09:42:55  bernie
  31  *#* Add support for multiplexed serial ports.
  32  *#*
  33  *#* Revision 1.8  2004/10/26 09:00:49  bernie
  34  *#* Don't access serial data register twice.
  35  *#*
  36  *#* Revision 1.7  2004/10/19 08:57:15  bernie
  37  *#* Bugfixes for DSP56K serial driver from scfirm.
  38  *#*
  39  *#* Revision 1.5  2004/08/25 14:12:08  rasky
  40  *#* Aggiornato il comment block dei log RCS
  41  *#*
  42  *#* Revision 1.4  2004/07/30 14:27:49  rasky
  43  *#* Aggiornati alcuni file DSP56k per la nuova libreria di IRQ management
  44  *#*
  45  *#* Revision 1.3  2004/06/03 11:27:09  bernie
  46  *#* Add dual-license information.
  47  *#*
  48  *#* Revision 1.2  2004/05/23 18:21:53  bernie
  49  *#* Trim CVS logs and cleanup header info.
  50  *#*/
  51
  52 #include "ser.h"
  53 #include "ser_p.h"
  54 #include <drv/irq.h>
  55 #include <cfg/debug.h>
  56 #include <hw.h>
  57 #include <DSP56F807.h>
  58
  59 // GPIO E is shared with SPI (in DSP56807). Pins 0&1 are TXD0 and RXD0. To use
  60 //  the serial, we need to disable the GPIO functions on them.
  61 #define REG_GPIO_SERIAL_0       REG_GPIO_E
  62 #define REG_GPIO_SERIAL_MASK_0  0x03
  63
  64 #define REG_GPIO_SERIAL_1       REG_GPIO_D
  65 #define REG_GPIO_SERIAL_MASK_1  0xC0
  66
  67
  68 // Check flag consistency
  69 #if (SERRF_PARITYERROR != REG_SCI_SR_PF) || \
  70         (SERRF_RXSROVERRUN != REG_SCI_SR_OR) || \
  71         (SERRF_FRAMEERROR  != REG_SCI_SR_FE) || \
  72         (SERRF_NOISEERROR  != REG_SCI_SR_NF)
  73         #error error flags do not match with register bits
  74 #endif
  75
  76 static unsigned char ser0_fifo_rx[CONFIG_SER0_FIFOSIZE_RX];
  77 static unsigned char ser0_fifo_tx[CONFIG_SER0_FIFOSIZE_TX];
  78 static unsigned char ser1_fifo_rx[CONFIG_SER1_FIFOSIZE_RX];
  79 static unsigned char ser1_fifo_tx[CONFIG_SER1_FIFOSIZE_TX];
  80
  81 #if CONFIG_SER_MULTI
  82         #include <kern/sem.h>
  83
  84         #define MAX_MULTI_GROUPS     1
  85
  86         struct Semaphore multi_sems[MAX_MULTI_GROUPS];
  87 #endif
  88
  89
  90 struct SCI
  91 {
  92         struct SerialHardware hw;
  93         struct Serial* serial;
  94         volatile struct REG_SCI_STRUCT* regs;
  95         IRQ_VECTOR irq_tx;
  96         IRQ_VECTOR irq_rx;
  97         int num_group;
  98         int id;
  99 };
 100
 101 static inline void enable_tx_irq_bare(volatile struct REG_SCI_STRUCT* regs)
 102 {
 103         regs->CR |= REG_SCI_CR_TEIE | REG_SCI_CR_TIIE;
 104 }
 105
 106 static inline void enable_rx_irq_bare(volatile struct REG_SCI_STRUCT* regs)
 107 {
 108         regs->CR |= REG_SCI_CR_RIE;
 109 }
 110
 111 static inline void disable_tx_irq_bare(volatile struct REG_SCI_STRUCT* regs)
 112 {
 113         regs->CR &= ~(REG_SCI_CR_TEIE | REG_SCI_CR_TIIE);
 114 }
 115
 116 static inline void disable_rx_irq_bare(volatile struct REG_SCI_STRUCT* regs)
 117 {
 118         regs->CR &= ~(REG_SCI_CR_RIE | REG_SCI_CR_REIE);
 119 }
 120
 121 static inline void disable_tx_irq(struct SerialHardware* _hw)
 122 {
 123         struct SCI* hw = (struct SCI*)_hw;
 124
 125         disable_tx_irq_bare(hw->regs);
 126 }
 127
 128 static inline void disable_rx_irq(struct SerialHardware* _hw)
 129 {
 130         struct SCI* hw = (struct SCI*)_hw;
 131
 132         disable_rx_irq_bare(hw->regs);
 133 }
 134
 135 static inline void enable_tx_irq(struct SerialHardware* _hw)
 136 {
 137         struct SCI* hw = (struct SCI*)_hw;
 138
 139         enable_tx_irq_bare(hw->regs);
 140 }
 141
 142 static inline void enable_rx_irq(struct SerialHardware* _hw)
 143 {
 144         struct SCI* hw = (struct SCI*)_hw;
 145
 146         enable_rx_irq_bare(hw->regs);
 147 }
 148
 149 static inline bool tx_irq_enabled(struct SerialHardware* _hw)
 150 {
 151         struct SCI* hw = (struct SCI*)_hw;
 152
 153         return (hw->regs->CR & REG_SCI_CR_TEIE);
 154 }
 155
 156 static void tx_isr(const struct SCI *hw)
 157 {
 158 #pragma interrupt warn
 159         volatile struct REG_SCI_STRUCT* regs = hw->regs;
 160
 161         if (fifo_isempty(&hw->serial->txfifo))
 162                 disable_tx_irq_bare(regs);
 163         else
 164         {
 165                 // Clear transmitter flags before sending data
 166                 (void)regs->SR;
 167                 regs->DR = fifo_pop(&hw->serial->txfifo);
 168         }
 169 }
 170
 171 static void rx_isr(const struct SCI *hw)
 172 {
 173 #pragma interrupt warn
 174         volatile struct REG_SCI_STRUCT* regs = hw->regs;
 175
 176         // Propagate errors
 177         hw->serial->status |= regs->SR & (SERRF_PARITYERROR |
 178                                           SERRF_RXSROVERRUN |
 179                                           SERRF_FRAMEERROR |
 180                                           SERRF_NOISEERROR);
 181
 182         /*
 183          * Serial IRQ can happen for two reason: data ready (RDRF) or overrun (OR)
 184          * If the data is ready, we need to fetch it from the data register or
 185          * the interrupt will retrigger immediatly. In case of overrun, instead,
 186          * the value of the data register is meaningless.
 187          */
 188         if (regs->SR & REG_SCI_SR_RDRF)
 189         {
 190                 unsigned char data = regs->DR;
 191
 192                 if (fifo_isfull(&hw->serial->rxfifo))
 193                         hw->serial->status |= SERRF_RXFIFOOVERRUN;
 194                 else
 195                         fifo_push(&hw->serial->rxfifo, data);
 196         }
 197
 198         // Writing anything to the status register clear the error bits.
 199         regs->SR = 0;
 200 }
 201
 202 static void init(struct SerialHardware* _hw, struct Serial* ser)
 203 {
 204         struct SCI* hw = (struct SCI*)_hw;
 205         volatile struct REG_SCI_STRUCT* regs = hw->regs;
 206
 207         // Clear status register (IRQ/status flags)
 208         (void)regs->SR;
 209         regs->SR = 0;
 210
 211         // Clear data register
 212         (void)regs->DR;
 213
 214         // Install the handlers and set priorities for both IRQs
 215         irq_install(hw->irq_tx, (isr_t)tx_isr, hw);
 216         irq_install(hw->irq_rx, (isr_t)rx_isr, hw);
 217         irq_setpriority(hw->irq_tx, IRQ_PRIORITY_SCI_TX);
 218         irq_setpriority(hw->irq_rx, IRQ_PRIORITY_SCI_RX);
 219
 220         // Activate the RX error interrupts, and RX/TX transmissions
 221         regs->CR = REG_SCI_CR_TE | REG_SCI_CR_RE;
 222         enable_rx_irq_bare(regs);
 223
 224         // Disable GPIO pins for TX and RX lines
 225         // \todo this should be divided into serial 0 and 1
 226         REG_GPIO_SERIAL_0->PER |= REG_GPIO_SERIAL_MASK_0;
 227         REG_GPIO_SERIAL_1->PER |= REG_GPIO_SERIAL_MASK_1;
 228
 229         hw->serial = ser;
 230 }
 231
 232 static void cleanup(struct SerialHardware* _hw)
 233 {
 234         struct SCI* hw = (struct SCI*)_hw;
 235
 236         // Uninstall the ISRs
 237         disable_rx_irq(_hw);
 238         disable_tx_irq(_hw);
 239         irq_uninstall(hw->irq_tx);
 240         irq_uninstall(hw->irq_rx);
 241 }
 242
 243 static void setbaudrate(struct SerialHardware* _hw, unsigned long rate)
 244 {
 245         struct SCI* hw = (struct SCI*)_hw;
 246
 247         // SCI has an internal 16x divider on the input clock, which comes
 248         //  from the IPbus (see the scheme in user manual, 12.7.3). We apply
 249         //  it to calculate the period to store in the register.
 250         hw->regs->BR = (IPBUS_FREQ + rate * 8ul) / (rate * 16ul);
 251 }
 252
 253 static void setparity(struct SerialHardware* _hw, int parity)
 254 {
 255         // ???
 256         ASSERT(0);
 257 }
 258
 259
 260 #if CONFIG_SER_MULTI
 261
 262 static void multi_init(void)
 263 {
 264         static bool flag = false;
 265         int i;
 266
 267         if (flag)
 268                 return;
 269
 270         for (i = 0; i < MAX_MULTI_GROUPS; ++i)
 271                 sem_init(&multi_sems[i]);
 272         flag = true;
 273 }
 274
 275 static void init_lock(struct SerialHardware* _hw, struct Serial *ser)
 276 {
 277         struct SCI* hw = (struct SCI*)_hw;
 278
 279         // Initialize the multi engine (if needed)
 280         multi_init();
 281
 282         // Acquire the lock of the semaphore for this group
 283         ASSERT(hw->num_group >= 0);
 284         ASSERT(hw->num_group < MAX_MULTI_GROUPS);
 285         sem_obtain(&multi_sems[hw->num_group]);
 286
 287         // Do a hardware switch to the given serial
 288         ser_hw_switch(hw->num_group, hw->id);
 289
 290         init(_hw, ser);
 291 }
 292
 293 static void cleanup_unlock(struct SerialHardware* _hw)
 294 {
 295         struct SCI* hw = (struct SCI*)_hw;
 296
 297         cleanup(_hw);
 298
 299         sem_release(&multi_sems[hw->num_group]);
 300 }
 301
 302 #endif /* CONFIG_SER_MULTI */
 303
 304
 305 static const struct SerialHardwareVT SCI_VT =
 306 {
 307         .init = init,
 308         .cleanup = cleanup,
 309         .setBaudrate = setbaudrate,
 310         .setParity = setparity,
 311         .txStart = enable_tx_irq,
 312         .txSending = tx_irq_enabled,
 313 };
 314
 315 #if CONFIG_SER_MULTI
 316 static const struct SerialHardwareVT SCI_MULTI_VT =
 317 {
 318         .init = init_lock,
 319         .cleanup = cleanup_unlock,
 320         .setBaudrate = setbaudrate,
 321         .setParity = setparity,
 322         .txStart = enable_tx_irq,
 323         .txSending = tx_irq_enabled,
 324 };
 325 #endif /* CONFIG_SER_MULTI */
 326
 327 #define SCI_DESC_NORMAL(hwch) \
 328         { \
 329                 .hw = \
 330                 { \
 331                         .table = &SCI_VT, \
 332                         .rxbuffer = ser ## hwch ## _fifo_rx, \
 333                         .txbuffer = ser ## hwch ## _fifo_tx, \
 334                         .rxbuffer_size = countof(ser ## hwch ## _fifo_rx), \
 335                         .txbuffer_size = countof(ser ## hwch ## _fifo_tx), \
 336                 }, \
 337                 .regs = &REG_SCI[hwch], \
 338                 .irq_rx = IRQ_SCI ## hwch ## _RECEIVER_FULL, \
 339                 .irq_tx = IRQ_SCI ## hwch ## _TRANSMITTER_READY, \
 340                 .num_group = -1, \
 341                 .id = -1, \
 342         } \
 343         /**/
 344
 345 #if CONFIG_SER_MULTI
 346 #define SCI_DESC_MULTI(hwch, group_, id_) \
 347         { \
 348                 .hw = \
 349                 { \
 350                         .table = &SCI_MULTI_VT, \
 351                         .rxbuffer = ser ## hwch ## _fifo_rx, \
 352                         .txbuffer = ser ## hwch ## _fifo_tx, \
 353                         .rxbuffer_size = countof(ser ## hwch ## _fifo_rx), \
 354                         .txbuffer_size = countof(ser ## hwch ## _fifo_tx), \
 355                 }, \
 356                 .regs = &REG_SCI[hwch], \
 357                 .irq_rx = IRQ_SCI ## hwch ## _RECEIVER_FULL, \
 358                 .irq_tx = IRQ_SCI ## hwch ## _TRANSMITTER_READY, \
 359                 .num_group = group_, \
 360                 .id = id_, \
 361         } \
 362         /**/
 363 #endif /* CONFIG_SER_MULTI */
 364
 365 // \todo Move this into hw.h, with a little preprocessor magic
 366 static struct SCI SCIDescs[] =
 367 {
 368         SCI_DESC_NORMAL(0),
 369         SCI_DESC_MULTI(1, 0, 0),
 370         SCI_DESC_MULTI(1, 0, 1),
 371 };
 372
 373 struct SerialHardware* ser_hw_getdesc(int unit)
 374 {
 375         ASSERT(unit < countof(SCIDescs));
 376         return &SCIDescs[unit].hw;
 377 }