source: rtems/cpukit/dev/serial/sc16is752.c @ e99847bf

5
Last change on this file since e99847bf was e99847bf, checked in by Christian Mauderer <christian.mauderer@…>, on Feb 21, 2019 at 6:01:22 AM

dev/sc16is752: Fix parity generation.

  • Property mode set to 100644
File size: 9.7 KB
Line 
1/*
2 * Copyright (c) 2016 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * The license and distribution terms for this file may be
11 * found in the file LICENSE in this distribution or at
12 * http://www.rtems.org/license/LICENSE.
13 */
14
15
16#include <dev/serial/sc16is752.h>
17
18#include <sys/param.h>
19
20#include <assert.h>
21#include <stdio.h>
22#include <fcntl.h>
23
24#include <rtems/seterr.h>
25
26#include "sc16is752-regs.h"
27
28static void write_reg(
29  sc16is752_context *ctx,
30  uint8_t addr,
31  const uint8_t *data,
32  size_t len
33)
34{
35  (*ctx->write_reg)(ctx, addr, data, len);
36}
37
38static void read_reg(
39  sc16is752_context *ctx,
40  uint8_t addr,
41  uint8_t *data,
42  size_t len
43)
44{
45  (*ctx->read_reg)(ctx, addr, data, len);
46}
47
48static void read_2_reg(
49  sc16is752_context *ctx,
50  uint8_t addr_0,
51  uint8_t addr_1,
52  uint8_t data[2]
53)
54{
55  (*ctx->read_2_reg)(ctx, addr_0, addr_1, data);
56}
57
58static bool is_sleep_mode_enabled(sc16is752_context *ctx)
59{
60  return (ctx->ier & SC16IS752_IER_SLEEP_MODE) != 0;
61}
62
63static void set_sleep_mode(sc16is752_context *ctx, bool enable)
64{
65  if (enable) {
66    ctx->ier |= SC16IS752_IER_SLEEP_MODE;
67  } else {
68    ctx->ier &= ~SC16IS752_IER_SLEEP_MODE;
69  }
70
71  write_reg(ctx, SC16IS752_IER, &ctx->ier, 1);
72}
73
74static void set_mcr_dll_dlh(
75  sc16is752_context *ctx,
76  uint8_t mcr,
77  uint32_t divisor
78)
79{
80  bool sleep_mode = is_sleep_mode_enabled(ctx);
81  uint8_t dll = (uint8_t)divisor;
82  uint8_t dlh = (uint8_t)(divisor >> 8);
83
84  if (sleep_mode) {
85    set_sleep_mode(ctx, false);
86  }
87
88  ctx->lcr |= SC16IS752_LCR_ENABLE_DIVISOR;
89  write_reg(ctx, SC16IS752_LCR, &ctx->lcr, 1);
90
91  write_reg(ctx, SC16IS752_MCR, &mcr, 1);
92  write_reg(ctx, SC16IS752_DLH, &dlh, 1);
93  write_reg(ctx, SC16IS752_DLL, &dll, 1);
94
95  ctx->lcr &= ~SC16IS752_LCR_ENABLE_DIVISOR;
96  write_reg(ctx, SC16IS752_LCR, &ctx->lcr, 1);
97
98  if (sleep_mode) {
99    set_sleep_mode(ctx, true);
100  }
101}
102
103static void set_efr(sc16is752_context *ctx, uint8_t efr)
104{
105  uint8_t lcr = ctx->lcr;
106
107  ctx->lcr = 0xbf;
108  write_reg(ctx, SC16IS752_LCR, &ctx->lcr, 1);
109
110  write_reg(ctx, SC16IS752_EFR, &efr, 1);
111
112  ctx->lcr = lcr;
113  write_reg(ctx, SC16IS752_LCR, &ctx->lcr, 1);
114}
115
116static bool set_baud(sc16is752_context *ctx, rtems_termios_baud_t baud)
117{
118  uint32_t freq = ctx->input_frequency;
119  uint8_t mcr;
120  uint32_t divisor;
121
122  read_reg(ctx, SC16IS752_MCR, &mcr, 1);
123
124  divisor = freq / baud / 16;
125  if (divisor > 0xFFFF){
126    divisor = (freq / (4 * baud)) / 16;
127    if (divisor > 0xFFFF){
128      return false;
129    } else {
130      mcr |= SC16IS752_MCR_PRESCALE_NEEDED;
131    }
132  } else {
133    mcr &= ~SC16IS752_MCR_PRESCALE_NEEDED;
134  }
135
136  set_mcr_dll_dlh(ctx, mcr, divisor);
137  return true;
138}
139
140static bool sc16is752_set_attributes(
141  rtems_termios_device_context *base,
142  const struct termios *term
143)
144{
145  sc16is752_context *ctx = (sc16is752_context *)base;
146  rtems_termios_baud_t baud;
147
148  ctx->lcr = 0;
149
150  baud = rtems_termios_baud_to_number(term->c_ospeed);
151
152  if (baud > 0) {
153    if (!set_baud(ctx, baud)){
154      return false;
155    }
156
157    ctx->efcr &= ~SC16IS752_EFCR_TX_DISABLE;
158
159    if ((term->c_cflag & CREAD) == 0){
160      ctx->efcr |= SC16IS752_EFCR_RX_DISABLE;
161    } else {
162      ctx->efcr &= ~SC16IS752_EFCR_RX_DISABLE;
163    }
164  } else {
165    ctx->efcr |= SC16IS752_EFCR_RX_DISABLE | SC16IS752_EFCR_TX_DISABLE;
166  }
167
168  write_reg(ctx, SC16IS752_EFCR, &ctx->efcr, 1);
169
170  switch (term->c_cflag & CSIZE) {
171    case CS5:
172      ctx->lcr |= SC16IS752_LCR_CHRL_5_BIT;
173      break;
174    case CS6:
175      ctx->lcr |= SC16IS752_LCR_CHRL_6_BIT;
176      break;
177    case CS7:
178      ctx->lcr |= SC16IS752_LCR_CHRL_7_BIT;
179      break;
180    case CS8:
181      ctx->lcr |= SC16IS752_LCR_CHRL_8_BIT;
182      break;
183  }
184
185  if ((term->c_cflag & PARENB) != 0){
186    ctx->lcr |= SC16IS752_LCR_SET_PARITY;
187    if ((term->c_cflag & PARODD) != 0) {
188      ctx->lcr &= ~SC16IS752_LCR_EVEN_PARITY;
189    } else {
190      ctx->lcr |= SC16IS752_LCR_EVEN_PARITY;
191    }
192  } else {
193    ctx->lcr &= ~SC16IS752_LCR_SET_PARITY;
194  }
195
196  if ((term->c_cflag & CSTOPB) != 0) {
197    ctx->lcr |= SC16IS752_LCR_2_STOP_BIT;
198  } else {
199    ctx->lcr &= ~SC16IS752_LCR_2_STOP_BIT;
200  }
201
202  write_reg(ctx, SC16IS752_LCR, &ctx->lcr, 1);
203  return true;
204}
205
206static bool sc16is752_first_open(
207  rtems_termios_tty *tty,
208  rtems_termios_device_context *base,
209  struct termios *term,
210  rtems_libio_open_close_args_t *args
211)
212{
213  bool ok;
214  uint8_t fcr;
215
216  (void)args;
217  sc16is752_context *ctx = (sc16is752_context *)base;
218
219  ctx->tty = tty;
220
221  ok = (*ctx->first_open)(ctx);
222  if (!ok) {
223    return ok;
224  }
225
226  if (ctx->mode == SC16IS752_MODE_RS485) {
227    ctx->efcr = SC16IS752_EFCR_RS485_ENABLE;
228  } else {
229    ctx->efcr = 0;
230  }
231
232  write_reg(ctx, SC16IS752_FCR, &ctx->efcr, 1);
233
234  fcr = SC16IS752_FCR_FIFO_EN
235    | SC16IS752_FCR_RX_FIFO_RST
236    | SC16IS752_FCR_TX_FIFO_RST
237    | SC16IS752_FCR_RX_FIFO_TRG_16
238    | SC16IS752_FCR_TX_FIFO_TRG_32;
239  write_reg(ctx, SC16IS752_FCR, &fcr, 1);
240
241  ctx->ier = SC16IS752_IER_RHR;
242  write_reg(ctx, SC16IS752_IER, &ctx->ier, 1);
243  set_efr(ctx, SC16IS752_EFR_ENHANCED_FUNC_ENABLE);
244
245  rtems_termios_set_initial_baud(tty, 115200);
246  ok = sc16is752_set_attributes(base, term);
247  if (!ok) {
248    return ok;
249  }
250
251  ok = (*ctx->install_irq)(ctx);
252  return ok;
253}
254
255static void sc16is752_last_close(
256  rtems_termios_tty *tty,
257  rtems_termios_device_context *base,
258  rtems_libio_open_close_args_t *args
259)
260{
261  sc16is752_context *ctx = (sc16is752_context *)base;
262
263  (void)tty;
264  (void)args;
265  (*ctx->last_close)(ctx);
266}
267
268static void sc16is752_write(
269  rtems_termios_device_context *base,
270  const char *buf,
271  size_t len
272)
273{
274  sc16is752_context *ctx = (sc16is752_context *)base;
275
276  if (len > 0) {
277    ctx->ier |= SC16IS752_IER_THR;
278    len = MIN(len, 32);
279    ctx->tx_in_progress = (uint8_t)len;
280    write_reg(ctx, SC16IS752_THR, (const uint8_t *)&buf[0], len);
281    write_reg(ctx, SC16IS752_IER, &ctx->ier, 1);
282  } else {
283    ctx->tx_in_progress = 0;
284    ctx->ier &= ~SC16IS752_IER_THR;
285    write_reg(ctx, SC16IS752_IER, &ctx->ier, 1);
286  }
287}
288
289static void sc16is752_get_modem_bits(sc16is752_context *ctx, int *bits)
290{
291  *bits = 0;
292  uint8_t msr;
293  uint8_t mcr;
294
295  read_reg(ctx, SC16IS752_MSR, &msr, 1);
296  read_reg(ctx, SC16IS752_MCR, &mcr, 1);
297
298  if (msr & SC16IS752_MSR_CTS) {
299    *bits |= TIOCM_CTS;
300  }
301  if (msr & SC16IS752_MSR_DSR) {
302    *bits |= TIOCM_DSR;
303  }
304  if (msr & SC16IS752_MSR_RI) {
305    *bits |= TIOCM_RI;
306  }
307  if (msr & SC16IS752_MSR_CD) {
308    *bits |= TIOCM_CD;
309  }
310  if ((mcr & SC16IS752_MCR_DTR) == 0) {
311    *bits |= TIOCM_DTR;
312  }
313  if ((mcr & SC16IS752_MCR_RTS) == 0) {
314    *bits |= TIOCM_RTS;
315  }
316}
317
318static void sc16is752_set_modem_bits(
319  sc16is752_context *ctx, int *bits, int set, int clear
320)
321{
322  uint8_t mcr;
323
324  read_reg(ctx, SC16IS752_MCR, &mcr, 1);
325
326  if (bits != NULL) {
327    if ((*bits & TIOCM_DTR) == 0) {
328      mcr |= SC16IS752_MCR_DTR;
329    } else {
330      mcr &= ~SC16IS752_MCR_DTR;
331    }
332
333    if ((*bits & TIOCM_RTS) == 0) {
334      mcr |= SC16IS752_MCR_RTS;
335    } else {
336      mcr &= ~SC16IS752_MCR_RTS;
337    }
338  }
339
340  if ((set & TIOCM_DTR) != 0) {
341    mcr &= ~SC16IS752_MCR_DTR;
342  }
343  if ((set & TIOCM_RTS) != 0) {
344    mcr &= ~SC16IS752_MCR_RTS;
345  }
346  if ((clear & TIOCM_DTR) != 0) {
347    mcr |= SC16IS752_MCR_DTR;
348  }
349  if ((clear & TIOCM_RTS) != 0) {
350    mcr |= SC16IS752_MCR_RTS;
351  }
352
353  write_reg(ctx, SC16IS752_MCR, &mcr, 1);
354}
355
356static int sc16is752_ioctl(
357  rtems_termios_device_context *base,
358  ioctl_command_t               request,
359  void                         *buffer
360)
361{
362  sc16is752_context *ctx = (sc16is752_context *)base;
363  uint8_t regval;
364
365  switch (request) {
366    case SC16IS752_SET_SLEEP_MODE:
367      set_sleep_mode(ctx, *(int *)buffer != 0);
368      break;
369    case SC16IS752_GET_SLEEP_MODE:
370      *(int *)buffer = is_sleep_mode_enabled(ctx);
371      break;
372    case SC16IS752_SET_IOCONTROL:
373      regval = (*(uint8_t *)buffer) & ~SC16IS752_IOCONTROL_SRESET;
374      write_reg(ctx, SC16IS752_IOCONTROL, &regval, 1);
375      break;
376    case SC16IS752_GET_IOCONTROL:
377      read_reg(ctx, SC16IS752_IOCONTROL, (uint8_t *)buffer, 1);
378      break;
379    case SC16IS752_SET_IODIR:
380      write_reg(ctx, SC16IS752_IODIR, (uint8_t *)buffer, 1);
381      break;
382    case SC16IS752_GET_IODIR:
383      read_reg(ctx, SC16IS752_IODIR, (uint8_t *)buffer, 1);
384      break;
385    case SC16IS752_SET_IOSTATE:
386      write_reg(ctx, SC16IS752_IOSTATE, (uint8_t *)buffer, 1);
387      break;
388    case SC16IS752_GET_IOSTATE:
389      read_reg(ctx, SC16IS752_IOSTATE, (uint8_t *)buffer, 1);
390      break;
391    case TIOCMGET:
392      sc16is752_get_modem_bits(ctx, (int *)buffer);
393      break;
394    case TIOCMSET:
395      sc16is752_set_modem_bits(ctx, (int *)buffer, 0, 0);
396      break;
397    case TIOCMBIS:
398      sc16is752_set_modem_bits(ctx, NULL, *(int *)buffer, 0);
399      break;
400    case TIOCMBIC:
401      sc16is752_set_modem_bits(ctx, NULL, 0, *(int *)buffer);
402      break;
403    default:
404      rtems_set_errno_and_return_minus_one(EINVAL);
405  }
406
407  return 0;
408}
409
410const rtems_termios_device_handler sc16is752_termios_handler = {
411  .first_open = sc16is752_first_open,
412  .last_close = sc16is752_last_close,
413  .write = sc16is752_write,
414  .set_attributes = sc16is752_set_attributes,
415  .ioctl = sc16is752_ioctl,
416  .mode = TERMIOS_IRQ_SERVER_DRIVEN
417};
418
419void sc16is752_interrupt_handler(void *arg)
420{
421  sc16is752_context *ctx = (sc16is752_context *)arg;
422  uint8_t data[2];
423  uint8_t iir;
424
425  read_2_reg(ctx, SC16IS752_IIR, SC16IS752_RXLVL, data);
426  iir = data[0];
427
428  if ((iir & SC16IS752_IIR_TX_INTERRUPT) != 0 && ctx->tx_in_progress > 0) {
429    rtems_termios_dequeue_characters(ctx->tty, ctx->tx_in_progress);
430  }
431
432  if ((iir & SC16IS752_IIR_RX_INTERRUPT) != 0) {
433    uint8_t buf[SC16IS752_FIFO_DEPTH];
434    uint8_t rxlvl = data[1];
435
436    rxlvl = MIN(rxlvl, SC16IS752_FIFO_DEPTH);
437    read_reg(ctx, SC16IS752_RHR, &buf[0], rxlvl);
438    rtems_termios_enqueue_raw_characters(ctx->tty, (const char *)&buf[0], rxlvl);
439  }
440}
Note: See TracBrowser for help on using the repository browser.