int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout,
void *din, unsigned long flags)
{
struct sh_spi *ss = to_sh_spi(slave);
const unsigned char *tx_data = dout;
unsigned char *rx_data = din;
unsigned int len = bitlen / 8;
int ret = 0;
if (flags & SPI_XFER_BEGIN)
sh_spi_write(sh_spi_read(&ss->regs->cr1) & ~SH_SPI_SSA,
&ss->regs->cr1);
if (tx_data)
ret = sh_spi_send(ss, tx_data, len, flags);
if (ret == 0 && rx_data)
ret = sh_spi_receive(ss, rx_data, len, flags);
if (flags & SPI_XFER_END) {
sh_spi_set_bit(SH_SPI_SSD, &ss->regs->cr1);
udelay(100);
sh_spi_clear_bit(SH_SPI_SSA | SH_SPI_SSDB | SH_SPI_SSD,
&ss->regs->cr1);
clear_fifo(ss);
}
return ret;
}
void octopus_keyboard_device::device_reset()
{
buffered_rs232_device::device_reset();
set_data_frame(1, 8, PARITY_NONE, STOP_BITS_1);
set_rcv_rate(1200);
set_tra_rate(9600);
receive_register_reset();
transmit_register_reset();
m_enabled = 0;
m_delay = 500; // 3*100+200
m_repeat = 110; // 4^2*5+30
stop_processing();
reset_key_state();
typematic_stop();
clear_fifo();
output_dcd(0);
output_dsr(0);
output_cts(0);
output_rxd(1);
start_processing(attotime::from_hz(9600));
}
struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
unsigned int max_hz, unsigned int mode)
{
struct sh_spi *ss;
if (!spi_cs_is_valid(bus, cs))
return NULL;
ss = malloc(sizeof(struct spi_slave));
if (!ss)
return NULL;
ss->slave.bus = bus;
ss->slave.cs = cs;
ss->regs = (struct sh_spi_regs *)CONFIG_SH_SPI_BASE;
/* SPI sycle stop */
sh_spi_write(0xfe, &ss->regs->cr1);
/* CR1 init */
sh_spi_write(0x00, &ss->regs->cr1);
/* CR3 init */
sh_spi_write(0x00, &ss->regs->cr3);
clear_fifo(ss);
/* 1/8 clock */
sh_spi_write(sh_spi_read(&ss->regs->cr2) | 0x07, &ss->regs->cr2);
udelay(10);
return &ss->slave;
}
void apricot_keyboard_hle_device::received_byte(uint8_t byte)
{
if ((byte & 0xf0) == 0xf0)
{
// rtc data
if (m_rtc_index >= 0)
{
m_rtc->address_w(m_rtc_index--);
m_rtc->data_w(machine().dummy_space(), 0, byte);
m_rtc->write_w(1);
m_rtc->write_w(0);
}
}
else
{
switch (byte)
{
case CMD_REQ_TIME_AND_DATE:
logerror("System requests current time\n");
// remove pending keys just in case
clear_fifo();
// send time prefix
transmit_byte(0xed);
// make rtc chip ready
m_rtc->cs_w(1);
m_rtc->read_w(1);
// send bcd encoded date and time to system
for (int i = 12; i >= 0; i--)
{
m_rtc->address_w(i);
transmit_byte(0xf0 | m_rtc->data_r(machine().dummy_space(), 0));
}
break;
case CMD_SET_TIME_AND_DATE:
logerror("System requests to set time\n");
// we start with the year
m_rtc_index = 12;
// make rtc chip ready
m_rtc->cs_w(1);
break;
case CMD_KEYBOARD_RESET:
logerror("System requests keyboard reset\n");
transmit_byte(ACK_DIAGNOSTICS);
break;
default:
logerror("Unhandled command: %02x\n", byte);
}
}
}
void init_rs232()
{
//printf("UART Initialization\n");
uart = alt_up_rs232_open_dev("/dev/rs232");
clear_fifo();
}
size_t i2c::command(uint8_t slaveaddr,
uint8_t cmd,
const uint8_t* data_addr,
size_t data_size)
{
reset_txfer_done();
set_slave_address(slaveaddr);
set_data_len(1 + data_size);
initiate_write();
write_byte(cmd);
size_t bytes_sent=1;
while (data_size>0)
{
if (write_byte(*data_addr))
{
data_addr++;
data_size--;
bytes_sent++;
}
// TODO check for error conditions
}
wait_for_done();
clear_fifo();
return bytes_sent;
}
//Sends the sound file names to android
void send_fnames(char * filenames[], int numfiles)
{
int i,j;
int size;
char * ptr;
rs_flag = false;
clear_fifo();
printf("Sending the message to the Middleman\n");
for (j = 0; j < numfiles; j++) {
alt_up_rs232_write_data(uart, 2);
alt_up_rs232_write_data(uart, j);
size = strlen(filenames[j]);
ptr = filenames[j];
//Make sure there is space
while(alt_up_rs232_get_available_space_in_write_FIFO(uart) < (size + 2));
// Now send the actual message to the Middleman
for (i = 0; i < size; i++) {
alt_up_rs232_write_data(uart, *(ptr + i));
}
wait();
do {
if (rs_flag == true) {
alt_up_rs232_read_data(uart, &data, &parity);
}
////////////////////////////
//TO BE COMMENTED OUT, this is my delay simulation for android
/*
testvalue++;
if (testvalue == 1000000) {
alt_up_rs232_write_data(uart, (unsigned char)ACK);
testvalue = 0;
}
*/
/////////////////////////////
}while(data != ACK);
clear_fifo();
}
}
uint8_t i2c::query(uint8_t slaveaddr,
uint8_t slave_register)
{
command(slaveaddr, slave_register);
initiate_read();
uint8_t b;
while (!read_byte(b)); // loop until success
clear_fifo();
// TODO error conditions?
return b;
}
void apricot_keyboard_hle_device::device_reset()
{
clear_fifo();
receive_register_reset();
transmit_register_reset();
set_data_frame(1, 8, PARITY_NONE, STOP_BITS_1);
set_rcv_rate(7800);
set_tra_rate(7800);
reset_key_state();
start_processing(attotime::from_hz(7800));
}
/******************************************
go to rx mode
*******************************************/
void to_rx_mode(void)
{
uint8_t i=0;
to_ready_mode();
clear_fifo();
while (to_rx_mode_table[i]!=0xFFFF)
{
spi_write_command(to_rx_mode_table[i]);
i++;
}
}
void m20_keyboard_device::device_reset()
{
buffered_rs232_device::device_reset();
reset_key_state();
clear_fifo();
set_data_frame(1, 8, PARITY_NONE, STOP_BITS_2);
set_rate(1'200);
receive_register_reset();
transmit_register_reset();
output_dcd(0);
output_dsr(0);
output_cts(0);
output_rxd(1);
start_processing(attotime::from_hz(1'200));
}
void ContinueAlg::continious(void) {
std::shared_ptr<const DataADC> pd;
for (;;) {
if (!check_valid_theard())
break;
pd = pop_fifo();
if (pd == nullptr)
continue;
size_t sizeBuf = pd->get_amount() * 4 * sizeof(short) + offsetof(DataAlgorithm, data);
if(buf_.size() < sizeBuf)
buf_.resize(sizeBuf);
DataAlgorithm *pDataAlg = reinterpret_cast<DataAlgorithm*>(buf_.data());
pDataAlg->numFirstCount = pd->get_first();
//передача данных на берег
memcpy(&pDataAlg->data, pd->get_data(), sizeBuf - offsetof(DataAlgorithm, data));
pass_(&buf_, sizeBuf, CONTINIOUS, pd);
}
clear_fifo();
return;
}
size_t i2c::query(uint8_t slaveaddr,
uint8_t slave_register,
uint8_t* buffer,
size_t buffer_size)
{
enum { READ_MULTIPLE=0x080 };
command(slaveaddr, slave_register | READ_MULTIPLE);
set_data_len(buffer_size);
initiate_read();
size_t bytes_read=0;
while (buffer_size > 0)
{
if (read_byte(*buffer))
{
buffer_size--;
bytes_read++;
buffer++;
}
// TODO check for error conditions
}
clear_fifo();
return bytes_read;
}
void x68k_keyboard_device::device_reset()
{
buffered_rs232_device::device_reset();
set_data_frame(1, 8, PARITY_NONE, STOP_BITS_1);
set_rate(38'400); // TODO: Should be 2400 but MC68901 doesn't support divide by 16
receive_register_reset();
transmit_register_reset();
m_enabled = 0;
m_delay = 500; // 3*100+200
m_repeat = 110; // 4^2*5+30
stop_processing();
reset_key_state();
typematic_stop();
clear_fifo();
output_dcd(0);
output_dsr(0);
output_cts(0);
output_rxd(1);
}
//DE2 waits for command from Android/middleman
void listen(char * soundfiles[], int numwavfiles, audisr * audmode)
{
printf("Listening\n");
int volume_index_up = 10;
int volume_index_down = 10;
int func;
bool headerfound = false;
int volume;
clear_fifo();
//stop_timer();
start_timer();
while(1)
{
if(rs_flag == true) {
if (headerfound == false) {
//Loop check header
if (rs_flag == true) {
alt_up_rs232_read_data(uart, &data, &parity);
if ((int)data == 1) {
headerfound = true;
while((int)data == 1) {
alt_up_rs232_read_data(uart, &data, &parity);
}
}
}
}
else {
//Function get
alt_up_rs232_read_data(uart, &data, &parity);
func = (int)data;
if (func == QUEUE) {
alt_up_audio_disable_write_interrupt(audio);
audmode->id = get_fnames(soundfiles,numwavfiles);
//alt_up_audio_enable_write_interrupt(audio);
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == PLAY) {
alt_up_audio_enable_write_interrupt(audio);
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == STOP) {
alt_up_audio_disable_write_interrupt(audio);
audio_isr_k = 0;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == PAUSE) {
alt_up_audio_disable_write_interrupt(audio);
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
/*
else if (func == VOLUME) {
int volumetemp;
do {
while(rs_flag == false);
alt_up_rs232_read_data(uart, &data, &parity);
volumetemp = (int)data;
}while((volumetemp == VOLUME) || (volumetemp == 0));
// alt_up_rs232_read_data(uart, &data, &parity);
volume = volumetemp;
if (volume == VOL_UP) {
volume_index_up += 3;
if (volume_index_up > 127) {
volume_index_up = 127;
}
printf("Up %d\n", volume_index_up);
audmode->newvolume = volume_index_up;
volume_index_down = 10;
}
else if (volume == VOL_DOWN) {
volume_index_down--;
if (volume_index_down < 1) {
volume_index_down = 1;
}
printf("Down %d\n", volume_index_down);
audmode->newvolume = volume_index_down;
volume_index_up = 10;
}
else {
printf("Error, unknown volume value %d\n", volume);
}
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
*/
else if (func == VOL_UP) {
volume_index_up += 5;
if (volume_index_up > 127) {
volume_index_up = 127;
}
printf("Up %d\n", volume_index_up);
audmode->newvolume = volume_index_up;
volume_index_down = 10;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == VOL_DOWN) {
volume_index_down--;
if (volume_index_down < 1) {
volume_index_down = 1;
}
printf("Down %d\n", volume_index_down);
audmode->newvolume = volume_index_down;
volume_index_up = 10;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == SELECT) {
int index = 0;
do {
if (rs_flag == true)
alt_up_rs232_read_data(uart, &data, &parity);
}while((int)data == SELECT);
index = (int)data;
if ((index < 0) || (index >= numwavfiles)) {
printf("Error, index out of bounds, playing index 0\n");
index = 0;
}
alt_up_audio_disable_write_interrupt(audio);
audmode->id = index;
printf("Changing to song: %s, Id: %d\n", soundfiles[audmode->id], audmode->id);
alt_up_audio_enable_write_interrupt(audio);
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == S_LOOP) {
printf("Loop song\n");
audmode->loop = true;
audmode->listloop = false;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == Q_LOOP) {
printf("List loop\n");
audmode->listloop = true;
audmode->loop = false;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == C_LOOP) {
printf("Cancel loops\n");
audmode->listloop = false;
audmode->loop = false;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == SEND) {
send_fnames(soundfiles, numwavfiles);
alt_up_rs232_write_data(uart, ACK);
}
else if (func == NEXT) {
alt_up_audio_disable_write_interrupt(audio);
audmode->id += 1;
if(audmode->id >= numwavfiles) {
audmode->id = numwavfiles - 1;
}
printf("Changing to song Id: %d\n", audmode->id);
alt_up_audio_enable_write_interrupt(audio);
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == PREVIOUS) {
alt_up_audio_disable_write_interrupt(audio);
audmode->id -= 1;
if(audmode->id < 0) {
audmode->id = 0;
}
printf("Changing to song Id: %d\n", audmode->id);
alt_up_audio_enable_write_interrupt(audio);
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == MIX) {
audmode->mode = 1;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == SHUFFLE) {
if(audmode->shuffle == true) {
audmode->shuffle = false;
}
else {
audmode->shuffle = true;
}
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if (func == VISUALON) {
visualflag = !visualflag;
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
else if ((func != 1) && (func != 0)) {
printf("Error, Function %d not implemented yet, or invalid\n", (int)data);
headerfound = false;
alt_up_rs232_write_data(uart, ACK);
}
}
}
}
stop_timer();
}
void send_filenames(char * filenames[], int numfiles)
{
int i,j;
int size;
char * ptr;
clear_fifo();
printf("Sending the message to the Middleman\n");
//Start with header
alt_up_rs232_write_data(uart, (unsigned char) HEAD);
//Function protocol
alt_up_rs232_write_data(uart, (unsigned char) 3);
//NumFiles
alt_up_rs232_write_data(uart, (unsigned char) numfiles);
/*
wait();
alt_up_rs232_read_data(uart, &data, &parity);
printf("%d files.\n", (int)data);
*/
for (j = 0; j < numfiles; j++) {
size = strlen(filenames[j]);
ptr = filenames[j];
//Make sure there is space
while(alt_up_rs232_get_available_space_in_write_FIFO(uart) < ((size * 2) + 2));
// Start with the number of bytes in our message
alt_up_rs232_write_data(uart, (unsigned char)size);
// Now send the actual message to the Middleman
for (i = 0; i < size; i++) {
alt_up_rs232_write_data(uart, *(ptr + i));
//Send ETX
alt_up_rs232_write_data(uart, (unsigned char) ETX);
}
alt_up_rs232_write_data(uart, (unsigned char) ETB);
wait();
//emulate_ack();
emulate_ack2();
wait();
alt_up_rs232_read_data(uart, &data, &parity);
//printf("%d\n", (int)data);
if (data != ACK) {
printf("Error, Acknowledge was not received.\n");
}
else
printf("Acknowledge received.\n");
clear_fifo();
if (j == (numfiles - 1)) {
//End of Transmission
alt_up_rs232_write_data(uart, (unsigned char) EOT);
}
}
wait();
alt_up_rs232_read_data(uart, &data, &parity);
printf("I received %d\n", (int)data);
}
/*
* Handle our "Vendor Extension" commands on endpoint 0.
* If we handle this one, return non-zero.
*/
unsigned char
app_vendor_cmd (void)
{
if (bRequestType == VRT_VENDOR_IN) {
/////////////////////////////////
// handle the IN requests
/////////////////////////////////
switch (bRequest) {
case VRQ_GET_STATUS: //this is no longer done via FX2 -- the FPGA will be queried instead
return 0;
break;
case VRQ_I2C_READ:
if (!i2c_read (wValueL, EP0BUF, wLengthL)) return 0;
EP0BCH = 0;
EP0BCL = wLengthL;
break;
case VRQ_SPI_READ:
return 0;
case VRQ_FW_COMPAT:
EP0BCH = 0;
EP0BCL = 3;
break;
default:
return 0;
}
}
else if (bRequestType == VRT_VENDOR_OUT) {
/////////////////////////////////
// handle the OUT requests
/////////////////////////////////
switch (bRequest) {
case VRQ_SET_LED:
switch (wIndexL) {
case 0:
set_led_0 (wValueL);
break;
case 1:
set_led_1 (wValueL);
break;
default:
return 0;
}
break;
case VRQ_FPGA_LOAD:
switch (wIndexL) { // sub-command
case FL_BEGIN:
return fpga_load_begin ();
case FL_XFER:
get_ep0_data ();
return fpga_load_xfer (EP0BUF, EP0BCL);
case FL_END:
return fpga_load_end ();
default:
return 0;
}
break;
case VRQ_FPGA_SET_RESET:
fpga_reset(wValueL);
break;
case VRQ_I2C_WRITE:
get_ep0_data ();
if (!i2c_write (wValueL, EP0BUF, EP0BCL)) return 0;
//SMINI_LED_REG ^= bmLED1;
break;
case VRQ_RESET_GPIF:
clear_fifo(wValueL);
break;
case VRQ_ENABLE_GPIF:
enable_xfers(wValueL);
break;
case VRQ_CLEAR_FPGA_FIFO:
//clear_fpga_data_fifo();
break;
default:
return 0;
}
}
else
return 0; // invalid bRequestType
return 1;
}
static void kbd_int_handler(int irq, void *dev_id, struct pt_regs *regs)
{
struct cir_port *cir;
int j;
unsigned char int_status;
cir = (struct cir_port *)dev_id;
int_status = get_int_status(cir);;
if (int_status & 0x4) {
clear_fifo(cir);
return;
}
while (cir_get_rx_count(cir)) {
cir_data[data_index] = cir_read_data(cir);
if (data_index == 0) {/* expecting first byte */
if (cir_data[data_index] != leading1) {
//printk("!leading byte %x\n", cir_data[data_index]);
set_rx_active(cir);
clear_fifo(cir);
continue;
}
}
if (data_index == 1) {
if ((cir_data[data_index] & 0xf) != leading2) {
set_rx_active(cir);
data_index = 0; /* start over */
clear_fifo(cir);
continue;
}
}
if ( (cir_data[data_index] == 0xff)) { /* last byte */
//printk("data_index %d\n", data_index);
set_rx_active(cir);
#if 0
for (j=0; j<=data_index; j++) {
printk("rx_data %d: %x\n", j, cir_data[j]);
}
#endif
data_index = 0;
handle_data(cir_data);
return;
}
else if (data_index>16) {
set_rx_active(cir);
#if 0
printk("warning: data_index %d\n", data_index);
for (j=0; j<=data_index; j++) {
printk("rx_data %d: %x\n", j, cir_data[j]);
}
#endif
data_index = 0;
clear_fifo(cir);
return;
}
data_index++;
}
}
/***********************************************
go to tx mode(transmit data leSS_RFM than 64byte)
************************************************/
void to_tx_mode(void)
{
to_ready_mode();
_delay_us(200);
unsigned char j,k;
txError=0;
clear_fifo();
spi_write(0x3E, txBufCnt);
_RFM_SPCR
_SS_AKT //start SS_RFM
_delay_us(1);
SPDR=0xff; //adres
while(!(SPSR & (1<<SPIF)));
for (k=0;k<txBufCnt;k++)
{ //dane
SPDR=txBufTab[k];
while(!(SPSR & (1<<SPIF)));
}
txBufCnt=0;
_delay_us(1);
_SS_DEZ
_delay_us(1);
j=0;/*
while (to_tx_mode_table[j]!=0xFFFF)
{
spi_write_command(to_tx_mode_table[j]);
j++;
}*/
spi_write_command(to_tx_mode_table[0]);
spi_write_command(to_tx_mode_table[1]);
ItStatus1 = spi_read(INTERRUPT_STATUS_1);
ItStatus2 = spi_read(INTERRUPT_STATUS_2);
spi_write_command(to_tx_mode_table[2]);
while(!(0x02&spi_read(0x02)));
//_delay_ms(50);
//tempStat1=spi_read(0x02);
#ifdef ODMIERZANIE_CZASU
txczas = czasomierz;
#endif
do
{
#ifdef ODMIERZANIE_CZASU
if (czasomierz>txczas+_STOMILI(TX_CZAS_CZEKANIA))
{
ItStatus2=spi_read(INTERRUPT_STATUS_2);
ItStatus1=spi_read(INTERRUPT_STATUS_1);
txError=1;
break;
}
#endif
}
#ifdef _RFM_NIRQ
while(_RFM_NIRQ); //zmienic na sprawdzanie flagi
//tempStat2=spi_read(0x02);
ItStatus2=spi_read(INTERRUPT_STATUS_2);
ItStatus1=spi_read(INTERRUPT_STATUS_1);
#else
while(!(spi_read(0x31)&0x01));
#endif
#ifdef TX_ERROR_RESET
if (txError)
{
RF23B_init_parameter();
//software_reset(); //module software reset
//_delay_ms(5); //delay 5ms,then re_Initialization the module
//RF23B_init_parameter();
}
#endif
to_rx_mode();
}
