void ivy_bridge_ep_memerr_misc(struct mce *m, int *channel, int *dimm)
{
u64 status = m->status;
unsigned failrank, chan;
/* Ignore unless this is an corrected extended error from an iMC bank */
if (!imc_log || m->bank < 9 || m->bank > 16 || (status & MCI_STATUS_UC) ||
!test_prefix(7, status & 0xefff))
return;
chan = EXTRACT(status, 0, 3);
if (chan == 0xf)
return;
if (EXTRACT(m->misc, 62, 62)) {
failrank = EXTRACT(m->misc, 46, 50);
dimm[0] = failrank2dimm(failrank, m->socketid, chan);
channel[0] = chan;
}
if (EXTRACT(m->misc, 63, 63)) {
failrank = EXTRACT(m->misc, 51, 55);
dimm[1] = failrank2dimm(failrank, m->socketid, chan);
channel[1] = chan;
}
}
void bdw_de_decode_model(int cputype, int bank, u64 status, u64 misc)
{
switch (bank) {
case 4:
Wprintf("PCU: ");
switch (EXTRACT(status, 0, 15) & ~(1ull << 12)) {
case 0x402: case 0x403:
Wprintf("Internal errors ");
break;
case 0x406:
Wprintf("Intel TXT errors ");
break;
case 0x407:
Wprintf("Other UBOX Internal errors ");
break;
}
if (EXTRACT(status, 16, 19) & 3)
Wprintf("PCU internal error ");
if (EXTRACT(status, 20, 23) & 4)
Wprintf("Ubox error ");
decode_bitfield(status, pcu_mc4);
break;
case 9: case 10:
Wprintf("MemCtrl: ");
decode_bitfield(status, memctrl_mc9);
break;
}
}
static void process_create_schedule(const char * string, const jsmntok_t * tokens)
{
char zs[128];
char query[2048];
char uid[16], stp_indicator[2], tsc[16];
MYSQL_RES * result0;
MYSQL_ROW row0;
stats[ScheduleCreate]++;
EXTRACT("CIF_stp_indicator", stp_indicator);
if(stp_indicator[0] == 'C') return;
EXTRACT("CIF_train_uid", uid);
EXTRACT("schedule_start_date", zs);
time_t start_date = parse_datestamp(zs);
EXTRACT("schedule_end_date", zs);
time_t end_date = parse_datestamp(zs);
EXTRACT("CIF_train_service_code", tsc);
sprintf(query, "SELECT id FROM cif_schedules WHERE CIF_stp_indicator = '%s' AND CIF_train_uid = '%s' AND schedule_start_date = %ld AND schedule_end_date = %ld AND CIF_train_service_code = '' AND update_id = %s", stp_indicator, uid, start_date, end_date, last_update_id);
if(!db_query(query))
{
result0 = db_store_result();
if((row0 = mysql_fetch_row(result0)))
{
sprintf(query, "UPDATE cif_schedules SET CIF_train_service_code = '%s' WHERE id = %s", tsc, row0[0]);
db_query(query);
stats[TSCUpdate]++;
_log(GENERAL, "Updated schedule %s (%s %s) with TSC \"%s\".", row0[0], uid, stp_indicator, tsc);
}
mysql_free_result(result0);
}
}
static void update_clocks(IMXCCMState *s)
{
/*
* If we ever emulate more clocks, this should switch to a data-driven
* approach
*/
if ((s->ccmr & CCMR_PRCS) == 1) {
s->pll_refclk_freq = CKIL_FREQ * 1024;
} else {
s->pll_refclk_freq = CKIH_FREQ;
}
/* ipg_clk_arm aka MCU clock */
if ((s->ccmr & CCMR_MDS) || !(s->ccmr & CCMR_MPE)) {
s->mcu_clk_freq = s->pll_refclk_freq;
} else {
s->mcu_clk_freq = calc_pll(s->mpctl, s->pll_refclk_freq);
}
/* High-speed clock */
s->hsp_clk_freq = s->mcu_clk_freq / (1 + EXTRACT(s->pdr0, HSP));
s->ipg_clk_freq = s->hsp_clk_freq / (1 + EXTRACT(s->pdr0, IPG));
DPRINTF("Clocks: mcu %uMHz, HSP %uMHz, IPG %uHz\n",
s->mcu_clk_freq / 1000000,
s->hsp_clk_freq / 1000000,
s->ipg_clk_freq);
}
integer *
integer_rshifta(integer * data, int y)
{
int bw, sw, rw, rl, i, j;
INTEGER_FULL_TYPE a;
if (y == 0 || data->len_of_integer == 0)
return data;
y = (y > 0 ? y : -y);
bw = y / INTEGER_HALF;
sw = y % INTEGER_HALF;
rw = INTEGER_HALF - sw;
rl = data->len_of_integer - bw;
if (rl < 0)
{
memset(data->vec_of_integer, 0, data->len_of_integer * sizeof(INTEGER_HALF_TYPE));
return data;
}
a = data->vec_of_integer[bw] >> sw;
for (j = 0, i = bw + 1; i < data->len_of_integer; i++, j++)
{
a |= ((INTEGER_FULL_TYPE) data->vec_of_integer[i]) << rw;
data->vec_of_integer[j] = EXTRACT(a);
a >>= INTEGER_HALF;
}
data->vec_of_integer[j] = EXTRACT(a);
integer_resize(data, j + 1);
return data;
}
static void
marvel_print_err_cyc(u64 err_cyc)
{
static char *packet_desc[] = {
"No Error",
"UNKNOWN",
"1 cycle (1 or 2 flit packet)",
"2 cycles (3 flit packet)",
"9 cycles (18 flit packet)",
"10 cycles (19 flit packet)",
"UNKNOWN",
"UNKNOWN",
"UNKNOWN"
};
#define IO7__ERR_CYC__ODD_FLT (1UL << 0)
#define IO7__ERR_CYC__EVN_FLT (1UL << 1)
#define IO7__ERR_CYC__PACKET__S (6)
#define IO7__ERR_CYC__PACKET__M (0x7)
#define IO7__ERR_CYC__LOC (1UL << 5)
#define IO7__ERR_CYC__CYCLE__S (2)
#define IO7__ERR_CYC__CYCLE__M (0x7)
printk("%s Packet In Error: %s\n"
"%s Error in %s, cycle %ld%s%s\n",
err_print_prefix,
packet_desc[EXTRACT(err_cyc, IO7__ERR_CYC__PACKET)],
err_print_prefix,
(err_cyc & IO7__ERR_CYC__LOC) ? "DATA" : "HEADER",
EXTRACT(err_cyc, IO7__ERR_CYC__CYCLE),
(err_cyc & IO7__ERR_CYC__ODD_FLT) ? " [ODD Flit]": "",
(err_cyc & IO7__ERR_CYC__EVN_FLT) ? " [Even Flit]": "");
}
static void nspire_clkinfo_classic(u32 val, struct nspire_clk_info *clk)
{
if (EXTRACT(val, FIXED_BASE))
clk->base_clock = 27 * MHZ;
else
clk->base_clock = (300 - 6 * EXTRACT(val, CLASSIC_BASE)) * MHZ;
clk->base_cpu_ratio = EXTRACT(val, BASE_CPU) * 2;
clk->base_ahb_ratio = clk->base_cpu_ratio * (EXTRACT(val, CPU_AHB) + 1);
}
static void nspire_clkinfo_cx(u32 val, struct nspire_clk_info *clk)
{
if (EXTRACT(val, FIXED_BASE))
clk->base_clock = 48 * MHZ;
else
clk->base_clock = 6 * EXTRACT(val, CX_BASE) * MHZ;
clk->base_cpu_ratio = EXTRACT(val, BASE_CPU) * EXTRACT(val, CX_UNKNOWN);
clk->base_ahb_ratio = clk->base_cpu_ratio * (EXTRACT(val, CPU_AHB) + 1);
}
static void
marvel_print_po7_crrct_sym(u64 crrct_sym)
{
#define IO7__PO7_CRRCT_SYM__SYN__S (0)
#define IO7__PO7_CRRCT_SYM__SYN__M (0x7f)
#define IO7__PO7_CRRCT_SYM__ERR_CYC__S (7) /* ERR_CYC + ODD_FLT + EVN_FLT */
#define IO7__PO7_CRRCT_SYM__ERR_CYC__M (0x1ff)
printk("%s Correctable Error Symptoms:\n"
"%s Syndrome: 0x%lx\n",
err_print_prefix,
err_print_prefix, EXTRACT(crrct_sym, IO7__PO7_CRRCT_SYM__SYN));
marvel_print_err_cyc(EXTRACT(crrct_sym, IO7__PO7_CRRCT_SYM__ERR_CYC));
}
static uint32_t imx25_ccm_get_mcu_clk(IMXCCMState *dev)
{
uint32_t freq;
IMX25CCMState *s = IMX25_CCM(dev);
freq = imx25_ccm_get_mpll_clk(dev);
if (EXTRACT(s->reg[IMX25_CCM_CCTL_REG], ARM_SRC)) {
freq = (freq * 3 / 4);
}
freq = freq / (1 + EXTRACT(s->reg[IMX25_CCM_CCTL_REG], ARM_CLK_DIV));
DPRINTF("freq = %d\n", freq);
return freq;
}
static bool imx_spi_is_multiple_master_burst(IMXSPIState *s)
{
uint8_t wave = EXTRACT(s->regs[ECSPI_CONFIGREG], ECSPI_CONFIGREG_SS_CTL);
return imx_spi_channel_is_master(s) &&
!(s->regs[ECSPI_CONREG] & ECSPI_CONREG_SMC) &&
((wave & (1 << imx_spi_selected_channel(s))) ? true : false);
}
static parameter
makelongparameter (ULONGLONG val, int start, int end)
{
parameter p;
p.val = (dwordU) EXTRACT(val, 48 - end, end - start);
p.nbits = end - start;
return p;
}
static void process_update_schedule(const char * string, const jsmntok_t * tokens)
{
char query[1024], CIF_train_uid[16], schedule_start_date[16], schedule_end_date[16], CIF_stp_indicator[8];
dword id;
MYSQL_RES * result0;
MYSQL_ROW row0;
EXTRACT("CIF_train_uid", CIF_train_uid);
EXTRACT("schedule_start_date", schedule_start_date);
EXTRACT("schedule_end_date", schedule_end_date);
EXTRACT("CIF_stp_indicator", CIF_stp_indicator);
time_t schedule_start_date_stamp = parse_datestamp(schedule_start_date);
// time_t schedule_end_date_stamp = parse_datestamp(schedule_end_date);
sprintf(query, "SELECT id FROM cif_schedules WHERE update_id = 0 AND CIF_train_uid = '%s' AND CIF_stp_indicator = '%s' AND schedule_start_date = %ld AND deleted > %ld", CIF_train_uid, CIF_stp_indicator, schedule_start_date_stamp, time(NULL));
if(!db_query(query))
{
result0 = db_store_result();
word num_rows = mysql_num_rows(result0);
if(num_rows != 1)
{
_log(MAJOR, "Update for schedule \"%s\" found %d existing records. Delete phase skipped.", CIF_train_uid, num_rows);
jsmn_dump_tokens(string, tokens, 0);
if(num_rows) stats[UpdateDeleteMulti]++; else stats[UpdateDeleteMiss]++;
}
else
{
row0 = mysql_fetch_row(result0);
id = atol(row0[0]);
//sprintf(query, "DELETE FROM cif_schedule_locations WHERE cif_schedule_id = %ld", id);
//db_query(query);
sprintf(query, "UPDATE cif_schedules SET deleted = %ld WHERE id = %ld", time(NULL), id);
db_query(query);
}
mysql_free_result(result0);
}
// Create phase.
process_create_schedule(string, tokens, true);
_log(DEBUG, "Updated schedule \"%s\".", CIF_train_uid);
}
void skylake_s_decode_model(int cputype, int bank, u64 status, u64 misc)
{
switch (bank) {
case 4:
Wprintf("PCU: ");
switch (EXTRACT(status, 0, 15) & ~(1ull << 12)) {
case 0x402: case 0x403:
Wprintf("Internal errors ");
break;
case 0x406:
Wprintf("Intel TXT errors ");
break;
case 0x407:
Wprintf("Other UBOX Internal errors ");
break;
}
if (EXTRACT(status, 16, 19))
Wprintf("PCU internal error ");
decode_bitfield(status, pcu_mc4);
break;
case 5:
case 12:
case 19:
Wprintf("UPI: ");
decode_bitfield(status, upi_mc);
if (EXTRACT(status, 16, 21) == 0x12)
decode_bitfield(status, upi_0x12);
break;
case 7: case 8:
Wprintf("M2M: ");
decode_bitfield(status, m2m);
break;
case 13: case 14: case 15:
case 16: case 17: case 18:
Wprintf("MemCtrl: ");
if (EXTRACT(status, 27, 27))
decode_bitfield(status, memctrl_mc13);
else
decode_bitfield(status, mc_bits);
break;
}
}
int sign_extend(int value, int length)
{
int result=0;
if( length==32 ) return value;
if( EXTRACT(value,length-1,length-1) )
result=power(2,32-length) << length;
return( result | ( value << (32-length) >> (32-length) ) );
}
static uint32_t imx25_ccm_get_ahb_clk(IMXCCMState *dev)
{
uint32_t freq;
IMX25CCMState *s = IMX25_CCM(dev);
freq = imx25_ccm_get_mcu_clk(dev)
/ (1 + EXTRACT(s->reg[IMX25_CCM_CCTL_REG], AHB_CLK_DIV));
DPRINTF("freq = %d\n", freq);
return freq;
}
// Helper function for input_thread() below
static inline void process_one_message(
char *data,
int numberOfPixels)
{
#define UC(value) ((unsigned char) (value))
#define UI(value) ((unsigned int) (value))
#define ULL(value) ((unsigned long long) (value))
int i;
for (i = 0; i < numberOfPixels; i++) {
unsigned char x1 = UC(data[i*7 + 0]);
unsigned char x2 = UC(data[i*7 + 1]);
unsigned char y1 = UC(data[i*7 + 2]);
unsigned char y2 = UC(data[i*7 + 3]);
unsigned int r = UI(data[i*7 + 4]);
unsigned int g = UI(data[i*7 + 5]);
unsigned int b = UI(data[i*7 + 6]);
int x = (((int)x1)<<8) + ((int)x2);
int y = (((int)y1)<<8) + ((int)y2);
if (((frameHeight-y-1)*frameWidth + x)*3 + 2 < frameWidth*frameHeight*3 - 1) {
int index = (frameHeight-y-1)*frameWidth + x;
unsigned long long receivedFrames = ULL(receivedFrame[index]);
#define EXTRACT(factor, base, index) \
UC((ULL(UC(base)) + (factor)*ULL(viewingFrame[index])) / ((factor) + 1))
viewingFrame[index*3] = EXTRACT(receivedFrames, r, index*3);
viewingFrame[index*3+1] = EXTRACT(receivedFrames, g, index*3+1);
viewingFrame[index*3+2] = EXTRACT(receivedFrames, b, index*3+2);
//viewingFrame[index*3] = (unsigned char) r;
//viewingFrame[index*3+1] = (unsigned char) g;
//viewingFrame[index*3+2] = (unsigned char) b;
receivedFrame[index] += 1;
}
}
}
static uint32_t imx25_ccm_get_upll_clk(IMXCCMState *dev)
{
uint32_t freq = 0;
IMX25CCMState *s = IMX25_CCM(dev);
if (!EXTRACT(s->reg[IMX25_CCM_CCTL_REG], UPLL_DIS)) {
freq = imx_ccm_calc_pll(s->reg[IMX25_CCM_UPCTL_REG], CKIH_FREQ);
}
DPRINTF("freq = %d\n", freq);
return freq;
}
static uint32_t imx25_ccm_get_mpll_clk(IMXCCMState *dev)
{
uint32_t freq;
IMX25CCMState *s = IMX25_CCM(dev);
if (EXTRACT(s->reg[IMX25_CCM_CCTL_REG], MPLL_BYPASS)) {
freq = CKIH_FREQ;
} else {
freq = imx_ccm_calc_pll(s->reg[IMX25_CCM_MPCTL_REG], CKIH_FREQ);
}
DPRINTF("freq = %d\n", freq);
return freq;
}
/*
* There isn't enough information to identify the DIMM. But
* we can derive the channel from the bank number.
* There can be two memory controllers. We number the channels
* on the second controller: 3, 4, 5
*/
void skylake_memerr_misc(struct mce *m, int *channel, int *dimm)
{
u64 status = m->status;
unsigned chan;
/* Check this is a memory error */
if (!test_prefix(7, status & 0xefff))
return;
chan = EXTRACT(status, 0, 3);
if (chan == 0xf)
return;
switch (m->bank) {
case 7:
/* Home agent 0 */
break;
case 8:
/* Home agent 1 */
chan += 3;
break;
case 13: /* Memory controller 0, channel 0 */
chan = 0;
break;
case 14: /* Memory controller 0, channel 1 */
chan = 1;
break;
case 15: /* Memory controller 1, channel 0 */
chan = 3;
break;
case 16: /* Memory controller 1, channel 1 */
chan = 4;
break;
case 17: /* Memory controller 0, channel 2 */
chan = 2;
break;
case 18: /* Memory controller 1, channel 2 */
chan = 5;
break;
default:
return;
}
channel[0] = chan;
}
// The following handler is called by the message interrupt service routine
void control_msg_handler(unsigned int* buffer,int len) {
// Extract sender information
unsigned int src = EXTRACT(buffer[0],OPTIMSOC_SRC_MSB,OPTIMSOC_SRC_LSB);
// Extract request type
int req = EXTRACT(buffer[0],CTRL_REQUEST_MSB,CTRL_REQUEST_LSB);
// Reply buffer
uint32_t rbuffer[5];
// Handle the respective request
switch (req) {
case CTRL_REQUEST_GETEP_REQ:
{
trace_ep_get_req_recv(src, buffer[1], buffer[2]);
// This is the request to get an endpoint handle
// Flit 1: node number
// Flit 2: port number
// Return the get endpoint response to sender
rbuffer[0] = (src << OPTIMSOC_DEST_LSB) |
(1 << OPTIMSOC_CLASS_LSB) |
(optimsoc_get_tileid() << OPTIMSOC_SRC_LSB) |
(CTRL_REQUEST_GETEP_RESP << CTRL_REQUEST_LSB);
// Get endpoint handle for <thisdomain,node,port> where
// this domain is the tile id
struct endpoint_handle *eph = endpoint_get(optimsoc_get_tileid(),
buffer[1], buffer[2]);
// If valid numbers and endpoint handle found
if (
//buffer[1] < MCA_MAX_NODES &&
//buffer[2] < MCAPI_MAX_ENDPOINTS &&
(eph!=0)) {
// Return endpoint
rbuffer[1] = (unsigned int) eph->ep;
} else {
// Signal this is an invalid endpoint
rbuffer[1] = (int) -1;
}
trace_ep_get_resp_send(src, (struct endpoint*) rbuffer[1]);
optimsoc_mp_simple_send(2,rbuffer);
break;
}
case CTRL_REQUEST_MSG_ALLOC_REQ:
{
rbuffer[0] = (src << OPTIMSOC_DEST_LSB) |
(1 << OPTIMSOC_CLASS_LSB) |
(optimsoc_get_tileid() << OPTIMSOC_SRC_LSB) |
(CTRL_REQUEST_MSG_ALLOC_RESP << CTRL_REQUEST_LSB);
struct endpoint *ep = (struct endpoint*) buffer[1];
unsigned int size = buffer[2];
trace_msg_alloc_req_recv(src, ep, size);
uint32_t ptr;
int rv = endpoint_alloc(ep, size, &ptr);
if (rv == 0) {
rbuffer[1] = CTRL_REQUEST_ACK;
rbuffer[2] = ptr;
trace_msg_alloc_resp_send(src, ep, ptr);
optimsoc_mp_simple_send(3, rbuffer);
} else {
rbuffer[1] = CTRL_REQUEST_NACK;
trace_msg_alloc_resp_send(src, ep, -1);
optimsoc_mp_simple_send(2,rbuffer);
}
break;
}
case CTRL_REQUEST_MSG_DATA:
{
struct endpoint *ep = (struct endpoint*) buffer[1];
endpoint_write(ep, buffer[2], buffer[3], (uint32_t*) &buffer[4], len-4);
break;
}
case CTRL_REQUEST_MSG_COMPLETE:
{
struct endpoint *ep = (struct endpoint*) buffer[1];
endpoint_write_complete(ep, buffer[2], buffer[3]);
#ifdef RUNTIME
if (ep->waiting) {
thread_resume(ep->waiting_thread);
ep->waiting = 0;
}
#endif
break;
}
case CTRL_REQUEST_CHAN_CONNECT_REQ:
{
struct endpoint *ep = (struct endpoint *) buffer[1];
ep->remotedomain = (uint32_t) buffer[2];
ep->remote = (struct endpoint *) buffer[3];
rbuffer[0] = (src << OPTIMSOC_DEST_LSB) |
(1 << OPTIMSOC_CLASS_LSB) |
(optimsoc_get_tileid() << OPTIMSOC_SRC_LSB) |
(CTRL_REQUEST_CHAN_CONNECT_RESP << CTRL_REQUEST_LSB);
rbuffer[1] = endpoint_channel_get_credit(ep);
optimsoc_mp_simple_send(2, rbuffer);
break;
}
case CTRL_REQUEST_CHAN_DATA:
{
struct endpoint *ep = (struct endpoint *) buffer[1];
uint32_t offset = buffer[2];
uint32_t eom = buffer[3];
endpoint_write(ep, ep->buffer->write_ptr, offset, (uint32_t*) &buffer[4], len-4);
if (eom) {
ep->buffer->data_size[ep->buffer->write_ptr] = offset + len - 4;
ep->buffer->write_ptr = _endpoint_addptrwrap(ep, ep->buffer->write_ptr, 1);
trace_ep_bufferstate(ep, endpoint_channel_get_fillstate(ep));
}
break;
}
case CTRL_REQUEST_CHAN_CREDIT:
{
struct endpoint *ep = (struct endpoint *) buffer[1];
uint32_t credit = buffer[2];
if (credit == 0) {
ep->remotecredit = 0;
} else {
ep->remotecredit += credit;
}
break;
}
case CTRL_REQUEST_GETEP_RESP:
case CTRL_REQUEST_MSG_ALLOC_RESP:
case CTRL_REQUEST_CHAN_CONNECT_RESP:
// Forward the responses to the handler
ctrl_request.buffer[0] = buffer[0];
ctrl_request.buffer[1] = buffer[1];
ctrl_request.buffer[2] = buffer[2];
ctrl_request.buffer[3] = buffer[3];
ctrl_request.buffer[4] = buffer[4];
ctrl_request.done = 1;
break;
default:
printf("Unknown request: %d\n",req);
break;
}
}
static void process_create_schedule(const char * string, const jsmntok_t * tokens, const word update)
{
// update true indicates this is as the result of a VSTP update.
char zs[128], zs1[128];
char query[2048];
word i;
char uid[16], stp_indicator[2];
char signalling_id[8];
if(debug) jsmn_dump_tokens(string, tokens, 0);
time_t now = time(NULL);
sprintf(query, "INSERT INTO cif_schedules VALUES(0, %ld, %lu", now, NOT_DELETED); // update_id == 0 => VSTP
EXTRACT_APPEND_SQL("CIF_bank_holiday_running");
//EXTRACT_APPEND_SQL("CIF_stp_indicator");
EXTRACT("CIF_stp_indicator", stp_indicator);
sprintf(zs1, ", '%s'", stp_indicator); strcat(query, zs1);
//EXTRACT_APPEND_SQL("CIF_train_uid");
EXTRACT("CIF_train_uid", uid);
sprintf(zs1, ", '%s'", uid); strcat(query, zs1);
EXTRACT_APPEND_SQL("applicable_timetable");
EXTRACT_APPEND_SQL("atoc_code");
// EXTRACT_APPEND_SQL("traction_class");
EXTRACT_APPEND_SQL("uic_code");
EXTRACT("schedule_days_runs", zs);
for(i=0; i<7; i++)
{
strcat(query, ", ");
strcat(query, (zs[i]=='1')?"1":"0");
}
EXTRACT("schedule_end_date", zs);
time_t z = parse_datestamp(zs);
sprintf(zs1, ", %ld", z);
strcat(query, zs1);
EXTRACT("signalling_id", signalling_id);
sprintf(zs1, ", '%s'", signalling_id); strcat(query, zs1);
EXTRACT_APPEND_SQL("CIF_train_category");
EXTRACT_APPEND_SQL("CIF_headcode");
//EXTRACT_APPEND_SQL("CIF_course_indicator");
EXTRACT_APPEND_SQL("CIF_train_service_code");
EXTRACT_APPEND_SQL("CIF_business_sector");
EXTRACT_APPEND_SQL("CIF_power_type");
EXTRACT_APPEND_SQL("CIF_timing_load");
EXTRACT_APPEND_SQL("CIF_speed");
EXTRACT_APPEND_SQL("CIF_operating_characteristics");
EXTRACT_APPEND_SQL("CIF_train_class");
EXTRACT_APPEND_SQL("CIF_sleepers");
EXTRACT_APPEND_SQL("CIF_reservations");
EXTRACT_APPEND_SQL("CIF_connection_indicator");
EXTRACT_APPEND_SQL("CIF_catering_code");
EXTRACT_APPEND_SQL("CIF_service_branding");
EXTRACT("schedule_start_date", zs);
z = parse_datestamp(zs);
sprintf(zs1, ", %ld", z);
strcat(query, zs1);
EXTRACT_APPEND_SQL("train_status");
strcat(query, ", 0, '', '')"); // id filled by MySQL
if(!db_query(query))
{
stats[update?UpdateCreate:Create]++;
}
dword id = db_insert_id();
word index = jsmn_find_name_token(string, tokens, 0, "schedule_location");
word locations = tokens[index+1].size;
huyton_flag = false;
index += 2;
for(i = 0; i < locations; i++)
{
index = process_create_schedule_location(string, tokens, index, id);
}
if(stp_indicator[0] == 'O' && (signalling_id[0] == '\0' || signalling_id[0] == ' '))
{
// Search db for schedules with a deduced headcode, and add it to this one, status = D
// Bug: Really this should also look for schedules with a signalling_id
MYSQL_RES * result;
MYSQL_ROW row;
sprintf(query, "SELECT deduced_headcode FROM cif_schedules WHERE CIF_train_uid = '%s' AND deduced_headcode != '' AND schedule_end_date > %ld ORDER BY created DESC", uid, now - (64L * 24L * 60L * 60L));
if(!db_query(query))
{
result = db_store_result();
if((row = mysql_fetch_row(result)))
{
sprintf(query, "UPDATE cif_schedules SET deduced_headcode = '%s', deduced_headcode_status = 'D' WHERE id = %ld", row[0], id);
db_query(query);
_log(DEBUG, "Deduced headcode \"%s\" applied to overlay schedule %ld, uid \"%s\".", row[0], id, uid);
stats[HeadcodeDeduced]++;
}
else
{
_log(DEBUG, "Deduced headcode not found for overlay schedule %ld, uid \"%s\".", id, uid);
}
mysql_free_result(result);
}
}
sprintf(query, "UPDATE status SET last_vstp_processed = %ld", now);
db_query(query);
if(huyton_flag)
{
_log(DEBUG, "Created schedule %ld%s. +++ Passes Huyton +++", id, update?" as a result of an Update transaction":"");
}
if(huyton_flag)
{
char title[64], message[512];
MYSQL_RES * result0;
MYSQL_ROW row0;
char stp[4];
sprintf(title, "Huyton Schedule Created.");
sprintf(message, "Created schedule which passes Huyton.");
if(update) strcat(message, " Due to a VSTP Update transaction.");
strcat(message, "\n\n");
EXTRACT("CIF_train_uid", zs1);
EXTRACT("CIF_stp_indicator", stp);
sprintf(zs, "%ld (%s %s) ", id, zs1, stp);
EXTRACT("signalling_id", zs1);
strcat(zs, zs1);
sprintf(query, "SELECT tiploc_code, departure FROM cif_schedule_locations WHERE record_identity = 'LO' AND cif_schedule_id = %ld", id);
if(!db_query(query))
{
result0 = db_store_result();
if((row0 = mysql_fetch_row(result0)))
{
sprintf(zs1, " %s %s to ", show_time_text(row0[1]), tiploc_name(row0[0]));
strcat(zs, zs1);
}
mysql_free_result(result0);
}
sprintf(query, "SELECT tiploc_code FROM cif_schedule_locations WHERE record_identity = 'LT' AND cif_schedule_id = %ld", id);
if(!db_query(query))
{
result0 = db_store_result();
if((row0 = mysql_fetch_row(result0)))
{
strcat (zs, tiploc_name(row0[0]));
}
mysql_free_result(result0);
}
strcat(message, zs);
sprintf(query, "SELECT schedule_start_date, schedule_end_date, CIF_stp_indicator FROM cif_schedules WHERE id = %ld", id);
if(!db_query(query))
{
result0 = db_store_result();
if((row0 = mysql_fetch_row(result0)))
{
dword from = atol(row0[0]);
dword to = atol(row0[1]);
if(from == to)
{
strcat(message, " Runs on ");
strcat(message, date_text(from, true));
}
else
{
strcat(message, " Runs from ");
strcat(message, date_text(from, true));
strcat(message, " to ");
strcat(message, date_text(to, true));
}
if(row0[2][0] == 'C') strcat(message, " CANCELLED");
strcat(message, "\n");
}
mysql_free_result(result0);
}
sprintf(query, "SELECT departure, arrival, pass, tiploc_code FROM cif_schedule_locations WHERE (tiploc_code = 'HUYTON' OR tiploc_code = 'HUYTJUN') AND cif_schedule_id = %ld", id);
if(!db_query(query))
{
result0 = db_store_result();
while((row0 = mysql_fetch_row(result0)))
{
char where[32], z[128];
if(row0[3][4] == 'J') strcpy(where, "Huyton Junction"); else strcpy(where, "Huyton");
if(row0[0][0])
{
sprintf(z, "Depart %s at %s.\n", where, row0[0]);
strcat(message, z);
}
else if(row0[1][0])
{
sprintf(z, "Arrive %s at %s.\n", where, row0[1]);
strcat(message, z);
}
else if(row0[2][0])
{
sprintf(z, "Pass %s at %s.\n", where, row0[2]);
strcat(message, z);
}
}
mysql_free_result(result0);
}
email_alert(NAME, BUILD, title, message);
}
}
static void process_delete_schedule(const char * string, const jsmntok_t * tokens)
{
char query[1024], CIF_train_uid[16], schedule_start_date[16], schedule_end_date[16], CIF_stp_indicator[8];
dword id;
word update_id;
MYSQL_RES * result0;
MYSQL_ROW row0;
word deleted = 0;
EXTRACT("CIF_train_uid", CIF_train_uid);
EXTRACT("schedule_start_date", schedule_start_date);
EXTRACT("schedule_end_date", schedule_end_date);
EXTRACT("CIF_stp_indicator", CIF_stp_indicator);
time_t schedule_start_date_stamp = parse_datestamp(schedule_start_date);
time_t schedule_end_date_stamp = parse_datestamp(schedule_end_date);
// Find the id
sprintf(query, "SELECT id, update_id FROM cif_schedules where CIF_train_uid = '%s' and schedule_start_date = '%ld' and schedule_end_date = %ld and CIF_stp_indicator = '%s' AND update_id = 0 AND deleted > %ld",
CIF_train_uid, schedule_start_date_stamp, schedule_end_date_stamp, CIF_stp_indicator, time(NULL));
// DO WE NEED DAYS RUNS AS WELL????
// Note: Only find VSTP ones.
if (db_query(query))
{
db_disconnect();
return;
}
result0 = db_store_result();
word num_rows = mysql_num_rows(result0);
if(num_rows > 1)
{
char zs[256];
sprintf(zs, "Delete schedule found %d matches.", num_rows);
_log(MAJOR, zs);
jsmn_dump_tokens(string, tokens, 0);
stats[DeleteMulti]++;
// Bodge!
query[7] = '*'; query[8] = ' ';
dump_mysql_result_query(query);
}
while((row0 = mysql_fetch_row(result0)) && row0[0])
{
id = atol(row0[0]);
update_id = atoi(row0[1]);
//sprintf(query, "DELETE FROM cif_schedule_locations WHERE cif_schedule_id = %ld", id);
//if(!db_query(query))
//{
//}
sprintf(query, "UPDATE cif_schedules SET deleted = %ld where id = %ld", time(NULL), id);
if(!db_query(query))
{
deleted++;
if(update_id)
{
// Can never happen!
_log(MAJOR, "Deleted non-VSTP schedule %ld.", id);
}
else
{
_log(DEBUG, "Deleted VSTP schedule %ld \"%s\".", id, CIF_train_uid);
}
}
}
mysql_free_result(result0);
if(deleted)
{
stats[DeleteHit]++;
}
else
{
_log(MAJOR, "Delete schedule miss.");
jsmn_dump_tokens(string, tokens, 0);
stats[DeleteMiss]++;
}
}
/*
Format a variant value as a string representation of time.
This method was written to convert a QVariant of type ??? (the type used to represent times in CA),
but should cope with a variant of any type.
*/
void QEStringFormatting::formatFromTime( const QVariant &value ) {
bool okay;
double seconds;
double time;
QString sign;
int days;
int hours;
int mins;
int secs;
int nanoSecs;
QString image;
int effectivePrecision;
QString fraction;
if( value.type() == QVariant::String )
stream << value.toString();
else {
seconds = value.toDouble( &okay );
if (okay) {
if (seconds >= 0.0) {
time = seconds;
sign= "";
} else {
time = -seconds;
sign= "-";
}
#define EXTRACT(item, spi) { item = int (floor (time / spi)); time = time - (spi * item); }
EXTRACT (days, 86400.0);
EXTRACT (hours, 3600.0);
EXTRACT (mins, 60.0);
EXTRACT (secs, 1.0);
EXTRACT (nanoSecs, 1.0E-9);
#undef EXTRACT
// Include days field if rquired or if requested.
//
if ((days > 0) || leadingZero) {
image.sprintf ("%d %02d:%02d:%02d", days, hours, mins, secs);
} else {
image.sprintf ("%02d:%02d:%02d", hours, mins, secs);
}
// Select data base or user precision as appropriate.
//
effectivePrecision = useDbPrecision ? dbPrecision : precision;
if (effectivePrecision > 9) effectivePrecision = 9;
if (effectivePrecision > 0) {
fraction.sprintf (".%09d", nanoSecs);
fraction.truncate( effectivePrecision + 1 );
} else {
fraction = "";
}
stream << sign << image << fraction;
} else {
stream << QString( "not a valid numeric" );
}
}
}
static void
marvel_print_po7_uncrr_sym(u64 uncrr_sym, u64 valid_mask)
{
static char *clk_names[] = { "_h[0]", "_h[1]", "_n[0]", "_n[1]" };
static char *clk_decode[] = {
"No Error",
"One extra rising edge",
"Two extra rising edges",
"Lost one clock"
};
static char *port_names[] = { "Port 0", "Port 1",
"Port 2", "Port 3",
"Unknown Port", "Unknown Port",
"Unknown Port", "Port 7" };
int scratch, i;
#define IO7__PO7_UNCRR_SYM__SYN__S (0)
#define IO7__PO7_UNCRR_SYM__SYN__M (0x7f)
#define IO7__PO7_UNCRR_SYM__ERR_CYC__S (7) /* ERR_CYC + ODD_FLT... */
#define IO7__PO7_UNCRR_SYM__ERR_CYC__M (0x1ff) /* ... + EVN_FLT */
#define IO7__PO7_UNCRR_SYM__CLK__S (16)
#define IO7__PO7_UNCRR_SYM__CLK__M (0xff)
#define IO7__PO7_UNCRR_SYM__CDT_OVF_TO__REQ (1UL << 24)
#define IO7__PO7_UNCRR_SYM__CDT_OVF_TO__RIO (1UL << 25)
#define IO7__PO7_UNCRR_SYM__CDT_OVF_TO__WIO (1UL << 26)
#define IO7__PO7_UNCRR_SYM__CDT_OVF_TO__BLK (1UL << 27)
#define IO7__PO7_UNCRR_SYM__CDT_OVF_TO__NBK (1UL << 28)
#define IO7__PO7_UNCRR_SYM__OVF__READIO (1UL << 29)
#define IO7__PO7_UNCRR_SYM__OVF__WRITEIO (1UL << 30)
#define IO7__PO7_UNCRR_SYM__OVF__FWD (1UL << 31)
#define IO7__PO7_UNCRR_SYM__VICTIM_SP__S (32)
#define IO7__PO7_UNCRR_SYM__VICTIM_SP__M (0xff)
#define IO7__PO7_UNCRR_SYM__DETECT_SP__S (40)
#define IO7__PO7_UNCRR_SYM__DETECT_SP__M (0xff)
#define IO7__PO7_UNCRR_SYM__STRV_VTR__S (48)
#define IO7__PO7_UNCRR_SYM__STRV_VTR__M (0x3ff)
#define IO7__STRV_VTR__LSI__INTX__S (0)
#define IO7__STRV_VTR__LSI__INTX__M (0x3)
#define IO7__STRV_VTR__LSI__SLOT__S (2)
#define IO7__STRV_VTR__LSI__SLOT__M (0x7)
#define IO7__STRV_VTR__LSI__BUS__S (5)
#define IO7__STRV_VTR__LSI__BUS__M (0x3)
#define IO7__STRV_VTR__MSI__INTNUM__S (0)
#define IO7__STRV_VTR__MSI__INTNUM__M (0x1ff)
#define IO7__STRV_VTR__IS_MSI (1UL << 9)
printk("%s Uncorrectable Error Symptoms:\n", err_print_prefix);
uncrr_sym &= valid_mask;
if (EXTRACT(valid_mask, IO7__PO7_UNCRR_SYM__SYN))
printk("%s Syndrome: 0x%lx\n",
err_print_prefix,
EXTRACT(uncrr_sym, IO7__PO7_UNCRR_SYM__SYN));
if (EXTRACT(valid_mask, IO7__PO7_UNCRR_SYM__ERR_CYC))
marvel_print_err_cyc(EXTRACT(uncrr_sym,
IO7__PO7_UNCRR_SYM__ERR_CYC));
scratch = EXTRACT(uncrr_sym, IO7__PO7_UNCRR_SYM__CLK);
for (i = 0; i < 4; i++, scratch >>= 2) {
if (scratch & 0x3)
printk("%s Clock %s: %s\n",
err_print_prefix,
clk_names[i], clk_decode[scratch & 0x3]);
}
if (uncrr_sym & IO7__PO7_UNCRR_SYM__CDT_OVF_TO__REQ)
printk("%s REQ Credit Timeout or Overflow\n",
err_print_prefix);
if (uncrr_sym & IO7__PO7_UNCRR_SYM__CDT_OVF_TO__RIO)
printk("%s RIO Credit Timeout or Overflow\n",
err_print_prefix);
if (uncrr_sym & IO7__PO7_UNCRR_SYM__CDT_OVF_TO__WIO)
printk("%s WIO Credit Timeout or Overflow\n",
err_print_prefix);
if (uncrr_sym & IO7__PO7_UNCRR_SYM__CDT_OVF_TO__BLK)
printk("%s BLK Credit Timeout or Overflow\n",
err_print_prefix);
if (uncrr_sym & IO7__PO7_UNCRR_SYM__CDT_OVF_TO__NBK)
printk("%s NBK Credit Timeout or Overflow\n",
err_print_prefix);
if (uncrr_sym & IO7__PO7_UNCRR_SYM__OVF__READIO)
printk("%s Read I/O Buffer Overflow\n",
err_print_prefix);
if (uncrr_sym & IO7__PO7_UNCRR_SYM__OVF__WRITEIO)
printk("%s Write I/O Buffer Overflow\n",
err_print_prefix);
if (uncrr_sym & IO7__PO7_UNCRR_SYM__OVF__FWD)
printk("%s FWD Buffer Overflow\n",
err_print_prefix);
if ((scratch = EXTRACT(uncrr_sym, IO7__PO7_UNCRR_SYM__VICTIM_SP))) {
int lost = scratch & (1UL << 4);
scratch &= ~lost;
for (i = 0; i < 8; i++, scratch >>= 1) {
if (!(scratch & 1))
continue;
printk("%s Error Response sent to %s",
err_print_prefix, port_names[i]);
}
if (lost)
printk("%s Lost Error sent somewhere else\n",
err_print_prefix);
}
static uint8_t imx_spi_selected_channel(IMXSPIState *s)
{
return EXTRACT(s->regs[ECSPI_CONREG], ECSPI_CONREG_CHANNEL_SELECT);
}
static uint32_t imx_spi_burst_length(IMXSPIState *s)
{
return EXTRACT(s->regs[ECSPI_CONREG], ECSPI_CONREG_BURST_LENGTH) + 1;
}
static bool imx_spi_channel_is_master(IMXSPIState *s)
{
uint8_t mode = EXTRACT(s->regs[ECSPI_CONREG], ECSPI_CONREG_CHANNEL_MODE);
return (mode & (1 << imx_spi_selected_channel(s))) ? true : false;
}
static int
ev6_parse_cbox(u64 c_addr, u64 c1_syn, u64 c2_syn,
u64 c_stat, u64 c_sts, int print)
{
char *sourcename[] = { "UNKNOWN", "UNKNOWN", "UNKNOWN",
"MEMORY", "BCACHE", "DCACHE",
"BCACHE PROBE", "BCACHE PROBE" };
char *streamname[] = { "D", "I" };
char *bitsname[] = { "SINGLE", "DOUBLE" };
int status = MCHK_DISPOSITION_REPORT;
int source = -1, stream = -1, bits = -1;
#define EV6__C_STAT__BC_PERR (0x01)
#define EV6__C_STAT__DC_PERR (0x02)
#define EV6__C_STAT__DSTREAM_MEM_ERR (0x03)
#define EV6__C_STAT__DSTREAM_BC_ERR (0x04)
#define EV6__C_STAT__DSTREAM_DC_ERR (0x05)
#define EV6__C_STAT__PROBE_BC_ERR0 (0x06) /* both 6 and 7 indicate... */
#define EV6__C_STAT__PROBE_BC_ERR1 (0x07) /* ...probe bc error. */
#define EV6__C_STAT__ISTREAM_MEM_ERR (0x0B)
#define EV6__C_STAT__ISTREAM_BC_ERR (0x0C)
#define EV6__C_STAT__DSTREAM_MEM_DBL (0x13)
#define EV6__C_STAT__DSTREAM_BC_DBL (0x14)
#define EV6__C_STAT__ISTREAM_MEM_DBL (0x1B)
#define EV6__C_STAT__ISTREAM_BC_DBL (0x1C)
#define EV6__C_STAT__SOURCE_MEMORY (0x03)
#define EV6__C_STAT__SOURCE_BCACHE (0x04)
#define EV6__C_STAT__SOURCE__S (0)
#define EV6__C_STAT__SOURCE__M (0x07)
#define EV6__C_STAT__ISTREAM__S (3)
#define EV6__C_STAT__ISTREAM__M (0x01)
#define EV6__C_STAT__DOUBLE__S (4)
#define EV6__C_STAT__DOUBLE__M (0x01)
#define EV6__C_STAT__ERRMASK (0x1F)
#define EV6__C_STS__SHARED (1 << 0)
#define EV6__C_STS__DIRTY (1 << 1)
#define EV6__C_STS__VALID (1 << 2)
#define EV6__C_STS__PARITY (1 << 3)
if (!(c_stat & EV6__C_STAT__ERRMASK))
return MCHK_DISPOSITION_UNKNOWN_ERROR;
if (!print)
return status;
source = EXTRACT(c_stat, EV6__C_STAT__SOURCE);
stream = EXTRACT(c_stat, EV6__C_STAT__ISTREAM);
bits = EXTRACT(c_stat, EV6__C_STAT__DOUBLE);
if (c_stat & EV6__C_STAT__BC_PERR) {
printk("%s Bcache tag parity error\n", err_print_prefix);
source = -1;
}
if (c_stat & EV6__C_STAT__DC_PERR) {
printk("%s Dcache tag parity error\n", err_print_prefix);
source = -1;
}
if (c_stat == EV6__C_STAT__PROBE_BC_ERR0 ||
c_stat == EV6__C_STAT__PROBE_BC_ERR1) {
printk("%s Bcache single-bit error on a probe hit\n",
err_print_prefix);
source = -1;
}
if (source != -1)
printk("%s %s-STREAM %s-BIT ECC error from %s\n",
err_print_prefix,
streamname[stream], bitsname[bits], sourcename[source]);
printk("%s Address: 0x%016lx\n"
" Syndrome[upper.lower]: %02lx.%02lx\n",
err_print_prefix,
c_addr,
c2_syn, c1_syn);
if (source == EV6__C_STAT__SOURCE_MEMORY ||
source == EV6__C_STAT__SOURCE_BCACHE)
printk("%s Block status: %s%s%s%s\n",
err_print_prefix,
(c_sts & EV6__C_STS__SHARED) ? "SHARED " : "",
(c_sts & EV6__C_STS__DIRTY) ? "DIRTY " : "",
(c_sts & EV6__C_STS__VALID) ? "VALID " : "",
(c_sts & EV6__C_STS__PARITY) ? "PARITY " : "");
return status;
}
static _OP DecodeOp(UINT16 Opcode)
{
switch(EXTRACT(Opcode,14,15))
{
case 0x0:
{
UINT8 Op=EXTRACT(Opcode,11,13);
switch(Op)
{
case 0x0:
return LDB;
case 0x1:
return LDS;
case 0x2:
return LD;
case 0x3:
return LDBU;
case 0x4:
return STB;
case 0x5:
return STS;
case 0x6:
return ST;
case 0x7:
return LDSU;
}
}
break;
case 0x1:
return LERI;
break;
case 0x2:
{
switch(EXTRACT(Opcode,11,13))
{
case 0:
return LDSP;
case 1:
return STSP;
case 2:
return PUSH;
case 3:
return POP;
case 4:
case 5:
case 6:
case 7:
case 8: //arith
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
switch(EXTRACT(Opcode,6,8))
{
case 0:
return ADDI;
case 1:
return ADCI;
case 2:
return SUBI;
case 3:
return SBCI;
case 4:
return ANDI;
case 5:
return ORI;
case 6:
return XORI;
case 7:
switch(EXTRACT(Opcode,0,2))
{
case 0:
return CMPI;
case 1:
return TSTI;
case 2:
return LEATOSP;
case 3:
return LEAFROMSP;
}
break;
}
break;
}
}
break;
case 3:
switch(EXTRACT(Opcode,12,13))
{
case 0:
switch(EXTRACT(Opcode,6,8))
{
case 0:
return ADD;
case 1:
return ADC;
case 2:
return SUB;
case 3:
return SBC;
case 4:
return AND;
case 5:
return OR;
case 6:
return XOR;
case 7:
switch(EXTRACT(Opcode,0,2))
{
case 0:
return CMP;
case 1:
return TST;
case 2:
return MOV;
case 3:
return NEG;
}
break;
}
break;
case 1: //Jumps
switch(EXTRACT(Opcode,8,11))
{
case 0x0:
return JNV;
case 0x1:
return JV;
case 0x2:
return JP;
case 0x3:
return JM;
case 0x4:
return JNZ;
case 0x5:
return JZ;
case 0x6:
return JNC;
case 0x7:
return JC;
case 0x8:
return JGT;
case 0x9:
return JLT;
case 0xa:
return JGE;
case 0xb:
return JLE;
case 0xc:
return JHI;
case 0xd:
return JLS;
case 0xe:
return JMP;
case 0xf:
return CALL;
}
break;
case 2:
if(Opcode&(1<<11))
return LDI;
else //SP Ops
{
if(Opcode&(1<<10))
{
switch(EXTRACT(Opcode,7,9))
{
case 0:
return LDBSP;
case 1:
return LDSSP;
case 3:
return LDBUSP;
case 4:
return STBSP;
case 5:
return STSSP;
case 7:
return LDSUSP;
}
}
else
{
if(Opcode&(1<<9))
{
return LEASPTOSP;
}
else
{
if(Opcode&(1<<8))
{
}
else
{
switch(EXTRACT(Opcode,4,7))
{
case 0:
return EXTB;
case 1:
return EXTS;
case 8:
return JR;
case 9:
return CALLR;
case 10:
return SET;
case 11:
return CLR;
case 12:
return SWI;
case 13:
return HALT;
}
}
}
}
}
break;
case 3:
switch(EXTRACT(Opcode,9,11))
{
case 0:
case 1:
case 2:
case 3:
switch(EXTRACT(Opcode,3,4))
{
case 0:
return ASR;
case 1:
return LSR;
case 2:
return ASL;
//case 3:
// return LSL;
}
break;
case 4:
return MULS;
case 6:
if(Opcode&(1<<3))
return MVFC;
else
return MVTC;
break;
}
break;
}
break;
}
return INVALIDOP;
}