X-Git-Url: http://rtime.felk.cvut.cz/gitweb/pes-rpp/rpp-lib.git/blobdiff_plain/70a8b6249b591e1bb9d5e042baa0eaee392878a7..5e5f1df1fad4674a87019fa6c72a2f2d2e0d8db0:/rpp/src/rpp/din.c diff --git a/rpp/src/rpp/din.c b/rpp/src/rpp/din.c index 0aaf5aa..0405645 100644 --- a/rpp/src/rpp/din.c +++ b/rpp/src/rpp/din.c @@ -1,20 +1,12 @@ -/* Copyright (C) 2013 Czech Technical University in Prague +/* Copyright (C) 2013, 2015 Czech Technical University in Prague * * Authors: * - Carlos Jenkins * - * 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, see . + * This document contains proprietary information belonging to Czech + * Technical University in Prague. Passing on and copying of this + * document, and communication of its contents is not permitted + * without prior written authorization. * * File : din.c * Abstract: @@ -27,163 +19,219 @@ #include "rpp/rpp.h" +#include "rpp/mutex.h" -#if rppCONFIG_INCLUDE_DIN == 1 - -#if rppCONFIG_DRV == 1 +#ifndef FREERTOS_POSIX #include "drv/din.h" +#include "drv/spi_def.h" #endif +RPP_MUTEX_DEFINE(mutex_din); + static boolean_t initialized = FALSE; int8_t rpp_din_init() { - if(initialized) { - return FAILURE; - } - initialized = TRUE; + if (initialized) + return FAILURE; + if (!RPP_MUTEX_INIT(mutex_din)) + return FAILURE; + initialized = TRUE; +#ifndef FREERTOS_POSIX + dmmInit(); + gioInit(); + hetInit(); + spi_tms570_init(spi_ifcs, ARRAY_SIZE(spi_ifcs)); +#endif - // FIXME: Implement. - return SUCCESS; + return SUCCESS; +} + +int8_t rpp_din_ref(uint16_t ref_a, uint16_t ref_b) +{ + if ((ref_a > 4095) || (ref_b > 4095)) + return -1; + +#ifndef FREERTOS_POSIX + RPP_MUTEX_LOCK(mutex_din); + drv_din_ref(ref_a, ref_b); + RPP_MUTEX_UNLOCK(mutex_din); +#endif + return SUCCESS; } // Check for configuration changes to avoid SPI overhead static boolean_t config_changed = FALSE; -// All cached values are 16 bits in the form [SG7,...,0][SP7,...,0] -static uint16_t pull_cache = 0x0; -static uint16_t active_cache = 0x0; + +// All cached values are 16 bits in the form [SG7,...,SG0][SP7,...,SP0] +static uint16_t pull_cache = 0x0; /* 0 - pull-down, 1 - pull-up */ +static uint16_t active_cache = 0x0; /* 0 - tri-state, 1 - active */ static uint16_t can_wake_cache = 0x0; -int8_t rpp_din_setup(uint8_t pin, boolean_t pull_type, - boolean_t active, boolean_t can_wake) +static boolean_t check_pin_busy(uint8_t pin) { - // Check range - if((pin < 1) || (pin > 16)) { - return -1; - } - - // Check programmable feature - if(pull_type && (pin > 8)) { - return -2; - } - - // Set bits - if(pull_type) { - bit_set(pull_cache, pin - 1); - } else { - bit_clear(pull_cache, pin - 1); - } - - if(active) { - bit_set(active_cache, pin - 1); - } else { - bit_clear(active_cache, pin - 1); - } - - if(can_wake) { - bit_set(can_wake_cache, pin - 1); - } else { - bit_clear(can_wake_cache, pin - 1); - } - - config_changed = TRUE; - return SUCCESS; + if (rpp_irc_status(RPP_IRC_1) == 1 && (pin == 10 || pin == 11)) + return TRUE; + if (rpp_irc_status(RPP_IRC_2) == 1 && (pin == 14 || pin == 15)) + return TRUE; + return FALSE; +} + +int8_t rpp_din_setup(uint8_t pin, boolean_t pull_up, + boolean_t active, boolean_t can_wake) +{ + // Check range + if (pin > 15) + return -1; + + // Check programmable feature + if (!pull_up && (pin > 7)) + return -2; + + RPP_MUTEX_LOCK(mutex_din); + // Check blockade of specific pins + if (check_pin_busy(pin)) { + RPP_MUTEX_UNLOCK(mutex_din); + return -RPP_EBUSY; + } + + // Set bits + if (pull_up) + bit_set(pull_cache, pin); + else + bit_clear(pull_cache, pin); + + if (active) + bit_set(active_cache, pin); + else + bit_clear(active_cache, pin); + + if (can_wake) + bit_set(can_wake_cache, pin); + else + bit_clear(can_wake_cache, pin); + + config_changed = TRUE; + RPP_MUTEX_UNLOCK(mutex_din); + return SUCCESS; } static uint16_t in_cache = 0x0; -int8_t rpp_din_get(uint8_t pin, boolean_t var_thr) +int8_t rpp_din_get(uint8_t pin) { - // Check range - if((pin < 1) || (pin > 16)) { - return -1; - } - - // Check feature - if(var_thr && (pin < 8)) { - return -2; - } - - // Use of variable threshold was requested - /* - // FIXME Implement. Now ignoring and returning cached low-speed value. - if(var_thr) { - if(something_get_value(pin) == 1) { - return HIGH; - } - return LOW; - } - */ - - if(is_bit_set(in_cache, pin - 1)) { - return HIGH; - } - return LOW; -} + // Check range + if (pin > 15) + return -1; + // Check blockade of specific pins + if (check_pin_busy(pin)) + return -RPP_EBUSY; -static uint16_t diag_cache = 0x0; + return is_bit_set(in_cache, pin) ? RPP_CLOSED : RPP_OPEN; +} -int8_t rpp_din_diag(uint8_t pin) +int8_t rpp_din_get_tr(uint8_t pin) { - // Check range - if((pin < 1) || (pin > 16)) { - return -1; - } - - if(is_bit_set(diag_cache, pin - 1)) { - return HIGH; - } - return LOW; + // Check range + if (pin < 8 || pin > 15) + return -1; + + // Check blockade of specific pins + if (check_pin_busy(pin)) + return -RPP_EBUSY; + +#ifndef FREERTOS_POSIX + if (drv_din_get_varthr(pin) == 1) + return HIGH; +#endif + return LOW; } -int rpp_din_update() + +static uint16_t diag_cache = 0x0; + +int8_t rpp_din_diag(uint8_t pin) { - #if rppCONFIG_DRV == 1 - /// Setup pins - if(config_changed) { - // Set pull-type. In DRV logic is inverted. - din_set_pr((uint8_t) ~pull_cache); - - // Set state type, active or tri-stated. - // Cached as [SG7,...,0][SP7,...,0] - // Expected as [15-8][SP7,...,0], [15-8][SG7,...,0] and logic inverted. - uint16_t sp = ~(active_cache & 0xFF); // Mask first 8 bits - uint16_t sg = ~(active_cache >> 8); - din_set_stat(sp, sg); - - // Set wake / interrupt. - // Cached as [SG7,...,0][SP7,...,0] - // Expected as [15-8][SP7,...,0], [15-8][SG7,...,0] - sp = can_wake_cache & 0xFF; - sg = can_wake_cache >> 8; - din_set_int(sp, sg); - } - - // Commit changes and read inputs back - // FIXME: Should care about SPI response? - din_spi_transfer(); - - // Update cached values - in_cache = din_get_val_word(); - - // FIXME: Implement. Dummy assign for now. - diag_cache = in_cache; - - if(diag_cache != in_cache) { - return FAILURE; - } - #else - UNUSED(config_changed); - #endif - - config_changed = FALSE; - return SUCCESS; -} + // Check range + if (pin > 15) + return -1; + // Check blockade of specific pins + if (check_pin_busy(pin)) + return -RPP_EBUSY; -#endif /* rppCONFIG_INCLUDE_DIN */ + return is_bit_set(diag_cache, pin) ? HIGH : LOW; +} +/* + * pouzivat din_mod s pouzivanim enumu + */ +int8_t rpp_din_update() +{ + RPP_MUTEX_LOCK(mutex_din); +#ifndef FREERTOS_POSIX + /// Setup pins + if (config_changed) { + uint16_t sp = 0x0; + uint16_t sg = 0x0; + + // Reset chip + din_set_reg(DIN_RESET_CMD, 0, 0); + //rpp_sci_printf("din_reset()\r\n"); + + // Set pull-type. + // In DRV logic is inverted: + // DRV: 1 - set pin as switch-to-battery. RPP: 0 - pull-down. + // DRV: 0 - set pin as switch-to-ground. RPP: 1 - pull-up. + sp = (~pull_cache) & 0xFF; + din_set_reg(DIN_SETTINGS_CMD, 0xffff, sp); + //rpp_sci_printf("din_set_pr(%X)\r\n", sp); + + // Set state type, active or tri-stated. + // In DRV logic is inverted: + // DRV: 1 - tri-state. RPP: 0 - tri-state. + // DRV: 0 - active. RPP: 1 - active. + sp = ((~active_cache) ) & 0xFF; + sg = ((~active_cache) >> 8) & 0xFF; + din_set_reg(DIN_TRI_STATE_CMD_YES, 0xffff, sp); + din_set_reg(DIN_TRI_STATE_CMD_NO, 0xffff, sg); + //rpp_sci_printf("din_set_stat(%X, %X)\r\n", sp, sg); + + // Set wake / interrupt. + // IN DRV logic is not inverted. + // DRV: 1 - can wake. RPP: 1 - can wake. + // DRV: 0 - interrupt disabled. RPP: 0 - interrupt disabled. + sp = (can_wake_cache ) & 0xFF; + sg = (can_wake_cache >> 8) & 0xFF; + + din_set_reg(DIN_WAKE_UP_CMD_ENB, 0xffff, sp); + din_set_reg(DIN_WAKE_UP_CMD_DIS, 0xffff, sg); + //rpp_sci_printf("din_set_int(%X, %X)\r\n", sp, sg); + + // Mark configuration as commited + config_changed = FALSE; + } + + // Update cached values + din_set_reg(DIN_SWITCH_STATUS_CMD, 0, 0); + in_cache = din_get_val_word(); + + // FIXME: Implement. Dummy assign for now. + diag_cache = in_cache; + + if (diag_cache != in_cache) { + RPP_MUTEX_UNLOCK(mutex_din); + return FAILURE; + } + + #else /* ifndef FREERTOS_POSIX */ + UNUSED(config_changed); + #endif /* ifndef FREERTOS_POSIX */ + + RPP_MUTEX_UNLOCK(mutex_din); + return SUCCESS; +}