forked from Minki/linux
tilcdc changes for v4.6
Accumulated fixes and improvements from ti-linux-4.1. * Almost complete rewrite of pagefliping code * dma-buf support * pinctrl support * lot of fixes and cleanups -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQIcBAABAgAGBQJW3ZNlAAoJEJA2s1DX1hlBBcEQALfPeM84vrjimisntOwxgMMC vuqAjFr0LjtbHjhEbNtG/jckCxsLAU88UY+vtvawkSw9+t+AlBdMbydbxfWO/7ER UuNm+a14clyxcJfIr9/VhtTKy9mlZ8uliz0sOfvAo+ayYJPa1YG9jw+HGJCYsD2f WFwMJwiPeTeDJGLRH+7Vuy4F4iGg6rYcT3fvkE5xHIevG+tavMWV9IFuflAwCvqA 1BE88kWK4f4phyW3DjEMgfVOk3T4EZqkIcI5XZBLC1vp5w5nEdeb4UrX4VBQQ34x WTJU+5nGdH7lMxMeadqfc/+0LOigSlNOh6h+ugGpTIka3CpE5nO9tq5Wid78QPfK vaSAyQ/b0a0hiCBs1bA/GEC/dbFSmmE9vE72DVSOwK30tgvhMip4rzZyM7ERz8lz DBZL0Fw8zb/mEyCfhuCImjzVuHNZKQlRw7tImOBqKrBBWU5LOIsgZ5srEzIeBnmV BxgAzI/NcTTo+w2t/+59wUiAep4OPP3Lyz8jRA4c7uhttwXknaX28FjKZJLHtcEM tBXJkLoGB2egpwnG5s+xKJA9qBE1AwbbRLnnySGEjtSagRAMZ7f1WqQmiRXkFGqQ Ilmteg2SFt/KX7EllL1U5ggX24IlzE+MLFhG/f4zcTBziidcyP2tpN5Tn7uMdx7V UHP4lSJKNldbRj5VwIh1 =vIeq -----END PGP SIGNATURE----- Merge tag 'tilcdc-4.6' of https://github.com/jsarha/linux into drm-next tilcdc changes for v4.6 Accumulated fixes and improvements from ti-linux-4.1. * Almost complete rewrite of pagefliping code * dma-buf support * pinctrl support * lot of fixes and cleanups * tag 'tilcdc-4.6' of https://github.com/jsarha/linux: (22 commits) drm/tilcdc: Use devm_kzalloc() and devm_kcalloc() for private data drm/tilcdc: Initialize crtc->port drm/tilcdc: Disable sync lost interrupt if it fires on every frame drm/tilcdc: Add prints on sync lost and FIFO underrun interrupts drm/tilcdc: Remove the duplicate LCDC_INT_ENABLE_SET_REG in registers[] drm/tilcdc: Fix interrupt enable/disable code for version 2 tilcdc drm/tilcdc: Do not update the next frame buffer close to vertical blank drm/tilcdc: Get rid of complex ping-pong mechanism drm/tilcdc: cleanup irq handling drm/tilcdc: remove broken error handling drm/tilcdc: split reset to a separate function drm/tilcdc: disable crtc on unload drm/tilcdc: cleanup runtime PM handling drm/tilcdc: Allocate register storage based on the actual number registers drm/tilcdc: fix build error when !CONFIG_CPU_FREQ drm/tilcdc: Implement dma-buf support for tilcdc drm/tilcdc: disable the lcd controller/dma engine when suspend invoked drm/tilcdc: make frame_done interrupt active at all times drm/tilcdc: fix kernel panic on suspend when no hdmi monitor connected drm/tilcdc: adopt pinctrl support ...
This commit is contained in:
Dave Airlie
commit
d8c61663c7
@ -21,25 +21,31 @@
|
||||
#include "tilcdc_drv.h"
|
||||
#include "tilcdc_regs.h"
|
||||
|
||||
#define TILCDC_VBLANK_SAFETY_THRESHOLD_US 1000
|
||||
|
||||
struct tilcdc_crtc {
|
||||
struct drm_crtc base;
|
||||
|
||||
const struct tilcdc_panel_info *info;
|
||||
uint32_t dirty;
|
||||
dma_addr_t start, end;
|
||||
struct drm_pending_vblank_event *event;
|
||||
int dpms;
|
||||
wait_queue_head_t frame_done_wq;
|
||||
bool frame_done;
|
||||
spinlock_t irq_lock;
|
||||
|
||||
/* fb currently set to scanout 0/1: */
|
||||
struct drm_framebuffer *scanout[2];
|
||||
ktime_t last_vblank;
|
||||
|
||||
struct drm_framebuffer *curr_fb;
|
||||
struct drm_framebuffer *next_fb;
|
||||
|
||||
/* for deferred fb unref's: */
|
||||
struct drm_flip_work unref_work;
|
||||
|
||||
/* Only set if an external encoder is connected */
|
||||
bool simulate_vesa_sync;
|
||||
|
||||
int sync_lost_count;
|
||||
bool frame_intact;
|
||||
};
|
||||
#define to_tilcdc_crtc(x) container_of(x, struct tilcdc_crtc, base)
|
||||
|
||||
@ -54,79 +60,53 @@ static void unref_worker(struct drm_flip_work *work, void *val)
|
||||
mutex_unlock(&dev->mode_config.mutex);
|
||||
}
|
||||
|
||||
static void set_scanout(struct drm_crtc *crtc, int n)
|
||||
{
|
||||
static const uint32_t base_reg[] = {
|
||||
LCDC_DMA_FB_BASE_ADDR_0_REG,
|
||||
LCDC_DMA_FB_BASE_ADDR_1_REG,
|
||||
};
|
||||
static const uint32_t ceil_reg[] = {
|
||||
LCDC_DMA_FB_CEILING_ADDR_0_REG,
|
||||
LCDC_DMA_FB_CEILING_ADDR_1_REG,
|
||||
};
|
||||
static const uint32_t stat[] = {
|
||||
LCDC_END_OF_FRAME0, LCDC_END_OF_FRAME1,
|
||||
};
|
||||
struct tilcdc_crtc *tilcdc_crtc = to_tilcdc_crtc(crtc);
|
||||
struct drm_device *dev = crtc->dev;
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
tilcdc_write(dev, base_reg[n], tilcdc_crtc->start);
|
||||
tilcdc_write(dev, ceil_reg[n], tilcdc_crtc->end);
|
||||
if (tilcdc_crtc->scanout[n]) {
|
||||
drm_flip_work_queue(&tilcdc_crtc->unref_work, tilcdc_crtc->scanout[n]);
|
||||
drm_flip_work_commit(&tilcdc_crtc->unref_work, priv->wq);
|
||||
}
|
||||
tilcdc_crtc->scanout[n] = crtc->primary->fb;
|
||||
drm_framebuffer_reference(tilcdc_crtc->scanout[n]);
|
||||
tilcdc_crtc->dirty &= ~stat[n];
|
||||
pm_runtime_put_sync(dev->dev);
|
||||
}
|
||||
|
||||
static void update_scanout(struct drm_crtc *crtc)
|
||||
static void set_scanout(struct drm_crtc *crtc, struct drm_framebuffer *fb)
|
||||
{
|
||||
struct tilcdc_crtc *tilcdc_crtc = to_tilcdc_crtc(crtc);
|
||||
struct drm_device *dev = crtc->dev;
|
||||
struct drm_framebuffer *fb = crtc->primary->fb;
|
||||
struct drm_gem_cma_object *gem;
|
||||
unsigned int depth, bpp;
|
||||
dma_addr_t start, end;
|
||||
|
||||
drm_fb_get_bpp_depth(fb->pixel_format, &depth, &bpp);
|
||||
gem = drm_fb_cma_get_gem_obj(fb, 0);
|
||||
|
||||
tilcdc_crtc->start = gem->paddr + fb->offsets[0] +
|
||||
(crtc->y * fb->pitches[0]) + (crtc->x * bpp/8);
|
||||
start = gem->paddr + fb->offsets[0] +
|
||||
crtc->y * fb->pitches[0] +
|
||||
crtc->x * bpp / 8;
|
||||
|
||||
tilcdc_crtc->end = tilcdc_crtc->start +
|
||||
(crtc->mode.vdisplay * fb->pitches[0]);
|
||||
end = start + (crtc->mode.vdisplay * fb->pitches[0]);
|
||||
|
||||
if (tilcdc_crtc->dpms == DRM_MODE_DPMS_ON) {
|
||||
/* already enabled, so just mark the frames that need
|
||||
* updating and they will be updated on vblank:
|
||||
*/
|
||||
tilcdc_crtc->dirty |= LCDC_END_OF_FRAME0 | LCDC_END_OF_FRAME1;
|
||||
drm_vblank_get(dev, 0);
|
||||
} else {
|
||||
/* not enabled yet, so update registers immediately: */
|
||||
set_scanout(crtc, 0);
|
||||
set_scanout(crtc, 1);
|
||||
}
|
||||
tilcdc_write(dev, LCDC_DMA_FB_BASE_ADDR_0_REG, start);
|
||||
tilcdc_write(dev, LCDC_DMA_FB_CEILING_ADDR_0_REG, end);
|
||||
|
||||
if (tilcdc_crtc->curr_fb)
|
||||
drm_flip_work_queue(&tilcdc_crtc->unref_work,
|
||||
tilcdc_crtc->curr_fb);
|
||||
|
||||
tilcdc_crtc->curr_fb = fb;
|
||||
}
|
||||
|
||||
static void reset(struct drm_crtc *crtc)
|
||||
{
|
||||
struct drm_device *dev = crtc->dev;
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
|
||||
if (priv->rev != 2)
|
||||
return;
|
||||
|
||||
tilcdc_set(dev, LCDC_CLK_RESET_REG, LCDC_CLK_MAIN_RESET);
|
||||
usleep_range(250, 1000);
|
||||
tilcdc_clear(dev, LCDC_CLK_RESET_REG, LCDC_CLK_MAIN_RESET);
|
||||
}
|
||||
|
||||
static void start(struct drm_crtc *crtc)
|
||||
{
|
||||
struct drm_device *dev = crtc->dev;
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
|
||||
if (priv->rev == 2) {
|
||||
tilcdc_set(dev, LCDC_CLK_RESET_REG, LCDC_CLK_MAIN_RESET);
|
||||
msleep(1);
|
||||
tilcdc_clear(dev, LCDC_CLK_RESET_REG, LCDC_CLK_MAIN_RESET);
|
||||
msleep(1);
|
||||
}
|
||||
reset(crtc);
|
||||
|
||||
tilcdc_set(dev, LCDC_DMA_CTRL_REG, LCDC_DUAL_FRAME_BUFFER_ENABLE);
|
||||
tilcdc_clear(dev, LCDC_DMA_CTRL_REG, LCDC_DUAL_FRAME_BUFFER_ENABLE);
|
||||
tilcdc_set(dev, LCDC_RASTER_CTRL_REG, LCDC_PALETTE_LOAD_MODE(DATA_ONLY));
|
||||
tilcdc_set(dev, LCDC_RASTER_CTRL_REG, LCDC_RASTER_ENABLE);
|
||||
}
|
||||
@ -138,17 +118,31 @@ static void stop(struct drm_crtc *crtc)
|
||||
tilcdc_clear(dev, LCDC_RASTER_CTRL_REG, LCDC_RASTER_ENABLE);
|
||||
}
|
||||
|
||||
static void tilcdc_crtc_dpms(struct drm_crtc *crtc, int mode);
|
||||
static void tilcdc_crtc_destroy(struct drm_crtc *crtc)
|
||||
{
|
||||
struct tilcdc_crtc *tilcdc_crtc = to_tilcdc_crtc(crtc);
|
||||
|
||||
tilcdc_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
|
||||
|
||||
of_node_put(crtc->port);
|
||||
drm_crtc_cleanup(crtc);
|
||||
drm_flip_work_cleanup(&tilcdc_crtc->unref_work);
|
||||
}
|
||||
|
||||
kfree(tilcdc_crtc);
|
||||
static int tilcdc_verify_fb(struct drm_crtc *crtc, struct drm_framebuffer *fb)
|
||||
{
|
||||
struct drm_device *dev = crtc->dev;
|
||||
unsigned int depth, bpp;
|
||||
|
||||
drm_fb_get_bpp_depth(fb->pixel_format, &depth, &bpp);
|
||||
|
||||
if (fb->pitches[0] != crtc->mode.hdisplay * bpp / 8) {
|
||||
dev_err(dev->dev,
|
||||
"Invalid pitch: fb and crtc widths must be the same");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tilcdc_crtc_page_flip(struct drm_crtc *crtc,
|
||||
@ -158,20 +152,48 @@ static int tilcdc_crtc_page_flip(struct drm_crtc *crtc,
|
||||
{
|
||||
struct tilcdc_crtc *tilcdc_crtc = to_tilcdc_crtc(crtc);
|
||||
struct drm_device *dev = crtc->dev;
|
||||
int r;
|
||||
unsigned long flags;
|
||||
s64 tdiff;
|
||||
ktime_t next_vblank;
|
||||
|
||||
r = tilcdc_verify_fb(crtc, fb);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
if (tilcdc_crtc->event) {
|
||||
dev_err(dev->dev, "already pending page flip!\n");
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
drm_framebuffer_reference(fb);
|
||||
|
||||
crtc->primary->fb = fb;
|
||||
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
|
||||
spin_lock_irqsave(&tilcdc_crtc->irq_lock, flags);
|
||||
|
||||
next_vblank = ktime_add_us(tilcdc_crtc->last_vblank,
|
||||
1000000 / crtc->hwmode.vrefresh);
|
||||
|
||||
tdiff = ktime_to_us(ktime_sub(next_vblank, ktime_get()));
|
||||
|
||||
if (tdiff >= TILCDC_VBLANK_SAFETY_THRESHOLD_US)
|
||||
set_scanout(crtc, fb);
|
||||
else
|
||||
tilcdc_crtc->next_fb = fb;
|
||||
|
||||
tilcdc_crtc->event = event;
|
||||
update_scanout(crtc);
|
||||
|
||||
spin_unlock_irqrestore(&tilcdc_crtc->irq_lock, flags);
|
||||
|
||||
pm_runtime_put_sync(dev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tilcdc_crtc_dpms(struct drm_crtc *crtc, int mode)
|
||||
void tilcdc_crtc_dpms(struct drm_crtc *crtc, int mode)
|
||||
{
|
||||
struct tilcdc_crtc *tilcdc_crtc = to_tilcdc_crtc(crtc);
|
||||
struct drm_device *dev = crtc->dev;
|
||||
@ -186,10 +208,8 @@ static void tilcdc_crtc_dpms(struct drm_crtc *crtc, int mode)
|
||||
|
||||
tilcdc_crtc->dpms = mode;
|
||||
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
|
||||
if (mode == DRM_MODE_DPMS_ON) {
|
||||
pm_runtime_forbid(dev->dev);
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
start(crtc);
|
||||
} else {
|
||||
tilcdc_crtc->frame_done = false;
|
||||
@ -207,10 +227,23 @@ static void tilcdc_crtc_dpms(struct drm_crtc *crtc, int mode)
|
||||
if (ret == 0)
|
||||
dev_err(dev->dev, "timeout waiting for framedone\n");
|
||||
}
|
||||
pm_runtime_allow(dev->dev);
|
||||
}
|
||||
|
||||
pm_runtime_put_sync(dev->dev);
|
||||
|
||||
if (tilcdc_crtc->next_fb) {
|
||||
drm_flip_work_queue(&tilcdc_crtc->unref_work,
|
||||
tilcdc_crtc->next_fb);
|
||||
tilcdc_crtc->next_fb = NULL;
|
||||
}
|
||||
|
||||
if (tilcdc_crtc->curr_fb) {
|
||||
drm_flip_work_queue(&tilcdc_crtc->unref_work,
|
||||
tilcdc_crtc->curr_fb);
|
||||
tilcdc_crtc->curr_fb = NULL;
|
||||
}
|
||||
|
||||
drm_flip_work_commit(&tilcdc_crtc->unref_work, priv->wq);
|
||||
}
|
||||
}
|
||||
|
||||
static bool tilcdc_crtc_mode_fixup(struct drm_crtc *crtc,
|
||||
@ -272,6 +305,10 @@ static int tilcdc_crtc_mode_set(struct drm_crtc *crtc,
|
||||
if (WARN_ON(!info))
|
||||
return -EINVAL;
|
||||
|
||||
ret = tilcdc_verify_fb(crtc, crtc->primary->fb);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
|
||||
/* Configure the Burst Size and fifo threshold of DMA: */
|
||||
@ -419,8 +456,10 @@ static int tilcdc_crtc_mode_set(struct drm_crtc *crtc,
|
||||
else
|
||||
tilcdc_clear(dev, LCDC_RASTER_CTRL_REG, LCDC_RASTER_ORDER);
|
||||
|
||||
drm_framebuffer_reference(crtc->primary->fb);
|
||||
|
||||
set_scanout(crtc, crtc->primary->fb);
|
||||
|
||||
update_scanout(crtc);
|
||||
tilcdc_crtc_update_clk(crtc);
|
||||
|
||||
pm_runtime_put_sync(dev->dev);
|
||||
@ -431,7 +470,21 @@ static int tilcdc_crtc_mode_set(struct drm_crtc *crtc,
|
||||
static int tilcdc_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
|
||||
struct drm_framebuffer *old_fb)
|
||||
{
|
||||
update_scanout(crtc);
|
||||
struct drm_device *dev = crtc->dev;
|
||||
int r;
|
||||
|
||||
r = tilcdc_verify_fb(crtc, crtc->primary->fb);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
drm_framebuffer_reference(crtc->primary->fb);
|
||||
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
|
||||
set_scanout(crtc, crtc->primary->fb);
|
||||
|
||||
pm_runtime_put_sync(dev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -573,7 +626,8 @@ void tilcdc_crtc_update_clk(struct drm_crtc *crtc)
|
||||
struct drm_device *dev = crtc->dev;
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
int dpms = tilcdc_crtc->dpms;
|
||||
unsigned int lcd_clk, div;
|
||||
unsigned long lcd_clk;
|
||||
const unsigned clkdiv = 2; /* using a fixed divider of 2 */
|
||||
int ret;
|
||||
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
@ -581,22 +635,21 @@ void tilcdc_crtc_update_clk(struct drm_crtc *crtc)
|
||||
if (dpms == DRM_MODE_DPMS_ON)
|
||||
tilcdc_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
|
||||
|
||||
/* in raster mode, minimum divisor is 2: */
|
||||
ret = clk_set_rate(priv->disp_clk, crtc->mode.clock * 1000 * 2);
|
||||
if (ret) {
|
||||
/* mode.clock is in KHz, set_rate wants parameter in Hz */
|
||||
ret = clk_set_rate(priv->clk, crtc->mode.clock * 1000 * clkdiv);
|
||||
if (ret < 0) {
|
||||
dev_err(dev->dev, "failed to set display clock rate to: %d\n",
|
||||
crtc->mode.clock);
|
||||
goto out;
|
||||
}
|
||||
|
||||
lcd_clk = clk_get_rate(priv->clk);
|
||||
div = lcd_clk / (crtc->mode.clock * 1000);
|
||||
|
||||
DBG("lcd_clk=%u, mode clock=%d, div=%u", lcd_clk, crtc->mode.clock, div);
|
||||
DBG("fck=%lu, dpll_disp_ck=%lu", clk_get_rate(priv->clk), clk_get_rate(priv->disp_clk));
|
||||
DBG("lcd_clk=%lu, mode clock=%d, div=%u",
|
||||
lcd_clk, crtc->mode.clock, clkdiv);
|
||||
|
||||
/* Configure the LCD clock divisor. */
|
||||
tilcdc_write(dev, LCDC_CTRL_REG, LCDC_CLK_DIVISOR(div) |
|
||||
tilcdc_write(dev, LCDC_CTRL_REG, LCDC_CLK_DIVISOR(clkdiv) |
|
||||
LCDC_RASTER_MODE);
|
||||
|
||||
if (priv->rev == 2)
|
||||
@ -611,44 +664,58 @@ out:
|
||||
pm_runtime_put_sync(dev->dev);
|
||||
}
|
||||
|
||||
#define SYNC_LOST_COUNT_LIMIT 50
|
||||
|
||||
irqreturn_t tilcdc_crtc_irq(struct drm_crtc *crtc)
|
||||
{
|
||||
struct tilcdc_crtc *tilcdc_crtc = to_tilcdc_crtc(crtc);
|
||||
struct drm_device *dev = crtc->dev;
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
uint32_t stat = tilcdc_read_irqstatus(dev);
|
||||
uint32_t stat;
|
||||
|
||||
if ((stat & LCDC_SYNC_LOST) && (stat & LCDC_FIFO_UNDERFLOW)) {
|
||||
stop(crtc);
|
||||
dev_err(dev->dev, "error: %08x\n", stat);
|
||||
stat = tilcdc_read_irqstatus(dev);
|
||||
tilcdc_clear_irqstatus(dev, stat);
|
||||
start(crtc);
|
||||
} else if (stat & LCDC_PL_LOAD_DONE) {
|
||||
tilcdc_clear_irqstatus(dev, stat);
|
||||
} else {
|
||||
struct drm_pending_vblank_event *event;
|
||||
|
||||
if (stat & LCDC_END_OF_FRAME0) {
|
||||
unsigned long flags;
|
||||
uint32_t dirty = tilcdc_crtc->dirty & stat;
|
||||
bool skip_event = false;
|
||||
ktime_t now;
|
||||
|
||||
tilcdc_clear_irqstatus(dev, stat);
|
||||
now = ktime_get();
|
||||
|
||||
if (dirty & LCDC_END_OF_FRAME0)
|
||||
set_scanout(crtc, 0);
|
||||
drm_flip_work_commit(&tilcdc_crtc->unref_work, priv->wq);
|
||||
|
||||
if (dirty & LCDC_END_OF_FRAME1)
|
||||
set_scanout(crtc, 1);
|
||||
spin_lock_irqsave(&tilcdc_crtc->irq_lock, flags);
|
||||
|
||||
tilcdc_crtc->last_vblank = now;
|
||||
|
||||
if (tilcdc_crtc->next_fb) {
|
||||
set_scanout(crtc, tilcdc_crtc->next_fb);
|
||||
tilcdc_crtc->next_fb = NULL;
|
||||
skip_event = true;
|
||||
}
|
||||
|
||||
spin_unlock_irqrestore(&tilcdc_crtc->irq_lock, flags);
|
||||
|
||||
drm_handle_vblank(dev, 0);
|
||||
|
||||
if (!skip_event) {
|
||||
struct drm_pending_vblank_event *event;
|
||||
|
||||
spin_lock_irqsave(&dev->event_lock, flags);
|
||||
|
||||
event = tilcdc_crtc->event;
|
||||
tilcdc_crtc->event = NULL;
|
||||
if (event)
|
||||
drm_send_vblank_event(dev, 0, event);
|
||||
spin_unlock_irqrestore(&dev->event_lock, flags);
|
||||
|
||||
if (dirty && !tilcdc_crtc->dirty)
|
||||
drm_vblank_put(dev, 0);
|
||||
spin_unlock_irqrestore(&dev->event_lock, flags);
|
||||
}
|
||||
|
||||
if (tilcdc_crtc->frame_intact)
|
||||
tilcdc_crtc->sync_lost_count = 0;
|
||||
else
|
||||
tilcdc_crtc->frame_intact = true;
|
||||
}
|
||||
|
||||
if (priv->rev == 2) {
|
||||
@ -659,16 +726,34 @@ irqreturn_t tilcdc_crtc_irq(struct drm_crtc *crtc)
|
||||
tilcdc_write(dev, LCDC_END_OF_INT_IND_REG, 0);
|
||||
}
|
||||
|
||||
if (stat & LCDC_SYNC_LOST) {
|
||||
dev_err_ratelimited(dev->dev, "%s(0x%08x): Sync lost",
|
||||
__func__, stat);
|
||||
tilcdc_crtc->frame_intact = false;
|
||||
if (tilcdc_crtc->sync_lost_count++ > SYNC_LOST_COUNT_LIMIT) {
|
||||
dev_err(dev->dev,
|
||||
"%s(0x%08x): Sync lost flood detected, disabling the interrupt",
|
||||
__func__, stat);
|
||||
tilcdc_write(dev, LCDC_INT_ENABLE_CLR_REG,
|
||||
LCDC_SYNC_LOST);
|
||||
}
|
||||
}
|
||||
|
||||
if (stat & LCDC_FIFO_UNDERFLOW)
|
||||
dev_err_ratelimited(dev->dev, "%s(0x%08x): FIFO underfow",
|
||||
__func__, stat);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
struct drm_crtc *tilcdc_crtc_create(struct drm_device *dev)
|
||||
{
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
struct tilcdc_crtc *tilcdc_crtc;
|
||||
struct drm_crtc *crtc;
|
||||
int ret;
|
||||
|
||||
tilcdc_crtc = kzalloc(sizeof(*tilcdc_crtc), GFP_KERNEL);
|
||||
tilcdc_crtc = devm_kzalloc(dev->dev, sizeof(*tilcdc_crtc), GFP_KERNEL);
|
||||
if (!tilcdc_crtc) {
|
||||
dev_err(dev->dev, "allocation failed\n");
|
||||
return NULL;
|
||||
@ -682,12 +767,32 @@ struct drm_crtc *tilcdc_crtc_create(struct drm_device *dev)
|
||||
drm_flip_work_init(&tilcdc_crtc->unref_work,
|
||||
"unref", unref_worker);
|
||||
|
||||
spin_lock_init(&tilcdc_crtc->irq_lock);
|
||||
|
||||
ret = drm_crtc_init(dev, crtc, &tilcdc_crtc_funcs);
|
||||
if (ret < 0)
|
||||
goto fail;
|
||||
|
||||
drm_crtc_helper_add(crtc, &tilcdc_crtc_helper_funcs);
|
||||
|
||||
if (priv->is_componentized) {
|
||||
struct device_node *ports =
|
||||
of_get_child_by_name(dev->dev->of_node, "ports");
|
||||
|
||||
if (ports) {
|
||||
crtc->port = of_get_child_by_name(ports, "port");
|
||||
of_node_put(ports);
|
||||
} else {
|
||||
crtc->port =
|
||||
of_get_child_by_name(dev->dev->of_node, "port");
|
||||
}
|
||||
if (!crtc->port) { /* This should never happen */
|
||||
dev_err(dev->dev, "Port node not found in %s\n",
|
||||
dev->dev->of_node->full_name);
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
return crtc;
|
||||
|
||||
fail:
|
||||
|
||||
@ -18,6 +18,8 @@
|
||||
/* LCDC DRM driver, based on da8xx-fb */
|
||||
|
||||
#include <linux/component.h>
|
||||
#include <linux/pinctrl/consumer.h>
|
||||
#include <linux/suspend.h>
|
||||
|
||||
#include "tilcdc_drv.h"
|
||||
#include "tilcdc_regs.h"
|
||||
@ -110,6 +112,8 @@ static int tilcdc_unload(struct drm_device *dev)
|
||||
{
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
|
||||
tilcdc_crtc_dpms(priv->crtc, DRM_MODE_DPMS_OFF);
|
||||
|
||||
tilcdc_remove_external_encoders(dev);
|
||||
|
||||
drm_fbdev_cma_fini(priv->fbdev);
|
||||
@ -139,11 +143,11 @@ static int tilcdc_unload(struct drm_device *dev)
|
||||
|
||||
pm_runtime_disable(dev->dev);
|
||||
|
||||
kfree(priv);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static size_t tilcdc_num_regs(void);
|
||||
|
||||
static int tilcdc_load(struct drm_device *dev, unsigned long flags)
|
||||
{
|
||||
struct platform_device *pdev = dev->platformdev;
|
||||
@ -154,8 +158,12 @@ static int tilcdc_load(struct drm_device *dev, unsigned long flags)
|
||||
u32 bpp = 0;
|
||||
int ret;
|
||||
|
||||
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv) {
|
||||
priv = devm_kzalloc(dev->dev, sizeof(*priv), GFP_KERNEL);
|
||||
if (priv)
|
||||
priv->saved_register =
|
||||
devm_kcalloc(dev->dev, tilcdc_num_regs(),
|
||||
sizeof(*priv->saved_register), GFP_KERNEL);
|
||||
if (!priv || !priv->saved_register) {
|
||||
dev_err(dev->dev, "failed to allocate private data\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
@ -168,7 +176,7 @@ static int tilcdc_load(struct drm_device *dev, unsigned long flags)
|
||||
priv->wq = alloc_ordered_workqueue("tilcdc", 0);
|
||||
if (!priv->wq) {
|
||||
ret = -ENOMEM;
|
||||
goto fail_free_priv;
|
||||
goto fail_unset_priv;
|
||||
}
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
@ -192,13 +200,6 @@ static int tilcdc_load(struct drm_device *dev, unsigned long flags)
|
||||
goto fail_iounmap;
|
||||
}
|
||||
|
||||
priv->disp_clk = clk_get(dev->dev, "dpll_disp_ck");
|
||||
if (IS_ERR(priv->clk)) {
|
||||
dev_err(dev->dev, "failed to get display clock\n");
|
||||
ret = -ENODEV;
|
||||
goto fail_put_clk;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_CPU_FREQ
|
||||
priv->lcd_fck_rate = clk_get_rate(priv->clk);
|
||||
priv->freq_transition.notifier_call = cpufreq_transition;
|
||||
@ -206,7 +207,7 @@ static int tilcdc_load(struct drm_device *dev, unsigned long flags)
|
||||
CPUFREQ_TRANSITION_NOTIFIER);
|
||||
if (ret) {
|
||||
dev_err(dev->dev, "failed to register cpufreq notifier\n");
|
||||
goto fail_put_disp_clk;
|
||||
goto fail_put_clk;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -227,7 +228,6 @@ static int tilcdc_load(struct drm_device *dev, unsigned long flags)
|
||||
DBG("Maximum Pixel Clock Value %dKHz", priv->max_pixelclock);
|
||||
|
||||
pm_runtime_enable(dev->dev);
|
||||
pm_runtime_irq_safe(dev->dev);
|
||||
|
||||
/* Determine LCD IP Version */
|
||||
pm_runtime_get_sync(dev->dev);
|
||||
@ -330,11 +330,9 @@ fail_cpufreq_unregister:
|
||||
#ifdef CONFIG_CPU_FREQ
|
||||
cpufreq_unregister_notifier(&priv->freq_transition,
|
||||
CPUFREQ_TRANSITION_NOTIFIER);
|
||||
fail_put_disp_clk:
|
||||
clk_put(priv->disp_clk);
|
||||
#endif
|
||||
|
||||
fail_put_clk:
|
||||
#endif
|
||||
clk_put(priv->clk);
|
||||
|
||||
fail_iounmap:
|
||||
@ -344,9 +342,9 @@ fail_free_wq:
|
||||
flush_workqueue(priv->wq);
|
||||
destroy_workqueue(priv->wq);
|
||||
|
||||
fail_free_priv:
|
||||
fail_unset_priv:
|
||||
dev->dev_private = NULL;
|
||||
kfree(priv);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -373,10 +371,14 @@ static int tilcdc_irq_postinstall(struct drm_device *dev)
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
|
||||
/* enable FIFO underflow irq: */
|
||||
if (priv->rev == 1)
|
||||
if (priv->rev == 1) {
|
||||
tilcdc_set(dev, LCDC_RASTER_CTRL_REG, LCDC_V1_UNDERFLOW_INT_ENA);
|
||||
else
|
||||
tilcdc_set(dev, LCDC_INT_ENABLE_SET_REG, LCDC_V2_UNDERFLOW_INT_ENA);
|
||||
} else {
|
||||
tilcdc_write(dev, LCDC_INT_ENABLE_SET_REG,
|
||||
LCDC_V2_UNDERFLOW_INT_ENA |
|
||||
LCDC_V2_END_OF_FRAME0_INT_ENA |
|
||||
LCDC_FRAME_DONE | LCDC_SYNC_LOST);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -391,43 +393,21 @@ static void tilcdc_irq_uninstall(struct drm_device *dev)
|
||||
LCDC_V1_UNDERFLOW_INT_ENA | LCDC_V1_PL_INT_ENA);
|
||||
tilcdc_clear(dev, LCDC_DMA_CTRL_REG, LCDC_V1_END_OF_FRAME_INT_ENA);
|
||||
} else {
|
||||
tilcdc_clear(dev, LCDC_INT_ENABLE_SET_REG,
|
||||
tilcdc_write(dev, LCDC_INT_ENABLE_CLR_REG,
|
||||
LCDC_V2_UNDERFLOW_INT_ENA | LCDC_V2_PL_INT_ENA |
|
||||
LCDC_V2_END_OF_FRAME0_INT_ENA | LCDC_V2_END_OF_FRAME1_INT_ENA |
|
||||
LCDC_FRAME_DONE);
|
||||
LCDC_V2_END_OF_FRAME0_INT_ENA |
|
||||
LCDC_FRAME_DONE | LCDC_SYNC_LOST);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void enable_vblank(struct drm_device *dev, bool enable)
|
||||
{
|
||||
struct tilcdc_drm_private *priv = dev->dev_private;
|
||||
u32 reg, mask;
|
||||
|
||||
if (priv->rev == 1) {
|
||||
reg = LCDC_DMA_CTRL_REG;
|
||||
mask = LCDC_V1_END_OF_FRAME_INT_ENA;
|
||||
} else {
|
||||
reg = LCDC_INT_ENABLE_SET_REG;
|
||||
mask = LCDC_V2_END_OF_FRAME0_INT_ENA |
|
||||
LCDC_V2_END_OF_FRAME1_INT_ENA | LCDC_FRAME_DONE;
|
||||
}
|
||||
|
||||
if (enable)
|
||||
tilcdc_set(dev, reg, mask);
|
||||
else
|
||||
tilcdc_clear(dev, reg, mask);
|
||||
}
|
||||
|
||||
static int tilcdc_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
enable_vblank(dev, true);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tilcdc_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
enable_vblank(dev, false);
|
||||
return;
|
||||
}
|
||||
|
||||
#if defined(CONFIG_DEBUG_FS) || defined(CONFIG_PM_SLEEP)
|
||||
@ -454,13 +434,22 @@ static const struct {
|
||||
/* new in revision 2: */
|
||||
REG(2, false, LCDC_RAW_STAT_REG),
|
||||
REG(2, false, LCDC_MASKED_STAT_REG),
|
||||
REG(2, false, LCDC_INT_ENABLE_SET_REG),
|
||||
REG(2, true, LCDC_INT_ENABLE_SET_REG),
|
||||
REG(2, false, LCDC_INT_ENABLE_CLR_REG),
|
||||
REG(2, false, LCDC_END_OF_INT_IND_REG),
|
||||
REG(2, true, LCDC_CLK_ENABLE_REG),
|
||||
REG(2, true, LCDC_INT_ENABLE_SET_REG),
|
||||
#undef REG
|
||||
};
|
||||
|
||||
static size_t tilcdc_num_regs(void)
|
||||
{
|
||||
return ARRAY_SIZE(registers);
|
||||
}
|
||||
#else
|
||||
static size_t tilcdc_num_regs(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
@ -547,7 +536,8 @@ static const struct file_operations fops = {
|
||||
};
|
||||
|
||||
static struct drm_driver tilcdc_driver = {
|
||||
.driver_features = DRIVER_HAVE_IRQ | DRIVER_GEM | DRIVER_MODESET,
|
||||
.driver_features = (DRIVER_HAVE_IRQ | DRIVER_GEM | DRIVER_MODESET |
|
||||
DRIVER_PRIME),
|
||||
.load = tilcdc_load,
|
||||
.unload = tilcdc_unload,
|
||||
.lastclose = tilcdc_lastclose,
|
||||
@ -564,6 +554,16 @@ static struct drm_driver tilcdc_driver = {
|
||||
.dumb_create = drm_gem_cma_dumb_create,
|
||||
.dumb_map_offset = drm_gem_cma_dumb_map_offset,
|
||||
.dumb_destroy = drm_gem_dumb_destroy,
|
||||
|
||||
.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
|
||||
.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
|
||||
.gem_prime_import = drm_gem_prime_import,
|
||||
.gem_prime_export = drm_gem_prime_export,
|
||||
.gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
|
||||
.gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
|
||||
.gem_prime_vmap = drm_gem_cma_prime_vmap,
|
||||
.gem_prime_vunmap = drm_gem_cma_prime_vunmap,
|
||||
.gem_prime_mmap = drm_gem_cma_prime_mmap,
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
.debugfs_init = tilcdc_debugfs_init,
|
||||
.debugfs_cleanup = tilcdc_debugfs_cleanup,
|
||||
@ -589,11 +589,24 @@ static int tilcdc_pm_suspend(struct device *dev)
|
||||
|
||||
drm_kms_helper_poll_disable(ddev);
|
||||
|
||||
/* Select sleep pin state */
|
||||
pinctrl_pm_select_sleep_state(dev);
|
||||
|
||||
if (pm_runtime_suspended(dev)) {
|
||||
priv->ctx_valid = false;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Disable the LCDC controller, to avoid locking up the PRCM */
|
||||
tilcdc_crtc_dpms(priv->crtc, DRM_MODE_DPMS_OFF);
|
||||
|
||||
/* Save register state: */
|
||||
for (i = 0; i < ARRAY_SIZE(registers); i++)
|
||||
if (registers[i].save && (priv->rev >= registers[i].rev))
|
||||
priv->saved_register[n++] = tilcdc_read(ddev, registers[i].reg);
|
||||
|
||||
priv->ctx_valid = true;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -603,10 +616,17 @@ static int tilcdc_pm_resume(struct device *dev)
|
||||
struct tilcdc_drm_private *priv = ddev->dev_private;
|
||||
unsigned i, n = 0;
|
||||
|
||||
/* Select default pin state */
|
||||
pinctrl_pm_select_default_state(dev);
|
||||
|
||||
if (priv->ctx_valid == true) {
|
||||
/* Restore register state: */
|
||||
for (i = 0; i < ARRAY_SIZE(registers); i++)
|
||||
if (registers[i].save && (priv->rev >= registers[i].rev))
|
||||
tilcdc_write(ddev, registers[i].reg, priv->saved_register[n++]);
|
||||
if (registers[i].save &&
|
||||
(priv->rev >= registers[i].rev))
|
||||
tilcdc_write(ddev, registers[i].reg,
|
||||
priv->saved_register[n++]);
|
||||
}
|
||||
|
||||
drm_kms_helper_poll_enable(ddev);
|
||||
|
||||
|
||||
@ -49,7 +49,6 @@
|
||||
struct tilcdc_drm_private {
|
||||
void __iomem *mmio;
|
||||
|
||||
struct clk *disp_clk; /* display dpll */
|
||||
struct clk *clk; /* functional clock */
|
||||
int rev; /* IP revision */
|
||||
|
||||
@ -67,7 +66,8 @@ struct tilcdc_drm_private {
|
||||
uint32_t max_width;
|
||||
|
||||
/* register contents saved across suspend/resume: */
|
||||
u32 saved_register[12];
|
||||
u32 *saved_register;
|
||||
bool ctx_valid;
|
||||
|
||||
#ifdef CONFIG_CPU_FREQ
|
||||
struct notifier_block freq_transition;
|
||||
@ -171,5 +171,6 @@ void tilcdc_crtc_set_simulate_vesa_sync(struct drm_crtc *crtc,
|
||||
bool simulate_vesa_sync);
|
||||
int tilcdc_crtc_mode_valid(struct drm_crtc *crtc, struct drm_display_mode *mode);
|
||||
int tilcdc_crtc_max_width(struct drm_crtc *crtc);
|
||||
void tilcdc_crtc_dpms(struct drm_crtc *crtc, int mode);
|
||||
|
||||
#endif /* __TILCDC_DRV_H__ */
|
||||
|
||||
@ -45,14 +45,6 @@ struct panel_encoder {
|
||||
};
|
||||
#define to_panel_encoder(x) container_of(x, struct panel_encoder, base)
|
||||
|
||||
|
||||
static void panel_encoder_destroy(struct drm_encoder *encoder)
|
||||
{
|
||||
struct panel_encoder *panel_encoder = to_panel_encoder(encoder);
|
||||
drm_encoder_cleanup(encoder);
|
||||
kfree(panel_encoder);
|
||||
}
|
||||
|
||||
static void panel_encoder_dpms(struct drm_encoder *encoder, int mode)
|
||||
{
|
||||
struct panel_encoder *panel_encoder = to_panel_encoder(encoder);
|
||||
@ -90,7 +82,7 @@ static void panel_encoder_mode_set(struct drm_encoder *encoder,
|
||||
}
|
||||
|
||||
static const struct drm_encoder_funcs panel_encoder_funcs = {
|
||||
.destroy = panel_encoder_destroy,
|
||||
.destroy = drm_encoder_cleanup,
|
||||
};
|
||||
|
||||
static const struct drm_encoder_helper_funcs panel_encoder_helper_funcs = {
|
||||
@ -107,7 +99,8 @@ static struct drm_encoder *panel_encoder_create(struct drm_device *dev,
|
||||
struct drm_encoder *encoder;
|
||||
int ret;
|
||||
|
||||
panel_encoder = kzalloc(sizeof(*panel_encoder), GFP_KERNEL);
|
||||
panel_encoder = devm_kzalloc(dev->dev, sizeof(*panel_encoder),
|
||||
GFP_KERNEL);
|
||||
if (!panel_encoder) {
|
||||
dev_err(dev->dev, "allocation failed\n");
|
||||
return NULL;
|
||||
@ -128,7 +121,7 @@ static struct drm_encoder *panel_encoder_create(struct drm_device *dev,
|
||||
return encoder;
|
||||
|
||||
fail:
|
||||
panel_encoder_destroy(encoder);
|
||||
drm_encoder_cleanup(encoder);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -147,10 +140,8 @@ struct panel_connector {
|
||||
|
||||
static void panel_connector_destroy(struct drm_connector *connector)
|
||||
{
|
||||
struct panel_connector *panel_connector = to_panel_connector(connector);
|
||||
drm_connector_unregister(connector);
|
||||
drm_connector_cleanup(connector);
|
||||
kfree(panel_connector);
|
||||
}
|
||||
|
||||
static enum drm_connector_status panel_connector_detect(
|
||||
@ -223,7 +214,8 @@ static struct drm_connector *panel_connector_create(struct drm_device *dev,
|
||||
struct drm_connector *connector;
|
||||
int ret;
|
||||
|
||||
panel_connector = kzalloc(sizeof(*panel_connector), GFP_KERNEL);
|
||||
panel_connector = devm_kzalloc(dev->dev, sizeof(*panel_connector),
|
||||
GFP_KERNEL);
|
||||
if (!panel_connector) {
|
||||
dev_err(dev->dev, "allocation failed\n");
|
||||
return NULL;
|
||||
|
||||
@ -54,14 +54,6 @@ struct tfp410_encoder {
|
||||
};
|
||||
#define to_tfp410_encoder(x) container_of(x, struct tfp410_encoder, base)
|
||||
|
||||
|
||||
static void tfp410_encoder_destroy(struct drm_encoder *encoder)
|
||||
{
|
||||
struct tfp410_encoder *tfp410_encoder = to_tfp410_encoder(encoder);
|
||||
drm_encoder_cleanup(encoder);
|
||||
kfree(tfp410_encoder);
|
||||
}
|
||||
|
||||
static void tfp410_encoder_dpms(struct drm_encoder *encoder, int mode)
|
||||
{
|
||||
struct tfp410_encoder *tfp410_encoder = to_tfp410_encoder(encoder);
|
||||
@ -99,7 +91,7 @@ static void tfp410_encoder_mode_set(struct drm_encoder *encoder,
|
||||
}
|
||||
|
||||
static const struct drm_encoder_funcs tfp410_encoder_funcs = {
|
||||
.destroy = tfp410_encoder_destroy,
|
||||
.destroy = drm_encoder_cleanup,
|
||||
};
|
||||
|
||||
static const struct drm_encoder_helper_funcs tfp410_encoder_helper_funcs = {
|
||||
@ -116,7 +108,8 @@ static struct drm_encoder *tfp410_encoder_create(struct drm_device *dev,
|
||||
struct drm_encoder *encoder;
|
||||
int ret;
|
||||
|
||||
tfp410_encoder = kzalloc(sizeof(*tfp410_encoder), GFP_KERNEL);
|
||||
tfp410_encoder = devm_kzalloc(dev->dev, sizeof(*tfp410_encoder),
|
||||
GFP_KERNEL);
|
||||
if (!tfp410_encoder) {
|
||||
dev_err(dev->dev, "allocation failed\n");
|
||||
return NULL;
|
||||
@ -138,7 +131,7 @@ static struct drm_encoder *tfp410_encoder_create(struct drm_device *dev,
|
||||
return encoder;
|
||||
|
||||
fail:
|
||||
tfp410_encoder_destroy(encoder);
|
||||
drm_encoder_cleanup(encoder);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -157,10 +150,8 @@ struct tfp410_connector {
|
||||
|
||||
static void tfp410_connector_destroy(struct drm_connector *connector)
|
||||
{
|
||||
struct tfp410_connector *tfp410_connector = to_tfp410_connector(connector);
|
||||
drm_connector_unregister(connector);
|
||||
drm_connector_cleanup(connector);
|
||||
kfree(tfp410_connector);
|
||||
}
|
||||
|
||||
static enum drm_connector_status tfp410_connector_detect(
|
||||
@ -228,7 +219,8 @@ static struct drm_connector *tfp410_connector_create(struct drm_device *dev,
|
||||
struct drm_connector *connector;
|
||||
int ret;
|
||||
|
||||
tfp410_connector = kzalloc(sizeof(*tfp410_connector), GFP_KERNEL);
|
||||
tfp410_connector = devm_kzalloc(dev->dev, sizeof(*tfp410_connector),
|
||||
GFP_KERNEL);
|
||||
if (!tfp410_connector) {
|
||||
dev_err(dev->dev, "allocation failed\n");
|
||||
return NULL;
|
||||
@ -313,7 +305,7 @@ static int tfp410_probe(struct platform_device *pdev)
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
tfp410_mod = kzalloc(sizeof(*tfp410_mod), GFP_KERNEL);
|
||||
tfp410_mod = devm_kzalloc(&pdev->dev, sizeof(*tfp410_mod), GFP_KERNEL);
|
||||
if (!tfp410_mod)
|
||||
return -ENOMEM;
|
||||
|
||||
@ -366,7 +358,6 @@ fail_adapter:
|
||||
i2c_put_adapter(tfp410_mod->i2c);
|
||||
|
||||
fail:
|
||||
kfree(tfp410_mod);
|
||||
tilcdc_module_cleanup(mod);
|
||||
return ret;
|
||||
}
|
||||
@ -380,7 +371,6 @@ static int tfp410_remove(struct platform_device *pdev)
|
||||
gpio_free(tfp410_mod->gpio);
|
||||
|
||||
tilcdc_module_cleanup(mod);
|
||||
kfree(tfp410_mod);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user