bybrooklyn/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-04-18 14:53:58 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
b7d74ea0fdaa8d641fe6f18507c5f0d21b652d53
linux/drivers/gpu/drm/amd/amdgpu/isp_v4_1_1.c
Pratap Nirujogi 3fc4648b53 drm/amdgpu: Fix ISP segfault issue in kernel v7.0 
Add NULL pointer checks for dev->type before accessing
dev->type->name in ISP genpd add/remove functions to
prevent kernel crashes.

This regression was introduced in v7.0 as the wakeup sources
are registered using physical device instead of ACPI device.
This led to adding wakeup source device as the first child of
AMDGPU device without initializing dev-type variable, and
resulted in segfault when accessed it in the amdgpu isp driver.

Fixes: 057edc58aa ("ACPI: PM: Register wakeup sources under physical devices")
Suggested-by: Bin Du <Bin.Du@amd.com>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
Signed-off-by: Pratap Nirujogi <pratap.nirujogi@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
(cherry picked from commit c51632d1ed)
2026-03-17 12:19:29 -04:00

418 lines
12 KiB
C
Raw Blame History

/* SPDX-License-Identifier: MIT */
/*
* Copyright (C) 2024 Advanced Micro Devices, Inc. All rights reserved.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
*/
#include <linux/gpio/machine.h>
#include <linux/pm_runtime.h>
#include "amdgpu.h"
#include "isp_v4_1_1.h"
MODULE_FIRMWARE("amdgpu/isp_4_1_1.bin");
#define ISP_PERFORMANCE_STATE_LOW 0
#define ISP_PERFORMANCE_STATE_HIGH 1
#define ISP_HIGH_PERFORMANC_XCLK 788
#define ISP_HIGH_PERFORMANC_ICLK 788
static const unsigned int isp_4_1_1_int_srcid[MAX_ISP411_INT_SRC] = {
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT9,
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT10,
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT11,
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT12,
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT13,
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT14,
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT15,
ISP_4_1__SRCID__ISP_RINGBUFFER_WPT16
};
static struct gpiod_lookup_table isp_gpio_table = {
.dev_id = "amd_isp_capture",
.table = {
GPIO_LOOKUP("AMDI0030:00", 85, "enable_isp", GPIO_ACTIVE_HIGH),
{ }
},
};
static struct gpiod_lookup_table isp_sensor_gpio_table = {
.dev_id = "i2c-ov05c10",
.table = {
GPIO_LOOKUP("amdisp-pinctrl", 0, "enable", GPIO_ACTIVE_HIGH),
{ }
},
};
static int isp_poweroff(struct generic_pm_domain *genpd)
{
struct amdgpu_isp *isp = container_of(genpd, struct amdgpu_isp, ispgpd);
struct amdgpu_device *adev = isp->adev;
return amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_ISP, true, 0);
}
static int isp_poweron(struct generic_pm_domain *genpd)
{
struct amdgpu_isp *isp = container_of(genpd, struct amdgpu_isp, ispgpd);
struct amdgpu_device *adev = isp->adev;
return amdgpu_dpm_set_powergating_by_smu(adev, AMD_IP_BLOCK_TYPE_ISP, false, 0);
}
static int isp_set_performance_state(struct generic_pm_domain *genpd,
unsigned int state)
{
struct amdgpu_isp *isp = container_of(genpd, struct amdgpu_isp, ispgpd);
struct amdgpu_device *adev = isp->adev;
u32 iclk, xclk;
int ret;
switch (state) {
case ISP_PERFORMANCE_STATE_HIGH:
xclk = ISP_HIGH_PERFORMANC_XCLK;
iclk = ISP_HIGH_PERFORMANC_ICLK;
break;
case ISP_PERFORMANCE_STATE_LOW:
/* isp runs at default lowest clock-rate on power-on, do nothing */
return 0;
default:
return -EINVAL;
}
ret = amdgpu_dpm_set_soft_freq_range(adev, PP_ISPXCLK, xclk, 0);
if (ret) {
drm_err(&adev->ddev, "failed to set xclk %u to %u: %d\n",
xclk, state, ret);
return ret;
}
ret = amdgpu_dpm_set_soft_freq_range(adev, PP_ISPICLK, iclk, 0);
if (ret) {
drm_err(&adev->ddev, "failed to set iclk %u to %u: %d\n",
iclk, state, ret);
return ret;
}
return 0;
}
static int isp_genpd_add_device(struct device *dev, void *data)
{
struct generic_pm_domain *gpd = data;
struct platform_device *pdev = container_of(dev, struct platform_device, dev);
struct amdgpu_isp *isp = container_of(gpd, struct amdgpu_isp, ispgpd);
struct amdgpu_device *adev = isp->adev;
int ret;
if (!pdev)
return -EINVAL;
if (!dev->type || !dev->type->name) {
drm_dbg(&adev->ddev, "Invalid device type to add\n");
goto exit;
}
if (strcmp(dev->type->name, "mfd_device")) {
drm_dbg(&adev->ddev, "Invalid isp mfd device %s to add\n", pdev->mfd_cell->name);
goto exit;
}
ret = pm_genpd_add_device(gpd, dev);
if (ret) {
drm_err(&adev->ddev, "Failed to add dev %s to genpd %d\n",
pdev->mfd_cell->name, ret);
return -ENODEV;
}
/* The devices will be managed by the pm ops from the parent */
dev_pm_syscore_device(dev, true);
exit:
/* Continue to add */
return 0;
}
static int isp_genpd_remove_device(struct device *dev, void *data)
{
struct generic_pm_domain *gpd = data;
struct platform_device *pdev = container_of(dev, struct platform_device, dev);
struct amdgpu_isp *isp = container_of(gpd, struct amdgpu_isp, ispgpd);
struct amdgpu_device *adev = isp->adev;
int ret;
if (!pdev)
return -EINVAL;
if (!dev->type || !dev->type->name) {
drm_dbg(&adev->ddev, "Invalid device type to remove\n");
goto exit;
}
if (strcmp(dev->type->name, "mfd_device")) {
drm_dbg(&adev->ddev, "Invalid isp mfd device %s to remove\n",
pdev->mfd_cell->name);
goto exit;
}
ret = pm_genpd_remove_device(dev);
if (ret) {
drm_err(&adev->ddev, "Failed to remove dev from genpd %d\n", ret);
return -ENODEV;
}
dev_pm_syscore_device(dev, false);
exit:
/* Continue to remove */
return 0;
}
static int isp_suspend_device(struct device *dev, void *data)
{
return pm_runtime_force_suspend(dev);
}
static int isp_resume_device(struct device *dev, void *data)
{
return pm_runtime_force_resume(dev);
}
static int isp_v4_1_1_hw_suspend(struct amdgpu_isp *isp)
{
int r;
r = device_for_each_child(isp->parent, NULL,
isp_suspend_device);
if (r)
dev_err(isp->parent, "failed to suspend hw devices (%d)\n", r);
return r;
}
static int isp_v4_1_1_hw_resume(struct amdgpu_isp *isp)
{
int r;
r = device_for_each_child(isp->parent, NULL,
isp_resume_device);
if (r)
dev_err(isp->parent, "failed to resume hw device (%d)\n", r);
return r;
}
static int isp_v4_1_1_hw_init(struct amdgpu_isp *isp)
{
const struct software_node *amd_camera_node, *isp4_node;
struct amdgpu_device *adev = isp->adev;
struct acpi_device *acpi_dev;
int idx, int_idx, num_res, r;
u64 isp_base;
if (adev->rmmio_size == 0 || adev->rmmio_size < 0x5289)
return -EINVAL;
r = amdgpu_acpi_get_isp4_dev(&acpi_dev);
if (r) {
drm_dbg(&adev->ddev, "Invalid isp platform detected (%d)", r);
/* allow GPU init to progress */
return 0;
}
/* add GPIO resources required for OMNI5C10 sensor */
if (!strcmp("OMNI5C10", acpi_device_hid(acpi_dev))) {
gpiod_add_lookup_table(&isp_gpio_table);
gpiod_add_lookup_table(&isp_sensor_gpio_table);
}
isp_base = adev->rmmio_base;
isp->ispgpd.name = "ISP_v_4_1_1";
isp->ispgpd.power_off = isp_poweroff;
isp->ispgpd.power_on = isp_poweron;
isp->ispgpd.set_performance_state = isp_set_performance_state;
r = pm_genpd_init(&isp->ispgpd, NULL, true);
if (r) {
drm_err(&adev->ddev, "failed to initialize genpd (%d)\n", r);
return -EINVAL;
}
isp->isp_cell = kzalloc_objs(struct mfd_cell, 3);
if (!isp->isp_cell) {
r = -ENOMEM;
drm_err(&adev->ddev, "isp mfd cell alloc failed (%d)\n", r);
goto failure;
}
num_res = MAX_ISP411_MEM_RES + MAX_ISP411_INT_SRC;
isp->isp_res = kzalloc_objs(struct resource, num_res);
if (!isp->isp_res) {
r = -ENOMEM;
drm_err(&adev->ddev, "isp mfd resource alloc failed (%d)\n", r);
goto failure;
}
isp->isp_pdata = kzalloc_obj(*isp->isp_pdata);
if (!isp->isp_pdata) {
r = -ENOMEM;
drm_err(&adev->ddev, "isp platform data alloc failed (%d)\n", r);
goto failure;
}
amd_camera_node = (const struct software_node *)acpi_dev->driver_data;
isp4_node = software_node_find_by_name(amd_camera_node, "isp4");
/* initialize isp platform data */
isp->isp_pdata->adev = (void *)adev;
isp->isp_pdata->asic_type = adev->asic_type;
isp->isp_pdata->base_rmmio_size = adev->rmmio_size;
isp->isp_res[0].name = "isp_4_1_1_reg";
isp->isp_res[0].flags = IORESOURCE_MEM;
isp->isp_res[0].start = isp_base;
isp->isp_res[0].end = isp_base + ISP_REGS_OFFSET_END;
isp->isp_res[1].name = "isp_4_1_1_phy0_reg";
isp->isp_res[1].flags = IORESOURCE_MEM;
isp->isp_res[1].start = isp_base + ISP411_PHY0_OFFSET;
isp->isp_res[1].end = isp_base + ISP411_PHY0_OFFSET + ISP411_PHY0_SIZE;
for (idx = MAX_ISP411_MEM_RES, int_idx = 0; idx < num_res; idx++, int_idx++) {
isp->isp_res[idx].name = "isp_4_1_1_irq";
isp->isp_res[idx].flags = IORESOURCE_IRQ;
isp->isp_res[idx].start =
amdgpu_irq_create_mapping(adev, isp_4_1_1_int_srcid[int_idx]);
isp->isp_res[idx].end =
isp->isp_res[idx].start;
}
isp->isp_cell[0].name = "amd_isp_capture";
isp->isp_cell[0].num_resources = num_res;
isp->isp_cell[0].resources = &isp->isp_res[0];
isp->isp_cell[0].platform_data = isp->isp_pdata;
isp->isp_cell[0].swnode = isp4_node;
isp->isp_cell[0].pdata_size = sizeof(struct isp_platform_data);
/* initialize isp i2c platform data */
isp->isp_i2c_res = kzalloc_objs(struct resource, 1);
if (!isp->isp_i2c_res) {
r = -ENOMEM;
drm_err(&adev->ddev, "isp mfd res alloc failed (%d)\n", r);
goto failure;
}
isp->isp_i2c_res[0].name = "isp_i2c0_reg";
isp->isp_i2c_res[0].flags = IORESOURCE_MEM;
isp->isp_i2c_res[0].start = isp_base + ISP411_I2C0_OFFSET;
isp->isp_i2c_res[0].end = isp_base + ISP411_I2C0_OFFSET + ISP411_I2C0_SIZE;
isp->isp_cell[1].name = "amd_isp_i2c_designware";
isp->isp_cell[1].num_resources = 1;
isp->isp_cell[1].resources = &isp->isp_i2c_res[0];
isp->isp_cell[1].platform_data = isp->isp_pdata;
isp->isp_cell[1].pdata_size = sizeof(struct isp_platform_data);
/* initialize isp gpiochip platform data */
isp->isp_gpio_res = kzalloc_objs(struct resource, 1);
if (!isp->isp_gpio_res) {
r = -ENOMEM;
drm_err(&adev->ddev, "isp gpio resource alloc failed (%d)\n", r);
goto failure;
}
isp->isp_gpio_res[0].name = "isp_gpio_reg";
isp->isp_gpio_res[0].flags = IORESOURCE_MEM;
isp->isp_gpio_res[0].start = isp_base + ISP411_GPIO_SENSOR_OFFSET;
isp->isp_gpio_res[0].end = isp_base + ISP411_GPIO_SENSOR_OFFSET +
ISP411_GPIO_SENSOR_SIZE;
isp->isp_cell[2].name = "amdisp-pinctrl";
isp->isp_cell[2].num_resources = 1;
isp->isp_cell[2].resources = &isp->isp_gpio_res[0];
isp->isp_cell[2].platform_data = isp->isp_pdata;
isp->isp_cell[2].pdata_size = sizeof(struct isp_platform_data);
/* add only amd_isp_capture and amd_isp_i2c_designware to genpd */
r = mfd_add_hotplug_devices(isp->parent, isp->isp_cell, 2);
if (r) {
drm_err(&adev->ddev, "add mfd hotplug device failed (%d)\n", r);
goto failure;
}
r = device_for_each_child(isp->parent, &isp->ispgpd,
isp_genpd_add_device);
if (r) {
drm_err(&adev->ddev, "failed to add devices to genpd (%d)\n", r);
goto failure;
}
r = mfd_add_hotplug_devices(isp->parent, &isp->isp_cell[2], 1);
if (r) {
drm_err(&adev->ddev, "add pinctl hotplug device failed (%d)\n", r);
goto failure;
}
return 0;
failure:
kfree(isp->isp_pdata);
kfree(isp->isp_res);
kfree(isp->isp_cell);
kfree(isp->isp_i2c_res);
kfree(isp->isp_gpio_res);
return r;
}
static int isp_v4_1_1_hw_fini(struct amdgpu_isp *isp)
{
device_for_each_child(isp->parent, NULL,
isp_genpd_remove_device);
mfd_remove_devices(isp->parent);
kfree(isp->isp_res);
kfree(isp->isp_cell);
kfree(isp->isp_pdata);
kfree(isp->isp_i2c_res);
kfree(isp->isp_gpio_res);
return 0;
}
static const struct isp_funcs isp_v4_1_1_funcs = {
.hw_init = isp_v4_1_1_hw_init,
.hw_fini = isp_v4_1_1_hw_fini,
.hw_suspend = isp_v4_1_1_hw_suspend,
.hw_resume = isp_v4_1_1_hw_resume,
};
void isp_v4_1_1_set_isp_funcs(struct amdgpu_isp *isp)
{
isp->funcs = &isp_v4_1_1_funcs;
}
Reference in New Issue View Git Blame Copy Permalink