/*
* Clear and Enable intterupt for keypad
* 1. Deassert BU9929FV INT pin by I2C read
* 2. Clear ICH2 GPIO[11] interrupt
* 3. Enable watch function of BU9929FV
* 4. Enable ICH2 GPIO[11] interrupt
*/
static void kpad_clear_and_enable_intr(void)
{
__u16 dummy;
/* clear interrupt */
out_raw(0xff); /* no raw is asserted */
bu9929gpio_in(0, &dummy); /* clear BU9929 intr. */
ichgpio_clear_intr(GPIO_SMBALERT); /* clear ICH2 GPIO intr. */
out_raw(0); /* assert all raw */
/* enable interrupt */
bu9929gpio_set_intrmode(0, BU9929_WATCH_ENABLE);
ichgpio_enable_intr(GPIO_SMBALERT);
}
int kpad_scan_line( SCANINFO *sinfo, unsigned int i)
{
__u8 col, downkey, upkey;
static __u8 row;
unsigned int j;
if (i == 0) row = 0x01;
out_raw(~row);
udelay(ROW_DELAY);
in_col(&col);
sinfo->key[i] = col;
if (~(sinfo->key[i]))
sinfo->push_flg = 1;
sinfo->diffkey[i] = sinfo->key[i] ^ sinfo->lastkey[i];
if (sinfo->diffkey[i]) {
downkey = ~sinfo->key[i] & sinfo->diffkey[i]; /* key went down */
upkey = sinfo->key[i] & sinfo->diffkey[i]; /* key went up */
for (j = 0, col=0x80; j < 8; j++, col >>= 1) {
if (downkey & col)
handle_scancode( KEYCODE(i, j), 1 );
else if ( upkey & col )
handle_scancode( KEYCODE(i, j) | KBUP, 0 );
}
}
bool emit_redirect_notification_decoded_dest(
v2_notification_t ntype,
const ip_address *dest_ip,
const char *dest_str,
const chunk_t *nonce, /* optional */
pb_stream *pbs)
{
struct ikev2_redirect_part gwi;
size_t id_len;
const unsigned char *id_bytes;
if (dest_ip == NULL) {
id_len = strlen(dest_str);
id_bytes = (const unsigned char *)dest_str;
} else {
passert(dest_str == NULL);
switch (addrtypeof(dest_ip)) {
case AF_INET:
gwi.gw_identity_type = GW_IPV4;
break;
case AF_INET6:
gwi.gw_identity_type = GW_IPV6;
break;
default:
bad_case(addrtypeof(dest_ip));
}
id_len = addrbytesptr_read(dest_ip, &id_bytes);
}
if (id_len > 0xFF) {
/* ??? what should we do? */
loglog(RC_LOG_SERIOUS, "redirect destination longer than 255 octets; ignoring");
return false;
}
gwi.gw_identity_len = id_len;
passert(nonce == NULL ||
(nonce->len >= IKEv2_MINIMUM_NONCE_SIZE &&
nonce->len <= IKEv2_MAXIMUM_NONCE_SIZE));
pb_stream gwid_pbs;
return
- emit_v2Npl(ntype, pbs, &gwid_pbs) &&
out_struct(&gwi, &ikev2_redirect_desc, &gwid_pbs, NULL) &&
out_raw(id_bytes, id_len , &gwid_pbs, "redirect ID") &&
(nonce == NULL || out_chunk(*nonce, &gwid_pbs, "redirect ID len")) &&
(close_output_pbs(&gwid_pbs), true);
}
bool ikev2_calculate_rsa_sha1(struct state *st
, enum phase1_role role
, unsigned char *idhash
, pb_stream *a_pbs)
{
unsigned char signed_octets[SHA1_DIGEST_SIZE+16];
size_t signed_len;
const struct connection *c = st->st_connection;
const struct RSA_private_key *k = get_RSA_private_key(c);
unsigned int sz;
if (k == NULL)
return 0; /* failure: no key to use */
sz = k->pub.k;
/*
* this is the prefix of the ASN/DER goop that lives inside RSA-SHA1
* signatures. If the signing hash changes, this needs to change
* too, but this function is specific to RSA-SHA1.
*/
memcpy(signed_octets, der_digestinfo, der_digestinfo_len);
ikev2_calculate_sighash(st, role, idhash
, st->st_firstpacket_me
, signed_octets+der_digestinfo_len);
signed_len = der_digestinfo_len + SHA1_DIGEST_SIZE;
passert(RSA_MIN_OCTETS <= sz && 4 + signed_len < sz && sz <= RSA_MAX_OCTETS);
DBG(DBG_CRYPT
, DBG_dump("v2rsa octets", signed_octets, signed_len));
{
u_char sig_val[RSA_MAX_OCTETS];
/* now generate signature blob */
sign_hash(k, signed_octets, signed_len
, sig_val, sz);
out_raw(sig_val, sz, a_pbs, "rsa signature");
}
return TRUE;
}
bool ikev2_calculate_rsa_sha1(struct state *st,
enum phase1_role role,
unsigned char *idhash,
pb_stream *a_pbs)
{
unsigned char signed_octets[SHA1_DIGEST_SIZE + 16];
size_t signed_len;
const struct connection *c = st->st_connection;
const struct RSA_private_key *k = get_RSA_private_key(c);
unsigned int sz;
if (k == NULL)
return FALSE; /* failure: no key to use */
sz = k->pub.k;
memcpy(signed_octets, der_digestinfo, der_digestinfo_len);
ikev2_calculate_sighash(st, role, idhash,
st->st_firstpacket_me,
signed_octets + der_digestinfo_len);
signed_len = der_digestinfo_len + SHA1_DIGEST_SIZE;
passert(RSA_MIN_OCTETS <= sz && 4 + signed_len < sz &&
sz <= RSA_MAX_OCTETS);
DBG(DBG_CRYPT,
DBG_dump("v2rsa octets", signed_octets, signed_len));
{
/* now generate signature blob */
u_char sig_val[RSA_MAX_OCTETS];
int shr;
shr = sign_hash(k, signed_octets, signed_len, sig_val, sz);
if (shr == 0)
return FALSE;
passert(shr == (int)sz);
if (!out_raw(sig_val, sz, a_pbs, "rsa signature"))
return FALSE;
}
return TRUE;
}
bool ikev2_calculate_psk_auth(struct state *st,
enum original_role role,
unsigned char *idhash,
pb_stream *a_pbs)
{
unsigned int hash_len = st->st_oakley.prf_hasher->hash_digest_len;
unsigned char signed_octets[hash_len];
if (!ikev2_calculate_psk_sighash(st, role, idhash,
st->st_firstpacket_me,
signed_octets))
return FALSE;
DBG(DBG_PRIVATE,
DBG_dump("PSK auth octets", signed_octets, hash_len ));
if (!out_raw(signed_octets, hash_len, a_pbs, "PSK auth"))
return FALSE;
return TRUE;
}
/*
* used by initiator to make chunk_t from ppk_id payload
* for sending it in PPK_ID Notify Payload over the wire
*/
bool emit_unified_ppk_id(struct ppk_id_payload *payl, pb_stream *pbs)
{
u_char type = PPK_ID_FIXED;
return out_raw(&type, sizeof(type), pbs, "PPK_ID_FIXED") &&
out_chunk(payl->ppk_id, pbs, "PPK_ID");
}
int main(int argc, char *argv[]) {
// mallocated stuff
float * wave_buffer;
float * aa_buffer;
float * work_buffer;
float * frame_buffer;
float * dft_bins;
unsigned int * frequencies;
unsigned int * volumes;
unsigned char * out_buffer;
unsigned char consolidate;
unsigned long wave_size, work_size;
unsigned int frame_size, frame_inc;
unsigned int i;
int ofs;
unsigned long idx;
unsigned long c, m, k, t, f;
unsigned int kmax;
float max_power;
float in_r, sum_r, sum_i;
float ratio;
unsigned long frame_idx = 0, frames;
char outfilepath[256];
unsigned int ext;
puts("PSGTalk 0.3 - furrtek 2017\n");
// Overlap = 0
// Data: ######################## (24)
// Frames: AAAAAAAA
// BBBBBBBB
// CCCCCCCC
// Count: 3
// Length: 8 = 24 / 3 * (0 + 1)
// Offset: 8 = Length * (1 - 0)
// Overlap = 0.5
// Data: ######################## (24)
// Frames: AAAAAAAAAAAA
// BBBBBBBBBBBB
// CCCCCCCCCCCC
// Count: 3
// Length: 12 = 24 / 3 * (0.5 + 1)
// Offset: Length * (1 - 0.5)
// Defaults
overlap = 0.25;
updates_per_frame = 2;
psg_channels = 3;
sim = 0;
mode = MODE_VGM;
fps = 60;
freq_res = 64;
if (parse_args(argc, argv))
return 1;
wave_size = load_wav(argv[argc - 1], &wave_buffer);
if (!wave_size) {
puts("Can't load wave file.\n");
return 1;
}
// Anti-alias filtering
aa_buffer = calloc(wave_size, sizeof(float));
if (aa_buffer == NULL) {
puts("Memory allocation failed\n");
free(wave_buffer);
return 1;
}
lowpass(wave_buffer, aa_buffer, 8192.0, samplerate_in, wave_size);
// Decimate
ratio = ((float)samplerate_in / 8192.0);
work_size = (int)(wave_size / ratio);
work_buffer = calloc(work_size, sizeof(float));
if (work_buffer == NULL) {
puts("Memory allocation failed\n");
free(wave_buffer);
free(aa_buffer);
return 1;
}
for (i = 0; i < work_size; i++)
work_buffer[i] = aa_buffer[(int)(i * ratio)];
update_rate = fps * updates_per_frame;
frame_size = (8192.0 * (overlap + 1.0)) / update_rate;
frame_inc = (float)frame_size * (1.0 - overlap);
m = 1; // Discrimination between power peaks
frames = work_size / frame_inc; // Total number of frames
freq_step = (8192 / freq_res) / 2;
frame_buffer = calloc(frame_size, sizeof(float));
dft_bins = calloc(freq_res, sizeof(float));
frequencies = calloc(frames * psg_channels, sizeof(unsigned int));
volumes = calloc(frames * psg_channels, sizeof(unsigned int));
if ((dft_bins == NULL) || (frame_buffer == NULL) || (frequencies == NULL) || (volumes == NULL)) {
puts("Memory allocation failed\n");
return 1;
}
if (!make_LUTs(frame_size)) {
puts("Table generation failed\n");
return 1;
}
// Show recap
printf("Frames: %lu\n", frames);
printf("Overlap: %u%%\n", (unsigned int)(overlap * 100.0));
printf("Samplerate: %luHz -> %uHz\n", samplerate_in, 8192);
printf("Resolution: %uHz\n", freq_step);
printf("Update rate: %u/frame (%uHz @ %ufps)\n", updates_per_frame, update_rate, fps);
printf("PSG channels: %u\n", psg_channels);
printf("Mode: %s\n", modestr[mode]);
f = 0;
do {
// Copy frame
memcpy(frame_buffer, &work_buffer[f], frame_size * sizeof(float));
// Apply window
for (t = 0; t < frame_size; t++)
frame_buffer[t] *= window_lut[t];
// Do DFT
for (k = 0; k < freq_res; k++) { // For each output element
sum_r = 0;
sum_i = 0;
for (t = 0; t < frame_size; t++) { // For each input element
c = ((32768 * t * k / 2) / frame_size) & 0x7FFF;
in_r = frame_buffer[t];
sum_r += (in_r * cos_lut[c]);
sum_i += (in_r * sin_lut[c]);
}
sum_r /= frame_size;
sum_i /= frame_size;
dft_bins[k] = sqrt((sum_i * sum_i) + (sum_r * sum_r));
//if (f == 0) printf("SAMP=%f POW=%f (%uHz)\n", frame_buffer[k], dft_bins[k], k * freq_step);
}
// Find highest peaks
consolidate = 0;
for (c = 0; c < psg_channels; c++) {
idx = (frame_idx * psg_channels) + c;
if (consolidate) {
max_power -= 0.4;
frequencies[idx] = frequencies[idx - 1];
volumes[idx] = lintolog(max_power);
} else {
// Find highest power and its associated frequency (skip DC bin)
max_power = 0;
for (k = 1; k < (frame_size - 1); k++) {
if (dft_bins[k] > max_power) {
max_power = dft_bins[k];
kmax = k;
}
}
// Clear surrounding bins if needed
for (t = 0; t < m; t++) {
ofs = kmax - t - 1;
if (ofs >= 0) dft_bins[ofs] = 0;
ofs = kmax + t + 1;
if (ofs < freq_res) dft_bins[ofs] = 0;
}
frequencies[idx] = kmax;
volumes[idx] = lintolog(max_power);
}
consolidate = (max_power >= 0.4) ? 1 : 0;
if (frame_idx == 0) printf("C%lu=%uHz\n", c, kmax * freq_step); // DEBUG
}
frame_idx++;
f += frame_inc;
printf("\rComputing frame %lu/%lu.", frame_idx, frames);
} while (f < (work_size - frame_size));
puts(" Done.\n");
// Generate output file
strcpy(outfilepath, argv[argc - 1]);
ext = strlen(outfilepath) - 3;
if (mode == MODE_VGM) {
outfilepath[ext++] = 'v';
outfilepath[ext++] = 'g';
outfilepath[ext] = 'm';
} else {
outfilepath[ext++] = 'b';
outfilepath[ext++] = 'i';
outfilepath[ext] = 'n';
}
FILE * fo = fopen(outfilepath, "wb");
if (mode == MODE_RAW) {
out_raw(&out_buffer, frequencies, volumes, frame_idx, freq_res);
} else if (mode == MODE_VGM) {
out_vgm(&out_buffer, frequencies, volumes, frame_idx);
} else if (mode == MODE_NGP) {
out_ngp(&out_buffer, frequencies, volumes, frame_idx);
}
fwrite(out_buffer, file_length, 1, fo);
fclose(fo);
free(out_buffer);
puts("Output file written.");
printf("Size: %lukB\n", file_length / 1024);
// Generate simulation file if needed
if (sim) {
if (gen_sim(frame_size, frame_idx, psg_channels, frequencies, volumes))
puts("\nSimulation file written.\n");
}
free(frequencies);
free(volumes);
free(frame_buffer);
free(wave_buffer);
free(work_buffer);
free(dft_bins);
system("pause");
//return 0;
return 0;
}
