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 * 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 * 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 * clk_mux_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct clk_mux_pdata_t * pdat;
struct clk_mux_parent_t * parent;
struct clk_t * clk;
struct device_t * dev;
struct dtnode_t o;
virtual_addr_t virt = phys_to_virt(dt_read_address(n));
char * name = dt_read_string(n, "name", NULL);
int nparent = dt_read_array_length(n, "parent");
int shift = dt_read_int(n, "shift", -1);
int width = dt_read_int(n, "width", -1);
int i;
if(!name || (nparent <= 0) || (shift < 0) || (width <= 0))
return NULL;
if(search_clk(name))
return NULL;
pdat = malloc(sizeof(struct clk_mux_pdata_t));
if(!pdat)
return NULL;
parent = malloc(sizeof(struct clk_mux_parent_t) * nparent);
if(!parent)
{
free(pdat);
return NULL;
}
clk = malloc(sizeof(struct clk_t));
if(!clk)
{
free(pdat);
free(parent);
return NULL;
}
for(i = 0; i < nparent; i++)
{
dt_read_array_object(n, "parent", i, &o);
parent[i].name = strdup(dt_read_string(&o, "name", NULL));
parent[i].value = dt_read_int(&o, "value", 0);
}
pdat->virt = virt;
pdat->parent = parent;
pdat->nparent = nparent;
pdat->shift = shift;
pdat->width = width;
clk->name = strdup(name);
clk->count = 0;
clk->set_parent = clk_mux_set_parent;
clk->get_parent = clk_mux_get_parent;
clk->set_enable = clk_mux_set_enable;
clk->get_enable = clk_mux_get_enable;
clk->set_rate = clk_mux_set_rate;
clk->get_rate = clk_mux_get_rate;
clk->priv = pdat;
if(!register_clk(&dev, clk))
{
for(i = 0; i < pdat->nparent; i++)
free(pdat->parent[i].name);
free(pdat->parent);
free(clk->name);
free(clk->priv);
free(clk);
return NULL;
}
dev->driver = drv;
if(dt_read_object(n, "default", &o))
{
char * c = clk->name;
char * p;
u64_t r;
int e;
if((p = dt_read_string(&o, "parent", NULL)) && search_clk(p))
clk_set_parent(c, p);
if((r = (u64_t)dt_read_long(&o, "rate", 0)) > 0)
clk_set_rate(c, r);
if((e = dt_read_bool(&o, "enable", -1)) != -1)
{
if(e > 0)
clk_enable(c);
else
clk_disable(c);
}
}
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 * clk_rk3128_gate_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct clk_rk3128_gate_pdata_t * pdat;
struct clk_t * clk;
struct device_t * dev;
struct dtnode_t o;
virtual_addr_t virt = phys_to_virt(dt_read_address(n));
char * parent = dt_read_string(n, "parent", NULL);
char * name = dt_read_string(n, "name", NULL);
int shift = dt_read_int(n, "shift", -1);
if(!parent || !name || (shift < 0))
return NULL;
if(!search_clk(parent) || search_clk(name))
return NULL;
pdat = malloc(sizeof(struct clk_rk3128_gate_pdata_t));
if(!pdat)
return NULL;
clk = malloc(sizeof(struct clk_t));
if(!clk)
{
free(pdat);
return NULL;
}
pdat->virt = virt;
pdat->parent = strdup(parent);
pdat->shift = shift;
pdat->invert = dt_read_bool(n, "invert", 0);
clk->name = strdup(name);
clk->count = 0;
clk->set_parent = clk_rk3128_gate_set_parent;
clk->get_parent = clk_rk3128_gate_get_parent;
clk->set_enable = clk_rk3128_gate_set_enable;
clk->get_enable = clk_rk3128_gate_get_enable;
clk->set_rate = clk_rk3128_gate_set_rate;
clk->get_rate = clk_rk3128_gate_get_rate;
clk->priv = pdat;
if(!register_clk(&dev, clk))
{
free(pdat->parent);
free(clk->name);
free(clk->priv);
free(clk);
return NULL;
}
dev->driver = drv;
if(dt_read_object(n, "default", &o))
{
char * c = clk->name;
char * p;
u64_t r;
int e;
if((p = dt_read_string(&o, "parent", NULL)) && search_clk(p))
clk_set_parent(c, p);
if((r = (u64_t)dt_read_long(&o, "rate", 0)) > 0)
clk_set_rate(c, r);
if((e = dt_read_bool(&o, "enable", -1)) != -1)
{
if(e > 0)
clk_enable(c);
else
clk_disable(c);
}
}
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 * fb_rk3288_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct fb_rk3288_pdata_t * pdat;
struct fb_t * fb;
struct device_t * dev;
virtual_addr_t virt = phys_to_virt(dt_read_address(n));
char * clk = dt_read_string(n, "clock-name", NULL);
if(!search_clk(clk))
return NULL;
pdat = malloc(sizeof(struct fb_rk3288_pdata_t));
if(!pdat)
return NULL;
fb = malloc(sizeof(struct fb_t));
if(!fb)
{
free(pdat);
return NULL;
}
pdat->virtvop = virt;
pdat->virtgrf = phys_to_virt(RK3288_GRF_BASE);
pdat->virtlvds = phys_to_virt(RK3288_LVDS_BASE);
pdat->lcd_avdd_3v3 = strdup(dt_read_string(n, "regulator-lcd-avdd-3v3", NULL));
pdat->lcd_avdd_1v8 = strdup(dt_read_string(n, "regulator-lcd-avdd-1v8", NULL));
pdat->lcd_avdd_1v0 = strdup(dt_read_string(n, "regulator-lcd-avdd-1v0", NULL));
pdat->clk = strdup(clk);
pdat->width = dt_read_int(n, "width", 1024);
pdat->height = dt_read_int(n, "height", 600);
pdat->xdpi = dt_read_int(n, "dots-per-inch-x", 160);
pdat->ydpi = dt_read_int(n, "dots-per-inch-y", 160);
pdat->bits_per_pixel = dt_read_int(n, "bits-per-pixel", 32);
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->interface = RK3288_VOP_INTERFACE_RGB_LVDS;
pdat->output = RK3288_LVDS_OUTPUT_RGB;
pdat->format = RK3288_LVDS_FORMAT_JEIDA;
pdat->mode.mirrorx = 0;
pdat->mode.mirrory = 0;
pdat->mode.swaprg = 0;
pdat->mode.swaprb = 0;
pdat->mode.swapbg = 0;
pdat->timing.pixel_clock_hz = dt_read_long(n, "clock-frequency", 52000000);
pdat->timing.h_front_porch = dt_read_int(n, "hfront-porch", 1);
pdat->timing.h_back_porch = dt_read_int(n, "hback-porch", 1);
pdat->timing.h_sync_len = dt_read_int(n, "hsync-len", 1);
pdat->timing.v_front_porch = dt_read_int(n, "vfront-porch", 1);
pdat->timing.v_back_porch = dt_read_int(n, "vback-porch", 1);
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), -1);
fb->width = pdat->width;
fb->height = pdat->height;
fb->xdpi = pdat->xdpi;
fb->ydpi = pdat->ydpi;
fb->bpp = pdat->bits_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;
regulator_set_voltage(pdat->lcd_avdd_3v3, 3300000);
regulator_enable(pdat->lcd_avdd_3v3);
regulator_set_voltage(pdat->lcd_avdd_1v8, 1800000);
regulator_enable(pdat->lcd_avdd_1v8);
regulator_set_voltage(pdat->lcd_avdd_1v0, 1000000);
regulator_enable(pdat->lcd_avdd_1v0);
clk_enable(pdat->clk);
rk3288_fb_init(pdat);
if(!register_fb(&dev, fb))
{
regulator_disable(pdat->lcd_avdd_3v3);
free(pdat->lcd_avdd_3v3);
regulator_disable(pdat->lcd_avdd_1v8);
free(pdat->lcd_avdd_1v8);
regulator_disable(pdat->lcd_avdd_1v0);
free(pdat->lcd_avdd_1v0);
clk_disable(pdat->clk);
free(pdat->clk);
dma_free_noncoherent(pdat->vram[0]);
dma_free_noncoherent(pdat->vram[1]);
free_device_name(fb->name);
free(fb->priv);
free(fb);
return NULL;
}
dev->driver = drv;
return dev;
}