HP85 GPIB Disk Emulator  1.0
HP85GPIBDiskEmulator
•All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
hal.c
Go to the documentation of this file.
1 
23 #include "user_config.h"
24 #include "hal.h"
25 
26 #ifdef ESP8266
27 #include <eagle_soc.h>
28 #endif
29 
30 #include <stdint.h>
31 #include <stdarg.h>
32 #include <string.h>
33 #include <math.h>
34 
35 #ifdef ESP8266
36 #include "hspi.h"
37 #include "gpio.h"
38 #endif
39 
40 #ifdef AVR
41 #include "gpio-1284p.h"
42 #endif
43 
44 #ifdef ESP8266
45 // =============================================
47 
52 void
53 gpio_pin_sfr_mode(int pin)
54 {
55  switch(pin)
56  {
57 
58  case 0:
59  PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
60  break;
61  case 1:
62  PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_GPIO1);
63  break;
64  case 2:
65  PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
66  break;
67  case 3:
68  PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_GPIO3);
69  break;
70  case 4: // some esp8266-12 boards have incorrect labels 4 and 5 swapped
71  PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO4_U, FUNC_GPIO4);
72  break;
73  case 5: // some esp8266-12 boards have incorrect labels 4 and 5 swapped
74  PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO5_U, FUNC_GPIO5);
75  break;
76  case 6:
77  PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_CLK_U, FUNC_GPIO6);
78  break;
79  case 7:
80  PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA0_U, FUNC_GPIO7);
81  break;
82  case 8:
83  PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA1_U, FUNC_GPIO8);
84  break;
85  case 9:
86  PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA2_U, FUNC_GPIO9);
87  break;
88  case 10:
89  PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA3_U, FUNC_GPIO10);
90  break;
91  case 11:
92  PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_CMD_U, FUNC_GPIO11);
93  break;
94  case 12:
95  PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12);
96  break;
97  case 13:
98  PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13);
99  break;
100  case 14:
101  PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, FUNC_GPIO14);
102  break;
103  case 15:
104  PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_GPIO15);
105  break;
106  case 16:
107 // mux configuration for XPD_DCDC to output rtc_gpio0
108  WRITE_PERI_REG(PAD_XPD_DCDC_CONF,
109  (READ_PERI_REG(PAD_XPD_DCDC_CONF) & 0xffffffbc) | (uint32)0x1);
110 //mux configuration for out enable
111  WRITE_PERI_REG(RTC_GPIO_CONF,
112  (READ_PERI_REG(RTC_GPIO_CONF) & (uint32)0xfffffffe) | (uint32)0x0);
113 //out enable
114  WRITE_PERI_REG(RTC_GPIO_ENABLE,
115  (READ_PERI_REG(RTC_GPIO_ENABLE) & (uint32)0xfffffffe) | (uint32)0x1);
116  break;
117  }
118 }
119 #endif
120 
121 #ifdef ESP8266
122 
127 void
128 gpio16_pin_dir(uint8_t out)
129 {
130 // mux XPD_DCDC to rtc_gpio0
131  WRITE_PERI_REG(PAD_XPD_DCDC_CONF,
132  (READ_PERI_REG(PAD_XPD_DCDC_CONF) & (uint32_t)0xffffffbc) | (uint32_t)1L);
133 
134 // mux out enable
135  WRITE_PERI_REG(RTC_GPIO_CONF,
136  (READ_PERI_REG(RTC_GPIO_CONF) & (uint32_t)0xfffffffe) | (uint32_t)0L);
137 
138 // out enable
139  WRITE_PERI_REG(RTC_GPIO_ENABLE,
140  (READ_PERI_REG(RTC_GPIO_ENABLE) & (uint32_t)0xfffffffe) | (uint32_t)out);
141 }
142 #endif // ESP8266
143 
150 void gpio_pin_out(uint8_t pin, uint8_t val)
151 {
152 #ifdef ESP8266
153  if(pin == 16)
154  {
155  if(val)
156  GPIO16_PIN_HI();
157  else
158  GPIO16_PIN_LOW();
159  }
160  else
161 #endif
162  if(val)
163  GPIO_PIN_HI(pin);
164  else
165  GPIO_PIN_LOW(pin);
166 }
167 
168 
174 uint8_t gpio_pin_rd(uint8_t pin)
175 {
176 #ifdef ESP8266
177  if(pin == 16)
178  {
179  return( GPIO16_PIN_RD() );
180  }
181  else
182 #endif
183  return( GPIO_PIN_RD(pin) );
184 }
185 
186 
187 // =============================================
189 
194 void chip_select_init(uint8_t pin)
195 {
196 //FIXME add address decoder options
197 #ifdef HAVE_DECODER
198 #error add address decoder code
199 #endif
200  GPIO_PIN_HI(pin);
201  GPIO_PIN_MODE(pin);
202 }
203 
204 
210 void chip_select(uint8_t pin)
211 {
212 //FIXME add address decoder options
213 #ifdef HAVE_DECODER
214 #error add address decoder code
215 #endif
216  GPIO_PIN_LOW(pin);
217 }
218 
219 
225 void chip_deselect(uint8_t pin)
226 {
227 //FIXME add address decoder options
228 #ifdef HAVE_DECODER
229 #error add address decoder code
230 #endif
231  GPIO_PIN_HI(pin);
232 }
233 
234 
235 // =============================================
237 
241 void chip_addr_init()
242 {
243 #ifdef ADDR_0
244  GPIO_PIN_LOW(ADDR_0);
245  GPIO_PIN_MODE(ADDR_0);
246 #endif
247 
248 #ifdef ADDR_1
249  GPIO_PIN_LOW(ADDR_1);
250  GPIO_PIN_MODE(ADDR_1);
251 #endif
252 
253 #ifdef ADDR_2
254  GPIO_PIN_LOW(ADDR_2);
255  GPIO_PIN_MODE(ADDR_2);
256 #endif
257 
258 #ifdef ADDR_3
259  GPIO_PIN_LOW(ADDR_3);
260  GPIO_PIN_MODE(ADDR_3);
261 #endif
262 }
263 
264 
271 void chip_addr(int addr __attribute__((unused)))
272 {
273 
274 #ifdef ADDR_0
275  if(addr & 1)
276  GPIO_PIN_HI(ADDR_0);
277  else
278  GPIO_PIN_LOW(ADDR_0);
279 #endif
280 #ifdef ADDR_1
281  if(addr & 2)
282  GPIO_PIN_HI(ADDR_1);
283  else
284  GPIO_PIN_LOW(ADDR_1);
285 #endif
286 #ifdef ADDR_2
287  if(addr & 4)
288  GPIO_PIN_HI(ADDR_2);
289  else
290  GPIO_PIN_LOW(ADDR_2);
291 #endif
292 #ifdef ADDR_3
293  if(addr & 8)
294  GPIO_PIN_HI(ADDR_3);
295  else
296  GPIO_PIN_LOW(ADDR_3);
297 #endif
298 }
299 
300 
301 // =============================================
303 
307 void spi_waitReady()
308 {
309 #ifdef AVR
310 #endif
311 #ifdef ESP8266
312  hspi_waitReady();
313 #endif
314 }
315 
316 
326 uint8_t _cs_pin = 0xff;
327 uint32_t _spi_clock = -1L;
328 void spi_init(uint32_t clock, int pin)
329 {
330  spi_waitReady();
331  chip_deselect(pin);
332  _cs_pin = 0xff;
333 
334 #ifdef AVR
335  SPI0_Init(clock); // Initialize the SPI bus - does nothing if clock unchanged
336  SPI0_Mode(0); // Set the clocking mode, etc
337 #endif
338 #ifdef ESP8266
339  hspi_init(clock,0); // Initialize the SPI bus - does nothing if clock unchanged
340 #endif
341  spi_TX(0xff);
342  _spi_clock = clock;
343 // waits for any prior transactions to complete before updating
344  spi_waitReady();
345 }
346 
347 
357 void spi_begin(uint32_t clock, int pin)
358 {
359 // FIXME allow nesting by using an array of clock values for each pin
360 
361 //@brief if there is a prior chip select in progress flag an error
362  if(_cs_pin != 0xff)
363  {
364 // This implies a bug!
365  printf("cs_enable was: %d, want: %d\n", 0xff & _cs_pin, pin);
366  }
367 
368 // waits for any prior transactions to complete before updating
369  spi_waitReady();
370 
373  if(_spi_clock != clock)
374  {
375  spi_init(clock,pin);
376  }
377 
378  chip_select(pin);
379  _cs_pin = pin;
380 }
381 
382 
391 void spi_end(uint8_t pin)
392 {
393 // DEBUG
394 // FIXME allow nesting
395  if(_cs_pin != pin && _cs_pin != 0xff )
396  {
397 // This implies a bug!
398  printf("cs_disable was: %d, want: %d\n", 0xff & _cs_pin, pin);
399  }
400  spi_waitReady();
401  chip_deselect(pin);
402  _cs_pin = 0xff;
403 }
404 
405 
408 uint8_t spi_chip_select_status()
409 {
410  return(_cs_pin);
411 }
412 
413 
418 void spi_TX_buffer(const uint8_t *data, int count)
419 {
420 #ifdef ESP8266
421  hspi_TX((uint8_t *) data,count);
422 #endif
423 #ifdef AVR
424  SPI0_TX((uint8_t *) data,count);
425 #endif
426 }
427 
428 
433 void spi_RX_buffer(const uint8_t *data, int count)
434 {
435 #ifdef ESP8266
436  hspi_RX((uint8_t *) data,count);
437 #endif
438 #ifdef AVR
439  SPI0_RX((uint8_t *)data,count);
440 #endif
441 }
442 
443 
448 void spi_TXRX_buffer(const uint8_t *data, int count)
449 {
450 #ifdef ESP8266
451  hspi_TXRX((uint8_t *) data,count);
452 #endif
453 #ifdef AVR
454  SPI0_TXRX((uint8_t *) data,count);
455 #endif
456 }
457 
458 
461 uint8_t spi_RX()
462 {
463  uint8_t data;
464 #ifdef ESP8266
465  hspi_RX(&data,1);
466 #endif
467 #ifdef AVR
468  SPI0_RX(&data,1);
469 #endif
470  return(data);
471 }
472 
473 
477 void spi_TX(uint8_t data)
478 {
479 #ifdef ESP8266
480  hspi_TX(&data,1);
481 #endif
482 #ifdef AVR
483  SPI0_TX(&data,1);
484 #endif
485 }
486 
487 
491 uint8_t spi_TXRX(uint8_t data)
492 {
493 #ifdef ESP8266
494  hspi_TXRX(&data,1);
495 #endif
496 #ifdef AVR
497  SPI0_TXRX(&data,1);
498 #endif
499  return(data);
500 }
501 
502 static uint8_t error_flag = 0;
505 void set_error(uint8_t error)
506 {
507  error_flag = error;
508  GPIO_PIN_HI(LED2);
509 }
510 
513 void clear_error()
514 {
515  error_flag = 0;
516  GPIO_PIN_LOW(LED2);
517 }
518 
521 uint8_t is_error()
522 {
523  return(error_flag);
524 }
_cs_pin
uint8_t _cs_pin
SPI init function Function waits for current tranaction to finish before proceeding.
Definition: hal.c:326
printf
MEMSPACE int printf(const char *format,...)
spi_TXRX
uint8_t spi_TXRX(uint8_t data)
SPI read and write 1 byte.
Definition: hal.c:491
hal.h
is_error
uint8_t is_error()
is error - test
Definition: hal.c:521
SPI0_Init
void SPI0_Init(uint32_t speed)
Initialize SPI0 device. See Atmel App Note AVR151 Set default speed, IO pins and mode.
Definition: spi.c:192
gpio-1284p.h
error_flag
static uint8_t error_flag
Definition: hal.c:502
chip_deselect
void chip_deselect(uint8_t pin)
set GPIO to deselect - HI
Definition: hal.c:225
spi_TX_buffer
void spi_TX_buffer(const uint8_t *data, int count)
SPI write buffer.
Definition: hal.c:418
gpio_pin_rd
uint8_t gpio_pin_rd(uint8_t pin)
read GPIO pin
Definition: hal.c:174
chip_addr
void chip_addr(int addr __attribute__((unused)))
set address on GPIO lines
Definition: hal.c:271
spi_TX
void spi_TX(uint8_t data)
SPI write 1 byte.
Definition: hal.c:477
clear_error
void clear_error()
Set error condition.
Definition: hal.c:513
user_config.h
Master Include for FatFs, RTC, Timers AVR8 - Part of HP85 disk emulator.
spi_RX
uint8_t spi_RX()
SPI read 1 byte.
Definition: hal.c:461
set_error
void set_error(uint8_t error)
Set error condition.
Definition: hal.c:505
gpio_pin_out
void gpio_pin_out(uint8_t pin, uint8_t val)
set GPIO pin state HI or LOW
Definition: hal.c:150
spi_chip_select_status
uint8_t spi_chip_select_status()
SPI CS pin status return CS GPIO pin number or 0xff.
Definition: hal.c:408
SPI0_RX
void SPI0_RX(uint8_t *data, int count)
HSPI read using FIFO.
Definition: spi.c:297
SPI0_TX
void SPI0_TX(uint8_t *data, int count)
SPI buffered write functions.
Definition: spi.c:264
SPI0_Mode
void SPI0_Mode(int mode)
Set SPI clock mode.
Definition: spi.c:150
spi_TXRX_buffer
void spi_TXRX_buffer(const uint8_t *data, int count)
SPI write/read buffer.
Definition: hal.c:448
chip_select_init
void chip_select_init(uint8_t pin)
CHIP select HAL.
Definition: hal.c:194
chip_addr_init
void chip_addr_init()
ADDRESS select HAL.
Definition: hal.c:241
_spi_clock
uint32_t _spi_clock
Definition: hal.c:327
spi_RX_buffer
void spi_RX_buffer(const uint8_t *data, int count)
SPI read buffer.
Definition: hal.c:433
spi_waitReady
void spi_waitReady()
SPI bus wrapper functions for multiple device support.
Definition: hal.c:307
spi_end
void spi_end(uint8_t pin)
SPI chip disable function wait for current tranaction to finish!
Definition: hal.c:391
spi_init
void spi_init(uint32_t clock, int pin)
Definition: hal.c:328
spi_begin
void spi_begin(uint32_t clock, int pin)
SPI chip enable function Function waits for current tranaction to finish before proceeding.
Definition: hal.c:357
chip_select
void chip_select(uint8_t pin)
set GPIO to select - LOW
Definition: hal.c:210
SPI0_TXRX
void SPI0_TXRX(uint8_t *data, int count)
HSPI write and read using FIFO.
Definition: spi.c:281
LED2
#define LED2
Definition: gpib_hal.h:76
Generated on Wed Apr 13 2022 21:56:48 for HP85 GPIB Disk Emulator by   doxygen 1.8.17