static void rk3288_fb_init(struct fb_rk3288_pdata_t * pdat)
{
gpio_set_cfg(RK3288_GPIO1_D0, 0x1);
gpio_set_cfg(RK3288_GPIO1_D1, 0x1);
gpio_set_cfg(RK3288_GPIO1_D2, 0x1);
gpio_set_cfg(RK3288_GPIO1_D3, 0x1);
gpio_set_rate(RK3288_GPIO1_D0, GPIO_RATE_FAST);
gpio_set_rate(RK3288_GPIO1_D1, GPIO_RATE_FAST);
gpio_set_rate(RK3288_GPIO1_D2, GPIO_RATE_FAST);
gpio_set_rate(RK3288_GPIO1_D3, GPIO_RATE_FAST);
gpio_set_drv(RK3288_GPIO1_D0, GPIO_DRV_STRONG);
gpio_set_drv(RK3288_GPIO1_D1, GPIO_DRV_STRONG);
gpio_set_drv(RK3288_GPIO1_D2, GPIO_DRV_STRONG);
gpio_set_drv(RK3288_GPIO1_D3, GPIO_DRV_STRONG);
rk3288_vop_set_interface(pdat);
rk3288_vop_set_mode(pdat);
rk3288_vop_set_timing(pdat);
rk3288_vop_set_polarity(pdat);
rk3288_vop_update_config(pdat);
rk3288_vop_set_win0(pdat);
rk3288_vop_set_win0_address(pdat, pdat->vram[0]);
rk3288_vop_update_config(pdat);
rk3288_lvds_enable(pdat, 0);
}
static inline void fb_f1c500s_cfg_gpios(int base, int n, int cfg, enum gpio_pull_t pull, enum gpio_drv_t drv)
{
for(; n > 0; n--, base++)
{
gpio_set_cfg(base, cfg);
gpio_set_pull(base, pull);
gpio_set_drv(base, drv);
}
}
static inline void s5p4418_fb_cfg_gpios(int base, int nr, int cfg, enum gpio_pull_t pull, enum gpio_drv_t drv)
{
for(; nr > 0; nr--, base++)
{
gpio_set_cfg(base, cfg);
gpio_set_pull(base, pull);
gpio_set_drv(base, drv);
}
}
static void pwm_bcm2836_enable(struct pwm_t * pwm)
{
struct pwm_bcm2836_pdata_t * pdat = (struct pwm_bcm2836_pdata_t *)pwm->priv;
u32_t ctrl;
gpio_set_cfg(pdat->pwm, pdat->pwmcfg);
clk_enable(pdat->clk);
ctrl = read32(pdat->virt + PWM_CTRL);
ctrl &= ~(PWM_CTRL_MASK << PWM_CTRL_SHIFT(pdat->channel));
ctrl |= (0x81 << PWM_CTRL_SHIFT(pdat->channel));
write32(pdat->virt + PWM_CTRL, ctrl);
}
static void pwm_v3s_enable(struct pwm_t * pwm)
{
struct pwm_v3s_pdata_t * pdat = (struct pwm_v3s_pdata_t *)pwm->priv;
u32_t ctrl;
if((pdat->pwm >= 0) && (pdat->pwmcfg >= 0))
gpio_set_cfg(pdat->pwm, pdat->pwmcfg);
clk_enable(pdat->clk);
ctrl = read32(pdat->virt + PWM_CTRL);
ctrl |= PWM_BIT(pdat->channel, 4);
ctrl |= PWM_BIT(pdat->channel, 6);
write32(pdat->virt + PWM_CTRL, ctrl);
}
static struct device_t * motor_gpio_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct motor_gpio_pdata_t * pdat;
struct motor_t * m;
struct device_t * dev;
int a = dt_read_int(n, "a-gpio", -1);
int b = dt_read_int(n, "b-gpio", -1);
int e = dt_read_int(n, "enable-gpio", -1);
if(!gpio_is_valid(a) || !gpio_is_valid(b))
return NULL;
pdat = malloc(sizeof(struct motor_gpio_pdata_t));
if(!pdat)
return NULL;
m = malloc(sizeof(struct motor_t));
if(!m)
{
free(pdat);
return NULL;
}
timer_init(&pdat->timer, motor_gpio_timer_function, m);
pdat->a = a;
pdat->acfg = dt_read_int(n, "a-gpio-config", -1);
pdat->b = b;
pdat->bcfg = dt_read_int(n, "b-gpio-config", -1);
pdat->e = e;
pdat->ecfg = dt_read_int(n, "enable-gpio-config", -1);
pdat->period = dt_read_int(n, "period-ns", 10 * 1000 * 1000);
pdat->duty = pdat->period / 2;
pdat->maxspeed = abs(dt_read_int(n, "max-speed-rpm", 1000));
pdat->speed = 0;
pdat->flag = 0;
m->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
m->enable = motor_gpio_enable;
m->disable = motor_gpio_disable;
m->set = motor_gpio_set;
m->priv = pdat;
if(pdat->a >= 0)
{
if(pdat->acfg >= 0)
gpio_set_cfg(pdat->a, pdat->acfg);
gpio_set_pull(pdat->a, GPIO_PULL_UP);
gpio_set_direction(pdat->a, GPIO_DIRECTION_OUTPUT);
gpio_set_value(pdat->a, 0);
}
if(pdat->b >= 0)
{
if(pdat->bcfg >= 0)
gpio_set_cfg(pdat->b, pdat->bcfg);
gpio_set_pull(pdat->b, GPIO_PULL_UP);
gpio_set_direction(pdat->b, GPIO_DIRECTION_OUTPUT);
gpio_set_value(pdat->b, 0);
}
if(pdat->e >= 0)
{
if(pdat->ecfg >= 0)
gpio_set_cfg(pdat->e, pdat->ecfg);
gpio_set_pull(pdat->e, GPIO_PULL_UP);
gpio_set_direction(pdat->e, GPIO_DIRECTION_OUTPUT);
gpio_set_value(pdat->e, 0);
}
if(!register_motor(&dev, m))
{
timer_cancel(&pdat->timer);
free_device_name(m->name);
free(m->priv);
free(m);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * sdhci_v3s_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct sdhci_v3s_pdata_t * pdat;
struct sdhci_t * sdhci;
struct device_t * dev;
virtual_addr_t virt = phys_to_virt(dt_read_address(n));
char * pclk = dt_read_string(n, "clock-name", NULL);
if(!search_clk(pclk))
return NULL;
pdat = malloc(sizeof(struct sdhci_v3s_pdata_t));
if(!pdat)
return FALSE;
sdhci = malloc(sizeof(struct sdhci_t));
if(!sdhci)
{
free(pdat);
return FALSE;
}
pdat->virt = virt;
pdat->pclk = strdup(pclk);
pdat->reset = dt_read_int(n, "reset", -1);
pdat->clk = dt_read_int(n, "clk-gpio", -1);
pdat->clkcfg = dt_read_int(n, "clk-gpio-config", -1);
pdat->cmd = dt_read_int(n, "cmd-gpio", -1);
pdat->cmdcfg = dt_read_int(n, "cmd-gpio-config", -1);
pdat->dat0 = dt_read_int(n, "dat0-gpio", -1);
pdat->dat0cfg = dt_read_int(n, "dat0-gpio-config", -1);
pdat->dat1 = dt_read_int(n, "dat1-gpio", -1);
pdat->dat1cfg = dt_read_int(n, "dat1-gpio-config", -1);
pdat->dat2 = dt_read_int(n, "dat2-gpio", -1);
pdat->dat2cfg = dt_read_int(n, "dat2-gpio-config", -1);
pdat->dat3 = dt_read_int(n, "dat3-gpio", -1);
pdat->dat3cfg = dt_read_int(n, "dat3-gpio-config", -1);
pdat->dat4 = dt_read_int(n, "dat4-gpio", -1);
pdat->dat4cfg = dt_read_int(n, "dat4-gpio-config", -1);
pdat->dat5 = dt_read_int(n, "dat5-gpio", -1);
pdat->dat5cfg = dt_read_int(n, "dat5-gpio-config", -1);
pdat->dat6 = dt_read_int(n, "dat6-gpio", -1);
pdat->dat6cfg = dt_read_int(n, "dat6-gpio-config", -1);
pdat->dat7 = dt_read_int(n, "dat7-gpio", -1);
pdat->dat7cfg = dt_read_int(n, "dat7-gpio-config", -1);
pdat->cd = dt_read_int(n, "cd-gpio", -1);
pdat->cdcfg = dt_read_int(n, "cd-gpio-config", -1);
sdhci->name = alloc_device_name(dt_read_name(n), -1);
sdhci->voltage = MMC_VDD_27_36;
sdhci->width = MMC_BUS_WIDTH_4;
sdhci->clock = 52 * 1000 * 1000;
sdhci->removable = TRUE;
sdhci->detect = sdhci_v3s_detect;
sdhci->setvoltage = sdhci_v3s_setvoltage;
sdhci->setwidth = sdhci_v3s_setwidth;
sdhci->setclock = sdhci_v3s_setclock;
sdhci->transfer = sdhci_v3s_transfer;
sdhci->priv = pdat;
clk_enable(pdat->pclk);
if(pdat->reset >= 0)
reset_deassert(pdat->reset);
if(pdat->clk >= 0)
{
if(pdat->clkcfg >= 0)
gpio_set_cfg(pdat->clk, pdat->clkcfg);
gpio_set_pull(pdat->clk, GPIO_PULL_UP);
}
if(pdat->cmd >= 0)
{
if(pdat->cmdcfg >= 0)
gpio_set_cfg(pdat->cmd, pdat->cmdcfg);
gpio_set_pull(pdat->cmd, GPIO_PULL_UP);
}
if(pdat->dat0 >= 0)
{
if(pdat->dat0cfg >= 0)
gpio_set_cfg(pdat->dat0, pdat->dat0cfg);
gpio_set_pull(pdat->dat0, GPIO_PULL_UP);
}
if(pdat->dat1 >= 0)
{
if(pdat->dat1cfg >= 0)
gpio_set_cfg(pdat->dat1, pdat->dat1cfg);
gpio_set_pull(pdat->dat1, GPIO_PULL_UP);
}
if(pdat->dat2 >= 0)
{
if(pdat->dat2cfg >= 0)
gpio_set_cfg(pdat->dat2, pdat->dat2cfg);
gpio_set_pull(pdat->dat2, GPIO_PULL_UP);
}
if(pdat->dat3 >= 0)
{
if(pdat->dat3cfg >= 0)
gpio_set_cfg(pdat->dat3, pdat->dat3cfg);
gpio_set_pull(pdat->dat3, GPIO_PULL_UP);
}
if(pdat->dat4 >= 0)
{
if(pdat->dat4cfg >= 0)
gpio_set_cfg(pdat->dat4, pdat->dat4cfg);
gpio_set_pull(pdat->dat4, GPIO_PULL_UP);
}
if(pdat->dat5 >= 0)
{
if(pdat->dat5cfg >= 0)
gpio_set_cfg(pdat->dat5, pdat->dat5cfg);
gpio_set_pull(pdat->dat5, GPIO_PULL_UP);
}
if(pdat->dat6 >= 0)
{
if(pdat->dat6cfg >= 0)
gpio_set_cfg(pdat->dat6, pdat->dat6cfg);
gpio_set_pull(pdat->dat6, GPIO_PULL_UP);
}
if(pdat->dat7 >= 0)
{
if(pdat->dat7cfg >= 0)
gpio_set_cfg(pdat->dat7, pdat->dat7cfg);
gpio_set_pull(pdat->dat7, GPIO_PULL_UP);
}
if(pdat->cd >= 0)
{
if(pdat->cdcfg >= 0)
gpio_set_cfg(pdat->cd, pdat->cdcfg);
gpio_set_pull(pdat->cd, GPIO_PULL_UP);
}
if(!register_sdhci(&dev, sdhci))
{
clk_disable(pdat->pclk);
free(pdat->pclk);
free_device_name(sdhci->name);
free(sdhci->priv);
free(sdhci);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * spi_rk3128_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct spi_rk3128_pdata_t * pdat;
struct spi_t * spi;
struct device_t * dev;
virtual_addr_t virt = phys_to_virt(dt_read_address(n));
char * clk = dt_read_string(n, "clock-name", NULL);
pdat = malloc(sizeof(struct spi_rk3128_pdata_t));
if(!pdat)
return FALSE;
spi = malloc(sizeof(struct spi_t));
if(!spi)
{
free(pdat);
return FALSE;
}
pdat->virt = virt;
pdat->clk = strdup(clk);
pdat->sclk = dt_read_int(n, "sclk-gpio", -1);
pdat->sclkcfg = dt_read_int(n, "sclk-gpio-config", -1);
pdat->mosi = dt_read_int(n, "mosi-gpio", -1);
pdat->mosicfg = dt_read_int(n, "mosi-gpio-config", -1);
pdat->miso = dt_read_int(n, "miso-gpio", -1);
pdat->misocfg = dt_read_int(n, "miso-gpio-config", -1);
pdat->cs = dt_read_int(n, "cs-gpio", -1);
pdat->cscfg = dt_read_int(n, "cs-gpio-config", -1);
spi->name = alloc_device_name(dt_read_name(n), -1);
spi->type = SPI_TYPE_SINGLE;
spi->transfer = spi_rk3128_transfer;
spi->select = spi_rk3128_select;
spi->deselect = spi_rk3128_deselect;
spi->priv = pdat;
clk_enable(pdat->clk);
if(pdat->sclk >= 0)
{
if(pdat->sclkcfg >= 0)
gpio_set_cfg(pdat->sclk, pdat->sclkcfg);
gpio_set_pull(pdat->sclk, GPIO_PULL_NONE);
}
if(pdat->mosi >= 0)
{
if(pdat->mosicfg >= 0)
gpio_set_cfg(pdat->mosi, pdat->mosicfg);
gpio_set_pull(pdat->mosi, GPIO_PULL_NONE);
}
if(pdat->miso >= 0)
{
if(pdat->misocfg >= 0)
gpio_set_cfg(pdat->miso, pdat->misocfg);
gpio_set_pull(pdat->miso, GPIO_PULL_NONE);
}
if(pdat->cs >= 0)
{
if(pdat->cscfg >= 0)
gpio_set_cfg(pdat->cs, pdat->cscfg);
gpio_set_pull(pdat->cs, GPIO_PULL_NONE);
}
rk3128_spi_enable_chip(pdat, 0);
write32(pdat->virt + SPI_CTRLR0, (0 << 20) | (0 << 18) | (0 << 16) | (3 << 14) | (0 << 12) | (0 << 11) | (1 << 10) | (0 << 8) | (1 << 0));
write32(pdat->virt + SPI_TXFTLR, 32 / 2 - 1);
write32(pdat->virt + SPI_RXFTLR, 32 / 2 - 1);
if(!register_spi(&dev, spi))
{
clk_disable(pdat->clk);
free(pdat->clk);
free_device_name(spi->name);
free(spi->priv);
free(spi);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * rotary_encoder_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct rotary_encoder_pdata_t * pdat;
struct input_t * input;
struct device_t * dev;
int a = dt_read_int(n, "a-gpio", -1);
int b = dt_read_int(n, "b-gpio", -1);
if(!gpio_is_valid(a) || !gpio_is_valid(b)
|| !irq_is_valid(gpio_to_irq(a))
|| !irq_is_valid(gpio_to_irq(b)))
return NULL;
pdat = malloc(sizeof(struct rotary_encoder_pdata_t));
if(!pdat)
return NULL;
input = malloc(sizeof(struct input_t));
if(!input)
{
free(pdat);
return NULL;
}
pdat->a = a;
pdat->acfg = dt_read_int(n, "a-gpio-config", -1);
pdat->b = b;
pdat->bcfg = dt_read_int(n, "b-gpio-config", -1);
pdat->c = dt_read_int(n, "c-gpio", -1);
pdat->ccfg = dt_read_int(n, "c-gpio-config", -1);
pdat->irqa = gpio_to_irq(pdat->a);
pdat->irqb = gpio_to_irq(pdat->b);
pdat->irqc = gpio_to_irq(pdat->c);
pdat->inva = dt_read_bool(n, "a-inverted", 0);
pdat->invb = dt_read_bool(n, "b-inverted", 0);
pdat->invc = dt_read_bool(n, "c-inverted", 0);
input->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
input->ioctl = rotary_encoder_ioctl;
input->priv = pdat;
if(pdat->acfg >= 0)
gpio_set_cfg(pdat->a, pdat->acfg);
gpio_set_pull(pdat->a, pdat->inva ? GPIO_PULL_DOWN : GPIO_PULL_UP);
gpio_direction_input(pdat->a);
if(pdat->bcfg >= 0)
gpio_set_cfg(pdat->b, pdat->bcfg);
gpio_set_pull(pdat->b, pdat->invb ? GPIO_PULL_DOWN : GPIO_PULL_UP);
gpio_direction_input(pdat->b);
switch(dt_read_int(n, "step-per-period", 1))
{
case 4:
request_irq(pdat->irqa, rotary_encoder_quarter_period_irq, IRQ_TYPE_EDGE_BOTH, input);
request_irq(pdat->irqb, rotary_encoder_quarter_period_irq, IRQ_TYPE_EDGE_BOTH, input);
pdat->state = rotary_encoder_get_state(pdat);
break;
case 2:
request_irq(pdat->irqa, rotary_encoder_half_period_irq, IRQ_TYPE_EDGE_BOTH, input);
request_irq(pdat->irqb, rotary_encoder_half_period_irq, IRQ_TYPE_EDGE_BOTH, input);
pdat->state = rotary_encoder_get_state(pdat);
break;
case 1:
request_irq(pdat->irqa, rotary_encoder_irq, IRQ_TYPE_EDGE_BOTH, input);
request_irq(pdat->irqb, rotary_encoder_irq, IRQ_TYPE_EDGE_BOTH, input);
pdat->state = 0;
break;
default:
request_irq(pdat->irqa, rotary_encoder_irq, IRQ_TYPE_EDGE_BOTH, input);
request_irq(pdat->irqb, rotary_encoder_irq, IRQ_TYPE_EDGE_BOTH, input);
pdat->state = 0;
break;
}
if(gpio_is_valid(pdat->c) && irq_is_valid(pdat->irqc))
{
if(pdat->ccfg >= 0)
gpio_set_cfg(pdat->c, pdat->ccfg);
gpio_set_pull(pdat->c, pdat->invc ? GPIO_PULL_DOWN : GPIO_PULL_UP);
gpio_direction_input(pdat->c);
request_irq(pdat->irqc, rotary_encoder_c_irq, IRQ_TYPE_EDGE_BOTH, input);
}
if(!register_input(&dev, input))
{
free_irq(pdat->irqa);
free_irq(pdat->irqb);
if(gpio_is_valid(pdat->c) && irq_is_valid(pdat->irqc))
free_irq(pdat->irqc);
free_device_name(input->name);
free(input->priv);
free(input);
return NULL;
}
dev->driver = drv;
return dev;
}
static void s5p6818_uart_init(struct uart_t * uart)
{
struct resource_t * res = (struct resource_t *)uart->priv;
struct s5p6818_uart_data_t * dat = (struct s5p6818_uart_data_t *)res->data;
switch(res->id)
{
case 0:
s5p6818_ip_reset(RESET_ID_UART0, 0);
clk_enable("GATE-UART0");
gpio_set_cfg(S5P6818_GPIOD(18), 0x1);
gpio_set_cfg(S5P6818_GPIOD(14), 0x1);
gpio_set_direction(S5P6818_GPIOD(18), GPIO_DIRECTION_OUTPUT);
gpio_set_direction(S5P6818_GPIOD(14), GPIO_DIRECTION_INPUT);
break;
case 1:
s5p6818_ip_reset(RESET_ID_UART1, 0);
clk_enable("GATE-UART1");
gpio_set_cfg(S5P6818_GPIOD(19), 0x1);
gpio_set_cfg(S5P6818_GPIOD(15), 0x1);
gpio_set_direction(S5P6818_GPIOD(19), GPIO_DIRECTION_OUTPUT);
gpio_set_direction(S5P6818_GPIOD(15), GPIO_DIRECTION_INPUT);
break;
case 2:
s5p6818_ip_reset(RESET_ID_UART2, 0);
clk_enable("GATE-UART2");
gpio_set_cfg(S5P6818_GPIOD(20), 0x1);
gpio_set_cfg(S5P6818_GPIOD(16), 0x1);
gpio_set_direction(S5P6818_GPIOD(20), GPIO_DIRECTION_OUTPUT);
gpio_set_direction(S5P6818_GPIOD(16), GPIO_DIRECTION_INPUT);
break;
case 3:
s5p6818_ip_reset(RESET_ID_UART3, 0);
clk_enable("GATE-UART3");
gpio_set_cfg(S5P6818_GPIOD(21), 0x1);
gpio_set_cfg(S5P6818_GPIOD(17), 0x1);
gpio_set_direction(S5P6818_GPIOD(21), GPIO_DIRECTION_OUTPUT);
gpio_set_direction(S5P6818_GPIOD(17), GPIO_DIRECTION_INPUT);
break;
case 4:
s5p6818_ip_reset(RESET_ID_UART4, 0);
clk_enable("GATE-UART4");
gpio_set_cfg(S5P6818_GPIOB(29), 0x3);
gpio_set_cfg(S5P6818_GPIOB(28), 0x3);
gpio_set_direction(S5P6818_GPIOB(29), GPIO_DIRECTION_OUTPUT);
gpio_set_direction(S5P6818_GPIOB(28), GPIO_DIRECTION_INPUT);
break;
case 5:
s5p6818_ip_reset(RESET_ID_UART5, 0);
clk_enable("GATE-UART5");
gpio_set_cfg(S5P6818_GPIOB(31), 0x3);
gpio_set_cfg(S5P6818_GPIOB(30), 0x3);
gpio_set_direction(S5P6818_GPIOB(31), GPIO_DIRECTION_OUTPUT);
gpio_set_direction(S5P6818_GPIOB(30), GPIO_DIRECTION_INPUT);
break;
default:
return;
}
write32(dat->regbase + UART_UCON, 0x00000005);
write32(dat->regbase + UART_UFCON, 0x00000777);
write32(dat->regbase + UART_UMCON, 0x00000000);
s5p6818_uart_set(uart, dat->baud, dat->data, dat->parity, dat->stop);
}
static void s5pv210_uart_init(struct uart_t * uart)
{
struct resource_t * res = (struct resource_t *)uart->priv;
struct s5pv210_uart_data_t * dat = (struct s5pv210_uart_data_t *)res->data;
switch(res->id)
{
case 0:
clk_enable("psys-pclk");
/* Configure GPA01, GPA00 for TXD0, RXD0 and pull up */
gpio_set_cfg(S5PV210_GPA0(1), 0x2);
gpio_set_cfg(S5PV210_GPA0(0), 0x2);
gpio_set_pull(S5PV210_GPA0(1), GPIO_PULL_UP);
gpio_set_pull(S5PV210_GPA0(0), GPIO_PULL_UP);
write32(dat->regbase + S5PV210_UCON, 0x00000005);
write32(dat->regbase + S5PV210_UFCON, 0x00000777);
write32(dat->regbase + S5PV210_UMON, 0x00000000);
break;
case 1:
clk_enable("psys-pclk");
/* Configure GPA05, GPA04 for TXD1, RXD1 */
gpio_set_cfg(S5PV210_GPA0(5), 0x2);
gpio_set_cfg(S5PV210_GPA0(4), 0x2);
gpio_set_pull(S5PV210_GPA0(5), GPIO_PULL_UP);
gpio_set_pull(S5PV210_GPA0(4), GPIO_PULL_UP);
write32(dat->regbase + S5PV210_UCON, 0x00000005);
write32(dat->regbase + S5PV210_UFCON, 0x00000777);
write32(dat->regbase + S5PV210_UMON, 0x00000000);
break;
case 2:
clk_enable("psys-pclk");
/* Configure GPA11, GPA10 for TXD2, RXD2 */
gpio_set_cfg(S5PV210_GPA1(1), 0x2);
gpio_set_cfg(S5PV210_GPA1(0), 0x2);
gpio_set_pull(S5PV210_GPA1(1), GPIO_PULL_UP);
gpio_set_pull(S5PV210_GPA1(0), GPIO_PULL_UP);
write32(dat->regbase + S5PV210_UCON, 0x00000005);
write32(dat->regbase + S5PV210_UFCON, 0x00000777);
break;
case 3:
clk_enable("psys-pclk");
/* Configure GPA13, GPA12 for TXD3, RXD3 */
gpio_set_cfg(S5PV210_GPA1(3), 0x2);
gpio_set_cfg(S5PV210_GPA1(2), 0x2);
gpio_set_pull(S5PV210_GPA1(3), GPIO_PULL_UP);
gpio_set_pull(S5PV210_GPA1(2), GPIO_PULL_UP);
write32(dat->regbase + S5PV210_UCON, 0x00000005);
write32(dat->regbase + S5PV210_UFCON, 0x00000777);
break;
default:
return;
}
s5pv210_uart_setup(uart, dat->baud, dat->data, dat->parity, dat->stop);
}
