byte GDClass::rd(unsigned int addr)
{
__start(addr);
byte r = SPI.transfer(0);
__end();
return r;
}
void ar9170_set_state_when(struct ar9170 *ar, enum ar9170_device_state current, enum ar9170_device_state newstate)
{
__start(&ar->state_lock);
if (CHK_DEV_STATE(ar, current)) {
__ar9170_set_state(ar, newstate);
} else {
printf("WARNING: Device in wrong state.\n");
}
__complete(&ar->state_lock);
}
unsigned int GDClass::rd16(unsigned int addr)
{
unsigned int r;
__start(addr);
r = SPI.transfer(0);
r |= (SPI.transfer(0) << 8);
__end();
return r;
}
void up_systemswitch(uint32_t sys_addr)
{
typedef void (FAR *__start_t)(void);
__start_t __start;
__start = (__start_t) *(CODE uint32_t*) (sys_addr + 4);
setcontrol(getcontrol() & 0xfffffffc);
setmsp(*(CODE uint32_t*) sys_addr);
__start();
}
int SoftI2C_Read(const SoftI2C *i2c, uint8_t addr, uint8_t *dat, int len) {
int i;
__start(i2c); // start
__onebyte(i2c, (addr << 1) + 1); // addr + Write
if (0 != __onebit(i2c, 1)) { // check ACK
return 0;
}
for (i = 0; i < len; ++i) {
*dat++ = __onebyte(i2c, 0xFF);
__onebit(i2c, 0); // ACK
}
__stop(i2c);
return i;
}
int SoftI2C_Write(const SoftI2C *i2c, uint8_t addr, const uint8_t *dat, int len) {
int i;
__start(i2c); // start
__onebyte(i2c, addr << 1); // addr + Write
if (0 != __onebit(i2c, 1)) { // check ACK
return 0;
}
for (i = 0; i < len; ++i) {
__onebyte(i2c, *dat++);
if (0 != __onebit(i2c, 1)) { // check ACK
break;
}
}
__stop(i2c);
return i;
}
bool ar9170_usb_send_cmd(completion_t* lock, uint8_t* cmd, uint16_t cmd_len) {
/* Lock asynchronous command transfer. The flag must
* be released by the callback function, which is
* called upon transfer completion.
*/
__start(lock);
/* Block execution while the endpoint is not available. */
while(!uhi_vendor_int_is_available());
/* Copy the command data to the
* interrupt endpoint output buffer.
*/
memcpy(int_out_buffer, cmd, cmd_len);
/* Start transferring OUT on the interrupt endpoint.
* Return the status of the transfer upon completion.
*/
return (bool) uhi_vendor_int_out_run(int_out_buffer,
(iram_size_t) cmd_len, ar9170_interrupt_out_transfer_done);
}
void NativeWrapper::compute()
{
__start();
}
void ar9170_set_state(struct ar9170 *ar, enum ar9170_device_state newstate)
{
__start(&ar->state_lock);
__ar9170_set_state(ar, newstate);
__complete(&ar->state_lock);
}
void CMainLoop::start()
{
__is_run = true;
emit __start();
}
void __wstart(unsigned int addr) // start an SPI write transaction to addr
{
__start(0x8000|addr);
}
/// Start all io_service objects in nonblock model.
void start(bool block=false)
{
__start(block);
}
void GDClass::__wstartspr(unsigned int sprnum)
{
__start((0x8000 | RAM_SPR) + (sprnum << 2));
spr = 0;
}
bool ar9170_usb_write_reg(completion_t* lock, uint8_t* cmd, uint16_t cmd_len)
{
int i;
bool result;
UNUSED(i);
if (cmd_len > INTR_ENDPOINT_MAX_SIZE) {
printf("ERROR: Command exceeds maximum length: %d.\n",cmd_len);
return false;
}
struct ar9170* ar = ar9170_get_device();
/* Lock execution */
__start(&ar->cmd_buf_lock);
if (ar->cmd_list->buffer == NULL) {
if(ar->cmd_list->next_send_chunk != NULL) {
printf("ERROR: Command buffer is null while next command is not.\n");
return false;
}
/*
* If command buffer is ready, we place the current command in
* the list of pending commands, and we attempt the command
* transmission down to the device.
*/
ar->cmd_list->buffer = cmd;
ar->cmd_list->send_chunk_len = cmd_len;
__complete(&ar->cmd_buf_lock);
/* Actual command transfer occurs here */
result = ar9170_usb_send_cmd(lock, cmd, cmd_len);
if(result == false) {
printf("ERROR: CMD could not be send correctly.\n");
return result;
}
} else {
printf("WARNING: Non-empty command buffer.\n");
/* If the command buffer is non-empty, put the current command in
* the tail of the list and return.
*/
int counter = 0;
struct ar9170_send_list* next_pos = ar->cmd_list;
while(next_pos->next_send_chunk != NULL) {
counter++;
next_pos = next_pos->next_send_chunk;
}
if (counter > AR9170_MAX_CMD_BUFFER_LEN) {
printf("ERROR: Command buffer reached maximum length!\n");
return false;
}
next_pos->next_send_chunk = smalloc(sizeof(struct ar9170_send_list));
if (next_pos->next_send_chunk == NULL) {
printf("ERROR: Could not allocate memory for register write.\n");
__complete(&ar->cmd_buf_lock);
return false;
} else {
next_pos->next_send_chunk->buffer = cmd;
next_pos->next_send_chunk->send_chunk_len = cmd_len;
next_pos->next_send_chunk->next_send_chunk = NULL;
}
__complete(&ar->cmd_buf_lock);
}
return true;
}
bool ar9170_write_data( uint8_t* data, uint16_t tx_len, bool zero_packet_flag )
{
int i;
bool result = true;
UNUSED(i);
UNUSED(zero_packet_flag); // TODO - add the option to send through a vendor API command with zero packet disabled
if (tx_len > BULK_ENDPOINT_MAX_OUT_SIZE) {
printf("ERROR: Data exceeds maximum length: %d.\n",tx_len);
return false;
}
struct ar9170* ar = ar9170_get_device();
/* Lock access to the tx buffer. */
__start(&ar->tx_buf_lock);
if (ar->tx_list->buffer == NULL) {
/* Consistency check. */
if(ar->tx_list->next_send_chunk != NULL) {
printf("ERROR: TX buffer is null while next tx chunk is not.\n");
__complete(&ar->tx_buf_lock);
return false;
}
/*
* If the transmit buffer is empty, we place the current chunk in
* the chunks list and execute the tx submit directly. TODO check
* how to implement atomic read and write for safer implementation.
*/
ar->tx_list->buffer = data;
ar->tx_list->send_chunk_len = tx_len;
__complete(&ar->tx_buf_lock);
/* Lock asynchronous TX process, so no more
* packets can be sent down, until the current
* transfer finishes.
*/
__start(&ar->tx_async_lock);
/* The actual data is sent here. */
result = ar9170_usb_send_data(data, tx_len);
#if USB_CMD_WRAPPER_DEBUG_DEEP
printf("Bulk OUT [%u]: ",(unsigned int)tx_len);
for (i=0; i<tx_len; i++) {
printf("%02x ", bulk_out_buffer[i]);
}
printf(" \n");
#endif
if(result == false) {
printf("ERROR: Data could not be submitted correctly.\n");
/* Release asynchronous TX process, because we normally
* do not expect the callback to be called and release
* the asynchronous transmission flag.
*/
__complete(&ar->tx_async_lock);
return result;
}
} else {
printf("WARNING: Non-empty usb packet list.\n");
/* If the transmission buffer is non-empty, put the current command
* in the tail of the list and return.
*/
struct ar9170_send_list* next_pos = ar->tx_list;
while(next_pos->next_send_chunk != NULL) {
next_pos = next_pos->next_send_chunk;
}
next_pos->next_send_chunk = smalloc(sizeof(struct ar9170_send_list));
if (next_pos->next_send_chunk == NULL) {
printf("ERROR: Could not allocate memory for data bulk transfer.\n");
__complete(&ar->tx_buf_lock);
return false;
} else {
next_pos->next_send_chunk->buffer = data;
next_pos->next_send_chunk->send_chunk_len = tx_len;
next_pos->next_send_chunk->next_send_chunk = NULL;
}
__complete(&ar->tx_buf_lock);
}
/* Note that the asynchronous transmission flag is locked, and will be
* released by the callback, so no more data can be transfered down to
* the USB line before the current transmission is over.
*/
return result;
}
