summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJordan Crouse <jcrouse@codeaurora.org>2016-01-25 16:01:58 -0700
committerDavid Keitel <dkeitel@codeaurora.org>2016-03-23 21:18:41 -0700
commitda324cf8f6ee36e5da13d543927ab6e077fb6531 (patch)
tree36726140fa3ce772660635dfcde66d49dca5021f
parent11d4029da91508ea4bc4ca66ea5bd3c333ef591b (diff)
msm: kgsl: Add and use KGSL_DEVICE macro
Add a helper macro to convert an adreno_device pointer to a struct kgsl_device pointer. This is mostly syntatic sugar but it makes the code a bit cleaner and it abstracts a bit of the ugliness away. Change-Id: Ic0dedbadd97bda3316a58514a5a64757bd4154c7 Signed-off-by: Jordan Crouse <jcrouse@codeaurora.org>
Diffstat
-rw-r--r--drivers/gpu/msm/adreno.c106
-rw-r--r--drivers/gpu/msm/adreno.h22
-rw-r--r--drivers/gpu/msm/adreno_a3xx.c65
-rw-r--r--drivers/gpu/msm/adreno_a3xx_snapshot.c4
-rw-r--r--drivers/gpu/msm/adreno_a4xx.c41
-rw-r--r--drivers/gpu/msm/adreno_a4xx_snapshot.c4
-rw-r--r--drivers/gpu/msm/adreno_a5xx.c117
-rw-r--r--drivers/gpu/msm/adreno_a5xx_snapshot.c11
-rw-r--r--drivers/gpu/msm/adreno_coresight.c8
-rw-r--r--drivers/gpu/msm/adreno_debugfs.c4
-rw-r--r--drivers/gpu/msm/adreno_dispatch.c89
-rw-r--r--drivers/gpu/msm/adreno_dispatch.h3
-rw-r--r--drivers/gpu/msm/adreno_drawctxt.c10
-rw-r--r--drivers/gpu/msm/adreno_iommu.c52
-rw-r--r--drivers/gpu/msm/adreno_perfcounter.c31
-rw-r--r--drivers/gpu/msm/adreno_profile.c9
-rw-r--r--drivers/gpu/msm/adreno_ringbuffer.c45
-rw-r--r--drivers/gpu/msm/adreno_ringbuffer.h2
-rw-r--r--drivers/gpu/msm/adreno_snapshot.c6
-rw-r--r--drivers/gpu/msm/adreno_sysfs.c42
-rw-r--r--drivers/gpu/msm/kgsl_iommu.c5
21 files changed, 328 insertions, 348 deletions
diff --git a/drivers/gpu/msm/adreno.c b/drivers/gpu/msm/adreno.c
index ebd23ab0a386..8b72428ee4d4 100644
--- a/drivers/gpu/msm/adreno.c
+++ b/drivers/gpu/msm/adreno.c
@@ -56,7 +56,7 @@ MODULE_PARM_DESC(nopreempt, "Disable GPU preemption");
#define KGSL_LOG_LEVEL_DEFAULT 3
static void adreno_input_work(struct work_struct *work);
-static unsigned int counter_delta(struct adreno_device *adreno_dev,
+static unsigned int counter_delta(struct kgsl_device *device,
unsigned int reg, unsigned int *counter);
static struct devfreq_msm_adreno_tz_data adreno_tz_data = {
@@ -137,7 +137,7 @@ void adreno_readreg64(struct adreno_device *adreno_dev,
{
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
unsigned int val_lo = 0, val_hi = 0;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (adreno_checkreg_off(adreno_dev, lo))
kgsl_regread(device, gpudev->reg_offsets->offsets[lo], &val_lo);
@@ -159,14 +159,13 @@ void adreno_writereg64(struct adreno_device *adreno_dev,
enum adreno_regs lo, enum adreno_regs hi, uint64_t val)
{
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
- struct kgsl_device *device = &adreno_dev->dev;
if (adreno_checkreg_off(adreno_dev, lo))
- kgsl_regwrite(device, gpudev->reg_offsets->offsets[lo],
- lower_32_bits(val));
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev),
+ gpudev->reg_offsets->offsets[lo], lower_32_bits(val));
if (adreno_checkreg_off(adreno_dev, hi))
- kgsl_regwrite(device, gpudev->reg_offsets->offsets[hi],
- upper_32_bits(val));
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev),
+ gpudev->reg_offsets->offsets[hi], upper_32_bits(val));
}
/**
@@ -189,7 +188,7 @@ static size_t efuse_len;
int adreno_efuse_map(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct resource *res;
if (efuse_base != NULL)
@@ -419,12 +418,10 @@ static int _get_counter(struct adreno_device *adreno_dev,
lo, hi, PERFCOUNTER_FLAG_KERNEL);
if (ret) {
- struct kgsl_device *device = &adreno_dev->dev;
-
- KGSL_DRV_ERR(device,
+ KGSL_DRV_ERR(KGSL_DEVICE(adreno_dev),
"Unable to allocate fault detect performance counter %d/%d\n",
group, countable);
- KGSL_DRV_ERR(device,
+ KGSL_DRV_ERR(KGSL_DEVICE(adreno_dev),
"GPU fault detect will be less reliable\n");
}
}
@@ -513,7 +510,7 @@ static void adreno_input_work(struct work_struct *work)
{
struct adreno_device *adreno_dev = container_of(work,
struct adreno_device, input_work);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
mutex_lock(&device->mutex);
@@ -707,14 +704,12 @@ void adreno_irqctrl(struct adreno_device *adreno_dev, int state)
*/
void adreno_hang_int_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
-
- KGSL_DRV_CRIT(device, "MISC: GPU hang detected\n");
+ KGSL_DRV_CRIT(KGSL_DEVICE(adreno_dev), "MISC: GPU hang detected\n");
adreno_irqctrl(adreno_dev, 0);
/* Trigger a fault in the dispatcher - this will effect a restart */
- adreno_set_gpu_fault(ADRENO_DEVICE(device), ADRENO_HARD_FAULT);
- adreno_dispatcher_schedule(device);
+ adreno_set_gpu_fault(adreno_dev, ADRENO_HARD_FAULT);
+ adreno_dispatcher_schedule(KGSL_DEVICE(adreno_dev));
}
/*
@@ -726,7 +721,7 @@ void adreno_hang_int_callback(struct adreno_device *adreno_dev, int bit)
*/
void adreno_cp_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_schedule_work(&device->event_work);
adreno_dispatcher_schedule(device);
@@ -799,16 +794,16 @@ adreno_identify_gpu(struct adreno_device *adreno_dev)
struct adreno_gpudev *gpudev;
int i;
- if (kgsl_property_read_u32(&adreno_dev->dev, "qcom,chipid",
+ if (kgsl_property_read_u32(KGSL_DEVICE(adreno_dev), "qcom,chipid",
&adreno_dev->chipid))
- KGSL_DRV_FATAL(&adreno_dev->dev,
+ KGSL_DRV_FATAL(KGSL_DEVICE(adreno_dev),
"No GPU chip ID was specified\n");
adreno_dev->gpucore = _get_gpu_core(adreno_dev->chipid);
if (adreno_dev->gpucore == NULL)
- KGSL_DRV_FATAL(&adreno_dev->dev, "Unknown GPU chip ID %8.8X\n",
- adreno_dev->chipid);
+ KGSL_DRV_FATAL(KGSL_DEVICE(adreno_dev),
+ "Unknown GPU chip ID %8.8X\n", adreno_dev->chipid);
/*
* The gmem size might be dynamic when ocmem is involved so copy it out
@@ -850,7 +845,7 @@ static const struct of_device_id adreno_match_table[] = {
static int adreno_of_parse_pwrlevels(struct adreno_device *adreno_dev,
struct device_node *node)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_pwrctrl *pwr = &device->pwrctrl;
struct device_node *child;
@@ -950,7 +945,7 @@ static struct {
static int adreno_of_get_power(struct adreno_device *adreno_dev,
struct platform_device *pdev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_pwrctrl *pwr = &device->pwrctrl;
struct device_node *node = pdev->dev.of_node;
int i, init_level;
@@ -1066,7 +1061,7 @@ static int adreno_probe(struct platform_device *pdev)
return -ENODEV;
}
- device = &adreno_dev->dev;
+ device = KGSL_DEVICE(adreno_dev);
device->pdev = pdev;
device->mmu.priv = &device_3d0_iommu;
@@ -1115,7 +1110,7 @@ static int adreno_probe(struct platform_device *pdev)
adreno_debugfs_init(adreno_dev);
adreno_profile_init(adreno_dev);
- adreno_sysfs_init(device);
+ adreno_sysfs_init(adreno_dev);
kgsl_pwrscale_init(&pdev->dev, CONFIG_QCOM_ADRENO_DEFAULT_GOVERNOR);
@@ -1141,7 +1136,8 @@ out:
static void _adreno_free_memories(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+
if (test_bit(ADRENO_DEVICE_CMDBATCH_PROFILE, &adreno_dev->priv))
kgsl_free_global(device, &adreno_dev->cmdbatch_profile_buffer);
@@ -1167,7 +1163,7 @@ static int adreno_remove(struct platform_device *pdev)
if (adreno_dev == NULL)
return 0;
- device = &adreno_dev->dev;
+ device = KGSL_DEVICE(adreno_dev);
/* The memory is fading */
_adreno_free_memories(adreno_dev);
@@ -1175,7 +1171,7 @@ static int adreno_remove(struct platform_device *pdev)
#ifdef CONFIG_INPUT
input_unregister_handler(&adreno_input_handler);
#endif
- adreno_sysfs_close(device);
+ adreno_sysfs_close(adreno_dev);
adreno_coresight_remove(adreno_dev);
adreno_profile_close(adreno_dev);
@@ -1333,7 +1329,7 @@ static int adreno_init(struct kgsl_device *device)
*/
if (!adreno_is_a3xx(adreno_dev)) {
- int r = kgsl_allocate_global(&adreno_dev->dev,
+ int r = kgsl_allocate_global(device,
&adreno_dev->cmdbatch_profile_buffer, PAGE_SIZE, 0, 0);
adreno_dev->cmdbatch_profile_index = 0;
@@ -1341,7 +1337,7 @@ static int adreno_init(struct kgsl_device *device)
if (r == 0) {
set_bit(ADRENO_DEVICE_CMDBATCH_PROFILE,
&adreno_dev->priv);
- kgsl_sharedmem_set(&adreno_dev->dev,
+ kgsl_sharedmem_set(device,
&adreno_dev->cmdbatch_profile_buffer, 0, 0,
PAGE_SIZE);
}
@@ -1434,7 +1430,7 @@ static uint64_t _read_throttling_counters(struct adreno_device *adreno_dev)
if (!adreno_dev->gpmu_throttle_counters[i])
return 0;
- th[i] = counter_delta(adreno_dev,
+ th[i] = counter_delta(KGSL_DEVICE(adreno_dev),
adreno_dev->gpmu_throttle_counters[i],
&busy->throttle_cycles[i]);
}
@@ -1447,8 +1443,9 @@ static void _update_threshold_count(struct adreno_device *adreno_dev,
uint64_t adj)
{
if (adreno_is_a530(adreno_dev))
- kgsl_regread(&adreno_dev->dev, adreno_dev->lm_threshold_count,
- &adreno_dev->lm_threshold_cross);
+ kgsl_regread(KGSL_DEVICE(adreno_dev),
+ adreno_dev->lm_threshold_count,
+ &adreno_dev->lm_threshold_cross);
else if (adreno_is_a540(adreno_dev))
adreno_dev->lm_threshold_cross = adj;
}
@@ -1462,7 +1459,7 @@ static void _update_threshold_count(struct adreno_device *adreno_dev,
*/
static int _adreno_start(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
int status = -EINVAL, ret;
unsigned int state = device->state;
@@ -2095,9 +2092,9 @@ static int adreno_setproperty(struct kgsl_device_private *dev_priv,
if (enable) {
device->pwrctrl.ctrl_flags = 0;
- if (!kgsl_active_count_get(&adreno_dev->dev)) {
+ if (!kgsl_active_count_get(device)) {
adreno_fault_detect_start(adreno_dev);
- kgsl_active_count_put(&adreno_dev->dev);
+ kgsl_active_count_put(device);
}
kgsl_pwrscale_enable(device);
@@ -2305,17 +2302,16 @@ bool adreno_isidle(struct kgsl_device *device)
/**
* adreno_spin_idle() - Spin wait for the GPU to idle
- * @device: Pointer to the KGSL device
+ * @adreno_dev: Pointer to an adreno device
* @timeout: milliseconds to wait before returning error
*
* Spin the CPU waiting for the RBBM status to return idle
*/
-int adreno_spin_idle(struct kgsl_device *device, unsigned int timeout)
+int adreno_spin_idle(struct adreno_device *adreno_dev, unsigned int timeout)
{
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
unsigned long wait = jiffies + msecs_to_jiffies(timeout);
- kgsl_cffdump_regpoll(device,
+ kgsl_cffdump_regpoll(KGSL_DEVICE(adreno_dev),
adreno_getreg(adreno_dev, ADRENO_REG_RBBM_STATUS) << 2,
0x00000000, 0x80000000);
@@ -2330,7 +2326,7 @@ int adreno_spin_idle(struct kgsl_device *device, unsigned int timeout)
if (adreno_gpu_fault(adreno_dev) != 0)
return -EDEADLK;
- if (adreno_isidle(device))
+ if (adreno_isidle(KGSL_DEVICE(adreno_dev)))
return 0;
}
@@ -2367,7 +2363,7 @@ int adreno_idle(struct kgsl_device *device)
if (ret)
return ret;
- return adreno_spin_idle(device, ADRENO_IDLE_TIMEOUT);
+ return adreno_spin_idle(adreno_dev, ADRENO_IDLE_TIMEOUT);
}
/**
@@ -2530,14 +2526,15 @@ static int adreno_waittimestamp(struct kgsl_device *device,
/**
* __adreno_readtimestamp() - Reads the timestamp from memstore memory
- * @device: Pointer to device whose memstore is read
+ * @adreno_dev: Pointer to an adreno device
* @index: Index into the memstore memory
* @type: Type of timestamp to read
* @timestamp: The out parameter where the timestamp is read
*/
-static int __adreno_readtimestamp(struct kgsl_device *device, int index,
+static int __adreno_readtimestamp(struct adreno_device *adreno_dev, int index,
int type, unsigned int *timestamp)
{
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int status = 0;
switch (type) {
@@ -2560,7 +2557,7 @@ static int __adreno_readtimestamp(struct kgsl_device *device, int index,
/**
* adreno_rb_readtimestamp(): Return the value of given type of timestamp
* for a RB
- * @device: GPU device whose timestamp values are being queried
+ * @adreno_dev: adreno device whose timestamp values are being queried
* @priv: The object being queried for a timestamp (expected to be a rb pointer)
* @type: The type of timestamp (one of 3) to be read
* @timestamp: Pointer to where the read timestamp is to be written to
@@ -2572,7 +2569,7 @@ static int __adreno_readtimestamp(struct kgsl_device *device, int index,
* The function returns 0 on success and timestamp value at the *timestamp
* address and returns -EINVAL on any read error/invalid type and timestamp = 0.
*/
-int adreno_rb_readtimestamp(struct kgsl_device *device,
+int adreno_rb_readtimestamp(struct adreno_device *adreno_dev,
void *priv, enum kgsl_timestamp_type type,
unsigned int *timestamp)
{
@@ -2589,7 +2586,7 @@ int adreno_rb_readtimestamp(struct kgsl_device *device,
if (KGSL_TIMESTAMP_QUEUED == type)
*timestamp = rb->timestamp;
else
- status = __adreno_readtimestamp(device,
+ status = __adreno_readtimestamp(adreno_dev,
rb->id + KGSL_MEMSTORE_MAX,
type, timestamp);
@@ -2629,7 +2626,7 @@ static int adreno_readtimestamp(struct kgsl_device *device,
if (KGSL_TIMESTAMP_QUEUED == type)
*timestamp = adreno_context_timestamp(context);
else
- status = __adreno_readtimestamp(device,
+ status = __adreno_readtimestamp(ADRENO_DEVICE(device),
context->id, type, timestamp);
return status;
@@ -2641,10 +2638,9 @@ static inline s64 adreno_ticks_to_us(u32 ticks, u32 freq)
return ticks / freq;
}
-static unsigned int counter_delta(struct adreno_device *adreno_dev,
+static unsigned int counter_delta(struct kgsl_device *device,
unsigned int reg, unsigned int *counter)
{
- struct kgsl_device *device = &adreno_dev->dev;
unsigned int val;
unsigned int ret = 0;
@@ -2684,7 +2680,7 @@ static void adreno_power_stats(struct kgsl_device *device,
if (adreno_dev->perfctr_pwr_lo != 0) {
uint64_t gpu_busy;
- gpu_busy = counter_delta(adreno_dev, adreno_dev->perfctr_pwr_lo,
+ gpu_busy = counter_delta(device, adreno_dev->perfctr_pwr_lo,
&busy->gpu_busy);
adj = _read_throttling_counters(adreno_dev);
@@ -2697,12 +2693,12 @@ static void adreno_power_stats(struct kgsl_device *device,
uint64_t ram_cycles = 0, starved_ram = 0;
if (adreno_dev->ram_cycles_lo != 0)
- ram_cycles = counter_delta(adreno_dev,
+ ram_cycles = counter_delta(device,
adreno_dev->ram_cycles_lo,
&busy->vbif_ram_cycles);
if (adreno_dev->starved_ram_lo != 0)
- starved_ram = counter_delta(adreno_dev,
+ starved_ram = counter_delta(device,
adreno_dev->starved_ram_lo,
&busy->vbif_starved_ram);
diff --git a/drivers/gpu/msm/adreno.h b/drivers/gpu/msm/adreno.h
index 12220ba82bec..9a38ea337b5c 100644
--- a/drivers/gpu/msm/adreno.h
+++ b/drivers/gpu/msm/adreno.h
@@ -39,6 +39,9 @@
#define ADRENO_DEVICE(device) \
container_of(device, struct adreno_device, dev)
+/* KGSL_DEVICE - given an adreno_device, return the KGSL device struct */
+#define KGSL_DEVICE(_dev) (&((_dev)->dev))
+
/* ADRENO_CONTEXT - Given a context return the adreno context struct */
#define ADRENO_CONTEXT(context) \
container_of(context, struct adreno_context, base)
@@ -818,7 +821,7 @@ long adreno_ioctl_helper(struct kgsl_device_private *dev_priv,
unsigned int cmd, unsigned long arg,
const struct kgsl_ioctl *cmds, int len);
-int adreno_spin_idle(struct kgsl_device *device, unsigned int timeout);
+int adreno_spin_idle(struct adreno_device *device, unsigned int timeout);
int adreno_idle(struct kgsl_device *device);
bool adreno_isidle(struct kgsl_device *device);
@@ -836,7 +839,7 @@ void adreno_snapshot(struct kgsl_device *device,
int adreno_reset(struct kgsl_device *device, int fault);
-void adreno_fault_skipcmd_detached(struct kgsl_device *device,
+void adreno_fault_skipcmd_detached(struct adreno_device *adreno_dev,
struct adreno_context *drawctxt,
struct kgsl_cmdbatch *cmdbatch);
@@ -876,8 +879,8 @@ unsigned int adreno_iommu_set_pt_generate_cmds(
unsigned int *cmds,
struct kgsl_pagetable *pt);
-int adreno_sysfs_init(struct kgsl_device *device);
-void adreno_sysfs_close(struct kgsl_device *device);
+int adreno_sysfs_init(struct adreno_device *adreno_dev);
+void adreno_sysfs_close(struct adreno_device *adreno_dev);
void adreno_irqctrl(struct adreno_device *adreno_dev, int state);
@@ -1044,7 +1047,7 @@ static inline void adreno_readreg(struct adreno_device *adreno_dev,
{
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
if (adreno_checkreg_off(adreno_dev, offset_name))
- kgsl_regread(&adreno_dev->dev,
+ kgsl_regread(KGSL_DEVICE(adreno_dev),
gpudev->reg_offsets->offsets[offset_name], val);
else
*val = 0;
@@ -1062,7 +1065,7 @@ static inline void adreno_writereg(struct adreno_device *adreno_dev,
{
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
if (adreno_checkreg_off(adreno_dev, offset_name))
- kgsl_regwrite(&adreno_dev->dev,
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev),
gpudev->reg_offsets->offsets[offset_name], val);
}
@@ -1185,7 +1188,7 @@ static inline void adreno_vbif_start(struct adreno_device *adreno_dev,
}
while ((vbif != NULL) && (vbif->reg != 0)) {
- kgsl_regwrite(&adreno_dev->dev, vbif->reg, vbif->val);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev), vbif->reg, vbif->val);
vbif++;
}
}
@@ -1232,7 +1235,7 @@ static inline void adreno_set_protected_registers(
val = 0x60000000 | ((mask_len & 0x1F) << 24) | ((reg << 2) & 0xFFFFF);
- kgsl_regwrite(&adreno_dev->dev, base + offset, val);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev), base + offset, val);
*index = *index + 1;
}
@@ -1378,7 +1381,8 @@ static inline void adreno_set_active_ctxs_null(struct adreno_device *adreno_dev)
if (rb->drawctxt_active)
kgsl_context_put(&(rb->drawctxt_active->base));
rb->drawctxt_active = NULL;
- kgsl_sharedmem_writel(&adreno_dev->dev, &rb->pagetable_desc,
+ kgsl_sharedmem_writel(KGSL_DEVICE(adreno_dev),
+ &rb->pagetable_desc,
offsetof(struct adreno_ringbuffer_pagetable_info,
current_rb_ptname), 0);
}
diff --git a/drivers/gpu/msm/adreno_a3xx.c b/drivers/gpu/msm/adreno_a3xx.c
index 6310250e1292..77771f78b4d6 100644
--- a/drivers/gpu/msm/adreno_a3xx.c
+++ b/drivers/gpu/msm/adreno_a3xx.c
@@ -171,7 +171,7 @@ int adreno_a3xx_pwron_fixup_init(struct adreno_device *adreno_dev)
if (test_bit(ADRENO_DEVICE_PWRON_FIXUP, &adreno_dev->priv))
return 0;
- ret = kgsl_allocate_global(&adreno_dev->dev,
+ ret = kgsl_allocate_global(KGSL_DEVICE(adreno_dev),
&adreno_dev->pwron_fixup, PAGE_SIZE,
KGSL_MEMFLAGS_GPUREADONLY, 0);
@@ -650,7 +650,7 @@ static int a3xx_rb_init(struct adreno_device *adreno_dev,
ret = adreno_ringbuffer_submit_spin(rb, NULL, 2000);
if (ret) {
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
dev_err(device->dev, "CP initialization failed to idle\n");
kgsl_device_snapshot(device, NULL);
@@ -666,7 +666,7 @@ static int a3xx_rb_init(struct adreno_device *adreno_dev,
*/
static void a3xx_err_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int reg;
switch (bit) {
@@ -1215,7 +1215,7 @@ static void a3xx_perfcounter_close(struct adreno_device *adreno_dev)
*/
static void a3xx_protect_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int index = 0;
struct kgsl_protected_registers *iommu_regs;
@@ -1254,7 +1254,7 @@ static void a3xx_protect_init(struct adreno_device *adreno_dev)
static void a3xx_start(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
adreno_vbif_start(adreno_dev, a3xx_vbif_platforms,
@@ -1495,7 +1495,7 @@ static int _load_firmware(struct kgsl_device *device, const char *fwfile,
int a3xx_microcode_read(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (adreno_dev->pm4_fw == NULL) {
int len;
@@ -1550,51 +1550,43 @@ int a3xx_microcode_read(struct adreno_device *adreno_dev)
return 0;
}
-
/**
- * adreno_ringbuffer_load_pm4_ucode() - Load pm4 ucode
- * @device: Pointer to a KGSL device
+ * load_pm4_ucode() - Load pm4 ucode
+ * @adreno_dev: Pointer to an adreno device
* @start: Starting index in pm4 ucode to load
* @end: Ending index of pm4 ucode to load
* @addr: Address to load the pm4 ucode
*
* Load the pm4 ucode from @start at @addr.
*/
-static inline int adreno_ringbuffer_load_pm4_ucode(struct kgsl_device *device,
+static inline void load_pm4_ucode(struct adreno_device *adreno_dev,
unsigned int start, unsigned int end, unsigned int addr)
{
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
int i;
adreno_writereg(adreno_dev, ADRENO_REG_CP_ME_RAM_WADDR, addr);
for (i = start; i < end; i++)
adreno_writereg(adreno_dev, ADRENO_REG_CP_ME_RAM_DATA,
adreno_dev->pm4_fw[i]);
-
- return 0;
}
-
/**
- * adreno_ringbuffer_load_pfp_ucode() - Load pfp ucode
- * @device: Pointer to a KGSL device
+ * load_pfp_ucode() - Load pfp ucode
+ * @adreno_dev: Pointer to an adreno device
* @start: Starting index in pfp ucode to load
* @end: Ending index of pfp ucode to load
* @addr: Address to load the pfp ucode
*
* Load the pfp ucode from @start at @addr.
*/
-static inline int adreno_ringbuffer_load_pfp_ucode(struct kgsl_device *device,
+static inline void load_pfp_ucode(struct adreno_device *adreno_dev,
unsigned int start, unsigned int end, unsigned int addr)
{
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
int i;
adreno_writereg(adreno_dev, ADRENO_REG_CP_PFP_UCODE_ADDR, addr);
for (i = start; i < end; i++)
adreno_writereg(adreno_dev, ADRENO_REG_CP_PFP_UCODE_DATA,
adreno_dev->pfp_fw[i]);
-
- return 0;
}
/**
@@ -1619,7 +1611,7 @@ static inline int adreno_ringbuffer_load_pfp_ucode(struct kgsl_device *device,
static int _ringbuffer_bootstrap_ucode(struct adreno_device *adreno_dev,
struct adreno_ringbuffer *rb, unsigned int load_jt)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int *cmds, bootstrap_size, rb_size;
int i = 0;
int ret;
@@ -1723,7 +1715,7 @@ static int _ringbuffer_bootstrap_ucode(struct adreno_device *adreno_dev,
}
/* idle device to validate bootstrap */
- ret = adreno_spin_idle(device, 2000);
+ ret = adreno_spin_idle(adreno_dev, 2000);
if (ret) {
KGSL_DRV_ERR(device, "microcode bootstrap failed to idle\n");
@@ -1743,7 +1735,6 @@ int a3xx_microcode_load(struct adreno_device *adreno_dev,
{
int status;
struct adreno_ringbuffer *rb = ADRENO_CURRENT_RINGBUFFER(adreno_dev);
- struct kgsl_device *device = &adreno_dev->dev;
if (start_type == ADRENO_START_COLD) {
/* If bootstrapping if supported to load ucode */
@@ -1759,15 +1750,11 @@ int a3xx_microcode_load(struct adreno_device *adreno_dev,
* microcode.
*/
- status = adreno_ringbuffer_load_pm4_ucode(device, 1,
+ load_pm4_ucode(adreno_dev, 1,
adreno_dev->gpucore->pm4_bstrp_size+1, 0);
- if (status != 0)
- return status;
- status = adreno_ringbuffer_load_pfp_ucode(device, 1,
+ load_pfp_ucode(adreno_dev, 1,
adreno_dev->gpucore->pfp_bstrp_size+1, 0);
- if (status != 0)
- return status;
/* Bootstrap rest of the ucode here */
status = _ringbuffer_bootstrap_ucode(adreno_dev, rb, 0);
@@ -1776,16 +1763,12 @@ int a3xx_microcode_load(struct adreno_device *adreno_dev,
} else {
/* load the CP ucode using AHB writes */
- status = adreno_ringbuffer_load_pm4_ucode(device, 1,
- adreno_dev->pm4_fw_size, 0);
- if (status != 0)
- return status;
+ load_pm4_ucode(adreno_dev, 1, adreno_dev->pm4_fw_size,
+ 0);
/* load the prefetch parser ucode using AHB writes */
- status = adreno_ringbuffer_load_pfp_ucode(device, 1,
- adreno_dev->pfp_fw_size, 0);
- if (status != 0)
- return status;
+ load_pfp_ucode(adreno_dev, 1, adreno_dev->pfp_fw_size,
+ 0);
}
} else if (start_type == ADRENO_START_WARM) {
/* If bootstrapping if supported to load jump tables */
@@ -1796,22 +1779,18 @@ int a3xx_microcode_load(struct adreno_device *adreno_dev,
} else {
/* load the CP jump tables using AHB writes */
- status = adreno_ringbuffer_load_pm4_ucode(device,
+ load_pm4_ucode(adreno_dev,
adreno_dev->gpucore->pm4_jt_idx,
adreno_dev->pm4_fw_size,
adreno_dev->gpucore->pm4_jt_addr);
- if (status != 0)
- return status;
/*
* load the prefetch parser jump tables using AHB writes
*/
- status = adreno_ringbuffer_load_pfp_ucode(device,
+ load_pfp_ucode(adreno_dev,
adreno_dev->gpucore->pfp_jt_idx,
adreno_dev->pfp_fw_size,
adreno_dev->gpucore->pfp_jt_addr);
- if (status != 0)
- return status;
}
} else
return -EINVAL;
diff --git a/drivers/gpu/msm/adreno_a3xx_snapshot.c b/drivers/gpu/msm/adreno_a3xx_snapshot.c
index c4d415adc9f0..48af1fe353f5 100644
--- a/drivers/gpu/msm/adreno_a3xx_snapshot.c
+++ b/drivers/gpu/msm/adreno_a3xx_snapshot.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -296,7 +296,7 @@ static void _snapshot_hlsq_regs(struct kgsl_device *device,
void a3xx_snapshot(struct adreno_device *adreno_dev,
struct kgsl_snapshot *snapshot)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
struct adreno_snapshot_data *snap_data = gpudev->snapshot_data;
unsigned int reg;
diff --git a/drivers/gpu/msm/adreno_a4xx.c b/drivers/gpu/msm/adreno_a4xx.c
index 9438be891377..351c4f9cee37 100644
--- a/drivers/gpu/msm/adreno_a4xx.c
+++ b/drivers/gpu/msm/adreno_a4xx.c
@@ -182,7 +182,7 @@ static const struct adreno_vbif_platform a4xx_vbif_platforms[] = {
static void a4xx_preemption_start(struct adreno_device *adreno_dev,
struct adreno_ringbuffer *rb)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
uint32_t val;
/*
@@ -220,7 +220,7 @@ static void a4xx_preemption_start(struct adreno_device *adreno_dev,
static void a4xx_preemption_save(struct adreno_device *adreno_dev,
struct adreno_ringbuffer *rb)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regread(device, A4XX_CP_SCRATCH_REG18, &rb->rptr);
kgsl_regread(device, A4XX_CP_SCRATCH_REG23, &rb->gpr11);
@@ -250,7 +250,7 @@ static int a4xx_preemption_pre_ibsubmit(
struct kgsl_context *context, uint64_t cond_addr,
struct kgsl_memobj_node *ib)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int *cmds_orig = cmds;
int exec_ib = 0;
@@ -290,7 +290,8 @@ static int a4xx_preemption_pre_ibsubmit(
static bool a4xx_is_sptp_idle(struct adreno_device *adreno_dev)
{
unsigned int reg;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+
if (!ADRENO_FEATURE(adreno_dev, ADRENO_SPTP_PC))
return true;
@@ -314,7 +315,8 @@ static bool a4xx_is_sptp_idle(struct adreno_device *adreno_dev)
static int a4xx_regulator_enable(struct adreno_device *adreno_dev)
{
unsigned int reg;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+
if (!(adreno_is_a430(adreno_dev) || adreno_is_a418(adreno_dev)))
return 0;
@@ -337,7 +339,8 @@ static int a4xx_regulator_enable(struct adreno_device *adreno_dev)
*/
static void a4xx_regulator_disable(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+
if (!(adreno_is_a430(adreno_dev) || adreno_is_a418(adreno_dev)))
return;
@@ -351,12 +354,12 @@ static void a4xx_regulator_disable(struct adreno_device *adreno_dev)
*/
static void a4xx_enable_pc(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
if (!ADRENO_FEATURE(adreno_dev, ADRENO_SPTP_PC) ||
!test_bit(ADRENO_SPTP_PC_CTRL, &adreno_dev->pwrctrl_flag))
return;
- kgsl_regwrite(device, A4XX_CP_POWER_COLLAPSE_CNTL, 0x00400010);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev), A4XX_CP_POWER_COLLAPSE_CNTL,
+ 0x00400010);
trace_adreno_sp_tp((unsigned long) __builtin_return_address(0));
};
@@ -369,7 +372,7 @@ static void a4xx_enable_pc(struct adreno_device *adreno_dev)
*/
static void a4xx_enable_ppd(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!ADRENO_FEATURE(adreno_dev, ADRENO_PPD) ||
!test_bit(ADRENO_PPD_CTRL, &adreno_dev->pwrctrl_flag) ||
@@ -401,7 +404,7 @@ static void a4xx_pwrlevel_change_settings(struct adreno_device *adreno_dev,
unsigned int prelevel, unsigned int postlevel,
bool post)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
static int pre;
/* PPD programming only for A430v2 */
@@ -563,7 +566,7 @@ static void a4xx_enable_hwcg(struct kgsl_device *device)
*/
static void a4xx_protect_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int index = 0;
struct kgsl_protected_registers *iommu_regs;
@@ -628,7 +631,7 @@ static struct adreno_snapshot_sizes a4xx_snap_sizes = {
static void a4xx_start(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
unsigned int cp_debug = A4XX_CP_DEBUG_DEFAULT;
@@ -730,7 +733,7 @@ static void a4xx_start(struct adreno_device *adreno_dev)
*/
static void a4xx_err_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int reg;
switch (bit) {
@@ -1457,7 +1460,7 @@ int adreno_a4xx_pwron_fixup_init(struct adreno_device *adreno_dev)
if (test_bit(ADRENO_DEVICE_PWRON_FIXUP, &adreno_dev->priv))
return 0;
- ret = kgsl_allocate_global(&adreno_dev->dev,
+ ret = kgsl_allocate_global(KGSL_DEVICE(adreno_dev),
&adreno_dev->pwron_fixup, PAGE_SIZE,
KGSL_MEMFLAGS_GPUREADONLY, 0);
@@ -1619,7 +1622,7 @@ static int a4xx_rb_init(struct adreno_device *adreno_dev,
ret = adreno_ringbuffer_submit_spin(rb, NULL, 2000);
if (ret) {
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
dev_err(device->dev, "CP initialization failed to idle\n");
kgsl_device_snapshot(device, NULL);
@@ -1804,7 +1807,7 @@ static void a4xx_preempt_trig_state(
struct adreno_device *adreno_dev)
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int rbbase, val;
/*
@@ -1902,7 +1905,7 @@ static void a4xx_preempt_clear_state(
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_dispatcher_cmdqueue *dispatch_tempq;
struct kgsl_cmdbatch *cmdbatch;
struct adreno_ringbuffer *highest_busy_rb;
@@ -2020,7 +2023,7 @@ static void a4xx_preempt_complete_state(
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_dispatcher_cmdqueue *dispatch_q;
unsigned int wptr, rbbase;
unsigned int val, val1;
@@ -2108,7 +2111,7 @@ static void a4xx_preemption_schedule(
struct adreno_device *adreno_dev)
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!adreno_is_preemption_enabled(adreno_dev))
return;
diff --git a/drivers/gpu/msm/adreno_a4xx_snapshot.c b/drivers/gpu/msm/adreno_a4xx_snapshot.c
index 96080d3b6d9f..b07e970aae32 100644
--- a/drivers/gpu/msm/adreno_a4xx_snapshot.c
+++ b/drivers/gpu/msm/adreno_a4xx_snapshot.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -516,7 +516,7 @@ static void a4xx_reset_hlsq(struct kgsl_device *device)
void a4xx_snapshot(struct adreno_device *adreno_dev,
struct kgsl_snapshot *snapshot)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
struct adreno_snapshot_data *snap_data = gpudev->snapshot_data;
diff --git a/drivers/gpu/msm/adreno_a5xx.c b/drivers/gpu/msm/adreno_a5xx.c
index 1ba35d497958..45179e6681be 100644
--- a/drivers/gpu/msm/adreno_a5xx.c
+++ b/drivers/gpu/msm/adreno_a5xx.c
@@ -82,7 +82,7 @@ static int a5xx_gpmu_init(struct adreno_device *adreno_dev);
static void a530_efuse_leakage(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int row0, row2;
unsigned int multiplier, gfx_active, leakage_pwr_on, coeff;
@@ -145,7 +145,7 @@ static void a5xx_check_features(struct adreno_device *adreno_dev)
static void a5xx_preemption_start(struct adreno_device *adreno_dev,
struct adreno_ringbuffer *rb)
{
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_iommu *iommu = device->mmu.priv;
uint64_t ttbr0;
uint32_t contextidr;
@@ -198,7 +198,7 @@ static void a5xx_preemption_save(struct adreno_device *adreno_dev,
static int a5xx_preemption_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_iommu *iommu = device->mmu.priv;
struct adreno_ringbuffer *rb;
int ret;
@@ -355,7 +355,7 @@ static int a5xx_preemption_post_ibsubmit(
struct adreno_ringbuffer *rb, unsigned int *cmds,
struct kgsl_context *context)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int *cmds_orig = cmds;
unsigned int ctx_id = context ? context->id : 0;
@@ -433,7 +433,7 @@ static void a5xx_init(struct adreno_device *adreno_dev)
*/
static void a5xx_protect_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int index = 0;
struct kgsl_protected_registers *iommu_regs;
@@ -486,7 +486,7 @@ static void a5xx_protect_init(struct adreno_device *adreno_dev)
static bool a5xx_is_sptp_idle(struct adreno_device *adreno_dev)
{
unsigned int reg;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
/* If feature is not supported or enabled, no worry */
if (!ADRENO_FEATURE(adreno_dev, ADRENO_SPTP_PC) ||
@@ -513,12 +513,11 @@ static int _poll_gdsc_status(struct adreno_device *adreno_dev,
unsigned int status_value)
{
unsigned int reg, retry = PWR_RETRY;
- struct kgsl_device *device = &adreno_dev->dev;
/* Bit 20 is the power on bit of SPTP and RAC GDSC status register */
do {
udelay(1);
- kgsl_regread(device, status_reg, &reg);
+ kgsl_regread(KGSL_DEVICE(adreno_dev), status_reg, &reg);
} while (((reg & BIT(20)) != (status_value << 20)) && retry--);
if ((reg & BIT(20)) != (status_value << 20))
return -ETIMEDOUT;
@@ -535,7 +534,7 @@ static int _poll_gdsc_status(struct adreno_device *adreno_dev,
static int a5xx_regulator_enable(struct adreno_device *adreno_dev)
{
unsigned int ret;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!(adreno_is_a530(adreno_dev) || adreno_is_a540(adreno_dev)))
return 0;
@@ -573,7 +572,7 @@ static int a5xx_regulator_enable(struct adreno_device *adreno_dev)
static void a5xx_regulator_disable(struct adreno_device *adreno_dev)
{
unsigned int reg;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
/* If feature is not supported or not enabled */
if (!ADRENO_FEATURE(adreno_dev, ADRENO_SPTP_PC) ||
@@ -626,7 +625,8 @@ static void a5xx_regulator_disable(struct adreno_device *adreno_dev)
*/
static void a5xx_enable_pc(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+
if (!ADRENO_FEATURE(adreno_dev, ADRENO_SPTP_PC) ||
!test_bit(ADRENO_SPTP_PC_CTRL, &adreno_dev->pwrctrl_flag))
return;
@@ -711,7 +711,7 @@ static int _load_gpmu_firmware(struct adreno_device *adreno_dev)
{
uint32_t *data;
const struct firmware *fw = NULL;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
const struct adreno_gpu_core *gpucore = adreno_dev->gpucore;
uint32_t *cmds, cmd_size;
int ret = -EINVAL;
@@ -796,7 +796,7 @@ static int a5xx_gpmu_start(struct adreno_device *adreno_dev)
{
int ret;
unsigned int reg, retry = GPMU_FW_INIT_RETRY;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!ADRENO_FEATURE(adreno_dev, ADRENO_GPMU))
return 0;
@@ -1166,7 +1166,7 @@ static const struct {
static void a5xx_hwcg_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
const struct kgsl_hwcg_reg *regs;
int i, j;
@@ -1261,7 +1261,7 @@ static int _read_fw2_block_header(uint32_t *header, uint32_t id,
*/
static void _load_regfile(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
const struct firmware *fw;
uint32_t block_size = 0, block_total = 0, fw_size;
uint32_t *block;
@@ -1321,7 +1321,6 @@ err:
static int _execute_reg_sequence(struct adreno_device *adreno_dev,
uint32_t *opcode, uint32_t length)
{
- struct kgsl_device *device = &adreno_dev->dev;
uint32_t *cur = opcode;
uint64_t reg, val;
@@ -1332,7 +1331,7 @@ static int _execute_reg_sequence(struct adreno_device *adreno_dev,
case 1:
reg = cur[2];
reg = (reg << 32) | cur[1];
- kgsl_regwrite(device, reg, cur[3]);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev), reg, cur[3]);
cur += 4;
break;
/* Write a 64 bit value to a 64 bit reg */
@@ -1341,7 +1340,7 @@ static int _execute_reg_sequence(struct adreno_device *adreno_dev,
reg = (reg << 32) | cur[1];
val = cur[4];
val = (val << 32) | cur[3];
- kgsl_regwrite(device, reg, val);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev), reg, val);
cur += 5;
break;
/* Delay for X usec */
@@ -1358,7 +1357,7 @@ static int _execute_reg_sequence(struct adreno_device *adreno_dev,
static uint32_t _write_voltage_table(struct adreno_device *adreno_dev,
unsigned int addr)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_pwrctrl *pwr = &device->pwrctrl;
int i;
struct dev_pm_opp *opp;
@@ -1384,7 +1383,7 @@ static uint32_t _write_voltage_table(struct adreno_device *adreno_dev,
static uint32_t lm_limit(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (adreno_dev->lm_limit)
return adreno_dev->lm_limit;
@@ -1402,7 +1401,7 @@ static uint32_t lm_limit(struct adreno_device *adreno_dev)
static void a530_lm_init(struct adreno_device *adreno_dev)
{
uint32_t length;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!ADRENO_FEATURE(adreno_dev, ADRENO_LM) ||
!test_bit(ADRENO_LM_CTRL, &adreno_dev->pwrctrl_flag))
@@ -1454,7 +1453,7 @@ static void a530_lm_init(struct adreno_device *adreno_dev)
*/
static void a530_lm_enable(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!ADRENO_FEATURE(adreno_dev, ADRENO_LM) ||
!test_bit(ADRENO_LM_CTRL, &adreno_dev->pwrctrl_flag))
@@ -1481,7 +1480,7 @@ static void a530_lm_enable(struct adreno_device *adreno_dev)
static int isense_cot(struct adreno_device *adreno_dev)
{
unsigned int r, ret;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regwrite(device, A5XX_GPU_CS_AMP_CALIBRATION_CONTROL1,
@@ -1518,7 +1517,7 @@ static int isense_cot(struct adreno_device *adreno_dev)
static int isense_enable(struct adreno_device *adreno_dev)
{
unsigned int r;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regwrite(device, A5XX_GPU_CS_ENABLE_REG,
adreno_is_a540v1(adreno_dev) ? 7 : 6);
@@ -1535,7 +1534,7 @@ static int isense_enable(struct adreno_device *adreno_dev)
static void isense_disable(struct adreno_device *adreno_dev)
{
unsigned int r;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regwrite(device, A5XX_GPU_CS_ENABLE_REG, 0);
udelay(1);
@@ -1547,7 +1546,7 @@ static void isense_disable(struct adreno_device *adreno_dev)
static bool isense_is_enabled(struct adreno_device *adreno_dev)
{
unsigned int r;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regread(device, A5XX_GPU_CS_SENSOR_GENERAL_STATUS, &r);
return r & CS_PWR_ON_STATUS;
@@ -1556,7 +1555,7 @@ static bool isense_is_enabled(struct adreno_device *adreno_dev)
static bool llm_is_enabled(struct adreno_device *adreno_dev)
{
unsigned int r;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regread(device, A5XX_GPMU_TEMP_SENSOR_CONFIG, &r);
return r & (GPMU_BCL_ENABLED | GPMU_LLM_ENABLED);
@@ -1566,7 +1565,7 @@ static bool llm_is_enabled(struct adreno_device *adreno_dev)
static void sleep_llm(struct adreno_device *adreno_dev)
{
unsigned int r, retry = 5;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!llm_is_enabled(adreno_dev))
return;
@@ -1594,8 +1593,7 @@ static void sleep_llm(struct adreno_device *adreno_dev)
static void wake_llm(struct adreno_device *adreno_dev)
{
unsigned int r, retry = 5;
- struct kgsl_device *device = &adreno_dev->dev;
-
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!llm_is_enabled(adreno_dev))
return;
@@ -1626,7 +1624,7 @@ static void wake_llm(struct adreno_device *adreno_dev)
static bool llm_is_awake(struct adreno_device *adreno_dev)
{
unsigned int r;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regread(device, A5XX_GPMU_GPMU_LLM_GLM_SLEEP_STATUS, &r);
return r & WAKEUP_ACK;
@@ -1634,7 +1632,7 @@ static bool llm_is_awake(struct adreno_device *adreno_dev)
static void a540_lm_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
uint32_t agc_lm_config =
AGC_LM_CONFIG_ENABLE_GPMU_ADAPTIVE | AGC_THROTTLE_SEL_DCS;
unsigned int r, i;
@@ -1711,15 +1709,16 @@ static void a5xx_lm_init(struct adreno_device *adreno_dev)
a540_lm_init(adreno_dev);
}
-static int gpmu_set_level(struct kgsl_device *device, unsigned int val)
+static int gpmu_set_level(struct adreno_device *adreno_dev, unsigned int val)
{
unsigned int reg;
int retry = 100;
- kgsl_regwrite(device, A5XX_GPMU_GPMU_VOLTAGE, val);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev), A5XX_GPMU_GPMU_VOLTAGE, val);
do {
- kgsl_regread(device, A5XX_GPMU_GPMU_VOLTAGE, &reg);
+ kgsl_regread(KGSL_DEVICE(adreno_dev), A5XX_GPMU_GPMU_VOLTAGE,
+ &reg);
} while ((reg & 0x80000000) && retry--);
return (reg & 0x80000000) ? -ETIMEDOUT : 0;
@@ -1737,7 +1736,6 @@ static void a5xx_pwrlevel_change_settings(struct adreno_device *adreno_dev,
unsigned int prelevel, unsigned int postlevel,
bool post)
{
- struct kgsl_device *device = &adreno_dev->dev;
int on = 0;
/* Only call through if PPD or LM is supported and enabled */
@@ -1753,11 +1751,11 @@ static void a5xx_pwrlevel_change_settings(struct adreno_device *adreno_dev,
return;
if (post == 0) {
- if (gpmu_set_level(device, (0x80000010 | postlevel)))
+ if (gpmu_set_level(adreno_dev, (0x80000010 | postlevel)))
KGSL_CORE_ERR(
"GPMU pre powerlevel did not stabilize\n");
} else {
- if (gpmu_set_level(device, (0x80000000 | postlevel)))
+ if (gpmu_set_level(adreno_dev, (0x80000000 | postlevel)))
KGSL_CORE_ERR(
"GPMU post powerlevel did not stabilize\n");
}
@@ -1765,7 +1763,7 @@ static void a5xx_pwrlevel_change_settings(struct adreno_device *adreno_dev,
static void a5xx_enable_64bit(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_regwrite(device, A5XX_CP_ADDR_MODE_CNTL, 0x1);
kgsl_regwrite(device, A5XX_VSC_ADDR_MODE_CNTL, 0x1);
@@ -1802,7 +1800,7 @@ static void a5xx_gpmu_reset(struct work_struct *work)
{
struct adreno_device *adreno_dev = container_of(work,
struct adreno_device, gpmu_work);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (test_bit(ADRENO_DEVICE_GPMU_INITIALIZED, &adreno_dev->priv))
return;
@@ -1844,7 +1842,7 @@ out:
*/
static void a5xx_start(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_iommu *iommu = device->mmu.priv;
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
unsigned int i;
@@ -2071,7 +2069,7 @@ static int _preemption_init(
struct adreno_ringbuffer *rb, unsigned int *cmds,
struct kgsl_context *context)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int *cmds_orig = cmds;
uint64_t gpuaddr = rb->preemption_desc.gpuaddr;
uint64_t gpuaddr_token = device->memstore.gpuaddr +
@@ -2167,7 +2165,7 @@ static void a5xx_post_start(struct adreno_device *adreno_dev)
return;
if (adreno_ringbuffer_submit_spin(rb, NULL, 2000)) {
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
KGSL_DRV_ERR(device, "hw initialization failed to idle\n");
kgsl_device_snapshot(device, NULL);
@@ -2177,7 +2175,7 @@ static void a5xx_post_start(struct adreno_device *adreno_dev)
static int a5xx_gpmu_init(struct adreno_device *adreno_dev)
{
int ret;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
/* GPU comes up in secured mode, make it unsecured by default */
if (!ADRENO_FEATURE(adreno_dev, ADRENO_CONTENT_PROTECTION))
@@ -2233,7 +2231,7 @@ static int a5xx_switch_to_unsecure_mode(struct adreno_device *adreno_dev,
ret = adreno_ringbuffer_submit_spin(rb, NULL, 2000);
if (ret != 0) {
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
dev_err(device->dev, "Switch to unsecure failed to idle\n");
spin_idle_debug(device);
@@ -2355,7 +2353,7 @@ static int a5xx_rb_init(struct adreno_device *adreno_dev,
ret = adreno_ringbuffer_submit_spin(rb, NULL, 2000);
if (ret != 0) {
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
dev_err(device->dev, "CP initialization failed to idle\n");
spin_idle_debug(device);
@@ -2369,11 +2367,10 @@ static int a5xx_rb_init(struct adreno_device *adreno_dev,
return ret;
}
-static int _load_firmware(struct adreno_device *adreno_dev, const char *fwfile,
+static int _load_firmware(struct kgsl_device *device, const char *fwfile,
struct kgsl_memdesc *ucode, size_t *ucode_size,
unsigned int *ucode_version)
{
- struct kgsl_device *device = &adreno_dev->dev;
const struct firmware *fw = NULL;
int ret;
@@ -2409,13 +2406,13 @@ static int a5xx_microcode_read(struct adreno_device *adreno_dev)
{
int ret;
- ret = _load_firmware(adreno_dev,
+ ret = _load_firmware(KGSL_DEVICE(adreno_dev),
adreno_dev->gpucore->pm4fw_name, &adreno_dev->pm4,
&adreno_dev->pm4_fw_size, &adreno_dev->pm4_fw_version);
if (ret)
return ret;
- ret = _load_firmware(adreno_dev,
+ ret = _load_firmware(KGSL_DEVICE(adreno_dev),
adreno_dev->gpucore->pfpfw_name, &adreno_dev->pfp,
&adreno_dev->pfp_fw_size, &adreno_dev->pfp_fw_version);
if (ret)
@@ -2439,7 +2436,7 @@ static int a5xx_microcode_load(struct adreno_device *adreno_dev,
unsigned int start_type)
{
void *ptr;
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
uint64_t gpuaddr;
gpuaddr = adreno_dev->pm4.gpuaddr;
@@ -3013,7 +3010,7 @@ static const struct adreno_reg_offsets a5xx_reg_offsets = {
static void a5xx_cp_hw_err_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int status1, status2;
kgsl_regread(device, A5XX_CP_INTERRUPT_STATUS, &status1);
@@ -3062,7 +3059,7 @@ static void a5xx_cp_hw_err_callback(struct adreno_device *adreno_dev, int bit)
static void a5xx_err_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int reg;
switch (bit) {
@@ -3214,7 +3211,7 @@ static const char *gpmu_int_msg[32] = {
static void a5xx_gpmu_int_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int reg, i;
kgsl_regread(device, A5XX_GPMU_RBBM_INTR_INFO, &reg);
@@ -3257,7 +3254,7 @@ static void a5xx_gpmu_int_callback(struct adreno_device *adreno_dev, int bit)
*/
void a5x_gpc_err_int_callback(struct adreno_device *adreno_dev, int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
/*
* GPC error is typically the result of mistake SW programming.
@@ -3269,7 +3266,7 @@ void a5x_gpc_err_int_callback(struct adreno_device *adreno_dev, int bit)
adreno_irqctrl(adreno_dev, 0);
/* Trigger a fault in the dispatcher - this will effect a restart */
- adreno_set_gpu_fault(ADRENO_DEVICE(device), ADRENO_SOFT_FAULT);
+ adreno_set_gpu_fault(adreno_dev, ADRENO_SOFT_FAULT);
adreno_dispatcher_schedule(device);
}
@@ -3563,7 +3560,7 @@ static void a5xx_preempt_trig_state(
struct adreno_device *adreno_dev)
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int preempt_busy;
uint64_t rbbase;
@@ -3640,7 +3637,7 @@ static void a5xx_preempt_clear_state(
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_ringbuffer *highest_busy_rb;
int switch_low_to_high;
int ret;
@@ -3732,7 +3729,7 @@ static void a5xx_preempt_complete_state(
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_dispatcher_cmdqueue *dispatch_q;
uint64_t rbbase;
unsigned int wptr;
@@ -3829,7 +3826,7 @@ static void a5xx_preemption_schedule(
struct adreno_device *adreno_dev)
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_ringbuffer *rb;
int i = 0;
diff --git a/drivers/gpu/msm/adreno_a5xx_snapshot.c b/drivers/gpu/msm/adreno_a5xx_snapshot.c
index 62eb4f7b24f4..36a70e30e6ac 100644
--- a/drivers/gpu/msm/adreno_a5xx_snapshot.c
+++ b/drivers/gpu/msm/adreno_a5xx_snapshot.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -794,7 +794,7 @@ static size_t a5xx_snapshot_registers(struct kgsl_device *device, u8 *buf,
void a5xx_snapshot(struct adreno_device *adreno_dev,
struct kgsl_snapshot *snapshot)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
struct adreno_snapshot_data *snap_data = gpudev->snapshot_data;
unsigned int clock_ctl, reg;
@@ -879,7 +879,6 @@ void a5xx_snapshot(struct adreno_device *adreno_dev,
void a5xx_crashdump_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
unsigned int i, count;
uint64_t *ptr;
uint64_t gpuaddr;
@@ -896,7 +895,7 @@ void a5xx_crashdump_init(struct adreno_device *adreno_dev)
* registers that we will capture.
*/
- if (kgsl_allocate_global(device, &capturescript,
+ if (kgsl_allocate_global(KGSL_DEVICE(adreno_dev), &capturescript,
((ARRAY_SIZE(a5xx_registers) / 2) * 16) + 16,
KGSL_MEMFLAGS_GPUREADONLY, 0))
return;
@@ -904,9 +903,9 @@ void a5xx_crashdump_init(struct adreno_device *adreno_dev)
/* Count the total number of registers to capture */
count = count_registers();
- if (kgsl_allocate_global(device, &registers,
+ if (kgsl_allocate_global(KGSL_DEVICE(adreno_dev), &registers,
count * sizeof(unsigned int), 0, 0)) {
- kgsl_free_global(device, &capturescript);
+ kgsl_free_global(KGSL_DEVICE(adreno_dev), &capturescript);
return;
}
diff --git a/drivers/gpu/msm/adreno_coresight.c b/drivers/gpu/msm/adreno_coresight.c
index 5f351d1caa57..71c63e267197 100644
--- a/drivers/gpu/msm/adreno_coresight.c
+++ b/drivers/gpu/msm/adreno_coresight.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -163,7 +163,7 @@ static void adreno_coresight_disable(struct coresight_device *csdev)
static int _adreno_coresight_get_and_clear(struct adreno_device *adreno_dev)
{
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_coresight *coresight = gpudev->coresight;
int i;
@@ -188,7 +188,7 @@ static int _adreno_coresight_get_and_clear(struct adreno_device *adreno_dev)
static int _adreno_coresight_set(struct adreno_device *adreno_dev)
{
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_coresight *coresight = gpudev->coresight;
int i;
@@ -298,7 +298,7 @@ int adreno_coresight_init(struct adreno_device *adreno_dev)
{
int ret = 0;
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct coresight_desc desc;
if (gpudev->coresight == NULL)
diff --git a/drivers/gpu/msm/adreno_debugfs.c b/drivers/gpu/msm/adreno_debugfs.c
index 2290d29fd28c..1a1db3ab3dc9 100644
--- a/drivers/gpu/msm/adreno_debugfs.c
+++ b/drivers/gpu/msm/adreno_debugfs.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2002,2008-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2002,2008-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -355,7 +355,7 @@ adreno_context_debugfs_init(struct adreno_device *adreno_dev,
void adreno_debugfs_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!device->d_debugfs || IS_ERR(device->d_debugfs))
return;
diff --git a/drivers/gpu/msm/adreno_dispatch.c b/drivers/gpu/msm/adreno_dispatch.c
index 48d37f4a5651..db52f412e141 100644
--- a/drivers/gpu/msm/adreno_dispatch.c
+++ b/drivers/gpu/msm/adreno_dispatch.c
@@ -78,8 +78,6 @@ unsigned int adreno_cmdbatch_timeout = 2000;
/* Interval for reading and comparing fault detection registers */
static unsigned int _fault_timer_interval = 200;
-static int dispatcher_do_fault(struct kgsl_device *device);
-
/**
* _track_context - Add a context ID to the list of recently seen contexts
* for the command queue
@@ -149,32 +147,22 @@ _cmdqueue_inflight(struct adreno_dispatcher_cmdqueue *cmdqueue)
? _dispatcher_q_inflight_lo : _dispatcher_q_inflight_hi;
}
-/**
- * fault_detect_read() - Read the set of fault detect registers
- * @device: Pointer to the KGSL device struct
- *
- * Read the set of fault detect registers and store them in the local array.
- * This is for the initial values that are compared later with
- * fault_detect_read_compare. Also store the initial timestamp of each rb
- * to compare the timestamps with.
- */
-static void fault_detect_read(struct kgsl_device *device)
+static void fault_detect_read(struct adreno_device *adreno_dev)
{
int i;
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
if (!test_bit(ADRENO_DEVICE_SOFT_FAULT_DETECT, &adreno_dev->priv))
return;
for (i = 0; i < adreno_dev->num_ringbuffers; i++) {
struct adreno_ringbuffer *rb = &(adreno_dev->ringbuffers[i]);
- adreno_rb_readtimestamp(device, rb,
+ adreno_rb_readtimestamp(adreno_dev, rb,
KGSL_TIMESTAMP_RETIRED, &(rb->fault_detect_ts));
}
for (i = 0; i < adreno_ft_regs_num; i++) {
if (adreno_ft_regs[i] != 0)
- kgsl_regread(device, adreno_ft_regs[i],
+ kgsl_regread(KGSL_DEVICE(adreno_dev), adreno_ft_regs[i],
&adreno_ft_regs_val[i]);
}
}
@@ -182,13 +170,12 @@ static void fault_detect_read(struct kgsl_device *device)
/*
* Check to see if the device is idle
*/
-static inline bool _isidle(struct kgsl_device *device)
+static inline bool _isidle(struct adreno_device *adreno_dev)
{
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
const struct adreno_gpu_core *gpucore = adreno_dev->gpucore;
unsigned int reg_rbbm_status;
- if (!kgsl_state_is_awake(device))
+ if (!kgsl_state_is_awake(KGSL_DEVICE(adreno_dev)))
goto ret;
/* only check rbbm status to determine if GPU is idle */
@@ -214,15 +201,14 @@ ret:
* of registers. Return 1 if any of the register values changed. Also, compare
* if the current RB's timstamp has changed or not.
*/
-static int fault_detect_read_compare(struct kgsl_device *device)
+static int fault_detect_read_compare(struct adreno_device *adreno_dev)
{
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
struct adreno_ringbuffer *rb = ADRENO_CURRENT_RINGBUFFER(adreno_dev);
int i, ret = 0;
unsigned int ts;
/* Check to see if the device is idle - if so report no hang */
- if (_isidle(device) == true)
+ if (_isidle(adreno_dev) == true)
ret = 1;
for (i = 0; i < adreno_ft_regs_num; i++) {
@@ -230,13 +216,13 @@ static int fault_detect_read_compare(struct kgsl_device *device)
if (adreno_ft_regs[i] == 0)
continue;
- kgsl_regread(device, adreno_ft_regs[i], &val);
+ kgsl_regread(KGSL_DEVICE(adreno_dev), adreno_ft_regs[i], &val);
if (val != adreno_ft_regs_val[i])
ret = 1;
adreno_ft_regs_val[i] = val;
}
- if (!adreno_rb_readtimestamp(device, adreno_dev->cur_rb,
+ if (!adreno_rb_readtimestamp(adreno_dev, adreno_dev->cur_rb,
KGSL_TIMESTAMP_RETIRED, &ts)) {
if (ts != rb->fault_detect_ts)
ret = 1;
@@ -529,7 +515,7 @@ static void dispatcher_queue_context(struct adreno_device *adreno_dev,
static int sendcmd(struct adreno_device *adreno_dev,
struct kgsl_cmdbatch *cmdbatch)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
struct adreno_context *drawctxt = ADRENO_CONTEXT(cmdbatch->context);
@@ -580,7 +566,7 @@ static int sendcmd(struct adreno_device *adreno_dev,
if (dispatcher->inflight == 1) {
if (ret == 0) {
- fault_detect_read(device);
+ fault_detect_read(adreno_dev);
if (!test_and_set_bit(ADRENO_DISPATCHER_ACTIVE,
&dispatcher->priv))
@@ -884,7 +870,7 @@ static void adreno_dispatcher_issuecmds(struct adreno_device *adreno_dev)
/* If the dispatcher is busy then schedule the work for later */
if (!mutex_trylock(&dispatcher->mutex)) {
- adreno_dispatcher_schedule(&adreno_dev->dev);
+ adreno_dispatcher_schedule(KGSL_DEVICE(adreno_dev));
return;
}
@@ -934,16 +920,16 @@ static int get_timestamp(struct adreno_context *drawctxt,
static void adreno_dispatcher_preempt_timer(unsigned long data)
{
struct adreno_device *adreno_dev = (struct adreno_device *) data;
- struct kgsl_device *device = &(adreno_dev->dev);
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
- KGSL_DRV_ERR(device,
+
+ KGSL_DRV_ERR(KGSL_DEVICE(adreno_dev),
"Preemption timed out. cur_rb rptr/wptr %x/%x id %d, next_rb rptr/wptr %x/%x id %d, disp_state: %d\n",
adreno_dev->cur_rb->rptr, adreno_dev->cur_rb->wptr,
adreno_dev->cur_rb->id, adreno_dev->next_rb->rptr,
adreno_dev->next_rb->wptr, adreno_dev->next_rb->id,
atomic_read(&dispatcher->preemption_state));
adreno_set_gpu_fault(adreno_dev, ADRENO_PREEMPT_FAULT);
- adreno_dispatcher_schedule(device);
+ adreno_dispatcher_schedule(KGSL_DEVICE(adreno_dev));
}
/**
@@ -1449,14 +1435,14 @@ static void adreno_fault_header(struct kgsl_device *device,
}
}
-void adreno_fault_skipcmd_detached(struct kgsl_device *device,
+void adreno_fault_skipcmd_detached(struct adreno_device *adreno_dev,
struct adreno_context *drawctxt,
struct kgsl_cmdbatch *cmdbatch)
{
if (test_bit(ADRENO_CONTEXT_SKIP_CMD, &drawctxt->base.priv) &&
kgsl_context_detached(&drawctxt->base)) {
- pr_context(device, cmdbatch->context, "gpu %s ctx %d\n",
- "detached", cmdbatch->context->id);
+ pr_context(KGSL_DEVICE(adreno_dev), cmdbatch->context,
+ "gpu detached context %d\n", cmdbatch->context->id);
clear_bit(ADRENO_CONTEXT_SKIP_CMD, &drawctxt->base.priv);
}
}
@@ -1752,9 +1738,9 @@ replay:
kfree(replay);
}
-static int dispatcher_do_fault(struct kgsl_device *device)
+static int dispatcher_do_fault(struct adreno_device *adreno_dev)
{
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
struct adreno_dispatcher_cmdqueue *dispatch_q = NULL, *dispatch_q_temp;
struct adreno_ringbuffer *rb;
@@ -1958,7 +1944,6 @@ int adreno_dispatch_process_cmdqueue(struct adreno_device *adreno_dev,
struct adreno_dispatcher_cmdqueue *dispatch_q,
int long_ib_detect)
{
- struct kgsl_device *device = &(adreno_dev->dev);
struct adreno_dispatcher *dispatcher = &(adreno_dev->dispatcher);
uint64_t start_ticks = 0, retire_ticks = 0;
@@ -1982,8 +1967,8 @@ int adreno_dispatch_process_cmdqueue(struct adreno_device *adreno_dev,
* pointers and continue processing the queue
*/
- if (kgsl_check_timestamp(device, cmdbatch->context,
- cmdbatch->timestamp)) {
+ if (kgsl_check_timestamp(KGSL_DEVICE(adreno_dev),
+ cmdbatch->context, cmdbatch->timestamp)) {
/*
* If the cmdbatch in question had faulted announce its
@@ -1995,7 +1980,8 @@ int adreno_dispatch_process_cmdqueue(struct adreno_device *adreno_dev,
set_bit(ADRENO_CONTEXT_FAULT,
&cmdbatch->context->priv);
- _print_recovery(device, cmdbatch);
+ _print_recovery(KGSL_DEVICE(adreno_dev),
+ cmdbatch);
}
/* Reduce the number of inflight command batches */
@@ -2071,7 +2057,7 @@ int adreno_dispatch_process_cmdqueue(struct adreno_device *adreno_dev,
/* Boom goes the dynamite */
- pr_context(device, cmdbatch->context,
+ pr_context(KGSL_DEVICE(adreno_dev), cmdbatch->context,
"gpu timeout ctx %d ts %d\n",
cmdbatch->context->id, cmdbatch->timestamp);
@@ -2093,7 +2079,7 @@ static void adreno_dispatcher_work(struct work_struct *work)
container_of(work, struct adreno_dispatcher, work);
struct adreno_device *adreno_dev =
container_of(dispatcher, struct adreno_device, dispatcher);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
int count = 0;
int cur_rb_id = adreno_dev->cur_rb->id;
@@ -2113,7 +2099,7 @@ static void adreno_dispatcher_work(struct work_struct *work)
&(adreno_dev->cur_rb->dispatch_q), 0);
/* Check if gpu fault occurred */
- if (dispatcher_do_fault(device))
+ if (dispatcher_do_fault(adreno_dev))
goto done;
gpudev->preemption_schedule(adreno_dev);
@@ -2223,7 +2209,6 @@ void adreno_dispatcher_queue_context(struct kgsl_device *device,
static void adreno_dispatcher_fault_timer(unsigned long data)
{
struct adreno_device *adreno_dev = (struct adreno_device *) data;
- struct kgsl_device *device = &adreno_dev->dev;
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
/* Leave if the user decided to turn off fast hang detection */
@@ -2231,7 +2216,7 @@ static void adreno_dispatcher_fault_timer(unsigned long data)
return;
if (adreno_gpu_fault(adreno_dev)) {
- adreno_dispatcher_schedule(device);
+ adreno_dispatcher_schedule(KGSL_DEVICE(adreno_dev));
return;
}
@@ -2240,9 +2225,9 @@ static void adreno_dispatcher_fault_timer(unsigned long data)
* so mark the dispatcher as faulted and schedule the work loop.
*/
- if (!fault_detect_read_compare(device)) {
+ if (!fault_detect_read_compare(adreno_dev)) {
adreno_set_gpu_fault(adreno_dev, ADRENO_SOFT_FAULT);
- adreno_dispatcher_schedule(device);
+ adreno_dispatcher_schedule(KGSL_DEVICE(adreno_dev));
} else {
mod_timer(&dispatcher->fault_timer,
jiffies + msecs_to_jiffies(_fault_timer_interval));
@@ -2256,9 +2241,8 @@ static void adreno_dispatcher_fault_timer(unsigned long data)
static void adreno_dispatcher_timer(unsigned long data)
{
struct adreno_device *adreno_dev = (struct adreno_device *) data;
- struct kgsl_device *device = &adreno_dev->dev;
- adreno_dispatcher_schedule(device);
+ adreno_dispatcher_schedule(KGSL_DEVICE(adreno_dev));
}
/**
@@ -2462,7 +2446,7 @@ static struct kobj_type ktype_dispatcher = {
*/
int adreno_dispatcher_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
int ret;
@@ -2506,7 +2490,7 @@ int adreno_dispatcher_init(struct adreno_device *adreno_dev)
*/
int adreno_dispatcher_idle(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
int ret;
@@ -2550,7 +2534,7 @@ int adreno_dispatcher_idle(struct adreno_device *adreno_dev)
void adreno_preempt_process_dispatch_queue(struct adreno_device *adreno_dev,
struct adreno_dispatcher_cmdqueue *dispatch_q)
{
- struct kgsl_device *device = &(adreno_dev->dev);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_cmdbatch *cmdbatch;
if (dispatch_q->head != dispatch_q->tail) {
@@ -2580,11 +2564,10 @@ void adreno_preempt_process_dispatch_queue(struct adreno_device *adreno_dev,
void adreno_dispatcher_preempt_callback(struct adreno_device *adreno_dev,
int bit)
{
- struct kgsl_device *device = &adreno_dev->dev;
struct adreno_dispatcher *dispatcher = &(adreno_dev->dispatcher);
if (ADRENO_DISPATCHER_PREEMPT_TRIGGERED !=
atomic_read(&dispatcher->preemption_state)) {
- KGSL_DRV_INFO(device,
+ KGSL_DRV_INFO(KGSL_DEVICE(adreno_dev),
"Preemption interrupt generated w/o trigger!\n");
return;
}
@@ -2592,5 +2575,5 @@ void adreno_dispatcher_preempt_callback(struct adreno_device *adreno_dev,
adreno_dev->next_rb);
atomic_set(&dispatcher->preemption_state,
ADRENO_DISPATCHER_PREEMPT_COMPLETE);
- adreno_dispatcher_schedule(device);
+ adreno_dispatcher_schedule(KGSL_DEVICE(adreno_dev));
}
diff --git a/drivers/gpu/msm/adreno_dispatch.h b/drivers/gpu/msm/adreno_dispatch.h
index 1e89e604e0ae..2699e9d537e5 100644
--- a/drivers/gpu/msm/adreno_dispatch.h
+++ b/drivers/gpu/msm/adreno_dispatch.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2008-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2008-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -137,6 +137,7 @@ void adreno_dispatcher_start(struct kgsl_device *device);
int adreno_dispatcher_init(struct adreno_device *adreno_dev);
void adreno_dispatcher_close(struct adreno_device *adreno_dev);
int adreno_dispatcher_idle(struct adreno_device *adreno_dev);
+void adreno_dispatcher_irq_fault(struct adreno_device *adreno_dev);
void adreno_dispatcher_stop(struct adreno_device *adreno_dev);
int adreno_dispatcher_queue_cmd(struct adreno_device *adreno_dev,
diff --git a/drivers/gpu/msm/adreno_drawctxt.c b/drivers/gpu/msm/adreno_drawctxt.c
index b53494eadf78..0ff2bd527431 100644
--- a/drivers/gpu/msm/adreno_drawctxt.c
+++ b/drivers/gpu/msm/adreno_drawctxt.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2002,2007-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2002,2007-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -143,7 +143,7 @@ int adreno_drawctxt_wait(struct adreno_device *adreno_dev,
struct kgsl_context *context,
uint32_t timestamp, unsigned int timeout)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_context *drawctxt = ADRENO_CONTEXT(context);
int ret;
long ret_temp;
@@ -207,7 +207,7 @@ static int adreno_drawctxt_wait_rb(struct adreno_device *adreno_dev,
struct kgsl_context *context,
uint32_t timestamp, unsigned int timeout)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_context *drawctxt = ADRENO_CONTEXT(context);
int ret = 0;
@@ -486,7 +486,7 @@ void adreno_drawctxt_detach(struct kgsl_context *context)
* the next command in GFT SKIP CMD, print the context
* detached status here.
*/
- adreno_fault_skipcmd_detached(device, drawctxt, list[i]);
+ adreno_fault_skipcmd_detached(adreno_dev, drawctxt, list[i]);
kgsl_cmdbatch_destroy(list[i]);
}
@@ -559,7 +559,7 @@ int adreno_drawctxt_switch(struct adreno_device *adreno_dev,
struct adreno_context *drawctxt,
unsigned int flags)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_pagetable *new_pt;
int ret = 0;
diff --git a/drivers/gpu/msm/adreno_iommu.c b/drivers/gpu/msm/adreno_iommu.c
index 00eebc312f4d..f42d94a8698c 100644
--- a/drivers/gpu/msm/adreno_iommu.c
+++ b/drivers/gpu/msm/adreno_iommu.c
@@ -56,11 +56,17 @@ static unsigned int _wait_reg(struct adreno_device *adreno_dev,
return cmds - start;
}
+#define KGSL_MMU(_dev) \
+ ((struct kgsl_mmu *) (&(KGSL_DEVICE((_dev))->mmu)))
+
+#define KGSL_IOMMU(_dev) \
+ ((struct kgsl_iommu *) ((KGSL_DEVICE((_dev))->mmu.priv)))
+
static unsigned int _iommu_lock(struct adreno_device *adreno_dev,
unsigned int *cmds)
{
unsigned int *start = cmds;
- struct kgsl_iommu *iommu = adreno_dev->dev.mmu.priv;
+ struct kgsl_iommu *iommu = KGSL_IOMMU(adreno_dev);
/*
* If we don't have this register, probe should have forced
@@ -96,7 +102,7 @@ static unsigned int _iommu_lock(struct adreno_device *adreno_dev,
static unsigned int _iommu_unlock(struct adreno_device *adreno_dev,
unsigned int *cmds)
{
- struct kgsl_iommu *iommu = adreno_dev->dev.mmu.priv;
+ struct kgsl_iommu *iommu = KGSL_IOMMU(adreno_dev);
unsigned int *start = cmds;
BUG_ON(iommu->micro_mmu_ctrl == UINT_MAX);
@@ -168,9 +174,9 @@ static unsigned int _cp_smmu_reg(struct adreno_device *adreno_dev,
{
unsigned int *start = cmds;
unsigned int offset;
- struct kgsl_iommu *iommu = adreno_dev->dev.mmu.priv;
+ struct kgsl_iommu *iommu = KGSL_IOMMU(adreno_dev);
- offset = kgsl_mmu_get_reg_ahbaddr(&adreno_dev->dev.mmu,
+ offset = kgsl_mmu_get_reg_ahbaddr(KGSL_MMU(adreno_dev),
KGSL_IOMMU_CONTEXT_USER, reg) >> 2;
if (adreno_is_a5xx(adreno_dev) || iommu->version == 1) {
@@ -193,7 +199,7 @@ static unsigned int _tlbiall(struct adreno_device *adreno_dev,
unsigned int *start = cmds;
unsigned int tlbstatus;
- tlbstatus = kgsl_mmu_get_reg_ahbaddr(&adreno_dev->dev.mmu,
+ tlbstatus = kgsl_mmu_get_reg_ahbaddr(KGSL_MMU(adreno_dev),
KGSL_IOMMU_CONTEXT_USER,
KGSL_IOMMU_CTX_TLBSTATUS) >> 2;
@@ -269,6 +275,7 @@ static bool _ctx_switch_use_cpu_path(
struct kgsl_pagetable *new_pt,
struct adreno_ringbuffer *rb)
{
+ struct kgsl_mmu *mmu = KGSL_MMU(adreno_dev);
/*
* If rb is current, we can use cpu path when GPU is
* idle and we are switching to default pt.
@@ -276,10 +283,10 @@ static bool _ctx_switch_use_cpu_path(
* pending commands (rptr = wptr) and we are switching to default pt.
*/
if (adreno_dev->cur_rb == rb)
- return adreno_isidle(&adreno_dev->dev) &&
- (new_pt == adreno_dev->dev.mmu.defaultpagetable);
+ return adreno_isidle(KGSL_DEVICE(adreno_dev)) &&
+ (new_pt == mmu->defaultpagetable);
else if ((rb->wptr == rb->rptr) &&
- (new_pt == adreno_dev->dev.mmu.defaultpagetable))
+ (new_pt == mmu->defaultpagetable))
return true;
return false;
@@ -585,11 +592,11 @@ unsigned int adreno_iommu_set_pt_generate_cmds(
struct kgsl_pagetable *pt)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
u64 ttbr0;
u32 contextidr;
unsigned int *cmds_orig = cmds;
- struct kgsl_iommu *iommu = device->mmu.priv;
+ struct kgsl_iommu *iommu = KGSL_IOMMU(adreno_dev);
ttbr0 = kgsl_mmu_pagetable_get_ttbr0(pt);
contextidr = kgsl_mmu_pagetable_get_contextidr(pt);
@@ -677,7 +684,7 @@ static unsigned int __add_curr_ctxt_cmds(struct adreno_ringbuffer *rb,
struct adreno_context *drawctxt)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int *cmds_orig = cmds;
/* write the context identifier to memstore memory */
@@ -728,7 +735,7 @@ static void _set_ctxt_cpu(struct adreno_ringbuffer *rb,
struct adreno_context *drawctxt)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (rb == adreno_dev->cur_rb) {
_invalidate_uche_cpu(adreno_dev);
@@ -771,7 +778,7 @@ static int _set_pagetable_cpu(struct adreno_ringbuffer *rb,
struct kgsl_pagetable *new_pt)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int result;
/* update TTBR0 only if we are updating current RB */
@@ -814,7 +821,6 @@ static int _set_pagetable_gpu(struct adreno_ringbuffer *rb,
struct kgsl_pagetable *new_pt)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
unsigned int *link = NULL, *cmds;
int result;
@@ -830,12 +836,13 @@ static int _set_pagetable_gpu(struct adreno_ringbuffer *rb,
return 0;
}
- kgsl_mmu_enable_clk(&device->mmu);
+ kgsl_mmu_enable_clk(KGSL_MMU(adreno_dev));
cmds += adreno_iommu_set_pt_generate_cmds(rb, cmds, new_pt);
if ((unsigned int) (cmds - link) > (PAGE_SIZE / sizeof(unsigned int))) {
- KGSL_DRV_ERR(device, "Temp command buffer overflow\n");
+ KGSL_DRV_ERR(KGSL_DEVICE(adreno_dev),
+ "Temp command buffer overflow\n");
BUG();
}
/*
@@ -851,10 +858,10 @@ static int _set_pagetable_gpu(struct adreno_ringbuffer *rb,
* after the command has been retired
*/
if (result)
- kgsl_mmu_disable_clk(&device->mmu);
+ kgsl_mmu_disable_clk(KGSL_MMU(adreno_dev));
else
- adreno_ringbuffer_mmu_disable_clk_on_ts(device, rb,
- rb->timestamp);
+ adreno_ringbuffer_mmu_disable_clk_on_ts(KGSL_DEVICE(adreno_dev),
+ rb, rb->timestamp);
kfree(link);
return result;
@@ -866,8 +873,8 @@ static int _set_pagetable_gpu(struct adreno_ringbuffer *rb,
*/
int adreno_iommu_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
- struct kgsl_iommu *iommu = device->mmu.priv;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+ struct kgsl_iommu *iommu = KGSL_IOMMU(adreno_dev);
if (kgsl_mmu_get_mmutype() == KGSL_MMU_TYPE_NONE)
return 0;
@@ -879,6 +886,7 @@ int adreno_iommu_init(struct adreno_device *adreno_dev)
* A nop is required in an indirect buffer when switching
* pagetables in-stream
*/
+
kgsl_sharedmem_writel(device, &iommu->setstate,
KGSL_IOMMU_SETSTATE_NOP_OFFSET,
cp_packet(adreno_dev, CP_NOP, 1));
@@ -921,7 +929,7 @@ int adreno_iommu_set_pt_ctx(struct adreno_ringbuffer *rb,
struct adreno_context *drawctxt)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_pagetable *cur_pt = device->mmu.defaultpagetable;
int result = 0;
int cpu_path = 0;
diff --git a/drivers/gpu/msm/adreno_perfcounter.c b/drivers/gpu/msm/adreno_perfcounter.c
index 2c25b2447a09..1779e8e7c0b7 100644
--- a/drivers/gpu/msm/adreno_perfcounter.c
+++ b/drivers/gpu/msm/adreno_perfcounter.c
@@ -245,7 +245,7 @@ void adreno_perfcounter_start(struct adreno_device *adreno_dev)
int adreno_perfcounter_read_group(struct adreno_device *adreno_dev,
struct kgsl_perfcounter_read_group __user *reads, unsigned int count)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcounters *counters = ADRENO_PERFCOUNTERS(adreno_dev);
struct adreno_perfcount_group *group;
struct kgsl_perfcounter_read_group *list = NULL;
@@ -382,7 +382,7 @@ int adreno_perfcounter_query_group(struct adreno_device *adreno_dev,
unsigned int groupid, unsigned int __user *countables,
unsigned int count, unsigned int *max_counters)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcounters *counters = ADRENO_PERFCOUNTERS(adreno_dev);
struct adreno_perfcount_group *group;
unsigned int i, t;
@@ -619,7 +619,7 @@ static int _perfcounter_enable_pwr(struct adreno_device *adreno_dev,
if (counter == 0)
return -EINVAL;
- kgsl_regwrite(&adreno_dev->dev, A5XX_RBBM_PERFCTR_RBBM_SEL_0, 6);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev), A5XX_RBBM_PERFCTR_RBBM_SEL_0, 6);
return 0;
}
@@ -628,7 +628,7 @@ static void _perfcounter_enable_vbif(struct adreno_device *adreno_dev,
struct adreno_perfcounters *counters, unsigned int counter,
unsigned int countable)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
reg = &counters->groups[KGSL_PERFCOUNTER_GROUP_VBIF].regs[counter];
@@ -644,7 +644,7 @@ static void _perfcounter_enable_vbif(struct adreno_device *adreno_dev,
static void _perfcounter_enable_vbif_pwr(struct adreno_device *adreno_dev,
struct adreno_perfcounters *counters, unsigned int counter)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
reg = &counters->groups[KGSL_PERFCOUNTER_GROUP_VBIF_PWR].regs[counter];
@@ -658,9 +658,8 @@ static void _perfcounter_enable_vbif_pwr(struct adreno_device *adreno_dev,
static void _power_counter_enable_alwayson(struct adreno_device *adreno_dev,
struct adreno_perfcounters *counters)
{
- struct kgsl_device *device = &adreno_dev->dev;
-
- kgsl_regwrite(device, A5XX_GPMU_ALWAYS_ON_COUNTER_RESET, 1);
+ kgsl_regwrite(KGSL_DEVICE(adreno_dev),
+ A5XX_GPMU_ALWAYS_ON_COUNTER_RESET, 1);
counters->groups[KGSL_PERFCOUNTER_GROUP_ALWAYSON_PWR].regs[0].value = 0;
}
@@ -668,7 +667,7 @@ static void _power_counter_enable_gpmu(struct adreno_device *adreno_dev,
struct adreno_perfcounters *counters, unsigned int group,
unsigned int counter, unsigned int countable)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
if (adreno_is_a530(adreno_dev)) {
@@ -696,7 +695,7 @@ static void _power_counter_enable_default(struct adreno_device *adreno_dev,
struct adreno_perfcounters *counters, unsigned int group,
unsigned int counter, unsigned int countable)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
reg = &counters->groups[group].regs[counter];
@@ -709,7 +708,7 @@ static int _perfcounter_enable_default(struct adreno_device *adreno_dev,
struct adreno_perfcounters *counters, unsigned int group,
unsigned int counter, unsigned int countable)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
int i;
@@ -843,7 +842,7 @@ static uint64_t _perfcounter_read_alwayson(struct adreno_device *adreno_dev,
static uint64_t _perfcounter_read_pwr(struct adreno_device *adreno_dev,
struct adreno_perfcount_group *group, unsigned int counter)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
unsigned int in = 0, out, lo = 0, hi = 0;
unsigned int enable_bit;
@@ -880,7 +879,7 @@ static uint64_t _perfcounter_read_pwr(struct adreno_device *adreno_dev,
static uint64_t _perfcounter_read_vbif(struct adreno_device *adreno_dev,
struct adreno_perfcount_group *group, unsigned int counter)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
unsigned int lo = 0, hi = 0;
@@ -905,7 +904,7 @@ static uint64_t _perfcounter_read_vbif(struct adreno_device *adreno_dev,
static uint64_t _perfcounter_read_vbif_pwr(struct adreno_device *adreno_dev,
struct adreno_perfcount_group *group, unsigned int counter)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
unsigned int lo = 0, hi = 0;
@@ -928,7 +927,7 @@ static uint64_t _perfcounter_read_vbif_pwr(struct adreno_device *adreno_dev,
static uint64_t _perfcounter_read_pwrcntr(struct adreno_device *adreno_dev,
struct adreno_perfcount_group *group, unsigned int counter)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
unsigned int lo = 0, hi = 0;
@@ -943,7 +942,7 @@ static uint64_t _perfcounter_read_pwrcntr(struct adreno_device *adreno_dev,
static uint64_t _perfcounter_read_default(struct adreno_device *adreno_dev,
struct adreno_perfcount_group *group, unsigned int counter)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_perfcount_register *reg;
unsigned int lo = 0, hi = 0;
unsigned int in = 0, out;
diff --git a/drivers/gpu/msm/adreno_profile.c b/drivers/gpu/msm/adreno_profile.c
index 1f73db223a0a..c4fab8a5528a 100644
--- a/drivers/gpu/msm/adreno_profile.c
+++ b/drivers/gpu/msm/adreno_profile.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -364,7 +364,6 @@ static bool _add_to_assignments_list(struct adreno_profile *profile,
static bool results_available(struct adreno_device *adreno_dev,
struct adreno_profile *profile, unsigned int *shared_buf_tail)
{
- struct kgsl_device *device = &adreno_dev->dev;
unsigned int global_eop;
unsigned int off = profile->shared_tail;
unsigned int *shared_ptr = (unsigned int *)
@@ -379,7 +378,7 @@ static bool results_available(struct adreno_device *adreno_dev,
if (shared_buf_empty(profile))
return false;
- if (adreno_rb_readtimestamp(device,
+ if (adreno_rb_readtimestamp(adreno_dev,
adreno_dev->cur_rb,
KGSL_TIMESTAMP_RETIRED, &global_eop))
return false;
@@ -1062,7 +1061,7 @@ DEFINE_SIMPLE_ATTRIBUTE(profile_enable_fops,
void adreno_profile_init(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_profile *profile = &adreno_dev->profile;
struct dentry *profile_dir;
int ret;
@@ -1108,7 +1107,7 @@ void adreno_profile_close(struct adreno_device *adreno_dev)
profile->log_tail = NULL;
profile->shared_head = 0;
profile->shared_tail = 0;
- kgsl_free_global(&adreno_dev->dev, &profile->shared_buffer);
+ kgsl_free_global(KGSL_DEVICE(adreno_dev), &profile->shared_buffer);
profile->shared_size = 0;
profile->assignment_count = 0;
diff --git a/drivers/gpu/msm/adreno_ringbuffer.c b/drivers/gpu/msm/adreno_ringbuffer.c
index d038762222c2..48210f7256f9 100644
--- a/drivers/gpu/msm/adreno_ringbuffer.c
+++ b/drivers/gpu/msm/adreno_ringbuffer.c
@@ -44,7 +44,7 @@
static void _cff_write_ringbuffer(struct adreno_ringbuffer *rb)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
uint64_t gpuaddr;
unsigned int *hostptr;
size_t size;
@@ -129,7 +129,7 @@ void adreno_ringbuffer_submit(struct adreno_ringbuffer *rb,
* Let the pwrscale policy know that new commands have
* been submitted.
*/
- kgsl_pwrscale_busy(&adreno_dev->dev);
+ kgsl_pwrscale_busy(KGSL_DEVICE(adreno_dev));
adreno_writereg(adreno_dev, ADRENO_REG_CP_RB_WPTR, rb->wptr);
}
}
@@ -140,7 +140,7 @@ int adreno_ringbuffer_submit_spin(struct adreno_ringbuffer *rb,
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
adreno_ringbuffer_submit(rb, NULL);
- return adreno_spin_idle(&adreno_dev->dev, timeout);
+ return adreno_spin_idle(adreno_dev, timeout);
}
static int
@@ -211,7 +211,7 @@ adreno_ringbuffer_waitspace(struct adreno_ringbuffer *rb,
break;
if (time_after(jiffies, wait_time)) {
- KGSL_DRV_ERR((&adreno_dev->dev),
+ KGSL_DRV_ERR(KGSL_DEVICE(adreno_dev),
"Timed out waiting for freespace in RB rptr: 0x%x, wptr: 0x%x, rb id %d\n",
rptr, wptr, rb->id);
return -ETIMEDOUT;
@@ -220,7 +220,7 @@ adreno_ringbuffer_waitspace(struct adreno_ringbuffer *rb,
done:
if (wptr_ahead) {
*cmds = cp_packet(adreno_dev, CP_NOP, nopcount);
- kgsl_cffdump_write(&adreno_dev->dev, gpuaddr, *cmds);
+ kgsl_cffdump_write(KGSL_DEVICE(adreno_dev), gpuaddr, *cmds);
}
return 0;
@@ -272,7 +272,7 @@ unsigned int *adreno_ringbuffer_allocspace(struct adreno_ringbuffer *rb,
*/
static void _ringbuffer_setup_common(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct adreno_ringbuffer *rb;
int i;
@@ -363,17 +363,24 @@ int adreno_ringbuffer_start(struct adreno_device *adreno_dev,
void adreno_ringbuffer_stop(struct adreno_device *adreno_dev)
{
- struct kgsl_device *device = &adreno_dev->dev;
struct adreno_ringbuffer *rb;
int i;
+
FOR_EACH_RINGBUFFER(adreno_dev, rb, i)
- kgsl_cancel_events(device, &(rb->events));
+ kgsl_cancel_events(KGSL_DEVICE(adreno_dev), &(rb->events));
+}
+
+static int _rb_readtimestamp(struct kgsl_device *device,
+ void *priv, enum kgsl_timestamp_type type,
+ unsigned int *timestamp)
+{
+ return adreno_rb_readtimestamp(ADRENO_DEVICE(device), priv, type,
+ timestamp);
}
static int _adreno_ringbuffer_init(struct adreno_device *adreno_dev,
int id)
{
- struct kgsl_device *device = &adreno_dev->dev;
struct adreno_ringbuffer *rb = &adreno_dev->ringbuffers[id];
int ret;
char name[64];
@@ -382,7 +389,7 @@ static int _adreno_ringbuffer_init(struct adreno_device *adreno_dev,
snprintf(name, sizeof(name), "rb_events-%d", id);
kgsl_add_event_group(&rb->events, NULL, name,
- adreno_rb_readtimestamp, rb);
+ _rb_readtimestamp, rb);
rb->timestamp = 0;
init_waitqueue_head(&rb->ts_expire_waitq);
@@ -390,12 +397,12 @@ static int _adreno_ringbuffer_init(struct adreno_device *adreno_dev,
* Allocate mem for storing RB pagetables and commands to
* switch pagetable
*/
- ret = kgsl_allocate_global(device, &rb->pagetable_desc,
+ ret = kgsl_allocate_global(KGSL_DEVICE(adreno_dev), &rb->pagetable_desc,
PAGE_SIZE, 0, KGSL_MEMDESC_PRIVILEGED);
if (ret)
return ret;
- return kgsl_allocate_global(device, &rb->buffer_desc,
+ return kgsl_allocate_global(KGSL_DEVICE(adreno_dev), &rb->buffer_desc,
KGSL_RB_SIZE, KGSL_MEMFLAGS_GPUREADONLY, 0);
}
@@ -427,7 +434,7 @@ int adreno_ringbuffer_init(struct adreno_device *adreno_dev, bool nopreempt)
static void _adreno_ringbuffer_close(struct adreno_device *adreno_dev,
struct adreno_ringbuffer *rb)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
kgsl_free_global(device, &rb->pagetable_desc);
kgsl_free_global(device, &rb->preemption_desc);
@@ -507,7 +514,7 @@ adreno_ringbuffer_addcmds(struct adreno_ringbuffer *rb,
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int *ringcmds, *start;
unsigned int total_sizedwords = sizedwords;
unsigned int i;
@@ -925,7 +932,7 @@ static inline int _get_alwayson_counter(struct adreno_device *adreno_dev,
int adreno_ringbuffer_submitcmd(struct adreno_device *adreno_dev,
struct kgsl_cmdbatch *cmdbatch, struct adreno_submit_time *time)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
struct kgsl_memobj_node *ib;
unsigned int numibs = 0;
unsigned int *link;
@@ -975,7 +982,7 @@ int adreno_ringbuffer_submitcmd(struct adreno_device *adreno_dev,
set_bit(CMDBATCH_FLAG_FORCE_PREAMBLE, &cmdbatch->priv);
/* if context is detached print fault recovery */
- adreno_fault_skipcmd_detached(device, drawctxt, cmdbatch);
+ adreno_fault_skipcmd_detached(adreno_dev, drawctxt, cmdbatch);
/* clear the drawctxt flags */
clear_bit(ADRENO_CONTEXT_SKIP_CMD, &drawctxt->base.priv);
@@ -1237,7 +1244,7 @@ static inline int adreno_ringbuffer_check_timestamp(
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
unsigned int ts;
- adreno_rb_readtimestamp(&adreno_dev->dev, rb, type, &ts);
+ adreno_rb_readtimestamp(adreno_dev, rb, type, &ts);
return (timestamp_cmp(ts, timestamp) >= 0);
}
@@ -1253,7 +1260,7 @@ int adreno_ringbuffer_waittimestamp(struct adreno_ringbuffer *rb,
unsigned int msecs)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int ret;
unsigned long wait_time;
@@ -1300,7 +1307,7 @@ int adreno_ringbuffer_submit_preempt_token(struct adreno_ringbuffer *rb,
struct adreno_ringbuffer *incoming_rb)
{
struct adreno_device *adreno_dev = ADRENO_RB_DEVICE(rb);
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
unsigned int *ringcmds, *start;
struct kgsl_iommu *iommu = device->mmu.priv;
struct adreno_gpudev *gpudev = ADRENO_GPU_DEVICE(adreno_dev);
diff --git a/drivers/gpu/msm/adreno_ringbuffer.h b/drivers/gpu/msm/adreno_ringbuffer.h
index 3bef6b3e6940..59f69a76279b 100644
--- a/drivers/gpu/msm/adreno_ringbuffer.h
+++ b/drivers/gpu/msm/adreno_ringbuffer.h
@@ -190,7 +190,7 @@ int adreno_ringbuffer_waittimestamp(struct adreno_ringbuffer *rb,
unsigned int timestamp,
unsigned int msecs);
-int adreno_rb_readtimestamp(struct kgsl_device *device,
+int adreno_rb_readtimestamp(struct adreno_device *adreno_dev,
void *priv, enum kgsl_timestamp_type type,
unsigned int *timestamp);
diff --git a/drivers/gpu/msm/adreno_snapshot.c b/drivers/gpu/msm/adreno_snapshot.c
index 7c7259879b74..6acc415dac76 100644
--- a/drivers/gpu/msm/adreno_snapshot.c
+++ b/drivers/gpu/msm/adreno_snapshot.c
@@ -469,9 +469,9 @@ static size_t snapshot_rb(struct kgsl_device *device, u8 *buf,
header->rptr = rb->rptr;
header->rbsize = KGSL_RB_DWORDS;
header->count = KGSL_RB_DWORDS;
- adreno_rb_readtimestamp(device, rb, KGSL_TIMESTAMP_QUEUED,
+ adreno_rb_readtimestamp(adreno_dev, rb, KGSL_TIMESTAMP_QUEUED,
&header->timestamp_queued);
- adreno_rb_readtimestamp(device, rb, KGSL_TIMESTAMP_RETIRED,
+ adreno_rb_readtimestamp(adreno_dev, rb, KGSL_TIMESTAMP_RETIRED,
&header->timestamp_retired);
header->gpuaddr = rb->buffer_desc.gpuaddr;
header->id = rb->id;
@@ -870,7 +870,7 @@ void adreno_snapshot(struct kgsl_device *device, struct kgsl_snapshot *snapshot,
/* Dump selected global buffers */
kgsl_snapshot_add_section(device, KGSL_SNAPSHOT_SECTION_GPU_OBJECT_V2,
- snapshot, snapshot_global, &adreno_dev->dev.memstore);
+ snapshot, snapshot_global, &device->memstore);
kgsl_snapshot_add_section(device, KGSL_SNAPSHOT_SECTION_GPU_OBJECT_V2,
snapshot, snapshot_global,
diff --git a/drivers/gpu/msm/adreno_sysfs.c b/drivers/gpu/msm/adreno_sysfs.c
index 4c082fc2850e..977ba7624d3f 100644
--- a/drivers/gpu/msm/adreno_sysfs.c
+++ b/drivers/gpu/msm/adreno_sysfs.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -53,7 +53,7 @@ static unsigned int _ft_policy_show(struct adreno_device *adreno_dev)
static int _ft_pagefault_policy_store(struct adreno_device *adreno_dev,
unsigned int val)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int ret = 0;
mutex_lock(&device->mutex);
@@ -79,7 +79,7 @@ static unsigned int _ft_pagefault_policy_show(struct adreno_device *adreno_dev)
static int _ft_fast_hang_detect_store(struct adreno_device *adreno_dev,
unsigned int val)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!test_bit(ADRENO_DEVICE_SOFT_FAULT_DETECT, &adreno_dev->priv))
return 0;
@@ -119,7 +119,7 @@ static unsigned int _ft_long_ib_detect_show(struct adreno_device *adreno_dev)
static int _ft_hang_intr_status_store(struct adreno_device *adreno_dev,
unsigned int val)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int ret = 0;
if (val == test_bit(ADRENO_DEVICE_HANG_INTR, &adreno_dev->priv))
@@ -148,7 +148,7 @@ static unsigned int _ft_hang_intr_status_show(struct adreno_device *adreno_dev)
static int _pwrctrl_store(struct adreno_device *adreno_dev,
unsigned int val, unsigned int flag)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (val == test_bit(flag, &adreno_dev->pwrctrl_flag))
return 0;
@@ -168,7 +168,7 @@ static int _pwrctrl_store(struct adreno_device *adreno_dev,
static int _preemption_store(struct adreno_device *adreno_dev,
unsigned int val)
{
- struct kgsl_device *device = &adreno_dev->dev;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (test_bit(ADRENO_DEVICE_PREEMPTION, &adreno_dev->priv) == val)
return 0;
@@ -414,9 +414,9 @@ static struct kobj_type ktype_ppd = {
.sysfs_ops = &ppd_sysfs_ops,
};
-static void ppd_sysfs_close(struct kgsl_device *device)
+static void ppd_sysfs_close(struct adreno_device *adreno_dev)
{
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
if (!ADRENO_FEATURE(adreno_dev, ADRENO_PPD))
return;
@@ -425,10 +425,10 @@ static void ppd_sysfs_close(struct kgsl_device *device)
kobject_put(&device->ppd_kobj);
}
-static int ppd_sysfs_init(struct kgsl_device *device)
+static int ppd_sysfs_init(struct adreno_device *adreno_dev)
{
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
int ret;
- struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
if (!ADRENO_FEATURE(adreno_dev, ADRENO_PPD))
return -ENODEV;
@@ -444,31 +444,35 @@ static int ppd_sysfs_init(struct kgsl_device *device)
/**
* adreno_sysfs_close() - Take down the adreno sysfs files
- * @device: Pointer to the KGSL device
+ * @adreno_dev: Pointer to the adreno device
*
* Take down the sysfs files on when the device goes away
*/
-void adreno_sysfs_close(struct kgsl_device *device)
+void adreno_sysfs_close(struct adreno_device *adreno_dev)
{
- ppd_sysfs_close(device);
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+
+ ppd_sysfs_close(adreno_dev);
kgsl_remove_device_sysfs_files(device->dev, _attr_list);
}
/**
* adreno_sysfs_init() - Initialize adreno sysfs files
- * @device: Pointer to the KGSL device
+ * @adreno_dev: Pointer to the adreno device
*
* Initialize many of the adreno specific sysfs files especially for fault
* tolerance and power control
*/
-int adreno_sysfs_init(struct kgsl_device *device)
+int adreno_sysfs_init(struct adreno_device *adreno_dev)
{
- int ret = kgsl_create_device_sysfs_files(device->dev, _attr_list);
- if (ret != 0)
- return ret;
+ struct kgsl_device *device = KGSL_DEVICE(adreno_dev);
+ int ret;
+
+ ret = kgsl_create_device_sysfs_files(device->dev, _attr_list);
/* Add the PPD directory and files */
- ppd_sysfs_init(device);
+ if (ret == 0)
+ ppd_sysfs_init(adreno_dev);
return 0;
}
diff --git a/drivers/gpu/msm/kgsl_iommu.c b/drivers/gpu/msm/kgsl_iommu.c
index 835583a6a0fb..695b2d38e3ed 100644
--- a/drivers/gpu/msm/kgsl_iommu.c
+++ b/drivers/gpu/msm/kgsl_iommu.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -1489,6 +1489,7 @@ kgsl_iommu_get_current_ttbr0(struct kgsl_mmu *mmu)
static int kgsl_iommu_set_pt(struct kgsl_mmu *mmu,
struct kgsl_pagetable *pt)
{
+ struct kgsl_device *device = KGSL_MMU_DEVICE(mmu);
struct kgsl_iommu *iommu = mmu->priv;
struct kgsl_iommu_context *ctx = &iommu->ctx[KGSL_IOMMU_CONTEXT_USER];
int ret = 0;
@@ -1513,7 +1514,7 @@ static int kgsl_iommu_set_pt(struct kgsl_mmu *mmu,
* Taking the liberty to spin idle since this codepath
* is invoked when we can spin safely for it to be idle
*/
- ret = adreno_spin_idle(KGSL_MMU_DEVICE(mmu), ADRENO_IDLE_TIMEOUT);
+ ret = adreno_spin_idle(ADRENO_DEVICE(device), ADRENO_IDLE_TIMEOUT);
if (ret)
return ret;
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-22 17:29:47 +0000