| /* Card UART handling |
| * |
| * (C) 2019-2020 by Harald Welte <laforge@gnumonks.org> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA |
| */ |
| |
| #include <errno.h> |
| #include <string.h> |
| #include <osmocom/core/linuxlist.h> |
| #include <osmocom/core/utils.h> |
| #include <osmocom/core/timer.h> |
| |
| #include "cuart.h" |
| |
| static LLIST_HEAD(g_cuart_drivers); |
| |
| const struct value_string card_uart_event_vals[] = { |
| OSMO_VALUE_STRING(CUART_E_RX_SINGLE), |
| OSMO_VALUE_STRING(CUART_E_RX_COMPLETE), |
| OSMO_VALUE_STRING(CUART_E_RX_TIMEOUT), |
| OSMO_VALUE_STRING(CUART_E_TX_COMPLETE), |
| { 0, NULL } |
| }; |
| |
| static struct card_uart_driver *cuart_drv_by_name(const char *driver_name) |
| { |
| struct card_uart_driver *drv; |
| llist_for_each_entry(drv, &g_cuart_drivers, list) { |
| if (!strcmp(drv->name, driver_name)) |
| return drv; |
| } |
| return NULL; |
| } |
| |
| /* obtain the current ETU in us */ |
| static int get_etu_in_us(struct card_uart *cuart) |
| { |
| OSMO_ASSERT(cuart); |
| OSMO_ASSERT(cuart->driver); |
| OSMO_ASSERT(cuart->driver->ops); |
| OSMO_ASSERT(cuart->driver->ops->ctrl); |
| |
| return 1e6 / cuart->driver->ops->ctrl(cuart, CUART_CTL_GET_BAUDRATE, 0); |
| } |
| |
| /* software waiting-time timer has expired */ |
| static void card_uart_wtime_cb(void *data) |
| { |
| struct card_uart *cuart = (struct card_uart *) data; |
| card_uart_notification(cuart, CUART_E_RX_TIMEOUT, NULL); |
| /* should we automatically disable the receiver? */ |
| } |
| |
| void card_uart_wtime_restart(struct card_uart *cuart) |
| { |
| int secs, usecs; |
| |
| if(!cuart->current_wtime_byte) |
| return; |
| |
| int etu_in_us = get_etu_in_us(cuart) + 1; |
| cuart->wtime_etu = cuart->wtime_etu ? cuart->wtime_etu : 1; |
| |
| /* timemout is wtime * ETU * expected number of bytes */ |
| usecs = etu_in_us * cuart->wtime_etu * cuart->current_wtime_byte; |
| |
| /* limit lower wait time to reasonable value */ |
| usecs = usecs < 300000 ? 300000 : usecs; |
| |
| if (usecs > 1000000) { |
| secs = usecs / 1000000; |
| usecs = usecs % 1000000; |
| } else |
| secs = 0; |
| osmo_timer_schedule(&cuart->wtime_tmr, secs, usecs); |
| } |
| |
| int card_uart_open(struct card_uart *cuart, const char *driver_name, const char *device_name) |
| { |
| struct card_uart_driver *drv = cuart_drv_by_name(driver_name); |
| int rc; |
| |
| if (!drv) |
| return -ENODEV; |
| |
| cuart->wtime_etu = 9600; /* ISO 7816-3 Section 8.1 */ |
| cuart->rx_enabled = true; |
| cuart->rx_threshold = 1; |
| osmo_timer_setup(&cuart->wtime_tmr, card_uart_wtime_cb, cuart); |
| |
| rc = drv->ops->open(cuart, device_name); |
| if (rc < 0) |
| return rc; |
| |
| cuart->driver = drv; |
| return 0; |
| } |
| |
| int card_uart_close(struct card_uart *cuart) |
| { |
| OSMO_ASSERT(cuart); |
| OSMO_ASSERT(cuart->driver); |
| OSMO_ASSERT(cuart->driver->ops); |
| OSMO_ASSERT(cuart->driver->ops->close); |
| return cuart->driver->ops->close(cuart); |
| } |
| |
| int card_uart_ctrl(struct card_uart *cuart, enum card_uart_ctl ctl, int arg) |
| { |
| int rc; |
| OSMO_ASSERT(cuart); |
| OSMO_ASSERT(cuart->driver); |
| OSMO_ASSERT(cuart->driver->ops); |
| OSMO_ASSERT(cuart->driver->ops->ctrl); |
| |
| rc = cuart->driver->ops->ctrl(cuart, ctl, arg); |
| if (rc < 0) |
| return rc; |
| |
| switch (ctl) { |
| case CUART_CTL_WTIME: |
| cuart->wtime_etu = arg; |
| break; |
| case CUART_CTL_RX: |
| cuart->rx_enabled = arg ? true : false; |
| if (!cuart->rx_enabled) |
| osmo_timer_del(&cuart->wtime_tmr); |
| // else |
| // card_uart_wtime_restart(cuart); |
| break; |
| case CUART_CTL_RX_TIMER_HINT: |
| cuart->current_wtime_byte = arg; |
| if(arg) |
| card_uart_wtime_restart(cuart); |
| else |
| osmo_timer_del(&cuart->wtime_tmr); |
| break; |
| default: |
| break; |
| } |
| |
| return rc; |
| } |
| |
| int card_uart_tx(struct card_uart *cuart, const uint8_t *data, size_t len, bool rx_after_complete) |
| { |
| OSMO_ASSERT(cuart); |
| OSMO_ASSERT(cuart->driver); |
| OSMO_ASSERT(cuart->driver->ops); |
| OSMO_ASSERT(cuart->driver->ops->async_tx); |
| |
| OSMO_ASSERT(!cuart->tx_busy); |
| cuart->tx_busy = true; |
| cuart->rx_after_tx_compl = rx_after_complete; |
| /* disable receiver to avoid receiving what we transmit */ |
| card_uart_ctrl(cuart, CUART_CTL_RX, false); |
| |
| return cuart->driver->ops->async_tx(cuart, data, len); |
| } |
| |
| int card_uart_rx(struct card_uart *cuart, uint8_t *data, size_t len) |
| { |
| OSMO_ASSERT(cuart); |
| OSMO_ASSERT(cuart->driver); |
| OSMO_ASSERT(cuart->driver->ops); |
| OSMO_ASSERT(cuart->driver->ops->async_rx); |
| return cuart->driver->ops->async_rx(cuart, data, len); |
| } |
| |
| void card_uart_set_rx_threshold(struct card_uart *cuart, size_t rx_threshold) |
| { |
| cuart->rx_threshold = rx_threshold; |
| } |
| |
| void card_uart_notification(struct card_uart *cuart, enum card_uart_event evt, void *data) |
| { |
| OSMO_ASSERT(cuart); |
| OSMO_ASSERT(cuart->handle_event); |
| |
| switch (evt) { |
| case CUART_E_TX_COMPLETE: |
| cuart->tx_busy = false; |
| /* re-enable receiver if we're done with transmit */ |
| if (cuart->rx_after_tx_compl) |
| card_uart_ctrl(cuart, CUART_CTL_RX, true); |
| break; |
| // case CUART_E_RX_COMPLETE: |
| // osmo_timer_del(&cuart->wtime_tmr); |
| // break; |
| // case CUART_E_RX_SINGLE: |
| // card_uart_wtime_restart(cuart); |
| // break; |
| default: |
| break; |
| } |
| |
| cuart->handle_event(cuart, evt, data); |
| } |
| |
| int card_uart_driver_register(struct card_uart_driver *drv) |
| { |
| OSMO_ASSERT(!cuart_drv_by_name(drv->name)); |
| OSMO_ASSERT(drv->name); |
| OSMO_ASSERT(drv->ops); |
| llist_add_tail(&drv->list, &g_cuart_drivers); |
| return 0; |
| } |