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

5
Last change on this file since b38887a was b38887a, checked in by Sebastian Huber <sebastian.huber@…>, on Oct 5, 2018 at 11:39:49 AM

dev/sc16is752: Deal with a baud of zero

Avoid division by zero and instead disable rx/tx in case of a zero baud
value. Problem identified by Coverity Scan.

  • Property mode set to 100644
File size: 9.6 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    if ((term->c_cflag & PARODD) != 0) {
187      ctx->lcr &= ~SC16IS752_LCR_EVEN_PARITY;
188    } else {
189      ctx->lcr |= SC16IS752_LCR_EVEN_PARITY;
190    }
191  } else {
192    ctx->lcr &= ~SC16IS752_LCR_SET_PARITY;
193  }
194
195  if ((term->c_cflag & CSTOPB) != 0) {
196    ctx->lcr |= SC16IS752_LCR_2_STOP_BIT;
197  } else {
198    ctx->lcr &= ~SC16IS752_LCR_2_STOP_BIT;
199  }
200
201  write_reg(ctx, SC16IS752_LCR, &ctx->lcr, 1);
202  return true;
203}
204
205static bool sc16is752_first_open(
206  rtems_termios_tty *tty,
207  rtems_termios_device_context *base,
208  struct termios *term,
209  rtems_libio_open_close_args_t *args
210)
211{
212  bool ok;
213  uint8_t fcr;
214
215  (void)args;
216  sc16is752_context *ctx = (sc16is752_context *)base;
217
218  ctx->tty = tty;
219
220  ok = (*ctx->first_open)(ctx);
221  if (!ok) {
222    return ok;
223  }
224
225  if (ctx->mode == SC16IS752_MODE_RS485) {
226    ctx->efcr = SC16IS752_EFCR_RS485_ENABLE;
227  } else {
228    ctx->efcr = 0;
229  }
230
231  write_reg(ctx, SC16IS752_FCR, &ctx->efcr, 1);
232
233  fcr = SC16IS752_FCR_FIFO_EN
234    | SC16IS752_FCR_RX_FIFO_RST
235    | SC16IS752_FCR_TX_FIFO_RST
236    | SC16IS752_FCR_RX_FIFO_TRG_16
237    | SC16IS752_FCR_TX_FIFO_TRG_32;
238  write_reg(ctx, SC16IS752_FCR, &fcr, 1);
239
240  ctx->ier = SC16IS752_IER_RHR;
241  write_reg(ctx, SC16IS752_IER, &ctx->ier, 1);
242  set_efr(ctx, SC16IS752_EFR_ENHANCED_FUNC_ENABLE);
243
244  rtems_termios_set_initial_baud(tty, 115200);
245  ok = sc16is752_set_attributes(base, term);
246  if (!ok) {
247    return ok;
248  }
249
250  ok = (*ctx->install_irq)(ctx);
251  return ok;
252}
253
254static void sc16is752_last_close(
255  rtems_termios_tty *tty,
256  rtems_termios_device_context *base,
257  rtems_libio_open_close_args_t *args
258)
259{
260  sc16is752_context *ctx = (sc16is752_context *)base;
261
262  (void)tty;
263  (void)args;
264  (*ctx->last_close)(ctx);
265}
266
267static void sc16is752_write(
268  rtems_termios_device_context *base,
269  const char *buf,
270  size_t len
271)
272{
273  sc16is752_context *ctx = (sc16is752_context *)base;
274
275  if (len > 0) {
276    ctx->ier |= SC16IS752_IER_THR;
277    len = MIN(len, 32);
278    ctx->tx_in_progress = (uint8_t)len;
279    write_reg(ctx, SC16IS752_THR, (const uint8_t *)&buf[0], len);
280    write_reg(ctx, SC16IS752_IER, &ctx->ier, 1);
281  } else {
282    ctx->tx_in_progress = 0;
283    ctx->ier &= ~SC16IS752_IER_THR;
284    write_reg(ctx, SC16IS752_IER, &ctx->ier, 1);
285  }
286}
287
288static void sc16is752_get_modem_bits(sc16is752_context *ctx, int *bits)
289{
290  *bits = 0;
291  uint8_t msr;
292  uint8_t mcr;
293
294  read_reg(ctx, SC16IS752_MSR, &msr, 1);
295  read_reg(ctx, SC16IS752_MCR, &mcr, 1);
296
297  if (msr & SC16IS752_MSR_CTS) {
298    *bits |= TIOCM_CTS;
299  }
300  if (msr & SC16IS752_MSR_DSR) {
301    *bits |= TIOCM_DSR;
302  }
303  if (msr & SC16IS752_MSR_RI) {
304    *bits |= TIOCM_RI;
305  }
306  if (msr & SC16IS752_MSR_CD) {
307    *bits |= TIOCM_CD;
308  }
309  if ((mcr & SC16IS752_MCR_DTR) == 0) {
310    *bits |= TIOCM_DTR;
311  }
312  if ((mcr & SC16IS752_MCR_RTS) == 0) {
313    *bits |= TIOCM_RTS;
314  }
315}
316
317static void sc16is752_set_modem_bits(
318  sc16is752_context *ctx, int *bits, int set, int clear
319)
320{
321  uint8_t mcr;
322
323  read_reg(ctx, SC16IS752_MCR, &mcr, 1);
324
325  if (bits != NULL) {
326    if ((*bits & TIOCM_DTR) == 0) {
327      mcr |= SC16IS752_MCR_DTR;
328    } else {
329      mcr &= ~SC16IS752_MCR_DTR;
330    }
331
332    if ((*bits & TIOCM_RTS) == 0) {
333      mcr |= SC16IS752_MCR_RTS;
334    } else {
335      mcr &= ~SC16IS752_MCR_RTS;
336    }
337  }
338
339  if ((set & TIOCM_DTR) != 0) {
340    mcr &= ~SC16IS752_MCR_DTR;
341  }
342  if ((set & TIOCM_RTS) != 0) {
343    mcr &= ~SC16IS752_MCR_RTS;
344  }
345  if ((clear & TIOCM_DTR) != 0) {
346    mcr |= SC16IS752_MCR_DTR;
347  }
348  if ((clear & TIOCM_RTS) != 0) {
349    mcr |= SC16IS752_MCR_RTS;
350  }
351
352  write_reg(ctx, SC16IS752_MCR, &mcr, 1);
353}
354
355static int sc16is752_ioctl(
356  rtems_termios_device_context *base,
357  ioctl_command_t               request,
358  void                         *buffer
359)
360{
361  sc16is752_context *ctx = (sc16is752_context *)base;
362  uint8_t regval;
363
364  switch (request) {
365    case SC16IS752_SET_SLEEP_MODE:
366      set_sleep_mode(ctx, *(int *)buffer != 0);
367      break;
368    case SC16IS752_GET_SLEEP_MODE:
369      *(int *)buffer = is_sleep_mode_enabled(ctx);
370      break;
371    case SC16IS752_SET_IOCONTROL:
372      regval = (*(uint8_t *)buffer) & ~SC16IS752_IOCONTROL_SRESET;
373      write_reg(ctx, SC16IS752_IOCONTROL, &regval, 1);
374      break;
375    case SC16IS752_GET_IOCONTROL:
376      read_reg(ctx, SC16IS752_IOCONTROL, (uint8_t *)buffer, 1);
377      break;
378    case SC16IS752_SET_IODIR:
379      write_reg(ctx, SC16IS752_IODIR, (uint8_t *)buffer, 1);
380      break;
381    case SC16IS752_GET_IODIR:
382      read_reg(ctx, SC16IS752_IODIR, (uint8_t *)buffer, 1);
383      break;
384    case SC16IS752_SET_IOSTATE:
385      write_reg(ctx, SC16IS752_IOSTATE, (uint8_t *)buffer, 1);
386      break;
387    case SC16IS752_GET_IOSTATE:
388      read_reg(ctx, SC16IS752_IOSTATE, (uint8_t *)buffer, 1);
389      break;
390    case TIOCMGET:
391      sc16is752_get_modem_bits(ctx, (int *)buffer);
392      break;
393    case TIOCMSET:
394      sc16is752_set_modem_bits(ctx, (int *)buffer, 0, 0);
395      break;
396    case TIOCMBIS:
397      sc16is752_set_modem_bits(ctx, NULL, *(int *)buffer, 0);
398      break;
399    case TIOCMBIC:
400      sc16is752_set_modem_bits(ctx, NULL, 0, *(int *)buffer);
401      break;
402    default:
403      rtems_set_errno_and_return_minus_one(EINVAL);
404  }
405
406  return 0;
407}
408
409const rtems_termios_device_handler sc16is752_termios_handler = {
410  .first_open = sc16is752_first_open,
411  .last_close = sc16is752_last_close,
412  .write = sc16is752_write,
413  .set_attributes = sc16is752_set_attributes,
414  .ioctl = sc16is752_ioctl,
415  .mode = TERMIOS_IRQ_SERVER_DRIVEN
416};
417
418void sc16is752_interrupt_handler(void *arg)
419{
420  sc16is752_context *ctx = (sc16is752_context *)arg;
421  uint8_t data[2];
422  uint8_t iir;
423
424  read_2_reg(ctx, SC16IS752_IIR, SC16IS752_RXLVL, data);
425  iir = data[0];
426
427  if ((iir & SC16IS752_IIR_TX_INTERRUPT) != 0 && ctx->tx_in_progress > 0) {
428    rtems_termios_dequeue_characters(ctx->tty, ctx->tx_in_progress);
429  }
430
431  if ((iir & SC16IS752_IIR_RX_INTERRUPT) != 0) {
432    uint8_t buf[SC16IS752_FIFO_DEPTH];
433    uint8_t rxlvl = data[1];
434
435    rxlvl = MIN(rxlvl, SC16IS752_FIFO_DEPTH);
436    read_reg(ctx, SC16IS752_RHR, &buf[0], rxlvl);
437    rtems_termios_enqueue_raw_characters(ctx->tty, (const char *)&buf[0], rxlvl);
438  }
439}
Note: See TracBrowser for help on using the repository browser.