void send_cmd_no_tms(int iTDI)
{
if(iTDI == 0)
{
if (tdi != 0)
{
GPIO_CLR(JTAG_TDI);
tdi = 0;
}
}
else
{
if (tdi != 1)
{
GPIO_SET(JTAG_TDI);
tdi = 1;
}
}
//nop_sleep(WAIT);
GPIO_SET(JTAG_TCK);
//nop_sleep(WAIT);
GPIO_CLR(JTAG_TCK);
//nop_sleep(WAIT);
}
//Entire file needs a rewrite, maybe routing table, for easy of transition in TAP controller
void UpdateState(int j_state, int iTMS)
{
switch(j_state)
{
case JTAG_RESET:
GPIO_SET(JTAG_TMS);
for(i=0; i<5; i++) //make sure we are in run-test/idle
{
nop_sleep(WAIT);
GPIO_CLR(JTAG_TCK);
nop_sleep(WAIT);
GPIO_SET(JTAG_TCK);
nop_sleep(WAIT);
}
GPIO_CLR(JTAG_TCK);
nop_sleep(WAIT);
jtag_state=JTAG_RESET;
break;
case JTAG_AUTO: //auto called when TMS is high, this one does no TMS=1,TCK=1
if((jtag_state & 0xFFE) < 15)
{
jtag_state++;
if(jtag_state > 5)
jtag_state = JTAG_RESET;
}
else if((jtag_state | 0x116) == 0x116) //if we are in UPDATE-IR/
jtag_state = JTAG_DR_SCAN;
break;
}
}
int
main()
{
if(init_gpio() == -1)
{
printf("Failed to map the physical GPIO registers into the virtual memory space.\n");
return (-1);
}
printf("Helloblink is started with GIOP%d at pin number 8.\n", LED_PIN);
// Define gpio 4 (LED) as output
INP_GPIO(LED_PIN);
OUT_GPIO(LED_PIN);
while(1)
{
GPIO_SET(LED_PIN);
usleep(100 * 1000);
GPIO_CLR(LED_PIN);
usleep(100 * 1000);
}
return 0;
}
/**
* device_write() - Called when a process writes to the device file
*/
static ssize_t device_write(struct file *filp,
const char *buff,
size_t len,
loff_t * off)
{
int i;
// Copy data from user space to kernel space.
for(i=0; i<len && i<BUF_LEN; i++)
{
get_user(msg[i], buff+i);
}
msg_Ptr = msg;
if(strcmp(msg_Ptr, "1") == 1)
{
printk(KERN_INFO "Put LED on\n");
GPIO_SET(GPIO_LED);
}
else
{
printk(KERN_INFO "Put LED off\n");
GPIO_CLR(GPIO_LED);
}
return i;
}
inline void digitalWrite(int g, int val)
{
if (val == LOW)
GPIO_CLR(g);
else
GPIO_SET(g);
}
static inline void leds_set(int state)
{
if (state % 2)
GPIO_SET(virt_addr) = (1 << gpio_nr);
else
GPIO_CLR(virt_addr) = (1 << gpio_nr);
}
void gpioSet(int pin, int v){
// Ottieni il numero BCM dal numero fornito
pin = libgpio_gpio_map[pin];
// Set/Clear cono in due registri separati quindi...
if(v) GPIO_SET(pin) = 1 << (pin & 0x1f);
else GPIO_CLR(pin) = 1 << (pin & 0x1f);
}
void resetPin(u32 bank, u8 pin) {
u32 pinMask = 0x1 << (pin);
#if defined(ARCH_SI32)
SET_REG(GPIO_CLR(bank), pinMask);
#elif defined(ARCH_STM32)
SET_REG(GPIO_BSRR(bank), pinMask << 16);
#endif // defined(ARCH_SI32)
}
void syncJTAGs()
{
GPIO_SET(JTAG_TMS);
for(i=0; i<5; i++) //make sure we are in run-test/idle
{
nop_sleep(WAIT);
GPIO_CLR(JTAG_TCK);
nop_sleep(WAIT);
GPIO_SET(JTAG_TCK);
nop_sleep(WAIT);
}
GPIO_CLR(JTAG_TCK);
nop_sleep(WAIT);
send_cmd(0,0); //Idle clock
send_cmd(0,1); //SELECT-DR-SCAN
jtag_state = JTAG_DR_SCAN;
}
// called in non-RT context
static ssize_t rpi_gpio_ioctl_nrt(struct rtdm_dev_context* context, rtdm_user_info_t* user_info, unsigned int request, void __user* arg)
{
struct rpi_gpio_context *ctx = (struct rpi_gpio_context *) context->dev_private;
// Set or Clear
if (request == 0)
GPIO_SET(ctx->gpio_addr) = (1 << ctx->gpio_nrt);
else
GPIO_CLR(ctx->gpio_addr) = (1 << ctx->gpio_nrt);
return 0;
}
void
gpio_init_outpin (unsigned int pin)
{
SYSCFG_UNLOCK;
gpio_init_pin(pin);
// clear pin data and set direction
GPIO_CLR(pin) = GPIO_MASK(pin);
GPIO_DIR(pin) &= ~GPIO_MASK(pin);
SYSCFG_LOCK;
}
int main(int argc, char **argv) {
int rep;
// Set up gpi pointer for direct register access
volatile unsigned *gpio = setup_io();
// Switch GPIO 17, 22 to output mode
INP_GPIO(gpio, 17); // must use INP_GPIO before we can use OUT_GPIO
OUT_GPIO(gpio, 17);
INP_GPIO(gpio, 22); // must use INP_GPIO before we can use OUT_GPIO
OUT_GPIO(gpio, 22);
for (rep=0; rep<10; rep++) {
GPIO_SET(gpio, 17);
sleep(1);
GPIO_SET(gpio, 22);
GPIO_CLR(gpio, 17);
sleep(1);
GPIO_CLR(gpio, 22);
}
return 0;
}
void send_cmd(int iTDI,int iTMS)
{
if(iTDI == 1)
{
GPIO_SET(JTAG_TDI);
tdi = 1;
}
else
{
GPIO_CLR(JTAG_TDI);
tdi = 0;
}
if(iTMS == 1)
{
GPIO_SET(JTAG_TMS);
}
else
GPIO_CLR(JTAG_TMS);
//nop_sleep(WAIT);
tick_clk();
//nop_sleep(WAIT);
}
/**
* r_irq_handler() - IRQ handler fired on interrupt
*/
static irqreturn_t r_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
{
unsigned long flags;
// disable hard interrupts (remember them in flag 'flags')
local_irq_save(flags);
// Set output
if (GPIO_READ(GPIO_PWM1))
{
GPIO_SET(GPIO_OUTP);
}
else
{
GPIO_CLR(GPIO_OUTP);
}
// restore hard interrupts
local_irq_restore(flags);
return (IRQ_HANDLED);
}
void
pi_start(void)
{
#warning IMPLEMENT _start
stage2_args args;
clear_bss();
call_ctors();
cpu_init();
gpio_init();
// Flick on "OK" led
GPIO_CLR(16);
mmu_init();
serial_init();
console_init();
args.heap_size = HEAP_SIZE;
args.arguments = NULL;
main(&args);
}
static inline void blink(void) {
GPIO_SET(1 << PIN);
await(1000000);
GPIO_CLR(1 << PIN);
}
void reset_clk()
{
GPIO_CLR(JTAG_TCK);
}
void gpio_clear(uint32_t gpioport, uint32_t gpios)
{
GPIO_CLR(gpioport) = gpios;
}
/**************************************************************************************************
* @fn MT_SysGpio
*
* @brief ZAccel RPC interface for controlling the available GPIO pins.
*
* @param uint8 pData - Pointer to the data.
*
* @return None
*************************************************************************************************/
void MT_SysGpio(uint8 *pBuf)
{
uint8 cmd, val;
GPIO_Op_t op;
cmd = pBuf[MT_RPC_POS_CMD1];
pBuf += MT_RPC_FRAME_HDR_SZ;
op = (GPIO_Op_t)(*pBuf++);
val = *pBuf;
switch (op)
{
case GPIO_DIR:
if (val & BV(0)) {GPIO_DIR_OUT(0);} else {GPIO_DIR_IN(0);}
if (val & BV(1)) {GPIO_DIR_OUT(1);} else {GPIO_DIR_IN(1);}
if (val & BV(2)) {GPIO_DIR_OUT(2);} else {GPIO_DIR_IN(2);}
if (val & BV(3)) {GPIO_DIR_OUT(3);} else {GPIO_DIR_IN(3);}
break;
case GPIO_TRI:
if(val & BV(0)) {GPIO_TRI(0);} else if(val & BV(4)) {GPIO_PULL_DN(0);} else {GPIO_PULL_UP(0);}
if(val & BV(1)) {GPIO_TRI(1);} else if(val & BV(5)) {GPIO_PULL_DN(1);} else {GPIO_PULL_UP(1);}
if(val & BV(2)) {GPIO_TRI(2);} else if(val & BV(6)) {GPIO_PULL_DN(2);} else {GPIO_PULL_UP(2);}
if(val & BV(3)) {GPIO_TRI(3);} else if(val & BV(7)) {GPIO_PULL_DN(3);} else {GPIO_PULL_UP(3);}
break;
case GPIO_SET:
if (val & BV(0)) {GPIO_SET(0);}
if (val & BV(1)) {GPIO_SET(1);}
if (val & BV(2)) {GPIO_SET(2);}
if (val & BV(3)) {GPIO_SET(3);}
break;
case GPIO_CLR:
if (val & BV(0)) {GPIO_CLR(0);}
if (val & BV(1)) {GPIO_CLR(1);}
if (val & BV(2)) {GPIO_CLR(2);}
if (val & BV(3)) {GPIO_CLR(3);}
break;
case GPIO_TOG:
if (val & BV(0)) {GPIO_TOG(0);}
if (val & BV(1)) {GPIO_TOG(1);}
if (val & BV(2)) {GPIO_TOG(2);}
if (val & BV(3)) {GPIO_TOG(3);}
break;
case GPIO_GET:
break;
case GPIO_HiD:
(val) ? GPIO_HiD_SET() : GPIO_HiD_CLR();
break;
default:
break;
}
val = (GPIO_GET(0)) ? BV(0) : 0;
val |= (GPIO_GET(1)) ? BV(1) : 0;
val |= (GPIO_GET(2)) ? BV(2) : 0;
val |= (GPIO_GET(3)) ? BV(3) : 0;
/* Build and send back the response */
MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_SYS), cmd, 1, &val);
}
void tick_clk()
{
GPIO_SET(JTAG_TCK);
//nop_sleep(WAIT);
GPIO_CLR(JTAG_TCK);
}
int N6100LCD::init(void)
{
if (MAP_FAILED==gpio_ && gpio_init() < 0) {
DBG("gpio init failed\n");
return -1;
}
if (spi_ < 0 && spi_init() < 0) {
DBG("spi init failed\n");
return -1;
}
DBG("gpio = %X\n", gpio_);
DBG("spi = %d\n", spi_);
INP_GPIO(rst_);
OUT_GPIO(rst_);
GPIO_CLR(rst_);
usleep(200*1000);
GPIO_SET(rst_);
usleep(200*1000);
if (type_ == TYPE_EPSON) {
spi_cmd(DISCTL); // Display control (0xCA)
spi_data(0x0C); // 12 = 1100 - CL dividing ratio [don't divide] switching period 8H (default)
spi_data(0x20); // nlines/4 - 1 = 132/4 - 1 = 32 duty
spi_data(0x00); // No inversely highlighted lines
spi_cmd(COMSCN); // common scanning direction (0xBB)
spi_data(0x01); // 1->68, 132<-69 scan direction
spi_cmd(OSCON); // internal oscialltor ON (0xD1)
spi_cmd(SLPOUT); // sleep out (0x94)
spi_cmd(PWRCTR); // power ctrl (0x20)
spi_data(0x0F); // everything on, no external reference resistors
spi_cmd(DISINV); // invert display mode (0xA7)
spi_cmd(DATCTL); // data control (0xBC)
spi_data(0x03); // Inverse page address, reverse rotation column address, column scan-direction !!! try 0x01
spi_data(0x00); // normal RGB arrangement
spi_data(0x02); // 16-bit Grayscale Type A (12-bit color)
spi_cmd(VOLCTR); // electronic volume, this is the contrast/brightness (0x81)
spi_data(32); // volume (contrast) setting - fine tuning, original (0-63)
spi_data(3); // internal resistor ratio - coarse adjustment (0-7)
spi_cmd(NOP);
usleep(100 * 1000);
spi_cmd(DISON); // display on (0xAF)
} else if (type_ == TYPE_PHILIPS) {
spi_cmd(SLEEPOUT); // Sleep Out (0x11)
spi_cmd(BSTRON); // Booster voltage on (0x03)
spi_cmd(DISPON); // Display on (0x29)
//spi_cmd(INVON); // Inversion on (0x20)
// 12-bit color pixel format:
spi_cmd(COLMOD); // Color interface format (0x3A)
spi_data(0x03); // 0b011 is 12-bit/pixel mode
spi_cmd(MADCTL); // Memory Access Control(PHILLIPS)
//spi_data(0x08);
spi_data(0xC0);
spi_cmd(SETCON); // Set Contrast(PHILLIPS)
spi_data(0x3E);
spi_cmd(NOPP); // nop(PHILLIPS)
}
spi_flush();
DBG("lcd init ok\n");
return 0;
}
void gpio_clear(u32 gpioport, u32 gpios)
{
GPIO_CLR(gpioport) = gpios;
}
int
main ( int argc, char **argv )
{
int result;
int period, half_period, half_period2;
uint32_t volatile * gpio_base = 0;
/* Retreive the mapped GPIO memory. */
result = setup_gpio_mmap ( &gpio_base );
if ( result < 0 ) {
printf ( "-- error: cannot setup mapped GPIO.\n" );
exit ( 1 );
}
period = 1000; /* default = 1Hz */
if ( argc > 1 ) {
period = atoi ( argv[1] );
}
half_period = set_frequency(1000);
half_period2 = set_frequency(500);
/* Setup GPIO of LED0 to output. */
GPIO_CONF_AS_OUTPUT ( gpio_base, GPIO_LED0 );
GPIO_CONF_AS_OUTPUT ( gpio_base, GPIO_LED1 );
GPIO_CONF_AS_INPUT ( gpio_base, GPIO_BTN0 );
printf ( "-- info: start blinking.\n" );
/* Blink led at frequency of 1Hz. */
while (1) {
/*GPIO_SET ( gpio_base, GPIO_LED0 );
GPIO_SET ( gpio_base, GPIO_LED1 );
delay ( half_period );
GPIO_CLR ( gpio_base, GPIO_LED0 );
delay ( half_period2 );
GPIO_CLR ( gpio_base, GPIO_LED1 );
delay ( half_period2 );*/
if(GPIO_VALUE( gpio_base, GPIO_BTN0 )==0)
{
GPIO_SET ( gpio_base, GPIO_LED0 );
GPIO_SET ( gpio_base, GPIO_LED1 );
delay ( half_period );
GPIO_CLR ( gpio_base, GPIO_LED0 );
delay ( half_period2 );
GPIO_CLR ( gpio_base, GPIO_LED1 );
delay ( half_period2 );
}
}
return 0;
}
