static struct device_t * led_pwm_bl_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct led_pwm_bl_pdata_t * pdat;
struct pwm_t * pwm;
struct led_t * led;
struct device_t * dev;
if(!(pwm = search_pwm(dt_read_string(n, "pwm-name", NULL))))
return NULL;
pdat = malloc(sizeof(struct led_pwm_bl_pdata_t));
if(!pdat)
return NULL;
led = malloc(sizeof(struct led_t));
if(!led)
{
free(pdat);
return NULL;
}
pdat->pwm = pwm;
pdat->regulator = strdup(dt_read_string(n, "regulator-name", NULL));
pdat->period = dt_read_int(n, "pwm-period-ns", 1000 * 1000);
pdat->polarity = dt_read_bool(n, "pwm-polarity", 0);
pdat->from = dt_read_int(n, "pwm-percent-from", 0) * pdat->period / 100;
pdat->to = dt_read_int(n, "pwm-percent-to", 100) * pdat->period / 100;
pdat->brightness = dt_read_int(n, "default-brightness", 0);
led->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
led->set = led_pwm_bl_set,
led->get = led_pwm_bl_get,
led->priv = pdat;
if(pdat->brightness > 0)
regulator_enable(pdat->regulator);
else
regulator_disable(pdat->regulator);
led_pwm_bl_set_brightness(pdat, pdat->brightness);
if(!register_led(&dev, led))
{
regulator_disable(pdat->regulator);
led_pwm_bl_set_brightness(pdat, 0);
if(pdat->regulator)
free(pdat->regulator);
free_device_name(led->name);
free(led->priv);
free(led);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * fb_bcm2837_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct fb_bcm2837_pdata_t * pdat;
struct fb_t * fb;
struct device_t * dev;
pdat = malloc(sizeof(struct fb_bcm2837_pdata_t));
if(!pdat)
return NULL;
fb = malloc(sizeof(struct fb_t));
if(!fb)
{
free(pdat);
return NULL;
}
pdat->width = dt_read_int(n, "width", 640);
pdat->height = dt_read_int(n, "height", 480);
pdat->xdpi = dt_read_int(n, "dots-per-inch-x", 160);
pdat->ydpi = dt_read_int(n, "dots-per-inch-y", 160);
pdat->bpp = dt_read_int(n, "bits-per-pixel", 32);
pdat->index = 0;
pdat->vram[0] = bcm2837_mbox_fb_alloc(pdat->width, pdat->height, pdat->bpp, 2);
pdat->vram[1] = pdat->vram[0] + (pdat->width * pdat->height * (pdat->bpp / 8));
pdat->brightness = 0;
fb->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
fb->width = pdat->width;
fb->height = pdat->height;
fb->xdpi = pdat->xdpi;
fb->ydpi = pdat->ydpi;
fb->bpp = pdat->bpp;
fb->setbl = fb_setbl,
fb->getbl = fb_getbl,
fb->create = fb_create,
fb->destroy = fb_destroy,
fb->present = fb_present,
fb->priv = pdat;
if(!register_fb(&dev, fb))
{
free_device_name(fb->name);
free(fb->priv);
free(fb);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * buzzer_pwm_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct buzzer_pwm_pdata_t * pdat;
struct pwm_t * pwm;
struct buzzer_t * buzzer;
struct device_t * dev;
if(!(pwm = search_pwm(dt_read_string(n, "pwm-name", NULL))))
return NULL;
pdat = malloc(sizeof(struct buzzer_pwm_pdata_t));
if(!pdat)
return NULL;
buzzer = malloc(sizeof(struct buzzer_t));
if(!buzzer)
{
free(pdat);
return NULL;
}
timer_init(&pdat->timer, buzzer_pwm_timer_function, buzzer);
pdat->queue = queue_alloc();
pdat->pwm = pwm;
pdat->polarity = dt_read_bool(n, "pwm-polarity", 0);
pdat->frequency = -1;
buzzer->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
buzzer->set = buzzer_pwm_set;
buzzer->get = buzzer_pwm_get;
buzzer->beep = buzzer_pwm_beep;
buzzer->priv = pdat;
buzzer_pwm_set(buzzer, 0);
if(!register_buzzer(&dev, buzzer))
{
timer_cancel(&pdat->timer);
queue_free(pdat->queue, iter_queue_node);
free_device_name(buzzer->name);
free(buzzer->priv);
free(buzzer);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * uart_sandbox_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct uart_sandbox_pdata_t * pdat;
struct uart_t * uart;
struct device_t * dev;
int fd = sandbox_uart_open(dt_read_string(n, "device", NULL));
if(fd < 0)
return NULL;
pdat = malloc(sizeof(struct uart_sandbox_pdata_t));
if(!pdat)
return NULL;
uart = malloc(sizeof(struct uart_t));
if(!uart)
{
free(pdat);
return NULL;
}
pdat->fd = fd;
pdat->baud = dt_read_int(n, "baud-rates", 115200);
pdat->data = dt_read_int(n, "data-bits", 8);
pdat->parity = dt_read_int(n, "parity-bits", 0);
pdat->stop = dt_read_int(n, "stop-bits", 1);
uart->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
uart->set = uart_sandbox_set;
uart->get = uart_sandbox_get;
uart->read = uart_sandbox_read;
uart->write = uart_sandbox_write;
uart->priv = pdat;
uart_sandbox_set(uart, pdat->baud, pdat->data, pdat->parity, pdat->stop);
if(!register_uart(&dev, uart))
{
sandbox_uart_close(pdat->fd);
free_device_name(uart->name);
free(uart->priv);
free(uart);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * servo_pwm_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct servo_pwm_pdata_t * pdat;
struct pwm_t * pwm;
struct servo_t * m;
struct device_t * dev;
if(!(pwm = search_pwm(dt_read_string(n, "pwm-name", NULL))))
return NULL;
pdat = malloc(sizeof(struct servo_pwm_pdata_t));
if(!pdat)
return NULL;
m = malloc(sizeof(struct servo_t));
if(!m)
{
free(pdat);
return NULL;
}
pdat->pwm = pwm;
pdat->period = dt_read_int(n, "pwm-period-ns", 20000 * 1000);
pdat->polarity = dt_read_bool(n, "pwm-polarity", 0);
pdat->from = dt_read_int(n, "pwm-duty-ns-from", 500 * 1000);
pdat->to = dt_read_int(n, "pwm-duty-ns-to", 2500 * 1000);
pdat->range = dt_read_int(n, "rotation-angle-range", 180);
pdat->angle = -360;
m->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
m->enable = servo_pwm_enable;
m->disable = servo_pwm_disable;
m->set = servo_pwm_set;
m->priv = pdat;
servo_pwm_set(m, dt_read_int(n, "default-angle", 0));
if(!register_servo(&dev, m))
{
free_device_name(m->name);
free(m->priv);
free(m);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * romdisk_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct romdisk_pdata_t * pdat;
struct block_t * blk;
struct device_t * dev;
virtual_addr_t addr = strtoull(dt_read_string(n, "address", "0"), NULL, 0);
virtual_size_t size = strtoull(dt_read_string(n, "size", "0"), NULL, 0);
if(size <= 0)
return NULL;
size = (size + SZ_512) / SZ_512;
pdat = malloc(sizeof(struct romdisk_pdata_t));
if(!pdat)
return NULL;
blk = malloc(sizeof(struct block_t));
if(!blk)
{
free(pdat);
return NULL;
}
pdat->addr = addr;
pdat->size = size;
blk->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
blk->blksz = SZ_512;
blk->blkcnt = (u64_t)size;
blk->read = romdisk_read;
blk->write = romdisk_write;
blk->sync = romdisk_sync;
blk->priv = pdat;
if(!register_block(&dev, blk))
{
free_device_name(blk->name);
free(blk->priv);
free(blk);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * ledtrig_general_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct ledtrig_general_pdata_t * pdat;
struct ledtrig_t * ledtrig;
struct device_t * dev;
struct led_t * led;
led = search_led(dt_read_string(n, "led-name", NULL));
if(!led)
return NULL;
pdat = malloc(sizeof(struct ledtrig_general_pdata_t));
if(!pdat)
return NULL;
ledtrig = malloc(sizeof(struct ledtrig_t));
if(!ledtrig)
{
free(pdat);
return NULL;
}
timer_init(&pdat->timer, ledtrig_general_timer_function, ledtrig);
pdat->led = led;
pdat->activity = 0;
pdat->last_activity = 0;
ledtrig->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
ledtrig->activity = ledtrig_general_activity;
ledtrig->priv = pdat;
if(!register_ledtrig(&dev, ledtrig))
{
timer_cancel(&pdat->timer);
free_device_name(ledtrig->name);
free(ledtrig->priv);
free(ledtrig);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * console_sandbox_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct console_t * console;
struct device_t * dev;
console = malloc(sizeof(struct console_t));
if(!console)
return NULL;
console->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
console->read = console_sandbox_read;
console->write = console_sandbox_write;
console->priv = NULL;
if(!register_console(&dev, console))
{
free_device_name(console->name);
free(console);
return NULL;
}
dev->driver = drv;
return dev;
}
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 * i2c_gpio_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct i2c_gpio_pdata_t * pdat;
struct i2c_t * i2c;
struct device_t * dev;
int sda = dt_read_int(n, "sda-gpio", -1);
int scl = dt_read_int(n, "scl-gpio", -1);
if(!gpio_is_valid(sda) || !gpio_is_valid(scl))
return NULL;
pdat = malloc(sizeof(struct i2c_gpio_pdata_t));
if(!pdat)
return FALSE;
i2c = malloc(sizeof(struct i2c_t));
if(!i2c)
{
free(pdat);
return FALSE;
}
pdat->sda = sda;
pdat->scl = scl;
pdat->sda_open_drain = dt_read_bool(n, "sda-open-drain", 0);
pdat->scl_open_drain = dt_read_bool(n, "scl-open-drain", 0);
pdat->scl_output_only = dt_read_bool(n, "sda-output-only", 0);
pdat->udelay = dt_read_int(n, "delay-us", 5);
pdat->bdat.priv = pdat;
if(pdat->sda_open_drain)
{
gpio_direction_output(pdat->sda, 1);
pdat->bdat.setsda = i2c_gpio_setsda_val;
}
else
{
gpio_direction_input(pdat->sda);
pdat->bdat.setsda = i2c_gpio_setsda_dir;
}
if(pdat->scl_open_drain || pdat->scl_output_only)
{
gpio_direction_output(pdat->scl, 1);
pdat->bdat.setscl = i2c_gpio_setscl_val;
}
else
{
gpio_direction_input(pdat->scl);
pdat->bdat.setscl = i2c_gpio_setscl_dir;
}
pdat->bdat.getsda = i2c_gpio_getsda;
if(pdat->scl_output_only)
pdat->bdat.getscl = 0;
else
pdat->bdat.getscl = i2c_gpio_getscl;
if(pdat->udelay > 0)
pdat->bdat.udelay = pdat->udelay;
else if(pdat->scl_output_only)
pdat->bdat.udelay = 50;
else
pdat->bdat.udelay = 5;
i2c->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
i2c->xfer = i2c_gpio_xfer,
i2c->priv = pdat;
if(!register_i2c(&dev, i2c))
{
free_device_name(i2c->name);
free(i2c->priv);
free(i2c);
return NULL;
}
dev->driver = drv;
return dev;
}
static struct device_t * fb_f1c500s_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct fb_f1c500s_pdata_t * pdat;
struct framebuffer_t * fb;
struct device_t * dev;
char * clkdefe = dt_read_string(n, "clock-name-defe", NULL);
char * clkdebe = dt_read_string(n, "clock-name-debe", NULL);
char * clktcon = dt_read_string(n, "clock-name-tcon", NULL);
int i;
if(!search_clk(clkdefe) || !search_clk(clkdebe) || !search_clk(clktcon))
return NULL;
pdat = malloc(sizeof(struct fb_f1c500s_pdata_t));
if(!pdat)
return NULL;
fb = malloc(sizeof(struct framebuffer_t));
if(!fb)
{
free(pdat);
return NULL;
}
pdat->virtdefe = phys_to_virt(F1C500S_DEFE_BASE);
pdat->virtdebe = phys_to_virt(F1C500S_DEBE_BASE);
pdat->virttcon = phys_to_virt(F1C500S_TCON_BASE);
pdat->virtgpio = phys_to_virt(F1C500S_GPIO_BASE);
pdat->clkdefe = strdup(clkdefe);
pdat->clkdebe = strdup(clkdebe);
pdat->clktcon = strdup(clktcon);
pdat->rstdefe = dt_read_int(n, "reset-defe", -1);
pdat->rstdebe = dt_read_int(n, "reset-debe", -1);
pdat->rsttcon = dt_read_int(n, "reset-tcon", -1);
pdat->width = dt_read_int(n, "width", 320);
pdat->height = dt_read_int(n, "height", 240);
pdat->pwidth = dt_read_int(n, "physical-width", 216);
pdat->pheight = dt_read_int(n, "physical-height", 135);
pdat->bits_per_pixel = dt_read_int(n, "bits-per-pixel", 18);
pdat->bytes_per_pixel = dt_read_int(n, "bytes-per-pixel", 4);
pdat->index = 0;
pdat->vram[0] = dma_alloc_noncoherent(pdat->width * pdat->height * pdat->bytes_per_pixel);
pdat->vram[1] = dma_alloc_noncoherent(pdat->width * pdat->height * pdat->bytes_per_pixel);
pdat->nrl = region_list_alloc(0);
pdat->orl = region_list_alloc(0);
pdat->timing.pixel_clock_hz = dt_read_long(n, "clock-frequency", 8000000);
pdat->timing.h_front_porch = dt_read_int(n, "hfront-porch", 40);
pdat->timing.h_back_porch = dt_read_int(n, "hback-porch", 87);
pdat->timing.h_sync_len = dt_read_int(n, "hsync-len", 1);
pdat->timing.v_front_porch = dt_read_int(n, "vfront-porch", 13);
pdat->timing.v_back_porch = dt_read_int(n, "vback-porch", 31);
pdat->timing.v_sync_len = dt_read_int(n, "vsync-len", 1);
pdat->timing.h_sync_active = dt_read_bool(n, "hsync-active", 0);
pdat->timing.v_sync_active = dt_read_bool(n, "vsync-active", 0);
pdat->timing.den_active = dt_read_bool(n, "den-active", 0);
pdat->timing.clk_active = dt_read_bool(n, "clk-active", 0);
pdat->backlight = search_led(dt_read_string(n, "backlight", NULL));
fb->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
fb->width = pdat->width;
fb->height = pdat->height;
fb->pwidth = pdat->pwidth;
fb->pheight = pdat->pheight;
fb->bytes = pdat->bytes_per_pixel;
fb->setbl = fb_setbl;
fb->getbl = fb_getbl;
fb->create = fb_create;
fb->destroy = fb_destroy;
fb->present = fb_present;
fb->priv = pdat;
clk_enable(pdat->clkdefe);
clk_enable(pdat->clkdebe);
clk_enable(pdat->clktcon);
if(pdat->rstdefe >= 0)
reset_deassert(pdat->rstdefe);
if(pdat->rstdebe >= 0)
reset_deassert(pdat->rstdebe);
if(pdat->rsttcon >= 0)
reset_deassert(pdat->rsttcon);
for(i = 0x0800; i < 0x1000; i += 4)
write32(pdat->virtdebe + i, 0);
fb_f1c500s_init(pdat);
if(!register_framebuffer(&dev, fb))
{
clk_disable(pdat->clkdefe);
clk_disable(pdat->clkdebe);
clk_disable(pdat->clktcon);
free(pdat->clkdefe);
free(pdat->clkdebe);
free(pdat->clktcon);
dma_free_noncoherent(pdat->vram[0]);
dma_free_noncoherent(pdat->vram[1]);
region_list_free(pdat->nrl);
region_list_free(pdat->orl);
free_device_name(fb->name);
free(fb->priv);
free(fb);
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 struct device_t * key_rc5t620_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct key_rc5t620_pdata_t * pdat;
struct input_t * input;
struct device_t * dev;
struct i2c_device_t * i2cdev;
int gpio = dt_read_int(n, "interrupt-gpio", -1);
int irq = gpio_to_irq(gpio);
u8_t val;
if(!gpio_is_valid(gpio) || !irq_is_valid(irq))
return NULL;
i2cdev = i2c_device_alloc(dt_read_string(n, "i2c-bus", NULL), dt_read_int(n, "slave-address", 0x32), 0);
if(!i2cdev)
return NULL;
if(rc5t620_read(i2cdev, RC5T620_LSIVER, &val) && (val == 0x03))
{
rc5t620_write(i2cdev, RC5T620_PWRIRQ, 0x00);
rc5t620_write(i2cdev, RC5T620_PWRIRSEL, 0x01);
rc5t620_write(i2cdev, RC5T620_INTEN, 0x01);
rc5t620_write(i2cdev, RC5T620_PWRIREN, 0x01);
}
else
{
i2c_device_free(i2cdev);
return NULL;
}
pdat = malloc(sizeof(struct key_rc5t620_pdata_t));
if(!pdat)
{
i2c_device_free(i2cdev);
return NULL;
}
input = malloc(sizeof(struct input_t));
if(!input)
{
i2c_device_free(i2cdev);
free(pdat);
return NULL;
}
pdat->dev = i2cdev;
pdat->irq = irq;
input->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
input->type = INPUT_TYPE_KEYBOARD;
input->ioctl = key_rc5t620_ioctl;
input->priv = pdat;
gpio_set_pull(gpio, GPIO_PULL_UP);
gpio_direction_input(gpio);
request_irq(pdat->irq, key_rc5t620_interrupt, IRQ_TYPE_EDGE_FALLING, input);
if(!register_input(&dev, input))
{
free_irq(pdat->irq);
i2c_device_free(pdat->dev);
free_device_name(input->name);
free(input->priv);
free(input);
return NULL;
}
dev->driver = drv;
return dev;
}
