ESPKit/sources/esplib.c

/*
==================================================
 Implementation of Sprinter-WiFi ISA Card Library
 Author: Roman A. Boykov
 License: BSD 3-Clause
==================================================
*/

#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <string.h>
#include "esplib.h"

#ifdef ESTEX
#pragma nonrec
#define outb(port, b) mset(port, b);
#define inb(port) mget(port);
#else
#define outb(port, b) outp(port, b);
#define inb(port) inp(port);
#endif


void util_delay(unsigned delay_ms)
{
#ifdef ESTEX
   if (delay_ms==0) {
      delay_ms = 20;
   }
	unsigned ctr;
	for (ctr = 0; ctr < delay_ms*1000; ctr++)
	{
   }
#else
   clock_t t;
   t = clock() + delay_ms;
   while (clock() < t) {
   }

	//delay(delay_ms);
#endif
}

char save_mmu3 = 0;       // Variable to save Sprinter memory mapping
char isa_slot = -1;       // Variable to storeISA slot number where WiFi card found

char isa_init()
{
    char wifi_found;
    wifi_found = find_wifi();
    if (wifi_found) {
       isa_reset();
       return 1;
    } else {
       return 0;
    }
}


void isa_reset()
{
#ifdef ESTEX
   outp(port_isa, ISA_RESET | ISA_AEN); // RESET=1 AEN=1
   delay(20);
   outp(port_isa, 0);    // RESET=0 AEN=0
   delay(40);
#endif
}


void isa_open()
{
#ifdef ESTEX
   save_mmu3 = inp(PORT_MMU3);
	outp(PORT_SYSTEM, 0x11);
	outp(PORT_MMU3, ((isa_slot & 0x01) << 1) | 0xd4);
#endif
}

void isa_close()
{
#ifdef ESTEX
   outp(PORT_SYSTEM, 0x01);
   // restore mmu3 (Close ISA ports memory mapping)
   outp(PORT_MMU3, save_mmu3);
#endif
}

char isa_get_slot()
{
    return isa_slot;
}

char check_slot(char slot)
{
    char irr;
    isa_slot = slot;
	 isa_open();
	 irr = inb(REG_IIR);
    isa_close();
    return irr & 0x3F;
}


char find_wifi()
{
    // check isa slot 0
	 char exists;
    exists = check_slot(0);
    if (exists) {
	return 1;
    } else {
#ifdef ESTEX
	return check_slot(1);
#else
	return 0;
#endif
    }
}


// MODULE uart

void uart_init()
{
	 isa_open();
	 // enable FIFO buffer, trigger to 14 byte
	 outb(REG_FCR, FCR_TR14 | FCR_FIFO);
	 // Disable interrupts
	 outb(REG_IER, 0x00);
	 // Set 8bit word and Divisor for speed
	 outb(REG_LCR, LCR_DLAB | LCR_WL8);  // enable Baud rate latch
	 outb(REG_DLL, DIVISOR);
	 outb(REG_DLM, 0x00);
	 outb(REG_LCR, LCR_WL8);             // 8bit word
	 isa_close();
}

char uart_read(reg)
unsigned reg;
{
	 char res;
	 isa_open();
	 res = inb(reg);
	 isa_close();
	 return res;
}

void uart_write(reg, value)
unsigned reg;
char value;
{
	 isa_open();
	 outb(reg, value);
	 isa_close();
}

char uart_wait_tr()
{
	 char res;
	 char loops = 100;
	 while (loops>0)
	 {
		  res = uart_read(REG_LSR);

		  if (res & LSR_THRE) {
			 break;
		  }

		  loops--;
		  util_delay(1);
	 }
	 return loops;
}

char uart_tx_byte(byte)
char byte;
{
	char ready = uart_wait_tr();
	if (ready){
		uart_write(REG_THR, byte);
	}
	return ready;
}

char uart_tx_buffer(char* tbuff, int size)
{
	int ctr = size;
	while (ctr--) {
		if (uart_wait_tr()) {
		  uart_write(REG_THR, *tbuff++);
		} else {
		  return RESULT_TX_TIMEOUT;
		}
	}
	return RESULT_OK;
}

char uart_tx_cmd(char* tx_buff, char* rs_buff, int size, int wait_ms)
{
	char resp = RESULT_OK;
	char rcv, *buff;
	char lstr[LSTR_SIZE];
	int  lstrp = 0;
   buff = rs_buff;
   buff[size-1] = 0; // mark last byte of buffer as end of string
   size--;
	uart_empty_rs();

	if (uart_tx_buffer(tx_buff, strlen(tx_buff)) == RESULT_OK) {
		while (1) {
		  if (uart_wait_rs(wait_ms)) {
			 rcv = uart_read(REG_RBR);
          if (size > 0 && rcv != CR) { // ignore CR
             *buff++ = rcv;
             size--;
          }
			 if (rcv == CR || rcv == LF) {

				 lstr[lstrp] = 0;

				 if (strcmp(lstr, "OK")==0) {
					break;
				 }

				 if (strcmp(lstr, "ERROR")==0) {
					resp = RESULT_ERROR;
					break;
				 }

             if (strcmp(lstr, "FAIL")==0) {
               resp = RESULT_FAIL;
               break;
             }

				 lstrp = 0;
			 }

			 if (lstrp<LSTR_SIZE && rcv != CR && rcv != LF) {
				 lstr[lstrp++] = rcv;
			 }

		  } else {
#ifdef DEBUG
			 printf("No ansver to CMD, RCVR empty! %s\n", lstr);
#endif
			 return RESULT_RS_TIMEOUT;
		  }
		}
	   if (uart_wait_rs(1)) {
			 rcv = uart_read(REG_RBR); // read last LF
      }
      if (size > 0) {
         *buff = 0; // mark end of string
      }
#ifdef DEBUG
		printf(": '%s'\n", lstr);
#endif
	} else {
#ifdef DEBUG
	  printf("Cmd transmit error, TR not ready!\n");
#endif
	  return RESULT_TX_TIMEOUT;
	}
	return resp;
}


void uart_empty_rs()
{
	uart_write(REG_FCR, FCR_TR14 | FCR_RESET_RX | FCR_FIFO);
}

char uart_wait_rs(wait_ms)
int wait_ms;
{
	char res;
	unsigned loops;

	if (wait_ms<0) {
	  loops = 1;
	} else {
	  loops = wait_ms;
	}

	while (loops>0) {
		res = uart_read(REG_LSR) & LSR_DR;
		if (res){
			break;
		}
		loops--;
		util_delay(1);
	}

	return loops>0;
}



void esp_reset(char full)
{
	isa_open();
   if (full) {
	   outb(REG_MCR, MCR_RST | MCR_RTS)    // 0110b ESP  -PGM=1, -RST=0, -RTS=0
	   util_delay(20);
   }
	outb(REG_MCR, MCR_AFE | MCR_RTS)    // 0x0202 -RST = 1 -RTS=0 AutoFlow enabled
	isa_close();
   if (full) {
	   util_delay(1000);
   }
}