void FlashBoth(u8 s)
{
mail = 0;
while((mail <= 62) && (SwitchAll == s))
{
SBIT(PORTD,LEDR);
SBIT(PORTD,LEDL);
}
mail = 0;
while((mail <= 62) && (SwitchAll == s))
{
CBIT(PORTD,LEDR);
CBIT(PORTD,LEDL);
}
}
/* message from lower layer
* WARNING: We must not free msg, since it will be performed by the
* lower layer. */
int gsm411_smr_recv(struct gsm411_smr_inst *inst, int msg_type,
struct msgb *msg)
{
int i, rc;
/* find function for current state and message */
for (i = 0; i < SMRDATASLLEN; i++) {
/* state must match, MM message must match
* CP msg must match only in case of MMSMS_DATA_IND
*/
if ((msg_type == smrdatastatelist[i].type)
&& (SBIT(inst->rp_state) & smrdatastatelist[i].states))
break;
}
if (i == SMRDATASLLEN) {
LOGP(DLSMS, LOGL_NOTICE,
SMR_LOG_STR "message %u unhandled at this state "
"%s.\n", inst->id, msg_type,
smr_state_names[inst->rp_state]);
return 0;
}
LOGP(DLSMS, LOGL_INFO,
SMR_LOG_STR "message %s received in state %s\n", inst->id,
smrdatastatelist[i].name, smr_state_names[inst->rp_state]);
rc = smrdatastatelist[i].rout(inst, msg);
return rc;
}
/* message from upper layer */
int gsm411_smr_send(struct gsm411_smr_inst *inst, int msg_type,
struct msgb *msg)
{
int i, rc;
/* find function for current state and message */
for (i = 0; i < SMRDOWNSLLEN; i++) {
if ((msg_type == smrdownstatelist[i].type)
&& (SBIT(inst->rp_state) & smrdownstatelist[i].states))
break;
}
if (i == SMRDOWNSLLEN) {
LOGP(DLSMS, LOGL_NOTICE,
SMR_LOG_STR "message %u unhandled at this state "
"%s.\n", inst->id, msg_type,
smr_state_names[inst->rp_state]);
msgb_free(msg);
return 0;
}
LOGP(DLSMS, LOGL_INFO,
SMR_LOG_STR "message %s received in state %s\n", inst->id,
smrdownstatelist[i].name, smr_state_names[inst->rp_state]);
rc = smrdownstatelist[i].rout(inst, msg);
return rc;
}
/* message from lower layer
* WARNING: We must not free msg, since it will be performed by the
* lower layer. */
int gsm411_smc_recv(struct gsm411_smc_inst *inst, int msg_type,
struct msgb *msg, int cp_msg_type)
{
int i, rc;
/* find function for current state and message */
for (i = 0; i < SMCDATASLLEN; i++) {
/* state must match, MM message must match
* CP msg must match only in case of MMSMS_DATA_IND
*/
if ((msg_type == smcdatastatelist[i].type)
&& (SBIT(inst->cp_state) & smcdatastatelist[i].states)
&& (msg_type != GSM411_MMSMS_DATA_IND
|| cp_msg_type == smcdatastatelist[i].cp_type))
break;
}
if (i == SMCDATASLLEN) {
LOGP(DLSMS, LOGL_NOTICE,
SMC_LOG_STR "message 0x%x/%u unhandled at this "
"state %s.\n", inst->id, msg_type, cp_msg_type,
smc_state_names[inst->cp_state]);
if (msg_type == GSM411_MMSMS_EST_IND
|| msg_type == GSM411_MMSMS_DATA_IND) {
struct msgb *nmsg;
LOGP(DLSMS, LOGL_NOTICE,
SMC_LOG_STR "RX Unimplemented CP "
"msg_type: 0x%02x\n", inst->id, msg_type);
/* 5.3.4 enter idle */
new_cp_state(inst, GSM411_CPS_IDLE);
/* indicate error */
gsm411_tx_cp_error(inst,
GSM411_CP_CAUSE_MSGTYPE_NOTEXIST);
/* send error indication to upper layer */
nmsg = gsm411_msgb_alloc();
inst->mn_recv(inst, GSM411_MNSMS_ERROR_IND, nmsg);
msgb_free(nmsg);
/* release MM connection */
nmsg = gsm411_msgb_alloc();
return inst->mm_send(inst, GSM411_MMSMS_REL_REQ, nmsg,
0);
}
return 0;
}
LOGP(DLSMS, LOGL_INFO,
SMC_LOG_STR "message %s received in state %s\n", inst->id,
smcdatastatelist[i].name, smc_state_names[inst->cp_state]);
rc = smcdatastatelist[i].rout(inst, msg);
return rc;
}
void init_frequency_meter(frequency_measurement_callback_function frequency_measurement_complete_callback)
{
uint8_t required_gate_timer_cycles = ((F_CPU/counter_max_steps/clock_divider*FREQ_METER_GATE_OPEN_TIME) + 1);
uint8_t counter_steps = ((FREQ_METER_GATE_OPEN_TIME*F_CPU/clock_divider - 256.0*required_gate_timer_cycles + counter_max_steps + 0.5));
counter_preload = ((counter_max_steps - counter_steps));
// set T1/PC3 as input
SBIT( DDRC, DDC3) = 0;
SBIT( PORTC,PORTC3) = 0;
// set T0/PC2 as input. This is only necessary because they are connected by a wire on my board.
SBIT( DDRC, DDC2) = 0;
SBIT( PORTC,PORTC2) = 0;
// initialise everything that can be initialised but don't start the timer and counter yet
// counter1 counts the edges of the input signal
// disconnect the OC1A/OC1B and count up normally
TCCR1A = (0<<COM1A1) | (0<<COM1A0) | (0<<COM1B1) | (0<<COM1B0) | (0<<WGM11) | (1<<WGM10);
// no noise cancelling, no clock yet
TCCR1B = (0<<ICNC1) | (0<<ICES1) | (0<<WGM13) | (0<<WGM12) | (0<<CS12) | (0<<CS11) | (0<<CS10);
// no force output compare
TCCR1C = (0<<FOC1A) | (0<<FOC1B);
// timer0 measures 0.1 s. It will overflow during this period so it has to run multiple times
// running in normal mode, the pins are disconnected
TCCR0A = (0<<COM0A1)| (0<<COM0A0)| (0<<COM0B1)| (0<<COM0B0)| (0<<WGM01)| (0<<WGM00);
// no force output compare, no clock yet
TCCR0B = (0<<FOC0A) | (0<<FOC0B) | (0<<WGM02) | (1<<CS02) | (0<<CS01) | (0<<CS00);
TCNT0 = 0;//counter_preload;
// no interrupts pending yet
TIFR0 = 0xff;
// only allow overflow interrupt
TIMSK0 = (0<<OCIE0B) | (0<<OCIE0A) | (1<<TOIE0);
measurement_complete_action=frequency_measurement_complete_callback;
}
void request_frequency_measurement()
{
uint8_t sreg = SREG;
cli();
if( SBIT( TIMSK0, TOIE0 ) ) // The overflow interrupt enable bit is only set while measuring
{
measurement_requested = 1; // Start measurement once no matter how many requestes are made.
SREG = sreg;
}
else // If no measurement is going on, we can start one directly
{
SREG = sreg;
start_measurement();
}
}
void FlashLeftE(u8 s)
{
CBIT(PORTD,LEDR);
mail = 0;
while((mail <= 18) && (SwitchAll == s))
{
SBIT(PORTD,LEDL);
}
mail = 0;
while((mail <= 18) && (SwitchAll == s))
{
CBIT(PORTD,LEDL);
}
}
void FlashRightE(u8 s)
{
CBIT(PORTD,LEDL);
mail = 0;
while((mail <= 18) && (SwitchAll == s) ) /* 1 sec */
{
SBIT(PORTD,LEDR);
}
mail=0;
while((mail <= 18) && (SwitchAll == s))
{
CBIT(PORTD,LEDR);
}
}
void FlashRight(u8 s)
{
CBIT(PORTD,LEDL);
mail = 0;
while((mail <= 62) && (SwitchAll == s) )
{
SBIT(PORTD,LEDR);
}
mail=0;
while((mail <= 62) && (SwitchAll == s))
{
CBIT(PORTD,LEDR);
}
}
LOGP(DLSMS, LOGL_DEBUG,
SMR_LOG_STR "%s expired\n", inst->id, str);
gsm411_send_report(inst);
gsm411_send_abort(inst);
}
/* statefull handling for SM-RL SAP messages */
static const struct smrdownstate {
uint32_t states;
int type;
const char *name;
int (*rout) (struct gsm411_smr_inst *inst,
struct msgb *msg);
} smrdownstatelist[] = {
/* data request */
{SBIT(GSM411_RPS_IDLE),
GSM411_SM_RL_DATA_REQ,
"SM-RL-DATA_REQ", gsm411_rl_data_req},
/* report request */
{SBIT(GSM411_RPS_WAIT_TO_TX_RP_ACK),
GSM411_SM_RL_REPORT_REQ,
"SM-RL-REPORT_REQ", gsm411_rl_report_req},
};
#define SMRDOWNSLLEN \
(sizeof(smrdownstatelist) / sizeof(struct smrdownstate))
/* message from upper layer */
int gsm411_smr_send(struct gsm411_smr_inst *inst, int msg_type,
struct msgb *msg)
static void clear(){
SBIT(ADDR_PR, Line)=1;
}
static bool pending(){
return SBIT(ADDR_PR, Line);
}
static void set_falling(bool x=true){
SBIT(ADDR_FTSR, Line)=x;
}
static void set_rising(bool x=true){
SBIT(ADDR_RTSR, Line)=x;
}
uint8_t frequency_meter_is_measuring()
{
return (SBIT( TIMSK0, TOIE0 ) | measurement_requested);
}
/* Determine if immediate is within the 16-bit signed range */
static inline bool is_range16(s32 imm)
{
return !(imm >= SBIT(15) || imm < -SBIT(15));
}
inst->mm_send(inst, GSM411_MMSMS_DATA_REQ, msg, GSM411_MT_CP_ERROR);
/* release MM connection */
nmsg = gsm411_msgb_alloc();
return inst->mm_send(inst, GSM411_MMSMS_REL_REQ, nmsg, 0);
}
/* statefull handling for MNSMS SAP messages */
static struct smcdownstate {
uint32_t states;
int type;
const char *name;
int (*rout) (struct gsm411_smc_inst *inst,
struct msgb *msg);
} smcdownstatelist[] = {
/* establish request */
{SBIT(GSM411_CPS_IDLE),
GSM411_MNSMS_EST_REQ,
"MNSMS-EST-REQ", gsm411_mnsms_est_req},
/* release request */
{ALL_STATES,
GSM411_MNSMS_REL_REQ,
"MNSMS-REL-REQ", gsm411_mnsms_rel_req},
/* data request */
{SBIT(GSM411_CPS_MM_ESTABLISHED),
GSM411_MNSMS_DATA_REQ,
"MNSMS-DATA-REQ", gsm411_mnsms_data_req},
/* abort request */
{ALL_STATES - SBIT(GSM411_CPS_IDLE),
/**
* usage: t_pfs <start> <n>
*
* for example: t_pfs /x/ 100
*
* This test case performs:
* 1) create <n> files under <start>, write full file name as file content
* 2) list files under <start>, check files are all listed once
* 3) check file content aganist file name
* 4) delete files on success
*/
static int cmd_TestPopulateFiles(int argc, char *argv[])
{
const char *start = "/";
int count = 80;
int i, fd, num;
char name[128];
char buf[128];
uffs_DIR *dirp;
struct uffs_dirent *ent;
unsigned long bitmap[50] = {0}; // one bit per file, maximu 32*50 = 1600 files
UBOOL succ = U_TRUE;
#define SBIT(n) bitmap[(n)/(sizeof(bitmap[0]) * 8)] |= (1 << ((n) % (sizeof(bitmap[0]) * 8)))
#define GBIT(n) (bitmap[(n)/(sizeof(bitmap[0]) * 8)] & (1 << ((n) % (sizeof(bitmap[0]) * 8))))
if (argc > 1) {
start = argv[1];
if (argc > 2) {
count = strtol(argv[2], NULL, 10);
}
}
if (count > sizeof(bitmap) * 8)
count = sizeof(bitmap) * 8;
for (i = 0, fd = -1; i < count; i++) {
sprintf(name, "%sFile%03d", start, i);
fd = uffs_open(name, UO_RDWR|UO_CREATE|UO_TRUNC);
if (fd < 0) {
MSGLN("Create file %s failed", name);
break;
}
if (uffs_write(fd, name, strlen(name)) != strlen(name)) { // write full path name to file
MSGLN("Write to file %s failed", name);
uffs_close(fd);
break;
}
uffs_close(fd);
}
if (i < count) {
// not success, need to clean up
for (; i >= 0; i--) {
sprintf(name, "%sFile%03d", start, i);
if (uffs_remove(name) < 0)
MSGLN("Delete file %s failed", name);
}
succ = U_FALSE;
goto ext;
}
MSGLN("%d files created.", count);
// list files
dirp = uffs_opendir(start);
if (dirp == NULL) {
MSGLN("Can't open dir %s !", start);
succ = U_FALSE;
goto ext;
}
ent = uffs_readdir(dirp);
while (ent && succ) {
if (!(ent->d_type & FILE_ATTR_DIR) && // not a dir
ent->d_namelen == strlen("File000") && // check file name length
memcmp(ent->d_name, "File", strlen("File")) == 0) { // file name start with "File"
MSGLN("List entry %s", ent->d_name);
num = strtol(ent->d_name + 4, NULL, 10);
if (GBIT(num)) {
// file already listed ?
MSGLN("File %d listed twice !", ent->d_name);
succ = U_FALSE;
break;
}
SBIT(num);
// check file content
sprintf(name, "%s%s", start, ent->d_name);
fd = uffs_open(name, UO_RDONLY);
if (fd < 0) {
MSGLN("Open file %d for read failed !", name);
}
else {
memset(buf, 0, sizeof(buf));
num = uffs_read(fd, buf, sizeof(buf));
if (num != strlen(name)) {
MSGLN("%s Read data length expect %d but got %d !", name, strlen(name), num);
succ = U_FALSE;
}
else {
if (memcmp(name, buf, num) != 0) {
MSGLN("File %s have wrong content '%s' !", name, buf);
succ = U_FALSE;
}
}
uffs_close(fd);
}
}
ent = uffs_readdir(dirp);
}
uffs_closedir(dirp);
// check absent files
for (i = 0; i < count; i++) {
if (GBIT(i) == 0) {
sprintf(name, "%sFile%03d", start, i);
MSGLN("File %s not listed !", name);
succ = U_FALSE;
}
}
// delete files if pass the test
for (i = 0; succ && i < count; i++) {
sprintf(name, "%sFile%03d", start, i);
if (uffs_remove(name) < 0) {
MSGLN("Delete file %s failed", name);
succ = U_FALSE;
}
}
ext:
MSGLN("Populate files test %s !", succ ? "SUCC" : "FAILED");
return succ ? 0 : -1;
}
static void disable(){
SBIT(ADDR_IMR, Line)=0;
}
}
static void
l3_1tr6_dl_release(struct l3_process *pc, u_char pr, void *arg)
{
newl3state(pc, 0);
pc->para.cause = 0x1b; /* Destination out of order */
pc->para.loc = 0;
pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
release_l3_process(pc);
}
/* *INDENT-OFF* */
static struct stateentry downstl[] =
{
{SBIT(0),
CC_SETUP | REQUEST, l3_1tr6_setup_req},
{SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(6) | SBIT(7) | SBIT(8) |
SBIT(10),
CC_DISCONNECT | REQUEST, l3_1tr6_disconnect_req},
{SBIT(12),
CC_RELEASE | REQUEST, l3_1tr6_release_req},
{SBIT(6),
CC_IGNORE | REQUEST, l3_1tr6_reset},
{SBIT(6),
CC_REJECT | REQUEST, l3_1tr6_disconnect_req},
{SBIT(6),
CC_ALERTING | REQUEST, l3_1tr6_alert_req},
{SBIT(6) | SBIT(7),
CC_SETUP | RESPONSE, l3_1tr6_setup_rsp},
{SBIT(1),
#include "../ppc/ethermii.h"
#define DBG 1
enum {
Nrdre = 128, /* receive descriptor ring entries */
Ntdre = 128, /* transmit descriptor ring entries */
Rbsize = ETHERMAXTU+4, /* ring buffer size (+4 for CRC) */
Bufsize = Rbsize+CACHELINESZ, /* extra room for alignment */
};
enum {
/* ether-specific Rx BD bits */
RxMiss= SBIT(7),
RxeLG= SBIT(10),
RxeNO= SBIT(11),
RxeSH= SBIT(12),
RxeCR= SBIT(13),
RxeOV= SBIT(14),
RxeCL= SBIT(15),
RxError= (RxeLG|RxeNO|RxeSH|RxeCR|RxeOV|RxeCL), /* various error flags */
/* ether-specific Tx BD bits */
TxPad= SBIT(1), /* pad short frames */
TxTC= SBIT(5), /* transmit CRC */
TxeDEF= SBIT(6),
TxeHB= SBIT(7),
TxeLC= SBIT(8),
TxeRL= SBIT(9),
