static uint16_t
ptp_ptpip_init_event_request(PTPParams *params)
{
unsigned char evtrequest[ptpip_eventinit_size];
ssize_t ret;
htod32a(&evtrequest[ptpip_type],PTPIP_INIT_EVENT_REQUEST);
htod32a(&evtrequest[ptpip_len],ptpip_eventinit_size);
htod32a(&evtrequest[ptpip_eventinit_idx],params->eventpipeid);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/init_event recieved\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(evtrequest, ptpip_eventinit_size, 16);
}
ret = write(params->evtfd, evtrequest, ptpip_eventinit_size);
if (ret == -1)
{
perror("write init evt request");
return PTP_RC_GeneralError;
}
if (ret != ptpip_eventinit_size)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip: unexpected retsize %zd, expected %d\n", ret, ptpip_eventinit_size);
return PTP_RC_GeneralError;
}
return PTP_RC_OK;
}
static int VitaMTP_Sock_Write_All(int sockfd, const unsigned char *data, size_t len, const struct sockaddr *dest_addr,
socklen_t addrlen)
{
while (1)
{
ssize_t clen;
if ((clen = sendto(sockfd, data, len, 0, dest_addr, addrlen)) == len)
{
break;
}
if (clen < 0)
{
return -1;
}
data += clen;
len -= clen;
}
VitaMTP_Log(VitaMTP_DEBUG, "Sent %d bytes to socket %d\n", (unsigned int)len, sockfd);
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(data, (unsigned int)len, 16);
}
return 0;
}
/* send / receive functions */
uint16_t
ptp_ptpip_sendreq(PTPParams *params, PTPContainer *req)
{
ssize_t ret;
uint32_t len = 18+req->Nparam*4;
unsigned char *request = malloc(len);
//ptp_ptpip_check_event (params);
htod32a(&request[ptpip_type],PTPIP_CMD_REQUEST);
htod32a(&request[ptpip_len],len);
htod32a(&request[ptpip_cmd_dataphase],1); /* FIXME: dataphase handling */
htod16a(&request[ptpip_cmd_code],req->Code);
htod32a(&request[ptpip_cmd_transid],req->Transaction_ID);
switch (req->Nparam)
{
case 5:
htod32a(&request[ptpip_cmd_param5],req->Param5);
case 4:
htod32a(&request[ptpip_cmd_param4],req->Param4);
case 3:
htod32a(&request[ptpip_cmd_param3],req->Param3);
case 2:
htod32a(&request[ptpip_cmd_param2],req->Param2);
case 1:
htod32a(&request[ptpip_cmd_param1],req->Param1);
case 0:
default:
break;
}
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/oprequest\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(request, len, 16);
}
ret = write(params->cmdfd, request, len);
free(request);
if (ret == -1)
perror("sendreq/write to cmdfd");
if (ret != len)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip: ptp_ptpip_sendreq() len =%d but ret=%zd\n", len, ret);
return PTP_RC_OK;
}
return PTP_RC_OK;
}
/* Parse command options */
static int parse(int c, char **argv, int invert, unsigned int *flags,
const struct ipt_entry *entry,
struct ipt_entry_target **target)
{
struct ipt_nldata *nld=(struct ipt_nldata *)(*target)->data;
switch (c) {
case 'd':
if (MASK(*flags, USE_DROP))
exit_error(PARAMETER_PROBLEM,
"Can't specify --nldrop twice");
if ( check_inverse(optarg, &invert, NULL, 0) ) {
MASK_UNSET(nld->flags, USE_DROP);
} else {
MASK_SET(nld->flags, USE_DROP);
}
MASK_SET(*flags, USE_DROP);
break;
case 'm':
if (MASK(*flags, USE_MARK))
exit_error(PARAMETER_PROBLEM,
"Can't specify --nlmark twice");
if (check_inverse(optarg, &invert, NULL, 0)) {
MASK_UNSET(nld->flags, USE_MARK);
}else{
MASK_SET(nld->flags, USE_MARK);
nld->mark=atoi(optarg);
}
MASK_SET(*flags, USE_MARK);
break;
case 's':
if (MASK(*flags, USE_SIZE))
exit_error(PARAMETER_PROBLEM,
"Can't specify --nlsize twice");
if ( atoi(optarg) <= 0 )
exit_error(PARAMETER_PROBLEM,
"--nlsize must be larger than zero");
if (check_inverse(optarg, &invert, NULL, 0)) {
MASK_UNSET(nld->flags, USE_SIZE);
}else{
MASK_SET(nld->flags, USE_SIZE);
nld->size=atoi(optarg);
}
MASK_SET(*flags, USE_SIZE);
break;
default:
return 0;
}
return 1;
}
/* Make CS case-insensitive. */
ScmObj Scm_CharSetCaseFold(ScmCharSet *cs)
{
for (int ch='a'; ch<='z'; ch++) {
if (MASK_ISSET(cs, ch) || MASK_ISSET(cs, (ch-('a'-'A')))) {
MASK_SET(cs, ch);
MASK_SET(cs, (ch-('a'-'A')));
}
}
ScmTreeIter iter;
ScmDictEntry *e;
Scm_TreeIterInit(&iter, &cs->large, NULL);
while ((e = Scm_TreeIterNext(&iter)) != NULL) {
for (ScmChar c = e->key; c <= e->value; c++) {
ScmChar uch = Scm_CharUpcase(c);
ScmChar lch = Scm_CharDowncase(c);
Scm_CharSetAddRange(cs, uch, uch);
Scm_CharSetAddRange(cs, lch, lch);
}
}
return SCM_OBJ(cs);
}
void initKeyboard(void)
{
INITIALIZE_CHECKING();
// Port to in with pull-up
MASK_CLEAR(KBD_DDR, KBD_MASK);
MASK_SET(KBD_PORT, KBD_MASK);
for (uint08 i = 0; i < KBD_KEYS_NUMBER; ++i)
{
m_keys[i] = KBD_KEY_EMPTY;
m_handlers[i] = &idleTask;
}
m_handlersCnt = 0;
setTimerTaskMS(&kbdTimerTask, 0, KBD_TIMER_TASK_PERIOD);
}
static int VitaMTP_Sock_Read_All(int sockfd, unsigned char **p_data, size_t *p_len, struct sockaddr *src_addr,
socklen_t *addrlen)
{
unsigned char buffer[REQUEST_BUFFER_SIZE];
unsigned char *data = NULL;
ssize_t len = 0;
while (1)
{
ssize_t clen;
if ((clen = recvfrom(sockfd, buffer, REQUEST_BUFFER_SIZE, len > 0 ? MSG_DONTWAIT : 0, src_addr, addrlen)) < 0)
{
if (errno == EWOULDBLOCK)
{
break;
}
VitaMTP_Log(VitaMTP_ERROR, "error recieving data\n");
free(data);
return -1;
}
if (clen == 0)
{
break;
}
VitaMTP_Log(VitaMTP_DEBUG, "Recieved %d bytes from socket %d\n", (unsigned int)clen, sockfd);
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(buffer, (unsigned int)clen, 16);
}
data = realloc(data, len+clen);
memcpy(data+len, buffer, clen);
len += clen;
}
*p_data = data;
*p_len = len;
return 0;
}
static uint16_t
ptp_ptpip_init_command_request(PTPParams *params)
{
unsigned char *cmdrequest;
unsigned int len;
ssize_t ret;
unsigned char guid[16] = {0};
// TODO: See if GUID is required
len = ptpip_initcmd_name;
cmdrequest = malloc(len);
htod32a(&cmdrequest[ptpip_type],PTPIP_INIT_COMMAND_REQUEST);
htod32a(&cmdrequest[ptpip_len],len);
memcpy(&cmdrequest[ptpip_initcmd_guid], guid, 16);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/init_cmd recieved\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(cmdrequest, len, 16);
}
ret = write(params->cmdfd, cmdrequest, len);
free(cmdrequest);
if (ret == -1)
{
perror("write init cmd request");
return PTP_RC_GeneralError;
}
VitaMTP_Log(VitaMTP_ERROR, "ptpip/init_cmd: return %zd / len %d\n", ret, len);
if (ret != len)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip: return %zd vs len %d\n", ret, len);
return PTP_RC_GeneralError;
}
return PTP_RC_OK;
}
int main(int argc, char *argv[])
{
int c;
int errflg = 0;
int quietflg = 0;
int i;
char **itype;
int mask_first = 1;
int sample_rate = -1;
unsigned int overlap = 0;
char *input_type = "hw";
while ((c = getopt(argc, argv, "t:a:s:v:b:f:g:d:o:cqhAmrxynipeu")) != EOF) {
switch (c) {
case 'h':
case '?':
errflg++;
break;
case 'q':
quietflg++;
break;
case 'A':
aprs_mode = 1;
memset(dem_mask, 0, sizeof(dem_mask));
mask_first = 0;
for (i = 0; (unsigned int) i < NUMDEMOD; i++)
if (!strcasecmp("AFSK1200", dem[i]->name)) {
MASK_SET(i);
break;
}
break;
case 'v':
verbose_level = strtoul(optarg, 0, 0);
break;
case 'b':
pocsag_error_correction = strtoul(optarg, 0, 0);
if(pocsag_error_correction > 2 || pocsag_error_correction < 0)
{
fprintf(stderr, "Invalid error correction value!\n");
pocsag_error_correction = 2;
}
break;
case'p':
pocsag_show_partial_decodes = 1;
break;
case'u':
pocsag_heuristic_pruning = 1;
break;
case'e':
pocsag_prune_empty = 1;
break;
case 'm':
mute_sox = 1;
break;
case 'r':
repeatable_sox = 1;
break;
case 't':
for (itype = (char **)allowed_types; *itype; itype++)
if (!strcmp(*itype, optarg)) {
input_type = *itype;
goto intypefound;
}
fprintf(stderr, "invalid input type \"%s\"\n"
"allowed types: ", optarg);
for (itype = (char **)allowed_types; *itype; itype++)
fprintf(stderr, "%s ", *itype);
fprintf(stderr, "\n");
errflg++;
intypefound:
break;
case 'a':
if (mask_first)
memset(dem_mask, 0, sizeof(dem_mask));
mask_first = 0;
for (i = 0; (unsigned int) i < NUMDEMOD; i++)
if (!strcasecmp(optarg, dem[i]->name)) {
MASK_SET(i);
break;
}
if ((unsigned int) i >= NUMDEMOD) {
fprintf(stderr, "invalid mode \"%s\"\n", optarg);
errflg++;
}
break;
case 's':
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
mask_first = 0;
for (i = 0; (unsigned int) i < NUMDEMOD; i++)
if (!strcasecmp(optarg, dem[i]->name)) {
MASK_RESET(i);
break;
}
if ((unsigned int) i >= NUMDEMOD) {
fprintf(stderr, "invalid mode \"%s\"\n", optarg);
errflg++;
}
break;
case 'c':
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
mask_first = 0;
for (i = 0; (unsigned int) i < NUMDEMOD; i++)
MASK_RESET(i);
break;
case 'f':
if(!pocsag_mode)
{
if(!strncmp("numeric",optarg, sizeof("numeric")))
pocsag_mode = POCSAG_MODE_NUMERIC;
else if(!strncmp("alpha",optarg, sizeof("alpha")))
pocsag_mode = POCSAG_MODE_ALPHA;
else if(!strncmp("skyper",optarg, sizeof("skyper")))
pocsag_mode = POCSAG_MODE_SKYPER;
}else fprintf(stderr, "a POCSAG mode has already been selected!\n");
break;
case 'n':
dont_flush = true;
break;
case 'i':
pocsag_invert_input = true;
break;
case 'd':
{
int i = 0;
sscanf(optarg, "%d", &i);
if(i) cw_dit_length = abs(i);
break;
}
case 'g':
{
int i = 0;
sscanf(optarg, "%d", &i);
if(i) cw_gap_length = abs(i);
break;
}
case 'o':
{
int i = 0;
sscanf(optarg, "%d", &i);
if(i) cw_threshold = abs(i);
break;
}
case 'x':
cw_disable_auto_threshold = true;
break;
case 'y':
cw_disable_auto_timing = true;
break;
}
}
if ( !quietflg )
{ // pay heed to the quietflg
fprintf(stderr, "multimon-ng (C) 1996/1997 by Tom Sailer HB9JNX/AE4WA\n"
" (C) 2012-2014 by Elias Oenal\n"
"available demodulators:");
for (i = 0; (unsigned int) i < NUMDEMOD; i++) {
fprintf(stderr, " %s", dem[i]->name);
}
fprintf(stderr, "\n");
}
if (errflg) {
(void)fprintf(stderr, usage_str, argv[0]);
exit(2);
}
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
if (!quietflg)
fprintf(stdout, "Enabled demodulators:");
for (i = 0; (unsigned int) i < NUMDEMOD; i++)
if (MASK_ISSET(i)) {
if (!quietflg)
fprintf(stdout, " %s", dem[i]->name); //Print demod name
if(dem[i]->float_samples) integer_only = false; //Enable float samples on demand
memset(dem_st+i, 0, sizeof(dem_st[i]));
dem_st[i].dem_par = dem[i];
if (dem[i]->init)
dem[i]->init(dem_st+i);
if (sample_rate == -1)
sample_rate = dem[i]->samplerate;
else if ( (unsigned int) sample_rate != dem[i]->samplerate) {
if (!quietflg)
fprintf(stdout, "\n");
fprintf(stderr, "Error: Current sampling rate %d, "
" demodulator \"%s\" requires %d\n",
sample_rate, dem[i]->name, dem[i]->samplerate);
exit(3);
}
if (dem[i]->overlap > overlap)
overlap = dem[i]->overlap;
}
if (!quietflg)
fprintf(stdout, "\n");
if (optind < argc && !strcmp(argv[optind], "-"))
{
input_type = "raw";
}
if (!strcmp(input_type, "hw")) {
if ((argc - optind) >= 1)
input_sound(sample_rate, overlap, argv[optind]);
else
input_sound(sample_rate, overlap, NULL);
quit();
exit(0);
}
if ((argc - optind) < 1) {
(void)fprintf(stderr, "no source files specified\n");
exit(4);
}
for (i = optind; i < argc; i++)
input_file(sample_rate, overlap, argv[i], input_type);
quit();
exit(0);
}
uint16_t
ptp_ptpip_senddata(PTPParams *params, PTPContainer *ptp,
unsigned long size, PTPDataHandler *handler
)
{
unsigned char request[0x14];
ssize_t ret;
unsigned long curwrite, towrite;
unsigned char *xdata;
htod32a(&request[ptpip_type],PTPIP_START_DATA_PACKET);
htod32a(&request[ptpip_len],sizeof(request));
htod32a(&request[ptpip_startdata_transid + 8],ptp->Transaction_ID);
htod32a(&request[ptpip_startdata_totallen + 8],(uint32_t)size);
htod32a(&request[ptpip_startdata_unknown + 8],0);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/senddata\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(request, sizeof(request), 16);
}
ret = write(params->cmdfd, request, sizeof(request));
if (ret == -1)
perror("sendreq/write to cmdfd");
if (ret != sizeof(request))
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/senddata: ptp_ptpip_senddata() len=%d but ret=%zd\n", (int)sizeof(request), ret);
return PTP_RC_GeneralError;
}
xdata = malloc(WRITE_BLOCKSIZE+8+4);
if (!xdata) return PTP_RC_GeneralError;
curwrite = 0;
while (curwrite < size)
{
unsigned long type, written, towrite2, xtowrite;
//ptp_ptpip_check_event (params);
towrite = size - curwrite;
if (towrite > WRITE_BLOCKSIZE)
{
towrite = WRITE_BLOCKSIZE;
type = PTPIP_DATA_PACKET;
}
else
{
type = PTPIP_END_DATA_PACKET;
}
ret = handler->getfunc(params, handler->priv, towrite, &xdata[ptpip_data_payload+8], &xtowrite);
if (ret == -1)
{
perror("getfunc in senddata failed");
free(xdata);
return PTP_RC_GeneralError;
}
towrite2 = xtowrite + 12;
htod32a(&xdata[ptpip_type], (uint32_t)type);
htod32a(&xdata[ptpip_len], (uint32_t)towrite2);
htod32a(&xdata[ptpip_data_transid+8], ptp->Transaction_ID);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/senddata\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(xdata, (unsigned int)towrite2, 16);
}
written = 0;
while (written < towrite2)
{
ret = write(params->cmdfd, xdata+written, towrite2-written);
if (ret == -1)
{
perror("write in senddata failed");
free(xdata);
return PTP_RC_GeneralError;
}
written += ret;
}
curwrite += towrite;
}
free(xdata);
return PTP_RC_OK;
}
static uint16_t
ptp_ptpip_generic_read(PTPParams *params, int fd, PTPIPHeader *hdr, unsigned char **data)
{
ssize_t ret;
int len, curread;
unsigned char *xhdr;
xhdr = (unsigned char *)hdr;
curread = 0;
len = sizeof(PTPIPHeader);
while (curread < len)
{
ret = read(fd, xhdr + curread, len - curread);
if (ret == -1)
{
perror("read PTPIPHeader");
return PTP_RC_GeneralError;
}
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/generic_read\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(xhdr+curread, (unsigned int)ret, 16);
}
curread += ret;
if (ret == 0)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip: End of stream after reading %zd bytes of ptpipheader\n", ret);
return PTP_RC_GeneralError;
}
}
len = dtoh32(hdr->length) - sizeof(PTPIPHeader);
if (len < 0)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/generic_read: len < 0, %d?\n", len);
return PTP_RC_GeneralError;
}
*data = malloc(len);
if (!*data)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/generic_read: malloc failed.\n");
return PTP_RC_GeneralError;
}
curread = 0;
while (curread < len)
{
ret = read(fd, (*data)+curread, len-curread);
if (ret == -1)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/generic_read: error %d in reading PTPIP data\n", errno);
free(*data);
*data = NULL;
return PTP_RC_GeneralError;
}
else
{
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/generic_read\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(((*data)+curread), (unsigned int)ret, 16);
}
}
if (ret == 0)
break;
curread += ret;
}
if (curread != len)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/generic_read: read PTPIP data, ret %zd vs len %d\n", ret, len);
free(*data);
*data = NULL;
return PTP_RC_GeneralError;
}
return PTP_RC_OK;
}
int main(int argc, char *argv[])
{
int c;
int errflg = 0;
int i;
char **itype;
int mask_first = 1;
int sample_rate = -1;
unsigned int overlap = 0;
char *input_type = "hw";
fprintf(stdout, "multimod (C) 1996/1997 by Tom Sailer HB9JNX/AE4WA\n"
"available demodulators:");
for (i = 0; i < NUMDEMOD; i++)
fprintf(stdout, " %s", dem[i]->name);
fprintf(stdout, "\n");
while ((c = getopt(argc, argv, "t:a:s:v:")) != EOF) {
switch (c) {
case '?':
errflg++;
break;
case 'v':
multimon_debug_level = strtoul(optarg, 0, 0);
break;
case 't':
for (itype = (char **)allowed_types; *itype; itype++)
if (!strcmp(*itype, optarg)) {
input_type = *itype;
goto intypefound;
}
fprintf(stderr, "invalid input type \"%s\"\n"
"allowed types: ", optarg);
for (itype = (char **)allowed_types; *itype; itype++)
fprintf(stderr, "%s ", *itype);
fprintf(stderr, "\n");
errflg++;
intypefound:
break;
case 'a':
if (mask_first)
memset(dem_mask, 0, sizeof(dem_mask));
mask_first = 0;
for (i = 0; i < NUMDEMOD; i++)
if (!strcasecmp(optarg, dem[i]->name)) {
MASK_SET(i);
break;
}
if (i >= NUMDEMOD) {
fprintf(stderr, "invalid mode \"%s\"\n", optarg);
errflg++;
}
break;
case 's':
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
mask_first = 0;
for (i = 0; i < NUMDEMOD; i++)
if (!strcasecmp(optarg, dem[i]->name)) {
MASK_RESET(i);
break;
}
if (i >= NUMDEMOD) {
fprintf(stderr, "invalid mode \"%s\"\n", optarg);
errflg++;
}
break;
}
}
if (errflg) {
(void)fprintf(stderr, usage_str);
exit(2);
}
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
fprintf(stdout, "Enabled demodulators:");
for (i = 0; i < NUMDEMOD; i++)
if (MASK_ISSET(i)) {
fprintf(stdout, " %s", dem[i]->name);
memset(dem_st+i, 0, sizeof(dem_st[i]));
dem_st[i].dem_par = dem[i];
if (dem[i]->init)
dem[i]->init(dem_st+i, print_data, NULL);
if (sample_rate == -1)
sample_rate = dem[i]->samplerate;
else if (sample_rate != dem[i]->samplerate) {
fprintf(stdout, "\n");
fprintf(stderr, "Error: Current sampling rate %d, "
" demodulator \"%s\" requires %d\n",
sample_rate, dem[i]->name, dem[i]->samplerate);
exit(3);
}
if (dem[i]->overlap > overlap)
overlap = dem[i]->overlap;
}
fprintf(stdout, "\n");
if (!strcmp(input_type, "hw")) {
if ((argc - optind) >= 1)
input_sound(sample_rate, overlap, argv[optind]);
else
input_sound(sample_rate, overlap, NULL);
exit(0);
}
if ((argc - optind) < 1) {
(void)fprintf(stderr, "no source files specified\n");
exit(4);
}
for (i = optind; i < argc; i++)
input_file(sample_rate, overlap, argv[i], input_type);
exit(0);
}
fapi2::ReturnCode
p9_hcd_core_stopclocks(
const fapi2::Target<fapi2::TARGET_TYPE_CORE>& i_target,
const bool i_sync_stop_quad_clk)
{
FAPI_INF(">>p9_hcd_core_stopclocks");
fapi2::ReturnCode l_rc;
fapi2::buffer<uint64_t> l_ccsr;
fapi2::buffer<uint64_t> l_data64;
fapi2::buffer<uint64_t> l_temp64;
uint32_t l_loops1ms;
uint8_t l_attr_chip_unit_pos;
uint8_t l_attr_vdm_enabled;
uint8_t l_attr_sdisn_setup;
const fapi2::Target<fapi2::TARGET_TYPE_SYSTEM> l_sys;
auto l_quad = i_target.getParent<fapi2::TARGET_TYPE_EQ>();
auto l_perv = i_target.getParent<fapi2::TARGET_TYPE_PERV>();
auto l_chip = i_target.getParent<fapi2::TARGET_TYPE_PROC_CHIP>();
auto l_ex_vector = l_quad.getChildren<fapi2::TARGET_TYPE_EX>
(fapi2::TARGET_STATE_FUNCTIONAL);
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_EC_FEATURE_SDISN_SETUP, l_chip,
l_attr_sdisn_setup));
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_ENABLED, l_chip,
l_attr_vdm_enabled));
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS, l_perv,
l_attr_chip_unit_pos));
l_attr_chip_unit_pos = (l_attr_chip_unit_pos -
p9hcd::PERV_TO_CORE_POS_OFFSET) % 4;
//Check if EQ is powered off; if so, return
FAPI_TRY(fapi2::getScom(l_quad, EQ_PPM_PFSNS, l_data64),
"Error reading data from EQ_PPM_PFSNS");
if (l_data64.getBit<EQ_PPM_PFSNS_VDD_PFETS_DISABLED_SENSE>())
{
FAPI_DBG("Set core as stopped in STOP history register");
FAPI_TRY(putScom(i_target, C_PPM_SSHSRC, BIT64(0)));
return fapi2::current_err;
}
//Check if core is powered off; if so, return
FAPI_TRY(fapi2::getScom(i_target, C_PPM_PFSNS, l_data64),
"Error reading data from C_PPM_PFSNS");
if (l_data64.getBit<C_PPM_PFSNS_VDD_PFETS_DISABLED_SENSE>())
{
FAPI_DBG("Set core as stopped in STOP history register");
FAPI_TRY(putScom(i_target, C_PPM_SSHSRC, BIT64(0)));
return fapi2::current_err;
}
// ----------------------------
// Prepare to stop core clocks
// ----------------------------
FAPI_DBG("Check PM_RESET_STATE_INDICATOR via GPMMR[15]");
FAPI_TRY(getScom(i_target, C_PPM_GPMMR_SCOM, l_data64));
if (!l_data64.getBit<15>())
{
FAPI_DBG("Gracefully turn off power management, continue anyways if fail");
/// @todo RTC158181 suspend_pm()
}
FAPI_DBG("Check core clock controller status");
l_rc = p9_common_clk_ctrl_state<fapi2::TARGET_TYPE_CORE>(i_target);
if (l_rc)
{
FAPI_INF("Clock controller of this core chiplet is inaccessible, return");
goto fapi_try_exit;
}
FAPI_DBG("Check cache clock controller status");
l_rc = p9_common_clk_ctrl_state<fapi2::TARGET_TYPE_EQ>(l_quad);
if (l_rc)
{
FAPI_INF("WARNING: core is enabled while cache is not, continue anyways");
}
else
{
FAPI_DBG("Check PERV clock status for access to CME via CLOCK_STAT[4]");
FAPI_TRY(getScom(l_quad, EQ_CLOCK_STAT_SL, l_data64));
FAPI_DBG("Check PERV fence status for access to CME via CPLT_CTRL1[4]");
FAPI_TRY(getScom(l_quad, EQ_CPLT_CTRL1, l_temp64));
if (l_data64.getBit<4>() == 0 && l_temp64.getBit<4>() == 0)
{
#ifdef DD2
FAPI_DBG("Halting the PGPE ...");
l_rc = ppe_halt(l_chip, PGPE_BASE_ADDRESS);
FAPI_ASSERT_NOEXIT(!l_rc,
fapi2::CORE_STOPCLKS_PGPE_HALT_TIMEOUT()
.set_CHIP(l_chip),
"PSTATE GPE Halt timeout");
FAPI_DBG("Halting the SGPE ...");
l_rc = ppe_halt(l_chip, SGPE_BASE_ADDRESS);
FAPI_ASSERT_NOEXIT(!l_rc,
fapi2::CORE_STOPCLKS_SGPE_HALT_TIMEOUT()
.set_CHIP(l_chip),
"STOP GPE Halt timeout");
FAPI_DBG("Clear the atomic lock on EQ %d", l_attr_chip_unit_pos);
l_rc = p9_clear_atomic_lock(l_quad);
FAPI_ASSERT_NOEXIT(!l_rc,
fapi2::CORE_STOPCLKS_ATOMIC_LOCK_FAIL()
.set_EQ(l_quad),
"EQ Atomic Halt timeout");
for ( auto& ex : l_ex_vector )
{
fapi2::ATTR_CHIP_UNIT_POS_Type l_cme_id = 0;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS, ex, l_cme_id));
FAPI_DBG("Halting CME %d", l_cme_id );
uint64_t l_cme_base_address = getCmeBaseAddress (l_cme_id);
l_rc = ppe_halt(l_chip, l_cme_base_address);
FAPI_ASSERT_NOEXIT(!l_rc,
fapi2::CACHE_STOPCLKS_CME_HALT_TIMEOUT()
.set_EX(ex),
"CME Halt timeout");
}
#endif
//if a core is only in special wakeup and asserting pm_exit,
//then setting 6,7 of SICR will cause pm_exit to drop and
//the core will re-enter a power saving state
FAPI_DBG("Prevent Core-L2 Quiesce from removing PM_EXIT CME_SCOM_LMCR[22]");
FAPI_TRY(putScom(l_quad,
(l_attr_chip_unit_pos < 2) ?
EX_0_CME_SCOM_LMCR_OR : EX_1_CME_SCOM_LMCR_OR,
(BIT64(22))));
FAPI_DBG("Assert Core-L2/CC Quiesces via CME_SCOM_SICR[6,8]/[7,9]");
FAPI_TRY(putScom(l_quad,
(l_attr_chip_unit_pos < 2) ?
EX_0_CME_SCOM_SICR_OR : EX_1_CME_SCOM_SICR_OR,
(BIT64(6 + (l_attr_chip_unit_pos % 2)) |
BIT64(8 + (l_attr_chip_unit_pos % 2)))));
}
}
FAPI_DBG("Assert pm_mux_disable to get PCB Mux from CME via SLAVE_CONFIG[7]");
FAPI_TRY(getScom(i_target, C_SLAVE_CONFIG_REG, l_data64));
FAPI_TRY(putScom(i_target, C_SLAVE_CONFIG_REG, DATA_SET(7)));
FAPI_DBG("Override possible PPM write protection to CME via CPPM_CPMMR[1]");
FAPI_TRY(putScom(i_target, C_CPPM_CPMMR_OR, MASK_SET(1)));
FAPI_DBG("Assert chiplet fence via NET_CTRL0[18]");
FAPI_TRY(putScom(i_target, C_NET_CTRL0_WOR, MASK_SET(18)));
// -------------------------------
// Stop core clocks
// -------------------------------
FAPI_DBG("Clear all SCAN_REGION_TYPE bits");
FAPI_TRY(putScom(i_target, C_SCAN_REGION_TYPE, MASK_ZERO));
if(i_sync_stop_quad_clk)
{
FAPI_DBG("Stop core clocks(all but pll) via CLK_REGION in SLAVE mode");
l_data64 = (p9hcd::CLK_STOP_CMD_SLAVE |
p9hcd::CLK_REGION_ALL_BUT_PLL |
p9hcd::CLK_THOLD_ALL);
FAPI_TRY(putScom(i_target, C_CLK_REGION, l_data64));
}
else
{
FAPI_DBG("Stop core clocks(all but pll) via CLK_REGION");
l_data64 = (p9hcd::CLK_STOP_CMD |
p9hcd::CLK_REGION_ALL_BUT_PLL |
p9hcd::CLK_THOLD_ALL);
FAPI_TRY(putScom(i_target, C_CLK_REGION, l_data64));
FAPI_DBG("Poll for core clocks stopped via CPLT_STAT0[8]");
l_loops1ms = 1E6 / CORE_CLK_STOP_POLLING_HW_NS_DELAY;
do
{
fapi2::delay(CORE_CLK_STOP_POLLING_HW_NS_DELAY,
CORE_CLK_STOP_POLLING_SIM_CYCLE_DELAY);
FAPI_TRY(getScom(i_target, C_CPLT_STAT0, l_data64));
}
while((l_data64.getBit<8>() != 1) && ((--l_loops1ms) != 0));
FAPI_ASSERT((l_loops1ms != 0),
fapi2::PMPROC_CORECLKSTOP_TIMEOUT().set_CORECPLTSTAT(l_data64),
"Core Clock Stop Timeout");
FAPI_DBG("Check core clocks stopped via CLOCK_STAT_SL[4-13]");
FAPI_TRY(getScom(i_target, C_CLOCK_STAT_SL, l_data64));
FAPI_ASSERT((((~l_data64) & p9hcd::CLK_REGION_ALL_BUT_PLL) == 0),
fapi2::PMPROC_CORECLKSTOP_FAILED().set_CORECLKSTAT(l_data64),
"Core Clock Stop Failed");
FAPI_DBG("Core clocks stopped now");
}
// -------------------------------
// Disable core clock sync
// -------------------------------
FAPI_DBG("Drop core clock sync enable via CPPM_CACCR[15]");
FAPI_TRY(putScom(i_target, C_CPPM_CACCR_CLEAR, MASK_SET(15)));
FAPI_DBG("Poll for core clock sync done to drop via CPPM_CACSR[13]");
l_loops1ms = 1E6 / CORE_CLK_SYNC_POLLING_HW_NS_DELAY;
do
{
fapi2::delay(CORE_CLK_SYNC_POLLING_HW_NS_DELAY,
CORE_CLK_SYNC_POLLING_SIM_CYCLE_DELAY);
FAPI_TRY(getScom(i_target, C_CPPM_CACSR, l_data64));
}
while((l_data64.getBit<13>() == 1) && ((--l_loops1ms) != 0));
FAPI_ASSERT((l_loops1ms != 0),
fapi2::PMPROC_CORECLKSYNCDROP_TIMEOUT().set_COREPPMCACSR(l_data64),
"Core Clock Sync Drop Timeout");
FAPI_DBG("Core clock sync done dropped");
// -------------------------------
// Fence up
// -------------------------------
FAPI_DBG("Assert skew sense to skew adjust fence via NET_CTRL0[22]");
FAPI_TRY(putScom(i_target, C_NET_CTRL0_WOR, MASK_SET(22)));
FAPI_DBG("Drop ABIST_SRAM_MODE_DC to support ABIST Recovery via BIST[1]");
FAPI_TRY(getScom(i_target, C_BIST, l_data64));
FAPI_TRY(putScom(i_target, C_BIST, DATA_UNSET(1)));
FAPI_DBG("Assert vital fence via CPLT_CTRL1[3]");
FAPI_TRY(putScom(i_target, C_CPLT_CTRL1_OR, MASK_SET(3)));
FAPI_DBG("Assert regional fences via CPLT_CTRL1[4-14]");
FAPI_TRY(putScom(i_target, C_CPLT_CTRL1_OR, p9hcd::CLK_REGION_ALL));
if (l_attr_sdisn_setup)
{
FAPI_DBG("DD1 Only: Drop sdis_n(flushing LCBES condition) vai CPLT_CONF0[34]");
FAPI_TRY(putScom(i_target, C_CPLT_CONF0_CLEAR, MASK_SET(34)));
}
// -------------------------------
// Disable VDM
// -------------------------------
if (l_attr_vdm_enabled == fapi2::ENUM_ATTR_VDM_ENABLED_TRUE)
{
FAPI_DBG("Set VDM Disable via CPPM_VDMCR[1]");
FAPI_TRY(putScom(i_target, C_PPM_VDMCR_OR, MASK_SET(1)));
FAPI_DBG("Drop VDM Poweron via CPPM_VDMCR[0]");
FAPI_TRY(putScom(i_target, C_PPM_VDMCR_CLEAR, MASK_SET(0)));
}
// -------------------------------
// Update stop history
// -------------------------------
FAPI_DBG("Set core as stopped in STOP history register");
FAPI_TRY(putScom(i_target, C_PPM_SSHSRC, BIT64(0)));
// -------------------------------
// Clean up
// -------------------------------
FAPI_DBG("Return possible PPM write protection to CME via CPPM_CPMMR[1]");
FAPI_TRY(putScom(i_target, C_CPPM_CPMMR_CLEAR, MASK_SET(1)));
FAPI_DBG("Drop pm_mux_disable to release PCB Mux via SLAVE_CONFIG[7]");
FAPI_TRY(getScom(i_target, C_SLAVE_CONFIG_REG, l_data64));
FAPI_TRY(putScom(i_target, C_SLAVE_CONFIG_REG, DATA_UNSET(7)));
fapi_try_exit:
FAPI_INF("<<p9_hcd_core_stopclocks");
return fapi2::current_err;
}
int main(int argc, char *argv[])
{
int c;
int errflg = 0;
int quietflg = 0;
int i;
char **itype;
int mask_first = 1;
int sample_rate = -1;
unsigned int overlap = 0;
char *input_type = "hw";
fprintf(stderr, "multimonNG (C) 1996/1997 by Tom Sailer HB9JNX/AE4WA\n"
" (C) 2012 by Elias Oenal\n"
"available demodulators:");
for (i = 0; i < NUMDEMOD; i++)
fprintf(stderr, " %s", dem[i]->name);
fprintf(stderr, "\n");
while ((c = getopt(argc, argv, "t:a:s:v:f:cqh")) != EOF) {
switch (c) {
case 'h':
case '?':
errflg++;
break;
case 'q':
quietflg++;
break;
case 'v':
verbose_level = strtoul(optarg, 0, 0);
break;
case 't':
for (itype = (char **)allowed_types; *itype; itype++)
if (!strcmp(*itype, optarg)) {
input_type = *itype;
goto intypefound;
}
fprintf(stderr, "invalid input type \"%s\"\n"
"allowed types: ", optarg);
for (itype = (char **)allowed_types; *itype; itype++)
fprintf(stderr, "%s ", *itype);
fprintf(stderr, "\n");
errflg++;
intypefound:
break;
case 'a':
if (mask_first)
memset(dem_mask, 0, sizeof(dem_mask));
mask_first = 0;
for (i = 0; i < NUMDEMOD; i++)
if (!strcasecmp(optarg, dem[i]->name)) {
MASK_SET(i);
break;
}
if (i >= NUMDEMOD) {
fprintf(stderr, "invalid mode \"%s\"\n", optarg);
errflg++;
}
break;
case 's':
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
mask_first = 0;
for (i = 0; i < NUMDEMOD; i++)
if (!strcasecmp(optarg, dem[i]->name)) {
MASK_RESET(i);
break;
}
if (i >= NUMDEMOD) {
fprintf(stderr, "invalid mode \"%s\"\n", optarg);
errflg++;
}
break;
case 'c':
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
mask_first = 0;
for (i = 0; i < NUMDEMOD; i++)
MASK_RESET(i);
break;
case 'f':
if(!pocsag_mode)
{
if(!strncmp("numeric",optarg, sizeof("numeric")))
pocsag_mode = POCSAG_MODE_NUMERIC;
else if(!strncmp("alpha",optarg, sizeof("alpha")))
pocsag_mode = POCSAG_MODE_ALPHA;
else if(!strncmp("skyper",optarg, sizeof("skyper")))
pocsag_mode = POCSAG_MODE_SKYPER;
}else fprintf(stderr, "a POCSAG mode has already been selected!\n");
break;
}
}
if (errflg) {
(void)fprintf(stderr, usage_str, argv[0]);
exit(2);
}
if (mask_first)
memset(dem_mask, 0xff, sizeof(dem_mask));
if (!quietflg)
fprintf(stdout, "Enabled demodulators:");
for (i = 0; i < NUMDEMOD; i++)
if (MASK_ISSET(i)) {
if (!quietflg)
fprintf(stdout, " %s", dem[i]->name);
memset(dem_st+i, 0, sizeof(dem_st[i]));
dem_st[i].dem_par = dem[i];
if (dem[i]->init)
dem[i]->init(dem_st+i);
if (sample_rate == -1)
sample_rate = dem[i]->samplerate;
else if (sample_rate != dem[i]->samplerate) {
if (!quietflg)
fprintf(stdout, "\n");
fprintf(stderr, "Error: Current sampling rate %d, "
" demodulator \"%s\" requires %d\n",
sample_rate, dem[i]->name, dem[i]->samplerate);
exit(3);
}
if (dem[i]->overlap > overlap)
overlap = dem[i]->overlap;
}
if (!quietflg)
fprintf(stdout, "\n");
if (optind < argc && !strcmp(argv[optind], "-"))
{
input_type = "raw";
}
if (!strcmp(input_type, "hw")) {
if ((argc - optind) >= 1)
input_sound(sample_rate, overlap, argv[optind]);
else
input_sound(sample_rate, overlap, NULL);
quit();
exit(0);
}
if ((argc - optind) < 1) {
(void)fprintf(stderr, "no source files specified\n");
exit(4);
}
for (i = optind; i < argc; i++)
input_file(sample_rate, overlap, argv[i], input_type);
quit();
exit(0);
}
