text
stringlengths 13
91.1k
|
|---|
//
// BHBaseRouter.h
// Pods
//
// Created by Chen Yihu on 6/3/15.
//
//
#import <UIKit/UIKit.h>
@interface BHBaseRouter : NSObject
@property (nonatomic, strong, readonly) NSMutableDictionary *routes;
@property (nonatomic, strong, readonly) NSMutableDictionary *schemas;
+ (instancetype)shared;
- (void)map:(NSString *)route toObject:(id)object withIdentifier:(NSString *)identifier;
- (NSDictionary *)subRoutesForRoutingString:(NSString *)route
extractParams:(NSDictionary **)extractParams;
// 参数解析,包括 route param 和 query param eg. /goods/:goodsId/?a=1&b=2
- (NSDictionary *)paramsInRoute:(NSString *)route;
// schema 映射,用于过滤处理特殊的 schema
- (void)mapSchema:(NSString *)schema toObject:(id)object withIdentifier:(NSString *)identifier;
- (NSString *)extractSchema:(NSString *)route;
- (id)objectForSchema:(NSString *)schema identifier:(NSString *)identifier;
@end
|
#ifndef SCENE_SHARED_H
#define SCENE_SHARED_H
#include "main_game.h"
#include "game_intro.h"
#include "credits.h"
#include "sound_test.h"
#include "game_over.h"
#include "game_win.h"
typedef union shared_data_t
{
mg_data_t mg;
gi_data_t gi;
cr_data_t cr;
st_data_t st;
go_data_t go;
gw_data_t gw;
} shared_data_t;
extern shared_data_t _shared_data;
#endif |
#include <stdio.h>
int parent(int index) {
return (index - 1) / 2;
}
int left(int index) {
return 2 * index + 1;
}
int right(int index) {
return 2 * index + 2;
}
int max(int num1, int num2) {
return (num1 > num2) ? num1 : num2;
}
int main() {
int n, flag;
flag = 1;
scanf("%d", &n);
int array[n];
for (int i = 0; i < n; i++) {
scanf("%d", &array[i]);
}
for (int j = n - 1; j >= 0; j--) {
if (array[j] == -1) {
int leftIndex = left(j);
int rightIndex = right(j);
if (leftIndex >= n && rightIndex >= n) { // has no children
array[j] = 1;
} else if (leftIndex >= n) { // has 1 children at right
array[j] = array[rightIndex] + 1;
} else if (rightIndex >= n) { // has 1 children at left
array[j] = array[leftIndex] + 1;
} else { // has 2 children
array[j] = max(array[rightIndex], array[leftIndex]) + 1;
}
}
int parentIndex = parent(j);
if (array[parentIndex] <= array[j] && array[parentIndex] != -1 && j != 0) {
flag = 0;
break;
}
}
if (flag != 1) {
printf("-1");
} else {
for (int i = 0; i < n; i++) {
printf("%d ", array[i]);
}
}
printf("\n");
return 0;
}
|
/**
* @file LazyInit.h
* @brief Implementation of lazy initialization.
* @author Petr Flajšingr
* @date 15.9.20
*/
#ifndef PF_COMMON_LAZY_INIT_H
#define PF_COMMON_LAZY_INIT_H
#include <concepts>
#include <functional>
#include <memory>
namespace pf {
/**
* @brief Lazy initialisation.
*
* Inner value is initialised on first access to it.
* @tparam T inner value type
*/
template<typename T>
class LazyInit {
public:
using calc_fnc = std::function<T()>;
using value_type = T;
using reference = T &;
using const_reference = const T &;
using pointer = T *;
using const_pointer = const T *;
/**
* Construct LazyInit.
* @param calc function calculation the inner value
*/
explicit LazyInit(std::invocable auto calc) : calc(calc) {}
pointer operator->() {
calculate();
return value.get();
}
reference operator*() {
calculate();
return *value;
}
const_pointer operator->() const {
calculate();
return value.get();
}
const_reference operator*() const {
calculate();
return *value;
}
private:
void calculate() const {
if (value == nullptr) { value = std::make_unique<T>(calc()); }
}
calc_fnc calc;
mutable std::unique_ptr<T> value;
};
}// namespace pf
#endif//PF_COMMON_LAZY_INIT_H
|
/*
*
*
* This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
*
* Copyright 2007-2020 Broadcom Inc. All rights reserved.
*
* File: hl65.c
* Purpose: Broadcom 10/100/1000/2500/10000/12000/13000/16000/20000 SerDes
* (HyperLite 65nm with x1 and x4 lane support)
*/
#include "phydefs.h" /* Must include before other phy related includes */
#if defined(INCLUDE_XGXS_HL65)
#include "phyconfig.h" /* Must include before other phy related includes */
#include <shared/bsl.h>
#include <sal/types.h>
#include <sal/core/spl.h>
#include <soc/drv.h>
#include <soc/error.h>
#include <soc/phyreg.h>
#include <soc/port_ability.h>
#include <soc/phyctrl.h>
#include <soc/phy.h>
#include <soc/phy/phyctrl.h>
#include <soc/phy/drv.h>
#include "phyreg.h"
#include "phyfege.h"
#include "phynull.h"
#include "serdesid.h"
#include "hl65.h"
/*
* HL/HC defines not contained in hl65.h which is generated from RDB files
*/
#define HL65_PLL_WAIT 250000
#define HL65_AN_WAIT 400000 /* 400ms */
#define HL65_NUM_LANES 4
#define TX_DRIVER_DFT_LN_CTRL 0x4
#define HL_SERDES_ID0_REVID_A0 0x0000
#define HL_SERDES_ID0_REVID_A1 0x0800
#define HL_SERDES_ID0_REVID_B0 0x4000
#define HL_SERDES_ID0_REVID_C0 0x8000
#define HL_SERDES_ID0_REVID_D0 0xc000
#define HL_ALL_LANES 0xf
#define HL_AER_BCST_OFS_STRAP 0x3ff
#define HL65_A0A1_DSC_DFE_BRCDR 0x2180
#define HL65_B0C0_DSC_DFE_BRCDR 0x2300
#define OVER1G_UP3_20GPLUS_MASK (DIGITAL3_UP3_DATARATE_25P45GX4_MASK | \
DIGITAL3_UP3_DATARATE_21GX4_MASK)
#define PLL_PLLACONTROL4_BIT12_MASK 0x1000
/* Broadcast to all lanes with AER::MMD_PORT set to aer_bcst_ofs_strap */
#define HL65_BROADCAST_WRITE(_unit, _pc, _bcst_strap, _reg_addr, _data) \
HL65_REG_WRITE((_unit), (_pc), 0x00, \
((_bcst_strap) << 16) | (_reg_addr), (_data))
typedef enum {
PHY_HL65_DSC_CFG_1X_OSR,
PHY_HL65_DSC_CFG_2X_OSR,
PHY_HL65_DSC_CFG_4X_OSR,
PHY_HL65_DSC_CFG_5X_OSR,
PHY_HL65_DSC_CFG_BR_CDR,
PHY_HL65_DSC_CFG_UNKNOWN
} phy_hl65_dsc_cfg_t;
/* function forward declaration */
STATIC int _phy_hl65_notify_duplex(int unit, soc_port_t port, uint32 duplex);
STATIC int _phy_hl65_notify_speed(int unit, soc_port_t port, uint32 speed);
STATIC int _phy_hl65_notify_stop(int unit, soc_port_t port, uint32 flags);
STATIC int _phy_hl65_notify_resume(int unit, soc_port_t port, uint32 flags);
STATIC int _phy_hl65_notify_interface(int unit, soc_port_t port, uint32 intf);
STATIC int phy_hl65_an_set(int unit, soc_port_t port, int an);
STATIC int phy_hl65_lb_set(int unit, soc_port_t port, int enable);
STATIC int phy_hl65_ability_advert_set(int unit, soc_port_t port,
soc_port_ability_t *ability);
STATIC int phy_hl65_ability_local_get(int unit, soc_port_t port,
soc_port_ability_t *ability);
STATIC int phy_hl65_diag_ctrl(int, soc_port_t, uint32, int, int, void *);
STATIC int phy_hl65_speed_set(int unit, soc_port_t port, int speed);
STATIC int phy_hl65_speed_get(int unit, soc_port_t port, int *speed);
STATIC int phy_hl65_an_get(int unit, soc_port_t port, int *an, int *an_done);
STATIC int _phy_hl65_analog_dsc_init (int unit,int port,int lane);
STATIC int _hl65_xgmii_scw_config (int unit, phy_ctrl_t *pc);
STATIC int _hl65_rxaui_config(int unit, phy_ctrl_t *pc,int rxaui);
STATIC int _hl65_soft_reset(int unit, phy_ctrl_t *pc);
STATIC int _hl65_lane_reg_init(int unit, phy_ctrl_t *pc);
STATIC int phy_hl65_uc_status_dump(int unit, soc_port_t port);
STATIC int
_phy_hl65_pll_lock_wait(int unit, soc_port_t port)
{
uint16 data16;
phy_ctrl_t *pc;
soc_timeout_t to;
int rv;
pc = INT_PHY_SW_STATE(unit, port);
soc_timeout_init(&to, HL65_PLL_WAIT, 0);
do {
rv = READ_HL65_XGXSBLK0_XGXSSTATUSr(unit, pc, &data16);
if ((data16 & XGXSBLK0_XGXSSTATUS_TXPLL_LOCK_MASK) ||
SOC_FAILURE(rv)) {
break;
}
} while (!soc_timeout_check(&to));
if ((data16 & XGXSBLK0_XGXSSTATUS_TXPLL_LOCK_MASK) == 0) {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"HL65 : TXPLL did not lock: u=%d p=%d\n"),
unit, port));
return (SOC_E_TIMEOUT);
}
return (SOC_E_NONE);
}
STATIC int
_phy_hl65_half_rate_set(int unit, soc_port_t port,int speed)
{
phy_ctrl_t *pc;
int tx_halfrate_bit;
uint16 serdes_id0;
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
/* only apply to these revisions */
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1) ||
(serdes_id0 == HL_SERDES_ID0_REVID_B0)) {
if (speed == 2500 || speed == 10000) {
tx_halfrate_bit = TX0_ANATXACONTROL1_TX_SEL_HALFRATE_MASK;
} else {
tx_halfrate_bit = 0;
}
/* set tx half rate bits after the link is established at 2.5G or 10G
* in both force mode or autoneg mode.
*/
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX0_ANATXACONTROL1r(unit, pc,
tx_halfrate_bit,
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_MASK));
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_ANATXACONTROL1r(unit, pc,
tx_halfrate_bit,
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_MASK));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX2_ANATXACONTROL1r(unit, pc,
tx_halfrate_bit,
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_MASK));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_ANATXACONTROL1r(unit, pc,
tx_halfrate_bit,
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_MASK));
}
}
return (SOC_E_NONE);
}
STATIC int
_phy_hl65_tx_control_set(int unit, soc_port_t port)
{
phy_ctrl_t *pc;
uint32 preemph;
uint32 idriver;
uint32 pdriver;
uint16 data16;
pc = INT_PHY_SW_STATE(unit, port);
if (PHY_EXTERNAL_MODE(unit, port)) {
/* HL65 connected to external PHY */
if (IS_HG_PORT(unit, port)) {
preemph = 0x0;
idriver = 0x9;
pdriver = 0x9;
} else if (IS_XE_PORT(unit, port)) {
preemph = 0x0;
idriver = 0x9;
pdriver = 0x9;
} else {
preemph = 0x0;
idriver = 0x9;
pdriver = 0x9;
}
} else {
/* No external PHY */
if (IS_HG_PORT(unit, port)) {
preemph = 0x0;
idriver = 0x9;
pdriver = 0x9;
} else if (IS_XE_PORT(unit, port)) {
preemph = 0x0;
idriver = 0x9;
pdriver = 0x9;
} else {
preemph = 0x0;
idriver = 0x9;
pdriver = 0x9;
}
}
/* Read config override */
preemph = soc_property_port_get(unit, port,
spn_SERDES_PREEMPHASIS, preemph);
idriver = soc_property_port_get(unit, port,
spn_SERDES_DRIVER_CURRENT, idriver);
pdriver = soc_property_port_get(unit, port,
spn_SERDES_PRE_DRIVER_CURRENT, pdriver);
preemph = (preemph << TXB_TX_OS_DRIVER_PREEMPHASIS_POST_SHIFT) &
TXB_TX_OS_DRIVER_PREEMPHASIS_POST_MASK;
idriver = (idriver << TXB_TX_OS_DRIVER_IDRIVER_SHIFT) &
TXB_TX_OS_DRIVER_IDRIVER_MASK;
pdriver = (pdriver << TXB_TX_OS_DRIVER_IPREDRIVER_SHIFT) &
TXB_TX_OS_DRIVER_IPREDRIVER_MASK;
data16 = (uint16)(preemph | idriver | pdriver);
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXB_TX_OS_DRIVERr(unit, pc, data16,
TXB_TX_OS_DRIVER_PREEMPHASIS_POST_MASK |
TXB_TX_OS_DRIVER_IDRIVER_MASK |
TXB_TX_OS_DRIVER_IPREDRIVER_MASK));
/* set for BR-CDR mode as well */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXB_TX_BR_DRIVERr(unit, pc, data16,
TXB_TX_OS_DRIVER_PREEMPHASIS_POST_MASK |
TXB_TX_OS_DRIVER_IDRIVER_MASK |
TXB_TX_OS_DRIVER_IPREDRIVER_MASK));
return SOC_E_NONE;
}
STATIC int
_hl65_ind_lane_polarity_set (int unit, soc_port_t port)
{
int rxpol;
int txpol;
uint16 data16;
uint16 mask16;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
txpol = soc_property_port_get(unit, port,
spn_PHY_XAUI_TX_POLARITY_FLIP, 0);
rxpol = soc_property_port_get(unit, port,
spn_PHY_XAUI_RX_POLARITY_FLIP, 0);
if (rxpol) {
/* Flip Rx polarity */
mask16 = RX0_ANARXCONTROLPCI_RX_POLARITY_FORCE_SM_MASK |
RX0_ANARXCONTROLPCI_RX_POLARITY_R_MASK;
data16 = mask16;
if (pc->lane_num == 0) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX0_ANARXCONTROLPCIr(unit,pc,data16,mask16));
} else if (pc->lane_num == 1) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX1_ANARXCONTROLPCIr(unit,pc,data16,mask16));
} else if (pc->lane_num == 2) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX2_ANARXCONTROLPCIr(unit,pc,data16,mask16));
} else if (pc->lane_num == 3) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX3_ANARXCONTROLPCIr(unit,pc,data16,mask16));
}
if (pc->phy_mode == PHYCTRL_DUAL_LANE_PORT) {
/* Also flip for the next lane */
if (pc->lane_num == 0) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX1_ANARXCONTROLPCIr(unit,pc,data16,mask16));
} else if (pc->lane_num == 2) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX3_ANARXCONTROLPCIr(unit,pc,data16,mask16));
}
}
}
if (txpol) {
/* Flip TX polarity */
data16 = TX0_ANATXACONTROL0_TXPOL_FLIP_MASK;
mask16 = TX0_ANATXACONTROL0_TXPOL_FLIP_MASK;
if (pc->lane_num == 0) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX0_ANATXACONTROL0r(unit, pc, data16, mask16));
} else if (pc->lane_num == 1) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_ANATXACONTROL0r(unit, pc, data16, mask16));
} else if (pc->lane_num == 2) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX2_ANATXACONTROL0r(unit, pc, data16, mask16));
} else if (pc->lane_num == 3) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_ANATXACONTROL0r(unit, pc, data16, mask16));
}
if (pc->phy_mode == PHYCTRL_DUAL_LANE_PORT) {
/* Also flip for the next lane */
if (pc->lane_num == 0) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_ANATXACONTROL0r(unit, pc, data16, mask16));
} else if (pc->lane_num == 2) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_ANATXACONTROL0r(unit, pc, data16, mask16));
}
}
}
return SOC_E_NONE;
}
STATIC int
_hl65_combo_lane_polarity_set (int unit, soc_port_t port)
{
int rxpol;
int txpol;
uint16 data16;
uint16 mask16;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
txpol = soc_property_port_get(unit, port,
spn_PHY_XAUI_TX_POLARITY_FLIP, 0);
rxpol = soc_property_port_get(unit, port,
spn_PHY_XAUI_RX_POLARITY_FLIP, 0);
if (txpol) { /* Flip TX polarity */
data16 = TX0_ANATXACONTROL0_TXPOL_FLIP_MASK;
mask16 = TX0_ANATXACONTROL0_TXPOL_FLIP_MASK;
if (txpol == 1) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXB_ANATXACONTROL0r(unit, pc, data16, mask16));
}
if ((txpol & 0x000F) == 0x000F) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX0_ANATXACONTROL0r(unit, pc, data16, mask16));
}
if ((txpol & 0x00F0) == 0x00F0) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_ANATXACONTROL0r(unit, pc, data16, mask16));
}
if ((txpol & 0x0F00) == 0x0F00) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX2_ANATXACONTROL0r(unit, pc, data16, mask16));
}
if ((txpol & 0xF000) == 0xF000) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_ANATXACONTROL0r(unit, pc, data16, mask16));
}
}
if (rxpol) {
/* Flip Rx polarity */
mask16 = RX0_ANARXCONTROLPCI_RX_POLARITY_FORCE_SM_MASK |
RX0_ANARXCONTROLPCI_RX_POLARITY_R_MASK;
data16 = mask16;
if (rxpol == 1) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RXB_ANARXCONTROLPCIr(unit,pc,data16,mask16));
}
if ((rxpol & 0x000F) == 0x000F) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX0_ANARXCONTROLPCIr(unit,pc,data16,mask16));
}
if ((rxpol & 0x00F0) == 0x00F0) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX1_ANARXCONTROLPCIr(unit,pc,data16,mask16));
}
if ((rxpol & 0x0F00) == 0x0F00) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX2_ANARXCONTROLPCIr(unit,pc,data16,mask16));
}
if ((rxpol & 0xF000) == 0xF000) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_RX3_ANARXCONTROLPCIr(unit,pc,data16,mask16));
}
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_independent_lane_init(int unit, soc_port_t port)
{
int fiber;
uint16 data16, mask16;
uint16 mode_1000x;
int rv;
soc_timeout_t to;
phy_ctrl_t *pc;
soc_port_ability_t ability;
if (SOC_IS_RELOADING(unit)) {
return SOC_E_NONE;
}
/* Only need to track fiber mode state.
* Copper mode state is tracked by external PHY.
*/
pc = INT_PHY_SW_STATE(unit, port);
fiber = PHY_FIBER_MODE(unit, port);
pc->fiber.enable = fiber;
pc->fiber.preferred = fiber;
pc->fiber.autoneg_enable = 1;
pc->fiber.force_speed = 1000;
pc->fiber.force_duplex = TRUE;
pc->fiber.master = SOC_PORT_MS_NONE;
pc->fiber.mdix = SOC_PORT_MDIX_NORMAL;
/* if the port is using two lanes and not using as dxgxs mode,
* then disable the second lane
*/
if ((pc->phy_mode == PHYCTRL_DUAL_LANE_PORT) && IS_GE_PORT(unit,port)) {
int mdio_addr_share = FALSE;
/* clear next lane default dxgxs configuration */
if (!(pc->flags & PHYCTRL_MDIO_ADDR_SHARE)) {
pc->phy_id++;
} else {
pc->lane_num++;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_MISC1r(unit, pc, 0, 0x1f));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL4_MISC3r(unit, pc, 0,
DIGITAL4_MISC3_FORCE_SPEED_B5_MASK));
if (!(pc->flags & PHYCTRL_MDIO_ADDR_SHARE)) {
pc->phy_id--;
} else {
pc->lane_num--;
}
/* disable the next lane
* the lane disable register can only be accessed from lane 0
*/
if (pc->flags & PHYCTRL_MDIO_ADDR_SHARE) {
mdio_addr_share = TRUE;
pc->flags &= ~PHYCTRL_MDIO_ADDR_SHARE;
} else {
pc->phy_id -= pc->lane_num;
}
mask16 = (1 << (pc->lane_num + 1)); /* rx lane */
mask16 |= (mask16 << 4); /* add tx lane */
mask16 |= 0x800; /* add force bit */
data16 = mask16;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK1_LANECTRL3r(unit,pc,data16,mask16));
/* restore the previous MDIO address mode */
if (mdio_addr_share == TRUE) {
pc->flags |= PHYCTRL_MDIO_ADDR_SHARE;
} else {
pc->phy_id += pc->lane_num;
}
}
/* Since driver reset function vector does not reset
* the SerDes, reset the SerDes in initialization first.
* The internal SERDES PHY's reset bit is self-clearing.
*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, MII_CTRL_RESET));
soc_timeout_init(&to, 10000, 0);
while (!soc_timeout_check(&to)) {
rv = READ_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, &data16);
if (((data16 & MII_CTRL_RESET) == 0) ||
SOC_FAILURE(rv)) {
break;
}
}
if ((data16 & MII_CTRL_RESET) != 0) {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Combo SerDes reset failed: u=%d p=%d\n"),
unit, port));
}
/* disable in-band MDIO. PHY-443 */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK3_LOCALCONTROL0r(unit,pc,
XGXSBLK3_LOCALCONTROL0_RX_INBANDMDIO_RST_MASK,
XGXSBLK3_LOCALCONTROL0_RX_INBANDMDIO_RST_MASK));
/* check if need to flip any polarity for the lane */
SOC_IF_ERROR_RETURN
(_hl65_ind_lane_polarity_set (unit, port));
/* Select recovered clock from MII fifo read */
if (IS_GE_PORT(unit, port) && (fiber == 0)) {
mask16 = DIGITAL4_MISC3_RXCK_MII_OVERRIDE_VAL_MASK |
DIGITAL4_MISC3_RXCK_MII_OVERRIDE_MASK;
data16 = mask16;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL4_MISC3r(unit, pc, data16, mask16));
}
/* Enable output clock to be present when the core is commanded into
* power down state.
*/
data16 = XGXSBLK1_LANETEST_PWRDWN_CLKS_EN_MASK;
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANETESTr(unit, pc, data16));
/* Set Local Advertising Configuration */
SOC_IF_ERROR_RETURN
(phy_hl65_ability_local_get(unit, port, &ability));
/* Do not advertise 2.5G. 2.5 Gbps AN is not supported */
ability.speed_full_duplex &= ~SOC_PA_SPEED_2500MB;
pc->fiber.advert_ability = ability;
SOC_IF_ERROR_RETURN
(phy_hl65_ability_advert_set(unit, port, &ability));
/* Disable BAM in Independent Lance mode. Over1G AN not supported */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL6_MP5_NEXTPAGECTRLr(unit, pc, 0));
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL6_UD_FIELDr(unit, pc, 0));
data16 = DIGITAL_CONTROL1000X2_DISABLE_FALSE_LINK_MASK |
DIGITAL_CONTROL1000X2_FILTER_FORCE_LINK_MASK;
mask16 = data16 | DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_MASK;
if ((PHY_FIBER_MODE(unit, port) && !PHY_EXTERNAL_MODE(unit, port)) ||
PHY_PASSTHRU_MODE(unit, port) ||
PHY_SGMII_AUTONEG_MODE(unit, port)) {
/* Enable 1000X parallel detect */
data16 |= DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_MASK;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X2r(unit, pc, data16, mask16));
/* Initialialize autoneg and fullduplex */
data16 = MII_CTRL_FD | MII_CTRL_SS_1000;
if ((PHY_FIBER_MODE(unit, port) && !PHY_EXTERNAL_MODE(unit, port)) ||
PHY_PASSTHRU_MODE(unit, port) ||
PHY_SGMII_AUTONEG_MODE(unit, port)) {
data16 |= MII_CTRL_AE | MII_CTRL_RAN;
}
SOC_IF_ERROR_RETURN
(WRITE_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, data16));
/* Configure default preemphasis, predriver, idriver values */
SOC_IF_ERROR_RETURN
(_phy_hl65_tx_control_set(unit, port));
/* Configuring operating mode */
data16 = DIGITAL_CONTROL1000X1_DISABLE_PLL_PWRDWN_MASK;
mask16 = DIGITAL_CONTROL1000X1_AUTODET_EN_MASK |
DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK |
DIGITAL_CONTROL1000X1_DISABLE_PLL_PWRDWN_MASK;
/*
* Configure signal auto-detection between SGMII and fiber.
* This detection only works if auto-negotiation is enabled.
*/
if (soc_property_port_get(unit, port,
spn_SERDES_AUTOMEDIUM, FALSE)) {
data16 |= DIGITAL_CONTROL1000X1_AUTODET_EN_MASK;
}
/*
* Put the Serdes in Fiber or SGMII mode
*/
mode_1000x = 0;
if ((PHY_FIBER_MODE(unit, port) && !PHY_EXTERNAL_MODE(unit, port)) ||
PHY_PASSTHRU_MODE(unit, port)) {
mode_1000x = DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK;
}
/* Allow property to override */
if (soc_property_port_get(unit, port,
spn_SERDES_FIBER_PREF, mode_1000x)) {
data16 |= DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK;
} else {
data16 &= ~DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK;
}
if (soc_property_port_get(unit, port,
spn_SERDES_SGMII_MASTER, FALSE)) {
data16 |= DIGITAL_CONTROL1000X1_SGMII_MASTER_MODE_MASK;
mask16 |= DIGITAL_CONTROL1000X1_SGMII_MASTER_MODE_MASK;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X1r(unit, pc, data16, mask16));
SOC_IF_ERROR_RETURN
(_hl65_lane_reg_init(unit,pc));
SOC_IF_ERROR_RETURN
(_phy_hl65_analog_dsc_init(unit,port,pc->lane_num));
/* config the 64B/66B for dxgxs mode */
SOC_IF_ERROR_RETURN
(_hl65_xgmii_scw_config (unit,pc));
/* autoneg is not supported in dxgxs mode */
if ((pc->phy_mode == PHYCTRL_DUAL_LANE_PORT) &&
(IS_HG_PORT(unit,port) || IS_XE_PORT(unit,port))) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, 0, MII_CTRL_AE));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_MISC1r(unit, pc, 0x1, 0x1f));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL4_MISC3r(unit, pc, DIGITAL4_MISC3_FORCE_SPEED_B5_MASK,
DIGITAL4_MISC3_FORCE_SPEED_B5_MASK));
} else { /* all other modes, enable autoneg by default */
/* clear forced speed control. Some two-lane ports are strapped
* in forced dxgxs speed.
*/
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_MISC1r(unit, pc, 0,
DIGITAL_MISC1_FORCE_SPEED_MASK));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL4_MISC3r(unit, pc, 0,
DIGITAL4_MISC3_FORCE_SPEED_B5_MASK));
/* enable autoneg */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, MII_CTRL_AE,
MII_CTRL_AE));
}
/* PRBS Polynomial for all lanes: 0x8019=0x0000 */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANEPRBSr(unit, pc, 0));
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_init: u=%d p=%d %s\n"),
unit, port, (fiber) ? "Fiber" : "Copper"));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_combo_core_init(int unit, soc_port_t port)
{
phy_ctrl_t *pc;
soc_port_ability_t ability;
uint16 data16, mask16;
pc = INT_PHY_SW_STATE(unit, port);
/* must be done after reset, otherwise will be cleared */
data16 = (XGXSBLK0_XGXSCONTROL_MODE_10G_ComboCoreMode <<
XGXSBLK0_XGXSCONTROL_MODE_10G_SHIFT);
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,data16,
(XGXSBLK0_XGXSCONTROL_MODE_10G_MASK)));
/* disable in-band MDIO. PHY-443 */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK3_LOCALCONTROL0r(unit,pc,
XGXSBLK3_LOCALCONTROL0_RX_INBANDMDIO_RST_MASK,
XGXSBLK3_LOCALCONTROL0_RX_INBANDMDIO_RST_MASK));
/* check if need to flip any polarity for the lanes */
SOC_IF_ERROR_RETURN
(_hl65_combo_lane_polarity_set (unit, port));
/* disable CL73 BAM */
SOC_IF_ERROR_RETURN
(HL65_REG_MODIFY(unit,pc,0,0x38008372,
0,
CL73_USERB0_CL73_BAMCTRL1_CL73_BAMEN_MASK));
if (!PHY_CLAUSE73_MODE(unit, port)) {
/* disable CL73 AN device*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_AN_IEEE0BLK_AN_IEEECONTROL1r(unit,pc,0));
}
/* PLL VCO step time */
SOC_IF_ERROR_RETURN
(WRITE_HL65_TXPLL_ANAPLLTIMER1r(unit, pc, 0x04ff));
/* Disable IEEE block select auto-detect.
* The driver will select desired block as necessary.
* By default, the driver keeps the mapping for XAUI block in
* IEEE address space.
*/
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_MISCCONTROL1r(unit, pc,
XGXSBLK0_MISCCONTROL1_IEEE_BLKSEL_VAL_MASK,
XGXSBLK0_MISCCONTROL1_IEEE_BLKSEL_AUTODET_MASK |
XGXSBLK0_MISCCONTROL1_IEEE_BLKSEL_VAL_MASK));
SOC_IF_ERROR_RETURN
(phy_hl65_ability_local_get(unit, port, &ability));
if (PHY_EXTERNAL_MODE(unit, port)) {
ability.speed_full_duplex = SOC_PA_SPEED_10GB;
}
SOC_IF_ERROR_RETURN
(phy_hl65_ability_advert_set(unit, port, &ability));
/* Configure 10G parallel detect */
SOC_IF_ERROR_RETURN /* Adjust parallel detect link timer to 60ms */
(WRITE_HL65_AN73_PDET_PARDET10GLINKr(unit, pc, 0x16E2));
data16 = 0;
mask16 = AN73_PDET_PARDET10GCONTROL_PD_12G_TXDON_DISABLE_MASK |
AN73_PDET_PARDET10GCONTROL_PD_12G_DISABLE_MASK |
AN73_PDET_PARDET10GCONTROL_PARDET10G_EN_MASK;
if (soc_property_port_get(unit, port, spn_XGXS_PDETECT_10G, 1)) {
data16 |= AN73_PDET_PARDET10GCONTROL_PARDET10G_EN_MASK;
if (pc->speed_max <= 10000) {
/* Disable parallel detect for 12Gbps. */
data16 |= AN73_PDET_PARDET10GCONTROL_PD_12G_TXDON_DISABLE_MASK |
AN73_PDET_PARDET10GCONTROL_PD_12G_DISABLE_MASK;
}
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN73_PDET_PARDET10GCONTROLr(unit, pc, data16, mask16));
/* Configure default preemphasis, predriver, idriver values */
SOC_IF_ERROR_RETURN
(_phy_hl65_tx_control_set(unit, port));
/* Enable output clock to be present when the core is commanded into
* power down state.
*/
data16 = XGXSBLK1_LANETEST_PWRDWN_CLKS_EN_MASK |
XGXSBLK1_LANETEST_PWRDN_SAFE_DIS_MASK;
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANETESTr(unit, pc, data16));
/*
* Transform CX4 pin out on the board to HG pinout
*/
if (soc_property_port_get(unit, port, spn_CX4_TO_HIGIG, FALSE)) {
SOC_IF_ERROR_RETURN /* Enable TX Lane swap */
(WRITE_HL65_XGXSBLK2_TXLNSWAPr(unit, pc, 0x80e4));
SOC_IF_ERROR_RETURN /* Flip TX Lane polarity */
(WRITE_HL65_TXB_ANATXACONTROL0r(unit, pc, 0x1020));
} else {
/* If CX4 to HG conversion is enabled, do not allow individual lane
* swapping.
*/
uint16 lane_map, i;
uint16 lane, hw_map, chk_map;
/* Update RX lane map */
lane_map = soc_property_port_get(unit, port,
spn_XGXS_RX_LANE_MAP, 0x0123) & 0xffff;
if (lane_map != 0x0123) {
hw_map = 0;
chk_map = 0;
for (i = 0; i < 4; i++) {
lane = (lane_map >> (i * 4)) & 0xf;
hw_map |= lane << (i * 2);
chk_map |= 1 << lane;
}
if (chk_map == 0xf) {
SOC_IF_ERROR_RETURN /* Enable RX Lane swap */
(MODIFY_HL65_XGXSBLK2_RXLNSWAPr(unit, pc,
XGXSBLK2_RXLNSWAP_RX_LNSWAP_EN_MASK |
XGXSBLK2_RXLNSWAP_RX_LNSWAP_FORCE_EN_MASK | hw_map,
XGXSBLK2_RXLNSWAP_RX_LNSWAP_FORCE_EN_MASK |
XGXSBLK2_RXLNSWAP_RX_LNSWAP_EN_MASK |
XGXSBLK2_RXLNSWAP_RX_LNSWAP_FORCE0_MASK |
XGXSBLK2_RXLNSWAP_RX_LNSWAP_FORCE1_MASK |
XGXSBLK2_RXLNSWAP_RX_LNSWAP_FORCE2_MASK |
XGXSBLK2_RXLNSWAP_RX_LNSWAP_FORCE3_MASK));
} else {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"unit %d port %s: Invalid RX lane map 0x%04x.\n"),
unit, SOC_PORT_NAME(unit, port), lane_map));
}
}
/* Update TX lane map */
lane_map = soc_property_port_get(unit, port,
spn_XGXS_TX_LANE_MAP, 0x0123) & 0xffff;
if (lane_map != 0x0123) {
hw_map = 0;
chk_map = 0;
for (i = 0; i < 4; i++) {
lane = (lane_map >> (i * 4)) & 0xf;
hw_map |= lane << (i * 2);
chk_map |= 1 << lane;
}
if (chk_map == 0xf) {
SOC_IF_ERROR_RETURN /* Enable TX Lane swap */
(MODIFY_HL65_XGXSBLK2_TXLNSWAPr(unit, pc, 0x8000 | hw_map,
0x80ff));
} else {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"unit %d port %s: Invalid TX lane map 0x%04x.\n"),
unit, SOC_PORT_NAME(unit, port), lane_map));
}
}
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, 0,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
SOC_IF_ERROR_RETURN
(_phy_hl65_analog_dsc_init(unit,port,HL_ALL_LANES));
/* config the 64B/66B for 25G, won't affect other speeds and AN */
SOC_IF_ERROR_RETURN
(_hl65_xgmii_scw_config (unit,pc));
/* broadcast to all lanes */
SOC_IF_ERROR_RETURN
(WRITE_HL65_AERBLK_AERr(unit,pc, HL_AER_BCST_OFS_STRAP));
SOC_IF_ERROR_RETURN
(_hl65_lane_reg_init(unit,pc));
/* reset AER */
SOC_IF_ERROR_RETURN
(WRITE_HL65_AERBLK_AERr(unit,pc, 0));
/* enable autoneg or force a speed depending on the port type */
if (PHY_EXTERNAL_MODE(unit, port) &&
(IS_XE_PORT(unit, port) || IS_HG_PORT(unit, port))) {
int force_speed;
if (soc_property_port_get(unit, port, spn_10G_IS_CX4, TRUE)) {
force_speed= DIGITAL_MISC1_FORCE_SPEED_dr_10GBASE_CX4; /* 10G CX4 */
} else {
force_speed= DIGITAL_MISC1_FORCE_SPEED_dr_10GHiGig_X4; /* 10G HiG */
}
/* disable autoneg */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc,
0,
MII_CTRL_AE));
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN_IEEE0BLK_AN_IEEECONTROL1r(unit, pc,
0,
MII_CTRL_AE));
}
/* force speed to 10G */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_MISC1r(unit, pc, force_speed,
DIGITAL_MISC1_FORCE_SPEED_MASK));
} else { /* autoneg */
/* clear forced bit */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_MISC1r(unit, pc, 0, 0x10));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc,
MII_CTRL_AE | MII_CTRL_RAN,
MII_CTRL_AE | MII_CTRL_RAN));
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN_IEEE0BLK_AN_IEEECONTROL1r(unit, pc,
MII_CTRL_AE | MII_CTRL_RAN,
MII_CTRL_AE | MII_CTRL_RAN));
}
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
/*
* Configure signal auto-detection between SGMII and fiber.
*/
data16 = DIGITAL_CONTROL1000X1_DISABLE_PLL_PWRDWN_MASK;
mask16 = DIGITAL_CONTROL1000X1_DISABLE_PLL_PWRDWN_MASK |
DIGITAL_CONTROL1000X1_AUTODET_EN_MASK |
DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK;
if (soc_property_port_get(unit, port, spn_SERDES_AUTOMEDIUM, TRUE)) {
data16 |= DIGITAL_CONTROL1000X1_AUTODET_EN_MASK;
}
if (soc_property_port_get(unit, port, spn_SERDES_FIBER_PREF, TRUE)) {
data16 |= DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X1r(unit, pc, data16, mask16));
/* set filter_force_link and disable_false_link */
mask16 = DIGITAL_CONTROL1000X2_DISABLE_FALSE_LINK_MASK |
DIGITAL_CONTROL1000X2_FILTER_FORCE_LINK_MASK;
data16 = mask16;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X2r(unit, pc, data16, mask16));
(void) _phy_hl65_pll_lock_wait(unit, port);
/* select recovery clock from lane0 for rxck0_10g */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK1_TESTTXr(unit,pc,
0,
XGXSBLK1_TESTTX_RX_CK4X1MUXSEL_MASK));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_fabric_init(int unit, soc_port_t port)
{
uint16 data;
uint16 serdes_id0;
uint16 aer_bcst_ofs_strap;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_fabric_init: u=%d p=%d\n"), unit, port));
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
if (serdes_id0 == HL_SERDES_ID0_REVID_C0) {
aer_bcst_ofs_strap = 0x1ff;
} else {
aer_bcst_ofs_strap = 0x3ff;
}
PHY_FLAGS_SET(unit, port, PHY_FLAGS_INDEPENDENT_LANE);
/* Broadcast all lanes only when initializing the first lane */
if (pc->lane_num == 0) {
/*
* Force the sync character to the lower byte of the parallel
* interface
*/
/* hwBm9600HcBroadcastWrite(pInitParams, HC_ffde_ADDR, 0x03ff) */
/* hwBm9600HcRead(pInitParams, HC_PORT_ZERO, HC_80b9_ADDR, &uReadData)*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit, pc, 0x00, 0x80b9, &data));
/* data = data | 0x0020;*/
data = data | (RX0_ANARXCONTROL1G_COMMA_LOW_BYTE_SM_BITS <<
RX0_ANARXCONTROL1G_COMMA_LOW_BYTE_SM_SHIFT);
/* Enable the comma byte adjust on the opposite byte */
data = data | (RX0_ANARXCONTROL1G_COMMA_BYTE_ADJ_EN_SM_BITS <<
RX0_ANARXCONTROL1G_COMMA_BYTE_ADJ_EN_SM_SHIFT);
/* hwBm9600HcBroadcastWrite(pInitParams, HC_80b9_ADDR, uReadData) */
SOC_IF_ERROR_RETURN
(HL65_BROADCAST_WRITE(unit, pc, aer_bcst_ofs_strap, 0x80b9, data));
}
/* PLL Sequencer disable */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0,
* 0x8000, 0x062f)
* >> Clear START_SEQUENCER_BITS 13
*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, 0x062f));
/* Set force_lane_mode so that lane rates can be configured independently */
/* soc_bm9600_mdio_hc_read(pInitParams->m_nBaseAddr, uPhyAddr, uLane,
* 0x8308, &uData)
*/
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_MISC1r(unit, pc, &data));
/* uData |= 0x0020 */
data |= (DIGITAL_MISC1_FORCE_LN_MODE_BITS << DIGITAL_MISC1_FORCE_LN_MODE_SHIFT);
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, uLane, 0x8308, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_MISC1r(unit, pc, data));
if (serdes_id0 == HL_SERDES_ID0_REVID_C0) {
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL0r(unit, pc, &data));
/* XgxsBlk1 Lanectrl0 (8015) :: Clear CL36- keep already set up 64/66 settings */
data &= 0xff00;
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL0r(unit, pc, data));
/*
* XgxsBlk1 Shared (0x800d) ::
* Clear SELECT_DEVPMD_EN_BITS | MMDSELECT_DEVAN_EN_BITS
* This setup matches other SBX fabric (88130)
*/
data = (XGXSBLK0_MMDSELECT_DEVDEVAD_EN_BITS <<
XGXSBLK0_MMDSELECT_DEVDEVAD_EN_SHIFT) |
(XGXSBLK0_MMDSELECT_DEVCL22_EN_BITS <<
XGXSBLK0_MMDSELECT_DEVCL22_EN_SHIFT);
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK0_MMDSELECTr(unit, pc, data));
/* SerdesDigital_Control1000X3 (0x8302) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_CONTROL1000X3r(unit, pc, 0));
/* Set pf_br_init to 4 for C0 */
/* DSC2B0_SM_CTRL7 uRegAddr = 0x8267 + (uLane*0x10) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8267 + (0x10 * pc->lane_num), 0x14A5));
/* Enable hysteresis, enable tuning state machine set postc_metric_ctrl to 1 */
/* DSC2B0_SM_CTRL0 uRegAddr = 0x8260 + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x0021) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8260 + (0x10 * pc->lane_num), 0x1821));
} else {
/* Perform suggested writes during init */
/* Set DSC2B0_SM_CTRL11[14:10] msr_br_vga_timeout = 0 */
/* uRegAddr = 0x826b + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x0312) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826b + (0x10 * pc->lane_num), 0x0312));
/* Set DSC2B0_SM_CTRL12[13:12] br_vga_lms_gain= 0 */
/* uRegAddr = 0x826c + (uLane*0x10); */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x046a) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826c + (0x10 * pc->lane_num), 0x046a));
/* Disable hysteresis, enable tuning state machine */
/* DSC2B0_SM_CTRL0 uRegAddr = 0x8260 + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x0021) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8260 + (0x10 * pc->lane_num), 0x0021));
/* Increase ACQVGA timeout to 580K bits */
/* DSC2B0_SM_CTRL2 uRegAddr = 0x8262 + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x3800)*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8262 + (0x10 * pc->lane_num), 0x3800));
/* Set pf_br_init to 2 */
/* DSC2B0_SM_CTRL7 uRegAddr = 0x8267 + (uLane*0x10) */
/* rv = soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x1495) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8267 + (0x10 * pc->lane_num), 0x1495));
/* Set vga_min=0, vga_max=31 */
/* DSC2B0_SM_CTRL8 uRegAddr = 0x8268 + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x03e0) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8268 + (0x10 * pc->lane_num), 0x03e0));
/* Set dfe_min=0, dfe_max=63 */
/* DSC2B0_SM_CTRL9 uRegAddr = 0x8269 + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x0fc0) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8269 + (0x10 * pc->lane_num), 0x0fc0));
/* Set BR ACQCDR kp=4 */
/* DSC2B0_SM_CTRL3 uRegAddr = 0x8263 + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x421b) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8263 + (0x10 * pc->lane_num), 0x421b));
/* Set BR ACQ1, ACQ2 kp=4 */
/* DSC2B0_SM_CTRL4 uRegAddr = 0x8264 + (uLane*0x10) */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, uRegAddr, 0x53e4) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x8264 + (0x10 * pc->lane_num), 0x53e4));
/* Jitter performance improvement over PVT (process voltage temperature) */
/* soc_bm9600_mdio_hc_read(pInitParams->m_nBaseAddr, uPhyAddr, 0, 0x805e, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_TXPLL_ANAPLLACONTROL4r(unit, pc, &data));
/* uData |= 0x1000 */
data |= 0x1000;
/*soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, 0x805e, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_TXPLL_ANAPLLACONTROL4r(unit, pc, data));
}
/* Set IQP to 200 uA 0x805c */
SOC_IF_ERROR_RETURN
(READ_HL65_TXPLL_ANAPLLACONTROL2r(unit, pc, &data));
/* uData |= 0x0004 */
data |= 0x0004;
/*soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, 0x805c, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_TXPLL_ANAPLLACONTROL2r(unit, pc, data));
/* PLL Sequencer enable */
/* soc_bm9600_mdio_hc_write(pInitParams->m_nBaseAddr, uPhyAddr, 0, 0x8000, 0x262f) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, 0x262f));
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_init
* Purpose:
* Initialize hc phys
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_init(int unit, soc_port_t port)
{
phy_ctrl_t *pc;
uint16 xgxs_ctrl;
uint16 vco_freq;
int mode_1000x;
uint16 id_rev;
if (PHY_HC65_FABRIC_MODE(unit, port)) {
return _phy_hl65_fabric_init(unit, port);
}
pc = INT_PHY_SW_STATE(unit, port);
if (!PHY_EXTERNAL_MODE(unit, port)) {
/* PHY reset callbacks */
SOC_IF_ERROR_RETURN(soc_phy_reset(unit, port));
if (soc_property_port_get(unit, port,
spn_SERDES_FIBER_PREF, 1)) {
PHY_FLAGS_SET(unit, port, PHY_FLAGS_FIBER);
} else {
PHY_FLAGS_CLR(unit, port, PHY_FLAGS_FIBER);
}
if (soc_property_port_get(unit, port,
spn_PHY_AN_C73, FALSE)) {
PHY_FLAGS_SET(unit, port, PHY_FLAGS_C73);
}
}
if (PHY_INDEPENDENT_LANE_MODE(unit, port)) {
/* In this mode, the device's 4 lanes connect to 4 different ports.
* It is necessary to configure and initialize the shared resource
* once before going to each lane. It is assumed the port connecting
* to lane 0 must be initialized first.
*/
if ((!PHY_FLAGS_TST(unit, port, PHY_FLAGS_INIT_DONE)) &&
(pc->lane_num == 0)) {
/* configure and initialize the resource shared by all 4 lanes*/
SOC_IF_ERROR_RETURN(_hl65_soft_reset(unit,pc)); /* reset once */
/* Force to asymetric 1G/2.5G independent lane mode.
* Support SGMII 10/100/100Mbps, 1000X, and 2500X speeds.
*/
/* workaround for a Rx problem running at 10M bps(PR20236).
* Use mode 6 for speed at 10/100/1000M bps, SGMII interface
* Use mode 5 for speed at 1000/2500 bps, optical device.
*
* Rev B and up has fixed the problem. No need to switch mode
* between fiber and SGMII.
*/
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit,pc,&id_rev));
if (!(id_rev & TEST_SERDESID0_REV_LETTER_MASK)) {
mode_1000x = FALSE;
if (PHY_FIBER_MODE(unit, port) &&
(!PHY_EXTERNAL_MODE(unit, port))) {
mode_1000x = TRUE;
}
/* Allow property to override */
mode_1000x = soc_property_port_get(unit, port,
spn_SERDES_FIBER_PREF, mode_1000x);
if (mode_1000x) {
xgxs_ctrl = 5;
} else {
xgxs_ctrl = 6;
}
} else {
/* REV B and above, use mode 6 if speed =<1000 */
if (pc->speed_max > 1000) {
xgxs_ctrl = 5;
} else {
xgxs_ctrl = 6;
}
}
/* allow mode override by configuration */
xgxs_ctrl = soc_property_port_get(unit, port,
spn_PHY_HL65_1LANE_MODE, xgxs_ctrl);
if (IS_HG_PORT(unit, port)) {
vco_freq = 0x7800;
} else {
vco_freq = xgxs_ctrl == 5? 0x7700:0x7500;
}
xgxs_ctrl <<= XGXSBLK0_XGXSCONTROL_MODE_10G_SHIFT;
/* set device's mode and disable PLL sequencer */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
xgxs_ctrl,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK |
XGXSBLK0_XGXSCONTROL_MODE_10G_MASK));
/* broadcast to all lanes */
SOC_IF_ERROR_RETURN
(WRITE_HL65_AERBLK_AERr(unit,pc, HL_AER_BCST_OFS_STRAP));
/* configure VCO frequency */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_MISC1r(unit,pc,vco_freq));
/* disable 10G parallel detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN73_PDET_PARDET10GCONTROLr(unit, pc,
0,
AN73_PDET_PARDET10GCONTROL_PARDET10G_EN_MASK));
/* reset AER */
SOC_IF_ERROR_RETURN
(WRITE_HL65_AERBLK_AERr(unit,pc, 0));
/* enable PLL sequencer */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
/* select recovery clock from lane0 for rxck0_10g */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK1_TESTTXr(unit,pc,
0,
XGXSBLK1_TESTTX_RX_CK4X1MUXSEL_MASK));
}
SOC_IF_ERROR_RETURN
(_phy_hl65_independent_lane_init(unit, port));
} else {
SOC_IF_ERROR_RETURN(_hl65_soft_reset(unit,pc)); /* soft reset */
/* Force to comboCore mode.
* Support SGMII 10/100/1000Mbps, 1000X, 2500X, 10G, and 12G.
*/
SOC_IF_ERROR_RETURN
(_phy_hl65_combo_core_init(unit, port));
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_init: u=%d p=%d\n"), unit, port));
return SOC_E_NONE;
}
/*
* phy_hl65_link_get
* Purpose:
* Get layer2 connection status.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* link - address of memory to store link up/down state.
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_link_get(int unit, soc_port_t port, int *link)
{
uint16 mii_stat;
phy_ctrl_t *pc;
if (PHY_DISABLED_MODE(unit, port)) {
*link = FALSE;
return SOC_E_NONE;
}
pc = INT_PHY_SW_STATE(unit, port);
*link = FALSE;
/* Check XAUI link first if XAUI mode */
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(READ_HL65_DTE_IEEE0BLK_DTE_IEEESTATUS1r(unit, pc, &mii_stat));
if (mii_stat & MII_STAT_LA) {
*link = TRUE;
}
}
/* Check combo link only if no XAUI link */
if (*link == FALSE) {
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_MIISTATr(unit, pc, &mii_stat));
if (mii_stat & MII_STAT_LA) {
*link = TRUE;
} else if (PHY_INDEPENDENT_LANE_MODE(unit,port)) {
/* Check dxgxs link */
if ((pc->phy_mode == PHYCTRL_DUAL_LANE_PORT) &&
(IS_HG_PORT(unit,port) || IS_XE_PORT(unit,port))) {
SOC_IF_ERROR_RETURN
(READ_HL65_DTE_IEEE0BLK_DTE_IEEESTATUS1r(unit, pc,
&mii_stat));
if (mii_stat & MII_STAT_LA) {
*link = TRUE;
}
}
}
}
return (SOC_E_NONE);
}
/*
* Function:
* phy_hl65_enable_set
* Purpose:
* Enable/Disable phy
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* enable - on/off state to set
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_enable_set(int unit, soc_port_t port, int enable)
{
int rv;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
rv = SOC_E_NONE;
if (PHY_INDEPENDENT_LANE_MODE(unit, port)) {
if (enable) {
PHY_FLAGS_CLR(unit, port, PHY_FLAGS_DISABLE);
rv = _phy_hl65_notify_resume(unit, port, PHY_STOP_PHY_DIS);
} else {
PHY_FLAGS_SET(unit, port, PHY_FLAGS_DISABLE);
rv = _phy_hl65_notify_stop(unit, port, PHY_STOP_PHY_DIS);
}
} else {
if (enable) {
PHY_FLAGS_CLR(unit, port, PHY_FLAGS_DISABLE);
rv = MODIFY_HL65_XGXSBLK0_MISCCONTROL1r(unit, pc, 0,
XGXSBLK0_MISCCONTROL1_GLOBAL_PMD_TX_DISABLE_MASK);
/* enable Rx */
rv = MODIFY_HL65_DSC2BB_DSC_MISC_CTRL0r(unit, pc, 0,
DSC2BB_DSC_MISC_CTRL0_RXSEQSTART_MASK);
} else {
PHY_FLAGS_SET(unit, port, PHY_FLAGS_DISABLE);
rv = MODIFY_HL65_XGXSBLK0_MISCCONTROL1r(unit, pc,
XGXSBLK0_MISCCONTROL1_GLOBAL_PMD_TX_DISABLE_MASK,
XGXSBLK0_MISCCONTROL1_GLOBAL_PMD_TX_DISABLE_MASK);
/* disable Rx */
rv = MODIFY_HL65_DSC2BB_DSC_MISC_CTRL0r(unit, pc,
DSC2BB_DSC_MISC_CTRL0_RXSEQSTART_MASK,
DSC2BB_DSC_MISC_CTRL0_RXSEQSTART_MASK);
}
}
return rv;
}
/*
* Function:
* phy_hl65_enable_get
* Purpose:
* Get Enable/Disable status
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* enable - address of where to store on/off state
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_enable_get(int unit, soc_port_t port, int *enable)
{
*enable = !PHY_FLAGS_TST(unit, port, PHY_FLAGS_DISABLE);
return SOC_E_NONE;
}
STATIC int
_phy_hl65_dsp_cfg (int unit, phy_ctrl_t *pc, int speed)
{
uint16 serdes_id0;
uint16 brcdr;
/* For speed at 20G, configure the device for BR CDR. */
if (speed == 20000) {
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1) ) {
brcdr = HL65_A0A1_DSC_DFE_BRCDR;
} else if ((serdes_id0 == HL_SERDES_ID0_REVID_B0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_C0) ) {
brcdr = HL65_B0C0_DSC_DFE_BRCDR;
} else {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"HL65 : BR-CDR setting may not be correct: u=%d p=%d\n"), unit, pc->port));
brcdr = HL65_B0C0_DSC_DFE_BRCDR; /* assumed for future versions */
}
/* enable DFE/BR CDR */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DSC2BB_DSC_MISC_CTRL0r(unit, pc, brcdr));
} else {
/* default value for CDR */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DSC2BB_DSC_MISC_CTRL0r(unit, pc, 0x2000));
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_fabric_mode_speed_set
* Purpose:
* Set PHY speed
* Parameters:
* unit - SBX device unit #.
* port - SBX device port #.
* speed - link speed in Mbps
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_fabric_mode_speed_set(int unit, soc_port_t port, int speed)
{
phy_ctrl_t *pc;
uint16 data;
int rv = SOC_E_NONE;
uint16 serdes_id0;
if (SOC_IS_RELOADING(unit)) {
return SOC_E_NONE;
}
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
switch (speed) {
case 3125:
/* Disable baud rate CDR */
/* uRegAddr = 0x826e + (uLaneAddr*0x10)*/
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uRegAddr, 0x2000) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826E + (0x10 * pc->lane_num),
DSC2B0_DSC_MISC_CTRL0_ENABLE_ACOR_PICW_BITS <<
DSC2B0_DSC_MISC_CTRL0_ENABLE_ACOR_PICW_SHIFT));
/* 6.25G rate half speed 0x603a */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, 0x8308, 0x603A)*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_MISC1r(unit, pc, 0x603a));
/* Set 6.25G speed through the backdoor method clock divisor is in shared lane register */
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, 0x8016, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL1r(unit, pc, &data));
/* clear bits */
data &= ~(0x0303 << (pc->lane_num * 2));
data |= (0x0202 << (pc->lane_num * 2));
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8016, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL1r(unit, pc, data));
/* Set half-rate indicator for equalization algorithm to work */
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8065, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_TX0_ANATXACONTROL1r(unit, pc, &data));
/* uData &= ~(BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_MASK << BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_SHIFT) */
/* uData |= (1 << BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_SHIFT) */
data &= ~(TX0_ANATXACONTROL1_TX_SEL_HALFRATE_BITS <<
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_SHIFT);
data |= (TX0_ANATXACONTROL1_TX_SEL_HALFRATE_BITS <<
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, 0x8065, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_TX0_ANATXACONTROL1r(unit, pc, data));
break;
case 6250:
/* Force baud rate CDR */
/* uRegAddr = 0x826e + (uLaneAddr*0x10) */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uRegAddr, 0x2180) */
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1)) {
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826E + (0x10 * pc->lane_num),
0x2180));
} else {
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826E + (0x10 * pc->lane_num),
0x2300));
}
/* 6.25G rate 156.25MHz then mult by 40 + independent lane mode setting */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, 0x8308, 0x7720) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_MISC1r(unit, pc, 0x7720));
/* Set 6.25G speed through the backdoor method clock divisor is in shared lane register */
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, 0x8016, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL1r(unit, pc, &data));
/* DWSDR_div1 = 0x3 for receive and transmit */
/* uData |= 0x0303 << (uLaneAddr * 2) */
data |= 0x0303 << (pc->lane_num * 2);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8016, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL1r(unit, pc, data));
/* Clear half-rate indicator for equalization algorithm to work */
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8065, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_TX0_ANATXACONTROL1r(unit, pc, &data));
/* uData &= ~(BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_MASK << BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_SHIFT) */
/* uData |= (0 << BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_SHIFT) */
data &= ~(TX0_ANATXACONTROL1_TX_SEL_HALFRATE_BITS <<
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, 0x8065, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_TX0_ANATXACONTROL1r(unit, pc, data));
break;
case 6500:
/* Jitter performance improvement over PVT - kvh_force=1 */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x805e, 0x1877) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_TXPLL_ANAPLLACONTROL4r(unit, pc, 0x1877));
/* Force baud rate CDR */
/* uRegAddr = 0x826e + (uLaneAddr*0x10) */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uRegAddr, 0x2180) */
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1)) {
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826E + (0x10 * pc->lane_num),
0x2180));
} else {
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826E + (0x10 * pc->lane_num),
0x2300));
}
/* 6.5G independent lane mode setting */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, 0x8308, 0x7820) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_MISC1r(unit, pc, 0x7820));
/* Set 6.5G speed through the backdoor method clock divisor is in shared lane register */
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, 0x8016, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL1r(unit, pc, &data));
/* DWSDR_div1 = 0x3 for receive and transmit */
/* uData |= 0x0303 << (uLaneAddr * 2) */
data |= 0x0303 << (pc->lane_num * 2);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8016, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL1r(unit, pc, data));
/* Clear half-rate indicator for equalization algorithm to work */
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8065, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_TX0_ANATXACONTROL1r(unit, pc, &data));
/* uData &= ~(BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_MASK << BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_SHIFT) */
/* uData |= (0 << BM9600_HYPERCORE_8065_TX_SEL_HALF_RATE_SHIFT) */
data &= ~(TX0_ANATXACONTROL1_TX_SEL_HALFRATE_BITS <<
TX0_ANATXACONTROL1_TX_SEL_HALFRATE_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, 0x8065, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_TX0_ANATXACONTROL1r(unit, pc, data));
break;
default:
rv = SOC_E_PARAM;
}
return rv;
}
/*
* Function:
* phy_hl65_speed_set
* Purpose:
* Set PHY speed
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* speed - link speed in Mbps
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_speed_set(int unit, soc_port_t port, int speed)
{
phy_ctrl_t *pc;
uint16 speed_val, mask;
uint16 speed_mii;
uint16 sgmii_status = 0;
int hg10g_port = FALSE;
int rxaui;
if (PHY_HC65_FABRIC_MODE(unit, port)) {
return phy_hl65_fabric_mode_speed_set(unit, port, speed);
}
pc = INT_PHY_SW_STATE(unit, port);
if (PHY_INDEPENDENT_LANE_MODE(unit, port) && (speed > 12000)) {
return SOC_E_PARAM;
}
/* check if RXAUI is set in combo mode */
rxaui = soc_property_port_get(unit, port,
spn_SERDES_2WIRE_XAUI, FALSE);
/* HC rev D0 supports 10G and 12G speeds in dxgxs mode in ind. lane mode */
if (pc->phy_mode == PHYCTRL_DUAL_LANE_PORT) {
rxaui = TRUE;
}
if (IS_HG_PORT(unit, port) &&
soc_property_port_get(unit, port, spn_10G_IS_CX4, TRUE) == FALSE) {
hg10g_port = TRUE;
}
speed_val = 0;
speed_mii = 0;
mask = DIGITAL_MISC1_FORCE_SPEED_MASK;
switch (speed) {
case 0:
/* Do not change speed */
return SOC_E_NONE;
case 10:
speed_mii = MII_CTRL_SS_10;
break;
case 100:
speed_mii = MII_CTRL_SS_100;
break;
case 1000:
speed_mii = MII_CTRL_SS_1000;
break;
case 2500:
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_2500BRCM_X1;
break;
case 10000:
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_10GBASE_CX4; /* 10G CX4 */
if ((hg10g_port == TRUE) && rxaui) {
speed_val = 0x21; /* 10.5HiG dual-XGXS */
} else if (rxaui) {
speed_val = 0x20; /* 10G ethernet dual-XGXS */
} else if (hg10g_port == TRUE) {
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_10GHiGig_X4; /* 10G HiG */
}
break;
case 12000:
speed_val = rxaui? 0x23: /* 12.7HiG dual-XGXS*/
DIGITAL_MISC1_FORCE_SPEED_dr_12GHiGig_X4; /* 12 HiG */
break;
case 13000:
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_13GHiGig_X4;
break;
case 16000:
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_16GHiGig_X4;
break;
case 20000:
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_20GHiGig_X4;
break;
case 21000:
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_21GHiGig_X4;
break;
case 25000:
speed_val = DIGITAL_MISC1_FORCE_SPEED_dr_25p45GHiGig_X4;
break;
default:
return SOC_E_PARAM;
}
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
/* set scrambler controls */
if (speed == 20000) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGMIIRCONTROLr(unit,pc,
XGXSBLK0_XGMIIRCONTROL_SCR_EN_4LANE_MASK,
XGXSBLK0_XGMIIRCONTROL_SCR_EN_4LANE_MASK));
} else {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGMIIRCONTROLr(unit,pc,
0,
XGXSBLK0_XGMIIRCONTROL_SCR_EN_4LANE_MASK));
}
_phy_hl65_dsp_cfg(unit,pc,speed);
/* Puts PLL in reset state and forces all datapath into reset state */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, 0,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
/* 2wire XAUI configuration */
SOC_IF_ERROR_RETURN
(_hl65_rxaui_config(unit,pc,rxaui));
} else {
/* Hold rxSeqStart */
SOC_IF_ERROR_RETURN
(HL65_REG_MODIFY(unit,pc,0x0,0x826E + (0x10 * pc->lane_num),
DSC2B0_DSC_MISC_CTRL0_RXSEQSTART_MASK,
DSC2B0_DSC_MISC_CTRL0_RXSEQSTART_MASK));
/* hold TX FIFO in reset */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X3r(unit, pc,
DIGITAL_CONTROL1000X3_TX_FIFO_RST_MASK,
DIGITAL_CONTROL1000X3_TX_FIFO_RST_MASK));
}
/* disable 100FX and 100FX auto-detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_FX100_CONTROL1r(unit,pc,
0,
FX100_CONTROL1_AUTODET_EN_MASK |
FX100_CONTROL1_ENABLE_MASK));
/* disable 100FX idle detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_FX100_CONTROL3r(unit,pc,
FX100_CONTROL3_CORRELATOR_DISABLE_MASK,
FX100_CONTROL3_CORRELATOR_DISABLE_MASK));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_MISC1r(unit, pc, speed_val, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL4_MISC3r(unit, pc,
(speed_val & 0x20)? DIGITAL4_MISC3_FORCE_SPEED_B5_MASK:0,
DIGITAL4_MISC3_FORCE_SPEED_B5_MASK));
if (speed <= 1000) {
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_STATUS1000X1r(unit, pc, &sgmii_status));
sgmii_status &= DIGITAL_STATUS1000X1_SGMII_MODE_MASK;
if (!sgmii_status && (speed == 100)) {
/* fiber mode 100fx, enable */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_FX100_CONTROL1r(unit,pc,
FX100_CONTROL1_FAR_END_FAULT_EN_MASK |
FX100_CONTROL1_ENABLE_MASK,
FX100_CONTROL1_FAR_END_FAULT_EN_MASK |
FX100_CONTROL1_ENABLE_MASK));
/* enable 100fx extended packet size */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_FX100_CONTROL2r(unit,pc,
FX100_CONTROL2_EXTEND_PKT_SIZE_MASK,
FX100_CONTROL2_EXTEND_PKT_SIZE_MASK));
} else {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, speed_mii,
MII_CTRL_SS_MASK));
}
}
/* for speed above 10G, txcko_div must be cleared */
speed_val = (speed > 10000) ? 0: XGXSBLK0_XGXSCONTROL_TXCKO_DIV_MASK;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, speed_val,
XGXSBLK0_XGXSCONTROL_TXCKO_DIV_MASK));
/* set tx half rate based on speed */
SOC_IF_ERROR_RETURN
(_phy_hl65_half_rate_set(unit,port,speed));
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
/* Bring PLL out of reset */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
(void) _phy_hl65_pll_lock_wait(unit, port);
} else {
/* release rxSeqStart */
SOC_IF_ERROR_RETURN
(HL65_REG_MODIFY(unit,pc,0x0,0x826E + (0x10 * pc->lane_num),
0,
DSC2B0_DSC_MISC_CTRL0_RXSEQSTART_MASK));
/* release TX FIFO reset */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X3r(unit, pc,
0,
DIGITAL_CONTROL1000X3_TX_FIFO_RST_MASK));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_tx_fifo_reset(int unit, soc_port_t port,uint32 speed)
{
uint16 data16;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
if (speed == 100) {
/* check if it is in 100fx mode */
SOC_IF_ERROR_RETURN
(READ_HL65_FX100_CONTROL1r(unit,pc,&data16));
if (data16 & FX100_CONTROL1_ENABLE_MASK) {
/* reset TX FIFO */
SOC_IF_ERROR_RETURN
(HL65_REG_MODIFY(unit,pc,0x0,0x8061 + (0x10 * pc->lane_num),
TX0_ANATXACONTROL0_TX1G_FIFO_RST_MASK,
TX0_ANATXACONTROL0_TX1G_FIFO_RST_MASK));
SOC_IF_ERROR_RETURN
(HL65_REG_MODIFY(unit,pc,0x0,0x8061 + (0x10 * pc->lane_num),
0,
TX0_ANATXACONTROL0_TX1G_FIFO_RST_MASK));
}
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_fabric_mode_speed_get
* Purpose:
* Get PHY speed
* Parameters:
* unit - SBX device unit #.
* port - SBX device port #.
* speed - link speed in Mbps
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_fabric_mode_speed_get(int unit, soc_port_t port, int *speed)
{
phy_ctrl_t *pc;
uint16 data;
pc = INT_PHY_SW_STATE(unit, port);
/* read speed from hardware */
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8308, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_MISC1r(unit, pc, &data));
if (data == 0x7720) {
*speed = 6250;
} else if (data == 0x7820) {
*speed = 6500;
} else {
*speed = 3125;
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_speed_get
* Purpose:
* Get PHY speed
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* speed - current link speed in Mbps
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_speed_get(int unit, soc_port_t port, int *speed)
{
phy_ctrl_t *pc;
uint16 speed_val;
if (PHY_HC65_FABRIC_MODE(unit, port)) {
return phy_hl65_fabric_mode_speed_get(unit, port, speed);
}
pc = INT_PHY_SW_STATE(unit, port);
if (PHY_INDEPENDENT_LANE_MODE(unit, port)) {
uint16 sd_stat;
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_STATUS1000X1r(unit, pc, &sd_stat));
sd_stat = (sd_stat & DIGITAL_STATUS1000X1_SPEED_STATUS_MASK)
>> DIGITAL_STATUS1000X1_SPEED_STATUS_SHIFT;
switch (sd_stat) {
case 2:
*speed = 1000;
break;
case 3:
*speed = 2500;
break;
case 0:
*speed = 10;
break;
case 1:
*speed = 100;
break;
default:
*speed = 0;
}
/* check dxgxs speeds
* There is no speed status for second dxgxs block. We'll simply
* check what the speed is set. It should be OK since the dxgxs mode
* does not support autoneg
*/
if ((pc->phy_mode == PHYCTRL_DUAL_LANE_PORT) &&
(IS_HG_PORT(unit,port) || IS_XE_PORT(unit,port))) {
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL4_MISC3r(unit, pc, &speed_val));
if (speed_val & DIGITAL4_MISC3_FORCE_SPEED_B5_MASK) {
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_MISC1r(unit, pc, &speed_val));
if ((speed_val & DIGITAL_MISC1_FORCE_SPEED_MASK) == 3) {
*speed=12000;
} else if ((speed_val & DIGITAL_MISC1_FORCE_SPEED_MASK) == 0 ||
(speed_val & DIGITAL_MISC1_FORCE_SPEED_MASK) == 1) {
*speed=10000;
}
}
}
} else {
uint16 xgxs_stat;
uint16 xgxs20g_stat = 0;
SOC_IF_ERROR_RETURN
(READ_HL65_GP_STATUS_XGXSSTATUS1r(unit, pc, &xgxs_stat));
switch (xgxs_stat & GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_MASK) {
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_10M:
*speed = 10;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_100M:
*speed = 100;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_1G:
*speed = 1000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_2p5G:
*speed = 2500;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_5G_X4:
*speed = 5000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_6G_X4:
*speed = 6000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_10G_HiG:
/* fall through */
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_10G_CX4:
*speed = 10000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_12G_HiG:
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_12p5G_X4:
*speed = 12000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_13G_X4:
*speed = 13000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_15G_X4:
*speed = 15000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_16G_X4:
*speed = 16000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_1G_KX:
*speed = 1000;
break;
case GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_dr_10G_KX4:
*speed = 10000;
break;
default:
*speed = 0;
}
/* check 20G and above and dxgxs speed */
SOC_IF_ERROR_RETURN
(READ_HL65_AN73_PDET_XGXSSTATUS4r(unit, pc, &xgxs20g_stat));
xgxs20g_stat &= AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_MASK;
switch (xgxs20g_stat) {
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_20G_X4:
*speed=20000;
break;
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_21G_X4:
*speed=21000;
break;
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_25G_X4:
*speed=25000;
break;
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_10G_HiG_DXGXS:
/* fall through */
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_10G_DXGXS:
/* fall through */
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_10p5G_HiG_DXGXS:
/* fall through */
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_10p5G_DXGXS:
*speed = 10000;
break;
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_12p773G_HiG_DXGXS: /* fall through */
case AN73_PDET_XGXSSTATUS4_ACTUAL_SPEED_LN0_dr_12p773G_DXGXS:
*speed = 12000;
break;
default:
break;
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_speed_get: u=%d p=%d GP_STATUS_TOPANSTATUS1 %04x speed= %d\n"),
unit, port,
((xgxs_stat & GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_MASK) >>
GP_STATUS_XGXSSTATUS1_ACTUAL_SPEED_LN0_SHIFT), *speed));
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_an_set
* Purpose:
* Enable or disabled auto-negotiation on the specified port.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* an - Boolean, if true, auto-negotiation is enabled
* (and/or restarted). If false, autonegotiation is disabled.
* Returns:
* SOC_E_XXX
*/
int
phy_hl65_an_set(int unit, soc_port_t port, int an)
{
phy_ctrl_t *pc;
uint16 an_enable;
uint16 auto_det;
uint16 data16;
uint16 mask16;
pc = INT_PHY_SW_STATE(unit, port);
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_an_set: u=%d p=%d an=%d\n"),
unit, port, an));
an_enable = 0;
auto_det = 0;
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
data16 = 0;
mask16 = AN73_PDET_PARDET10GCONTROL_PARDET10G_EN_MASK;
if (soc_property_port_get(unit, port, spn_XGXS_PDETECT_10G, 1) && an) {
data16 = AN73_PDET_PARDET10GCONTROL_PARDET10G_EN_MASK;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN73_PDET_PARDET10GCONTROLr(unit, pc, data16,
mask16));
/* Always enable 1000X parallel detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X2r(unit, pc,
DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_MASK,
DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_MASK));
}
if (an) {
/* disable 100FX and 100FX auto-detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_FX100_CONTROL1r(unit,pc,
0,
FX100_CONTROL1_AUTODET_EN_MASK |
FX100_CONTROL1_ENABLE_MASK));
/* disable 100FX idle detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_FX100_CONTROL3r(unit,pc,
FX100_CONTROL3_CORRELATOR_DISABLE_MASK,
FX100_CONTROL3_CORRELATOR_DISABLE_MASK));
/* set tx half rate with default value before starting AN */
SOC_IF_ERROR_RETURN
(_phy_hl65_half_rate_set(unit,port,0));
an_enable = MII_CTRL_AE | MII_CTRL_RAN;
/*
* Should read one during init and cache it in Phy flags
*/
if (soc_property_port_get(unit, port,
spn_SERDES_AUTOMEDIUM,
(PHY_INDEPENDENT_LANE_MODE(unit, port)) ?
FALSE : TRUE)) {
auto_det = DIGITAL_CONTROL1000X1_AUTODET_EN_MASK;
}
/* If auto-neg is enabled, make sure not forcing any speed */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_MISC1r(unit, pc, 0,
DIGITAL_MISC1_FORCE_SPEED_MASK));
/* Enable/Disable auto detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X1r(unit, pc, auto_det,
DIGITAL_CONTROL1000X1_AUTODET_EN_MASK));
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
/*
* Set the default value for DSP related registers which may be
* changed for 20G forced speed mode, otherwise AN won't work
*/
/* clear scrambler controls */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGMIIRCONTROLr(unit,pc,
0,
XGXSBLK0_XGMIIRCONTROL_SCR_EN_4LANE_MASK));
_phy_hl65_dsp_cfg(unit,pc,0);
/* clear 2wire XAUI configuration */
SOC_IF_ERROR_RETURN
(_hl65_rxaui_config(unit,pc,FALSE));
/* only in combo mode, reset the sequence. In independent mode,
* resetting sequence affects all lanes
*/
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, 0,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
/* set BAM enable */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL6_MP5_NEXTPAGECTRLr(unit,pc,1));
/* enable autoneg */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, MII_CTRL_AE,
MII_CTRL_AE));
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN_IEEE0BLK_AN_IEEECONTROL1r(unit, pc,
MII_CTRL_AE,
MII_CTRL_AE));
}
/* restart the sequence */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
/* wait for PLL lock */
_phy_hl65_pll_lock_wait(unit, port);
}
} else {
/* Disable auto detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X1r(unit, pc, auto_det,
DIGITAL_CONTROL1000X1_AUTODET_EN_MASK));
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, 0,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
/* reset BAM enable */
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL6_MP5_NEXTPAGECTRLr(unit,pc,0));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, 0,
MII_CTRL_AE));
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN_IEEE0BLK_AN_IEEECONTROL1r(unit, pc,
0,
MII_CTRL_AE));
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK,
XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK));
/* wait for PLL lock */
_phy_hl65_pll_lock_wait(unit, port);
}
}
/* restart the autoneg if enabled, or disable the autoneg */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, an_enable,
MII_CTRL_AE | MII_CTRL_RAN));
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN_IEEE0BLK_AN_IEEECONTROL1r(unit, pc, an_enable,
MII_CTRL_AE | MII_CTRL_RAN));
}
pc->fiber.autoneg_enable = an;
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_an_get
* Purpose:
* Get the current auto-negotiation status (enabled/busy)
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* an - (OUT) if true, auto-negotiation is enabled.
* an_done - (OUT) if true, auto-negotiation is complete. This
* value is undefined if an == false.
* Returns:
* SOC_E_XXX
*/
STATIC int
phy_hl65_an_get(int unit, soc_port_t port, int *an, int *an_done)
{
uint16 mii_ctrl;
uint16 mii_stat;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, &mii_ctrl));
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_MIISTATr(unit, pc, &mii_stat));
*an = (mii_ctrl & MII_CTRL_AE) ? TRUE : FALSE;
*an_done = (mii_stat & MII_STAT_AN_DONE) ? TRUE : FALSE;
if (!((*an == TRUE) && (*an_done == TRUE))) {
if (PHY_CLAUSE73_MODE(unit, port)) {
/* check clause 73 */
SOC_IF_ERROR_RETURN
(READ_HL65_AN_IEEE0BLK_AN_IEEECONTROL1r(unit, pc, &mii_ctrl));
SOC_IF_ERROR_RETURN
(READ_HL65_AN_IEEE0BLK_AN_IEEESTATUS1r(unit, pc, &mii_stat));
*an = (mii_ctrl & MII_CTRL_AE) ? TRUE : FALSE;
*an_done = (mii_stat & MII_STAT_AN_DONE) ? TRUE : FALSE;
}
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_c73_adv_local_set(int unit, soc_port_t port,
soc_port_ability_t *ability)
{
uint16 an_adv;
uint16 pause;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
an_adv = (ability->speed_full_duplex & SOC_PA_SPEED_1000MB) ?
CL73_AN_ADV_TECH_1G_KX : 0;
an_adv |= (ability->speed_full_duplex & SOC_PA_SPEED_10GB) ?
CL73_AN_ADV_TECH_10G_KX4 : 0;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN_IEEE1BLK_AN_ADVERTISEMENT1r(unit, pc, an_adv,
CL73_AN_ADV_TECH_SPEEDS_MASK));
switch (ability->pause & (SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX)) {
case SOC_PA_PAUSE_TX:
pause = CL73_AN_ADV_ASYM_PAUSE;
break;
case SOC_PA_PAUSE_RX:
pause = CL73_AN_ADV_PAUSE | CL73_AN_ADV_ASYM_PAUSE;
break;
case SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX:
pause = CL73_AN_ADV_PAUSE;
break;
default:
pause = 0;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_AN_IEEE1BLK_AN_ADVERTISEMENT0r(unit, pc, pause,
(CL73_AN_ADV_PAUSE |
CL73_AN_ADV_ASYM_PAUSE)));
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"_phy_hl65_c73_adv_local_set: u=%d p=%d pause=%08x speeds=%04x,adv=0x%x\n"),
unit, port, pause, an_adv,ability->speed_full_duplex));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_c73_adv_local_get(int unit, soc_port_t port,
soc_port_ability_t *ability)
{
uint16 an_adv;
soc_port_mode_t speeds,pause;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_AN_IEEE1BLK_AN_ADVERTISEMENT1r(unit, pc, &an_adv));
speeds = (an_adv & CL73_AN_ADV_TECH_1G_KX) ? SOC_PA_SPEED_1000MB : 0;
speeds |= (an_adv & CL73_AN_ADV_TECH_10G_KX4) ? SOC_PA_SPEED_10GB : 0;
ability->speed_full_duplex |= speeds;
SOC_IF_ERROR_RETURN
(READ_HL65_AN_IEEE1BLK_AN_ADVERTISEMENT0r(unit, pc, &an_adv));
switch (an_adv & (CL73_AN_ADV_PAUSE | CL73_AN_ADV_ASYM_PAUSE)) {
case CL73_AN_ADV_PAUSE:
pause = SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX;
break;
case CL73_AN_ADV_ASYM_PAUSE:
pause = SOC_PA_PAUSE_TX;
break;
case CL73_AN_ADV_PAUSE | CL73_AN_ADV_ASYM_PAUSE:
pause = SOC_PA_PAUSE_RX;
break;
default:
pause = 0;
}
ability->pause = pause;
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"_phy_hl65_c73_adv_local_get: u=%d p=%d pause=%08x speeds=%04x\n"),
unit, port, pause, speeds));
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_ability_advert_set
* Purpose:
* Set the current advertisement for auto-negotiation.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* mode - Port mode mask indicating supported options/speeds.
* Returns:
* SOC_E_XXX
* Notes:
* The advertisement is set only for the ACTIVE medium.
* No synchronization performed at this level.
*/
STATIC int
phy_hl65_ability_advert_set(int unit, soc_port_t port,
soc_port_ability_t *ability)
{
uint16 an_adv;
uint16 an_sp_20g;
soc_port_mode_t mode;
phy_ctrl_t *pc;
if (NULL == ability) {
return (SOC_E_PARAM);
}
pc = INT_PHY_SW_STATE(unit, port);
/*
* Set advertised duplex (only FD supported).
*/
an_adv = (ability->speed_full_duplex & SOC_PA_SPEED_1000MB) ? MII_ANA_C37_FD : 0;
/*
* Set advertised pause bits in link code word.
*/
switch (ability->pause & (SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX)) {
case SOC_PA_PAUSE_TX:
an_adv |= MII_ANA_C37_ASYM_PAUSE;
break;
case SOC_PA_PAUSE_RX:
an_adv |= MII_ANA_C37_PAUSE | MII_ANA_C37_ASYM_PAUSE;
break;
case SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX:
an_adv |= MII_ANA_C37_PAUSE;
break;
}
/* Update less than 1G capability */
SOC_IF_ERROR_RETURN
(WRITE_HL65_COMBO_IEEE0_AUTONEGADVr(unit, pc, an_adv));
mode = ability->speed_full_duplex;
an_adv = 0;
an_sp_20g = 0;
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
an_adv |= (mode & SOC_PA_SPEED_2500MB) ?
DIGITAL3_UP1_DATARATE_2P5GX1_MASK : 0;
an_adv |= (mode & SOC_PA_SPEED_12GB) ?
DIGITAL3_UP1_DATARATE_12GX4_MASK : 0;
an_adv |= (mode & SOC_PA_SPEED_13GB) ?
DIGITAL3_UP1_DATARATE_13GX4_MASK : 0;
an_adv |= (mode & SOC_PA_SPEED_16GB) ?
DIGITAL3_UP1_DATARATE_16GX4_MASK : 0;
/* 20G operation in autoneg is not reliable.
* Use forced mode only.
*an_adv |= (mode & SOC_PA_SPEED_20GB) ?
* DIGITAL3_UP1_DATARATE_20GX4_MASK : 0;
*/
an_sp_20g |= (mode & SOC_PA_SPEED_21GB) ?
DIGITAL3_UP3_DATARATE_21GX4_MASK : 0;
an_sp_20g |= (mode & SOC_PA_SPEED_25GB) ?
DIGITAL3_UP3_DATARATE_25P45GX4_MASK : 0;
}
if (mode & SOC_PA_SPEED_10GB) {
if (IS_HG_PORT(unit, port)) {
/* For Draco and Hercules, use pre-CX4 signalling */
an_adv |= DIGITAL3_UP1_DATARATE_10GX4_MASK;
if (soc_property_port_get(unit, port, spn_10G_IS_CX4, TRUE)) {
/* Also include 10G CX4 signalling by default */
an_adv |= DIGITAL3_UP1_DATARATE_10GCX4_MASK;
}
} else {
an_adv |= DIGITAL3_UP1_DATARATE_10GCX4_MASK;
}
}
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL3_UP1r(unit, pc, an_adv));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL3_UP3r(unit, pc, an_sp_20g,
OVER1G_UP3_20GPLUS_MASK));
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(_phy_hl65_c73_adv_local_set(unit, port, ability));
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_ability_advert_set: u=%d p=%d pause=%08x OVER1G_UP1 %04x\n"),
unit, port, ability->pause, an_adv));
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_ability_advert_get
* Purpose:
* Get the current advertisement for auto-negotiation.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* mode - (OUT) Port mode mask indicating supported options/speeds.
* Returns:
* SOC_E_XXX
* Notes:
* The advertisement is retrieved for the ACTIVE medium.
* No synchronization performed at this level.
*/
STATIC int
phy_hl65_ability_advert_get(int unit, soc_port_t port,
soc_port_ability_t *ability)
{
uint16 an_adv;
uint16 an_sp_20g;
soc_port_mode_t mode;
phy_ctrl_t *pc;
if (NULL == ability) {
return (SOC_E_PARAM);
}
pc = INT_PHY_SW_STATE(unit, port);
sal_memset(ability, 0, sizeof(*ability));
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL3_UP1r(unit, pc, &an_adv));
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL3_UP3r(unit, pc, &an_sp_20g));
mode = 0;
mode |= (an_sp_20g & DIGITAL3_UP3_DATARATE_25P45GX4_MASK) ?
SOC_PA_SPEED_25GB : 0;
mode |= (an_sp_20g & DIGITAL3_UP3_DATARATE_21GX4_MASK) ?
SOC_PA_SPEED_21GB : 0;
mode |= (an_adv & DIGITAL3_UP1_DATARATE_20GX4_MASK) ? SOC_PA_SPEED_20GB : 0;
mode |= (an_adv & DIGITAL3_UP1_DATARATE_16GX4_MASK) ? SOC_PA_SPEED_16GB : 0;
mode |= (an_adv & DIGITAL3_UP1_DATARATE_13GX4_MASK) ? SOC_PA_SPEED_13GB : 0;
mode |= (an_adv & DIGITAL3_UP1_DATARATE_12GX4_MASK) ? SOC_PA_SPEED_12GB : 0;
mode |= (an_adv & DIGITAL3_UP1_DATARATE_10GCX4_MASK) ? SOC_PA_SPEED_10GB: 0;
mode |= (an_adv & DIGITAL3_UP1_DATARATE_10GX4_MASK) ? SOC_PA_SPEED_10GB : 0;
mode |= (an_adv & DIGITAL3_UP1_DATARATE_2P5GX1_MASK) ?
SOC_PA_SPEED_2500MB : 0;
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_AUTONEGADVr(unit, pc, &an_adv));
mode |= (an_adv & MII_ANA_C37_FD) ? SOC_PA_SPEED_1000MB : 0;
ability->speed_full_duplex = mode;
mode = 0;
switch (an_adv & (MII_ANA_C37_PAUSE | MII_ANA_C37_ASYM_PAUSE)) {
case MII_ANA_C37_PAUSE:
mode = SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX;
break;
case MII_ANA_C37_ASYM_PAUSE:
mode = SOC_PA_PAUSE_TX;
break;
case MII_ANA_C37_PAUSE | MII_ANA_C37_ASYM_PAUSE:
mode = SOC_PA_PAUSE_RX;
break;
}
ability->pause = mode;
/* check for clause73 */
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(_phy_hl65_c73_adv_local_get(unit, port, ability));
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_ability_advert_get:unit=%d p=%d pause=%08x sp=%08x\n"),
unit, port, ability->pause, ability->speed_full_duplex));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_c73_adv_remote_get(int unit, soc_port_t port,
soc_port_ability_t *ability)
{
uint16 an_adv;
soc_port_mode_t mode;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_AN_IEEE1BLK_AN_LP_BASEPAGEABILITY1r(unit, pc, &an_adv));
mode = (an_adv & CL73_AN_ADV_TECH_1G_KX) ? SOC_PA_SPEED_1000MB : 0;
mode |= (an_adv & CL73_AN_ADV_TECH_10G_KX4) ? SOC_PA_SPEED_10GB : 0;
ability->speed_full_duplex |= mode;
SOC_IF_ERROR_RETURN
(READ_HL65_AN_IEEE1BLK_AN_LP_BASEPAGEABILITY0r(unit, pc, &an_adv));
mode = 0;
switch (an_adv & (CL73_AN_ADV_PAUSE | CL73_AN_ADV_ASYM_PAUSE)) {
case CL73_AN_ADV_PAUSE:
mode = SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX;
break;
case CL73_AN_ADV_ASYM_PAUSE:
mode = SOC_PA_PAUSE_TX;
break;
case CL73_AN_ADV_PAUSE | CL73_AN_ADV_ASYM_PAUSE:
mode = SOC_PA_PAUSE_RX;
break;
}
ability->pause = mode;
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_ability_remote_get
* Purpose:
* Get the current advertisement for auto-negotiation.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* mode - (OUT) Port mode mask indicating supported options/speeds.
* Returns:
* SOC_E_XXX
* Notes:
* The advertisement is retrieved for the ACTIVE medium.
* No synchronization performed at this level.
*/
STATIC int
phy_hl65_ability_remote_get(int unit, soc_port_t port,
soc_port_ability_t *ability)
{
uint16 an_adv;
uint16 an_sp_20g;
uint16 data16;
int an_enable;
int link_1000x = FALSE;
int link_combo = FALSE;
soc_port_mode_t mode;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, &data16));
an_enable = (data16 & MII_CTRL_AE) ? TRUE : FALSE;
if (PHY_INDEPENDENT_LANE_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_STATUS1000X1r(unit, pc, &data16));
if (data16 & DIGITAL_STATUS1000X1_LINK_STATUS_MASK) {
link_1000x = TRUE;
}
} else {
SOC_IF_ERROR_RETURN
(READ_HL65_GP_STATUS_XGXSSTATUS1r(unit, pc, &data16));
if (data16 & (GP_STATUS_XGXSSTATUS1_LINKSTAT_MASK |
GP_STATUS_XGXSSTATUS1_LINK10G_MASK)) {
link_combo = TRUE;
}
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"u=%d p=%d an_enable=%04x link_1000x=%04x link_combo=%04x\n"),
unit, port, an_enable, link_1000x,link_combo));
sal_memset(ability, 0, sizeof(*ability));
mode = 0;
if (an_enable && (link_1000x || link_combo)) {
/* Decode remote advertisement only when link is up and autoneg is
* completed.
*/
SOC_IF_ERROR_RETURN
(READ_HL65_GP_STATUS_LP_UP3r(unit, pc, &an_sp_20g));
SOC_IF_ERROR_RETURN
(READ_HL65_GP_STATUS_LP_UP1r(unit, pc, &an_adv));
mode |= (an_sp_20g & GP_STATUS_LP_UP3_DATARATE_25P45GX4_MASK)?
SOC_PA_SPEED_25GB: 0;
mode |= (an_sp_20g & GP_STATUS_LP_UP3_DATARATE_21GX4_MASK)?
SOC_PA_SPEED_21GB: 0;
mode |= (an_adv & GP_STATUS_LP_UP1_DATARATE_20GX4_MASK) ?
SOC_PA_SPEED_20GB : 0;
mode |= (an_adv & GP_STATUS_LP_UP1_DATARATE_16GX4_MASK) ?
SOC_PA_SPEED_16GB : 0;
mode |= (an_adv & GP_STATUS_LP_UP1_DATARATE_13GX4_MASK) ?
SOC_PA_SPEED_13GB : 0;
mode |= (an_adv & GP_STATUS_LP_UP1_DATARATE_12GX4_MASK) ?
SOC_PA_SPEED_12GB : 0;
mode |= (an_adv & GP_STATUS_LP_UP1_DATARATE_10GCX4_MASK) ?
SOC_PA_SPEED_10GB : 0;
mode |= (an_adv & GP_STATUS_LP_UP1_DATARATE_10GX4_MASK) ?
SOC_PA_SPEED_10GB : 0;
mode |= (an_adv & GP_STATUS_LP_UP1_DATARATE_2P5GX1_MASK) ?
SOC_PA_SPEED_2500MB : 0;
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"u=%d p=%d over1G an_adv=%04x\n"),
unit, port, an_adv));
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_AUTONEGLPABILr(unit, pc, &an_adv));
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"u=%d p=%d combo an_adv=%04x\n"),
unit, port, an_adv));
mode |= (an_adv & MII_ANP_C37_FD) ? SOC_PA_SPEED_1000MB : 0;
ability->speed_full_duplex = mode;
switch (an_adv & (MII_ANP_C37_PAUSE | MII_ANP_C37_ASYM_PAUSE)) {
case MII_ANP_C37_PAUSE:
ability->pause |= SOC_PA_PAUSE_TX | SOC_PA_PAUSE_RX;
break;
case MII_ANP_C37_ASYM_PAUSE:
ability->pause |= SOC_PA_PAUSE_TX;
break;
case MII_ANP_C37_PAUSE | MII_ANP_C37_ASYM_PAUSE:
ability->pause |= SOC_PA_PAUSE_RX;
break;
}
if (PHY_CLAUSE73_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(READ_HL65_AN_IEEE0BLK_AN_IEEESTATUS1r(unit, pc, &data16));
if (data16 & MII_STAT_AN_DONE) {
SOC_IF_ERROR_RETURN
(_phy_hl65_c73_adv_remote_get(unit, port, ability));
}
}
} else {
/* Simply return local abilities */
phy_hl65_ability_advert_get(unit, port, ability);
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_ability_remote_get:unit=%d p=%d pause=%08x sp=%08x\n"),
unit, port, ability->pause, ability->speed_full_duplex));
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_lb_set
* Purpose:
* Put hc/FusionCore in PHY loopback
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* enable - binary value for on/off (1/0)
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_lb_set(int unit, soc_port_t port, int enable)
{
phy_ctrl_t *pc;
uint16 serdes_id0;
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1) ||
(serdes_id0 == HL_SERDES_ID0_REVID_B0)) {
SOC_IF_ERROR_RETURN(MODIFY_HL65_DSC2BB_SM_CTRL0r(unit, pc,
enable? 0x0: DSC2BB_SM_CTRL0_TUNING_SM_EN_MASK,
DSC2BB_SM_CTRL0_TUNING_SM_EN_MASK));
}
if (PHY_HC65_FABRIC_MODE(unit, port)) {
uint16 lane_mask = 1 << pc->lane_num;
if (enable) {
/* Set global and individual loopback control */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_IEEE0BLK_MIICNTLr(unit, pc, MII_CTRL_LE,
MII_CTRL_LE));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK1_LANECTRL2r(unit, pc, lane_mask, lane_mask));
} else {
/* Clear global and individual loopback control */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_IEEE0BLK_MIICNTLr(unit, pc, 0,
MII_CTRL_LE));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK1_LANECTRL2r(unit, pc, 0, lane_mask));
}
} else if (PHY_INDEPENDENT_LANE_MODE(unit, port)) {
if (enable) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc,
MII_CTRL_LE,
MII_CTRL_AE | MII_CTRL_RAN |
MII_CTRL_LE));
if(!IS_GE_PORT(unit, port)) {
/* in case it is in dxgxs mode */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DTE_IEEE0BLK_DTE_IEEECONTROL1r(unit, pc,
MII_CTRL_LE,MII_CTRL_LE));
}
} else {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc,
0,
MII_CTRL_LE));
if(!IS_GE_PORT(unit, port)) {
/* in case it is in dxgxs mode */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DTE_IEEE0BLK_DTE_IEEECONTROL1r(unit, pc,
0,MII_CTRL_LE));
}
}
} else {
uint16 misc_ctrl;
uint16 lb_bit;
uint16 lb_mask;
if (enable) {
/* Disable TX serializer output in gloopback mode. Link partner will
* show link off
*/
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXB_ANATXACONTROL0r(unit, pc, 0x200,0x200));
} else {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXB_ANATXACONTROL0r(unit, pc, 0x000,0x200));
}
/* Configure Loopback in XAUI */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK0_MISCCONTROL1r(unit, pc, &misc_ctrl));
if (misc_ctrl & XGXSBLK0_MISCCONTROL1_PCS_DEV_EN_OVERRIDE_MASK) {
/* PCS */
lb_bit = (enable) ? IEEE0BLK_MIICNTL_GLOOPBACK_MASK : 0;
lb_mask = IEEE0BLK_MIICNTL_GLOOPBACK_MASK;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DTE_IEEE0BLK_DTE_IEEECONTROL1r(unit, pc,
lb_bit, lb_mask));
} else if (misc_ctrl & XGXSBLK0_MISCCONTROL1_PMD_DEV_EN_OVERRIDE_MASK) {
/* PMA/PMD */
lb_bit = (enable) ? 1 : 0;
lb_mask = 1;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_PMD_IEEE0BLK_PMD_IEEECONTROL1r(unit, pc,
lb_bit, lb_mask));
} else {
/* PHY XS, DTE XS */
lb_bit = (enable) ? IEEE0BLK_MIICNTL_GLOOPBACK_MASK : 0;
lb_mask = IEEE0BLK_MIICNTL_GLOOPBACK_MASK;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DTE_IEEE0BLK_DTE_IEEECONTROL1r(unit, pc,
lb_bit, lb_mask));
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc,
(enable) ? MII_CTRL_LE : 0,
MII_CTRL_LE));
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_lb_get
* Purpose:
* Get hc/FusionCore PHY loopback state
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* enable - address of location to store binary value for on/off (1/0)
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_lb_get(int unit, soc_port_t port, int *enable)
{
phy_ctrl_t *pc;
uint16 mii_ctrl;
pc = INT_PHY_SW_STATE(unit, port);
if (PHY_HC65_FABRIC_MODE(unit, port)) {
uint16 data;
uint16 lane_mask = 1 << pc->lane_num;
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL2r(unit, pc, &data));
*enable = ((data & lane_mask) == lane_mask);
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hc65_loopback_get: "
"u=%d p=%d lb=%d\n"), unit, port, *enable));
} else {
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, &mii_ctrl));
*enable = mii_ctrl & MII_CTRL_LE;
}
return SOC_E_NONE;
}
STATIC int
phy_hl65_interface_set(int unit, soc_port_t port, soc_port_if_t pif)
{
COMPILER_REFERENCE(unit);
COMPILER_REFERENCE(port);
COMPILER_REFERENCE(pif);
return SOC_E_NONE;
}
STATIC int
phy_hl65_interface_get(int unit, soc_port_t port, soc_port_if_t *pif)
{
COMPILER_REFERENCE(unit);
COMPILER_REFERENCE(port);
if (PHY_INDEPENDENT_LANE_MODE(unit, port)) {
*pif = SOC_PORT_IF_SGMII;
} else {
*pif = SOC_PORT_IF_XGMII;
}
return SOC_E_NONE;
}
STATIC int
phy_hl65_ability_local_get(int unit, soc_port_t port, soc_port_ability_t *ability)
{
phy_ctrl_t *pc;
uint16 id_rev;
if (NULL == ability) {
return SOC_E_PARAM;
}
pc = INT_PHY_SW_STATE(unit, port);
sal_memset(ability, 0, sizeof(*ability));
if (PHY_INDEPENDENT_LANE_MODE(unit, port)) {
/* dxgxs mode */
if (IS_HG_PORT(unit, port)) {
ability->speed_full_duplex = SOC_PA_SPEED_10GB |
SOC_PA_SPEED_12GB;
ability->pause = 0;
ability->interface = SOC_PA_INTF_XGMII;
ability->medium = SOC_PA_MEDIUM_FIBER;
ability->loopback = SOC_PA_LB_PHY;
ability->flags = 0;
} else {
ability->speed_full_duplex = SOC_PA_SPEED_1000MB;
if (IS_XE_PORT(unit,port)) {
ability->speed_full_duplex += SOC_PA_SPEED_10GB;
}
ability->speed_half_duplex = SOC_PA_ABILITY_NONE;
if (PHY_FIBER_MODE(unit, port)) {
ability->speed_full_duplex |= SOC_PA_SPEED_2500MB;
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit,pc,&id_rev));
if (id_rev & TEST_SERDESID0_REV_LETTER_MASK) {
ability->speed_full_duplex |= SOC_PA_SPEED_100MB;
ability->speed_half_duplex = SOC_PA_SPEED_100MB;
}
} else {
ability->speed_half_duplex = SOC_PA_SPEED_10MB |
SOC_PA_SPEED_100MB;
ability->speed_full_duplex |= SOC_PA_SPEED_10MB |
SOC_PA_SPEED_100MB;
}
ability->interface = SOC_PA_INTF_GMII | SOC_PA_INTF_SGMII;
ability->pause = SOC_PA_PAUSE | SOC_PA_PAUSE_ASYMM;
ability->medium = SOC_PA_MEDIUM_FIBER;
ability->loopback = SOC_PA_LB_PHY;
ability->flags = SOC_PA_AUTONEG;
}
} else {
if ( PHY_EXTERNAL_MODE(unit, port) ) {
ability->speed_half_duplex = SOC_PA_SPEED_100MB |
SOC_PA_SPEED_10MB;
ability->speed_full_duplex = SOC_PA_SPEED_2500MB |
SOC_PA_SPEED_1000MB |
SOC_PA_SPEED_100MB |
SOC_PA_SPEED_10MB;
} else {
ability->speed_half_duplex = SOC_PA_ABILITY_NONE;
ability->speed_full_duplex = SOC_PA_SPEED_1000MB |
SOC_PA_SPEED_2500MB;
}
switch(pc->speed_max) {
case 25000:
ability->speed_full_duplex |= SOC_PA_SPEED_25GB;
/* fall through */
case 21000:
ability->speed_full_duplex |= SOC_PA_SPEED_21GB;
/* fall through */
case 20000:
ability->speed_full_duplex |= SOC_PA_SPEED_20GB;
/* fall through */
case 16000:
ability->speed_full_duplex |= SOC_PA_SPEED_16GB;
/* fall through */
case 13000:
ability->speed_full_duplex |= SOC_PA_SPEED_13GB;
/* fall through */
case 12000:
ability->speed_full_duplex |= SOC_PA_SPEED_12GB;
/* fall through */
default:
ability->speed_full_duplex |= SOC_PA_SPEED_10GB;
}
ability->pause = SOC_PA_PAUSE | SOC_PA_PAUSE_ASYMM;
ability->interface = SOC_PA_INTF_XGMII;
ability->medium = SOC_PA_MEDIUM_FIBER;
ability->loopback = SOC_PA_LB_PHY;
ability->flags = SOC_PA_AUTONEG;
}
return (SOC_E_NONE);
}
STATIC int
_phy_hl65_control_scrambler_set(int unit, soc_port_t port, uint32 value)
{
uint16 data;
phy_ctrl_t *pc;
int rv = SOC_E_NONE;
if (SOC_IS_RELOADING(unit)) {
return SOC_E_NONE;
}
pc = INT_PHY_SW_STATE(unit, port);
if (PHY_HC65_FABRIC_MODE(unit, port)) {
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x833c, &uData);*/
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL4_MISC3r(unit, pc, &data));
if (value) {
data |= (DIGITAL4_MISC3_SCR_EN_PER_LANE_BITS <<
DIGITAL4_MISC3_SCR_EN_PER_LANE_SHIFT);
} else {
data &= ~(DIGITAL4_MISC3_SCR_EN_PER_LANE_BITS <<
DIGITAL4_MISC3_SCR_EN_PER_LANE_SHIFT);
}
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, 0x833c, uData);*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL4_MISC3r(unit, pc, data));
} else {
rv = SOC_E_UNAVAIL;
}
return rv;
}
STATIC int
_phy_hl65_control_scrambler_get(int unit, soc_port_t port, uint32 *value)
{
uint16 data;
phy_ctrl_t *pc;
int rv = SOC_E_NONE;
pc = INT_PHY_SW_STATE(unit, port);
if (PHY_HC65_FABRIC_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL4_MISC3r(unit, pc, &data));
*value = ((data & DIGITAL4_MISC3_SCR_EN_PER_LANE_MASK) == 0x100);
} else {
rv = SOC_E_UNAVAIL;
}
return rv;
}
STATIC int
_phy_hl65_control_encoding_set(int unit, soc_port_t port, uint32 value)
{
uint16 data;
phy_ctrl_t *pc;
int rv = SOC_E_NONE;
if (SOC_IS_RELOADING(unit)) {
return SOC_E_NONE;
}
pc = INT_PHY_SW_STATE(unit, port);
if (PHY_HC65_FABRIC_MODE(unit, port)) {
switch (value) {
case phyControlEncoding8b10b:
/*
* 8b10b only, disable 64/66
* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, 0x8015, &uData);
*/
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL0r(unit, pc, &data));
data &= ~(1 << (pc->lane_num + 12));
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8015, uData); */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL0r(unit, pc, data));
/*
* Force the sync character to the lower byte of the parallel
* interface
* uRegAddr = 0x80b9 + (uLaneAddr * 0x10);
* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit, pc, 0x0, 0x80b9 + (0x10 * pc->lane_num),
&data));
data = data | 0x0020;
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uRegAddr, uData); */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x80b9 + (0x10 * pc->lane_num),
data));
break;
case phyControlEncoding64b66b:
/*
* Force the sync character to the upper byte of the parallel
* interface
* uRegAddr = 0x80b9 + (uLaneAddr * 0x10);
* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit, pc, 0x0, 0x80b9 + (0x10 * pc->lane_num),
&data));
data = data & ~0x0020;
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uRegAddr, uData); */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x80b9 + (0x10 * pc->lane_num),
data));
/*
* enable 64b66b
* socd c_bm9600_mdio_hc_read(unit, uPhyAddr, 0, 0x8015, &uData);
*/
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL0r(unit, pc, &data));
data |= 1 << (pc->lane_num + 12);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8015, uData); */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL0r(unit, pc, data));
break;
default:
rv = SOC_E_UNAVAIL;
}
} else {
rv = SOC_E_UNAVAIL;
}
return rv;
}
#define PHY_HL65_LANEPRBS_LANE_SHIFT 4
STATIC int
_phy_hl65_control_prbs_polynomial_set(int unit, soc_port_t port, uint32 value)
{
uint16 data = 0;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
if (PHY_HC65_FABRIC_MODE(unit, pc->port)) {
uint32 prbs_lane_mask = 0;
prbs_lane_mask = 0x3 << (PHY_HL65_LANEPRBS_LANE_SHIFT * pc->lane_num);
data &= ~prbs_lane_mask;
data |= value << (PHY_HL65_LANEPRBS_LANE_SHIFT * pc->lane_num);
} else {
data &= ~(XGXSBLK1_LANEPRBS_PRBS_ORDER0_MASK |
XGXSBLK1_LANEPRBS_PRBS_ORDER1_MASK |
XGXSBLK1_LANEPRBS_PRBS_ORDER2_MASK |
XGXSBLK1_LANEPRBS_PRBS_ORDER3_MASK);
data |= ((value << XGXSBLK1_LANEPRBS_PRBS_ORDER0_SHIFT) |
(value << XGXSBLK1_LANEPRBS_PRBS_ORDER1_SHIFT) |
(value << XGXSBLK1_LANEPRBS_PRBS_ORDER2_SHIFT) |
(value << XGXSBLK1_LANEPRBS_PRBS_ORDER3_SHIFT));
}
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANEPRBSr(unit, pc, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_polynomial_get(int unit, soc_port_t port, uint32 *value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);;
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8019, &uData);*/
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
if (PHY_HC65_FABRIC_MODE(unit, pc->port)) {
/* Extract prbs polynomial setting from register */
*value = ((data >> (XGXSBLK1_LANEPRBS_PRBS_ORDER1_SHIFT * pc->lane_num)) &
XGXSBLK1_LANEPRBS_PRBS_ORDER0_MASK);
} else {
*value = ((data & 0x0003) | ((data >> 4) & 0x0003) |
((data >> 8) & 0x0003) | ((data >> 12) & 0x0003));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_tx_invert_data_set(int unit, soc_port_t port, uint32 value)
{
uint16 data = 0;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
if (PHY_HC65_FABRIC_MODE(unit, pc->port)) {
uint32 lane_mask = 0;
lane_mask = 0x4 << (PHY_HL65_LANEPRBS_LANE_SHIFT * pc->lane_num);
data &= ~lane_mask;
data |= value << (PHY_HL65_LANEPRBS_LANE_SHIFT * pc->lane_num);
} else {
data &= ~(XGXSBLK1_LANEPRBS_PRBS_INV0_MASK |
XGXSBLK1_LANEPRBS_PRBS_INV1_MASK |
XGXSBLK1_LANEPRBS_PRBS_INV2_MASK |
XGXSBLK1_LANEPRBS_PRBS_INV3_MASK);
value &= (1 << XGXSBLK1_LANEPRBS_PRBS_INV0_BITS) - 1;
data |= ((value << XGXSBLK1_LANEPRBS_PRBS_INV0_SHIFT) |
(value << XGXSBLK1_LANEPRBS_PRBS_INV1_SHIFT) |
(value << XGXSBLK1_LANEPRBS_PRBS_INV2_SHIFT) |
(value << XGXSBLK1_LANEPRBS_PRBS_INV3_SHIFT));
}
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANEPRBSr(unit, pc, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_tx_invert_data_get(int unit, soc_port_t port, uint32 *value)
{
uint16 data;
uint16 inv_shifter = 0;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8019, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
inv_shifter = (XGXSBLK1_LANEPRBS_PRBS_ORDER1_SHIFT * pc->lane_num) +
XGXSBLK1_LANEPRBS_PRBS_INV0_SHIFT;
data &= (1 << inv_shifter);
*value = (data) ? 1 : 0;
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_fabric_prbs_tx_enable_set(int unit, soc_port_t port,
uint32 value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
uint32 lane_mask = 1 << (PHY_HL65_LANEPRBS_LANE_SHIFT * pc->lane_num);
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8019, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
if (value) {
data |= lane_mask << XGXSBLK1_LANEPRBS_PRBS_EN0_SHIFT;
} else {
data &= ~(lane_mask << XGXSBLK1_LANEPRBS_PRBS_EN0_SHIFT);
}
/* write back updated configuration */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8019, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANEPRBSr(unit, pc, data));
SOC_IF_ERROR_RETURN(
phy_hl65_lb_set(unit, port, (value & 0x8000) ? 1 : 0));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_xgxs_prbs_tx_enable_set(int unit, soc_port_t port,
uint32 value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
uint16 pll_mode;
if (value) {
/* Assume that the core has already been forced to the desired speed */
/* Get the current PLL operating mode */
SOC_IF_ERROR_RETURN(READ_HL65_TXPLL_ANAPLLSTATUSr(unit, pc, &data));
pll_mode = data & TXPLL_ANAPLLSTATUS_PLL_MODE_AFE_MASK;
/* Change to independent lane mode */
SOC_IF_ERROR_RETURN(READ_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, &data));
data &= ~(XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK |
XGXSBLK0_XGXSCONTROL_MODE_10G_MASK);
data |= ((XGXSBLK0_XGXSCONTROL_MODE_10G_Indlanes <<
XGXSBLK0_XGXSCONTROL_MODE_10G_SHIFT) |
XGXSBLK0_XGXSCONTROL_MDIO_CONT_EN_MASK);
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, data));
/* Set appropriate data width mode */
if (data & XGXSBLK0_XGXSCONTROL_TXCKO_DIV_MASK) {
/* Half rate mode */
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK1_LANECTRL1r(unit, pc,
0x5555));
} else {
/* Full rate mode */
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK1_LANECTRL1r(unit, pc,
0xffff));
}
/* Force the VCO based on the previously read mode */
SOC_IF_ERROR_RETURN(READ_HL65_DIGITAL_MISC1r(unit, pc, &data));
data &= ~(DIGITAL_MISC1_FORCE_PLL_MODE_AFE_MASK |
DIGITAL_MISC1_FORCE_LN_MODE_MASK |
DIGITAL_MISC1_FORCE_SPEED_MASK);
data |= (DIGITAL_MISC1_FORCE_PLL_MODE_AFE_SEL_MASK |
(pll_mode << DIGITAL_MISC1_FORCE_PLL_MODE_AFE_SHIFT) |
DIGITAL_MISC1_FORCE_LN_MODE_MASK);
SOC_IF_ERROR_RETURN(WRITE_HL65_DIGITAL_MISC1r(unit, pc, data));
/* Disable CL36 PCS */
SOC_IF_ERROR_RETURN(READ_HL65_XGXSBLK1_LANECTRL0r(unit, pc, &data));
data &= ~(XGXSBLK1_LANECTRL0_CL36_PCS_EN_RX_MASK |
XGXSBLK1_LANECTRL0_CL36_PCS_EN_TX_MASK);
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK1_LANECTRL0r(unit, pc, data));
/* Disable comma detect, error detect */
SOC_IF_ERROR_RETURN(READ_HL65_XGXSBLK1_LANECTRL2r(unit, pc, &data));
data &= ~(XGXSBLK1_LANECTRL2_CDET_EN1G_MASK |
XGXSBLK1_LANECTRL2_EDEN1G_MASK);
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK1_LANECTRL2r(unit, pc, data));
/* Set loopback (if requested) */
if (value & 0x8000) {
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK1_LANECTRL2r(unit, pc,
XGXSBLK1_LANECTRL2_GLOOP1G_MASK));
}
/* Enable PRBS transmit function */
SOC_IF_ERROR_RETURN(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
data |= (XGXSBLK1_LANEPRBS_PRBS_EN0_MASK |
XGXSBLK1_LANEPRBS_PRBS_EN1_MASK |
XGXSBLK1_LANEPRBS_PRBS_EN2_MASK |
XGXSBLK1_LANEPRBS_PRBS_EN3_MASK);
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK1_LANEPRBSr(unit, pc, data));
/* Set receiver status to PRBS */
SOC_IF_ERROR_RETURN(READ_HL65_RXB_ANARXCONTROLr(unit, pc, &data));
data &= ~RXB_ANARXCONTROL_STATUS_SEL_MASK;
data |= 0x7; /* PRBS status */
SOC_IF_ERROR_RETURN(WRITE_HL65_RXB_ANARXCONTROLr(unit, pc, data));
/* Start the PLL sequencer */
SOC_IF_ERROR_RETURN(READ_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, &data));
data |= XGXSBLK0_XGXSCONTROL_START_SEQUENCER_MASK;
SOC_IF_ERROR_RETURN(WRITE_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc, data));
/* Delay a while */
sal_usleep(250000);
} else {
/* Restore port */
return phy_hl65_init(unit, port);
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_tx_enable_set(int unit, soc_port_t port, uint32 value)
{
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
if (PHY_HC65_FABRIC_MODE(unit, pc->port)) {
SOC_IF_ERROR_RETURN(
_phy_hl65_control_fabric_prbs_tx_enable_set(unit, port, value));
} else {
SOC_IF_ERROR_RETURN(
_phy_hl65_control_xgxs_prbs_tx_enable_set(unit, port, value));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_tx_rx_enable_get(int unit, soc_port_t port,
uint32 *value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);;
/*
* Hypercore PRBS - note that in the Hypercore there is only 1 enable
* for both TX/RX
*/
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8019, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
data = data & ((1 << (XGXSBLK1_LANEPRBS_PRBS_ORDER1_SHIFT * pc->lane_num))
<< XGXSBLK1_LANEPRBS_PRBS_EN0_SHIFT);
*value = (data) ? 1 : 0;
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_tx_enable_get(int unit, soc_port_t port, uint32 *value)
{
return _phy_hl65_control_prbs_tx_rx_enable_get(unit, port, value);
}
STATIC int
_phy_hl65_control_prbs_rx_enable_set(int unit, soc_port_t port, uint32 value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
uint32 lane_mask = 1 << (PHY_HL65_LANEPRBS_LANE_SHIFT * pc->lane_num);
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, 0x8019, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANEPRBSr(unit, pc, &data));
/* if (value) {
* uData |= uLaneMask << BM9600_HYPERCORE_8019_PRBS_ENABLE_SHIFT;
* } else {
* uData &= ~(uLaneMask << BM9600_HYPERCORE_8019_PRBS_ENABLE_SHIFT);
* }
*/
if (value) {
data |= lane_mask << XGXSBLK1_LANEPRBS_PRBS_EN0_SHIFT;
} else {
data &= ~(lane_mask << XGXSBLK1_LANEPRBS_PRBS_EN0_SHIFT);
}
/* write back updated configuration */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8019, uData) */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANEPRBSr(unit, pc, data));
/* Set up status collection */
/* uPrbsRxControlReg = 0x80b1;
* uPrbsRxControlReg += uLaneAddr * 0x10;
* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uPrbsRxControlReg, &uData)
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x80B1 + (0x10 * pc->lane_num), &data));
/* if (value) {
* uData &= ~BM9600_HYPERCORE_80B1_STATUS_MASK;
* uData |= BM9600_HYPERCORE_80B1_PRBS_STATUS_VALUE;
* } else {
* uData &= ~BM9600_HYPERCORE_80B1_STATUS_MASK;
* uData &= ~BM9600_HYPERCORE_80B1_PRBS_STATUS_VALUE;
* }
*/
data &= ~RX0_ANARXCONTROL_STATUS_SEL_MASK;
if (value) {
data |= RX0_ANARXCONTROL_STATUS_SEL_prbsStatus;
} else {
data &= ~RX0_ANARXCONTROL_STATUS_SEL_prbsStatus;
}
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uPrbsRxControlReg, uData) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,0x80B1 + (0x10 * pc->lane_num), data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_rx_enable_get(int unit, soc_port_t port, uint32 *value)
{
return _phy_hl65_control_prbs_tx_rx_enable_get(unit, port, value);
}
/*
* Returns value
* == 0: PRBS receive is in sync
* == -1: PRBS receive never got into sync
* == n: number of errors
*/
STATIC int
_phy_hl65_control_fabric_prbs_rx_status_get(int unit, soc_port_t port,
uint32 *value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);;
/* Get status */
/* uPrbsRxControlReg = 0x80b0;
* uPrbsRxControlReg += uLaneAddr * 0x10;
* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uPrbsRxControlReg, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit, pc, 0x0, 0x80b0 + (0x10 * pc->lane_num), &data));
if (data == (RX0_ANARXSTATUS_PRBS_STATUS_PRBS_LOCK_BITS <<
RX0_ANARXSTATUS_PRBS_STATUS_PRBS_LOCK_SHIFT)) {
/* PRBS is in sync */
*value = 0;
} else if (data == 0) {
/* PRBS not in sync */
*value = -1;
} else {
/* Get errors */
*value = data & RX0_ANARXSTATUS_PRBS_STATUS_PTBS_ERRORS_MASK;
}
return SOC_E_NONE;
}
/*
* Returns value
* == 0: PRBS receive is in sync
* == -1: PRBS receive never got into sync
* == n: number of errors
*/
STATIC int
_phy_hl65_control_xgxs_prbs_rx_status_get(int unit, soc_port_t port,
uint32 *value)
{
int lane;
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);;
/* JOE */
/* Get status for all 4 lanes and check for sync
* 0x80b0, 0x80c0, 0x80d0, 0x80e0
*/
*value = 0;
for (lane = 0; lane < 4; lane++) {
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit, pc, 0x0, 0x80b0 + (0x10 * lane), &data));
if (data == (RX0_ANARXSTATUS_PRBS_STATUS_PRBS_LOCK_BITS <<
RX0_ANARXSTATUS_PRBS_STATUS_PRBS_LOCK_SHIFT)) {
/* PRBS is in sync */
continue;
} else if (data == 0) {
/* PRBS not in sync */
*value = -1;
break;
} else {
/* Get errors */
*value += data & RX0_ANARXSTATUS_PRBS_STATUS_PTBS_ERRORS_MASK;
}
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_prbs_rx_status_get(int unit, soc_port_t port, uint32 *value)
{
int rv;
uint16 rx_sts, saved_rx_sts;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/* Set up prbs rx status collection */
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x80B1 + (0x10 * pc->lane_num), &rx_sts));
saved_rx_sts = rx_sts;
rx_sts = (rx_sts & ~RX0_ANARXCONTROL_STATUS_SEL_MASK) |
RX0_ANARXCONTROL_STATUS_SEL_prbsStatus;
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,0x80B1 + (0x10 * pc->lane_num), rx_sts));
if (PHY_HC65_FABRIC_MODE(unit, pc->port)) {
rv = _phy_hl65_control_fabric_prbs_rx_status_get(unit, port, value);
} else {
rv = _phy_hl65_control_xgxs_prbs_rx_status_get(unit, port, value);
}
/* Restore rx status */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,0x80B1 + (0x10 * pc->lane_num), saved_rx_sts));
return rv;
}
STATIC int
_phy_hl65_control_serdes_driver_tune_set(int unit, soc_port_t port,
int lane_num,
uint32 value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
if (SOC_IS_RELOADING(unit)) {
return SOC_E_NONE;
}
/* Start receive tuning via rxSeqStart */
/* uRegAddr = 0x826e + (uLaneAddr*0x10);
* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr , &uData)
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit, pc, 0x0, 0x826E + (0x10 * lane_num), &data));
/* tune by toggling rxSeqStart */
/* uData |= 0x8000; */
data |= (DSC2B0_DSC_MISC_CTRL0_RXSEQSTART_BITS <<
DSC2B0_DSC_MISC_CTRL0_RXSEQSTART_SHIFT);
/* write back updated configuration */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826E + (0x10 * lane_num), data));
/* tune by toggling rxSeqStart */
data &= ~ (DSC2B0_DSC_MISC_CTRL0_RXSEQSTART_BITS <<
DSC2B0_DSC_MISC_CTRL0_RXSEQSTART_SHIFT);
/* write back updated configuration */
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData) */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x826E + (0x10 * lane_num), data));
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"hl_65: Equalization tune start\n")));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_64b66b_set(int unit, soc_port_t port, uint32 value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
uint32 lane_mask = 1 << pc->lane_num;
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, 0x8015, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL0r(unit, pc, &data));
if (value) {
data |= lane_mask << XGXSBLK1_LANECTRL0_ED66EN_SHIFT;
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8015, uData);*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL0r(unit, pc, data));
} else {
data &= ~(lane_mask << XGXSBLK1_LANECTRL0_ED66EN_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8015, uData);*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL0r(unit, pc, data));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_8b10b_set(int unit, soc_port_t port, uint32 value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
uint32 lane_mask = 1 << pc->lane_num;
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, 0x8017, &uData) */
SOC_IF_ERROR_RETURN
(READ_HL65_XGXSBLK1_LANECTRL2r(unit, pc, &data));
if (value) {
/* uData |= uLaneMask << BM9600_HYPERCORE_8017_8B10B_SHIFT;
* uData |= uLaneMask << BM9600_HYPERCORE_8017_KCHAR_SHIFT;
*/
data |= lane_mask << XGXSBLK1_LANECTRL2_CDET_EN1G_SHIFT;
data |= lane_mask << XGXSBLK1_LANECTRL2_EDEN1G_SHIFT;
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8017, uData);*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL2r(unit, pc, data));
} else {
/* uData &= ~(uLaneMask << BM9600_HYPERCORE_8017_8B10B_SHIFT);
* uData &= ~(uLaneMask << BM9600_HYPERCORE_8017_KCHAR_SHIFT);
*/
data &= ~(lane_mask << XGXSBLK1_LANECTRL2_CDET_EN1G_SHIFT);
data &= ~(lane_mask << XGXSBLK1_LANECTRL2_EDEN1G_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, 0x8017, uData);*/
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK1_LANECTRL2r(unit, pc, data));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_tx_driver_field_get(soc_phy_control_t type,int *ln_ctrl,uint16 *mask,int *shfter)
{
int lane_ctrl;
lane_ctrl = TX_DRIVER_DFT_LN_CTRL;
*mask = 0;
*shfter = 0;
/* _LANEn(n=0-3) control type only applies to combo mode or dxgxs in
* independent channel mode
*/
switch(type) {
case SOC_PHY_CONTROL_PREEMPHASIS_LANE0:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE1:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE2:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE3:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS:
*shfter = TXB_TX_OS_DRIVER_PREEMPHASIS_POST_SHIFT;
*mask = TXB_TX_OS_DRIVER_PREEMPHASIS_POST_MASK;
if (type == SOC_PHY_CONTROL_PREEMPHASIS_LANE0) {
lane_ctrl = 0;
} else if (type == SOC_PHY_CONTROL_PREEMPHASIS_LANE1) {
lane_ctrl = 1;
} else if (type == SOC_PHY_CONTROL_PREEMPHASIS_LANE2) {
lane_ctrl = 2;
} else if (type == SOC_PHY_CONTROL_PREEMPHASIS_LANE3) {
lane_ctrl = 3;
}
break;
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE0:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE1:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE2:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE3:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT:
*shfter = TXB_TX_OS_DRIVER_IDRIVER_SHIFT;
*mask = TXB_TX_OS_DRIVER_IDRIVER_MASK;
if (type == SOC_PHY_CONTROL_DRIVER_CURRENT_LANE0) {
lane_ctrl = 0;
} else if (type == SOC_PHY_CONTROL_DRIVER_CURRENT_LANE1) {
lane_ctrl = 1;
} else if (type == SOC_PHY_CONTROL_DRIVER_CURRENT_LANE2) {
lane_ctrl = 2;
} else if (type == SOC_PHY_CONTROL_DRIVER_CURRENT_LANE3) {
lane_ctrl = 3;
}
break;
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE0:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE1:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE2:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE3:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT:
*shfter = TXB_TX_OS_DRIVER_IPREDRIVER_SHIFT;
*mask = TXB_TX_OS_DRIVER_IPREDRIVER_MASK;
if (type == SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE0) {
lane_ctrl = 0;
} else if (type == SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE1) {
lane_ctrl = 1;
} else if (type == SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE2) {
lane_ctrl = 2;
/* coverity[mixed_enums:FALSE] */
} else if (type == SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE3) {
lane_ctrl = 3;
}
break;
case SOC_PHY_CONTROL_PRE_PREEMPHASIS:
*shfter = TXB_TX_OS_DRIVER_PREEMPHASIS_PRE_SHIFT;
*mask = TXB_TX_OS_DRIVER_PREEMPHASIS_PRE_MASK;
break;
default:
/* should never get here */
return SOC_E_PARAM;
}
*ln_ctrl = lane_ctrl;
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_tx_driver_set(int unit, phy_ctrl_t *pc,
soc_phy_control_t type, uint32 value)
{
uint16 data; /* Temporary holder of reg value to be written */
uint16 mask; /* Bit mask of reg value to be updated */
uint16 ivalue;
int lane_ctrl;
int lane_num;
int shifter;
/* Both cases 6.5G/3.125G handled the same, ignore MSB though it may be passed in*/
ivalue = value & 0x7fff;
if (ivalue > 15) {
return SOC_E_PARAM;
}
SOC_IF_ERROR_RETURN
(_phy_hl65_tx_driver_field_get(type,&lane_ctrl,&mask,&shifter));
data = ivalue << shifter;
if ((lane_ctrl != TX_DRIVER_DFT_LN_CTRL) ||
PHY_INDEPENDENT_LANE_MODE(unit, pc->port) ||
PHY_HC65_FABRIC_MODE(unit, pc->port)) {
if (lane_ctrl != TX_DRIVER_DFT_LN_CTRL) {
lane_num = lane_ctrl;
} else {
lane_num = pc->lane_num;
}
if (lane_num == 0) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX0_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX0_TX_OS_DRIVERr(unit, pc, data, mask));
} else if (lane_num == 1) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_TX_OS_DRIVERr(unit, pc, data, mask));
} else if (lane_num == 2) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX2_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX2_TX_OS_DRIVERr(unit, pc, data, mask));
} else if (lane_num == 3) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_TX_OS_DRIVERr(unit, pc, data, mask));
}
} else { /* default control in combo mode: bcst to all lanes */
/* set for both BR mode and OS mode */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX0_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX0_TX_OS_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX1_TX_OS_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX2_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX2_TX_OS_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_TX_BR_DRIVERr(unit, pc, data, mask));
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TX3_TX_OS_DRIVERr(unit, pc, data, mask));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_tx_driver_get(int unit, phy_ctrl_t *pc,
soc_phy_control_t type, uint32 *value)
{
uint16 data16; /* Temporary holder of 16 bit reg value */
uint16 mask;
int shifter;
int lane_ctrl;
int lane_num;
SOC_IF_ERROR_RETURN
(_phy_hl65_tx_driver_field_get(type,&lane_ctrl,&mask,&shifter));
/* Read preemphasis/driver/pre-driver current */
if ((lane_ctrl != TX_DRIVER_DFT_LN_CTRL) ||
PHY_INDEPENDENT_LANE_MODE(unit, pc->port) ||
PHY_HC65_FABRIC_MODE(unit, pc->port)) {
if (lane_ctrl != TX_DRIVER_DFT_LN_CTRL) {
lane_num = lane_ctrl;
} else {
lane_num = pc->lane_num;
}
if (lane_num == 0) {
SOC_IF_ERROR_RETURN
(READ_HL65_TX0_TX_OS_DRIVERr(unit, pc, &data16));
} else if (lane_num == 1) {
SOC_IF_ERROR_RETURN
(READ_HL65_TX1_TX_OS_DRIVERr(unit, pc, &data16));
} else if (lane_num == 2) {
SOC_IF_ERROR_RETURN
(READ_HL65_TX2_TX_OS_DRIVERr(unit, pc, &data16));
} else if (lane_num == 3) {
SOC_IF_ERROR_RETURN
(READ_HL65_TX3_TX_OS_DRIVERr(unit, pc, &data16));
} else {
return (SOC_E_PARAM);
}
} else {
SOC_IF_ERROR_RETURN
(READ_HL65_TX0_TX_OS_DRIVERr(unit, pc, &data16));
}
*value = (data16 & mask) >> shifter;
return SOC_E_NONE;
}
STATIC int
_phy_hl65_tuning_done_get(int unit, soc_port_t port,int lane_num, uint16 *done)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/* *bTuningDone = FALSE;*/
*done = 0;
/* Read tuning status */
/* uRegAddr = 0x82b7 + (uLaneAddr*0x10);
* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x82B7 + (0x10 * lane_num), &data));
#if 0
/* If tuning is done */
if (uData & 0x2000) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"hc(%02d:%02d) Tuning Done indication received\n"),
uPhyAddr, uLaneAddr));
*bTuningDone = TRUE;
}
#endif
*done = (data &
(DSC3B0_SM_STATUS0_TUNING_DONE_BITS <<
DSC3B0_SM_STATUS0_TUNING_DONE_SHIFT)) ? 1 : 0;
return SOC_E_NONE;
}
/* #define BCM_BM9600_HYPERCORE_PORT_TUNING_AVG 40 */
#define PHY_HL65_PORT_TUNING_AVG 40
STATIC int
_phy_hl65_tuning_status_get(int unit, soc_port_t port,
int lane_num,
uint16 *vga_sum_avg,
uint16 *dfe_tap_bin_avg)
{
uint16 data, cnt;
uint16 cur_vga, avg_vga, cur_dfe, avg_dfe;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
avg_vga = 0;
avg_dfe = 0;
for (cnt=0; cnt < PHY_HL65_PORT_TUNING_AVG; cnt++) {
/* uRegAddr = 0x82b5 + (uLaneAddr*0x10);
* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x82b5 + (0x10 * lane_num), &data));
/* uCurrentVga = (uData & 0x07c0)>>6;
* uCurrentDfe = (uData & 0x003f);
*/
cur_vga = (data & DSC3B0_DFE_VGA_STATUS0_VGA_SUM_MASK) >>
DSC3B0_DFE_VGA_STATUS0_VGA_SUM_SHIFT;
cur_dfe = (data & DSC3B0_DFE_VGA_STATUS0_DFE_TAP_BIN_MASK);
/*uAvgVga += uCurrentVga;
*uAvgDfe += uCurrentDfe;
*/
avg_vga += cur_vga;
avg_dfe += cur_dfe;
}
/* Divide to get the average value */
/* uAvgVga = uAvgVga/BCM_BM9600_HYPERCORE_PORT_TUNING_AVG;
* uAvgDfe = uAvgDfe/BCM_BM9600_HYPERCORE_PORT_TUNING_AVG;
*/
avg_vga = avg_vga / PHY_HL65_PORT_TUNING_AVG;
avg_dfe = avg_dfe / PHY_HL65_PORT_TUNING_AVG;
/* *pVgaSumAvg = uAvgVga;
* *pDfeTapBinAvg = uAvgDfe;
*/
*vga_sum_avg = avg_vga;
*dfe_tap_bin_avg = avg_dfe;
#if 0
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"hc(%02d:%02d) VGA avg(%d)\n"),
uPhyAddr, uLaneAddr, uAvgVga));
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"hc(%02d:%02d) DFE avg(%d)\n"),
uPhyAddr, uLaneAddr, uAvgDfe));
#endif
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"hc(%02d) VGA avg(%d)\n"), port, avg_vga));
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"hc(%02d) DFE avg(%d)\n"), port, avg_dfe));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_fine_tune(int unit, soc_port_t port, int lane_num)
{
uint16 data, cnt;
uint16 tuning_done;
uint32 reg_addr;
int avg_vga_sum;
int rv = SOC_E_NONE;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
uint16 serdes_id0;
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1) ||
(serdes_id0 == HL_SERDES_ID0_REVID_B0)) {
/* Disable DSC tuning state machine */
/* uRegAddr = 0x8260 + (uLaneAddr*0x10);
* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);
*/
reg_addr = 0x8260 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/* tuning_sm_en: bit 0 */
/* uData &= ~0x1; */
data &= ~DSC2B0_SM_CTRL0_TUNING_SM_EN_BITS;
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Enable training mode in state machine */
/* uRegAddr = 0x8262 + (uLaneAddr*0x10);
* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);
*/
reg_addr = 0x8262 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/* uData |= 1; */ /* train_mode_en */
data |= DSC2B0_SM_CTRL2_TRAIN_MODE_EN_BITS;
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
}
/* Bypass BR peaking filter calibration */
/* uRegAddr = 0x8260 + (uLaneAddr*0x10);
* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);
*/
reg_addr = 0x8260 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/* bypass_br_pf_cal */
/* uData |= 0x200; */
data |= (DSC2B0_SM_CTRL0_BYPASS_BR_PF_CAL_BITS <<
DSC2B0_SM_CTRL0_BYPASS_BR_PF_CAL_SHIFT);
if (serdes_id0 == HL_SERDES_ID0_REVID_C0) {
/* bypass _tx_postc_calibration */
data |= (DSC2B0_SM_CTRL0_BYPASS_TX_POSTC_CAL_BITS <<
DSC2B0_SM_CTRL0_BYPASS_TX_POSTC_CAL_SHIFT);
}
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1) ||
(serdes_id0 == HL_SERDES_ID0_REVID_B0)) {
/* DSC Analog control 0 odd ctrl register setup */
/* uRegAddr = 0x821a + (uLaneAddr*0x10);
* uData = 0x8000;
*/
/* Write 0 to p1_odd_ctrl, d_odd_ctrl and m1_odd_ctrl and set force_odd_ctrl to 1 */
reg_addr = 0x821a + (lane_num * 0x10);
data = (DSC1B0_DSC_ANA_CTRL0_FORCE_ODD_CTRL_BITS <<
DSC1B0_DSC_ANA_CTRL0_FORCE_ODD_CTRL_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* DSC Analog control 0 even ctrl register setup */
/* uRegAddr = 0x821b + (uLaneAddr*0x10);
* uData = 0x8000;
*/
reg_addr = 0x821b + (lane_num * 0x10);
/* Write 0 to p1_evn_ctrl, d_evn_ctrl and m1_evn_ctrl and set force_evn_ctrl to 1 */
data = (DSC1B0_DSC_ANA_CTRL1_FORCE_EVN_CTRL_BITS <<
DSC1B0_DSC_ANA_CTRL1_FORCE_EVN_CTRL_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* read vga_sum 10 times and average */
/* uRegAddr = 0x82b5 + (uLaneAddr*0x10);
* uAvgVgaSum = 0;
*/
reg_addr = 0x82b5 + (lane_num * 0x10);
avg_vga_sum = 0;
for (cnt=0; cnt < 10; cnt++) {
/* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uRegAddr, &uData); */
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/*uAvgVgaSum += (uData & 0x07c0) >> 6;*/
avg_vga_sum += ((data & DSC3B0_DFE_VGA_STATUS0_VGA_SUM_MASK) >>
DSC3B0_DFE_VGA_STATUS0_VGA_SUM_SHIFT);
}
/* uAvgVgaSum = uAvgVgaSum/10; */
avg_vga_sum = avg_vga_sum / 10;
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"hc(%02d) VGA avg sum(%d)\n"),
port, avg_vga_sum));
if (avg_vga_sum > 31) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) VGA avg sum out of range(%d) maximum allowed 31\n"),
port, avg_vga_sum));
return SOC_E_FAIL;
}
/* write vga average into vga_write_val */
/* uRegAddr = 0x8215 + (uLaneAddr*0x10);
* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);
*/
reg_addr = 0x8215 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/*uData = uData & ~0x03e;
* uData |= uAvgVgaSum << 1;
*/
data = data & (~DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_VAL_MASK);
data |= (avg_vga_sum << DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_VAL_SHIFT);
/* rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Toggle vga_write_en to complete the VGA write */
/* uData |= 1;*/
data |= DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_BITS;
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* uData &=~1; */
data &= ~DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_BITS;
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* DSC Analog control 0 odd ctrl register setup */
/* uRegAddr = 0x821a + (uLaneAddr*0x10);
* uData = 0x0000;
*/
/* Write 0 to p1_odd_ctrl, d_odd_ctrl and m1_odd_ctrl and set force_odd_ctrl to 0 */
reg_addr = 0x821a + (lane_num * 0x10);
data = 0;
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* DSC Analog control 0 even ctrl register setup */
/* uRegAddr = 0x821b + (uLaneAddr*0x10);
* uData = 0x0000;
*/
reg_addr = 0x821b + (lane_num * 0x10);
/* Write 0 to p1_evn_ctrl, d_evn_ctrl and m1_evn_ctrl and set force_evn_ctrl to 0 */
data = 0;
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
}
/* Enable DSC tuning state machine */
/* uRegAddr = 0x8260 + (uLaneAddr*0x10);*/
reg_addr = 0x8260 + (lane_num * 0x10 );
/*rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/* uData |= 0x1; */
/* tuning_sm_en: bit 0 */
data |= DSC2B0_SM_CTRL0_TUNING_SM_EN_BITS;
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Restart tuning */
/* uData |= 2;*/
data |= (DSC2B0_SM_CTRL0_RESTART_TUNING_BITS <<
DSC2B0_SM_CTRL0_RESTART_TUNING_SHIFT);
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Wait for tuning done signal (timeout) */
for (cnt = 0; cnt < 50; cnt++) {
/* _bcm_bm9600_hypercore_tuning_done_get(unit, uPhyAddr, uLaneAddr, &bTuningDone);*/
SOC_IF_ERROR_RETURN
(_phy_hl65_tuning_done_get(unit, port, lane_num,&tuning_done));
if (tuning_done) {
break;
}
/*thin_delay(10000000);*/
/* 10 milliseconds */
sal_usleep(10000);
}
if (!tuning_done) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) tuning done timed out during BR fine tuning\n"),
port));
rv = SOC_E_TIMEOUT;
}
/* restore br_pf_calibration and disable training mode */
/* uRegAddr = 0x8260 + (uLaneAddr*0x10);*/
reg_addr = 0x8260 + (lane_num * 0x10);
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/*uData &= ~0x200; */
/* bypass_br_pf_cal */
data &= ~(DSC2B0_SM_CTRL0_BYPASS_BR_PF_CAL_BITS <<
DSC2B0_SM_CTRL0_BYPASS_BR_PF_CAL_SHIFT);
if (serdes_id0 == HL_SERDES_ID0_REVID_C0) {
/* bypass _tx_postc_calibration */
data &= ~(DSC2B0_SM_CTRL0_BYPASS_TX_POSTC_CAL_BITS <<
DSC2B0_SM_CTRL0_BYPASS_TX_POSTC_CAL_SHIFT);
}
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* disable training mode */
/* uRegAddr = 0x8262 + (uLaneAddr*0x10); */
reg_addr = 0x8262 + (lane_num * 0x10);
/* soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/* uData &= ~1; */
/* train_mode_en */
data &= ~DSC2B0_SM_CTRL2_TRAIN_MODE_EN_BITS;
/* soc_bm9600_mdio_hc_write(unit, uPhyAddr, uLaneAddr, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
return rv;
}
STATIC int
_phy_hl65_control_eq_tune_status_get(int unit,
soc_port_t port,
int lane_num,
uint32 *value)
{
uint16 data;
uint16 sig_detected;
uint16 saved_status_select;
uint16 tuning_done;
uint16 avg_vga, avg_dfe;
uint16 postc_metric, negative;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
int cnt;
uint16 serdes_id0;
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
*value = FALSE;
/* Make sure we have signal detect */
/* status = _bcm_bm9600_hypercore_sigdet_status_get(unit, uPhyAddr, uLaneAddr, &bSigDetected)
* ---> code for this function brought here---
* uRegAddr = 0x80b1;
* uRegAddr += uLaneAddr * 0x10;
*
* Save off current value of 0x80b1 status_sel
*
* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x80B1 + (0x10 * lane_num), &data));
/* uSavedStatusSelect = uData; */
saved_status_select = data;
/* Set register 0x80b1 status_sel to get sigDetStatus=0 */
/* uData &= ~BM9600_HYPERCORE_80B1_STATUS_MASK;
* uData |= BM9600_HYPERCORE_80B1_SIGDET_STATUS_VALUE;
*/
data &= ~RX0_ANARXCONTROL_STATUS_SEL_MASK;
data |= RX0_ANARXCONTROL_STATUS_SEL_sigdetStatus;
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uRegAddr, uData);*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,0x80B1 + (0x10 * lane_num), data));
/* read to clear latched status */
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x80B0 + (0x10 * lane_num), &data));
/* read register 0x80b0 to get status and fill in bSigDetected */
/* uRegAddr = 0x80b0;
* uRegAddr += uLaneAddr * 0x10;
* rv = soc_bm9600_mdio_hc_read(unit, uPhyAddr, 0, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x80B0 + (0x10 * lane_num), &data));
/* if (uData & 0x8000) {
* *bSigDetected = TRUE;
* }else {
* *bSigDetected = FALSE;
* }
*/
sig_detected = (data &
(RX0_ANARXSTATUS_SIGDET_STATUS_CX4_SIGDET_BITS <<
RX0_ANARXSTATUS_SIGDET_STATUS_CX4_SIGDET_SHIFT)) ? 1 : 0;
/* write back old value of 0x80b1 status_sel */
/*rv = soc_bm9600_mdio_hc_write(unit, uPhyAddr, 0, uRegAddr, uSavedStatusSelect); */
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,0x80B1 + (0x10 * lane_num), saved_status_select));
#if 0
if (!bSigDetected) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: Receiver indicates that no signal detected, check far end enable.\n")));
}
#endif
if (!sig_detected) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Receiver indicates that no signal detected. "
"Checking far end enable.\n")));
}
/* Wait for tuning done signal (timeout) */
for (cnt = 0; cnt < 50; cnt++) {
/* _bcm_bm9600_hypercore_tuning_done_get(unit, uPhyAddr, uLaneAddr, &bTuningDone);*/
SOC_IF_ERROR_RETURN
(_phy_hl65_tuning_done_get(unit, port, lane_num,&tuning_done));
if (tuning_done) {
break;
}
/*thin_delay(10000000);*/ /* 10 milliseconds */
sal_usleep(10000);
}
#if 0
if (!bTuningDone) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: Tuning error port(%d), no tuning done indication from hardware\n"),
port));
}
#endif
if (!tuning_done) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"No tune done indication received on port %d\n"),
port));
} else {
/* _bcm_bm9600_hypercore_tuning_status_get(unit, uPhyAddr, uLaneAddr, &uAvgVga, &uAvgDfe);*/
SOC_IF_ERROR_RETURN
(_phy_hl65_tuning_status_get(unit, port, lane_num,
&avg_vga, &avg_dfe));
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1) ||
(serdes_id0 == HL_SERDES_ID0_REVID_B0)) {
/* If (uAvgDfe < 8) {
* postc_metric = 0x400; -1023 11 bit 2s complement number
* } else if (uAvgDfe > 56) {
* postc_metric = 0x3ff; 1023 11 bit 2s complement number
* } else {
*/
if (avg_dfe < 8) {
postc_metric = 0x400; /* -1023 11 bit 2s complement number */
} else if (avg_dfe > 56) {
postc_metric = 0x3ff; /* 1023 11 bit 2s complement number */
} else {
/* uRegAddr = 0x82b8 + (uLaneAddr*0x10);
* status = soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x82b8 + (0x10 * lane_num), &data));
/* postc_metric = uData & 0x7ff;*/
postc_metric = data & DSC3B0_SM_STATUS1_POSTC_METRIC_MASK;
}
} else { /* C0 */
/* uRegAddr = 0x82b8 + (uLaneAddr*0x10);
* status = soc_bm9600_mdio_hc_read(unit, uPhyAddr, uLaneAddr, uRegAddr, &uData);
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,0x82b8 + (0x10 * lane_num), &data));
/* postc_metric = uData & 0x7ff;*/
postc_metric = data & DSC3B0_SM_STATUS1_POSTC_METRIC_MASK;
}
/* negative = postc_metric >> 10; */
/* Extract the sign bit */
negative = postc_metric >> (DSC3B0_SM_STATUS1_POSTC_METRIC_BITS - 1);
/* Get rid of the sign on the metric now */
if (postc_metric > 1023) postc_metric -= 1024;
/* if (!negative && (uAvgDfe < 30) && (postc_metric < 15)) { */
if ((!negative) && (avg_dfe < 30)) {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"port(%d) postc_metric(0x%x) is positive\n"),
port, postc_metric));
*value = FALSE;
} else {
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"port(%d) remote equalization calibration complete\n"),
port));
*value = TRUE;
}
/* Perform fine tuning operation */
/*status = _bcm_bm9600_hypercore_fine_tune(unit, uPhyAddr, uLaneAddr);*/
if (_phy_hl65_fine_tune(unit, port,lane_num) != SOC_E_NONE) {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"port(%d) hl65_fine_tune fail\n"), port));
}
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_linkdown_transmit_set(int unit, soc_port_t port, uint32 value)
{
uint16 ctrl2_data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
if (value) {
ctrl2_data = (DIGITAL_CONTROL1000X2_DISABLE_FALSE_LINK_BITS <<
DIGITAL_CONTROL1000X2_DISABLE_FALSE_LINK_SHIFT) |
(DIGITAL_CONTROL1000X2_FILTER_FORCE_LINK_BITS <<
DIGITAL_CONTROL1000X2_FILTER_FORCE_LINK_SHIFT) |
(DIGITAL_CONTROL1000X2_FORCE_XMIT_DATA_ON_TXSIDE_BITS <<
DIGITAL_CONTROL1000X2_FORCE_XMIT_DATA_ON_TXSIDE_SHIFT);
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_CONTROL1000X2r(unit, pc, ctrl2_data));
} else {
ctrl2_data = (DIGITAL_CONTROL1000X2_FILTER_FORCE_LINK_BITS <<
DIGITAL_CONTROL1000X2_FILTER_FORCE_LINK_SHIFT) |
(DIGITAL_CONTROL1000X2_DISABLE_FALSE_LINK_BITS <<
DIGITAL_CONTROL1000X2_DISABLE_FALSE_LINK_SHIFT) |
(DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_BITS <<
DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_SHIFT);
SOC_IF_ERROR_RETURN
(WRITE_HL65_DIGITAL_CONTROL1000X2r(unit, pc, ctrl2_data));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_control_linkdown_transmit_get(int unit, soc_port_t port, uint32 *value)
{
uint16 data;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_CONTROL1000X2r(unit, pc, &data));
/* Check if FORCE_XMIT_DATA_ON_TXSIDE is set */
*value = (data & (DIGITAL_CONTROL1000X2_FORCE_XMIT_DATA_ON_TXSIDE_BITS <<
DIGITAL_CONTROL1000X2_FORCE_XMIT_DATA_ON_TXSIDE_SHIFT))
? 1 : 0;
return SOC_E_NONE;
}
/*
* Get current DSC config
*/
STATIC int
_phy_hl65_dsc_cfg_get(int unit, soc_port_t port, int lane_num,
phy_hl65_dsc_cfg_t *dsc_cfg)
{
int rv = SOC_E_NONE;
uint16 data;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
reg_addr = 0x82b2 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
if (data & DSC3B0_CDR_STATUS2_BR_CDR_ENABLED_MASK) {
*dsc_cfg = PHY_HL65_DSC_CFG_BR_CDR;
} else {
data = (data & DSC3B0_CDR_STATUS2_OSCDR_MODE_MASK) >>
DSC3B0_CDR_STATUS2_OSCDR_MODE_SHIFT;
switch (data) {
case 0:
*dsc_cfg = PHY_HL65_DSC_CFG_1X_OSR;
break;
case 1:
*dsc_cfg = PHY_HL65_DSC_CFG_2X_OSR;
break;
case 2:
*dsc_cfg = PHY_HL65_DSC_CFG_4X_OSR;
break;
case 3:
*dsc_cfg = PHY_HL65_DSC_CFG_5X_OSR;
break;
default:
*dsc_cfg = PHY_HL65_DSC_CFG_UNKNOWN;
rv = SOC_E_INTERNAL;
break;
}
}
return rv;
}
/*
* Return value range
*/
STATIC int
_phy_hl65_control_serdes_tune_margin_max_get(int unit, soc_port_t port,
int lane_num, uint32 *max)
{
phy_hl65_dsc_cfg_t dsc_cfg;
/* Get DSC config */
SOC_IF_ERROR_RETURN
(_phy_hl65_dsc_cfg_get(unit, port, lane_num, &dsc_cfg));
switch (dsc_cfg) {
case PHY_HL65_DSC_CFG_BR_CDR:
/* vertical diag */
*max = (1 << DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_BITS);
break;
case PHY_HL65_DSC_CFG_1X_OSR:
case PHY_HL65_DSC_CFG_2X_OSR:
/* horizontal diag 1xOSR
* pi_phase_delta for 1xOSR == 1 so return full range
*/
*max = (1 << DSC3B0_PI_STATUS0_CLK90_PHASE_OFFSET_BITS);
break;
default:
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Tune margin supported for 1XOSR, 2XOSR, "
"BR CDR DSC")));
return SOC_E_UNAVAIL;
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_common_start(int unit, soc_port_t port,
int lane_num)
{
uint16 data;
uint16 vga_sum_avg;
uint16 dfe_tap_bin_avg;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/* Step 1: check tuning done */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 1: check tuning done\n")));
reg_addr = 0x82b7 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
if (!(data & DSC3B0_SM_STATUS0_TUNING_DONE_MASK)) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) tuning has not finished\n"), port));
return SOC_E_FAIL;
}
/* Step 2: average vga_sum and dfe_tap_bin */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 2: compute vga_sum, dfe_tap_bin average\n")));
SOC_IF_ERROR_RETURN
(_phy_hl65_tuning_status_get(unit, port, pc->lane_num,
&vga_sum_avg, &dfe_tap_bin_avg));
/* Step 3: fix vga_sum and dfe_tab_bin */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 3: fix vga_sum, dfe_tap_bin\n")));
reg_addr = 0x8215 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data &= ~(DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_VAL_MASK |
DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_MASK |
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_VAL_MASK |
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_MASK);
data |= (vga_sum_avg << DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_VAL_SHIFT) |
(dfe_tap_bin_avg << DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_VAL_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Now toggle the write enable bits */
data &= ~((DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_SHIFT) |
(DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_SHIFT));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
data |= (DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_SHIFT) |
(DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/*
* Leave vga_write and dfe_write enabled - will be disabled
* when diag stops
*/
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_horizontal_start(int unit, soc_port_t port,
int lane_num,
phy_hl65_dsc_cfg_t dsc_cfg)
{
uint16 data, delta, exp_clk90_po;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_common_start(unit, port, lane_num));
/*
* Step 4: verify clk90_phase_offset
* ==32 1xOSR
* ==0 2xOSR
*/
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 4: verify clk90_phase_offset\n")));
reg_addr = 0x82b3 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data = (data & DSC3B0_PI_STATUS0_CLK90_PHASE_OFFSET_MASK) >>
DSC3B0_PI_STATUS0_CLK90_PHASE_OFFSET_SHIFT;
exp_clk90_po = (dsc_cfg == PHY_HL65_DSC_CFG_1X_OSR) ? 32 : 0;
if (data != exp_clk90_po) {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"WARNING: hc(%02d) diag clk90 phase offset=%d "
"expected %d\nMake sure DSC is properly configured "
"and tuning is done before running diag\n"),
port, data, exp_clk90_po));
}
/* Step 5: clk90 offset override */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 5: enable clk90 offset override\n")));
reg_addr = 0x8213 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data |= (DSC1B0_PI_CTRL0_PI_CLK90_OFFSET_OVERRIDE_BITS <<
DSC1B0_PI_CTRL0_PI_CLK90_OFFSET_OVERRIDE_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Step 6: pi_phase_delta */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 6: set pi_phase_delta\n")));
if (dsc_cfg == PHY_HL65_DSC_CFG_1X_OSR) {
/* 1xOSR */
delta = 1;
} else if (dsc_cfg == PHY_HL65_DSC_CFG_2X_OSR) {
delta = 2;
} else {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) invalid DSC config\n"),
port));
return SOC_E_PARAM;
}
data = (data & ~(DSC1B0_PI_CTRL0_PI_PHASE_DELTA_MASK)) |
(delta << DSC1B0_PI_CTRL0_PI_PHASE_DELTA_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_horizontal_adjust(int unit, soc_port_t port,
int lane_num, uint32 inc)
{
uint16 data;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/*
* Step 7: set phase offset moving direction
*/
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 7: set phase offset moving direction\n")));
reg_addr = 0x8213 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data &= ~(DSC1B0_PI_CTRL0_PI_PHASE_INC_MASK |
DSC1B0_PI_CTRL0_PI_PHASE_DEC_MASK);
if (inc == 1) {
data |= (DSC1B0_PI_CTRL0_PI_PHASE_INC_BITS <<
DSC1B0_PI_CTRL0_PI_PHASE_INC_SHIFT);
} else if (inc == 0) {
data |= (DSC1B0_PI_CTRL0_PI_PHASE_DEC_BITS <<
DSC1B0_PI_CTRL0_PI_PHASE_DEC_SHIFT);
} else {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) diag invalid adjust\n"),
port));
return SOC_E_PARAM;
}
/* Step 8: toggle pi phase strobe */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 8: toggle pi phase strobe\n")));
data &= ~(DSC1B0_PI_CTRL0_PI_PHASE_STROBE_BITS <<
DSC1B0_PI_CTRL0_PI_PHASE_STROBE_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
data |= (DSC1B0_PI_CTRL0_PI_PHASE_STROBE_BITS <<
DSC1B0_PI_CTRL0_PI_PHASE_STROBE_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
data &= ~(DSC1B0_PI_CTRL0_PI_PHASE_STROBE_BITS <<
DSC1B0_PI_CTRL0_PI_PHASE_STROBE_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_horizontal_stop(int unit, soc_port_t port,
int lane_num,
phy_hl65_dsc_cfg_t dsc_cfg)
{
uint16 data;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/*
* Step 11: restore pi_clk90_offset_override,
* pi_phase_data, pi_phase_inc/dec
*/
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 11: restore values\n")));
reg_addr = 0x8213 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data &= ~(DSC1B0_PI_CTRL0_PI_CLK90_OFFSET_OVERRIDE_MASK |
DSC1B0_PI_CTRL0_PI_PHASE_DELTA_MASK |
DSC1B0_PI_CTRL0_PI_PHASE_INC_MASK |
DSC1B0_PI_CTRL0_PI_PHASE_DEC_MASK);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Step 12,13: release vga_write and dfe_write */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 12: release vga_write, dfe_write enable\n")));
reg_addr = 0x8215 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data &= ~(DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_VAL_MASK |
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_VAL_MASK);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
data &= ~((DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_SHIFT) |
(DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_SHIFT));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_horizontal_value_get(int unit, soc_port_t port,
int lane_num,
uint32 *value)
{
uint16 data;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
reg_addr = 0x82b3 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
*value = (data & DSC3B0_PI_STATUS0_CLK90_PHASE_OFFSET_MASK) >>
DSC3B0_PI_STATUS0_CLK90_PHASE_OFFSET_SHIFT;
/*
* External values are scaled
*
* Internal range 0..127
*
* Internal Value Scaled Value
* Signed / Unsigned Unsigned
* 0 0 64
* 1 1 65
* 2 2 66
* .. .. ..
* 63 63 127
* -64 64 0
* -63 65 1
* -1 127 63
*/
*value = (*value + 64) &
(DSC3B0_PI_STATUS0_CLK90_PHASE_OFFSET_MASK >>
DSC3B0_PI_STATUS0_CLK90_PHASE_OFFSET_SHIFT);
return SOC_E_NONE;
}
/*
* Horizontal adjust
*/
STATIC int
_phy_hl65_serdes_tune_margin_horizontal_value_set(int unit, soc_port_t port,
int lane_num,
phy_hl65_dsc_cfg_t dsc_cfg,
uint32 value)
{
uint32 max, cur_value,
inc = 0;
int i, steps;
SOC_IF_ERROR_RETURN
(_phy_hl65_control_serdes_tune_margin_max_get(unit, port, lane_num,
&max));
if (value > max) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Invalid value %d (0..%d)\n"),
value, max-1));
return SOC_E_PARAM;
}
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_value_get(unit, port,
lane_num,
&cur_value));
if (value < cur_value) {
steps = cur_value - value;
inc = 0;
} else if (value > cur_value) {
steps = value - cur_value;
inc = 1;
} else {
return SOC_E_NONE;
}
if (dsc_cfg == PHY_HL65_DSC_CFG_2X_OSR) {
/* 2xOSR steps by 2 */
steps /= 2;
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"horizontal adjusting to %d from %d steps %d\n"),
value, cur_value, steps));
/* Adjust to value */
for (i = 0; i < steps; i++) {
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_adjust(unit, port,
lane_num, inc));
}
/* Verify if got there */
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_value_get(unit, port,
lane_num,
&cur_value));
/* Adjust if 2xOSR to increment in steps by 2 */
if ((dsc_cfg == PHY_HL65_DSC_CFG_2X_OSR) && (value % 2)) {
value--;
}
if (cur_value != value) {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"WARNING: Adjusted value %d does not match requested "
"value %d\n"), cur_value, value));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_vertical_start(int unit, soc_port_t port,
int lane_num)
{
uint16 data;
uint16 slicer_offset_me, slicer_offset_ze, slicer_offset_pe;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_common_start(unit, port, lane_num));
/* Step 4: read slicer offset status */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 4: read slice offset status\n")));
reg_addr = 0x82ba + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
slicer_offset_me = (data & DSC3B0_SM_STATUS3_SLICER_OFFSET_ME_MASK) >>
DSC3B0_SM_STATUS3_SLICER_OFFSET_ME_SHIFT;
slicer_offset_ze = (data & DSC3B0_SM_STATUS3_SLICER_OFFSET_ZE_MASK) >>
DSC3B0_SM_STATUS3_SLICER_OFFSET_ZE_SHIFT;
slicer_offset_pe = (data & DSC3B0_SM_STATUS3_SLICER_OFFSET_PE_MASK) >>
DSC3B0_SM_STATUS3_SLICER_OFFSET_PE_SHIFT;
/* Step 5: write slicer offsets to control */
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 5: write slice offset status\n")));
reg_addr = 0x821b + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data &= ~( DSC1B0_DSC_ANA_CTRL1_P1_EVN_CTRL_MASK |
DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_MASK |
DSC1B0_DSC_ANA_CTRL1_M1_EVN_CTRL_MASK);
data |= (slicer_offset_me << DSC1B0_DSC_ANA_CTRL1_M1_EVN_CTRL_SHIFT) |
(slicer_offset_ze << DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_SHIFT) |
(slicer_offset_pe << DSC1B0_DSC_ANA_CTRL1_P1_EVN_CTRL_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_vertical_adjust(int unit, soc_port_t port,
int lane_num, uint32 inc)
{
uint16 data;
int16 tmp;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/*
* Step 6: perturb data even slicer
*/
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 6: perturb data even slicer\n")));
reg_addr = 0x821b + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
tmp = (data & DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_MASK)
>> DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_SHIFT;
if (inc == 1) {
/* increment */
if (tmp == 0xf) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) cannot increment anymore\n"),
port));
return SOC_E_PARAM;
}
tmp++;
} else if (inc == 0) {
/* decrement */
if (tmp == 0x10) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) cannot decrement anymore\n"),
port));
return SOC_E_PARAM;
}
tmp--;
} else {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"ERROR: hc(%02d) diag invalid operation\n"),
port));
return SOC_E_PARAM;
}
data &= ~(DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_MASK);
data |= (tmp << DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_SHIFT) |
(DSC1B0_DSC_ANA_CTRL1_FORCE_EVN_CTRL_BITS <<
DSC1B0_DSC_ANA_CTRL1_FORCE_EVN_CTRL_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/* Toggle force even - required? */
data &= ~(DSC1B0_DSC_ANA_CTRL1_FORCE_EVN_CTRL_BITS <<
DSC1B0_DSC_ANA_CTRL1_FORCE_EVN_CTRL_SHIFT);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_vertical_value_get(int unit, soc_port_t port,
int lane_num, uint32 *value)
{
uint16 data;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
reg_addr = 0x821b + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
*value = (data & DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_MASK)
>> DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_SHIFT;
/* Scale value */
*value = (*value + 16) &
(DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_MASK >>
DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_SHIFT);
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_vertical_value_set(int unit, soc_port_t port,
int lane_num, uint32 value)
{
int i, steps;
uint32 cur_value, max, inc = 0;
SOC_IF_ERROR_RETURN
(_phy_hl65_control_serdes_tune_margin_max_get(unit, port, lane_num,
&max));
if (value > max) {
LOG_ERROR(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Invalid value %d (0..%d)\n"), value, max));
return SOC_E_PARAM;
}
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_value_get(unit, port,
lane_num,
&cur_value));
if (value < cur_value) {
steps = cur_value - value;
inc = 0;
} else if (value > cur_value) {
steps = value - cur_value;
inc = 1;
} else {
return SOC_E_NONE;
}
/* Adjust to value */
for (i = 0; i < steps; i++) {
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_adjust(unit, port,
lane_num,
inc));
}
/* Verify if got there */
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_value_get(unit, port,
lane_num,
&cur_value));
if (cur_value != value) {
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Adjusted value %d does not match "
"requested value %d\n"), cur_value, value));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_vertical_stop(int unit, soc_port_t port,
int lane_num)
{
uint16 data;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/*
* Step 9: restore all slice offset control registers to 0
*/
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 9: restore slice offset\n")));
reg_addr = 0x821b + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data &= ~( DSC1B0_DSC_ANA_CTRL1_P1_EVN_CTRL_MASK |
DSC1B0_DSC_ANA_CTRL1_D_EVN_CTRL_MASK |
DSC1B0_DSC_ANA_CTRL1_M1_EVN_CTRL_MASK);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
/*
* Step 10: release and restore vga_write and dfe_write
*/
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Step 10: release vga_write, dfe_write enable\n")));
reg_addr = 0x8215 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
data &= ~(DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_VAL_MASK |
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_VAL_MASK);
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
data &= ~((DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_SHIFT) |
(DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_BITS <<
DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_SHIFT));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit,pc,0x0,reg_addr, data));
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_horizontal_mode_set(int unit,
soc_port_t port, int lane_num,
uint32 start,
phy_hl65_dsc_cfg_t dsc_cfg)
{
if (start) {
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_start(unit, port,
lane_num,
dsc_cfg));
} else {
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_stop(unit, port,
lane_num,
dsc_cfg));
}
return SOC_E_NONE;
}
STATIC int
_phy_hl65_serdes_tune_margin_vertical_mode_set(int unit,
soc_port_t port,
int lane_num,
uint32 start)
{
if (start) {
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_start(unit, port,
lane_num));
} else {
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_stop(unit, port,
lane_num));
}
return SOC_E_NONE;
}
/*
* Start/stop HC diag
*/
STATIC int
_phy_hl65_control_serdes_tune_margin_mode_set(int unit, soc_port_t port,
int lane_num, uint32 start)
{
phy_hl65_dsc_cfg_t dsc_cfg;
/* Get DSC config */
SOC_IF_ERROR_RETURN
(_phy_hl65_dsc_cfg_get(unit, port, lane_num, &dsc_cfg));
switch (dsc_cfg) {
case PHY_HL65_DSC_CFG_BR_CDR:
/* vertical diag */
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_mode_set(unit, port,
lane_num, start));
break;
case PHY_HL65_DSC_CFG_1X_OSR:
case PHY_HL65_DSC_CFG_2X_OSR:
/* horizontal diag */
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_mode_set(unit, port,
lane_num, start,
dsc_cfg));
break;
default:
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Tune margin supported for 1XOSR, 2XOSR, BR CDR DSC")));
return SOC_E_UNAVAIL;
}
return SOC_E_NONE;
}
/*
* Check whether diag is running or not
*/
STATIC int
_phy_hl65_control_serdes_tune_margin_mode_get(int unit, soc_port_t port,
int lane_num, uint32 *value)
{
uint16 data;
uint32 reg_addr;
phy_ctrl_t *pc = INT_PHY_SW_STATE(unit, port);
/* Read write enable */
reg_addr = 0x8215 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data));
/*
* Assumption here is that DFE and VGA write is only enabled
* while running diag
*/
*value = ((data & DSC1B0_DFE_VGA_CTRL1_DFE_WRITE_EN_MASK) &&
(data & DSC1B0_DFE_VGA_CTRL1_VGA_WRITE_EN_MASK)) ? 1 : 0;
return SOC_E_NONE;
}
/*
* Return value depending on DSC configuration
*/
STATIC int
_phy_hl65_control_serdes_tune_margin_value_get(int unit, soc_port_t port,
int lane_num, uint32 *value)
{
phy_hl65_dsc_cfg_t dsc_cfg;
/* Get DSC config */
SOC_IF_ERROR_RETURN
(_phy_hl65_dsc_cfg_get(unit, port, lane_num, &dsc_cfg));
switch (dsc_cfg) {
case PHY_HL65_DSC_CFG_BR_CDR:
/* vertical diag */
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_value_get(unit, port,
lane_num,
value));
break;
case PHY_HL65_DSC_CFG_1X_OSR:
case PHY_HL65_DSC_CFG_2X_OSR:
/* horizontal diag 1xOSR */
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_value_get(unit, port,
lane_num,
value));
break;
default:
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Tune margin supported for 1XOSR, 2XOSR, "
"BR CDR DSC\n")));
return SOC_E_UNAVAIL;
}
return SOC_E_NONE;
}
/*
* Adjust to requested value
*/
STATIC int
_phy_hl65_control_serdes_tune_margin_value_set(int unit, soc_port_t port,
int lane_num, uint32 value)
{
phy_hl65_dsc_cfg_t dsc_cfg;
/* Get DSC config */
SOC_IF_ERROR_RETURN
(_phy_hl65_dsc_cfg_get(unit, port, lane_num, &dsc_cfg));
switch (dsc_cfg) {
case PHY_HL65_DSC_CFG_BR_CDR:
/* vertical diag */
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_vertical_value_set(unit, port,
lane_num, value));
break;
case PHY_HL65_DSC_CFG_1X_OSR:
case PHY_HL65_DSC_CFG_2X_OSR:
SOC_IF_ERROR_RETURN
(_phy_hl65_serdes_tune_margin_horizontal_value_set(unit, port,
lane_num,
dsc_cfg,
value));
break;
default:
LOG_WARN(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"Tune margin supported for 1XOSR, 2XOSR, BR CDR DSC")));
return SOC_E_UNAVAIL;
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_control_set
* Purpose:
* Configure PHY device specific control fucntion.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* type - Control to update
* value - New setting for the control
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_control_set(int unit, soc_port_t port,
soc_phy_control_t type, uint32 value)
{
int rv;
phy_ctrl_t *pc;
int i;
/* coverity[mixed_enums] */
if ((type < 0) || (type >= SOC_PHY_CONTROL_COUNT)) {
return SOC_E_PARAM;
}
pc = INT_PHY_SW_STATE(unit, port);
rv = SOC_E_UNAVAIL;
switch(type) {
case SOC_PHY_CONTROL_PREEMPHASIS:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE0:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE1:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE2:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE3:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE0:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE1:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE2:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE3:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE0:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE1:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE2:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE3:
/* fall through */
case SOC_PHY_CONTROL_PRE_PREEMPHASIS:
rv = _phy_hl65_control_tx_driver_set(unit, pc, type, value);
break;
case SOC_PHY_CONTROL_ENCODING:
rv = _phy_hl65_control_encoding_set(unit, port, value);
break;
case SOC_PHY_CONTROL_SCRAMBLER:
rv = _phy_hl65_control_scrambler_set(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_POLYNOMIAL:
rv = _phy_hl65_control_prbs_polynomial_set(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_TX_INVERT_DATA:
rv = _phy_hl65_control_prbs_tx_invert_data_set(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_TX_ENABLE:
rv = _phy_hl65_control_prbs_tx_enable_set(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_RX_ENABLE:
rv = _phy_hl65_control_prbs_rx_enable_set(unit, port, value);
break;
case SOC_PHY_CONTROL_SERDES_DRIVER_TUNE:
if (PHY_INDEPENDENT_LANE_MODE(unit, port) ||
PHY_HC65_FABRIC_MODE(unit, port)) {
rv = _phy_hl65_control_serdes_driver_tune_set(unit, port,
pc->lane_num,value);
} else {
for (i = 0; i < HL65_NUM_LANES; i++) {
rv = _phy_hl65_control_serdes_driver_tune_set(unit, port,
i ,value);
if (rv != SOC_E_NONE) {
break;
}
}
}
break;
case SOC_PHY_CONTROL_8B10B:
rv = _phy_hl65_control_8b10b_set(unit, port, value);
break;
case SOC_PHY_CONTROL_64B66B:
rv = _phy_hl65_control_64b66b_set(unit, port, value);
break;
case SOC_PHY_CONTROL_LINKDOWN_TRANSMIT:
rv = _phy_hl65_control_linkdown_transmit_set(unit, port, value);
break;
case SOC_PHY_CONTROL_SERDES_TUNE_MARGIN_MODE:
if (PHY_HC65_FABRIC_MODE(unit, port)) {
rv = _phy_hl65_control_serdes_tune_margin_mode_set(unit, port,
pc->lane_num,
value);
} else {
rv = SOC_E_UNAVAIL;
}
break;
case SOC_PHY_CONTROL_SERDES_TUNE_MARGIN_VALUE:
if (PHY_HC65_FABRIC_MODE(unit, port)) {
rv = _phy_hl65_control_serdes_tune_margin_value_set(unit, port,
pc->lane_num,
value);
} else {
rv = SOC_E_UNAVAIL;
}
break;
case SOC_PHY_CONTROL_PARALLEL_DETECTION:
/* enable 1000X parallel detect */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X2r(unit, pc,
value? DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_MASK:0,
DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_MASK));
rv = SOC_E_NONE;
break;
case SOC_PHY_CONTROL_EQUALIZER_BOOST:
/*
RX Equalizer Boost settings for stack ports
So modifying register 0x1C(RX0/1/2/3_ANACONTROL)
of block 0x8250 (reg 0x825C)
*/
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0x0, 0x825C, value));
rv = SOC_E_NONE;
break;
default:
rv = SOC_E_UNAVAIL;
break;
}
return rv;
}
/*
* Function:
* phy_hl65_control_get
* Purpose:
* Get current control settign of the PHY.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* type - Control to update
* value - (OUT)Current setting for the control
* Returns:
* SOC_E_NONE
*/
STATIC int
phy_hl65_control_get(int unit, soc_port_t port,
soc_phy_control_t type, uint32 *value)
{
int rv;
phy_ctrl_t *pc;
int i;
uint16 data16 = 0;
if (NULL == value) {
return SOC_E_PARAM;
}
/* coverity[mixed_enums] */
if ((type < 0) || (type >= SOC_PHY_CONTROL_COUNT)) {
return SOC_E_PARAM;
}
pc = INT_PHY_SW_STATE(unit, port);
rv = SOC_E_UNAVAIL;
switch(type) {
case SOC_PHY_CONTROL_PREEMPHASIS_LANE0:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE1:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE2:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS_LANE3:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE0:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE1:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE2:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT_LANE3:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE0:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE1:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE2:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT_LANE3:
/* fall through */
case SOC_PHY_CONTROL_PREEMPHASIS:
/* fall through */
case SOC_PHY_CONTROL_PRE_PREEMPHASIS:
/* fall through */
case SOC_PHY_CONTROL_DRIVER_CURRENT:
/* fall through */
case SOC_PHY_CONTROL_PRE_DRIVER_CURRENT:
rv = _phy_hl65_control_tx_driver_get(unit, pc, type, value);
break;
case SOC_PHY_CONTROL_SCRAMBLER:
rv = _phy_hl65_control_scrambler_get(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_POLYNOMIAL:
rv = _phy_hl65_control_prbs_polynomial_get(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_TX_INVERT_DATA:
rv = _phy_hl65_control_prbs_tx_invert_data_get(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_TX_ENABLE:
rv = _phy_hl65_control_prbs_tx_enable_get(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_RX_ENABLE:
rv = _phy_hl65_control_prbs_rx_enable_get(unit, port, value);
break;
case SOC_PHY_CONTROL_PRBS_RX_STATUS:
rv = _phy_hl65_control_prbs_rx_status_get(unit, port, value);
break;
case SOC_PHY_CONTROL_SERDES_DRIVER_EQUALIZATION_TUNE_STATUS_FAR_END:
if (PHY_INDEPENDENT_LANE_MODE(unit, port) ||
PHY_HC65_FABRIC_MODE(unit, port)) {
rv = _phy_hl65_control_eq_tune_status_get(unit, port,
pc->lane_num,value);
} else {
for (i = 0; i < HL65_NUM_LANES; i++) {
rv = _phy_hl65_control_eq_tune_status_get(unit, port,
i,value);
if ((*value != TRUE) || (rv != SOC_E_NONE)) {
break;
}
}
}
break;
case SOC_PHY_CONTROL_LINKDOWN_TRANSMIT:
rv = _phy_hl65_control_linkdown_transmit_get(unit, port, value);
break;
case SOC_PHY_CONTROL_SERDES_TUNE_MARGIN_MODE:
if (PHY_HC65_FABRIC_MODE(unit, port)) {
rv = _phy_hl65_control_serdes_tune_margin_mode_get(unit, port,
pc->lane_num,
value);
} else {
rv = SOC_E_UNAVAIL;
}
break;
case SOC_PHY_CONTROL_SERDES_TUNE_MARGIN_MAX:
if (PHY_HC65_FABRIC_MODE(unit, port)) {
rv = _phy_hl65_control_serdes_tune_margin_max_get(unit, port,
pc->lane_num,
value);
} else {
rv = SOC_E_UNAVAIL;
}
break;
case SOC_PHY_CONTROL_SERDES_TUNE_MARGIN_VALUE:
if (PHY_HC65_FABRIC_MODE(unit, port)) {
rv = _phy_hl65_control_serdes_tune_margin_value_get(unit, port,
pc->lane_num,
value);
} else {
rv = SOC_E_UNAVAIL;
}
break;
case SOC_PHY_CONTROL_PARALLEL_DETECTION:
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_CONTROL1000X2r(unit, pc,&data16));
*value = data16 & DIGITAL_CONTROL1000X2_ENABLE_PARALLEL_DETECTION_MASK?
TRUE: FALSE;
rv = SOC_E_NONE;
break;
case SOC_PHY_CONTROL_EQUALIZER_BOOST:
/*
RX Equalizer Boost settings for stack ports
Reading register 0x1C(RX0/1/2/3_ANACONTROL)
of block 0x8250 (reg 0x825C)
*/
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit, pc, 0x0, 0x825C, &data16));
*value = data16;
rv = SOC_E_NONE;
break;
default:
rv = SOC_E_UNAVAIL;
break;
}
return rv;
}
/*
* Function:
* phy_hl65_reg_read
* Purpose:
* Routine to read PHY register
* Parameters:
* uint - BCM unit number
* pc - PHY state
* flags - Flags which specify the register type
* phy_reg_addr - Encoded register address
* phy_data - (OUT) Value read from PHY register
* Note:
* This register read function is not thread safe. Higher level
* function that calls this function must obtain a per port lock
* to avoid overriding register page mapping between threads.
*/
STATIC int
phy_hl65_reg_read(int unit, soc_port_t port, uint32 flags,
uint32 phy_reg_addr, uint32 *phy_data)
{
uint16 data; /* Temporary holder for phy_data */
phy_ctrl_t *pc; /* PHY software state */
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(phy_reg_aer_read(unit, pc, phy_reg_addr, &data));
*phy_data = data;
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_reg_write
* Purpose:
* Routine to write PHY register
* Parameters:
* uint - BCM unit number
* pc - PHY state
* flags - Flags which specify the register type
* phy_reg_addr - Encoded register address
* phy_data - Value write to PHY register
* Note:
* This register read function is not thread safe. Higher level
* function that calls this function must obtain a per port lock
* to avoid overriding register page mapping between threads.
*/
STATIC int
phy_hl65_reg_write(int unit, soc_port_t port, uint32 flags,
uint32 phy_reg_addr, uint32 phy_data)
{
uint16 data; /* Temporary holder for phy_data */
phy_ctrl_t *pc; /* PHY software state */
pc = INT_PHY_SW_STATE(unit, port);
data = (uint16) (phy_data & 0x0000FFFF);
SOC_IF_ERROR_RETURN
(phy_reg_aer_write(unit, pc, phy_reg_addr, data));
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_reg_modify
* Purpose:
* Routine to write PHY register
* Parameters:
* uint - BCM unit number
* pc - PHY state
* flags - Flags which specify the register type
* phy_reg_addr - Encoded register address
* phy_mo_data - New value for the bits specified in phy_mo_mask
* phy_mo_mask - Bit mask to modify
* Note:
* This register read function is not thread safe. Higher level
* function that calls this function must obtain a per port lock
* to avoid overriding register page mapping between threads.
*/
STATIC int
phy_hl65_reg_modify(int unit, soc_port_t port, uint32 flags,
uint32 phy_reg_addr, uint32 phy_data,
uint32 phy_data_mask)
{
uint16 data; /* Temporary holder for phy_data */
uint16 mask;
phy_ctrl_t *pc; /* PHY software state */
pc = INT_PHY_SW_STATE(unit, port);
data = (uint16) (phy_data & 0x0000FFFF);
mask = (uint16) (phy_data_mask & 0x0000FFFF);
SOC_IF_ERROR_RETURN
(phy_reg_aer_modify(unit, pc, phy_reg_addr, data, mask));
return SOC_E_NONE;
}
STATIC int
phy_hl65_probe(int unit, phy_ctrl_t *pc)
{
uint16 serdes_id0;
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
if (!(((serdes_id0 & TEST_SERDESID0_MODEL_NUMBER_MASK) ==
SERDES_ID0_MODEL_NUMBER_HYPERLITE) ||
((serdes_id0 & TEST_SERDESID0_MODEL_NUMBER_MASK) ==
SERDES_ID0_MODEL_NUMBER_HYPERCORE))) {
return SOC_E_NOT_FOUND;
}
if ((serdes_id0 & TEST_SERDESID0_TECH_PROC_MASK) !=
SERDES_ID0_TECH_PROC_65NM) {
return SOC_E_NOT_FOUND;
}
return SOC_E_NONE;
}
STATIC int
phy_hl65_notify(int unit, soc_port_t port,
soc_phy_event_t event, uint32 value)
{
int rv;
if (event >= phyEventCount) {
return SOC_E_PARAM;
}
rv = SOC_E_NONE;
switch(event) {
case phyEventInterface:
rv = (_phy_hl65_notify_interface(unit, port, value));
break;
case phyEventDuplex:
rv = (_phy_hl65_notify_duplex(unit, port, value));
break;
case phyEventSpeed:
rv = (_phy_hl65_notify_speed(unit, port, value));
break;
case phyEventStop:
rv = (_phy_hl65_notify_stop(unit, port, value));
break;
case phyEventResume:
rv = (_phy_hl65_notify_resume(unit, port, value));
break;
case phyEventAutoneg:
rv = (phy_hl65_an_set(unit, port, value));
break;
case phyEventTxFifoReset:
rv = (_phy_hl65_tx_fifo_reset(unit, port, value));
break;
default:
rv = SOC_E_UNAVAIL;
}
return rv;
}
STATIC int
phy_hl65_linkup_evt (int unit, soc_port_t port)
{
phy_ctrl_t *pc;
int an,an_done,speed;
pc = INT_PHY_SW_STATE(unit, port);
phy_hl65_an_get(unit,port,&an,&an_done);
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_linkup_evt: "
"u=%d p=%d an=%d\n"), unit, port, an));
/* check if the link is established due to the auto-negotiation. If so,
* configure the tx half rate and DSP related registers. These settings
* can only be done after the autoneg speed is determined.
*/
if (an == TRUE) {
/* check the autoneg speed */
phy_hl65_speed_get(unit,port,&speed);
/* set tx half rate. */
SOC_IF_ERROR_RETURN
(_phy_hl65_half_rate_set(unit,port,speed));
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
/* configure DSP related registers based on speed */
_phy_hl65_dsp_cfg(unit,pc,speed);
}
/* for speed above 10G, txcko_div must be cleared */
if (speed > 10000) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
0,
XGXSBLK0_XGXSCONTROL_TXCKO_DIV_MASK));
} else {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK0_XGXSCONTROLr(unit, pc,
XGXSBLK0_XGXSCONTROL_TXCKO_DIV_MASK,
XGXSBLK0_XGXSCONTROL_TXCKO_DIV_MASK));
}
}
return SOC_E_NONE;
}
STATIC int
phy_hl65_linkdown_evt (int unit, soc_port_t port)
{
phy_ctrl_t *pc;
int an,an_done;
uint16 dfe_brcdr;
pc = INT_PHY_SW_STATE(unit, port);
phy_hl65_an_get(unit,port,&an,&an_done);
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_linkdown_evt: "
"u=%d p=%d an=%d\n"), unit, port, an));
/* The DSP related registers must be set to the default
* values before the autoneg starts.
*/
if (an == TRUE) {
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
/* check if DFE/BR CDR(20G speed). if so, restart AN */
SOC_IF_ERROR_RETURN
(READ_HL65_DSC2BB_DSC_MISC_CTRL0r(unit, pc, &dfe_brcdr));
if ((dfe_brcdr == HL65_A0A1_DSC_DFE_BRCDR) ||
(dfe_brcdr == HL65_B0C0_DSC_DFE_BRCDR) ) {
phy_hl65_an_set(unit,port,TRUE);
}
}
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_duplex_set
* Purpose:
* Set the current duplex mode (forced).
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* duplex - Boolean, true indicates full duplex, false indicates half.
* Returns:
* SOC_E_XXX
*/
STATIC int
phy_hl65_duplex_set(int unit, soc_port_t port, int duplex)
{
uint16 data16;
phy_ctrl_t *pc;
uint16 serdes_id0;
int duplex_value;
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
return SOC_E_NONE;
}
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_STATUS1000X1r(unit, pc, &data16));
if (!(data16 & DIGITAL_STATUS1000X1_SGMII_MODE_MASK)) {
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
/* 1000X fiber mode, 100fx */
if ((serdes_id0 & TEST_SERDESID0_REV_LETTER_MASK) > 0) {
duplex_value = duplex? FX100_CONTROL1_FULL_DUPLEX_MASK:0;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_FX100_CONTROL1r(unit,pc,
duplex_value,
FX100_CONTROL1_FULL_DUPLEX_MASK));
}
/* 1000X should always be full duplex */
duplex = TRUE;
}
data16 = duplex? MII_CTRL_FD: 0;
/* program the duplex setting */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, data16,MII_CTRL_FD));
return SOC_E_NONE;
}
STATIC int
phy_hl65_duplex_get(int unit, soc_port_t port, int *duplex)
{
uint16 reg0_16;
uint16 mii_ctrl;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
*duplex = TRUE;
return SOC_E_NONE;
}
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_STATUS1000X1r(unit, pc, ®0_16));
/* default to fiber mode duplex */
*duplex = (reg0_16 & DIGITAL_STATUS1000X1_DUPLEX_STATUS_MASK)?
TRUE:FALSE;
if (reg0_16 & DIGITAL_STATUS1000X1_SGMII_MODE_MASK) {
/* retrieve the duplex setting in SGMII mode */
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, &mii_ctrl));
if (mii_ctrl & MII_CTRL_AE) {
SOC_IF_ERROR_RETURN
(READ_HL65_COMBO_IEEE0_AUTONEGLPABILr(unit,pc,®0_16));
/* make sure link partner is also in SGMII mode
* otherwise fall through to use the FD bit in MII_CTRL reg
*/
if (reg0_16 & MII_ANP_SGMII_MODE) {
if (reg0_16 & MII_ANP_SGMII_FD) {
*duplex = TRUE;
} else {
*duplex = FALSE;
}
return SOC_E_NONE;
}
}
*duplex = (mii_ctrl & MII_CTRL_FD) ? TRUE : FALSE;
}
return SOC_E_NONE;
}
/*
* Function:
* phy_hl65_diag_ctrl
* Purpose:
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* Returns:
* SOC_E_NONE
* Notes:
*/
STATIC int
phy_hl65_diag_ctrl(
int unit, /* unit */
soc_port_t port, /* port */
uint32 inst, /* the specific device block the control action directs to */
int op_type, /* operation types: read,write or command sequence */
int op_cmd, /* command code */
void *arg) /* command argument based on op_type/op_cmd */
{
int rv;
rv = SOC_E_NONE;
switch(op_cmd) {
case PHY_DIAG_CTRL_DSC:
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_diag_ctrl: "
"u=%d p=%d PHY_DIAG_CTRL_DSC 0x%x\n"),
unit, port, PHY_DIAG_CTRL_DSC));
(void)phy_hl65_uc_status_dump(unit, port);
break;
default:
if (op_type == PHY_DIAG_CTRL_SET) {
rv = phy_hl65_control_set(unit, port, op_cmd, PTR_TO_INT(arg));
} else if (op_type == PHY_DIAG_CTRL_GET) {
rv = phy_hl65_control_get(unit, port, op_cmd, (uint32 *)arg);
}
break;
}
return rv;
}
#define HL65_UC_DEBUG
#ifdef HL65_UC_DEBUG
typedef struct {
int postc_metric;
int pf_ctrl;
int vga_sum;
int dfe_bin;
int integ_reg;
int integ_reg_xfer;
int clk90_offset;
int slicer_target;
int offset_pe;
int offset_ze;
int offset_me;
int offset_po;
int offset_zo;
int offset_mo;
int tx_os;
int tx_br;
} HL65_DESC;
#define LANE0_ACCESS 1
#define LANE1_ACCESS 2
#define LANE2_ACCESS 3
#define LANE3_ACCESS 4
#define MAX_LANES 4
static HL65_DESC hl65_desc;
int
phy_hl65_uc_status_dump(int unit, soc_port_t port)
{
phy_ctrl_t *pc;
HL65_DESC * pDesc;
int lane_num;
uint16 data16;
int regval, reg_addr;
uint8 print_menu = TRUE;
pc = INT_PHY_SW_STATE(unit, port);
for (lane_num = 0; lane_num < MAX_LANES; lane_num++) {
sal_memset((char *)&hl65_desc, 0, (sizeof(HL65_DESC)));
pDesc = &hl65_desc;
/* integ_reg(lane) = rd22_integ_reg (phy, lane) */
reg_addr = 0x82b0 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval &= 65535;
if (regval >= 32768) {
regval -=65536;
}
regval /= 84;
pDesc->integ_reg = regval;
/* integ_reg_xfer(lane) = rd22_integ_reg_xfer (phy, lane) */
reg_addr = 0x82b1 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval &= 65535;
if (regval >= 32768) {
regval -=65536;
}
regval /= 84;
pDesc->integ_reg_xfer = regval;
/* clk90_offset(lane) = rd22_clk90_phase_offset (phy, lane) */
reg_addr = 0x82b3 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval /= 128;
regval &= 127;
pDesc->clk90_offset = regval;
/* pf_ctrl(lane) = rd22_pf_ctrl (phy, lane) */
reg_addr = 0x82bb + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval &= 0x7;
pDesc->pf_ctrl = regval;
/* slicer_target(lane) = ((25*rd22_rx_thresh_sel (phy, lane)) + 125) */
reg_addr = 0x821c + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval /= 32;
regval &= 3;
pDesc->slicer_target = regval * 25 + 125;
/* vga_sum(lane) = rd22_vga_sum (phy, lane) */
reg_addr = 0x82b5 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval /= 64;
regval &= 0x1f;
pDesc->vga_sum = regval;
/* dfe_bin(lane) = rd22_dfe_tap_bin (phy, lane) */
reg_addr = 0x82b5 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval &= 0x3f;
pDesc->dfe_bin = regval;
/* postc_metric(lane) = rd22_postc_metric (phy, lane)*/
reg_addr = 0x82b8 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval &= 0x7ff;
if (regval >=1024) {
regval -= 2048;
}
pDesc->postc_metric = regval;
/* offset_mo(lane) = rd22_slicer_offset_mo (phy, lane) */
reg_addr = 0x82b9 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval &= 0x1f;
if(regval > 16) {
regval -= 32;
}
pDesc->offset_mo = regval;
/* offset_zo(lane) = rd22_slicer_offset_zo (phy, lane) */
regval = data16;
regval /= 32;
regval &= 0x1f;
if(regval > 16) {
regval -= 32;
}
pDesc->offset_zo = regval;
/* offset_po(lane) = rd22_slicer_offset_po (phy, lane) */
regval = data16;
regval /= 1024;
regval &= 0x1f;
if(regval > 16) {
regval -= 32;
}
pDesc->offset_po = regval;
/* offset_me(lane) = rd22_slicer_offset_me (phy, lane) */
reg_addr = 0x82ba + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
regval &= 0x1f;
if(regval > 16) {
regval -= 32;
}
pDesc->offset_me = regval;
/* offset_ze(lane) = rd22_slicer_offset_ze (phy, lane) */
regval = data16;
regval /= 32;
regval &= 0x1f;
if(regval > 16) {
regval -= 32;
}
pDesc->offset_ze = regval;
/* offset_pe(lane) = rd22_slicer_offset_pe (phy, lane) */
regval = data16;
regval /= 1024;
regval &= 0x1f;
if(regval > 16) {
regval -= 32;
}
pDesc->offset_pe = regval;
reg_addr = 0x8067 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
pDesc->tx_os = regval;
reg_addr = 0x8068 + (lane_num * 0x10);
SOC_IF_ERROR_RETURN
(HL65_REG_READ(unit,pc,0x0,reg_addr, &data16));
regval = data16;
pDesc->tx_br = regval;
SOC_IF_ERROR_RETURN
(READ_HL65_TXPLL_ANAPLLASTATUS1r(unit, pc, &data16));
/* regval = (data16 >> 8) & 0xf; */
if( print_menu == TRUE) {
LOG_CLI((BSL_META_U(unit,
"\n\nDSC parameters for port %d\n\n"), port));
LOG_CLI((BSL_META_U(unit,
"PLL Range: %d\n\n"),data16));
LOG_CLI((BSL_META_U(unit,
"LN PPM PPM_XFR clk90_ofs "
"PF SL_TRGT VGA DFE "
"TXDIR_OS TXDR_BR MTRC PE "
"ZE ME PO ZO "
"MO\n")));
print_menu = FALSE;
}
LOG_CLI((BSL_META_U(unit,
"%02d %04d %07d %09d "
"%04d %07d %04d %04d "
"0x%06x 0x%06x %04d %04d "
"%04d %2d %3d %3d "
"%2d\n"),
lane_num, pDesc->integ_reg, pDesc->integ_reg_xfer,
pDesc->clk90_offset, pDesc->pf_ctrl,
pDesc->slicer_target, pDesc->vga_sum, pDesc->dfe_bin,
pDesc->tx_os, pDesc->tx_br,
pDesc->postc_metric, pDesc->offset_pe,
pDesc->offset_ze, pDesc->offset_me,
pDesc->offset_po, pDesc->offset_zo,
pDesc->offset_mo));
}
return SOC_E_NONE;
}
#endif
/*
* Variable:
* phy_hl65_drv
* Purpose:
* Phy Driver for 10G (XAUI x 4) Serdes PHY.
*/
phy_driver_t phy_hl65_hg = {
/* .drv_name = */ "HyperLite PHY Driver",
/* .pd_init = */ phy_hl65_init,
/* .pd_reset = */ phy_null_reset,
/* .pd_link_get = */ phy_hl65_link_get,
/* .pd_enable_set = */ phy_hl65_enable_set,
/* .pd_enable_get = */ phy_hl65_enable_get,
/* .pd_duplex_set = */ phy_hl65_duplex_set,
/* .pd_duplex_get = */ phy_hl65_duplex_get,
/* .pd_speed_set = */ phy_hl65_speed_set,
/* .pd_speed_get = */ phy_hl65_speed_get,
/* .pd_master_set = */ phy_null_set,
/* .pd_master_get = */ phy_null_zero_get,
/* .pd_an_set = */ phy_hl65_an_set,
/* .pd_an_get = */ phy_hl65_an_get,
/* .pd_adv_local_set = */ NULL, /* Deprecated */
/* .pd_adv_local_get = */ NULL, /* Deprecated */
/* .pd_adv_remote_get = */ NULL, /* Deprecated */
/* .pd_lb_set = */ phy_hl65_lb_set,
/* .pd_lb_get = */ phy_hl65_lb_get,
/* .pd_interface_set = */ phy_hl65_interface_set,
/* .pd_interface_get = */ phy_hl65_interface_get,
/* .pd_ability = */ NULL, /* Deprecated */
/* .pd_linkup_evt = */ phy_hl65_linkup_evt,
/* .pd_linkdn_evt = */ phy_hl65_linkdown_evt,
/* .pd_mdix_set = */ phy_null_mdix_set,
/* .pd_mdix_get = */ phy_null_mdix_get,
/* .pd_mdix_status_get = */ phy_null_mdix_status_get,
/* .pd_medium_config_set = */ NULL,
/* .pd_medium_config_get = */ NULL,
/* .pd_medium_get = */ phy_null_medium_get,
/* .pd_cable_diag = */ NULL,
/* .pd_link_change = */ NULL,
/* .pd_control_set = */ phy_hl65_control_set,
/* .pd_control_get = */ phy_hl65_control_get,
/* .pd_reg_read = */ phy_hl65_reg_read,
/* .pd_reg_write = */ phy_hl65_reg_write,
/* .pd_reg_modify = */ phy_hl65_reg_modify,
/* .pd_notify = */ phy_hl65_notify,
/* .pd_probe = */ phy_hl65_probe,
/* .pd_ability_advert_set = */ phy_hl65_ability_advert_set,
/* .pd_ability_advert_get = */ phy_hl65_ability_advert_get,
/* .pd_ability_remote_get = */ phy_hl65_ability_remote_get,
/* .pd_ability_local_get = */ phy_hl65_ability_local_get,
/* .pd_firmware_set = */ NULL,
/* .pdpd_timesync_config_set = */ NULL,
/* .pdpd_timesync_config_get = */ NULL,
/* .pdpd_timesync_control_set = */ NULL,
/* .pdpd_timesync_control_set = */ NULL,
/* .pd_diag_ctrl = */ phy_hl65_diag_ctrl
};
/***********************************************************************
*
* PASS-THROUGH NOTIFY ROUTINES
*/
/*
* Function:
* _phy_hl65_notify_duplex
* Purpose:
* Program duplex if (and only if) serdeshl65 is an intermediate PHY.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* duplex - Boolean, TRUE indicates full duplex, FALSE
* indicates half.
* Returns:
* SOC_E_XXX
* Notes:
* If PHY_FLAGS_FIBER is set, it indicates the PHY is being used to
* talk directly to an external fiber module.
*
* If PHY_FLAGS_FIBER is clear, the PHY is being used in
* pass-through mode to talk to an external SGMII PHY.
*
* When used in pass-through mode, autoneg must be turned off and
* the speed/duplex forced to match that of the external PHY.
*/
STATIC int
_phy_hl65_notify_duplex(int unit, soc_port_t port, uint32 duplex)
{
int fiber;
uint16 mii_ctrl;
phy_ctrl_t *pc;
fiber = PHY_FIBER_MODE(unit, port);
pc = INT_PHY_SW_STATE(unit, port);
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"_phy_hl65_notify_duplex: "
"u=%d p=%d duplex=%d fiber=%d\n"),
unit, port, duplex, fiber));
if (SAL_BOOT_SIMULATION) {
return SOC_E_NONE;
}
if (fiber) {
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc,
MII_CTRL_FD, MII_CTRL_FD));
return SOC_E_NONE;
}
/* Put SERDES PHY in reset */
SOC_IF_ERROR_RETURN
(_phy_hl65_notify_stop(unit, port, PHY_STOP_DUPLEX_CHG));
/* Update duplexity */
mii_ctrl = (duplex) ? MII_CTRL_FD : 0;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_COMBO_IEEE0_MIICNTLr(unit, pc, mii_ctrl, MII_CTRL_FD));
/* Take SERDES PHY out of reset */
SOC_IF_ERROR_RETURN
(_phy_hl65_notify_resume(unit, port, PHY_STOP_DUPLEX_CHG));
/* Autonegotiation must be turned off to talk to external PHY if
* SGMII autoneg is not enabled.
*/
if (!PHY_SGMII_AUTONEG_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(phy_hl65_an_set(unit, port, FALSE));
}
return SOC_E_NONE;
}
/*
* Function:
* _phy_hl65_notify_speed
* Purpose:
* Program duplex if (and only if) serdeshl65 is an intermediate PHY.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* speed - Speed to program.
* Returns:
* SOC_E_XXX
* Notes:
* If PHY_FLAGS_FIBER is set, it indicates the PHY is being used to
* talk directly to an external fiber module.
*
* If PHY_FLAGS_FIBER is clear, the PHY is being used in
* pass-through mode to talk to an external SGMII PHY.
*
* When used in pass-through mode, autoneg must be turned off and
* the speed/duplex forced to match that of the external PHY.
*/
STATIC int
_phy_hl65_notify_speed(int unit, soc_port_t port, uint32 speed)
{
int fiber;
uint16 fiber_status;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
fiber = PHY_FIBER_MODE(unit, port);
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"_phy_hl65_notify_speed: "
"u=%d p=%d speed=%d fiber=%d\n"),
unit, port, speed, fiber));
if (SAL_BOOT_SIMULATION) {
return SOC_E_NONE;
}
SOC_IF_ERROR_RETURN
(READ_HL65_DIGITAL_STATUS1000X1r(unit, pc, &fiber_status));
/* Put SERDES PHY in reset */
SOC_IF_ERROR_RETURN
(_phy_hl65_notify_stop(unit, port, PHY_STOP_SPEED_CHG));
/* Update speed */
SOC_IF_ERROR_RETURN
(phy_hl65_speed_set(unit, port, speed));
/* Take SERDES PHY out of reset */
SOC_IF_ERROR_RETURN
(_phy_hl65_notify_resume(unit, port, PHY_STOP_SPEED_CHG));
/* Autonegotiation must be turned off to talk to external PHY */
if (!PHY_SGMII_AUTONEG_MODE(unit, port) && PHY_EXTERNAL_MODE(unit, port)) {
SOC_IF_ERROR_RETURN
(phy_hl65_an_set(unit, port, FALSE));
}
return SOC_E_NONE;
}
/*
* Function:
* _phy_hl65_stop
* Purpose:
* Put serdeshl65 SERDES in or out of reset depending on conditions
*/
STATIC int
_phy_hl65_stop(int unit, soc_port_t port)
{
int stop, copper;
uint16 mask16,data16;
phy_ctrl_t *pc;
int mdio_addr_share = FALSE;
if (!PHY_INDEPENDENT_LANE_MODE(unit, port)) {
return SOC_E_NONE;
}
pc = INT_PHY_SW_STATE(unit, port);
copper = (pc->stop &
PHY_STOP_COPPER) != 0;
stop = ((pc->stop &
(PHY_STOP_PHY_DIS |
PHY_STOP_DRAIN)) != 0 ||
(copper &&
(pc->stop &
(PHY_STOP_MAC_DIS |
PHY_STOP_DUPLEX_CHG |
PHY_STOP_SPEED_CHG)) != 0));
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_stop: u=%d p=%d copper=%d stop=%d flg=0x%x\n"),
unit, port, copper, stop,
pc->stop));
/* check for dxgxs ports. Don't disable RX lane, we're using rx_ck clock
* for MAC Rx block registers in 10G mode
*/
mask16 = (1 << pc->lane_num); /* rx lane */
if (IS_HG_PORT(unit, port) || IS_XE_PORT(unit,port)) {
mask16 <<= 4; /* assign tx lane */
} else {
mask16 |= (mask16 << 4); /* add tx lane */
}
if (stop) {
mask16 |= 0x800;
data16 = mask16;
} else {
data16 = 0;
}
/* point to lane0 mdio addressing.
* This register can only be accessed from lane0.
*/
if (pc->flags & PHYCTRL_MDIO_ADDR_SHARE) {
mdio_addr_share = TRUE;
pc->flags &= ~PHYCTRL_MDIO_ADDR_SHARE;
} else {
pc->phy_id -= pc->lane_num;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK1_LANECTRL3r(unit,pc,data16,mask16));
/* restore the previous MDIO address mode */
if (mdio_addr_share == TRUE) {
pc->flags |= PHYCTRL_MDIO_ADDR_SHARE;
} else {
pc->phy_id += pc->lane_num;
}
LOG_INFO(BSL_LS_SOC_PHY,
(BSL_META_U(unit,
"phy_hl65_stop: u=%d p=%d mask=0x%x value=0x%x\n"),
unit, port, mask16, data16));
return SOC_E_NONE;
}
/*
* Function:
* _phy_hl65_notify_stop
* Purpose:
* Add a reason to put serdeshl65 PHY in reset.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* flags - Reason to stop
* Returns:
* SOC_E_XXX
*/
STATIC int
_phy_hl65_notify_stop(int unit, soc_port_t port, uint32 flags)
{
INT_PHY_SW_STATE(unit, port)->stop |= flags;
return _phy_hl65_stop(unit, port);
}
/*
* Function:
* _phy_hl65_notify_resume
* Purpose:
* Remove a reason to put serdeshl65 PHY in reset.
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* flags - Reason to stop
* Returns:
* SOC_E_XXX
*/
STATIC int
_phy_hl65_notify_resume(int unit, soc_port_t port, uint32 flags)
{
INT_PHY_SW_STATE(unit, port)->stop &= ~flags;
return _phy_hl65_stop(unit, port);
}
/*
* Function:
* phy_hl65_media_setup
* Purpose:
* Configure
* Parameters:
* unit - StrataSwitch unit #.
* port - StrataSwitch port #.
* fiber_mode - Configure for fiber mode
* fiber_pref - Fiber preferrred (if fiber mode)
* Returns:
* SOC_E_XXX
*/
STATIC int
_phy_hl65_notify_interface(int unit, soc_port_t port, uint32 intf)
{
phy_ctrl_t *pc;
uint16 data16;
pc = INT_PHY_SW_STATE(unit, port);
data16 = 0;
if (intf != SOC_PORT_IF_SGMII) {
data16 = DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK;
}
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X1r(unit, pc, data16,
DIGITAL_CONTROL1000X1_FIBER_MODE_1000X_MASK));
return SOC_E_NONE;
}
STATIC
int _phy_hl65_analog_dsc_init (int unit,int port, int lane)
{
uint16 serdes_id0;
int reg;
phy_ctrl_t *pc;
pc = INT_PHY_SW_STATE(unit, port);
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
/* use default if wrong lane specified */
if (lane < 0 || lane > 3) {
lane = HL_ALL_LANES;
}
if (lane == HL_ALL_LANES) {
reg = 0x82A0;
} else {
reg = 0x8260 + lane * 0x10;
}
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1) ||
(serdes_id0 == HL_SERDES_ID0_REVID_B0) ) {
if ((serdes_id0 == HL_SERDES_ID0_REVID_A0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_A1)) {
/* Set this bit for the best possible PLL jitter performance */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXPLL_ANAPLLACONTROL4r(unit, pc,
PLL_PLLACONTROL4_BIT12_MASK,
PLL_PLLACONTROL4_BIT12_MASK));
}
/* Set lpq = 200uA */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXPLL_ANAPLLACONTROL2r(unit, pc, (1 << 2),(1 << 2)));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0x0, 0x21));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0x2, 0x3800));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0x3, 0x421b));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0x4, 0x53e4));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0x7, 0x14A5));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0x8, 0x03e0));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0x9, 0x0fc0));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0xb, 0x0312));
SOC_IF_ERROR_RETURN
(HL65_REG_WRITE(unit, pc, 0, reg + 0xc, 0x046a));
} else if (serdes_id0 == HL_SERDES_ID0_REVID_C0) {
/* Set lpq = 200uA */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_TXPLL_ANAPLLACONTROL2r(unit, pc, (1 << 2),(1 << 2)));
}
return SOC_E_NONE;
}
STATIC
int _hl65_xgmii_scw_config (int unit, phy_ctrl_t *pc)
{
uint16 serdes_id0;
/* only apply to hypercore */
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
if ((serdes_id0 & TEST_SERDESID0_MODEL_NUMBER_MASK) ==
SERDES_ID0_MODEL_NUMBER_HYPERLITE) {
return(SOC_E_NONE);
}
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW0r(unit,pc,0xE070));
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW1r(unit,pc,0xC0D0));
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW2r(unit,pc,0xA0B0));
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW3r(unit,pc,0x8090));
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW0_MASKr(unit,pc,0xF0F0));
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW1_MASKr(unit,pc,0xF0F0));
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW2_MASKr(unit,pc,0xF0F0));
SOC_IF_ERROR_RETURN
(WRITE_HL65_RX66_A_SCW3_MASKr(unit,pc,0xF0F0));
return(SOC_E_NONE);
}
STATIC
int _hl65_rxaui_config(int unit, phy_ctrl_t *pc,int rxaui)
{
uint16 mask16,data16;
mask16 = XGXSBLK1_LANECTRL3_PWRDWN_FORCE_MASK |
0xc | /* lane 2 and 3 RX */
(0xc << XGXSBLK1_LANECTRL3_PWRDN_TX_SHIFT); /* TX */
/* if in reduced XAUI mode, disable lane 2 and 3 */
data16 = rxaui? mask16: 0;
SOC_IF_ERROR_RETURN
(MODIFY_HL65_XGXSBLK1_LANECTRL3r(unit,pc, data16,mask16));
return(SOC_E_NONE);
}
STATIC
int _hl65_soft_reset(int unit, phy_ctrl_t *pc)
{
/* Set AER to DTE */
SOC_IF_ERROR_RETURN
(WRITE_HL65_AERBLK_AERr(unit,pc, 0x2800));
/* select multi mmd */
SOC_IF_ERROR_RETURN
(WRITE_HL65_XGXSBLK0_MMDSELECTr(unit, pc, 0x400F));
if (soc_property_get(unit, spn_SERDES_LANE0_RESET, 1)) {
/* soft reset via DTE */
SOC_IF_ERROR_RETURN
(WRITE_HL65_IEEE0BLK_MIICNTLr(unit,pc, 0xA040));
/* wait 2us for reset to complete */
sal_usleep(2);
}
/* restore the AER to default */
SOC_IF_ERROR_RETURN
(WRITE_HL65_AERBLK_AERr(unit,pc, 0x0));
return(SOC_E_NONE);
}
/*
* This routine initializes some of the device's lane specific registers
* applying to all modes. In the combo mode, the AER register should be
* set to broadcast to all lanes before entering this function.
*/
STATIC
int _hl65_lane_reg_init(int unit, phy_ctrl_t *pc)
{
uint16 serdes_id0;
uint16 data16;
SOC_IF_ERROR_RETURN
(READ_HL65_TEST_SERDESID0r(unit, pc, &serdes_id0));
serdes_id0 = serdes_id0 & (TEST_SERDESID0_REV_NUMBER_MASK |
TEST_SERDESID0_REV_LETTER_MASK);
if ((serdes_id0 == HL_SERDES_ID0_REVID_B0) ||
(serdes_id0 == HL_SERDES_ID0_REVID_C0)) {
/* Revert Back to original Rx fifo if C0/B0 version */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL4_MISC3r(unit, pc,
0,
DIGITAL4_MISC3_FIFO_IPG_CYA_MASK));
}
data16 = (1 << 2); /* Set FIFO Elasticity to 13.5k */
data16 |= soc_feature(unit, soc_feature_unimac_tx_crs)?
DIGITAL_CONTROL1000X3_DISABLE_TX_CRS_MASK:
0; /* set disable_tx_crs bit accordingly */
SOC_IF_ERROR_RETURN
(MODIFY_HL65_DIGITAL_CONTROL1000X3r(unit, pc,
data16,
DIGITAL_CONTROL1000X3_DISABLE_TX_CRS_MASK |
DIGITAL_CONTROL1000X3_FIFO_ELASICITY_TX_RX_MASK));
return(SOC_E_NONE);
}
#else /* INCLUDE_XGXS_HL65 */
typedef int _xgxs_hl65_not_empty; /* Make ISO compilers happy. */
#endif /* INCLUDE_XGXS_HL65 */
|
#ifndef IMGUI_IMPL_CUSTOM_H
#define IMGUI_IMPL_CUSTOM_H
#include "imgui.h" // IMGUI_IMPL_API
typedef void (*SetClipboardTextPtr)(const char* text);
typedef const char* (*GetClipboardTextPtr)();
typedef void (*ShowMouseCursorPtr)(bool show);
typedef void (*SetMouseCursorPtr)(int index);
typedef void (*WarpMousePtr)(int x, int y);
typedef void (*GetMousePositionPtr)(int* x, int* y);
typedef void (*GetWindowPositionPtr)(int* x, int* y);
typedef int (*CreateCursorPtr)(int type);
typedef int (*GetMouseButtonPtr)(int gdkButton);
struct ImGuiImplCallbackTypes
{
SetClipboardTextPtr setClipboardText;
GetClipboardTextPtr getClipboardText;
ShowMouseCursorPtr showMouseCursor;
SetMouseCursorPtr setMouseCursor;
WarpMousePtr warpMouse;
GetMousePositionPtr getMousePosition;
GetWindowPositionPtr getWindowPosition;
CreateCursorPtr createCursor;
GetMouseButtonPtr getMouseButton;
};
enum class ImGuiImplWindowEventType
{
MOUSEWHEEL,
MOUSEBUTTONDOWN,
MOUSEBUTTONUP,
TEXTINPUT,
KEYDOWN,
KEYUP,
NONE
};
struct ImGuiImplFrameSettings
{
int windowWidth;
int windowHeight;
int drawableWidth;
int drawableHeight;
bool isMinimized;
float deltaTime;
};
struct ImGuiImplMouseState
{
int buttonLeft;
int buttonRight;
int buttonMiddle;
int wheelX;
int wheelY;
};
struct ImGuiImplKeybindings
{
int Tab;
int LeftArrow;
int RightArrow;
int UpArrow;
int DownArrow;
int PageUp;
int PageDown;
int Home;
int End;
int Insert;
int Delete;
int Backspace;
int Space;
int Enter;
int Escape;
int KeyPadEnter;
int A;
int C;
int V;
int X;
int Y;
int Z;
};
struct ImGuiImplKeyboardState
{
int scancode;
int shiftIsDown;
int controlisDown;
int altIsDown;
int superIsDown;
};
struct ImGuiImplCursorType
{
int Arrow;
int TextInput;
int ResizeAll;
int ResizeNS;
int ResizeEW;
int ResizeNESW;
int ResizeNWSE;
int Hand;
int NotAllowed;
};
struct ImGuiImplMouseButton
{
int Left;
int Right;
int Middle;
};
IMGUI_IMPL_API bool ImGui_ImplCustom_InitForOpenGL(ImGuiImplCallbackTypes callbacks, ImGuiImplKeybindings keybindings, ImGuiImplCursorType cursorTypes, ImGuiImplMouseButton mouseButtons);
IMGUI_IMPL_API void ImGui_ImplCustom_Shutdown();
IMGUI_IMPL_API void ImGui_ImplCustom_NewFrame(const ImGuiImplFrameSettings frameSettings);
IMGUI_IMPL_API bool ImGui_ImplCustom_ProcessEvent(const ImGuiImplWindowEventType event, const ImGuiImplKeyboardState keyboardState, const ImGuiImplMouseState mouseState, const char* inputText);
#endif |
/*
* uniform_lens.h
*
* Created on: Jan 21, 2013
* Author: D. Leier
*/
#ifndef UNIFORM_LENS_H_
#define UNIFORM_LENS_H_
#include "base_analens.h"
/**
* \brief A uniform surface density and shear lens.
*
* Note the units of the input shear and surface density are not Sigma_crit's.
* This lens will extend to infinity in the angular directions.
*
* If the magnitude g and position angle, theta, are specified then
*
* Shear[0] = g * cos( 2*theta )
* Shear[1] = g * sin( 2*theta )
*/
class LensHaloUniform: public LensHalo{
public:
/// Direct constructor without any stars
LensHaloUniform(double zlens /// lens redshift
,double Sigma /// surface density of lens in Msun/Mpc^2
,Point_2d &Shear /// shear in M_sun/Mpc^2 ie gamma * Sigma_crit
,COSMOLOGY &cosmo
);
~LensHaloUniform();
/// surface density in Msun/Mpc^2
float getSigma() const {return perturb_modes[0];};
/// shear in Msun/Mpc^2
Point_2d getShear() const{
Point_2d p(perturb_modes[1],perturb_modes[2]);
return p;
}
/// reset the shear keeping the redshift of the plane fixed
void resetGamma(const Point_2d &Shear /// Shear in units of critical density Msun/Mpc^2, ie gamma * Sigma_crit
){
perturb_modes[1] = Shear[0];
perturb_modes[2] = Shear[1];
}
/// reset the convergence keeping the redshift of the plane fixed
void resetKappa(double Sigma /// Surface density in Msun/Mpc^2, ie kappa * Sigma_crit
){
perturb_modes[0] = Sigma;;
}
void force_halo(PosType *alpha,KappaType *kappa,KappaType *gamma,KappaType *phi,PosType const *xcm,bool subtract_point=false,PosType screening = 1.0);
LensHaloUniform(const LensHaloUniform &h):LensHalo(h){
perturb_modes[0] = h.perturb_modes[0];
perturb_modes[1] = h.perturb_modes[1];
perturb_modes[2] = h.perturb_modes[2];
}
LensHaloUniform & operator=(const LensHaloUniform &h){
if(this == &h) return *this;
LensHalo::operator=(h);
perturb_modes[0] = h.perturb_modes[0];
perturb_modes[1] = h.perturb_modes[1];
perturb_modes[2] = h.perturb_modes[2];
return *this;
}
protected:
PosType perturb_modes[3]; ///first two are shear
PosType lens_expand(PosType *mod,PosType const *x,PosType *alpha,KappaType *gamma,KappaType *phi);
};
#endif /* UNIFORM_LENS_H_ */
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_DNS_DNS_CONFIG_SERVICE_POSIX_H_
#define NET_DNS_DNS_CONFIG_SERVICE_POSIX_H_
#pragma once
#include <sys/types.h>
#include <netinet/in.h>
#include <resolv.h>
#include "base/compiler_specific.h"
#include "net/base/net_export.h"
#include "net/dns/dns_config_service.h"
namespace net {
// Use DnsConfigService::CreateSystemService to use it outside of tests.
namespace internal {
class NET_EXPORT_PRIVATE DnsConfigServicePosix : public DnsConfigService {
public:
DnsConfigServicePosix();
virtual ~DnsConfigServicePosix();
private:
// NetworkChangeNotifier::DNSObserver:
virtual void OnDNSChanged(unsigned detail) OVERRIDE;
scoped_refptr<SerialWorker> config_reader_;
scoped_refptr<SerialWorker> hosts_reader_;
DISALLOW_COPY_AND_ASSIGN(DnsConfigServicePosix);
};
// Fills in |dns_config| from |res|.
bool NET_EXPORT_PRIVATE ConvertResStateToDnsConfig(
const struct __res_state& res, DnsConfig* dns_config);
} // namespace internal
} // namespace net
#endif // NET_DNS_DNS_CONFIG_SERVICE_POSIX_H_
|
/*==============================================================================
Program: 3D Slicer
Portions (c) Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.
See COPYRIGHT.txt
or http://www.slicer.org/copyright/copyright.txt for details.
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
/// Markups Module MRML storage nodes
///
/// vtkMRMLMarkupsJsonStorageNode - MRML node for storing markups in JSON file
///
#ifndef __vtkMRMLMarkupsJsonStorageNode_h
#define __vtkMRMLMarkupsJsonStorageNode_h
// Markups includes
#include "vtkSlicerMarkupsModuleMRMLExport.h"
#include "vtkMRMLMarkupsStorageNode.h"
class vtkMRMLMarkupsNode;
class vtkMRMLMarkupsDisplayNode;
/// \ingroup Slicer_QtModules_Markups
class VTK_SLICER_MARKUPS_MODULE_MRML_EXPORT vtkMRMLMarkupsJsonStorageNode : public vtkMRMLMarkupsStorageNode
{
public:
static vtkMRMLMarkupsJsonStorageNode *New();
vtkTypeMacro(vtkMRMLMarkupsJsonStorageNode,vtkMRMLMarkupsStorageNode);
void PrintSelf(ostream& os, vtkIndent indent) override;
vtkMRMLNode* CreateNodeInstance() override;
vtkMRMLMarkupsNode* AddNewMarkupsNodeFromFile(const char* filePath, const char* nodeName=nullptr, int markupIndex=0);
///
/// Get node XML tag name (like Storage, Model)
const char* GetNodeTagName() override {return "MarkupsJsonStorage";};
/// Read node attributes from XML file
void ReadXMLAttributes( const char** atts) override;
/// Write this node's information to a MRML file in XML format.
void WriteXML(ostream& of, int indent) override;
/// Copy the node's attributes to this object
void Copy(vtkMRMLNode *node) override;
bool CanReadInReferenceNode(vtkMRMLNode *refNode) override;
protected:
vtkMRMLMarkupsJsonStorageNode();
~vtkMRMLMarkupsJsonStorageNode() override;
vtkMRMLMarkupsJsonStorageNode(const vtkMRMLMarkupsJsonStorageNode&);
void operator=(const vtkMRMLMarkupsJsonStorageNode&);
/// Initialize all the supported write file types
void InitializeSupportedReadFileTypes() override;
/// Initialize all the supported write file types
void InitializeSupportedWriteFileTypes() override;
/// Read data and set it in the referenced node
int ReadDataInternal(vtkMRMLNode *refNode) override;
/// Write data from a referenced node.
int WriteDataInternal(vtkMRMLNode *refNode) override;
class vtkInternal;
vtkInternal* Internal;
friend class vtkInternal;
};
#endif
|
/*
* Arquivo : busca.h
* Tipo : Header, tambem chamado de: arquivo-interface ou API
* Cabecalho/nomenclatura e descricao das funcoes do arquivo "busca.c"
*
* Autor : Guilherme Esdras ([email protected])
* Data : 06/2019 | Junho de 2019
* Curso : Bacharel em Engenharia de Computacao / 2019.1 / Periodo: 2
* Instituicao : Instituto Federal de Ciencia e Tecnologia da Paraiba (IFPB) - Campus Campina Grande
*
* Descricao do Arquivo:
*
* Esse arquivo contem o cabecalho, nomenclatura e descricao de
* funcoes relacionadas a buscas usando a linguagem C.
* As funcoes aqui implementadas permitem ao usuario buscar
* um determinado valor dentro de um array de elementos ORDENADOS.
*
*/
/* Condicao que impede a bibliteca de ser inclusa mais de uma vez ao compilar
garantindo que nao ocorrera erros de importacao durante a compilacao */
#ifndef BUSCA_H
#define BUSCA_H
/* Bibliotecas Padroes Auxiliares */
#include <stdio.h> // Necessaria para realizar operacoes importantes de entrada e saida de dados
#include <stdlib.h> // Necessaria para realizar operacoes com alocacao de memoria e ponteiros
#include <string.h> // Necessaria para manipulacao de Chars
#include <stdbool.h> // Necessaria para usar tipo booleano, true e false
/*
* Funcao: Busca Binaria
* --------------------
* | Descricao |
* Busca um determinado valor dentro de um array.
*
* | Parameters |
* *vetor: Array de elementos a ser vasculhado
* tam: Tamanho do array
* valorBuscado: Valor a ser buscado dentro deste array
*
* | returns |
* Posicao do elemento buscado (caso seja encontrado),
* ou -1 caso nao seja encontrado
*
* | Exemplo de Uso |
* int arr[10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
* buscaBinaria(arr, 10, 5);
* (Return: 4)
*
*/
int buscaBinaria(int *vetor, int tam, int valorBuscado);
/*
* Funcao: Busca Binaria Recursiva
* --------------------
* | Descricao |
* Busca um determinado valor dentro de um array de forma recursiva.
*
* | Parameters |
* *vetor: Array de elementos a ser vasculhado
* inicio: Primeira posicao do array
* fim: Ultima posicao do array
* valorBuscado: Valor a ser buscado dentro deste array
*
* | returns |
* Posicao do elemento buscado (caso seja encontrado),
* ou -1 caso nao seja encontrado
*
* | Exemplo de Uso |
* int arr[10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
* buscaBinariaRecursiva(arr, 0, 9, 5);
* (Return: 4)
*
*/
int buscaBinariaRecursiva(int *vetor, int inicio, int fim, int valorBuscado);
/*
* Funcao: Busca Sequencial
* --------------------
* | Descricao |
* Busca um determinado valor dentro de um array vasculhando todo o array
* de forma sequencial.
*
* | Complexidade |
* Melhor caso : O(1) // Quando o valor a ser buscado esta na primeira posicao do array
* Caso medio : (N+1)/2 -> O(N) // Quando o valor a ser buscado esta pelo meio do array
* Pior caso : O(N) // Quando o valor a ser buscaso esta na ultima posicao do array
*
* | Parameters |
* *vetor: Array de elementos a ser vasculhado
* tam: Tamanho do array
* valorBuscado: Valor a ser buscado dentro deste array
*
* | returns |
* Posicao do elemento buscado (caso seja encontrado),
* ou -1 caso nao seja encontrado
*
* | Exemplo de Uso |
* int arr[10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
* buscaSequencial(arr, 10, 5);
* (Return: 4)
*
*/
int buscaSequencial(int *vetor, int tam, int valorBuscado);
/*
* Funcao: Busca Sequencial com Parada
* --------------------
* | Descricao |
* Busca um determinado valor dentro de um array.
* Forma otimizada da busca sequencial.
* Encerra a funcao caso o valor analisado seja maior que o valorBuscado.
* Nao altera a complexidade do algoritmo, mas impede que todo o array seja
* buscado sem necessidade, caso algum valor maior que o procurado
* seja encontrado antes.
*
* | Parameters |
* *vetor: Array de elementos a ser vasculhado
* tam: Tamanho do array
* valorBuscado: Valor a ser buscado dentro deste array
*
* | returns |
* Posicao do elemento buscado (caso seja encontrado),
* ou -1 caso nao seja encontrado
*
* | Exemplo de Uso |
* int arr[10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
* buscaSequencialComParada(arr, 10, 5);
* (Return: 4)
*
*/
int buscaSequencialComParada(int *vetor, int tam, int valorBuscado);
/*
* Funcao: Busca Sequencial Sentinela
* --------------------
* | Descricao |
* Busca um determinado valor dentro de um array.
* Forma otimizada da busca sequencial.
* E necessario que o array possua uma posicao vazia no final.
* Nao altera a complexidade do algoritmo, mas melhora a velocidade de busca
* retirando a comparacao de dentro do laco.
*
* | Parameters |
* *vetor: Array de elementos a ser vasculhado
* tam: Tamanho do array
* valorBuscado: Valor a ser buscado dentro deste array
*
* | returns |
* Posicao do elemento buscado (caso seja encontrado),
* ou -1 caso nao seja encontrado
*
* | Exemplo de Uso |
* int arr[11] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]; // A ultima posicao do array deve estar vazia nesse tipo de busca
* buscaSequencialSentinela(arr, 11, 5);
* (Return: 4)
*
*/
int buscaSequencialSentinela(int *vetor, int tam, int valorBuscado);
#endif |
/**CFile****************************************************************
FileName [giaCCof.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Scalable AIG package.]
Synopsis [Backward reachability using circuit cofactoring.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - June 20, 2005.]
Revision [$Id: giaCCof.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
***********************************************************************/
#include "gia.h"
#include "sat/bsat/satSolver.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
typedef struct Ccf_Man_t_ Ccf_Man_t; // manager
struct Ccf_Man_t_
{
// user data
Gia_Man_t * pGia; // single-output AIG manager
int nFrameMax; // maximum number of frames
int nConfMax; // maximum number of conflicts
int nTimeMax; // maximum runtime in seconds
int fVerbose; // verbose flag
// internal data
void * pUnr; // unrolling manager
Gia_Man_t * pFrames; // unrolled timeframes
Vec_Int_t * vCopies; // copy pointers of the AIG
sat_solver * pSat; // SAT solver
};
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Create manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Ccf_Man_t * Ccf_ManStart( Gia_Man_t * pGia, int nFrameMax, int nConfMax, int nTimeMax, int fVerbose )
{
static Gia_ParFra_t Pars, * pPars = &Pars;
Ccf_Man_t * p;
assert( nFrameMax > 0 );
p = ABC_CALLOC( Ccf_Man_t, 1 );
p->pGia = pGia;
p->nFrameMax = nFrameMax;
p->nConfMax = nConfMax;
p->nTimeMax = nTimeMax;
p->fVerbose = fVerbose;
// create unrolling manager
memset( pPars, 0, sizeof(Gia_ParFra_t) );
pPars->fVerbose = fVerbose;
pPars->nFrames = nFrameMax;
pPars->fSaveLastLit = 1;
p->pUnr = Gia_ManUnrollStart( pGia, pPars );
p->vCopies = Vec_IntAlloc( 1000 );
// internal data
p->pSat = sat_solver_new();
// sat_solver_setnvars( p->pSat, 10000 );
return p;
}
/**Function*************************************************************
Synopsis [Delete manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Ccf_ManStop( Ccf_Man_t * p )
{
Vec_IntFree( p->vCopies );
Gia_ManUnrollStop( p->pUnr );
sat_solver_delete( p->pSat );
Gia_ManStopP( &p->pFrames );
ABC_FREE( p );
}
/**Function*************************************************************
Synopsis [Extends the solver.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_ManCofExtendSolver( Ccf_Man_t * p )
{
Gia_Obj_t * pObj;
int i;
// add SAT clauses
for ( i = sat_solver_nvars(p->pSat); i < Gia_ManObjNum(p->pFrames); i++ )
{
pObj = Gia_ManObj( p->pFrames, i );
if ( Gia_ObjIsAnd(pObj) )
sat_solver_add_and( p->pSat, i,
Gia_ObjFaninId0(pObj, i),
Gia_ObjFaninId1(pObj, i),
Gia_ObjFaninC0(pObj),
Gia_ObjFaninC1(pObj), 0 );
}
sat_solver_setnvars( p->pSat, Gia_ManObjNum(p->pFrames) );
}
static inline int Gia_Obj0Copy( Vec_Int_t * vCopies, int Fan0, int fCompl0 )
{ return Abc_LitNotCond( Vec_IntEntry(vCopies, Fan0), fCompl0 ); }
static inline int Gia_Obj1Copy( Vec_Int_t * vCopies, int Fan1, int fCompl1 )
{ return Abc_LitNotCond( Vec_IntEntry(vCopies, Fan1), fCompl1 ); }
/**Function*************************************************************
Synopsis [Cofactor the circuit w.r.t. the given assignment.]
Description [Assumes that the solver has just returned SAT.]
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_ManCofOneDerive_rec( Ccf_Man_t * p, int Id )
{
Gia_Obj_t * pObj;
int Res;
if ( Vec_IntEntry(p->vCopies, Id) != -1 )
return;
pObj = Gia_ManObj(p->pFrames, Id);
assert( Gia_ObjIsCi(pObj) || Gia_ObjIsAnd(pObj) );
if ( Gia_ObjIsAnd(pObj) )
{
int fCompl0 = Gia_ObjFaninC0(pObj);
int fCompl1 = Gia_ObjFaninC1(pObj);
int Fan0 = Gia_ObjFaninId0p(p->pFrames, pObj);
int Fan1 = Gia_ObjFaninId1p(p->pFrames, pObj);
Gia_ManCofOneDerive_rec( p, Fan0 );
Gia_ManCofOneDerive_rec( p, Fan1 );
Res = Gia_ManHashAnd( p->pFrames,
Gia_Obj0Copy(p->vCopies, Fan0, fCompl0),
Gia_Obj1Copy(p->vCopies, Fan1, fCompl1) );
}
else if ( Gia_ObjCioId(pObj) >= Gia_ManRegNum(p->pGia) ) // PI
Res = sat_solver_var_value( p->pSat, Id );
else
Res = Abc_Var2Lit( Id, 0 );
Vec_IntWriteEntry( p->vCopies, Id, Res );
}
/**Function*************************************************************
Synopsis [Cofactor the circuit w.r.t. the given assignment.]
Description [Assumes that the solver has just returned SAT.]
SideEffects []
SeeAlso []
***********************************************************************/
int Gia_ManCofOneDerive( Ccf_Man_t * p, int LitProp )
{
int LitOut;
// derive the cofactor of the property node
Vec_IntFill( p->vCopies, Gia_ManObjNum(p->pFrames), -1 );
Gia_ManCofOneDerive_rec( p, Abc_Lit2Var(LitProp) );
LitOut = Vec_IntEntry( p->vCopies, Abc_Lit2Var(LitProp) );
LitOut = Abc_LitNotCond( LitOut, Abc_LitIsCompl(LitProp) );
// add new PO for the cofactor
Gia_ManAppendCo( p->pFrames, LitOut );
// add SAT clauses
Gia_ManCofExtendSolver( p );
// return negative literal of the cofactor
return Abc_LitNot(LitOut);
}
/**Function*************************************************************
Synopsis [Enumerates backward reachable states.]
Description [Return -1 if resource limit is reached. Returns 1
if computation converged (there is no more reachable states).
Returns 0 if no more states to enumerate.]
SideEffects []
SeeAlso []
***********************************************************************/
int Gia_ManCofGetReachable( Ccf_Man_t * p, int Lit )
{
int ObjPrev = 0, ConfPrev = 0;
int Count = 0, LitOut, RetValue;
abctime clk;
// try solving for the first time and quit if converged
RetValue = sat_solver_solve( p->pSat, &Lit, &Lit + 1, p->nConfMax, 0, 0, 0 );
if ( RetValue == l_False )
return 1;
// iterate circuit cofactoring
while ( RetValue == l_True )
{
clk = Abc_Clock();
// derive cofactor
LitOut = Gia_ManCofOneDerive( p, Lit );
// add the blocking clause
RetValue = sat_solver_addclause( p->pSat, &LitOut, &LitOut + 1 );
assert( RetValue );
// try solving again
RetValue = sat_solver_solve( p->pSat, &Lit, &Lit + 1, p->nConfMax, 0, 0, 0 );
// derive cofactors
if ( p->fVerbose )
{
printf( "%3d : AIG =%7d Conf =%7d. ", Count++,
Gia_ManObjNum(p->pFrames) - ObjPrev, sat_solver_nconflicts(p->pSat) - ConfPrev );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
ObjPrev = Gia_ManObjNum(p->pFrames);
ConfPrev = sat_solver_nconflicts(p->pSat);
}
}
if ( RetValue == l_Undef )
return -1;
return 0;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Gia_Man_t * Gia_ManCofTest( Gia_Man_t * pGia, int nFrameMax, int nConfMax, int nTimeMax, int fVerbose )
{
Gia_Man_t * pNew;
Ccf_Man_t * p;
Gia_Obj_t * pObj;
int f, i, Lit, RetValue = -1, fFailed = 0;
abctime nTimeToStop = Abc_Clock() + nTimeMax * CLOCKS_PER_SEC;
abctime clk = Abc_Clock();
assert( Gia_ManPoNum(pGia) == 1 );
// create reachability manager
p = Ccf_ManStart( pGia, nFrameMax, nConfMax, nTimeMax, fVerbose );
// set runtime limit
if ( nTimeMax )
sat_solver_set_runtime_limit( p->pSat, nTimeToStop );
// perform backward image computation
for ( f = 0; f < nFrameMax; f++ )
{
if ( fVerbose )
printf( "ITER %3d :\n", f );
// add to the mapping of nodes
p->pFrames = (Gia_Man_t *)Gia_ManUnrollAdd( p->pUnr, f+1 );
// add SAT clauses
Gia_ManCofExtendSolver( p );
// return output literal
Lit = Gia_ManUnrollLastLit( p->pUnr );
// derives cofactors of the property literal till all states are blocked
RetValue = Gia_ManCofGetReachable( p, Lit );
if ( RetValue )
break;
// check the property output
Gia_ManSetPhase( p->pFrames );
Gia_ManForEachPo( p->pFrames, pObj, i )
if ( pObj->fPhase )
{
printf( "Property failed in frame %d.\n", f );
fFailed = 1;
break;
}
if ( i < Gia_ManPoNum(p->pFrames) )
break;
}
// report the result
if ( nTimeToStop && Abc_Clock() > nTimeToStop )
printf( "Runtime limit (%d sec) is reached after %d frames. ", nTimeMax, f );
else if ( f == nFrameMax )
printf( "Completed %d frames without converging. ", f );
else if ( RetValue == 1 )
printf( "Backward reachability converged after %d iterations. ", f-1 );
else if ( RetValue == -1 )
printf( "Conflict limit or timeout is reached after %d frames. ", f-1 );
Abc_PrintTime( 1, "Runtime", Abc_Clock() - clk );
if ( !fFailed && RetValue == 1 )
printf( "Property holds.\n" );
else if ( !fFailed )
printf( "Property is undecided.\n" );
// get the resulting AIG manager
Gia_ManHashStop( p->pFrames );
pNew = p->pFrames; p->pFrames = NULL;
Ccf_ManStop( p );
// cleanup
// if ( fVerbose )
// Gia_ManPrintStats( pNew, 0 );
pNew = Gia_ManCleanup( pGia = pNew );
Gia_ManStop( pGia );
// if ( fVerbose )
// Gia_ManPrintStats( pNew, 0 );
return pNew;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
|
//
// ZHYLoginRegisterController.h
// BSBDJ
//
// Created by MitnickKevin on 16/5/20.
// Copyright © 2016年 SWUST. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface ZHYLoginRegisterController : UIViewController
@end
|
/* Copyright (c) 2018 Griefer@Work *
* *
* This software is provided 'as-is', without any express or implied *
* warranty. In no event will the authors be held liable for any damages *
* arising from the use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not *
* claim that you wrote the original software. If you use this software *
* in a product, an acknowledgement in the product documentation would be *
* appreciated but is not required. *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* 3. This notice may not be removed or altered from any source distribution. *
*/
#ifndef _PARTS_KOS2_STRING_H
#define _PARTS_KOS2_STRING_H 1
#include <__stdinc.h>
#include "malldefs.h"
#include <features.h>
#include <hybrid/typecore.h>
#include <libc/string.h>
#include <xlocale.h>
#include <bits/types.h>
#ifdef __OPTIMIZE_LIBC__
#include <asm-generic/string.h>
#endif
__SYSDECL_BEGIN
#ifndef __size_t_defined
#define __size_t_defined 1
typedef __SIZE_TYPE__ size_t;
#endif
#if !defined(__CRT_KOS) && \
(defined(__CYG_COMPAT__) || defined(__GLC_COMPAT__))
/* GLibC/Cygwin compatibility (NOTE: Doesn't work in KOS) */
__LOCAL __WUNUSED __ATTR_CONST char const *(__LIBCCALL strerror_s)(int __errnum) {
#ifndef ___sys_errlist_defined
__LIBC char const *const _sys_errlist[]; __LIBC int _sys_nerr;
#endif
return (unsigned int)__errnum < (unsigned int)_sys_nerr ? _sys_errlist[__errnum] : __NULLPTR;
}
#elif !defined(__CRT_KOS) && defined(__DOS_COMPAT__)
/* DOS/MSVcrt compatibility (NOTE: Doesn't work in KOS) */
#ifndef __int___sys_errlist_defined
#define __int___sys_errlist_defined 1
__NAMESPACE_INT_BEGIN
__LIBC __WUNUSED __ATTR_CONST char **(__LIBCCALL __sys_errlist)(void);
__LIBC __WUNUSED __ATTR_CONST int *(__LIBCCALL __sys_nerr)(void);
__NAMESPACE_INT_END
#endif /* !__int___sys_errlist_defined */
__LOCAL __WUNUSED __ATTR_CONST char const *(__LIBCCALL strerror_s)(int __errnum) {
return (unsigned int)__errnum < (unsigned int)*(__NAMESPACE_INT_SYM __sys_nerr)() ?
(__NAMESPACE_INT_SYM __sys_errlist)()[__errnum] : __NULLPTR;
}
#else
/* KOS direct function implementation. */
__LIBC __WUNUSED __ATTR_CONST char const *(__LIBCCALL strerror_s)(int __errnum);
#endif
#if defined(__CRT_KOS) && !defined(__CYG_COMPAT__) && \
!defined(__GLC_COMPAT__) && !defined(__DOS_COMPAT__)
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_CONST char const *(__LIBCCALL strerrorname_s)(int __errnum);
#endif /* ... */
#ifndef __local_memset
#ifdef __OPTIMIZE_LIBC__
#define __local_memset(dst,byte,n_bytes) __opt_memset(dst,byte,n_bytes)
#define __local_memcmp(a,b,n_bytes) __opt_memcmp(a,b,n_bytes)
#define __local_memcpy(dst,src,n_bytes) __opt_memcpy(dst,src,n_bytes)
#define __local_memmove(dst,src,n_bytes) __opt_memmove(dst,src,n_bytes)
#define __local_mempcpy(dst,src,n_bytes) __opt_mempcpy(dst,src,n_bytes)
#define __local_memchr(haystack,needle,n_bytes) __opt_memchr(haystack,needle,n_bytes)
#define __local_memrchr(haystack,needle,n_bytes) __opt_memrchr(haystack,needle,n_bytes)
#define __local_memend(haystack,needle,n_bytes) __opt_memend(haystack,needle,n_bytes)
#define __local_memrend(haystack,needle,n_bytes) __opt_memrend(haystack,needle,n_bytes)
#define __local_rawmemchr(haystack,needle) __opt_rawmemchr(haystack,needle)
#define __local_rawmemrchr(haystack,needle) __opt_rawmemrchr(haystack,needle)
#define __local_memlen(haystack,needle,n_bytes) __opt_memlen(haystack,needle,n_bytes)
#define __local_memrlen(haystack,needle,n_bytes) __opt_memrlen(haystack,needle,n_bytes)
#define __local_rawmemlen(haystack,needle) __opt_rawmemlen(haystack,needle)
#define __local_rawmemrlen(haystack,needle) __opt_rawmemrlen(haystack,needle)
#else /* __OPTIMIZE_LIBC__ */
#define __local_memset(dst,byte,n_bytes) __libc_memset(dst,byte,n_bytes)
#define __local_memcmp(a,b,n_bytes) __libc_memcmp(a,b,n_bytes)
#define __local_memcpy(dst,src,n_bytes) __libc_memcpy(dst,src,n_bytes)
#define __local_memmove(dst,src,n_bytes) __libc_memmove(dst,src,n_bytes)
#define __local_mempcpy(dst,src,n_bytes) __libc_mempcpy(dst,src,n_bytes)
#define __local_memchr(haystack,needle,n_bytes) __libc_memchr(haystack,needle,n_bytes)
#define __local_memrchr(haystack,needle,n_bytes) __libc_memrchr(haystack,needle,n_bytes)
#define __local_memend(haystack,needle,n_bytes) __libc_memend(haystack,needle,n_bytes)
#define __local_memrend(haystack,needle,n_bytes) __libc_memrend(haystack,needle,n_bytes)
#define __local_rawmemchr(haystack,needle) __libc_rawmemchr(haystack,needle)
#define __local_rawmemrchr(haystack,needle) __libc_rawmemrchr(haystack,needle)
#define __local_memlen(haystack,needle,n_bytes) __libc_memlen(haystack,needle,n_bytes)
#define __local_memrlen(haystack,needle,n_bytes) __libc_memrlen(haystack,needle,n_bytes)
#define __local_rawmemlen(haystack,needle) __libc_rawmemlen(haystack,needle)
#define __local_rawmemrlen(haystack,needle) __libc_rawmemrlen(haystack,needle)
#endif /* !__OPTIMIZE_LIBC__ */
#endif /* !__local_memset */
#ifdef __OPTIMIZE_LIBC__
#define __local_memsetw(dst,word,n_words) __opt_memsetw(dst,word,n_words)
#define __local_memsetl(dst,dword,n_dwords) __opt_memsetl(dst,dword,n_dwords)
#define __local_memsetq(dst,qword,n_qwords) __opt_memsetq(dst,qword,n_qwords)
#define __local_memcmpw(a,b,n_words) __opt_memcmpw(a,b,n_words)
#define __local_memcmpl(a,b,n_dwords) __opt_memcmpl(a,b,n_dwords)
#define __local_memcmpq(a,b,n_qwords) __opt_memcmpq(a,b,n_qwords)
#define __local_memcpyw(dst,src,n_words) __opt_memcpyw(dst,src,n_words)
#define __local_memcpyl(dst,src,n_dwords) __opt_memcpyl(dst,src,n_dwords)
#define __local_memcpyq(dst,src,n_qwords) __opt_memcpyq(dst,src,n_qwords)
#define __local_memmovew(dst,src,n_words) __opt_memmovew(dst,src,n_words)
#define __local_memmovel(dst,src,n_dwords) __opt_memmovel(dst,src,n_dwords)
#define __local_memmoveq(dst,src,n_qwords) __opt_memmoveq(dst,src,n_qwords)
#define __local_mempcpyw(dst,src,n_words) __opt_mempcpyw(dst,src,n_words)
#define __local_mempcpyl(dst,src,n_dwords) __opt_mempcpyl(dst,src,n_dwords)
#define __local_mempcpyq(dst,src,n_qwords) __opt_mempcpyq(dst,src,n_qwords)
#define __local_memchrw(haystack,needle,n_words) __opt_memchrw(haystack,needle,n_words)
#define __local_memchrl(haystack,needle,n_dwords) __opt_memchrl(haystack,needle,n_dwords)
#define __local_memchrq(haystack,needle,n_qwords) __opt_memchrq(haystack,needle,n_qwords)
#define __local_memrchrw(haystack,needle,n_words) __opt_memrchrw(haystack,needle,n_words)
#define __local_memrchrl(haystack,needle,n_dwords) __opt_memrchrl(haystack,needle,n_dwords)
#define __local_memrchrq(haystack,needle,n_qwords) __opt_memrchrq(haystack,needle,n_qwords)
#define __local_memendw(haystack,needle,n_words) __opt_memendw(haystack,needle,n_words)
#define __local_memendl(haystack,needle,n_dwords) __opt_memendl(haystack,needle,n_dwords)
#define __local_memendq(haystack,needle,n_qwords) __opt_memendq(haystack,needle,n_qwords)
#define __local_memrendw(haystack,needle,n_words) __opt_memrendw(haystack,needle,n_words)
#define __local_memrendl(haystack,needle,n_dwords) __opt_memrendl(haystack,needle,n_dwords)
#define __local_memrendq(haystack,needle,n_qwords) __opt_memrendq(haystack,needle,n_qwords)
#define __local_rawmemchrw(haystack,needle) __opt_rawmemchrw(haystack,needle)
#define __local_rawmemchrl(haystack,needle) __opt_rawmemchrl(haystack,needle)
#define __local_rawmemchrq(haystack,needle) __opt_rawmemchrq(haystack,needle)
#define __local_rawmemrchrw(haystack,needle) __opt_rawmemrchrw(haystack,needle)
#define __local_rawmemrchrl(haystack,needle) __opt_rawmemrchrl(haystack,needle)
#define __local_rawmemrchrq(haystack,needle) __opt_rawmemrchrq(haystack,needle)
#define __local_memlenw(haystack,needle,n_words) __opt_memlenw(haystack,needle,n_words)
#define __local_memlenl(haystack,needle,n_dwords) __opt_memlenl(haystack,needle,n_dwords)
#define __local_memlenq(haystack,needle,n_qwords) __opt_memlenq(haystack,needle,n_qwords)
#define __local_memrlenw(haystack,needle,n_words) __opt_memrlenw(haystack,needle,n_words)
#define __local_memrlenl(haystack,needle,n_dwords) __opt_memrlenl(haystack,needle,n_dwords)
#define __local_memrlenq(haystack,needle,n_qwords) __opt_memrlenq(haystack,needle,n_qwords)
#define __local_rawmemlenw(haystack,needle) __opt_rawmemlenw(haystack,needle)
#define __local_rawmemlenl(haystack,needle) __opt_rawmemlenl(haystack,needle)
#define __local_rawmemlenq(haystack,needle) __opt_rawmemlenq(haystack,needle)
#define __local_rawmemrlenw(haystack,needle) __opt_rawmemrlenw(haystack,needle)
#define __local_rawmemrlenl(haystack,needle) __opt_rawmemrlenl(haystack,needle)
#define __local_rawmemrlenq(haystack,needle) __opt_rawmemrlenq(haystack,needle)
#else /* __OPTIMIZE_LIBC__ */
#define __local_memsetw(dst,word,n_words) __libc_memsetw(dst,word,n_words)
#define __local_memsetl(dst,dword,n_dwords) __libc_memsetl(dst,dword,n_dwords)
#define __local_memsetq(dst,qword,n_qwords) __libc_memsetq(dst,qword,n_qwords)
#define __local_memcmpw(a,b,n_words) __libc_memcmpw(a,b,n_words)
#define __local_memcmpl(a,b,n_dwords) __libc_memcmpl(a,b,n_dwords)
#define __local_memcmpq(a,b,n_qwords) __libc_memcmpq(a,b,n_qwords)
#define __local_memcpyw(dst,src,n_words) __libc_memcpyw(dst,src,n_words)
#define __local_memcpyl(dst,src,n_dwords) __libc_memcpyl(dst,src,n_dwords)
#define __local_memcpyq(dst,src,n_qwords) __libc_memcpyq(dst,src,n_qwords)
#define __local_memmovew(dst,src,n_words) __libc_memmovew(dst,src,n_words)
#define __local_memmovel(dst,src,n_dwords) __libc_memmovel(dst,src,n_dwords)
#define __local_memmoveq(dst,src,n_qwords) __libc_memmoveq(dst,src,n_qwords)
#define __local_mempcpyw(dst,src,n_words) __libc_mempcpyw(dst,src,n_words)
#define __local_mempcpyl(dst,src,n_dwords) __libc_mempcpyl(dst,src,n_dwords)
#define __local_mempcpyq(dst,src,n_qwords) __libc_mempcpyq(dst,src,n_qwords)
#define __local_memchrw(haystack,needle,n_words) __libc_memchrw(haystack,needle,n_words)
#define __local_memchrl(haystack,needle,n_dwords) __libc_memchrl(haystack,needle,n_dwords)
#define __local_memchrq(haystack,needle,n_qwords) __libc_memchrq(haystack,needle,n_qwords)
#define __local_memrchrw(haystack,needle,n_words) __libc_memrchrw(haystack,needle,n_words)
#define __local_memrchrl(haystack,needle,n_dwords) __libc_memrchrl(haystack,needle,n_dwords)
#define __local_memrchrq(haystack,needle,n_qwords) __libc_memrchrq(haystack,needle,n_qwords)
#define __local_memendw(haystack,needle,n_words) __libc_memendw(haystack,needle,n_words)
#define __local_memendl(haystack,needle,n_dwords) __libc_memendl(haystack,needle,n_dwords)
#define __local_memendq(haystack,needle,n_qwords) __libc_memendq(haystack,needle,n_qwords)
#define __local_memrendw(haystack,needle,n_words) __libc_memrendw(haystack,needle,n_words)
#define __local_memrendl(haystack,needle,n_dwords) __libc_memrendl(haystack,needle,n_dwords)
#define __local_memrendq(haystack,needle,n_qwords) __libc_memrendq(haystack,needle,n_qwords)
#define __local_rawmemchrw(haystack,needle) __libc_rawmemchrw(haystack,needle)
#define __local_rawmemchrl(haystack,needle) __libc_rawmemchrl(haystack,needle)
#define __local_rawmemchrq(haystack,needle) __libc_rawmemchrq(haystack,needle)
#define __local_rawmemrchrw(haystack,needle) __libc_rawmemrchrw(haystack,needle)
#define __local_rawmemrchrl(haystack,needle) __libc_rawmemrchrl(haystack,needle)
#define __local_rawmemrchrq(haystack,needle) __libc_rawmemrchrq(haystack,needle)
#define __local_memlenw(haystack,needle,n_words) __libc_memlenw(haystack,needle,n_words)
#define __local_memlenl(haystack,needle,n_dwords) __libc_memlenl(haystack,needle,n_dwords)
#define __local_memlenq(haystack,needle,n_qwords) __libc_memlenq(haystack,needle,n_qwords)
#define __local_memrlenw(haystack,needle,n_words) __libc_memrlenw(haystack,needle,n_words)
#define __local_memrlenl(haystack,needle,n_dwords) __libc_memrlenl(haystack,needle,n_dwords)
#define __local_memrlenq(haystack,needle,n_qwords) __libc_memrlenq(haystack,needle,n_qwords)
#define __local_rawmemlenw(haystack,needle) __libc_rawmemlenw(haystack,needle)
#define __local_rawmemlenl(haystack,needle) __libc_rawmemlenl(haystack,needle)
#define __local_rawmemlenq(haystack,needle) __libc_rawmemlenq(haystack,needle)
#define __local_rawmemrlenw(haystack,needle) __libc_rawmemrlenw(haystack,needle)
#define __local_rawmemrlenl(haystack,needle) __libc_rawmemrlenl(haystack,needle)
#define __local_rawmemrlenq(haystack,needle) __libc_rawmemrlenq(haystack,needle)
#endif /* !__OPTIMIZE_LIBC__ */
/* KOS String extensions. */
#if defined(__OPTIMIZE_LIBC__) || !defined(__CRT_KOS) || \
(defined(__DOS_COMPAT__) || defined(__GLC_COMPAT__))
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlen)(void const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memlen(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlen)(void const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memrlen(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlen)(void const *__restrict __haystack, int __needle) { return __local_rawmemlen(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlen)(void const *__restrict __haystack, int __needle) { return __local_rawmemrlen(__haystack,__needle); }
#else
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlen)(void const *__restrict __haystack, int __needle, size_t __n_bytes);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlen)(void const *__restrict __haystack, int __needle, size_t __n_bytes);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlen)(void const *__restrict __haystack, int __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlen)(void const *__restrict __haystack, int __needle);
#endif
#if !defined(__CRT_KOS) || defined(__DOS_COMPAT__) || \
defined(__GLC_COMPAT__) || defined(__CYG_COMPAT__)
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL stroff)(char const *__restrict __haystack, int __needle) { return __libc_stroff(__haystack,__needle); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL strroff)(char const *__restrict __haystack, int __needle) { return __libc_strroff(__haystack,__needle); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL strnoff)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnoff(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL strnroff)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnroff(__haystack,__needle,__max_chars); }
#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
extern "C++" {
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strend)(char *__restrict __str) { return __libc_strend(__str); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char const *(__LIBCCALL strend)(char const *__restrict __str) { return __libc_strend(__str); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnend)(char *__restrict __str, size_t __max_chars) { return __libc_strnend(__str,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char const *(__LIBCCALL strnend)(char const *__restrict __str, size_t __max_chars) { return __libc_strnend(__str,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strrchrnul)(char *__restrict __haystack, int __needle) { return __libc_strrchrnul(__haystack,__needle); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char const *(__LIBCCALL strrchrnul)(char const *__restrict __haystack, int __needle) { return __libc_strrchrnul(__haystack,__needle); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) char *(__LIBCCALL strnchr)(char *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnchr(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) char const *(__LIBCCALL strnchr)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnchr(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) char *(__LIBCCALL strnrchr)(char *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnrchr(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) char const *(__LIBCCALL strnrchr)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnrchr(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnchrnul)(char *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnchrnul(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char const *(__LIBCCALL strnchrnul)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnchrnul(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnrchrnul)(char *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnrchrnul(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char const *(__LIBCCALL strnrchrnul)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnrchrnul(__haystack,__needle,__max_chars); }
}
#else /* __CORRECT_ISO_CPP_STRING_H_PROTO */
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strend)(char const *__str) { return __libc_strend(__str); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnend)(char const *__str, size_t __max_chars) { return __libc_strnend(__str,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strrchrnul)(char const *__restrict __haystack, int __needle) { return __libc_strrchrnul(__haystack,__needle); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) char *(__LIBCCALL strnchr)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnchr(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) char *(__LIBCCALL strnrchr)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnrchr(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnchrnul)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnchrnul(__haystack,__needle,__max_chars); }
__LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnrchrnul)(char const *__restrict __haystack, int __needle, size_t __max_chars) { return __libc_strnrchrnul(__haystack,__needle,__max_chars); }
#endif /* !__CORRECT_ISO_CPP_STRING_H_PROTO */
#else /* Emulate extensions... */
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL stroff)(char const *__restrict __haystack, int __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL strroff)(char const *__restrict __haystack, int __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL strnoff)(char const *__restrict __haystack, int __needle, size_t __max_chars);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL strnroff)(char const *__restrict __haystack, int __needle, size_t __max_chars);
#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
extern "C++" {
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strend,(char *__restrict __str),strend,(__str))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char const *,__LIBCCALL,strend,(char const *__restrict __str),strend,(__str))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strnend,(char *__restrict __str, size_t __max_chars),strnend,(__str,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char const *,__LIBCCALL,strnend,(char const *__restrict __str, size_t __max_chars),strnend,(__str,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strrchrnul,(char *__restrict __haystack, int __needle),strrchrnul,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char const *,__LIBCCALL,strrchrnul,(char const *__restrict __haystack, int __needle),strrchrnul,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),char *,__LIBCCALL,strnchr,(char *__restrict __haystack, int __needle, size_t __max_chars),strnchr,(__haystack,__needle,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),char const *,__LIBCCALL,strnchr,(char const *__restrict __haystack, int __needle, size_t __max_chars),strnchr,(__haystack,__needle,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),char *,__LIBCCALL,strnrchr,(char *__restrict __haystack, int __needle, size_t __max_chars),strnrchr,(__haystack,__needle,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),char const *,__LIBCCALL,strnrchr,(char const *__restrict __haystack, int __needle, size_t __max_chars),strnrchr,(__haystack,__needle,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strnchrnul,(char *__restrict __haystack, int __needle, size_t __max_chars),strnchrnul,(__haystack,__needle,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char const *,__LIBCCALL,strnchrnul,(char const *__restrict __haystack, int __needle, size_t __max_chars),strnchrnul,(__haystack,__needle,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strnrchrnul,(char *__restrict __haystack, int __needle, size_t __max_chars),strnrchrnul,(__haystack,__needle,__max_chars))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),char const *,__LIBCCALL,strnrchrnul,(char const *__restrict __haystack, int __needle, size_t __max_chars),strnrchrnul,(__haystack,__needle,__max_chars))
}
#else /* __CORRECT_ISO_CPP_STRING_H_PROTO */
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strend)(char const *__restrict __str);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnend)(char const *__restrict __str, size_t __max_chars);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strrchrnul)(char const *__restrict __haystack, int __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) char *(__LIBCCALL strnchr)(char const *__restrict __haystack, int __needle, size_t __max_chars);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) char *(__LIBCCALL strnrchr)(char const *__restrict __haystack, int __needle, size_t __max_chars);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnchrnul)(char const *__restrict __haystack, int __needle, size_t __max_chars);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL strnrchrnul)(char const *__restrict __haystack, int __needle, size_t __max_chars);
#endif /* !__CORRECT_ISO_CPP_STRING_H_PROTO */
#endif /* !Emulate extensions... */
#if defined(__OPTIMIZE_LIBC__) || !defined(__CRT_KOS) || \
defined(__DOS_COMPAT__) || defined(__GLC_COMPAT__)
#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
extern "C++" {
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL rawmemrchr)(void *__restrict __haystack, int __needle) { return __local_rawmemrchr(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void const *(__LIBCCALL rawmemrchr)(void const *__restrict __haystack, int __needle) { return __local_rawmemrchr(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memend)(void *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void const *(__LIBCCALL memend)(void const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memrend)(void *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memrend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void const *(__LIBCCALL memrend)(void const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memrend(__haystack,__needle,__n_bytes); }
}
#else /* __CORRECT_ISO_CPP_STRING_H_PROTO */
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL rawmemrchr)(void const *__restrict __haystack, int __needle) { return __local_rawmemrchr(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memend)(void const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memrend)(void const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memrend(__haystack,__needle,__n_bytes); }
#endif /* !__CORRECT_ISO_CPP_STRING_H_PROTO */
#else /* Emulate extensions... */
#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
extern "C++" {
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),void *,__LIBCCALL,rawmemrchr,(void *__restrict __haystack, int __needle),rawmemrchr,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),void const *,__LIBCCALL,rawmemrchr,(void const *__restrict __haystack, int __needle),rawmemrchr,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),void *,__LIBCCALL,memend,(void *__restrict __haystack, int __needle, size_t __n_bytes),memend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),void const *,__LIBCCALL,memend,(void const *__restrict __haystack, int __needle, size_t __n_bytes),memend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),void *,__LIBCCALL,memrend,(void *__restrict __haystack, int __needle, size_t __n_bytes),memrend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),void const *,__LIBCCALL,memrend,(void const *__restrict __haystack, int __needle, size_t __n_bytes),memrend,(__haystack,__needle,__n_bytes))
}
#else /* __CORRECT_ISO_CPP_STRING_H_PROTO */
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL rawmemrchr)(void const *__restrict __haystack, int __needle);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memend)(void const *__restrict __haystack, int __needle, size_t __n_bytes);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memrend)(void const *__restrict __haystack, int __needle, size_t __n_bytes);
#endif /* !__CORRECT_ISO_CPP_STRING_H_PROTO */
#endif /* !Emulate extensions... */
#ifndef __KERNEL__
#if defined(__CRT_GLC) && defined(__GLC_COMPAT__)
/* Implement using `asprintf' */
__REDIRECT(__LIBC,,__ssize_t,__LIBCCALL,__libc_vasprintf,(char **__restrict __pstr, char const *__restrict __format, __builtin_va_list __args),vasprintf,(__ptr,__format,__args))
__LOCAL __ATTR_LIBC_PRINTF(1,0) __WUNUSED __MALL_DEFAULT_ALIGNED __ATTR_MALLOC
char *(__LIBCCALL vstrdupf)(char const *__restrict __format, __builtin_va_list __args) {
char *__result;
return __libc_vasprintf(&__result,__format,__args) >= 0 ? __result : 0;
}
__LOCAL __ATTR_LIBC_PRINTF(1,2) __WUNUSED __MALL_DEFAULT_ALIGNED __ATTR_MALLOC
char *(__ATTR_CDECL strdupf)(char const *__restrict __format, ...) {
char *__result; __builtin_va_list __args; __builtin_va_start(__args,__format);
__result = vstrdupf(__format,__args);
__builtin_va_end(__args);
return __result;
}
#elif defined(__CRT_DOS) && defined(__DOS_COMPAT__)
/* Implement using scprintf()+malloc()+sprintf() */
__SYSDECL_END
#include "hybrid/malloc.h"
__SYSDECL_BEGIN
#ifndef ____dos_vscprintf_defined
#define ____dos_vscprintf_defined 1
__REDIRECT(__LIBC,,int,__LIBCCALL,__dos_vscprintf,(char const *__restrict __format, __builtin_va_list __args),_vscprintf,(__format,__args))
#endif /* !____dos_vsnprintf_defined */
#ifndef ____libc_vsprintf_defined
#define ____libc_vsprintf_defined 1
__REDIRECT(__LIBC,,int,__LIBCCALL,__libc_vsprintf,(char *__restrict __buf, char const *__restrict __format, __builtin_va_list __args),vsprintf,(__buf,__format,__args))
#endif /* !____libc_vsprintf_defined */
__LOCAL __ATTR_LIBC_PRINTF(1,0) __WUNUSED __MALL_DEFAULT_ALIGNED __ATTR_MALLOC
char *(__LIBCCALL vstrdupf)(char const *__restrict __format, __builtin_va_list __args) {
int __resultlen = __dos_vscprintf(__format,__args);
char *__result = __resultlen >= 0 ? (char *)__hybrid_malloc((__resultlen+1)*sizeof(char)) : 0;
if (__result) __libc_vsprintf(__result,__format,__args);
return __result;
}
__LOCAL __ATTR_LIBC_PRINTF(1,2) __WUNUSED __MALL_DEFAULT_ALIGNED __ATTR_MALLOC
char *(__ATTR_CDECL strdupf)(char const *__restrict __format, ...) {
char *__result; __builtin_va_list __args; __builtin_va_start(__args,__format);
__result = vstrdupf(__format,__args);
__builtin_va_end(__args);
return __result;
}
#else /* ... */
/* Use actual functions exported from libc. */
__REDIRECT_EXCEPT(__LIBC,__XATTR_RETNONNULL __ATTR_LIBC_PRINTF(1,0) __WUNUSED __MALL_DEFAULT_ALIGNED __ATTR_MALLOC,char *,__LIBCCALL,
vstrdupf,(char const *__restrict __format, __builtin_va_list __args),(__format,__args))
__VREDIRECT_EXCEPT(__LIBC,__XATTR_RETNONNULL __ATTR_LIBC_PRINTF(1,2) __WUNUSED __MALL_DEFAULT_ALIGNED __ATTR_MALLOC,char *,
__ATTR_CDECL,strdupf,(char const *__restrict __format, ...),vstrdupf,(__format),__format)
#endif /* !... */
#endif /* !__KERNEL__ */
/* byte/word/dword-wise string operations. */
#ifndef __OPTIMIZE_LIBC__
__REDIRECT(__LIBC,__ATTR_RETNONNULL __NONNULL((1,2)),void *,__LIBCCALL,memcpyb,(void *__restrict __dst, void const *__restrict __src, size_t __n_bytes),memcpy,(__dst,__src,__n_bytes))
__REDIRECT(__LIBC,__ATTR_RETNONNULL __NONNULL((1)) ,void *,__LIBCCALL,memsetb,(void *__restrict __dst, int __byte, size_t __n_bytes),memset,(__dst,__byte,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1,2)),int ,__LIBCCALL,memcmpb,(void const *__a, void const *__b, size_t __n_bytes),memcmp,(__a,__b,__n_bytes))
__REDIRECT(__LIBC,__ATTR_RETNONNULL __NONNULL((1,2)),void *,__LIBCCALL,memmoveb,(void *__dst, void const *__src, size_t __n_bytes),memmove,(__dst,__src,__n_bytes))
#else
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memcpyb)(void *__restrict __dst, void const *__restrict __src, size_t __n_bytes) { return __local_memcpy(__dst,__src,__n_bytes); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memsetb)(void *__restrict __dst, int __byte, size_t __n_bytes) { return __local_memset(__dst,__byte,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcmpb)(void const *__a, void const *__b, size_t __n_bytes) { return __local_memcmp(__a,__b,__n_bytes); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memmoveb)(void *__dst, void const *__src, size_t __n_bytes) { return __local_memmove(__dst,__src,__n_bytes); }
#endif
#if defined(__CRT_KOS) && \
(!defined(__DOS_COMPAT__) && !defined(__GLC_COMPAT__))
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memcpyw)(void *__restrict __dst, void const *__restrict __src, size_t __n_words);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memcpyl)(void *__restrict __dst, void const *__restrict __src, size_t __n_dwords);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memcpyq)(void *__restrict __dst, void const *__restrict __src, size_t __n_qwords);
__LIBC __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memsetw)(void *__restrict __dst, __UINT16_TYPE__ __word, size_t __n_words);
__LIBC __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memsetl)(void *__restrict __dst, __UINT32_TYPE__ __dword, size_t __n_dwords);
__LIBC __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memsetq)(void *__restrict __dst, __UINT64_TYPE__ __qword, size_t __n_qwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcmpw)(void const *__a, void const *__b, size_t __n_words);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcmpl)(void const *__a, void const *__b, size_t __n_dwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcmpq)(void const *__a, void const *__b, size_t __n_qwords);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memmovew)(void *__dst, void const *__src, size_t __n_words);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memmovel)(void *__dst, void const *__src, size_t __n_dwords);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memmoveq)(void *__dst, void const *__src, size_t __n_qwords);
#ifdef __USE_GNU
__REDIRECT(__LIBC,__ATTR_RETNONNULL __NONNULL((1,2)),void *,__LIBCCALL,mempcpyb,(void *__restrict __dst, void const *__restrict __src, size_t __n_bytes),mempcpy,(__dst,__src,__n_bytes))
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL mempcpyw)(void *__restrict __dst, void const *__restrict __src, size_t __n_words);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL mempcpyl)(void *__restrict __dst, void const *__restrict __src, size_t __n_dwords);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL mempcpyq)(void *__restrict __dst, void const *__restrict __src, size_t __n_qwords);
#endif /* __USE_GNU */
#else /* Builtin... */
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memcpyw)(void *__restrict __dst, void const *__restrict __src, size_t __n_words) { return __local_memcpyw(__dst,__src,__n_words); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memcpyl)(void *__restrict __dst, void const *__restrict __src, size_t __n_dwords) { return __local_memcpyl(__dst,__src,__n_dwords); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memcpyq)(void *__restrict __dst, void const *__restrict __src, size_t __n_qwords) { return __local_memcpyq(__dst,__src,__n_qwords); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memsetw)(void *__restrict __dst, __UINT16_TYPE__ __word, size_t __n_words) { return __local_memsetw(__dst,__word,__n_words); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memsetl)(void *__restrict __dst, __UINT32_TYPE__ __dword, size_t __n_dwords) { return __local_memsetl(__dst,__dword,__n_dwords); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL memsetq)(void *__restrict __dst, __UINT64_TYPE__ __qword, size_t __n_qwords) { return __local_memsetq(__dst,__qword,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcmpw)(void const *__a, void const *__b, size_t __n_words) { return __local_memcmpw(__a,__b,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcmpl)(void const *__a, void const *__b, size_t __n_dwords) { return __local_memcmpl(__a,__b,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcmpq)(void const *__a, void const *__b, size_t __n_qwords) { return __local_memcmpq(__a,__b,__n_qwords); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memmovew)(void *__dst, void const *__src, size_t __n_words) { return __local_memmovew(__dst,__src,__n_words); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memmovel)(void *__dst, void const *__src, size_t __n_dwords) { return __local_memmovel(__dst,__src,__n_dwords); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL memmoveq)(void *__dst, void const *__src, size_t __n_qwords) { return __local_memmoveq(__dst,__src,__n_qwords); }
#ifdef __USE_GNU
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL mempcpyb)(void *__restrict __dst, void const *__restrict __src, size_t __n_bytes) { return __local_mempcpy(__dst,__src,__n_bytes); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL mempcpyw)(void *__restrict __dst, void const *__restrict __src, size_t __n_words) { return __local_mempcpyw(__dst,__src,__n_words); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL mempcpyl)(void *__restrict __dst, void const *__restrict __src, size_t __n_dwords) { return __local_mempcpyl(__dst,__src,__n_dwords); }
__OPT_LOCAL __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL mempcpyq)(void *__restrict __dst, void const *__restrict __src, size_t __n_qwords) { return __local_mempcpyq(__dst,__src,__n_qwords); }
#endif /* __USE_GNU */
#endif /* Compat... */
/* Similar to memset(), but fill memory using the given pattern:
* >> mempatb(addr,0x12,7):
* Same as regular memset().
* >> mempatw(addr,0x12fd,7):
* addr&1 == 0: 12fd12fd12fd12
* addr&1 == 1: fd12fd12fd1212
* >> `*byte = (__pattern >> 8*((uintptr_t)byte & 0x2)) & 0xff;'
* >> mempatl(addr,0x12345678,11):
* addr&3 == 0: 12345678123
* addr&3 == 1: 34567812312
* addr&3 == 2: 56781231234
* addr&3 == 3: 78123123456
* >> `*byte = (__pattern >> 8*((uintptr_t)byte & 0x3)) & 0xff;'
* WARNING: PATTERN is encoded in host endian, meaning that
* byte-order is reversed on little-endian machines. */
__REDIRECT(__LIBC,__ATTR_RETNONNULL __NONNULL((1)),void *,__LIBCCALL,mempatb,(void *__restrict __dst, int __pattern, size_t __n_bytes),memset,(__dst,__pattern,__n_bytes))
#if defined(__CRT_KOS) && \
(!defined(__DOS_COMPAT__) && !defined(__GLC_COMPAT__))
__LIBC __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL mempatw)(void *__restrict __dst, __UINT16_TYPE__ __pattern, size_t __n_bytes);
__LIBC __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL mempatl)(void *__restrict __dst, __UINT32_TYPE__ __pattern, size_t __n_bytes);
__LIBC __ATTR_RETNONNULL __NONNULL((1)) void *(__LIBCCALL mempatq)(void *__restrict __dst, __UINT64_TYPE__ __pattern, size_t __n_bytes);
#else /* Builtin... */
__LOCAL __ATTR_RETNONNULL __NONNULL((1))
void *(__LIBCCALL mempatw)(void *__restrict __dst, __UINT16_TYPE__ __pattern, size_t __n_bytes) {
__BYTE_TYPE__ *__iter = (__BYTE_TYPE__ *)__dst;
if (__n_bytes && (__UINTPTR_TYPE__)__iter & 1) {
*__iter = ((__UINT8_TYPE__ *)&__pattern)[1];
++__iter,--__n_bytes;
}
memsetw(__iter,__pattern,__n_bytes/2);
__iter += __n_bytes,__n_bytes &= 1;
if (__n_bytes) *__iter = ((__UINT8_TYPE__ *)&__pattern)[0];
return __dst;
}
__LOCAL __ATTR_RETNONNULL __NONNULL((1))
void *(__LIBCCALL mempatl)(void *__restrict __dst, __UINT32_TYPE__ __pattern, size_t __n_bytes) {
__BYTE_TYPE__ *__iter = (__BYTE_TYPE__ *)__dst;
while (__n_bytes && (__UINTPTR_TYPE__)__iter & 3) {
*__iter = ((__UINT8_TYPE__ *)&__pattern)[(__UINTPTR_TYPE__)__iter & 3];
++__iter,--__n_bytes;
}
memsetl(__iter,__pattern,__n_bytes/4);
__iter += __n_bytes,__n_bytes &= 3;
while (__n_bytes) {
*__iter = ((__UINT8_TYPE__ *)&__pattern)[(__UINTPTR_TYPE__)__iter & 3];
++__iter,--__n_bytes;
}
return __dst;
}
__LOCAL __ATTR_RETNONNULL __NONNULL((1))
void *(__LIBCCALL mempatq)(void *__restrict __dst, __UINT64_TYPE__ __pattern, size_t __n_bytes) {
__BYTE_TYPE__ *__iter = (__BYTE_TYPE__ *)__dst;
while (__n_bytes && (__UINTPTR_TYPE__)__iter & 7) {
*__iter = ((__UINT8_TYPE__ *)&__pattern)[(__UINTPTR_TYPE__)__iter & 7];
++__iter,--__n_bytes;
}
memsetq(__iter,__pattern,__n_bytes/8);
__iter += __n_bytes,__n_bytes &= 7;
while (__n_bytes) {
*__iter = ((__UINT8_TYPE__ *)&__pattern)[(__UINTPTR_TYPE__)__iter & 7];
++__iter,--__n_bytes;
}
return __dst;
}
#endif /* Compat... */
#if !defined(__OPTIMIZE_LIBC__) && defined(__CRT_KOS) && \
(!defined(__DOS_COMPAT__) && !defined(__GLC_COMPAT__))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),size_t,__LIBCCALL,memlenb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memlen,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),size_t,__LIBCCALL,memrlenb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memrlen,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),size_t,__LIBCCALL,rawmemlenb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle),rawmemlen,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),size_t,__LIBCCALL,rawmemrlenb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle),rawmemrlen,(__haystack,__needle))
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle);
#else /* Builtin... */
/* Compatibility/optimized multibyte memory functions. */
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlenb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memlen(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlenb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return __local_memrlen(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlenb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle) { return __local_rawmemlen(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlenb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle) { return __local_rawmemrlen(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memlenw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memlenl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memlenq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memrlenw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memrlenl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL memrlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memrlenq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemlenw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemlenl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemlenq(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlenw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemrlenw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlenl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemrlenl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) size_t (__LIBCCALL rawmemrlenq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemrlenq(__haystack,__needle); }
#endif /* Compat... */
#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
extern "C++" {
#ifndef __OPTIMIZE_LIBC__
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memchrb,(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes),memchr,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT8_TYPE__ const *,__LIBCCALL,memchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memchr,(__haystack,__needle,__n_bytes))
#else /* !__OPTIMIZE_LIBC__ */
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memchrb)(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memchr(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT8_TYPE__ const *(__LIBCCALL memchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memchr(__haystack,__needle,__n_bytes); }
#endif /* __OPTIMIZE_LIBC__ */
#if !defined(__OPTIMIZE_LIBC__) && defined(__CRT_GLC) && !defined(__DOS_COMPAT__)
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memrchrb,(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes),memrchr,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT8_TYPE__ const *,__LIBCCALL,memrchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memrchr,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,rawmemchrb,(__UINT8_TYPE__ *__restrict __haystack, int __needle),rawmemchr,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ const *,__LIBCCALL,rawmemchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle),rawmemchr,(__haystack,__needle))
#else /* GLC... */
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memrchrb)(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memrchr(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT8_TYPE__ const *(__LIBCCALL memrchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memrchr(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL rawmemchrb)(__UINT8_TYPE__ *__restrict __haystack, int __needle) { return (__UINT8_TYPE__ *)__local_rawmemchr(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ const *(__LIBCCALL rawmemchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle) { return (__UINT8_TYPE__ *)__local_rawmemchr(__haystack,__needle); }
#endif /* !GLC... */
#if !defined(__OPTIMIZE_LIBC__) && defined(__CRT_KOS) && \
(!defined(__DOS_COMPAT__) && !defined(__GLC_COMPAT__))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT16_TYPE__ *,__LIBCCALL,memchrw,(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memchrw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT16_TYPE__ const *,__LIBCCALL,memchrw,(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memchrw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT32_TYPE__ *,__LIBCCALL,memchrl,(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memchrl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT32_TYPE__ const *,__LIBCCALL,memchrl,(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memchrl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT64_TYPE__ *,__LIBCCALL,memchrq,(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_dwords),memchrq,(__haystack,__needle,__n_qwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT64_TYPE__ const *,__LIBCCALL,memchrq,(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_dwords),memchrq,(__haystack,__needle,__n_qwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT16_TYPE__ *,__LIBCCALL,memrchrw,(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memrchrw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT16_TYPE__ const *,__LIBCCALL,memrchrw,(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memrchrw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT32_TYPE__ *,__LIBCCALL,memrchrl,(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memrchrl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT32_TYPE__ const *,__LIBCCALL,memrchrl,(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memrchrl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT64_TYPE__ *,__LIBCCALL,memrchrq,(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords),memrchrq,(__haystack,__needle,__n_qwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT64_TYPE__ const *,__LIBCCALL,memrchrq,(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords),memrchrq,(__haystack,__needle,__n_qwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ *,__LIBCCALL,rawmemchrw,(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle),rawmemchrw,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ const *,__LIBCCALL,rawmemchrw,(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle),rawmemchrw,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ *,__LIBCCALL,rawmemchrl,(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle),rawmemchrl,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ const *,__LIBCCALL,rawmemchrl,(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle),rawmemchrl,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ *,__LIBCCALL,rawmemchrq,(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle),rawmemchrq,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ const *,__LIBCCALL,rawmemchrq,(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle),rawmemchrq,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,rawmemrchrb,(__UINT8_TYPE__ *__restrict __haystack, int __needle),rawmemrchr,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ const *,__LIBCCALL,rawmemrchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle),rawmemrchr,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ *,__LIBCCALL,rawmemrchrw,(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle),rawmemrchrw,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ const *,__LIBCCALL,rawmemrchrw,(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle),rawmemrchrw,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ *,__LIBCCALL,rawmemrchrl,(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle),rawmemrchrl,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ const *,__LIBCCALL,rawmemrchrl,(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle),rawmemrchrl,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ *,__LIBCCALL,rawmemrchrq,(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle),rawmemrchrq,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ const *,__LIBCCALL,rawmemrchrq,(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle),rawmemrchrq,(__haystack,__needle))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memendb,(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes),memend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ const *,__LIBCCALL,memendb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ *,__LIBCCALL,memendw,(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memendw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ const *,__LIBCCALL,memendw,(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memendw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ *,__LIBCCALL,memendl,(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memendl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ const *,__LIBCCALL,memendl,(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memendl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ *,__LIBCCALL,memendq,(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords),memendq,(__haystack,__needle,__n_qwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ const *,__LIBCCALL,memendq,(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords),memendq,(__haystack,__needle,__n_qwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memrendb,(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes),memrend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ const *,__LIBCCALL,memrendb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memrend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ *,__LIBCCALL,memrendw,(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memrendw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT16_TYPE__ const *,__LIBCCALL,memrendw,(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words),memrendw,(__haystack,__needle,__n_words))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ *,__LIBCCALL,memrendl,(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memrendl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT32_TYPE__ const *,__LIBCCALL,memrendl,(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords),memrendl,(__haystack,__needle,__n_dwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ *,__LIBCCALL,memrendq,(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords),memrendq,(__haystack,__needle,__n_qwords))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT64_TYPE__ const *,__LIBCCALL,memrendq,(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords),memrendq,(__haystack,__needle,__n_qwords))
#else /* KOS... */
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memchrw)(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memchrw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ const *(__LIBCCALL memchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memchrw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memchrl)(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memchrl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ const *(__LIBCCALL memchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memchrl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memrchrw)(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memrchrw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ const *(__LIBCCALL memrchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memrchrw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memrchrl)(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memrchrl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ const *(__LIBCCALL memrchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memrchrl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL rawmemrchrb)(__UINT8_TYPE__ *__restrict __haystack, int __needle) { return (__UINT8_TYPE__ *)__local_rawmemrchr(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ const *(__LIBCCALL rawmemrchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle) { return (__UINT8_TYPE__ *)__local_rawmemrchr(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL rawmemchrw)(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemchrw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ const *(__LIBCCALL rawmemchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemchrw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL rawmemchrl)(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemchrl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ const *(__LIBCCALL rawmemchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemchrl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL rawmemrchrw)(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemrchrw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ const *(__LIBCCALL rawmemrchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemrchrw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL rawmemrchrl)(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemrchrl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ const *(__LIBCCALL rawmemrchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemrchrl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memendb)(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ const *(__LIBCCALL memendb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memrendb)(__UINT8_TYPE__ *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memrend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ const *(__LIBCCALL memrendb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memrend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memendw)(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memendw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ const *(__LIBCCALL memendw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memendw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memendl)(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memendl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ const *(__LIBCCALL memendl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memendl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memrendw)(__UINT16_TYPE__ *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memrendw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ const *(__LIBCCALL memrendw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memrendw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memrendl)(__UINT32_TYPE__ *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memrendl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ const *(__LIBCCALL memrendl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memrendl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memchrq)(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memchrq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ const *(__LIBCCALL memchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memchrq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memrchrq)(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memrchrq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ const *(__LIBCCALL memrchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memrchrq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL rawmemchrq)(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemchrq(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ const *(__LIBCCALL rawmemchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemchrq(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL rawmemrchrq)(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemrchrq(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ const *(__LIBCCALL rawmemrchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemrchrq(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memendq)(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memendq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ const *(__LIBCCALL memendq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memendq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memrendq)(__UINT64_TYPE__ *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memrendq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ const *(__LIBCCALL memrendq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memrendq(__haystack,__needle,__n_qwords); }
#endif /* !KOS... */
}
#else /* __CORRECT_ISO_CPP_STRING_H_PROTO */
#ifndef __OPTIMIZE_LIBC__
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memchr,(__haystack,__needle,__n_bytes))
#else /* !__OPTIMIZE_LIBC__ */
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memchr(__haystack,__needle,__n_bytes); }
#endif /* __OPTIMIZE_LIBC__ */
#if !defined(__OPTIMIZE_LIBC__) && defined(__CRT_GLC) && !defined(__DOS_COMPAT__)
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memrchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memrchr,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,rawmemchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle),rawmemchr,(__haystack,__needle))
#else /* GLC... */
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memrchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memrchr(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL rawmemchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle) { return (__UINT8_TYPE__ *)__local_rawmemchr(__haystack,__needle); }
#endif /* !GLC... */
#if !defined(__OPTIMIZE_LIBC__) && defined(__CRT_KOS) && \
(!defined(__DOS_COMPAT__) && !defined(__GLC_COMPAT__))
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memrchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memrchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords);
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memrchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL rawmemchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL rawmemchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL rawmemchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle);
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,rawmemrchrb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle),rawmemrchr,(__haystack,__needle))
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL rawmemrchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL rawmemrchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL rawmemrchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle);
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memendb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memend,(__haystack,__needle,__n_bytes))
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)),__UINT8_TYPE__ *,__LIBCCALL,memrendb,(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes),memrend,(__haystack,__needle,__n_bytes))
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memendw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memendl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memendq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memrendw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memrendl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords);
__LIBC __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memrendq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords);
#else
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memchrw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memchrl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memchrq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memrchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memrchrw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memrchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memrchrl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memrchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memrchrq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL rawmemrchrb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle) { return (__UINT8_TYPE__ *)__local_rawmemrchr(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL rawmemchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemchrw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL rawmemchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemchrl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL rawmemchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemchrq(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL rawmemrchrw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle) { return __local_rawmemrchrw(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL rawmemrchrl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle) { return __local_rawmemrchrl(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL rawmemrchrq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle) { return __local_rawmemrchrq(__haystack,__needle); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memendb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT8_TYPE__ *(__LIBCCALL memrendb)(__UINT8_TYPE__ const *__restrict __haystack, int __needle, size_t __n_bytes) { return (__UINT8_TYPE__ *)__local_memrend(__haystack,__needle,__n_bytes); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memendw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memendw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memendl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memendl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memendq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memendq(__haystack,__needle,__n_qwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT16_TYPE__ *(__LIBCCALL memrendw)(__UINT16_TYPE__ const *__restrict __haystack, __UINT16_TYPE__ __needle, size_t __n_words) { return __local_memrendw(__haystack,__needle,__n_words); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT32_TYPE__ *(__LIBCCALL memrendl)(__UINT32_TYPE__ const *__restrict __haystack, __UINT32_TYPE__ __needle, size_t __n_dwords) { return __local_memrendl(__haystack,__needle,__n_dwords); }
__OPT_LOCAL __WUNUSED __ATTR_PURE __ATTR_RETNONNULL __NONNULL((1)) __UINT64_TYPE__ *(__LIBCCALL memrendq)(__UINT64_TYPE__ const *__restrict __haystack, __UINT64_TYPE__ __needle, size_t __n_qwords) { return __local_memrendq(__haystack,__needle,__n_qwords); }
#endif
#endif /* !__CORRECT_ISO_CPP_STRING_H_PROTO */
#ifdef __CRT_KOS
/* Fuzzy string compare extensions.
* - Lower return values indicate more closely matching data.
* - ZERO(0) indicates perfectly matching data. */
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,2)) size_t (__LIBCCALL fuzzy_strcmp)(char const *__a, char const *__b);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,3)) size_t (__LIBCCALL fuzzy_memcmp)(void const *__a, size_t __a_bytes, void const *__b, size_t __b_bytes);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,3)) size_t (__LIBCCALL fuzzy_strncmp)(char const *__a, size_t __max_a_chars, char const *__b, size_t __max_b_chars);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,2)) size_t (__LIBCCALL fuzzy_strcasecmp)(char const *__a, char const *__b);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,3)) size_t (__LIBCCALL fuzzy_memcasecmp)(void const *__a, size_t __a_bytes, void const *__b, size_t __b_bytes);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,3)) size_t (__LIBCCALL fuzzy_strncasecmp)(char const *__a, size_t __max_a_chars, char const *__b, size_t __max_b_chars);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,2)) size_t (__LIBCCALL fuzzy_strcasecmp_l)(char const *__a, char const *__b, __locale_t __locale);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,3)) size_t (__LIBCCALL fuzzy_memcasecmp_l)(void const *__a, size_t __a_bytes, void const *__b, size_t __b_bytes, __locale_t __locale);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,3)) size_t (__LIBCCALL fuzzy_strncasecmp_l)(char const *__a, size_t __max_a_chars, char const *__b, size_t __max_b_chars, __locale_t __locale);
/* Perform a wildcard string comparison, returning ZERO(0) upon match, or non-zero when not. */
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL wildstrcmp)(char const *__pattern, char const *__string);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL wildstrcasecmp)(char const *__pattern, char const *__string);
__LIBC __PORT_KOSONLY __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL wildstrcasecmp_l)(char const *__pattern, char const *__string, __locale_t __locale);
#endif /* __CRT_KOS */
#if !defined(__GLC_COMPAT__) && !defined(__CYG_COMPAT__)
#if __KOS_VERSION__ >= 300 && !defined(__DOS_COMPAT__)
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcasecmp)(void const *__a, void const *__b, size_t __n_bytes);
#else
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1,2)),int,__LIBCCALL,memcasecmp,(void const *__a, void const *__b, size_t __n_bytes),_memicmp,(__a,__b,__n_bytes))
#endif
#ifndef __KERNEL__
#if __KOS_VERSION__ >= 300 && !defined(__DOS_COMPAT__)
__LIBC __WUNUSED __ATTR_PURE __NONNULL((1,2)) int (__LIBCCALL memcasecmp_l)(void const *__a, void const *__b, size_t __n_bytes, __locale_t __locale);
#else
__REDIRECT(__LIBC,__WUNUSED __ATTR_PURE __NONNULL((1,2)),int,__LIBCCALL,memcasecmp_l,
(void const *__a, void const *__b, size_t __n_bytes, __locale_t __locale),_memicmp_l,(__a,__b,__n_bytes,__locale))
#endif
#endif /* !__KERNEL__ */
#else /* !__GLC_COMPAT__ */
#ifndef ____libc_tolower_defined
#define ____libc_tolower_defined 1
__REDIRECT_NOTHROW(__LIBC,__WUNUSED,int,__LIBCCALL,__libc_tolower,(int __c),tolower,(__c))
#endif /* !____libc_tolower_defined */
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1,2))
int (__LIBCCALL memcasecmp)(void const *__a, void const *__b, size_t __n_bytes) {
__BYTE_TYPE__ *__ai = (__BYTE_TYPE__ *)__a,*__bi = (__BYTE_TYPE__ *)__b; int __temp;
while (__n_bytes--) if ((__temp = __libc_tolower(*__ai++) - __libc_tolower(*__bi++)) != 0) return __temp;
return 0;
}
#ifndef __KERNEL__
__LOCAL __WUNUSED __ATTR_PURE __NONNULL((1,2))
int (__LIBCCALL memcasecmp_l)(void const *__a, void const *__b, size_t __n_bytes,
__locale_t __UNUSED(__locale)) {
return memcasecmp(__a,__b,__n_bytes);
}
#endif /* !__KERNEL__ */
#endif /* __GLC_COMPAT__ */
#ifndef __KERNEL__
#ifdef __DOS_COMPAT__
__SYSDECL_END
#include <parts/kos2/amalloc.h>
__SYSDECL_BEGIN
#ifndef ____dos_vscprintf_defined
#define ____dos_vscprintf_defined 1
__REDIRECT(__LIBC,,int,__LIBCCALL,__dos_vscprintf,(char const *__restrict __format, __builtin_va_list __args),_vscprintf,(__format,__args))
#endif /* !____dos_vsnprintf_defined */
#ifndef ____libc_vsprintf_defined
#define ____libc_vsprintf_defined 1
__REDIRECT(__LIBC,,int,__LIBCCALL,__libc_vsprintf,(char *__restrict __buf, char const *__restrict __format, __builtin_va_list __args),vsprintf,(__buf,__format,__args))
#endif /* !____libc_vsprintf_defined */
#ifndef __NO_ASMNAME
__LIBC __ATTR_LIBC_PRINTF(1,2) int (__ATTR_CDECL __dos_scprintf)(char const *__restrict __format, ...) __ASMNAME("_scprintf");
__LIBC __ATTR_LIBC_PRINTF(2,3) __ssize_t (__ATTR_CDECL __libc_sprintf)(char *__restrict __buf, char const *__restrict __format, ...) __ASMNAME("sprintf");
#else /* !__NO_ASMNAME */
#define __dos_scprintf(...) _scprintf(__VA_ARGS__)
#define __libc_sprintf(...) __NAMESPACE_STD_SYM sprintf(__VA_ARGS__)
#ifndef ___scprintf_defined
#define ___scprintf_defined 1
#ifdef __USE_KOS_STDEXT
__REDIRECT_DPB(__LIBC,__ATTR_LIBC_PRINTF(1,0),__ssize_t,__LIBCCALL,vscprintf,(char const *__restrict __format, __builtin_va_list __args),(__format,__args))
__VREDIRECT_DPB(__LIBC,__ATTR_LIBC_PRINTF(1,2),__ssize_t,__ATTR_CDECL,scprintf,(char const *__restrict __format, ...),vscprintf,(__format),__format)
#else
__REDIRECT_DPB(__LIBC,__ATTR_LIBC_PRINTF(1,0),int,__LIBCCALL,vscprintf,(char const *__restrict __format, __builtin_va_list __args),(__format,__args))
__VREDIRECT_DPB(__LIBC,__ATTR_LIBC_PRINTF(1,2),int,__ATTR_CDECL,scprintf,(char const *__restrict __format, ...),vscprintf,(__format),__format)
#endif
#endif /* !___scprintf_defined */
#ifndef __std_sprintf_defined
#define __std_sprintf_defined
__NAMESPACE_STD_BEGIN
__LIBC __ATTR_LIBC_PRINTF(2,3) __ssize_t (__ATTR_CDECL sprintf)(char *__restrict __buf, char const *__restrict __format, ...);
__NAMESPACE_STD_END
#endif /* !__std_sprintf_defined */
#ifndef __sprintf_defined
#define __sprintf_defined
__NAMESPACE_STD_USING(sprintf)
#endif /* !__sprintf_defined */
#endif /* __NO_ASMNAME */
__LOCAL __ATTR_LIBC_PRINTF(2,3) char *(__ATTR_CDECL __forward_sprintf)(char *__restrict __buf, char const *__restrict __format, ...) { __builtin_va_list __args; __builtin_va_start(__args,__format); __libc_vsprintf(__buf,__format,__args); __builtin_va_end(__args); return __buf; }
__LOCAL __ATTR_LIBC_PRINTF(2,0) char *(__LIBCCALL __forward_vsprintf)(char *__restrict __buf, char const *__restrict __format, __builtin_va_list __args) { __libc_vsprintf(__buf,__format,__args); return __buf; }
/* Without dedicated Libc functionality, double-evaluation can't be prevented. */
#define strdupaf(...) \
__forward_sprintf((char *)__ALLOCA(((size_t)__dos_scprintf(__VA_ARGS__)+1)*sizeof(char)),__VA_ARGS__)
#ifdef __NO_XBLOCK
#define vstrdupaf(format,args) \
__forward_vsprintf((char *)__ALLOCA(((size_t)__dos_vscprintf(format,args)+1)*sizeof(char)),format,args)
#else /* __NO_XBLOCK */
#define vstrdupaf(format,args) \
__XBLOCK({ char const *const __format = (format); \
__builtin_va_list __args = (args); \
__XRETURN __forward_vsprintf((char *)__ALLOCA(((size_t) \
__dos_vscprintf(__format,__args)+1)*sizeof(char)),__format,__args); \
})
#endif /* !__NO_XBLOCK */
#elif defined(__GLC_COMPAT__) || defined(__CYG_COMPAT__)
__SYSDECL_END
#include <hybrid/alloca.h>
__SYSDECL_BEGIN
#ifndef ____libc_vsprintf_defined
#define ____libc_vsprintf_defined 1
__REDIRECT(__LIBC,__ATTR_LIBC_PRINTF(2,0),int,__LIBCCALL,__libc_vsprintf,(char *__restrict __buf, char const *__restrict __format, __builtin_va_list __args),vsprintf,(__buf,__format,__args))
#endif /* !____libc_vsprintf_defined */
#ifndef ____libc_vsnprintf_defined
#define ____libc_vsnprintf_defined 1
__REDIRECT(__LIBC,__ATTR_LIBC_PRINTF(3,0),int,__LIBCCALL,__libc_vsnprintf,(char *__restrict __buf, size_t __buflen, char const *__restrict __format, __builtin_va_list __args),vsnprintf,(__buf,__buflen,__format,__args))
#endif /* !____libc_vsnprintf_defined */
#ifndef __NO_ASMNAME
__LIBC __ATTR_LIBC_PRINTF(2,3) __ssize_t (__ATTR_CDECL __libc_sprintf)(char *__restrict __buf, char const *__restrict __format, ...) __ASMNAME("sprintf");
__LIBC __ATTR_LIBC_PRINTF(3,0) __ssize_t (__ATTR_CDECL __libc_snprintf)(char *__restrict __buf, size_t __buflen, char const *__restrict __format, ...) __ASMNAME("snprintf");
#else /* !__NO_ASMNAME */
#define __libc_sprintf(...) __NAMESPACE_STD_SYM sprintf(__VA_ARGS__)
#define __libc_snprintf(...) __NAMESPACE_STD_SYM snprintf(__VA_ARGS__)
#ifndef __std_sprintf_defined
#define __std_sprintf_defined
__NAMESPACE_STD_BEGIN
__LIBC __ATTR_LIBC_PRINTF(2,3) __ssize_t (__ATTR_CDECL sprintf)(char *__restrict __buf, char const *__restrict __format, ...);
__NAMESPACE_STD_END
#endif /* !__std_sprintf_defined */
#ifndef __std_snprintf_defined
#define __std_snprintf_defined 1
__NAMESPACE_STD_BEGIN
__LIBC __ATTR_LIBC_PRINTF(3,4) __ssize_t (__ATTR_CDECL snprintf)(char *__restrict __buf, size_t __buflen, char const *__restrict __format, ...);
__NAMESPACE_STD_END
#endif /* !__std_snprintf_defined */
#ifndef __sprintf_defined
#define __sprintf_defined
__NAMESPACE_STD_USING(sprintf)
#endif /* !__sprintf_defined */
#ifndef __snprintf_defined
#define __snprintf_defined 1
__NAMESPACE_STD_USING(snprintf)
#endif /* !__snprintf_defined */
#endif /* __NO_ASMNAME */
__LOCAL __ATTR_LIBC_PRINTF(2,3) char *(__ATTR_CDECL __forward_sprintf)(char *__restrict __buf, char const *__restrict __format, ...) { __builtin_va_list __args; __builtin_va_start(__args,__format); __libc_vsprintf(__buf,__format,__args); __builtin_va_end(__args); return __buf; }
__LOCAL __ATTR_LIBC_PRINTF(2,0) char *(__LIBCCALL __forward_vsprintf)(char *__restrict __buf, char const *__restrict __format, __builtin_va_list __args) { __libc_vsprintf(__buf,__format,__args); return __buf; }
/* TODO: Better code for handling `__DOS_COMPAT__' here. */
/* Without dedicated Libc functionality, double-evaluation can't be prevented. */
#define strdupaf(...) \
__forward_sprintf((char *)__ALLOCA(((size_t)__libc_snprintf(NULL,0,__VA_ARGS__)+1)*sizeof(char)),__VA_ARGS__)
#ifdef __NO_XBLOCK
#define vstrdupaf(format,args) \
__forward_vsprintf((char *)__ALLOCA(((size_t)__libc_snprintf(NULL,0,format,args)+1)*sizeof(char)),format,args)
#else /* __NO_XBLOCK */
#define vstrdupaf(format,args) \
__XBLOCK({ char const *const __format = (format); \
__builtin_va_list __args = (args); \
__XRETURN __forward_vsprintf((char *)__ALLOCA(((size_t) \
__libc_snprintf(NULL,0,__format,__args)+1)*sizeof(char)),__format,__args); \
})
#endif /* !__NO_XBLOCK */
#else /* Compat... */
/* >> char *strdupaf(char const *__restrict format, ...);
* String duplicate as fu$k!
* Similar to strdupf, but allocates memory of the stack, instead of the heap.
* While this function is _very_ useful, be warned that due to the way variadic
* arguments are managed by cdecl (the only calling convention possible to use
* for them on most platforms) it is nearly impossible not to waste the stack
* space that was originally allocated for the arguments (Because in cdecl, the
* callee is responsible for argument cleanup).
* ANYWAYS: Since its the stack, it shouldn't really matter, but please be advised
* that use of these functions fall under the same restrictions as all
* other alloca-style functions.
* >> int open_file_in_folder(char const *folder, char const *file) {
* >> return open(strdupaf("%s/%s",folder,file),O_RDONLY);
* >> }
*/
__LIBC __ATTR_LIBC_PRINTF(1,2) __WUNUSED __ATTR_MALLOC char *(__ATTR_CDECL strdupaf)(char const *__restrict __format, ...);
__LIBC __ATTR_LIBC_PRINTF(1,0) __WUNUSED __ATTR_MALLOC char *(__LIBCCALL vstrdupaf)(char const *__restrict __format, __builtin_va_list __args);
#ifdef __INTELLISENSE__
#elif defined(__GNUC__)
/* Dear GCC devs: WHY IS THERE NO `__attribute__((alloca))'?
* Or better yet! Add something like: `__attribute__((clobber("%esp")))'
*
* Here's what the hacky code below does:
* We must use `__builtin_alloca' to inform the compiler that the stack pointer
* contract has been broken, meaning that %ESP can (no longer) be used for offsets.
* NOTE: If you don't believe me that this is required, and think this is just me
* ranting about missing GCC functionality, try the following code yourself:
* >> printf("path = `%s'\n",strdupaf("%s/%s","/usr","lib")); // OK (Also try cloning this line a bunch of times)
* >> #undef strdupaf
* >> printf("path = `%s'\n",strdupaf("%s/%s","/usr","lib")); // Breaks
*
* NOTE: We also can't do __builtin_alloca(0) because that's optimized away too early
* and the compiler will (correctly) not mark %ESP as clobbered internally.
* So we're left with no choice but to waste another bit of
* stack memory, and more importantly: instructions!
* Oh and by-the-way: Unlike with str(n)dupa It's only possible to implement
* this as a dedicated function, when wanting to ensure
* one-time evaluation of the variadic arguments.
* -> So we can't just implement the whole thing as a macro.
* (OK: '_vstrdupaf' could be, but when are you even going to use any to begin with...)
* HINT: A standard-compliant, but double-evaluating version would look something like this:
* >> #define strdupaf(...) \
* >> ({ char *result; size_t s;\
* >> s = (snprintf(NULL,0,__VA_ARGS__)+1)*sizeof(char);\
* >> result = (char *)__builtin_alloca(s);\
* >> snprintf(result,s,__VA_ARGS__);\
* >> result;\
* >> })
*/
#define strdupaf(...) \
__XBLOCK({ char *const __sdares = strdupaf(__VA_ARGS__);\
(void)__builtin_alloca(1);\
__XRETURN __sdares;\
})
#define vstrdupaf(fmt,args) \
__XBLOCK({ char *__sdares = _vstrdupaf(fmt,args);\
(void)__builtin_alloca(1);\
__XRETURN __sdares;\
})
#else
/* This might not work, because the compiler has no
* idea these functions are violating the stack layout. */
#endif
#endif /* Builtin... */
#ifdef __CRT_DOS
__REDIRECT_DPA(__LIBC,__PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strlwr_l,(char *__restrict __str, __locale_t __locale),(__str,__locale))
__REDIRECT_DPA(__LIBC,__PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strupr_l,(char *__restrict __str, __locale_t __locale),(__str,__locale))
__REDIRECT_DPA(__LIBC,__ATTR_PURE __PORT_DOSONLY __NONNULL((1,2)),int,__LIBCCALL,strncoll,(char const *__str1, char const *__str2, size_t __max_chars),(__str1,__str2,__max_chars))
__REDIRECT_DPA(__LIBC,__ATTR_PURE __PORT_DOSONLY __NONNULL((1,2)),int,__LIBCCALL,strncoll_l,(char const *__str1, char const *__str2, size_t __max_chars, __locale_t __locale),(__str1,__str2,__max_chars,__locale))
#ifdef __DOS_COMPAT__
__REDIRECT(__LIBC,__ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)),int,__LIBCCALL,strcasecoll,(char const *__str1, char const *__str2),_stricoll,(__str1,__str2))
__REDIRECT(__LIBC,__ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)),int,__LIBCCALL,strcasecoll_l,(char const *__str1, char const *__str2, __locale_t __locale),_stricoll_l,(__str1,__str2,__locale))
__REDIRECT(__LIBC,__ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)),int,__LIBCCALL,strncasecoll,(char const *__str1, char const *__str2, size_t __max_chars),_strnicoll,(__str1,__str2,__max_chars))
__REDIRECT(__LIBC,__ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)),int,__LIBCCALL,strncasecoll_l,(char const *__str1, char const *__str2, size_t __max_chars, __locale_t __locale),_strnicoll_l,(__str1,__str2,__max_chars,__locale))
#else
__LIBC __ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)) int (__LIBCCALL strcasecoll)(char const *__str1, char const *__str2);
__LIBC __ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)) int (__LIBCCALL strcasecoll_l)(char const *__str1, char const *__str2, __locale_t __locale);
__LIBC __ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)) int (__LIBCCALL strncasecoll)(char const *__str1, char const *__str2, size_t __max_chars);
__LIBC __ATTR_PURE __WUNUSED __PORT_DOSONLY __NONNULL((1,2)) int (__LIBCCALL strncasecoll_l)(char const *__str1, char const *__str2, size_t __max_chars, __locale_t __locale);
#endif
#ifndef __strlwr_defined
#define __strlwr_defined 1
__REDIRECT_DPA(__LIBC,__PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strlwr,(char *__restrict __str),(__str))
__REDIRECT_DPA(__LIBC,__PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strnset,(char *__restrict __str, int __char, size_t __max_chars),(__str,__char,__max_chars))
__REDIRECT_DPA(__LIBC,__PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strrev,(char *__restrict __str),(__str))
__REDIRECT_DPA(__LIBC,__PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strupr,(char *__restrict __str),(__str))
#ifdef _MSC_VER
#ifndef ___strset_defined
#define ___strset_defined 1
__LIBC __PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)) char *(__LIBCCALL _strset)(char *__restrict __str, int __char);
#endif /* !___strset_defined */
#pragma intrinsic(_strset)
#define strset _strset
#else
__REDIRECT_DPA(__LIBC,__PORT_DOSONLY __ATTR_RETNONNULL __NONNULL((1)),char *,__LIBCCALL,strset,(char *__restrict __str, int __char),(__str,__char))
#endif
#endif /* !__strlwr_defined */
#endif /* __CRT_DOS */
#endif /* !__KERNEL__ */
#ifdef __USE_DEBUG
#include "hybrid/debuginfo.h"
#if __USE_DEBUG != 0 && defined(__CRT_KOS) && \
(!defined(__DOS_COMPAT__) && !defined(__GLC_COMPAT__))
__REDIRECT(__LIBC,__ATTR_RETNONNULL __NONNULL((1,2)),void *,__LIBCCALL,_memcpyb_d,(void *__restrict __dst, void const *__restrict __src, size_t __n_bytes, __DEBUGINFO),_memcpy_d,(__dst,__src,__n_bytes,__DEBUGINFO_FWD))
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL _memcpyw_d)(void *__restrict __dst, void const *__restrict __src, size_t __n_words, __DEBUGINFO);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL _memcpyl_d)(void *__restrict __dst, void const *__restrict __src, size_t __n_dwords, __DEBUGINFO);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL _memcpyq_d)(void *__restrict __dst, void const *__restrict __src, size_t __n_qwords, __DEBUGINFO);
#ifdef __USE_GNU
__REDIRECT(__LIBC,__ATTR_RETNONNULL __NONNULL((1,2)),void *,__LIBCCALL,_mempcpyb_d,(void *__restrict __dst, void const *__restrict __src, size_t __n_bytes, __DEBUGINFO),_mempcpy_d,(__dst,__src,__n_bytes,__DEBUGINFO_FWD))
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL _mempcpyw_d)(void *__restrict __dst, void const *__restrict __src, size_t __n_words, __DEBUGINFO);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL _mempcpyl_d)(void *__restrict __dst, void const *__restrict __src, size_t __n_dwords, __DEBUGINFO);
__LIBC __ATTR_RETNONNULL __NONNULL((1,2)) void *(__LIBCCALL _mempcpyq_d)(void *__restrict __dst, void const *__restrict __src, size_t __n_qwords, __DEBUGINFO);
#endif /* __USE_GNU */
#else /* __USE_DEBUG != 0 */
# define _memcpyb_d(dst,src,n_bytes,...) memcpyb(dst,src,n_bytes)
# define _memcpyw_d(dst,src,n_words,...) memcpyw(dst,src,n_words)
# define _memcpyl_d(dst,src,n_dwords,...) memcpyl(dst,src,n_dwords)
# define _memcpyq_d(dst,src,n_qwords,...) memcpyq(dst,src,n_qwords)
#ifdef __USE_GNU
# define _mempcpyb_d(dst,src,n_bytes,...) mempcpyb(dst,src,n_bytes)
# define _mempcpyw_d(dst,src,n_words,...) mempcpyw(dst,src,n_words)
# define _mempcpyl_d(dst,src,n_dwords,...) mempcpyl(dst,src,n_dwords)
# define _mempcpyq_d(dst,src,n_dwords,...) mempcpyq(dst,src,n_qwords)
#endif /* __USE_GNU */
#endif /* __USE_DEBUG == 0 */
#ifdef __USE_DEBUG_HOOK
#ifndef __OPTIMIZE_LIBC__
# define memcpyb(dst,src,n_bytes) _memcpyb_d(dst,src,n_bytes,__DEBUGINFO_GEN)
# define memcpyw(dst,src,n_words) _memcpyw_d(dst,src,n_words,__DEBUGINFO_GEN)
# define memcpyl(dst,src,n_dwords) _memcpyl_d(dst,src,n_dwords,__DEBUGINFO_GEN)
# define memcpyq(dst,src,n_qwords) _memcpyq_d(dst,src,n_qwords,__DEBUGINFO_GEN)
#ifdef __USE_GNU
# define mempcpyb(dst,src,n_bytes) _mempcpyb_d(dst,src,n_bytes,__DEBUGINFO_GEN)
# define mempcpyw(dst,src,n_words) _mempcpyw_d(dst,src,n_words,__DEBUGINFO_GEN)
# define mempcpyl(dst,src,n_dwords) _mempcpyl_d(dst,src,n_dwords,__DEBUGINFO_GEN)
# define mempcpyq(dst,src,n_qwords) _mempcpyq_d(dst,src,n_qwords,__DEBUGINFO_GEN)
#endif /* __USE_GNU */
#endif /* !__OPTIMIZE_LIBC__ */
#endif /* __USE_DEBUG_HOOK */
#endif /* __USE_DEBUG */
__SYSDECL_END
#ifdef _WCHAR_H
#ifndef _PARTS_KOS2_WSTRING_H
#include "wstring.h"
#endif
#endif
#ifdef __USE_KOS3
#ifndef _PARTS_KOS3_STRING_H
#include <parts/kos3/string.h>
#endif
#endif
#endif /* !_PARTS_KOS2_STRING_H */
|
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef http_strpool_h
# define http_strpool_h
#ifndef _http_STRPOOL_
# define _AK_EXTERN extern
#else
# define _AK_EXTERN
#endif
_AK_EXTERN const char _s_http_pool_0[];
#define _s_http_0(x) (_s_http_pool_0 + x)
/* _s_http_pool_0 */
#define _s_http_GET _s_http_0(0)
#define _s_http_GET_LEN 4
#define _s_http_POST _s_http_0(5)
#define _s_http_POST_LEN 4
#endif /* http_strpool_h */
|
/* Copyright 2015 Rasmus Dall - [email protected]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */
#ifndef JNDSLAM_IO_H
#define JNDSLAM_IO_H
#include <string>
#include <vector>
#include <array>
#include <iostream>
#include <stdexcept>
#include <fstream>
#include <dirent.h>
#include <sys/stat.h>
#include "utterance.h"
#include "jndslam_std.h"
#include "jndslam_style.h"
// Checks if a file exists
bool file_exists(std::string &filename);
// List the contents of a directory
std::vector<std::string> list_dir(std::string dir);
// Opens a file line by line. Throws if file does not exist.
std::vector<std::string> open_file(std::string filepath);
// Parse an EST style file opened line by line and add timing information
// to sylls in an utt.
// Note that sylls must already exist for this to work.
void parse_est(typename utterance::utterance &utt, std::vector<std::string> &line_list);
// Parse an HTS style label list and add sylls to an utterance
void parse_hts_lab(typename utterance::utterance &utt, std::vector<std::string> &line_list, std::vector<std::string> &delims);
// Parse a simple space-delimited label list and add sylls to an utterance
// Format for each line is:
// start_time_in_seconds end_time_in_seconds segment_id
void parse_simple_lab(typename utterance::utterance &utt, std::vector<std::string> &line_list);
// Write out a file for each utterance with stylisations of each syllable line by line
void write_utts_to_file(std::vector<typename utterance::utterance> &utts, std::string &out_path, Style_Alg &algorithm);
// Write out a file for a utterance with stylisations of each syllable line by line
void write_utt_to_file(typename utterance::utterance &utts, std::string &out_path, Style_Alg &algorithm);
#endif
|
#include "util.h"
#include <dc_posix/dc_stdlib.h>
#include <dc_posix/dc_string.h>
#include <stdlib.h>
#include <string.h>
char *get_prompt(const struct dc_posix_env *env, struct dc_error *err)
{
const char *env_PS1;
env_PS1 = dc_getenv(env, "PS1");
if(env_PS1 == NULL)
env_PS1 = "$ ";
return env_PS1;
}
char *get_path(const struct dc_posix_env *env, struct dc_error *err)
{
const char *path;
path = dc_getenv(env, "PATH");
return path;
}
size_t count(const char *str, int c)
{
size_t num;
num = 0;
for(const char *tmp = str; *tmp; tmp++)
{
if(*tmp == c)
{
num++;
}
}
return num;
}
char **parse_path(const struct dc_posix_env *env, struct dc_error *err, const char *path_str)
{
char *str;
char *state;
char *token;
char **list;
size_t num;
size_t i;
str = strdup(path_str);
state = str;
num = count(str, ':') + 1;
list = malloc((num + 1) * sizeof(char *));
i = 0;
while((token = strtok_r(state, ":", &state)) != NULL)
{
list[i] = strdup(token);
i++;
};
list[i] = NULL;
free(str);
return list;
}
void do_reset_state(const struct dc_posix_env *env, struct dc_error *err, struct state *state)
{
dc_free(env, state->current_line, sizeof(state->current_line));
state->current_line = NULL;
dc_free(env, state->command, sizeof(state->command));
state->command = NULL;
state->current_line_length = 0;
dc_free(env, err->message, sizeof(err->message));
state->fatal_error = false;
err->message = NULL;
err->file_name = NULL;
err->function_name = NULL;
err->line_number = NULL;
err->line_number = 0;
err->type = 0;
err->err_code = 0;
}
void display_state(const struct dc_posix_env *env, const struct state *state, FILE *stream)
{
}
char *state_to_string(const struct dc_posix_env *env, struct dc_error *err, const struct state *state)
{
size_t len;
char *line;
if(state->current_line == NULL)
{
len = strlen("current_line = NULL");
}
else
{
len = strlen("current_line = \"\"");
len += state->current_line_length;
}
len += strlen(", fatal_error = ");
// +1 for 0 or 1 for the fatal_error and +1 for the null byte
line = malloc(len + 1 + 1);
if(state->current_line == NULL)
{
sprintf(line, "current_line = NULL, fatal_error = %d", state->fatal_error);
}
else
{
sprintf(line, "current_line = \"%s\", fatal_error = %d", state->current_line, state->fatal_error);
}
return line;
}
|
/******************************************************************************
* PROJECT: PLC data server library *
* MODULE: pdsnp_api.h *
* PURPOSE: Header file for the PDS network protocol API module *
* AUTHOR: Paul M. Breen *
* DATE: 2000-06-28 *
******************************************************************************/
#ifndef __PDSNP_API_H
#define __PDSNP_API_H
#include <pds.h>
#include <pdsnp_defs.h>
/******************************************************************************
* Function prototypes *
******************************************************************************/
/******************************************************************************
* Function to connect a client to the server *
* *
* Pre-condition: A server host & port are passed to the function. If the *
* host is NULL a local connection is made, else a network *
* connection is made *
* Post-condition: The client program is connected to the server which is *
* identified by the host & port. The server connection *
* structure is returned which is used in all subsequent *
* calls to the server. On return the connection structure *
* should be interrogated to determine if the connection was *
* successful or if an error occurred. If memory cannot be *
* allocated for the connection structure a null pointer is *
* returned *
******************************************************************************/
pdsconn* PDSNPconnect(const char *host, unsigned short int port);
/******************************************************************************
* Function to disconnect a client from the server *
* *
* Pre-condition: A valid server connection struct is passed to the function *
* Post-condition: The client program is disconnected from the server. If an *
* error occurrs a -1 is returned *
******************************************************************************/
int PDSNPdisconnect(pdsconn *conn);
/******************************************************************************
* Function to get a tag's value *
* *
* Pre-condition: A valid server connection, the tagname and a string for *
* storage of the tag's value are passed to the function *
* Post-condition: The tagname is accessed in the shared memory segment and *
* its corresponding value is returned. On error a -1 is *
* returned *
******************************************************************************/
int PDSNPget_tag(pdsconn *conn, const char *tagname, char *tagvalue);
/******************************************************************************
* Function to set tag value(s) *
* *
* Pre-condition: A valid server connection, the base tagname, the no. of *
* tags to write and the tag value(s) as an integer pointer *
* are passed to the function *
* Post-condition: A message is sent to the server requesting that the tag *
* value(s) be written to the PLC. On error a -1 is returned *
******************************************************************************/
int PDSNPset_tag(pdsconn *conn, const char *tagname, short int ntags,
const short int *tagvalues);
#endif
|
#pragma once
#include "common/common_types.h"
#include "game/sound/common/voice.h"
#define SD_VA_SSA ((0x20 << 8) + (0x01 << 6))
#define SD_VA_LSAX ((0x21 << 8) + (0x01 << 6))
#define SD_S_VMIXL (0x18 << 8)
#define SD_S_VMIXR (0x1a << 8)
#define SD_VP_VOLL (0x00 << 8)
#define SD_VP_VOLR (0x01 << 8)
#define SD_VP_PITCH (0x02 << 8)
#define SD_VP_ADSR1 (0x03 << 8)
#define SD_VP_ADSR2 (0x04 << 8)
#define SD_VA_NAX ((0x22 << 8) + (0x01 << 6))
extern std::shared_ptr<snd::voice> voice;
extern u8 spu_memory[0xc060];
using sceSdTransIntrHandler = int (*)(int, void*);
u32 sceSdGetSwitch(u32 entry);
u32 sceSdGetAddr(u32 entry);
void sceSdSetSwitch(u32 entry, u32 value);
void sceSdSetAddr(u32 entry, u32 value);
void sceSdSetParam(u32 entry, u32 value);
void sceSdSetTransIntrHandler(s32 channel, sceSdTransIntrHandler, void* data);
u32 sceSdVoiceTrans(s32 channel, s32 mode, void* iop_addr, u32 spu_addr, u32 size);
|
// Copyright Epic Games, Inc.All Rights Reserved.
#pragma once
#include "ShooterTestControllerBase.h"
#include "Templates/SharedPointer.h"
#include "ShooterTestControllerDedicatedServerTest.generated.h"
UCLASS()
class UShooterTestControllerDedicatedServerTest : public UShooterTestControllerBase
{
GENERATED_BODY()
protected:
virtual void OnTick(float TimeDelta) override;
}; |
#pragma once
namespace Morpheus {
struct PositionComponent final
{
float x;
float y;
PositionComponent(float posX, float posY)
: x(posX)
, y(posY)
{
}
};
}
|
//
// CanapeConstants.h
// CanapeProject
//
// Canape Software License
// Copyright (c) 2016 BliexSoft, Inc.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for any purpose, without fee, and without
// a written agreement is hereby granted, provided that the above
// copyright notice and this and the following paragraphs appear
// in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
#ifndef CanapeConstants_h
#define CanapeConstants_h
///////////////////////////////////////////////////////////////
//
// SIZE
//
///////////////////////////////////////////////////////////////
#define DEVICE_SIZE [[[[UIApplication sharedApplication] keyWindow] rootViewController].view convertRect:[[UIScreen mainScreen] bounds] fromView:nil].size
#define pixelToPointX(x) [UIScreen mainScreen].bounds.size.width / (1242/3) * (x/3)
#define pixelToPointY(y) [UIScreen mainScreen].bounds.size.height / (2208/3) * (y/3)
#define pixelToWidth(w) ([UIScreen mainScreen].bounds.size.width / (1242/3) * (w/3))
#define pixelToHeight(h) ([UIScreen mainScreen].bounds.size.height / (2208/3) * (h/3))
///////////////////////////////////////////////////////////////
//
// COLOR
//
///////////////////////////////////////////////////////////////
#define RGB(r, g, b) [UIColor colorWithRed:r/255.0 green:g/255.0 blue:b/255.0 alpha:1]
#define RGBA(r, g, b, a) [UIColor colorWithRed:r/255.0 green:g/255.0 blue:b/255.0 alpha:a]
#define HTML(rgb) RGB((double)(rgb >> 16 & 0xff), (double)(rgb >> 8 & 0xff), (double)(rgb & 0xff))
#endif /* CanapeConstants_h */ |
/*
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include "esp_rom_sys.h"
/**
* @file esp_hw_log.h
* @brief ESP HW Support logging functions
*
* This header file provides wrappers for logging functions for libraries which may or
* may not use the ESP-IDF environment.
*/
#ifdef ESP_PLATFORM
#include "esp_log.h"
#define ESP_HW_LOGE(tag, fmt, ...) ESP_EARLY_LOGE(tag, fmt, ##__VA_ARGS__)
#define ESP_HW_LOGW(tag, fmt, ...) ESP_EARLY_LOGW(tag, fmt, ##__VA_ARGS__)
#define ESP_HW_LOGI(tag, fmt, ...) ESP_EARLY_LOGI(tag, fmt, ##__VA_ARGS__)
#define ESP_HW_LOGD(tag, fmt, ...) ESP_EARLY_LOGD(tag, fmt, ##__VA_ARGS__)
#define ESP_HW_LOGV(tag, fmt, ...) ESP_EARLY_LOGV(tag, fmt, ##__VA_ARGS__)
#else
#define ESP_HW_LOGE(tag, fmt, ...) esp_rom_printf("%s(err): " fmt, tag, ##__VA_ARGS__)
#define ESP_HW_LOGW(tag, fmt, ...) esp_rom_printf("%s(warn): " fmt, tag, ##__VA_ARGS__)
#define ESP_HW_LOGI(tag, fmt, ...) esp_rom_printf("%s(info): " fmt, tag, ##__VA_ARGS__)
#define ESP_HW_LOGD(tag, fmt, ...) esp_rom_printf("%s(dbg): " fmt, tag, ##__VA_ARGS__)
#define ESP_HW_LOGV(tag, fmt, ...) esp_rom_printf("%s: " fmt, tag, ##__VA_ARGS__)
#endif //ESP_PLATFORM
|
//
// Symbols.h
//
// Copyright (c) 2013-2018 Tomas Palazuelos
//
// Distributed under the MIT Software License. (See accompanying file LICENSE.md)
//
#ifndef ORION_DEBUG_SYMBOLS_H
#define ORION_DEBUG_SYMBOLS_H
#include <orion/Config.h>
#include <memory>
#include <string>
namespace orion
{
namespace debug
{
struct SymbolsImpl;
//--------------------------------------------------------------------------------------------------
struct LocationInfo
{
std::string file_name;
std::string function_name;
uint32_t line = 0;
};
//--------------------------------------------------------------------------------------------------
class Symbols
{
public:
explicit Symbols(const std::wstring& file_name);
Symbols(uintptr_t file_handle, const std::wstring& name);
~Symbols();
// No copy
Symbols(const Symbols&) = delete;
Symbols& operator=(const Symbols&) = delete;
// Move
Symbols(Symbols&& rhs) noexcept;
Symbols& operator=(Symbols&& rhs) noexcept;
bool find_address(uintptr_t address, LocationInfo& location_info) const;
void dump() const;
private:
const SymbolsImpl* impl() const { return _impl.get(); }
SymbolsImpl* impl() { return _impl.get(); }
std::unique_ptr<SymbolsImpl> _impl;
};
Symbols make_symbols(const std::wstring& file_name);
Symbols make_symbols(uintptr_t file_handle, const std::wstring& image_name);
} // namespace debug
} // namespace orion
#endif // ORION_DEBUG_SYMBOLS_H
|
/* bessel.c
Copyright (c) 1998
Kapteyn Institute Groningen
All Rights Reserved.
*/
/*
#> bessel.dc2
Function: BESSEL
Purpose: Evaluate Bessel function J, Y, I, K of integer order.
Category: MATH
File: bessel.c
Author: M.G.R. Vogelaar
Use: See bessj.dc2, bessy.dc2, bessi.dc2 or bessk.dc2
Description: The differential equation
2
2 d w dw 2 2
x . --- + x . --- + (x - v ).w = 0
2 dx
dx
has two solutions called Bessel functions of the first kind
Jv(x) and Bessel functions of the second kind Yv(x).
The routines bessj and bessy return the J and Y for
integer v and therefore are called Bessel functions
of integer order.
The differential equation
2
2 d w dw 2 2
x . --- + x . --- - (x + v ).w = 0
2 dx
dx
has two solutions called modified Bessel functions
Iv(x) and Kv(x).
The routines bessi and bessk return the I and K for
integer v and therefore are called Modified Bessel
functions of integer order.
(Abramowitz & Stegun, Handbook of mathematical
functions, ch. 9, pages 358,- and 374,- )
The implementation is based on the ideas from
Numerical Recipes, Press et. al.
This routine is NOT callable in FORTRAN.
Updates: Jun 29, 1998: VOG, Document created.
#<
*/
//#> bessel.h
#if !defined(_bessel_h_)
#define _bessel_h_
extern double bessj( int, double );
extern double bessy( int, double );
extern double bessi( int, double );
extern double bessk( int, double );
extern double bessj0( double );
extern double bessy0( double );
//double bessj( int, double );
//double bessy( int, double );
//double bessi( int, double );
//double bessk( int, double );
#endif |
../../../MBProgressHUD/MBProgressHUD.h |
/**
* Copyright (c) 2021 OceanBase
* OceanBase Database Proxy(ODP) is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#ifndef OBPROXY_MYSQL_PROXY_H
#define OBPROXY_MYSQL_PROXY_H
#include "lib/ob_define.h"
#include "lib/container/ob_iarray.h"
#include "proxy/client/ob_raw_mysql_client.h"
#include "proxy/client/ob_mysql_client_pool.h"
#define MYSQL_PROXY_EXECUTE_REQUEST_EVENT (MYSQL_RPOXY_EVENT_EVENTS_START + 1)
#define MYSQL_PROXY_POST_REQUEST_EVENT (MYSQL_RPOXY_EVENT_EVENTS_START + 2)
#define MYSQL_PROXY_ACTIVE_TIMEOUT_EVENT (MYSQL_RPOXY_EVENT_EVENTS_START + 3)
namespace oceanbase
{
namespace common
{
class ObAddr;
}
namespace obproxy
{
namespace obutils
{
class ObClusterResource;
}
namespace event
{
class ObContinuation;
class ObAction;
}
namespace proxy
{
class ObClientMysqlResp;
class ObMysqlResultHandler;
class ObRawMysqlClient;
class ClientPoolOption;
class ObMysqlProxy
{
public:
ObMysqlProxy()
: is_inited_(false), stop_(false), is_raw_execute_(false), timeout_ms_(0),
client_pool_(NULL), raw_mysql_client_(), rwlock_() {}
~ObMysqlProxy() { destroy(); }
int init(const int64_t timeout_ms,
const common::ObString &user_name,
const common::ObString &password,
const common::ObString &database,
const common::ObString &password1 = "");
bool is_inited() const { return is_inited_; }
void destroy();
int set_timeout_ms(const int64_t timeout_ms);
// if client pool is null, create it;
// otherwise, we will clear current client pool and create a new one
int rebuild_client_pool(dbconfig::ObShardConnector *shard_conn,
const bool is_meta_mysql_client,
const common::ObString &user_name,
const common::ObString &password,
const common::ObString &database,
const common::ObString &password1 = "",
ClientPoolOption* client_pool_option = NULL);
int rebuild_client_pool(obutils::ObClusterResource *cr,
const bool is_meta_mysql_client,
const common::ObString &cluster_name,
const int64_t cluster_id,
const common::ObString &user_name,
const common::ObString &password,
const common::ObString &database,
const common::ObString &password1 = "",
ClientPoolOption* client_pool_option = NULL);
void destroy_client_pool();
// Attention!! sync_read or sync_write must not be called in working thread
int read(const char *sql, ObMysqlResultHandler &result_handler);
int write(const char *sql, int64_t &affected_rows);
// Attention!! async_read or async_write must be called by ObEThread
int async_read(event::ObContinuation *cont, const char *sql, event::ObAction *&action);
int async_read(event::ObContinuation *cont, const ObMysqlRequestParam &request_param, event::ObAction *&action);
int async_write(event::ObContinuation *cont, const char *sql, event::ObAction *&action);
// raw execute related
int set_raw_execute(const common::ObIArray<proxy::ObProxyReplicaLocation> &addrs);
int clear_raw_execute();
DECLARE_TO_STRING;
private:
void stop() { stop_ = true; }
int async_execute(event::ObContinuation *cont,
const ObMysqlRequestParam &request_param,
const int64_t timeout_ms, event::ObAction *&action);
int sync_execute(const char *sql, const int64_t timeout_ms, ObClientMysqlResp *&res);
// client pool related
int alloc_client_pool(const bool is_meta_mysql_client,
const common::ObString &user_name,
const common::ObString &password,
const common::ObString &database,
const common::ObString &password1 = "",
ClientPoolOption* client_pool_option = NULL);
public:
ObMysqlClientPool *acquire_client_pool();
void release_client_pool(ObMysqlClientPool *pool);
// this function must be called under write lock
void clear_client_pool();
private:
bool is_inited_;
bool stop_;
bool is_raw_execute_;//if true, means no depend sm
int64_t timeout_ms_;
ObMysqlClientPool *client_pool_;
ObRawMysqlClient raw_mysql_client_;
mutable obsys::CRWLock rwlock_; // used for client pool
DISALLOW_COPY_AND_ASSIGN(ObMysqlProxy);
};
inline int ObMysqlProxy::set_timeout_ms(const int64_t timeout_ms)
{
int ret = common::OB_SUCCESS;
if (timeout_ms <= 0) {
ret = common::OB_INVALID_ARGUMENT;
PROXY_LOG(WARN, "invalid argument", K(timeout_ms), K(ret));
} else {
timeout_ms_ = timeout_ms;
}
return ret;
}
inline int ObMysqlProxy::clear_raw_execute()
{
int ret = common::OB_SUCCESS;
if (!is_inited_) {
ret = common::OB_NOT_INIT;
PROXY_LOG(WARN, "not init", K_(is_inited), K(ret));
} else if (OB_FAIL(raw_mysql_client_.disconnect())) {
PROXY_LOG(WARN, "fail to disconnect raw mysql client", K(ret));
} else {
is_raw_execute_ = false;
}
return ret;
}
inline void ObMysqlProxy::destroy_client_pool()
{
if (OB_LIKELY(is_inited_)) {
obsys::CWLockGuard guard(rwlock_);
clear_client_pool();
}
}
inline void ObMysqlProxy::clear_client_pool()
{
if (OB_LIKELY(NULL != client_pool_)) {
PROXY_LOG(INFO, "client pool will be destroyed", KPC_(client_pool));
client_pool_->destroy();
client_pool_->dec_ref();
client_pool_ = NULL;
}
}
inline ObMysqlClientPool *ObMysqlProxy::acquire_client_pool()
{
ObMysqlClientPool *client_pool = NULL;
obsys::CRLockGuard guard(rwlock_);
if (OB_LIKELY(NULL != client_pool_)) {
client_pool = client_pool_;
client_pool->inc_ref();
}
return client_pool;
}
inline void ObMysqlProxy::release_client_pool(ObMysqlClientPool *pool)
{
if (OB_LIKELY(NULL != pool)) {
pool->dec_ref();
pool = NULL;
}
}
} // end of namespace proxy
} // end of namespace obproxy
} // end of namespace oceanbase
#endif // OBPROXY_MYSQL_PROXY_H
|
// Copyright 2008-2014 Simon Ekström
#ifndef __FRAMEWORK_TRANSFORM_H__
#define __FRAMEWORK_TRANSFORM_H__
#include <Foundation/Math/Matrix4x4.h>
#include <Foundation/Math/Matrix3x3.h>
#include <Foundation/Math/Vec3.h>
namespace sb
{
class SceneGraphManager;
class SceneGraph;
class Transform
{
public:
Transform();
~Transform();
void SetLocalRotation(const Mat3x3f& rotation);
void SetLocalPosition(const Vec3f& position);
void SetLocalScale(const Vec3f& scale);
const Mat3x3f& GetLocalRotation() const;
const Vec3f& GetLocalPosition() const;
const Vec3f& GetLocalScale() const;
/// @brief Returns world transformation for this object.
const Mat4x4f& GetWorld() const;
Transform* GetParent();
/// Detaches this node from any parent node.
void Detach();
void AttachChild(Transform* child);
void DetachChild(Transform* child);
void Update();
private:
Mat4x4f BuildTransform() const;
Transform* _parent;
vector<Transform*> _children;
Mat3x3f _rotation;
Vec3f _position;
Vec3f _scale;
Mat4x4f _world;
};
} // namespace sb
#endif // __FRAMEWORK_TRANSFORM_H__
|
//
// CCWallet+CoreDataProperties.h
// Karathen
//
// Created by Karathen on 2018/11/26.
// Copyright © 2018 raistone. All rights reserved.
//
//
#import "CCWallet+CoreDataClass.h"
NS_ASSUME_NONNULL_BEGIN
@interface CCWallet (CoreDataProperties)
+ (NSFetchRequest<CCWallet *> *)fetchRequest;
@property (nullable, nonatomic, copy) NSString *accountID;
@property (nullable, nonatomic, copy) NSString *address;
@property (nullable, nonatomic, copy) NSString *balance;
@property (nullable, nonatomic, copy) NSString *filterType;
@property (nonatomic) int16_t iconId;
@property (nonatomic) BOOL isHideNoBalance;
@property (nonatomic) BOOL isSelected;
@property (nonatomic) int16_t slot;
@property (nonatomic) int16_t coinType;
@property (nullable, nonatomic, copy) NSString *walletName;
@end
NS_ASSUME_NONNULL_END
|
#pragma once
class uaGlobals
{
public:
};
|
/*
* Copyright (c) 2012 Jonas 'Sortie' Termansen.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* sortix/mman.h
* Memory management declarations.
*/
#ifndef SORTIX_MMAN_H
#define SORTIX_MMAN_H
/* Note that not all combinations of the following may be possible on all
architectures. However, you do get at least as much access as you request. */
#define PROT_NONE (0)
/* Flags that control user-space access to memory. */
#define PROT_EXEC (1<<0)
#define PROT_WRITE (1<<1)
#define PROT_READ (1<<2)
#define PROT_USER (PROT_EXEC | PROT_WRITE | PROT_READ)
/* Flags that control kernel access to memory. */
#define PROT_KEXEC (1<<3)
#define PROT_KWRITE (1<<4)
#define PROT_KREAD (1<<5)
#define PROT_KERNEL (PROT_KEXEC | PROT_KWRITE | PROT_KREAD)
#define PROT_FORK (1<<6)
#define MAP_SHARED (1<<0)
#define MAP_PRIVATE (1<<1)
#define MAP_ANONYMOUS (1<<2)
#define MAP_FIXED (1<<3)
#define MAP_FAILED ((void*) -1)
#endif
|
/*
* The MIT License (MIT)
*
* Copyright (c) Henry Gabryjelski
* Copyright (c) Ha Thach for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef COMPILE_DATE_H
#define COMPILE_DATE_H
/* Help enable build to be deterministic. */
/* Allows Ghostfat to generate 100% reproducible images across compilations. */
/* Reproducible builds are also important for other reasons. */
/* See generally, https://reproducible-builds.org/ */
#ifndef COMPILE_DATE
#define COMPILE_DATE __DATE__
#endif
#ifndef COMPILE_TIME
#define COMPILE_TIME __TIME__
#endif
#define COMPILE_YEAR_INT (((\
(COMPILE_DATE[7u] - '0') * 10u + \
(COMPILE_DATE[8u] - '0')) * 10u + \
(COMPILE_DATE[9u] - '0')) * 10u + \
(COMPILE_DATE[10u] - '0'))
#define COMPILE_MONTH_INT (\
(COMPILE_DATE[2u] == 'n' && COMPILE_DATE[1u] == 'a') ? 1u /*Jan*/ \
: (COMPILE_DATE[2u] == 'b') ? 2u /*Feb*/ \
: (COMPILE_DATE[2u] == 'r' && COMPILE_DATE[1u] == 'a') ? 3u /*Mar*/ \
: (COMPILE_DATE[2u] == 'r') ? 4u /*Apr*/ \
: (COMPILE_DATE[2u] == 'y') ? 5u /*May*/ \
: (COMPILE_DATE[2u] == 'n') ? 6u /*Jun*/ \
: (COMPILE_DATE[2u] == 'l') ? 7u /*Jul*/ \
: (COMPILE_DATE[2u] == 'g') ? 8u /*Aug*/ \
: (COMPILE_DATE[2u] == 'p') ? 9u /*Sep*/ \
: (COMPILE_DATE[2u] == 't') ? 10u /*Oct*/ \
: (COMPILE_DATE[2u] == 'v') ? 11u /*Nov*/ \
: 12u /*Dec*/)
#define COMPILE_DAY_INT (\
(COMPILE_DATE[4u] == ' ' ? 0 : COMPILE_DATE[4u] - '0') * 10u + \
(COMPILE_DATE[5u] - '0') \
)
/* __TIME__ expands to an eight-character string constant */
/* "23:59:01", or (if cannot determine time) "??:??:??" */
#define COMPILE_HOUR_INT (\
(COMPILE_TIME[0u] == '?' ? 0 : COMPILE_TIME[0u] - '0') * 10u \
+ (COMPILE_TIME[1u] == '?' ? 0 : COMPILE_TIME[1u] - '0'))
#define COMPILE_MINUTE_INT (\
(COMPILE_TIME[3u] == '?' ? 0 : COMPILE_TIME[3u] - '0') * 10u \
+ (COMPILE_TIME[4u] == '?' ? 0 : COMPILE_TIME[4u] - '0'))
#define COMPILE_SECONDS_INT (\
(COMPILE_TIME[6u] == '?' ? 0 : COMPILE_TIME[6u] - '0') * 10u \
+ (COMPILE_TIME[7u] == '?' ? 0 : COMPILE_TIME[7u] - '0'))
#define COMPILE_DOS_DATE (\
((COMPILE_YEAR_INT - 1980u) << 9u) | \
(COMPILE_MONTH_INT << 5u) | \
(COMPILE_DAY_INT << 0u))
#define COMPILE_DOS_TIME (\
(COMPILE_HOUR_INT << 11u) | \
(COMPILE_MINUTE_INT << 5u) | \
(COMPILE_SECONDS_INT << 0u))
#endif /* COMPILE_DATE_H */
|
//
// TTBatchActionHeaderView.h
// Turn Touch Remote
//
// Created by Samuel Clay on 12/20/15.
// Copyright © 2015 Turn Touch. All rights reserved.
//
#import <Cocoa/Cocoa.h>
#import "TTAppDelegate.h"
@interface TTBatchActionHeaderView : NSView <NSMenuDelegate>
@property (nonatomic, weak) TTAppDelegate *appDelegate;
@property (nonatomic) TTMode *mode;
@property (nonatomic) TTAction *batchAction;
- (instancetype)initWithTempMode:(TTMode *)_mode;
- (instancetype)initWithBatchAction:(TTAction *)_batchAction;
@end
|
#include <stdlib.h>
#include <math.h>
char*
eratosthenes(int n, int *c)
{
char* sieve;
int i, j, m;
if(n < 2)
return NULL;
*c = n-1; /* primes count */
m = (int) sqrt((double) n);
/* calloc initializes to zero */
sieve = calloc(n+1,sizeof(char));
sieve[0] = 1;
sieve[1] = 1;
for(i = 2; i <= m; i++)
if(!sieve[i])
for (j = i*i; j <= n; j += i)
if(!sieve[j]){
sieve[j] = 1;
--(*c);
}
return sieve;
}
|
/*
* Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
* From ASN.1 module "NGAP-Containers"
* found in "asn/ngap-15.8.0.asn1"
* `asn1c -fcompound-names -pdu=all -findirect-choice -fno-include-deps -gen-PER -no-gen-OER -no-gen-example -D ngap`
*/
#include "ASN_NGAP_ProtocolIE-Container.h"
#include "ASN_NGAP_ProtocolIE-Field.h"
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P0_constr_1 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P1_constr_3 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P2_constr_5 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P3_constr_7 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P4_constr_9 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P5_constr_11 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P6_constr_13 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P7_constr_15 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P8_constr_17 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P9_constr_19 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P10_constr_21 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P11_constr_23 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P12_constr_25 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P13_constr_27 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P14_constr_29 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P15_constr_31 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P16_constr_33 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P17_constr_35 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P18_constr_37 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P19_constr_39 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P20_constr_41 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P21_constr_43 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P22_constr_45 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P23_constr_47 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P24_constr_49 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P25_constr_51 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P26_constr_53 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P27_constr_55 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P28_constr_57 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P29_constr_59 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P30_constr_61 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P31_constr_63 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P32_constr_65 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P33_constr_67 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P34_constr_69 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P35_constr_71 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P36_constr_73 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P37_constr_75 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P38_constr_77 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P39_constr_79 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P40_constr_81 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P41_constr_83 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P42_constr_85 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P43_constr_87 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P44_constr_89 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P45_constr_91 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P46_constr_93 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P47_constr_95 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P48_constr_97 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P49_constr_99 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P50_constr_101 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P51_constr_103 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P52_constr_105 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P53_constr_107 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P54_constr_109 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P55_constr_111 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P56_constr_113 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P57_constr_115 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P58_constr_117 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P59_constr_119 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P60_constr_121 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P61_constr_123 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P62_constr_125 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P63_constr_127 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P64_constr_129 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P65_constr_131 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P66_constr_133 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P67_constr_135 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P68_constr_137 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P69_constr_139 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P70_constr_141 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P71_constr_143 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P72_constr_145 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P73_constr_147 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P74_constr_149 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P75_constr_151 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P76_constr_153 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P77_constr_155 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P78_constr_157 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_per_constraints_t asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P79_constr_159 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 16, 16, 0, 65535 } /* (SIZE(0..65535)) */,
0, 0 /* No PER value map */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P0_1[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceSetupRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P0_specs_1 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P0),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P0, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0_tags_1,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0_tags_1)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0_tags_1[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0_tags_1, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0_tags_1)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P0_tags_1[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P0_constr_1, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P0_1,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P0_specs_1 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P1_3[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceSetupResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1_tags_3[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P1_specs_3 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P1),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P1, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1_tags_3,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1_tags_3)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1_tags_3[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1_tags_3, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1_tags_3)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P1_tags_3[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P1_constr_3, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P1_3,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P1_specs_3 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P2_5[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceReleaseCommandIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2_tags_5[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P2_specs_5 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P2),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P2, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2_tags_5,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2_tags_5)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2_tags_5[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2_tags_5, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2_tags_5)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P2_tags_5[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P2_constr_5, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P2_5,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P2_specs_5 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P3_7[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceReleaseResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3_tags_7[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P3_specs_7 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P3),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P3, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3_tags_7,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3_tags_7)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3_tags_7[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3_tags_7, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3_tags_7)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P3_tags_7[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P3_constr_7, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P3_7,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P3_specs_7 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P4_9[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceModifyRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4_tags_9[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P4_specs_9 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P4),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P4, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4_tags_9,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4_tags_9)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4_tags_9[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4_tags_9, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4_tags_9)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P4_tags_9[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P4_constr_9, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P4_9,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P4_specs_9 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P5_11[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceModifyResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5_tags_11[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P5_specs_11 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P5),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P5, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5_tags_11,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5_tags_11)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5_tags_11[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5_tags_11, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5_tags_11)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P5_tags_11[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P5_constr_11, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P5_11,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P5_specs_11 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P6_13[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceNotifyIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6_tags_13[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P6_specs_13 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P6),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P6, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6_tags_13,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6_tags_13)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6_tags_13[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6_tags_13, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6_tags_13)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P6_tags_13[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P6_constr_13, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P6_13,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P6_specs_13 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P7_15[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceModifyIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7_tags_15[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P7_specs_15 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P7),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P7, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7_tags_15,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7_tags_15)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7_tags_15[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7_tags_15, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7_tags_15)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P7_tags_15[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P7_constr_15, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P7_15,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P7_specs_15 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P8_17[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceModifyConfirmIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8_tags_17[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P8_specs_17 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P8),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P8, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8_tags_17,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8_tags_17)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8_tags_17[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8_tags_17, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8_tags_17)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P8_tags_17[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P8_constr_17, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P8_17,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P8_specs_17 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P9_19[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_InitialContextSetupRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9_tags_19[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P9_specs_19 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P9),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P9, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9_tags_19,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9_tags_19)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9_tags_19[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9_tags_19, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9_tags_19)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P9_tags_19[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P9_constr_19, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P9_19,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P9_specs_19 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P10_21[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_InitialContextSetupResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10_tags_21[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P10_specs_21 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P10),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P10, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10_tags_21,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10_tags_21)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10_tags_21[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10_tags_21, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10_tags_21)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P10_tags_21[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P10_constr_21, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P10_21,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P10_specs_21 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P11_23[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_InitialContextSetupFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11_tags_23[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P11_specs_23 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P11),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P11, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11_tags_23,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11_tags_23)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11_tags_23[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11_tags_23, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11_tags_23)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P11_tags_23[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P11_constr_23, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P11_23,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P11_specs_23 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P12_25[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UEContextReleaseRequest_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12_tags_25[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P12_specs_25 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P12),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P12, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12_tags_25,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12_tags_25)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12_tags_25[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12_tags_25, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12_tags_25)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P12_tags_25[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P12_constr_25, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P12_25,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P12_specs_25 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P13_27[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UEContextReleaseCommand_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13_tags_27[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P13_specs_27 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P13),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P13, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13_tags_27,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13_tags_27)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13_tags_27[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13_tags_27, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13_tags_27)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P13_tags_27[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P13_constr_27, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P13_27,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P13_specs_27 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P14_29[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UEContextReleaseComplete_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14_tags_29[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P14_specs_29 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P14),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P14, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14_tags_29,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14_tags_29)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14_tags_29[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14_tags_29, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14_tags_29)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P14_tags_29[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P14_constr_29, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P14_29,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P14_specs_29 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P15_31[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UEContextModificationRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15_tags_31[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P15_specs_31 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P15),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P15, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15_tags_31,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15_tags_31)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15_tags_31[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15_tags_31, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15_tags_31)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P15_tags_31[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P15_constr_31, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P15_31,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P15_specs_31 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P16_33[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UEContextModificationResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16_tags_33[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P16_specs_33 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P16),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P16, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16_tags_33,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16_tags_33)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16_tags_33[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16_tags_33, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16_tags_33)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P16_tags_33[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P16_constr_33, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P16_33,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P16_specs_33 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P17_35[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UEContextModificationFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17_tags_35[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P17_specs_35 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P17),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P17, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17_tags_35,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17_tags_35)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17_tags_35[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17_tags_35, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17_tags_35)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P17_tags_35[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P17_constr_35, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P17_35,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P17_specs_35 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P18_37[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_RRCInactiveTransitionReportIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18_tags_37[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P18_specs_37 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P18),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P18, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18_tags_37,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18_tags_37)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18_tags_37[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18_tags_37, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18_tags_37)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P18_tags_37[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P18_constr_37, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P18_37,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P18_specs_37 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P19_39[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverRequiredIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19_tags_39[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P19_specs_39 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P19),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P19, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19_tags_39,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19_tags_39)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19_tags_39[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19_tags_39, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19_tags_39)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P19_tags_39[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P19_constr_39, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P19_39,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P19_specs_39 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P20_41[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverCommandIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20_tags_41[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P20_specs_41 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P20),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P20, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20_tags_41,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20_tags_41)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20_tags_41[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20_tags_41, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20_tags_41)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P20_tags_41[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P20_constr_41, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P20_41,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P20_specs_41 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P21_43[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverPreparationFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21_tags_43[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P21_specs_43 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P21),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P21, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21_tags_43,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21_tags_43)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21_tags_43[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21_tags_43, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21_tags_43)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P21_tags_43[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P21_constr_43, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P21_43,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P21_specs_43 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P22_45[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22_tags_45[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P22_specs_45 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P22),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P22, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22_tags_45,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22_tags_45)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22_tags_45[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22_tags_45, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22_tags_45)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P22_tags_45[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P22_constr_45, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P22_45,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P22_specs_45 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P23_47[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverRequestAcknowledgeIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23_tags_47[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P23_specs_47 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P23),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P23, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23_tags_47,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23_tags_47)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23_tags_47[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23_tags_47, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23_tags_47)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P23_tags_47[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P23_constr_47, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P23_47,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P23_specs_47 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P24_49[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24_tags_49[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P24_specs_49 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P24),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P24, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24_tags_49,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24_tags_49)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24_tags_49[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24_tags_49, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24_tags_49)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P24_tags_49[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P24_constr_49, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P24_49,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P24_specs_49 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P25_51[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverNotifyIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25_tags_51[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P25_specs_51 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P25),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P25, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25_tags_51,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25_tags_51)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25_tags_51[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25_tags_51, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25_tags_51)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P25_tags_51[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P25_constr_51, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P25_51,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P25_specs_51 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P26_53[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PathSwitchRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26_tags_53[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P26_specs_53 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P26),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P26, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26_tags_53,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26_tags_53)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26_tags_53[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26_tags_53, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26_tags_53)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P26_tags_53[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P26_constr_53, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P26_53,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P26_specs_53 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P27_55[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PathSwitchRequestAcknowledgeIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27_tags_55[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P27_specs_55 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P27),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P27, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27_tags_55,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27_tags_55)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27_tags_55[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27_tags_55, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27_tags_55)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P27_tags_55[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P27_constr_55, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P27_55,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P27_specs_55 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P28_57[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PathSwitchRequestFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28_tags_57[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P28_specs_57 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P28),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P28, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28_tags_57,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28_tags_57)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28_tags_57[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28_tags_57, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28_tags_57)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P28_tags_57[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P28_constr_57, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P28_57,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P28_specs_57 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P29_59[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverCancelIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29_tags_59[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P29_specs_59 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P29),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P29, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29_tags_59,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29_tags_59)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29_tags_59[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29_tags_59, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29_tags_59)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P29_tags_59[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P29_constr_59, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P29_59,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P29_specs_59 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P30_61[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_HandoverCancelAcknowledgeIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30_tags_61[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P30_specs_61 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P30),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P30, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30_tags_61,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30_tags_61)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30_tags_61[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30_tags_61, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30_tags_61)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P30_tags_61[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P30_constr_61, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P30_61,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P30_specs_61 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P31_63[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UplinkRANStatusTransferIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31_tags_63[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P31_specs_63 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P31),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P31, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31_tags_63,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31_tags_63)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31_tags_63[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31_tags_63, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31_tags_63)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P31_tags_63[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P31_constr_63, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P31_63,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P31_specs_63 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P32_65[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_DownlinkRANStatusTransferIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32_tags_65[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P32_specs_65 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P32),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P32, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32_tags_65,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32_tags_65)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32_tags_65[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32_tags_65, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32_tags_65)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P32_tags_65[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P32_constr_65, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P32_65,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P32_specs_65 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P33_67[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PagingIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33_tags_67[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P33_specs_67 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P33),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P33, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33_tags_67,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33_tags_67)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33_tags_67[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33_tags_67, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33_tags_67)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P33_tags_67[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P33_constr_67, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P33_67,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P33_specs_67 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P34_69[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_InitialUEMessage_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34_tags_69[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P34_specs_69 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P34),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P34, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34_tags_69,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34_tags_69)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34_tags_69[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34_tags_69, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34_tags_69)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P34_tags_69[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P34_constr_69, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P34_69,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P34_specs_69 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P35_71[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_DownlinkNASTransport_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35_tags_71[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P35_specs_71 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P35),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P35, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35_tags_71,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35_tags_71)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35_tags_71[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35_tags_71, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35_tags_71)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P35_tags_71[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P35_constr_71, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P35_71,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P35_specs_71 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P36_73[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UplinkNASTransport_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36_tags_73[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P36_specs_73 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P36),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P36, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36_tags_73,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36_tags_73)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36_tags_73[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36_tags_73, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36_tags_73)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P36_tags_73[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P36_constr_73, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P36_73,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P36_specs_73 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P37_75[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_NASNonDeliveryIndication_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37_tags_75[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P37_specs_75 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P37),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P37, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37_tags_75,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37_tags_75)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37_tags_75[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37_tags_75, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37_tags_75)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P37_tags_75[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P37_constr_75, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P37_75,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P37_specs_75 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P38_77[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_RerouteNASRequest_IEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38_tags_77[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P38_specs_77 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P38),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P38, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38_tags_77,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38_tags_77)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38_tags_77[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38_tags_77, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38_tags_77)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P38_tags_77[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P38_constr_77, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P38_77,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P38_specs_77 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P39_79[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_NGSetupRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39_tags_79[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P39_specs_79 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P39),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P39, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39_tags_79,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39_tags_79)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39_tags_79[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39_tags_79, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39_tags_79)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P39_tags_79[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P39_constr_79, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P39_79,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P39_specs_79 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P40_81[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_NGSetupResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40_tags_81[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P40_specs_81 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P40),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P40, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40_tags_81,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40_tags_81)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40_tags_81[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40_tags_81, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40_tags_81)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P40_tags_81[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P40_constr_81, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P40_81,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P40_specs_81 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P41_83[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_NGSetupFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41_tags_83[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P41_specs_83 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P41),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P41, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41_tags_83,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41_tags_83)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41_tags_83[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41_tags_83, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41_tags_83)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P41_tags_83[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P41_constr_83, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P41_83,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P41_specs_83 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P42_85[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_RANConfigurationUpdateIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42_tags_85[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P42_specs_85 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P42),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P42, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42_tags_85,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42_tags_85)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42_tags_85[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42_tags_85, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42_tags_85)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P42_tags_85[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P42_constr_85, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P42_85,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P42_specs_85 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P43_87[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_RANConfigurationUpdateAcknowledgeIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43_tags_87[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P43_specs_87 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P43),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P43, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43_tags_87,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43_tags_87)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43_tags_87[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43_tags_87, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43_tags_87)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P43_tags_87[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P43_constr_87, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P43_87,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P43_specs_87 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P44_89[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_RANConfigurationUpdateFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44_tags_89[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P44_specs_89 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P44),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P44, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44_tags_89,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44_tags_89)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44_tags_89[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44_tags_89, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44_tags_89)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P44_tags_89[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P44_constr_89, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P44_89,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P44_specs_89 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P45_91[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_AMFConfigurationUpdateIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45_tags_91[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P45_specs_91 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P45),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P45, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45_tags_91,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45_tags_91)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45_tags_91[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45_tags_91, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45_tags_91)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P45_tags_91[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P45_constr_91, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P45_91,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P45_specs_91 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P46_93[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_AMFConfigurationUpdateAcknowledgeIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46_tags_93[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P46_specs_93 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P46),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P46, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46_tags_93,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46_tags_93)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46_tags_93[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46_tags_93, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46_tags_93)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P46_tags_93[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P46_constr_93, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P46_93,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P46_specs_93 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P47_95[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_AMFConfigurationUpdateFailureIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47_tags_95[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P47_specs_95 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P47),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P47, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47_tags_95,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47_tags_95)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47_tags_95[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47_tags_95, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47_tags_95)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P47_tags_95[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P47_constr_95, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P47_95,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P47_specs_95 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P48_97[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_AMFStatusIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48_tags_97[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P48_specs_97 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P48),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P48, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48_tags_97,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48_tags_97)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48_tags_97[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48_tags_97, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48_tags_97)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P48_tags_97[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P48_constr_97, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P48_97,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P48_specs_97 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P49_99[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_NGResetIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49_tags_99[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P49_specs_99 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P49),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P49, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49_tags_99,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49_tags_99)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49_tags_99[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49_tags_99, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49_tags_99)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P49_tags_99[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P49_constr_99, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P49_99,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P49_specs_99 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P50_101[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_NGResetAcknowledgeIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50_tags_101[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P50_specs_101 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P50),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P50, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50_tags_101,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50_tags_101)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50_tags_101[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50_tags_101, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50_tags_101)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P50_tags_101[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P50_constr_101, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P50_101,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P50_specs_101 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P51_103[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_ErrorIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51_tags_103[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P51_specs_103 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P51),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P51, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51_tags_103,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51_tags_103)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51_tags_103[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51_tags_103, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51_tags_103)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P51_tags_103[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P51_constr_103, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P51_103,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P51_specs_103 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P52_105[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_OverloadStartIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52_tags_105[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P52_specs_105 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P52),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P52, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52_tags_105,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52_tags_105)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52_tags_105[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52_tags_105, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52_tags_105)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P52_tags_105[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P52_constr_105, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P52_105,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P52_specs_105 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P53_107[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_OverloadStopIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53_tags_107[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P53_specs_107 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P53),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P53, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53_tags_107,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53_tags_107)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53_tags_107[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53_tags_107, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53_tags_107)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P53_tags_107[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P53_constr_107, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P53_107,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P53_specs_107 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P54_109[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UplinkRANConfigurationTransferIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54_tags_109[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P54_specs_109 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P54),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P54, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54_tags_109,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54_tags_109)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54_tags_109[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54_tags_109, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54_tags_109)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P54_tags_109[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P54_constr_109, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P54_109,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P54_specs_109 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P55_111[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_DownlinkRANConfigurationTransferIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55_tags_111[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P55_specs_111 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P55),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P55, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55_tags_111,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55_tags_111)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55_tags_111[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55_tags_111, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55_tags_111)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P55_tags_111[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P55_constr_111, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P55_111,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P55_specs_111 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P56_113[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_WriteReplaceWarningRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56_tags_113[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P56_specs_113 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P56),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P56, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56_tags_113,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56_tags_113)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56_tags_113[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56_tags_113, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56_tags_113)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P56_tags_113[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P56_constr_113, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P56_113,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P56_specs_113 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P57_115[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_WriteReplaceWarningResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57_tags_115[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P57_specs_115 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P57),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P57, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57_tags_115,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57_tags_115)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57_tags_115[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57_tags_115, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57_tags_115)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P57_tags_115[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P57_constr_115, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P57_115,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P57_specs_115 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P58_117[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PWSCancelRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58_tags_117[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P58_specs_117 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P58),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P58, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58_tags_117,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58_tags_117)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58_tags_117[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58_tags_117, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58_tags_117)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P58_tags_117[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P58_constr_117, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P58_117,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P58_specs_117 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P59_119[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PWSCancelResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59_tags_119[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P59_specs_119 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P59),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P59, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59_tags_119,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59_tags_119)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59_tags_119[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59_tags_119, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59_tags_119)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P59_tags_119[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P59_constr_119, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P59_119,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P59_specs_119 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P60_121[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PWSRestartIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60_tags_121[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P60_specs_121 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P60),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P60, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60_tags_121,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60_tags_121)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60_tags_121[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60_tags_121, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60_tags_121)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P60_tags_121[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P60_constr_121, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P60_121,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P60_specs_121 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P61_123[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PWSFailureIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61_tags_123[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P61_specs_123 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P61),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P61, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61_tags_123,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61_tags_123)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61_tags_123[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61_tags_123, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61_tags_123)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P61_tags_123[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P61_constr_123, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P61_123,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P61_specs_123 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P62_125[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_DownlinkUEAssociatedNRPPaTransportIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62_tags_125[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P62_specs_125 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P62),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P62, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62_tags_125,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62_tags_125)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62_tags_125[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62_tags_125, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62_tags_125)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P62_tags_125[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P62_constr_125, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P62_125,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P62_specs_125 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P63_127[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UplinkUEAssociatedNRPPaTransportIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63_tags_127[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P63_specs_127 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P63),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P63, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63_tags_127,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63_tags_127)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63_tags_127[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63_tags_127, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63_tags_127)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P63_tags_127[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P63_constr_127, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P63_127,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P63_specs_127 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P64_129[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_DownlinkNonUEAssociatedNRPPaTransportIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64_tags_129[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P64_specs_129 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P64),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P64, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64_tags_129,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64_tags_129)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64_tags_129[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64_tags_129, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64_tags_129)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P64_tags_129[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P64_constr_129, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P64_129,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P64_specs_129 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P65_131[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UplinkNonUEAssociatedNRPPaTransportIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65_tags_131[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P65_specs_131 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P65),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P65, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65_tags_131,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65_tags_131)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65_tags_131[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65_tags_131, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65_tags_131)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P65_tags_131[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P65_constr_131, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P65_131,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P65_specs_131 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P66_133[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_TraceStartIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66_tags_133[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P66_specs_133 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P66),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P66, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66_tags_133,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66_tags_133)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66_tags_133[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66_tags_133, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66_tags_133)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P66_tags_133[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P66_constr_133, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P66_133,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P66_specs_133 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P67_135[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_TraceFailureIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67_tags_135[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P67_specs_135 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P67),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P67, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67_tags_135,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67_tags_135)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67_tags_135[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67_tags_135, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67_tags_135)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P67_tags_135[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P67_constr_135, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P67_135,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P67_specs_135 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P68_137[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_DeactivateTraceIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68_tags_137[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P68_specs_137 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P68),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P68, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68_tags_137,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68_tags_137)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68_tags_137[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68_tags_137, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68_tags_137)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P68_tags_137[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P68_constr_137, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P68_137,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P68_specs_137 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P69_139[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_CellTrafficTraceIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69_tags_139[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P69_specs_139 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P69),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P69, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69_tags_139,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69_tags_139)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69_tags_139[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69_tags_139, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69_tags_139)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P69_tags_139[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P69_constr_139, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P69_139,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P69_specs_139 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P70_141[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_LocationReportingControlIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70_tags_141[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P70_specs_141 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P70),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P70, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70_tags_141,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70_tags_141)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70_tags_141[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70_tags_141, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70_tags_141)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P70_tags_141[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P70_constr_141, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P70_141,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P70_specs_141 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P71_143[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_LocationReportingFailureIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71_tags_143[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P71_specs_143 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P71),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P71, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71_tags_143,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71_tags_143)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71_tags_143[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71_tags_143, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71_tags_143)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P71_tags_143[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P71_constr_143, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P71_143,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P71_specs_143 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P72_145[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_LocationReportIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72_tags_145[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P72_specs_145 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P72),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P72, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72_tags_145,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72_tags_145)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72_tags_145[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72_tags_145, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72_tags_145)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P72_tags_145[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P72_constr_145, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P72_145,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P72_specs_145 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P73_147[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UETNLABindingReleaseRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73_tags_147[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P73_specs_147 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P73),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P73, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73_tags_147,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73_tags_147)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73_tags_147[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73_tags_147, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73_tags_147)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P73_tags_147[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P73_constr_147, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P73_147,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P73_specs_147 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P74_149[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UERadioCapabilityInfoIndicationIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74_tags_149[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P74_specs_149 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P74),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P74, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74_tags_149,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74_tags_149)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74_tags_149[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74_tags_149, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74_tags_149)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P74_tags_149[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P74_constr_149, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P74_149,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P74_specs_149 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P75_151[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UERadioCapabilityCheckRequestIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75_tags_151[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P75_specs_151 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P75),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P75, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75_tags_151,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75_tags_151)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75_tags_151[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75_tags_151, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75_tags_151)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P75_tags_151[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P75_constr_151, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P75_151,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P75_specs_151 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P76_153[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_UERadioCapabilityCheckResponseIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76_tags_153[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P76_specs_153 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P76),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P76, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76_tags_153,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76_tags_153)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76_tags_153[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76_tags_153, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76_tags_153)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P76_tags_153[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P76_constr_153, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P76_153,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P76_specs_153 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P77_155[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_SecondaryRATDataUsageReportIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77_tags_155[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P77_specs_155 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P77),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P77, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77_tags_155,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77_tags_155)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77_tags_155[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77_tags_155, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77_tags_155)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P77_tags_155[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P77_constr_155, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P77_155,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P77_specs_155 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P78_157[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceModifyRequestTransferIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78_tags_157[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P78_specs_157 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P78),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P78, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78_tags_157,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78_tags_157)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78_tags_157[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78_tags_157, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78_tags_157)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P78_tags_157[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P78_constr_157, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P78_157,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P78_specs_157 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P79_159[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_ASN_NGAP_PDUSessionResourceSetupRequestTransferIEs,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79_tags_159[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P79_specs_159 = {
sizeof(struct ASN_NGAP_ProtocolIE_Container_6810P79),
offsetof(struct ASN_NGAP_ProtocolIE_Container_6810P79, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79 = {
"ProtocolIE-Container",
"ProtocolIE-Container",
&asn_OP_SEQUENCE_OF,
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79_tags_159,
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79_tags_159)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79_tags_159[0]), /* 1 */
asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79_tags_159, /* Same as above */
sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79_tags_159)
/sizeof(asn_DEF_ASN_NGAP_ProtocolIE_Container_6810P79_tags_159[0]), /* 1 */
{ 0, &asn_PER_type_ASN_NGAP_ProtocolIE_Container_6810P79_constr_159, SEQUENCE_OF_constraint },
asn_MBR_ASN_NGAP_ProtocolIE_Container_6810P79_159,
1, /* Single element */
&asn_SPC_ASN_NGAP_ProtocolIE_Container_6810P79_specs_159 /* Additional specs */
};
|
//
// Collection of converters from/to java objects
//
#ifndef SPARK_EXAMPLE_CONVERTERS_H
#define SPARK_EXAMPLE_CONVERTERS_H
#include <jni.h>
#include <arrow/api.h>
#include <iostream>
using arrow::Status;
std::string get_java_string(JNIEnv *env, jstring java_string);
std::vector<std::string> get_java_string_array(JNIEnv *env, jobjectArray jstringArr);
std::vector<int> get_java_int_array(JNIEnv *env, jintArray java_field_indices);
// Copied from https://github.com/apache/arrow/blob/apache-arrow-0.17.0/cpp/src/gandiva/jni/jni_common.cc#L517
Status make_record_batch_with_buf_addrs(std::shared_ptr<arrow::Schema> schema, int,
jlong *, jlong *,
int,
std::shared_ptr<arrow::RecordBatch> *);
Status copy_record_batch_ito_buffers(JNIEnv* env, jobject jexpander,
std::shared_ptr<arrow::RecordBatch> recordBatch,
jlong *out_buf_addrs, jlong *out_buf_sizes,
int out_bufs_len);
#endif //SPARK_EXAMPLE_CONVERTERS_H
|
/*
* Copyright (c) 2012, Mao Jianjun <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef YACL_OBJECT_H
#define YACL_OBJECT_H
#include <assert.h>
#include <stddef.h>
#include <stdbool.h>
#include <yacl/__conf.h>
/**
* Object class.
* `_sizeof_` represents the byte size of its type(must greater than 0).
* `_init_` will *never* be used by YACL(can be `NULL`).
* `_initcp_` is the copy constructor, and used in containers(can't be `NULL`).
* `_del_` is the destructor, and used in containers, too(can be `NULL`).
*/
#undef def_object_z
#define def_object_z(object_t, ...) \
struct { \
size_t _sizeof_; \
\
object_t* (*_init_)(__VA_ARGS__); \
\
object_t* (*_initcp_)(object_t* self, const object_t* other); \
\
object_t* (*_del_)(object_t* self); \
}
/* object type */
typedef void object_t;
typedef def_object_z(object_t, void) object_z;
/* object instance helper */
object_t* make(object_z Object, ...); /* dummy func for auto-complete? */
#undef make
#define make(Object, ...) (Object)._init_(__VA_ARGS__)
void nmake(size_t n, object_z Object, ...);
#undef nmake /* FIXME: strange style... */
#define nmake(n, Object, ...) \
{ size_t i; for(i=0; i<n; i++) (Object)._init_(__VA_ARGS__); }
object_t* make_copy(object_z Object, object_t* self, const object_t* other);
#undef make_copy
#define make_copy(Object, self, other) (Object)._initcp_(self, other)
object_t* clean(object_z Object, object_t* self);
#undef clean
#define clean(Object, self) (Object)._del_(self)
void nclean(size_t n, object_z Object, object_t* i_self);
#undef nclean /* FIXME: strange style... */
#define nclean(n, Object, self) \
{ size_t i; for(i=0; i<n; i++) (Object)._del_(self); }
/* Object reference class */
#undef def_ref_z
#define def_ref_z(ref_t, ...) \
struct { \
def_object_z(ref_t, __VA_ARGS__); \
\
object_t* (*value)(ref_t ref);\
\
ref_t (*next)(ref_t ref); \
\
ref_t (*next_n)(ref_t ref, ptrdiff_t n); \
\
ptrdiff_t (*dist)(ref_t first, ref_t last); \
}
/* reference */
typedef object_t* ref_t;
typedef def_ref_z(ref_t, void) ref_z;
/* func types */
typedef bool(cmp_f)(const object_t*, const object_t*);
typedef size_t(hash_f)(const object_t*);
/* comparable class */
#undef def_objcmp_z
#define def_objcmp_z(object_t, ...) \
struct { \
def_object_z(object_t, __VA_ARGS__); \
size_t (*_hash_)(const object_t* self); \
bool (*_lt_)(const object_t* self, const object_t* other); \
bool (*_le_)(const object_t* self, const object_t* other); \
bool (*_eq_)(const object_t* self, const object_t* other); \
bool (*_ne_)(const object_t* self, const object_t* other); \
bool (*_gt_)(const object_t* self, const object_t* other); \
bool (*_ge_)(const object_t* self, const object_t* other); \
}
/* comparable object */
typedef object_t objcmp_t;
typedef def_objcmp_z(objcmp_t, void) objcmp_z;
/* -- built in types --*/
typedef void* ptr_t;
typedef def_objcmp_z(ptr_t, ptr_t* self) ptr_z;
extern const ptr_z Ptr; /* void* */
typedef def_objcmp_z(ptrdiff_t, ptrdiff_t* self) ptrdiff_z;
extern const ptrdiff_z Ptrdiff; /* ptrdiff_t */
typedef def_objcmp_z(size_t, size_t* self) size_z;
extern const size_z Size; /* size_t */
typedef def_objcmp_z(char, char* self) char_z;
extern const char_z Char; /* char */
typedef def_objcmp_z(signed char, signed char* self) schar_z;
extern const schar_z SChar; /* signed char */
typedef def_objcmp_z(unsigned char, unsigned char* self) uchar_z;
extern const uchar_z UChar; /* unsigned char */
typedef def_objcmp_z(short, short* self) short_z;
extern const short_z Short; /* short */
typedef def_objcmp_z(unsigned short, unsigned short* self) ushort_z;
extern const ushort_z UShort; /* unsigned short */
typedef def_objcmp_z(int, int* self) int_z;
extern const int_z Int; /* int */
typedef def_objcmp_z(unsigned int, unsigned int* self) uint_z;
extern const uint_z UInt; /* unsigned int */
typedef def_objcmp_z(long, long* self) long_z;
extern const long_z Long; /* long */
typedef def_objcmp_z(unsigned long, unsigned long* self) ulong_z;
extern const ulong_z ULong; /* unsigned long */
typedef def_objcmp_z(float, float* self) float_z;
extern const float_z Float; /* float */
typedef def_objcmp_z(double, double* self) double_z;
extern const double_z Double; /* double */
#ifdef YACL_LONGLONG
typedef def_objcmp_z(long long, long long* self) llong_z;
extern const llong_z LLong; /* long long */
typedef def_objcmp_z(unsigned long long, unsigned long long* self) ullong_z;
extern const ullong_z ULLong; /* unsigned long long */
#endif /* YACL_LONGLONG */
/* C string type */
typedef char* cstring_t;
/* C string class */
typedef struct{
def_objcmp_z(cstring_t, void);
size_t (*size)(const char* cstr); /* strlen */
char* (*concat)(char* cstr, const char* other); /* strcat */
char* (*concat_n)(char* cstr, const char* other, size_t n); /* strncat */
char* (*copy)(char* cstr, const char* other); /* strcpy */
char* (*copy_n)(char* cstr, const char* other, size_t n); /* strncpy */
char* (*find)(const char* cstr, int c); /* strchr */
char* (*rfind)(const char* cstr, int c); /* strrchr */
char* (*find_sub)(const char* cstr, const char* sub); /* strstr */
/**
* Find `cstr` for the first occurrence of a char is in `set`.
* Returns reference (NULL for not found).
*/
char* (*first_in)(const char* cstr, const char* set); /* strpbrk */
/**
* Find `cstr` for the first absence of a char is in `set`.
* Returns reference (NULL for not found).
*/
char* (*first_not_in)(const char* cstr, const char* set); /* strspn */
/**
* Return the length of the initial portion of `cstr` containing chars in `set`.
* Used as first not in ??
*/
size_t (*match_set)(const char* cstr, const char* set); /* strspn */
int (*to_int)(const char* cstr); /* atoi */
long (*to_long)(const char* cstr); /* atol */
long (*to_long0)(const char* cstr, char** err, int base); /* strtol */
unsigned long (*to_ulong0)(const char* cstr, char** err, int base); /* strtoul */
long long (*to_llong)(const char* cstr); /* atoll */
long long (*to_llong0)(const char* cstr, char** err, int base); /* strtoll */
unsigned long long (*to_ullong0)(const char* cstr, char** err, int base); /* strtoull */
double (*to_double)(const char* cstr);
float (*to_float0)(const char* cstr, char** err); /* strtof */
double (*to_double0)(const char* cstr, char** err); /* strtod */
} cstring_z;
/* c string class instance */
extern const cstring_z CString;
#endif /* YACL_OBJECT_H */
|
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* linux/sound/cs42l52.h -- Platform data for CS42L52
*
* Copyright (c) 2012 Cirrus Logic Inc.
*/
#ifndef __CS42L52_H
#define __CS42L52_H
struct cs42l52_platform_data {
/* MICBIAS Level. Check datasheet Pg48 */
unsigned int micbias_lvl;
/* MICA mode selection Differential or Single-ended */
bool mica_diff_cfg;
/* MICB mode selection Differential or Single-ended */
bool micb_diff_cfg;
/* Charge Pump Freq. Check datasheet Pg73 */
unsigned int chgfreq;
/* Reset GPIO */
unsigned int reset_gpio;
};
#endif /* __CS42L52_H */
|
#pragma once
/**
* This header provides configuration defaults for ili9325 lib.
*
* The preferred way of configuring is to override current default values with user ones
* in separate config file (or using compilation-time -DDEFINES) instead of directly modifying
* this file.
*
*/
/*Make library code smaller at the cost of performance penalty */
#define _USE_SIZE_OPTIMIZATIONS 0
#if !defined(ILI9325_USE_SIZE_OPTIMIZATIONS)
#define ILI9325_USE_SIZE_OPTIMIZATIONS (_USE_SIZE_OPTIMIZATIONS)
#endif
//#define HAL
#define _LIBOPENCM3 0
#define _LIBHAL 1
#if !defined(HAL)
#define MCU_LIB (_LIBOPENCM3)
#else
#define MCU_LIB (_LIBHAL)
#endif
|
///
/// @file
///
/// @brief This file contains code which is related segments.
///
/// @author Mirko Myllykoski ([email protected]), Umeå University
///
/// @internal LICENSE
///
/// Copyright (c) 2019-2020, Umeå Universitet
///
/// Redistribution and use in source and binary forms, with or without
/// modification, are permitted provided that the following conditions are met:
///
/// 1. Redistributions of source code must retain the above copyright notice,
/// this list of conditions and the following disclaimer.
///
/// 2. Redistributions in binary form must reproduce the above copyright notice,
/// this list of conditions and the following disclaimer in the documentation
/// and/or other materials provided with the distribution.
///
/// 3. Neither the name of the copyright holder nor the names of its
/// contributors may be used to endorse or promote products derived from this
/// software without specific prior written permission.
///
/// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
/// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
/// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
/// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
/// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
/// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
/// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
/// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
/// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
/// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
/// POSSIBILITY OF SUCH DAMAGE.
///
#ifndef STARNEIG_SCHUR_SEGMENT_H
#define STARNEIG_SCHUR_SEGMENT_H
#include <starneig_config.h>
#include <starneig/configuration.h>
#include "process_args.h"
#include <starpu.h>
///
/// @brief Segment status enumerator.
///
/// At an any given moment, a segment is in one of the following states:
///
enum segment_status {
SEGMENT_EMPTY = 0, ///< empty segment
SEGMENT_BOOTSTRAP, ///< segment is waiting for a bootstrap sequence
SEGMENT_NEW, ///< segment should go through a new iteration
SEGMENT_SMALL, ///< small (sequential) QR algorithm in progress
SEGMENT_AED_SMALL, ///< small (sequential) AED in progress
SEGMENT_AED_SCHUR, ///< AED window is being reduced to Schur form
SEGMENT_AED_DEFLATE, ///< AED window is being deflated
SEGMENT_BULGES, ///< bulge chasing in progress
SEGMENT_CHILDREN, ///< segment has been divided into sub-segments
SEGMENT_CONVERGED, ///< segment has converged
SEGMENT_FAILURE ///< an error has occurred while processing the segment
};
struct segment_list;
///
/// @brief Segment structure.
///
struct segment {
/// segment status
enum segment_status status;
/// segment iteration counter
int iter;
/// first row/column that belongs to the segment
int begin;
/// last row/column that belongs to the segment + 1
int end;
/// when the segment is in the state SEGMENT_SMALL, this handle
/// encapsulates the matching small QR window task status structure
starpu_data_handle_t small_status_h;
/// when the segment is in the state SEGMENT_AED_*, this variable
/// stores the first row/column that belongs the padded AED window
int aed_begin;
/// stores the number of failed AEDs
int aed_failed;
/// Allocator for AED related tasks. Used when the segment is in the states
/// SEGMENT_AED_SCHUR and SEGMENT_AED_DEFLATE.
struct allocator *aed_allocator;
/// when the segment is in the state SEGMENT_AED_*, this handle
/// encapsulates the matching AED window task status structure
starpu_data_handle_t aed_status_h;
/// when the segment is in the state SEGMENT_AED_SMALL, this handle
/// encapsulates the matching left-hand side AED transformation matrix
starpu_data_handle_t aed_small_lQ_h;
/// when the segment is in the state SEGMENT_AED_SMALL, this handle
/// encapsulates the matching right-hand side AED transformation matrix
starpu_data_handle_t aed_small_lZ_h;
/// when the segment is in the state SEGMENT_AED_SCHUR or
/// SEGMENT_AED_DEFLATE, this variable stores the segment processing
/// arguments for the matching AED sub-matrix
struct process_args aed_args;
/// when the segment is in the state SEGMENT_AED_DEFLATE, this
//// variable stores the location where the next batch of undeflated
/// blocks should be moved inside the padded AED window
int aed_deflate_top;
/// when the segment is in the state SEGMENT_AED_DEFLATE, this
/// variable stores the location of the topmost deflated block inside
/// the padded AED window
int aed_deflate_bottom;
/// when the segment is in the state SEGMENT_AED_DEFLATE, this handle
/// encapsulates the matching deflate window task status structure
starpu_data_handle_t aed_deflate_status_h;
/// when the segment is in the state SEGMENT_AED_DEFLATE, this handle
/// encapsulates the spike inducer (the sub-diagonal entry to the
/// left of the AED window)
starpu_data_handle_t aed_deflate_inducer_h;
/// when the segment is in the state SEGMENT_AED_DEFLATE, this handle
/// encapsulates the spike base (the first row from AED
/// transformation matrix)
starneig_vector_t aed_deflate_base;
/// when the segment is in the state SEGMENT_BULGES, this variable
/// stores the number of computed shifts
int computed_shifts;
/// when the segment is in the state SEGMENT_BULGES, this vectors
/// stores the real parts of the computed shifts
starneig_vector_t shifts_real;
/// when the segment is in the state SEGMENT_BULGES, this vectors
/// stores the imaginary parts of the computed shifts
starneig_vector_t shifts_imag;
/// bulge chasing aftermath vector
starneig_vector_t bulges_aftermath;
/// peaks submitted task count (recorded just after the bulges have
/// been inserted)
int peak_submitted;
/// time when pead_submitted got recorded
double peak_time;
/// calculated submitted tasks slope (i.e. the rate at which the
/// tasks get consumed)
double slope;
/// sub-segments
struct segment_list *children;
/// previous/upper segment
struct segment *up;
/// next/lower segment
struct segment *down;
};
///
/// @brief Segment list.
///
struct segment_list {
struct segment *top; ///< first/topmost segment
struct segment *bottom; ///< last/bottom segment
};
///
/// @brief Creates a new segment.
///
/// @param[in] status segment status
/// @param[in] begin first row that belongs to the segment
/// @param[in] end last row that belongs to the segment + 1
///
/// @return new segment
///
struct segment * starneig_create_segment(
enum segment_status status, int begin, int end);
///
/// @brief Moves the contents of a segment to a new segment.
///
/// The old segment retains the list pointers (up and down). The new segment is
/// not linked (up and down are NULL).
///
/// @param[in,out] segment segment whose contents are to be copied
///
/// @return new segment with identical contents
///
struct segment * starneig_move_segment(struct segment *segment);
///
/// @brief Frees a previously allocated segment.
///
/// @param[in,out] segment segment to be freed
///
void starneig_free_segment(struct segment *segment);
///
/// @brief Creates an empty segment list.
///
/// @return empty segment list
///
struct segment_list * starneig_create_segment_list();
///
/// @brief Adds a segment to the beginning/top of a segment list.
///
/// @param[in,out] segment segment to be added to the segment list
/// @param[in,out] list segment list
///
void starneig_add_segment_to_list_top(
struct segment *segment, struct segment_list *list);
///
/// @brief Adds a segment to the end/bottom of a segment list.
///
/// @param[in,out] segment segment to be added segment list
/// @param[in,out] end segment list
///
void starneig_add_segment_to_list_bottom(
struct segment *segment, struct segment_list *list);
///
/// @brief Removes a segment from a segment list.
///
/// @param[in,out] segment segment to be removed from the segment list
/// @param[in,out] list segment list
///
void starneig_remove_segment_from_list(
struct segment *segment, struct segment_list *list);
///
/// @brief Replaces a segment with a segment list.
///
/// @param[in,out] segment segment to be replaced
/// @param[in,out] sub_list segment list that replaces the segment
/// @param[in,out] list segment list that contains the segment
///
void starneig_replace_segment_with_list(struct segment *segment,
struct segment_list *sublist, struct segment_list *list);
///
/// @brief Frees a previously allocated segment list.
///
/// @param[in,out] list segment list to be freed
///
void starneig_free_segment_list(struct segment_list *list);
#endif
|
// SDLSetDisplayLayout.h
//
#import "SDLRPCRequest.h"
#import "SDLPredefinedLayout.h"
/**
* Used to set an alternate display layout. If not sent, default screen for
* given platform will be shown
*
* Since SmartDeviceLink 2.0
*/
NS_ASSUME_NONNULL_BEGIN
@interface SDLSetDisplayLayout : SDLRPCRequest
- (instancetype)initWithPredefinedLayout:(SDLPredefinedLayout)predefinedLayout;
- (instancetype)initWithLayout:(NSString *)displayLayout;
/**
* @abstract A display layout. Predefined or dynamically created screen layout.
* Currently only predefined screen layouts are defined. Predefined layouts
* include: "ONSCREEN_PRESETS" Custom screen containing app-defined onscreen
* presets. Currently defined for GEN2
*/
@property (strong, nonatomic) NSString *displayLayout;
@end
NS_ASSUME_NONNULL_END
|
/* Generated by RuntimeBrowser
Image: /System/Library/Frameworks/NetworkExtension.framework/NetworkExtension
*/
@interface NETunnelNetworkSettings : NSObject <NEConfigurationValidating, NEPrettyDescription, NSCopying, NSSecureCoding> {
NEDNSSettings * _DNSSettings;
NEProxySettings * _proxySettings;
NSString * _tunnelRemoteAddress;
}
@property (copy) NEDNSSettings *DNSSettings;
@property (copy) NEProxySettings *proxySettings;
@property (readonly) NSString *tunnelRemoteAddress;
+ (bool)supportsSecureCoding;
- (void).cxx_destruct;
- (id)DNSSettings;
- (bool)checkValidityAndCollectErrors:(id)arg1;
- (id)copyWithZone:(struct _NSZone { }*)arg1;
- (id)descriptionWithIndent:(int)arg1 options:(unsigned long long)arg2;
- (void)encodeWithCoder:(id)arg1;
- (id)initFromLegacyDictionary:(id)arg1;
- (id)initWithCoder:(id)arg1;
- (id)initWithTunnelRemoteAddress:(id)arg1;
- (id)proxySettings;
- (void)setDNSSettings:(id)arg1;
- (void)setProxySettings:(id)arg1;
- (id)tunnelRemoteAddress;
@end
|
/*
* "ex" API implementation
* http://lua-users.org/wiki/ExtensionProposal
* Copyright 2007 Mark Edgar < medgar at student gc maricopa edu >
*/
#ifndef pusherror_h
#define pusherror_h
#if defined(_WIN32)
#include <windows.h>
#endif
#include "lua.h"
#if defined(_WIN32)
int windows_pusherror(lua_State *L, DWORD error, int nresults);
#define windows_pushlasterror(L) windows_pusherror(L, GetLastError(), -2)
#define push_error(L) windows_pushlasterror(L)
#else
#include <string.h>
#include <errno.h>
int push_error(lua_State *L);
#endif
#endif/*pusherror_h*/
|
#pragma once
#include "basic_eipc.h"
_MANGO_PACK_PUSH
_MANGO_NAMESPACE_BEGIN
namespace interprocess
{
namespace eipc
{
class client :
public _mangodetail::interprocess::eipc::basic_eipc
{
public:
client()
{
m_inited = false;
}
~client()
{
disconnect();
}
public:
/// @brief
/// @param server_name 此名字是共享内存对象的名字,即便不是同一个进程,也不能重复
/// @param client_name 此名字是共享内存对象的名字,即便不是同一个进程,也不能重复
/// @param buffer_size 共享内存大小
/// @return 如果连接正常,返回 true
bool connect(std::string server_name,
std::string client_name,
size_t buffer_size)
{
bool result = true;
size_t first_buffer_size = buffer_size / 2;
size_t second_buffer_size = buffer_size - first_buffer_size;
return _connect(server_name, client_name, first_buffer_size, second_buffer_size);
}
bool disconnect()
{
if (m_inited)
{
_mangodetail::interprocess::eipc::protocol::package msg = {};
msg.req_disconnect.use_this(name());
_send_to_mq(msg);
_shared_memory_release();
m_inited = false;
}
return true;
}
inline std::string name()
{
return smo_name();
}
/// @brief 写入数据
template<typename _Ty>
inline write_result_t write(tag_t tag, _Ty& data)
{
return this->write(tag, sizeof(_Ty), &data);
}
/// @brief 写入数据
inline write_result_t write(tag_t tag, size_t size, void* data)
{
return m_second_buffer_queue.write(tag, size, data);
}
/// @brief 读取数据
inline read_result_t fast_read(content_ptr& con)
{
return m_first_buffer_queue.fast_read(&con);
}
/// @brief 读取数据
inline read_result_t fast_read(content_ptr& con, bool block, bool& block_quit_flag)
{
if (block) { m_first_buffer_queue.read_block(block_quit_flag); }
return m_first_buffer_queue.fast_read(&con);
}
inline void fast_read_release(content_ptr con)
{
return m_first_buffer_queue.fast_read_release(con);
}
private:
bool m_inited;
private:
bool _connect(std::string server_name,
std::string client_name,
size_t first_buffer_size,
size_t second_buffer_size)
{
bool result = true;
if (m_inited == false)
{
if (first_buffer_size < 50) first_buffer_size = 50;
if (second_buffer_size < 50) second_buffer_size = 50;
result = result && _create_shared_memory(
client_name, first_buffer_size, second_buffer_size);
result = result && _open_message_queue(server_name);
if (result == false) return result;
}
m_inited = true;
_mangodetail::interprocess::eipc::protocol::package msg = {};
msg.req_connect.use_this(client_name, first_buffer_size, second_buffer_size);
_send_to_mq(msg);
return result;
}
};
} // namespace eipc
} // namespace interprocess
_MANGO_NAMESPACE_END
_MANGO_PACK_POP
|
/* config.h. Generated automatically by configure. */
/* config.h.in. Generated automatically from configure.in by autoheader. */
/* Define to empty if the keyword does not work. */
/* #undef const */
/* Define as __inline if that's what the C compiler calls it. */
/* #undef inline */
/* Define as the return type of signal handlers (int or void). */
#define RETSIGTYPE void
/* Define if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Define if you can safely include both <sys/time.h> and <time.h>. */
/* #undef TIME_WITH_SYS_TIME */
/* Define if your processor stores words with the most significant
byte first (like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */
/* #undef GNU_MP */
#define CRYPTOLIB 1
#define HIGHFIRST 1
#define SHA1HANDSOFF 1
/* #undef POSIX_TERMIOS */
/* #undef POSIX_SIGTYPE */
#define PACKAGE "libsrp"
#define VERSION "1.2"
/* The number of bytes in a int. */
#define SIZEOF_INT 4
/* The number of bytes in a long. */
#define SIZEOF_LONG 4
/* The number of bytes in a short. */
#define SIZEOF_SHORT 2
/* Define if you have the memcpy function. */
#define HAVE_MEMCPY 1
/* Define if you have the strchr function. */
#define HAVE_STRCHR 1
/* Define if you have the <sgtty.h> header file. */
/* #undef HAVE_SGTTY_H */
/* Define if you have the <sys/ioctl.h> header file. */
/* #undef HAVE_SYS_IOCTL_H */
/* Define if you have the <sys/time.h> header file. */
/* #undef HAVE_SYS_TIME_H */
/* Define if you have the <termio.h> header file. */
/* #undef HAVE_TERMIO_H */
/* Define if you have the <termios.h> header file. */
/* #undef HAVE_TERMIOS_H */
|
/*
This file is part of the WebKit open source project.
This file has been generated by generate-bindings.pl. DO NOT MODIFY!
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef JSHTMLObjectElement_h
#define JSHTMLObjectElement_h
#include "JSHTMLElement.h"
#include <runtime/CallData.h>
#include <runtime/JSObjectWithGlobalObject.h>
namespace WebCore {
class HTMLObjectElement;
class JSHTMLObjectElement : public JSHTMLElement {
typedef JSHTMLElement Base;
public:
JSHTMLObjectElement(JSC::Structure*, JSDOMGlobalObject*, PassRefPtr<HTMLObjectElement>);
static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
bool getOwnPropertySlotDelegate(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&);
bool getOwnPropertyDescriptorDelegate(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&);
virtual void put(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSValue, JSC::PutPropertySlot&);
bool putDelegate(JSC::ExecState*, const JSC::Identifier&, JSC::JSValue, JSC::PutPropertySlot&);
static const JSC::ClassInfo s_info;
static JSC::Structure* createStructure(JSC::JSGlobalData& globalData, JSC::JSValue prototype)
{
return JSC::Structure::create(globalData, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
}
virtual JSC::CallType getCallData(JSC::CallData&);
static JSC::JSValue getConstructor(JSC::ExecState*, JSC::JSGlobalObject*);
protected:
static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
};
class JSHTMLObjectElementPrototype : public JSC::JSObjectWithGlobalObject {
typedef JSC::JSObjectWithGlobalObject Base;
public:
static JSC::JSObject* self(JSC::ExecState*, JSC::JSGlobalObject*);
static const JSC::ClassInfo s_info;
virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&);
virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&);
static JSC::Structure* createStructure(JSC::JSGlobalData& globalData, JSC::JSValue prototype)
{
return JSC::Structure::create(globalData, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
}
JSHTMLObjectElementPrototype(JSC::JSGlobalData& globalData, JSC::JSGlobalObject* globalObject, JSC::Structure* structure) : JSC::JSObjectWithGlobalObject(globalData, globalObject, structure) { }
protected:
static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
};
// Functions
JSC::EncodedJSValue JSC_HOST_CALL jsHTMLObjectElementPrototypeFunctionCheckValidity(JSC::ExecState*);
JSC::EncodedJSValue JSC_HOST_CALL jsHTMLObjectElementPrototypeFunctionSetCustomValidity(JSC::ExecState*);
JSC::EncodedJSValue JSC_HOST_CALL jsHTMLObjectElementPrototypeFunctionGetSVGDocument(JSC::ExecState*);
// Attributes
JSC::JSValue jsHTMLObjectElementForm(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
JSC::JSValue jsHTMLObjectElementCode(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementCode(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementAlign(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementAlign(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementArchive(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementArchive(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementBorder(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementBorder(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementCodeBase(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementCodeBase(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementCodeType(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementCodeType(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementData(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementData(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementDeclare(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementDeclare(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementHeight(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementHeight(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementHspace(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementHspace(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementName(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementName(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementStandby(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementStandby(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementType(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementType(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementUseMap(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementUseMap(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementVspace(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementVspace(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementWidth(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
void setJSHTMLObjectElementWidth(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
JSC::JSValue jsHTMLObjectElementWillValidate(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
JSC::JSValue jsHTMLObjectElementValidity(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
JSC::JSValue jsHTMLObjectElementValidationMessage(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
JSC::JSValue jsHTMLObjectElementContentDocument(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
JSC::JSValue jsHTMLObjectElementConstructor(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
} // namespace WebCore
#endif
|
/* **************************************************
SMSlib - C programming library for the SMS/GG
( part of devkitSMS - github.com/sverx/devkitSMS )
************************************************** */
// #define TARGET_GG
/* uncomment previous line to compile for the GameGear */
// #define NO_MD_PAD_SUPPORT
/* uncomment previous line to remove support for the Genesis/MegaDrive pad (SMS only) */
#ifdef TARGET_GG
#define NO_MD_PAD_SUPPORT /* no MD pad support on GG! */
#endif
/* library initialization. you don't need to call this if you use devkitSMS crt0.rel */
void SMS_init (void);
/* VDP operative mode handling functions */
void SMS_VDPturnOnFeature (unsigned int feature);
void SMS_VDPturnOffFeature (unsigned int feature);
/* turns on/off a VDP feature */
/* feature can be one of the following: */
/* group 0 */
#define VDPFEATURE_EXTRAHEIGHT 0x0002
#define VDPFEATURE_SHIFTSPRITES 0x0008
#define VDPFEATURE_HIDEFIRSTCOL 0x0020
#define VDPFEATURE_LOCKHSCROLL 0x0040
#define VDPFEATURE_LOCKVSCROLL 0x0080
/* group 1 */
#define VDPFEATURE_ZOOMSPRITES 0x0101
#define VDPFEATURE_USETALLSPRITES 0x0102
#define VDPFEATURE_240LINES 0x0108
#define VDPFEATURE_224LINES 0x0110
#define VDPFEATURE_FRAMEIRQ 0x0120
#define VDPFEATURE_SHOWDISPLAY 0x0140
/* (it's possible to combine (OR) them if they belong to the same group) */
/* example: VDPFEATURE_ZOOMSPRITES|VDPFEATURE_USETALLSPRITES */
/* handy macros :) */
#define SMS_displayOn() SMS_VDPturnOnFeature(VDPFEATURE_SHOWDISPLAY) /* turns on display */
#define SMS_displayOff() SMS_VDPturnOffFeature(VDPFEATURE_SHOWDISPLAY) /* turns off display */
void SMS_setBGScrollX (int scrollX);
void SMS_setBGScrollY (int scrollY);
void SMS_setBackdropColor (unsigned char entry);
void SMS_useFirstHalfTilesforSprites (_Bool usefirsthalf);
/* macro for bankswitching */
volatile __at (0xffff) unsigned char bank_to_be_mapped_on_slot2;
#define SMS_mapROMBank(n) bank_to_be_mapped_on_slot2=n
/* wait until next VBlank starts */
void SMS_waitForVBlank (void);
#ifdef TARGET_GG
/* GG functions to set a color / load a palette */
void GG_setBGPaletteColor (unsigned char entry, unsigned int color);
void GG_setSpritePaletteColor (unsigned char entry, unsigned int color);
void GG_loadBGPalette (void *palette);
void GG_loadSpritePalette (void *palette);
#else
/* functions to set a color / load a palette */
void SMS_setBGPaletteColor (unsigned char entry, unsigned char color);
void SMS_setSpritePaletteColor (unsigned char entry, unsigned char color);
void SMS_loadBGPalette (void *palette);
void SMS_loadSpritePalette (void *palette);
#endif
/* functions to load tiles into VRAM */
void SMS_loadTiles (void *src, unsigned int tilefrom, unsigned int size);
void SMS_loadPSGaidencompressedTiles (void *src, unsigned int tilefrom);
/* functions for the tilemap */
void SMS_loadTileMap (unsigned char x, unsigned char y, void *src, unsigned int size);
void SMS_loadSTMcompressedTileMap (unsigned char x, unsigned char y, unsigned char *src);
void SMS_loadTileMapArea (unsigned char x, unsigned char y, void *src, unsigned char width, unsigned char height);
void SMS_setTileatXY (unsigned char x, unsigned char y, unsigned int tile);
void SMS_setNextTileatXY (unsigned char x, unsigned char y);
void SMS_setTile (unsigned int tile);
/* handy defines for tilemaps entry */
#define TILE_FLIPPED_X 0x0200
#define TILE_FLIPPED_Y 0x0400
#define TILE_USE_SPRITE_PALETTE 0x0800
#define TILE_PRIORITY 0x1000
/* functions for sprites handling */
void SMS_initSprites (void);
_Bool SMS_addSprite (unsigned char x, unsigned char y, unsigned char tile); /* returns false if no more sprites are available */
void SMS_setClippingWindow (unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1);
_Bool SMS_addSpriteClipping (int x, int y, unsigned char tile); /* returns false if no more sprites are available or sprite clipped */
void SMS_finalizeSprites (void);
void SMS_copySpritestoSAT (void);
/* functions to read joypad(s) */
unsigned int SMS_getKeysStatus (void);
unsigned int SMS_getKeysPressed (void);
unsigned int SMS_getKeysHeld (void);
unsigned int SMS_getKeysReleased (void);
/* handy defines for joypad(s) handling */
#define PORT_A_KEY_UP 0x0001
#define PORT_A_KEY_DOWN 0x0002
#define PORT_A_KEY_LEFT 0x0004
#define PORT_A_KEY_RIGHT 0x0008
#define PORT_A_KEY_1 0x0010
#define PORT_A_KEY_2 0x0020
#define PORT_A_KEY_START PORT_A_KEY_1 /* handy alias */
#define PORT_B_KEY_UP 0x0040
#define PORT_B_KEY_DOWN 0x0080
#define PORT_B_KEY_LEFT 0x0100
#define PORT_B_KEY_RIGHT 0x0200
#define PORT_B_KEY_1 0x0400
#define PORT_B_KEY_2 0x0800
#define PORT_B_KEY_START PORT_B_KEY_1 /* handy alias */
#define RESET_KEY_NOT 0x1000 /* 0 = pressed */
#define CARTRIDGE_SLOT 0x2000 /* ??? */
#define PORT_A_TH 0x4000 /* for light gun */
#define PORT_B_TH 0x8000 /* for light gun */
#ifdef TARGET_GG
#define GG_KEY_START 0x8000 /* START key on GG */
#endif
#ifndef NO_MD_PAD_SUPPORT
/* functions to read additional MD buttons */
unsigned int SMS_getMDKeysStatus (void);
unsigned int SMS_getMDKeysPressed (void);
unsigned int SMS_getMDKeysHeld (void);
unsigned int SMS_getMDKeysReleased (void);
/* handy defines for additional MD joypad(s) handling */
#define PORT_A_MD_KEY_Z 0x0001
#define PORT_A_MD_KEY_Y 0x0002
#define PORT_A_MD_KEY_X 0x0004
#define PORT_A_MD_KEY_MODE 0x0008
#define PORT_A_MD_KEY_A 0x0010
#define PORT_A_MD_KEY_START 0x0020
/* port B still missing */
#endif
#ifndef TARGET_GG
/* pause handling (SMS only) */
_Bool SMS_queryPauseRequested (void);
void SMS_resetPauseRequest (void);
#endif
/* line interrupt */
void SMS_setLineInterruptHandler (void (*theHandlerFunction)(void));
void SMS_setLineCounter (unsigned char count);
#define SMS_enableLineInterrupt() SMS_VDPturnOnFeature(0x0010) /* turns on line IRQ */
#define SMS_disableLineInterrupt() SMS_VDPturnOffFeature(0x0010) /* turns off line IRQ */
/* Vcount */
unsigned char SMS_getVCount (void);
/* Hcount */
unsigned char SMS_getHCount (void);
/* low level functions */
void SMS_VRAMmemcpy (unsigned int dst, void *src, unsigned int size);
void SMS_VRAMmemcpy_brief (unsigned int dst, void *src, unsigned char size);
void SMS_VRAMmemset (unsigned int dst, unsigned char value, unsigned int size);
void SMS_VRAMmemsetW (unsigned int dst, unsigned int value, unsigned int size);
/* VRAM unsafe functions. Fast, but dangerous! */
void UNSAFE_SMS_copySpritestoSAT (void);
/* macros for SEGA and SDSC headers */
#define SMS_BYTE_TO_BCD(n) (((n)/10)*16+((n)%10))
#define SMS_EMBED_SEGA_ROM_HEADER(productCode,revision) \
const __at (0x7ff0) unsigned char __SMS__SEGA_signature[16]={'T','M','R',' ','S','E','G','A', \
0xFF,0xFF,0xFF,0xFF, \
SMS_BYTE_TO_BCD((productCode)%100),SMS_BYTE_TO_BCD(((productCode)/100)%100), \
(((productCode)/10000)<<4)|((revision)&0x0f),0x4C}
#define SMS_EMBED_SDSC_HEADER(verMaj,verMin,dateYear,dateMonth,dateDay,author,name,descr) \
const __at (0x7fe0-sizeof(author)) char __SMS__SDSC_author[]=author; \
const __at (0x7fe0-sizeof(author)-sizeof(name)) char __SMS__SDSC_name[]=name; \
const __at (0x7fe0-sizeof(author)-sizeof(name)-sizeof(descr)) char __SMS__SDSC_descr[]=descr; \
const __at (0x7fe0) char __SMS__SDSC_signature[16]={'S','D','S','C', \
SMS_BYTE_TO_BCD(verMaj),SMS_BYTE_TO_BCD(verMin), \
SMS_BYTE_TO_BCD(dateDay),SMS_BYTE_TO_BCD(dateMonth), \
SMS_BYTE_TO_BCD((dateYear)%100),SMS_BYTE_TO_BCD((dateYear)/100), \
(0x7fe0-sizeof(author))&0xff,(0x7fe0-sizeof(author))>>8, \
(0x7fe0-sizeof(author)-sizeof(name))&0xff,(0x7fe0-sizeof(author)-sizeof(name))>>8, \
(0x7fe0-sizeof(author)-sizeof(name)-sizeof(descr))&0xff, \
(0x7fe0-sizeof(author)-sizeof(name)-sizeof(descr))>>8}
/* pretty nice, isn't it? :) */
/* the Interrupt Service Routines (do not modify) */
void SMS_isr (void) __interrupt;
void SMS_nmi_isr (void) __critical __interrupt;
/* STILL MISSING
void SMS_VDPSetSATLocation (unsigned int location);
void SMS_VDPSetPNTLocation (unsigned int location);
void SMS_VDPSetSpritesLocation (unsigned int location);
*/
|
/*
* STM32 HID Bootloader - USB HID bootloader for STM32F10X
* Copyright (c) 2018 Bruno Freitas - [email protected]
*
* Modified January 2019
* by Michel Stempin <[email protected]>
* Cleanup and optimizations
*
* 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 3 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 <http://www.gnu.org/licenses/>.
*
*/
/**
* @file usb.c
*
* @brief File containing the generic USB low-level functions.
*/
#include <stm32f10x.h>
#include <stdlib.h>
#include <stdbool.h>
#include "usb.h"
#include "hid.h"
/** USB interrupt enable mask */
#define CNTR_MASK (CNTR_RESETM | CNTR_SUSPM | CNTR_WKUPM)
/** USB interrupt flag mask */
#define ISTR_MASK (ISTR_CTR | ISTR_RESET | ISTR_SUSP | ISTR_WKUP)
/** USB RX/TX buffer */
USB_RxTxBuf_t RxTxBuffer[MAX_EP_NUM];
/** USB device address that will be set up by host */
volatile uint8_t DeviceAddress;
/** USB configuration flag */
volatile uint16_t DeviceConfigured;
/**
* @brief Transfer data from USB PMA memory to buffer.
*
* The PMA (Packet Memory Area) is a dual-port access memory that is
* access by both the processor as 32-bit wide values and by the USB
* peripheral device as 16-bit wide values.
*
* @param[in] endpoint
* The data endpoint to read from.
*/
void USB_PMA2Buffer(uint8_t endpoint)
{
volatile uint32_t *btable = BTABLE_ADDR(endpoint);
uint32_t count = RxTxBuffer[endpoint].RXL = btable[USB_COUNTn_RX] & 0x3ff;
uint32_t *address = (uint32_t *) (PMAAddr + btable[USB_ADDRn_RX] * 2);
uint16_t *destination = (uint16_t *) RxTxBuffer[endpoint].RXB;
for (uint32_t i = 0; i < count; i++) {
*destination++ = *address++;
}
}
/**
* @brief Transfer data from buffer to USB PMA memory.
*
* The PMA (Packet Memory Area) is a dual-port access memory that is
* access by both the processor as 32-bit wide values and by the USB
* peripheral device as 16-bit wide values.
*
* @param[in] endpoint
* The data endpoint to write to.
*/
void USB_Buffer2PMA(uint8_t endpoint)
{
volatile uint32_t *btable = BTABLE_ADDR(endpoint);
uint32_t count = RxTxBuffer[endpoint].TXL <= RxTxBuffer[endpoint].MaxPacketSize ?
RxTxBuffer[endpoint].TXL : RxTxBuffer[endpoint].MaxPacketSize;
uint16_t *address = RxTxBuffer[endpoint].TXB;
uint32_t *destination = (uint32_t *) (PMAAddr + btable[USB_ADDRn_TX] * 2);
/* Set transmission byte count in buffer descriptor table */
btable[USB_COUNTn_TX] = count;
for (uint32_t i = (count + 1) / 2; i; i--) {
*destination++ = *address++;
}
RxTxBuffer[endpoint].TXL -= count;
RxTxBuffer[endpoint].TXB = address;
}
/**
* @brief Send a data buffer to an USB endpoint.
*
* @param[in] endpoint
* The data endpoint to write to.
*
* @param[in] data
* Pointer to the 16-bit aligned data buffer.
*
* @param[in] length
* Length of the data buffer in bytes.
*/
void USB_SendData(uint8_t endpoint, uint16_t *data, uint16_t length)
{
if (endpoint > 0 && !DeviceConfigured) {
return;
}
RxTxBuffer[endpoint].TXL = length;
RxTxBuffer[endpoint].TXB = data;
USB_Buffer2PMA(endpoint);
SET_TX_STATUS(endpoint, EP_TX_VALID);
}
/**
* @brief Shutdown the USB peripheral.
*
* The USB peripheral is deconfigured, its interrupts and clock are
* disabled, and the USB D+ data line is turned into an open drain
* output connected to GND to signal an USB disconnection to the host.
*/
void USB_Shutdown(void)
{
/* Disable USB IRQ */
//NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
WRITE_REG(*ISTR, 0);
DeviceConfigured = 0;
/* Turn USB Macrocell off */
WRITE_REG(*CNTR, CNTR_FRES | CNTR_PDWN);
/* PA12: General purpose output 50 MHz open drain */
SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);
MODIFY_REG(GPIOA->CRH,
GPIO_CRH_CNF12 | GPIO_CRH_MODE12,
GPIO_CRH_CNF12_0 | GPIO_CRH_MODE12);
/* Sinks PA12 to GND */
WRITE_REG(GPIOA->BRR, GPIO_BRR_BR12);
/* Disable USB Clock on APB1 */
CLEAR_BIT(RCC->APB1ENR, RCC_APB1ENR_USBEN);
}
/**
* @brief Initialize the USB perpiheral.
*
* The RX/TX buffers are cleared, the USB D+ data line is turned into
* an floating input, the USB peripheral is deconfigured, and its
* interrupts and clock are enabled.
*/
void USB_Init(void)
{
/* Reset RX and TX lengths inside RxTxBuffer struct for all
* endpoints
*/
for (int i = 0; i < MAX_EP_NUM; i++) {
RxTxBuffer[i].RXL = RxTxBuffer[i].TXL = 0;
}
/* PA12: General purpose Input Float */
SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);
MODIFY_REG(GPIOA->CRH,
GPIO_CRH_CNF12 | GPIO_CRH_MODE12,
GPIO_CRH_CNF12_0);
/* USB devices start as not configured */
DeviceConfigured = 0;
/* Enable USB clock */
SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USBEN);
/* CNTR_FRES = 1, CNTR_PWDN = 0 */
WRITE_REG(*CNTR, CNTR_FRES);
/* The following sequence is recommended:
* 1- FRES = 0
* 2- Wait until RESET flag = 1 (polling)
* 3- clear ISTR register
*/
/* CNTR_FRES = 0 */
WRITE_REG(*CNTR, 0);
/* Wait until RESET flag = 1 (polling) */
while (!READ_BIT(*ISTR, ISTR_RESET)) {
;
}
/* Clear pending interrupts */
WRITE_REG(*ISTR, 0);
/* Set interrupt mask */
WRITE_REG(*CNTR, CNTR_MASK);
}
/**
* @brief Main USB event polling function.
*
* This function checks for the various USB interrupt causes by
* checking the USB interrupt status register.
*
* Note that this function may be called by manual polling, or
* automatically if it is set into the corresponding USB interrupt
* handler in the Vector Table.
*/
void USB_Poll(void)
{
volatile uint16_t istr;
while ((istr = READ_REG(*ISTR) & ISTR_MASK) != 0) {
/* Handle EP data */
if (READ_BIT(istr, ISTR_CTR)) {
/* Handle data on EP */
WRITE_REG(*ISTR, CLR_CTR);
USB_EPHandler(READ_REG(*ISTR));
}
/* Handle Reset */
if (READ_BIT(istr, ISTR_RESET)) {
WRITE_REG(*ISTR, CLR_RESET);
USB_Reset();
}
/* Handle Suspend */
if (READ_BIT(istr, ISTR_SUSP)) {
WRITE_REG(*ISTR, CLR_SUSP);
/* If device address is assigned, then reset it */
if (READ_REG(*DADDR) & USB_DADDR_ADD) {
WRITE_REG(*DADDR, 0);
CLEAR_BIT(*CNTR, CNTR_SUSPM);
}
}
/* Handle Wakeup */
if (READ_BIT(istr, ISTR_WKUP)) {
WRITE_REG(*ISTR, CLR_WKUP);
}
}
/* Default to clear all interrupt flags */
WRITE_REG(*ISTR, 0);
}
|
// SPDX-License-Identifier: MIT
/**
Network Driver for Beckhoff CCAT communication controller
Copyright (C) 2014-2018 Beckhoff Automation GmbH & Co. KG
Author: Patrick Bruenn <[email protected]>
*/
#include <linux/etherdevice.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/platform_device.h>
#include <linux/mfd/core.h>
#include "module.h"
MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_AUTHOR("Patrick Bruenn <[email protected]>");
MODULE_LICENSE("GPL and additional rights");
MODULE_VERSION(DRV_VERSION);
static struct ccat_cell ccat_cells[] = {
{
.type = CCATINFO_ETHERCAT_NODMA,
.cell = {.name = "ccat_eth_eim"},
},
{
.type = CCATINFO_ETHERCAT_MASTER_DMA,
.cell = {.name = "ccat_eth_dma"},
},
{
.type = CCATINFO_GPIO,
.cell = {.name = "ccat_gpio"},
},
{
.type = CCATINFO_EPCS_PROM,
.cell = {.name = "ccat_update"},
},
{
.type = CCATINFO_SRAM,
.cell = {.name = "ccat_sram"},
},
{
.type = CCATINFO_SYSTEMTIME,
.cell = {.name = "ccat_systemtime"},
},
};
static int __init ccat_class_init(struct ccat_class *base)
{
if (1 == atomic_inc_return(&base->instances)) {
if (alloc_chrdev_region
(&base->dev, 0, base->count, KBUILD_MODNAME)) {
pr_warn("alloc_chrdev_region() for '%s' failed\n",
base->name);
return -1;
}
base->class = class_create(THIS_MODULE, base->name);
if (!base->class) {
pr_warn("Create device class '%s' failed\n",
base->name);
unregister_chrdev_region(base->dev, base->count);
return -1;
}
}
return 0;
}
static void ccat_class_exit(struct ccat_class *base)
{
if (!atomic_dec_return(&base->instances)) {
class_destroy(base->class);
unregister_chrdev_region(base->dev, base->count);
}
}
static void free_ccat_cdev(struct ccat_cdev *ccdev)
{
ccat_class_exit(ccdev->class);
ccdev->dev = 0;
}
static struct ccat_cdev *alloc_ccat_cdev(struct ccat_class *base)
{
int i = 0;
ccat_class_init(base);
for (i = 0; i < base->count; ++i) {
if (base->devices[i].dev == 0) {
base->devices[i].dev = MKDEV(MAJOR(base->dev), i);
return &base->devices[i];
}
}
pr_warn("exceeding max. number of '%s' devices (%d)\n",
base->class->name, base->count);
atomic_dec_return(&base->instances);
return NULL;
}
loff_t ccat_cdev_llseek(struct file * f, loff_t offset, int whence)
{
struct cdev_buffer *buffer = f->private_data;
const size_t iosize = buffer->ccdev->iosize;
return fixed_size_llseek(f, offset, whence, iosize);
}
EXPORT_SYMBOL(ccat_cdev_llseek);
static int ccat_cdev_init(struct cdev *cdev, dev_t dev, struct class *class,
struct file_operations *fops)
{
if (!device_create
(class, NULL, dev, NULL, "%s%d", class->name, MINOR(dev))) {
pr_warn("device_create() failed\n");
return -1;
}
cdev_init(cdev, fops);
cdev->owner = fops->owner;
if (cdev_add(cdev, dev, 1)) {
pr_warn("add update device failed\n");
device_destroy(class, dev);
return -1;
}
pr_info("registered %s%d.\n", class->name, MINOR(dev));
return 0;
}
int ccat_cdev_open(struct inode *const i, struct file *const f)
{
struct ccat_cdev *ccdev =
container_of(i->i_cdev, struct ccat_cdev, cdev);
struct cdev_buffer *buf;
if (!atomic_dec_and_test(&ccdev->in_use)) {
atomic_inc(&ccdev->in_use);
return -EBUSY;
}
buf = kzalloc(sizeof(*buf) + ccdev->iosize, GFP_KERNEL);
if (!buf) {
atomic_inc(&ccdev->in_use);
return -ENOMEM;
}
buf->ccdev = ccdev;
f->private_data = buf;
return 0;
}
EXPORT_SYMBOL(ccat_cdev_open);
int ccat_cdev_probe(struct ccat_function *func, struct ccat_class *cdev_class,
size_t iosize)
{
struct ccat_cdev *const ccdev = alloc_ccat_cdev(cdev_class);
if (!ccdev) {
return -ENOMEM;
}
ccdev->ioaddr = func->ccat->bar_0 + func->info.addr;
ccdev->iosize = iosize;
atomic_set(&ccdev->in_use, 1);
if (ccat_cdev_init
(&ccdev->cdev, ccdev->dev, cdev_class->class, &cdev_class->fops)) {
pr_warn("ccat_cdev_probe() failed\n");
free_ccat_cdev(ccdev);
return -1;
}
ccdev->class = cdev_class;
func->private_data = ccdev;
return 0;
}
EXPORT_SYMBOL(ccat_cdev_probe);
int ccat_cdev_release(struct inode *const i, struct file *const f)
{
const struct cdev_buffer *const buf = f->private_data;
struct ccat_cdev *const ccdev = buf->ccdev;
kfree(f->private_data);
atomic_inc(&ccdev->in_use);
return 0;
}
EXPORT_SYMBOL(ccat_cdev_release);
int ccat_cdev_remove(struct platform_device *pdev)
{
struct ccat_function *const func = pdev->dev.platform_data;
struct ccat_cdev *const ccdev = func->private_data;
cdev_del(&ccdev->cdev);
device_destroy(ccdev->class->class, ccdev->dev);
free_ccat_cdev(ccdev);
return 0;
}
EXPORT_SYMBOL(ccat_cdev_remove);
static int ccat_function_connect(struct ccat_function
*const func, struct ccat_device *const ccatdev)
{
int i;
for (i = 0; i < ARRAY_SIZE(ccat_cells); ++i) {
if (func->info.type == ccat_cells[i].type) {
ccat_cells[i].cell.platform_data = func;
ccat_cells[i].cell.pdata_size = sizeof(*func);
return mfd_add_devices(ccatdev->dev,
PLATFORM_DEVID_AUTO,
&ccat_cells[i].cell, 1, NULL, 0,
NULL);
}
}
return 0;
}
/**
* Initialize all available CCAT functions.
*
* Return: count of failed functions
*/
static int ccat_functions_init(struct ccat_device *const ccatdev)
{
static const size_t block_size = sizeof(struct ccat_info_block);
struct ccat_function *next = kzalloc(sizeof(*next), GFP_KERNEL);
void __iomem *addr = ccatdev->bar_0; /** first block is the CCAT information block entry */
const u8 num_func = ioread8(addr + 4); /** number of CCAT function blocks is at offset 0x4 */
const void __iomem *end = addr + (block_size * num_func);
int ret = 0;
for (; addr < end && next; addr += block_size) {
memcpy_fromio(&next->info, addr, sizeof(next->info));
if (CCATINFO_NOTUSED != next->info.type) {
next->ccat = ccatdev;
ret = ccat_function_connect(next, ccatdev);
if (ret < 0) {
return ret;
}
next = kzalloc(sizeof(*next), GFP_KERNEL);
}
}
kfree(next);
return 0;
}
#ifdef CONFIG_PCI
static int ccat_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
struct ccat_device *ccatdev;
u8 rev;
int status;
ccatdev = devm_kzalloc(&pdev->dev, sizeof(*ccatdev), GFP_KERNEL);
if (!ccatdev) {
pr_err("%s() out of memory.\n", __FUNCTION__);
return -ENOMEM;
}
ccatdev->pdev = pdev;
ccatdev->dev = &pdev->dev;
pci_set_drvdata(pdev, ccatdev);
status = pci_enable_device_mem(pdev);
if (status) {
pr_err("enable %s failed: %d\n", pdev->dev.kobj.name, status);
return status;
}
status = pci_read_config_byte(pdev, PCI_REVISION_ID, &rev);
if (status) {
pr_err("read CCAT pci revision failed with %d\n", status);
goto disable_device;
}
status = pci_request_regions(pdev, KBUILD_MODNAME);
if (status) {
pr_err("allocate mem_regions failed.\n");
goto disable_device;
}
status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
if (status) {
status =
dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
if (status) {
pr_err("No suitable DMA available, pci rev: %u\n", rev);
goto release_regions;
}
pr_debug("32 bit DMA supported, pci rev: %u\n", rev);
} else {
pr_debug("64 bit DMA supported, pci rev: %u\n", rev);
}
ccatdev->bar_0 = pci_iomap(pdev, 0, 0);
if (!ccatdev->bar_0) {
pr_err("initialization of bar0 failed.\n");
status = -EIO;
goto release_regions;
}
ccatdev->bar_2 = pci_iomap(pdev, 2, 0);
if (!ccatdev->bar_2) {
pr_warn("initialization of optional bar2 failed.\n");
}
pci_set_master(pdev);
if (ccat_functions_init(ccatdev)) {
pr_warn("some functions couldn't be initialized\n");
}
return 0;
release_regions:
pci_release_regions(pdev);
disable_device:
pci_disable_device(pdev);
return status;
}
static void ccat_pci_remove(struct pci_dev *pdev)
{
struct ccat_device *ccatdev = pci_get_drvdata(pdev);
if (ccatdev) {
mfd_remove_devices(ccatdev->dev);
if (ccatdev->bar_2)
pci_iounmap(pdev, ccatdev->bar_2);
pci_iounmap(pdev, ccatdev->bar_0);
pci_release_regions(pdev);
pci_disable_device(pdev);
}
}
#define PCI_DEVICE_ID_BECKHOFF_CCAT 0x5000
#define PCI_VENDOR_ID_BECKHOFF 0x15EC
static const struct pci_device_id pci_ids[] = {
{PCI_DEVICE(PCI_VENDOR_ID_BECKHOFF, PCI_DEVICE_ID_BECKHOFF_CCAT)},
{0,},
};
MODULE_DEVICE_TABLE(pci, pci_ids);
static struct pci_driver ccat_pci_driver = {
.name = KBUILD_MODNAME,
.id_table = pci_ids,
.probe = ccat_pci_probe,
.remove = ccat_pci_remove,
};
module_pci_driver(ccat_pci_driver);
#else /* #ifdef CONFIG_PCI */
static const size_t CCAT_EIM_ADDR = 0xf0000000;
static const size_t CCAT_EIM_LEN = 0x02000000;
static int ccat_eim_probe(struct platform_device *pdev)
{
struct ccat_device *ccatdev;
ccatdev = devm_kzalloc(&pdev->dev, sizeof(*ccatdev), GFP_KERNEL);
if (!ccatdev) {
pr_err("%s() out of memory.\n", __FUNCTION__);
return -ENOMEM;
}
ccatdev->pdev = pdev;
ccatdev->dev = &pdev->dev;
platform_set_drvdata(pdev, ccatdev);
if (!request_mem_region(CCAT_EIM_ADDR, CCAT_EIM_LEN, pdev->name)) {
pr_warn("request mem region failed.\n");
return -EIO;
}
if (!(ccatdev->bar_0 = ioremap(CCAT_EIM_ADDR, CCAT_EIM_LEN))) {
pr_warn("initialization of bar0 failed.\n");
return -EIO;
}
ccatdev->bar_2 = NULL;
if (ccat_functions_init(ccatdev)) {
pr_warn("some functions couldn't be initialized\n");
}
return 0;
}
static int ccat_eim_remove(struct platform_device *pdev)
{
struct ccat_device *ccatdev = platform_get_drvdata(pdev);
if (ccatdev) {
mfd_remove_devices(ccatdev->dev);
iounmap(ccatdev->bar_0);
release_mem_region(CCAT_EIM_ADDR, CCAT_EIM_LEN);
}
return 0;
}
static const struct of_device_id bhf_eim_ccat_ids[] = {
{.compatible = "bhf,emi-ccat",},
{}
};
MODULE_DEVICE_TABLE(of, bhf_eim_ccat_ids);
static struct platform_driver ccat_eim_driver = {
.driver = {
.name = KBUILD_MODNAME,
.of_match_table = bhf_eim_ccat_ids,
},
.probe = ccat_eim_probe,
.remove = ccat_eim_remove,
};
module_platform_driver(ccat_eim_driver);
#endif /* #ifdef CONFIG_PCI */
|
/******* d_congrad2_cl.c - conjugate gradient for clover fermions ****/
/* MIMD version 7 */
/* Clover fermions */
/* For clover_dynamical/update.c. Solves M_adjoint*M psi = chi */
/* if "LU" is defined use the LU preconditioned fermion matrix, where
the fermion spinors live on even sites only. In other words, if
Dslash_oe is the dslash operator with its source on even sites and
its result on odd sites, etc.:
without LU:
M = A - kappa*( Dslash_eo + DSLASH_oe )
with LU:
M = A_e - kappa^2 * Dslash_eo * (A_o)^{-1} * Dslash_oe
*/
#ifdef LU
#define FORMYSITES FOREVENSITESDOMAIN
#else
#define FORMYSITES FORALLSITESDOMAIN
#endif
/* This version looks at the initial vector every "niter" passes */
/* The source vector is in "chi", and the initial guess and answer
in "psi". "r" is the residual vector, and "p" and "mp" are
working vectors for the conjugate gradient.
niter = maximum number of iterations.
rsqmin = desired rsq, quit when we reach rsq = rsqmin*source_norm.
*/
#include "generic_clover_includes.h"
int congrad_cl(int niter,Real rsqmin,Real *final_rsq_ptr)
{
register int i;
register site *s;
int iteration; /* counter for iterations */
double source_norm;
double rsqstop;
Real a,b;
double rsq,oldrsq,pkp; /* Sugar's a,b,resid**2,previous resid*2 */
/* pkp = cg_p.K.cg_p */
void dslash_w_site_special();
msg_tag *tag[8],*tag2[8];
#ifdef LU
Real KAP = -kappa*kappa;
#else
Real KAP = -kappa;
#endif
double dtime;
dtime= -dclock();
iteration=0;
start:
/* mp <- M_adjoint*M*psi
r,p <- chi - mp
rsq = |r|^2
source_norm = |chi|^2
*/
rsq = source_norm = 0.0;
#ifdef LU
mult_this_ldu_site(gen_clov, F_OFFSET(psi), F_OFFSET(tmp), EVEN);
dslash_w_site_special(F_OFFSET(psi), F_OFFSET(mp), PLUS, ODD, tag, 0);
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), ODD);
dslash_w_site_special(F_OFFSET(tmp), F_OFFSET(mp), PLUS, EVEN, tag2, 0);
FOREVENSITESDOMAIN(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp));
}
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), EVEN);
dslash_w_site_special(F_OFFSET(mp), F_OFFSET(mp), MINUS, ODD, tag, 1);
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), ODD);
dslash_w_site_special(F_OFFSET(tmp), F_OFFSET(mp), MINUS, EVEN, tag2, 1);
FOREVENSITESDOMAIN(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp) );
sub_wilson_vector( &(s->chi), &(s->mp), &(s->r) );
s->p = s->r;
source_norm += (double)magsq_wvec( &(s->chi) );
rsq += (double)magsq_wvec( &(s->r) );
}
#else
mult_this_ldu_site(gen_clov, F_OFFSET(psi), F_OFFSET(tmp), EVENANDODD);
dslash_w_site_special(F_OFFSET(psi), F_OFFSET(mp), PLUS, EVENANDODD, tag, 0);
FORALLSITES(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp) );
}
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), EVENANDODD);
dslash_w_site_special(F_OFFSET(mp), F_OFFSET(mp), MINUS, EVENANDODD, tag, 1);
FORALLSITES(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp) );
sub_wilson_vector( &(s->chi), &(s->mp), &(s->r) );
s->p = s->r;
source_norm += (double)magsq_wvec( &(s->chi) );
rsq += (double)magsq_wvec( &(s->r) );
}
#endif
g_doublesum( &source_norm );
g_doublesum( &rsq );
iteration++ ; /* iteration counts number of multiplications
by M_adjoint*M */
total_iters++;
/**if(this_node==0)printf("congrad2: source_norm = %e\n",source_norm);
if(this_node==0)printf("congrad2: iter %d, rsq %e, pkp %e, a %e\n",
iteration,(double)rsq,(double)pkp,(double)a );**/
rsqstop = rsqmin * source_norm;
if( rsq <= rsqstop ){
*final_rsq_ptr= (Real)rsq;
for( i=XUP; i <= TUP; i++) {
cleanup_gather(tag[i]);
cleanup_gather(tag[OPP_DIR(i)]);
#ifdef LU
cleanup_gather(tag2[i]);
cleanup_gather(tag2[OPP_DIR(i)]);
#endif
}
cleanup_dslash_wtemps();
return (iteration);
}
/* main loop - do until convergence or time to restart */
/*
oldrsq <- rsq
mp <- M_adjoint*M*p
pkp <- p.M_adjoint*M.p
a <- rsq/pkp
psi <- psi + a*p
r <- r - a*mp
rsq <- |r|^2
b <- rsq/oldrsq
p <- r + b*p
*/
do{
oldrsq = rsq;
pkp = 0.0;
#ifdef LU
mult_this_ldu_site(gen_clov, F_OFFSET(p), F_OFFSET(tmp), EVEN);
dslash_w_site_special(F_OFFSET(p), F_OFFSET(mp), PLUS, ODD, tag, 1);
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), ODD);
dslash_w_site_special(F_OFFSET(tmp), F_OFFSET(mp), PLUS, EVEN, tag2, 1);
FOREVENSITESDOMAIN(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp) );
}
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), EVEN);
dslash_w_site_special(F_OFFSET(mp), F_OFFSET(mp), MINUS, ODD, tag, 1);
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), ODD);
dslash_w_site_special(F_OFFSET(tmp), F_OFFSET(mp), MINUS, EVEN, tag2, 1);
FOREVENSITESDOMAIN(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp) );
pkp += (double)wvec_rdot( &(s->p), &(s->mp) );
}
#else
mult_this_ldu_site(gen_clov, F_OFFSET(p), F_OFFSET(tmp), EVENANDODD);
dslash_w_site_special(F_OFFSET(p), F_OFFSET(mp), PLUS, EVENANDODD, tag, 1);
FORALLSITES(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp) );
}
mult_this_ldu_site(gen_clov, F_OFFSET(mp), F_OFFSET(tmp), EVENANDODD);
dslash_w_site_special(F_OFFSET(mp), F_OFFSET(mp), MINUS, EVENANDODD, tag, 1);
FORALLSITES(i,s){
scalar_mult_add_wvec( &(s->tmp), &(s->mp), KAP, &(s->mp) );
pkp += (double)wvec_rdot( &(s->p), &(s->mp) );
}
#endif
g_doublesum( &pkp );
iteration++;
total_iters++;
a = (Real)(rsq/pkp);
rsq = 0.0;
FORMYSITES(i,s){
scalar_mult_add_wvec( &(s->psi), &(s->p), a, &(s->psi) );
scalar_mult_add_wvec( &(s->r), &(s->mp), -a, &(s->r) );
rsq += (double)magsq_wvec( &(s->r) );
}
g_doublesum( &rsq );
/**if(this_node==0)printf("congrad2: iter %d, rsq %e, pkp %e, a %e\n",
iteration,(double)rsq,(double)pkp,(double)a );**/
if( rsq <= rsqstop ){
*final_rsq_ptr= (Real)rsq;
for( i=XUP; i <= TUP; i++) {
cleanup_gather(tag[i]);
cleanup_gather(tag[OPP_DIR(i)]);
#ifdef LU
cleanup_gather(tag2[i]);
cleanup_gather(tag2[OPP_DIR(i)]);
#endif
}
dtime += dclock();
/** UMH if(this_node==0)printf("CONGRAD2: time = %e iters = %d mflops = %e\n",
dtime,iteration,(double)(2840.0*volume*iteration/(1.0e6*dtime*numnodes())) ); **/
cleanup_dslash_wtemps();
return (iteration);
}
b = (Real)(rsq/oldrsq);
FORMYSITES(i,s){
scalar_mult_add_wvec( &(s->r), &(s->p), b, &(s->p) );
}
} while( iteration%niter != 0);
for( i=XUP; i <= TUP; i++) {
cleanup_gather(tag[i]);
cleanup_gather(tag[OPP_DIR(i)]);
#ifdef LU
cleanup_gather(tag2[i]);
cleanup_gather(tag2[OPP_DIR(i)]);
#endif
}
if( iteration < 3*niter ) goto start;
*final_rsq_ptr= (Real)rsq;
if( rsq > rsqstop ){
if(this_node==0)printf("No convergence in d_congrad2\n");
}
cleanup_dslash_wtemps();
return(iteration);
}
|
#pragma once
#include "common/base.h"
#include "common/segment_tree/action/none.h"
#include "common/segment_tree/base/get_segment_info.h"
#include "common/segment_tree/info/min_with_index.h"
#include "common/segment_tree/info/none.h"
#include "common/segment_tree/segment_tree.h"
#include "common/segment_tree/sinfo/position.h"
#include "common/vector/rmq/position_value.h"
#include <vector>
namespace nvector {
namespace rmq {
// O(N) memory, O(N) preprocessing time, O(log N) request time
template <class TTValue>
class SegmentTree {
public:
using TValue = TTValue;
using TPositionValue = PositionValue<TValue>;
using TSTree =
st::SegmentTree<TValue, st::info::MinWithIndex<TValue, st::info::None>,
st::action::None, st::sinfo::Position<>, false>;
using TNode = typename TSTree::TNode;
protected:
TSTree tree;
TNode* root = nullptr;
public:
SegmentTree() {}
SegmentTree(const std::vector<TValue>& v) { Build(v); }
void Build(const std::vector<TValue>& v) {
tree.ResetNodes(v.size());
root = tree.BuildTree(v);
}
TPositionValue Minimum(size_t b, size_t e) const {
assert(b < e);
auto s = st::GetSegmentInfo(root, b, e - 1);
return {s.min_coordinate, s.min};
}
};
} // namespace rmq
} // namespace nvector
|
/*
* File: POEdiopins.h
* Author: Patrick O. Ehrmann ([email protected])
* License: Creative Commons Zero (https://creativecommons.org/publicdomain/zero/1.0/)
*
* Created on 2015-03-26
* Description:
* PIN definitions for digital input output library
* Major Changes:
* Version 0: alpha development
*/
#ifndef POEDIOPINS_H
#define POEDIOPINS_H
#define DIO_PIN_B0 0x00
#define DIO_PIN_B1 0x01
#define DIO_PIN_B2 0x02
#define DIO_PIN_B3 0x03
#define DIO_PIN_B4 0x04
#define DIO_PIN_B5 0x05
#define DIO_PIN_B6 0x06
#define DIO_PIN_B7 0x07
#define DIO_PIN_B8 0x08
#define DIO_PIN_B9 0x09
#define DIO_PIN_B10 0x0a
#define DIO_PIN_B11 0x0b
#define DIO_PIN_B12 0x0c
#define DIO_PIN_B13 0x0d
#define DIO_PIN_B14 0x0e
#define DIO_PIN_B15 0x0f
#define DIO_PIN_A0 0x10
#define DIO_PIN_A1 0x11
#define DIO_PIN_A2 0x12
#define DIO_PIN_A3 0x13
#define DIO_PIN_A4 0x14
#define DIO_PIN_COUNT 0x15
#endif // ifndef POEDIOPINS_H
|
/**
* BONKERS!
*
* Detect button presses from USB devices, such as the Big Red Button and
* USB Fidget.
*
* @site https://github.com/fidian/bonkers
* @license MIT (LICENSE.md)
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <libusb-1.0/libusb.h>
#define LOG(level, _fmt, ...) if (output_level > level) { fprintf(stdout, _fmt "\n", ## __VA_ARGS__); fflush(stdout); }
#define ERROR(_fmt, ...) fprintf(stderr, _fmt "\n", ## __VA_ARGS__); fflush(stderr);
#define CONTROL_REQUEST_TYPE_OUT LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE
// Actions
#define HID_REPORT 0x09
// Max number of characters in a converted state string (not including NULL)
#define MAX_STATE_STRING_LENGTH 11
// Return codes
typedef enum {
BONKERS_RUN = -1,
BONKERS_SUCCESS,
BONKERS_ERROR,
BONKERS_WARN
} bonkers_result;
/* This structure is passed around a lot. It contains the information
* necessary to contact and communicate with a device.
*/
typedef struct device_config {
const char *name;
int vendor_id;
int product_id;
struct libusb_device_handle *handle;
uint16_t wValue;
bonkers_result (*read_state)(struct device_config *);
void (*convert_state)(struct device_config *);
uint8_t state[8];
char state_now[MAX_STATE_STRING_LENGTH + 1];
char state_prev[MAX_STATE_STRING_LENGTH + 1];
} device_config;
static int output_level = 1; // 0 = none, 1 = info, 2+ = debug
static bonkers_result exit_code = -1; // -1 = run, 0 = success, 1+ = error
/**
* Finds a device when given a vendor_id and product_id.
*
* name = Name of device for debug message
* vendor_id = Vendor ID of USB device
* product_id = Product ID of USB device
* config = Where to store device information
*/
static bonkers_result seek_device(const char *name, int vendor_id, int product_id, device_config *config) {
struct libusb_device_handle *handle = NULL;
LOG(1, "Attempting to open %s (vendor 0x%04x, device 0x%04x)", name, vendor_id, product_id);
handle = libusb_open_device_with_vid_pid(NULL, vendor_id, product_id);
if (!handle) {
return BONKERS_ERROR;
}
config->name = name;
config->vendor_id = vendor_id;
config->product_id = product_id;
config->handle = handle;
return BONKERS_SUCCESS;
}
/**
* Detaches the kernel driver if it is currently attached.
*
* handle = USB device
*/
static bonkers_result detach_kernel_driver(libusb_device_handle *handle) {
/* If the kernel driver is active, we need to detach it */
if (libusb_kernel_driver_active(handle, 0)) {
LOG(1, "Kernel driver active, attempting to detach");
if (LIBUSB_SUCCESS != libusb_detach_kernel_driver(handle, 0)) {
return BONKERS_ERROR;
}
LOG(1, "Kernel driver detached successfully");
} else {
LOG(1, "Kernel driver not active");
}
return BONKERS_SUCCESS;
}
/**
* Attempt to read the current button state.
*
* device = USB device
* timeout = timeout in MS, 0 to wait forever
*
* Returns libusb status code.
*/
static bonkers_result interrupt_transfer(device_config *device, int timeout) {
int ret, transferred;
memset(device->state, 0, 8);
/* Use endpoint 0x81 and retrieve the state */
ret = libusb_interrupt_transfer(device->handle, LIBUSB_ENDPOINT_IN | 0x01, device->state, 8, &transferred, timeout);
if (LIBUSB_SUCCESS != ret) {
// Soft error
LOG(1, "Error getting interrupt data: %d", ret);
return ret;
}
if (transferred < 8) {
LOG(1, "Transferred %d of %d bytes", transferred, 8);
return ret;
}
return 0;
}
/* Attempt a control_transfer
*
* device = The device
* timeout = The timeout in ms
*
* Returns libusb status code.
*/
static int control_transfer_out_report(device_config *device, uint16_t wValue, uint16_t wIndex, unsigned char *data, uint16_t data_len, unsigned int timeout) {
int ret;
ret = libusb_control_transfer(device->handle, CONTROL_REQUEST_TYPE_OUT, HID_REPORT, wValue, wIndex, data, data_len, timeout);
if (ret < 0) {
LOG(1, "Error sending report - libusb error %d", ret);
return ret;
}
if (ret < data_len) {
ERROR("Short write - sent %d of %d bytes", ret, data_len);
return ret;
}
return ret;
}
/* Dream Cheeky - USB Fidget
* Device ID: 1d34:0001 (Soccer - Untested)
* Device ID: 1d34:0001 (Basketball)
* Device ID: 1d34:0003 (Golf)
*
* Button not pressed
* 1f 00 00 00 00 00 00 03
* Button pressed
* 1e 00 00 00 00 00 00 03
*/
static void convert_state_1d34_fidget(device_config *device) {
if (device->state[0] == 0x1E) {
device->state_now[0] = '1';
} else {
device->state_now[0] = '0';
}
device->state_now[1] = '\0';
}
static bonkers_result read_state_1d34_fidget(device_config *device) {
uint8_t rep[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
int ret;
ret = control_transfer_out_report(device, 0x0000, 0x0000, rep, 8, 200);
if (ret != 8) {
return BONKERS_ERROR;
}
ret = interrupt_transfer(device, 200);
// Ignore timeout errors
if (ret == LIBUSB_ERROR_TIMEOUT) {
return BONKERS_WARN;
}
if (ret) {
return BONKERS_ERROR;
}
return BONKERS_SUCCESS;
}
/* Dream Cheeky - Big Red Button
* Device ID: 1d34:0004
*
* Lid closed, button pressed: (first byte: 0001 0100)
* 14 00 00 00 00 00 00 03
* Lid closed, button not pressed: (first byte: 0001 0101)
* 15 00 00 00 00 00 00 03
* Lid open, button pressed: (first byte: 0001 0110)
* 16 00 00 00 00 00 00 03
* Lid open, button not pressed: (first byte: 0001 0111)
* 17 00 00 00 00 00 00 03
*/
static void convert_state_1d34_000d(device_config *device) {
// bit 1: on = button not pressed
if (device->state[0] & 0x01) {
device->state_now[0] = '0';
} else {
device->state_now[0] = '1';
}
device->state_now[1] = ' ';
// bit 2: on = lid open
if (device->state[0] & 0x02) {
device->state_now[2] = '1';
} else {
device->state_now[2] = '0';
}
device->state_now[3] = '\0';
}
static bonkers_result read_state_1d34_000d(device_config *device) {
uint8_t rep[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
int ret;
ret = control_transfer_out_report(device, 0x0000, 0x0000, rep, 8, 200);
if (ret != 8) {
return BONKERS_ERROR;
}
ret = interrupt_transfer(device, 200);
// Ignore occasional timeout errors
if (ret == LIBUSB_ERROR_TIMEOUT) {
return BONKERS_WARN;
}
if (ret) {
return BONKERS_ERROR;
}
return BONKERS_SUCCESS;
}
/* Dream Cheeky - Stress Ball
* Device ID: 1d34:0020
*
* First three bytes are the sensors. Here is an example for my device
* at rest:
* 6c 8c b1 fb 00 00 00 03
*
* The first number (6c) is the squeeze sensor. When squeezed, mine will
* drop to about 08.
*
* The second number (8c) measures twist. When twisted left, mine drops to
* 08 and twisting right this goes up to ff.
*
* The third number (b1) measures the pull/push. When pushed, mine will go
* down to 08 and pulling will increase it to ff.
*/
static void convert_state_1d34_0020(device_config *device) {
// Convert into arguments
sprintf(device->state_now, "%d %d %d", device->state[0], device->state[1], device->state[2]);
}
static int read_state_1d34_0020(device_config *device) {
uint8_t rep1[8] = { 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08 },
rep2[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 };
int ret;
// Tell the sensors to start working (or something like that)
ret = control_transfer_out_report(device, 0x0200, 0x0000, rep1, 8, 200);
// We expect IO errors from this call
if (ret != 8 && ret != LIBUSB_ERROR_IO) {
return BONKERS_ERROR;
}
// Read the response
ret = interrupt_transfer(device, 200);
if (ret) {
return BONKERS_ERROR;
}
// Report on the sensors
ret = control_transfer_out_report(device, 0x0200, 0x0000, rep2, 8, 200);
// Again, we expect IO errors
if (ret != 8 && ret != LIBUSB_ERROR_IO) {
return BONKERS_ERROR;
}
// Read the sensors
ret = interrupt_transfer(device, 200);
if (ret) {
return BONKERS_ERROR;
}
// Sometimes the device doesn't send us valid data.
// The last byte should never be 0x00.
if (device->state[7] == 0x00) {
return BONKERS_WARN; // Soft error reading state
}
return BONKERS_SUCCESS;
}
/* EB Brands - USB ! Key
* Device ID: 1130:6626
*
* This will time out the report when no events happen, so the code just
* waits for an event to occur.
*
* When pressed the button will provide
* 68 00 26 00 00 00 00 00
* and then immediately provide
* 00 00 00 00 00 00 00 00
*
* Holding the button down doesn't do anything special and it just returns
* the two codes immediately. You can not detect a held button.
*/
static void convert_state_1130_6626(device_config *device) {
if (device->state[0] == 0x68) {
device->state_now[0] = '1';
} else {
device->state_now[0] = '0';
}
device->state_now[1] = '\0';
}
static bonkers_result read_state_1130_6626(device_config *device) {
int ret;
ret = interrupt_transfer(device, 0);
if (ret) {
return BONKERS_ERROR;
}
return BONKERS_SUCCESS;
}
/**
* Repeatedly try to read the button state, pausing between reads.
*
* If a hard error is reported or there is success, this function exits.
*
* device = USB device
* dest = where to store the resulting byte
* interval = how long to wait between soft errors and trying again
*/
static int repeat_read_button_state(device_config *device, int interval) {
int result;
while (exit_code == -1) {
result = device->read_state(device);
if (result == BONKERS_SUCCESS) {
LOG(2, "State: %02x %02x %02x %02x %02x %02x %02x %02x", device->state[0], device->state[1], device->state[2], device->state[3], device->state[4], device->state[5], device->state[6], device->state[7]);
device->convert_state(device);
LOG(2, "State converted: %s", device->state_now);
}
if (result == BONKERS_SUCCESS || result == BONKERS_ERROR) {
return result;
}
usleep(interval);
}
return BONKERS_WARN;
}
/**
* Run a command. This also adds the current and previous status
* as command-line arguments.
*
* cmd = command to run (we add two more arguments)
* now = current status
* then = previous status
*/
void run_command(char const *cmd, char const *now, char const *prev) {
static char *modified = NULL;
int ret, bytes;
if (cmd) {
if (!modified) {
bytes = strlen(cmd) + MAX_STATE_STRING_LENGTH * 2 + 3;
modified = malloc(bytes);
if (!modified) {
ERROR("Could not allocate memory for command (%d bytes)", bytes);
exit_code = 1;
return;
}
}
sprintf(modified, "%s %s %s", cmd, now, prev);
LOG(1, "Running command: %s", modified);
ret = system(modified);
LOG(1, "Command returned %i", ret);
}
}
/**
* Set a flag to clean up gracefully.
*/
void exit_handler(int sig_num) {
exit_code = 0;
}
/**
* Help text
*
* name = the name of the program from the command line
*/
static void usage(char *name) {
printf(
"BONKERS!\n"
"\n"
"For more information, see the website:\n"
" https://github.com/fidian/bonkers\n"
"\n"
"Usage: %s [options]\n"
" -c <command> Command to execute with current and previous status.\n"
" -h This help text.\n"
" -p <microsends> Polling interval.\n"
" -q Quiet - silences output.\n"
" -v Turn on verbose output. With -vv, way more is printed.\n",
name
);
}
/**
* Run the detection loop. This repeatedly polls the device for a status.
*
* This loop function must watch exit_code, terminating if it is not -1.
*
* device = the device
* interval = usleep time
* command = command to execute on status updates
*/
static void run_detector(device_config *device, int interval, const char *command) {
LOG(1, "Detecting events");
// Poll the device to get the status until SIGINT or hard error
while (exit_code == BONKERS_RUN) {
if (repeat_read_button_state(device, interval)) {
exit_code = BONKERS_ERROR;
}
if (exit_code == BONKERS_RUN) {
if (strcmp(device->state_now, device->state_prev)) {
LOG(0, "State switched from '%s' to '%s'", device->state_prev, device->state_now);
run_command(command, device->state_now, device->state_prev);
strcpy(device->state_prev, device->state_now);
}
usleep(interval);
}
}
LOG(1, "Exit code was changed: %d", exit_code);
}
/**
* Use getopt to parse the command-line arguments.
*
* argc, argv = same as main
* interval = where to set an interval if one is passed
* command = where to assign the pointer for the command to execute
*/
void parse_arguments(int argc, char **argv, int *interval, const char **command) {
int c; // This typically stores a character but EOF is an integer
while ((c = getopt(argc, argv, "c:hp:qv")) != EOF) {
switch (c) {
case 'c':
*command = optarg;
break;
case 'h':
usage(argv[0]);
exit_code = BONKERS_SUCCESS;
return;
case 'p':
*interval = atoi(optarg);
if (*interval <= 0) {
exit_code = BONKERS_ERROR;
return;
}
break;
case 'q':
output_level = 0;
break;
case 'v':
output_level ++;
break;
}
}
}
/**
* Opens the handle and configures the device
*
* device = where to store the configured device information
*/
static bonkers_result scan_all_devices(device_config *device) {
// Clear the entire structure. This does a lot for us, such as
// nulling strings and setting all defaults to zero.
memset(device, 0, sizeof(device_config));
// Try to get a handle for each supported device
if (!seek_device("Dream Cheeky - USB Fidget (Soccer [Football])", 0x1d34, 0x0001, device)) {
device->read_state = read_state_1d34_fidget;
device->convert_state = convert_state_1d34_fidget;
return BONKERS_SUCCESS;
}
if (!seek_device("Dream Cheeky - USB Fidget (Basketball)", 0x1d34, 0x0002, device)) {
device->read_state = read_state_1d34_fidget;
device->convert_state = convert_state_1d34_fidget;
return BONKERS_SUCCESS;
}
if (!seek_device("Dream Cheeky - USB Fidget (Golf)", 0x1d34, 0x0003, device)) {
device->read_state = read_state_1d34_fidget;
device->convert_state = convert_state_1d34_fidget;
return BONKERS_SUCCESS;
}
if (!seek_device("Dream Cheeky - Big Red Button", 0x1d34, 0x000d, device)) {
device->read_state = read_state_1d34_000d;
device->convert_state = convert_state_1d34_000d;
return BONKERS_SUCCESS;
}
if (!seek_device("Dream Cheeky - Stress Ball", 0x1d34, 0x0020, device)) {
device->wValue = 0x0200;
device->read_state = read_state_1d34_0020;
device->convert_state = convert_state_1d34_0020;
return BONKERS_SUCCESS;
}
if (!seek_device("EB Brands - USB ! Key", 0x1130, 0x6626, device)) {
device->read_state = read_state_1130_6626;
device->convert_state = convert_state_1130_6626;
return BONKERS_SUCCESS;
}
return BONKERS_ERROR;
}
/**
* Our program
*/
int main(int argc, char **argv) {
char const *command = NULL;
int interval = 20000;
device_config device;
// Handle arguments to our program
parse_arguments(argc, argv, &interval, &command);
// In case any arguments were invalid
if (exit_code != BONKERS_RUN) {
return exit_code;
}
// Setup a signal handler, so we can cleanup gracefully
signal(SIGINT, exit_handler);
// Initialise libusb (with the default context)
if (LIBUSB_SUCCESS != libusb_init(NULL)) {
ERROR("Unable to initialize libusb");
return BONKERS_ERROR;
}
if (scan_all_devices(&device)) {
ERROR("Failed opening device descriptor (you may need to be root)...");
return BONKERS_ERROR;
}
// Detach the kernel driver if it is attached
if (detach_kernel_driver(device.handle)) {
ERROR("Can't detach kernel driver");
return BONKERS_ERROR;
}
if (LIBUSB_SUCCESS != libusb_claim_interface(device.handle, 0)) {
ERROR("Can't claim interface");
return BONKERS_ERROR;
}
LOG(1, "Interface claimed");
// Run the detector - this polls the device in a loop
run_detector(&device, interval, command);
// We are done
LOG(1, "Closing USB");
fflush(stdout);
fflush(stderr);
libusb_close(device.handle);
return exit_code;
}
|
#pragma src "/sys/src/libsexp"
#pragma lib "libsexp.a"
enum
{
Nil = 0,
List = 1,
Atom = 2,
ATOMSZ = 64,
};
typedef struct O O;
struct O
{
union {
O *o[2];
char *a;
};
int type;
};
/* sexp.c */
char *atomstr(O *o);
O *mka(char *c);
O *cons(O *car, O *cdr);
O *car(O *o);
O *cdr(O *o);
O *r(void);
void prin1(O *o);
void initsexp(void);
|
#include <gb/gb.h>
#include <stdbool.h>
#include "text.h"
#include "menu.h"
#include "title.h"
#include "intro.h"
#include "image_defeat.h"
#include "tools.h"
#include "gfx/defeat_tilemap.h"
// DRAW IMAGE_DEFEAT
void draw_image_defeat(unsigned int x, unsigned int y) {
set_bkg_tiles(x, y, DEFEAT_TILEMAP_WIDTH, DEFEAT_TILEMAP_HEIGHT, DEFEAT_TILEMAP);
}
UINT8 state_image_defeat() {
INT8 selected = -1;
if (english) {
text_print_string_win(0, 1, "GAME OVER");
text_print_string_win(1, 2, "RETRY");
text_print_string_win(1, 3, "QUIT");
} else {
text_print_string_win(0, 1, "eCHEC");
text_print_string_win(1, 2, "ReESSAYER");
text_print_string_win(1, 3, "QUITTER");
}
selected = draw_menu();
if (selected == 0) {
sound_OK();
return SCREEN_INTRO;
}
if (selected == 1) {
sound_OK();
return SCREEN_TITLE;
}
return SCREEN_SAME;
} |
#ifndef LEETCODE_SOLUTION_H
#define LEETCODE_SOLUTION_H
#include <vector>
using std::vector;
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int size = nums.size();
int nonZeroTailIdx = 0;
for (int i = 0, nonZeroTailIdx = 0; i < size; ++i) {
if (nums[i] != 0) {
nums[nonZeroTailIdx] = nums[i];
if (nonZeroTailIdx != i) {
nums[i] = 0;
}
++nonZeroTailIdx;
}
}
}
};
#endif //LEETCODE_SOLUTION_H |
#ifndef Base_h
#define Base_h
// 如果是调试模式(DEBUG 是调试模式下, 自带的宏)
#ifdef DEBUG
#define MHJLog(...) NSLog(__VA_ARGS__)
#define ENV @"Debug"
#else
#define MHJLog(...)
#define ENV @"Release"
#endif
#define MHJLogFunc MHJLog(@"%s", __func__)
// 屏幕尺寸相关
#define kScreenBounds [[UIScreen mainScreen] bounds]
#define kScreenWidth [[UIScreen mainScreen] bounds].size.width
#define kScreenHeight [[UIScreen mainScreen] bounds].size.height
// 弱引用
#define kWeakSelf __weak typeof(self) weakSelf = self;
#endif /* Base_h */
|
#ifndef __ALLOC_H__
#define __ALLOC_H__
#include <stddef.h>
void init_alloc(void);
void *kalloc(size_t);
void kfree(void *);
void *krealloc(void *, size_t);
#endif
|
#include "all.h"
int debug;
int initflag;
int apiflag;
int nomute;
char * dialcmd;
char * dquerycmd;
int Startquery = 8; /* default for 7506 set */
int Nextquery = 9;
char * srvname;
int pipefd[2];
int ttypid;
int alarmpid;
int fonepid;
int fonefd;
int fonectlfd;
char * logname = "call.log";
int logfd = -1;
#define NCALLS 26 /* number of appearances */
Call calls[NCALLS+1]; /* 1 extra */
Call * callsN = &calls[NCALLS];
Call * callsNout = &calls[4];
char display[2][64];
int switchhook;
char * dialstr;
ulong dialflags;
Call * dialother;
char dialbuf[64];
void
main(int argc, char **argv)
{
Biobufhdr bpp;
uchar buf[512]; char *l;
int n;
/*peek();/**/
ARGBEGIN{
case 'a':
setapiflag(1);
break;
case 'm':
++nomute;
break;
case 'n':
n = strtoul(ARGF(), 0, 0);
if(n < NCALLS)
callsNout = &calls[n+1];
break;
case 'f':
fname = ARGF();
break;
case 'F':
srvname = ARGF();
break;
case 't':
telcmd = ARGF();
break;
case 'l':
logname = ARGF();
break;
case 's':
srvname = dsrvname;
break;
case 'D':
++debug;
break;
}ARGEND
USED(argc, argv);
plumb();
fonepid = readfone();
alarmpid = readalarm();
ttypid = readtty();
close(0);
close(pipefd[1]);
logfd = open(logname, OWRITE);
if(logfd >= 0){
if(seek(logfd, 0, 2) < 0){
perror(logname);
close(logfd);
logfd = -1;
}
}
Binits((Biobuf *)&bpp, pipefd[0], OREAD, buf, sizeof buf);
foneinit();
while(l = Brdline((Biobuf *)&bpp, '\n')){ /* assign = */
n = BLINELEN((Biobuf *)&bpp);
if(n <= 0){
perror("pipe");
exits("read");
}
if(n < 2)
break;
l[n-1] = 0;
switch(l[0]){
case 't':
dotty(l+1);
break;
case 'q':
goto out;
case 'f':
if(dofone(l+1) < 0)
goto out;
break;
case 'a':
doalarm();
break;
}
}
out:
killproc(fonepid);
killproc(alarmpid);
killproc(ttypid);
exits(0);
}
void
dotty(char *buf)
{
char tonestr[32];
int id, nactive, smart, slot;
Call *cp;
if(debug){
char *t = ascnow();
t[19] = 0;
print("%s t %s\n", &t[11], buf);
}
while(*buf == ' ' || *buf == '\t')
buf++;
if(*buf == 0)
return;
if(!initflag && buf[0] != 'I'){
print("Telephone not responding, restart or try `I'\n");
return;
}
switch(buf[0]){
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if(!actcall()){
smart = 1;
goto Dialit;
}
/* fall through */
case '*': case '#':
case '.':
if(keyparse(tonestr, buf, sizeof tonestr))
putcmd("AT%s%s\r", dialcmd, tonestr);
else
print("can't parse touchtone string\n");
break;
case '/':
smart = 1;
goto Dialit;
case 'C':
case 'c':
if(!buf[1])
break;
smart = (*buf++ == 'c');
Dialit:
if(*buf == '/'){
buf++;
if(*buf >= 'a' && *buf <= 'z')
slot = *buf++ - 'a' + 1;
else
slot = strtoul(buf, &buf, 10);
}else
slot = 0;
if(!dialparse(smart, dialbuf, buf, sizeof dialbuf)){
print("can't parse dialstring\n");
break;
}
cp = outcall(slot);
if(cp == 0){
print(slot>0 ? "call slot %d not available\n" :
"no call slots available\n", slot);
break;
}
cp->dialp = dialbuf;
if(debug)
print("id=%d, dial=%s\n", cp->id, cp->dialp);
if(cp->state == Null){
putcmd("AT*B%c\r", '1' + cp->id - 1);
cp->flags |= Spkrdial;
}else
dialcall(cp);
break;
case 'a':
putcmd("AT*A\r");
break;
case 'd':
cp = actcall();
if(apiflag){
if(!cp || cp->confcount == 0)
putcmd("AT*H\r"); /* hangup */
else
putcmd("AT*J\r"); /* DROP button */
}else{
if((!cp || cp->confcount == 0) && (switchhook&~Mute) == Speaker)
putcmd("ATT*BS\r"); /* SPEAKER button */
else
putcmd("ATT*J\r"); /* DROP button */
}
break;
case 'h':
putcmd("AT*W\r");
break;
case 'I':
foneinit();
break;
case 'k':
xfrconf(Confdial, 'K', buf+1);
break;
case 'L':
putcmd("AT&&L\r");
break;
case 'q':
querystart(buf+1);
break;
case 'r':
id = strtol(buf+1,0,10);
for(cp=calls; cp<callsN; cp++){
if(cp->state != Suspended)
continue;
if(id == 0 || cp->id == id)
break;
}
if(cp >= callsN){
print("no suspended calls\n");
break;
}
putcmd("AT*B%c\r", '1' + cp->id - 1);
break;
case 's':
nactive = 0;
for(cp=calls; cp<callsN; cp++)
if(cp->state != Null){
++nactive;
showstate(cp);
}
if(nactive == 0)
print("no active calls\n");
break;
case 't':
telparse(buf+1);
break;
case '!':
shcmd(buf+1);
break;
case 'T':
if(apiflag)
setclock();
else
print("Can't set clock.\n");
break;
case 'x':
xfrconf(Xfrdial, 'T', buf+1);
break;
case '?':
print("%s", helptext);
break;
default:
print("unknown command, type ? for help\n");
break;
}
}
void
xfrconf(ulong flag, int code, char *buf)
{
Call *act, *cp;
act=actcall();
if(!act){
print("no active call\n");
return;
}
for(cp=calls; cp<callsN; cp++){
if(cp->flags & flag)
break;
}
if(cp >= callsN && !*buf){
print("dialstring required\n");
return;
}
if(cp < callsN && *buf){
print("dialstring illegal\n");
return;
}
if(*buf){
if(!dialparse(1, dialbuf, buf, sizeof dialbuf)){
print("can't parse dialstring\n");
return;
}
dialstr = dialbuf;
dialflags = flag;
dialother = act;
}
putcmd("AT*%c\r", code);
}
int
dofone(char *buf)
{
static int trouble;
int msg, type, pattern, r, c;
char *p, *q;
Call *cp;
switch(*buf){
case 'R':
msg = Red_lamp;
buf += 2;
break;
case 'G':
msg = Green_lamp;
buf += 2;
break;
case '0':
p = 0;
if(memcmp(buf, "03- 750", 7) == 0)
p = buf+7;
else if(memcmp(buf+1, "01-N- 750", 9) == 0)
p = buf+9;
if(p && (*p == '5' || *p == '6' || *p == '7')){
if(memcmp(buf+strlen(buf)-5, " PASS", 5) == 0){
msg = API_phone;
if(*p == '7'){
Startquery = 33;
Nextquery = 34;
}
break;
}
}
/* fall through */
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8':
msg = msgcode(&buf);
break;
case '9':
case 'P':
if(memcmp(buf, "969", 3) == 0 ||
memcmp(buf, "ProPhone", 8) == 0){
msg = Pro_phone;
break;
}
/* fall through */
default:
if(++trouble > 3 || debug)
showmsg(-1, buf);
if(trouble > 3){
print("couldn't init telephone, please try again\n");
return -1;
}
foneinit();
return 0;
}
if(debug)
showmsg(msg, buf);
switch(msg){
case Pro_phone:
if(buf[0] == 'P')
print("%s\n", buf);
initflag = 1;
setapiflag(0);
break;
case API_phone:
print("API %s\n", buf);
initflag = 1;
setapiflag(1);
putcmd("AT&D3\r");
putcmd("AT%%A0=3\r");
break;
case OK:
cmdpending = 0;
sendcmd();
break;
case Red_lamp:
print("Red: %s\n", buf);
break;
case Green_lamp:
print("Green: %s\n", buf);
break;
case Connected:
cp = getcall(&buf);
if(cp->assoc == Asc_setup){
cp->assoc = Asc_connect;
logstate(cp, "[connected]");
break;
}
cp->state = Active;
logstate(cp, "connected");
break;
case Ring:
cp = getcall(&buf);
incall(cp);
break;
case Cleared:
if(*buf == 0)
break;
cp = getcall(&buf);
logstate(cp, "disconnected");
memset(cp, 0, sizeof(Call));
cp->state = Null;
break;
case Error:
print("error\n");
cmdpending = 0;
sendcmd();
break;
case Delivered:
cp = getcall(&buf);
cp->state = Call_delivered;
break;
case Display:
dodisplay(buf);
break;
case Busy:
break;
case Feature:
break;
case Proceeding:
cp = getcall(&buf);
cp->state = Out_proceeding;
break;
case Progress:
break;
case Prompt:
cp = getcall(&buf);
cp->state = Overlap_send;
if(cp->dialp){
putcmd("AT%s%s\r", dialcmd, cp->dialp);
cp->dialp = 0;
break;
}
break;
case Signal:
cp = getcall(&buf);
pattern = hexcode(&buf);
if(cp->state == Null && pattern == 0x40)
incall(cp);
break;
case Outcall:
cp = getcall(&buf);
cp->state = Overlap_send;
cp->assoc = 0;
memset(cp->num, 0, sizeof cp->num);
strcpy(cp->who, "Outgoing call");
memset(cp->tty, 0, sizeof cp->tty);
if(!cp->dialp){
if(!dialstr)
break; /* sic */
cp->dialp = dialstr;
cp->flags = dialflags;
cp->other = dialother;
dialstr = 0;
dialflags = 0;
dialother = 0;
}
if(cp->flags & Spkrdial){
cp->flags &= ~Spkrdial;
if(!nomute){
if(apiflag)
apibutton(B_Mute, 0);
else
putcmd("AT*BM\r");
}
}
dialcall(cp);
break;
case Completed:
cp = getcall(&buf);
switch(hexcode(&buf)){
case 0x02: /* added to conference */
case 0x90: /* ProPhone */
if(cp->other)
cp->other->confcount++;
break;
case 0x03: /* dropped from conference */
case 0x98: /* ProPhone */
cp->confcount--;
break;
case 0x00: /* on hold */
case 0x9B: /* ProPhone */
logstate(cp, "suspended");
cp->state = Suspended;
break;
case 0x01: /* reconnected */
case 0x9E: /* ProPhone */
logstate(cp, "reconnected");
cp->state = Active;
break;
}
break;
case Rejected:
print("request rejected\n");
break;
case ATT_lamp:
break;
case ATT_tones:
break;
case Switchhook:
type = hexcode(&buf);
switch(type){
case Sw_Handset:
switchhook = Handset;
break;
case Sw_Handset|Off:
switchhook &= ~Handset;
break;
case Sw_Adjunct:
switchhook |= Adjunct;
break;
case Sw_Adjunct|Off:
switchhook &= ~Adjunct;
break;
case Sw_Speaker:
case Sw_Remote:
switchhook |= Speaker;
switchhook &= ~Mute;
break;
case Sw_Speaker|Off:
case Sw_Remote|Off:
switchhook &= ~Speaker;
break;
case Sw_Spokesman:
switchhook |= Spokesman;
break;
case Sw_Spokesman|Off:
switchhook &= ~Spokesman;
break;
case Sw_Mute:
if(switchhook&Speaker)
switchhook |= Mute;
break;
case Sw_Mute|Off:
if(switchhook&Speaker)
switchhook &= ~Mute;
break;
}
break;
case Disconnect:
cp = getcall(&buf);
cp->state = Release_req;
break;
case L3_error:
break;
case ATT_display:
break;
case Associated:
cp = getcall(&buf);
if(!apiflag)
hexcode(&buf);
type = hexcode(&buf);
switch(type){
case Asc_setup:
cp->state = Suspended;
cp->assoc = type;
logstate(cp, "[setup]");
break;
case Asc_connect:
if(cp->state == Call_received)
cp->state = Suspended;
cp->assoc = type;
logstate(cp, "[connected]");
break;
case Asc_hold:
cp->assoc = type;
logstate(cp, "[hold]");
break;
case Asc_reconn:
cp->assoc = type;
logstate(cp, "[reconnected]");
break;
case Asc_excl:
logstate(cp, "exclusion");
break;
case Asc_noconn:
cp->state = Suspended;
logstate(cp, "connection denied");
break;
case Asc_noclear:
cp->state = Suspended;
logstate(cp, "clearing denied");
break;
}
break;
case ATT_cause:
break;
case ATT_HI:
type = hexcode(&buf);
r = hexcode(&buf);
if(type == 0x11 && 1<= r && r <= 2){
q = display[r-1];
c = buf[2];
p = buf+3;
while(*p){
if(*p != c)
*q++ = *p++;
else if(p[1] == c)
*q++ = c, p+=2;
else
break;
}
*q = 0;
if(r == 2)
clockcruft();
}
break;
}
return 0;
}
void
dialcall(Call *cp)
{
switch(*cp->dialp){
case '9':
putcmd("AT%s%c\r", dialcmd, *cp->dialp++);
break;
default:
putcmd("AT%s%s\r", dialcmd, cp->dialp);
cp->dialp = 0;
break;
}
}
void
dodisplay(char *buf)
{
int id;
char ibuf[4];
char *ib = ibuf;
static Call *cp;
char *p = 0, *q;
if(apiflag){
hexcode(&buf);
ibuf[0] = *buf++;
ibuf[1] = *buf++;
ibuf[2] = 0;
id = hexcode(&ib);
}else{
id = hexcode(&buf);
hexcode(&buf);
}
while(*buf == ' ')
++buf;
switch(id){
case Call_appear_id:
cp = getcall(&buf);
break;
case Called_id:
case Calling_id:
if(cp)
p = cp->num;
break;
case Calling_name:
if(cp)
p = cp->who;
break;
case Isdn_call_id:
if(cp)
p = cp->tty;
break;
case Dir_info:
queryinfo(buf);
break;
case Date_Time:
break;
}
if(!(cp && p))
return;
q = &buf[strlen(buf)];
while(*--q == ' ')
*q = 0;
if(*buf && strcmp(p, buf) != 0){
strcpy(p, buf);
cp->flags |= Altered;
if(*cp->tty)
logstate(cp, 0);
}
}
static int clockset;
void
setclock(void)
{
int i;
apibutton(B_Normal, 1);
apibutton(B_Select, 1);
apibutton(B_Clock, 1);
for(i=0; i<6; i++)
apibutton(B_Keypad|'#', i<5);
putcmd("AT&&X0,0,3\r");
clockset = 1;
}
static void
showtm(Tm *tm)
{
print("%2d/%.2d/%d %2d:%.2d:%.2d\n",
tm->mon+1, tm->mday, tm->year%100,
tm->hour, tm->min, tm->sec);
}
static void
clkadvance(int n, int mod)
{
if(n < 0)
n += mod;
while(--n >= 0)
apibutton(B_Keypad|'*', 1);
apibutton(B_Keypad|'#', 1);
}
void
clockcruft(void)
{
static char *mnames[] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
0,
};
static int mdays[] = {
31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
};
int i;
Tm *tm, ctm;
char *p;
print("%s\n%s\n", display[0], display[1]);
if(clockset++ != 1){
clockset = 0;
return;
}
i = time(0);
tm = Localtime(i);
/*showtm(tm);*/
if(tm->sec >= 30)
tm = Localtime(i+30);
p = display[0];
while(*p == ' ')
p++;
for(i=0; mnames[i]; i++)
if(memcmp(p, mnames[i], 3) == 0)
break;
if(!mnames[i])
return;
memset(&ctm, 0, sizeof ctm);
ctm.mon = i;
ctm.mday = strtol(p+3, &p, 10);
if(!*p)
return;
ctm.year = strtol(p+1, &p, 10)-1900;
ctm.hour = strtol(p, &p, 10);
if(ctm.hour == 12)
ctm.hour = 0;
if(!*p)
return;
ctm.min = strtol(p+1, &p, 10);
while(*p == ' ')
p++;
if(*p == 'P')
ctm.hour += 12;
else if(*p != 'A')
return;
if(p[1] != 'M')
return;
/*showtm(&ctm);*/
apibutton(B_Normal, 1);
apibutton(B_Select, 1);
apibutton(B_Clock, 1);
clkadvance(tm->mon - ctm.mon, 12);
if(ctm.mday > mdays[tm->mon])
ctm.mday = mdays[tm->mon];
clkadvance(tm->mday - ctm.mday, mdays[tm->mon]);
clkadvance(tm->year - ctm.year, 25);
clkadvance(tm->hour - ctm.hour, 24);
clkadvance(tm->min - ctm.min, 60);
apibutton(B_Keypad|'#', 0);
putcmd("AT&&X0,0,3\r");
}
void
apibutton(int code, int keepem)
{
static int ctrl[8];
int group, number;
group = (code&B_Group)>>8;
number = code&B_Number;
if(!ctrl[group]){
ctrl[group] = 1;
putcmd("AT&&X0,%d,1,0\r", group);
}
if(group == (B_Keypad>>8) && number > 9){
putcmd("AT&&X%d,%c,1\r", group, number);
putcmd("AT&&X%d,%c,0\r", group, number);
}else{
putcmd("AT&&X%d,%d,1\r", group, number);
putcmd("AT&&X%d,%d,0\r", group, number);
}
if(keepem)
return;
for(group=0; group<nelem(ctrl); group++)
if(ctrl[group]){
ctrl[group] = 0;
putcmd("AT&&X0,%d,0,0\r", group);
}
}
void
logstate(Call *cp, char *p)
{
char *t, buf[128], *bp;
int n;
if(p == 0 && !(cp->flags & Altered))
return;
cp->flags &= ~Altered;
t = ascnow();
t[10]=t[19]=0;
bp = buf;
bp += sprint(bp, "%s:\t%s %s\t%d",
p ? p : cp->who, &t[4], &t[11], cp->id);
if(cp->tty[0] || cp->num[0])
bp += sprint(bp, "\t%s", cp->tty);
if(cp->num[0])
bp += sprint(bp, "\t%s", cp->num);
bp += sprint(bp, "\n");
n = bp - buf;
write(1, buf, n);
if(logfd >= 0)
write(logfd, buf, n);
}
void
incall(Call *cp)
{
cp->state = Call_received;
cp->assoc = 0;
memset(cp->num, 0, sizeof cp->num);
strcpy(cp->who, "Incoming call");
memset(cp->tty, 0, sizeof cp->tty);
}
Call *
getcall(char **bufp)
{
Call *cp;
int id;
id = hexcode(bufp);
cp = &calls[id];
if(cp >= callsN){
fprint(2, "bogus id %d\n", id);
cp = callsN;
}
cp->id = id;
return cp;
}
Call *
outcall(int slot)
{
Call *cp;
if(slot > 0){
cp = &calls[slot];
if(cp >= callsNout)
return 0;
if(cp->state == Null || (cp->state==Overlap_send && !cp->dialp))
goto found;
return 0;
}
for(cp=calls+1; cp<callsNout; cp++)
if(cp->state==Null || (cp->state==Overlap_send && !cp->dialp))
goto found;
return 0;
found:
cp->id = cp-calls;
return cp;
}
Call *
actcall(void)
{
Call *cp;
for(cp=calls; cp<callsN; cp++)
if(cp->state==Active)
return cp;
return 0;
}
void
showmsg(int msg, char *buf)
{
char *t;
Mname *m;
t = ascnow();
t[19] = 0;
for(m=M_Messages; m->name; m++)
if(msg == m->msg)
break;
if(m->name)
print("%s %s %s\n", &t[11], m->name, buf);
else
print("%s [%.2ux] %s\n", &t[11], msg, buf);
}
void
showstate(Call *cp)
{
Mname *m;
for(m=M_Callstates; m->name; m++)
if(cp->state == m->msg)
break;
print("id: %d\t%-15s\t%s\t%s\t%s\n",
cp->id, m->name ,cp->who, cp->tty, cp->num);
}
void
doalarm(void)
{}
void
setapiflag(int v)
{
apiflag = v;
dialcmd = apiflag ? "*D/" : "*D";
dquerycmd = apiflag ? "*D00/" : "*D";
}
void
foneinit(void)
{
if(debug)
print("foneinit...");
flushcmd();
fprint(fonefd, "ATE0V0&D0\r");
msleep(500);
initflag = 0;
putcmd("AT&&II3\r");
}
int
readfone(void)
{
int pid, n;
char *p;
Biobufhdr in;
uchar buf[512];
openfone();
switch(pid=fork()){
default:
return pid;
case -1:
perror("fork");
exits("fork");
case 0:
break;
}
close(0);
close(1);
close(pipefd[0]);
Binits((Biobuf *)&in, fonefd, OREAD, buf, sizeof buf);
while(p = Brdline((Biobuf *)&in, '\r')){ /* assign = */
n = BLINELEN((Biobuf *)&in);
while(n > 0 && (p[n-1] == '\n' || p[n-1] == '\r'))
--n;
while(n > 0 && (*p == '\n' || *p == '\r'))
--n, ++p;
if(n <= 0)
continue;
p[n] = 0;
if(fprint(pipefd[1], "f%s\n", p) < 0){
perror("pipe");
_exits("write");
}
}
_exits(0);
return 1; /* dummy to shut up compiler */
}
int
readalarm(void)
{
int pid;
long talarm = 1000;
switch(pid=fork()){
default:
return pid;
case -1:
perror("fork");
exits("fork");
case 0:
break;
}
close(0);
close(1);
close(pipefd[0]);
for(;;){
msleep(talarm);
if(write(pipefd[1], "a\n", 2) < 0)
break;
}
_exits(0);
return 1; /* dummy to shut up compiler */
}
int
readtty(void)
{
int pid, n;
char buf[256];
switch(pid=fork()){
default:
return pid;
case -1:
perror("fork");
exits("fork");
case 0:
break;
}
close(1);
close(pipefd[0]);
buf[0] = 't';
for(;;){
n = read(0, buf+1, sizeof buf-1);
if(n < 0)
fprint(2, "%s: can't read /fd/0: %r\n", argv0);
if(n <= 0){
buf[0] = 'q';
buf[1] = '\n';
n = 1;
}
if(write(pipefd[1], buf, n+1) < 0){
perror("pipe");
_exits("write");
}
if(buf[0] == 'q')
break;
}
_exits(0);
return 1; /* dummy to shut up compiler */
}
void
shcmd(char *cmd)
{
char *q;
switch(fork2()){
case -1:
perror("fork");
break;
case 0:
close(pipefd[0]);
close(fonefd);
close(0);
open("/dev/null", OREAD);
if(q = strrchr(shname, '/')) /* assign = */
++q;
else
q = shname;
execl(shname, q, "-c", cmd, 0);
fprint(2, "%s: can't exec %s: %r\n", argv0, shname);
_exits("exec");
}
}
void
telparse(char *p)
{
char *cmd;
int n;
while(*p == ' ')
p++;
n = strlen(telcmd)+strlen(p)+2;
cmd = malloc(n);
if(cmd == 0)
print("%s: %s %s: can't malloc %d\n",
argv0, telcmd, p, n);
else{
sprint(cmd, "%s %s", telcmd, p);
shcmd(cmd);
free(cmd);
}
}
int
msgcode(char **pp)
{
int msg;
msg = strtoul(*pp, pp, apiflag ? 10 : 16);
if(**pp)
*pp += 1;
return msg;
}
int
hexcode(char **pp)
{
int msg;
msg = strtoul(*pp, pp, 16);
if(**pp)
*pp += 1;
return msg;
}
|
/*++
Copyright(c) 1998,99 Microsoft Corporation
Module Name:
wlbsip.h
Abstract:
Windows Load Balancing Service (WLBS)
IP/TCP/UDP support
Author:
kyrilf
Environment:
Revision History:
--*/
#ifndef _Tcpip_h_
#define _Tcpip_h_
#ifdef KERNEL_MODE
#include <ndis.h>
#endif
#pragma pack(1)
/* type structures for basic protocols */
typedef struct
{
UCHAR byte [20];
}
IP_HDR, * PIP_HDR;
typedef struct
{
UCHAR byte [20];
}
TCP_HDR, * PTCP_HDR;
typedef struct
{
UCHAR byte [8];
}
UDP_HDR, * PUDP_HDR;
typedef struct
{
UCHAR byte [28];
}
ARP_HDR, * PARP_HDR;
#define TCPIP_BCAST_ADDR 0xffffffff /* IP broadcast address */
#define TCPIP_CLASSC_MASK 0x00ffffff /* IP address Class C mask */
/* protocol type signatures carried in the length field of Ethernet frame */
#define TCPIP_IP_SIG 0x0800 /* IP protocol */
#define TCPIP_ARP_SIG 0x0806 /* ARP/RARP protocol */
/* supported IP version */
#define TCPIP_VERSION 4 /* current IP version */
/* protocol types as encoded in IP header */
#define TCPIP_PROTOCOL_IP 0 /* Internet protocol id */
#define TCPIP_PROTOCOL_ICMP 1 /* Internet control message protocol id */
#define TCPIP_PROTOCOL_IGMP 2 /* Internet gateway message protocol id */
#define TCPIP_PROTOCOL_GGP 3 /* Gateway-gateway protocol id */
#define TCPIP_PROTOCOL_TCP 6 /* Transmission control protocol id */
#define TCPIP_PROTOCOL_EGP 8 /* Exterior gateway protocol id */
#define TCPIP_PROTOCOL_PUP 12 /* PARC universal packet protocol id */
#define TCPIP_PROTOCOL_UDP 17 /* user datagram protocol id */
#define TCPIP_PROTOCOL_HMP 20 /* Host monitoring protocol id */
#define TCPIP_PROTOCOL_XNS_IDP 22 /* Xerox NS IDP protocol id */
#define TCPIP_PROTOCOL_RDP 27 /* Reliable datagram protocol id */
#define TCPIP_PROTOCOL_RVD 66 /* MIT remote virtual disk protocol id */
#define TCPIP_PROTOCOL_RAW_IP 255 /* raw IP protocol id */
#define TCPIP_PROTOCOL_GRE 47 /* PPTP's GRE stream */
#define TCPIP_PROTOCOL_IPSEC1 50 /* IPSEC's data stream */
#define TCPIP_PROTOCOL_IPSEC2 51 /* IPSEC's data stream */
#define TCPIP_PROTOCOL_PPTP 99 /* This is a bogus protocol ID used by descriptor tracking in the load module. */
#define TCPIP_PROTOCOL_IPSEC_UDP 217 /* Bogus protocol ID used to track UDP subsequent
fragments within the IPSEC protocol in load.c */
#define IP_ADDR_LEN 4 /* in bytes */
/* Stolen from net\ipsec\oakley\ikedef.h and net\ipsec\oakley\isakmp.h for reference. */
#if 0
#define COOKIE_LEN 8
typedef struct isakmp_hdr_ {
unsigned char init_cookie[COOKIE_LEN];
unsigned char resp_cookie[COOKIE_LEN];
unsigned char next_payload;
#ifdef ISAKMP_i386
unsigned char minver:4,
majver:4;
#else
unsigned char majver:4,
minver:4;
#endif
unsigned char exch;
unsigned char flags;
unsigned long mess_id;
unsigned long len;
} isakmp_hdr;
typedef struct generic_payload_ {
unsigned char next_payload;
unsigned char reserved;
unsigned short payload_len;
} generic_payload;
typedef struct vendor_payload_ {
unsigned char next_payload;
unsigned char reserved;
unsigned short payload_len;
unsigned char vendor_id[1];
} generic_payload;
typedef struct notify_payload_ {
unsigned char next_payload;
unsigned char reserved;
unsigned short payload_len;
unsigned long doi;
unsigned char protocol_id;
unsigned char spi_size;
unsigned short notify_message;
}
#endif
/* IPSec/IKE header macros. */
typedef enum {
NLB_IPSEC_OTHER = 1,
NLB_IPSEC_INITIAL_CONTACT,
NLB_IPSEC_IDENTIFICATION
} NLB_IPSEC_PACKET_TYPE;
#define IPSEC_ISAKMP_SA 1
#define IPSEC_ISAKMP_ID 5
#define IPSEC_ISAKMP_VENDOR_ID 13
#define IPSEC_ISAKMP_NOTIFY 11
#define IPSEC_ISAKMP_NAT_DELIMITER_LENGTH 4
#define IPSEC_ISAKMP_NAT_DELIMITER {0x00, 0x00, 0x00, 0x00}
#define IPSEC_ISAKMP_MAIN_MODE_RCOOKIE {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
#define IPSEC_ISAKMP_HEADER_LENGTH 28
#define IPSEC_ISAKMP_HEADER_RCOOKIE_OFFSET 8
#define IPSEC_ISAKMP_HEADER_RCOOKIE_LENGTH 8
#define IPSEC_ISAKMP_HEADER_NEXT_PAYLOAD_OFFSET 16
#define IPSEC_ISAKMP_HEADER_PACKET_LENGTH_OFFSET 24
typedef struct {
UCHAR byte[IPSEC_ISAKMP_HEADER_LENGTH];
} IPSEC_ISAKMP_HDR, * PIPSEC_ISAKMP_HDR;
#define IPSEC_ISAKMP_GET_RCOOKIE_POINTER(isakmp_hdrp) ((PUCHAR)isakmp_hdrp + IPSEC_ISAKMP_HEADER_RCOOKIE_OFFSET)
#define IPSEC_ISAKMP_GET_NEXT_PAYLOAD(isakmp_hdrp) ((UCHAR)((isakmp_hdrp)->byte[IPSEC_ISAKMP_HEADER_NEXT_PAYLOAD_OFFSET]))
#define IPSEC_ISAKMP_GET_PACKET_LENGTH(isakmp_hdrp) ((ULONG)(((isakmp_hdrp)->byte[IPSEC_ISAKMP_HEADER_PACKET_LENGTH_OFFSET] << 24) | \
((isakmp_hdrp)->byte[IPSEC_ISAKMP_HEADER_PACKET_LENGTH_OFFSET + 1] << 16) | \
((isakmp_hdrp)->byte[IPSEC_ISAKMP_HEADER_PACKET_LENGTH_OFFSET + 2] << 8) | \
((isakmp_hdrp)->byte[IPSEC_ISAKMP_HEADER_PACKET_LENGTH_OFFSET + 3] << 0)))
#define IPSEC_GENERIC_HEADER_LENGTH 4
#define IPSEC_GENERIC_HEADER_NEXT_PAYLOAD_OFFSET 0
#define IPSEC_GENERIC_HEADER_PAYLOAD_LENGTH_OFFSET 2
typedef struct {
UCHAR byte[IPSEC_GENERIC_HEADER_LENGTH];
} IPSEC_GENERIC_HDR, * PIPSEC_GENERIC_HDR;
#define IPSEC_GENERIC_GET_NEXT_PAYLOAD(generic_hdrp) ((UCHAR)((generic_hdrp)->byte[IPSEC_GENERIC_HEADER_NEXT_PAYLOAD_OFFSET]))
#define IPSEC_GENERIC_GET_PAYLOAD_LENGTH(generic_hdrp) ((USHORT)(((generic_hdrp)->byte[IPSEC_GENERIC_HEADER_PAYLOAD_LENGTH_OFFSET] << 8) | \
((generic_hdrp)->byte[IPSEC_GENERIC_HEADER_PAYLOAD_LENGTH_OFFSET + 1] << 0)))
#define IPSEC_VENDOR_ID_INITIAL_CONTACT {0x26, 0x24, 0x4D, 0x38, 0xED, 0xDB, 0x61, 0xB3, 0x17, 0x2A, 0x36, 0xE3, 0xD0, 0xCF, 0xB8, 0x19}
#define IPSEC_VENDOR_ID_INITIAL_CONTACT_SUPPORT {0xA7, 0x72, 0xD1, 0x78, 0x08, 0x40, 0x9E, 0xDC, 0xCD, 0xAB, 0x92, 0x9A, 0x0F, 0x96, 0x91, 0xD0}
#define IPSEC_VENDOR_ID_MICROSOFT {0x1E, 0x2B, 0x51, 0x69, 0x05, 0x99, 0x1C, 0x7D, 0x7C, 0x96, 0xFC, 0xBF, 0xB5, 0x87, 0xE4, 0x61}
#define IPSEC_VENDOR_ID_MICROSOFT_MIN_VERSION 0x00000004
#define IPSEC_VENDOR_ID_PAYLOAD_LENGTH 20
#define IPSEC_VENDOR_HEADER_VENDOR_ID_OFFSET 4
#define IPSEC_VENDOR_HEADER_VENDOR_ID_LENGTH 16
#define IPSEC_VENDOR_HEADER_VENDOR_VERSION_OFFSET 20
#define IPSEC_VENDOR_HEADER_VENDOR_VERSION_LENGTH 4
typedef struct {
UCHAR byte[IPSEC_GENERIC_HEADER_LENGTH + IPSEC_VENDOR_ID_PAYLOAD_LENGTH];
} IPSEC_VENDOR_HDR, * PIPSEC_VENDOR_HDR;
#define IPSEC_VENDOR_ID_GET_ID_POINTER(vendor_hdrp) ((PUCHAR)vendor_hdrp + IPSEC_VENDOR_HEADER_VENDOR_ID_OFFSET)
#define IPSEC_VENDOR_ID_GET_VERSION(vendor_hdrp) ((ULONG)(((vendor_hdrp)->byte[IPSEC_VENDOR_HEADER_VENDOR_VERSION_OFFSET] << 24) | \
((vendor_hdrp)->byte[IPSEC_VENDOR_HEADER_VENDOR_VERSION_OFFSET + 1] << 16) | \
((vendor_hdrp)->byte[IPSEC_VENDOR_HEADER_VENDOR_VERSION_OFFSET + 2] << 8) | \
((vendor_hdrp)->byte[IPSEC_VENDOR_HEADER_VENDOR_VERSION_OFFSET + 3] << 0)))
#define IPSEC_NOTIFY_INITIAL_CONTACT 24578
#define IPSEC_NOTIFY_PAYLOAD_LENGTH 8
#define IPSEC_NOTIFY_HEADER_NOTIFY_MESSAGE_OFFSET 10
typedef struct {
UCHAR byte[IPSEC_GENERIC_HEADER_LENGTH + IPSEC_NOTIFY_PAYLOAD_LENGTH];
} IPSEC_NOTIFY_HDR, * PIPSEC_NOTIFY_HDR;
#define IPSEC_NOTIFY_GET_NOTIFY_MESSAGE(notify_hdrp) ((USHORT)(((notify_hdrp)->byte[IPSEC_NOTIFY_HEADER_NOTIFY_MESSAGE_OFFSET] << 8) | \
((notify_hdrp)->byte[IPSEC_NOTIFY_HEADER_NOTIFY_MESSAGE_OFFSET + 1] << 0)))
/* ARP header macros - note address locations assume 6 byte MAC (Ethernet)
and 4 byte protocol (IP) sizes */
/* type of hardware address */
#define ARP_GET_MAC_TYPE(p) (((ULONG) ((p) -> byte[0]) << 8) | (ULONG) ((p) -> byte[1]))
/* higher layer addressing protocol */
#define ARP_GET_PROT_TYPE(p) (((ULONG) ((p) -> byte[2]) << 8) | (ULONG) ((p) -> byte[3]))
/* length of hardware address */
#define ARP_GET_MAC_LEN(p) ((ULONG) ((p) -> byte[4]))
/* length of higher layer address */
#define ARP_GET_PROT_LEN(p) ((ULONG) ((p) -> byte[5]))
/* type of message */
#define ARP_GET_MSG_TYPE(p) (((ULONG) ((p) -> byte[6]) << 8) | (ULONG) ((p) -> byte[7]))
/* source hardware address */
#define ARP_GET_SRC_MAC_PTR(p) (&((p) -> byte[8]))
#define ARP_GET_SRC_MAC(p,n) ((ULONG) ((p) -> byte[8 + (n)]))
/* source higher layer address */
#define ARP_GET_SRC_PROT(p,n) ((ULONG) ((p) -> byte[14 + (n)]))
#define ARP_GET_SRC_FPROT(p) (* ((PULONG) &((p) -> byte[14])))
/* 64-bit -- ramkrish */
#define ARP_GET_SRC_PROT_64(p) ((ULONG) (((p) -> byte[14] << 0) | ((p) -> byte[15] << 8) | \
((p) -> byte[16] << 16) | ((p) -> byte[17] << 24)))
/* destination hardware address */
#define ARP_GET_DST_MAC_PTR(p) (&((p) -> byte[18]))
#define ARP_GET_DST_MAC(p,n) ((ULONG) ((p) -> byte[18 + (n)]))
/* destination higher layer address */
#define ARP_GET_DST_PROT(p,n) ((ULONG) ((p) -> byte[24 + (n)]))
#define ARP_GET_DST_FPROT(p) (* ((PULONG) &((p) -> byte[24])))
/* 64-bit -- ramkrish */
#define ARP_GET_DST_PROT_64(p) ((ULONG) (((p) -> byte[18] << 0) | ((p) -> byte[19] << 8) | \
((p) -> byte[20] << 16) | ((p) -> byte[21] << 24)))
#define ARP_MAC_TYPE_ETH 0x0001
#define ARP_PROT_TYPE_IP 0x0800
#define ARP_MAC_LEN_ETH 6
#define ARP_PROT_LEN_IP 4
#define ARP_MSG_TYPE_REQ 0x1
#define ARP_MSG_TYPE_RSP 0x2
/* IP datagram header macros */
/* IP version number */
#define IP_GET_VERS(p) ((ULONG) ((((p) -> byte[0]) >> 4) & 0xf))
/* header length in 32-bit words */
#define IP_GET_HLEN(p) ((ULONG) (((p) -> byte[0]) & 0xf))
/* service type */
#define IP_GET_SRVC(p) ((ULONG) ((p) -> byte[1]))
/* total datagram packet length in bytes */
#define IP_GET_PLEN(p) (((ULONG) ((p) -> byte[2]) << 8) | (ULONG) ((p) -> byte[3]))
/* fragmentation identification - this one seems to have bytes swaped within
the short word ??? */
#define IP_GET_FRAG_ID(p) (((ULONG) ((p) -> byte[5]) << 8) | (ULONG) ((p) -> byte[4]))
/* fragmentation flags */
#define IP_GET_FRAG_FLGS(p) ((ULONG) ((((p) -> byte[6]) >> 5) & 0x7))
/* fragmentation offset */
#define IP_GET_FRAG_OFF(p) (((ULONG) ((p) -> byte[6] & 0x1f) << 8) | (ULONG) ((p) -> byte[7]))
/* Time To Live in seconds */
#define IP_GET_TTL(p) ((ULONG) ((p) -> byte[8]))
/* higher level protocol id */
#define IP_GET_PROT(p) ((ULONG) ((p) -> byte[9]))
/* header checksum - this one seems to have bytes swaped within
the short word ??? */
#define IP_GET_CHKSUM(p) (((USHORT) ((p) -> byte[10]) << 8) | (USHORT) ((p) -> byte[11]))
#define IP_SET_CHKSUM(p,c) (((p) -> byte[10] = (c) >> 8), ((p) -> byte[11] = (c) & 0xff))
/* source IP address */
#define IP_GET_SRC_ADDR(p,n) ((ULONG) ((p) -> byte[12 + (n)]))
#define IP_GET_SRC_ADDR_PTR(p) (&((p) -> byte[12]))
#define IP_GET_SRC_FADDR(p) (* ((PULONG) &((p) -> byte[12]))) /* 64-bit -- ramkrish */
#ifdef _WIN64
#define IP_GET_SRC_ADDR_64(p) ((ULONG) (((p) -> byte[12] << 0) | ((p) -> byte[13] << 8) | \
((p) -> byte[14] << 16) | ((p) -> byte[15] << 24)))
#else
// This is faster than the one above. This function is called in critical receiving path
#define IP_GET_SRC_ADDR_64(p) (* ((PULONG) &((p) -> byte[12])))
#endif
/* destination IP address */
#define IP_GET_DST_ADDR(p,n) ((ULONG) ((p) -> byte[16 + (n)]))
#ifdef _WIN64
#define IP_GET_DST_ADDR_64(p) ((ULONG) (((p) -> byte[16] << 0) | ((p) -> byte[17] << 8) | \
((p) -> byte[18] << 16) | ((p) -> byte[19] << 24)))
#else
// This is faster than the one above. This function is called in critical receiving path
#define IP_GET_DST_ADDR_64(p) (* ((PULONG) &((p) -> byte[16])))
#endif
/* 64-bit -- ramkrish */
#define IP_SET_SRC_ADDR_64(p,c) { \
PUCHAR tmp = (PUCHAR) (&(c)); \
(p) -> byte[12] = tmp[0]; (p) -> byte[13] = tmp[1]; \
(p) -> byte[14] = tmp[2]; (p) -> byte[15] = tmp[3]; \
}
#define IP_SET_DST_ADDR_64(p,c) { \
PUCHAR tmp = (PUCHAR) (&(c)); \
(p) -> byte[16] = tmp[0]; (p) -> byte[17] = tmp[1]; \
(p) -> byte[18] = tmp[2]; (p) -> byte[19] = tmp[3]; \
}
/* get IP address octets. */
#define IP_GET_ADDR(p,b0,b1,b2,b3) { \
*(b3) = ((p) & 0xff000000) >> 24; \
*(b2) = ((p) & 0x00ff0000) >> 16; \
*(b1) = ((p) & 0x0000ff00) >> 8; \
*(b0) = ((p) & 0x000000ff) >> 0; \
}
/* Get the Nth octect of an IP address DWORD. The zeroeth octect is the least significant byte of the DWORD. */
#define IP_GET_OCTET(p,n) (((p) & (0x000000ff << (8*(n)))) >> (8*(n)))
/* create IP address from 4 bytes */
#define IP_SET_ADDR(p,b0,b1,b2,b3) (* (p) = (((b0) << 0) | ((b1) << 8) | ((b2) << 16) | ((b3) << 24)))
/* compute broadcast address from IP address and netmask */
#define IP_SET_BCAST(p,a,m) (* (p) = ((a) & (m)) | (~(m)))
/* TCP header macros */
/* pointer to TCP header from IP header pointer */
#define TCP_PTR(p) ((PTCP_HDR)(((ULONG *)(p)) + ((ULONG)IP_GET_HLEN(p))))
/* source port */
#define TCP_GET_SRC_PORT(p) (((ULONG) ((p) -> byte[0]) << 8) | (ULONG) ((p) -> byte[1]))
#define TCP_GET_SRC_PORT_PTR(p) (& ((p) -> byte[0])) /* 64-bit -- ramkrish */
/* destination port */
#define TCP_GET_DST_PORT(p) (((ULONG) ((p) -> byte[2]) << 8) | (ULONG) ((p) -> byte[3]))
#define TCP_GET_DST_PORT_PTR(p) (& ((p) -> byte[2])) /* 64-bit -- ramkrish */
/* sequence number */
#define TCP_GET_SEQ_NO(p) (((ULONG) ((p) -> byte[4]) << 24) | ((ULONG) ((p) -> byte[5]) << 16) | \
((ULONG) ((p) -> byte[6]) << 8) | (ULONG) ((p) -> byte[7]))
/* acknowledgement number */
#define TCP_GET_ACK_NO(p) (((ULONG) ((p) -> byte[8]) << 24) | ((ULONG) ((p) -> byte[9]) << 16) | \
((ULONG) ((p) -> byte[10]) << 8) | (ULONG) ((p) -> byte[11]))
/* flags */
#define TCP_GET_FLAGS(p) (((ULONG) ((p) -> byte[13])) & 0x3f)
/* header length in 32-bit words */
#define TCP_GET_HLEN(p) ((ULONG) (((p) -> byte[12]) >> 4))
/* datagram length */
#define TCP_GET_DGRAM_LEN(i,t) (IP_GET_PLEN (i) - ((IP_GET_HLEN (i) + TCP_GET_HLEN (t)) * sizeof (ULONG)))
/* pointer to datagram */
#define TCP_GET_DGRAM_PTR(p) ((PUCHAR)(((ULONG *)(p)) + ((ULONG) TCP_GET_HLEN(p))))
/* checksum field */
#define TCP_GET_CHKSUM(p) ((((USHORT)((p) -> byte[16])) << 8) | (USHORT)((p) -> byte[17]))
#define TCP_SET_CHKSUM(p,c) (((p) -> byte[16] = (c) >> 8), ((p) -> byte[17] = (c) & 0xff))
#define TCP_FLAG_URG 0x20
#define TCP_FLAG_ACK 0x10
#define TCP_FLAG_PSH 0x8
#define TCP_FLAG_RST 0x4
#define TCP_FLAG_SYN 0x2
#define TCP_FLAG_FIN 0x1
/* UDP header macros */
/* pointer to TCP header from IP header pointer */
#define UDP_PTR(p) ((PUDP_HDR)(((ULONG *)(p)) + ((ULONG)IP_GET_HLEN(p))))
/* source port */
#define UDP_GET_SRC_PORT(p) (((ULONG) ((p) -> byte[0]) << 8) | (ULONG) ((p) -> byte[1]))
#define UDP_GET_SRC_PORT_PTR(p) (& ((p) -> byte[0]))
#define UDP_GET_SRC_FPORT(p) (* ((PUSHORT) &((p) -> byte[0])))
/* 64-bit -- ramkrish */
#define UDP_SET_SRC_PORT_64(p,v) (((p) -> byte[0] = v >> 8), ((p) -> byte[1] = v & 0xff))
/* destination port */
#define UDP_GET_DST_PORT(p) (((ULONG) ((p) -> byte[2]) << 8) | (ULONG) ((p) -> byte[3]))
#define UDP_GET_DST_PORT_PTR(p) (& ((p) -> byte[2]))
#define UDP_GET_DST_FPORT(p) (* ((PUSHORT) &((p) -> byte[2])))
/* 64-bit -- ramkrish */
#define UDP_SET_DST_PORT_64(p,v) (((p) -> byte[2] = v >> 8), ((p) -> byte[3] = v & 0xff))
/* packet length */
#define UDP_GET_LEN(p) (((ULONG) ((p) -> byte[4]) << 8) | (ULONG) ((p) -> byte[5]))
/* packet length */
#define UDP_GET_CHKSUM(p) (((USHORT) ((p) -> byte[6]) << 8) | (USHORT) ((p) -> byte[7]))
#define UDP_SET_CHKSUM(p,c) (((p) -> byte[6] = (c) >> 8), ((p) -> byte[7] = (c) & 0xff))
/* pointer to datagram */
#define UDP_GET_DGRAM_PTR(p) ((PUCHAR)(p) + sizeof (UDP_HDR))
/* V1.11 NetBIOS name cluster name support */
#define NBT_NAME_LEN 16
#define NBT_ENCODED_NAME_LEN (2 * NBT_NAME_LEN) /* multiplier HAS to be 2 */
#define NBT_ENCODED_NAME_BASE 'A'
#define NBT_NAME_SHADOW "*SMBSERVER "
#define NBT_ENCODED_NAME_SHADOW \
{ \
'C', 'K', 'F', 'D', 'E', 'N', 'E', 'C', 'F', 'D', 'E', 'F', 'F', 'C', 'F', 'G', \
'E', 'F', 'F', 'C', 'C', 'A', 'C', 'A', 'C', 'A', 'C', 'A', 'C', 'A', 'C', 'A' \
}
#define NBT_ENCODE_FIRST(c) (((c) >> 4) + NBT_ENCODED_NAME_BASE)
#define NBT_ENCODE_SECOND(c) (((c) & 0xf) + NBT_ENCODED_NAME_BASE)
#define NBT_SESSION_PORT 139
#define NBT_SESSION_REQUEST 0x81 /* packet type */
typedef struct
{
UCHAR byte[72]; /* only the session request packet */
}
NBT_HDR, * PNBT_HDR;
/* pointer to NBT header from TCP header */
#define NBT_PTR(p) ((PNBT_HDR)(((ULONG *)(p)) + ((ULONG) TCP_GET_HLEN(p))))
/* packet type */
#define NBT_GET_PKT_TYPE(p) ((ULONG) ((p) -> byte[0]))
/* packet length */
#define NBT_GET_PKT_LEN(p) ((ULONG) ((p) -> byte[3]))
/* called name */
#define NBT_GET_CALLED_NAME(p) ((PUCHAR) & ((p) -> byte[4])) /* server's name */
/* calling name */
#define NBT_GET_CALLING_NAME(p) ((PUCHAR) & ((p) -> byte[36])) /* client's name */
/* PPTP/IPSEC support */
#define PPTP_CTRL_PORT 1723
#define IPSEC_NAT_PORT 4500
#define IPSEC_CTRL_PORT 500
#define TCP_HTTP_PORT 80
/* TCPIP module context */
typedef struct
{
UCHAR nbt_encoded_cluster_name [NBT_ENCODED_NAME_LEN]; /* V1.2 */
}
TCPIP_CTXT, * PTCPIP_CTXT;
#pragma pack()
#endif /* _Tcpip_h_ */
|
#ifndef __READING_H__
#define __READING_H__
#include "config.h"
struct Reading {
int temperature = UNSET_INT;
int humidity = UNSET_INT;
int connectionTime = -1;
int readTime = -1;
int battery = 0;
};
#endif |
/*
*jugle a words is palindrome
*/
#include <stdio.h>
#include <string.h>
int main()
{
int flag = 0, length, i;
char str[100];
scanf("%s", str);
length = strlen(str) - 1;
for(i = 0; i <= length / 2; i++){
if(str[i] == str[length -i]){
flag = 1;
}else{
flag = 0;
}
}
if(flag == 1){
printf("Yes, It is a palindrome.\n");
}else{
printf("No, It is not a palindrome.\n");
}
return 0;
}
|
#ifndef OPENTISSUE_CORE_CONTAINERS_GRID_UTIL_RESAMPLE_H
#define OPENTISSUE_CORE_CONTAINERS_GRID_UTIL_RESAMPLE_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>
#include <cmath>
#include <OpenTissue/core/containers/grid/util/grid_value_at_point.h>
#include <OpenTissue/core/containers/grid/util/grid_idx2coord.h>
namespace OpenTissue
{
namespace grid
{
/**
* Resample a grid to lower dimensions.
* @param M Original grid to be resampled.
* @param m Destination grid.
* @param factor_i Scale factor in the I-direction of the grid.
* @param factor_j Scale factor in the J-direction of the grid.
* @param factor_k Scale factor in the K-direction of the grid.
* @return Upon return the destination grid m contains the resampled grid.
*/
template <typename grid_type, typename real_type>
inline void resample(grid_type const & M, grid_type & m, real_type factor_i, real_type factor_j, real_type factor_k)
{
using std::floor;
assert(factor_i > 0 || !"resample(): i scale factor must be positive");
assert(factor_j > 0 || !"resample(): j scale factor must be positive");
assert(factor_k > 0 || !"resample(): k scale factor must be positive");
typedef typename grid_type::math_types math_types;
typedef typename math_types::vector3_type vector3_type;
typedef typename grid_type::index_iterator index_iterator;
// TODO: Add gaussian smoothing with a standard deviation corresponding to factor_n.
//grid_type S = M;
//grid_gaussian_convolution(M,S,factor_i/2.0,factor_j/2.0,factor_k/2.0);
m.create(
M.min_coord(), M.max_coord()
, static_cast<size_t>( floor(M.I()/factor_i) )
, static_cast<size_t>( floor(M.J()/factor_j) )
, static_cast<size_t>( floor(M.K()/factor_k) )
);
vector3_type point;
for( index_iterator iter = m.begin(); iter != m.end(); ++iter )
{
idx2coord( iter,point );
(*iter) = value_at_point( M, point );
}
}
} // namespace grid
} // namespace OpenTissue
// OPENTISSUE_CORE_CONTAINERS_GRID_UTIL_RESAMPLE_H
#endif
|
/***************************************************************************//**
* @file main.c
* @version V3.00
* @brief Demonstrate how to light up the WS1812B LED array.
*
* SPDX-License-Identifier: Apache-2.0
* @copyright (C) 2019 Nuvoton Technology Corp. All rights reserved.
******************************************************************************/
#include <stdio.h>
#include "NuMicro.h"
#include "WS1812B_driver_LED.h"
#define LED_NUMBER 8
#define PIN_NUMBER 2
typedef enum
{
eCASE_GREEN_BLUE = 0,
eCASE_RED_GREEN,
eCASE_BLUE_RED,
eCASE_WHITE,
} E_LED_COLOR;
void SYS_Init(void)
{
/*---------------------------------------------------------------------------------------------------------*/
/* Init System Clock */
/*---------------------------------------------------------------------------------------------------------*/
/* Enable HIRC clock (Internal RC 48 MHz) */
CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
/* Wait for HIRC clock ready */
CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
/* Select HCLK clock source as HIRC and and HCLK clock divider as 1 */
CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HIRC, CLK_CLKDIV0_HCLK(1));
/* Set XT1_OUT(PF.2) and XT1_IN(PF.3) to input mode */
PF->MODE &= ~(GPIO_MODE_MODE2_Msk | GPIO_MODE_MODE3_Msk);
/* Disable digital input path of analog pin XT1_OUT to prevent leakage */
GPIO_DISABLE_DIGITAL_PATH(PF, (1ul << 2));
/* Disable digital input path of analog pin XT1_IN to prevent leakage */
GPIO_DISABLE_DIGITAL_PATH(PF, (1ul << 3));
/* Enable PDMA module clock */
CLK_EnableModuleClock(PDMA_MODULE);
/* Enable PSIO module clock */
CLK_EnableModuleClock(PSIO_MODULE);
/* Select PSIO module clock source as HIRC and PSIO module clock divider as 4 */
CLK_SetModuleClock(PSIO_MODULE, CLK_CLKSEL2_PSIOSEL_HIRC, CLK_CLKDIV1_PSIO(4));
/* Enable UART module clock */
CLK_EnableModuleClock(UART0_MODULE);
/* Select UART module clock source as HIRC and UART module clock divider as 1 */
CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART0SEL_HIRC, CLK_CLKDIV0_UART0(1));
/* PDMA Clock Enable */
CLK->AHBCLK |= CLK_AHBCLK_PDMACKEN_Msk;
/* Update System Core Clock */
/* User can use SystemCoreClockUpdate() to calculate SystemCoreClock. */
SystemCoreClockUpdate();
/*---------------------------------------------------------------------------------------------------------*/
/* Init I/O Multi-function */
/*---------------------------------------------------------------------------------------------------------*/
Uart0DefaultMPF();
/* PSIO multi-function pin CH0(PB.15) and CH1(PC.4)*/
SYS->GPB_MFPH &= ~(SYS_GPB_MFPH_PB15MFP_Msk);
SYS->GPB_MFPH |= (SYS_GPB_MFPH_PB15MFP_PSIO0_CH0);
SYS->GPC_MFPL &= ~(SYS_GPC_MFPL_PC4MFP_Msk);
SYS->GPC_MFPL |= (SYS_GPC_MFPL_PC4MFP_PSIO0_CH1);
}
void UART0_Init()
{
/*---------------------------------------------------------------------------------------------------------*/
/* Init UART */
/*---------------------------------------------------------------------------------------------------------*/
/* Configure UART0 and set UART0 baud rate */
UART_Open(UART0, 115200);
}
/*---------------------------------------------------------------------------------------------------------*/
/* Main Function */
/*---------------------------------------------------------------------------------------------------------*/
int main(void)
{
/* For library internal used, this memory size should be (data length)*3 word at least, */
/* this case is LED_NUMBER*PIN_NUMBER*3 word. */
uint32_t au32LedPattern[LED_NUMBER * PIN_NUMBER], au32InternalUse[LED_NUMBER * PIN_NUMBER * 3];
S_PSIO_WS2812B_LED_CFG sConfig;
E_LED_COLOR eColor = eCASE_GREEN_BLUE;
WS2812B_LED_Pin_CFG sPinCFG = {PSIO_PIN0, PSIO_PIN1, 0, 0, 0, 0, 0, 0}; //Enable Pin0 and Pin1
/* Unlock protected registers */
SYS_UnlockReg();
/* Init System, IP clock and multi-function I/O */
SYS_Init();
/* Lock protected registers */
/* If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register. */
SYS_LockReg();
/* Init UART for printf */
UART0_Init();
printf("\n\nCPU @ %dHz\n", SystemCoreClock);
printf("+------------------------------------------------------+ \n");
printf("| Worldsemi WS2812B LED sample code | \n");
printf("| Please connected PSIO_CH0(PB.15) | \n");
printf("| and PSIO_CH1(PC.4) to device | \n");
printf("+------------------------------------------------------+ \n");
/* Set Led configuration */
sConfig.u8SlotCtrl = PSIO_SC0;
sConfig.u8PDMAChannel = 0;
sConfig.pu8PinCFG = sPinCFG;
sConfig.u8PinNumber = 2;
sConfig.pu32DataAddr = au32LedPattern;
sConfig.u32DataLength = LED_NUMBER * PIN_NUMBER;
sConfig.pu32InternalMemory = au32InternalUse; /* For library internal used, the memory size should be (data length)*3 word at least. */
/* This case is LED_NUMBER*PIN_NUMBER*3 word. */
/* Initialize PSIO setting for WS2812B LED */
PSIO_WS2812B_Open(&sConfig);
do
{
switch (eColor)
{
case eCASE_GREEN_BLUE:
/* PIN0 */ /* PIN1 */
au32LedPattern[0] = WS2812B_GREEN;
au32LedPattern[1] = WS2812B_BLUE; //LED0
au32LedPattern[2] = WS2812B_GREEN;
au32LedPattern[3] = WS2812B_BLUE; //LED1
au32LedPattern[4] = WS2812B_GREEN;
au32LedPattern[5] = WS2812B_BLUE; //LED2
au32LedPattern[6] = WS2812B_GREEN;
au32LedPattern[7] = WS2812B_BLUE; //LED3
au32LedPattern[8] = WS2812B_GREEN;
au32LedPattern[9] = WS2812B_BLUE; //LED4
au32LedPattern[10] = WS2812B_GREEN;
au32LedPattern[11] = WS2812B_BLUE; //LED5
au32LedPattern[12] = WS2812B_GREEN;
au32LedPattern[13] = WS2812B_BLUE; //LED6
au32LedPattern[14] = WS2812B_GREEN;
au32LedPattern[15] = WS2812B_BLUE; //LED7
eColor = eCASE_RED_GREEN;
break;
case eCASE_RED_GREEN:
/* PIN0 */ /* PIN1 */
au32LedPattern[0] = WS2812B_RED;
au32LedPattern[1] = WS2812B_GREEN; //LED0
au32LedPattern[2] = WS2812B_RED;
au32LedPattern[3] = WS2812B_GREEN; //LED1
au32LedPattern[4] = WS2812B_RED;
au32LedPattern[5] = WS2812B_GREEN; //LED2
au32LedPattern[6] = WS2812B_RED;
au32LedPattern[7] = WS2812B_GREEN; //LED3
au32LedPattern[8] = WS2812B_RED;
au32LedPattern[9] = WS2812B_GREEN; //LED4
au32LedPattern[10] = WS2812B_RED;
au32LedPattern[11] = WS2812B_GREEN; //LED5
au32LedPattern[12] = WS2812B_RED;
au32LedPattern[13] = WS2812B_GREEN; //LED6
au32LedPattern[14] = WS2812B_RED;
au32LedPattern[15] = WS2812B_GREEN; //LED7
eColor = eCASE_BLUE_RED;
break;
case eCASE_BLUE_RED:
/* PIN0 */ /* PIN1 */
au32LedPattern[0] = WS2812B_BLUE;
au32LedPattern[1] = WS2812B_RED; //LED0
au32LedPattern[2] = WS2812B_BLUE;
au32LedPattern[3] = WS2812B_RED; //LED1
au32LedPattern[4] = WS2812B_BLUE;
au32LedPattern[5] = WS2812B_RED; //LED2
au32LedPattern[6] = WS2812B_BLUE;
au32LedPattern[7] = WS2812B_RED; //LED3
au32LedPattern[8] = WS2812B_BLUE;
au32LedPattern[9] = WS2812B_RED; //LED4
au32LedPattern[10] = WS2812B_BLUE;
au32LedPattern[11] = WS2812B_RED; //LED5
au32LedPattern[12] = WS2812B_BLUE;
au32LedPattern[13] = WS2812B_RED; //LED6
au32LedPattern[14] = WS2812B_BLUE;
au32LedPattern[15] = WS2812B_RED; //LED7
eColor = eCASE_WHITE;
break;
case eCASE_WHITE:
/* PIN0 */ /* PIN1 */
au32LedPattern[0] = WS2812B_WHITE;
au32LedPattern[1] = WS2812B_WHITE; //LED0
au32LedPattern[2] = WS2812B_WHITE;
au32LedPattern[3] = WS2812B_WHITE; //LED1
au32LedPattern[4] = WS2812B_WHITE;
au32LedPattern[5] = WS2812B_WHITE; //LED2
au32LedPattern[6] = WS2812B_WHITE;
au32LedPattern[7] = WS2812B_WHITE; //LED3
au32LedPattern[8] = WS2812B_WHITE;
au32LedPattern[9] = WS2812B_WHITE; //LED4
au32LedPattern[10] = WS2812B_WHITE;
au32LedPattern[11] = WS2812B_WHITE; //LED5
au32LedPattern[12] = WS2812B_WHITE;
au32LedPattern[13] = WS2812B_WHITE; //LED6
au32LedPattern[14] = WS2812B_WHITE;
au32LedPattern[15] = WS2812B_WHITE; //LED7
eColor = eCASE_GREEN_BLUE;
break;
}
/* Send LED pattern by PSIO */
PSIO_WS2812B_Send_Pattern(&sConfig);
/* Delay 50000 us */
CLK_SysTickDelay(500000);
} while (1);
PSIO_WS2812B_Close(&sConfig);
while (1);
}
/*** (C) COPYRIGHT 2019 Nuvoton Technology Corp. ***/
|
/*
* Copyright (c) 2011 Yeecco Limited
*/
#import <CoreFoundation/CFData.h>
#import "StellaGraphicsExport.h"
/* Compatibility */
#define CGDataProvider SGDataProvider
#define CGDataProviderRef SGDataProviderRef
#define CGDataProviderCopyData SGDataProviderCopyData
#define CGDataProviderCreateWithCFData SGDataProviderCreateWithCFData
#define CGDataProviderCreateWithData SGDataProviderCreateWithData
#define CGDataProviderRelease SGDataProviderRelease
#define CGDataProviderRetain SGDataProviderRetain
/* callbacks */
#define CGDataProviderReleaseDataCallback SGDataProviderReleaseDataCallback
/* Prototypes */
@class SGDataProvider;
typedef SGDataProvider * SGDataProviderRef;
typedef void (*SGDataProviderReleaseDataCallback)(void * info, const void * data, size_t size);
STELLA_GRAPHICS_EXPORT CFDataRef SGDataProviderCopyData (SGDataProviderRef self);
STELLA_GRAPHICS_EXPORT SGDataProviderRef SGDataProviderCreateWithCFData (CFDataRef data);
STELLA_GRAPHICS_EXPORT SGDataProviderRef SGDataProviderCreateWithData (void * info, const void * data, size_t size, SGDataProviderReleaseDataCallback releaseCallback);
STELLA_GRAPHICS_EXPORT void SGDataProviderRelease (SGDataProviderRef provider);
STELLA_GRAPHICS_EXPORT SGDataProviderRef SGDataProviderRetain (SGDataProviderRef provider);
|
//
// Generated by classdumpios 1.0.1 (64 bit) (iOS port by DreamDevLost)(Debug version compiled Sep 26 2020 13:48:20).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
#import <objc/NSObject.h>
@protocol OS_os_transaction;
@interface CRProcessTransaction : NSObject
{
NSObject<OS_os_transaction> *_transaction; // 8 = 0x8
}
+ (id)transactionWithDescription:(id)arg1; // IMP=0x0000000100010630
- (id)description; // IMP=0x0000000100010718
- (void)dealloc; // IMP=0x00000001000106d0
- (id)initWithDescription:(id)arg1; // IMP=0x000000010001066c
- (id)init; // IMP=0x0000000100010660
@end
|
#include "utils.h"
int is_whitespace(char c) {
return c == '\n' || c == '\r' || c == '\t' || c == ' ';
}
int is_namestartchar(char c) {
return isalpha(c) || c == ':' || c == '_';
}
int is_namechar(char c) {
return is_namestartchar(c) || isdigit(c) || c == '-' || c == '.';
}
|
/* Libvisual - The audio visualisation framework.
*
* Copyright (C) 2004, 2005, 2006 Dennis Smit <[email protected]>
*
* Authors: Dennis Smit <[email protected]>
* Duilio J. Protti <[email protected]>
* Chong Kai Xiong <[email protected]>
* Jean-Christophe Hoelt <[email protected]>
*
* $Id: lv_video.h,v 1.34.2.1 2006/03/04 12:32:48 descender Exp $
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1
* 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser 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
*/
#ifndef _LV_VIDEO_H
#define _LV_VIDEO_H
#include <libvisual/lv_common.h>
#include <libvisual/lv_palette.h>
#include <libvisual/lv_rectangle.h>
#include <libvisual/lv_buffer.h>
#include <libvisual/lv_gl.h>
VISUAL_BEGIN_DECLS
#define VISUAL_VIDEO(obj) (VISUAL_CHECK_CAST ((obj), VisVideo))
#define VISUAL_VIDEO_ATTRIBUTE_OPTIONS(obj) (VISUAL_CHECK_CAST ((obj), VisVideoAttributeOptions))
#define VISUAL_VIDEO_ATTRIBUTE_OPTIONS_GL_ENTRY(options, attr, val) \
options.gl_attributes[attr].attribute = attr; \
options.gl_attributes[attr].value = val; \
options.gl_attributes[attr].mutated = TRUE;
/* NOTE: The depth find helper code in lv_actor depends on an arrangment from low to high */
/**
* Enumerate that defines video depths for use within plugins, libvisual functions, etc.
*/
typedef enum {
VISUAL_VIDEO_DEPTH_NONE = 0, /**< No video surface flag. */
VISUAL_VIDEO_DEPTH_8BIT = 1, /**< 8 bits indexed surface flag. */
VISUAL_VIDEO_DEPTH_16BIT = 2, /**< 16 bits 5-6-5 surface flag. */
VISUAL_VIDEO_DEPTH_24BIT = 4, /**< 24 bits surface flag. */
VISUAL_VIDEO_DEPTH_32BIT = 8, /**< 32 bits surface flag. */
VISUAL_VIDEO_DEPTH_GL = 16, /**< openGL surface flag. */
VISUAL_VIDEO_DEPTH_ENDLIST = 32, /**< Used to mark the end of the depth list. */
VISUAL_VIDEO_DEPTH_ERROR = -1, /**< Used when there is an error. */
VISUAL_VIDEO_DEPTH_ALL = VISUAL_VIDEO_DEPTH_8BIT | \
VISUAL_VIDEO_DEPTH_16BIT | \
VISUAL_VIDEO_DEPTH_24BIT | \
VISUAL_VIDEO_DEPTH_32BIT | \
VISUAL_VIDEO_DEPTH_GL /**< All graphical depths. */
} VisVideoDepth;
/**
* Enumerate that defines video rotate types, used with the visual_video_rotate_*() functions.
*/
typedef enum {
VISUAL_VIDEO_ROTATE_NONE = 0, /**< No rotating. */
VISUAL_VIDEO_ROTATE_90 = 1, /**< 90 degrees rotate. */
VISUAL_VIDEO_ROTATE_180 = 2, /**< 180 degrees rotate. */
VISUAL_VIDEO_ROTATE_270 = 3 /**< 270 degrees rotate. */
} VisVideoRotateDegrees;
/**
* Enumerate that defines the video mirror types, used with the visual_video_mirror_*() functions.
*/
typedef enum {
VISUAL_VIDEO_MIRROR_NONE = 0, /**< No mirroring. */
VISUAL_VIDEO_MIRROR_X = 1, /**< Mirror on the X ax. */
VISUAL_VIDEO_MIRROR_Y = 2 /**< Mirror on the Y ax. */
} VisVideoMirrorOrient;
/**
* Enumerate that defines the different methods of scaling within VisVideo.
*/
typedef enum {
VISUAL_VIDEO_SCALE_NEAREST = 0, /**< Nearest neighbour. */
VISUAL_VIDEO_SCALE_BILINEAR = 1 /**< Bilinearly interpolated. */
} VisVideoScaleMethod;
/**
* Enumerate that defines the different blitting methods for a VisVideo.
*/
typedef enum {
VISUAL_VIDEO_COMPOSITE_TYPE_NONE = 0, /**< No composite set, use default. */
VISUAL_VIDEO_COMPOSITE_TYPE_SRC, /**< Source alpha channel. */
VISUAL_VIDEO_COMPOSITE_TYPE_COLORKEY, /**< Colorkey alpha. */
VISUAL_VIDEO_COMPOSITE_TYPE_SURFACE, /**< One alpha channel for the complete surface. */
VISUAL_VIDEO_COMPOSITE_TYPE_SURFACECOLORKEY, /**< Use surface alpha on colorkey. */
VISUAL_VIDEO_COMPOSITE_TYPE_CUSTOM /**< Custom composite function (looks up on the source VisVideo. */
} VisVideoCompositeType;
typedef struct _VisVideo VisVideo;
typedef struct _VisVideoAttributeOptions VisVideoAttributeOptions;
/* VisVideo custom composite method */
/**
* A custom composite function needs this signature. Custom composite functions can be
* used to overload the normal libvisual overlay functions, these are used by the different
* blit methods. The following template should be used for custom composite functions:
*
* int custom_composite (VisVideo *dest, VisVideo *src)
* {
* int i
* uint8_t *destbuf = dest->pixels;
* uint8_t *srcbuf = src->pixels;
*
* for (i = 0; i < src->height; i++) {
* for (j = 0; j < src->width; j++) {
*
*
* destbuf += dest->bpp;
* srcbuf += src->bpp;
* }
*
* destbuf += dest->pitch - (dest->width * dest->bpp);
* srcbuf += src->pitch - (src->width * src->bpp);
* }
* }
*
* It's very important that the function is pitch (rowstride, bytes per line) aware, also
* for width and height, it's compulsory to look at the source, and not the dest. Also be aware
* that the custom composite function is correct for the depth you're using, if you want to add
* depth awareness to the function, you could do this by checking dest->depth.
*
* @see visual_video_blit_overlay_rectangle_custom
* @see visual_video_blit_overlay_rectangle_scale_custom
* @see visual_video_blit_overlay_custom
*
* @arg dest a pointer to the dest visvideo source.
* @arg src A pointer to the source VisVideo source.
*
* @return VISUAL_OK on succes -VISUAL_ERROR_GENERAL on error.
*/
typedef int (*VisVideoCustomCompositeFunc)(VisVideo *dest, VisVideo *src);
/**
* Data structure that contains all the information about a screen surface.
* Contains all the information regarding a screen surface like the current depth it's in,
* width, height, bpp, the size in bytes it's pixel buffer is and the screen pitch.
*
* It also contains a pointer to the pixels and an optional pointer to the palette.
*
* Elements within the structure should be set using the VisVideo system it's methods.
*/
struct _VisVideo {
VisObject object; /**< The VisObject data. */
VisVideoDepth depth; /**< Surface it's depth. */
int width; /**< Surface it's width. */
int height; /**< Surface it's height. */
int bpp; /**< Surface it's bytes per pixel. */
int pitch; /**< Surface it's pitch value. Value contains
* the number of bytes per line. */
VisBuffer *buffer; /**< The video buffer. */
void **pixel_rows; /**< Pixel row start pointer table. */
VisPalette *pal; /**< Optional pointer to the palette. */
/* Sub region */
VisVideo *parent; /**< The surface it's parent, ONLY when it is a subregion. */
VisRectangle rect; /**< The rectangle over the parent surface. */
/* Composite control */
VisVideoCompositeType compositetype; /**< The surface it's composite type. */
VisVideoCustomCompositeFunc compfunc; /**< The surface it's custom composite function. */
VisColor colorkey; /**< The surface it's alpha colorkey. */
uint8_t density; /**< The surface it's global alpha density. */
};
struct _VisVideoAttributeOptions {
VisObject object;
int depth;
VisGLAttributeEntry gl_attributes[VISUAL_GL_ATTRIBUTE_LAST];
};
/* prototypes */
VisVideo *visual_video_new (void);
int visual_video_init (VisVideo *video);
VisVideo *visual_video_new_with_buffer (int width, int height, VisVideoDepth depth);
int visual_video_free_buffer (VisVideo *video);
int visual_video_allocate_buffer (VisVideo *video);
int visual_video_have_allocated_buffer (VisVideo *video);
int visual_video_clone (VisVideo *dest, VisVideo *src);
int visual_video_compare (VisVideo *src1, VisVideo *src2);
int visual_video_compare_ignore_pitch (VisVideo *src1, VisVideo *src2);
int visual_video_set_palette (VisVideo *video, VisPalette *pal);
int visual_video_set_buffer (VisVideo *video, void *buffer);
int visual_video_set_dimension (VisVideo *video, int width, int height);
int visual_video_set_pitch (VisVideo *video, int pitch);
int visual_video_set_depth (VisVideo *video, VisVideoDepth depth);
int visual_video_set_attributes (VisVideo *video, int width, int height, int pitch, VisVideoDepth depth);
int visual_video_get_size (VisVideo *video);
void *visual_video_get_pixels (VisVideo *video);
VisBuffer *visual_video_get_buffer (VisVideo *video);
int visual_video_depth_is_supported (int depthflag, VisVideoDepth depth);
VisVideoDepth visual_video_depth_get_next (int depthflag, VisVideoDepth depth);
VisVideoDepth visual_video_depth_get_prev (int depthflag, VisVideoDepth depth);
VisVideoDepth visual_video_depth_get_lowest (int depthflag);
VisVideoDepth visual_video_depth_get_highest (int depthflag);
VisVideoDepth visual_video_depth_get_highest_nogl (int depthflag);
int visual_video_depth_is_sane (VisVideoDepth depth);
int visual_video_depth_value_from_enum (VisVideoDepth depth);
VisVideoDepth visual_video_depth_enum_from_value (int depthvalue);
int visual_video_bpp_from_depth (VisVideoDepth depth);
int visual_video_get_boundary (VisVideo *video, VisRectangle *rect);
int visual_video_region_sub (VisVideo *dest, VisVideo *src, VisRectangle *rect);
int visual_video_region_sub_by_values (VisVideo *dest, VisVideo *src, int x, int y, int width, int height);
int visual_video_region_sub_all (VisVideo *dest, VisVideo *src);
int visual_video_region_sub_with_boundary (VisVideo *dest, VisRectangle *drect, VisVideo *src, VisRectangle *srect);
int visual_video_composite_set_type (VisVideo *video, VisVideoCompositeType type);
int visual_video_composite_set_colorkey (VisVideo *video, VisColor *color);
int visual_video_composite_set_surface (VisVideo *video, uint8_t alpha);
VisVideoCustomCompositeFunc visual_video_composite_get_function (VisVideo *dest, VisVideo *src, int alpha);
int visual_video_composite_set_function (VisVideo *video, VisVideoCustomCompositeFunc compfunc);
int visual_video_blit_overlay_rectangle (VisVideo *dest, VisRectangle *drect, VisVideo *src, VisRectangle *srect, int alpha);
int visual_video_blit_overlay_rectangle_custom (VisVideo *dest, VisRectangle *drect, VisVideo *src, VisRectangle *srect,
VisVideoCustomCompositeFunc compfunc);
int visual_video_blit_overlay_rectangle_scale (VisVideo *dest, VisRectangle *drect, VisVideo *src, VisRectangle *srect,
int alpha, VisVideoScaleMethod scale_method);
int visual_video_blit_overlay_rectangle_scale_custom (VisVideo *dest, VisRectangle *drect, VisVideo *src, VisRectangle *srect,
VisVideoScaleMethod scale_method, VisVideoCustomCompositeFunc compfunc);
int visual_video_blit_overlay (VisVideo *dest, VisVideo *src, int x, int y, int alpha);
int visual_video_blit_overlay_custom (VisVideo *dest, VisVideo *src, int x, int y, VisVideoCustomCompositeFunc compfunc);
int visual_video_fill_alpha_color (VisVideo *video, VisColor *color, uint8_t density);
int visual_video_fill_alpha (VisVideo *video, uint8_t density);
int visual_video_fill_alpha_rectangle (VisVideo *video, uint8_t density, VisRectangle *rect);
int visual_video_fill_color (VisVideo *video, VisColor *color);
int visual_video_fill_color_rectangle (VisVideo *video, VisColor *color, VisRectangle *rect);
int visual_video_color_bgr_to_rgb (VisVideo *dest, VisVideo *src);
int visual_video_rotate (VisVideo *dest, VisVideo *src, VisVideoRotateDegrees degrees);
VisVideo *visual_video_rotate_new (VisVideo *src, VisVideoRotateDegrees degrees);
int visual_video_mirror (VisVideo *dest, VisVideo *src, VisVideoMirrorOrient orient);
VisVideo *visual_video_mirror_new (VisVideo *src, VisVideoMirrorOrient orient);
int visual_video_depth_transform (VisVideo *viddest, VisVideo *vidsrc);
VisVideo *visual_video_zoom_new (VisVideo *src, VisVideoScaleMethod scale_method, float zoom_factor);
int visual_video_zoom_double (VisVideo *dest, VisVideo *src);
int visual_video_scale (VisVideo *dest, VisVideo *src, VisVideoScaleMethod scale_method);
VisVideo *visual_video_scale_new (VisVideo *src, int width, int height, VisVideoScaleMethod scale_method);
int visual_video_scale_depth (VisVideo *dest, VisVideo *src, VisVideoScaleMethod scale_method);
VisVideo *visual_video_scale_depth_new (VisVideo *src, int width, int height, VisVideoDepth depth,
VisVideoScaleMethod scale_method);
/* Optimized versions of performance sensitive routines */
/* mmx from lv_video_simd.c */ /* FIXME can we do this nicer ? */
int _lv_blit_overlay_alphasrc_mmx (VisVideo *dest, VisVideo *src);
int _lv_scale_bilinear_32_mmx (VisVideo *dest, VisVideo *src);
VISUAL_END_DECLS
#endif /* _LV_VIDEO_H */
|
//
// rvmSnowView.h
// Retro Virtual Machine
//
// Created by Juan Carlos González Amestoy on 22/4/15.
// Copyright (c) 2015 Juan Carlos González Amestoy. All rights reserved.
//
#import <Cocoa/Cocoa.h>
IB_DESIGNABLE
@interface rvmShaderView : NSView
@property IBInspectable NSString* programName;
@end
|
#import <UIKit/UIKit.h>
#import <Foundation/Foundation.h>
#import <CoreText/CoreText.h>
#import "NSImageRoundCornerTransformer.h"
#import "NSImageDecodeSizeTransformer.h"
|
/* net/atm/common.c - ATM sockets (common part for PVC and SVC) */
/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/net.h> /* struct socket, struct net_proto, struct
proto_ops */
#include <linux/atm.h> /* ATM stuff */
#include <linux/atmdev.h>
#include <linux/atmclip.h> /* CLIP_*ENCAP */
#include <linux/atmarp.h> /* manifest constants */
#include <linux/sonet.h> /* for ioctls */
#include <linux/socket.h> /* SOL_SOCKET */
#include <linux/errno.h> /* error codes */
#include <linux/capability.h>
#include <linux/mm.h> /* verify_area */
#include <linux/sched.h>
#include <linux/time.h> /* struct timeval */
#include <linux/skbuff.h>
#include <linux/bitops.h>
#include <linux/init.h>
#include <net/sock.h> /* struct sock */
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <asm/poll.h>
#include <asm/ioctls.h>
#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
#include <linux/atmlec.h>
#include "lec.h"
#include "lec_arpc.h"
struct atm_lane_ops *atm_lane_ops;
static DECLARE_MUTEX(atm_lane_ops_mutex);
void atm_lane_ops_set(struct atm_lane_ops *hook)
{
down(&atm_lane_ops_mutex);
atm_lane_ops = hook;
up(&atm_lane_ops_mutex);
}
int try_atm_lane_ops(void)
{
down(&atm_lane_ops_mutex);
if (atm_lane_ops && try_inc_mod_count(atm_lane_ops->owner)) {
up(&atm_lane_ops_mutex);
return 1;
}
up(&atm_lane_ops_mutex);
return 0;
}
#if defined(CONFIG_ATM_LANE_MODULE) || defined(CONFIG_ATM_MPOA_MODULE)
EXPORT_SYMBOL(atm_lane_ops);
EXPORT_SYMBOL(try_atm_lane_ops);
EXPORT_SYMBOL(atm_lane_ops_set);
#endif
#endif
#if defined(CONFIG_ATM_MPOA) || defined(CONFIG_ATM_MPOA_MODULE)
#include <linux/atmmpc.h>
#include "mpc.h"
struct atm_mpoa_ops *atm_mpoa_ops;
static DECLARE_MUTEX(atm_mpoa_ops_mutex);
void atm_mpoa_ops_set(struct atm_mpoa_ops *hook)
{
down(&atm_mpoa_ops_mutex);
atm_mpoa_ops = hook;
up(&atm_mpoa_ops_mutex);
}
int try_atm_mpoa_ops(void)
{
down(&atm_mpoa_ops_mutex);
if (atm_mpoa_ops && try_inc_mod_count(atm_mpoa_ops->owner)) {
up(&atm_mpoa_ops_mutex);
return 1;
}
up(&atm_mpoa_ops_mutex);
return 0;
}
#ifdef CONFIG_ATM_MPOA_MODULE
EXPORT_SYMBOL(atm_mpoa_ops);
EXPORT_SYMBOL(try_atm_mpoa_ops);
EXPORT_SYMBOL(atm_mpoa_ops_set);
#endif
#endif
#if defined(CONFIG_ATM_TCP) || defined(CONFIG_ATM_TCP_MODULE)
#include <linux/atm_tcp.h>
#ifdef CONFIG_ATM_TCP_MODULE
struct atm_tcp_ops atm_tcp_ops;
EXPORT_SYMBOL(atm_tcp_ops);
#endif
#endif
#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
#include <net/atmclip.h>
struct atm_clip_ops *atm_clip_ops;
static DECLARE_MUTEX(atm_clip_ops_mutex);
void atm_clip_ops_set(struct atm_clip_ops *hook)
{
down(&atm_clip_ops_mutex);
atm_clip_ops = hook;
up(&atm_clip_ops_mutex);
}
int try_atm_clip_ops(void)
{
down(&atm_clip_ops_mutex);
if (atm_clip_ops && try_inc_mod_count(atm_clip_ops->owner)) {
up(&atm_clip_ops_mutex);
return 1;
}
up(&atm_clip_ops_mutex);
return 0;
}
#ifdef CONFIG_ATM_CLIP_MODULE
EXPORT_SYMBOL(atm_clip_ops);
EXPORT_SYMBOL(try_atm_clip_ops);
EXPORT_SYMBOL(atm_clip_ops_set);
#endif
#endif
#if defined(CONFIG_PPPOATM) || defined(CONFIG_PPPOATM_MODULE)
static DECLARE_MUTEX(pppoatm_ioctl_mutex);
static int (*pppoatm_ioctl_hook)(struct atm_vcc *, unsigned int, unsigned long);
void pppoatm_ioctl_set(int (*hook)(struct atm_vcc *, unsigned int, unsigned long))
{
down(&pppoatm_ioctl_mutex);
pppoatm_ioctl_hook = hook;
up(&pppoatm_ioctl_mutex);
}
#ifdef CONFIG_PPPOATM_MODULE
EXPORT_SYMBOL(pppoatm_ioctl_set);
#endif
#endif
#if defined(CONFIG_ATM_BR2684) || defined(CONFIG_ATM_BR2684_MODULE)
static DECLARE_MUTEX(br2684_ioctl_mutex);
static int (*br2684_ioctl_hook)(struct atm_vcc *, unsigned int, unsigned long);
void br2684_ioctl_set(int (*hook)(struct atm_vcc *, unsigned int, unsigned long))
{
down(&br2684_ioctl_mutex);
br2684_ioctl_hook = hook;
up(&br2684_ioctl_mutex);
}
#ifdef CONFIG_ATM_BR2684_MODULE
EXPORT_SYMBOL(br2684_ioctl_set);
EXPORT_SYMBOL(br2684_ioctl_hook);
#endif
#endif
#include "resources.h" /* atm_find_dev */
#include "common.h" /* prototypes */
#include "protocols.h" /* atm_init_<transport> */
#include "addr.h" /* address registry */
#ifdef CONFIG_ATM_CLIP
#include <net/atmclip.h> /* for clip_create */
#endif
#include "signaling.h" /* for WAITING and sigd_attach */
#if 0
#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
#else
#define DPRINTK(format,args...)
#endif
struct sock *vcc_sklist;
rwlock_t vcc_sklist_lock = RW_LOCK_UNLOCKED;
void __vcc_insert_socket(struct sock *sk)
{
sk->next = vcc_sklist;
if (sk->next)
vcc_sklist->pprev = &sk->next;
vcc_sklist = sk;
sk->pprev = &vcc_sklist;
}
void vcc_insert_socket(struct sock *sk)
{
write_lock_irq(&vcc_sklist_lock);
__vcc_insert_socket(sk);
write_unlock_irq(&vcc_sklist_lock);
}
void vcc_remove_socket(struct sock *sk)
{
write_lock_irq(&vcc_sklist_lock);
if (sk->pprev) {
if (sk->next)
sk->next->pprev = sk->pprev;
*sk->pprev = sk->next;
sk->pprev = NULL;
}
write_unlock_irq(&vcc_sklist_lock);
}
static struct sk_buff *alloc_tx(struct atm_vcc *vcc,unsigned int size)
{
struct sk_buff *skb;
if (atomic_read(&vcc->sk->wmem_alloc) && !atm_may_send(vcc,size)) {
DPRINTK("Sorry: wmem_alloc = %d, size = %d, sndbuf = %d\n",
atomic_read(&vcc->sk->wmem_alloc),size,vcc->sk->sndbuf);
return NULL;
}
while (!(skb = alloc_skb(size,GFP_KERNEL))) schedule();
DPRINTK("AlTx %d += %d\n",atomic_read(&vcc->sk->wmem_alloc),skb->truesize);
atomic_add(skb->truesize, &vcc->sk->wmem_alloc);
return skb;
}
EXPORT_SYMBOL(vcc_sklist);
EXPORT_SYMBOL(vcc_sklist_lock);
EXPORT_SYMBOL(vcc_insert_socket);
EXPORT_SYMBOL(vcc_remove_socket);
static void vcc_sock_destruct(struct sock *sk)
{
struct atm_vcc *vcc = sk->protinfo.af_atm;
if (atomic_read(&vcc->sk->rmem_alloc))
printk(KERN_DEBUG "vcc_sock_destruct: rmem leakage (%d bytes) detected.\n", atomic_read(&sk->rmem_alloc));
if (atomic_read(&vcc->sk->wmem_alloc))
printk(KERN_DEBUG "vcc_sock_destruct: wmem leakage (%d bytes) detected.\n", atomic_read(&sk->wmem_alloc));
kfree(sk->protinfo.af_atm);
MOD_DEC_USE_COUNT;
}
int vcc_create(struct socket *sock, int protocol, int family)
{
struct sock *sk;
struct atm_vcc *vcc;
sock->sk = NULL;
if (sock->type == SOCK_STREAM)
return -EINVAL;
sk = sk_alloc(family, GFP_KERNEL, 1);
if (!sk)
return -ENOMEM;
sock_init_data(NULL, sk);
vcc = sk->protinfo.af_atm = kmalloc(sizeof(*vcc), GFP_KERNEL);
if (!vcc) {
sk_free(sk);
return -ENOMEM;
}
memset(vcc, 0, sizeof(*vcc));
vcc->sk = sk;
vcc->dev = NULL;
vcc->callback = NULL;
memset(&vcc->local,0,sizeof(struct sockaddr_atmsvc));
memset(&vcc->remote,0,sizeof(struct sockaddr_atmsvc));
vcc->qos.txtp.max_sdu = 1 << 16; /* for meta VCs */
atomic_set(&vcc->sk->wmem_alloc,0);
atomic_set(&vcc->sk->rmem_alloc,0);
vcc->push = NULL;
vcc->pop = NULL;
vcc->push_oam = NULL;
vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */
vcc->atm_options = vcc->aal_options = 0;
init_waitqueue_head(&vcc->sleep);
sk->sleep = &vcc->sleep;
sk->destruct = vcc_sock_destruct;
sock->sk = sk;
MOD_INC_USE_COUNT;
return 0;
}
static void vcc_destroy_socket(struct sock *sk)
{
struct atm_vcc *vcc;
struct sk_buff *skb;
vcc = sk->protinfo.af_atm;
clear_bit(ATM_VF_READY, &vcc->flags);
if (vcc->dev) {
if (vcc->dev->ops->close)
vcc->dev->ops->close(vcc);
if (vcc->push)
vcc->push(vcc, NULL); /* atmarpd has no push */
vcc_remove_socket(sk); /* no more receive */
while ((skb = skb_dequeue(&vcc->sk->receive_queue))) {
atm_return(vcc,skb->truesize);
kfree_skb(skb);
}
if (vcc->dev->ops->owner)
__MOD_DEC_USE_COUNT(vcc->dev->ops->owner);
atm_dev_put(vcc->dev);
}
}
int vcc_release(struct socket *sock)
{
struct sock *sk = sock->sk;
if (sk) {
lock_sock(sk);
vcc_destroy_socket(sock->sk);
release_sock(sk);
sock_put(sk);
}
return 0;
}
void vcc_release_async(struct atm_vcc *vcc, int reply)
{
set_bit(ATM_VF_CLOSE, &vcc->flags);
vcc->reply = reply;
vcc->sk->err = -reply;
wake_up(&vcc->sleep);
}
EXPORT_SYMBOL(vcc_release_async);
static int adjust_tp(struct atm_trafprm *tp,unsigned char aal)
{
int max_sdu;
if (!tp->traffic_class) return 0;
switch (aal) {
case ATM_AAL0:
max_sdu = ATM_CELL_SIZE-1;
break;
case ATM_AAL34:
max_sdu = ATM_MAX_AAL34_PDU;
break;
default:
printk(KERN_WARNING "ATM: AAL problems ... "
"(%d)\n",aal);
/* fall through */
case ATM_AAL5:
max_sdu = ATM_MAX_AAL5_PDU;
}
if (!tp->max_sdu) tp->max_sdu = max_sdu;
else if (tp->max_sdu > max_sdu) return -EINVAL;
if (!tp->max_cdv) tp->max_cdv = ATM_MAX_CDV;
return 0;
}
static int __vcc_connect(struct atm_vcc *vcc, struct atm_dev *dev, int vpi,
int vci)
{
int error;
if ((vpi != ATM_VPI_UNSPEC && vpi != ATM_VPI_ANY &&
vpi >> dev->ci_range.vpi_bits) || (vci != ATM_VCI_UNSPEC &&
vci != ATM_VCI_ANY && vci >> dev->ci_range.vci_bits))
return -EINVAL;
if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE))
return -EPERM;
error = 0;
if (!try_inc_mod_count(dev->ops->owner))
return -ENODEV;
vcc->dev = dev;
vcc_insert_socket(vcc->sk);
switch (vcc->qos.aal) {
case ATM_AAL0:
error = atm_init_aal0(vcc);
vcc->stats = &dev->stats.aal0;
break;
case ATM_AAL34:
error = atm_init_aal34(vcc);
vcc->stats = &dev->stats.aal34;
break;
case ATM_NO_AAL:
/* ATM_AAL5 is also used in the "0 for default" case */
vcc->qos.aal = ATM_AAL5;
/* fall through */
case ATM_AAL5:
error = atm_init_aal5(vcc);
vcc->stats = &dev->stats.aal5;
break;
default:
error = -EPROTOTYPE;
}
if (!error) error = adjust_tp(&vcc->qos.txtp,vcc->qos.aal);
if (!error) error = adjust_tp(&vcc->qos.rxtp,vcc->qos.aal);
if (error)
goto fail;
DPRINTK("VCC %d.%d, AAL %d\n",vpi,vci,vcc->qos.aal);
DPRINTK(" TX: %d, PCR %d..%d, SDU %d\n",vcc->qos.txtp.traffic_class,
vcc->qos.txtp.min_pcr,vcc->qos.txtp.max_pcr,vcc->qos.txtp.max_sdu);
DPRINTK(" RX: %d, PCR %d..%d, SDU %d\n",vcc->qos.rxtp.traffic_class,
vcc->qos.rxtp.min_pcr,vcc->qos.rxtp.max_pcr,vcc->qos.rxtp.max_sdu);
if (dev->ops->open) {
if ((error = dev->ops->open(vcc,vpi,vci)))
goto fail;
}
return 0;
fail:
vcc_remove_socket(vcc->sk);
if (dev->ops->owner)
__MOD_DEC_USE_COUNT(dev->ops->owner);
/* ensure we get dev module ref count correct */
vcc->dev = NULL;
return error;
}
int vcc_connect(struct socket *sock, int itf, short vpi, int vci)
{
struct atm_dev *dev;
struct atm_vcc *vcc = ATM_SD(sock);
int error;
DPRINTK("vcc_connect (vpi %d, vci %d)\n",vpi,vci);
if (sock->state == SS_CONNECTED)
return -EISCONN;
if (sock->state != SS_UNCONNECTED)
return -EINVAL;
if (!(vpi || vci))
return -EINVAL;
if (vpi != ATM_VPI_UNSPEC && vci != ATM_VCI_UNSPEC)
clear_bit(ATM_VF_PARTIAL,&vcc->flags);
else
if (test_bit(ATM_VF_PARTIAL,&vcc->flags))
return -EINVAL;
DPRINTK("vcc_connect (TX: cl %d,bw %d-%d,sdu %d; "
"RX: cl %d,bw %d-%d,sdu %d,AAL %s%d)\n",
vcc->qos.txtp.traffic_class,vcc->qos.txtp.min_pcr,
vcc->qos.txtp.max_pcr,vcc->qos.txtp.max_sdu,
vcc->qos.rxtp.traffic_class,vcc->qos.rxtp.min_pcr,
vcc->qos.rxtp.max_pcr,vcc->qos.rxtp.max_sdu,
vcc->qos.aal == ATM_AAL5 ? "" : vcc->qos.aal == ATM_AAL0 ? "" :
" ??? code ",vcc->qos.aal == ATM_AAL0 ? 0 : vcc->qos.aal);
if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
return -EBADFD;
if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
return -EINVAL;
if (itf != ATM_ITF_ANY) {
dev = atm_dev_lookup(itf);
if (!dev)
return -ENODEV;
error = __vcc_connect(vcc, dev, vpi, vci);
if (error) {
atm_dev_put(dev);
return error;
}
} else {
struct list_head *p, *next;
dev = NULL;
spin_lock(&atm_dev_lock);
list_for_each_safe(p, next, &atm_devs) {
dev = list_entry(p, struct atm_dev, dev_list);
atm_dev_hold(dev);
spin_unlock(&atm_dev_lock);
if (!__vcc_connect(vcc, dev, vpi, vci))
break;
atm_dev_put(dev);
dev = NULL;
spin_lock(&atm_dev_lock);
}
spin_unlock(&atm_dev_lock);
if (!dev)
return -ENODEV;
}
if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC)
set_bit(ATM_VF_PARTIAL,&vcc->flags);
if (test_bit(ATM_VF_READY,&ATM_SD(sock)->flags))
sock->state = SS_CONNECTED;
return 0;
}
int vcc_recvmsg(struct socket *sock, struct msghdr *msg,
int size, int flags, struct scm_cookie *scm)
{
struct sock *sk = sock->sk;
struct atm_vcc *vcc;
struct sk_buff *skb;
int copied, error = -EINVAL;
if (sock->state != SS_CONNECTED)
return -ENOTCONN;
if (flags & ~MSG_DONTWAIT) /* only handle MSG_DONTWAIT */
return -EOPNOTSUPP;
vcc = ATM_SD(sock);
if (test_bit(ATM_VF_RELEASED,&vcc->flags) ||
test_bit(ATM_VF_CLOSE, &vcc->flags) ||
!test_bit(ATM_VF_READY, &vcc->flags))
return 0;
skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &error);
if (!skb)
return error;
copied = skb->len;
if (copied > size) {
copied = size;
msg->msg_flags |= MSG_TRUNC;
}
error = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
if (error)
return error;
sock_recv_timestamp(msg, sk, skb);
if (vcc->dev->ops->feedback)
vcc->dev->ops->feedback(vcc, skb, (unsigned long) skb->data,
(unsigned long) msg->msg_iov->iov_base, copied);
DPRINTK("RcvM %d -= %d\n", atomic_read(&vcc->sk->rmem_alloc), skb->truesize);
atm_return(vcc, skb->truesize);
skb_free_datagram(sk, skb);
return copied;
}
int vcc_sendmsg(struct socket *sock, struct msghdr *m, int total_len,
struct scm_cookie *scm)
{
struct sock *sk = sock->sk;
DECLARE_WAITQUEUE(wait,current);
struct atm_vcc *vcc;
struct sk_buff *skb;
int eff,error;
const void *buff;
int size;
lock_sock(sk);
if (sock->state != SS_CONNECTED) {
error = -ENOTCONN;
goto out;
}
if (m->msg_name) {
error = -EISCONN;
goto out;
}
if (m->msg_iovlen != 1) {
error = -ENOSYS; /* fix this later @@@ */
goto out;
}
buff = m->msg_iov->iov_base;
size = m->msg_iov->iov_len;
vcc = ATM_SD(sock);
if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
test_bit(ATM_VF_CLOSE, &vcc->flags) ||
!test_bit(ATM_VF_READY, &vcc->flags)) {
error = -EPIPE;
send_sig(SIGPIPE, current, 0);
goto out;
}
if (!size) {
error = 0;
goto out;
}
if (size < 0 || size > vcc->qos.txtp.max_sdu) {
error = -EMSGSIZE;
goto out;
}
/* verify_area is done by net/socket.c */
eff = (size+3) & ~3; /* align to word boundary */
add_wait_queue(&vcc->sleep,&wait);
set_current_state(TASK_INTERRUPTIBLE);
error = 0;
while (!(skb = alloc_tx(vcc,eff))) {
if (m->msg_flags & MSG_DONTWAIT) {
error = -EAGAIN;
break;
}
schedule();
set_current_state(TASK_INTERRUPTIBLE);
if (signal_pending(current)) {
error = -ERESTARTSYS;
break;
}
if (test_bit(ATM_VF_RELEASED,&vcc->flags) ||
test_bit(ATM_VF_CLOSE, &vcc->flags) ||
!test_bit(ATM_VF_READY, &vcc->flags)) {
error = -EPIPE;
send_sig(SIGPIPE, current, 0);
break;
}
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&vcc->sleep,&wait);
if (error)
goto out;
skb->dev = NULL; /* for paths shared with net_device interfaces */
ATM_SKB(skb)->atm_options = vcc->atm_options;
if (copy_from_user(skb_put(skb,size),buff,size)) {
kfree_skb(skb);
error = -EFAULT;
goto out;
}
if (eff != size) memset(skb->data+size,0,eff-size);
error = vcc->dev->ops->send(vcc,skb);
error = error ? error : size;
out:
release_sock(sk);
return error;
}
unsigned int atm_poll(struct file *file,struct socket *sock,poll_table *wait)
{
struct atm_vcc *vcc;
unsigned int mask;
vcc = ATM_SD(sock);
poll_wait(file,&vcc->sleep,wait);
mask = 0;
if (skb_peek(&vcc->sk->receive_queue))
mask |= POLLIN | POLLRDNORM;
if (test_bit(ATM_VF_RELEASED,&vcc->flags) ||
test_bit(ATM_VF_CLOSE,&vcc->flags))
mask |= POLLHUP;
if (sock->state != SS_CONNECTING) {
if (vcc->qos.txtp.traffic_class != ATM_NONE &&
vcc->qos.txtp.max_sdu+atomic_read(&vcc->sk->wmem_alloc) <= vcc->sk->sndbuf)
mask |= POLLOUT | POLLWRNORM;
}
else if (vcc->reply != WAITING) {
mask |= POLLOUT | POLLWRNORM;
if (vcc->reply) mask |= POLLERR;
}
return mask;
}
int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
struct atm_vcc *vcc;
int error;
vcc = ATM_SD(sock);
switch (cmd) {
case SIOCOUTQ:
if (sock->state != SS_CONNECTED ||
!test_bit(ATM_VF_READY, &vcc->flags)) {
error = -EINVAL;
goto done;
}
error = put_user(vcc->sk->sndbuf-
atomic_read(&vcc->sk->wmem_alloc),
(int *) arg) ? -EFAULT : 0;
goto done;
case SIOCINQ:
{
struct sk_buff *skb;
if (sock->state != SS_CONNECTED) {
error = -EINVAL;
goto done;
}
skb = skb_peek(&vcc->sk->receive_queue);
error = put_user(skb ? skb->len : 0,
(int *) arg) ? -EFAULT : 0;
goto done;
}
case SIOCGSTAMP: /* borrowed from IP */
if (!vcc->sk->stamp.tv_sec) {
error = -ENOENT;
goto done;
}
error = copy_to_user((void *) arg, &vcc->sk->stamp,
sizeof(struct timeval)) ? -EFAULT : 0;
goto done;
case ATM_SETSC:
printk(KERN_WARNING "ATM_SETSC is obsolete\n");
error = 0;
goto done;
case ATMSIGD_CTRL:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
/*
* The user/kernel protocol for exchanging signalling
* info uses kernel pointers as opaque references,
* so the holder of the file descriptor can scribble
* on the kernel... so we should make sure that we
* have the same privledges that /proc/kcore needs
*/
if (!capable(CAP_SYS_RAWIO)) {
error = -EPERM;
goto done;
}
error = sigd_attach(vcc);
if (!error)
sock->state = SS_CONNECTED;
goto done;
#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
case SIOCMKCLIP:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (try_atm_clip_ops()) {
error = atm_clip_ops->clip_create(arg);
if (atm_clip_ops->owner)
__MOD_DEC_USE_COUNT(atm_clip_ops->owner);
} else
error = -ENOSYS;
goto done;
case ATMARPD_CTRL:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
#if defined(CONFIG_ATM_CLIP_MODULE)
if (!atm_clip_ops)
request_module("clip");
#endif
if (try_atm_clip_ops()) {
error = atm_clip_ops->atm_init_atmarp(vcc);
if (atm_clip_ops->owner)
__MOD_DEC_USE_COUNT(atm_clip_ops->owner);
if (!error)
sock->state = SS_CONNECTED;
} else
error = -ENOSYS;
goto done;
case ATMARP_MKIP:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (try_atm_clip_ops()) {
error = atm_clip_ops->clip_mkip(vcc, arg);
if (atm_clip_ops->owner)
__MOD_DEC_USE_COUNT(atm_clip_ops->owner);
} else
error = -ENOSYS;
goto done;
case ATMARP_SETENTRY:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (try_atm_clip_ops()) {
error = atm_clip_ops->clip_setentry(vcc, arg);
if (atm_clip_ops->owner)
__MOD_DEC_USE_COUNT(atm_clip_ops->owner);
} else
error = -ENOSYS;
goto done;
case ATMARP_ENCAP:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (try_atm_clip_ops()) {
error = atm_clip_ops->clip_encap(vcc, arg);
if (atm_clip_ops->owner)
__MOD_DEC_USE_COUNT(atm_clip_ops->owner);
} else
error = -ENOSYS;
goto done;
#endif
#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
case ATMLEC_CTRL:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
#if defined(CONFIG_ATM_LANE_MODULE)
if (!atm_lane_ops)
request_module("lec");
#endif
if (try_atm_lane_ops()) {
error = atm_lane_ops->lecd_attach(vcc, (int) arg);
if (atm_lane_ops->owner)
__MOD_DEC_USE_COUNT(atm_lane_ops->owner);
if (error >= 0)
sock->state = SS_CONNECTED;
} else
error = -ENOSYS;
goto done;
case ATMLEC_MCAST:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (try_atm_lane_ops()) {
error = atm_lane_ops->mcast_attach(vcc, (int) arg);
if (atm_lane_ops->owner)
__MOD_DEC_USE_COUNT(atm_lane_ops->owner);
} else
error = -ENOSYS;
goto done;
case ATMLEC_DATA:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (try_atm_lane_ops()) {
error = atm_lane_ops->vcc_attach(vcc, (void *) arg);
if (atm_lane_ops->owner)
__MOD_DEC_USE_COUNT(atm_lane_ops->owner);
} else
error = -ENOSYS;
goto done;
#endif
#if defined(CONFIG_ATM_MPOA) || defined(CONFIG_ATM_MPOA_MODULE)
case ATMMPC_CTRL:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
#if defined(CONFIG_ATM_MPOA_MODULE)
if (!atm_mpoa_ops)
request_module("mpoa");
#endif
if (try_atm_mpoa_ops()) {
error = atm_mpoa_ops->mpoad_attach(vcc, (int) arg);
if (atm_mpoa_ops->owner)
__MOD_DEC_USE_COUNT(atm_mpoa_ops->owner);
if (error >= 0)
sock->state = SS_CONNECTED;
} else
error = -ENOSYS;
goto done;
case ATMMPC_DATA:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (try_atm_mpoa_ops()) {
error = atm_mpoa_ops->vcc_attach(vcc, arg);
if (atm_mpoa_ops->owner)
__MOD_DEC_USE_COUNT(atm_mpoa_ops->owner);
} else
error = -ENOSYS;
goto done;
#endif
#if defined(CONFIG_ATM_TCP) || defined(CONFIG_ATM_TCP_MODULE)
case SIOCSIFATMTCP:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (!atm_tcp_ops.attach) {
error = -ENOPKG;
goto done;
}
fops_get(&atm_tcp_ops);
error = atm_tcp_ops.attach(vcc, (int) arg);
if (error >= 0)
sock->state = SS_CONNECTED;
else
fops_put(&atm_tcp_ops);
goto done;
case ATMTCP_CREATE:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (!atm_tcp_ops.create_persistent) {
error = -ENOPKG;
goto done;
}
error = atm_tcp_ops.create_persistent((int) arg);
if (error < 0)
fops_put(&atm_tcp_ops);
goto done;
case ATMTCP_REMOVE:
if (!capable(CAP_NET_ADMIN)) {
error = -EPERM;
goto done;
}
if (!atm_tcp_ops.remove_persistent) {
error = -ENOPKG;
goto done;
}
error = atm_tcp_ops.remove_persistent((int) arg);
fops_put(&atm_tcp_ops);
goto done;
#endif
default:
break;
}
error = -ENOIOCTLCMD;
#if defined(CONFIG_PPPOATM) || defined(CONFIG_PPPOATM_MODULE)
down(&pppoatm_ioctl_mutex);
if (pppoatm_ioctl_hook)
error = pppoatm_ioctl_hook(vcc, cmd, arg);
up(&pppoatm_ioctl_mutex);
if (error != -ENOIOCTLCMD)
goto done;
#endif
#if defined(CONFIG_ATM_BR2684) || defined(CONFIG_ATM_BR2684_MODULE)
down(&br2684_ioctl_mutex);
if (br2684_ioctl_hook)
error = br2684_ioctl_hook(vcc, cmd, arg);
up(&br2684_ioctl_mutex);
if (error != -ENOIOCTLCMD)
goto done;
#endif
error = atm_dev_ioctl(cmd, arg);
done:
return error;
}
static int atm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos)
{
int error;
/*
* Don't let the QoS change the already connected AAL type nor the
* traffic class.
*/
if (qos->aal != vcc->qos.aal ||
qos->rxtp.traffic_class != vcc->qos.rxtp.traffic_class ||
qos->txtp.traffic_class != vcc->qos.txtp.traffic_class)
return -EINVAL;
error = adjust_tp(&qos->txtp,qos->aal);
if (!error) error = adjust_tp(&qos->rxtp,qos->aal);
if (error) return error;
if (!vcc->dev->ops->change_qos) return -EOPNOTSUPP;
if (vcc->sk->family == AF_ATMPVC)
return vcc->dev->ops->change_qos(vcc,qos,ATM_MF_SET);
return svc_change_qos(vcc,qos);
}
static int check_tp(struct atm_trafprm *tp)
{
/* @@@ Should be merged with adjust_tp */
if (!tp->traffic_class || tp->traffic_class == ATM_ANYCLASS) return 0;
if (tp->traffic_class != ATM_UBR && !tp->min_pcr && !tp->pcr &&
!tp->max_pcr) return -EINVAL;
if (tp->min_pcr == ATM_MAX_PCR) return -EINVAL;
if (tp->min_pcr && tp->max_pcr && tp->max_pcr != ATM_MAX_PCR &&
tp->min_pcr > tp->max_pcr) return -EINVAL;
/*
* We allow pcr to be outside [min_pcr,max_pcr], because later
* adjustment may still push it in the valid range.
*/
return 0;
}
static int check_qos(struct atm_qos *qos)
{
int error;
if (!qos->txtp.traffic_class && !qos->rxtp.traffic_class)
return -EINVAL;
if (qos->txtp.traffic_class != qos->rxtp.traffic_class &&
qos->txtp.traffic_class && qos->rxtp.traffic_class &&
qos->txtp.traffic_class != ATM_ANYCLASS &&
qos->rxtp.traffic_class != ATM_ANYCLASS) return -EINVAL;
error = check_tp(&qos->txtp);
if (error) return error;
return check_tp(&qos->rxtp);
}
int vcc_setsockopt(struct socket *sock, int level, int optname,
char *optval, int optlen)
{
struct atm_vcc *vcc;
unsigned long value;
int error;
if (__SO_LEVEL_MATCH(optname, level) && optlen != __SO_SIZE(optname))
return -EINVAL;
vcc = ATM_SD(sock);
switch (optname) {
case SO_ATMQOS:
{
struct atm_qos qos;
if (copy_from_user(&qos,optval,sizeof(qos)))
return -EFAULT;
error = check_qos(&qos);
if (error) return error;
if (sock->state == SS_CONNECTED)
return atm_change_qos(vcc,&qos);
if (sock->state != SS_UNCONNECTED)
return -EBADFD;
vcc->qos = qos;
set_bit(ATM_VF_HASQOS,&vcc->flags);
return 0;
}
case SO_SETCLP:
if (get_user(value,(unsigned long *) optval))
return -EFAULT;
if (value) vcc->atm_options |= ATM_ATMOPT_CLP;
else vcc->atm_options &= ~ATM_ATMOPT_CLP;
return 0;
default:
if (level == SOL_SOCKET) return -EINVAL;
break;
}
if (!vcc->dev || !vcc->dev->ops->setsockopt) return -EINVAL;
return vcc->dev->ops->setsockopt(vcc,level,optname,optval,optlen);
}
int vcc_getsockopt(struct socket *sock, int level, int optname,
char *optval, int *optlen)
{
struct atm_vcc *vcc;
int len;
if (get_user(len, optlen))
return -EFAULT;
if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname))
return -EINVAL;
vcc = ATM_SD(sock);
switch (optname) {
case SO_ATMQOS:
if (!test_bit(ATM_VF_HASQOS,&vcc->flags))
return -EINVAL;
return copy_to_user(optval,&vcc->qos,sizeof(vcc->qos)) ?
-EFAULT : 0;
case SO_SETCLP:
return put_user(vcc->atm_options & ATM_ATMOPT_CLP ? 1 :
0,(unsigned long *) optval) ? -EFAULT : 0;
case SO_ATMPVC:
{
struct sockaddr_atmpvc pvc;
if (!vcc->dev ||
!test_bit(ATM_VF_ADDR,&vcc->flags))
return -ENOTCONN;
pvc.sap_family = AF_ATMPVC;
pvc.sap_addr.itf = vcc->dev->number;
pvc.sap_addr.vpi = vcc->vpi;
pvc.sap_addr.vci = vcc->vci;
return copy_to_user(optval,&pvc,sizeof(pvc)) ?
-EFAULT : 0;
}
default:
if (level == SOL_SOCKET) return -EINVAL;
break;
}
if (!vcc->dev || !vcc->dev->ops->getsockopt) return -EINVAL;
return vcc->dev->ops->getsockopt(vcc, level, optname, optval, len);
}
#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
unsigned char *addr) = NULL;
void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) = NULL;
#if defined(CONFIG_ATM_LANE_MODULE) || defined(CONFIG_BRIDGE_MODULE)
EXPORT_SYMBOL(br_fdb_get_hook);
EXPORT_SYMBOL(br_fdb_put_hook);
#endif /* defined(CONFIG_ATM_LANE_MODULE) || defined(CONFIG_BRIDGE_MODULE) */
#endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
#endif /* defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE) */
static int __init atm_init(void)
{
int error;
if ((error = atmpvc_init()) < 0) {
printk(KERN_ERR "atmpvc_init() failed with %d\n", error);
goto failure;
}
if ((error = atmsvc_init()) < 0) {
printk(KERN_ERR "atmsvc_init() failed with %d\n", error);
goto failure;
}
#ifdef CONFIG_PROC_FS
if ((error = atm_proc_init()) < 0) {
printk(KERN_ERR "atm_proc_init() failed with %d\n",error);
goto failure;
}
#endif
return 0;
failure:
atmsvc_exit();
atmpvc_exit();
return error;
}
static void __exit atm_exit(void)
{
#ifdef CONFIG_PROC_FS
atm_proc_exit();
#endif
atmsvc_exit();
atmpvc_exit();
}
module_init(atm_init);
module_exit(atm_exit);
MODULE_LICENSE("GPL");
|
#include "Beach.h"
#include "Bread.h"
#include "Flower.h"
#include "Hat.h"
#include "Skull.h"
namespace Tiles
{
constexpr const uint8_t * tilesets[] PROGMEM
{
Tiles::beach,
Tiles::bread,
Tiles::flower,
Tiles::hat,
Tiles::skull,
};
} |
#include <stdio.h>
/************************************************************************
* Function: iaddsec1
*
* Purpose: adds an integer number of seconds to a valid time expressed
* as (year, month, hr, day, min, sec). Increases minutes, hours, and
* days if neccessary, but not months! The reason for this is that these
* times are used to write in ISC 96-byte format, which does not allow
* phase arrival times with different reference months (for a given event)
*
* This function does not account for leap seconds
*
* Author: Antonio Villasenor, USGS, Golden
* Date: 17-FEB-1999
************************************************************************/
struct itm {
int year;
int month;
int day;
int hour;
int minute;
int second;
int millisecond;
};
struct itm iaddsec1(struct itm RefTime, int dt)
{
struct itm NewTime;
struct itm nerr = {0, 0, 0, 0, 0, 0, 0};
/* First check that RefTime is a valid time */
if (RefTime.month < 1 || RefTime.month > 12) {
fprintf(stderr, "Invalid month: %d\n", RefTime.month);
return nerr;
}
/* Here calculate number of days in this month and year */
/*
dom = days_in_month(RefTime.year, RefTime.month);
if (RefTime.day < 0 || RefTime.hour > dom) {
fprintf(stderr, "Invalid day: %d\n", RefTime.day);
return nerr;
}
*/
if (RefTime.hour < 0 || RefTime.hour >= 24) {
fprintf(stderr, "Invalid hour: %d\n", RefTime.hour);
return nerr;
}
if (RefTime.minute < 0 || RefTime.minute >= 60) {
fprintf(stderr, "Invalid minute: %d\n", RefTime.minute);
return nerr;
}
if (RefTime.second < 0 || RefTime.second >= 60) {
fprintf(stderr, "Invalid second: %d\n", RefTime.second);
return nerr;
}
if (RefTime.millisecond < 0 || RefTime.millisecond >= 999) {
fprintf(stderr, "Invalid millisecond: %d\n", RefTime.millisecond);
return nerr;
}
NewTime = RefTime;
NewTime.second += dt;
/* correct seconds (does not correct for leap seconds) */
if (NewTime.second >= 60)
do {
NewTime.minute++;
NewTime.second -= 60;
} while (NewTime.second >= 60);
else if (NewTime.second < 0)
do {
NewTime.minute --;
NewTime.second += 60;
} while (NewTime.second < 0);
else
return NewTime;
/* correct minutes */
if (NewTime.minute >= 60)
do {
NewTime.hour++;
NewTime.minute -= 60;
} while (NewTime.minute >= 60);
else if (NewTime.minute < 0)
do {
NewTime.hour--;
NewTime.minute += 60;
} while (NewTime.minute < 0);
else
return NewTime;
/* correct hours */
if (NewTime.hour >= 24)
do {
NewTime.day++;
NewTime.hour -= 24;
} while (NewTime.hour >= 24);
else if (NewTime.hour < 0)
do {
NewTime.day--;
NewTime.hour += 24;
} while (NewTime.hour < 0);
else
return NewTime;
/* iaddsec1 does not correct days that fall outside a month
(day <= 0, or day > number of days in the month)
because in ISS 96-byte format files, the reference month
for one event cannot be changed */
return NewTime;
}
|
/******************************************************************************
SPS/BAM driver Unit-Test: User-Space part
-----------------------------------------------------------------------------
Copyright (c) 2011 Qualcomm Technologies, Inc.
All Rights Reserved. Qualcomm Technologies Proprietary and Confidential.
-----------------------------------------------------------------------------
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include "msm_sps_test.h"
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
enum test_types {
NOMINAL,
ADVERSARIAL,
REPEAT,
RELEASE,
};
enum verbosity_level {
PRINT_ERROR = 0,
PRINT_WARNING,
PRINT_INFO,
PRINT_DEBUG,
};
static int verbosity;
static int iteration_number = 5;
static int interval_ms = 10;
static int failure_number;
int fd;
#define pr_err(msg, args...) do { \
if (verbosity >= (int)PRINT_ERROR) \
printf("\n"msg, ##args);\
} while (0)
#define pr_warn(msg, args...) do { \
if (verbosity >= (int)PRINT_WARN) \
printf("\n"msg, ##args);\
} while (0)
#define pr_info(msg, args...) do { \
if (verbosity >= (int)PRINT_INFO) \
printf("\n"msg, ##args);\
} while (0)
#define pr_debug(msg, args...) do { \
if (verbosity >= (int)PRINT_DEBUG) \
printf("\n"msg, ##args);\
} while (0)
static void showerrorandexit(char *message)
{
printf("%s\n", message);
failure_number++;
if (verbosity < (int)PRINT_DEBUG)
exit(-1);
}
static void nominal_test()
{
int ret;
int test_type = 1;
pr_info("Start running nominal test\n");
ret = ioctl(fd, MSM_SPS_TEST_TYPE, &test_type);
if (ret == -ENOTTY || ret == -EFAULT || ret == -EINVAL) {
pr_err("Fail to start testing; Error Code:%d\n", ret);
exit(-1);
}
else if (ret < 0) {
pr_info("Nominal test failed\n");
if (verbosity < (int)PRINT_DEBUG)
exit(-1);
else
failure_number++;
}
else if (verbosity < (int)PRINT_DEBUG)
pr_info("Nominal test passed\n");
}
static void adversarial_test()
{
int ret;
int test_type = 2;
pr_info("Start running adversarial test\n");
ret = ioctl(fd, MSM_SPS_TEST_TYPE, &test_type);
if (ret == -ENOTTY || ret == -EFAULT || ret == -EINVAL) {
pr_err("Fail to start testing; Error Code:%d\n", ret);
exit(-1);
}
else if (ret < 0) {
pr_info("Adversarial test failed\n");
if (verbosity < (int)PRINT_DEBUG)
exit(-1);
else
failure_number++;
}
else if (verbosity < (int)PRINT_DEBUG)
pr_info("Adversarial test passed\n");
}
static void repeatability_test()
{
int i;
pr_info("Start running repeatability test\n");
for (i = 1; i <= iteration_number; i++) {
pr_info("Iteration %d of repeatability test:\n", i);
nominal_test();
adversarial_test();
usleep(interval_ms*1000);
}
if (verbosity < (int)PRINT_DEBUG)
pr_info("Repeatability test passed\n");
}
static void release_test()
{
pr_info("Start running release test\n");
nominal_test();
adversarial_test();
repeatability_test();
if (verbosity < (int)PRINT_DEBUG)
pr_info("Release test passed\n");
}
static int (*test_func[]) () = {
[NOMINAL] = nominal_test,
[ADVERSARIAL] = adversarial_test,
[REPEAT] = repeatability_test,
[RELEASE] = release_test,
};
static void usage(int ret)
{
printf("Usage: msm_sps_test [OPTIONS] [TEST_TYPE]...\n"
"Runs the user space tests specified by the TEST_TYPE\n"
"parameters. If no TEST_TYPE is specified, then the release\n"
" test is run.\n"
"\n"
"OPTIONS can be:\n"
" -v, --verbose run with debug messages on\n"
" (debugging level: 0-3).\n"
" -i, --iteration iteration number for repeatability\n"
" -t, --interval interval (ms) between two iterations\n"
"\n"
"TEST_TYPE can be:\n"
" -n, --nominal run standard functionality tests\n"
" -a, --adversarial run tests that try to break the \n"
" driver\n"
" -p, --repeatability run 5 iterations of both the \n"
" nominal and adversarial tests\n"
" -r, --release run one iteration of the nominal, \n"
" adversarial and repeatability tests\n"
" -h, --help print this help message and exit\n");
exit(ret);
}
static unsigned int parse_command(int argc, char *const argv[])
{
int command;
unsigned ret = 0;
struct option longopts[] = {
{"verbose", required_argument, NULL, 'v'},
{"iteration", required_argument, NULL, 'i'},
{"interval", required_argument, NULL, 't'},
{"nominal", no_argument, NULL, 'n'},
{"adversarial", no_argument, NULL, 'a'},
{"repeatability", no_argument, NULL, 'p'},
{"release", no_argument, NULL, 'r'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0},
};
while ((command = getopt_long(argc, argv, "v:i:t:naprh", longopts,
NULL)) != -1) {
switch (command) {
case 'v':
verbosity = (int)(strtol(optarg, NULL, 0));
break;
case 'i':
iteration_number = (int)(strtol(optarg, NULL, 0));
break;
case 't':
interval_ms = (int)(strtol(optarg, NULL, 0));
break;
case 'n':
ret |= 1 << NOMINAL;
break;
case 'a':
ret |= 1 << ADVERSARIAL;
break;
case 'p':
ret |= 1 << REPEAT;
break;
case 'r':
ret |= 1 << RELEASE;
break;
case 'h':
usage(0);
default:
usage(-1);
}
}
return ret;
}
int main(int argc, char **argv)
{
int i;
unsigned int test_mask = parse_command(argc, argv);
int ignore_failure = 0;
/* Run the release case if none is specified */
if (test_mask == 0)
test_mask = 1 << RELEASE;
fd = open("/dev/sps_test", O_RDWR);
if (fd < 0)
showerrorandexit("Unable to open /dev/sps_test\n"
"Testing exits!\n");
if (verbosity == (int)PRINT_DEBUG)
ignore_failure = 1;
if (ioctl(fd, MSM_SPS_TEST_IGNORE_FAILURE, &ignore_failure))
showerrorandexit("Fail to set the "
"IGNORE_FAILURE parameter!\n");
for (i = 0; i < (int)ARRAY_SIZE(test_func); i++) {
/* Look for the test that was selected */
if (!(test_mask & (1U << i)))
continue;
/* This test was selected, so run it */
test_func[i] ();
}
if (failure_number == 0) {
printf("All tests have been passed.\n");
return 0;
}
else
return -1;
}
|
#pragma once
#include "Command.h"
#include "Color.h"
#include "Rectangle.h"
#include "Line.h"
#include "Circle.h"
#include<string>
#include "CommandParamsException.h"
#include "Property.h"
class CreateCommand : public Command
{
private:
const struct
{
std::string RECTANGLE = "rectangle";
std::string CIRCLE = "circle";
std::string LINE = "line";
} SHAPE_NAMES;
static void create_rectangle(const CommandContext& context);
static void create_circle(const CommandContext& context);
static void create_line(const CommandContext& context);
public:
bool can_execute(const CommandContext& context) const override;
void execute(const CommandContext& context) const override;
void onSuccess(const CommandContext& context) const override;
};
|
//
// 581. Shortest Unsorted Continuous Subarray.h
// leetcode
//
// Created by andysheng on 2019/10/7.
// Copyright © 2019 Andy. All rights reserved.
//
#ifndef _81__Shortest_Unsorted_Continuous_Subarray_h
#define _81__Shortest_Unsorted_Continuous_Subarray_h
#include <vector>
using namespace std;
namespace ShortestUnsortedContinuousSubarray {
class Solution {
public:
int findUnsortedSubarray(vector<int>& nums) {
int lowBoundary = -1;
int highBoundary = -2; // just for ascending input case. (-2 - -1 + 1 = 0)
// find left boundary
for (int i = 0; i < nums.size() - 1; ++i) {
if (nums[i] > nums[i + 1]) {
int smallest = nums[i + 1];
for (int j = i + 1; j < nums.size(); ++j) {
smallest = smallest <= nums[j] ? smallest : nums[j];
}
for (int j = 0; j <= i; ++j) {
if (nums[j] > smallest) {
lowBoundary = j;
break;
}
}
break;
}
}
// find right boundary
for (int i = (int)nums.size() - 1; i > 0; --i) {
if (nums[i] < nums[i - 1]) {
int biggest = nums[i - 1];
for (int j = i - 1; j >= lowBoundary; --j) {
biggest = biggest >= nums[j] ? biggest : nums[j];
}
for (int j = (int)nums.size() - 1; j >= i; --j) {
if (nums[j] < biggest) {
highBoundary = j;
break;
}
}
break;
}
}
return highBoundary - lowBoundary + 1;
}
};
}
#endif /* _81__Shortest_Unsorted_Continuous_Subarray_h */
|
/***********************************************************************
*
* Copyright 1996, University Corporation for Atmospheric Research.
*
* stringclean.c
*
* String cleaning utility.
*
* History:
*
* 11/96 COMET Original copy
*
***********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <ctype.h>
/*
*
* Squeeze out all unprintable string junk from given character
* string. The input parameter is re-written in place.
*
*/
StringClean( char *s )
{
char *t;
t = s;
while( *s ) {
if( ! isspace(*s) && ! iscntrl(*s) )
*t++ = *s;
*s++;
}
*t = '\0';
}
|
#include "HTHSM.h"
#include "unity.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/queue.h>
HTHSM_Fsm fsm;
HTHSM_STATE_DEF(0,stateA);
HTHSM_SUBSTATE_DEF(1,stateB, stateA);
HTHSM_SUBSTATE_DEF(2,stateC, stateA);
HTHSM_SUBSTATE_DEF(3,stateD, stateC);
HTHSM_STATE_DEF(4,stateE);
enum {
SIG_1 = HTHSM_SIG_USER_START,
SIG_2,
SIG_3,
SIG_4,
SIG_5,
SIG_6,
};
const HTHSM_State * __lowestCommonSuperstate(const HTHSM_State* const state1, const HTHSM_State* const state2);
// Queue variables for storing a record of what state handlers are called on what events
typedef struct Entry Entry;
typedef struct{
const HTHSM_State * state;
HTHSM_Event event;
} HandledEvent;
struct Entry{
HandledEvent handledEvent;
TAILQ_ENTRY(Entry) links;
};
TAILQ_HEAD(Queue, Entry) queue;
void addToQueue(const HTHSM_State * const state, HTHSM_Event const * event) {
Entry *elem;
elem = malloc(sizeof(Entry));
if (elem) {
elem->handledEvent.state = state;
memcpy(&(elem->handledEvent.event), event, sizeof(HTHSM_Event));
}
TAILQ_INSERT_TAIL(&queue, elem, links);
}
Entry removeFromQueue() {
Entry elem;
Entry* pFirstElem;
pFirstElem = TAILQ_FIRST(&queue);
memcpy(&elem, (Entry*)pFirstElem, sizeof(Entry));
TAILQ_REMOVE(&queue, pFirstElem, links);
free(pFirstElem);
return elem;
}
void emptyQueue(){
Entry *elem;
TAILQ_FOREACH(elem, &queue, links) {
TAILQ_REMOVE(&queue, elem, links);
}
}
uint8_t queueSize(){
uint8_t count = 0;
Entry *elem;
TAILQ_FOREACH(elem, &queue, links) {
count++;
}
return count;
}
void printQueue(){
Entry *elem;
TAILQ_FOREACH(elem, &queue, links) {
printf("State: %d\t Event Signal: %d\t Event Param: %d\n",elem->handledEvent.state->identifier, elem->handledEvent.event.sig, elem->handledEvent.event.param);
}
}
HTHSM_return_t stateA_fxn(HTHSM_Fsm *fsm, HTHSM_Event const * pEvent){
addToQueue(stateA, pEvent);
return HTHSM_CONTINUE;
}
HTHSM_return_t stateB_fxn(HTHSM_Fsm *fsm, HTHSM_Event const * pEvent){
addToQueue(stateB, pEvent);
return HTHSM_CONTINUE;
}
HTHSM_return_t stateC_fxn(HTHSM_Fsm *fsm, HTHSM_Event const * pEvent){
addToQueue(stateC, pEvent);
return HTHSM_CONTINUE;
}
HTHSM_return_t stateD_fxn(HTHSM_Fsm *fsm, HTHSM_Event const * pEvent){
addToQueue(stateD, pEvent);
switch(pEvent->sig){
case SIG_1:
return HTHSM_CONTINUE;
case SIG_2:
return HTHSM_SUPPRESS_SUPERSTATES;
case SIG_3:
return HTHSM_SUPPRESS_IMMEDIATE_SUPERSTATE;
case SIG_4:
HTHSM_Transition(fsm, stateB);
break;
case SIG_5:
HTHSM_Transition(fsm, stateE);
break;
case SIG_6:
HTHSM_Transition(fsm, stateA);
break;
default:
break;
}
return HTHSM_CONTINUE;
}
HTHSM_return_t stateE_fxn(HTHSM_Fsm *fsm, HTHSM_Event const * pEvent){
addToQueue(stateE, pEvent);
return HTHSM_CONTINUE;
}
void assertEventsHandled(HandledEvent* pexpectation, size_t count){
TEST_ASSERT_EQUAL(count, queueSize());
Entry *elem;
uint8_t i=0;
TAILQ_FOREACH(elem, &queue, links) {
TEST_ASSERT_EQUAL(pexpectation[i].state, elem->handledEvent.state);
TEST_ASSERT_EQUAL(pexpectation[i].event.sig, elem->handledEvent.event.sig);
i++;
}
}
void setUp(void)
{
TAILQ_INIT(&queue);
}
void tearDown(void)
{
}
void test_lowestCommonSuperstate(void){
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateA, stateA));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateB, stateC));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateC, stateB));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateB, stateD));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateD, stateB));
TEST_ASSERT_EQUAL(NULL, __lowestCommonSuperstate(stateA, stateE));
TEST_ASSERT_EQUAL(NULL, __lowestCommonSuperstate(stateB, stateE));
TEST_ASSERT_EQUAL(NULL, __lowestCommonSuperstate(stateC, stateE));
TEST_ASSERT_EQUAL(NULL, __lowestCommonSuperstate(stateD, stateE));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateA, stateC));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateA, stateD));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateC, stateA));
TEST_ASSERT_EQUAL(stateA, __lowestCommonSuperstate(stateD, stateA));
}
void test_initialization(void){
HandledEvent expectation[] = {
{stateB, {HTHSM_SIG_INIT, 0}},
{stateA, {HTHSM_SIG_ENTRY, 0}},
{stateB, {HTHSM_SIG_ENTRY, 0}},
};
HTHSM_FsmCtor(&fsm, stateB, NULL);
TEST_ASSERT_EQUAL(0, queueSize());
HTHSM_FsmInit(&fsm);
assertEventsHandled(expectation, sizeof(expectation)/sizeof(expectation[0]));
}
void test_hierarchyWithDepth3(void)
{
HTHSM_Event event = {SIG_1, 0};
HandledEvent expectation[] = {
{stateD, {event.sig, 0}},
{stateC, {event.sig, 0}},
{stateA, {event.sig, 0}},
};
HTHSM_FsmCtor(&fsm, stateD, NULL);
HTHSM_FsmInit(&fsm);
emptyQueue();
TEST_ASSERT_EQUAL(0, queueSize());
HTHSM_Dispatch(&fsm, &event);
assertEventsHandled(expectation, sizeof(expectation)/sizeof(expectation[0]));
}
void test_hierarchyWithDepth3_suppressSuperstates(void)
{
HTHSM_Event event = {SIG_2, 0};
HandledEvent expectation[] = {
{stateD, {event.sig, 0}},
};
HTHSM_FsmCtor(&fsm, stateD, NULL);
HTHSM_FsmInit(&fsm);
emptyQueue();
TEST_ASSERT_EQUAL(0, queueSize());
HTHSM_Dispatch(&fsm, &event);
assertEventsHandled(expectation, sizeof(expectation)/sizeof(expectation[0]));
}
void test_hierarchyWithDepth3_suppressImmediateSuperstates(void)
{
HTHSM_Event event = {SIG_3, 0};
HandledEvent expectation[] = {
{stateD, {event.sig, 0}},
{stateA, {event.sig, 0}},
};
HTHSM_FsmCtor(&fsm, stateD, NULL);
HTHSM_FsmInit(&fsm);
emptyQueue();
TEST_ASSERT_EQUAL(0, queueSize());
HTHSM_Dispatch(&fsm, &event);
assertEventsHandled(expectation, sizeof(expectation)/sizeof(expectation[0]));
}
void test_hierarchyWithDepth3_transition_toLSA(void)
{
HTHSM_Event event = {SIG_6, 0};
HandledEvent expectation[] = {
{stateD, {event.sig, 0}},
{stateC, {event.sig, 0}},
{stateA, {event.sig, 0}},
{stateD, {HTHSM_SIG_EXIT, 0}},
{stateC, {HTHSM_SIG_EXIT, 0}},
};
HTHSM_FsmCtor(&fsm, stateD, NULL);
HTHSM_FsmInit(&fsm);
emptyQueue();
TEST_ASSERT_EQUAL(0, queueSize());
HTHSM_Dispatch(&fsm, &event);
assertEventsHandled(expectation, sizeof(expectation)/sizeof(expectation[0]));
}
void test_hierarchyWithDepth3_transition_withLSA(void)
{
HTHSM_Event event = {SIG_4, 0}; // targeting state B
HandledEvent expectation[] = {
{stateD, {event.sig, 0}},
{stateC, {event.sig, 0}},
{stateA, {event.sig, 0}},
{stateD, {HTHSM_SIG_EXIT, 0}},
{stateC, {HTHSM_SIG_EXIT, 0}},
{stateB, {HTHSM_SIG_ENTRY, 0}},
};
HTHSM_FsmCtor(&fsm, stateD, NULL);
HTHSM_FsmInit(&fsm);
emptyQueue();
TEST_ASSERT_EQUAL(0, queueSize());
HTHSM_Dispatch(&fsm, &event);
assertEventsHandled(expectation, sizeof(expectation)/sizeof(expectation[0]));
}
void test_hierarchyWithDepth3_transition_withoutLSA(void)
{
HTHSM_Event event = {SIG_5, 0}; // targeting state B
HandledEvent expectation[] = {
{stateD, {event.sig, 0}},
{stateC, {event.sig, 0}},
{stateA, {event.sig, 0}},
{stateD, {HTHSM_SIG_EXIT, 0}},
{stateC, {HTHSM_SIG_EXIT, 0}},
{stateA, {HTHSM_SIG_EXIT, 0}},
{stateE, {HTHSM_SIG_ENTRY, 0}},
};
HTHSM_FsmCtor(&fsm, stateD, NULL);
HTHSM_FsmInit(&fsm);
emptyQueue();
TEST_ASSERT_EQUAL(0, queueSize());
HTHSM_Dispatch(&fsm, &event);
assertEventsHandled(expectation, sizeof(expectation)/sizeof(expectation[0]));
}
|
/*
* Attention:
* To keep things simple, do not handle
* socket/bind/listen/.../epoll_create/epoll_wait API error
*/
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#define DEFAULT_PORT (8088)
#define MAX_CONN (16)
#define MAX_EVENTS (32)
#define BUF_SIZE (16)
#define MAX_LINE (256)
void server_run();
void client_run();
int main(int argc, char *argv[]) {
int opt;
char role = 's';
while ((opt = getopt(argc, argv, "cs")) != -1) {
switch (opt) {
case 'c':
role = 'c';
break;
case 's':
break;
default:
printf("usage: %s [-cs]\n", argv[0]);
exit(1);
}
}
if (role == 's') {
server_run();
} else {
client_run();
}
return 0;
}
/*
* register events of fd to epfd
*/
static void epoll_ctl_add(int epfd, int fd, uint32_t events) {
struct epoll_event ev;
ev.events = events;
ev.data.fd = fd;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
perror("epoll_ctl()\n");
exit(1);
}
}
static void set_sockaddr(struct sockaddr_in *addr) {
bzero((char *)addr, sizeof(struct sockaddr_in));
addr->sin_family = AF_INET;
addr->sin_addr.s_addr = INADDR_ANY;
addr->sin_port = htons(DEFAULT_PORT);
}
static int setnonblocking(int sockfd) {
if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0) | O_NONBLOCK) == -1) {
return -1;
}
return 0;
}
/*
* epoll echo server
*/
void server_run() {
int i;
int n;
int epfd;
int nfds;
int listen_sock;
int conn_sock;
int socklen;
char buf[BUF_SIZE];
struct sockaddr_in srv_addr;
struct sockaddr_in cli_addr;
struct epoll_event events[MAX_EVENTS];
listen_sock = socket(AF_INET, SOCK_STREAM, 0);
set_sockaddr(&srv_addr);
bind(listen_sock, (struct sockaddr *)&srv_addr, sizeof(srv_addr));
setnonblocking(listen_sock);
listen(listen_sock, MAX_CONN);
epfd = epoll_create(1);
epoll_ctl_add(epfd, listen_sock, EPOLLIN | EPOLLOUT | EPOLLET);
socklen = sizeof(cli_addr);
for (;;) {
nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
for (i = 0; i < nfds; i++) {
if (events[i].data.fd == listen_sock) {
/* handle new connection */
conn_sock = accept(listen_sock, (struct sockaddr *)&cli_addr,
&socklen);
inet_ntop(AF_INET, (char *)&(cli_addr.sin_addr), buf,
sizeof(cli_addr));
printf("[+] connected with %s:%d\n", buf,
ntohs(cli_addr.sin_port));
setnonblocking(conn_sock);
epoll_ctl_add(epfd, conn_sock,
EPOLLIN | EPOLLET | EPOLLRDHUP | EPOLLHUP);
} else if (events[i].events & EPOLLIN) {
/* handle EPOLLIN event */
for (;;) {
bzero(buf, sizeof(buf));
n = read(events[i].data.fd, buf, sizeof(buf));
if (n <= 0 /* || errno == EAGAIN */) {
break;
} else {
printf("[+] data: %s\n", buf);
write(events[i].data.fd, buf, strlen(buf));
}
}
} else {
printf("[+] unexpected\n");
}
/* check if the connection is closing */
if (events[i].events & (EPOLLRDHUP | EPOLLHUP)) {
printf("[+] connection closed\n");
epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
close(events[i].data.fd);
continue;
}
}
}
}
/*
* test clinet
*/
void client_run() {
int n;
int c;
int sockfd;
char buf[MAX_LINE];
struct sockaddr_in srv_addr;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
set_sockaddr(&srv_addr);
if (connect(sockfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0) {
perror("connect()");
exit(1);
}
for (;;) {
printf("input: ");
fgets(buf, sizeof(buf), stdin);
c = strlen(buf) - 1;
buf[c] = '\0';
write(sockfd, buf, c + 1);
bzero(buf, sizeof(buf));
while (errno != EAGAIN && (n = read(sockfd, buf, sizeof(buf))) > 0) {
printf("echo: %s\n", buf);
bzero(buf, sizeof(buf));
c -= n;
if (c <= 0) {
break;
}
}
}
close(sockfd);
} |
#ifndef TkDetLayers_PixelRodBuilder_h
#define TkDetLayers_PixelRodBuilder_h
#include "PixelRod.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
/** A concrete builder for PixelRod
*/
#pragma GCC visibility push(hidden)
class PixelRodBuilder {
public:
PixelRodBuilder(){};
PixelRod* build(const GeometricDet* aRod,
const TrackerGeometry* theGeomDetGeometry) __attribute__ ((cold));
};
#pragma GCC visibility pop
#endif
|
//树
// Created by Jeza on 2017/9/21.
//
#ifndef DSL_BINNODE_TRAVPOST_H
#define DSL_BINNODE_TRAVPOST_H
#include "BinNode.h"
#include "../Stack/Linked_Stack.h"
namespace DSLibrary
{
template<typename T, typename VST>
void travPost_R(BinNodePosi(T)x, VST &visit) //递归版后序遍历
{
if (!x) return; //递归基
travPost_R(x->lc, visit);
travPost_R(x->rc, visit);
visit(x);
};
//迭代版的后续遍历有点抽象
template<typename T>
void gotoHLVFL(Stack<BinNodePosi(T)> &S) //找到最高左侧可见叶节点
{
while (BinNodePosi(T)x = S.top()) //自顶而下的寻找
{
if (HasLChild(*x))
{
if (HasRChild(*x)) S.push(x->rc); //若有右孩子,右孩子有限入栈
S.push(x->lc); //左孩子入栈
}
else
S.push(x->rc); //迫不得已,右孩子入栈
}
S.pop(); //记得弹出栈顶的空节点
}
template<typename T, typename VST>
void travPost_I(BinNodePosi(T)x, VST &visit) //迭代版后序遍历
{
Single_Linked::LStack<BinNodePosi(T)> S; //辅助栈
if (x) S.push(x); //根节点入栈
while (S.empty())
{
if (S.top() != x->_parent) //若栈顶非当前节点的父节点,则必为右兄弟或者是当前节点是根节点
{
gotoHLVFL(S); //找到栈顶节点的最高左侧可见叶节点
}
x = S.pop();
visit(x); //访问当前节点
}
}
}
#endif //DSL_BINNODE_TRAVPOST_H
|
#ifndef EXT4_CRYPT_H_
#define EXT4_CRYPT_H_
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <asm-generic/ioctl.h>
#include <keyutils.h>
#define UNUSED __attribute__((unused))
#define VERBOSE_PRINT(opts, format, args...) ({ \
if ( opts.verbose ) \
fprintf(stderr, format "\n", ##args); \
}) \
/*
* Definitions imported from Linux kernel 4.1.2.
*/
#define EXT4_KEY_DESCRIPTOR_SIZE 8
/* Policy provided via an ioctl on the topmost directory */
struct ext4_encryption_policy {
char version;
char contents_encryption_mode;
char filenames_encryption_mode;
char flags;
char master_key_descriptor[EXT4_KEY_DESCRIPTOR_SIZE];
} __attribute__((__packed__));
#define EXT4_ENCRYPTION_CONTEXT_FORMAT_V1 1
#define EXT4_KEY_DERIVATION_NONCE_SIZE 16
#define EXT4_POLICY_FLAGS_PAD_4 0x00
#define EXT4_POLICY_FLAGS_PAD_8 0x01
#define EXT4_POLICY_FLAGS_PAD_16 0x02
#define EXT4_POLICY_FLAGS_PAD_32 0x03
#define EXT4_POLICY_FLAGS_PAD_MASK 0x03
#define EXT4_POLICY_FLAGS_VALID 0x03
/* Encryption algorithms */
#define EXT4_ENCRYPTION_MODE_INVALID 0
#define EXT4_ENCRYPTION_MODE_AES_256_XTS 1
#define EXT4_ENCRYPTION_MODE_AES_256_GCM 2
#define EXT4_ENCRYPTION_MODE_AES_256_CBC 3
#define EXT4_ENCRYPTION_MODE_AES_256_CTS 4
/* Encryption parameters */
#define EXT4_XTS_TWEAK_SIZE 16
#define EXT4_AES_128_ECB_KEY_SIZE 16
#define EXT4_AES_256_GCM_KEY_SIZE 32
#define EXT4_AES_256_CBC_KEY_SIZE 32
#define EXT4_AES_256_CTS_KEY_SIZE 32
#define EXT4_AES_256_XTS_KEY_SIZE 64
#define EXT4_MAX_KEY_SIZE 64
#define EXT4_KEY_DESC_PREFIX "ext4:"
#define EXT4_KEY_DESC_PREFIX_SIZE 5
struct ext4_encryption_key {
uint32_t mode;
unsigned char raw[EXT4_MAX_KEY_SIZE];
uint32_t size;
};
#define EXT4_IOC_SET_ENCRYPTION_POLICY _IOR('f', 19, struct ext4_encryption_policy)
#define EXT4_IOC_GET_ENCRYPTION_PWSALT _IOW('f', 20, __u8[16])
#define EXT4_IOC_GET_ENCRYPTION_POLICY _IOW('f', 21, struct ext4_encryption_policy)
#define EXT4_MAX_PASSPHRASE_SZ 128
#define EXT4_ENCRYPTION_KEY_TYPE "logon"
#define EXT4_FULL_KEY_DESCRIPTOR_SIZE (EXT4_KEY_DESCRIPTOR_SIZE * 2 + EXT4_KEY_DESC_PREFIX_SIZE)
struct ext4_crypt_options {
bool verbose;
char *contents_cipher;
char *filename_cipher;
unsigned filename_padding;
char key_descriptor[EXT4_KEY_DESCRIPTOR_SIZE];
bool requires_descriptor;
};
static inline
char padding_length_to_flags(unsigned padding)
{
switch ( padding ) {
case 4:
return EXT4_POLICY_FLAGS_PAD_4;
case 8:
return EXT4_POLICY_FLAGS_PAD_8;
case 16:
return EXT4_POLICY_FLAGS_PAD_16;
case 32:
return EXT4_POLICY_FLAGS_PAD_32;
default:
fprintf(stderr, "Invalid padding value: %d\n", padding);
abort();
}
}
static inline
unsigned flags_to_padding_length(char flags)
{
return (4 << (flags & EXT4_POLICY_FLAGS_PAD_MASK));
}
struct cipher {
const char *cipher_name;
size_t cipher_key_size;
};
static
struct cipher cipher_modes[] = {
[EXT4_ENCRYPTION_MODE_INVALID] = { "invalid", 0 },
[EXT4_ENCRYPTION_MODE_AES_256_XTS] = { "aes-256-xts", EXT4_AES_256_XTS_KEY_SIZE },
[EXT4_ENCRYPTION_MODE_AES_256_GCM] = { "aes-256-gcm", EXT4_AES_256_GCM_KEY_SIZE },
[EXT4_ENCRYPTION_MODE_AES_256_CBC] = { "aes-256-cbc", EXT4_AES_256_CBC_KEY_SIZE },
[EXT4_ENCRYPTION_MODE_AES_256_CTS] = { "aes-256-cts", EXT4_AES_256_CTS_KEY_SIZE },
};
#define NR_EXT4_ENCRYPTION_MODES (sizeof(cipher_modes) / sizeof(cipher_modes[0]))
static inline
const char *cipher_mode_to_string(unsigned char mode)
{
if ( mode >= NR_EXT4_ENCRYPTION_MODES )
return "invalid";
return cipher_modes[mode].cipher_name;
}
static inline
char cipher_string_to_mode(const char *cipher)
{
for ( size_t i = 0; i < NR_EXT4_ENCRYPTION_MODES; i++ ) {
if ( strcmp(cipher, cipher_modes[i].cipher_name) == 0 )
return i;
}
fprintf(stderr, "Invalid cipher mode: %s\n", cipher);
abort();
}
static inline
size_t cipher_key_size(const char *cipher)
{
for ( size_t i = 0; i < NR_EXT4_ENCRYPTION_MODES; i++ ) {
if ( strcmp(cipher, cipher_modes[i].cipher_name) == 0 )
return cipher_modes[i].cipher_key_size;
}
fprintf(stderr, "Invalid cipher mode: %s\n", cipher);
abort();
}
typedef char key_desc_t[EXT4_KEY_DESCRIPTOR_SIZE];
typedef char full_key_desc_t[EXT4_FULL_KEY_DESCRIPTOR_SIZE];
int crypto_init();
int container_status(const char *dir_path);
int container_create(const char *dir_path, struct ext4_crypt_options);
int container_attach(const char *dir_path, struct ext4_crypt_options);
int container_detach(const char *dir_path, struct ext4_crypt_options);
void generate_random_name(char *, size_t);
int find_key_by_descriptor(key_desc_t *, key_serial_t *);
int request_key_for_descriptor(key_desc_t *, struct ext4_crypt_options, bool);
int remove_key_for_descriptor(key_desc_t *);
#endif
|
require_extension('Q');
require_fp;
MMU.store_float128(RS1 + insn.s_imm(), FRS2);
|
//
// Created by zdavid on 26/12/18.
//
#include "../headers/storeanewword.h"
#include "../headers/createmenuitem.h"
#include "../headers/renderview.h"
#include <stdio.h>
#include <string.h>
void showSuccessFeedback(WORD *newWord)
{
char wordMessage[VIEW_WIDTH] = "",
categoryMessage[VIEW_WIDTH] = "";
strcat(wordMessage, "The word \"");
strcat(wordMessage, newWord->content);
strcat(wordMessage, "\" successfully saved to");
strcat(categoryMessage, "the \"");
strcat(categoryMessage, newWord->category);
strcat(categoryMessage, "\" category!");
MENUITEM *menu;
menu = createMenuItem("====================== ADD NEW WORD =======================");
MENUITEM *first = menu;
menu->next = createMenuItem(" "); menu = menu->next;
menu->next = createMenuItem(wordMessage); menu = menu->next;
menu->next = createMenuItem(categoryMessage); menu = menu->next;
menu->next = createMenuItem(" "); menu = menu->next;
menu->next = createMenuItem("Press <ENTER> to go back!"); menu = menu->next;
renderView(first);
while(getchar() != '\n');
}
int storeANewWord(char *category, char *newWord, char *filename, WORD **wordList, int length)
{
char title[VIEW_WIDTH] = "",
message[VIEW_WIDTH] = "";
unsigned int isValidWord = 1,
i = 0,
lengthOfNewWord = 0;
FILE *db;
db = fopen(filename, "a+");
/**
* Check file permission
*/
if (db == NULL) {
strcpy(message, "Error! File is not found or don\'t have permission to write!");
}
do {
strcpy(title, "Add new word to \"");
MENUITEM *menu;
menu = createMenuItem("====================== ADD NEW WORD =======================");
MENUITEM *first = menu;
menu->next = createMenuItem(" "); menu = menu->next;
if (db != NULL) {
strcat(title, category);
strcat(title, "\" category.");
menu->next = createMenuItem(title); menu = menu->next;
menu->next = createMenuItem(" "); menu = menu->next;
menu->next = createMenuItem("Enter the new word, then press <ENTER>"); menu = menu->next;
menu->next = createMenuItem(" "); menu = menu->next;
menu->next = createMenuItem("(Note: only letters, \"'\", \" \" and \"-\" characters are"); menu = menu->next;
menu->next = createMenuItem("accepted, and the word should have at least 4 characters,"); menu = menu->next;
menu->next = createMenuItem("but the word cannot be longer than 32 characters.)"); menu = menu->next;
menu->next = createMenuItem(" "); menu = menu->next;
menu->next = createMenuItem("If you would like to go back, press <b> and press <ENTER> !"); menu = menu->next;
menu->next = createMenuItem(" "); menu = menu->next;
menu->next = createMenuItem(" "); menu = menu->next;
}
menu->next = createMenuItem(message);
if (db == NULL) {
menu = menu->next;
menu->next = createMenuItem(" "); menu = menu->next;
menu->next = createMenuItem("Press <ENTER> to go back!");
}
renderView(first);
fgets(newWord, 100, stdin);
if (db == NULL) {
return 2;
}
lengthOfNewWord = (unsigned int) strlen(newWord);
/*
* Remove \n from the end of the newWord
*/
newWord[lengthOfNewWord - 1] = '\0';
/*
* Set the isValidWord flag to true, to let the for loop
* decide if it is a valid word
*/
if (isValidWord == 0) isValidWord = 1;
if (lengthOfNewWord == 2 && (newWord[0] == 'b' || newWord[0] == 'B')) {
fclose(db);
return 1;
}
if (lengthOfNewWord > 32) {
isValidWord = 0;
strcpy(message, "Error! The given word is longer than 32 characters!");
} else if (lengthOfNewWord < 4) {
isValidWord = 0;
strcpy(message, "Error! The given word should have at least 4 characters!");
}
else {
for (i = 0; i < lengthOfNewWord - 1; i++) {
/*
* It's a tricky condition, let me explain it:
* If a char is a lowercase letter OR
* a char is an uppercase letter OR
* a char is ' ' OR
* a char is '-' OR
* a char is "'"
* then the given character is a valid character.
*
* So if I negate the statement (!), I can trigger
* the invalid case.
*/
if (!((newWord[i] >= 'a' && newWord[i] <= 'z') ||
(newWord[i] >= 'A' && newWord[i] <= 'Z') ||
(newWord[i] == ' ') ||
(newWord[i] == '-') ||
(newWord[i] == '\'')
)){
isValidWord = 0;
strcpy(message, "Error! The given word contains illegal characters!");
}
}
}
/*
* checks, that if the new word is already on the list
*/
if (isValidWord == 1) {
for (i = 0; i < length; i++) {
if (strcasecmp(newWord, wordList[i]->content) == 0) {
isValidWord = 0;
strcpy(message, "Error! The given word is already stored in the word list!");
}
}
}
} while (isValidWord == 0);
/*
* If everything is fine, write it to the file
*/
fprintf(db,"\n%s\t%s",category, newWord);
fclose(db);
return 0;
} |
#pragma once
#include "Tile.h"
#include <unordered_map>
#include "RayHit.h"
#include "../../../NimbleEditor/d3drenderwidget.h"
using std::vector;
class TileMap
{
public:
explicit TileMap(const int width, const int height)
: _map(width * height), _visibleMap(width * height)
{}
void Load(ComPtr<ID3D11Device> device, ComPtr<ID3D11DeviceContext> deviceContext);
void Draw(ComPtr<ID3D11Device> device, ComPtr<ID3D11DeviceContext> deviceContext,
const Matrix& viewMatrix, const Matrix& projectionMatrix, const Light& light, const Frustum& frustum);
void SplatTexture(D3DDevice device, D3DDeviceContext deviceContext, Vector3 location, float radius, int intensity, int texture_number);
Tile* GetRayIntersectingTile(const Ray& r) const
{
for (const auto& tile: _visibleMap)
{
auto rayhit = tile->IsRayIntersecting(r);
if (rayhit.hit)
{
return tile;
}
}
return nullptr;
}
~TileMap() = default;
private:
void LoadChunks(ComPtr<ID3D11Device> device);
void UpdateChunks(ComPtr<ID3D11Device> device, ComPtr<ID3D11DeviceContext> deviceContext);
// Container for all map tiles.
vector<Tile> _map;
// Cache for visible tiles found in the frustrum.
vector<Tile*> _visibleMap;
};
|
#ifndef FRAMESOURCEPLUGINBASE_H
#define FRAMESOURCEPLUGINBASE_H
#include "eirFrameSource.h"
#include <QObject>
#include "FrameSourceInterface.h"
#include <QtCore/QList>
#include <QtCore/QStringList>
#include <QtXml/QDomElement>
#include "../eirTypes/MillisecondTime.h"
#include "../eirCore/VariableSet.h"
#include "../eirExe/Log.h"
#include "../eirExe/Results.h"
#include "../eirImage/ImageEntity.h"
class HttpManager;
class FrameSourceBehavior;
class FrameSourceMachine;
class FrameSourceState;
class FrameSourceStatusIndex;
#define FSPPOINTER(typ, ptr) { OBJPOINTER(QObject, ptr); \
EXPECT(ptr->objectName().endsWith("FrameSourcePlugin")); \
TODO("Why wont FrameSourcePlugin qobject_cast?"); }
class EIRFRAMESOURCESHARED_EXPORT FrameSourcePlugin
: public QObject, public FrameSourceInterface
{
Q_OBJECT
Q_INTERFACES(FrameSourceInterface)
public:
FrameSourcePlugin(QObject * parent=0);
~FrameSourcePlugin();
#include "FrameSourcePlugin-common.h"
};
#endif // FRAMESOURCEPLUGINBASE_H
|
//
// JEProgress.h
// JustPromises
//
// Created by Marek Rogosz on 05/12/2014.
// Copyright (c) 2014 JUST EAT. All rights reserved.
//
#import <Foundation/Foundation.h>
@protocol JECancellableProgressProtocol;
@class JEProgress;
typedef void (^JECancellationHandler)(id<JECancellableProgressProtocol> token);
typedef void (^JEProgressHandler)(JEProgress *progress);
/**
* This protocol represents a general interface for a cancellable progress operation.
*/
@protocol JECancellableProgressProtocol
/**
* This method is intended to check the cancellation status of the receiver.
*
* @return YES if the receiver is cancelled, NO otherwise.
*/
- (BOOL)isCancelled;
/**
* This method is intended to set a handler to be executed when the the receiver is cancelled.
* If the receiver is already cancelled the handler should be executed immediately.
*
* @param handler The cancellation handler.
*/
- (void)setCancellationHandler:(JECancellationHandler)handler;
- (void)onQueue:(dispatch_queue_t)queue setCancellationHandler:(JECancellationHandler)handler;
/**
* This method is intended to update the receiver with a partial unit count and a total.
*
* @param completed The unit count.
* @param total The total.
*/
- (void)updateCompletedUnitCount:(NSUInteger)completed total:(NSUInteger)total;
/**
* This method is intended to set a state on the receiver.
*
* @param state The state.
*/
- (void)updateState:(NSUInteger)state;
/**
* This method is intended to set a progress description on the receiver.
*
* @param description The progress description.
*/
- (void)updateProgressDescription:(NSString *)progressDescription;
@end
/**
* This class represents a cancellable progress operation.
*/
@interface JEProgress : NSObject <JECancellableProgressProtocol>
/**
* Cancel the receiver.
*/
- (void)cancel;
/**
* Get the completed amount of units and total of the receiver.
*
* @param completed The passed-in by reference unit count.
* @param total The passed-in by reference total.
*/
- (void)getCompletedUnitCount:(NSUInteger *)completed total:(NSUInteger *)total;
/**
* Set a handler called when the state is updated through updateState:
*
* @param handler The handler.
*/
- (void)setProgressHandler:(JEProgressHandler)handler;
/**
* Set a handler called on a specific queue when the state is updated through updateState:
*
* @param queue The queue.
* @param handler The handler.
*/
- (void)onQueue:(dispatch_queue_t)queue setProgressHandler:(JEProgressHandler)handler;
/**
* Retrieve the state of the receiver.
*
* @return The state of the receiver.
*/
- (NSUInteger)state;
/**
* Set a handler called when the progress is updated through updateCompletedUnitCount:total:
*
* @param handler The handler.
*/
- (void)setStateHandler:(JEProgressHandler)handler;
/**
* Set a handler called on a specific queue when the state is updated through updateCompletedUnitCount:total:
*
* @param queue The queue.
* @param handler The handler.
*/
- (void)onQueue:(dispatch_queue_t)queue setStateHandler:(JEProgressHandler)handler;
/**
* Retrieve the current description of the receiver.
*
* @return The current description of the receiver.
*/
- (NSString *)progressDescription;
/**
* Set a handler called when the state is updated through updateProgressDescription:
*
* @param handler The handler.
*/
- (void)setProgressDescriptionHandler:(JEProgressHandler)handler;
/**
* Set a handler called on a specific queue when the state is updated through updateProgressDescription:
*
* @param queue The queue.
* @param handler The handler.
*/
- (void)onQueue:(dispatch_queue_t)queue setProgressDescriptionHandler:(JEProgressHandler)handler;
@end
|
//
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import <PowerlogCore/PLTimeReference.h>
@class NSDate, NSMutableArray, NSMutableDictionary, PLTimer;
@interface PLTimeReferenceDynamic : PLTimeReference
{
int _offsetHistoryHead;
NSMutableDictionary *_timeChangeBlocks;
double _tooFarInFutureDistance;
double _tooFarInPastDistance;
NSDate *_lastQueryTime;
NSMutableArray *_offsetHistory;
PLTimer *_periodicCurrentTime;
}
+ (double)nearestDistanceFromDate:(id)arg1 toRegionWithStartDate:(id)arg2 andEndDate:(id)arg3;
@property(retain) PLTimer *periodicCurrentTime; // @synthesize periodicCurrentTime=_periodicCurrentTime;
@property int offsetHistoryHead; // @synthesize offsetHistoryHead=_offsetHistoryHead;
@property(retain) NSMutableArray *offsetHistory; // @synthesize offsetHistory=_offsetHistory;
@property(retain) NSDate *lastQueryTime; // @synthesize lastQueryTime=_lastQueryTime;
@property double tooFarInPastDistance; // @synthesize tooFarInPastDistance=_tooFarInPastDistance;
@property double tooFarInFutureDistance; // @synthesize tooFarInFutureDistance=_tooFarInFutureDistance;
@property(retain) NSMutableDictionary *timeChangeBlocks; // @synthesize timeChangeBlocks=_timeChangeBlocks;
- (void).cxx_destruct;
- (void)notifyTimeChange:(double)arg1;
- (void)unregisterForTimeChangedCallbackWithIdentifier:(id)arg1;
- (void)registerForTimeChangedCallbackWithIdentifier:(id)arg1 usingBlock:(CDUnknownBlockType)arg2;
- (BOOL)shouldQueryCurrentTime;
- (id)removeTimeOffsetFromReferenceTime:(id)arg1;
- (void)setOffset:(double)arg1;
- (id)newOffsetEntryWithCurrentTime;
- (void)checkForTimeChangeWithCurrentTime:(id)arg1;
- (void)registerForClockSetNotification;
- (void)registerForTimeChangedNotification;
- (void)initializeOffsetHistoryWithEntries:(id)arg1;
- (void)initializeOffsetWithEntries:(id)arg1;
- (id)initWithTimeManager:(id)arg1 entryDefinitionKey:(id)arg2 timeReferenceType:(long long)arg3;
@end
|
/* C99 32-bit closed hashing integer hash set header library
*
* This is free and unencumbered software released into the public domain.
*
* It's up to the caller to allocate and zero-initialize the table. The
* set32_z() function assists in choosing a table size, which must be a
* power of 2. This hash set cannot store the integer 0.
*
* To get the implementation, define SET32_IMPLEMENTATION before
* including this file. Optionally define SET32_API to control linkage.
*/
#ifndef SET32_H
#define SET32_H
#include <stdint.h>
#ifndef SET32_API
# define SET32_API static
#endif
/* Compute a power of two table size from a maximum number of elements */
SET32_API
int set32_z(uint32_t max);
/* 32-bit hash function */
SET32_API
uint32_t set32_hash(uint32_t);
/* Insert an integer into the set, which may already be present */
SET32_API
void set32_insert(uint32_t *table, int z, uint32_t v);
/* Remove an integer, which may not actually be present in the set */
SET32_API
void set32_remove(uint32_t *table, int z, uint32_t v);
/* Check set membership of an integer */
SET32_API
int set32_contains(uint32_t *table, int z, uint32_t v);
#ifdef SET32_IMPLEMENTATION
SET32_API
int
set32_z(uint32_t n)
{
int z = 0;
while (UINT32_C(1) << z < n * 3 / 2)
z++;
return z;
}
SET32_API
uint32_t
set32_hash(uint32_t a)
{
a = (a ^ UINT32_C(61)) ^ (a >> 16);
a = a + (a << 3);
a = a ^ (a >> 4);
a = a * UINT32_C(0x27d4eb2d);
a = a ^ (a >> 15);
return a;
}
SET32_API
void
set32_insert(uint32_t *table, int z, uint32_t v)
{
uint32_t mask = (UINT32_C(1) << z) - 1;
uint32_t i = set32_hash(v) & mask;
while (table[i] && table[i] != v)
i = (i + 1) & mask;
if (!table[i])
table[i] = v;
}
SET32_API
void
set32_remove(uint32_t *table, int z, uint32_t v)
{
uint32_t mask = (UINT32_C(1) << z) - 1;
uint32_t i = set32_hash(v) & mask;
while (table[i] && table[i] != v)
i = (i + 1) & mask;
if (table[i]) {
table[i] = 0;
for (i = (i + 1) & mask; table[i]; i = (i + 1) & mask) {
v = table[i];
table[i] = 0;
set32_insert(table, z, v);
}
}
}
SET32_API
int
set32_contains(uint32_t *table, int z, uint32_t v)
{
uint32_t mask = (UINT32_C(1) << z) - 1;
uint32_t i = set32_hash(v) & mask;
while (table[i] && table[i] != v)
i = (i + 1) & mask;
return !!table[i];
}
#endif /* SET32_IMPLEMENTATION */
#endif /* SET32_H */
|
#include <stdio.h>
int main(void) {
int N;
scanf("%d", &N);
int rabbit = 0, rat = 0, frog = 0, total = 0;
int ammount;
while (N != 0) {
char name;
scanf("%d %c", &ammount, &name);
if (name == 'C')
rabbit += ammount;
else if (name == 'R')
rat += ammount;
else if (name == 'S')
frog += ammount;
N--;
}
total = (rabbit + rat + frog);
printf("Total: %d cobaias\n", total);
printf("Total de coelhos: %d\n", rabbit);
printf("Total de ratos: %d\n", rat);
printf("Total de sapos: %d\n", frog);
printf("Percentual de coelhos: %.2f %%\n", ((double) rabbit / total) * 100.00);
printf("Percentual de ratos: %.2f %%\n", ((double) rat / total) * 100.00);
printf("Percentual de sapos: %.2f %%\n", ((double) frog / total) * 100.00);
return 0;
} |
#ifndef CONNECTION_H
#define CONNECTION_H
#include <memory>
#include "connection_data_type.h"
namespace noises
{
class InputSocket;
class OutputSocket;
class Graph;
class Connection
{
public:
Connection(InputSocket& input, OutputSocket& output, Graph& parent_graph);
bool input_output_type_compatible() const;
const InputSocket& input() const;
const OutputSocket& output() const;
const Graph& parent_graph() const;
const ConnectionDataType& data_type() const;
int id() const;
void set_id(int id);
void disconnect();
private:
// The input is generally the *right* side of a connection
InputSocket& input_;
// The output is generally the *left* side of a connection
OutputSocket& output_;
Graph& parent_graph_;
int id_;
};
}
#endif // CONNECTION_H
|
#ifndef __Base_64_h__
#define __Base_64_h__
#include <cv.h>
#include <string>
#include <vector>
static const std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
static inline bool is_base64(unsigned char c) {
return (isalnum(c) || (c == '+') || (c == '/'));
}
std::string base64_encode(std::vector<unsigned char> buffer);
std::vector<unsigned char> base64_decode(std::string const& encoded_string);
static bool MatToBase64(cv::Mat input, std::string ext,
std::string &output, std::vector<int> params=std::vector<int>());
static bool Base64ToMat(std::string input, cv::Mat & output,
std::string &ext);
#endif |
#pragma once
#include <iostream>
#include <opencv2/opencv.hpp>
// opencv legacy includes
#include <opencv2/core/core_c.h>
#include <opencv2/imgproc/imgproc_c.h>
namespace bgslibrary
{
namespace algorithms
{
namespace vumeter
{
class TBackground
{
public:
TBackground();
virtual ~TBackground();
virtual void Clear();
virtual void Reset();
virtual int UpdateBackground(IplImage * pSource, IplImage *pBackground, IplImage *pMotionMask);
virtual int UpdateTest(IplImage *pSource, IplImage *pBackground, IplImage *pTest, int nX, int nY, int nInd);
virtual IplImage *CreateTestImg();
virtual int GetParameterCount();
virtual std::string GetParameterName(int nInd);
virtual std::string GetParameterValue(int nInd);
virtual int SetParameterValue(int nInd, std::string csNew);
protected:
virtual int Init(IplImage * pSource);
virtual bool isInitOk(IplImage * pSource, IplImage *pBackground, IplImage *pMotionMask);
};
}
}
}
|
/* Generated by RuntimeBrowser
Image: /System/Library/Frameworks/SecurityInterface.framework/Versions/A/SecurityInterface
*/
@interface SFTokenHIPlugin : NSObject
+ (BOOL)plugInClassIsValid:(Class)arg1;
@end
|
#ifndef M_INDEX_H
#define M_INDEX_H
#include <QWidget>
#include <QMessageBox>
#include <mongoc/mongoc.h>
#include <QtDebug>
#include "kc_utility.h"
#include "m_append.h"
namespace Ui {
class M_index;
}
class M_index : public QWidget
{
Q_OBJECT
public:
explicit M_index(QWidget *parent = nullptr);
~M_index();
Kc_utility ut;
void start();
void deleted(QString); //刪除指定紀錄
signals:
void updated_detected(const QString&);
public slots:
void on_pushButton_append_clicked();
private slots:
void tableWidget_doubleClicked(const QModelIndex &index);//偵測表格雙擊
void on_pushButton_delete_clicked();
private:
Ui::M_index *ui;
QMessageBox msgBox;
int denominators;//判別資料數,計算分母總數
int progresiveStep=0;//進度條分子累進數
};
#endif // M_INDEX_H
|
#import <UIKit/UIKit.h>
FOUNDATION_EXPORT double DKChainableAnimationKitVersionNumber;
FOUNDATION_EXPORT const unsigned char DKChainableAnimationKitVersionString[];
|
#include <windows.h>
#include <stdbool.h>
#include <stdint.h>
#include "bemanitools/jbio.h"
#include "jbhook1/p3io.h"
#include "p3ioemu/emu.h"
#include "p3ioemu/uart.h"
#include "security/rp-sign-key.h"
#include "security/rp3.h"
#include "util/log.h"
static HRESULT jbhook1_p3io_read_jamma(void *ctx, uint32_t *state);
static HRESULT jbhook1_p3io_get_roundplug(
void *ctx, uint8_t plug_id, uint8_t *rom, uint8_t *eeprom);
/*
0:0 b13
0:1 -
0:2 b15
0:3 -
0:4 test
0:5 coin
0:6 service
0:7 -
1:0 -
1:1 b4
1:2 b8
1:3 b12
1:4 b16
1:5 b3
1:6 b7
1:7 b11
2:0 -
2:1 b2
2:2 b6
2:3 b10
2:4 b14
2:5 b1
2:6 b5
2:7 b9
3:0 -
3:1 -
3:2 -
3:3 -
3:4 -
3:5 -
3:6 -
3:7 -
*/
static const uint32_t jbhook1_p3io_panel_mappings[] = {
(1 << 21),
(1 << 17),
(1 << 13),
(1 << 9),
(1 << 22),
(1 << 18),
(1 << 14),
(1 << 10),
(1 << 23),
(1 << 19),
(1 << 15),
(1 << 11),
(1 << 0),
(1 << 20),
(1 << 2),
(1 << 12),
};
static const uint32_t jbhook1_p3io_sys_button_mappings[] = {
(1 << 4),
(1 << 6),
(1 << 5),
};
static struct security_mcode jbhook1_p3io_mcode;
static struct security_id jbhook1_p3io_pcbid;
static struct security_id jbhook1_p3io_eamid;
static const struct p3io_ops p3io_ddr_ops = {
.read_jamma = jbhook1_p3io_read_jamma,
.get_roundplug = jbhook1_p3io_get_roundplug,
};
void jbhook1_p3io_init(
const struct security_mcode *mcode,
const struct security_id *pcbid,
const struct security_id *eamid)
{
memcpy(&jbhook1_p3io_mcode, mcode, sizeof(struct security_mcode));
memcpy(&jbhook1_p3io_pcbid, pcbid, sizeof(struct security_id));
memcpy(&jbhook1_p3io_eamid, eamid, sizeof(struct security_id));
p3io_emu_init(&p3io_ddr_ops, NULL);
}
void jbhook1_p3io_finit(void)
{
p3io_emu_fini();
}
static HRESULT jbhook1_p3io_read_jamma(void *ctx, uint32_t *state)
{
uint16_t panels;
uint8_t buttons;
log_assert(state != NULL);
/* lower three bytes low active, highest byte high active */
*state = 0;
if (!jb_io_read_inputs()) {
log_warning("Reading inputs from jbio failed");
return E_FAIL;
}
panels = jb_io_get_panel_inputs();
buttons = jb_io_get_sys_inputs();
for (uint8_t i = 0; i < 16; i++) {
if (panels & (1 << i)) {
*state |= jbhook1_p3io_panel_mappings[i];
}
}
for (uint8_t i = 0; i < 2; i++) {
if (buttons & (1 << i)) {
*state |= jbhook1_p3io_sys_button_mappings[i];
}
}
return S_OK;
}
static HRESULT jbhook1_p3io_get_roundplug(
void *ctx, uint8_t plug_id, uint8_t *rom, uint8_t *eeprom)
{
struct security_rp3_eeprom eeprom_out;
if (plug_id == 0) {
/* black */
memcpy(rom, jbhook1_p3io_pcbid.id, sizeof(jbhook1_p3io_pcbid.id));
security_rp3_generate_signed_eeprom_data(
SECURITY_RP_UTIL_RP_TYPE_BLACK,
&security_rp_sign_key_black_gfdmv4,
&jbhook1_p3io_mcode,
&jbhook1_p3io_pcbid,
&eeprom_out);
} else {
/* white */
memcpy(rom, jbhook1_p3io_eamid.id, sizeof(jbhook1_p3io_eamid.id));
security_rp3_generate_signed_eeprom_data(
SECURITY_RP_UTIL_RP_TYPE_WHITE,
&security_rp_sign_key_white_eamuse,
&security_mcode_eamuse,
&jbhook1_p3io_eamid,
&eeprom_out);
}
memcpy(eeprom, &eeprom_out, sizeof(struct security_rp3_eeprom));
return S_OK;
}
|
/*
Copyright 2014 Cluster Reply s.r.l.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by IntermediateBootstrapper.rc
//
#define IDR_SIZE 64000
#define IDR_MAINCONFIG 64001
#define IDR_TRANSLATIONS 64002
#define IDR_TRANSLATION_OVERRIDES 64003
#define IDI_SETUP 64004
#define IDR_FILECONFIG 64005
#define IDR_PROVIDERCONFIG 64006
#define IDR_INSTALLATIONID 64007
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 103
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1001
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif
|
/*
* Copyright (C) 2014 Martin Willi
* Copyright (C) 2014 revosec AG
*
* 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. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* 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.
*/
/**
* @defgroup winhttp_fetcher winhttp_fetcher
* @{ @ingroup winhttp_p
*/
#ifndef WINHTTP_FETCHER_H_
#define WINHTTP_FETCHER_H_
#include <library.h>
typedef struct winhttp_fetcher_t winhttp_fetcher_t;
/**
* Fetcher implementation using Microsofts WinHTTP.
*/
struct winhttp_fetcher_t {
/**
* Implements fetcher interface.
*/
fetcher_t interface;
};
/**
* Create a winhttp_fetcher instance
*
* @return WinHTTP based fetcher
*/
winhttp_fetcher_t *winhttp_fetcher_create();
#endif /** WINHTTP_FETCHER_H_ @}*/
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* emplace.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ourgot <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/03/10 06:49:27 by ourgot #+# #+# */
/* Updated: 2020/03/10 10:28:33 by ourgot ### ########.fr */
/* */
/* ************************************************************************** */
#include "vectorobj.h"
/*
** TODO make it applicable for any collection
*/
void *emplace(t_obj *vect, t_f2s_r f, const void *arg)
{
void *dst;
long n;
n = vect->meta->size;
vector_resize(vect, n + 1);
dst = vector_getitem(vect, n);
(*f)(arg, dst);
return (dst);
}
|
#error RandomP8.h is an obsolete header, should not be used anymore
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.